PageRenderTime 35ms CodeModel.GetById 24ms RepoModel.GetById 1ms app.codeStats 0ms

/application/libraries/getid3/module.audio-video.riff.php

https://github.com/libis/Flandrica
PHP | 2391 lines | 1858 code | 404 blank | 129 comment | 248 complexity | fb6c7610710749b4a70742c09517cf5d MD5 | raw file
Possible License(s): GPL-3.0, LGPL-2.1, Apache-2.0 
    

  1. <?php
    2. 

  2. // +----------------------------------------------------------------------+
    3. 

  3. // | PHP version 5                                                        |
    4. 

  4. // +----------------------------------------------------------------------+
    5. 

  5. // | Copyright (c) 2002-2009 James Heinrich, Allan Hansen                 |
    6. 

  6. // +----------------------------------------------------------------------+
    7. 

  7. // | This source file is subject to version 2 of the GPL license,         |
    8. 

  8. // | that is bundled with this package in the file license.txt and is     |
    9. 

  9. // | available through the world-wide-web at the following url:           |
    10. 

  10. // | http://www.gnu.org/copyleft/gpl.html                                 |
    11. 

  11. // +----------------------------------------------------------------------+
    12. 

  12. // | getID3() - http://getid3.sourceforge.net or http://www.getid3.org    |
    13. 

  13. // +----------------------------------------------------------------------+
    14. 

  14. // | Authors: James Heinrich <infoŘgetid3*org>                            |
    15. 

  15. // |          Allan Hansen <ahŘartemis*dk>                                |
    16. 

  16. // +----------------------------------------------------------------------+
    17. 

  17. // | module.audio-video.riff.php                                          |
    18. 

  18. // | module for analyzing RIFF files:                                     |
    19. 

  19. // |    Wave, AVI, AIFF/AIFC, (MP3,AC3)/RIFF, Wavpack3, 8SVX              |
    20. 

  20. // | dependencies: module.audio.mp3.php (optional)                        |
    21. 

  21. // |               module.audio.ac3.php (optional)                        |
    22. 

  22. // |               module.audio.dts.php (optional)                        |
    23. 

  23. // |               module.audio-video.mpeg.php (optional)                 |
    24. 

  24. // +----------------------------------------------------------------------+
    25. 

  25. //
    26. 

  26. // $Id: module.audio-video.riff.php,v 1.10 2006/12/03 20:13:17 ah Exp $
    27. 

  27. 

  28. 

  29. 

  30. class getid3_riff extends getid3_handler
    31. 

  31. {
    32. 

  32. 

  33. 	private $endian_function = 'LittleEndian2Int';
    34. 

  34. 

  35. 

  36. 	public function Analyze() {
    37. 

  37. 

  38. 		$getid3 = $this->getid3;
    39. 

  39. 

  40. 		$getid3->info['riff']['raw'] = array ();
    41. 

  41. 		$info_riff             = &$getid3->info['riff'];
    42. 

  42. 		$info_riff_raw         = &$info_riff['raw'];
    43. 

  43. 		$info_audio            = &$getid3->info['audio'];
    44. 

  44. 		$info_video            = &$getid3->info['video'];
    45. 

  45. 		$info_avdataoffset     = &$getid3->info['avdataoffset'];
    46. 

  46. 		$info_avdataend        = &$getid3->info['avdataend'];
    47. 

  47. 		$info_audio_dataformat = &$info_audio['dataformat'];
    48. 

  48. 		$info_riff_audio       = &$info_riff['audio'];
    49. 

  49. 		$info_riff_video       = &$info_riff['video'];
    50. 

  50. 

  51. 		$original['avdataend'] = $info_avdataend;
    52. 

  52. 

  53. 		$this->fseek($info_avdataoffset, SEEK_SET);
    54. 

  54. 		$riff_header   = $this->fread(12);
    55. 

  55. 

  56. 		$riff_sub_type = substr($riff_header, 8, 4);
    57. 

  57. 

  58. 		switch (substr($riff_header, 0, 4)) {
    59. 

  59. 

  60. 			case 'FORM':
    61. 

  61. 				$getid3->info['fileformat'] = 'aiff';
    62. 

  62. 				$this->endian_function      = 'BigEndian2Int';
    63. 

  63. 				$riff_header_size           = getid3_lib::BigEndian2Int(substr($riff_header, 4, 4));
    64. 

  64. 				$info_riff[$riff_sub_type]  = $this->ParseRIFF($info_avdataoffset + 12, $info_avdataoffset + $riff_header_size);
    65. 

  65. 				$info_riff['header_size']   = $riff_header_size;
    66. 

  66. 				break;
    67. 

  67. 

  68. 

  69. 			case 'RIFF':
    70. 

  70. 			case 'SDSS':  // SDSS is identical to RIFF, just renamed. Used by SmartSound QuickTracks (www.smartsound.com)
    71. 

  71. 			case 'RMP3':  // RMP3 is identical to RIFF, just renamed. Used by [unknown program] when creating RIFF-MP3s
    72. 

  72. 

  73. 				if ($riff_sub_type == 'RMP3') {
    74. 

  74. 					$riff_sub_type = 'WAVE';
    75. 

  75. 				}
    76. 

  76. 

  77. 				$getid3->info['fileformat'] = 'riff';
    78. 

  78. 				$this->endian_function      = 'LittleEndian2Int';
    79. 

  79. 				$riff_header_size           = getid3_lib::LittleEndian2Int(substr($riff_header, 4, 4));
    80. 

  80. 				$info_riff[$riff_sub_type]  = $this->ParseRIFF($info_avdataoffset + 12, $info_avdataoffset + $riff_header_size);
    81. 

  81. 				$info_riff['header_size']   = $riff_header_size;
    82. 

  82. 				if ($riff_sub_type == 'WAVE') {
    83. 

  83. 					$info_riff_wave = &$info_riff['WAVE'];
    84. 

  84. 				}
    85. 

  85. 				break;
    86. 

  86. 

  87. 

  88. 			default:
    89. 

  89. 				throw new getid3_exception('Cannot parse RIFF (this is maybe not a RIFF / WAV / AVI file?) - expecting "FORM|RIFF|SDSS|RMP3" found "'.$riff_sub_type.'" instead');
    90. 

  90. 		}
    91. 

  91. 

  92. 		$endian_function = $this->endian_function;
    93. 

  93. 

  94. 		$stream_index = 0;
    95. 

  95. 		switch ($riff_sub_type) {
    96. 

  96. 

  97. 			case 'WAVE':
    98. 

  98. 

  99. 				if (empty($info_audio['bitrate_mode'])) {
    100. 

  100. 					$info_audio['bitrate_mode'] = 'cbr';
    101. 

  101. 				}
    102. 

  102. 

  103. 				if (empty($info_audio_dataformat)) {
    104. 

  104. 					$info_audio_dataformat = 'wav';
    105. 

  105. 				}
    106. 

  106. 

  107. 				if (isset($info_riff_wave['data'][0]['offset'])) {
    108. 

  108. 					$info_avdataoffset = $info_riff_wave['data'][0]['offset'] + 8;
    109. 

  109. 					$info_avdataend    = $info_avdataoffset + $info_riff_wave['data'][0]['size'];
    110. 

  110. 				}
    111. 

  111. 

  112. 				if (isset($info_riff_wave['fmt '][0]['data'])) {
    113. 

  113. 

  114. 					$info_riff_audio[$stream_index] = getid3_riff::RIFFparseWAVEFORMATex($info_riff_wave['fmt '][0]['data']);
    115. 

  115. 					$info_audio['wformattag'] = $info_riff_audio[$stream_index]['raw']['wFormatTag'];
    116. 

  116. 					$info_riff_raw['fmt '] = $info_riff_audio[$stream_index]['raw'];
    117. 

  117. 					unset($info_riff_audio[$stream_index]['raw']);
    118. 

  118. 					$info_audio['streams'][$stream_index] = $info_riff_audio[$stream_index];
    119. 

  119. 

  120. 					$info_audio = getid3_riff::array_merge_noclobber($info_audio, $info_riff_audio[$stream_index]);
    121. 

  121. 					if (substr($info_audio['codec'], 0, strlen('unknown: 0x')) == 'unknown: 0x') {
    122. 

  122. 						$getid3->warning('Audio codec = '.$info_audio['codec']);
    123. 

  123. 					}
    124. 

  124. 					$info_audio['bitrate'] = $info_riff_audio[$stream_index]['bitrate'];
    125. 

  125. 

  126. 					$getid3->info['playtime_seconds'] = (float)((($info_avdataend - $info_avdataoffset) * 8) / $info_audio['bitrate']);
    127. 

  127. 

  128. 					$info_audio['lossless'] = false;
    129. 

  129. 

  130. 					if (isset($info_riff_wave['data'][0]['offset']) && isset($info_riff_raw['fmt ']['wFormatTag'])) {
    131. 

  131. 

  132. 						switch ($info_riff_raw['fmt ']['wFormatTag']) {
    133. 

  133. 

  134. 							case 0x0001:  // PCM
    135. 

  135. 								$info_audio['lossless'] = true;
    136. 

  136. 								break;
    137. 

  137. 

  138. 							case 0x2000:  // AC-3
    139. 

  139. 								$info_audio_dataformat = 'ac3';
    140. 

  140. 								break;
    141. 

  141. 

  142. 							default:
    143. 

  143. 								// do nothing
    144. 

  144. 								break;
    145. 

  145. 

  146. 						}
    147. 

  147. 					}
    148. 

  148. 

  149. 					$info_audio['streams'][$stream_index]['wformattag']   = $info_audio['wformattag'];
    150. 

  150. 					$info_audio['streams'][$stream_index]['bitrate_mode'] = $info_audio['bitrate_mode'];
    151. 

  151. 					$info_audio['streams'][$stream_index]['lossless']     = $info_audio['lossless'];
    152. 

  152. 					$info_audio['streams'][$stream_index]['dataformat']   = $info_audio_dataformat;
    153. 

  153. 				}
    154. 

  154. 

  155. 

  156. 				if (isset($info_riff_wave['rgad'][0]['data'])) {
    157. 

  157. 

  158. 					// shortcuts
    159. 

  159. 					$rgadData = &$info_riff_wave['rgad'][0]['data'];
    160. 

  160. 					$info_riff_raw['rgad']    = array ('track'=>array(), 'album'=>array());
    161. 

  161. 					$info_riff_raw_rgad       = &$info_riff_raw['rgad'];
    162. 

  162. 					$info_riff_raw_rgad_track = &$info_riff_raw_rgad['track'];
    163. 

  163. 					$info_riff_raw_rgad_album = &$info_riff_raw_rgad['album'];
    164. 

  164. 

  165. 					$info_riff_raw_rgad['fPeakAmplitude']      = getid3_riff::BigEndian2Float(strrev(substr($rgadData, 0, 4)));   // LittleEndian2Float()
    166. 

  166. 					$info_riff_raw_rgad['nRadioRgAdjust']      = getid3_lib::$endian_function(substr($rgadData, 4, 2));
    167. 

  167. 					$info_riff_raw_rgad['nAudiophileRgAdjust'] = getid3_lib::$endian_function(substr($rgadData, 6, 2));
    168. 

  168. 

  169. 					$n_track_rg_adjust_bit_string              = str_pad(decbin($info_riff_raw_rgad['nRadioRgAdjust']),      16, '0', STR_PAD_LEFT);
    170. 

  170. 					$n_album_rg_adjust_bit_string              = str_pad(decbin($info_riff_raw_rgad['nAudiophileRgAdjust']), 16, '0', STR_PAD_LEFT);
    171. 

  171. 

  172. 					$info_riff_raw_rgad_track['name']          = bindec(substr($n_track_rg_adjust_bit_string, 0, 3));
    173. 

  173. 					$info_riff_raw_rgad_track['originator']    = bindec(substr($n_track_rg_adjust_bit_string, 3, 3));
    174. 

  174. 					$info_riff_raw_rgad_track['signbit']       = bindec($n_track_rg_adjust_bit_string[6]);
    175. 

  175. 					$info_riff_raw_rgad_track['adjustment']    = bindec(substr($n_track_rg_adjust_bit_string, 7, 9));
    176. 

  176. 					$info_riff_raw_rgad_album['name']          = bindec(substr($n_album_rg_adjust_bit_string, 0, 3));
    177. 

  177. 					$info_riff_raw_rgad_album['originator']    = bindec(substr($n_album_rg_adjust_bit_string, 3, 3));
    178. 

  178. 					$info_riff_raw_rgad_album['signbit']       = bindec($n_album_rg_adjust_bit_string[6]);
    179. 

  179. 					$info_riff_raw_rgad_album['adjustment']    = bindec(substr($n_album_rg_adjust_bit_string, 7, 9));
    180. 

  180. 

  181. 					$info_riff['rgad']['peakamplitude'] = $info_riff_raw_rgad['fPeakAmplitude'];
    182. 

  182. 					if (($info_riff_raw_rgad_track['name'] != 0) && ($info_riff_raw_rgad_track['originator'] != 0)) {
    183. 

  183. 						$info_riff['rgad']['track']['name']       = getid3_lib_replaygain::NameLookup($info_riff_raw_rgad_track['name']);
    184. 

  184. 						$info_riff['rgad']['track']['originator'] = getid3_lib_replaygain::OriginatorLookup($info_riff_raw_rgad_track['originator']);
    185. 

  185. 						$info_riff['rgad']['track']['adjustment'] = getid3_lib_replaygain::AdjustmentLookup($info_riff_raw_rgad_track['adjustment'], $info_riff_raw_rgad_track['signbit']);
    186. 

  186. 					}
    187. 

  187. 

  188. 					if (($info_riff_raw_rgad_album['name'] != 0) && ($info_riff_raw_rgad_album['originator'] != 0)) {
    189. 

  189. 						$info_riff['rgad']['album']['name']       = getid3_lib_replaygain::NameLookup($info_riff_raw_rgad_album['name']);
    190. 

  190. 						$info_riff['rgad']['album']['originator'] = getid3_lib_replaygain::OriginatorLookup($info_riff_raw_rgad_album['originator']);
    191. 

  191. 						$info_riff['rgad']['album']['adjustment'] = getid3_lib_replaygain::AdjustmentLookup($info_riff_raw_rgad_album['adjustment'], $info_riff_raw_rgad_album['signbit']);
    192. 

  192. 					}
    193. 

  193. 				}
    194. 

  194. 

  195. 				if (isset($info_riff_wave['fact'][0]['data'])) {
    196. 

  196. 

  197. 					$info_riff_raw['fact']['NumberOfSamples'] = getid3_lib::$endian_function(substr($info_riff_wave['fact'][0]['data'], 0, 4));
    198. 

  198. 

  199. 					// This should be a good way of calculating exact playtime, but some sample files have had incorrect number of samples, so cannot use this method
    200. 

  200. 					// if (!empty($info_riff_raw['fmt ']['nSamplesPerSec'])) {
    201. 

  201. 					//     $getid3->info['playtime_seconds'] = (float)$info_riff_raw['fact']['NumberOfSamples'] / $info_riff_raw['fmt ']['nSamplesPerSec'];
    202. 

  202. 					// }
    203. 

  203. 				}
    204. 

  204. 

  205. 

  206. 				if (!empty($info_riff_raw['fmt ']['nAvgBytesPerSec'])) {
    207. 

  207. 					$info_audio['bitrate'] = (int)$info_riff_raw['fmt ']['nAvgBytesPerSec'] * 8;
    208. 

  208. 				}
    209. 

  209. 

  210. 				if (isset($info_riff_wave['bext'][0]['data'])) {
    211. 

  211. 

  212. 					$info_riff_wave_bext_0 = &$info_riff_wave['bext'][0];
    213. 

  213. 

  214. 					getid3_lib::ReadSequence('LittleEndian2Int', $info_riff_wave_bext_0, $info_riff_wave_bext_0['data'], 0,
    215. 

  215. 						array (
    216. 

  216. 							'title'          => -256,
    217. 

  217. 							'author'         =>  -32,
    218. 

  218. 							'reference'      =>  -32,
    219. 

  219. 							'origin_date'    =>  -10,
    220. 

  220. 							'origin_time'    =>   -8,
    221. 

  221. 							'time_reference' =>    8,
    222. 

  222. 							'bwf_version'    =>    1,
    223. 

  223. 							'reserved'       =>  254
    224. 

  224. 						)
    225. 

  225. 					);
    226. 

  226. 

  227. 					foreach (array ('title', 'author', 'reference') as $key) {
    228. 

  228. 						$info_riff_wave_bext_0[$key] = trim($info_riff_wave_bext_0[$key]);
    229. 

  229. 					}
    230. 

  230. 

  231. 					$info_riff_wave_bext_0['coding_history'] = explode("\r\n", trim(substr($info_riff_wave_bext_0['data'], 601)));
    232. 

  232. 

  233. 					$info_riff_wave_bext_0['origin_date_unix'] = gmmktime(substr($info_riff_wave_bext_0['origin_time'], 0, 2),
    234. 

  234. 																		  substr($info_riff_wave_bext_0['origin_time'], 3, 2),
    235. 

  235. 																		  substr($info_riff_wave_bext_0['origin_time'], 6, 2),
    236. 

  236. 																		  substr($info_riff_wave_bext_0['origin_date'], 5, 2),
    237. 

  237. 																		  substr($info_riff_wave_bext_0['origin_date'], 8, 2),
    238. 

  238. 																		  substr($info_riff_wave_bext_0['origin_date'], 0, 4));
    239. 

  239. 

  240. 					$info_riff['comments']['author'][] = $info_riff_wave_bext_0['author'];
    241. 

  241. 					$info_riff['comments']['title'][]  = $info_riff_wave_bext_0['title'];
    242. 

  242. 				}
    243. 

  243. 

  244. 				if (isset($info_riff_wave['MEXT'][0]['data'])) {
    245. 

  245. 

  246. 					$info_riff_wave_mext_0 = &$info_riff_wave['MEXT'][0];
    247. 

  247. 

  248. 					$info_riff_wave_mext_0['raw']['sound_information']      = getid3_lib::LittleEndian2Int(substr($info_riff_wave_mext_0['data'], 0, 2));
    249. 

  249. 					$info_riff_wave_mext_0['flags']['homogenous']           = (bool)($info_riff_wave_mext_0['raw']['sound_information'] & 0x0001);
    250. 

  250. 					if ($info_riff_wave_mext_0['flags']['homogenous']) {
    251. 

  251. 						$info_riff_wave_mext_0['flags']['padding']          = ($info_riff_wave_mext_0['raw']['sound_information'] & 0x0002) ? false : true;
    252. 

  252. 						$info_riff_wave_mext_0['flags']['22_or_44']         = (bool)($info_riff_wave_mext_0['raw']['sound_information'] & 0x0004);
    253. 

  253. 						$info_riff_wave_mext_0['flags']['free_format']      = (bool)($info_riff_wave_mext_0['raw']['sound_information'] & 0x0008);
    254. 

  254. 

  255. 						$info_riff_wave_mext_0['nominal_frame_size']        = getid3_lib::LittleEndian2Int(substr($info_riff_wave_mext_0['data'], 2, 2));
    256. 

  256. 					}
    257. 

  257. 					$info_riff_wave_mext_0['anciliary_data_length']         = getid3_lib::LittleEndian2Int(substr($info_riff_wave_mext_0['data'], 6, 2));
    258. 

  258. 					$info_riff_wave_mext_0['raw']['anciliary_data_def']     = getid3_lib::LittleEndian2Int(substr($info_riff_wave_mext_0['data'], 8, 2));
    259. 

  259. 					$info_riff_wave_mext_0['flags']['anciliary_data_left']  = (bool)($info_riff_wave_mext_0['raw']['anciliary_data_def'] & 0x0001);
    260. 

  260. 					$info_riff_wave_mext_0['flags']['anciliary_data_free']  = (bool)($info_riff_wave_mext_0['raw']['anciliary_data_def'] & 0x0002);
    261. 

  261. 					$info_riff_wave_mext_0['flags']['anciliary_data_right'] = (bool)($info_riff_wave_mext_0['raw']['anciliary_data_def'] & 0x0004);
    262. 

  262. 				}
    263. 

  263. 

  264. 				if (isset($info_riff_wave['cart'][0]['data'])) {
    265. 

  265. 

  266. 					$info_riff_wave_cart_0 = &$info_riff_wave['cart'][0];
    267. 

  267. 

  268. 					getid3_lib::ReadSequence('LittleEndian2Int', $info_riff_wave_cart_0, $info_riff_wave_cart_0['data'], 0,
    269. 

  269. 						array (
    270. 

  270. 							'version'              => -4,
    271. 

  271. 							'title'                => -64,
    272. 

  272. 							'artist'               => -64,
    273. 

  273. 							'cut_id'               => -64,
    274. 

  274. 							'client_id'            => -64,
    275. 

  275. 							'category'             => -64,
    276. 

  276. 							'classification'       => -64,
    277. 

  277. 							'out_cue'              => -64,
    278. 

  278. 							'start_date'           => -10,
    279. 

  279. 							'start_time'           => -8,
    280. 

  280. 							'end_date'             => -10,
    281. 

  281. 							'end_time'             => -8,
    282. 

  282. 							'producer_app_id'      => -64,
    283. 

  283. 							'producer_app_version' => -64,
    284. 

  284. 							'user_defined_text'    => -64,
    285. 

  285. 						)
    286. 

  286. 					);
    287. 

  287. 

  288. 					foreach (array ('artist', 'cut_id', 'client_id', 'category', 'classification', 'out_cue', 'start_date', 'start_time', 'end_date', 'end_time', 'producer_app_id', 'producer_app_version', 'user_defined_text') as $key) {
    289. 

  289. 						$info_riff_wave_cart_0[$key] = trim($info_riff_wave_cart_0[$key]);
    290. 

  290. 					}
    291. 

  291. 

  292. 					$info_riff_wave_cart_0['zero_db_reference'] = getid3_lib::LittleEndian2Int(substr($info_riff_wave_cart_0['data'], 680, 4), true);
    293. 

  293. 

  294. 					for ($i = 0; $i < 8; $i++) {
    295. 

  295. 						$info_riff_wave_cart_0['post_time'][$i]['usage_fourcc'] =                              substr($info_riff_wave_cart_0['data'], 684 + ($i * 8), 4);
    296. 

  296. 						$info_riff_wave_cart_0['post_time'][$i]['timer_value']  = getid3_lib::LittleEndian2Int(substr($info_riff_wave_cart_0['data'], 684 + ($i * 8) + 4, 4));
    297. 

  297. 					}
    298. 

  298. 					$info_riff_wave_cart_0['url']              =                 trim(substr($info_riff_wave_cart_0['data'],  748, 1024));
    299. 

  299. 					$info_riff_wave_cart_0['tag_text']         = explode("\r\n", trim(substr($info_riff_wave_cart_0['data'], 1772)));
    300. 

  300. 

  301. 					$info_riff['comments']['artist'][] = $info_riff_wave_cart_0['artist'];
    302. 

  302. 					$info_riff['comments']['title'][]  = $info_riff_wave_cart_0['title'];
    303. 

  303. 				}
    304. 

  304. 

  305. 

  306. 				if (isset($info_riff_wave['SNDM'][0]['data'])) {
    307. 

  307. 					// SoundMiner metadata
    308. 

  308. 

  309. 					// shortcuts
    310. 

  310. 					$info_riff_wave_SNDM_0      = &$info_riff_wave['SNDM'][0];
    311. 

  311. 					$info_riff_wave_SNDM_0_data = &$info_riff_wave_SNDM_0['data'];
    312. 

  312. 					$SNDM_startoffset = 0;
    313. 

  313. 					$SNDM_endoffset   = $info_riff_wave_SNDM_0['size'];
    314. 

  314. 

  315. 					while ($SNDM_startoffset < $SNDM_endoffset) {
    316. 

  316. 						$SNDM_thisTagOffset = 0;
    317. 

  317. 						$SNDM_thisTagSize      = getid3_lib::BigEndian2Int(substr($info_riff_wave_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 4));
    318. 

  318. 						$SNDM_thisTagOffset += 4;
    319. 

  319. 						$SNDM_thisTagKey       =                           substr($info_riff_wave_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 4);
    320. 

  320. 						$SNDM_thisTagOffset += 4;
    321. 

  321. 						$SNDM_thisTagDataSize  = getid3_lib::BigEndian2Int(substr($info_riff_wave_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 2));
    322. 

  322. 						$SNDM_thisTagOffset += 2;
    323. 

  323. 						$SNDM_thisTagDataFlags = getid3_lib::BigEndian2Int(substr($info_riff_wave_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 2));
    324. 

  324. 						$SNDM_thisTagOffset += 2;
    325. 

  325. 						$SNDM_thisTagDataText =                            substr($info_riff_wave_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, $SNDM_thisTagDataSize);
    326. 

  326. 						$SNDM_thisTagOffset += $SNDM_thisTagDataSize;
    327. 

  327. 

  328. 						if ($SNDM_thisTagSize != (4 + 4 + 2 + 2 + $SNDM_thisTagDataSize)) {
    329. 

  329. 							$getid3->warning('RIFF.WAVE.SNDM.data contains tag not expected length (expected: '.$SNDM_thisTagSize.', found: '.(4 + 4 + 2 + 2 + $SNDM_thisTagDataSize).') at offset '.$SNDM_startoffset.' (file offset '.($info_riff_wave_SNDM_0['offset'] + $SNDM_startoffset).')');
    330. 

  330. 							break;
    331. 

  331. 						} elseif ($SNDM_thisTagSize <= 0) {
    332. 

  332. 							$getid3->warning('RIFF.WAVE.SNDM.data contains zero-size tag at offset '.$SNDM_startoffset.' (file offset '.($info_riff_wave_SNDM_0['offset'] + $SNDM_startoffset).')');
    333. 

  333. 							break;
    334. 

  334. 						}
    335. 

  335. 						$SNDM_startoffset += $SNDM_thisTagSize;
    336. 

  336. 

  337. 						$info_riff_wave_SNDM_0['parsed_raw'][$SNDM_thisTagKey] = $SNDM_thisTagDataText;
    338. 

  338. 						$parsedkey = $this->RIFFwaveSNDMtagLookup($SNDM_thisTagKey);
    339. 

  339. 						if ($parsedkey) {
    340. 

  340. 							$info_riff_wave_SNDM_0['parsed'][$parsedkey] = $SNDM_thisTagDataText;
    341. 

  341. 						} else {
    342. 

  342. 							$getid3->warning('RIFF.WAVE.SNDM contains unknown tag "'.$SNDM_thisTagKey.'" at offset '.$SNDM_startoffset.' (file offset '.($info_riff_wave_SNDM_0['offset'] + $SNDM_startoffset).')');
    343. 

  343. 						}
    344. 

  344. 					}
    345. 

  345. 

  346. 					$tagmapping = array(
    347. 

  347. 						'tracktitle'=>'title',
    348. 

  348. 						'category'  =>'genre',
    349. 

  349. 						'cdtitle'   =>'album',
    350. 

  350. 						'tracktitle'=>'title',
    351. 

  351. 					);
    352. 

  352. 					foreach ($tagmapping as $fromkey => $tokey) {
    353. 

  353. 						if (isset($info_riff_wave_SNDM_0['parsed'][$fromkey])) {
    354. 

  354. 							$info_riff['comments'][$tokey][] = $info_riff_wave_SNDM_0['parsed'][$fromkey];
    355. 

  355. 						}
    356. 

  356. 					}
    357. 

  357. 				}
    358. 

  358. 

  359. 

  360. 				if (!isset($info_audio['bitrate']) && isset($info_riff_audio[$stream_index]['bitrate'])) {
    361. 

  361. 					$info_audio['bitrate'] = $info_riff_audio[$stream_index]['bitrate'];
    362. 

  362. 					$getid3->info['playtime_seconds'] = (float)((($info_avdataend - $info_avdataoffset) * 8) / $info_audio['bitrate']);
    363. 

  363. 				}
    364. 

  364. 

  365. 				if (@$getid3->info['wavpack']) {
    366. 

  366. 

  367. 					if (!$this->data_string_flag)  {
    368. 

  368. 

  369. 						$info_audio_dataformat      = 'wavpack';
    370. 

  370. 						$info_audio['bitrate_mode'] = 'vbr';
    371. 

  371. 						$info_audio['encoder']      = 'WavPack v'.$getid3->info['wavpack']['version'];
    372. 

  372. 

  373. 						// Reset to the way it was - RIFF parsing will have messed this up
    374. 

  374. 						$info_avdataend        = $original['avdataend'];
    375. 

  375. 						$info_audio['bitrate'] = (($info_avdataend - $info_avdataoffset) * 8) / $getid3->info['playtime_seconds'];
    376. 

  376. 

  377. 						$this->fseek($info_avdataoffset - 44, SEEK_SET);
    378. 

  378. 						$riff_data = $this->fread(44);
    379. 

  379. 						$orignal_riff_header_size = getid3_lib::LittleEndian2Int(substr($riff_data,  4, 4)) +  8;
    380. 

  380. 						$orignal_riff_data_size   = getid3_lib::LittleEndian2Int(substr($riff_data, 40, 4)) + 44;
    381. 

  381. 

  382. 						if ($orignal_riff_header_size > $orignal_riff_data_size) {
    383. 

  383. 							$info_avdataend -= ($orignal_riff_header_size - $orignal_riff_data_size);
    384. 

  384. 							$this->fseek($info_avdataend, SEEK_SET);
    385. 

  385. 							$riff_data .= $this->fread($orignal_riff_header_size - $orignal_riff_data_size);
    386. 

  386. 						}
    387. 

  387. 

  388. 						// move the data chunk after all other chunks (if any)
    389. 

  389. 						// so that the RIFF parser doesn't see EOF when trying
    390. 

  390. 						// to skip over the data chunk
    391. 

  391. 						$riff_data = substr($riff_data, 0, 36).substr($riff_data, 44).substr($riff_data, 36, 8);
    392. 

  392. 

  393. 						// Save audio info key
    394. 

  394. 						$saved_info_audio = $info_audio;
    395. 

  395. 

  396. 						// Analyze riff_data
    397. 

  397. 						$this->AnalyzeString($riff_data);
    398. 

  398. 

  399. 						// Restore info key
    400. 

  400. 						$info_audio = $saved_info_audio;
    401. 

  401. 					}
    402. 

  402. 				}
    403. 

  403. 

  404. 				if (isset($info_riff_raw['fmt ']['wFormatTag'])) {
    405. 

  405. 

  406. 					switch ($info_riff_raw['fmt ']['wFormatTag']) {
    407. 

  407. 

  408. 						case 0x08AE: // ClearJump LiteWave
    409. 

  409. 							$info_audio['bitrate_mode'] = 'vbr';
    410. 

  410. 							$info_audio_dataformat      = 'litewave';
    411. 

  411. 

  412. 							//typedef struct tagSLwFormat {
    413. 

  413. 							//  WORD    m_wCompFormat;     // low byte defines compression method, high byte is compression flags
    414. 

  414. 							//  DWORD   m_dwScale;         // scale factor for lossy compression
    415. 

  415. 							//  DWORD   m_dwBlockSize;     // number of samples in encoded blocks
    416. 

  416. 							//  WORD    m_wQuality;        // alias for the scale factor
    417. 

  417. 							//  WORD    m_wMarkDistance;   // distance between marks in bytes
    418. 

  418. 							//  WORD    m_wReserved;
    419. 

  419. 							//
    420. 

  420. 							//  //following paramters are ignored if CF_FILESRC is not set
    421. 

  421. 							//  DWORD   m_dwOrgSize;       // original file size in bytes
    422. 

  422. 							//  WORD    m_bFactExists;     // indicates if 'fact' chunk exists in the original file
    423. 

  423. 							//  DWORD   m_dwRiffChunkSize; // riff chunk size in the original file
    424. 

  424. 							//
    425. 

  425. 							//  PCMWAVEFORMAT m_OrgWf;     // original wave format
    426. 

  426. 							// }SLwFormat, *PSLwFormat;
    427. 

  427. 

  428. 							$info_riff['litewave']['raw'] = array ();
    429. 

  429. 							$info_riff_litewave           = &$info_riff['litewave'];
    430. 

  430. 							$info_riff_litewave_raw       = &$info_riff_litewave['raw'];
    431. 

  431. 

  432. 							getid3_lib::ReadSequence('LittleEndian2Int', $info_riff_litewave_raw, $info_riff_wave['fmt '][0]['data'], 18,
    433. 

  433. 								array (
    434. 

  434. 									'compression_method' => 1,
    435. 

  435. 									'compression_flags'  => 1,
    436. 

  436. 									'm_dwScale'          => 4,
    437. 

  437. 									'm_dwBlockSize'      => 4,
    438. 

  438. 									'm_wQuality'         => 2,
    439. 

  439. 									'm_wMarkDistance'    => 2,
    440. 

  440. 									'm_wReserved'        => 2,
    441. 

  441. 									'm_dwOrgSize'        => 4,
    442. 

  442. 									'm_bFactExists'      => 2,
    443. 

  443. 									'm_dwRiffChunkSize'  => 4
    444. 

  444. 								)
    445. 

  445. 							);
    446. 

  446. 

  447. 							//$info_riff_litewave['quality_factor'] = intval(round((2000 - $info_riff_litewave_raw['m_dwScale']) / 20));
    448. 

  448. 							$info_riff_litewave['quality_factor'] = $info_riff_litewave_raw['m_wQuality'];
    449. 

  449. 

  450. 							$info_riff_litewave['flags']['raw_source']    = ($info_riff_litewave_raw['compression_flags'] & 0x01) ? false : true;
    451. 

  451. 							$info_riff_litewave['flags']['vbr_blocksize'] = ($info_riff_litewave_raw['compression_flags'] & 0x02) ? false : true;
    452. 

  452. 							$info_riff_litewave['flags']['seekpoints']    = (bool)($info_riff_litewave_raw['compression_flags'] & 0x04);
    453. 

  453. 

  454. 							$info_audio['lossless']        = (($info_riff_litewave_raw['m_wQuality'] == 100) ? true : false);
    455. 

  455. 							$info_audio['encoder_options'] = '-q'.$info_riff_litewave['quality_factor'];
    456. 

  456. 							break;
    457. 

  457. 					}
    458. 

  458. 				}
    459. 

  459. 

  460. 				if ($info_avdataend > $getid3->info['filesize']) {
    461. 

  461. 

  462. 					switch (@$info_audio_dataformat) {
    463. 

  463. 

  464. 						case 'wavpack': // WavPack
    465. 

  465. 						case 'lpac':    // LPAC
    466. 

  466. 						case 'ofr':     // OptimFROG
    467. 

  467. 						case 'ofs':     // OptimFROG DualStream
    468. 

  468. 							// lossless compressed audio formats that keep original RIFF headers - skip warning
    469. 

  469. 							break;
    470. 

  470. 

  471. 

  472. 						case 'litewave':
    473. 

  473. 							if (($info_avdataend - $getid3->info['filesize']) == 1) {
    474. 

  474. 								// LiteWave appears to incorrectly *not* pad actual output file
    475. 

  475. 								// to nearest WORD boundary so may appear to be short by one
    476. 

  476. 								// byte, in which case - skip warning
    477. 

  477. 							} else {
    478. 

  478. 								// Short by more than one byte, throw warning
    479. 

  479. 								$getid3->warning('Probably truncated file - expecting '.$info_riff[$riff_sub_type]['data'][0]['size'].' bytes of data, only found '.($getid3->info['filesize'] - $info_avdataoffset).' (short by '.($info_riff[$riff_sub_type]['data'][0]['size'] - ($getid3->info['filesize'] - $info_avdataoffset)).' bytes)');
    480. 

  480. 							}
    481. 

  481. 							break;
    482. 

  482. 

  483. 

  484. 						default:
    485. 

  485. 							if ((($info_avdataend - $getid3->info['filesize']) == 1) && (($info_riff[$riff_sub_type]['data'][0]['size'] % 2) == 0) && ((($getid3->info['filesize'] - $info_avdataoffset) % 2) == 1)) {
    486. 

  486. 								// output file appears to be incorrectly *not* padded to nearest WORD boundary
    487. 

  487. 								// Output less severe warning
    488. 

  488. 								$getid3->warning('File should probably be padded to nearest WORD boundary, but it is not (expecting '.$info_riff[$riff_sub_type]['data'][0]['size'].' bytes of data, only found '.($getid3->info['filesize'] - $info_avdataoffset).' therefore short by '.($info_riff[$riff_sub_type]['data'][0]['size'] - ($getid3->info['filesize'] - $info_avdataoffset)).' bytes)');
    489. 

  489. 								$info_avdataend = $getid3->info['filesize'];
    490. 

  490. 								break;
    491. 

  491. 

  492. 							}
    493. 

  493. 							// Short by more than one byte, throw warning
    494. 

  494. 							$getid3->warning('Probably truncated file - expecting '.$info_riff[$riff_sub_type]['data'][0]['size'].' bytes of data, only found '.($getid3->info['filesize'] - $info_avdataoffset).' (short by '.($info_riff[$riff_sub_type]['data'][0]['size'] - ($getid3->info['filesize'] - $info_avdataoffset)).' bytes)');
    495. 

  495. 							$info_avdataend = $getid3->info['filesize'];
    496. 

  496. 							break;
    497. 

  497. 					}
    498. 

  498. 				}
    499. 

  499. 

  500. 				if (!empty($getid3->info['mpeg']['audio']['LAME']['audio_bytes'])) {
    501. 

  501. 					if ((($info_avdataend - $info_avdataoffset) - $getid3->info['mpeg']['audio']['LAME']['audio_bytes']) == 1) {
    502. 

  502. 						$info_avdataend--;
    503. 

  503. 						$getid3->warning('Extra null byte at end of MP3 data assumed to be RIFF padding and therefore ignored');
    504. 

  504. 					}
    505. 

  505. 				}
    506. 

  506. 

  507. 				if (@$info_audio_dataformat == 'ac3') {
    508. 

  508. 					unset($info_audio['bits_per_sample']);
    509. 

  509. 					if (!empty($getid3->info['ac3']['bitrate']) && ($getid3->info['ac3']['bitrate'] != $info_audio['bitrate'])) {
    510. 

  510. 						$info_audio['bitrate'] = $getid3->info['ac3']['bitrate'];
    511. 

  511. 					}
    512. 

  512. 				}
    513. 

  513. 				break;
    514. 

  514. 

  515. 

  516. 			case 'AVI ':
    517. 

  517. 				$info_video['bitrate_mode'] = 'vbr'; // maybe not, but probably
    518. 

  518. 				$info_video['dataformat']   = 'avi';
    519. 

  519. 				$getid3->info['mime_type']  = 'video/avi';
    520. 

  520. 

  521. 				if (isset($info_riff[$riff_sub_type]['movi']['offset'])) {
    522. 

  522. 					$info_avdataoffset = $info_riff[$riff_sub_type]['movi']['offset'] + 8;
    523. 

  523. 					$info_avdataend    = $info_avdataoffset + $info_riff[$riff_sub_type]['movi']['size'];
    524. 

  524. 					if ($info_avdataend > $getid3->info['filesize']) {
    525. 

  525. 						$getid3->warning('Probably truncated file - expecting '.$info_riff[$riff_sub_type]['movi']['size'].' bytes of data, only found '.($getid3->info['filesize'] - $info_avdataoffset).' (short by '.($info_riff[$riff_sub_type]['movi']['size'] - ($getid3->info['filesize'] - $info_avdataoffset)).' bytes)');
    526. 

  526. 						$info_avdataend = $getid3->info['filesize'];
    527. 

  527. 					}
    528. 

  528. 				}
    529. 

  529. 

  530. 				if (isset($info_riff['AVI ']['hdrl']['avih'][$stream_index]['data'])) {
    531. 

  531. 					$avihData = $info_riff['AVI ']['hdrl']['avih'][$stream_index]['data'];
    532. 

  532. 

  533. 					$info_riff_raw['avih'] = array ();
    534. 

  534. 					$info_riff_raw_avih = &$info_riff_raw['avih'];
    535. 

  535. 

  536. 					getid3_lib::ReadSequence($this->endian_function, $info_riff_raw_avih, $avihData, 0,
    537. 

  537. 						array (
    538. 

  538. 							'dwMicroSecPerFrame'    => 4, // frame display rate (or 0L)
    539. 

  539. 							'dwMaxBytesPerSec'      => 4, // max. transfer rate
    540. 

  540. 							'dwPaddingGranularity'  => 4, // pad to multiples of this size; normally 2K.
    541. 

  541. 							'dwFlags'               => 4, // the ever-present flags
    542. 

  542. 							'dwTotalFrames'         => 4, // # frames in file
    543. 

  543. 							'dwInitialFrames'       => 4,
    544. 

  544. 							'dwStreams'             => 4,
    545. 

  545. 							'dwSuggestedBufferSize' => 4,
    546. 

  546. 							'dwWidth'               => 4,
    547. 

  547. 							'dwHeight'              => 4,
    548. 

  548. 							'dwScale'               => 4,
    549. 

  549. 							'dwRate'                => 4,
    550. 

  550. 							'dwStart'               => 4,
    551. 

  551. 							'dwLength'              => 4
    552. 

  552. 						)
    553. 

  553. 					);
    554. 

  554. 

  555. 					$info_riff_raw_avih['flags']['hasindex']     = (bool)($info_riff_raw_avih['dwFlags'] & 0x00000010);
    556. 

  556. 					$info_riff_raw_avih['flags']['mustuseindex'] = (bool)($info_riff_raw_avih['dwFlags'] & 0x00000020);
    557. 

  557. 					$info_riff_raw_avih['flags']['interleaved']  = (bool)($info_riff_raw_avih['dwFlags'] & 0x00000100);
    558. 

  558. 					$info_riff_raw_avih['flags']['trustcktype']  = (bool)($info_riff_raw_avih['dwFlags'] & 0x00000800);
    559. 

  559. 					$info_riff_raw_avih['flags']['capturedfile'] = (bool)($info_riff_raw_avih['dwFlags'] & 0x00010000);
    560. 

  560. 					$info_riff_raw_avih['flags']['copyrighted']  = (bool)($info_riff_raw_avih['dwFlags'] & 0x00020010);
    561. 

  561. 

  562. 					$info_riff_video[$stream_index] = array ();
    563. 

  563. 					$info_riff_video_current = &$info_riff_video[$stream_index];
    564. 

  564. 

  565. 					if ($info_riff_raw_avih['dwWidth'] > 0) {
    566. 

  566. 						$info_riff_video_current['frame_width'] = $info_riff_raw_avih['dwWidth'];
    567. 

  567. 						$info_video['resolution_x']             = $info_riff_video_current['frame_width'];
    568. 

  568. 					}
    569. 

  569. 

  570. 					if ($info_riff_raw_avih['dwHeight'] > 0) {
    571. 

  571. 						$info_riff_video_current['frame_height'] = $info_riff_raw_avih['dwHeight'];
    572. 

  572. 						$info_video['resolution_y']              = $info_riff_video_current['frame_height'];
    573. 

  573. 					}
    574. 

  574. 

  575. 					if ($info_riff_raw_avih['dwTotalFrames'] > 0) {
    576. 

  576. 						$info_riff_video_current['total_frames'] = $info_riff_raw_avih['dwTotalFrames'];
    577. 

  577. 						$info_video['total_frames']              = $info_riff_video_current['total_frames'];
    578. 

  578. 					}
    579. 

  579. 

  580. 					$info_riff_video_current['frame_rate'] = round(1000000 / $info_riff_raw_avih['dwMicroSecPerFrame'], 3);
    581. 

  581. 					$info_video['frame_rate'] = $info_riff_video_current['frame_rate'];
    582. 

  582. 				}
    583. 

  583. 

  584. 				if (isset($info_riff['AVI ']['hdrl']['strl']['strh'][0]['data'])) {
    585. 

  585. 					if (is_array($info_riff['AVI ']['hdrl']['strl']['strh'])) {
    586. 

  586. 						for ($i = 0; $i < count($info_riff['AVI ']['hdrl']['strl']['strh']); $i++) {
    587. 

  587. 							if (isset($info_riff['AVI ']['hdrl']['strl']['strh'][$i]['data'])) {
    588. 

  588. 								$strh_data = $info_riff['AVI ']['hdrl']['strl']['strh'][$i]['data'];
    589. 

  589. 								$strh_fcc_type = substr($strh_data,  0, 4);
    590. 

  590. 

  591. 								if (isset($info_riff['AVI ']['hdrl']['strl']['strf'][$i]['data'])) {
    592. 

  592. 									$strf_data = $info_riff['AVI ']['hdrl']['strl']['strf'][$i]['data'];
    593. 

  593. 

  594. 									// shortcut
    595. 

  595. 									$info_riff_raw_strf_strh_fcc_type_stream_index = &$info_riff_raw['strf'][$strh_fcc_type][$stream_index];
    596. 

  596. 

  597. 									switch ($strh_fcc_type) {
    598. 

  598. 										case 'auds':
    599. 

  599. 											$info_audio['bitrate_mode'] = 'cbr';
    600. 

  600. 											$info_audio_dataformat      = 'wav';
    601. 

  601. 											if (isset($info_riff_audio) && is_array($info_riff_audio)) {
    602. 

  602. 												$stream_index = count($info_riff_audio);
    603. 

  603. 											}
    604. 

  604. 

  605. 											$info_riff_audio[$stream_index] = getid3_riff::RIFFparseWAVEFORMATex($strf_data);
    606. 

  606. 											$info_audio['wformattag'] = $info_riff_audio[$stream_index]['raw']['wFormatTag'];
    607. 

  607. 

  608. 											// shortcut
    609. 

  609. 											$info_audio['streams'][$stream_index] = $info_riff_audio[$stream_index];
    610. 

  610. 											$info_audio_streams_currentstream = &$info_audio['streams'][$stream_index];
    611. 

  611. 

  612. 											if (@$info_audio_streams_currentstream['bits_per_sample'] === 0) {
    613. 

  613. 												unset($info_audio_streams_currentstream['bits_per_sample']);
    614. 

  614. 											}
    615. 

  615. 											$info_audio_streams_currentstream['wformattag'] = $info_audio_streams_currentstream['raw']['wFormatTag'];
    616. 

  616. 											unset($info_audio_streams_currentstream['raw']);
    617. 

  617. 

  618. 											// shortcut
    619. 

  619. 											$info_riff_raw['strf'][$strh_fcc_type][$stream_index] = $info_riff_audio[$stream_index]['raw'];
    620. 

  620. 

  621. 											unset($info_riff_audio[$stream_index]['raw']);
    622. 

  622. 											$info_audio = getid3_riff::array_merge_noclobber($info_audio, $info_riff_audio[$stream_index]);
    623. 

  623. 

  624. 											$info_audio['lossless'] = false;
    625. 

  625. 											switch ($info_riff_raw_strf_strh_fcc_type_stream_index['wFormatTag']) {
    626. 

  626. 

  627. 												case 0x0001:  // PCM
    628. 

  628. 													$info_audio_dataformat  = 'wav';
    629. 

  629. 													$info_audio['lossless'] = true;
    630. 

  630. 													break;
    631. 

  631. 

  632. 												case 0x0050: // MPEG Layer 2 or Layer 1
    633. 

  633. 													$info_audio_dataformat = 'mp2'; // Assume Layer-2
    634. 

  634. 													break;
    635. 

  635. 

  636. 												case 0x0055: // MPEG Layer 3
    637. 

  637. 													$info_audio_dataformat = 'mp3';
    638. 

  638. 													break;
    639. 

  639. 

  640. 												case 0x00FF: // AAC
    641. 

  641. 													$info_audio_dataformat = 'aac';
    642. 

  642. 													break;
    643. 

  643. 

  644. 												case 0x0161: // Windows Media v7 / v8 / v9
    645. 

  645. 												case 0x0162: // Windows Media Professional v9
    646. 

  646. 												case 0x0163: // Windows Media Lossess v9
    647. 

  647. 													$info_audio_dataformat = 'wma';
    648. 

  648. 													break;
    649. 

  649. 

  650. 												case 0x2000: // AC-3
    651. 

  651. 													$info_audio_dataformat = 'ac3';
    652. 

  652. 													break;
    653. 

  653. 

  654. 												case 0x2001: // DTS
    655. 

  655. 													$info_audio_dataformat = 'dts';
    656. 

  656. 													break;
    657. 

  657. 

  658. 												default:
    659. 

  659. 													$info_audio_dataformat = 'wav';
    660. 

  660. 													break;
    661. 

  661. 											}
    662. 

  662. 											$info_audio_streams_currentstream['dataformat']   = $info_audio_dataformat;
    663. 

  663. 											$info_audio_streams_currentstream['lossless']     = $info_audio['lossless'];
    664. 

  664. 											$info_audio_streams_currentstream['bitrate_mode'] = $info_audio['bitrate_mode'];
    665. 

  665. 											break;
    666. 

  666. 

  667. 

  668. 										case 'iavs':
    669. 

  669. 										case 'vids':
    670. 

  670. 											// shortcut
    671. 

  671. 											$info_riff_raw['strh'][$i]  = array ();
    672. 

  672. 											$info_riff_raw_strh_current = &$info_riff_raw['strh'][$i];
    673. 

  673. 

  674. 											getid3_lib::ReadSequence($this->endian_function, $info_riff_raw_strh_current, $strh_data, 0,
    675. 

  675. 												array (
    676. 

  676. 													'fccType'               => -4, // same as $strh_fcc_type;
    677. 

  677. 													'fccHandler'            => -4,
    678. 

  678. 													'dwFlags'               => 4, // Contains AVITF_* flags
    679. 

  679. 													'wPriority'             => 2,
    680. 

  680. 													'wLanguage'             => 2,
    681. 

  681. 													'dwInitialFrames'       => 4,
    682. 

  682. 													'dwScale'               => 4,
    683. 

  683. 													'dwRate'                => 4,
    684. 

  684. 													'dwStart'               => 4,
    685. 

  685. 													'dwLength'              => 4,
    686. 

  686. 													'dwSuggestedBufferSize' => 4,
    687. 

  687. 													'dwQuality'             => 4,
    688. 

  688. 													'dwSampleSize'          => 4,
    689. 

  689. 													'rcFrame'               => 4
    690. 

  690. 												)
    691. 

  691. 											);
    692. 

  692. 

  693. 											$info_riff_video_current['codec'] = getid3_riff::RIFFfourccLookup($info_riff_raw_strh_current['fccHandler']);
    694. 

  694. 											$info_video['fourcc']             = $info_riff_raw_strh_current['fccHandler'];
    695. 

  695. 

  696. 											if (!$info_riff_video_current['codec'] && isset($info_riff_raw_strf_strh_fcc_type_stream_index['fourcc']) && getid3_riff::RIFFfourccLookup($info_riff_raw_strf_strh_fcc_type_stream_index['fourcc'])) {
    697. 

  697. 												$info_riff_video_current['codec'] = getid3_riff::RIFFfourccLookup($info_riff_raw_strf_strh_fcc_type_stream_index['fourcc']);
    698. 

  698. 												$info_video['fourcc']             = $info_riff_raw_strf_strh_fcc_type_stream_index['fourcc'];
    699. 

  699. 											}
    700. 

  700. 

  701. 											$info_video['codec']              = $info_riff_video_current['codec'];
    702. 

  702. 											$info_video['pixel_aspect_ratio'] = (float)1;
    703. 

  703. 

  704. 											switch ($info_riff_raw_strh_current['fccHandler']) {
    705. 

  705. 

  706. 												case 'HFYU': // Huffman Lossless Codec
    707. 

  707. 												case 'IRAW': // Intel YUV Uncompressed
    708. 

  708. 												case 'YUY2': // Uncompressed YUV 4:2:2
    709. 

  709. 													$info_video['lossless'] = true;
    710. 

  710. 													break;
    711. 

  711. 

  712. 												default:
    713. 

  713. 													$info_video['lossless'] = false;
    714. 

  714. 													break;
    715. 

  715. 											}
    716. 

  716. 

  717. 											switch ($strh_fcc_type) {
    718. 

  718. 

  719. 												case 'vids':
    720. 

  720. 													getid3_lib::ReadSequence($this->endian_function, $info_riff_raw_strf_strh_fcc_type_stream_index, $strf_data, 0,
    721. 

  721. 														array (
    722. 

  722. 															'biSize'          => 4, // number of bytes required by the BITMAPINFOHEADER structure
    723. 

  723. 															'biWidth'         => 4, // width of the bitmap in pixels
    724. 

  724. 															'biHeight'        => 4, // height of the bitmap in pixels. If biHeight is positive, the bitmap is a 'bottom-up' DIB and its origin is the lower left corner. If biHeight is negative, the bitmap is a 'top-down' DIB and its origin is the upper left corner
    725. 

  725. 															'biPlanes'        => 2, // number of color planes on the target device. In most cases this value must be set to 1
    726. 

  726. 															'biBitCount'      => 2, // Specifies the number of bits per pixels
    727. 

  727. 															'fourcc'          => -4, //
    728. 

  728. 															'biSizeImage'     => 4, // size of the bitmap data section of the image (the actual pixel data, excluding BITMAPINFOHEADER and RGBQUAD structures)
    729. 

  729. 															'biXPelsPerMeter' => 4, // horizontal resolution, in pixels per metre, of the target device
    730. 

  730. 															'biYPelsPerMeter' => 4, // vertical resolution, in pixels per metre, of the target device
    731. 

  731. 															'biClrUsed'       => 4, // actual number of color indices in the color table used by the bitmap. If this value is zero, the bitmap uses the maximum number of colors corresponding to the value of the biBitCount member for the compression mode specified by biCompression
    732. 

  732. 															'biClrImportant'  => 4 // number of color indices that are considered important for displaying the bitmap. If this value is zero, all colors are important
    733. 

  733. 														)
    734. 

  734. 													);
    735. 

  735. 

  736. 													$info_video['bits_per_sample'] = $info_riff_raw_strf_strh_fcc_type_stream_index['biBitCount'];
    737. 

  737. 

  738. 													if ($info_riff_video_current['codec'] == 'DV') {
    739. 

  739. 														$info_riff_video_current['dv_type'] = 2;
    740. 

  740. 													}
    741. 

  741. 													break;
    742. 

  742. 

  743. 												case 'iavs':
    744. 

  744. 													$info_riff_video_current['dv_type'] = 1;
    745. 

  745. 													break;
    746. 

  746. 											}
    747. 

  747. 											break;
    748. 

  748. 

  749. 										default:
    750. 

  750. 											$getid3->warning('Unhandled fccType for stream ('.$i.'): "'.$strh_fcc_type.'"');
    751. 

  751. 											break;
    752. 

  752. 

  753. 									}
    754. 

  754. 								}
    755. 

  755. 							}
    756. 

  756. 

  757. 							if (isset($info_riff_raw_strf_strh_fcc_type_stream_index['fourcc']) && getid3_riff::RIFFfourccLookup($info_riff_raw_strf_strh_fcc_type_stream_index['fourcc'])) {
    758. 

  758. 

  759. 								$info_riff_video_current['codec'] = getid3_riff::RIFFfourccLookup($info_riff_raw_strf_strh_fcc_type_stream_index['fourcc']);
    760. 

  760. 								$info_video['codec']              = $info_riff_video_current['codec'];
    761. 

  761. 								$info_video['fourcc']             = $info_riff_raw_strf_strh_fcc_type_stream_index['fourcc'];
    762. 

  762. 

  763. 								switch ($info_riff_raw_strf_strh_fcc_type_stream_index['fourcc']) {
    764. 

  764. 

  765. 									case 'HFYU': // Huffman Lossless Codec
    766. 

  766. 									case 'IRAW': // Intel YUV Uncompressed
    767. 

  767. 									case 'YUY2': // Uncompressed YUV 4:2:2
    768. 

  768. 										$info_video['lossless']        = true;
    769. 

  769. 										$info_video['bits_per_sample'] = 24;
    770. 

  770. 										break;
    771. 

  771. 

  772. 									default:
    773. 

  773. 										$info_video['lossless']        = false;
    774. 

  774. 										$info_video['bits_per_sample'] = 24;
    775. 

  775. 										break;
    776. 

  776. 								}
    777. 

  777. 

  778. 							}
    779. 

  779. 						}
    780. 

  780. 					}
    781. 

  781. 				}
    782. 

  782. 				break;
    783. 

  783. 

  784. 

  785. 			case 'CDDA':
    786. 

  786. 				$info_audio['bitrate_mode'] = 'cbr';
    787. 

  787. 				$info_audio_dataformat      = 'cda';
    788. 

  788. 				$info_audio['lossless']     = true;
    789. 

  789. 				unset($getid3->info['mime_type']);
    790. 

  790. 

  791. 				$info_avdataoffset = 44;
    792. 

  792. 

  793. 				if (isset($info_riff['CDDA']['fmt '][0]['data'])) {
    794. 

  794. 

  795. 					$info_riff_cdda_fmt_0 = &$info_riff['CDDA']['fmt '][0];
    796. 

  796. 

  797. 					getid3_lib::ReadSequence($this->endian_function, $info_riff_cdda_fmt_0, $info_riff_cdda_fmt_0['data'], 0,
    798. 

  798. 						array (
    799. 

  799. 							'unknown1'           => 2,
    800. 

  800. 							'track_num'          => 2,
    801. 

  801. 							'disc_id'            => 4,
    802. 

  802. 							'start_offset_frame' => 4,
    803. 

  803. 							'playtime_frames'    => 4,
    804. 

  804. 							'unknown6'           => 4,
    805. 

  805. 							'unknown7'           => 4
    806. 

  806. 						)
    807. 

  807. 					);
    808. 

  808. 

  809. 					$info_riff_cdda_fmt_0['start_offset_seconds'] = (float)$info_riff_cdda_fmt_0['start_offset_frame'] / 75;
    810. 

  810. 					$info_riff_cdda_fmt_0['playtime_seconds']     = (float)$info_riff_cdda_fmt_0['playtime_frames'] / 75;
    811. 

  811. 					$getid3->info['comments']['track']            = $info_riff_cdda_fmt_0['track_num'];
    812. 

  812. 					$getid3->info['playtime_seconds']             = $info_riff_cdda_fmt_0['playtime_seconds'];
    813. 

  813. 

  814. 					// hardcoded data for CD-audio
    815. 

  815. 					$info_audio['sample_rate']     = 44100;
    816. 

  816. 					$info_audio['channels']        = 2;
    817. 

  817. 					$info_audio['bits_per_sample'] = 16;
    818. 

  818. 					$info_audio['bitrate']         = $info_audio['sample_rate'] * $info_audio['channels'] * $info_audio['bits_per_sample'];
    819. 

  819. 					$info_audio['bitrate_mode']    = 'cbr';
    820. 

  820. 				}
    821. 

  821. 				break;
    822. 

  822. 

  823. 

  824. 			case 'AIFF':
    825. 

  825. 			case 'AIFC':
    826. 

  826. 				$info_audio['bitrate_mode'] = 'cbr';
    827. 

  827. 				$info_audio_dataformat      = 'aiff';
    828. 

  828. 				$info_audio['lossless']     = true;
    829. 

  829. 				$getid3->info['mime_type']      = 'audio/x-aiff';
    830. 

  830. 

  831. 				if (isset($info_riff[$riff_sub_type]['SSND'][0]['offset'])) {
    832. 

  832. 					$info_avdataoffset = $info_riff[$riff_sub_type]['SSND'][0]['offset'] + 8;
    833. 

  833. 					$info_avdataend    = $info_avdataoffset + $info_riff[$riff_sub_type]['SSND'][0]['size'];
    834. 

  834. 					if ($info_avdataend > $getid3->info['filesize']) {
    835. 

  835. 						if (($info_avdataend == ($getid3->info['filesize'] + 1)) && (($getid3->info['filesize'] % 2) == 1)) {
    836. 

  836. 							// structures rounded to 2-byte boundary, but dumb encoders
    837. 

  837. 							// forget to pad end of file to make this actually work
    838. 

  838. 						} else {
    839. 

  839. 							$getid3->warning('Probable truncated AIFF file: expecting '.$info_riff[$riff_sub_type]['SSND'][0]['size'].' bytes of audio data, only '.($getid3->info['filesize'] - $info_avdataoffset).' bytes found');
    840. 

  840. 						}
    841. 

  841. 						$info_avdataend = $getid3->info['filesize'];
    842. 

  842. 					}
    843. 

  843. 				}
    844. 

  844. 

  845. 				if (isset($info_riff[$riff_sub_type]['COMM'][0]['data'])) {
    846. 

  846. 

  847. 					// shortcut
    848. 

  848. 					$info_riff_RIFFsubtype_COMM_0_data = &$info_riff[$riff_sub_type]['COMM'][0]['data'];
    849. 

  849. 

  850. 					$info_riff_audio['channels']         = getid3_lib::BigEndianSyncSafe2Int(substr($info_riff_RIFFsubtype_COMM_0_data,  0,  2));
    851. 

  851. 					$info_riff_audio['total_samples']    = getid3_lib::BigEndian2Int(        substr($info_riff_RIFFsubtype_COMM_0_data,  2,  4));
    852. 

  852. 					$info_riff_audio['bits_per_sample']  = getid3_lib::BigEndianSyncSafe2Int(substr($info_riff_RIFFsubtype_COMM_0_data,  6,  2));
    853. 

  853. 					$info_riff_audio['sample_rate']      = (int)getid3_riff::BigEndian2Float(substr($info_riff_RIFFsubtype_COMM_0_data,  8, 10));
    854. 

  854. 

  855. 					if ($info_riff[$riff_sub_type]['COMM'][0]['size'] > 18) {
    856. 

  856. 						$info_riff_audio['codec_fourcc'] =                           substr($info_riff_RIFFsubtype_COMM_0_data, 18,  4);
    857. 

  857. 						$codec_name_size                 = getid3_lib::BigEndian2Int(substr($info_riff_RIFFsubtype_COMM_0_data, 22,  1));
    858. 

  858. 						$info_riff_audio['codec_name']   =                           substr($info_riff_RIFFsubtype_COMM_0_data, 23,  $codec_name_size);
    859. 

  859. 

  860. 						switch ($info_riff_audio['codec_name']) {
    861. 

  861. 

  862. 							case 'NONE':
    863. 

  863. 								$info_audio['codec']    = 'Pulse Code Modulation (PCM)';
    864. 

  864. 								$info_audio['lossless'] = true;
    865. 

  865. 								break;
    866. 

  866. 

  867. 							case '':
    868. 

  868. 								switch ($info_riff_audio['codec_fourcc']) {
    869. 

  869. 

  870. 									// http://developer.apple.com/qa/snd/snd07.html
    871. 

  871. 									case 'sowt':
    872. 

  872. 										$info_riff_audio['codec_name'] = 'Two\'s Compliment Little-Endian PCM';
    873. 

  873. 										$info_audio['lossless'] = true;
    874. 

  874. 										break;
    875. 

  875. 

  876. 									case 'twos':
    877. 

  877. 										$info_riff_audio['codec_name'] = 'Two\'s Compliment Big-Endian PCM';
    878. 

  878. 										$info_audio['lossless'] = true;
    879. 

  879. 										break;
    880. 

  880. 

  881. 									default:
    882. 

  882. 										break;
    883. 

  883. 								}
    884. 

  884. 								break;
    885. 

  885. 

  886. 							default:
    887. 

  887. 								$info_audio['codec']    = $info_riff_audio['codec_name'];
    888. 

  888. 								$info_audio['lossless'] = false;
    889. 

  889. 								break;
    890. 

  890. 						}
    891. 

  891. 					}
    892. 

  892. 

  893. 					$info_audio['channels'] = $info_riff_audio['channels'];
    894. 

  894. 

  895. 					if ($info_riff_audio['bits_per_sample'] > 0) {
    896. 

  896. 						$info_audio['bits_per_sample'] = $info_riff_audio['bits_per_sample'];
    897. 

  897. 					}
    898. 

  898. 

  899. 					$info_audio['sample_rate']        = $info_riff_audio['sample_rate'];
    900. 

  900. 					$getid3->info['playtime_seconds'] = $info_riff_audio['total_samples'] / $info_audio['sample_rate'];
    901. 

  901. 				}
    902. 

  902. 

  903. 				if (isset($info_riff[$riff_sub_type]['COMT'])) {
    904. 

  904. 

  905. 					$comment_count = getid3_lib::BigEndian2Int(substr($info_riff[$riff_sub_type]['COMT'][0]['data'], 0, 2));
    906. 

  906. 					$offset = 2;
    907. 

  907. 

  908. 					for ($i = 0; $i < $comment_count; $i++) {
    909. 

  909. 

  910. 						$getid3->info['comments_raw'][$i]['timestamp'] = getid3_lib::BigEndian2Int(        substr($info_riff[$riff_sub_type]['COMT'][0]['data'], $offset, 4));
    911. 

  911. 						$offset += 4;
    912. 

  912. 

  913. 						$getid3->info['comments_raw'][$i]['marker_id'] = getid3_lib::BigEndianSyncSafe2Int(substr($info_riff[$riff_sub_type]['COMT'][0]['data'], $offset, 2));
    914. 

  914. 						$offset += 2;
    915. 

  915. 

  916. 						$comment_length                                = getid3_lib::BigEndian2Int(        substr($info_riff[$riff_sub_type]['COMT'][0]['data'], $offset, 2));
    917. 

  917. 						$offset += 2;
    918. 

  918. 

  919. 						$getid3->info['comments_raw'][$i]['comment']   =                                   substr($info_riff[$riff_sub_type]['COMT'][0]['data'], $offset, $comment_length);
    920. 

  920. 						$offset += $comment_length;
    921. 

  921. 

  922. 						$getid3->info['comments_raw'][$i]['timestamp_unix'] = getid3_riff::DateMac2Unix($getid3->info['comments_raw'][$i]['timestamp']);
    923. 

  923. 						$info_riff['comments']['comment'][] = $getid3->info['comments_raw'][$i]['comment'];
    924. 

  924. 					}
    925. 

  925. 				}
    926. 

  926. 

  927. 				foreach (array ('NAME'=>'title', 'author'=>'artist', '(c) '=>'copyright', 'ANNO'=>'comment') as $key => $value) {
    928. 

  928. 					if (isset($info_riff[$riff_sub_type][$key][0]['data'])) {
    929. 

  929. 						$info_riff['comments'][$value][] = $info_riff[$riff_sub_type][$key][0]['data'];
    930. 

  930. 					}
    931. 

  931. 				}
    932. 

  932. 				break;
    933. 

  933. 

  934. 

  935. 			case '8SVX':
    936. 

  936. 				$info_audio['bitrate_mode']    = 'cbr';
    937. 

  937. 				$info_audio_dataformat         = '8svx';
    938. 

  938. 				$info_audio['bits_per_sample'] = 8;
    939. 

  939. 				$info_audio['channels']        = 1; // overridden below, if need be
    940. 

  940. 				$getid3->info['mime_type']     = 'audio/x-aiff';
    941. 

  941. 

  942. 				if (isset($info_riff[$riff_sub_type]['BODY'][0]['offset'])) {
    943. 

  943. 					$info_avdataoffset = $info_riff[$riff_sub_type]['BODY'][0]['offset'] + 8;
    944. 

  944. 					$info_avdataend    = $info_avdataoffset + $info_riff[$riff_sub_type]['BODY'][0]['size'];
    945. 

  945. 					if ($info_avdataend > $getid3->info['filesize']) {
    946. 

  946. 						$getid3->warning('Probable truncated AIFF file: expecting '.$info_riff[$riff_sub_type]['BODY'][0]['size'].' bytes of audio data, only '.($getid3->info['filesize'] - $info_avdataoffset).' bytes found');
    947. 

  947. 					}
    948. 

  948. 				}
    949. 

  949. 

  950. 				if (isset($info_riff[$riff_sub_type]['VHDR'][0]['offset'])) {
    951. 

  951. 					// shortcut
    952. 

  952. 					$info_riff_riff_sub_type_vhdr_0 = &$info_riff[$riff_sub_type]['VHDR'][0];
    953. 

  953. 

  954. 					getid3_lib::ReadSequence('BigEndian2Int', $info_riff_riff_sub_type_vhdr_0, $info_riff_riff_sub_type_vhdr_0['data'], 0,
    955. 

  955. 						array (
    956. 

  956. 							'oneShotHiSamples'  => 4,
    957. 

  957. 							'repeatHiSamples'   => 4,
    958. 

  958. 							'samplesPerHiCycle' => 4,
    959. 

  959. 							'samplesPerSec'     => 2,
    960. 

  960. 							'ctOctave'          => 1,
    961. 

  961. 							'sCompression'      => 1,
    962. 

  962. 							'Volume'            => -4
    963. 

  963. 						)
    964. 

  964. 					);
    965. 

  965. 

  966. 					$info_riff_riff_sub_type_vhdr_0['Volume'] = getid3_riff::FixedPoint16_16($info_riff_riff_sub_type_vhdr_0['Volume']);
    967. 

  967. 

  968. 					$info_audio['sample_rate'] = $info_riff_riff_sub_type_vhdr_0['samplesPerSec'];
    969. 

  969. 

  970. 					switch ($info_riff_riff_sub_type_vhdr_0['sCompression']) {
    971. 

  971. 						case 0:
    972. 

  972. 							$info_audio['codec']    = 'Pulse Code Modulation (PCM)';
    973. 

  973. 							$info_audio['lossless'] = true;
    974. 

  974. 							$actual_bits_per_sample = 8;
    975. 

  975. 							break;
    976. 

  976. 

  977. 						case 1:
    978. 

  978. 							$info_audio['codec']    = 'Fibonacci-delta encoding';
    979. 

  979. 							$info_audio['lossless'] = false;
    980. 

  980. 							$actual_bits_per_sample = 4;
    981. 

  981. 							break;
    982. 

  982. 

  983. 						default:
    984. 

  984. 							$getid3->warning('Unexpected sCompression value in 8SVX.VHDR chunk - expecting 0 or 1, found "'.sCompression.'"');
    985. 

  985. 							break;
    986. 

  986. 					}
    987. 

  987. 				}
    988. 

  988. 

  989. 				if (isset($info_riff[$riff_sub_type]['CHAN'][0]['data'])) {
    990. 

  990. 					$ChannelsIndex = getid3_lib::BigEndian2Int(substr($info_riff[$riff_sub_type]['CHAN'][0]['data'], 0, 4));
    991. 

  991. 					switch ($ChannelsIndex) {
    992. 

  992. 						case 6: // Stereo
    993. 

  993. 							$info_audio['channels'] = 2;
    994. 

  994. 							break;
    995. 

  995. 

  996. 						case 2: // Left channel only
    997. 

  997. 						case 4: // Right channel only
    998. 

  998. 							$info_audio['channels'] = 1;
    999. 

  999. 							break;
    1000. 

  1000. 

  1001. 						default:
    1002. 

  1002. 							$getid3->warning('Unexpected value in 8SVX.CHAN chunk - expecting 2 or 4 or 6, found "'.$ChannelsIndex.'"');
    1003. 

  1003. 							break;
    1004. 

  1004. 					}
    1005. 

  1005. 

  1006. 				}
    1007. 

  1007. 

  1008. 				foreach (array ('NAME'=>'title', 'author'=>'artist', '(c) '=>'copyright', 'ANNO'=>'comment') as $key => $value) {
    1009. 

  1009. 					if (isset($info_riff[$riff_sub_type][$key][0]['data'])) {
    1010. 

  1010. 						$info_riff['comments'][$value][] = $info_riff[$riff_sub_type][$key][0]['data'];
    1011. 

  1011. 					}
    1012. 

  1012. 				}
    1013. 

  1013. 

  1014. 				$info_audio['bitrate'] = $info_audio['sample_rate'] * $actual_bits_per_sample * $info_audio['channels'];
    1015. 

  1015. 				if (!empty($info_audio['bitrate'])) {
    1016. 

  1016. 					$getid3->info['playtime_seconds'] = ($info_avdataend - $info_avdataoffset) / ($info_audio['bitrate'] / 8);
    1017. 

  1017. 				}
    1018. 

  1018. 				break;
    1019. 

  1019. 

  1020. 

  1021. 			case 'CDXA':
    1022. 

  1022. 

  1023. 				$getid3->info['mime_type'] = 'video/mpeg';
    1024. 

  1024. 				if (!empty($info_riff['CDXA']['data'][0]['size'])) {
    1025. 

  1025. 					$GETID3_ERRORARRAY = &$getid3->info['warning'];
    1026. 

  1026. 

  1027. 					if (!$getid3->include_module_optional('audio-video.mpeg')) {
    1028. 

  1028. 						$getid3->warning('MPEG skipped because mpeg module is missing.');
    1029. 

  1029. 					}
    1030. 

  1030. 

  1031. 					else {
    1032. 

  1032. 

  1033. 						// Clone getid3 - messing with offsets - better safe than sorry
    1034. 

  1034. 						$clone = clone $getid3;
    1035. 

  1035. 

  1036. 						// Analyse
    1037. 

  1037. 						$mpeg = new getid3_mpeg($clone);
    1038. 

  1038. 						$mpeg->Analyze();
    1039. 

  1039. 

  1040. 						// Import from clone and destroy
    1041. 

  1041. 						$getid3->info['audio']   = $clone->info['audio'];
    1042. 

  1042. 						$getid3->info['video']   = $clone->info['video'];
    1043. 

  1043. 						$getid3->info['mpeg']    = $clone->info['mpeg'];
    1044. 

  1044. 						$getid3->info['warning'] = $clone->info['warning'];
    1045. 

  1045. 

  1046. 						unset($clone);
    1047. 

  1047. 					}
    1048. 

  1048. 				}
    1049. 

  1049. 

  1050. 				break;
    1051. 

  1051. 

  1052. 

  1053. 			default:
    1054. 

  1054. 				throw new getid3_exception('Unknown RIFF type: expecting one of (WAVE|RMP3|AVI |CDDA|AIFF|AIFC|8SVX|CDXA), found "'.$riff_sub_type.'" instead');
    1055. 

  1055. 		}
    1056. 

  1056. 

  1057. 

  1058. 		if (@$info_riff_raw['fmt ']['wFormatTag'] == 1) {
    1059. 

  1059. 

  1060. 			// http://www.mega-nerd.com/erikd/Blog/Windiots/dts.html
    1061. 

  1061. 			$this->fseek($getid3->info['avdataoffset'], SEEK_SET);
    1062. 

  1062. 			$bytes4 = $this->fread(4);
    1063. 

  1063. 

  1064. 			// DTSWAV
    1065. 

  1065. 			if (preg_match('/^\xFF\x1F\x00\xE8/s', $bytes4)) {
    1066. 

  1066. 				$info_audio_dataformat = 'dts';
    1067. 

  1067. 			}
    1068. 

  1068. 

  1069. 			// DTS, but this probably shouldn't happen
    1070. 

  1070. 			elseif (preg_match('/^\x7F\xFF\x80\x01/s', $bytes4)) {
    1071. 

  1071. 				$info_audio_dataformat = 'dts';
    1072. 

  1072. 			}
    1073. 

  1073. 		}
    1074. 

  1074. 

  1075. 		if (@is_array($info_riff_wave['DISP'])) {
    1076. 

  1076. 			$info_riff['comments']['title'][] = trim(substr($info_riff_wave['DISP'][count($info_riff_wave['DISP']) - 1]['data'], 4));
    1077. 

  1077. 		}
    1078. 

  1078. 

  1079. 		if (@is_array($info_riff_wave['INFO'])) {
    1080. 

  1080. 			getid3_riff::RIFFCommentsParse($info_riff_wave['INFO'], $info_riff['comments']);
    1081. 

  1081. 		}
    1082. 

  1082. 

  1083. 		if (isset($info_riff_wave['INFO']) && is_array($info_riff_wave['INFO'])) {
    1084. 

  1084. 

  1085. 			foreach (array ('IARL' => 'archivallocation', 'IART' => 'artist', 'ICDS' => 'costumedesigner', 'ICMS' => 'commissionedby', 'ICMT' => 'comment', 'ICNT' => 'country', 'ICOP' => 'copyright', 'ICRD' => 'creationdate', 'IDIM' => 'dimensions', 'IDIT' => 'digitizationdate', 'IDPI' => 'resolution', 'IDST' => 'distributor', 'IEDT' => 'editor', 'IENG' => 'engineers', 'IFRM' => 'accountofparts', 'IGNR' => 'genre', 'IKEY' => 'keywords', 'ILGT' => 'lightness', 'ILNG' => 'language', 'IMED' => 'orignalmedium', 'IMUS' => 'composer', 'INAM' => 'title', 'IPDS' => 'productiondesigner', 'IPLT' => 'palette', 'IPRD' => 'product', 'IPRO' => 'producer', 'IPRT' => 'part', 'IRTD' => 'rating', 'ISBJ' => 'subject', 'ISFT' => 'software', 'ISGN' => 'secondarygenre', 'ISHP' => 'sharpness', 'ISRC' => 'sourcesupplier', 'ISRF' => 'digitizationsource', 'ISTD' => 'productionstudio', 'ISTR' => 'starring', 'ITCH' => 'encoded_by', 'IWEB' => 'url', 'IWRI' => 'writer') as $key => $value) {
    1086. 

  1086. 				if (isset($info_riff_wave['INFO'][$key])) {
    1087. 

  1087. 					foreach ($info_riff_wave['INFO'][$key] as $comment_id => $comment_data) {
    1088. 

  1088. 						if (trim($comment_data['data']) != '') {
    1089. 

  1089. 							$info_riff['comments'][$value][] = trim($comment_data['data']);
    1090. 

  1090. 						}
    1091. 

  1091. 					}
    1092. 

  1092. 				}
    1093. 

  1093. 			}
    1094. 

  1094. 		}
    1095. 

  1095. 

  1096. 		if (empty($info_audio['encoder']) && !empty($getid3->info['mpeg']['audio']['LAME']['short_version'])) {
    1097. 

  1097. 			$info_audio['encoder'] = $getid3->info['mpeg']['audio']['LAME']['short_version'];
    1098. 

  1098. 		}
    1099. 

  1099. 

  1100. 		if (!isset($getid3->info['playtime_seconds'])) {
    1101. 

  1101. 			$getid3->info['playtime_seconds'] = 0;
    1102. 

  1102. 		}
    1103. 

  1103. 

  1104. 		if (isset($info_riff_raw['avih']['dwTotalFrames']) && isset($info_riff_raw['avih']['dwMicroSecPerFrame'])) {
    1105. 

  1105. 			$getid3->info['playtime_seconds'] = $info_riff_raw['avih']['dwTotalFrames'] * ($info_riff_raw['avih']['dwMicroSecPerFrame'] / 1000000);
    1106. 

  1106. 		}
    1107. 

  1107. 

  1108. 		if ($getid3->info['playtime_seconds'] > 0) {
    1109. 

  1109. 			if (isset($info_riff_audio) && isset($info_riff_video)) {
    1110. 

  1110. 

  1111. 				if (!isset($getid3->info['bitrate'])) {
    1112. 

  1112. 					$getid3->info['bitrate'] = ((($info_avdataend - $info_avdataoffset) / $getid3->info['playtime_seconds']) * 8);
    1113. 

  1113. 				}
    1114. 

  1114. 

  1115. 			} elseif (isset($info_riff_audio) && !isset($info_riff_video)) {
    1116. 

  1116. 

  1117. 				if (!isset($info_audio['bitrate'])) {
    1118. 

  1118. 					$info_audio['bitrate'] = ((($info_avdataend - $info_avdataoffset) / $getid3->info['playtime_seconds']) * 8);
    1119. 

  1119. 				}
    1120. 

  1120. 

  1121. 			} elseif (!isset($info_riff_audio) && isset($info_riff_video)) {
    1122. 

  1122. 

  1123. 				if (!isset($info_video['bitrate'])) {
    1124. 

  1124. 					$info_video['bitrate'] = ((($info_avdataend - $info_avdataoffset) / $getid3->info['playtime_seconds']) * 8);
    1125. 

  1125. 				}
    1126. 

  1126. 

  1127. 			}
    1128. 

  1128. 		}
    1129. 

  1129. 

  1130. 

  1131. 		if (isset($info_riff_video) && isset($info_audio['bitrate']) && ($info_audio['bitrate'] > 0) && ($getid3->info['playtime_seconds'] > 0)) {
    1132. 

  1132. 

  1133. 			$getid3->info['bitrate'] = ((($info_avdataend - $info_avdataoffset) / $getid3->info['playtime_seconds']) * 8);
    1134. 

  1134. 			$info_audio['bitrate'] = 0;
    1135. 

  1135. 			$info_video['bitrate'] = $getid3->info['bitrate'];
    1136. 

  1136. 			foreach ($info_riff_audio as $channelnumber => $audioinfoarray) {
    1137. 

  1137. 				$info_video['bitrate'] -= $audioinfoarray['bitrate'];
    1138. 

  1138. 				$info_audio['bitrate'] += $audioinfoarray['bitrate'];
    1139. 

  1139. 			}
    1140. 

  1140. 			if ($info_video['bitrate'] <= 0) {
    1141. 

  1141. 				unset($info_video['bitrate']);
    1142. 

  1142. 			}
    1143. 

  1143. 			if ($info_audio['bitrate'] <= 0) {
    1144. 

  1144. 				unset($info_audio['bitrate']);
    1145. 

  1145. 			}
    1146. 

  1146. 		}
    1147. 

  1147. 

  1148. 		if (isset($getid3->info['mpeg']['audio'])) {
    1149. 

  1149. 			$info_audio_dataformat      = 'mp'.$getid3->info['mpeg']['audio']['layer'];
    1150. 

  1150. 			$info_audio['sample_rate']  = $getid3->info['mpeg']['audio']['sample_rate'];
    1151. 

  1151. 			$info_audio['channels']     = $getid3->info['mpeg']['audio']['channels'];
    1152. 

  1152. 			$info_audio['bitrate']      = $getid3->info['mpeg']['audio']['bitrate'];
    1153. 

  1153. 			$info_audio['bitrate_mode'] = strtolower($getid3->info['mpeg']['audio']['bitrate_mode']);
    1154. 

  1154. 

  1155. 			if (!empty($getid3->info['mpeg']['audio']['codec'])) {
    1156. 

  1156. 				$info_audio['codec'] = $getid3->info['mpeg']['audio']['codec'].' '.$info_audio['codec'];
    1157. 

  1157. 			}
    1158. 

  1158. 

  1159. 			if (!empty($info_audio['streams'])) {
    1160. 

  1160. 				foreach ($info_audio['streams'] as $streamnumber => $streamdata) {
    1161. 

  1161. 					if ($streamdata['dataformat'] == $info_audio_dataformat) {
    1162. 

  1162. 						$info_audio['streams'][$streamnumber]['sample_rate']  = $info_audio['sample_rate'];
    1163. 

  1163. 						$info_audio['streams'][$streamnumber]['channels']     = $info_audio['channels'];
    1164. 

  1164. 						$info_audio['streams'][$streamnumber]['bitrate']      = $info_audio['bitrate'];
    1165. 

  1165. 						$info_audio['streams'][$streamnumber]['bitrate_mode'] = $info_audio['bitrate_mode'];
    1166. 

  1166. 						$info_audio['streams'][$streamnumber]['codec']        = $info_audio['codec'];
    1167. 

  1167. 					}
    1168. 

  1168. 				}
    1169. 

  1169. 			}
    1170. 

  1170. 			$info_audio['encoder_options'] = getid3_mp3::GuessEncoderOptions($getid3->info);
    1171. 

  1171. 		}
    1172. 

  1172. 

  1173. 

  1174. 		if (!empty($info_riff_raw['fmt ']['wBitsPerSample']) && ($info_riff_raw['fmt ']['wBitsPerSample'] > 0)) {
    1175. 

  1175. 			switch ($info_audio_dataformat) {
    1176. 

  1176. 				case 'ac3':
    1177. 

  1177. 					// ignore bits_per_sample
    1178. 

  1178. 					break;
    1179. 

  1179. 

  1180. 				default:
    1181. 

  1181. 					$info_audio['bits_per_sample'] = $info_riff_raw['fmt ']['wBitsPerSample'];
    1182. 

  1182. 					break;
    1183. 

  1183. 			}
    1184. 

  1184. 		}
    1185. 

  1185. 

  1186. 

  1187. 		if (empty($info_riff_raw)) {
    1188. 

  1188. 			unset($info_riff['raw']);
    1189. 

  1189. 		}
    1190. 

  1190. 		if (empty($info_riff_audio)) {
    1191. 

  1191. 			unset($info_riff['audio']);
    1192. 

  1192. 		}
    1193. 

  1193. 		if (empty($info_riff_video)) {
    1194. 

  1194. 			unset($info_riff['video']);
    1195. 

  1195. 		}
    1196. 

  1196. 		if (empty($info_audio_dataformat)) {
    1197. 

  1197. 			unset($info_audio['dataformat']);
    1198. 

  1198. 		}
    1199. 

  1199. 		if (empty($getid3->info['audio'])) {
    1200. 

  1200. 			unset($getid3->info['audio']);
    1201. 

  1201. 		}
    1202. 

  1202. 		if (empty($info_video)) {
    1203. 

  1203. 			unset($getid3->info['video']);
    1204. 

  1204. 		}
    1205. 

  1205. 

  1206. 		return true;
    1207. 

  1207. 	}
    1208. 

  1208. 

  1209. 

  1210. 

  1211. 	public function ParseRIFF($start_offset, $max_offset) {
    1212. 

  1212. 

  1213. 		$getid3 = $this->getid3;
    1214. 

  1214. 

  1215. 		$info   = &$getid3->info;
    1216. 

  1216. 

  1217. 		$endian_function = $this->endian_function;
    1218. 

  1218. 

  1219. 		$max_offset = min($max_offset, $info['avdataend']);
    1220. 

  1220. 

  1221. 		$riff_chunk = false;
    1222. 

  1222. 

  1223. 		$this->fseek($start_offset, SEEK_SET);
    1224. 

  1224. 

  1225. 		while ($this->ftell() < $max_offset) {
    1226. 

  1226. 

  1227. 			$chunk_name = $this->fread(4);
    1228. 

  1228. 

  1229. 			if (strlen($chunk_name) < 4) {
    1230. 

  1230. 				throw new getid3_exception('Expecting chunk name at offset '.($this->ftell() - 4).' but found nothing. Aborting RIFF parsing.');
    1231. 

  1231. 			}
    1232. 

  1232. 

  1233. 			$chunk_size = getid3_lib::$endian_function($this->fread(4));
    1234. 

  1234. 

  1235. 			if ($chunk_size == 0) {
    1236. 

  1236. 				continue;
    1237. 

  1237. 				throw new getid3_exception('Chunk size at offset '.($this->ftell() - 4).' is zero. Aborting RIFF parsing.');
    1238. 

  1238. 			}
    1239. 

  1239. 

  1240. 			if (($chunk_size % 2) != 0) {
    1241. 

  1241. 				// all structures are packed on word boundaries
    1242. 

  1242. 				$chunk_size++;
    1243. 

  1243. 			}
    1244. 

  1244. 

  1245. 			switch ($chunk_name) {
    1246. 

  1246. 

  1247. 				case 'LIST':
    1248. 

  1248. 					$list_name = $this->fread(4);
    1249. 

  1249. 

  1250. 					switch ($list_name) {
    1251. 

  1251. 

  1252. 						case 'movi':
    1253. 

  1253. 						case 'rec ':
    1254. 

  1254. 							$riff_chunk[$list_name]['offset'] = $this->ftell() - 4;
    1255. 

  1255. 							$riff_chunk[$list_name]['size']   = $chunk_size;
    1256. 

  1256. 

  1257. 							static $parsed_audio_stream = false;
    1258. 

  1258. 

  1259. 							if (!$parsed_audio_stream) {
    1260. 

  1260. 								$where_we_were = $this->ftell();
    1261. 

  1261. 								$audio_chunk_header = $this->fread(12);
    1262. 

  1262. 								$audio_chunk_stream_num  =                             substr($audio_chunk_header, 0, 2);
    1263. 

  1263. 								$audio_chunk_stream_type =                             substr($audio_chunk_header, 2, 2);
    1264. 

  1264. 								$audio_chunk_size       = getid3_lib::LittleEndian2Int(substr($audio_chunk_header, 4, 4));
    1265. 

  1265. 

  1266. 								if ($audio_chunk_stream_type == 'wb') {
    1267. 

  1267. 									$first_four_bytes = substr($audio_chunk_header, 8, 4);
    1268. 

  1268. 

  1269. 

  1270. 									//// MPEG
    1271. 

  1271. 

  1272. 									if (preg_match('/^\xFF[\xE2-\xE7\xF2-\xF7\xFA-\xFF][\x00-\xEB]/s', $first_four_bytes)) {
    1273. 

  1273. 

  1274. 										if (!$getid3->include_module_optional('audio.mp3')) {
    1275. 

  1275. 											$getid3->warning('MP3 skipped because mp3 module is missing.');
    1276. 

  1276. 										}
    1277. 

  1277. 

  1278. 										elseif (getid3_mp3::MPEGaudioHeaderBytesValid($first_four_bytes)) {
    1279. 

  1279. 

  1280. 											// Clone getid3 - messing with offsets - better safe than sorry
    1281. 

  1281. 											$clone = clone $getid3;
    1282. 

  1282. 											$clone->info['avdataoffset'] = $this->ftell() - 4;
    1283. 

  1283. 											$clone->info['avdataend']    = $this->ftell() + $audio_chunk_size;
    1284. 

  1284. 

  1285. 											$mp3 = new getid3_mp3($clone);
    1286. 

  1286. 											$mp3->AnalyzeMPEGaudioInfo();
    1287. 

  1287. 

  1288. 											// Import from clone and destroy
    1289. 

  1289. 											if (isset($clone->info['mpeg']['audio'])) {
    1290. 

  1290. 

  1291. 												$info['mpeg']['audio'] = $clone->info['mpeg']['audio'];
    1292. 

  1292. 

  1293. 												$info['audio']['dataformat']   = 'mp'.$info['mpeg']['audio']['layer'];
    1294. 

  1294. 												$info['audio']['sample_rate']  = $info['mpeg']['audio']['sample_rate'];
    1295. 

  1295. 												$info['audio']['channels']     = $info['mpeg']['audio']['channels'];
    1296. 

  1296. 												$info['audio']['bitrate']      = $info['mpeg']['audio']['bitrate'];
    1297. 

  1297. 												$info['audio']['bitrate_mode'] = strtolower($info['mpeg']['audio']['bitrate_mode']);
    1298. 

  1298. 												$info['bitrate']               = $info['audio']['bitrate'];
    1299. 

  1299. 

  1300. 												$getid3->warning($clone->warnings());
    1301. 

  1301. 												unset($clone);
    1302. 

  1302. 											}
    1303. 

  1303. 										}
    1304. 

  1304. 									}
    1305. 

  1305. 

  1306. 									//// AC3-WAVE
    1307. 

  1307. 

  1308. 									elseif (preg_match('/^\x0B\x77/s', $first_four_bytes)) {
    1309. 

  1309. 

  1310. 										if (!$getid3->include_module_optional('audio.ac3')) {
    1311. 

  1311. 											$getid3->warning('AC3 skipped because ac3 module is missing.');
    1312. 

  1312. 										}
    1313. 

  1313. 

  1314. 										else {
    1315. 

  1315. 

  1316. 											// Clone getid3 - messing with offsets - better safe than sorry
    1317. 

  1317. 											$clone = clone $getid3;
    1318. 

  1318. 											$clone->info['avdataoffset'] = $this->ftell() - 4;
    1319. 

  1319. 											$clone->info['avdataend']    = $this->ftell() + $audio_chunk_size;
    1320. 

  1320. 

  1321. 											// Analyze clone by fp
    1322. 

  1322. 											$ac3 = new getid3_ac3($clone);
    1323. 

  1323. 											$ac3->Analyze();
    1324. 

  1324. 

  1325. 											// Import from clone and destroy
    1326. 

  1326. 											$info['audio'] = $clone->info['audio'];
    1327. 

  1327. 											$info['ac3']   = $clone->info['ac3'];
    1328. 

  1328. 											$getid3->warning($clone->warnings());
    1329. 

  1329. 											unset($clone);
    1330. 

  1330. 										}
    1331. 

  1331. 									}
    1332. 

  1332. 								}
    1333. 

  1333. 

  1334. 								$parsed_audio_stream = true;
    1335. 

  1335. 								$this->fseek($where_we_were, SEEK_SET);
    1336. 

  1336. 

  1337. 							}
    1338. 

  1338. 							$this->fseek($chunk_size - 4, SEEK_CUR);
    1339. 

  1339. 							break;
    1340. 

  1340. 

  1341. 						default:
    1342. 

  1342. 							if (!isset($riff_chunk[$list_name])) {
    1343. 

  1343. 								$riff_chunk[$list_name] = array ();
    1344. 

  1344. 							}
    1345. 

  1345. 							$list_chunk_parent    = $list_name;
    1346. 

  1346. 							$list_chunk_max_offset = $this->ftell() - 4 + $chunk_size;
    1347. 

  1347. 							if ($parsed_chunk = $this->ParseRIFF($this->ftell(), $this->ftell() + $chunk_size - 4)) {
    1348. 

  1348. 								$riff_chunk[$list_name] = array_merge_recursive($riff_chunk[$list_name], $parsed_chunk);
    1349. 

  1349. 							}
    1350. 

  1350. 							break;
    1351. 

  1351. 					}
    1352. 

  1352. 					break;
    1353. 

  1353. 

  1354. 

  1355. 				default:
    1356. 

  1356. 

  1357. 					$this_index = 0;
    1358. 

  1358. 					if (isset($riff_chunk[$chunk_name]) && is_array($riff_chunk[$chunk_name])) {
    1359. 

  1359. 						$this_index = count($riff_chunk[$chunk_name]);
    1360. 

  1360. 					}
    1361. 

  1361. 					$riff_chunk[$chunk_name][$this_index]['offset'] = $this->ftell() - 8;
    1362. 

  1362. 					$riff_chunk[$chunk_name][$this_index]['size']   = $chunk_size;
    1363. 

  1363. 					switch ($chunk_name) {
    1364. 

  1364. 						case 'data':
    1365. 

  1365. 							$info['avdataoffset'] = $this->ftell();
    1366. 

  1366. 							$info['avdataend']    = $info['avdataoffset'] + $chunk_size;
    1367. 

  1367. 

  1368. 							$riff_data_chunk_contents_test = $this->fread(36);
    1369. 

  1369. 

  1370. 

  1371. 							//// This is probably MP3 data
    1372. 

  1372. 

  1373. 							if ((strlen($riff_data_chunk_contents_test) > 0) && preg_match('/^\xFF[\xE2-\xE7\xF2-\xF7\xFA-\xFF][\x00-\xEB]/s', substr($riff_data_chunk_contents_test, 0, 4))) {
    1374. 

  1374. 

  1375. 								try {
    1376. 

  1376. 

  1377. 									if (!$getid3->include_module_optional('audio.mp3')) {
    1378. 

  1378. 										$getid3->warning('MP3 skipped because mp3 module is missing.');
    1379. 

  1379. 									}
    1380. 

  1380. 

  1381. 

  1382. 									// Clone getid3 - messing with offsets - better safe than sorry
    1383. 

  1383. 									$clone = clone $getid3;
    1384. 

  1384. 

  1385. 									if (getid3_mp3::MPEGaudioHeaderBytesValid(substr($riff_data_chunk_contents_test, 0, 4))) {
    1386. 

  1386. 

  1387. 										$mp3 = new getid3_mp3($clone);
    1388. 

  1388. 										$mp3->AnalyzeMPEGaudioInfo();
    1389. 

  1389. 

  1390. 										// Import from clone and destroy
    1391. 

  1391. 										if (isset($clone->info['mpeg']['audio'])) {
    1392. 

  1392. 

  1393. 											$info['mpeg']['audio'] = $clone->info['mpeg']['audio'];
    1394. 

  1394. 

  1395. 											$info['audio']['sample_rate']  = $info['mpeg']['audio']['sample_rate'];
    1396. 

  1396. 											$info['audio']['channels']     = $info['mpeg']['audio']['channels'];
    1397. 

  1397. 											$info['audio']['bitrate']      = $info['mpeg']['audio']['bitrate'];
    1398. 

  1398. 											$info['audio']['bitrate_mode'] = strtolower($info['mpeg']['audio']['bitrate_mode']);
    1399. 

  1399. 											$info['bitrate']               = $info['audio']['bitrate'];
    1400. 

  1400. 

  1401. 											$getid3->warning($clone->warnings());
    1402. 

  1402. 											unset($clone);
    1403. 

  1403. 										}
    1404. 

  1404. 									}
    1405. 

  1405. 								}
    1406. 

  1406. 								catch (Exception $e) {
    1407. 

  1407. 									// do nothing - not MP3 data
    1408. 

  1408. 								}
    1409. 

  1409. 							}
    1410. 

  1410. 

  1411. 

  1412. 							//// This is probably AC-3 data
    1413. 

  1413. 

  1414. 							elseif ((strlen($riff_data_chunk_contents_test) > 0) && (substr($riff_data_chunk_contents_test, 0, 2) == "\x0B\x77")) {
    1415. 

  1415. 

  1416. 								if (!$getid3->include_module_optional('audio.ac3')) {
    1417. 

  1417. 									$getid3->warning('AC3 skipped because ac3 module is missing.');
    1418. 

  1418. 								}
    1419. 

  1419. 

  1420. 								else {
    1421. 

  1421. 

  1422. 									// Clone getid3 - messing with offsets - better safe than sorry
    1423. 

  1423. 									$clone = clone $getid3;
    1424. 

  1424. 									$clone->info['avdataoffset'] = $riff_chunk[$chunk_name][$this_index]['offset'];
    1425. 

  1425. 									$clone->info['avdataend']    = $clone->info['avdataoffset'] + $riff_chunk[$chunk_name][$this_index]['size'];
    1426. 

  1426. 

  1427. 									// Analyze clone by fp
    1428. 

  1428. 									$ac3 = new getid3_ac3($clone);
    1429. 

  1429. 									$ac3->Analyze();
    1430. 

  1430. 

  1431. 									// Import from clone and destroy
    1432. 

  1432. 									$info['audio'] = $clone->info['audio'];
    1433. 

  1433. 									$info['ac3']   = $clone->info['ac3'];
    1434. 

  1434. 									$getid3->warning($clone->warnings());
    1435. 

  1435. 									unset($clone);
    1436. 

  1436. 								}
    1437. 

  1437. 							}
    1438. 

  1438. 

  1439. 

  1440. 							// Dolby Digital WAV
    1441. 

  1441. 							// AC-3 content, but not encoded in same format as normal AC-3 file
    1442. 

  1442. 							// For one thing, byte order is swapped
    1443. 

  1443. 

  1444. 							elseif ((strlen($riff_data_chunk_contents_test) > 0) && (substr($riff_data_chunk_contents_test, 8, 2) == "\x77\x0B")) {
    1445. 

  1445. 

  1446. 								if (!$getid3->include_module_optional('audio.ac3')) {
    1447. 

  1447. 									$getid3->warning('AC3 skipped because ac3 module is missing.');
    1448. 

  1448. 								}
    1449. 

  1449. 

  1450. 								else {
    1451. 

  1451. 

  1452. 									// Extract ac3 data to string
    1453. 

  1453. 									$ac3_data = '';
    1454. 

  1454. 									for ($i = 0; $i < 28; $i += 2) {
    1455. 

  1455. 										// swap byte order
    1456. 

  1456. 										$ac3_data .= substr($riff_data_chunk_contents_test, 8 + $i + 1, 1);
    1457. 

  1457. 										$ac3_data .= substr($riff_data_chunk_contents_test, 8 + $i + 0, 1);
    1458. 

  1458. 									}
    1459. 

  1459. 

  1460. 									// Clone getid3 - messing with offsets - better safe than sorry
    1461. 

  1461. 									$clone = clone $getid3;
    1462. 

  1462. 									$clone->info['avdataoffset'] = 0;
    1463. 

  1463. 									$clone->info['avdataend']    = 20;
    1464. 

  1464. 

  1465. 									// Analyse clone by string
    1466. 

  1466. 									$ac3 = new getid3_ac3($clone);
    1467. 

  1467. 									$ac3->AnalyzeString($ac3_data);
    1468. 

  1468. 

  1469. 									// Import from clone and destroy
    1470. 

  1470. 									$info['audio'] = $clone->info['audio'];
    1471. 

  1471. 									$info['ac3']   = $clone->info['ac3'];
    1472. 

  1472. 									$getid3->warning($clone->warnings());
    1473. 

  1473. 									unset($clone);
    1474. 

  1474. 								}
    1475. 

  1475. 							}
    1476. 

  1476. 

  1477. 

  1478. 							if ((strlen($riff_data_chunk_contents_test) > 0) && (substr($riff_data_chunk_contents_test, 0, 4) == 'wvpk')) {
    1479. 

  1479. 

  1480. 								// This is WavPack data
    1481. 

  1481. 								$info['wavpack']['offset'] = $riff_chunk[$chunk_name][$this_index]['offset'];
    1482. 

  1482. 								$info['wavpack']['size']   = getid3_lib::LittleEndian2Int(substr($riff_data_chunk_contents_test, 4, 4));
    1483. 

  1483. 								$this->RIFFparseWavPackHeader(substr($riff_data_chunk_contents_test, 8, 28));
    1484. 

  1484. 

  1485. 							} else {
    1486. 

  1486. 

  1487. 								// This is some other kind of data (quite possibly just PCM)
    1488. 

  1488. 								// do nothing special, just skip it
    1489. 

  1489. 

  1490. 							}
    1491. 

  1491. 							$this->fseek($riff_chunk[$chunk_name][$this_index]['offset'] + 8 + $chunk_size, SEEK_SET);
    1492. 

  1492. 							break;
    1493. 

  1493. 

  1494. 						case 'bext':
    1495. 

  1495. 						case 'cart':
    1496. 

  1496. 						case 'fmt ':
    1497. 

  1497. 						case 'MEXT':
    1498. 

  1498. 						case 'DISP':
    1499. 

  1499. 							// always read data in
    1500. 

  1500. 							$riff_chunk[$chunk_name][$this_index]['data'] = $this->fread($chunk_size);
    1501. 

  1501. 							break;
    1502. 

  1502. 

  1503. 						default:
    1504. 

  1504. 							if (!empty($list_chunk_parent) && (($riff_chunk[$chunk_name][$this_index]['offset'] + $riff_chunk[$chunk_name][$this_index]['size']) <= $list_chunk_max_offset)) {
    1505. 

  1505. 								$riff_chunk[$list_chunk_parent][$chunk_name][$this_index]['offset'] = $riff_chunk[$chunk_name][$this_index]['offset'];
    1506. 

  1506. 								$riff_chunk[$list_chunk_parent][$chunk_name][$this_index]['size']   = $riff_chunk[$chunk_name][$this_index]['size'];
    1507. 

  1507. 								unset($riff_chunk[$chunk_name][$this_index]['offset']);
    1508. 

  1508. 								unset($riff_chunk[$chunk_name][$this_index]['size']);
    1509. 

  1509. 								if (isset($riff_chunk[$chunk_name][$this_index]) && empty($riff_chunk[$chunk_name][$this_index])) {
    1510. 

  1510. 									unset($riff_chunk[$chunk_name][$this_index]);
    1511. 

  1511. 								}
    1512. 

  1512. 								if (isset($riff_chunk[$chunk_name]) && empty($riff_chunk[$chunk_name])) {
    1513. 

  1513. 									unset($riff_chunk[$chunk_name]);
    1514. 

  1514. 								}
    1515. 

  1515. 								$riff_chunk[$list_chunk_parent][$chunk_name][$this_index]['data'] = $this->fread($chunk_size);
    1516. 

  1516. 							} elseif ($chunk_size < 2048) {
    1517. 

  1517. 								// only read data in if smaller than 2kB
    1518. 

  1518. 								$riff_chunk[$chunk_name][$this_index]['data'] = $this->fread($chunk_size);
    1519. 

  1519. 							} else {
    1520. 

  1520. 								$this->fseek($chunk_size, SEEK_CUR);
    1521. 

  1521. 							}
    1522. 

  1522. 							break;
    1523. 

  1523. 					}
    1524. 

  1524. 					break;
    1525. 

  1525. 

  1526. 			}
    1527. 

  1527. 

  1528. 		}
    1529. 

  1529. 

  1530. 		return $riff_chunk;
    1531. 

  1531. 	}
    1532. 

  1532. 

  1533. 

  1534. 

  1535. 	private function RIFFparseWavPackHeader($wavpack3_chunk_data) {
    1536. 

  1536. 

  1537. 		// typedef struct {
    1538. 

  1538. 		//     char ckID [4];
    1539. 

  1539. 		//     long ckSize;
    1540. 

  1540. 		//     short version;
    1541. 

  1541. 		//     short bits;                // added for version 2.00
    1542. 

  1542. 		//     short flags, shift;        // added for version 3.00
    1543. 

  1543. 		//     long total_samples, crc, crc2;
    1544. 

  1544. 		//     char extension [4], extra_bc, extras [3];
    1545. 

  1545. 		// } WavpackHeader;
    1546. 

  1546. 

  1547. 		$this->getid3->info['wavpack'] = array ();
    1548. 

  1548. 		$info_wavpack = &$this->getid3->info['wavpack'];
    1549. 

  1549. 

  1550. 		$info_wavpack['version'] = getid3_lib::LittleEndian2Int(substr($wavpack3_chunk_data,  0, 2));
    1551. 

  1551. 

  1552. 		if ($info_wavpack['version'] >= 2) {
    1553. 

  1553. 			$info_wavpack['bits'] = getid3_lib::LittleEndian2Int(substr($wavpack3_chunk_data,  2, 2));
    1554. 

  1554. 		}
    1555. 

  1555. 

  1556. 		if ($info_wavpack['version'] >= 3) {
    1557. 

  1557. 

  1558. 			getid3_lib::ReadSequence('LittleEndian2Int', $info_wavpack, $wavpack3_chunk_data,  4,
    1559. 

  1559. 				array (
    1560. 

  1560. 					'flags_raw'     => 2,
    1561. 

  1561. 					'shift'         => 2,
    1562. 

  1562. 					'total_samples' => 4,
    1563. 

  1563. 					'crc1'          => 4,
    1564. 

  1564. 					'crc2'          => 4,
    1565. 

  1565. 					'extension'     => -4,
    1566. 

  1566. 					'extra_bc'      => 1
    1567. 

  1567. 				)
    1568. 

  1568. 			);
    1569. 

  1569. 

  1570. 			for ($i = 0; $i < 3; $i++) {
    1571. 

  1571. 				$info_wavpack['extras'][] = getid3_lib::LittleEndian2Int($wavpack3_chunk_data{25 + $i});
    1572. 

  1572. 			}
    1573. 

  1573. 

  1574. 			$info_wavpack['flags'] = array ();
    1575. 

  1575. 			$info_wavpack_flags = &$info_wavpack['flags'];
    1576. 

  1576. 

  1577. 			$info_wavpack_flags['mono']                 = (bool)($info_wavpack['flags_raw'] & 0x000001);
    1578. 

  1578. 			$info_wavpack_flags['fast_mode']            = (bool)($info_wavpack['flags_raw'] & 0x000002);
    1579. 

  1579. 			$info_wavpack_flags['raw_mode']             = (bool)($info_wavpack['flags_raw'] & 0x000004);
    1580. 

  1580. 			$info_wavpack_flags['calc_noise']           = (bool)($info_wavpack['flags_raw'] & 0x000008);
    1581. 

  1581. 			$info_wavpack_flags['high_quality']         = (bool)($info_wavpack['flags_raw'] & 0x000010);
    1582. 

  1582. 			$info_wavpack_flags['3_byte_samples']       = (bool)($info_wavpack['flags_raw'] & 0x000020);
    1583. 

  1583. 			$info_wavpack_flags['over_20_bits']         = (bool)($info_wavpack['flags_raw'] & 0x000040);
    1584. 

  1584. 			$info_wavpack_flags['use_wvc']              = (bool)($info_wavpack['flags_raw'] & 0x000080);
    1585. 

  1585. 			$info_wavpack_flags['noiseshaping']         = (bool)($info_wavpack['flags_raw'] & 0x000100);
    1586. 

  1586. 			$info_wavpack_flags['very_fast_mode']       = (bool)($info_wavpack['flags_raw'] & 0x000200);
    1587. 

  1587. 			$info_wavpack_flags['new_high_quality']     = (bool)($info_wavpack['flags_raw'] & 0x000400);
    1588. 

  1588. 			$info_wavpack_flags['cancel_extreme']       = (bool)($info_wavpack['flags_raw'] & 0x000800);
    1589. 

  1589. 			$info_wavpack_flags['cross_decorrelation']  = (bool)($info_wavpack['flags_raw'] & 0x001000);
    1590. 

  1590. 			$info_wavpack_flags['new_decorrelation']    = (bool)($info_wavpack['flags_raw'] & 0x002000);
    1591. 

  1591. 			$info_wavpack_flags['joint_stereo']         = (bool)($info_wavpack['flags_raw'] & 0x004000);
    1592. 

  1592. 			$info_wavpack_flags['extra_decorrelation']  = (bool)($info_wavpack['flags_raw'] & 0x008000);
    1593. 

  1593. 			$info_wavpack_flags['override_noiseshape']  = (bool)($info_wavpack['flags_raw'] & 0x010000);
    1594. 

  1594. 			$info_wavpack_flags['override_jointstereo'] = (bool)($info_wavpack['flags_raw'] & 0x020000);
    1595. 

  1595. 			$info_wavpack_flags['copy_source_filetime'] = (bool)($info_wavpack['flags_raw'] & 0x040000);
    1596. 

  1596. 			$info_wavpack_flags['create_exe']           = (bool)($info_wavpack['flags_raw'] & 0x080000);
    1597. 

  1597. 		}
    1598. 

  1598. 

  1599. 		return true;
    1600. 

  1600. 	}
    1601. 

  1601. 

  1602. 

  1603. 

  1604. 	public function AnalyzeString(&$string) {
    1605. 

  1605. 

  1606. 		// Rewrite header_size in header
    1607. 

  1607. 		$new_header_size = getid3_lib::LittleEndian2String(strlen($string), 4);
    1608. 

  1608. 		for ($i = 0; $i < 4; $i++) {
    1609. 

  1609. 			$string{$i + 4} = $new_header_size{$i};
    1610. 

  1610. 		}
    1611. 

  1611. 

  1612. 		return parent::AnalyzeString($string);
    1613. 

  1613. 	}
    1614. 

  1614. 

  1615. 

  1616. 

  1617. 	public static function RIFFparseWAVEFORMATex($wave_format_ex_data) {
    1618. 

  1618. 

  1619. 		$wave_format_ex['raw'] = array ();
    1620. 

  1620. 		$wave_format_ex_raw    = &$wave_format_ex['raw'];
    1621. 

  1621. 

  1622. 		getid3_lib::ReadSequence('LittleEndian2Int', $wave_format_ex_raw, $wave_format_ex_data, 0,
    1623. 

  1623. 			array (
    1624. 

  1624. 				'wFormatTag'      => 2,
    1625. 

  1625. 				'nChannels'       => 2,
    1626. 

  1626. 				'nSamplesPerSec'  => 4,
    1627. 

  1627. 				'nAvgBytesPerSec' => 4,
    1628. 

  1628. 				'nBlockAlign'     => 2,
    1629. 

  1629. 				'wBitsPerSample'  => 2
    1630. 

  1630. 			)
    1631. 

  1631. 		);
    1632. 

  1632. 

  1633. 		if (strlen($wave_format_ex_data) > 16) {
    1634. 

  1634. 			$wave_format_ex_raw['cbSize'] = getid3_lib::LittleEndian2Int(substr($wave_format_ex_data, 16, 2));
    1635. 

  1635. 		}
    1636. 

  1636. 

  1637. 		$wave_format_ex['codec']           = getid3_riff::RIFFwFormatTagLookup($wave_format_ex_raw['wFormatTag']);
    1638. 

  1638. 		$wave_format_ex['channels']        = $wave_format_ex_raw['nChannels'];
    1639. 

  1639. 		$wave_format_ex['sample_rate']     = $wave_format_ex_raw['nSamplesPerSec'];
    1640. 

  1640. 		$wave_format_ex['bitrate']         = $wave_format_ex_raw['nAvgBytesPerSec'] * 8;
    1641. 

  1641. 		if (@$wave_format_ex_raw['wBitsPerSample']) {
    1642. 

  1642. 			$wave_format_ex['bits_per_sample'] = $wave_format_ex_raw['wBitsPerSample'];
    1643. 

  1643. 		}
    1644. 

  1644. 

  1645. 		return $wave_format_ex;
    1646. 

  1646. 	}
    1647. 

  1647. 

  1648. 

  1649. 

  1650. 	public static function RIFFwaveSNDMtagLookup($tagshortname) {
    1651. 

  1651. 		static $lookup = array(
    1652. 

  1652. 			'Škwd' => 'keywords',
    1653. 

  1653. 			'ŠBPM' => 'bpm',
    1654. 

  1654. 			'Štrt' => 'tracktitle',
    1655. 

  1655. 			'Šdes' => 'description',
    1656. 

  1656. 			'Šgen' => 'category',
    1657. 

  1657. 			'Šfin' => 'featuredinstrument',
    1658. 

  1658. 			'ŠLID' => 'longid',
    1659. 

  1659. 			'Šbex' => 'bwdescription',
    1660. 

  1660. 			'Špub' => 'publisher',
    1661. 

  1661. 			'Šcdt' => 'cdtitle',
    1662. 

  1662. 			'Šalb' => 'library',
    1663. 

  1663. 			'Šcom' => 'composer',
    1664. 

  1664. 		);
    1665. 

  1665. 		return @$lookup[$tagshortname];
    1666. 

  1666. 	}
    1667. 

  1667. 

  1668. 

  1669. 	public static function RIFFwFormatTagLookup($w_format_tag) {
    1670. 

  1670. 

  1671. 		static $lookup = array (
    1672. 

  1672. 			0x0000 => 'Microsoft Unknown Wave Format',
    1673. 

  1673. 			0x0001 => 'Pulse Code Modulation (PCM)',
    1674. 

  1674. 			0x0002 => 'Microsoft ADPCM',
    1675. 

  1675. 			0x0003 => 'IEEE Float',
    1676. 

  1676. 			0x0004 => 'Compaq Computer VSELP',
    1677. 

  1677. 			0x0005 => 'IBM CVSD',
    1678. 

  1678. 			0x0006 => 'Microsoft A-Law',
    1679. 

  1679. 			0x0007 => 'Microsoft mu-Law',
    1680. 

  1680. 			0x0008 => 'Microsoft DTS',
    1681. 

  1681. 			0x0010 => 'OKI ADPCM',
    1682. 

  1682. 			0x0011 => 'Intel DVI/IMA ADPCM',
    1683. 

  1683. 			0x0012 => 'Videologic MediaSpace ADPCM',
    1684. 

  1684. 			0x0013 => 'Sierra Semiconductor ADPCM',
    1685. 

  1685. 			0x0014 => 'Antex Electronics G.723 ADPCM',
    1686. 

  1686. 			0x0015 => 'DSP Solutions DigiSTD',
    1687. 

  1687. 			0x0016 => 'DSP Solutions DigiFIX',
    1688. 

  1688. 			0x0017 => 'Dialogic OKI ADPCM',
    1689. 

  1689. 			0x0018 => 'MediaVision ADPCM',
    1690. 

  1690. 			0x0019 => 'Hewlett-Packard CU',
    1691. 

  1691. 			0x0020 => 'Yamaha ADPCM',
    1692. 

  1692. 			0x0021 => 'Speech Compression Sonarc',
    1693. 

  1693. 			0x0022 => 'DSP Group TrueSpeech',
    1694. 

  1694. 			0x0023 => 'Echo Speech EchoSC1',
    1695. 

  1695. 			0x0024 => 'Audiofile AF36',
    1696. 

  1696. 			0x0025 => 'Audio Processing Technology APTX',
    1697. 

  1697. 			0x0026 => 'AudioFile AF10',
    1698. 

  1698. 			0x0027 => 'Prosody 1612',
    1699. 

  1699. 			0x0028 => 'LRC',
    1700. 

  1700. 			0x0030 => 'Dolby AC2',
    1701. 

  1701. 			0x0031 => 'Microsoft GSM 6.10',
    1702. 

  1702. 			0x0032 => 'MSNAudio',
    1703. 

  1703. 			0x0033 => 'Antex Electronics ADPCME',
    1704. 

  1704. 			0x0034 => 'Control Resources VQLPC',
    1705. 

  1705. 			0x0035 => 'DSP Solutions DigiREAL',
    1706. 

  1706. 			0x0036 => 'DSP Solutions DigiADPCM',
    1707. 

  1707. 			0x0037 => 'Control Resources CR10',
    1708. 

  1708. 			0x0038 => 'Natural MicroSystems VBXADPCM',
    1709. 

  1709. 			0x0039 => 'Crystal Semiconductor IMA ADPCM',
    1710. 

  1710. 			0x003A => 'EchoSC3',
    1711. 

  1711. 			0x003B => 'Rockwell ADPCM',
    1712. 

  1712. 			0x003C => 'Rockwell Digit LK',
    1713. 

  1713. 			0x003D => 'Xebec',
    1714. 

  1714. 			0x0040 => 'Antex Electronics G.721 ADPCM',
    1715. 

  1715. 			0x0041 => 'G.728 CELP',
    1716. 

  1716. 			0x0042 => 'MSG723',
    1717. 

  1717. 			0x0050 => 'MPEG Layer-2 or Layer-1',
    1718. 

  1718. 			0x0052 => 'RT24',
    1719. 

  1719. 			0x0053 => 'PAC',
    1720. 

  1720. 			0x0055 => 'MPEG Layer-3',
    1721. 

  1721. 			0x0059 => 'Lucent G.723',
    1722. 

  1722. 			0x0060 => 'Cirrus',
    1723. 

  1723. 			0x0061 => 'ESPCM',
    1724. 

  1724. 			0x0062 => 'Voxware',
    1725. 

  1725. 			0x0063 => 'Canopus Atrac',
    1726. 

  1726. 			0x0064 => 'G.726 ADPCM',
    1727. 

  1727. 			0x0065 => 'G.722 ADPCM',
    1728. 

  1728. 			0x0066 => 'DSAT',
    1729. 

  1729. 			0x0067 => 'DSAT Display',
    1730. 

  1730. 			0x0069 => 'Voxware Byte Aligned',
    1731. 

  1731. 			0x0070 => 'Voxware AC8',
    1732. 

  1732. 			0x0071 => 'Voxware AC10',
    1733. 

  1733. 			0x0072 => 'Voxware AC16',
    1734. 

  1734. 			0x0073 => 'Voxware AC20',
    1735. 

  1735. 			0x0074 => 'Voxware MetaVoice',
    1736. 

  1736. 			0x0075 => 'Voxware MetaSound',
    1737. 

  1737. 			0x0076 => 'Voxware RT29HW',
    1738. 

  1738. 			0x0077 => 'Voxware VR12',
    1739. 

  1739. 			0x0078 => 'Voxware VR18',
    1740. 

  1740. 			0x0079 => 'Voxware TQ40',
    1741. 

  1741. 			0x0080 => 'Softsound',
    1742. 

  1742. 			0x0081 => 'Voxware TQ60',
    1743. 

  1743. 			0x0082 => 'MSRT24',
    1744. 

  1744. 			0x0083 => 'G.729A',
    1745. 

  1745. 			0x0084 => 'MVI MV12',
    1746. 

  1746. 			0x0085 => 'DF G.726',
    1747. 

  1747. 			0x0086 => 'DF GSM610',
    1748. 

  1748. 			0x0088 => 'ISIAudio',
    1749. 

  1749. 			0x0089 => 'Onlive',
    1750. 

  1750. 			0x0091 => 'SBC24',
    1751. 

  1751. 			0x0092 => 'Dolby AC3 SPDIF',
    1752. 

  1752. 			0x0093 => 'MediaSonic G.723',
    1753. 

  1753. 			0x0094 => 'Aculab PLC    Prosody 8kbps',
    1754. 

  1754. 			0x0097 => 'ZyXEL ADPCM',
    1755. 

  1755. 			0x0098 => 'Philips LPCBB',
    1756. 

  1756. 			0x0099 => 'Packed',
    1757. 

  1757. 			0x00FF => 'AAC',
    1758. 

  1758. 			0x0100 => 'Rhetorex ADPCM',
    1759. 

  1759. 			0x0101 => 'IBM mu-law',
    1760. 

  1760. 			0x0102 => 'IBM A-law',
    1761. 

  1761. 			0x0103 => 'IBM AVC Adaptive Differential Pulse Code Modulation (ADPCM)',
    1762. 

  1762. 			0x0111 => 'Vivo G.723',
    1763. 

  1763. 			0x0112 => 'Vivo Siren',
    1764. 

  1764. 			0x0123 => 'Digital G.723',
    1765. 

  1765. 			0x0125 => 'Sanyo LD ADPCM',
    1766. 

  1766. 			0x0130 => 'Sipro Lab Telecom ACELP NET',
    1767. 

  1767. 			0x0131 => 'Sipro Lab Telecom ACELP 4800',
    1768. 

  1768. 			0x0132 => 'Sipro Lab Telecom ACELP 8V3',
    1769. 

  1769. 			0x0133 => 'Sipro Lab Telecom G.729',
    1770. 

  1770. 			0x0134 => 'Sipro Lab Telecom G.729A',
    1771. 

  1771. 			0x0135 => 'Sipro Lab Telecom Kelvin',
    1772. 

  1772. 			0x0140 => 'Windows Media Video V8',
    1773. 

  1773. 			0x0150 => 'Qualcomm PureVoice',
    1774. 

  1774. 			0x0151 => 'Qualcomm HalfRate',
    1775. 

  1775. 			0x0155 => 'Ring Zero Systems TUB GSM',
    1776. 

  1776. 			0x0160 => 'Microsoft Audio 1',
    1777. 

  1777. 			0x0161 => 'Windows Media Audio V7 / V8 / V9',
    1778. 

  1778. 			0x0162 => 'Windows Media Audio Professional V9',
    1779. 

  1779. 			0x0163 => 'Windows Media Audio Lossless V9',
    1780. 

  1780. 			0x0200 => 'Creative Labs ADPCM',
    1781. 

  1781. 			0x0202 => 'Creative Labs Fastspeech8',
    1782. 

  1782. 			0x0203 => 'Creative Labs Fastspeech10',
    1783. 

  1783. 			0x0210 => 'UHER Informatic GmbH ADPCM',
    1784. 

  1784. 			0x0220 => 'Quarterdeck',
    1785. 

  1785. 			0x0230 => 'I-link Worldwide VC',
    1786. 

  1786. 			0x0240 => 'Aureal RAW Sport',
    1787. 

  1787. 			0x0250 => 'Interactive Products HSX',
    1788. 

  1788. 			0x0251 => 'Interactive Products RPELP',
    1789. 

  1789. 			0x0260 => 'Consistent Software CS2',
    1790. 

  1790. 			0x0270 => 'Sony SCX',
    1791. 

  1791. 			0x0300 => 'Fujitsu FM Towns Snd',
    1792. 

  1792. 			0x0400 => 'BTV Digital',
    1793. 

  1793. 			0x0401 => 'Intel Music Coder',
    1794. 

  1794. 			0x0450 => 'QDesign Music',
    1795. 

  1795. 			0x0680 => 'VME VMPCM',
    1796. 

  1796. 			0x0681 => 'AT&T Labs TPC',
    1797. 

  1797. 			0x08AE => 'ClearJump LiteWave',
    1798. 

  1798. 			0x1000 => 'Olivetti GSM',
    1799. 

  1799. 			0x1001 => 'Olivetti ADPCM',
    1800. 

  1800. 			0x1002 => 'Olivetti CELP',
    1801. 

  1801. 			0x1003 => 'Olivetti SBC',
    1802. 

  1802. 			0x1004 => 'Olivetti OPR',
    1803. 

  1803. 			0x1100 => 'Lernout & Hauspie Codec (0x1100)',
    1804. 

  1804. 			0x1101 => 'Lernout & Hauspie CELP Codec (0x1101)',
    1805. 

  1805. 			0x1102 => 'Lernout & Hauspie SBC Codec (0x1102)',
    1806. 

  1806. 			0x1103 => 'Lernout & Hauspie SBC Codec (0x1103)',
    1807. 

  1807. 			0x1104 => 'Lernout & Hauspie SBC Codec (0x1104)',
    1808. 

  1808. 			0x1400 => 'Norris',
    1809. 

  1809. 			0x1401 => 'AT&T ISIAudio',
    1810. 

  1810. 			0x1500 => 'Soundspace Music Compression',
    1811. 

  1811. 			0x181C => 'VoxWare RT24 Speech',
    1812. 

  1812. 			0x1FC4 => 'NCT Soft ALF2CD (www.nctsoft.com)',
    1813. 

  1813. 			0x2000 => 'Dolby AC3',
    1814. 

  1814. 			0x2001 => 'Dolby DTS',
    1815. 

  1815. 			0x2002 => 'WAVE_FORMAT_14_4',
    1816. 

  1816. 			0x2003 => 'WAVE_FORMAT_28_8',
    1817. 

  1817. 			0x2004 => 'WAVE_FORMAT_COOK',
    1818. 

  1818. 			0x2005 => 'WAVE_FORMAT_DNET',
    1819. 

  1819. 			0x674F => 'Ogg Vorbis 1',
    1820. 

  1820. 			0x6750 => 'Ogg Vorbis 2',
    1821. 

  1821. 			0x6751 => 'Ogg Vorbis 3',
    1822. 

  1822. 			0x676F => 'Ogg Vorbis 1+',
    1823. 

  1823. 			0x6770 => 'Ogg Vorbis 2+',
    1824. 

  1824. 			0x6771 => 'Ogg Vorbis 3+',
    1825. 

  1825. 			0x7A21 => 'GSM-AMR (CBR, no SID)',
    1826. 

  1826. 			0x7A22 => 'GSM-AMR (VBR, including SID)',
    1827. 

  1827. 			0xFFFE => 'WAVE_FORMAT_EXTENSIBLE',
    1828. 

  1828. 			0xFFFF => 'WAVE_FORMAT_DEVELOPMENT'
    1829. 

  1829. 		);
    1830. 

  1830. 

  1831. 		return @$lookup[$w_format_tag];
    1832. 

  1832. 	}
    1833. 

  1833. 

  1834. 

  1835. 

  1836. 	public static function RIFFfourccLookup($four_cc) {
    1837. 

  1837. 

  1838. 		static $lookup = array (
    1839. 

  1839. 			'swot' => 'http://developer.apple.com/qa/snd/snd07.html',
    1840. 

  1840. 			'____' => 'No Codec (____)',
    1841. 

  1841. 			'_BIT' => 'BI_BITFIELDS (Raw RGB)',
    1842. 

  1842. 			'_JPG' => 'JPEG compressed',
    1843. 

  1843. 			'_PNG' => 'PNG compressed W3C/ISO/IEC (RFC-2083)',
    1844. 

  1844. 			'_RAW' => 'Full Frames (Uncompressed)',
    1845. 

  1845. 			'_RGB' => 'Raw RGB Bitmap',
    1846. 

  1846. 			'_RL4' => 'RLE 4bpp RGB',
    1847. 

  1847. 			'_RL8' => 'RLE 8bpp RGB',
    1848. 

  1848. 			'3IV1' => '3ivx MPEG-4 v1',
    1849. 

  1849. 			'3IV2' => '3ivx MPEG-4 v2',
    1850. 

  1850. 			'3IVX' => '3ivx MPEG-4',
    1851. 

  1851. 			'AASC' => 'Autodesk Animator',
    1852. 

  1852. 			'ABYR' => 'Kensington ?ABYR?',
    1853. 

  1853. 			'AEMI' => 'Array Microsystems VideoONE MPEG1-I Capture',
    1854. 

  1854. 			'AFLC' => 'Autodesk Animator FLC',
    1855. 

  1855. 			'AFLI' => 'Autodesk Animator FLI',
    1856. 

  1856. 			'AMPG' => 'Array Microsystems VideoONE MPEG',
    1857. 

  1857. 			'ANIM' => 'Intel RDX (ANIM)',
    1858. 

  1858. 			'AP41' => 'AngelPotion Definitive',
    1859. 

  1859. 			'ASV1' => 'Asus Video v1',
    1860. 

  1860. 			'ASV2' => 'Asus Video v2',
    1861. 

  1861. 			'ASVX' => 'Asus Video 2.0 (audio)',
    1862. 

  1862. 			'AUR2' => 'AuraVision Aura 2 Codec - YUV 4:2:2',
    1863. 

  1863. 			'AURA' => 'AuraVision Aura 1 Codec - YUV 4:1:1',
    1864. 

  1864. 			'AVDJ' => 'Independent JPEG Group\'s codec (AVDJ)',
    1865. 

  1865. 			'AVRN' => 'Independent JPEG Group\'s codec (AVRN)',
    1866. 

  1866. 			'AYUV' => '4:4:4 YUV (AYUV)',
    1867. 

  1867. 			'AZPR' => 'Quicktime Apple Video (AZPR)',
    1868. 

  1868. 			'BGR ' => 'Raw RGB32',
    1869. 

  1869. 			'BLZ0' => 'FFmpeg MPEG-4',
    1870. 

  1870. 			'BTVC' => 'Conexant Composite Video',
    1871. 

  1871. 			'BINK' => 'RAD Game Tools Bink Video',
    1872. 

  1872. 			'BT20' => 'Conexant Prosumer Video',
    1873. 

  1873. 			'BTCV' => 'Conexant Composite Video Codec',
    1874. 

  1874. 			'BW10' => 'Data Translation Broadway MPEG Capture',
    1875. 

  1875. 			'CC12' => 'Intel YUV12',
    1876. 

  1876. 			'CDVC' => 'Canopus DV',
    1877. 

  1877. 			'CFCC' => 'Digital Processing Systems DPS Perception',
    1878. 

  1878. 			'CGDI' => 'Microsoft Office 97 Camcorder Video',
    1879. 

  1879. 			'CHAM' => 'Winnov Caviara Champagne',
    1880. 

  1880. 			'CJPG' => 'Creative WebCam JPEG',
    1881. 

  1881. 			'CLJR' => 'Cirrus Logic YUV 4:1:1',
    1882. 

  1882. 			'CMYK' => 'Common Data Format in Printing (Colorgraph)',
    1883. 

  1883. 			'CPLA' => 'Weitek 4:2:0 YUV Planar',
    1884. 

  1884. 			'CRAM' => 'Microsoft Video 1 (CRAM)',
    1885. 

  1885. 			'cvid' => 'Radius Cinepak',
    1886. 

  1886. 			'CVID' => 'Radius Cinepak',
    1887. 

  1887. 			'CWLT' => 'Microsoft Color WLT DIB',
    1888. 

  1888. 			'CYUV' => 'Creative Labs YUV',
    1889. 

  1889. 			'CYUY' => 'ATI YUV',
    1890. 

  1890. 			'D261' => 'H.261',
    1891. 

  1891. 			'D263' => 'H.263',
    1892. 

  1892. 			'DIB ' => 'Device Independent Bitmap',
    1893. 

  1893. 			'DIV1' => 'FFmpeg OpenDivX',
    1894. 

  1894. 			'DIV2' => 'Microsoft MPEG-4 v1/v2',
    1895. 

  1895. 			'DIV3' => 'DivX ;-) MPEG-4 v3.x Low-Motion',
    1896. 

  1896. 			'DIV4' => 'DivX ;-) MPEG-4 v3.x Fast-Motion',
    1897. 

  1897. 			'DIV5' => 'DivX MPEG-4 v5.x',
    1898. 

  1898. 			'DIV6' => 'DivX ;-) (MS MPEG-4 v3.x)',
    1899. 

  1899. 			'DIVX' => 'DivX MPEG-4 v4 (OpenDivX / Project Mayo)',
    1900. 

  1900. 			'divx' => 'DivX MPEG-4',
    1901. 

  1901. 			'DMB1' => 'Matrox Rainbow Runner hardware MJPEG',
    1902. 

  1902. 			'DMB2' => 'Paradigm MJPEG',
    1903. 

  1903. 			'DSVD' => '?DSVD?',
    1904. 

  1904. 			'DUCK' => 'Duck TrueMotion 1.0',
    1905. 

  1905. 			'DPS0' => 'DPS/Leitch Reality Motion JPEG',
    1906. 

  1906. 			'DPSC' => 'DPS/Leitch PAR Motion JPEG',
    1907. 

  1907. 			'DV25' => 'Matrox DVCPRO codec',
    1908. 

  1908. 			'DV50' => 'Matrox DVCPRO50 codec',
    1909. 

  1909. 			'DVC ' => 'IEC 61834 and SMPTE 314M (DVC/DV Video)',
    1910. 

  1910. 			'DVCP' => 'IEC 61834 and SMPTE 314M (DVC/DV Video)',
    1911. 

  1911. 			'DVHD' => 'IEC Standard DV 1125 lines @ 30fps / 1250 lines @ 25fps',
    1912. 

  1912. 			'DVMA' => 'Darim Vision DVMPEG (dummy for MPEG compressor) (www.darvision.com)',
    1913. 

  1913. 			'DVSL' => 'IEC Standard DV compressed in SD (SDL)',
    1914. 

  1914. 			'DVAN' => '?DVAN?',
    1915. 

  1915. 			'DVE2' => 'InSoft DVE-2 Videoconferencing',
    1916. 

  1916. 			'dvsd' => 'IEC 61834 and SMPTE 314M DVC/DV Video',
    1917. 

  1917. 			'DVSD' => 'IEC 61834 and SMPTE 314M DVC/DV Video',
    1918. 

  1918. 			'DVX1' => 'Lucent DVX1000SP Video Decoder',
    1919. 

  1919. 			'DVX2' => 'Lucent DVX2000S Video Decoder',
    1920. 

  1920. 			'DVX3' => 'Lucent DVX3000S Video Decoder',
    1921. 

  1921. 			'DX50' => 'DivX v5',
    1922. 

  1922. 			'DXT1' => 'Microsoft DirectX Compressed Texture (DXT1)',
    1923. 

  1923. 			'DXT2' => 'Microsoft DirectX Compressed Texture (DXT2)',
    1924. 

  1924. 			'DXT3' => 'Microsoft DirectX Compressed Texture (DXT3)',
    1925. 

  1925. 			'DXT4' => 'Microsoft DirectX Compressed Texture (DXT4)',
    1926. 

  1926. 			'DXT5' => 'Microsoft DirectX Compressed Texture (DXT5)',
    1927. 

  1927. 			'DXTC' => 'Microsoft DirectX Compressed Texture (DXTC)',
    1928. 

  1928. 			'DXTn' => 'Microsoft DirectX Compressed Texture (DXTn)',
    1929. 

  1929. 			'EM2V' => 'Etymonix MPEG-2 I-frame (www.etymonix.com)',
    1930. 

  1930. 			'EKQ0' => 'Elsa ?EKQ0?',
    1931. 

  1931. 			'ELK0' => 'Elsa ?ELK0?',
    1932. 

  1932. 			'ESCP' => 'Eidos Escape',
    1933. 

  1933. 			'ETV1' => 'eTreppid Video ETV1',
    1934. 

  1934. 			'ETV2' => 'eTreppid Video ETV2',
    1935. 

  1935. 			'ETVC' => 'eTreppid Video ETVC',
    1936. 

  1936. 			'FLIC' => 'Autodesk FLI/FLC Animation',
    1937. 

  1937. 			'FRWT' => 'Darim Vision Forward Motion JPEG (www.darvision.com)',
    1938. 

  1938. 			'FRWU' => 'Darim Vision Forward Uncompressed (www.darvision.com)',
    1939. 

  1939. 			'FLJP' => 'D-Vision Field Encoded Motion JPEG',
    1940. 

  1940. 			'FRWA' => 'SoftLab-Nsk Forward Motion JPEG w/ alpha channel',
    1941. 

  1941. 			'FRWD' => 'SoftLab-Nsk Forward Motion JPEG',
    1942. 

  1942. 			'FVF1' => 'Iterated Systems Fractal Video Frame',
    1943. 

  1943. 			'GLZW' => 'Motion LZW (gabest@freemail.hu)',
    1944. 

  1944. 			'GPEG' => 'Motion JPEG (gabest@freemail.hu)',
    1945. 

  1945. 			'GWLT' => 'Microsoft Greyscale WLT DIB',
    1946. 

  1946. 			'H260' => 'Intel ITU H.260 Videoconferencing',
    1947. 

  1947. 			'H261' => 'Intel ITU H.261 Videoconferencing',
    1948. 

  1948. 			'H262' => 'Intel ITU H.262 Videoconferencing',
    1949. 

  1949. 			'H263' => 'Intel ITU H.263 Videoconferencing',
    1950. 

  1950. 			'H264' => 'Intel ITU H.264 Videoconferencing',
    1951. 

  1951. 			'H265' => 'Intel ITU H.265 Videoconferencing',
    1952. 

  1952. 			'H266' => 'Intel ITU H.266 Videoconferencing',
    1953. 

  1953. 			'H267' => 'Intel ITU H.267 Videoconferencing',
    1954. 

  1954. 			'H268' => 'Intel ITU H.268 Videoconferencing',
    1955. 

  1955. 			'H269' => 'Intel ITU H.269 Videoconferencing',
    1956. 

  1956. 			'HFYU' => 'Huffman Lossless Codec',
    1957. 

  1957. 			'HMCR' => 'Rendition Motion Compensation Format (HMCR)',
    1958. 

  1958. 			'HMRR' => 'Rendition Motion Compensation Format (HMRR)',
    1959. 

  1959. 			'I263' => 'FFmpeg I263 decoder',
    1960. 

  1960. 			'IF09' => 'Indeo YVU9 ("YVU9 with additional delta-frame info after the U plane")',
    1961. 

  1961. 			'IUYV' => 'Interlaced version of UYVY (www.leadtools.com)',
    1962. 

  1962. 			'IY41' => 'Interlaced version of Y41P (www.leadtools.com)',
    1963. 

  1963. 			'IYU1' => '12 bit format used in mode 2 of the IEEE 1394 Digital Camera 1.04 spec    IEEE standard',
    1964. 

  1964. 			'IYU2' => '24 bit format used in mode 2 of the IEEE 1394 Digital Camera 1.04 spec    IEEE standard',
    1965. 

  1965. 			'IYUV' => 'Planar YUV format (8-bpp Y plane, followed by 8-bpp 2×2 U and V planes)',
    1966. 

  1966. 			'i263' => 'Intel ITU H.263 Videoconferencing (i263)',
    1967. 

  1967. 			'I420' => 'Intel Indeo 4',
    1968. 

  1968. 			'IAN ' => 'Intel Indeo 4 (RDX)',
    1969. 

  1969. 			'ICLB' => 'InSoft CellB Videoconferencing',
    1970. 

  1970. 			'IGOR' => 'Power DVD',
    1971. 

  1971. 			'IJPG' => 'Intergraph JPEG',
    1972. 

  1972. 			'ILVC' => 'Intel Layered Video',
    1973. 

  1973. 			'ILVR' => 'ITU-T H.263+',
    1974. 

  1974. 			'IPDV' => 'I-O Data Device Giga AVI DV Codec',
    1975. 

  1975. 			'IR21' => 'Intel Indeo 2.1',
    1976. 

  1976. 			'IRAW' => 'Intel YUV Uncompressed',
    1977. 

  1977. 			'IV30' => 'Intel Indeo 3.0',
    1978. 

  1978. 			'IV31' => 'Intel Indeo 3.1',
    1979. 

  1979. 			'IV32' => 'Ligos Indeo 3.2',
    1980. 

  1980. 			'IV33' => 'Ligos Indeo 3.3',
    1981. 

  1981. 			'IV34' => 'Ligos Indeo 3.4',
    1982. 

  1982. 			'IV35' => 'Ligos Indeo 3.5',
    1983. 

  1983. 			'IV36' => 'Ligos Indeo 3.6',
    1984. 

  1984. 			'IV37' => 'Ligos Indeo 3.7',
    1985. 

  1985. 			'IV38' => 'Ligos Indeo 3.8',
    1986. 

  1986. 			'IV39' => 'Ligos Indeo 3.9',
    1987. 

  1987. 			'IV40' => 'Ligos Indeo Interactive 4.0',
    1988. 

  1988. 			'IV41' => 'Ligos Indeo Interactive 4.1',
    1989. 

  1989. 			'IV42' => 'Ligos Indeo Interactive 4.2',
    1990. 

  1990. 			'IV43' => 'Ligos Indeo Interactive 4.3',
    1991. 

  1991. 			'IV44' => 'Ligos Indeo Interactive 4.4',
    1992. 

  1992. 			'IV45' => 'Ligos Indeo Interactive 4.5',
    1993. 

  1993. 			'IV46' => 'Ligos Indeo Interactive 4.6',
    1994. 

  1994. 			'IV47' => 'Ligos Indeo Interactive 4.7',
    1995. 

  1995. 			'IV48' => 'Ligos Indeo Interactive 4.8',
    1996. 

  1996. 			'IV49' => 'Ligos Indeo Interactive 4.9',
    1997. 

  1997. 			'IV50' => 'Ligos Indeo Interactive 5.0',
    1998. 

  1998. 			'JBYR' => 'Kensington ?JBYR?',
    1999. 

  1999. 			'JPEG' => 'Still Image JPEG DIB',
    2000. 

  2000. 			'JPGL' => 'Pegasus Lossless Motion JPEG',
    2001. 

  2001. 			'KMVC' => 'Team17 Software Karl Morton\'s Video Codec',
    2002. 

  2002. 			'LSVM' => 'Vianet Lighting Strike Vmail (Streaming) (www.vianet.com)',
    2003. 

  2003. 			'LEAD' => 'LEAD Video Codec',
    2004. 

  2004. 			'Ljpg' => 'LEAD MJPEG Codec',
    2005. 

  2005. 			'MDVD' => 'Alex MicroDVD Video (hacked MS MPEG-4) (www.tiasoft.de)',
    2006. 

  2006. 			'MJPA' => 'Morgan Motion JPEG (MJPA) (www.morgan-multimedia.com)',
    2007. 

  2007. 			'MJPB' => 'Morgan Motion JPEG (MJPB) (www.morgan-multimedia.com)',
    2008. 

  2008. 			'MMES' => 'Matrox MPEG-2 I-frame',
    2009. 

  2009. 			'MP2v' => 'Microsoft S-Mpeg 4 version 1 (MP2v)',
    2010. 

  2010. 			'MP42' => 'Microsoft S-Mpeg 4 version 2 (MP42)',
    2011. 

  2011. 			'MP43' => 'Microsoft S-Mpeg 4 version 3 (MP43)',
    2012. 

  2012. 			'MP4S' => 'Microsoft S-Mpeg 4 version 3 (MP4S)',
    2013. 

  2013. 			'MP4V' => 'FFmpeg MPEG-4',
    2014. 

  2014. 			'MPG1' => 'FFmpeg MPEG 1/2',
    2015. 

  2015. 			'MPG2' => 'FFmpeg MPEG 1/2',
    2016. 

  2016. 			'MPG3' => 'FFmpeg DivX ;-) (MS MPEG-4 v3)',
    2017. 

  2017. 			'MPG4' => 'Microsoft MPEG-4',
    2018. 

  2018. 			'MPGI' => 'Sigma Designs MPEG',
    2019. 

  2019. 			'MPNG' => 'PNG images decoder',
    2020. 

  2020. 			'MSS1' => 'Microsoft Windows Screen Video',
    2021. 

  2021. 			'MSZH' => 'LCL (Lossless Codec Library) (www.geocities.co.jp/Playtown-Denei/2837/LRC.htm)',
    2022. 

  2022. 			'M261' => 'Microsoft H.261',
    2023. 

  2023. 			'M263' => 'Microsoft H.263',
    2024. 

  2024. 			'M4S2' => 'Microsoft Fully Compliant MPEG-4 v2 simple profile (M4S2)',
    2025. 

  2025. 			'm4s2' => 'Microsoft Fully Compliant MPEG-4 v2 simple profile (m4s2)',
    2026. 

  2026. 			'MC12' => 'ATI Motion Compensation Format (MC12)',
    2027. 

  2027. 			'MCAM' => 'ATI Motion Compensation Format (MCAM)',
    2028. 

  2028. 			'MJ2C' => 'Morgan Multimedia Motion JPEG2000',
    2029. 

  2029. 			'mJPG' => 'IBM Motion JPEG w/ Huffman Tables',
    2030. 

  2030. 			'MJPG' => 'Microsoft Motion JPEG DIB',
    2031. 

  2031. 			'MP42' => 'Microsoft MPEG-4 (low-motion)',
    2032. 

  2032. 			'MP43' => 'Microsoft MPEG-4 (fast-motion)',
    2033. 

  2033. 			'MP4S' => 'Microsoft MPEG-4 (MP4S)',
    2034. 

  2034. 			'mp4s' => 'Microsoft MPEG-4 (mp4s)',
    2035. 

  2035. 			'MPEG' => 'Chromatic Research MPEG-1 Video I-Frame',
    2036. 

  2036. 			'MPG4' => 'Microsoft MPEG-4 Video High Speed Compressor',
    2037. 

  2037. 			'MPGI' => 'Sigma Designs MPEG',
    2038. 

  2038. 			'MRCA' => 'FAST Multimedia Martin Regen Codec',
    2039. 

  2039. 			'MRLE' => 'Microsoft Run Length Encoding',
    2040. 

  2040. 			'MSVC' => 'Microsoft Video 1',
    2041. 

  2041. 			'MTX1' => 'Matrox ?MTX1?',
    2042. 

  2042. 			'MTX2' => 'Matrox ?MTX2?',
    2043. 

  2043. 			'MTX3' => 'Matrox ?MTX3?',
    2044. 

  2044. 			'MTX4' => 'Matrox ?MTX4?',
    2045. 

  2045. 			'MTX5' => 'Matrox ?MTX5?',
    2046. 

  2046. 			'MTX6' => 'Matrox ?MTX6?',
    2047. 

  2047. 			'MTX7' => 'Matrox ?MTX7?',
    2048. 

  2048. 			'MTX8' => 'Matrox ?MTX8?',
    2049. 

  2049. 			'MTX9' => 'Matrox ?MTX9?',
    2050. 

  2050. 			'MV12' => 'Motion Pixels Codec (old)',
    2051. 

  2051. 			'MWV1' => 'Aware Motion Wavelets',
    2052. 

  2052. 			'nAVI' => 'SMR Codec (hack of Microsoft MPEG-4) (IRC #shadowrealm)',
    2053. 

  2053. 			'NT00' => 'NewTek LightWave HDTV YUV w/ Alpha (www.newtek.com)',
    2054. 

  2054. 			'NUV1' => 'NuppelVideo',
    2055. 

  2055. 			'NTN1' => 'Nogatech Video Compression 1',
    2056. 

  2056. 			'NVS0' => 'nVidia GeForce Texture (NVS0)',
    2057. 

  2057. 			'NVS1' => 'nVidia GeForce Texture (NVS1)',
    2058. 

  2058. 			'NVS2' => 'nVidia GeForce Texture (NVS2)',
    2059. 

  2059. 			'NVS3' => 'nVidia GeForce Texture (NVS3)',
    2060. 

  2060. 			'NVS4' => 'nVidia GeForce Texture (NVS4)',
    2061. 

  2061. 			'NVS5' => 'nVidia GeForce Texture (NVS5)',
    2062. 

  2062. 			'NVT0' => 'nVidia GeForce Texture (NVT0)',
    2063. 

  2063. 			'NVT1' => 'nVidia GeForce Texture (NVT1)',
    2064. 

  2064. 			'NVT2' => 'nVidia GeForce Texture (NVT2)',
    2065. 

  2065. 			'NVT3' => 'nVidia GeForce Texture (NVT3)',
    2066. 

  2066. 			'NVT4' => 'nVidia GeForce Texture (NVT4)',
    2067. 

  2067. 			'NVT5' => 'nVidia GeForce Texture (NVT5)',
    2068. 

  2068. 			'PIXL' => 'MiroXL, Pinnacle PCTV',
    2069. 

  2069. 			'PDVC' => 'I-O Data Device Digital Video Capture DV codec',
    2070. 

  2070. 			'PGVV' => 'Radius Video Vision',
    2071. 

  2071. 			'PHMO' => 'IBM Photomotion',
    2072. 

  2072. 			'PIM1' => 'MPEG Realtime (Pinnacle Cards)',
    2073. 

  2073. 			'PIM2' => 'Pegasus Imaging ?PIM2?',
    2074. 

  2074. 			'PIMJ' => 'Pegasus Imaging Lossless JPEG',
    2075. 

  2075. 			'PVEZ' => 'Horizons Technology PowerEZ',
    2076. 

  2076. 			'PVMM' => 'PacketVideo Corporation MPEG-4',
    2077. 

  2077. 			'PVW2' => 'Pegasus Imaging Wavelet Compression',
    2078. 

  2078. 			'Q1.0' => 'Q-Team\'s QPEG 1.0 (www.q-team.de)',
    2079. 

  2079. 			'Q1.1' => 'Q-Team\'s QPEG 1.1 (www.q-team.de)',
    2080. 

  2080. 			'QPEG' => 'Q-Team QPEG 1.0',
    2081. 

  2081. 			'qpeq' => 'Q-Team QPEG 1.1',
    2082. 

  2082. 			'RGB ' => 'Raw BGR32',
    2083. 

  2083. 			'RGBA' => 'Raw RGB w/ Alpha',
    2084. 

  2084. 			'RMP4' => 'REALmagic MPEG-4 (unauthorized XVID copy) (www.sigmadesigns.com)',
    2085. 

  2085. 			'ROQV' => 'Id RoQ File Video Decoder',
    2086. 

  2086. 			'RPZA' => 'Quicktime Apple Video (RPZA)',
    2087. 

  2087. 			'RUD0' => 'Rududu video codec (http://rududu.ifrance.com/rududu/)',
    2088. 

  2088. 			'RV10' => 'RealVideo 1.0 (aka RealVideo 5.0)',
    2089. 

  2089. 			'RV13' => 'RealVideo 1.0 (RV13)',
    2090. 

  2090. 			'RV20' => 'RealVideo G2',
    2091. 

  2091. 			'RV30' => 'RealVideo 8',
    2092. 

  2092. 			'RV40' => 'RealVideo 9',
    2093. 

  2093. 			'RGBT' => 'Raw RGB w/ Transparency',
    2094. 

  2094. 			'RLE ' => 'Microsoft Run Length Encoder',
    2095. 

  2095. 			'RLE4' => 'Run Length Encoded (4bpp, 16-color)',
    2096. 

  2096. 			'RLE8' => 'Run Length Encoded (8bpp, 256-color)',
    2097. 

  2097. 			'RT21' => 'Intel Indeo RealTime Video 2.1',
    2098. 

  2098. 			'rv20' => 'RealVideo G2',
    2099. 

  2099. 			'rv30' => 'RealVideo 8',
    2100. 

  2100. 			'RVX ' => 'Intel RDX (RVX )',
    2101. 

  2101. 			'SMC ' => 'Apple Graphics (SMC )',
    2102. 

  2102. 			'SP54' => 'Logitech Sunplus Sp54 Codec for Mustek GSmart Mini 2',
    2103. 

  2103. 			'SPIG' => 'Radius Spigot',
    2104. 

  2104. 			'SVQ3' => 'Sorenson Video 3 (Apple Quicktime 5)',
    2105. 

  2105. 			's422' => 'Tekram VideoCap C210 YUV 4:2:2',
    2106. 

  2106. 			'SDCC' => 'Sun Communication Digital Camera Codec',
    2107. 

  2107. 			'SFMC' => 'CrystalNet Surface Fitting Method',
    2108. 

  2108. 			'SMSC' => 'Radius SMSC',
    2109. 

  2109. 			'SMSD' => 'Radius SMSD',
    2110. 

  2110. 			'smsv' => 'WorldConnect Wavelet Video',
    2111. 

  2111. 			'SPIG' => 'Radius Spigot',
    2112. 

  2112. 			'SPLC' => 'Splash Studios ACM Audio Codec (www.splashstudios.net)',
    2113. 

  2113. 			'SQZ2' => 'Microsoft VXTreme Video Codec V2',
    2114. 

  2114. 			'STVA' => 'ST Microelectronics CMOS Imager Data (Bayer)',
    2115. 

  2115. 			'STVB' => 'ST Microelectronics CMOS Imager Data (Nudged Bayer)',
    2116. 

  2116. 			'STVC' => 'ST Microelectronics CMOS Imager Data (Bunched)',
    2117. 

  2117. 			'STVX' => 'ST Microelectronics CMOS Imager Data (Extended CODEC Data Format)',
    2118. 

  2118. 			'STVY' => 'ST Microelectronics CMOS Imager Data (Extended CODEC Data Format with Correction Data)',
    2119. 

  2119. 			'SV10' => 'Sorenson Video R1',
    2120. 

  2120. 			'SVQ1' => 'Sorenson Video',
    2121. 

  2121. 			'T420' => 'Toshiba YUV 4:2:0',
    2122. 

  2122. 			'TM2A' => 'Duck TrueMotion Archiver 2.0 (www.duck.com)',
    2123. 

  2123. 			'TVJP' => 'Pinnacle/Truevision Targa 2000 board (TVJP)',
    2124. 

  2124. 			'TVMJ' => 'Pinnacle/Truevision Targa 2000 board (TVMJ)',
    2125. 

  2125. 			'TY0N' => 'Tecomac Low-Bit Rate Codec (www.tecomac.com)',
    2126. 

  2126. 			'TY2C' => 'Trident Decompression Driver',
    2127. 

  2127. 			'TLMS' => 'TeraLogic Motion Intraframe Codec (TLMS)',
    2128. 

  2128. 			'TLST' => 'TeraLogic Motion Intraframe Codec (TLST)',
    2129. 

  2129. 			'TM20' => 'Duck TrueMotion 2.0',
    2130. 

  2130. 			'TM2X' => 'Duck TrueMotion 2X',
    2131. 

  2131. 			'TMIC' => 'TeraLogic Motion Intraframe Codec (TMIC)',
    2132. 

  2132. 			'TMOT' => 'Horizons Technology TrueMotion S',
    2133. 

  2133. 			'tmot' => 'Horizons TrueMotion Video Compression',
    2134. 

  2134. 			'TR20' => 'Duck TrueMotion RealTime 2.0',
    2135. 

  2135. 			'TSCC' => 'TechSmith Screen Capture Codec',
    2136. 

  2136. 			'TV10' => 'Tecomac Low-Bit Rate Codec',
    2137. 

  2137. 			'TY2N' => 'Trident ?TY2N?',
    2138. 

  2138. 			'U263' => 'UB Video H.263/H.263+/H.263++ Decoder',
    2139. 

  2139. 			'UMP4' => 'UB Video MPEG 4 (www.ubvideo.com)',
    2140. 

  2140. 			'UYNV' => 'Nvidia UYVY packed 4:2:2',
    2141. 

  2141. 			'UYVP' => 'Evans & Sutherland YCbCr 4:2:2 extended precision',
    2142. 

  2142. 			'UCOD' => 'eMajix.com ClearVideo',
    2143. 

  2143. 			'ULTI' => 'IBM Ultimotion',
    2144. 

  2144. 			'UYVY' => 'UYVY packed 4:2:2',
    2145. 

  2145. 			'V261' => 'Lucent VX2000S',
    2146. 

  2146. 			'VIFP' => 'VFAPI Reader Codec (www.yks.ne.jp/~hori/)',
    2147. 

  2147. 			'VIV1' => 'FFmpeg H263+ decoder',
    2148. 

  2148. 			'VIV2' => 'Vivo H.263',
    2149. 

  2149. 			'VQC2' => 'Vector-quantised codec 2 (research) http://eprints.ecs.soton.ac.uk/archive/00001310/01/VTC97-js.pdf)',
    2150. 

  2150. 			'VTLP' => 'Alaris VideoGramPiX',
    2151. 

  2151. 			'VYU9' => 'ATI YUV (VYU9)',
    2152. 

  2152. 			'VYUY' => 'ATI YUV (VYUY)',
    2153. 

  2153. 			'V261' => 'Lucent VX2000S',
    2154. 

  2154. 			'V422' => 'Vitec Multimedia 24-bit YUV 4:2:2 Format',
    2155. 

  2155. 			'V655' => 'Vitec Multimedia 16-bit YUV 4:2:2 Format',
    2156. 

  2156. 			'VCR1' => 'ATI Video Codec 1',
    2157. 

  2157. 			'VCR2' => 'ATI Video Codec 2',
    2158. 

  2158. 			'VCR3' => 'ATI VCR 3.0',
    2159. 

  2159. 			'VCR4' => 'ATI VCR 4.0',
    2160. 

  2160. 			'VCR5' => 'ATI VCR 5.0',
    2161. 

  2161. 			'VCR6' => 'ATI VCR 6.0',
    2162. 

  2162. 			'VCR7' => 'ATI VCR 7.0',
    2163. 

  2163. 			'VCR8' => 'ATI VCR 8.0',
    2164. 

  2164. 			'VCR9' => 'ATI VCR 9.0',
    2165. 

  2165. 			'VDCT' => 'Vitec Multimedia Video Maker Pro DIB',
    2166. 

  2166. 			'VDOM' => 'VDOnet VDOWave',
    2167. 

  2167. 			'VDOW' => 'VDOnet VDOLive (H.263)',
    2168. 

  2168. 			'VDTZ' => 'Darim Vison VideoTizer YUV',
    2169. 

  2169. 			'VGPX' => 'Alaris VideoGramPiX',
    2170. 

  2170. 			'VIDS' => 'Vitec Multimedia YUV 4:2:2 CCIR 601 for V422',
    2171. 

  2171. 			'VIVO' => 'Vivo H.263 v2.00',
    2172. 

  2172. 			'vivo' => 'Vivo H.263',
    2173. 

  2173. 			'VIXL' => 'Miro/Pinnacle Video XL',
    2174. 

  2174. 			'VLV1' => 'VideoLogic/PURE Digital Videologic Capture',
    2175. 

  2175. 			'VP30' => 'On2 VP3.0',
    2176. 

  2176. 			'VP31' => 'On2 VP3.1',
    2177. 

  2177. 			'VX1K' => 'Lucent VX1000S Video Codec',
    2178. 

  2178. 			'VX2K' => 'Lucent VX2000S Video Codec',
    2179. 

  2179. 			'VXSP' => 'Lucent VX1000SP Video Codec',
    2180. 

  2180. 			'WBVC' => 'Winbond W9960',
    2181. 

  2181. 			'WHAM' => 'Microsoft Video 1 (WHAM)',
    2182. 

  2182. 			'WINX' => 'Winnov Software Compression',
    2183. 

  2183. 			'WJPG' => 'AverMedia Winbond JPEG',
    2184. 

  2184. 			'WMV1' => 'Windows Media Video V7',
    2185. 

  2185. 			'WMV2' => 'Windows Media Video V8',
    2186. 

  2186. 			'WMV3' => 'Windows Media Video V9',
    2187. 

  2187. 			'WNV1' => 'Winnov Hardware Compression',
    2188. 

  2188. 			'XYZP' => 'Extended PAL format XYZ palette (www.riff.org)',
    2189. 

  2189. 			'x263' => 'Xirlink H.263',
    2190. 

  2190. 			'XLV0' => 'NetXL Video Decoder',
    2191. 

  2191. 			'XMPG' => 'Xing MPEG (I-Frame only)',
    2192. 

  2192. 			'XVID' => 'XviD MPEG-4 (www.xvid.org)',
    2193. 

  2193. 			'XXAN' => '?XXAN?',
    2194. 

  2194. 			'YU92' => 'Intel YUV (YU92)',
    2195. 

  2195. 			'YUNV' => 'Nvidia Uncompressed YUV 4:2:2',
    2196. 

  2196. 			'YUVP' => 'Extended PAL format YUV palette (www.riff.org)',
    2197. 

  2197. 			'Y211' => 'YUV 2:1:1 Packed',
    2198. 

  2198. 			'Y411' => 'YUV 4:1:1 Packed',
    2199. 

  2199. 			'Y41B' => 'Weitek YUV 4:1:1 Planar',
    2200. 

  2200. 			'Y41P' => 'Brooktree PC1 YUV 4:1:1 Packed',
    2201. 

  2201. 			'Y41T' => 'Brooktree PC1 YUV 4:1:1 with transparency',
    2202. 

  2202. 			'Y42B' => 'Weitek YUV 4:2:2 Planar',
    2203. 

  2203. 			'Y42T' => 'Brooktree UYUV 4:2:2 with transparency',
    2204. 

  2204. 			'Y422' => 'ADS Technologies Copy of UYVY used in Pyro WebCam firewire camera',
    2205. 

  2205. 			'Y800' => 'Simple, single Y plane for monochrome images',
    2206. 

  2206. 			'Y8  ' => 'Grayscale video',
    2207. 

  2207. 			'YC12' => 'Intel YUV 12 codec',
    2208. 

  2208. 			'YUV8' => 'Winnov Caviar YUV8',
    2209. 

  2209. 			'YUV9' => 'Intel YUV9',
    2210. 

  2210. 			'YUY2' => 'Uncompressed YUV 4:2:2',
    2211. 

  2211. 			'YUYV' => 'Canopus YUV',
    2212. 

  2212. 			'YV12' => 'YVU12 Planar',
    2213. 

  2213. 			'YVU9' => 'Intel YVU9 Planar (8-bpp Y plane, followed by 8-bpp 4x4 U and V planes)',
    2214. 

  2214. 			'YVYU' => 'YVYU 4:2:2 Packed',
    2215. 

  2215. 			'ZLIB' => 'Lossless Codec Library zlib compression (www.geocities.co.jp/Playtown-Denei/2837/LRC.htm)',
    2216. 

  2216. 			'ZPEG' => 'Metheus Video Zipper'
    2217. 

  2217. 		);
    2218. 

  2218. 

  2219. 		return @$lookup[$four_cc];
    2220. 

  2220. 	}
    2221. 

  2221. 

  2222. 

  2223. 

  2224. 	public static function RIFFcommentsParse(&$riff_info_aray, &$comments_target_array) {
    2225. 

  2225. 

  2226. 		static $lookup = array(
    2227. 

  2227. 			'IARL' => 'archivallocation',
    2228. 

  2228. 			'IART' => 'artist',
    2229. 

  2229. 			'ICDS' => 'costumedesigner',
    2230. 

  2230. 			'ICMS' => 'commissionedby',
    2231. 

  2231. 			'ICMT' => 'comment',
    2232. 

  2232. 			'ICNT' => 'country',
    2233. 

  2233. 			'ICOP' => 'copyright',
    2234. 

  2234. 			'ICRD' => 'creationdate',
    2235. 

  2235. 			'IDIM' => 'dimensions',
    2236. 

  2236. 			'IDIT' => 'digitizationdate',
    2237. 

  2237. 			'IDPI' => 'resolution',
    2238. 

  2238. 			'IDST' => 'distributor',
    2239. 

  2239. 			'IEDT' => 'editor',
    2240. 

  2240. 			'IENG' => 'engineers',
    2241. 

  2241. 			'IFRM' => 'accountofparts',
    2242. 

  2242. 			'IGNR' => 'genre',
    2243. 

  2243. 			'IKEY' => 'keywords',
    2244. 

  2244. 			'ILGT' => 'lightness',
    2245. 

  2245. 			'ILNG' => 'language',
    2246. 

  2246. 			'IMED' => 'orignalmedium',
    2247. 

  2247. 			'IMUS' => 'composer',
    2248. 

  2248. 			'INAM' => 'title',
    2249. 

  2249. 			'IPDS' => 'productiondesigner',
    2250. 

  2250. 			'IPLT' => 'palette',
    2251. 

  2251. 			'IPRD' => 'product',
    2252. 

  2252. 			'IPRO' => 'producer',
    2253. 

  2253. 			'IPRT' => 'part',
    2254. 

  2254. 			'IRTD' => 'rating',
    2255. 

  2255. 			'ISBJ' => 'subject',
    2256. 

  2256. 			'ISFT' => 'software',
    2257. 

  2257. 			'ISGN' => 'secondarygenre',
    2258. 

  2258. 			'ISHP' => 'sharpness',
    2259. 

  2259. 			'ISRC' => 'sourcesupplier',
    2260. 

  2260. 			'ISRF' => 'digitizationsource',
    2261. 

  2261. 			'ISTD' => 'productionstudio',
    2262. 

  2262. 			'ISTR' => 'starring',
    2263. 

  2263. 			'ITCH' => 'encoded_by',
    2264. 

  2264. 			'IWEB' => 'url',
    2265. 

  2265. 			'IWRI' => 'writer'
    2266. 

  2266. 		);
    2267. 

  2267. 

  2268. 		foreach ($lookup as $key => $value) {
    2269. 

  2269. 			if (isset($riff_info_aray[$key])) {
    2270. 

  2270. 				foreach ($riff_info_aray[$key] as $comment_id => $comment_data) {
    2271. 

  2271. 					if (trim($comment_data['data']) != '') {
    2272. 

  2272. 						@$comments_target_array[$value][] = trim($comment_data['data']);
    2273. 

  2273. 					}
    2274. 

  2274. 				}
    2275. 

  2275. 			}
    2276. 

  2276. 		}
    2277. 

  2277. 		return true;
    2278. 

  2278. 	}
    2279. 

  2279. 

  2280. 

  2281. 

  2282. 	public static function array_merge_noclobber($array1, $array2) {
    2283. 

  2283. 		if (!is_array($array1) || !is_array($array2)) {
    2284. 

  2284. 			return false;
    2285. 

  2285. 		}
    2286. 

  2286. 		$new_array = $array1;
    2287. 

  2287. 		foreach ($array2 as $key => $val) {
    2288. 

  2288. 			if (is_array($val) && isset($new_array[$key]) && is_array($new_array[$key])) {
    2289. 

  2289. 				$new_array[$key] = getid3_riff::array_merge_noclobber($new_array[$key], $val);
    2290. 

  2290. 			} elseif (!isset($new_array[$key])) {
    2291. 

  2291. 				$new_array[$key] = $val;
    2292. 

  2292. 			}
    2293. 

  2293. 		}
    2294. 

  2294. 		return $new_array;
    2295. 

  2295. 	}
    2296. 

  2296. 

  2297. 

  2298. 

  2299. 	public static function DateMac2Unix($mac_date) {
    2300. 

  2300. 

  2301. 		// Macintosh timestamp: seconds since 00:00h January 1, 1904
    2302. 

  2302. 		// UNIX timestamp:      seconds since 00:00h January 1, 1970
    2303. 

  2303. 		return (int)($mac_date - 2082844800);
    2304. 

  2304. 	}
    2305. 

  2305. 

  2306. 

  2307. 

  2308. 	public static function FixedPoint16_16($raw_data) {
    2309. 

  2309. 

  2310. 		return getid3_lib::BigEndian2Int(substr($raw_data, 0, 2)) + (float)(getid3_lib::BigEndian2Int(substr($raw_data, 2, 2)) / 65536);  // pow(2, 16) = 65536
    2311. 

  2311. 	}
    2312. 

  2312. 

  2313. 

  2314. 

  2315.    	function BigEndian2Float($byte_word) {
    2316. 

  2316. 

  2317. 		// ANSI/IEEE Standard 754-1985, Standard for Binary Floating Point Arithmetic
    2318. 

  2318. 		// http://www.psc.edu/general/software/packages/ieee/ieee.html
    2319. 

  2319. 		// http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee.html
    2320. 

  2320. 

  2321. 		$bit_word = getid3_lib::BigEndian2Bin($byte_word);
    2322. 

  2322. 		$sign_bit = $bit_word{0};
    2323. 

  2323. 

  2324. 		switch (strlen($byte_word) * 8) {
    2325. 

  2325. 			case 32:
    2326. 

  2326. 				$exponent_bits = 8;
    2327. 

  2327. 				$fraction_bits = 23;
    2328. 

  2328. 				break;
    2329. 

  2329. 

  2330. 			case 64:
    2331. 

  2331. 				$exponent_bits = 11;
    2332. 

  2332. 				$fraction_bits = 52;
    2333. 

  2333. 				break;
    2334. 

  2334. 

  2335. 			case 80:
    2336. 

  2336. 				// 80-bit Apple SANE format
    2337. 

  2337. 				// http://www.mactech.com/articles/mactech/Vol.06/06.01/SANENormalized/
    2338. 

  2338. 				$exponent_string = substr($bit_word, 1, 15);
    2339. 

  2339. 				$is_normalized   = intval($bit_word{16});
    2340. 

  2340. 				$fraction_string = substr($bit_word, 17, 63);
    2341. 

  2341. 				$exponent = pow(2, bindec($exponent_string) - 16383);
    2342. 

  2342. 				$fraction = $is_normalized + bindec($fraction_string) / bindec('1'.str_repeat('0', strlen($fraction_string)));
    2343. 

  2343. 				$float_value = $exponent * $fraction;
    2344. 

  2344. 				if ($sign_bit == '1') {
    2345. 

  2345. 					$float_value *= -1;
    2346. 

  2346. 				}
    2347. 

  2347. 				return $float_value;
    2348. 

  2348. 				break;
    2349. 

  2349. 

  2350. 			default:
    2351. 

  2351. 				return false;
    2352. 

  2352. 				break;
    2353. 

  2353. 		}
    2354. 

  2354. 		$exponent_string = substr($bit_word, 1, $exponent_bits);
    2355. 

  2355. 		$fraction_string = substr($bit_word, $exponent_bits + 1, $fraction_bits);
    2356. 

  2356. 		$exponent = bindec($exponent_string);
    2357. 

  2357. 		$fraction = bindec($fraction_string);
    2358. 

  2358. 

  2359. 		if (($exponent == (pow(2, $exponent_bits) - 1)) && ($fraction != 0)) {
    2360. 

  2360. 			// Not a Number
    2361. 

  2361. 			$float_value = false;
    2362. 

  2362. 		} elseif (($exponent == (pow(2, $exponent_bits) - 1)) && ($fraction == 0)) {
    2363. 

  2363. 			if ($sign_bit == '1') {
    2364. 

  2364. 				$float_value = '-infinity';
    2365. 

  2365. 			} else {
    2366. 

  2366. 				$float_value = '+infinity';
    2367. 

  2367. 			}
    2368. 

  2368. 		} elseif (($exponent == 0) && ($fraction == 0)) {
    2369. 

  2369. 			if ($sign_bit == '1') {
    2370. 

  2370. 				$float_value = -0;
    2371. 

  2371. 			} else {
    2372. 

  2372. 				$float_value = 0;
    2373. 

  2373. 			}
    2374. 

  2374. 			$float_value = ($sign_bit ? 0 : -0);
    2375. 

  2375. 		} elseif (($exponent == 0) && ($fraction != 0)) {
    2376. 

  2376. 			// These are 'unnormalized' values
    2377. 

  2377. 			$float_value = pow(2, (-1 * (pow(2, $exponent_bits - 1) - 2))) * bindec($fraction_string) / bindec('1'.str_repeat('0', strlen($fraction_string)));
    2378. 

  2378. 			if ($sign_bit == '1') {
    2379. 

  2379. 				$float_value *= -1;
    2380. 

  2380. 			}
    2381. 

  2381. 		} elseif ($exponent != 0) {
    2382. 

  2382. 			$float_value = pow(2, ($exponent - (pow(2, $exponent_bits - 1) - 1))) * (1 + bindec($fraction_string) / bindec('1'.str_repeat('0', strlen($fraction_string))));
    2383. 

  2383. 			if ($sign_bit == '1') {
    2384. 

  2384. 				$float_value *= -1;
    2385. 

  2385. 			}
    2386. 

  2386. 		}
    2387. 

  2387. 		return (float) $float_value;
    2388. 

  2388. 	}
    2389. 

  2389. }
    2390. 

  2390. 

  2391. ?>
    2392.