?<h3>D¨¹zenle: module.audio-video.quicktime.php</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>&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-video.quicktime.php                            //
// module for analyzing Quicktime and MP3-in-MP4 files         //
// dependencies: module.audio.mp3.php                          //
// dependencies: module.tag.id3v2.php                          //
//                                                            ///
/////////////////////////////////////////////////////////////////

if (!defined(&#039;GETID3_INCLUDEPATH&#039;)) { // prevent path-exposing attacks that access modules directly on public webservers
	exit;
}
getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.&#039;module.audio.mp3.php&#039;, __FILE__, true);
getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.&#039;module.tag.id3v2.php&#039;, __FILE__, true); // needed for ISO 639-2 language code lookup

class getid3_quicktime extends getid3_handler
{

	/** audio-video.quicktime
	 * return all parsed data from all atoms if true, otherwise just returned parsed metadata
	 *
	 * @var bool
	 */
	public $ReturnAtomData        = false;

	/** audio-video.quicktime
	 * return all parsed data from all atoms if true, otherwise just returned parsed metadata
	 *
	 * @var bool
	 */
	public $ParseAllPossibleAtoms = false;

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

		$info[&#039;fileformat&#039;] = &#039;quicktime&#039;;
		$info[&#039;quicktime&#039;][&#039;hinting&#039;]    = false;
		$info[&#039;quicktime&#039;][&#039;controller&#039;] = &#039;standard&#039;; // may be overridden if &#039;ctyp&#039; atom is present

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

		$offset      = 0;
		$atomcounter = 0;
		$atom_data_read_buffer_size = $info[&#039;php_memory_limit&#039;] ? round($info[&#039;php_memory_limit&#039;] / 4) : $this-&gt;getid3-&gt;option_fread_buffer_size * 1024; // set read buffer to 25% of PHP memory limit (if one is specified), otherwise use option_fread_buffer_size [default: 32MB]
		while ($offset &lt; $info[&#039;avdataend&#039;]) {
			if (!getid3_lib::intValueSupported($offset)) {
				$this-&gt;error(&#039;Unable to parse atom at offset &#039;.$offset.&#039; because beyond &#039;.round(PHP_INT_MAX / 1073741824).&#039;GB limit of PHP filesystem functions&#039;);
				break;
			}
			$this-&gt;fseek($offset);
			$AtomHeader = $this-&gt;fread(8);

			// https://github.com/JamesHeinrich/getID3/issues/382
			// Atom sizes are stored as 32-bit number in most cases, but sometimes (notably for &quot;mdat&quot;)
			// a 64-bit value is required, in which case the normal 32-bit size field is set to 0x00000001
			// and the 64-bit &quot;real&quot; size value is the next 8 bytes.
			$atom_size_extended_bytes = 0;
			$atomsize = getid3_lib::BigEndian2Int(substr($AtomHeader, 0, 4));
			$atomname = substr($AtomHeader, 4, 4);
			if ($atomsize == 1) {
				$atom_size_extended_bytes = 8;
				$atomsize = getid3_lib::BigEndian2Int($this-&gt;fread($atom_size_extended_bytes));
			}

			if (($offset + $atomsize) &gt; $info[&#039;avdataend&#039;]) {
				$info[&#039;quicktime&#039;][$atomname][&#039;name&#039;]   = $atomname;
				$info[&#039;quicktime&#039;][$atomname][&#039;size&#039;]   = $atomsize;
				$info[&#039;quicktime&#039;][$atomname][&#039;offset&#039;] = $offset;
				$this-&gt;error(&#039;Atom at offset &#039;.$offset.&#039; claims to go beyond end-of-file (length: &#039;.$atomsize.&#039; bytes)&#039;);
				return false;
			}
			if ($atomsize == 0) {
				// Furthermore, for historical reasons the list of atoms is optionally
				// terminated by a 32-bit integer set to 0. If you are writing a program
				// to read user data atoms, you should allow for the terminating 0.
				$info[&#039;quicktime&#039;][$atomname][&#039;name&#039;]   = $atomname;
				$info[&#039;quicktime&#039;][$atomname][&#039;size&#039;]   = $atomsize;
				$info[&#039;quicktime&#039;][$atomname][&#039;offset&#039;] = $offset;
				break;
			}
			$atomHierarchy = array();
			$parsedAtomData = $this-&gt;QuicktimeParseAtom($atomname, $atomsize, $this-&gt;fread(min($atomsize - $atom_size_extended_bytes, $atom_data_read_buffer_size)), $offset, $atomHierarchy, $this-&gt;ParseAllPossibleAtoms);
			$parsedAtomData[&#039;name&#039;]   = $atomname;
			$parsedAtomData[&#039;size&#039;]   = $atomsize;
			$parsedAtomData[&#039;offset&#039;] = $offset;
			if ($atom_size_extended_bytes) {
				$parsedAtomData[&#039;xsize_bytes&#039;] = $atom_size_extended_bytes;
			}
			if (in_array($atomname, array(&#039;uuid&#039;))) {
				@$info[&#039;quicktime&#039;][$atomname][] = $parsedAtomData;
			} else {
				$info[&#039;quicktime&#039;][$atomname] = $parsedAtomData;
			}

			$offset += $atomsize;
			$atomcounter++;
		}

		if (!empty($info[&#039;avdataend_tmp&#039;])) {
			// this value is assigned to a temp value and then erased because
			// otherwise any atoms beyond the &#039;mdat&#039; atom would not get parsed
			$info[&#039;avdataend&#039;] = $info[&#039;avdataend_tmp&#039;];
			unset($info[&#039;avdataend_tmp&#039;]);
		}

		if (isset($info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;chapters&#039;]) &amp;&amp; is_array($info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;chapters&#039;]) &amp;&amp; (count($info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;chapters&#039;]) &gt; 0)) {
			$durations = $this-&gt;quicktime_time_to_sample_table($info);
			for ($i = 0; $i &lt; count($info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;chapters&#039;]); $i++) {
				$bookmark = array();
				$bookmark[&#039;title&#039;] = $info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;chapters&#039;][$i];
				if (isset($durations[$i])) {
					$bookmark[&#039;duration_sample&#039;] = $durations[$i][&#039;sample_duration&#039;];
					if ($i &gt; 0) {
						$bookmark[&#039;start_sample&#039;] = $info[&#039;quicktime&#039;][&#039;bookmarks&#039;][($i - 1)][&#039;start_sample&#039;] + $info[&#039;quicktime&#039;][&#039;bookmarks&#039;][($i - 1)][&#039;duration_sample&#039;];
					} else {
						$bookmark[&#039;start_sample&#039;] = 0;
					}
					if ($time_scale = $this-&gt;quicktime_bookmark_time_scale($info)) {
						$bookmark[&#039;duration_seconds&#039;] = $bookmark[&#039;duration_sample&#039;] / $time_scale;
						$bookmark[&#039;start_seconds&#039;]    = $bookmark[&#039;start_sample&#039;]    / $time_scale;
					}
				}
				$info[&#039;quicktime&#039;][&#039;bookmarks&#039;][] = $bookmark;
			}
		}

		if (isset($info[&#039;quicktime&#039;][&#039;temp_meta_key_names&#039;])) {
			unset($info[&#039;quicktime&#039;][&#039;temp_meta_key_names&#039;]);
		}

		if (!empty($info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;location.ISO6709&#039;])) {
			// https://en.wikipedia.org/wiki/ISO_6709
			foreach ($info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;location.ISO6709&#039;] as $ISO6709string) {
				$ISO6709parsed = array(&#039;latitude&#039;=&gt;false, &#039;longitude&#039;=&gt;false, &#039;altitude&#039;=&gt;false);
				if (preg_match(&#039;#^([\\+\\-])([0-9]{2}|[0-9]{4}|[0-9]{6})(\\.[0-9]+)?([\\+\\-])([0-9]{3}|[0-9]{5}|[0-9]{7})(\\.[0-9]+)?(([\\+\\-])([0-9]{3}|[0-9]{5}|[0-9]{7})(\\.[0-9]+)?)?/$#&#039;, $ISO6709string, $matches)) {
					// phpcs:ignore PHPCompatibility.Lists.AssignmentOrder.Affected
					@list($dummy, $lat_sign, $lat_deg, $lat_deg_dec, $lon_sign, $lon_deg, $lon_deg_dec, $dummy, $alt_sign, $alt_deg, $alt_deg_dec) = $matches;

					if (strlen($lat_deg) == 2) {        // [+-]DD.D
						$ISO6709parsed[&#039;latitude&#039;] = (($lat_sign == &#039;-&#039;) ? -1 : 1) * floatval(ltrim($lat_deg, &#039;0&#039;).$lat_deg_dec);
					} elseif (strlen($lat_deg) == 4) {  // [+-]DDMM.M
						$ISO6709parsed[&#039;latitude&#039;] = (($lat_sign == &#039;-&#039;) ? -1 : 1) * floatval(ltrim(substr($lat_deg, 0, 2), &#039;0&#039;)) + floatval(ltrim(substr($lat_deg, 2, 2), &#039;0&#039;).$lat_deg_dec / 60);
					} elseif (strlen($lat_deg) == 6) {  // [+-]DDMMSS.S
						$ISO6709parsed[&#039;latitude&#039;] = (($lat_sign == &#039;-&#039;) ? -1 : 1) * floatval(ltrim(substr($lat_deg, 0, 2), &#039;0&#039;)) + floatval((int) ltrim(substr($lat_deg, 2, 2), &#039;0&#039;) / 60) + floatval(ltrim(substr($lat_deg, 4, 2), &#039;0&#039;).$lat_deg_dec / 3600);
					}

					if (strlen($lon_deg) == 3) {        // [+-]DDD.D
						$ISO6709parsed[&#039;longitude&#039;] = (($lon_sign == &#039;-&#039;) ? -1 : 1) * floatval(ltrim($lon_deg, &#039;0&#039;).$lon_deg_dec);
					} elseif (strlen($lon_deg) == 5) {  // [+-]DDDMM.M
						$ISO6709parsed[&#039;longitude&#039;] = (($lon_sign == &#039;-&#039;) ? -1 : 1) * floatval(ltrim(substr($lon_deg, 0, 2), &#039;0&#039;)) + floatval(ltrim(substr($lon_deg, 2, 2), &#039;0&#039;).$lon_deg_dec / 60);
					} elseif (strlen($lon_deg) == 7) {  // [+-]DDDMMSS.S
						$ISO6709parsed[&#039;longitude&#039;] = (($lon_sign == &#039;-&#039;) ? -1 : 1) * floatval(ltrim(substr($lon_deg, 0, 2), &#039;0&#039;)) + floatval((int) ltrim(substr($lon_deg, 2, 2), &#039;0&#039;) / 60) + floatval(ltrim(substr($lon_deg, 4, 2), &#039;0&#039;).$lon_deg_dec / 3600);
					}

					if (strlen($alt_deg) == 3) {        // [+-]DDD.D
						$ISO6709parsed[&#039;altitude&#039;] = (($alt_sign == &#039;-&#039;) ? -1 : 1) * floatval(ltrim($alt_deg, &#039;0&#039;).$alt_deg_dec);
					} elseif (strlen($alt_deg) == 5) {  // [+-]DDDMM.M
						$ISO6709parsed[&#039;altitude&#039;] = (($alt_sign == &#039;-&#039;) ? -1 : 1) * floatval(ltrim(substr($alt_deg, 0, 2), &#039;0&#039;)) + floatval(ltrim(substr($alt_deg, 2, 2), &#039;0&#039;).$alt_deg_dec / 60);
					} elseif (strlen($alt_deg) == 7) {  // [+-]DDDMMSS.S
						$ISO6709parsed[&#039;altitude&#039;] = (($alt_sign == &#039;-&#039;) ? -1 : 1) * floatval(ltrim(substr($alt_deg, 0, 2), &#039;0&#039;)) + floatval((int) ltrim(substr($alt_deg, 2, 2), &#039;0&#039;) / 60) + floatval(ltrim(substr($alt_deg, 4, 2), &#039;0&#039;).$alt_deg_dec / 3600);
					}

					foreach (array(&#039;latitude&#039;, &#039;longitude&#039;, &#039;altitude&#039;) as $key) {
						if ($ISO6709parsed[$key] !== false) {
							$value = (($lat_sign == &#039;-&#039;) ? -1 : 1) * floatval($ISO6709parsed[$key]);
							if (!isset($info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_&#039;.$key]) || !in_array($value, $info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_&#039;.$key])) {
								@$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_&#039;.$key][] = (($lat_sign == &#039;-&#039;) ? -1 : 1) * floatval($ISO6709parsed[$key]);
							}
						}
					}
				}
				if ($ISO6709parsed[&#039;latitude&#039;] === false) {
					$this-&gt;warning(&#039;location.ISO6709 string not parsed correctly: &quot;&#039;.$ISO6709string.&#039;&quot;, please submit as a bug&#039;);
				}
				break;
			}
		}

		if (!isset($info[&#039;bitrate&#039;]) &amp;&amp; !empty($info[&#039;playtime_seconds&#039;])) {
			$info[&#039;bitrate&#039;] = (($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;]) * 8) / $info[&#039;playtime_seconds&#039;];
		}
		if (isset($info[&#039;bitrate&#039;]) &amp;&amp; !isset($info[&#039;audio&#039;][&#039;bitrate&#039;]) &amp;&amp; !isset($info[&#039;quicktime&#039;][&#039;video&#039;])) {
			$info[&#039;audio&#039;][&#039;bitrate&#039;] = $info[&#039;bitrate&#039;];
		}
		if (!empty($info[&#039;bitrate&#039;]) &amp;&amp; !empty($info[&#039;audio&#039;][&#039;bitrate&#039;]) &amp;&amp; empty($info[&#039;video&#039;][&#039;bitrate&#039;]) &amp;&amp; !empty($info[&#039;video&#039;][&#039;frame_rate&#039;]) &amp;&amp; !empty($info[&#039;video&#039;][&#039;resolution_x&#039;]) &amp;&amp; ($info[&#039;bitrate&#039;] &gt; $info[&#039;audio&#039;][&#039;bitrate&#039;])) {
			$info[&#039;video&#039;][&#039;bitrate&#039;] = $info[&#039;bitrate&#039;] - $info[&#039;audio&#039;][&#039;bitrate&#039;];
		}
		if (!empty($info[&#039;playtime_seconds&#039;]) &amp;&amp; !isset($info[&#039;video&#039;][&#039;frame_rate&#039;]) &amp;&amp; !empty($info[&#039;quicktime&#039;][&#039;stts_framecount&#039;])) {
			foreach ($info[&#039;quicktime&#039;][&#039;stts_framecount&#039;] as $key =&gt; $samples_count) {
				$samples_per_second = $samples_count / $info[&#039;playtime_seconds&#039;];
				if ($samples_per_second &gt; 240) {
					// has to be audio samples
				} else {
					$info[&#039;video&#039;][&#039;frame_rate&#039;] = $samples_per_second;
					break;
				}
			}
		}
		if ($info[&#039;audio&#039;][&#039;dataformat&#039;] == &#039;mp4&#039;) {
			$info[&#039;fileformat&#039;] = &#039;mp4&#039;;
			if (empty($info[&#039;video&#039;][&#039;resolution_x&#039;])) {
				$info[&#039;mime_type&#039;]  = &#039;audio/mp4&#039;;
				unset($info[&#039;video&#039;][&#039;dataformat&#039;]);
			} else {
				$info[&#039;mime_type&#039;]  = &#039;video/mp4&#039;;
			}
		}

		if (!$this-&gt;ReturnAtomData) {
			unset($info[&#039;quicktime&#039;][&#039;moov&#039;]);
		}

		if (empty($info[&#039;audio&#039;][&#039;dataformat&#039;]) &amp;&amp; !empty($info[&#039;quicktime&#039;][&#039;audio&#039;])) {
			$info[&#039;audio&#039;][&#039;dataformat&#039;] = &#039;quicktime&#039;;
		}
		if (empty($info[&#039;video&#039;][&#039;dataformat&#039;]) &amp;&amp; !empty($info[&#039;quicktime&#039;][&#039;video&#039;])) {
			$info[&#039;video&#039;][&#039;dataformat&#039;] = &#039;quicktime&#039;;
		}
		if (isset($info[&#039;video&#039;]) &amp;&amp; ($info[&#039;mime_type&#039;] == &#039;audio/mp4&#039;) &amp;&amp; empty($info[&#039;video&#039;][&#039;resolution_x&#039;]) &amp;&amp; empty($info[&#039;video&#039;][&#039;resolution_y&#039;]))  {
			unset($info[&#039;video&#039;]);
		}

		return true;
	}

	/**
	 * @param string $atomname
	 * @param int    $atomsize
	 * @param string $atom_data
	 * @param int    $baseoffset
	 * @param array  $atomHierarchy
	 * @param bool   $ParseAllPossibleAtoms
	 *
	 * @return array|false
	 */
	public function QuicktimeParseAtom($atomname, $atomsize, $atom_data, $baseoffset, &amp;$atomHierarchy, $ParseAllPossibleAtoms) {
		// http://developer.apple.com/techpubs/quicktime/qtdevdocs/APIREF/INDEX/atomalphaindex.htm
		// https://code.google.com/p/mp4v2/wiki/iTunesMetadata

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

		$atom_parent = end($atomHierarchy); // not array_pop($atomHierarchy); see https://www.getid3.org/phpBB3/viewtopic.php?t=1717
		array_push($atomHierarchy, $atomname);
		$atom_structure              = array();
		$atom_structure[&#039;hierarchy&#039;] = implode(&#039; &#039;, $atomHierarchy);
		$atom_structure[&#039;name&#039;]      = $atomname;
		$atom_structure[&#039;size&#039;]      = $atomsize;
		$atom_structure[&#039;offset&#039;]    = $baseoffset;
		if (substr($atomname, 0, 3) == &quot;\x00\x00\x00&quot;) {
			// https://github.com/JamesHeinrich/getID3/issues/139
			$atomname = getid3_lib::BigEndian2Int($atomname);
			$atom_structure[&#039;name&#039;] = $atomname;
			$atom_structure[&#039;subatoms&#039;] = $this-&gt;QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
		} else {
			switch ($atomname) {
				case &#039;moov&#039;: // MOVie container atom
				case &#039;moof&#039;: // MOvie Fragment box
				case &#039;trak&#039;: // TRAcK container atom
				case &#039;traf&#039;: // TRAck Fragment box
				case &#039;clip&#039;: // CLIPping container atom
				case &#039;matt&#039;: // track MATTe container atom
				case &#039;edts&#039;: // EDiTS container atom
				case &#039;tref&#039;: // Track REFerence container atom
				case &#039;mdia&#039;: // MeDIA container atom
				case &#039;minf&#039;: // Media INFormation container atom
				case &#039;dinf&#039;: // Data INFormation container atom
				case &#039;nmhd&#039;: // Null Media HeaDer container atom
				case &#039;udta&#039;: // User DaTA container atom
				case &#039;cmov&#039;: // Compressed MOVie container atom
				case &#039;rmra&#039;: // Reference Movie Record Atom
				case &#039;rmda&#039;: // Reference Movie Descriptor Atom
				case &#039;gmhd&#039;: // Generic Media info HeaDer atom (seen on QTVR)
					$atom_structure[&#039;subatoms&#039;] = $this-&gt;QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
					break;

				case &#039;ilst&#039;: // Item LiST container atom
					if ($atom_structure[&#039;subatoms&#039;] = $this-&gt;QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms)) {
						// some &quot;ilst&quot; atoms contain data atoms that have a numeric name, and the data is far more accessible if the returned array is compacted
						$allnumericnames = true;
						foreach ($atom_structure[&#039;subatoms&#039;] as $subatomarray) {
							if (!is_integer($subatomarray[&#039;name&#039;]) || (count($subatomarray[&#039;subatoms&#039;]) != 1)) {
								$allnumericnames = false;
								break;
							}
						}
						if ($allnumericnames) {
							$newData = array();
							foreach ($atom_structure[&#039;subatoms&#039;] as $subatomarray) {
								foreach ($subatomarray[&#039;subatoms&#039;] as $newData_subatomarray) {
									unset($newData_subatomarray[&#039;hierarchy&#039;], $newData_subatomarray[&#039;name&#039;]);
									$newData[$subatomarray[&#039;name&#039;]] = $newData_subatomarray;
									break;
								}
							}
							$atom_structure[&#039;data&#039;] = $newData;
							unset($atom_structure[&#039;subatoms&#039;]);
						}
					}
					break;

				case &#039;stbl&#039;: // Sample TaBLe container atom
					$atom_structure[&#039;subatoms&#039;] = $this-&gt;QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
					$isVideo = false;
					$framerate  = 0;
					$framecount = 0;
					foreach ($atom_structure[&#039;subatoms&#039;] as $key =&gt; $value_array) {
						if (isset($value_array[&#039;sample_description_table&#039;])) {
							foreach ($value_array[&#039;sample_description_table&#039;] as $key2 =&gt; $value_array2) {
								if (isset($value_array2[&#039;data_format&#039;])) {
									switch ($value_array2[&#039;data_format&#039;]) {
										case &#039;avc1&#039;:
										case &#039;mp4v&#039;:
											// video data
											$isVideo = true;
											break;
										case &#039;mp4a&#039;:
											// audio data
											break;
									}
								}
							}
						} elseif (isset($value_array[&#039;time_to_sample_table&#039;])) {
							foreach ($value_array[&#039;time_to_sample_table&#039;] as $key2 =&gt; $value_array2) {
								if (isset($value_array2[&#039;sample_count&#039;]) &amp;&amp; isset($value_array2[&#039;sample_duration&#039;]) &amp;&amp; ($value_array2[&#039;sample_duration&#039;] &gt; 0) &amp;&amp; !empty($info[&#039;quicktime&#039;][&#039;time_scale&#039;])) {
									$framerate  = round($info[&#039;quicktime&#039;][&#039;time_scale&#039;] / $value_array2[&#039;sample_duration&#039;], 3);
									$framecount = $value_array2[&#039;sample_count&#039;];
								}
							}
						}
					}
					if ($isVideo &amp;&amp; $framerate) {
						$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;frame_rate&#039;] = $framerate;
						$info[&#039;video&#039;][&#039;frame_rate&#039;] = $info[&#039;quicktime&#039;][&#039;video&#039;][&#039;frame_rate&#039;];
					}
					if ($isVideo &amp;&amp; $framecount) {
						$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;frame_count&#039;] = $framecount;
					}
					break;


				case &quot;\xA9&quot;.&#039;alb&#039;: // ALBum
				case &quot;\xA9&quot;.&#039;ART&#039;: //
				case &quot;\xA9&quot;.&#039;art&#039;: // ARTist
				case &quot;\xA9&quot;.&#039;aut&#039;: //
				case &quot;\xA9&quot;.&#039;cmt&#039;: // CoMmenT
				case &quot;\xA9&quot;.&#039;com&#039;: // COMposer
				case &quot;\xA9&quot;.&#039;cpy&#039;: //
				case &quot;\xA9&quot;.&#039;day&#039;: // content created year
				case &quot;\xA9&quot;.&#039;dir&#039;: //
				case &quot;\xA9&quot;.&#039;ed1&#039;: //
				case &quot;\xA9&quot;.&#039;ed2&#039;: //
				case &quot;\xA9&quot;.&#039;ed3&#039;: //
				case &quot;\xA9&quot;.&#039;ed4&#039;: //
				case &quot;\xA9&quot;.&#039;ed5&#039;: //
				case &quot;\xA9&quot;.&#039;ed6&#039;: //
				case &quot;\xA9&quot;.&#039;ed7&#039;: //
				case &quot;\xA9&quot;.&#039;ed8&#039;: //
				case &quot;\xA9&quot;.&#039;ed9&#039;: //
				case &quot;\xA9&quot;.&#039;enc&#039;: //
				case &quot;\xA9&quot;.&#039;fmt&#039;: //
				case &quot;\xA9&quot;.&#039;gen&#039;: // GENre
				case &quot;\xA9&quot;.&#039;grp&#039;: // GRouPing
				case &quot;\xA9&quot;.&#039;hst&#039;: //
				case &quot;\xA9&quot;.&#039;inf&#039;: //
				case &quot;\xA9&quot;.&#039;lyr&#039;: // LYRics
				case &quot;\xA9&quot;.&#039;mak&#039;: //
				case &quot;\xA9&quot;.&#039;mod&#039;: //
				case &quot;\xA9&quot;.&#039;nam&#039;: // full NAMe
				case &quot;\xA9&quot;.&#039;ope&#039;: //
				case &quot;\xA9&quot;.&#039;PRD&#039;: //
				case &quot;\xA9&quot;.&#039;prf&#039;: //
				case &quot;\xA9&quot;.&#039;req&#039;: //
				case &quot;\xA9&quot;.&#039;src&#039;: //
				case &quot;\xA9&quot;.&#039;swr&#039;: //
				case &quot;\xA9&quot;.&#039;too&#039;: // encoder
				case &quot;\xA9&quot;.&#039;trk&#039;: // TRacK
				case &quot;\xA9&quot;.&#039;url&#039;: //
				case &quot;\xA9&quot;.&#039;wrn&#039;: //
				case &quot;\xA9&quot;.&#039;wrt&#039;: // WRiTer
				case &#039;----&#039;: // itunes specific
				case &#039;aART&#039;: // Album ARTist
				case &#039;akID&#039;: // iTunes store account type
				case &#039;apID&#039;: // Purchase Account
				case &#039;atID&#039;: //
				case &#039;catg&#039;: // CaTeGory
				case &#039;cmID&#039;: //
				case &#039;cnID&#039;: //
				case &#039;covr&#039;: // COVeR artwork
				case &#039;cpil&#039;: // ComPILation
				case &#039;cprt&#039;: // CoPyRighT
				case &#039;desc&#039;: // DESCription
				case &#039;disk&#039;: // DISK number
				case &#039;egid&#039;: // Episode Global ID
				case &#039;geID&#039;: //
				case &#039;gnre&#039;: // GeNRE
				case &#039;hdvd&#039;: // HD ViDeo
				case &#039;keyw&#039;: // KEYWord
				case &#039;ldes&#039;: // Long DEScription
				case &#039;pcst&#039;: // PodCaST
				case &#039;pgap&#039;: // GAPless Playback
				case &#039;plID&#039;: //
				case &#039;purd&#039;: // PURchase Date
				case &#039;purl&#039;: // Podcast URL
				case &#039;rati&#039;: //
				case &#039;rndu&#039;: //
				case &#039;rpdu&#039;: //
				case &#039;rtng&#039;: // RaTiNG
				case &#039;sfID&#039;: // iTunes store country
				case &#039;soaa&#039;: // SOrt Album Artist
				case &#039;soal&#039;: // SOrt ALbum
				case &#039;soar&#039;: // SOrt ARtist
				case &#039;soco&#039;: // SOrt COmposer
				case &#039;sonm&#039;: // SOrt NaMe
				case &#039;sosn&#039;: // SOrt Show Name
				case &#039;stik&#039;: //
				case &#039;tmpo&#039;: // TeMPO (BPM)
				case &#039;trkn&#039;: // TRacK Number
				case &#039;tven&#039;: // tvEpisodeID
				case &#039;tves&#039;: // TV EpiSode
				case &#039;tvnn&#039;: // TV Network Name
				case &#039;tvsh&#039;: // TV SHow Name
				case &#039;tvsn&#039;: // TV SeasoN
					if ($atom_parent == &#039;udta&#039;) {
						// User data atom handler
						$atom_structure[&#039;data_length&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, 0, 2));
						$atom_structure[&#039;language_id&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, 2, 2));
						$atom_structure[&#039;data&#039;]        =                           substr($atom_data, 4);

						$atom_structure[&#039;language&#039;]    = $this-&gt;QuicktimeLanguageLookup($atom_structure[&#039;language_id&#039;]);
						if (empty($info[&#039;comments&#039;][&#039;language&#039;]) || (!in_array($atom_structure[&#039;language&#039;], $info[&#039;comments&#039;][&#039;language&#039;]))) {
							$info[&#039;comments&#039;][&#039;language&#039;][] = $atom_structure[&#039;language&#039;];
						}
					} else {
						// Apple item list box atom handler
						$atomoffset = 0;
						if (substr($atom_data, 2, 2) == &quot;\x10\xB5&quot;) {
							// not sure what it means, but observed on iPhone4 data.
							// Each $atom_data has 2 bytes of datasize, plus 0x10B5, then data
							while ($atomoffset &lt; strlen($atom_data)) {
								$boxsmallsize = getid3_lib::BigEndian2Int(substr($atom_data, $atomoffset,     2));
								$boxsmalltype =                           substr($atom_data, $atomoffset + 2, 2);
								$boxsmalldata =                           substr($atom_data, $atomoffset + 4, $boxsmallsize);
								if ($boxsmallsize &lt;= 1) {
									$this-&gt;warning(&#039;Invalid QuickTime atom smallbox size &quot;&#039;.$boxsmallsize.&#039;&quot; in atom &quot;&#039;.preg_replace(&#039;#[^a-zA-Z0-9 _\\-]#&#039;, &#039;?&#039;, $atomname).&#039;&quot; at offset: &#039;.($atom_structure[&#039;offset&#039;] + $atomoffset));
									$atom_structure[&#039;data&#039;] = null;
									$atomoffset = strlen($atom_data);
									break;
								}
								switch ($boxsmalltype) {
									case &quot;\x10\xB5&quot;:
										$atom_structure[&#039;data&#039;] = $boxsmalldata;
										break;
									default:
										$this-&gt;warning(&#039;Unknown QuickTime smallbox type: &quot;&#039;.preg_replace(&#039;#[^a-zA-Z0-9 _\\-]#&#039;, &#039;?&#039;, $boxsmalltype).&#039;&quot; (&#039;.trim(getid3_lib::PrintHexBytes($boxsmalltype)).&#039;) at offset &#039;.$baseoffset);
										$atom_structure[&#039;data&#039;] = $atom_data;
										break;
								}
								$atomoffset += (4 + $boxsmallsize);
							}
						} else {
							while ($atomoffset &lt; strlen($atom_data)) {
								$boxsize = getid3_lib::BigEndian2Int(substr($atom_data, $atomoffset, 4));
								$boxtype =                           substr($atom_data, $atomoffset + 4, 4);
								$boxdata =                           substr($atom_data, $atomoffset + 8, $boxsize - 8);
								if ($boxsize &lt;= 1) {
									$this-&gt;warning(&#039;Invalid QuickTime atom box size &quot;&#039;.$boxsize.&#039;&quot; in atom &quot;&#039;.preg_replace(&#039;#[^a-zA-Z0-9 _\\-]#&#039;, &#039;?&#039;, $atomname).&#039;&quot; at offset: &#039;.($atom_structure[&#039;offset&#039;] + $atomoffset));
									$atom_structure[&#039;data&#039;] = null;
									$atomoffset = strlen($atom_data);
									break;
								}
								$atomoffset += $boxsize;

								switch ($boxtype) {
									case &#039;mean&#039;:
									case &#039;name&#039;:
										$atom_structure[$boxtype] = substr($boxdata, 4);
										break;

									case &#039;data&#039;:
										$atom_structure[&#039;version&#039;]   = getid3_lib::BigEndian2Int(substr($boxdata,  0, 1));
										$atom_structure[&#039;flags_raw&#039;] = getid3_lib::BigEndian2Int(substr($boxdata,  1, 3));
										switch ($atom_structure[&#039;flags_raw&#039;]) {
											case  0: // data flag
											case 21: // tmpo/cpil flag
												switch ($atomname) {
													case &#039;cpil&#039;:
													case &#039;hdvd&#039;:
													case &#039;pcst&#039;:
													case &#039;pgap&#039;:
														// 8-bit integer (boolean)
														$atom_structure[&#039;data&#039;] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 1));
														break;

													case &#039;tmpo&#039;:
														// 16-bit integer
														$atom_structure[&#039;data&#039;] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 2));
														break;

													case &#039;disk&#039;:
													case &#039;trkn&#039;:
														// binary
														$num       = getid3_lib::BigEndian2Int(substr($boxdata, 10, 2));
														$num_total = getid3_lib::BigEndian2Int(substr($boxdata, 12, 2));
														$atom_structure[&#039;data&#039;]  = empty($num) ? &#039;&#039; : $num;
														$atom_structure[&#039;data&#039;] .= empty($num_total) ? &#039;&#039; : &#039;/&#039;.$num_total;
														break;

													case &#039;gnre&#039;:
														// enum
														$GenreID = getid3_lib::BigEndian2Int(substr($boxdata, 8, 4));
														$atom_structure[&#039;data&#039;]    = getid3_id3v1::LookupGenreName($GenreID - 1);
														break;

													case &#039;rtng&#039;:
														// 8-bit integer
														$atom_structure[$atomname] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 1));
														$atom_structure[&#039;data&#039;]    = $this-&gt;QuicktimeContentRatingLookup($atom_structure[$atomname]);
														break;

													case &#039;stik&#039;:
														// 8-bit integer (enum)
														$atom_structure[$atomname] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 1));
														$atom_structure[&#039;data&#039;]    = $this-&gt;QuicktimeSTIKLookup($atom_structure[$atomname]);
														break;

													case &#039;sfID&#039;:
														// 32-bit integer
														$atom_structure[$atomname] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 4));
														$atom_structure[&#039;data&#039;]    = $this-&gt;QuicktimeStoreFrontCodeLookup($atom_structure[$atomname]);
														break;

													case &#039;egid&#039;:
													case &#039;purl&#039;:
														$atom_structure[&#039;data&#039;] = substr($boxdata, 8);
														break;

													case &#039;plID&#039;:
														// 64-bit integer
														$atom_structure[&#039;data&#039;] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 8));
														break;

													case &#039;covr&#039;:
														$atom_structure[&#039;data&#039;] = substr($boxdata, 8);
														// not a foolproof check, but better than nothing
														if (preg_match(&#039;#^\\xFF\\xD8\\xFF#&#039;, $atom_structure[&#039;data&#039;])) {
															$atom_structure[&#039;image_mime&#039;] = &#039;image/jpeg&#039;;
														} elseif (preg_match(&#039;#^\\x89\\x50\\x4E\\x47\\x0D\\x0A\\x1A\\x0A#&#039;, $atom_structure[&#039;data&#039;])) {
															$atom_structure[&#039;image_mime&#039;] = &#039;image/png&#039;;
														} elseif (preg_match(&#039;#^GIF#&#039;, $atom_structure[&#039;data&#039;])) {
															$atom_structure[&#039;image_mime&#039;] = &#039;image/gif&#039;;
														}
														$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;picture&#039;][] = array(&#039;image_mime&#039;=&gt;$atom_structure[&#039;image_mime&#039;], &#039;data&#039;=&gt;$atom_structure[&#039;data&#039;], &#039;description&#039;=&gt;&#039;cover&#039;);
														break;

													case &#039;atID&#039;:
													case &#039;cnID&#039;:
													case &#039;geID&#039;:
													case &#039;tves&#039;:
													case &#039;tvsn&#039;:
													default:
														// 32-bit integer
														$atom_structure[&#039;data&#039;] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 4));
												}
												break;

											case  1: // text flag
											case 13: // image flag
											default:
												$atom_structure[&#039;data&#039;] = substr($boxdata, 8);
												if ($atomname == &#039;covr&#039;) {
													if (!empty($atom_structure[&#039;data&#039;])) {
														$atom_structure[&#039;image_mime&#039;] = &#039;image/unknown&#039;; // provide default MIME type to ensure array keys exist
														if (function_exists(&#039;getimagesizefromstring&#039;) &amp;&amp; ($getimagesize = getimagesizefromstring($atom_structure[&#039;data&#039;])) &amp;&amp; !empty($getimagesize[&#039;mime&#039;])) {
															$atom_structure[&#039;image_mime&#039;] = $getimagesize[&#039;mime&#039;];
														} else {
															// if getimagesizefromstring is not available, or fails for some reason, fall back to simple detection of common image formats
															$ImageFormatSignatures = array(
																&#039;image/jpeg&#039; =&gt; &quot;\xFF\xD8\xFF&quot;,
																&#039;image/png&#039;  =&gt; &quot;\x89\x50\x4E\x47\x0D\x0A\x1A\x0A&quot;,
																&#039;image/gif&#039;  =&gt; &#039;GIF&#039;,
															);
															foreach ($ImageFormatSignatures as $mime =&gt; $image_format_signature) {
																if (substr($atom_structure[&#039;data&#039;], 0, strlen($image_format_signature)) == $image_format_signature) {
																	$atom_structure[&#039;image_mime&#039;] = $mime;
																	break;
																}
															}
														}
														$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;picture&#039;][] = array(&#039;image_mime&#039;=&gt;$atom_structure[&#039;image_mime&#039;], &#039;data&#039;=&gt;$atom_structure[&#039;data&#039;], &#039;description&#039;=&gt;&#039;cover&#039;);
													} else {
														$this-&gt;warning(&#039;Unknown empty &quot;covr&quot; image at offset &#039;.$baseoffset);
													}
												}
												break;

										}
										break;

									default:
										$this-&gt;warning(&#039;Unknown QuickTime box type: &quot;&#039;.preg_replace(&#039;#[^a-zA-Z0-9 _\\-]#&#039;, &#039;?&#039;, $boxtype).&#039;&quot; (&#039;.trim(getid3_lib::PrintHexBytes($boxtype)).&#039;) at offset &#039;.$baseoffset);
										$atom_structure[&#039;data&#039;] = $atom_data;

								}
							}
						}
					}
					$this-&gt;CopyToAppropriateCommentsSection($atomname, $atom_structure[&#039;data&#039;], $atom_structure[&#039;name&#039;]);
					break;


				case &#039;play&#039;: // auto-PLAY atom
					$atom_structure[&#039;autoplay&#039;] = (bool) getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));

					$info[&#039;quicktime&#039;][&#039;autoplay&#039;] = $atom_structure[&#039;autoplay&#039;];
					break;


				case &#039;WLOC&#039;: // Window LOCation atom
					$atom_structure[&#039;location_x&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data,  0, 2));
					$atom_structure[&#039;location_y&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data,  2, 2));
					break;


				case &#039;LOOP&#039;: // LOOPing atom
				case &#039;SelO&#039;: // play SELection Only atom
				case &#039;AllF&#039;: // play ALL Frames atom
					$atom_structure[&#039;data&#039;] = getid3_lib::BigEndian2Int($atom_data);
					break;


				case &#039;name&#039;: //
				case &#039;MCPS&#039;: // Media Cleaner PRo
				case &#039;@PRM&#039;: // adobe PReMiere version
				case &#039;@PRQ&#039;: // adobe PRemiere Quicktime version
					$atom_structure[&#039;data&#039;] = $atom_data;
					break;


				case &#039;cmvd&#039;: // Compressed MooV Data atom
					// Code by ubergeekØubergeek*tv based on information from
					// http://developer.apple.com/quicktime/icefloe/dispatch012.html
					$atom_structure[&#039;unCompressedSize&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, 0, 4));

					$CompressedFileData = substr($atom_data, 4);
					if ($UncompressedHeader = @gzuncompress($CompressedFileData)) {
						$atom_structure[&#039;subatoms&#039;] = $this-&gt;QuicktimeParseContainerAtom($UncompressedHeader, 0, $atomHierarchy, $ParseAllPossibleAtoms);
					} else {
						$this-&gt;warning(&#039;Error decompressing compressed MOV atom at offset &#039;.$atom_structure[&#039;offset&#039;]);
					}
					break;


				case &#039;dcom&#039;: // Data COMpression atom
					$atom_structure[&#039;compression_id&#039;]   = $atom_data;
					$atom_structure[&#039;compression_text&#039;] = $this-&gt;QuicktimeDCOMLookup($atom_data);
					break;


				case &#039;rdrf&#039;: // Reference movie Data ReFerence atom
					$atom_structure[&#039;version&#039;]                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
					$atom_structure[&#039;flags&#039;][&#039;internal_data&#039;] = (bool) ($atom_structure[&#039;flags_raw&#039;] &amp; 0x000001);

					$atom_structure[&#039;reference_type_name&#039;]    =                           substr($atom_data,  4, 4);
					$atom_structure[&#039;reference_length&#039;]       = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
					switch ($atom_structure[&#039;reference_type_name&#039;]) {
						case &#039;url &#039;:
							$atom_structure[&#039;url&#039;]            =       $this-&gt;NoNullString(substr($atom_data, 12));
							break;

						case &#039;alis&#039;:
							$atom_structure[&#039;file_alias&#039;]     =                           substr($atom_data, 12);
							break;

						case &#039;rsrc&#039;:
							$atom_structure[&#039;resource_alias&#039;] =                           substr($atom_data, 12);
							break;

						default:
							$atom_structure[&#039;data&#039;]           =                           substr($atom_data, 12);
							break;
					}
					break;


				case &#039;rmqu&#039;: // Reference Movie QUality atom
					$atom_structure[&#039;movie_quality&#039;] = getid3_lib::BigEndian2Int($atom_data);
					break;


				case &#039;rmcs&#039;: // Reference Movie Cpu Speed atom
					$atom_structure[&#039;version&#039;]          = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;cpu_speed_rating&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
					break;


				case &#039;rmvc&#039;: // Reference Movie Version Check atom
					$atom_structure[&#039;version&#039;]            = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]          = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;gestalt_selector&#039;]   =                           substr($atom_data,  4, 4);
					$atom_structure[&#039;gestalt_value_mask&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
					$atom_structure[&#039;gestalt_value&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
					$atom_structure[&#039;gestalt_check_type&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, 14, 2));
					break;


				case &#039;rmcd&#039;: // Reference Movie Component check atom
					$atom_structure[&#039;version&#039;]                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;component_type&#039;]         =                           substr($atom_data,  4, 4);
					$atom_structure[&#039;component_subtype&#039;]      =                           substr($atom_data,  8, 4);
					$atom_structure[&#039;component_manufacturer&#039;] =                           substr($atom_data, 12, 4);
					$atom_structure[&#039;component_flags_raw&#039;]    = getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
					$atom_structure[&#039;component_flags_mask&#039;]   = getid3_lib::BigEndian2Int(substr($atom_data, 20, 4));
					$atom_structure[&#039;component_min_version&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data, 24, 4));
					break;


				case &#039;rmdr&#039;: // Reference Movie Data Rate atom
					$atom_structure[&#039;version&#039;]       = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]     = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;data_rate&#039;]     = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));

					$atom_structure[&#039;data_rate_bps&#039;] = $atom_structure[&#039;data_rate&#039;] * 10;
					break;


				case &#039;rmla&#039;: // Reference Movie Language Atom
					$atom_structure[&#039;version&#039;]     = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]   = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;language_id&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));

					$atom_structure[&#039;language&#039;]    = $this-&gt;QuicktimeLanguageLookup($atom_structure[&#039;language_id&#039;]);
					if (empty($info[&#039;comments&#039;][&#039;language&#039;]) || (!in_array($atom_structure[&#039;language&#039;], $info[&#039;comments&#039;][&#039;language&#039;]))) {
						$info[&#039;comments&#039;][&#039;language&#039;][] = $atom_structure[&#039;language&#039;];
					}
					break;


				case &#039;ptv &#039;: // Print To Video - defines a movie&#039;s full screen mode
					// http://developer.apple.com/documentation/QuickTime/APIREF/SOURCESIV/at_ptv-_pg.htm
					$atom_structure[&#039;display_size_raw&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data, 0, 2));
					$atom_structure[&#039;reserved_1&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data, 2, 2)); // hardcoded: 0x0000
					$atom_structure[&#039;reserved_2&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data, 4, 2)); // hardcoded: 0x0000
					$atom_structure[&#039;slide_show_flag&#039;]   = getid3_lib::BigEndian2Int(substr($atom_data, 6, 1));
					$atom_structure[&#039;play_on_open_flag&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, 7, 1));

					$atom_structure[&#039;flags&#039;][&#039;play_on_open&#039;] = (bool) $atom_structure[&#039;play_on_open_flag&#039;];
					$atom_structure[&#039;flags&#039;][&#039;slide_show&#039;]   = (bool) $atom_structure[&#039;slide_show_flag&#039;];

					$ptv_lookup = array(
						0 =&gt; &#039;normal&#039;,
						1 =&gt; &#039;double&#039;,
						2 =&gt; &#039;half&#039;,
						3 =&gt; &#039;full&#039;,
						4 =&gt; &#039;current&#039;
					);
					if (isset($ptv_lookup[$atom_structure[&#039;display_size_raw&#039;]])) {
						$atom_structure[&#039;display_size&#039;] = $ptv_lookup[$atom_structure[&#039;display_size_raw&#039;]];
					} else {
						$this-&gt;warning(&#039;unknown &quot;ptv &quot; display constant (&#039;.$atom_structure[&#039;display_size_raw&#039;].&#039;)&#039;);
					}
					break;


				case &#039;stsd&#039;: // Sample Table Sample Description atom
					$atom_structure[&#039;version&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1)); // hardcoded: 0x00
					$atom_structure[&#039;flags_raw&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x000000
					$atom_structure[&#039;number_entries&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));

					// see: https://github.com/JamesHeinrich/getID3/issues/111
					// Some corrupt files have been known to have high bits set in the number_entries field
					// This field shouldn&#039;t really need to be 32-bits, values stores are likely in the range 1-100000
					// Workaround: mask off the upper byte and throw a warning if it&#039;s nonzero
					if ($atom_structure[&#039;number_entries&#039;] &gt; 0x000FFFFF) {
						if ($atom_structure[&#039;number_entries&#039;] &gt; 0x00FFFFFF) {
							$this-&gt;warning(&#039;&quot;stsd&quot; atom contains improbably large number_entries (0x&#039;.getid3_lib::PrintHexBytes(substr($atom_data, 4, 4), true, false).&#039; = &#039;.$atom_structure[&#039;number_entries&#039;].&#039;), probably in error. Ignoring upper byte and interpreting this as 0x&#039;.getid3_lib::PrintHexBytes(substr($atom_data, 5, 3), true, false).&#039; = &#039;.($atom_structure[&#039;number_entries&#039;] &amp; 0x00FFFFFF));
							$atom_structure[&#039;number_entries&#039;] = ($atom_structure[&#039;number_entries&#039;] &amp; 0x00FFFFFF);
						} else {
							$this-&gt;warning(&#039;&quot;stsd&quot; atom contains improbably large number_entries (0x&#039;.getid3_lib::PrintHexBytes(substr($atom_data, 4, 4), true, false).&#039; = &#039;.$atom_structure[&#039;number_entries&#039;].&#039;), probably in error. Please report this to info@getid3.org referencing bug report #111&#039;);
						}
					}

					$stsdEntriesDataOffset = 8;
					for ($i = 0; $i &lt; $atom_structure[&#039;number_entries&#039;]; $i++) {
						$atom_structure[&#039;sample_description_table&#039;][$i][&#039;size&#039;]             = getid3_lib::BigEndian2Int(substr($atom_data, $stsdEntriesDataOffset, 4));
						$stsdEntriesDataOffset += 4;
						$atom_structure[&#039;sample_description_table&#039;][$i][&#039;data_format&#039;]      =                           substr($atom_data, $stsdEntriesDataOffset, 4);
						$stsdEntriesDataOffset += 4;
						$atom_structure[&#039;sample_description_table&#039;][$i][&#039;reserved&#039;]         = getid3_lib::BigEndian2Int(substr($atom_data, $stsdEntriesDataOffset, 6));
						$stsdEntriesDataOffset += 6;
						$atom_structure[&#039;sample_description_table&#039;][$i][&#039;reference_index&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data, $stsdEntriesDataOffset, 2));
						$stsdEntriesDataOffset += 2;
						$atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;]             =                           substr($atom_data, $stsdEntriesDataOffset, ($atom_structure[&#039;sample_description_table&#039;][$i][&#039;size&#039;] - 4 - 4 - 6 - 2));
						$stsdEntriesDataOffset += ($atom_structure[&#039;sample_description_table&#039;][$i][&#039;size&#039;] - 4 - 4 - 6 - 2);
						if (substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;],  1, 54) == &#039;application/octet-stream;type=com.parrot.videometadata&#039;) {
							// special handling for apparently-malformed (TextMetaDataSampleEntry?) data for some version of Parrot drones
							$atom_structure[&#039;sample_description_table&#039;][$i][&#039;parrot_frame_metadata&#039;][&#039;mime_type&#039;]        =       substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;],  1, 55);
							$atom_structure[&#039;sample_description_table&#039;][$i][&#039;parrot_frame_metadata&#039;][&#039;metadata_version&#039;] = (int) substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 55,  1);
							unset($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;]);
$this-&gt;warning(&#039;incomplete/incorrect handling of &quot;stsd&quot; with Parrot metadata in this version of getID3() [&#039;.$this-&gt;getid3-&gt;version().&#039;]&#039;);
							continue;
						}

						$atom_structure[&#039;sample_description_table&#039;][$i][&#039;encoder_version&#039;]  = getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;],  0, 2));
						$atom_structure[&#039;sample_description_table&#039;][$i][&#039;encoder_revision&#039;] = getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;],  2, 2));
						$atom_structure[&#039;sample_description_table&#039;][$i][&#039;encoder_vendor&#039;]   =                           substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;],  4, 4);

						switch ($atom_structure[&#039;sample_description_table&#039;][$i][&#039;encoder_vendor&#039;]) {

							case &quot;\x00\x00\x00\x00&quot;:
								// audio tracks
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;audio_channels&#039;]       =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;],  8,  2));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;audio_bit_depth&#039;]      =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 10,  2));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;audio_compression_id&#039;] =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 12,  2));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;audio_packet_size&#039;]    =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 14,  2));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;audio_sample_rate&#039;]    = getid3_lib::FixedPoint16_16(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 16,  4));

								// video tracks
								// http://developer.apple.com/library/mac/#documentation/QuickTime/QTFF/QTFFChap3/qtff3.html
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;temporal_quality&#039;] =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;],  8,  4));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;spatial_quality&#039;]  =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 12,  4));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;width&#039;]            =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 16,  2));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;height&#039;]           =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 18,  2));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;resolution_x&#039;]     = getid3_lib::FixedPoint16_16(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 24,  4));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;resolution_y&#039;]     = getid3_lib::FixedPoint16_16(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 28,  4));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;data_size&#039;]        =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 32,  4));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;frame_count&#039;]      =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 36,  2));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;compressor_name&#039;]  =                             substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 38,  4);
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;pixel_depth&#039;]      =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 42,  2));
								$atom_structure[&#039;sample_description_table&#039;][$i][&#039;color_table_id&#039;]   =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 44,  2));

								switch ($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data_format&#039;]) {
									case &#039;2vuY&#039;:
									case &#039;avc1&#039;:
									case &#039;cvid&#039;:
									case &#039;dvc &#039;:
									case &#039;dvcp&#039;:
									case &#039;gif &#039;:
									case &#039;h263&#039;:
									case &#039;hvc1&#039;:
									case &#039;jpeg&#039;:
									case &#039;kpcd&#039;:
									case &#039;mjpa&#039;:
									case &#039;mjpb&#039;:
									case &#039;mp4v&#039;:
									case &#039;png &#039;:
									case &#039;raw &#039;:
									case &#039;rle &#039;:
									case &#039;rpza&#039;:
									case &#039;smc &#039;:
									case &#039;SVQ1&#039;:
									case &#039;SVQ3&#039;:
									case &#039;tiff&#039;:
									case &#039;v210&#039;:
									case &#039;v216&#039;:
									case &#039;v308&#039;:
									case &#039;v408&#039;:
									case &#039;v410&#039;:
									case &#039;yuv2&#039;:
										$info[&#039;fileformat&#039;] = &#039;mp4&#039;;
										$info[&#039;video&#039;][&#039;fourcc&#039;] = $atom_structure[&#039;sample_description_table&#039;][$i][&#039;data_format&#039;];
										if ($this-&gt;QuicktimeVideoCodecLookup($info[&#039;video&#039;][&#039;fourcc&#039;])) {
											$info[&#039;video&#039;][&#039;fourcc_lookup&#039;] = $this-&gt;QuicktimeVideoCodecLookup($info[&#039;video&#039;][&#039;fourcc&#039;]);
										}

										// https://www.getid3.org/phpBB3/viewtopic.php?t=1550
										//if ((!empty($atom_structure[&#039;sample_description_table&#039;][$i][&#039;width&#039;]) &amp;&amp; !empty($atom_structure[&#039;sample_description_table&#039;][$i][&#039;width&#039;])) &amp;&amp; (empty($info[&#039;video&#039;][&#039;resolution_x&#039;]) || empty($info[&#039;video&#039;][&#039;resolution_y&#039;]) || (number_format($info[&#039;video&#039;][&#039;resolution_x&#039;], 6) != number_format(round($info[&#039;video&#039;][&#039;resolution_x&#039;]), 6)) || (number_format($info[&#039;video&#039;][&#039;resolution_y&#039;], 6) != number_format(round($info[&#039;video&#039;][&#039;resolution_y&#039;]), 6)))) { // ugly check for floating point numbers
										if (!empty($atom_structure[&#039;sample_description_table&#039;][$i][&#039;width&#039;]) &amp;&amp; !empty($atom_structure[&#039;sample_description_table&#039;][$i][&#039;height&#039;])) {
											// assume that values stored here are more important than values stored in [tkhd] atom
											$info[&#039;video&#039;][&#039;resolution_x&#039;] = $atom_structure[&#039;sample_description_table&#039;][$i][&#039;width&#039;];
											$info[&#039;video&#039;][&#039;resolution_y&#039;] = $atom_structure[&#039;sample_description_table&#039;][$i][&#039;height&#039;];
											$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;resolution_x&#039;] = $info[&#039;video&#039;][&#039;resolution_x&#039;];
											$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;resolution_y&#039;] = $info[&#039;video&#039;][&#039;resolution_y&#039;];
										}
										break;

									case &#039;qtvr&#039;:
										$info[&#039;video&#039;][&#039;dataformat&#039;] = &#039;quicktimevr&#039;;
										break;

									case &#039;mp4a&#039;:
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;subatoms&#039;] = $this-&gt;QuicktimeParseContainerAtom(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 20), $baseoffset + $stsdEntriesDataOffset - 20 - 16, $atomHierarchy, $ParseAllPossibleAtoms);

										$info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;codec&#039;]       = $this-&gt;QuicktimeAudioCodecLookup($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data_format&#039;]);
										$info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;sample_rate&#039;] = $atom_structure[&#039;sample_description_table&#039;][$i][&#039;audio_sample_rate&#039;];
										$info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;channels&#039;]    = $atom_structure[&#039;sample_description_table&#039;][$i][&#039;audio_channels&#039;];
										$info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;bit_depth&#039;]   = $atom_structure[&#039;sample_description_table&#039;][$i][&#039;audio_bit_depth&#039;];
										$info[&#039;audio&#039;][&#039;codec&#039;]                    = $info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;codec&#039;];
										$info[&#039;audio&#039;][&#039;sample_rate&#039;]              = $info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;sample_rate&#039;];
										$info[&#039;audio&#039;][&#039;channels&#039;]                 = $info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;channels&#039;];
										$info[&#039;audio&#039;][&#039;bits_per_sample&#039;]          = $info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;bit_depth&#039;];
										switch ($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data_format&#039;]) {
											case &#039;raw &#039;: // PCM
											case &#039;alac&#039;: // Apple Lossless Audio Codec
											case &#039;sowt&#039;: // signed/two&#039;s complement (Little Endian)
											case &#039;twos&#039;: // signed/two&#039;s complement (Big Endian)
											case &#039;in24&#039;: // 24-bit Integer
											case &#039;in32&#039;: // 32-bit Integer
											case &#039;fl32&#039;: // 32-bit Floating Point
											case &#039;fl64&#039;: // 64-bit Floating Point
												$info[&#039;audio&#039;][&#039;lossless&#039;] = $info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;lossless&#039;] = true;
												$info[&#039;audio&#039;][&#039;bitrate&#039;]  = $info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;bitrate&#039;]  = $info[&#039;audio&#039;][&#039;channels&#039;] * $info[&#039;audio&#039;][&#039;bits_per_sample&#039;] * $info[&#039;audio&#039;][&#039;sample_rate&#039;];
												break;
											default:
												$info[&#039;audio&#039;][&#039;lossless&#039;] = false;
												break;
										}
										break;

									default:
										break;
								}
								break;

							default:
								switch ($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data_format&#039;]) {
									case &#039;mp4s&#039;:
										$info[&#039;fileformat&#039;] = &#039;mp4&#039;;
										break;

									default:
										// video atom
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_temporal_quality&#039;]  =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;],  8,  4));
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_spatial_quality&#039;]   =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 12,  4));
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_frame_width&#039;]       =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 16,  2));
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_frame_height&#039;]      =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 18,  2));
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_resolution_x&#039;]      = getid3_lib::FixedPoint16_16(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 20,  4));
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_resolution_y&#039;]      = getid3_lib::FixedPoint16_16(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 24,  4));
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_data_size&#039;]         =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 28,  4));
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_frame_count&#039;]       =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 32,  2));
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_encoder_name_len&#039;]  =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 34,  1));
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_encoder_name&#039;]      =                             substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 35, $atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_encoder_name_len&#039;]);
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_pixel_color_depth&#039;] =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 66,  2));
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_color_table_id&#039;]    =   getid3_lib::BigEndian2Int(substr($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;], 68,  2));

										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_pixel_color_type&#039;]  = (((int) $atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_pixel_color_depth&#039;] &gt; 32) ? &#039;grayscale&#039; : &#039;color&#039;);
										$atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_pixel_color_name&#039;]  = $this-&gt;QuicktimeColorNameLookup($atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_pixel_color_depth&#039;]);

										if ($atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_pixel_color_name&#039;] != &#039;invalid&#039;) {
											$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;codec_fourcc&#039;]        = $atom_structure[&#039;sample_description_table&#039;][$i][&#039;data_format&#039;];
											$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;codec_fourcc_lookup&#039;] = $this-&gt;QuicktimeVideoCodecLookup($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data_format&#039;]);
											$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;codec&#039;]               = (((int) $atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_encoder_name_len&#039;] &gt; 0) ? $atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_encoder_name&#039;] : $atom_structure[&#039;sample_description_table&#039;][$i][&#039;data_format&#039;]);
											$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;color_depth&#039;]         = $atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_pixel_color_depth&#039;];
											$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;color_depth_name&#039;]    = $atom_structure[&#039;sample_description_table&#039;][$i][&#039;video_pixel_color_name&#039;];

											$info[&#039;video&#039;][&#039;codec&#039;]           = $info[&#039;quicktime&#039;][&#039;video&#039;][&#039;codec&#039;];
											$info[&#039;video&#039;][&#039;bits_per_sample&#039;] = $info[&#039;quicktime&#039;][&#039;video&#039;][&#039;color_depth&#039;];
										}
										$info[&#039;video&#039;][&#039;lossless&#039;]           = false;
										$info[&#039;video&#039;][&#039;pixel_aspect_ratio&#039;] = (float) 1;
										break;
								}
								break;
						}
						switch (strtolower($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data_format&#039;])) {
							case &#039;mp4a&#039;:
								$info[&#039;audio&#039;][&#039;dataformat&#039;]         = &#039;mp4&#039;;
								$info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;codec&#039;] = &#039;mp4&#039;;
								break;

							case &#039;3ivx&#039;:
							case &#039;3iv1&#039;:
							case &#039;3iv2&#039;:
								$info[&#039;video&#039;][&#039;dataformat&#039;] = &#039;3ivx&#039;;
								break;

							case &#039;xvid&#039;:
								$info[&#039;video&#039;][&#039;dataformat&#039;] = &#039;xvid&#039;;
								break;

							case &#039;mp4v&#039;:
								$info[&#039;video&#039;][&#039;dataformat&#039;] = &#039;mpeg4&#039;;
								break;

							case &#039;divx&#039;:
							case &#039;div1&#039;:
							case &#039;div2&#039;:
							case &#039;div3&#039;:
							case &#039;div4&#039;:
							case &#039;div5&#039;:
							case &#039;div6&#039;:
								$info[&#039;video&#039;][&#039;dataformat&#039;] = &#039;divx&#039;;
								break;

							default:
								// do nothing
								break;
						}
						unset($atom_structure[&#039;sample_description_table&#039;][$i][&#039;data&#039;]);
					}
					break;


				case &#039;stts&#039;: // Sample Table Time-to-Sample atom
					$atom_structure[&#039;version&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;number_entries&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
					$sttsEntriesDataOffset = 8;
					//$FrameRateCalculatorArray = array();
					$frames_count = 0;

					$max_stts_entries_to_scan = ($info[&#039;php_memory_limit&#039;] ? min(floor($this-&gt;getid3-&gt;memory_limit / 10000), $atom_structure[&#039;number_entries&#039;]) : $atom_structure[&#039;number_entries&#039;]);
					if ($max_stts_entries_to_scan &lt; $atom_structure[&#039;number_entries&#039;]) {
						$this-&gt;warning(&#039;QuickTime atom &quot;stts&quot; has &#039;.$atom_structure[&#039;number_entries&#039;].&#039; but only scanning the first &#039;.$max_stts_entries_to_scan.&#039; entries due to limited PHP memory available (&#039;.floor($this-&gt;getid3-&gt;memory_limit / 1048576).&#039;MB).&#039;);
					}
					for ($i = 0; $i &lt; $max_stts_entries_to_scan; $i++) {
						$atom_structure[&#039;time_to_sample_table&#039;][$i][&#039;sample_count&#039;]    = getid3_lib::BigEndian2Int(substr($atom_data, $sttsEntriesDataOffset, 4));
						$sttsEntriesDataOffset += 4;
						$atom_structure[&#039;time_to_sample_table&#039;][$i][&#039;sample_duration&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $sttsEntriesDataOffset, 4));
						$sttsEntriesDataOffset += 4;

						$frames_count += $atom_structure[&#039;time_to_sample_table&#039;][$i][&#039;sample_count&#039;];

						// THIS SECTION REPLACED WITH CODE IN &quot;stbl&quot; ATOM
						//if (!empty($info[&#039;quicktime&#039;][&#039;time_scale&#039;]) &amp;&amp; ($atom_structure[&#039;time_to_sample_table&#039;][$i][&#039;sample_duration&#039;] &gt; 0)) {
						//	$stts_new_framerate = $info[&#039;quicktime&#039;][&#039;time_scale&#039;] / $atom_structure[&#039;time_to_sample_table&#039;][$i][&#039;sample_duration&#039;];
						//	if ($stts_new_framerate &lt;= 60) {
						//		// some atoms have durations of &quot;1&quot; giving a very large framerate, which probably is not right
						//		$info[&#039;video&#039;][&#039;frame_rate&#039;] = max($info[&#039;video&#039;][&#039;frame_rate&#039;], $stts_new_framerate);
						//	}
						//}
						//
						//$FrameRateCalculatorArray[($info[&#039;quicktime&#039;][&#039;time_scale&#039;] / $atom_structure[&#039;time_to_sample_table&#039;][$i][&#039;sample_duration&#039;])] += $atom_structure[&#039;time_to_sample_table&#039;][$i][&#039;sample_count&#039;];
					}
					$info[&#039;quicktime&#039;][&#039;stts_framecount&#039;][] = $frames_count;
					//$sttsFramesTotal  = 0;
					//$sttsSecondsTotal = 0;
					//foreach ($FrameRateCalculatorArray as $frames_per_second =&gt; $frame_count) {
					//	if (($frames_per_second &gt; 60) || ($frames_per_second &lt; 1)) {
					//		// not video FPS information, probably audio information
					//		$sttsFramesTotal  = 0;
					//		$sttsSecondsTotal = 0;
					//		break;
					//	}
					//	$sttsFramesTotal  += $frame_count;
					//	$sttsSecondsTotal += $frame_count / $frames_per_second;
					//}
					//if (($sttsFramesTotal &gt; 0) &amp;&amp; ($sttsSecondsTotal &gt; 0)) {
					//	if (($sttsFramesTotal / $sttsSecondsTotal) &gt; $info[&#039;video&#039;][&#039;frame_rate&#039;]) {
					//		$info[&#039;video&#039;][&#039;frame_rate&#039;] = $sttsFramesTotal / $sttsSecondsTotal;
					//	}
					//}
					break;


				case &#039;stss&#039;: // Sample Table Sync Sample (key frames) atom
					if ($ParseAllPossibleAtoms) {
						$atom_structure[&#039;version&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
						$atom_structure[&#039;flags_raw&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
						$atom_structure[&#039;number_entries&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
						$stssEntriesDataOffset = 8;
						for ($i = 0; $i &lt; $atom_structure[&#039;number_entries&#039;]; $i++) {
							$atom_structure[&#039;time_to_sample_table&#039;][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stssEntriesDataOffset, 4));
							$stssEntriesDataOffset += 4;
						}
					}
					break;


				case &#039;stsc&#039;: // Sample Table Sample-to-Chunk atom
					if ($ParseAllPossibleAtoms) {
						$atom_structure[&#039;version&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
						$atom_structure[&#039;flags_raw&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
						$atom_structure[&#039;number_entries&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
						$stscEntriesDataOffset = 8;
						for ($i = 0; $i &lt; $atom_structure[&#039;number_entries&#039;]; $i++) {
							$atom_structure[&#039;sample_to_chunk_table&#039;][$i][&#039;first_chunk&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data, $stscEntriesDataOffset, 4));
							$stscEntriesDataOffset += 4;
							$atom_structure[&#039;sample_to_chunk_table&#039;][$i][&#039;samples_per_chunk&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data, $stscEntriesDataOffset, 4));
							$stscEntriesDataOffset += 4;
							$atom_structure[&#039;sample_to_chunk_table&#039;][$i][&#039;sample_description&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $stscEntriesDataOffset, 4));
							$stscEntriesDataOffset += 4;
						}
					}
					break;


				case &#039;stsz&#039;: // Sample Table SiZe atom
					if ($ParseAllPossibleAtoms) {
						$atom_structure[&#039;version&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
						$atom_structure[&#039;flags_raw&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
						$atom_structure[&#039;sample_size&#039;]    = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
						$atom_structure[&#039;number_entries&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
						$stszEntriesDataOffset = 12;
						if ($atom_structure[&#039;sample_size&#039;] == 0) {
							for ($i = 0; $i &lt; $atom_structure[&#039;number_entries&#039;]; $i++) {
								$atom_structure[&#039;sample_size_table&#039;][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stszEntriesDataOffset, 4));
								$stszEntriesDataOffset += 4;
							}
						}
					}
					break;


				case &#039;stco&#039;: // Sample Table Chunk Offset atom
//					if (true) {
					if ($ParseAllPossibleAtoms) {
						$atom_structure[&#039;version&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
						$atom_structure[&#039;flags_raw&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
						$atom_structure[&#039;number_entries&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
						$stcoEntriesDataOffset = 8;
						for ($i = 0; $i &lt; $atom_structure[&#039;number_entries&#039;]; $i++) {
							$atom_structure[&#039;chunk_offset_table&#039;][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stcoEntriesDataOffset, 4));
							$stcoEntriesDataOffset += 4;
						}
					}
					break;


				case &#039;co64&#039;: // Chunk Offset 64-bit (version of &quot;stco&quot; that supports &gt; 2GB files)
					if ($ParseAllPossibleAtoms) {
						$atom_structure[&#039;version&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
						$atom_structure[&#039;flags_raw&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
						$atom_structure[&#039;number_entries&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
						$stcoEntriesDataOffset = 8;
						for ($i = 0; $i &lt; $atom_structure[&#039;number_entries&#039;]; $i++) {
							$atom_structure[&#039;chunk_offset_table&#039;][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stcoEntriesDataOffset, 8));
							$stcoEntriesDataOffset += 8;
						}
					}
					break;


				case &#039;dref&#039;: // Data REFerence atom
					$atom_structure[&#039;version&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;number_entries&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
					$drefDataOffset = 8;
					for ($i = 0; $i &lt; $atom_structure[&#039;number_entries&#039;]; $i++) {
						$atom_structure[&#039;data_references&#039;][$i][&#039;size&#039;]                    = getid3_lib::BigEndian2Int(substr($atom_data, $drefDataOffset, 4));
						$drefDataOffset += 4;
						$atom_structure[&#039;data_references&#039;][$i][&#039;type&#039;]                    =                           substr($atom_data, $drefDataOffset, 4);
						$drefDataOffset += 4;
						$atom_structure[&#039;data_references&#039;][$i][&#039;version&#039;]                 = getid3_lib::BigEndian2Int(substr($atom_data,  $drefDataOffset, 1));
						$drefDataOffset += 1;
						$atom_structure[&#039;data_references&#039;][$i][&#039;flags_raw&#039;]               = getid3_lib::BigEndian2Int(substr($atom_data,  $drefDataOffset, 3)); // hardcoded: 0x0000
						$drefDataOffset += 3;
						$atom_structure[&#039;data_references&#039;][$i][&#039;data&#039;]                    =                           substr($atom_data, $drefDataOffset, ($atom_structure[&#039;data_references&#039;][$i][&#039;size&#039;] - 4 - 4 - 1 - 3));
						$drefDataOffset += ($atom_structure[&#039;data_references&#039;][$i][&#039;size&#039;] - 4 - 4 - 1 - 3);

						$atom_structure[&#039;data_references&#039;][$i][&#039;flags&#039;][&#039;self_reference&#039;] = (bool) ($atom_structure[&#039;data_references&#039;][$i][&#039;flags_raw&#039;] &amp; 0x001);
					}
					break;


				case &#039;gmin&#039;: // base Media INformation atom
					$atom_structure[&#039;version&#039;]                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;graphics_mode&#039;]          = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
					$atom_structure[&#039;opcolor_red&#039;]            = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2));
					$atom_structure[&#039;opcolor_green&#039;]          = getid3_lib::BigEndian2Int(substr($atom_data,  8, 2));
					$atom_structure[&#039;opcolor_blue&#039;]           = getid3_lib::BigEndian2Int(substr($atom_data, 10, 2));
					$atom_structure[&#039;balance&#039;]                = getid3_lib::BigEndian2Int(substr($atom_data, 12, 2));
					$atom_structure[&#039;reserved&#039;]               = getid3_lib::BigEndian2Int(substr($atom_data, 14, 2));
					break;


				case &#039;smhd&#039;: // Sound Media information HeaDer atom
					$atom_structure[&#039;version&#039;]                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;balance&#039;]                = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
					$atom_structure[&#039;reserved&#039;]               = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2));
					break;


				case &#039;vmhd&#039;: // Video Media information HeaDer atom
					$atom_structure[&#039;version&#039;]                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
					$atom_structure[&#039;graphics_mode&#039;]          = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
					$atom_structure[&#039;opcolor_red&#039;]            = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2));
					$atom_structure[&#039;opcolor_green&#039;]          = getid3_lib::BigEndian2Int(substr($atom_data,  8, 2));
					$atom_structure[&#039;opcolor_blue&#039;]           = getid3_lib::BigEndian2Int(substr($atom_data, 10, 2));

					$atom_structure[&#039;flags&#039;][&#039;no_lean_ahead&#039;] = (bool) ($atom_structure[&#039;flags_raw&#039;] &amp; 0x001);
					break;


				case &#039;hdlr&#039;: // HanDLeR reference atom
					$atom_structure[&#039;version&#039;]                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;component_type&#039;]         =                           substr($atom_data,  4, 4);
					$atom_structure[&#039;component_subtype&#039;]      =                           substr($atom_data,  8, 4);
					$atom_structure[&#039;component_manufacturer&#039;] =                           substr($atom_data, 12, 4);
					$atom_structure[&#039;component_flags_raw&#039;]    = getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
					$atom_structure[&#039;component_flags_mask&#039;]   = getid3_lib::BigEndian2Int(substr($atom_data, 20, 4));
					$atom_structure[&#039;component_name&#039;]         = $this-&gt;MaybePascal2String(substr($atom_data, 24));

					if (($atom_structure[&#039;component_subtype&#039;] == &#039;STpn&#039;) &amp;&amp; ($atom_structure[&#039;component_manufacturer&#039;] == &#039;zzzz&#039;)) {
						$info[&#039;video&#039;][&#039;dataformat&#039;] = &#039;quicktimevr&#039;;
					}
					break;


				case &#039;mdhd&#039;: // MeDia HeaDer atom
					$atom_structure[&#039;version&#039;]               = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]             = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;creation_time&#039;]         = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
					$atom_structure[&#039;modify_time&#039;]           = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
					$atom_structure[&#039;time_scale&#039;]            = getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
					$atom_structure[&#039;duration&#039;]              = getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
					$atom_structure[&#039;language_id&#039;]           = getid3_lib::BigEndian2Int(substr($atom_data, 20, 2));
					$atom_structure[&#039;quality&#039;]               = getid3_lib::BigEndian2Int(substr($atom_data, 22, 2));

					if ($atom_structure[&#039;time_scale&#039;] == 0) {
						$this-&gt;error(&#039;Corrupt Quicktime file: mdhd.time_scale == zero&#039;);
						return false;
					}
					$info[&#039;quicktime&#039;][&#039;time_scale&#039;] = ((isset($info[&#039;quicktime&#039;][&#039;time_scale&#039;]) &amp;&amp; ($info[&#039;quicktime&#039;][&#039;time_scale&#039;] &lt; 1000)) ? max($info[&#039;quicktime&#039;][&#039;time_scale&#039;], $atom_structure[&#039;time_scale&#039;]) : $atom_structure[&#039;time_scale&#039;]);

					$atom_structure[&#039;creation_time_unix&#039;]    = getid3_lib::DateMac2Unix($atom_structure[&#039;creation_time&#039;]);
					$atom_structure[&#039;modify_time_unix&#039;]      = getid3_lib::DateMac2Unix($atom_structure[&#039;modify_time&#039;]);
					$atom_structure[&#039;playtime_seconds&#039;]      = $atom_structure[&#039;duration&#039;] / $atom_structure[&#039;time_scale&#039;];
					$atom_structure[&#039;language&#039;]              = $this-&gt;QuicktimeLanguageLookup($atom_structure[&#039;language_id&#039;]);
					if (empty($info[&#039;comments&#039;][&#039;language&#039;]) || (!in_array($atom_structure[&#039;language&#039;], $info[&#039;comments&#039;][&#039;language&#039;]))) {
						$info[&#039;comments&#039;][&#039;language&#039;][] = $atom_structure[&#039;language&#039;];
					}
					$info[&#039;quicktime&#039;][&#039;timestamps_unix&#039;][&#039;create&#039;][$atom_structure[&#039;hierarchy&#039;]] = $atom_structure[&#039;creation_time_unix&#039;];
					$info[&#039;quicktime&#039;][&#039;timestamps_unix&#039;][&#039;modify&#039;][$atom_structure[&#039;hierarchy&#039;]] = $atom_structure[&#039;modify_time_unix&#039;];
					break;


				case &#039;pnot&#039;: // Preview atom
					$atom_structure[&#039;modification_date&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4)); // &quot;standard Macintosh format&quot;
					$atom_structure[&#039;version_number&#039;]         = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2)); // hardcoded: 0x00
					$atom_structure[&#039;atom_type&#039;]              =                           substr($atom_data,  6, 4);        // usually: &#039;PICT&#039;
					$atom_structure[&#039;atom_index&#039;]             = getid3_lib::BigEndian2Int(substr($atom_data, 10, 2)); // usually: 0x01

					$atom_structure[&#039;modification_date_unix&#039;] = getid3_lib::DateMac2Unix($atom_structure[&#039;modification_date&#039;]);
					$info[&#039;quicktime&#039;][&#039;timestamps_unix&#039;][&#039;modify&#039;][$atom_structure[&#039;hierarchy&#039;]] = $atom_structure[&#039;modification_date_unix&#039;];
					break;


				case &#039;crgn&#039;: // Clipping ReGioN atom
					$atom_structure[&#039;region_size&#039;]   = getid3_lib::BigEndian2Int(substr($atom_data,  0, 2)); // The Region size, Region boundary box,
					$atom_structure[&#039;boundary_box&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data,  2, 8)); // and Clipping region data fields
					$atom_structure[&#039;clipping_data&#039;] =                           substr($atom_data, 10);           // constitute a QuickDraw region.
					break;


				case &#039;load&#039;: // track LOAD settings atom
					$atom_structure[&#039;preload_start_time&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4));
					$atom_structure[&#039;preload_duration&#039;]   = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
					$atom_structure[&#039;preload_flags_raw&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
					$atom_structure[&#039;default_hints_raw&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));

					$atom_structure[&#039;default_hints&#039;][&#039;double_buffer&#039;] = (bool) ($atom_structure[&#039;default_hints_raw&#039;] &amp; 0x0020);
					$atom_structure[&#039;default_hints&#039;][&#039;high_quality&#039;]  = (bool) ($atom_structure[&#039;default_hints_raw&#039;] &amp; 0x0100);
					break;


				case &#039;tmcd&#039;: // TiMe CoDe atom
				case &#039;chap&#039;: // CHAPter list atom
				case &#039;sync&#039;: // SYNChronization atom
				case &#039;scpt&#039;: // tranSCriPT atom
				case &#039;ssrc&#039;: // non-primary SouRCe atom
					for ($i = 0; $i &lt; strlen($atom_data); $i += 4) {
						@$atom_structure[&#039;track_id&#039;][] = getid3_lib::BigEndian2Int(substr($atom_data, $i, 4));
					}
					break;


				case &#039;elst&#039;: // Edit LiST atom
					$atom_structure[&#039;version&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;number_entries&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
					for ($i = 0; $i &lt; $atom_structure[&#039;number_entries&#039;]; $i++ ) {
						$atom_structure[&#039;edit_list&#039;][$i][&#039;track_duration&#039;] =   getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($i * 12) + 0, 4));
						$atom_structure[&#039;edit_list&#039;][$i][&#039;media_time&#039;]     =   getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($i * 12) + 4, 4));
						$atom_structure[&#039;edit_list&#039;][$i][&#039;media_rate&#039;]     = getid3_lib::FixedPoint16_16(substr($atom_data, 8 + ($i * 12) + 8, 4));
					}
					break;


				case &#039;kmat&#039;: // compressed MATte atom
					$atom_structure[&#039;version&#039;]        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
					$atom_structure[&#039;matte_data_raw&#039;] =               substr($atom_data,  4);
					break;


				case &#039;ctab&#039;: // Color TABle atom
					$atom_structure[&#039;color_table_seed&#039;]   = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4)); // hardcoded: 0x00000000
					$atom_structure[&#039;color_table_flags&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2)); // hardcoded: 0x8000
					$atom_structure[&#039;color_table_size&#039;]   = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2)) + 1;
					for ($colortableentry = 0; $colortableentry &lt; $atom_structure[&#039;color_table_size&#039;]; $colortableentry++) {
						$atom_structure[&#039;color_table&#039;][$colortableentry][&#039;alpha&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 0, 2));
						$atom_structure[&#039;color_table&#039;][$colortableentry][&#039;red&#039;]   = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 2, 2));
						$atom_structure[&#039;color_table&#039;][$colortableentry][&#039;green&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 4, 2));
						$atom_structure[&#039;color_table&#039;][$colortableentry][&#039;blue&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 6, 2));
					}
					break;


				case &#039;mvhd&#039;: // MoVie HeaDer atom
					$atom_structure[&#039;version&#039;]            =   getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]          =   getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
					$atom_structure[&#039;creation_time&#039;]      =   getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
					$atom_structure[&#039;modify_time&#039;]        =   getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
					$atom_structure[&#039;time_scale&#039;]         =   getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
					$atom_structure[&#039;duration&#039;]           =   getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
					$atom_structure[&#039;preferred_rate&#039;]     = getid3_lib::FixedPoint16_16(substr($atom_data, 20, 4));
					$atom_structure[&#039;preferred_volume&#039;]   =   getid3_lib::FixedPoint8_8(substr($atom_data, 24, 2));
					$atom_structure[&#039;reserved&#039;]           =                             substr($atom_data, 26, 10);
					$atom_structure[&#039;matrix_a&#039;]           = getid3_lib::FixedPoint16_16(substr($atom_data, 36, 4));
					$atom_structure[&#039;matrix_b&#039;]           = getid3_lib::FixedPoint16_16(substr($atom_data, 40, 4));
					$atom_structure[&#039;matrix_u&#039;]           =  getid3_lib::FixedPoint2_30(substr($atom_data, 44, 4));
					$atom_structure[&#039;matrix_c&#039;]           = getid3_lib::FixedPoint16_16(substr($atom_data, 48, 4));
					$atom_structure[&#039;matrix_d&#039;]           = getid3_lib::FixedPoint16_16(substr($atom_data, 52, 4));
					$atom_structure[&#039;matrix_v&#039;]           =  getid3_lib::FixedPoint2_30(substr($atom_data, 56, 4));
					$atom_structure[&#039;matrix_x&#039;]           = getid3_lib::FixedPoint16_16(substr($atom_data, 60, 4));
					$atom_structure[&#039;matrix_y&#039;]           = getid3_lib::FixedPoint16_16(substr($atom_data, 64, 4));
					$atom_structure[&#039;matrix_w&#039;]           =  getid3_lib::FixedPoint2_30(substr($atom_data, 68, 4));
					$atom_structure[&#039;preview_time&#039;]       =   getid3_lib::BigEndian2Int(substr($atom_data, 72, 4));
					$atom_structure[&#039;preview_duration&#039;]   =   getid3_lib::BigEndian2Int(substr($atom_data, 76, 4));
					$atom_structure[&#039;poster_time&#039;]        =   getid3_lib::BigEndian2Int(substr($atom_data, 80, 4));
					$atom_structure[&#039;selection_time&#039;]     =   getid3_lib::BigEndian2Int(substr($atom_data, 84, 4));
					$atom_structure[&#039;selection_duration&#039;] =   getid3_lib::BigEndian2Int(substr($atom_data, 88, 4));
					$atom_structure[&#039;current_time&#039;]       =   getid3_lib::BigEndian2Int(substr($atom_data, 92, 4));
					$atom_structure[&#039;next_track_id&#039;]      =   getid3_lib::BigEndian2Int(substr($atom_data, 96, 4));

					if ($atom_structure[&#039;time_scale&#039;] == 0) {
						$this-&gt;error(&#039;Corrupt Quicktime file: mvhd.time_scale == zero&#039;);
						return false;
					}
					$atom_structure[&#039;creation_time_unix&#039;]        = getid3_lib::DateMac2Unix($atom_structure[&#039;creation_time&#039;]);
					$atom_structure[&#039;modify_time_unix&#039;]          = getid3_lib::DateMac2Unix($atom_structure[&#039;modify_time&#039;]);
					$info[&#039;quicktime&#039;][&#039;timestamps_unix&#039;][&#039;create&#039;][$atom_structure[&#039;hierarchy&#039;]] = $atom_structure[&#039;creation_time_unix&#039;];
					$info[&#039;quicktime&#039;][&#039;timestamps_unix&#039;][&#039;modify&#039;][$atom_structure[&#039;hierarchy&#039;]] = $atom_structure[&#039;modify_time_unix&#039;];
					$info[&#039;quicktime&#039;][&#039;time_scale&#039;]    = ((isset($info[&#039;quicktime&#039;][&#039;time_scale&#039;]) &amp;&amp; ($info[&#039;quicktime&#039;][&#039;time_scale&#039;] &lt; 1000)) ? max($info[&#039;quicktime&#039;][&#039;time_scale&#039;], $atom_structure[&#039;time_scale&#039;]) : $atom_structure[&#039;time_scale&#039;]);
					$info[&#039;quicktime&#039;][&#039;display_scale&#039;] = $atom_structure[&#039;matrix_a&#039;];
					$info[&#039;playtime_seconds&#039;]           = $atom_structure[&#039;duration&#039;] / $atom_structure[&#039;time_scale&#039;];
					break;


				case &#039;tkhd&#039;: // TracK HeaDer atom
					$atom_structure[&#039;version&#039;]             =   getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]           =   getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
					$atom_structure[&#039;creation_time&#039;]       =   getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
					$atom_structure[&#039;modify_time&#039;]         =   getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
					$atom_structure[&#039;trackid&#039;]             =   getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
					$atom_structure[&#039;reserved1&#039;]           =   getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
					$atom_structure[&#039;duration&#039;]            =   getid3_lib::BigEndian2Int(substr($atom_data, 20, 4));
					$atom_structure[&#039;reserved2&#039;]           =   getid3_lib::BigEndian2Int(substr($atom_data, 24, 8));
					$atom_structure[&#039;layer&#039;]               =   getid3_lib::BigEndian2Int(substr($atom_data, 32, 2));
					$atom_structure[&#039;alternate_group&#039;]     =   getid3_lib::BigEndian2Int(substr($atom_data, 34, 2));
					$atom_structure[&#039;volume&#039;]              =   getid3_lib::FixedPoint8_8(substr($atom_data, 36, 2));
					$atom_structure[&#039;reserved3&#039;]           =   getid3_lib::BigEndian2Int(substr($atom_data, 38, 2));
					// http://developer.apple.com/library/mac/#documentation/QuickTime/RM/MovieBasics/MTEditing/K-Chapter/11MatrixFunctions.html
					// http://developer.apple.com/library/mac/#documentation/QuickTime/qtff/QTFFChap4/qtff4.html#//apple_ref/doc/uid/TP40000939-CH206-18737
					$atom_structure[&#039;matrix_a&#039;]            = getid3_lib::FixedPoint16_16(substr($atom_data, 40, 4));
					$atom_structure[&#039;matrix_b&#039;]            = getid3_lib::FixedPoint16_16(substr($atom_data, 44, 4));
					$atom_structure[&#039;matrix_u&#039;]            =  getid3_lib::FixedPoint2_30(substr($atom_data, 48, 4));
					$atom_structure[&#039;matrix_c&#039;]            = getid3_lib::FixedPoint16_16(substr($atom_data, 52, 4));
					$atom_structure[&#039;matrix_d&#039;]            = getid3_lib::FixedPoint16_16(substr($atom_data, 56, 4));
					$atom_structure[&#039;matrix_v&#039;]            =  getid3_lib::FixedPoint2_30(substr($atom_data, 60, 4));
					$atom_structure[&#039;matrix_x&#039;]            = getid3_lib::FixedPoint16_16(substr($atom_data, 64, 4));
					$atom_structure[&#039;matrix_y&#039;]            = getid3_lib::FixedPoint16_16(substr($atom_data, 68, 4));
					$atom_structure[&#039;matrix_w&#039;]            =  getid3_lib::FixedPoint2_30(substr($atom_data, 72, 4));
					$atom_structure[&#039;width&#039;]               = getid3_lib::FixedPoint16_16(substr($atom_data, 76, 4));
					$atom_structure[&#039;height&#039;]              = getid3_lib::FixedPoint16_16(substr($atom_data, 80, 4));
					$atom_structure[&#039;flags&#039;][&#039;enabled&#039;]    = (bool) ($atom_structure[&#039;flags_raw&#039;] &amp; 0x0001);
					$atom_structure[&#039;flags&#039;][&#039;in_movie&#039;]   = (bool) ($atom_structure[&#039;flags_raw&#039;] &amp; 0x0002);
					$atom_structure[&#039;flags&#039;][&#039;in_preview&#039;] = (bool) ($atom_structure[&#039;flags_raw&#039;] &amp; 0x0004);
					$atom_structure[&#039;flags&#039;][&#039;in_poster&#039;]  = (bool) ($atom_structure[&#039;flags_raw&#039;] &amp; 0x0008);
					$atom_structure[&#039;creation_time_unix&#039;]  = getid3_lib::DateMac2Unix($atom_structure[&#039;creation_time&#039;]);
					$atom_structure[&#039;modify_time_unix&#039;]    = getid3_lib::DateMac2Unix($atom_structure[&#039;modify_time&#039;]);
					$info[&#039;quicktime&#039;][&#039;timestamps_unix&#039;][&#039;create&#039;][$atom_structure[&#039;hierarchy&#039;]] = $atom_structure[&#039;creation_time_unix&#039;];
					$info[&#039;quicktime&#039;][&#039;timestamps_unix&#039;][&#039;modify&#039;][$atom_structure[&#039;hierarchy&#039;]] = $atom_structure[&#039;modify_time_unix&#039;];

					// https://www.getid3.org/phpBB3/viewtopic.php?t=1908
					// attempt to compute rotation from matrix values
					// 2017-Dec-28: uncertain if 90/270 are correctly oriented; values returned by FixedPoint16_16 should perhaps be -1 instead of 65535(?)
					$matrixRotation = 0;
					switch ($atom_structure[&#039;matrix_a&#039;].&#039;:&#039;.$atom_structure[&#039;matrix_b&#039;].&#039;:&#039;.$atom_structure[&#039;matrix_c&#039;].&#039;:&#039;.$atom_structure[&#039;matrix_d&#039;]) {
						case &#039;1:0:0:1&#039;:         $matrixRotation =   0; break;
						case &#039;0:1:65535:0&#039;:     $matrixRotation =  90; break;
						case &#039;65535:0:0:65535&#039;: $matrixRotation = 180; break;
						case &#039;0:65535:1:0&#039;:     $matrixRotation = 270; break;
						default: break;
					}

					// https://www.getid3.org/phpBB3/viewtopic.php?t=2468
					// The rotation matrix can appear in the Quicktime file multiple times, at least once for each track,
					// and it&#039;s possible that only the video track (or, in theory, one of the video tracks) is flagged as
					// rotated while the other tracks (e.g. audio) is tagged as rotation=0 (behavior noted on iPhone 8 Plus)
					// The correct solution would be to check if the TrackID associated with the rotation matrix is indeed
					// a video track (or the main video track) and only set the rotation then, but since information about
					// what track is what is not trivially there to be examined, the lazy solution is to set the rotation
					// if it is found to be nonzero, on the assumption that tracks that don&#039;t need it will have rotation set
					// to zero (and be effectively ignored) and the video track will have rotation set correctly, which will
					// either be zero and automatically correct, or nonzero and be set correctly.
					if (!isset($info[&#039;video&#039;][&#039;rotate&#039;]) || (($info[&#039;video&#039;][&#039;rotate&#039;] == 0) &amp;&amp; ($matrixRotation &gt; 0))) {
						$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;rotate&#039;] = $info[&#039;video&#039;][&#039;rotate&#039;] = $matrixRotation;
					}

					if ($atom_structure[&#039;flags&#039;][&#039;enabled&#039;] == 1) {
						if (!isset($info[&#039;video&#039;][&#039;resolution_x&#039;]) || !isset($info[&#039;video&#039;][&#039;resolution_y&#039;])) {
							$info[&#039;video&#039;][&#039;resolution_x&#039;] = $atom_structure[&#039;width&#039;];
							$info[&#039;video&#039;][&#039;resolution_y&#039;] = $atom_structure[&#039;height&#039;];
						}
						$info[&#039;video&#039;][&#039;resolution_x&#039;] = max($info[&#039;video&#039;][&#039;resolution_x&#039;], $atom_structure[&#039;width&#039;]);
						$info[&#039;video&#039;][&#039;resolution_y&#039;] = max($info[&#039;video&#039;][&#039;resolution_y&#039;], $atom_structure[&#039;height&#039;]);
						$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;resolution_x&#039;] = $info[&#039;video&#039;][&#039;resolution_x&#039;];
						$info[&#039;quicktime&#039;][&#039;video&#039;][&#039;resolution_y&#039;] = $info[&#039;video&#039;][&#039;resolution_y&#039;];
					} else {
						// see: https://www.getid3.org/phpBB3/viewtopic.php?t=1295
						//if (isset($info[&#039;video&#039;][&#039;resolution_x&#039;])) { unset($info[&#039;video&#039;][&#039;resolution_x&#039;]); }
						//if (isset($info[&#039;video&#039;][&#039;resolution_y&#039;])) { unset($info[&#039;video&#039;][&#039;resolution_y&#039;]); }
						//if (isset($info[&#039;quicktime&#039;][&#039;video&#039;]))    { unset($info[&#039;quicktime&#039;][&#039;video&#039;]);    }
					}
					break;


				case &#039;iods&#039;: // Initial Object DeScriptor atom
					// http://www.koders.com/c/fid1FAB3E762903DC482D8A246D4A4BF9F28E049594.aspx?s=windows.h
					// http://libquicktime.sourcearchive.com/documentation/1.0.2plus-pdebian/iods_8c-source.html
					$offset = 0;
					$atom_structure[&#039;version&#039;]                =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
					$offset += 1;
					$atom_structure[&#039;flags_raw&#039;]              =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 3));
					$offset += 3;
					$atom_structure[&#039;mp4_iod_tag&#039;]            =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
					$offset += 1;
					$atom_structure[&#039;length&#039;]                 = $this-&gt;quicktime_read_mp4_descr_length($atom_data, $offset);
					//$offset already adjusted by quicktime_read_mp4_descr_length()
					$atom_structure[&#039;object_descriptor_id&#039;]   =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 2));
					$offset += 2;
					$atom_structure[&#039;od_profile_level&#039;]       =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
					$offset += 1;
					$atom_structure[&#039;scene_profile_level&#039;]    =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
					$offset += 1;
					$atom_structure[&#039;audio_profile_id&#039;]       =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
					$offset += 1;
					$atom_structure[&#039;video_profile_id&#039;]       =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
					$offset += 1;
					$atom_structure[&#039;graphics_profile_level&#039;] =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
					$offset += 1;

					$atom_structure[&#039;num_iods_tracks&#039;] = ($atom_structure[&#039;length&#039;] - 7) / 6; // 6 bytes would only be right if all tracks use 1-byte length fields
					for ($i = 0; $i &lt; $atom_structure[&#039;num_iods_tracks&#039;]; $i++) {
						$atom_structure[&#039;track&#039;][$i][&#039;ES_ID_IncTag&#039;] =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
						$offset += 1;
						$atom_structure[&#039;track&#039;][$i][&#039;length&#039;]       = $this-&gt;quicktime_read_mp4_descr_length($atom_data, $offset);
						//$offset already adjusted by quicktime_read_mp4_descr_length()
						$atom_structure[&#039;track&#039;][$i][&#039;track_id&#039;]     =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 4));
						$offset += 4;
					}

					$atom_structure[&#039;audio_profile_name&#039;] = $this-&gt;QuicktimeIODSaudioProfileName($atom_structure[&#039;audio_profile_id&#039;]);
					$atom_structure[&#039;video_profile_name&#039;] = $this-&gt;QuicktimeIODSvideoProfileName($atom_structure[&#039;video_profile_id&#039;]);
					break;

				case &#039;ftyp&#039;: // FileTYPe (?) atom (for MP4 it seems)
					$atom_structure[&#039;signature&#039;] =                           substr($atom_data,  0, 4);
					$atom_structure[&#039;unknown_1&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
					$atom_structure[&#039;fourcc&#039;]    =                           substr($atom_data,  8, 4);
					break;

				case &#039;mdat&#039;: // Media DATa atom
					// &#039;mdat&#039; contains the actual data for the audio/video, possibly also subtitles

	/* due to lack of known documentation, this is a kludge implementation. If you know of documentation on how mdat is properly structed, please send it to info@getid3.org */

					// first, skip any &#039;wide&#039; padding, and second &#039;mdat&#039; header (with specified size of zero?)
					$mdat_offset = 0;
					while (true) {
						if (substr($atom_data, $mdat_offset, 8) == &quot;\x00\x00\x00\x08&quot;.&#039;wide&#039;) {
							$mdat_offset += 8;
						} elseif (substr($atom_data, $mdat_offset, 8) == &quot;\x00\x00\x00\x00&quot;.&#039;mdat&#039;) {
							$mdat_offset += 8;
						} else {
							break;
						}
					}
					if (substr($atom_data, $mdat_offset, 4) == &#039;GPRO&#039;) {
						$GOPRO_chunk_length = getid3_lib::LittleEndian2Int(substr($atom_data, $mdat_offset + 4, 4));
						$GOPRO_offset = 8;
						$atom_structure[&#039;GPRO&#039;][&#039;raw&#039;] = substr($atom_data, $mdat_offset + 8, $GOPRO_chunk_length - 8);
						$atom_structure[&#039;GPRO&#039;][&#039;firmware&#039;] = substr($atom_structure[&#039;GPRO&#039;][&#039;raw&#039;],  0, 15);
						$atom_structure[&#039;GPRO&#039;][&#039;unknown1&#039;] = substr($atom_structure[&#039;GPRO&#039;][&#039;raw&#039;], 15, 16);
						$atom_structure[&#039;GPRO&#039;][&#039;unknown2&#039;] = substr($atom_structure[&#039;GPRO&#039;][&#039;raw&#039;], 31, 32);
						$atom_structure[&#039;GPRO&#039;][&#039;unknown3&#039;] = substr($atom_structure[&#039;GPRO&#039;][&#039;raw&#039;], 63, 16);
						$atom_structure[&#039;GPRO&#039;][&#039;camera&#039;]   = substr($atom_structure[&#039;GPRO&#039;][&#039;raw&#039;], 79, 32);
						$info[&#039;quicktime&#039;][&#039;camera&#039;][&#039;model&#039;] = rtrim($atom_structure[&#039;GPRO&#039;][&#039;camera&#039;], &quot;\x00&quot;);
					}

					// check to see if it looks like chapter titles, in the form of unterminated strings with a leading 16-bit size field
					while (($mdat_offset &lt; (strlen($atom_data) - 8))
						&amp;&amp; ($chapter_string_length = getid3_lib::BigEndian2Int(substr($atom_data, $mdat_offset, 2)))
						&amp;&amp; ($chapter_string_length &lt; 1000)
						&amp;&amp; ($chapter_string_length &lt;= (strlen($atom_data) - $mdat_offset - 2))
						&amp;&amp; preg_match(&#039;#^([\x00-\xFF]{2})([\x20-\xFF]+)$#&#039;, substr($atom_data, $mdat_offset, $chapter_string_length + 2), $chapter_matches)) {
							list($dummy, $chapter_string_length_hex, $chapter_string) = $chapter_matches;
							$mdat_offset += (2 + $chapter_string_length);
							@$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;chapters&#039;][] = $chapter_string;

							// &quot;encd&quot; atom specifies encoding. In theory could be anything, almost always UTF-8, but may be UTF-16 with BOM (not currently handled)
							if (substr($atom_data, $mdat_offset, 12) == &quot;\x00\x00\x00\x0C\x65\x6E\x63\x64\x00\x00\x01\x00&quot;) { // UTF-8
								$mdat_offset += 12;
							}
					}

					if (($atomsize &gt; 8) &amp;&amp; (!isset($info[&#039;avdataend_tmp&#039;]) || ($info[&#039;quicktime&#039;][$atomname][&#039;size&#039;] &gt; ($info[&#039;avdataend_tmp&#039;] - $info[&#039;avdataoffset&#039;])))) {

						$info[&#039;avdataoffset&#039;] = $atom_structure[&#039;offset&#039;] + 8;                       // $info[&#039;quicktime&#039;][$atomname][&#039;offset&#039;] + 8;
						$OldAVDataEnd         = $info[&#039;avdataend&#039;];
						$info[&#039;avdataend&#039;]    = $atom_structure[&#039;offset&#039;] + $atom_structure[&#039;size&#039;]; // $info[&#039;quicktime&#039;][$atomname][&#039;offset&#039;] + $info[&#039;quicktime&#039;][$atomname][&#039;size&#039;];

						$getid3_temp = new getID3();
						$getid3_temp-&gt;openfile($this-&gt;getid3-&gt;filename, $this-&gt;getid3-&gt;info[&#039;filesize&#039;], $this-&gt;getid3-&gt;fp);
						$getid3_temp-&gt;info[&#039;avdataoffset&#039;] = $info[&#039;avdataoffset&#039;];
						$getid3_temp-&gt;info[&#039;avdataend&#039;]    = $info[&#039;avdataend&#039;];
						$getid3_mp3 = new getid3_mp3($getid3_temp);
						if ($getid3_mp3-&gt;MPEGaudioHeaderValid($getid3_mp3-&gt;MPEGaudioHeaderDecode($this-&gt;fread(4)))) {
							$getid3_mp3-&gt;getOnlyMPEGaudioInfo($getid3_temp-&gt;info[&#039;avdataoffset&#039;], false);
							if (!empty($getid3_temp-&gt;info[&#039;warning&#039;])) {
								foreach ($getid3_temp-&gt;info[&#039;warning&#039;] as $value) {
									$this-&gt;warning($value);
								}
							}
							if (!empty($getid3_temp-&gt;info[&#039;mpeg&#039;])) {
								$info[&#039;mpeg&#039;] = $getid3_temp-&gt;info[&#039;mpeg&#039;];
								if (isset($info[&#039;mpeg&#039;][&#039;audio&#039;])) {
									$info[&#039;audio&#039;][&#039;dataformat&#039;]   = &#039;mp3&#039;;
									$info[&#039;audio&#039;][&#039;codec&#039;]        = (!empty($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;encoder&#039;]) ? $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;encoder&#039;] : (!empty($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;codec&#039;]) ? $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;codec&#039;] : (!empty($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;LAME&#039;]) ? &#039;LAME&#039; :&#039;mp3&#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;channels&#039;]     = $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;channels&#039;];
									$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;] = strtolower($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;]);
									$info[&#039;bitrate&#039;]               = $info[&#039;audio&#039;][&#039;bitrate&#039;];
								}
							}
						}
						unset($getid3_mp3, $getid3_temp);
						$info[&#039;avdataend&#039;] = $OldAVDataEnd;
						unset($OldAVDataEnd);

					}

					unset($mdat_offset, $chapter_string_length, $chapter_matches);
					break;

				case &#039;ID32&#039;: // ID3v2
					getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.&#039;module.tag.id3v2.php&#039;, __FILE__, true);

					$getid3_temp = new getID3();
					$getid3_temp-&gt;openfile($this-&gt;getid3-&gt;filename, $this-&gt;getid3-&gt;info[&#039;filesize&#039;], $this-&gt;getid3-&gt;fp);
					$getid3_id3v2 = new getid3_id3v2($getid3_temp);
					$getid3_id3v2-&gt;StartingOffset = $atom_structure[&#039;offset&#039;] + 14; // framelength(4)+framename(4)+flags(4)+??(2)
					if ($atom_structure[&#039;valid&#039;] = $getid3_id3v2-&gt;Analyze()) {
						$atom_structure[&#039;id3v2&#039;] = $getid3_temp-&gt;info[&#039;id3v2&#039;];
					} else {
						$this-&gt;warning(&#039;ID32 frame at offset &#039;.$atom_structure[&#039;offset&#039;].&#039; did not parse&#039;);
					}
					unset($getid3_temp, $getid3_id3v2);
					break;

				case &#039;free&#039;: // FREE space atom
				case &#039;skip&#039;: // SKIP atom
				case &#039;wide&#039;: // 64-bit expansion placeholder atom
					// &#039;free&#039;, &#039;skip&#039; and &#039;wide&#039; are just padding, contains no useful data at all

					// When writing QuickTime files, it is sometimes necessary to update an atom&#039;s size.
					// It is impossible to update a 32-bit atom to a 64-bit atom since the 32-bit atom
					// is only 8 bytes in size, and the 64-bit atom requires 16 bytes. Therefore, QuickTime
					// puts an 8-byte placeholder atom before any atoms it may have to update the size of.
					// In this way, if the atom needs to be converted from a 32-bit to a 64-bit atom, the
					// placeholder atom can be overwritten to obtain the necessary 8 extra bytes.
					// The placeholder atom has a type of kWideAtomPlaceholderType ( &#039;wide&#039; ).
					break;


				case &#039;nsav&#039;: // NoSAVe atom
					// http://developer.apple.com/technotes/tn/tn2038.html
					$atom_structure[&#039;data&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4));
					break;

				case &#039;ctyp&#039;: // Controller TYPe atom (seen on QTVR)
					// http://homepages.slingshot.co.nz/~helmboy/quicktime/formats/qtm-layout.txt
					// some controller names are:
					//   0x00 + &#039;std&#039; for linear movie
					//   &#039;none&#039; for no controls
					$atom_structure[&#039;ctyp&#039;] = substr($atom_data, 0, 4);
					$info[&#039;quicktime&#039;][&#039;controller&#039;] = $atom_structure[&#039;ctyp&#039;];
					switch ($atom_structure[&#039;ctyp&#039;]) {
						case &#039;qtvr&#039;:
							$info[&#039;video&#039;][&#039;dataformat&#039;] = &#039;quicktimevr&#039;;
							break;
					}
					break;

				case &#039;pano&#039;: // PANOrama track (seen on QTVR)
					$atom_structure[&#039;pano&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4));
					break;

				case &#039;hint&#039;: // HINT track
				case &#039;hinf&#039;: //
				case &#039;hinv&#039;: //
				case &#039;hnti&#039;: //
					$info[&#039;quicktime&#039;][&#039;hinting&#039;] = true;
					break;

				case &#039;imgt&#039;: // IMaGe Track reference (kQTVRImageTrackRefType) (seen on QTVR)
					for ($i = 0; $i &lt; ($atom_structure[&#039;size&#039;] - 8); $i += 4) {
						$atom_structure[&#039;imgt&#039;][] = getid3_lib::BigEndian2Int(substr($atom_data, $i, 4));
					}
					break;


				// Observed-but-not-handled atom types are just listed here to prevent warnings being generated
				case &#039;FXTC&#039;: // Something to do with Adobe After Effects (?)
				case &#039;PrmA&#039;:
				case &#039;code&#039;:
				case &#039;FIEL&#039;: // this is NOT &quot;fiel&quot; (Field Ordering) as describe here: http://developer.apple.com/documentation/QuickTime/QTFF/QTFFChap3/chapter_4_section_2.html
				case &#039;tapt&#039;: // TrackApertureModeDimensionsAID - http://developer.apple.com/documentation/QuickTime/Reference/QT7-1_Update_Reference/Constants/Constants.html
							// tapt seems to be used to compute the video size [https://www.getid3.org/phpBB3/viewtopic.php?t=838]
							// * http://lists.apple.com/archives/quicktime-api/2006/Aug/msg00014.html
							// * http://handbrake.fr/irclogs/handbrake-dev/handbrake-dev20080128_pg2.html
				case &#039;ctts&#039;://  STCompositionOffsetAID             - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
				case &#039;cslg&#039;://  STCompositionShiftLeastGreatestAID - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
				case &#039;sdtp&#039;://  STSampleDependencyAID              - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
				case &#039;stps&#039;://  STPartialSyncSampleAID             - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
					//$atom_structure[&#039;data&#039;] = $atom_data;
					break;

				case &quot;\xA9&quot;.&#039;xyz&#039;:  // GPS latitude+longitude+altitude
					$atom_structure[&#039;data&#039;] = $atom_data;
					if (preg_match(&#039;#([\\+\\-][0-9\\.]+)([\\+\\-][0-9\\.]+)([\\+\\-][0-9\\.]+)?/$#i&#039;, $atom_data, $matches)) {
						@list($all, $latitude, $longitude, $altitude) = $matches;
						$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_latitude&#039;][]  = floatval($latitude);
						$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_longitude&#039;][] = floatval($longitude);
						if (!empty($altitude)) {
							$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_altitude&#039;][] = floatval($altitude);
						}
					} else {
						$this-&gt;warning(&#039;QuickTime atom &quot;©xyz&quot; data does not match expected data pattern at offset &#039;.$baseoffset.&#039;. Please report as getID3() bug.&#039;);
					}
					break;

				case &#039;NCDT&#039;:
					// https://exiftool.org/TagNames/Nikon.html
					// Nikon-specific QuickTime tags found in the NCDT atom of MOV videos from some Nikon cameras such as the Coolpix S8000 and D5100
					$atom_structure[&#039;subatoms&#039;] = $this-&gt;QuicktimeParseContainerAtom($atom_data, $baseoffset + 4, $atomHierarchy, $ParseAllPossibleAtoms);
					break;
				case &#039;NCTH&#039;: // Nikon Camera THumbnail image
				case &#039;NCVW&#039;: // Nikon Camera preVieW image
				case &#039;NCM1&#039;: // Nikon Camera preview iMage 1
				case &#039;NCM2&#039;: // Nikon Camera preview iMage 2
					// https://exiftool.org/TagNames/Nikon.html
					if (preg_match(&#039;/^\xFF\xD8\xFF/&#039;, $atom_data)) {
						$descriptions = array(
							&#039;NCTH&#039; =&gt; &#039;Nikon Camera Thumbnail Image&#039;,
							&#039;NCVW&#039; =&gt; &#039;Nikon Camera Preview Image&#039;,
							&#039;NCM1&#039; =&gt; &#039;Nikon Camera Preview Image 1&#039;,
							&#039;NCM2&#039; =&gt; &#039;Nikon Camera Preview Image 2&#039;,
						);
						$atom_structure[&#039;data&#039;] = $atom_data;
						$atom_structure[&#039;image_mime&#039;] = &#039;image/jpeg&#039;;
						$atom_structure[&#039;description&#039;] = $descriptions[$atomname];
						$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;picture&#039;][] = array(
							&#039;image_mime&#039; =&gt; $atom_structure[&#039;image_mime&#039;],
							&#039;data&#039; =&gt; $atom_data,
							&#039;description&#039; =&gt; $atom_structure[&#039;description&#039;]
						);
					}
					break;
				case &#039;NCTG&#039;: // Nikon - https://exiftool.org/TagNames/Nikon.html#NCTG
					getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.&#039;module.tag.nikon-nctg.php&#039;, __FILE__, true);
					$nikonNCTG = new getid3_tag_nikon_nctg($this-&gt;getid3);

					$atom_structure[&#039;data&#039;] = $nikonNCTG-&gt;parse($atom_data);
					break;
				case &#039;NCHD&#039;: // Nikon:MakerNoteVersion  - https://exiftool.org/TagNames/Nikon.html
					$makerNoteVersion = &#039;&#039;;
					for ($i = 0, $iMax = strlen($atom_data); $i &lt; $iMax; ++$i) {
						if (ord($atom_data[$i]) &lt;= 0x1F) {
							$makerNoteVersion .= &#039; &#039;.ord($atom_data[$i]);
						} else {
							$makerNoteVersion .= $atom_data[$i];
						}
					}
					$makerNoteVersion = rtrim($makerNoteVersion, &quot;\x00&quot;);
					$atom_structure[&#039;data&#039;] = array(
						&#039;MakerNoteVersion&#039; =&gt; $makerNoteVersion
					);
					break;
				case &#039;NCDB&#039;: // Nikon                   - https://exiftool.org/TagNames/Nikon.html
				case &#039;CNCV&#039;: // Canon:CompressorVersion - https://exiftool.org/TagNames/Canon.html
					$atom_structure[&#039;data&#039;] = $atom_data;
					break;

				case &quot;\x00\x00\x00\x00&quot;:
					// some kind of metacontainer, may contain a big data dump such as:
					// mdta keys \005 mdtacom.apple.quicktime.make (mdtacom.apple.quicktime.creationdate ,mdtacom.apple.quicktime.location.ISO6709 $mdtacom.apple.quicktime.software !mdtacom.apple.quicktime.model ilst \01D \001 \015data \001DE\010Apple 0 \002 (data \001DE\0102011-05-11T17:54:04+0200 2 \003 *data \001DE\010+52.4936+013.3897+040.247/ \01D \004 \015data \001DE\0104.3.1 \005 \018data \001DE\010iPhone 4
					// https://xhelmboyx.tripod.com/formats/qti-layout.txt

					$atom_structure[&#039;version&#039;]   =          getid3_lib::BigEndian2Int(substr($atom_data, 0, 1));
					$atom_structure[&#039;flags_raw&#039;] =          getid3_lib::BigEndian2Int(substr($atom_data, 1, 3));
					$atom_structure[&#039;subatoms&#039;]  = $this-&gt;QuicktimeParseContainerAtom(substr($atom_data, 4), $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
					//$atom_structure[&#039;subatoms&#039;]  = $this-&gt;QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
					break;

				case &#039;meta&#039;: // METAdata atom
					// https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/Metadata/Metadata.html

					$atom_structure[&#039;version&#039;]   =          getid3_lib::BigEndian2Int(substr($atom_data, 0, 1));
					$atom_structure[&#039;flags_raw&#039;] =          getid3_lib::BigEndian2Int(substr($atom_data, 1, 3));
					$atom_structure[&#039;subatoms&#039;]  = $this-&gt;QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
					break;

				case &#039;data&#039;: // metaDATA atom
					static $metaDATAkey = 1; // real ugly, but so is the QuickTime structure that stores keys and values in different multinested locations that are hard to relate to each other
					// seems to be 2 bytes language code (ASCII), 2 bytes unknown (set to 0x10B5 in sample I have), remainder is useful data
					$atom_structure[&#039;language&#039;] =                           substr($atom_data, 4 + 0, 2);
					$atom_structure[&#039;unknown&#039;]  = getid3_lib::BigEndian2Int(substr($atom_data, 4 + 2, 2));
					$atom_structure[&#039;data&#039;]     =                           substr($atom_data, 4 + 4);
					$atom_structure[&#039;key_name&#039;] = (isset($info[&#039;quicktime&#039;][&#039;temp_meta_key_names&#039;][$metaDATAkey]) ? $info[&#039;quicktime&#039;][&#039;temp_meta_key_names&#039;][$metaDATAkey] : &#039;&#039;);
					$metaDATAkey++;

					if ($atom_structure[&#039;key_name&#039;] &amp;&amp; $atom_structure[&#039;data&#039;]) {
						@$info[&#039;quicktime&#039;][&#039;comments&#039;][str_replace(&#039;com.apple.quicktime.&#039;, &#039;&#039;, $atom_structure[&#039;key_name&#039;])][] = $atom_structure[&#039;data&#039;];
					}
					break;

				case &#039;keys&#039;: // KEYS that may be present in the metadata atom.
					// https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW21
					// The metadata item keys atom holds a list of the metadata keys that may be present in the metadata atom.
					// This list is indexed starting with 1; 0 is a reserved index value. The metadata item keys atom is a full atom with an atom type of &quot;keys&quot;.
					$atom_structure[&#039;version&#039;]       = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
					$atom_structure[&#039;flags_raw&#039;]     = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
					$atom_structure[&#039;entry_count&#039;]   = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
					$keys_atom_offset = 8;
					for ($i = 1; $i &lt;= $atom_structure[&#039;entry_count&#039;]; $i++) {
						$atom_structure[&#039;keys&#039;][$i][&#039;key_size&#039;]      = getid3_lib::BigEndian2Int(substr($atom_data, $keys_atom_offset + 0, 4));
						$atom_structure[&#039;keys&#039;][$i][&#039;key_namespace&#039;] =                           substr($atom_data, $keys_atom_offset + 4, 4);
						$atom_structure[&#039;keys&#039;][$i][&#039;key_value&#039;]     =                           substr($atom_data, $keys_atom_offset + 8, $atom_structure[&#039;keys&#039;][$i][&#039;key_size&#039;] - 8);
						$keys_atom_offset += $atom_structure[&#039;keys&#039;][$i][&#039;key_size&#039;]; // key_size includes the 4+4 bytes for key_size and key_namespace

						$info[&#039;quicktime&#039;][&#039;temp_meta_key_names&#039;][$i] = $atom_structure[&#039;keys&#039;][$i][&#039;key_value&#039;];
					}
					break;

				case &#039;uuid&#039;: // user-defined atom often seen containing XML data, also used for potentially many other purposes, only a few specifically handled by getID3 (e.g. 360fly spatial data)
					//Get the UUID ID in first 16 bytes
					$uuid_bytes_read = unpack(&#039;H8time_low/H4time_mid/H4time_hi/H4clock_seq_hi/H12clock_seq_low&#039;, substr($atom_data, 0, 16));
					$atom_structure[&#039;uuid_field_id&#039;] = implode(&#039;-&#039;, $uuid_bytes_read);

					switch ($atom_structure[&#039;uuid_field_id&#039;]) {   // http://fileformats.archiveteam.org/wiki/Boxes/atoms_format#UUID_boxes

						case &#039;0537cdab-9d0c-4431-a72a-fa561f2a113e&#039;: // Exif                                       - http://fileformats.archiveteam.org/wiki/Exif
						case &#039;2c4c0100-8504-40b9-a03e-562148d6dfeb&#039;: // Photoshop Image Resources                  - http://fileformats.archiveteam.org/wiki/Photoshop_Image_Resources
						case &#039;33c7a4d2-b81d-4723-a0ba-f1a3e097ad38&#039;: // IPTC-IIM                                   - http://fileformats.archiveteam.org/wiki/IPTC-IIM
						case &#039;8974dbce-7be7-4c51-84f9-7148f9882554&#039;: // PIFF Track Encryption Box                  - http://fileformats.archiveteam.org/wiki/Protected_Interoperable_File_Format
						case &#039;96a9f1f1-dc98-402d-a7ae-d68e34451809&#039;: // GeoJP2 World File Box                      - http://fileformats.archiveteam.org/wiki/GeoJP2
						case &#039;a2394f52-5a9b-4f14-a244-6c427c648df4&#039;: // PIFF Sample Encryption Box                 - http://fileformats.archiveteam.org/wiki/Protected_Interoperable_File_Format
						case &#039;b14bf8bd-083d-4b43-a5ae-8cd7d5a6ce03&#039;: // GeoJP2 GeoTIFF Box                         - http://fileformats.archiveteam.org/wiki/GeoJP2
						case &#039;d08a4f18-10f3-4a82-b6c8-32d8aba183d3&#039;: // PIFF Protection System Specific Header Box - http://fileformats.archiveteam.org/wiki/Protected_Interoperable_File_Format
							$this-&gt;warning(&#039;Unhandled (but recognized) &quot;uuid&quot; atom identified by &quot;&#039;.$atom_structure[&#039;uuid_field_id&#039;].&#039;&quot; at offset &#039;.$atom_structure[&#039;offset&#039;].&#039; (&#039;.strlen($atom_data).&#039; bytes)&#039;);
							break;

						case &#039;be7acfcb-97a9-42e8-9c71-999491e3afac&#039;: // XMP data (in XML format)
							$atom_structure[&#039;xml&#039;] = substr($atom_data, 16, strlen($atom_data) - 16 - 8); // 16 bytes for UUID, 8 bytes header(?)
							break;

						case &#039;efe1589a-bb77-49ef-8095-27759eb1dc6f&#039;: // 360fly data
							/* 360fly code in this block by Paul Lewis 2019-Oct-31 */
							/*	Sensor Timestamps need to be calculated using the recordings base time at [&#039;quicktime&#039;][&#039;moov&#039;][&#039;subatoms&#039;][0][&#039;creation_time_unix&#039;]. */
							$atom_structure[&#039;title&#039;] = &#039;360Fly Sensor Data&#039;;

							//Get the UUID HEADER data
							$uuid_bytes_read = unpack(&#039;vheader_size/vheader_version/vtimescale/vhardware_version/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/&#039;, substr($atom_data, 16, 32));
							$atom_structure[&#039;uuid_header&#039;] = $uuid_bytes_read;

							$start_byte = 48;
							$atom_SENSOR_data = substr($atom_data, $start_byte);
							$atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;] = array(
									&#039;fusion_count&#039;   =&gt; 0,       // ID 250
									&#039;fusion_data&#039;    =&gt; array(),
									&#039;accel_count&#039;    =&gt; 0,       // ID 1
									&#039;accel_data&#039;     =&gt; array(),
									&#039;gyro_count&#039;     =&gt; 0,       // ID 2
									&#039;gyro_data&#039;      =&gt; array(),
									&#039;magno_count&#039;    =&gt; 0,       // ID 3
									&#039;magno_data&#039;     =&gt; array(),
									&#039;gps_count&#039;      =&gt; 0,       // ID 5
									&#039;gps_data&#039;       =&gt; array(),
									&#039;rotation_count&#039; =&gt; 0,       // ID 6
									&#039;rotation_data&#039;  =&gt; array(),
									&#039;unknown_count&#039;  =&gt; 0,       // ID ??
									&#039;unknown_data&#039;   =&gt; array(),
									&#039;debug_list&#039;     =&gt; &#039;&#039;,      // Used to debug variables stored as comma delimited strings
							);
							$debug_structure = array();
							$debug_structure[&#039;debug_items&#039;] = array();
							// Can start loop here to decode all sensor data in 32 Byte chunks:
							foreach (str_split($atom_SENSOR_data, 32) as $sensor_key =&gt; $sensor_data) {
								// This gets me a data_type code to work out what data is in the next 31 bytes.
								$sensor_data_type = substr($sensor_data, 0, 1);
								$sensor_data_content = substr($sensor_data, 1);
								$uuid_bytes_read = unpack(&#039;C*&#039;, $sensor_data_type);
								$sensor_data_array = array();
								switch ($uuid_bytes_read[1]) {
									case 250:
										$atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;fusion_count&#039;]++;
										$uuid_bytes_read = unpack(&#039;cmode/Jtimestamp/Gyaw/Gpitch/Groll/x*&#039;, $sensor_data_content);
										$sensor_data_array[&#039;mode&#039;]      = $uuid_bytes_read[&#039;mode&#039;];
										$sensor_data_array[&#039;timestamp&#039;] = $uuid_bytes_read[&#039;timestamp&#039;];
										$sensor_data_array[&#039;yaw&#039;]       = $uuid_bytes_read[&#039;yaw&#039;];
										$sensor_data_array[&#039;pitch&#039;]     = $uuid_bytes_read[&#039;pitch&#039;];
										$sensor_data_array[&#039;roll&#039;]      = $uuid_bytes_read[&#039;roll&#039;];
										array_push($atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;fusion_data&#039;], $sensor_data_array);
										break;
									case 1:
										$atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;accel_count&#039;]++;
										$uuid_bytes_read = unpack(&#039;cmode/Jtimestamp/Gyaw/Gpitch/Groll/x*&#039;, $sensor_data_content);
										$sensor_data_array[&#039;mode&#039;]      = $uuid_bytes_read[&#039;mode&#039;];
										$sensor_data_array[&#039;timestamp&#039;] = $uuid_bytes_read[&#039;timestamp&#039;];
										$sensor_data_array[&#039;yaw&#039;]       = $uuid_bytes_read[&#039;yaw&#039;];
										$sensor_data_array[&#039;pitch&#039;]     = $uuid_bytes_read[&#039;pitch&#039;];
										$sensor_data_array[&#039;roll&#039;]      = $uuid_bytes_read[&#039;roll&#039;];
										array_push($atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;accel_data&#039;], $sensor_data_array);
										break;
									case 2:
										$atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;gyro_count&#039;]++;
										$uuid_bytes_read = unpack(&#039;cmode/Jtimestamp/Gyaw/Gpitch/Groll/x*&#039;, $sensor_data_content);
										$sensor_data_array[&#039;mode&#039;]      = $uuid_bytes_read[&#039;mode&#039;];
										$sensor_data_array[&#039;timestamp&#039;] = $uuid_bytes_read[&#039;timestamp&#039;];
										$sensor_data_array[&#039;yaw&#039;]       = $uuid_bytes_read[&#039;yaw&#039;];
										$sensor_data_array[&#039;pitch&#039;]     = $uuid_bytes_read[&#039;pitch&#039;];
										$sensor_data_array[&#039;roll&#039;]      = $uuid_bytes_read[&#039;roll&#039;];
										array_push($atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;gyro_data&#039;], $sensor_data_array);
										break;
									case 3:
										$atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;magno_count&#039;]++;
										$uuid_bytes_read = unpack(&#039;cmode/Jtimestamp/Gmagx/Gmagy/Gmagz/x*&#039;, $sensor_data_content);
										$sensor_data_array[&#039;mode&#039;]      = $uuid_bytes_read[&#039;mode&#039;];
										$sensor_data_array[&#039;timestamp&#039;] = $uuid_bytes_read[&#039;timestamp&#039;];
										$sensor_data_array[&#039;magx&#039;]      = $uuid_bytes_read[&#039;magx&#039;];
										$sensor_data_array[&#039;magy&#039;]      = $uuid_bytes_read[&#039;magy&#039;];
										$sensor_data_array[&#039;magz&#039;]      = $uuid_bytes_read[&#039;magz&#039;];
										array_push($atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;magno_data&#039;], $sensor_data_array);
										break;
									case 5:
										$atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;gps_count&#039;]++;
										$uuid_bytes_read = unpack(&#039;cmode/Jtimestamp/Glat/Glon/Galt/Gspeed/nbearing/nacc/x*&#039;, $sensor_data_content);
										$sensor_data_array[&#039;mode&#039;]      = $uuid_bytes_read[&#039;mode&#039;];
										$sensor_data_array[&#039;timestamp&#039;] = $uuid_bytes_read[&#039;timestamp&#039;];
										$sensor_data_array[&#039;lat&#039;]       = $uuid_bytes_read[&#039;lat&#039;];
										$sensor_data_array[&#039;lon&#039;]       = $uuid_bytes_read[&#039;lon&#039;];
										$sensor_data_array[&#039;alt&#039;]       = $uuid_bytes_read[&#039;alt&#039;];
										$sensor_data_array[&#039;speed&#039;]     = $uuid_bytes_read[&#039;speed&#039;];
										$sensor_data_array[&#039;bearing&#039;]   = $uuid_bytes_read[&#039;bearing&#039;];
										$sensor_data_array[&#039;acc&#039;]       = $uuid_bytes_read[&#039;acc&#039;];
										array_push($atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;gps_data&#039;], $sensor_data_array);
										//array_push($debug_structure[&#039;debug_items&#039;], $uuid_bytes_read[&#039;timestamp&#039;]);
										break;
									case 6:
										$atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;rotation_count&#039;]++;
										$uuid_bytes_read = unpack(&#039;cmode/Jtimestamp/Grotx/Groty/Grotz/x*&#039;, $sensor_data_content);
										$sensor_data_array[&#039;mode&#039;]      = $uuid_bytes_read[&#039;mode&#039;];
										$sensor_data_array[&#039;timestamp&#039;] = $uuid_bytes_read[&#039;timestamp&#039;];
										$sensor_data_array[&#039;rotx&#039;]      = $uuid_bytes_read[&#039;rotx&#039;];
										$sensor_data_array[&#039;roty&#039;]      = $uuid_bytes_read[&#039;roty&#039;];
										$sensor_data_array[&#039;rotz&#039;]      = $uuid_bytes_read[&#039;rotz&#039;];
										array_push($atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;rotation_data&#039;], $sensor_data_array);
										break;
									default:
										$atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;unknown_count&#039;]++;
										break;
								}
							}
							//if (isset($debug_structure[&#039;debug_items&#039;]) &amp;&amp; count($debug_structure[&#039;debug_items&#039;]) &gt; 0) {
							//	$atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;debug_list&#039;] = implode(&#039;,&#039;, $debug_structure[&#039;debug_items&#039;]);
							//} else {
								$atom_structure[&#039;sensor_data&#039;][&#039;data_type&#039;][&#039;debug_list&#039;] = &#039;No debug items in list!&#039;;
							//}
							break;

						default:
							$this-&gt;warning(&#039;Unhandled &quot;uuid&quot; atom identified by &quot;&#039;.$atom_structure[&#039;uuid_field_id&#039;].&#039;&quot; at offset &#039;.$atom_structure[&#039;offset&#039;].&#039; (&#039;.strlen($atom_data).&#039; bytes)&#039;);
					}
					break;

				case &#039;gps &#039;:
					// https://dashcamtalk.com/forum/threads/script-to-extract-gps-data-from-novatek-mp4.20808/page-2#post-291730
					// The &#039;gps &#039; contains simple look up table made up of 8byte rows, that point to the &#039;free&#039; atoms that contains the actual GPS data.
					// The first row is version/metadata/notsure, I skip that.
					// The following rows consist of 4byte address (absolute) and 4byte size (0x1000), these point to the GPS data in the file.

					$GPS_rowsize = 8; // 4 bytes for offset, 4 bytes for size
					if (strlen($atom_data) &gt; 0) {
						if ((strlen($atom_data) % $GPS_rowsize) == 0) {
							$atom_structure[&#039;gps_toc&#039;] = array();
							foreach (str_split($atom_data, $GPS_rowsize) as $counter =&gt; $datapair) {
								$atom_structure[&#039;gps_toc&#039;][] = unpack(&#039;Noffset/Nsize&#039;, substr($atom_data, $counter * $GPS_rowsize, $GPS_rowsize));
							}

							$atom_structure[&#039;gps_entries&#039;] = array();
							$previous_offset = $this-&gt;ftell();
							foreach ($atom_structure[&#039;gps_toc&#039;] as $key =&gt; $gps_pointer) {
								if ($key == 0) {
									// &quot;The first row is version/metadata/notsure, I skip that.&quot;
									continue;
								}
								$this-&gt;fseek($gps_pointer[&#039;offset&#039;]);
								$GPS_free_data = $this-&gt;fread($gps_pointer[&#039;size&#039;]);

								/*
								// 2017-05-10: I see some of the data, notably the Hour-Minute-Second, but cannot reconcile the rest of the data. However, the NMEA &quot;GPRMC&quot; line is there and relatively easy to parse, so I&#039;m using that instead

								// https://dashcamtalk.com/forum/threads/script-to-extract-gps-data-from-novatek-mp4.20808/page-2#post-291730
								// The structure of the GPS data atom (the &#039;free&#039; atoms mentioned above) is following:
								// hour,minute,second,year,month,day,active,latitude_b,longitude_b,unknown2,latitude,longitude,speed = struct.unpack_from(&#039;&lt;IIIIIIssssfff&#039;,data, 48)
								// For those unfamiliar with python struct:
								// I = int
								// s = is string (size 1, in this case)
								// f = float

								//$atom_structure[&#039;gps_entries&#039;][$key] = unpack(&#039;Vhour/Vminute/Vsecond/Vyear/Vmonth/Vday/Vactive/Vlatitude_b/Vlongitude_b/Vunknown2/flatitude/flongitude/fspeed&#039;, substr($GPS_free_data, 48));
								*/

								// $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62
								// $GPRMC,183731,A,3907.482,N,12102.436,W,000.0,360.0,080301,015.5,E*67
								// $GPRMC,002454,A,3553.5295,N,13938.6570,E,0.0,43.1,180700,7.1,W,A*3F
								// $GPRMC,094347.000,A,5342.0061,N,00737.9908,W,0.01,156.75,140217,,,A*7D
								if (preg_match(&#039;#\\$GPRMC,([0-9\\.]*),([AV]),([0-9\\.]*),([NS]),([0-9\\.]*),([EW]),([0-9\\.]*),([0-9\\.]*),([0-9]*),([0-9\\.]*),([EW]?)(,[A])?(\\*[0-9A-F]{2})#&#039;, $GPS_free_data, $matches)) {
									$GPS_this_GPRMC = array();
									$GPS_this_GPRMC_raw = array();
									list(
										$GPS_this_GPRMC_raw[&#039;gprmc&#039;],
										$GPS_this_GPRMC_raw[&#039;timestamp&#039;],
										$GPS_this_GPRMC_raw[&#039;status&#039;],
										$GPS_this_GPRMC_raw[&#039;latitude&#039;],
										$GPS_this_GPRMC_raw[&#039;latitude_direction&#039;],
										$GPS_this_GPRMC_raw[&#039;longitude&#039;],
										$GPS_this_GPRMC_raw[&#039;longitude_direction&#039;],
										$GPS_this_GPRMC_raw[&#039;knots&#039;],
										$GPS_this_GPRMC_raw[&#039;angle&#039;],
										$GPS_this_GPRMC_raw[&#039;datestamp&#039;],
										$GPS_this_GPRMC_raw[&#039;variation&#039;],
										$GPS_this_GPRMC_raw[&#039;variation_direction&#039;],
										$dummy,
										$GPS_this_GPRMC_raw[&#039;checksum&#039;],
									) = $matches;
									$GPS_this_GPRMC[&#039;raw&#039;] = $GPS_this_GPRMC_raw;

									$hour   = substr($GPS_this_GPRMC[&#039;raw&#039;][&#039;timestamp&#039;], 0, 2);
									$minute = substr($GPS_this_GPRMC[&#039;raw&#039;][&#039;timestamp&#039;], 2, 2);
									$second = substr($GPS_this_GPRMC[&#039;raw&#039;][&#039;timestamp&#039;], 4, 2);
									$ms     = substr($GPS_this_GPRMC[&#039;raw&#039;][&#039;timestamp&#039;], 6);    // may contain decimal seconds
									$day    = substr($GPS_this_GPRMC[&#039;raw&#039;][&#039;datestamp&#039;], 0, 2);
									$month  = substr($GPS_this_GPRMC[&#039;raw&#039;][&#039;datestamp&#039;], 2, 2);
									$year   = (int) substr($GPS_this_GPRMC[&#039;raw&#039;][&#039;datestamp&#039;], 4, 2);
									$year += (($year &gt; 90) ? 1900 : 2000); // complete lack of foresight: datestamps are stored with 2-digit years, take best guess
									$GPS_this_GPRMC[&#039;timestamp&#039;] = $year.&#039;-&#039;.$month.&#039;-&#039;.$day.&#039; &#039;.$hour.&#039;:&#039;.$minute.&#039;:&#039;.$second.$ms;

									$GPS_this_GPRMC[&#039;active&#039;] = ($GPS_this_GPRMC[&#039;raw&#039;][&#039;status&#039;] == &#039;A&#039;); // A=Active,V=Void

									foreach (array(&#039;latitude&#039;,&#039;longitude&#039;) as $latlon) {
										preg_match(&#039;#^([0-9]{1,3})([0-9]{2}\\.[0-9]+)$#&#039;, $GPS_this_GPRMC[&#039;raw&#039;][$latlon], $matches);
										list($dummy, $deg, $min) = $matches;
										$GPS_this_GPRMC[$latlon] = $deg + ($min / 60);
									}
									$GPS_this_GPRMC[&#039;latitude&#039;]  *= (($GPS_this_GPRMC[&#039;raw&#039;][&#039;latitude_direction&#039;]  == &#039;S&#039;) ? -1 : 1);
									$GPS_this_GPRMC[&#039;longitude&#039;] *= (($GPS_this_GPRMC[&#039;raw&#039;][&#039;longitude_direction&#039;] == &#039;W&#039;) ? -1 : 1);

									$GPS_this_GPRMC[&#039;heading&#039;]    = $GPS_this_GPRMC[&#039;raw&#039;][&#039;angle&#039;];
									$GPS_this_GPRMC[&#039;speed_knot&#039;] = $GPS_this_GPRMC[&#039;raw&#039;][&#039;knots&#039;];
									$GPS_this_GPRMC[&#039;speed_kmh&#039;]  = $GPS_this_GPRMC[&#039;raw&#039;][&#039;knots&#039;] * 1.852;
									if ($GPS_this_GPRMC[&#039;raw&#039;][&#039;variation&#039;]) {
										$GPS_this_GPRMC[&#039;variation&#039;]  = $GPS_this_GPRMC[&#039;raw&#039;][&#039;variation&#039;];
										$GPS_this_GPRMC[&#039;variation&#039;] *= (($GPS_this_GPRMC[&#039;raw&#039;][&#039;variation_direction&#039;] == &#039;W&#039;) ? -1 : 1);
									}

									$atom_structure[&#039;gps_entries&#039;][$key] = $GPS_this_GPRMC;

									@$info[&#039;quicktime&#039;][&#039;gps_track&#039;][$GPS_this_GPRMC[&#039;timestamp&#039;]] = array(
										&#039;latitude&#039;  =&gt; (float) $GPS_this_GPRMC[&#039;latitude&#039;],
										&#039;longitude&#039; =&gt; (float) $GPS_this_GPRMC[&#039;longitude&#039;],
										&#039;speed_kmh&#039; =&gt; (float) $GPS_this_GPRMC[&#039;speed_kmh&#039;],
										&#039;heading&#039;   =&gt; (float) $GPS_this_GPRMC[&#039;heading&#039;],
									);

								} else {
									$this-&gt;warning(&#039;Unhandled GPS format in &quot;free&quot; atom at offset &#039;.$gps_pointer[&#039;offset&#039;]);
								}
							}
							$this-&gt;fseek($previous_offset);

						} else {
							$this-&gt;warning(&#039;QuickTime atom &quot;&#039;.$atomname.&#039;&quot; is not mod-8 bytes long (&#039;.$atomsize.&#039; bytes) at offset &#039;.$baseoffset);
						}
					} else {
						$this-&gt;warning(&#039;QuickTime atom &quot;&#039;.$atomname.&#039;&quot; is zero bytes long at offset &#039;.$baseoffset);
					}
					break;

				case &#039;loci&#039;:// 3GP location (El Loco)
					$loffset = 0;
					$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_flags&#039;]     = array(  getid3_lib::BigEndian2Int(substr($atom_data, 0, 4)));
					$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_lang&#039;]      = array(  getid3_lib::BigEndian2Int(substr($atom_data, 4, 2)));
					$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_location&#039;]  = array(          $this-&gt;LociString(substr($atom_data, 6), $loffset));
					$loci_data = substr($atom_data, 6 + $loffset);
					$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_role&#039;]      = array(  getid3_lib::BigEndian2Int(substr($loci_data, 0, 1)));
					$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_longitude&#039;] = array(getid3_lib::FixedPoint16_16(substr($loci_data, 1, 4)));
					$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_latitude&#039;]  = array(getid3_lib::FixedPoint16_16(substr($loci_data, 5, 4)));
					$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_altitude&#039;]  = array(getid3_lib::FixedPoint16_16(substr($loci_data, 9, 4)));
					$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_body&#039;]      = array(          $this-&gt;LociString(substr($loci_data, 13           ), $loffset));
					$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;gps_notes&#039;]     = array(          $this-&gt;LociString(substr($loci_data, 13 + $loffset), $loffset));
					break;

				case &#039;chpl&#039;: // CHaPter List
					// https://www.adobe.com/content/dam/Adobe/en/devnet/flv/pdfs/video_file_format_spec_v10.pdf
					$chpl_version = getid3_lib::BigEndian2Int(substr($atom_data, 4, 1)); // Expected to be 0
					$chpl_flags   = getid3_lib::BigEndian2Int(substr($atom_data, 5, 3)); // Reserved, set to 0
					$chpl_count   = getid3_lib::BigEndian2Int(substr($atom_data, 8, 1));
					$chpl_offset = 9;
					for ($i = 0; $i &lt; $chpl_count; $i++) {
						if (($chpl_offset + 9) &gt;= strlen($atom_data)) {
							$this-&gt;warning(&#039;QuickTime chapter &#039;.$i.&#039; extends beyond end of &quot;chpl&quot; atom&#039;);
							break;
						}
						$info[&#039;quicktime&#039;][&#039;chapters&#039;][$i][&#039;timestamp&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $chpl_offset, 8)) / 10000000; // timestamps are stored as 100-nanosecond units
						$chpl_offset += 8;
						$chpl_title_size = getid3_lib::BigEndian2Int(substr($atom_data, $chpl_offset, 1));
						$chpl_offset += 1;
						$info[&#039;quicktime&#039;][&#039;chapters&#039;][$i][&#039;title&#039;]     =                           substr($atom_data, $chpl_offset, $chpl_title_size);
						$chpl_offset += $chpl_title_size;
					}
					break;

				case &#039;FIRM&#039;: // FIRMware version(?), seen on GoPro Hero4
					$info[&#039;quicktime&#039;][&#039;camera&#039;][&#039;firmware&#039;] = $atom_data;
					break;

				case &#039;CAME&#039;: // FIRMware version(?), seen on GoPro Hero4
					$info[&#039;quicktime&#039;][&#039;camera&#039;][&#039;serial_hash&#039;] = unpack(&#039;H*&#039;, $atom_data);
					break;

				case &#039;dscp&#039;:
				case &#039;rcif&#039;:
					// https://www.getid3.org/phpBB3/viewtopic.php?t=1908
					if (substr($atom_data, 0, 7) == &quot;\x00\x00\x00\x00\x55\xC4&quot;.&#039;{&#039;) {
						if ($json_decoded = @json_decode(rtrim(substr($atom_data, 6), &quot;\x00&quot;), true)) {
							$info[&#039;quicktime&#039;][&#039;camera&#039;][$atomname] = $json_decoded;
							if (($atomname == &#039;rcif&#039;) &amp;&amp; isset($info[&#039;quicktime&#039;][&#039;camera&#039;][&#039;rcif&#039;][&#039;wxcamera&#039;][&#039;rotate&#039;])) {
								$info[&#039;video&#039;][&#039;rotate&#039;] = $info[&#039;quicktime&#039;][&#039;video&#039;][&#039;rotate&#039;] = $info[&#039;quicktime&#039;][&#039;camera&#039;][&#039;rcif&#039;][&#039;wxcamera&#039;][&#039;rotate&#039;];
							}
						} else {
							$this-&gt;warning(&#039;Failed to JSON decode atom &quot;&#039;.$atomname.&#039;&quot;&#039;);
							$atom_structure[&#039;data&#039;] = $atom_data;
						}
						unset($json_decoded);
					} else {
						$this-&gt;warning(&#039;Expecting 55 C4 7B at start of atom &quot;&#039;.$atomname.&#039;&quot;, found &#039;.getid3_lib::PrintHexBytes(substr($atom_data, 4, 3)).&#039; instead&#039;);
						$atom_structure[&#039;data&#039;] = $atom_data;
					}
					break;

				case &#039;frea&#039;:
					// https://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Kodak.html#frea
					// may contain &quot;scra&quot; (PreviewImage) and/or &quot;thma&quot; (ThumbnailImage)
					$atom_structure[&#039;subatoms&#039;] = $this-&gt;QuicktimeParseContainerAtom($atom_data, $baseoffset + 4, $atomHierarchy, $ParseAllPossibleAtoms);
					break;
				case &#039;tima&#039;: // subatom to &quot;frea&quot;
					// no idea what this does, the one sample file I&#039;ve seen has a value of 0x00000027
					$atom_structure[&#039;data&#039;] = $atom_data;
					break;
				case &#039;ver &#039;: // subatom to &quot;frea&quot;
					// some kind of version number, the one sample file I&#039;ve seen has a value of &quot;3.00.073&quot;
					$atom_structure[&#039;data&#039;] = $atom_data;
					break;
				case &#039;thma&#039;: // subatom to &quot;frea&quot; -- &quot;ThumbnailImage&quot;
					// https://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Kodak.html#frea
					if (strlen($atom_data) &gt; 0) {
						$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;picture&#039;][] = array(&#039;data&#039;=&gt;$atom_data, &#039;image_mime&#039;=&gt;&#039;image/jpeg&#039;, &#039;description&#039;=&gt;&#039;ThumbnailImage&#039;);
					}
					break;
				case &#039;scra&#039;: // subatom to &quot;frea&quot; -- &quot;PreviewImage&quot;
					// https://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Kodak.html#frea
					// but the only sample file I&#039;ve seen has no useful data here
					if (strlen($atom_data) &gt; 0) {
						$info[&#039;quicktime&#039;][&#039;comments&#039;][&#039;picture&#039;][] = array(&#039;data&#039;=&gt;$atom_data, &#039;image_mime&#039;=&gt;&#039;image/jpeg&#039;, &#039;description&#039;=&gt;&#039;PreviewImage&#039;);
					}
					break;

				case &#039;cdsc&#039;: // timed metadata reference
					// A QuickTime movie can contain none, one, or several timed metadata tracks. Timed metadata tracks can refer to multiple tracks.
					// Metadata tracks are linked to the tracks they describe using a track-reference of type &#039;cdsc&#039;. The metadata track holds the &#039;cdsc&#039; track reference.
					$atom_structure[&#039;track_number&#039;] = getid3_lib::BigEndian2Int($atom_data);
					break;


				case &#039;esds&#039;: // Elementary Stream DeScriptor
					// https://github.com/JamesHeinrich/getID3/issues/414
					// https://chromium.googlesource.com/chromium/src/media/+/refs/heads/main/formats/mp4/es_descriptor.cc
					// https://chromium.googlesource.com/chromium/src/media/+/refs/heads/main/formats/mp4/es_descriptor.h
					$atom_structure[&#039;version&#039;]   = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1)); // hardcoded: 0x00
					$atom_structure[&#039;flags_raw&#039;] = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x000000
					$esds_offset = 4;

					$atom_structure[&#039;ES_DescrTag&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 1));
					$esds_offset += 1;
					if ($atom_structure[&#039;ES_DescrTag&#039;] != 0x03) {
						$this-&gt;warning(&#039;expecting esds.ES_DescrTag = 0x03, found 0x&#039;.getid3_lib::PrintHexBytes($atom_structure[&#039;ES_DescrTag&#039;]).&#039;), at offset &#039;.$atom_structure[&#039;offset&#039;]);
						break;
					}
					$atom_structure[&#039;ES_DescrSize&#039;] = $this-&gt;quicktime_read_mp4_descr_length($atom_data, $esds_offset);

					$atom_structure[&#039;ES_ID&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 2));
					$esds_offset += 2;
					$atom_structure[&#039;ES_flagsraw&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 1));
					$esds_offset += 1;
					$atom_structure[&#039;ES_flags&#039;][&#039;stream_dependency&#039;] = (bool) ($atom_structure[&#039;ES_flagsraw&#039;] &amp; 0x80);
					$atom_structure[&#039;ES_flags&#039;][&#039;url_flag&#039;]          = (bool) ($atom_structure[&#039;ES_flagsraw&#039;] &amp; 0x40);
					$atom_structure[&#039;ES_flags&#039;][&#039;ocr_stream&#039;]        = (bool) ($atom_structure[&#039;ES_flagsraw&#039;] &amp; 0x20);
					$atom_structure[&#039;ES_stream_priority&#039;]            =        ($atom_structure[&#039;ES_flagsraw&#039;] &amp; 0x1F);
					if ($atom_structure[&#039;ES_flags&#039;][&#039;url_flag&#039;]) {
						$this-&gt;warning(&#039;Unsupported esds.url_flag enabled at offset &#039;.$atom_structure[&#039;offset&#039;]);
						break;
					}
					if ($atom_structure[&#039;ES_flags&#039;][&#039;stream_dependency&#039;]) {
						$atom_structure[&#039;ES_dependsOn_ES_ID&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 2));
						$esds_offset += 2;
					}
					if ($atom_structure[&#039;ES_flags&#039;][&#039;ocr_stream&#039;]) {
						$atom_structure[&#039;ES_OCR_ES_Id&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 2));
						$esds_offset += 2;
					}

					$atom_structure[&#039;ES_DecoderConfigDescrTag&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 1));
					$esds_offset += 1;
					if ($atom_structure[&#039;ES_DecoderConfigDescrTag&#039;] != 0x04) {
						$this-&gt;warning(&#039;expecting esds.ES_DecoderConfigDescrTag = 0x04, found 0x&#039;.getid3_lib::PrintHexBytes($atom_structure[&#039;ES_DecoderConfigDescrTag&#039;]).&#039;), at offset &#039;.$atom_structure[&#039;offset&#039;]);
						break;
					}
					$atom_structure[&#039;ES_DecoderConfigDescrTagSize&#039;] = $this-&gt;quicktime_read_mp4_descr_length($atom_data, $esds_offset);

					$atom_structure[&#039;ES_objectTypeIndication&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 1));
					$esds_offset += 1;
					// https://stackoverflow.com/questions/3987850
					// 0x40 = &quot;Audio ISO/IEC 14496-3&quot;                       = MPEG-4 Audio
					// 0x67 = &quot;Audio ISO/IEC 13818-7 LowComplexity Profile&quot; = MPEG-2 AAC LC
					// 0x69 = &quot;Audio ISO/IEC 13818-3&quot;                       = MPEG-2 Backward Compatible Audio (MPEG-2 Layers 1, 2, and 3)
					// 0x6B = &quot;Audio ISO/IEC 11172-3&quot;                       = MPEG-1 Audio (MPEG-1 Layers 1, 2, and 3)

					$streamTypePlusFlags = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 1));
					$esds_offset += 1;
					$atom_structure[&#039;ES_streamType&#039;] =        ($streamTypePlusFlags &amp; 0xFC) &gt;&gt; 2;
					$atom_structure[&#039;ES_upStream&#039;]   = (bool) ($streamTypePlusFlags &amp; 0x02) &gt;&gt; 1;
					$atom_structure[&#039;ES_bufferSizeDB&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 3));
					$esds_offset += 3;
					$atom_structure[&#039;ES_maxBitrate&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 4));
					$esds_offset += 4;
					$atom_structure[&#039;ES_avgBitrate&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 4));
					$esds_offset += 4;
					if ($atom_structure[&#039;ES_avgBitrate&#039;]) {
						$info[&#039;quicktime&#039;][&#039;audio&#039;][&#039;bitrate&#039;] = $atom_structure[&#039;ES_avgBitrate&#039;];
						$info[&#039;audio&#039;][&#039;bitrate&#039;]              = $atom_structure[&#039;ES_avgBitrate&#039;];
					}

					$atom_structure[&#039;ES_DecSpecificInfoTag&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 1));
					$esds_offset += 1;
					if ($atom_structure[&#039;ES_DecSpecificInfoTag&#039;] != 0x05) {
						$this-&gt;warning(&#039;expecting esds.ES_DecSpecificInfoTag = 0x05, found 0x&#039;.getid3_lib::PrintHexBytes($atom_structure[&#039;ES_DecSpecificInfoTag&#039;]).&#039;), at offset &#039;.$atom_structure[&#039;offset&#039;]);
						break;
					}
					$atom_structure[&#039;ES_DecSpecificInfoTagSize&#039;] = $this-&gt;quicktime_read_mp4_descr_length($atom_data, $esds_offset);

					$atom_structure[&#039;ES_DecSpecificInfo&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, $atom_structure[&#039;ES_DecSpecificInfoTagSize&#039;]));
					$esds_offset += $atom_structure[&#039;ES_DecSpecificInfoTagSize&#039;];

					$atom_structure[&#039;ES_SLConfigDescrTag&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, 1));
					$esds_offset += 1;
					if ($atom_structure[&#039;ES_SLConfigDescrTag&#039;] != 0x06) {
						$this-&gt;warning(&#039;expecting esds.ES_SLConfigDescrTag = 0x05, found 0x&#039;.getid3_lib::PrintHexBytes($atom_structure[&#039;ES_SLConfigDescrTag&#039;]).&#039;), at offset &#039;.$atom_structure[&#039;offset&#039;]);
						break;
					}
					$atom_structure[&#039;ES_SLConfigDescrTagSize&#039;] = $this-&gt;quicktime_read_mp4_descr_length($atom_data, $esds_offset);

					$atom_structure[&#039;ES_SLConfigDescr&#039;] = getid3_lib::BigEndian2Int(substr($atom_data, $esds_offset, $atom_structure[&#039;ES_SLConfigDescrTagSize&#039;]));
					$esds_offset += $atom_structure[&#039;ES_SLConfigDescrTagSize&#039;];
					break;

// AVIF-related - https://docs.rs/avif-parse/0.13.2/src/avif_parse/boxes.rs.html
				case &#039;pitm&#039;: // Primary ITeM
				case &#039;iloc&#039;: // Item LOCation
				case &#039;iinf&#039;: // Item INFo
				case &#039;iref&#039;: // Image REFerence
				case &#039;iprp&#039;: // Image PRoPerties
$this-&gt;error(&#039;AVIF files not currently supported&#039;);
					$atom_structure[&#039;data&#039;] = $atom_data;
					break;

				case &#039;tfdt&#039;: // Track Fragment base media Decode Time box
				case &#039;tfhd&#039;: // Track Fragment HeaDer box
				case &#039;mfhd&#039;: // Movie Fragment HeaDer box
				case &#039;trun&#039;: // Track fragment RUN box
$this-&gt;error(&#039;fragmented mp4 files not currently supported&#039;);
					$atom_structure[&#039;data&#039;] = $atom_data;
					break;

				case &#039;mvex&#039;: // MoVie EXtends box
				case &#039;pssh&#039;: // Protection System Specific Header box
				case &#039;sidx&#039;: // Segment InDeX box
				default:
					$this-&gt;warning(&#039;Unknown QuickTime atom type: &quot;&#039;.preg_replace(&#039;#[^a-zA-Z0-9 _\\-]#&#039;, &#039;?&#039;, $atomname).&#039;&quot; (&#039;.trim(getid3_lib::PrintHexBytes($atomname)).&#039;), &#039;.$atomsize.&#039; bytes at offset &#039;.$baseoffset);
					$atom_structure[&#039;data&#039;] = $atom_data;
					break;
			}
		}
		array_pop($atomHierarchy);
		return $atom_structure;
	}

	/**
	 * @param string $atom_data
	 * @param int    $baseoffset
	 * @param array  $atomHierarchy
	 * @param bool   $ParseAllPossibleAtoms
	 *
	 * @return array|false
	 */
	public function QuicktimeParseContainerAtom($atom_data, $baseoffset, &amp;$atomHierarchy, $ParseAllPossibleAtoms) {
		$atom_structure = array();
		$subatomoffset  = 0;
		$subatomcounter = 0;
		if ((strlen($atom_data) == 4) &amp;&amp; (getid3_lib::BigEndian2Int($atom_data) == 0x00000000)) {
			return false;
		}
		while ($subatomoffset &lt; strlen($atom_data)) {
			$subatomsize = getid3_lib::BigEndian2Int(substr($atom_data, $subatomoffset + 0, 4));
			$subatomname =                           substr($atom_data, $subatomoffset + 4, 4);
			$subatomdata =                           substr($atom_data, $subatomoffset + 8, $subatomsize - 8);
			if ($subatomsize == 0) {
				// Furthermore, for historical reasons the list of atoms is optionally
				// terminated by a 32-bit integer set to 0. If you are writing a program
				// to read user data atoms, you should allow for the terminating 0.
				if (strlen($atom_data) &gt; 12) {
					$subatomoffset += 4;
					continue;
				}
				break;
			}
			if (strlen($subatomdata) &lt; ($subatomsize - 8)) {
			    // we don&#039;t have enough data to decode the subatom.
			    // this may be because we are refusing to parse large subatoms, or it may be because this atom had its size set too large
			    // so we passed in the start of a following atom incorrectly?
			    break;
			}
			$atom_structure[$subatomcounter++] = $this-&gt;QuicktimeParseAtom($subatomname, $subatomsize, $subatomdata, $baseoffset + $subatomoffset, $atomHierarchy, $ParseAllPossibleAtoms);
			$subatomoffset += $subatomsize;
		}

		if (empty($atom_structure)) {
			return false;
		}

		return $atom_structure;
	}

	/**
	 * @param string $data
	 * @param int    $offset
	 *
	 * @return int
	 */
	public function quicktime_read_mp4_descr_length($data, &amp;$offset) {
		// http://libquicktime.sourcearchive.com/documentation/2:1.0.2plus-pdebian-2build1/esds_8c-source.html
		$num_bytes = 0;
		$length    = 0;
		do {
			$b = ord(substr($data, $offset++, 1));
			$length = ($length &lt;&lt; 7) | ($b &amp; 0x7F);
		} while (($b &amp; 0x80) &amp;&amp; ($num_bytes++ &lt; 4));
		return $length;
	}

	/**
	 * @param int $languageid
	 *
	 * @return string
	 */
	public function QuicktimeLanguageLookup($languageid) {
		// http://developer.apple.com/library/mac/#documentation/QuickTime/QTFF/QTFFChap4/qtff4.html#//apple_ref/doc/uid/TP40000939-CH206-34353
		static $QuicktimeLanguageLookup = array();
		if (empty($QuicktimeLanguageLookup)) {
			$QuicktimeLanguageLookup[0]     = &#039;English&#039;;
			$QuicktimeLanguageLookup[1]     = &#039;French&#039;;
			$QuicktimeLanguageLookup[2]     = &#039;German&#039;;
			$QuicktimeLanguageLookup[3]     = &#039;Italian&#039;;
			$QuicktimeLanguageLookup[4]     = &#039;Dutch&#039;;
			$QuicktimeLanguageLookup[5]     = &#039;Swedish&#039;;
			$QuicktimeLanguageLookup[6]     = &#039;Spanish&#039;;
			$QuicktimeLanguageLookup[7]     = &#039;Danish&#039;;
			$QuicktimeLanguageLookup[8]     = &#039;Portuguese&#039;;
			$QuicktimeLanguageLookup[9]     = &#039;Norwegian&#039;;
			$QuicktimeLanguageLookup[10]    = &#039;Hebrew&#039;;
			$QuicktimeLanguageLookup[11]    = &#039;Japanese&#039;;
			$QuicktimeLanguageLookup[12]    = &#039;Arabic&#039;;
			$QuicktimeLanguageLookup[13]    = &#039;Finnish&#039;;
			$QuicktimeLanguageLookup[14]    = &#039;Greek&#039;;
			$QuicktimeLanguageLookup[15]    = &#039;Icelandic&#039;;
			$QuicktimeLanguageLookup[16]    = &#039;Maltese&#039;;
			$QuicktimeLanguageLookup[17]    = &#039;Turkish&#039;;
			$QuicktimeLanguageLookup[18]    = &#039;Croatian&#039;;
			$QuicktimeLanguageLookup[19]    = &#039;Chinese (Traditional)&#039;;
			$QuicktimeLanguageLookup[20]    = &#039;Urdu&#039;;
			$QuicktimeLanguageLookup[21]    = &#039;Hindi&#039;;
			$QuicktimeLanguageLookup[22]    = &#039;Thai&#039;;
			$QuicktimeLanguageLookup[23]    = &#039;Korean&#039;;
			$QuicktimeLanguageLookup[24]    = &#039;Lithuanian&#039;;
			$QuicktimeLanguageLookup[25]    = &#039;Polish&#039;;
			$QuicktimeLanguageLookup[26]    = &#039;Hungarian&#039;;
			$QuicktimeLanguageLookup[27]    = &#039;Estonian&#039;;
			$QuicktimeLanguageLookup[28]    = &#039;Lettish&#039;;
			$QuicktimeLanguageLookup[28]    = &#039;Latvian&#039;;
			$QuicktimeLanguageLookup[29]    = &#039;Saamisk&#039;;
			$QuicktimeLanguageLookup[29]    = &#039;Lappish&#039;;
			$QuicktimeLanguageLookup[30]    = &#039;Faeroese&#039;;
			$QuicktimeLanguageLookup[31]    = &#039;Farsi&#039;;
			$QuicktimeLanguageLookup[31]    = &#039;Persian&#039;;
			$QuicktimeLanguageLookup[32]    = &#039;Russian&#039;;
			$QuicktimeLanguageLookup[33]    = &#039;Chinese (Simplified)&#039;;
			$QuicktimeLanguageLookup[34]    = &#039;Flemish&#039;;
			$QuicktimeLanguageLookup[35]    = &#039;Irish&#039;;
			$QuicktimeLanguageLookup[36]    = &#039;Albanian&#039;;
			$QuicktimeLanguageLookup[37]    = &#039;Romanian&#039;;
			$QuicktimeLanguageLookup[38]    = &#039;Czech&#039;;
			$QuicktimeLanguageLookup[39]    = &#039;Slovak&#039;;
			$QuicktimeLanguageLookup[40]    = &#039;Slovenian&#039;;
			$QuicktimeLanguageLookup[41]    = &#039;Yiddish&#039;;
			$QuicktimeLanguageLookup[42]    = &#039;Serbian&#039;;
			$QuicktimeLanguageLookup[43]    = &#039;Macedonian&#039;;
			$QuicktimeLanguageLookup[44]    = &#039;Bulgarian&#039;;
			$QuicktimeLanguageLookup[45]    = &#039;Ukrainian&#039;;
			$QuicktimeLanguageLookup[46]    = &#039;Byelorussian&#039;;
			$QuicktimeLanguageLookup[47]    = &#039;Uzbek&#039;;
			$QuicktimeLanguageLookup[48]    = &#039;Kazakh&#039;;
			$QuicktimeLanguageLookup[49]    = &#039;Azerbaijani&#039;;
			$QuicktimeLanguageLookup[50]    = &#039;AzerbaijanAr&#039;;
			$QuicktimeLanguageLookup[51]    = &#039;Armenian&#039;;
			$QuicktimeLanguageLookup[52]    = &#039;Georgian&#039;;
			$QuicktimeLanguageLookup[53]    = &#039;Moldavian&#039;;
			$QuicktimeLanguageLookup[54]    = &#039;Kirghiz&#039;;
			$QuicktimeLanguageLookup[55]    = &#039;Tajiki&#039;;
			$QuicktimeLanguageLookup[56]    = &#039;Turkmen&#039;;
			$QuicktimeLanguageLookup[57]    = &#039;Mongolian&#039;;
			$QuicktimeLanguageLookup[58]    = &#039;MongolianCyr&#039;;
			$QuicktimeLanguageLookup[59]    = &#039;Pashto&#039;;
			$QuicktimeLanguageLookup[60]    = &#039;Kurdish&#039;;
			$QuicktimeLanguageLookup[61]    = &#039;Kashmiri&#039;;
			$QuicktimeLanguageLookup[62]    = &#039;Sindhi&#039;;
			$QuicktimeLanguageLookup[63]    = &#039;Tibetan&#039;;
			$QuicktimeLanguageLookup[64]    = &#039;Nepali&#039;;
			$QuicktimeLanguageLookup[65]    = &#039;Sanskrit&#039;;
			$QuicktimeLanguageLookup[66]    = &#039;Marathi&#039;;
			$QuicktimeLanguageLookup[67]    = &#039;Bengali&#039;;
			$QuicktimeLanguageLookup[68]    = &#039;Assamese&#039;;
			$QuicktimeLanguageLookup[69]    = &#039;Gujarati&#039;;
			$QuicktimeLanguageLookup[70]    = &#039;Punjabi&#039;;
			$QuicktimeLanguageLookup[71]    = &#039;Oriya&#039;;
			$QuicktimeLanguageLookup[72]    = &#039;Malayalam&#039;;
			$QuicktimeLanguageLookup[73]    = &#039;Kannada&#039;;
			$QuicktimeLanguageLookup[74]    = &#039;Tamil&#039;;
			$QuicktimeLanguageLookup[75]    = &#039;Telugu&#039;;
			$QuicktimeLanguageLookup[76]    = &#039;Sinhalese&#039;;
			$QuicktimeLanguageLookup[77]    = &#039;Burmese&#039;;
			$QuicktimeLanguageLookup[78]    = &#039;Khmer&#039;;
			$QuicktimeLanguageLookup[79]    = &#039;Lao&#039;;
			$QuicktimeLanguageLookup[80]    = &#039;Vietnamese&#039;;
			$QuicktimeLanguageLookup[81]    = &#039;Indonesian&#039;;
			$QuicktimeLanguageLookup[82]    = &#039;Tagalog&#039;;
			$QuicktimeLanguageLookup[83]    = &#039;MalayRoman&#039;;
			$QuicktimeLanguageLookup[84]    = &#039;MalayArabic&#039;;
			$QuicktimeLanguageLookup[85]    = &#039;Amharic&#039;;
			$QuicktimeLanguageLookup[86]    = &#039;Tigrinya&#039;;
			$QuicktimeLanguageLookup[87]    = &#039;Galla&#039;;
			$QuicktimeLanguageLookup[87]    = &#039;Oromo&#039;;
			$QuicktimeLanguageLookup[88]    = &#039;Somali&#039;;
			$QuicktimeLanguageLookup[89]    = &#039;Swahili&#039;;
			$QuicktimeLanguageLookup[90]    = &#039;Ruanda&#039;;
			$QuicktimeLanguageLookup[91]    = &#039;Rundi&#039;;
			$QuicktimeLanguageLookup[92]    = &#039;Chewa&#039;;
			$QuicktimeLanguageLookup[93]    = &#039;Malagasy&#039;;
			$QuicktimeLanguageLookup[94]    = &#039;Esperanto&#039;;
			$QuicktimeLanguageLookup[128]   = &#039;Welsh&#039;;
			$QuicktimeLanguageLookup[129]   = &#039;Basque&#039;;
			$QuicktimeLanguageLookup[130]   = &#039;Catalan&#039;;
			$QuicktimeLanguageLookup[131]   = &#039;Latin&#039;;
			$QuicktimeLanguageLookup[132]   = &#039;Quechua&#039;;
			$QuicktimeLanguageLookup[133]   = &#039;Guarani&#039;;
			$QuicktimeLanguageLookup[134]   = &#039;Aymara&#039;;
			$QuicktimeLanguageLookup[135]   = &#039;Tatar&#039;;
			$QuicktimeLanguageLookup[136]   = &#039;Uighur&#039;;
			$QuicktimeLanguageLookup[137]   = &#039;Dzongkha&#039;;
			$QuicktimeLanguageLookup[138]   = &#039;JavaneseRom&#039;;
			$QuicktimeLanguageLookup[32767] = &#039;Unspecified&#039;;
		}
		if (($languageid &gt; 138) &amp;&amp; ($languageid &lt; 32767)) {
			/*
			ISO Language Codes - http://www.loc.gov/standards/iso639-2/php/code_list.php
			Because the language codes specified by ISO 639-2/T are three characters long, they must be packed to fit into a 16-bit field.
			The packing algorithm must map each of the three characters, which are always lowercase, into a 5-bit integer and then concatenate
			these integers into the least significant 15 bits of a 16-bit integer, leaving the 16-bit integer&#039;s most significant bit set to zero.

			One algorithm for performing this packing is to treat each ISO character as a 16-bit integer. Subtract 0x60 from the first character
			and multiply by 2^10 (0x400), subtract 0x60 from the second character and multiply by 2^5 (0x20), subtract 0x60 from the third character,
			and add the three 16-bit values. This will result in a single 16-bit value with the three codes correctly packed into the 15 least
			significant bits and the most significant bit set to zero.
			*/
			$iso_language_id  = &#039;&#039;;
			$iso_language_id .= chr((($languageid &amp; 0x7C00) &gt;&gt; 10) + 0x60);
			$iso_language_id .= chr((($languageid &amp; 0x03E0) &gt;&gt;  5) + 0x60);
			$iso_language_id .= chr((($languageid &amp; 0x001F) &gt;&gt;  0) + 0x60);
			$QuicktimeLanguageLookup[$languageid] = getid3_id3v2::LanguageLookup($iso_language_id);
		}
		return (isset($QuicktimeLanguageLookup[$languageid]) ? $QuicktimeLanguageLookup[$languageid] : &#039;invalid&#039;);
	}

	/**
	 * @param string $codecid
	 *
	 * @return string
	 */
	public function QuicktimeVideoCodecLookup($codecid) {
		static $QuicktimeVideoCodecLookup = array();
		if (empty($QuicktimeVideoCodecLookup)) {
			$QuicktimeVideoCodecLookup[&#039;.SGI&#039;] = &#039;SGI&#039;;
			$QuicktimeVideoCodecLookup[&#039;3IV1&#039;] = &#039;3ivx MPEG-4 v1&#039;;
			$QuicktimeVideoCodecLookup[&#039;3IV2&#039;] = &#039;3ivx MPEG-4 v2&#039;;
			$QuicktimeVideoCodecLookup[&#039;3IVX&#039;] = &#039;3ivx MPEG-4&#039;;
			$QuicktimeVideoCodecLookup[&#039;8BPS&#039;] = &#039;Planar RGB&#039;;
			$QuicktimeVideoCodecLookup[&#039;avc1&#039;] = &#039;H.264/MPEG-4 AVC&#039;;
			$QuicktimeVideoCodecLookup[&#039;avr &#039;] = &#039;AVR-JPEG&#039;;
			$QuicktimeVideoCodecLookup[&#039;b16g&#039;] = &#039;16Gray&#039;;
			$QuicktimeVideoCodecLookup[&#039;b32a&#039;] = &#039;32AlphaGray&#039;;
			$QuicktimeVideoCodecLookup[&#039;b48r&#039;] = &#039;48RGB&#039;;
			$QuicktimeVideoCodecLookup[&#039;b64a&#039;] = &#039;64ARGB&#039;;
			$QuicktimeVideoCodecLookup[&#039;base&#039;] = &#039;Base&#039;;
			$QuicktimeVideoCodecLookup[&#039;clou&#039;] = &#039;Cloud&#039;;
			$QuicktimeVideoCodecLookup[&#039;cmyk&#039;] = &#039;CMYK&#039;;
			$QuicktimeVideoCodecLookup[&#039;cvid&#039;] = &#039;Cinepak&#039;;
			$QuicktimeVideoCodecLookup[&#039;dmb1&#039;] = &#039;OpenDML JPEG&#039;;
			$QuicktimeVideoCodecLookup[&#039;dvc &#039;] = &#039;DVC-NTSC&#039;;
			$QuicktimeVideoCodecLookup[&#039;dvcp&#039;] = &#039;DVC-PAL&#039;;
			$QuicktimeVideoCodecLookup[&#039;dvpn&#039;] = &#039;DVCPro-NTSC&#039;;
			$QuicktimeVideoCodecLookup[&#039;dvpp&#039;] = &#039;DVCPro-PAL&#039;;
			$QuicktimeVideoCodecLookup[&#039;fire&#039;] = &#039;Fire&#039;;
			$QuicktimeVideoCodecLookup[&#039;flic&#039;] = &#039;FLC&#039;;
			$QuicktimeVideoCodecLookup[&#039;gif &#039;] = &#039;GIF&#039;;
			$QuicktimeVideoCodecLookup[&#039;h261&#039;] = &#039;H261&#039;;
			$QuicktimeVideoCodecLookup[&#039;h263&#039;] = &#039;H263&#039;;
			$QuicktimeVideoCodecLookup[&#039;hvc1&#039;] = &#039;H.265/HEVC&#039;;
			$QuicktimeVideoCodecLookup[&#039;IV41&#039;] = &#039;Indeo4&#039;;
			$QuicktimeVideoCodecLookup[&#039;jpeg&#039;] = &#039;JPEG&#039;;
			$QuicktimeVideoCodecLookup[&#039;kpcd&#039;] = &#039;PhotoCD&#039;;
			$QuicktimeVideoCodecLookup[&#039;mjpa&#039;] = &#039;Motion JPEG-A&#039;;
			$QuicktimeVideoCodecLookup[&#039;mjpb&#039;] = &#039;Motion JPEG-B&#039;;
			$QuicktimeVideoCodecLookup[&#039;msvc&#039;] = &#039;Microsoft Video1&#039;;
			$QuicktimeVideoCodecLookup[&#039;myuv&#039;] = &#039;MPEG YUV420&#039;;
			$QuicktimeVideoCodecLookup[&#039;path&#039;] = &#039;Vector&#039;;
			$QuicktimeVideoCodecLookup[&#039;png &#039;] = &#039;PNG&#039;;
			$QuicktimeVideoCodecLookup[&#039;PNTG&#039;] = &#039;MacPaint&#039;;
			$QuicktimeVideoCodecLookup[&#039;qdgx&#039;] = &#039;QuickDrawGX&#039;;
			$QuicktimeVideoCodecLookup[&#039;qdrw&#039;] = &#039;QuickDraw&#039;;
			$QuicktimeVideoCodecLookup[&#039;raw &#039;] = &#039;RAW&#039;;
			$QuicktimeVideoCodecLookup[&#039;ripl&#039;] = &#039;WaterRipple&#039;;
			$QuicktimeVideoCodecLookup[&#039;rpza&#039;] = &#039;Video&#039;;
			$QuicktimeVideoCodecLookup[&#039;smc &#039;] = &#039;Graphics&#039;;
			$QuicktimeVideoCodecLookup[&#039;SVQ1&#039;] = &#039;Sorenson Video 1&#039;;
			$QuicktimeVideoCodecLookup[&#039;SVQ1&#039;] = &#039;Sorenson Video 3&#039;;
			$QuicktimeVideoCodecLookup[&#039;syv9&#039;] = &#039;Sorenson YUV9&#039;;
			$QuicktimeVideoCodecLookup[&#039;tga &#039;] = &#039;Targa&#039;;
			$QuicktimeVideoCodecLookup[&#039;tiff&#039;] = &#039;TIFF&#039;;
			$QuicktimeVideoCodecLookup[&#039;WRAW&#039;] = &#039;Windows RAW&#039;;
			$QuicktimeVideoCodecLookup[&#039;WRLE&#039;] = &#039;BMP&#039;;
			$QuicktimeVideoCodecLookup[&#039;y420&#039;] = &#039;YUV420&#039;;
			$QuicktimeVideoCodecLookup[&#039;yuv2&#039;] = &#039;ComponentVideo&#039;;
			$QuicktimeVideoCodecLookup[&#039;yuvs&#039;] = &#039;ComponentVideoUnsigned&#039;;
			$QuicktimeVideoCodecLookup[&#039;yuvu&#039;] = &#039;ComponentVideoSigned&#039;;
		}
		return (isset($QuicktimeVideoCodecLookup[$codecid]) ? $QuicktimeVideoCodecLookup[$codecid] : &#039;&#039;);
	}

	/**
	 * @param string $codecid
	 *
	 * @return mixed|string
	 */
	public function QuicktimeAudioCodecLookup($codecid) {
		static $QuicktimeAudioCodecLookup = array();
		if (empty($QuicktimeAudioCodecLookup)) {
			$QuicktimeAudioCodecLookup[&#039;.mp3&#039;]          = &#039;Fraunhofer MPEG Layer-III alias&#039;;
			$QuicktimeAudioCodecLookup[&#039;aac &#039;]          = &#039;ISO/IEC 14496-3 AAC&#039;;
			$QuicktimeAudioCodecLookup[&#039;agsm&#039;]          = &#039;Apple GSM 10:1&#039;;
			$QuicktimeAudioCodecLookup[&#039;alac&#039;]          = &#039;Apple Lossless Audio Codec&#039;;
			$QuicktimeAudioCodecLookup[&#039;alaw&#039;]          = &#039;A-law 2:1&#039;;
			$QuicktimeAudioCodecLookup[&#039;conv&#039;]          = &#039;Sample Format&#039;;
			$QuicktimeAudioCodecLookup[&#039;dvca&#039;]          = &#039;DV&#039;;
			$QuicktimeAudioCodecLookup[&#039;dvi &#039;]          = &#039;DV 4:1&#039;;
			$QuicktimeAudioCodecLookup[&#039;eqal&#039;]          = &#039;Frequency Equalizer&#039;;
			$QuicktimeAudioCodecLookup[&#039;fl32&#039;]          = &#039;32-bit Floating Point&#039;;
			$QuicktimeAudioCodecLookup[&#039;fl64&#039;]          = &#039;64-bit Floating Point&#039;;
			$QuicktimeAudioCodecLookup[&#039;ima4&#039;]          = &#039;Interactive Multimedia Association 4:1&#039;;
			$QuicktimeAudioCodecLookup[&#039;in24&#039;]          = &#039;24-bit Integer&#039;;
			$QuicktimeAudioCodecLookup[&#039;in32&#039;]          = &#039;32-bit Integer&#039;;
			$QuicktimeAudioCodecLookup[&#039;lpc &#039;]          = &#039;LPC 23:1&#039;;
			$QuicktimeAudioCodecLookup[&#039;MAC3&#039;]          = &#039;Macintosh Audio Compression/Expansion (MACE) 3:1&#039;;
			$QuicktimeAudioCodecLookup[&#039;MAC6&#039;]          = &#039;Macintosh Audio Compression/Expansion (MACE) 6:1&#039;;
			$QuicktimeAudioCodecLookup[&#039;mixb&#039;]          = &#039;8-bit Mixer&#039;;
			$QuicktimeAudioCodecLookup[&#039;mixw&#039;]          = &#039;16-bit Mixer&#039;;
			$QuicktimeAudioCodecLookup[&#039;mp4a&#039;]          = &#039;ISO/IEC 14496-3 AAC&#039;;
			$QuicktimeAudioCodecLookup[&#039;MS&#039;.&quot;\x00\x02&quot;] = &#039;Microsoft ADPCM&#039;;
			$QuicktimeAudioCodecLookup[&#039;MS&#039;.&quot;\x00\x11&quot;] = &#039;DV IMA&#039;;
			$QuicktimeAudioCodecLookup[&#039;MS&#039;.&quot;\x00\x55&quot;] = &#039;Fraunhofer MPEG Layer III&#039;;
			$QuicktimeAudioCodecLookup[&#039;NONE&#039;]          = &#039;No Encoding&#039;;
			$QuicktimeAudioCodecLookup[&#039;Qclp&#039;]          = &#039;Qualcomm PureVoice&#039;;
			$QuicktimeAudioCodecLookup[&#039;QDM2&#039;]          = &#039;QDesign Music 2&#039;;
			$QuicktimeAudioCodecLookup[&#039;QDMC&#039;]          = &#039;QDesign Music 1&#039;;
			$QuicktimeAudioCodecLookup[&#039;ratb&#039;]          = &#039;8-bit Rate&#039;;
			$QuicktimeAudioCodecLookup[&#039;ratw&#039;]          = &#039;16-bit Rate&#039;;
			$QuicktimeAudioCodecLookup[&#039;raw &#039;]          = &#039;raw PCM&#039;;
			$QuicktimeAudioCodecLookup[&#039;sour&#039;]          = &#039;Sound Source&#039;;
			$QuicktimeAudioCodecLookup[&#039;sowt&#039;]          = &#039;signed/two\&#039;s complement (Little Endian)&#039;;
			$QuicktimeAudioCodecLookup[&#039;str1&#039;]          = &#039;Iomega MPEG layer II&#039;;
			$QuicktimeAudioCodecLookup[&#039;str2&#039;]          = &#039;Iomega MPEG *layer II&#039;;
			$QuicktimeAudioCodecLookup[&#039;str3&#039;]          = &#039;Iomega MPEG **layer II&#039;;
			$QuicktimeAudioCodecLookup[&#039;str4&#039;]          = &#039;Iomega MPEG ***layer II&#039;;
			$QuicktimeAudioCodecLookup[&#039;twos&#039;]          = &#039;signed/two\&#039;s complement (Big Endian)&#039;;
			$QuicktimeAudioCodecLookup[&#039;ulaw&#039;]          = &#039;mu-law 2:1&#039;;
		}
		return (isset($QuicktimeAudioCodecLookup[$codecid]) ? $QuicktimeAudioCodecLookup[$codecid] : &#039;&#039;);
	}

	/**
	 * @param string $compressionid
	 *
	 * @return string
	 */
	public function QuicktimeDCOMLookup($compressionid) {
		static $QuicktimeDCOMLookup = array();
		if (empty($QuicktimeDCOMLookup)) {
			$QuicktimeDCOMLookup[&#039;zlib&#039;] = &#039;ZLib Deflate&#039;;
			$QuicktimeDCOMLookup[&#039;adec&#039;] = &#039;Apple Compression&#039;;
		}
		return (isset($QuicktimeDCOMLookup[$compressionid]) ? $QuicktimeDCOMLookup[$compressionid] : &#039;&#039;);
	}

	/**
	 * @param int $colordepthid
	 *
	 * @return string
	 */
	public function QuicktimeColorNameLookup($colordepthid) {
		static $QuicktimeColorNameLookup = array();
		if (empty($QuicktimeColorNameLookup)) {
			$QuicktimeColorNameLookup[1]  = &#039;2-color (monochrome)&#039;;
			$QuicktimeColorNameLookup[2]  = &#039;4-color&#039;;
			$QuicktimeColorNameLookup[4]  = &#039;16-color&#039;;
			$QuicktimeColorNameLookup[8]  = &#039;256-color&#039;;
			$QuicktimeColorNameLookup[16] = &#039;thousands (16-bit color)&#039;;
			$QuicktimeColorNameLookup[24] = &#039;millions (24-bit color)&#039;;
			$QuicktimeColorNameLookup[32] = &#039;millions+ (32-bit color)&#039;;
			$QuicktimeColorNameLookup[33] = &#039;black &amp; white&#039;;
			$QuicktimeColorNameLookup[34] = &#039;4-gray&#039;;
			$QuicktimeColorNameLookup[36] = &#039;16-gray&#039;;
			$QuicktimeColorNameLookup[40] = &#039;256-gray&#039;;
		}
		return (isset($QuicktimeColorNameLookup[$colordepthid]) ? $QuicktimeColorNameLookup[$colordepthid] : &#039;invalid&#039;);
	}

	/**
	 * @param int $stik
	 *
	 * @return string
	 */
	public function QuicktimeSTIKLookup($stik) {
		static $QuicktimeSTIKLookup = array();
		if (empty($QuicktimeSTIKLookup)) {
			$QuicktimeSTIKLookup[0]  = &#039;Movie&#039;;
			$QuicktimeSTIKLookup[1]  = &#039;Normal&#039;;
			$QuicktimeSTIKLookup[2]  = &#039;Audiobook&#039;;
			$QuicktimeSTIKLookup[5]  = &#039;Whacked Bookmark&#039;;
			$QuicktimeSTIKLookup[6]  = &#039;Music Video&#039;;
			$QuicktimeSTIKLookup[9]  = &#039;Short Film&#039;;
			$QuicktimeSTIKLookup[10] = &#039;TV Show&#039;;
			$QuicktimeSTIKLookup[11] = &#039;Booklet&#039;;
			$QuicktimeSTIKLookup[14] = &#039;Ringtone&#039;;
			$QuicktimeSTIKLookup[21] = &#039;Podcast&#039;;
		}
		return (isset($QuicktimeSTIKLookup[$stik]) ? $QuicktimeSTIKLookup[$stik] : &#039;invalid&#039;);
	}

	/**
	 * @param int $audio_profile_id
	 *
	 * @return string
	 */
	public function QuicktimeIODSaudioProfileName($audio_profile_id) {
		static $QuicktimeIODSaudioProfileNameLookup = array();
		if (empty($QuicktimeIODSaudioProfileNameLookup)) {
			$QuicktimeIODSaudioProfileNameLookup = array(
				0x00 =&gt; &#039;ISO Reserved (0x00)&#039;,
				0x01 =&gt; &#039;Main Audio Profile @ Level 1&#039;,
				0x02 =&gt; &#039;Main Audio Profile @ Level 2&#039;,
				0x03 =&gt; &#039;Main Audio Profile @ Level 3&#039;,
				0x04 =&gt; &#039;Main Audio Profile @ Level 4&#039;,
				0x05 =&gt; &#039;Scalable Audio Profile @ Level 1&#039;,
				0x06 =&gt; &#039;Scalable Audio Profile @ Level 2&#039;,
				0x07 =&gt; &#039;Scalable Audio Profile @ Level 3&#039;,
				0x08 =&gt; &#039;Scalable Audio Profile @ Level 4&#039;,
				0x09 =&gt; &#039;Speech Audio Profile @ Level 1&#039;,
				0x0A =&gt; &#039;Speech Audio Profile @ Level 2&#039;,
				0x0B =&gt; &#039;Synthetic Audio Profile @ Level 1&#039;,
				0x0C =&gt; &#039;Synthetic Audio Profile @ Level 2&#039;,
				0x0D =&gt; &#039;Synthetic Audio Profile @ Level 3&#039;,
				0x0E =&gt; &#039;High Quality Audio Profile @ Level 1&#039;,
				0x0F =&gt; &#039;High Quality Audio Profile @ Level 2&#039;,
				0x10 =&gt; &#039;High Quality Audio Profile @ Level 3&#039;,
				0x11 =&gt; &#039;High Quality Audio Profile @ Level 4&#039;,
				0x12 =&gt; &#039;High Quality Audio Profile @ Level 5&#039;,
				0x13 =&gt; &#039;High Quality Audio Profile @ Level 6&#039;,
				0x14 =&gt; &#039;High Quality Audio Profile @ Level 7&#039;,
				0x15 =&gt; &#039;High Quality Audio Profile @ Level 8&#039;,
				0x16 =&gt; &#039;Low Delay Audio Profile @ Level 1&#039;,
				0x17 =&gt; &#039;Low Delay Audio Profile @ Level 2&#039;,
				0x18 =&gt; &#039;Low Delay Audio Profile @ Level 3&#039;,
				0x19 =&gt; &#039;Low Delay Audio Profile @ Level 4&#039;,
				0x1A =&gt; &#039;Low Delay Audio Profile @ Level 5&#039;,
				0x1B =&gt; &#039;Low Delay Audio Profile @ Level 6&#039;,
				0x1C =&gt; &#039;Low Delay Audio Profile @ Level 7&#039;,
				0x1D =&gt; &#039;Low Delay Audio Profile @ Level 8&#039;,
				0x1E =&gt; &#039;Natural Audio Profile @ Level 1&#039;,
				0x1F =&gt; &#039;Natural Audio Profile @ Level 2&#039;,
				0x20 =&gt; &#039;Natural Audio Profile @ Level 3&#039;,
				0x21 =&gt; &#039;Natural Audio Profile @ Level 4&#039;,
				0x22 =&gt; &#039;Mobile Audio Internetworking Profile @ Level 1&#039;,
				0x23 =&gt; &#039;Mobile Audio Internetworking Profile @ Level 2&#039;,
				0x24 =&gt; &#039;Mobile Audio Internetworking Profile @ Level 3&#039;,
				0x25 =&gt; &#039;Mobile Audio Internetworking Profile @ Level 4&#039;,
				0x26 =&gt; &#039;Mobile Audio Internetworking Profile @ Level 5&#039;,
				0x27 =&gt; &#039;Mobile Audio Internetworking Profile @ Level 6&#039;,
				0x28 =&gt; &#039;AAC Profile @ Level 1&#039;,
				0x29 =&gt; &#039;AAC Profile @ Level 2&#039;,
				0x2A =&gt; &#039;AAC Profile @ Level 4&#039;,
				0x2B =&gt; &#039;AAC Profile @ Level 5&#039;,
				0x2C =&gt; &#039;High Efficiency AAC Profile @ Level 2&#039;,
				0x2D =&gt; &#039;High Efficiency AAC Profile @ Level 3&#039;,
				0x2E =&gt; &#039;High Efficiency AAC Profile @ Level 4&#039;,
				0x2F =&gt; &#039;High Efficiency AAC Profile @ Level 5&#039;,
				0xFE =&gt; &#039;Not part of MPEG-4 audio profiles&#039;,
				0xFF =&gt; &#039;No audio capability required&#039;,
			);
		}
		return (isset($QuicktimeIODSaudioProfileNameLookup[$audio_profile_id]) ? $QuicktimeIODSaudioProfileNameLookup[$audio_profile_id] : &#039;ISO Reserved / User Private&#039;);
	}

	/**
	 * @param int $video_profile_id
	 *
	 * @return string
	 */
	public function QuicktimeIODSvideoProfileName($video_profile_id) {
		static $QuicktimeIODSvideoProfileNameLookup = array();
		if (empty($QuicktimeIODSvideoProfileNameLookup)) {
			$QuicktimeIODSvideoProfileNameLookup = array(
				0x00 =&gt; &#039;Reserved (0x00) Profile&#039;,
				0x01 =&gt; &#039;Simple Profile @ Level 1&#039;,
				0x02 =&gt; &#039;Simple Profile @ Level 2&#039;,
				0x03 =&gt; &#039;Simple Profile @ Level 3&#039;,
				0x08 =&gt; &#039;Simple Profile @ Level 0&#039;,
				0x10 =&gt; &#039;Simple Scalable Profile @ Level 0&#039;,
				0x11 =&gt; &#039;Simple Scalable Profile @ Level 1&#039;,
				0x12 =&gt; &#039;Simple Scalable Profile @ Level 2&#039;,
				0x15 =&gt; &#039;AVC/H264 Profile&#039;,
				0x21 =&gt; &#039;Core Profile @ Level 1&#039;,
				0x22 =&gt; &#039;Core Profile @ Level 2&#039;,
				0x32 =&gt; &#039;Main Profile @ Level 2&#039;,
				0x33 =&gt; &#039;Main Profile @ Level 3&#039;,
				0x34 =&gt; &#039;Main Profile @ Level 4&#039;,
				0x42 =&gt; &#039;N-bit Profile @ Level 2&#039;,
				0x51 =&gt; &#039;Scalable Texture Profile @ Level 1&#039;,
				0x61 =&gt; &#039;Simple Face Animation Profile @ Level 1&#039;,
				0x62 =&gt; &#039;Simple Face Animation Profile @ Level 2&#039;,
				0x63 =&gt; &#039;Simple FBA Profile @ Level 1&#039;,
				0x64 =&gt; &#039;Simple FBA Profile @ Level 2&#039;,
				0x71 =&gt; &#039;Basic Animated Texture Profile @ Level 1&#039;,
				0x72 =&gt; &#039;Basic Animated Texture Profile @ Level 2&#039;,
				0x81 =&gt; &#039;Hybrid Profile @ Level 1&#039;,
				0x82 =&gt; &#039;Hybrid Profile @ Level 2&#039;,
				0x91 =&gt; &#039;Advanced Real Time Simple Profile @ Level 1&#039;,
				0x92 =&gt; &#039;Advanced Real Time Simple Profile @ Level 2&#039;,
				0x93 =&gt; &#039;Advanced Real Time Simple Profile @ Level 3&#039;,
				0x94 =&gt; &#039;Advanced Real Time Simple Profile @ Level 4&#039;,
				0xA1 =&gt; &#039;Core Scalable Profile @ Level1&#039;,
				0xA2 =&gt; &#039;Core Scalable Profile @ Level2&#039;,
				0xA3 =&gt; &#039;Core Scalable Profile @ Level3&#039;,
				0xB1 =&gt; &#039;Advanced Coding Efficiency Profile @ Level 1&#039;,
				0xB2 =&gt; &#039;Advanced Coding Efficiency Profile @ Level 2&#039;,
				0xB3 =&gt; &#039;Advanced Coding Efficiency Profile @ Level 3&#039;,
				0xB4 =&gt; &#039;Advanced Coding Efficiency Profile @ Level 4&#039;,
				0xC1 =&gt; &#039;Advanced Core Profile @ Level 1&#039;,
				0xC2 =&gt; &#039;Advanced Core Profile @ Level 2&#039;,
				0xD1 =&gt; &#039;Advanced Scalable Texture @ Level1&#039;,
				0xD2 =&gt; &#039;Advanced Scalable Texture @ Level2&#039;,
				0xE1 =&gt; &#039;Simple Studio Profile @ Level 1&#039;,
				0xE2 =&gt; &#039;Simple Studio Profile @ Level 2&#039;,
				0xE3 =&gt; &#039;Simple Studio Profile @ Level 3&#039;,
				0xE4 =&gt; &#039;Simple Studio Profile @ Level 4&#039;,
				0xE5 =&gt; &#039;Core Studio Profile @ Level 1&#039;,
				0xE6 =&gt; &#039;Core Studio Profile @ Level 2&#039;,
				0xE7 =&gt; &#039;Core Studio Profile @ Level 3&#039;,
				0xE8 =&gt; &#039;Core Studio Profile @ Level 4&#039;,
				0xF0 =&gt; &#039;Advanced Simple Profile @ Level 0&#039;,
				0xF1 =&gt; &#039;Advanced Simple Profile @ Level 1&#039;,
				0xF2 =&gt; &#039;Advanced Simple Profile @ Level 2&#039;,
				0xF3 =&gt; &#039;Advanced Simple Profile @ Level 3&#039;,
				0xF4 =&gt; &#039;Advanced Simple Profile @ Level 4&#039;,
				0xF5 =&gt; &#039;Advanced Simple Profile @ Level 5&#039;,
				0xF7 =&gt; &#039;Advanced Simple Profile @ Level 3b&#039;,
				0xF8 =&gt; &#039;Fine Granularity Scalable Profile @ Level 0&#039;,
				0xF9 =&gt; &#039;Fine Granularity Scalable Profile @ Level 1&#039;,
				0xFA =&gt; &#039;Fine Granularity Scalable Profile @ Level 2&#039;,
				0xFB =&gt; &#039;Fine Granularity Scalable Profile @ Level 3&#039;,
				0xFC =&gt; &#039;Fine Granularity Scalable Profile @ Level 4&#039;,
				0xFD =&gt; &#039;Fine Granularity Scalable Profile @ Level 5&#039;,
				0xFE =&gt; &#039;Not part of MPEG-4 Visual profiles&#039;,
				0xFF =&gt; &#039;No visual capability required&#039;,
			);
		}
		return (isset($QuicktimeIODSvideoProfileNameLookup[$video_profile_id]) ? $QuicktimeIODSvideoProfileNameLookup[$video_profile_id] : &#039;ISO Reserved Profile&#039;);
	}

	/**
	 * @param int $rtng
	 *
	 * @return string
	 */
	public function QuicktimeContentRatingLookup($rtng) {
		static $QuicktimeContentRatingLookup = array();
		if (empty($QuicktimeContentRatingLookup)) {
			$QuicktimeContentRatingLookup[0]  = &#039;None&#039;;
			$QuicktimeContentRatingLookup[1]  = &#039;Explicit&#039;;
			$QuicktimeContentRatingLookup[2]  = &#039;Clean&#039;;
			$QuicktimeContentRatingLookup[4]  = &#039;Explicit (old)&#039;;
		}
		return (isset($QuicktimeContentRatingLookup[$rtng]) ? $QuicktimeContentRatingLookup[$rtng] : &#039;invalid&#039;);
	}

	/**
	 * @param int $akid
	 *
	 * @return string
	 */
	public function QuicktimeStoreAccountTypeLookup($akid) {
		static $QuicktimeStoreAccountTypeLookup = array();
		if (empty($QuicktimeStoreAccountTypeLookup)) {
			$QuicktimeStoreAccountTypeLookup[0] = &#039;iTunes&#039;;
			$QuicktimeStoreAccountTypeLookup[1] = &#039;AOL&#039;;
		}
		return (isset($QuicktimeStoreAccountTypeLookup[$akid]) ? $QuicktimeStoreAccountTypeLookup[$akid] : &#039;invalid&#039;);
	}

	/**
	 * @param int $sfid
	 *
	 * @return string
	 */
	public function QuicktimeStoreFrontCodeLookup($sfid) {
		static $QuicktimeStoreFrontCodeLookup = array();
		if (empty($QuicktimeStoreFrontCodeLookup)) {
			$QuicktimeStoreFrontCodeLookup[143460] = &#039;Australia&#039;;
			$QuicktimeStoreFrontCodeLookup[143445] = &#039;Austria&#039;;
			$QuicktimeStoreFrontCodeLookup[143446] = &#039;Belgium&#039;;
			$QuicktimeStoreFrontCodeLookup[143455] = &#039;Canada&#039;;
			$QuicktimeStoreFrontCodeLookup[143458] = &#039;Denmark&#039;;
			$QuicktimeStoreFrontCodeLookup[143447] = &#039;Finland&#039;;
			$QuicktimeStoreFrontCodeLookup[143442] = &#039;France&#039;;
			$QuicktimeStoreFrontCodeLookup[143443] = &#039;Germany&#039;;
			$QuicktimeStoreFrontCodeLookup[143448] = &#039;Greece&#039;;
			$QuicktimeStoreFrontCodeLookup[143449] = &#039;Ireland&#039;;
			$QuicktimeStoreFrontCodeLookup[143450] = &#039;Italy&#039;;
			$QuicktimeStoreFrontCodeLookup[143462] = &#039;Japan&#039;;
			$QuicktimeStoreFrontCodeLookup[143451] = &#039;Luxembourg&#039;;
			$QuicktimeStoreFrontCodeLookup[143452] = &#039;Netherlands&#039;;
			$QuicktimeStoreFrontCodeLookup[143461] = &#039;New Zealand&#039;;
			$QuicktimeStoreFrontCodeLookup[143457] = &#039;Norway&#039;;
			$QuicktimeStoreFrontCodeLookup[143453] = &#039;Portugal&#039;;
			$QuicktimeStoreFrontCodeLookup[143454] = &#039;Spain&#039;;
			$QuicktimeStoreFrontCodeLookup[143456] = &#039;Sweden&#039;;
			$QuicktimeStoreFrontCodeLookup[143459] = &#039;Switzerland&#039;;
			$QuicktimeStoreFrontCodeLookup[143444] = &#039;United Kingdom&#039;;
			$QuicktimeStoreFrontCodeLookup[143441] = &#039;United States&#039;;
		}
		return (isset($QuicktimeStoreFrontCodeLookup[$sfid]) ? $QuicktimeStoreFrontCodeLookup[$sfid] : &#039;invalid&#039;);
	}

	/**
	 * @param string $keyname
	 * @param string|array $data
	 * @param string $boxname
	 *
	 * @return bool
	 */
	public function CopyToAppropriateCommentsSection($keyname, $data, $boxname=&#039;&#039;) {
		static $handyatomtranslatorarray = array();
		if (empty($handyatomtranslatorarray)) {
			// http://www.geocities.com/xhelmboyx/quicktime/formats/qtm-layout.txt
			// http://www.geocities.com/xhelmboyx/quicktime/formats/mp4-layout.txt
			// http://atomicparsley.sourceforge.net/mpeg-4files.html
			// https://code.google.com/p/mp4v2/wiki/iTunesMetadata
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;alb&#039;] = &#039;album&#039;;               // iTunes 4.0
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;ART&#039;] = &#039;artist&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;art&#039;] = &#039;artist&#039;;              // iTunes 4.0
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;aut&#039;] = &#039;author&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;cmt&#039;] = &#039;comment&#039;;             // iTunes 4.0
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;com&#039;] = &#039;comment&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;cpy&#039;] = &#039;copyright&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;day&#039;] = &#039;creation_date&#039;;       // iTunes 4.0
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;dir&#039;] = &#039;director&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;ed1&#039;] = &#039;edit1&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;ed2&#039;] = &#039;edit2&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;ed3&#039;] = &#039;edit3&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;ed4&#039;] = &#039;edit4&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;ed5&#039;] = &#039;edit5&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;ed6&#039;] = &#039;edit6&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;ed7&#039;] = &#039;edit7&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;ed8&#039;] = &#039;edit8&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;ed9&#039;] = &#039;edit9&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;enc&#039;] = &#039;encoded_by&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;fmt&#039;] = &#039;format&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;gen&#039;] = &#039;genre&#039;;               // iTunes 4.0
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;grp&#039;] = &#039;grouping&#039;;            // iTunes 4.2
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;hst&#039;] = &#039;host_computer&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;inf&#039;] = &#039;information&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;lyr&#039;] = &#039;lyrics&#039;;              // iTunes 5.0
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;mak&#039;] = &#039;make&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;mod&#039;] = &#039;model&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;nam&#039;] = &#039;title&#039;;               // iTunes 4.0
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;ope&#039;] = &#039;composer&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;prd&#039;] = &#039;producer&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;PRD&#039;] = &#039;product&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;prf&#039;] = &#039;performers&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;req&#039;] = &#039;system_requirements&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;src&#039;] = &#039;source_credit&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;swr&#039;] = &#039;software&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;too&#039;] = &#039;encoding_tool&#039;;       // iTunes 4.0
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;trk&#039;] = &#039;track_number&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;url&#039;] = &#039;url&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;wrn&#039;] = &#039;warning&#039;;
			$handyatomtranslatorarray[&quot;\xA9&quot;.&#039;wrt&#039;] = &#039;composer&#039;;
			$handyatomtranslatorarray[&#039;aART&#039;] = &#039;album_artist&#039;;
			$handyatomtranslatorarray[&#039;apID&#039;] = &#039;purchase_account&#039;;
			$handyatomtranslatorarray[&#039;catg&#039;] = &#039;category&#039;;            // iTunes 4.9
			$handyatomtranslatorarray[&#039;covr&#039;] = &#039;picture&#039;;             // iTunes 4.0
			$handyatomtranslatorarray[&#039;cpil&#039;] = &#039;compilation&#039;;         // iTunes 4.0
			$handyatomtranslatorarray[&#039;cprt&#039;] = &#039;copyright&#039;;           // iTunes 4.0?
			$handyatomtranslatorarray[&#039;desc&#039;] = &#039;description&#039;;         // iTunes 5.0
			$handyatomtranslatorarray[&#039;disk&#039;] = &#039;disc_number&#039;;         // iTunes 4.0
			$handyatomtranslatorarray[&#039;egid&#039;] = &#039;episode_guid&#039;;        // iTunes 4.9
			$handyatomtranslatorarray[&#039;gnre&#039;] = &#039;genre&#039;;               // iTunes 4.0
			$handyatomtranslatorarray[&#039;hdvd&#039;] = &#039;hd_video&#039;;            // iTunes 4.0
			$handyatomtranslatorarray[&#039;ldes&#039;] = &#039;description_long&#039;;    //
			$handyatomtranslatorarray[&#039;keyw&#039;] = &#039;keyword&#039;;             // iTunes 4.9
			$handyatomtranslatorarray[&#039;pcst&#039;] = &#039;podcast&#039;;             // iTunes 4.9
			$handyatomtranslatorarray[&#039;pgap&#039;] = &#039;gapless_playback&#039;;    // iTunes 7.0
			$handyatomtranslatorarray[&#039;purd&#039;] = &#039;purchase_date&#039;;       // iTunes 6.0.2
			$handyatomtranslatorarray[&#039;purl&#039;] = &#039;podcast_url&#039;;         // iTunes 4.9
			$handyatomtranslatorarray[&#039;rtng&#039;] = &#039;rating&#039;;              // iTunes 4.0
			$handyatomtranslatorarray[&#039;soaa&#039;] = &#039;sort_album_artist&#039;;   //
			$handyatomtranslatorarray[&#039;soal&#039;] = &#039;sort_album&#039;;          //
			$handyatomtranslatorarray[&#039;soar&#039;] = &#039;sort_artist&#039;;         //
			$handyatomtranslatorarray[&#039;soco&#039;] = &#039;sort_composer&#039;;       //
			$handyatomtranslatorarray[&#039;sonm&#039;] = &#039;sort_title&#039;;          //
			$handyatomtranslatorarray[&#039;sosn&#039;] = &#039;sort_show&#039;;           //
			$handyatomtranslatorarray[&#039;stik&#039;] = &#039;stik&#039;;                // iTunes 4.9
			$handyatomtranslatorarray[&#039;tmpo&#039;] = &#039;bpm&#039;;                 // iTunes 4.0
			$handyatomtranslatorarray[&#039;trkn&#039;] = &#039;track_number&#039;;        // iTunes 4.0
			$handyatomtranslatorarray[&#039;tven&#039;] = &#039;tv_episode_id&#039;;       //
			$handyatomtranslatorarray[&#039;tves&#039;] = &#039;tv_episode&#039;;          // iTunes 6.0
			$handyatomtranslatorarray[&#039;tvnn&#039;] = &#039;tv_network_name&#039;;     // iTunes 6.0
			$handyatomtranslatorarray[&#039;tvsh&#039;] = &#039;tv_show_name&#039;;        // iTunes 6.0
			$handyatomtranslatorarray[&#039;tvsn&#039;] = &#039;tv_season&#039;;           // iTunes 6.0

			// boxnames:
			/*
			$handyatomtranslatorarray[&#039;iTunSMPB&#039;]                    = &#039;iTunSMPB&#039;;
			$handyatomtranslatorarray[&#039;iTunNORM&#039;]                    = &#039;iTunNORM&#039;;
			$handyatomtranslatorarray[&#039;Encoding Params&#039;]             = &#039;Encoding Params&#039;;
			$handyatomtranslatorarray[&#039;replaygain_track_gain&#039;]       = &#039;replaygain_track_gain&#039;;
			$handyatomtranslatorarray[&#039;replaygain_track_peak&#039;]       = &#039;replaygain_track_peak&#039;;
			$handyatomtranslatorarray[&#039;replaygain_track_minmax&#039;]     = &#039;replaygain_track_minmax&#039;;
			$handyatomtranslatorarray[&#039;MusicIP PUID&#039;]                = &#039;MusicIP PUID&#039;;
			$handyatomtranslatorarray[&#039;MusicBrainz Artist Id&#039;]       = &#039;MusicBrainz Artist Id&#039;;
			$handyatomtranslatorarray[&#039;MusicBrainz Album Id&#039;]        = &#039;MusicBrainz Album Id&#039;;
			$handyatomtranslatorarray[&#039;MusicBrainz Album Artist Id&#039;] = &#039;MusicBrainz Album Artist Id&#039;;
			$handyatomtranslatorarray[&#039;MusicBrainz Track Id&#039;]        = &#039;MusicBrainz Track Id&#039;;
			$handyatomtranslatorarray[&#039;MusicBrainz Disc Id&#039;]         = &#039;MusicBrainz Disc Id&#039;;

			// http://age.hobba.nl/audio/tag_frame_reference.html
			$handyatomtranslatorarray[&#039;PLAY_COUNTER&#039;]                = &#039;play_counter&#039;; // Foobar2000 - https://www.getid3.org/phpBB3/viewtopic.php?t=1355
			$handyatomtranslatorarray[&#039;MEDIATYPE&#039;]                   = &#039;mediatype&#039;;    // Foobar2000 - https://www.getid3.org/phpBB3/viewtopic.php?t=1355
			*/
		}
		$info = &amp;$this-&gt;getid3-&gt;info;
		$comment_key = &#039;&#039;;
		if ($boxname &amp;&amp; ($boxname != $keyname)) {
			$comment_key = (isset($handyatomtranslatorarray[$boxname]) ? $handyatomtranslatorarray[$boxname] : $boxname);
		} elseif (isset($handyatomtranslatorarray[$keyname])) {
			$comment_key = $handyatomtranslatorarray[$keyname];
		}
		if ($comment_key) {
			if ($comment_key == &#039;picture&#039;) {
				// already copied directly into [comments][picture] elsewhere, do not re-copy here
				return true;
			}
			$gooddata = array($data);
			if ($comment_key == &#039;genre&#039;) {
				// some other taggers separate multiple genres with semicolon, e.g. &quot;Heavy Metal;Thrash Metal;Metal&quot;
				$gooddata = explode(&#039;;&#039;, $data);
			}
			foreach ($gooddata as $data) {
				if (!empty($info[&#039;quicktime&#039;][&#039;comments&#039;][$comment_key]) &amp;&amp; in_array($data, $info[&#039;quicktime&#039;][&#039;comments&#039;][$comment_key], true)) {
					// avoid duplicate copies of identical data
					continue;
				}
				$info[&#039;quicktime&#039;][&#039;comments&#039;][$comment_key][] = $data;
			}
		}
		return true;
	}

	/**
	 * @param string $lstring
	 * @param int    $count
	 *
	 * @return string
	 */
	public function LociString($lstring, &amp;$count) {
		// Loci strings are UTF-8 or UTF-16 and null (x00/x0000) terminated. UTF-16 has a BOM
		// Also need to return the number of bytes the string occupied so additional fields can be extracted
		$len = strlen($lstring);
		if ($len == 0) {
			$count = 0;
			return &#039;&#039;;
		}
		if ($lstring[0] == &quot;\x00&quot;) {
			$count = 1;
			return &#039;&#039;;
		}
		// check for BOM
		if (($len &gt; 2) &amp;&amp; ((($lstring[0] == &quot;\xFE&quot;) &amp;&amp; ($lstring[1] == &quot;\xFF&quot;)) || (($lstring[0] == &quot;\xFF&quot;) &amp;&amp; ($lstring[1] == &quot;\xFE&quot;)))) {
			// UTF-16
			if (preg_match(&#039;/(.*)\x00/&#039;, $lstring, $lmatches)) {
				$count = strlen($lmatches[1]) * 2 + 2; //account for 2 byte characters and trailing \x0000
				return getid3_lib::iconv_fallback_utf16_utf8($lmatches[1]);
			} else {
				return &#039;&#039;;
			}
		}
		// UTF-8
		if (preg_match(&#039;/(.*)\x00/&#039;, $lstring, $lmatches)) {
			$count = strlen($lmatches[1]) + 1; //account for trailing \x00
			return $lmatches[1];
		}
		return &#039;&#039;;
	}

	/**
	 * @param string $nullterminatedstring
	 *
	 * @return string
	 */
	public function NoNullString($nullterminatedstring) {
		// remove the single null terminator on null terminated strings
		if (substr($nullterminatedstring, strlen($nullterminatedstring) - 1, 1) === &quot;\x00&quot;) {
			return substr($nullterminatedstring, 0, strlen($nullterminatedstring) - 1);
		}
		return $nullterminatedstring;
	}

	/**
	 * @param string $pascalstring
	 *
	 * @return string
	 */
	public function Pascal2String($pascalstring) {
		// Pascal strings have 1 unsigned byte at the beginning saying how many chars (1-255) are in the string
		return substr($pascalstring, 1);
	}

	/**
	 * @param string $pascalstring
	 *
	 * @return string
	 */
	public function MaybePascal2String($pascalstring) {
		// Pascal strings have 1 unsigned byte at the beginning saying how many chars (1-255) are in the string
		// Check if string actually is in this format or written incorrectly, straight string, or null-terminated string
		if (ord(substr($pascalstring, 0, 1)) == (strlen($pascalstring) - 1)) {
			return substr($pascalstring, 1);
		} elseif (substr($pascalstring, -1, 1) == &quot;\x00&quot;) {
			// appears to be null-terminated instead of Pascal-style
			return substr($pascalstring, 0, -1);
		}
		return $pascalstring;
	}


	/**
	 * Helper functions for m4b audiobook chapters
	 * code by Steffen Hartmann 2015-Nov-08.
	 *
	 * @param array  $info
	 * @param string $tag
	 * @param string $history
	 * @param array  $result
	 */
	public function search_tag_by_key($info, $tag, $history, &amp;$result) {
		foreach ($info as $key =&gt; $value) {
			$key_history = $history.&#039;/&#039;.$key;
			if ($key === $tag) {
				$result[] = array($key_history, $info);
			} else {
				if (is_array($value)) {
					$this-&gt;search_tag_by_key($value, $tag, $key_history, $result);
				}
			}
		}
	}

	/**
	 * @param array  $info
	 * @param string $k
	 * @param string $v
	 * @param string $history
	 * @param array  $result
	 */
	public function search_tag_by_pair($info, $k, $v, $history, &amp;$result) {
		foreach ($info as $key =&gt; $value) {
			$key_history = $history.&#039;/&#039;.$key;
			if (($key === $k) &amp;&amp; ($value === $v)) {
				$result[] = array($key_history, $info);
			} else {
				if (is_array($value)) {
					$this-&gt;search_tag_by_pair($value, $k, $v, $key_history, $result);
				}
			}
		}
	}

	/**
	 * @param array $info
	 *
	 * @return array
	 */
	public function quicktime_time_to_sample_table($info) {
		$res = array();
		$this-&gt;search_tag_by_pair($info[&#039;quicktime&#039;][&#039;moov&#039;], &#039;name&#039;, &#039;stbl&#039;, &#039;quicktime/moov&#039;, $res);
		foreach ($res as $value) {
			$stbl_res = array();
			$this-&gt;search_tag_by_pair($value[1], &#039;data_format&#039;, &#039;text&#039;, $value[0], $stbl_res);
			if (count($stbl_res) &gt; 0) {
				$stts_res = array();
				$this-&gt;search_tag_by_key($value[1], &#039;time_to_sample_table&#039;, $value[0], $stts_res);
				if (count($stts_res) &gt; 0) {
					return $stts_res[0][1][&#039;time_to_sample_table&#039;];
				}
			}
		}
		return array();
	}


	/**
	 * @param array $info
	 *
	 * @return int
	 */
	public function quicktime_bookmark_time_scale($info) {
		$time_scale = &#039;&#039;;
		$ts_prefix_len = 0;
		$res = array();
		$this-&gt;search_tag_by_pair($info[&#039;quicktime&#039;][&#039;moov&#039;], &#039;name&#039;, &#039;stbl&#039;, &#039;quicktime/moov&#039;, $res);
		foreach ($res as $value) {
			$stbl_res = array();
			$this-&gt;search_tag_by_pair($value[1], &#039;data_format&#039;, &#039;text&#039;, $value[0], $stbl_res);
			if (count($stbl_res) &gt; 0) {
				$ts_res = array();
				$this-&gt;search_tag_by_key($info[&#039;quicktime&#039;][&#039;moov&#039;], &#039;time_scale&#039;, &#039;quicktime/moov&#039;, $ts_res);
				foreach ($ts_res as $sub_value) {
					$prefix = substr($sub_value[0], 0, -12);
					if ((substr($stbl_res[0][0], 0, strlen($prefix)) === $prefix) &amp;&amp; ($ts_prefix_len &lt; strlen($prefix))) {
						$time_scale = $sub_value[1][&#039;time_scale&#039;];
						$ts_prefix_len = strlen($prefix);
					}
				}
			}
		}
		return $time_scale;
	}
	/*
	// END helper functions for m4b audiobook chapters
	*/


}
</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fm.elifov%2Fstudyondalinda.com%2Fwp-includes'>?? Yukar?</a>