PageRenderTime 65ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 1ms

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

https://bitbucket.org/holyfield/getid3
PHP | 2410 lines | 1442 code | 248 blank | 720 comment | 298 complexity | ea51b9b326e29ec6aeb499bc6d871067 MD5 | raw file
Possible License(s): GPL-2.0 
    

  1. <?php
    2. 

  2. /////////////////////////////////////////////////////////////////
    3. 

  3. /// getID3() by James Heinrich <info@getid3.org>               //
    4. 

  4. //  available at http://getid3.sourceforge.net                 //
    5. 

  5. //            or http://www.getid3.org                         //
    6. 

  6. /////////////////////////////////////////////////////////////////
    7. 

  7. // See readme.txt for more details                             //
    8. 

  8. /////////////////////////////////////////////////////////////////
    9. 

  9. //                                                             //
    10. 

  10. // module.audio-video.riff.php                                 //
    11. 

  11. // module for analyzing RIFF files                             //
    12. 

  12. // multiple formats supported by this module:                  //
    13. 

  13. //    Wave, AVI, AIFF/AIFC, (MP3,AC3)/RIFF, Wavpack v3, 8SVX   //
    14. 

  14. // dependencies: module.audio.mp3.php                          //
    15. 

  15. //               module.audio.ac3.php (optional)               //
    16. 

  16. //               module.audio.dts.php (optional)               //
    17. 

  17. //                                                            ///
    18. 

  18. /////////////////////////////////////////////////////////////////
    19. 

  19. 

  20. 

  21. getid3_lib::IncludeDependency ( GETID3_INCLUDEPATH . 'module.audio.mp3.php', __FILE__, true );
    22. 

  22. 

  23. class getid3_riff extends getid3_handler {
    24. 

  24. 	
    25. 

  25. 	function Analyze() {
    26. 

  26. 		$info = &$this->getid3->info;
    27. 

  27. 		
    28. 

  28. 		// initialize these values to an empty array, otherwise they default to NULL
    29. 

  29. 		// and you can't append array values to a NULL value
    30. 

  30. 		$info ['riff'] = array (
    31. 

  31. 										'raw' => array () );
    32. 

  32. 		
    33. 

  33. 		// Shortcuts
    34. 

  34. 		$thisfile_riff = &$info ['riff'];
    35. 

  35. 		$thisfile_riff_raw = &$thisfile_riff ['raw'];
    36. 

  36. 		$thisfile_audio = &$info ['audio'];
    37. 

  37. 		$thisfile_video = &$info ['video'];
    38. 

  38. 		$thisfile_audio_dataformat = &$thisfile_audio ['dataformat'];
    39. 

  39. 		$thisfile_riff_audio = &$thisfile_riff ['audio'];
    40. 

  40. 		$thisfile_riff_video = &$thisfile_riff ['video'];
    41. 

  41. 		
    42. 

  42. 		$Original ['avdataoffset'] = $info ['avdataoffset'];
    43. 

  43. 		$Original ['avdataend'] = $info ['avdataend'];
    44. 

  44. 		
    45. 

  45. 		fseek ( $this->getid3->fp, $info ['avdataoffset'], SEEK_SET );
    46. 

  46. 		$RIFFheader = fread ( $this->getid3->fp, 12 );
    47. 

  47. 		$RIFFsubtype = substr ( $RIFFheader, 8, 4 );
    48. 

  48. 		switch (substr ( $RIFFheader, 0, 4 )) {
    49. 

  49. 			case 'FORM' :
    50. 

  50. 				$info ['fileformat'] = 'aiff';
    51. 

  51. 				$thisfile_riff ['header_size'] = $this->EitherEndian2Int ( substr ( $RIFFheader, 4, 4 ) );
    52. 

  52. 				$thisfile_riff [$RIFFsubtype] = $this->ParseRIFF ( $info ['avdataoffset'] + 12, $info ['avdataoffset'] + $thisfile_riff ['header_size'] );
    53. 

  53. 				break;
    54. 

  54. 			
    55. 

  55. 			case 'RIFF' : // AVI, WAV, etc
    56. 

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

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

  58. 				$info ['fileformat'] = 'riff';
    59. 

  59. 				$thisfile_riff ['header_size'] = $this->EitherEndian2Int ( substr ( $RIFFheader, 4, 4 ) );
    60. 

  60. 				if ($RIFFsubtype == 'RMP3') {
    61. 

  61. 					// RMP3 is identical to WAVE, just renamed. Used by [unknown program] when creating RIFF-MP3s
    62. 

  62. 					$RIFFsubtype = 'WAVE';
    63. 

  63. 				}
    64. 

  64. 				$thisfile_riff [$RIFFsubtype] = $this->ParseRIFF ( $info ['avdataoffset'] + 12, $info ['avdataoffset'] + $thisfile_riff ['header_size'] );
    65. 

  65. 				if (($info ['avdataend'] - $info ['filesize']) == 1) {
    66. 

  66. 					// LiteWave appears to incorrectly *not* pad actual output file
    67. 

  67. 					// to nearest WORD boundary so may appear to be short by one
    68. 

  68. 					// byte, in which case - skip warning
    69. 

  69. 					$info ['avdataend'] = $info ['filesize'];
    70. 

  70. 				}
    71. 

  71. 				
    72. 

  72. 				$nextRIFFoffset = $Original ['avdataoffset'] + 8 + $thisfile_riff ['header_size']; // 8 = "RIFF" + 32-bit offset
    73. 

  73. 				while ( $nextRIFFoffset < min ( $info ['filesize'], $info ['avdataend'] ) ) {
    74. 

  74. 					if (! getid3_lib::intValueSupported ( $nextRIFFoffset + 1024 )) {
    75. 

  75. 						$info ['error'] [] = 'AVI extends beyond ' . round ( PHP_INT_MAX / 1073741824 ) . 'GB and PHP filesystem functions cannot read that far, playtime is probably wrong';
    76. 

  76. 						$info ['warning'] [] = '[avdataend] value may be incorrect, multiple AVIX chunks may be present';
    77. 

  77. 						break;
    78. 

  78. 					} else {
    79. 

  79. 						fseek ( $this->getid3->fp, $nextRIFFoffset, SEEK_SET );
    80. 

  80. 						$nextRIFFheader = fread ( $this->getid3->fp, 12 );
    81. 

  81. 						if ($nextRIFFoffset == ($info ['avdataend'] - 1)) {
    82. 

  82. 							if (substr ( $nextRIFFheader, 0, 1 ) == "\x00") {
    83. 

  83. 								// RIFF padded to WORD boundary, we're actually already at the end
    84. 

  84. 								break;
    85. 

  85. 							}
    86. 

  86. 						}
    87. 

  87. 						$nextRIFFheaderID = substr ( $nextRIFFheader, 0, 4 );
    88. 

  88. 						$nextRIFFsize = $this->EitherEndian2Int ( substr ( $nextRIFFheader, 4, 4 ) );
    89. 

  89. 						$nextRIFFtype = substr ( $nextRIFFheader, 8, 4 );
    90. 

  90. 						$chunkdata = array ();
    91. 

  91. 						$chunkdata ['offset'] = $nextRIFFoffset + 8;
    92. 

  92. 						$chunkdata ['size'] = $nextRIFFsize;
    93. 

  93. 						$nextRIFFoffset = $chunkdata ['offset'] + $chunkdata ['size'];
    94. 

  94. 						switch ($nextRIFFheaderID) {
    95. 

  95. 							case 'RIFF' :
    96. 

  96. 								$info ['avdataend'] = $nextRIFFoffset;
    97. 

  97. 								if (! getid3_lib::intValueSupported ( $info ['avdataend'] )) {
    98. 

  98. 									$info ['error'] [] = 'AVI extends beyond ' . round ( PHP_INT_MAX / 1073741824 ) . 'GB and PHP filesystem functions cannot read that far, playtime is probably wrong';
    99. 

  99. 									$info ['warning'] [] = '[avdataend] value may be incorrect, multiple AVIX chunks may be present';
    100. 

  100. 								}
    101. 

  101. 								$chunkdata ['chunks'] = $this->ParseRIFF ( $chunkdata ['offset'] + 4, $chunkdata ['offset'] + $chunkdata ['size'] );
    102. 

  102. 								
    103. 

  103. 								if (! isset ( $thisfile_riff [$nextRIFFtype] )) {
    104. 

  104. 									$thisfile_riff [$nextRIFFtype] = array ();
    105. 

  105. 								}
    106. 

  106. 								$thisfile_riff [$nextRIFFtype] [] = $chunkdata;
    107. 

  107. 								break;
    108. 

  108. 							case 'JUNK' :
    109. 

  109. 								// ignore
    110. 

  110. 								$thisfile_riff [$nextRIFFheaderID] [] = $chunkdata;
    111. 

  111. 								break;
    112. 

  112. 							default :
    113. 

  113. 								if ($info ['filesize'] == ($chunkdata ['offset'] - 8 + 128)) {
    114. 

  114. 									$DIVXTAG = $nextRIFFheader . fread ( $this->getid3->fp, 128 - 12 );
    115. 

  115. 									if (substr ( $DIVXTAG, - 7 ) == 'DIVXTAG') {
    116. 

  116. 										// DIVXTAG is supposed to be inside an IDVX chunk in a LIST chunk, but some bad encoders just slap it on the end of a file
    117. 

  117. 										$info ['warning'] [] = 'Found wrongly-structured DIVXTAG at offset ' . (ftell ( $this->getid3->fp ) - 128 + 12) . ', parsing anyway';
    118. 

  118. 										$thisfile_riff ['DIVXTAG'] = $this->ParseDIVXTAG ( $DIVXTAG );
    119. 

  119. 										foreach ( $thisfile_riff ['DIVXTAG'] as $key => $value ) {
    120. 

  120. 											if ($value && ! preg_match ( '#_id$#', $key )) {
    121. 

  121. 												$thisfile_riff ['comments'] [$key] [] = $value;
    122. 

  122. 											}
    123. 

  123. 										}
    124. 

  124. 										break 2;
    125. 

  125. 									}
    126. 

  126. 								}
    127. 

  127. 								$info ['warning'] [] = 'expecting "RIFF" or "JUNK" at ' . $nextRIFFoffset . ', found ' . getid3_lib::PrintHexBytes ( substr ( $nextRIFFheader, 0, 4 ) ) . ' - skipping rest of file';
    128. 

  128. 								break 2;
    129. 

  129. 						}
    130. 

  130. 					}
    131. 

  131. 				}
    132. 

  132. 				if ($RIFFsubtype == 'WAVE') {
    133. 

  133. 					$thisfile_riff_WAVE = &$thisfile_riff ['WAVE'];
    134. 

  134. 				}
    135. 

  135. 				break;
    136. 

  136. 			
    137. 

  137. 			default :
    138. 

  138. 				$info ['error'] [] = 'Cannot parse RIFF (this is maybe not a RIFF / WAV / AVI file?) - expecting "FORM|RIFF|SDSS|RMP3" found "' . $RIFFsubtype . '" instead';
    139. 

  139. 				unset ( $info ['fileformat'] );
    140. 

  140. 				return false;
    141. 

  141. 				break;
    142. 

  142. 		}
    143. 

  143. 		
    144. 

  144. 		$streamindex = 0;
    145. 

  145. 		switch ($RIFFsubtype) {
    146. 

  146. 			case 'WAVE' :
    147. 

  147. 				if (empty ( $thisfile_audio ['bitrate_mode'] )) {
    148. 

  148. 					$thisfile_audio ['bitrate_mode'] = 'cbr';
    149. 

  149. 				}
    150. 

  150. 				if (empty ( $thisfile_audio_dataformat )) {
    151. 

  151. 					$thisfile_audio_dataformat = 'wav';
    152. 

  152. 				}
    153. 

  153. 				
    154. 

  154. 				if (isset ( $thisfile_riff_WAVE ['data'] [0] ['offset'] )) {
    155. 

  155. 					$info ['avdataoffset'] = $thisfile_riff_WAVE ['data'] [0] ['offset'] + 8;
    156. 

  156. 					$info ['avdataend'] = $info ['avdataoffset'] + $thisfile_riff_WAVE ['data'] [0] ['size'];
    157. 

  157. 				}
    158. 

  158. 				if (isset ( $thisfile_riff_WAVE ['fmt '] [0] ['data'] )) {
    159. 

  159. 					
    160. 

  160. 					$thisfile_riff_audio [$streamindex] = getid3_riff::RIFFparseWAVEFORMATex ( $thisfile_riff_WAVE ['fmt '] [0] ['data'] );
    161. 

  161. 					$thisfile_audio ['wformattag'] = $thisfile_riff_audio [$streamindex] ['raw'] ['wFormatTag'];
    162. 

  162. 					if (! isset ( $thisfile_riff_audio [$streamindex] ['bitrate'] ) || ($thisfile_riff_audio [$streamindex] ['bitrate'] == 0)) {
    163. 

  163. 						$info ['error'] [] = 'Corrupt RIFF file: bitrate_audio == zero';
    164. 

  164. 						return false;
    165. 

  165. 					}
    166. 

  166. 					$thisfile_riff_raw ['fmt '] = $thisfile_riff_audio [$streamindex] ['raw'];
    167. 

  167. 					unset ( $thisfile_riff_audio [$streamindex] ['raw'] );
    168. 

  168. 					$thisfile_audio ['streams'] [$streamindex] = $thisfile_riff_audio [$streamindex];
    169. 

  169. 					
    170. 

  170. 					$thisfile_audio = getid3_lib::array_merge_noclobber ( $thisfile_audio, $thisfile_riff_audio [$streamindex] );
    171. 

  171. 					if (substr ( $thisfile_audio ['codec'], 0, strlen ( 'unknown: 0x' ) ) == 'unknown: 0x') {
    172. 

  172. 						$info ['warning'] [] = 'Audio codec = ' . $thisfile_audio ['codec'];
    173. 

  173. 					}
    174. 

  174. 					$thisfile_audio ['bitrate'] = $thisfile_riff_audio [$streamindex] ['bitrate'];
    175. 

  175. 					
    176. 

  176. 					$info ['playtime_seconds'] = ( float ) ((($info ['avdataend'] - $info ['avdataoffset']) * 8) / $thisfile_audio ['bitrate']);
    177. 

  177. 					
    178. 

  178. 					$thisfile_audio ['lossless'] = false;
    179. 

  179. 					if (isset ( $thisfile_riff_WAVE ['data'] [0] ['offset'] ) && isset ( $thisfile_riff_raw ['fmt '] ['wFormatTag'] )) {
    180. 

  180. 						switch ($thisfile_riff_raw ['fmt '] ['wFormatTag']) {
    181. 

  181. 							
    182. 

  182. 							case 0x0001 : // PCM
    183. 

  183. 								$thisfile_audio ['lossless'] = true;
    184. 

  184. 								break;
    185. 

  185. 							
    186. 

  186. 							case 0x2000 : // AC-3
    187. 

  187. 								$thisfile_audio_dataformat = 'ac3';
    188. 

  188. 								break;
    189. 

  189. 							
    190. 

  190. 							default :
    191. 

  191. 								// do nothing
    192. 

  192. 								break;
    193. 

  193. 						
    194. 

  194. 						}
    195. 

  195. 					}
    196. 

  196. 					$thisfile_audio ['streams'] [$streamindex] ['wformattag'] = $thisfile_audio ['wformattag'];
    197. 

  197. 					$thisfile_audio ['streams'] [$streamindex] ['bitrate_mode'] = $thisfile_audio ['bitrate_mode'];
    198. 

  198. 					$thisfile_audio ['streams'] [$streamindex] ['lossless'] = $thisfile_audio ['lossless'];
    199. 

  199. 					$thisfile_audio ['streams'] [$streamindex] ['dataformat'] = $thisfile_audio_dataformat;
    200. 

  200. 				}
    201. 

  201. 				
    202. 

  202. 				if (isset ( $thisfile_riff_WAVE ['rgad'] [0] ['data'] )) {
    203. 

  203. 					
    204. 

  204. 					// shortcuts
    205. 

  205. 					$rgadData = &$thisfile_riff_WAVE ['rgad'] [0] ['data'];
    206. 

  206. 					$thisfile_riff_raw ['rgad'] = array (
    207. 

  207. 														'track' => array (), 
    208. 

  208. 														'album' => array () );
    209. 

  209. 					$thisfile_riff_raw_rgad = &$thisfile_riff_raw ['rgad'];
    210. 

  210. 					$thisfile_riff_raw_rgad_track = &$thisfile_riff_raw_rgad ['track'];
    211. 

  211. 					$thisfile_riff_raw_rgad_album = &$thisfile_riff_raw_rgad ['album'];
    212. 

  212. 					
    213. 

  213. 					$thisfile_riff_raw_rgad ['fPeakAmplitude'] = getid3_lib::LittleEndian2Float ( substr ( $rgadData, 0, 4 ) );
    214. 

  214. 					$thisfile_riff_raw_rgad ['nRadioRgAdjust'] = $this->EitherEndian2Int ( substr ( $rgadData, 4, 2 ) );
    215. 

  215. 					$thisfile_riff_raw_rgad ['nAudiophileRgAdjust'] = $this->EitherEndian2Int ( substr ( $rgadData, 6, 2 ) );
    216. 

  216. 					
    217. 

  217. 					$nRadioRgAdjustBitstring = str_pad ( getid3_lib::Dec2Bin ( $thisfile_riff_raw_rgad ['nRadioRgAdjust'] ), 16, '0', STR_PAD_LEFT );
    218. 

  218. 					$nAudiophileRgAdjustBitstring = str_pad ( getid3_lib::Dec2Bin ( $thisfile_riff_raw_rgad ['nAudiophileRgAdjust'] ), 16, '0', STR_PAD_LEFT );
    219. 

  219. 					$thisfile_riff_raw_rgad_track ['name'] = getid3_lib::Bin2Dec ( substr ( $nRadioRgAdjustBitstring, 0, 3 ) );
    220. 

  220. 					$thisfile_riff_raw_rgad_track ['originator'] = getid3_lib::Bin2Dec ( substr ( $nRadioRgAdjustBitstring, 3, 3 ) );
    221. 

  221. 					$thisfile_riff_raw_rgad_track ['signbit'] = getid3_lib::Bin2Dec ( substr ( $nRadioRgAdjustBitstring, 6, 1 ) );
    222. 

  222. 					$thisfile_riff_raw_rgad_track ['adjustment'] = getid3_lib::Bin2Dec ( substr ( $nRadioRgAdjustBitstring, 7, 9 ) );
    223. 

  223. 					$thisfile_riff_raw_rgad_album ['name'] = getid3_lib::Bin2Dec ( substr ( $nAudiophileRgAdjustBitstring, 0, 3 ) );
    224. 

  224. 					$thisfile_riff_raw_rgad_album ['originator'] = getid3_lib::Bin2Dec ( substr ( $nAudiophileRgAdjustBitstring, 3, 3 ) );
    225. 

  225. 					$thisfile_riff_raw_rgad_album ['signbit'] = getid3_lib::Bin2Dec ( substr ( $nAudiophileRgAdjustBitstring, 6, 1 ) );
    226. 

  226. 					$thisfile_riff_raw_rgad_album ['adjustment'] = getid3_lib::Bin2Dec ( substr ( $nAudiophileRgAdjustBitstring, 7, 9 ) );
    227. 

  227. 					
    228. 

  228. 					$thisfile_riff ['rgad'] ['peakamplitude'] = $thisfile_riff_raw_rgad ['fPeakAmplitude'];
    229. 

  229. 					if (($thisfile_riff_raw_rgad_track ['name'] != 0) && ($thisfile_riff_raw_rgad_track ['originator'] != 0)) {
    230. 

  230. 						$thisfile_riff ['rgad'] ['track'] ['name'] = getid3_lib::RGADnameLookup ( $thisfile_riff_raw_rgad_track ['name'] );
    231. 

  231. 						$thisfile_riff ['rgad'] ['track'] ['originator'] = getid3_lib::RGADoriginatorLookup ( $thisfile_riff_raw_rgad_track ['originator'] );
    232. 

  232. 						$thisfile_riff ['rgad'] ['track'] ['adjustment'] = getid3_lib::RGADadjustmentLookup ( $thisfile_riff_raw_rgad_track ['adjustment'], $thisfile_riff_raw_rgad_track ['signbit'] );
    233. 

  233. 					}
    234. 

  234. 					if (($thisfile_riff_raw_rgad_album ['name'] != 0) && ($thisfile_riff_raw_rgad_album ['originator'] != 0)) {
    235. 

  235. 						$thisfile_riff ['rgad'] ['album'] ['name'] = getid3_lib::RGADnameLookup ( $thisfile_riff_raw_rgad_album ['name'] );
    236. 

  236. 						$thisfile_riff ['rgad'] ['album'] ['originator'] = getid3_lib::RGADoriginatorLookup ( $thisfile_riff_raw_rgad_album ['originator'] );
    237. 

  237. 						$thisfile_riff ['rgad'] ['album'] ['adjustment'] = getid3_lib::RGADadjustmentLookup ( $thisfile_riff_raw_rgad_album ['adjustment'], $thisfile_riff_raw_rgad_album ['signbit'] );
    238. 

  238. 					}
    239. 

  239. 				}
    240. 

  240. 				
    241. 

  241. 				if (isset ( $thisfile_riff_WAVE ['fact'] [0] ['data'] )) {
    242. 

  242. 					$thisfile_riff_raw ['fact'] ['NumberOfSamples'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_WAVE ['fact'] [0] ['data'], 0, 4 ) );
    243. 

  243. 					
    244. 

  244. 					// This should be a good way of calculating exact playtime,
    245. 

  245. 					// but some sample files have had incorrect number of samples,
    246. 

  246. 					// so cannot use this method
    247. 

  247. 					
    248. 

  248. 

  249. 					// if (!empty($thisfile_riff_raw['fmt ']['nSamplesPerSec'])) {
    250. 

  250. 					//     $info['playtime_seconds'] = (float) $thisfile_riff_raw['fact']['NumberOfSamples'] / $thisfile_riff_raw['fmt ']['nSamplesPerSec'];
    251. 

  251. 					// }
    252. 

  252. 				}
    253. 

  253. 				if (! empty ( $thisfile_riff_raw ['fmt '] ['nAvgBytesPerSec'] )) {
    254. 

  254. 					$thisfile_audio ['bitrate'] = getid3_lib::CastAsInt ( $thisfile_riff_raw ['fmt '] ['nAvgBytesPerSec'] * 8 );
    255. 

  255. 				}
    256. 

  256. 				
    257. 

  257. 				if (isset ( $thisfile_riff_WAVE ['bext'] [0] ['data'] )) {
    258. 

  258. 					// shortcut
    259. 

  259. 					$thisfile_riff_WAVE_bext_0 = &$thisfile_riff_WAVE ['bext'] [0];
    260. 

  260. 					
    261. 

  261. 					$thisfile_riff_WAVE_bext_0 ['title'] = trim ( substr ( $thisfile_riff_WAVE_bext_0 ['data'], 0, 256 ) );
    262. 

  262. 					$thisfile_riff_WAVE_bext_0 ['author'] = trim ( substr ( $thisfile_riff_WAVE_bext_0 ['data'], 256, 32 ) );
    263. 

  263. 					$thisfile_riff_WAVE_bext_0 ['reference'] = trim ( substr ( $thisfile_riff_WAVE_bext_0 ['data'], 288, 32 ) );
    264. 

  264. 					$thisfile_riff_WAVE_bext_0 ['origin_date'] = substr ( $thisfile_riff_WAVE_bext_0 ['data'], 320, 10 );
    265. 

  265. 					$thisfile_riff_WAVE_bext_0 ['origin_time'] = substr ( $thisfile_riff_WAVE_bext_0 ['data'], 330, 8 );
    266. 

  266. 					$thisfile_riff_WAVE_bext_0 ['time_reference'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE_bext_0 ['data'], 338, 8 ) );
    267. 

  267. 					$thisfile_riff_WAVE_bext_0 ['bwf_version'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE_bext_0 ['data'], 346, 1 ) );
    268. 

  268. 					$thisfile_riff_WAVE_bext_0 ['reserved'] = substr ( $thisfile_riff_WAVE_bext_0 ['data'], 347, 254 );
    269. 

  269. 					$thisfile_riff_WAVE_bext_0 ['coding_history'] = explode ( "\r\n", trim ( substr ( $thisfile_riff_WAVE_bext_0 ['data'], 601 ) ) );
    270. 

  270. 					if (preg_match ( '#^([0-9]{4}).([0-9]{2}).([0-9]{2})$#', $thisfile_riff_WAVE_bext_0 ['origin_date'], $matches_bext_date )) {
    271. 

  271. 						if (preg_match ( '#^([0-9]{2}).([0-9]{2}).([0-9]{2})$#', $thisfile_riff_WAVE_bext_0 ['origin_time'], $matches_bext_time )) {
    272. 

  272. 							list ( $dummy, $bext_timestamp ['year'], $bext_timestamp ['month'], $bext_timestamp ['day'] ) = $matches_bext_date;
    273. 

  273. 							list ( $dummy, $bext_timestamp ['hour'], $bext_timestamp ['minute'], $bext_timestamp ['second'] ) = $matches_bext_time;
    274. 

  274. 							$thisfile_riff_WAVE_bext_0 ['origin_date_unix'] = gmmktime ( $bext_timestamp ['hour'], $bext_timestamp ['minute'], $bext_timestamp ['second'], $bext_timestamp ['month'], $bext_timestamp ['day'], $bext_timestamp ['year'] );
    275. 

  275. 						} else {
    276. 

  276. 							$info ['warning'] [] = 'RIFF.WAVE.BEXT.origin_time is invalid';
    277. 

  277. 						}
    278. 

  278. 					} else {
    279. 

  279. 						$info ['warning'] [] = 'RIFF.WAVE.BEXT.origin_date is invalid';
    280. 

  280. 					}
    281. 

  281. 					$thisfile_riff ['comments'] ['author'] [] = $thisfile_riff_WAVE_bext_0 ['author'];
    282. 

  282. 					$thisfile_riff ['comments'] ['title'] [] = $thisfile_riff_WAVE_bext_0 ['title'];
    283. 

  283. 				}
    284. 

  284. 				
    285. 

  285. 				if (isset ( $thisfile_riff_WAVE ['MEXT'] [0] ['data'] )) {
    286. 

  286. 					// shortcut
    287. 

  287. 					$thisfile_riff_WAVE_MEXT_0 = &$thisfile_riff_WAVE ['MEXT'] [0];
    288. 

  288. 					
    289. 

  289. 					$thisfile_riff_WAVE_MEXT_0 ['raw'] ['sound_information'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE_MEXT_0 ['data'], 0, 2 ) );
    290. 

  290. 					$thisfile_riff_WAVE_MEXT_0 ['flags'] ['homogenous'] = ( bool ) ($thisfile_riff_WAVE_MEXT_0 ['raw'] ['sound_information'] & 0x0001);
    291. 

  291. 					if ($thisfile_riff_WAVE_MEXT_0 ['flags'] ['homogenous']) {
    292. 

  292. 						$thisfile_riff_WAVE_MEXT_0 ['flags'] ['padding'] = ($thisfile_riff_WAVE_MEXT_0 ['raw'] ['sound_information'] & 0x0002) ? false : true;
    293. 

  293. 						$thisfile_riff_WAVE_MEXT_0 ['flags'] ['22_or_44'] = ( bool ) ($thisfile_riff_WAVE_MEXT_0 ['raw'] ['sound_information'] & 0x0004);
    294. 

  294. 						$thisfile_riff_WAVE_MEXT_0 ['flags'] ['free_format'] = ( bool ) ($thisfile_riff_WAVE_MEXT_0 ['raw'] ['sound_information'] & 0x0008);
    295. 

  295. 						
    296. 

  296. 						$thisfile_riff_WAVE_MEXT_0 ['nominal_frame_size'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE_MEXT_0 ['data'], 2, 2 ) );
    297. 

  297. 					}
    298. 

  298. 					$thisfile_riff_WAVE_MEXT_0 ['anciliary_data_length'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE_MEXT_0 ['data'], 6, 2 ) );
    299. 

  299. 					$thisfile_riff_WAVE_MEXT_0 ['raw'] ['anciliary_data_def'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE_MEXT_0 ['data'], 8, 2 ) );
    300. 

  300. 					$thisfile_riff_WAVE_MEXT_0 ['flags'] ['anciliary_data_left'] = ( bool ) ($thisfile_riff_WAVE_MEXT_0 ['raw'] ['anciliary_data_def'] & 0x0001);
    301. 

  301. 					$thisfile_riff_WAVE_MEXT_0 ['flags'] ['anciliary_data_free'] = ( bool ) ($thisfile_riff_WAVE_MEXT_0 ['raw'] ['anciliary_data_def'] & 0x0002);
    302. 

  302. 					$thisfile_riff_WAVE_MEXT_0 ['flags'] ['anciliary_data_right'] = ( bool ) ($thisfile_riff_WAVE_MEXT_0 ['raw'] ['anciliary_data_def'] & 0x0004);
    303. 

  303. 				}
    304. 

  304. 				
    305. 

  305. 				if (isset ( $thisfile_riff_WAVE ['cart'] [0] ['data'] )) {
    306. 

  306. 					// shortcut
    307. 

  307. 					$thisfile_riff_WAVE_cart_0 = &$thisfile_riff_WAVE ['cart'] [0];
    308. 

  308. 					
    309. 

  309. 					$thisfile_riff_WAVE_cart_0 ['version'] = substr ( $thisfile_riff_WAVE_cart_0 ['data'], 0, 4 );
    310. 

  310. 					$thisfile_riff_WAVE_cart_0 ['title'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 4, 64 ) );
    311. 

  311. 					$thisfile_riff_WAVE_cart_0 ['artist'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 68, 64 ) );
    312. 

  312. 					$thisfile_riff_WAVE_cart_0 ['cut_id'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 132, 64 ) );
    313. 

  313. 					$thisfile_riff_WAVE_cart_0 ['client_id'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 196, 64 ) );
    314. 

  314. 					$thisfile_riff_WAVE_cart_0 ['category'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 260, 64 ) );
    315. 

  315. 					$thisfile_riff_WAVE_cart_0 ['classification'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 324, 64 ) );
    316. 

  316. 					$thisfile_riff_WAVE_cart_0 ['out_cue'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 388, 64 ) );
    317. 

  317. 					$thisfile_riff_WAVE_cart_0 ['start_date'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 452, 10 ) );
    318. 

  318. 					$thisfile_riff_WAVE_cart_0 ['start_time'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 462, 8 ) );
    319. 

  319. 					$thisfile_riff_WAVE_cart_0 ['end_date'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 470, 10 ) );
    320. 

  320. 					$thisfile_riff_WAVE_cart_0 ['end_time'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 480, 8 ) );
    321. 

  321. 					$thisfile_riff_WAVE_cart_0 ['producer_app_id'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 488, 64 ) );
    322. 

  322. 					$thisfile_riff_WAVE_cart_0 ['producer_app_version'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 552, 64 ) );
    323. 

  323. 					$thisfile_riff_WAVE_cart_0 ['user_defined_text'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 616, 64 ) );
    324. 

  324. 					$thisfile_riff_WAVE_cart_0 ['zero_db_reference'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 680, 4 ), true );
    325. 

  325. 					for($i = 0; $i < 8; $i ++) {
    326. 

  326. 						$thisfile_riff_WAVE_cart_0 ['post_time'] [$i] ['usage_fourcc'] = substr ( $thisfile_riff_WAVE_cart_0 ['data'], 684 + ($i * 8), 4 );
    327. 

  327. 						$thisfile_riff_WAVE_cart_0 ['post_time'] [$i] ['timer_value'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 684 + ($i * 8) + 4, 4 ) );
    328. 

  328. 					}
    329. 

  329. 					$thisfile_riff_WAVE_cart_0 ['url'] = trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 748, 1024 ) );
    330. 

  330. 					$thisfile_riff_WAVE_cart_0 ['tag_text'] = explode ( "\r\n", trim ( substr ( $thisfile_riff_WAVE_cart_0 ['data'], 1772 ) ) );
    331. 

  331. 					
    332. 

  332. 					$thisfile_riff ['comments'] ['artist'] [] = $thisfile_riff_WAVE_cart_0 ['artist'];
    333. 

  333. 					$thisfile_riff ['comments'] ['title'] [] = $thisfile_riff_WAVE_cart_0 ['title'];
    334. 

  334. 				}
    335. 

  335. 				
    336. 

  336. 				if (isset ( $thisfile_riff_WAVE ['SNDM'] [0] ['data'] )) {
    337. 

  337. 					// SoundMiner metadata
    338. 

  338. 					
    339. 

  339. 

  340. 					// shortcuts
    341. 

  341. 					$thisfile_riff_WAVE_SNDM_0 = &$thisfile_riff_WAVE ['SNDM'] [0];
    342. 

  342. 					$thisfile_riff_WAVE_SNDM_0_data = &$thisfile_riff_WAVE_SNDM_0 ['data'];
    343. 

  343. 					$SNDM_startoffset = 0;
    344. 

  344. 					$SNDM_endoffset = $thisfile_riff_WAVE_SNDM_0 ['size'];
    345. 

  345. 					
    346. 

  346. 					while ( $SNDM_startoffset < $SNDM_endoffset ) {
    347. 

  347. 						$SNDM_thisTagOffset = 0;
    348. 

  348. 						$SNDM_thisTagSize = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_WAVE_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 4 ) );
    349. 

  349. 						$SNDM_thisTagOffset += 4;
    350. 

  350. 						$SNDM_thisTagKey = substr ( $thisfile_riff_WAVE_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 4 );
    351. 

  351. 						$SNDM_thisTagOffset += 4;
    352. 

  352. 						$SNDM_thisTagDataSize = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_WAVE_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 2 ) );
    353. 

  353. 						$SNDM_thisTagOffset += 2;
    354. 

  354. 						$SNDM_thisTagDataFlags = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_WAVE_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, 2 ) );
    355. 

  355. 						$SNDM_thisTagOffset += 2;
    356. 

  356. 						$SNDM_thisTagDataText = substr ( $thisfile_riff_WAVE_SNDM_0_data, $SNDM_startoffset + $SNDM_thisTagOffset, $SNDM_thisTagDataSize );
    357. 

  357. 						$SNDM_thisTagOffset += $SNDM_thisTagDataSize;
    358. 

  358. 						
    359. 

  359. 						if ($SNDM_thisTagSize != (4 + 4 + 2 + 2 + $SNDM_thisTagDataSize)) {
    360. 

  360. 							$info ['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 ' . ($thisfile_riff_WAVE_SNDM_0 ['offset'] + $SNDM_startoffset) . ')';
    361. 

  361. 							break;
    362. 

  362. 						} elseif ($SNDM_thisTagSize <= 0) {
    363. 

  363. 							$info ['warning'] [] = 'RIFF.WAVE.SNDM.data contains zero-size tag at offset ' . $SNDM_startoffset . ' (file offset ' . ($thisfile_riff_WAVE_SNDM_0 ['offset'] + $SNDM_startoffset) . ')';
    364. 

  364. 							break;
    365. 

  365. 						}
    366. 

  366. 						$SNDM_startoffset += $SNDM_thisTagSize;
    367. 

  367. 						
    368. 

  368. 						$thisfile_riff_WAVE_SNDM_0 ['parsed_raw'] [$SNDM_thisTagKey] = $SNDM_thisTagDataText;
    369. 

  369. 						if (($parsedkey = $this->RIFFwaveSNDMtagLookup ( $SNDM_thisTagKey )) != false) {
    370. 

  370. 							$thisfile_riff_WAVE_SNDM_0 ['parsed'] [$parsedkey] = $SNDM_thisTagDataText;
    371. 

  371. 						} else {
    372. 

  372. 							$info ['warning'] [] = 'RIFF.WAVE.SNDM contains unknown tag "' . $SNDM_thisTagKey . '" at offset ' . $SNDM_startoffset . ' (file offset ' . ($thisfile_riff_WAVE_SNDM_0 ['offset'] + $SNDM_startoffset) . ')';
    373. 

  373. 						}
    374. 

  374. 					}
    375. 

  375. 					
    376. 

  376. 					$tagmapping = array (
    377. 

  377. 										'tracktitle' => 'title', 
    378. 

  378. 										'category' => 'genre', 
    379. 

  379. 										'cdtitle' => 'album', 
    380. 

  380. 										'tracktitle' => 'title' );
    381. 

  381. 					foreach ( $tagmapping as $fromkey => $tokey ) {
    382. 

  382. 						if (isset ( $thisfile_riff_WAVE_SNDM_0 ['parsed'] [$fromkey] )) {
    383. 

  383. 							$thisfile_riff ['comments'] [$tokey] [] = $thisfile_riff_WAVE_SNDM_0 ['parsed'] [$fromkey];
    384. 

  384. 						}
    385. 

  385. 					}
    386. 

  386. 				}
    387. 

  387. 				
    388. 

  388. 				if (isset ( $thisfile_riff_WAVE ['iXML'] [0] ['data'] )) {
    389. 

  389. 					// requires functions simplexml_load_string and get_object_vars
    390. 

  390. 					if (($parsedXML = getid3_lib::XML2array ( $thisfile_riff_WAVE ['iXML'] [0] ['data'] )) != false) {
    391. 

  391. 						$thisfile_riff_WAVE ['iXML'] [0] ['parsed'] = $parsedXML;
    392. 

  392. 						if (isset ( $parsedXML ['SPEED'] ['MASTER_SPEED'] )) {
    393. 

  393. 							@list ( $numerator, $denominator ) = explode ( '/', $parsedXML ['SPEED'] ['MASTER_SPEED'] );
    394. 

  394. 							$thisfile_riff_WAVE ['iXML'] [0] ['master_speed'] = $numerator / ($denominator ? $denominator : 1000);
    395. 

  395. 						}
    396. 

  396. 						if (isset ( $parsedXML ['SPEED'] ['TIMECODE_RATE'] )) {
    397. 

  397. 							@list ( $numerator, $denominator ) = explode ( '/', $parsedXML ['SPEED'] ['TIMECODE_RATE'] );
    398. 

  398. 							$thisfile_riff_WAVE ['iXML'] [0] ['timecode_rate'] = $numerator / ($denominator ? $denominator : 1000);
    399. 

  399. 						}
    400. 

  400. 						if (isset ( $parsedXML ['SPEED'] ['TIMESTAMP_SAMPLES_SINCE_MIDNIGHT_LO'] ) && ! empty ( $parsedXML ['SPEED'] ['TIMESTAMP_SAMPLE_RATE'] ) && ! empty ( $thisfile_riff_WAVE ['iXML'] [0] ['timecode_rate'] )) {
    401. 

  401. 							$samples_since_midnight = floatval ( ltrim ( $parsedXML ['SPEED'] ['TIMESTAMP_SAMPLES_SINCE_MIDNIGHT_HI'] . $parsedXML ['SPEED'] ['TIMESTAMP_SAMPLES_SINCE_MIDNIGHT_LO'], '0' ) );
    402. 

  402. 							$thisfile_riff_WAVE ['iXML'] [0] ['timecode_seconds'] = $samples_since_midnight / $parsedXML ['SPEED'] ['TIMESTAMP_SAMPLE_RATE'];
    403. 

  403. 							$h = floor ( $thisfile_riff_WAVE ['iXML'] [0] ['timecode_seconds'] / 3600 );
    404. 

  404. 							$m = floor ( ($thisfile_riff_WAVE ['iXML'] [0] ['timecode_seconds'] - ($h * 3600)) / 60 );
    405. 

  405. 							$s = floor ( $thisfile_riff_WAVE ['iXML'] [0] ['timecode_seconds'] - ($h * 3600) - ($m * 60) );
    406. 

  406. 							$f = ($thisfile_riff_WAVE ['iXML'] [0] ['timecode_seconds'] - ($h * 3600) - ($m * 60) - $s) * $thisfile_riff_WAVE ['iXML'] [0] ['timecode_rate'];
    407. 

  407. 							$thisfile_riff_WAVE ['iXML'] [0] ['timecode_string'] = sprintf ( '%02d:%02d:%02d:%05.2f', $h, $m, $s, $f );
    408. 

  408. 							$thisfile_riff_WAVE ['iXML'] [0] ['timecode_string_round'] = sprintf ( '%02d:%02d:%02d:%02d', $h, $m, $s, round ( $f ) );
    409. 

  409. 						}
    410. 

  410. 						unset ( $parsedXML );
    411. 

  411. 					}
    412. 

  412. 				}
    413. 

  413. 				
    414. 

  414. 				if (! isset ( $thisfile_audio ['bitrate'] ) && isset ( $thisfile_riff_audio [$streamindex] ['bitrate'] )) {
    415. 

  415. 					$thisfile_audio ['bitrate'] = $thisfile_riff_audio [$streamindex] ['bitrate'];
    416. 

  416. 					$info ['playtime_seconds'] = ( float ) ((($info ['avdataend'] - $info ['avdataoffset']) * 8) / $thisfile_audio ['bitrate']);
    417. 

  417. 				}
    418. 

  418. 				
    419. 

  419. 				if (! empty ( $info ['wavpack'] )) {
    420. 

  420. 					$thisfile_audio_dataformat = 'wavpack';
    421. 

  421. 					$thisfile_audio ['bitrate_mode'] = 'vbr';
    422. 

  422. 					$thisfile_audio ['encoder'] = 'WavPack v' . $info ['wavpack'] ['version'];
    423. 

  423. 					
    424. 

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

  425. 					$info ['avdataend'] = $Original ['avdataend'];
    426. 

  426. 					$thisfile_audio ['bitrate'] = (($info ['avdataend'] - $info ['avdataoffset']) * 8) / $info ['playtime_seconds'];
    427. 

  427. 					
    428. 

  428. 					fseek ( $this->getid3->fp, $info ['avdataoffset'] - 44, SEEK_SET );
    429. 

  429. 					$RIFFdata = fread ( $this->getid3->fp, 44 );
    430. 

  430. 					$OrignalRIFFheaderSize = getid3_lib::LittleEndian2Int ( substr ( $RIFFdata, 4, 4 ) ) + 8;
    431. 

  431. 					$OrignalRIFFdataSize = getid3_lib::LittleEndian2Int ( substr ( $RIFFdata, 40, 4 ) ) + 44;
    432. 

  432. 					
    433. 

  433. 					if ($OrignalRIFFheaderSize > $OrignalRIFFdataSize) {
    434. 

  434. 						$info ['avdataend'] -= ($OrignalRIFFheaderSize - $OrignalRIFFdataSize);
    435. 

  435. 						fseek ( $this->getid3->fp, $info ['avdataend'], SEEK_SET );
    436. 

  436. 						$RIFFdata .= fread ( $this->getid3->fp, $OrignalRIFFheaderSize - $OrignalRIFFdataSize );
    437. 

  437. 					}
    438. 

  438. 					
    439. 

  439. 					// move the data chunk after all other chunks (if any)
    440. 

  440. 					// so that the RIFF parser doesn't see EOF when trying
    441. 

  441. 					// to skip over the data chunk
    442. 

  442. 					$RIFFdata = substr ( $RIFFdata, 0, 36 ) . substr ( $RIFFdata, 44 ) . substr ( $RIFFdata, 36, 8 );
    443. 

  443. 					$getid3_riff = new getid3_riff ( $this->getid3 );
    444. 

  444. 					$getid3_riff->ParseRIFFdata ( $RIFFdata );
    445. 

  445. 					unset ( $getid3_riff );
    446. 

  446. 				}
    447. 

  447. 				
    448. 

  448. 				if (isset ( $thisfile_riff_raw ['fmt '] ['wFormatTag'] )) {
    449. 

  449. 					switch ($thisfile_riff_raw ['fmt '] ['wFormatTag']) {
    450. 

  450. 						case 0x0001 : // PCM
    451. 

  451. 							if (! empty ( $info ['ac3'] )) {
    452. 

  452. 								// Dolby Digital WAV files masquerade as PCM-WAV, but they're not
    453. 

  453. 								$thisfile_audio ['wformattag'] = 0x2000;
    454. 

  454. 								$thisfile_audio ['codec'] = $this->RIFFwFormatTagLookup ( $thisfile_audio ['wformattag'] );
    455. 

  455. 								$thisfile_audio ['lossless'] = false;
    456. 

  456. 								$thisfile_audio ['bitrate'] = $info ['ac3'] ['bitrate'];
    457. 

  457. 								$thisfile_audio ['sample_rate'] = $info ['ac3'] ['sample_rate'];
    458. 

  458. 							}
    459. 

  459. 							break;
    460. 

  460. 						case 0x08AE : // ClearJump LiteWave
    461. 

  461. 							$thisfile_audio ['bitrate_mode'] = 'vbr';
    462. 

  462. 							$thisfile_audio_dataformat = 'litewave';
    463. 

  463. 							
    464. 

  464. 							//typedef struct tagSLwFormat {
    465. 

  465. 							//  WORD    m_wCompFormat;     // low byte defines compression method, high byte is compression flags
    466. 

  466. 							//  DWORD   m_dwScale;         // scale factor for lossy compression
    467. 

  467. 							//  DWORD   m_dwBlockSize;     // number of samples in encoded blocks
    468. 

  468. 							//  WORD    m_wQuality;        // alias for the scale factor
    469. 

  469. 							//  WORD    m_wMarkDistance;   // distance between marks in bytes
    470. 

  470. 							//  WORD    m_wReserved;
    471. 

  471. 							//
    472. 

  472. 							//  //following paramters are ignored if CF_FILESRC is not set
    473. 

  473. 							//  DWORD   m_dwOrgSize;       // original file size in bytes
    474. 

  474. 							//  WORD    m_bFactExists;     // indicates if 'fact' chunk exists in the original file
    475. 

  475. 							//  DWORD   m_dwRiffChunkSize; // riff chunk size in the original file
    476. 

  476. 							//
    477. 

  477. 							//  PCMWAVEFORMAT m_OrgWf;     // original wave format
    478. 

  478. 							// }SLwFormat, *PSLwFormat;
    479. 

  479. 							
    480. 

  480. 

  481. 							// shortcut
    482. 

  482. 							$thisfile_riff ['litewave'] ['raw'] = array ();
    483. 

  483. 							$thisfile_riff_litewave = &$thisfile_riff ['litewave'];
    484. 

  484. 							$thisfile_riff_litewave_raw = &$thisfile_riff_litewave ['raw'];
    485. 

  485. 							
    486. 

  486. 							$thisfile_riff_litewave_raw ['compression_method'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE ['fmt '] [0] ['data'], 18, 1 ) );
    487. 

  487. 							$thisfile_riff_litewave_raw ['compression_flags'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE ['fmt '] [0] ['data'], 19, 1 ) );
    488. 

  488. 							$thisfile_riff_litewave_raw ['m_dwScale'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE ['fmt '] [0] ['data'], 20, 4 ) );
    489. 

  489. 							$thisfile_riff_litewave_raw ['m_dwBlockSize'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE ['fmt '] [0] ['data'], 24, 4 ) );
    490. 

  490. 							$thisfile_riff_litewave_raw ['m_wQuality'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE ['fmt '] [0] ['data'], 28, 2 ) );
    491. 

  491. 							$thisfile_riff_litewave_raw ['m_wMarkDistance'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE ['fmt '] [0] ['data'], 30, 2 ) );
    492. 

  492. 							$thisfile_riff_litewave_raw ['m_wReserved'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE ['fmt '] [0] ['data'], 32, 2 ) );
    493. 

  493. 							$thisfile_riff_litewave_raw ['m_dwOrgSize'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE ['fmt '] [0] ['data'], 34, 4 ) );
    494. 

  494. 							$thisfile_riff_litewave_raw ['m_bFactExists'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE ['fmt '] [0] ['data'], 38, 2 ) );
    495. 

  495. 							$thisfile_riff_litewave_raw ['m_dwRiffChunkSize'] = getid3_lib::LittleEndian2Int ( substr ( $thisfile_riff_WAVE ['fmt '] [0] ['data'], 40, 4 ) );
    496. 

  496. 							
    497. 

  497. 							//$thisfile_riff_litewave['quality_factor'] = intval(round((2000 - $thisfile_riff_litewave_raw['m_dwScale']) / 20));
    498. 

  498. 							$thisfile_riff_litewave ['quality_factor'] = $thisfile_riff_litewave_raw ['m_wQuality'];
    499. 

  499. 							
    500. 

  500. 							$thisfile_riff_litewave ['flags'] ['raw_source'] = ($thisfile_riff_litewave_raw ['compression_flags'] & 0x01) ? false : true;
    501. 

  501. 							$thisfile_riff_litewave ['flags'] ['vbr_blocksize'] = ($thisfile_riff_litewave_raw ['compression_flags'] & 0x02) ? false : true;
    502. 

  502. 							$thisfile_riff_litewave ['flags'] ['seekpoints'] = ( bool ) ($thisfile_riff_litewave_raw ['compression_flags'] & 0x04);
    503. 

  503. 							
    504. 

  504. 							$thisfile_audio ['lossless'] = (($thisfile_riff_litewave_raw ['m_wQuality'] == 100) ? true : false);
    505. 

  505. 							$thisfile_audio ['encoder_options'] = '-q' . $thisfile_riff_litewave ['quality_factor'];
    506. 

  506. 							break;
    507. 

  507. 						
    508. 

  508. 						default :
    509. 

  509. 							break;
    510. 

  510. 					}
    511. 

  511. 				}
    512. 

  512. 				if ($info ['avdataend'] > $info ['filesize']) {
    513. 

  513. 					switch (! empty ( $thisfile_audio_dataformat ) ? $thisfile_audio_dataformat : '') {
    514. 

  514. 						case 'wavpack' : // WavPack
    515. 

  515. 						case 'lpac' : // LPAC
    516. 

  516. 						case 'ofr' : // OptimFROG
    517. 

  517. 						case 'ofs' : // OptimFROG DualStream
    518. 

  518. 							// lossless compressed audio formats that keep original RIFF headers - skip warning
    519. 

  519. 							break;
    520. 

  520. 						
    521. 

  521. 						case 'litewave' :
    522. 

  522. 							if (($info ['avdataend'] - $info ['filesize']) == 1) {
    523. 

  523. 								// LiteWave appears to incorrectly *not* pad actual output file
    524. 

  524. 								// to nearest WORD boundary so may appear to be short by one
    525. 

  525. 								// byte, in which case - skip warning
    526. 

  526. 							} else {
    527. 

  527. 								// Short by more than one byte, throw warning
    528. 

  528. 								$info ['warning'] [] = 'Probably truncated file - expecting ' . $thisfile_riff [$RIFFsubtype] ['data'] [0] ['size'] . ' bytes of data, only found ' . ($info ['filesize'] - $info ['avdataoffset']) . ' (short by ' . ($thisfile_riff [$RIFFsubtype] ['data'] [0] ['size'] - ($info ['filesize'] - $info ['avdataoffset'])) . ' bytes)';
    529. 

  529. 								$info ['avdataend'] = $info ['filesize'];
    530. 

  530. 							}
    531. 

  531. 							break;
    532. 

  532. 						
    533. 

  533. 						default :
    534. 

  534. 							if ((($info ['avdataend'] - $info ['filesize']) == 1) && (($thisfile_riff [$RIFFsubtype] ['data'] [0] ['size'] % 2) == 0) && ((($info ['filesize'] - $info ['avdataoffset']) % 2) == 1)) {
    535. 

  535. 								// output file appears to be incorrectly *not* padded to nearest WORD boundary
    536. 

  536. 								// Output less severe warning
    537. 

  537. 								$info ['warning'] [] = 'File should probably be padded to nearest WORD boundary, but it is not (expecting ' . $thisfile_riff [$RIFFsubtype] ['data'] [0] ['size'] . ' bytes of data, only found ' . ($info ['filesize'] - $info ['avdataoffset']) . ' therefore short by ' . ($thisfile_riff [$RIFFsubtype] ['data'] [0] ['size'] - ($info ['filesize'] - $info ['avdataoffset'])) . ' bytes)';
    538. 

  538. 								$info ['avdataend'] = $info ['filesize'];
    539. 

  539. 							} else {
    540. 

  540. 								// Short by more than one byte, throw warning
    541. 

  541. 								$info ['warning'] [] = 'Probably truncated file - expecting ' . $thisfile_riff [$RIFFsubtype] ['data'] [0] ['size'] . ' bytes of data, only found ' . ($info ['filesize'] - $info ['avdataoffset']) . ' (short by ' . ($thisfile_riff [$RIFFsubtype] ['data'] [0] ['size'] - ($info ['filesize'] - $info ['avdataoffset'])) . ' bytes)';
    542. 

  542. 								$info ['avdataend'] = $info ['filesize'];
    543. 

  543. 							}
    544. 

  544. 							break;
    545. 

  545. 					}
    546. 

  546. 				}
    547. 

  547. 				if (! empty ( $info ['mpeg'] ['audio'] ['LAME'] ['audio_bytes'] )) {
    548. 

  548. 					if ((($info ['avdataend'] - $info ['avdataoffset']) - $info ['mpeg'] ['audio'] ['LAME'] ['audio_bytes']) == 1) {
    549. 

  549. 						$info ['avdataend'] --;
    550. 

  550. 						$info ['warning'] [] = 'Extra null byte at end of MP3 data assumed to be RIFF padding and therefore ignored';
    551. 

  551. 					}
    552. 

  552. 				}
    553. 

  553. 				if (isset ( $thisfile_audio_dataformat ) && ($thisfile_audio_dataformat == 'ac3')) {
    554. 

  554. 					unset ( $thisfile_audio ['bits_per_sample'] );
    555. 

  555. 					if (! empty ( $info ['ac3'] ['bitrate'] ) && ($info ['ac3'] ['bitrate'] != $thisfile_audio ['bitrate'])) {
    556. 

  556. 						$thisfile_audio ['bitrate'] = $info ['ac3'] ['bitrate'];
    557. 

  557. 					}
    558. 

  558. 				}
    559. 

  559. 				break;
    560. 

  560. 			
    561. 

  561. 			case 'AVI ' :
    562. 

  562. 				$thisfile_video ['bitrate_mode'] = 'vbr'; // maybe not, but probably
    563. 

  563. 				$thisfile_video ['dataformat'] = 'avi';
    564. 

  564. 				$info ['mime_type'] = 'video/avi';
    565. 

  565. 				
    566. 

  566. 				if (isset ( $thisfile_riff [$RIFFsubtype] ['movi'] ['offset'] )) {
    567. 

  567. 					$info ['avdataoffset'] = $thisfile_riff [$RIFFsubtype] ['movi'] ['offset'] + 8;
    568. 

  568. 					if (isset ( $thisfile_riff ['AVIX'] )) {
    569. 

  569. 						$info ['avdataend'] = $thisfile_riff ['AVIX'] [(count ( $thisfile_riff ['AVIX'] ) - 1)] ['chunks'] ['movi'] ['offset'] + $thisfile_riff ['AVIX'] [(count ( $thisfile_riff ['AVIX'] ) - 1)] ['chunks'] ['movi'] ['size'];
    570. 

  570. 					} else {
    571. 

  571. 						$info ['avdataend'] = $thisfile_riff ['AVI '] ['movi'] ['offset'] + $thisfile_riff ['AVI '] ['movi'] ['size'];
    572. 

  572. 					}
    573. 

  573. 					if ($info ['avdataend'] > $info ['filesize']) {
    574. 

  574. 						$info ['warning'] [] = 'Probably truncated file - expecting ' . ($info ['avdataend'] - $info ['avdataoffset']) . ' bytes of data, only found ' . ($info ['filesize'] - $info ['avdataoffset']) . ' (short by ' . ($info ['avdataend'] - $info ['filesize']) . ' bytes)';
    575. 

  575. 						$info ['avdataend'] = $info ['filesize'];
    576. 

  576. 					}
    577. 

  577. 				}
    578. 

  578. 				
    579. 

  579. 				if (isset ( $thisfile_riff ['AVI '] ['hdrl'] ['strl'] ['indx'] )) {
    580. 

  580. 					//$bIndexType = array(
    581. 

  581. 					//	0x00 => 'AVI_INDEX_OF_INDEXES',
    582. 

  582. 					//	0x01 => 'AVI_INDEX_OF_CHUNKS',
    583. 

  583. 					//	0x80 => 'AVI_INDEX_IS_DATA',
    584. 

  584. 					//);
    585. 

  585. 					//$bIndexSubtype = array(
    586. 

  586. 					//	0x01 => array(
    587. 

  587. 					//		0x01 => 'AVI_INDEX_2FIELD',
    588. 

  588. 					//	),
    589. 

  589. 					//);
    590. 

  590. 					foreach ( $thisfile_riff ['AVI '] ['hdrl'] ['strl'] ['indx'] as $streamnumber => $steamdataarray ) {
    591. 

  591. 						$thisfile_riff_avi_hdrl_strl_indx_stream_data = &$thisfile_riff ['AVI '] ['hdrl'] ['strl'] ['indx'] [$streamnumber] ['data'];
    592. 

  592. 						
    593. 

  593. 						$thisfile_riff_raw ['indx'] [$streamnumber] ['wLongsPerEntry'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_avi_hdrl_strl_indx_stream_data, 0, 2 ) );
    594. 

  594. 						$thisfile_riff_raw ['indx'] [$streamnumber] ['bIndexSubType'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_avi_hdrl_strl_indx_stream_data, 2, 1 ) );
    595. 

  595. 						$thisfile_riff_raw ['indx'] [$streamnumber] ['bIndexType'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_avi_hdrl_strl_indx_stream_data, 3, 1 ) );
    596. 

  596. 						$thisfile_riff_raw ['indx'] [$streamnumber] ['nEntriesInUse'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_avi_hdrl_strl_indx_stream_data, 4, 4 ) );
    597. 

  597. 						$thisfile_riff_raw ['indx'] [$streamnumber] ['dwChunkId'] = substr ( $thisfile_riff_avi_hdrl_strl_indx_stream_data, 8, 4 );
    598. 

  598. 						$thisfile_riff_raw ['indx'] [$streamnumber] ['dwReserved'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_avi_hdrl_strl_indx_stream_data, 12, 4 ) );
    599. 

  599. 						
    600. 

  600. 						//$thisfile_riff_raw['indx'][$streamnumber]['bIndexType_name']    =    $bIndexType[$thisfile_riff_raw['indx'][$streamnumber]['bIndexType']];
    601. 

  601. 						//$thisfile_riff_raw['indx'][$streamnumber]['bIndexSubType_name'] = $bIndexSubtype[$thisfile_riff_raw['indx'][$streamnumber]['bIndexType']][$thisfile_riff_raw['indx'][$streamnumber]['bIndexSubType']];
    602. 

  602. 						
    603. 

  603. 

  604. 						unset ( $thisfile_riff_avi_hdrl_strl_indx_stream_data );
    605. 

  605. 					}
    606. 

  606. 				}
    607. 

  607. 				if (isset ( $thisfile_riff ['AVI '] ['hdrl'] ['avih'] [$streamindex] ['data'] )) {
    608. 

  608. 					$avihData = $thisfile_riff ['AVI '] ['hdrl'] ['avih'] [$streamindex] ['data'];
    609. 

  609. 					
    610. 

  610. 					// shortcut
    611. 

  611. 					$thisfile_riff_raw ['avih'] = array ();
    612. 

  612. 					$thisfile_riff_raw_avih = &$thisfile_riff_raw ['avih'];
    613. 

  613. 					
    614. 

  614. 					$thisfile_riff_raw_avih ['dwMicroSecPerFrame'] = $this->EitherEndian2Int ( substr ( $avihData, 0, 4 ) ); // frame display rate (or 0L)
    615. 

  615. 					if ($thisfile_riff_raw_avih ['dwMicroSecPerFrame'] == 0) {
    616. 

  616. 						$info ['error'] [] = 'Corrupt RIFF file: avih.dwMicroSecPerFrame == zero';
    617. 

  617. 						return false;
    618. 

  618. 					}
    619. 

  619. 					$thisfile_riff_raw_avih ['dwMaxBytesPerSec'] = $this->EitherEndian2Int ( substr ( $avihData, 4, 4 ) ); // max. transfer rate
    620. 

  620. 					$thisfile_riff_raw_avih ['dwPaddingGranularity'] = $this->EitherEndian2Int ( substr ( $avihData, 8, 4 ) ); // pad to multiples of this size; normally 2K.
    621. 

  621. 					$thisfile_riff_raw_avih ['dwFlags'] = $this->EitherEndian2Int ( substr ( $avihData, 12, 4 ) ); // the ever-present flags
    622. 

  622. 					$thisfile_riff_raw_avih ['dwTotalFrames'] = $this->EitherEndian2Int ( substr ( $avihData, 16, 4 ) ); // # frames in file
    623. 

  623. 					$thisfile_riff_raw_avih ['dwInitialFrames'] = $this->EitherEndian2Int ( substr ( $avihData, 20, 4 ) );
    624. 

  624. 					$thisfile_riff_raw_avih ['dwStreams'] = $this->EitherEndian2Int ( substr ( $avihData, 24, 4 ) );
    625. 

  625. 					$thisfile_riff_raw_avih ['dwSuggestedBufferSize'] = $this->EitherEndian2Int ( substr ( $avihData, 28, 4 ) );
    626. 

  626. 					$thisfile_riff_raw_avih ['dwWidth'] = $this->EitherEndian2Int ( substr ( $avihData, 32, 4 ) );
    627. 

  627. 					$thisfile_riff_raw_avih ['dwHeight'] = $this->EitherEndian2Int ( substr ( $avihData, 36, 4 ) );
    628. 

  628. 					$thisfile_riff_raw_avih ['dwScale'] = $this->EitherEndian2Int ( substr ( $avihData, 40, 4 ) );
    629. 

  629. 					$thisfile_riff_raw_avih ['dwRate'] = $this->EitherEndian2Int ( substr ( $avihData, 44, 4 ) );
    630. 

  630. 					$thisfile_riff_raw_avih ['dwStart'] = $this->EitherEndian2Int ( substr ( $avihData, 48, 4 ) );
    631. 

  631. 					$thisfile_riff_raw_avih ['dwLength'] = $this->EitherEndian2Int ( substr ( $avihData, 52, 4 ) );
    632. 

  632. 					
    633. 

  633. 					$thisfile_riff_raw_avih ['flags'] ['hasindex'] = ( bool ) ($thisfile_riff_raw_avih ['dwFlags'] & 0x00000010);
    634. 

  634. 					$thisfile_riff_raw_avih ['flags'] ['mustuseindex'] = ( bool ) ($thisfile_riff_raw_avih ['dwFlags'] & 0x00000020);
    635. 

  635. 					$thisfile_riff_raw_avih ['flags'] ['interleaved'] = ( bool ) ($thisfile_riff_raw_avih ['dwFlags'] & 0x00000100);
    636. 

  636. 					$thisfile_riff_raw_avih ['flags'] ['trustcktype'] = ( bool ) ($thisfile_riff_raw_avih ['dwFlags'] & 0x00000800);
    637. 

  637. 					$thisfile_riff_raw_avih ['flags'] ['capturedfile'] = ( bool ) ($thisfile_riff_raw_avih ['dwFlags'] & 0x00010000);
    638. 

  638. 					$thisfile_riff_raw_avih ['flags'] ['copyrighted'] = ( bool ) ($thisfile_riff_raw_avih ['dwFlags'] & 0x00020010);
    639. 

  639. 					
    640. 

  640. 					// shortcut
    641. 

  641. 					$thisfile_riff_video [$streamindex] = array ();
    642. 

  642. 					$thisfile_riff_video_current = &$thisfile_riff_video [$streamindex];
    643. 

  643. 					
    644. 

  644. 					if ($thisfile_riff_raw_avih ['dwWidth'] > 0) {
    645. 

  645. 						$thisfile_riff_video_current ['frame_width'] = $thisfile_riff_raw_avih ['dwWidth'];
    646. 

  646. 						$thisfile_video ['resolution_x'] = $thisfile_riff_video_current ['frame_width'];
    647. 

  647. 					}
    648. 

  648. 					if ($thisfile_riff_raw_avih ['dwHeight'] > 0) {
    649. 

  649. 						$thisfile_riff_video_current ['frame_height'] = $thisfile_riff_raw_avih ['dwHeight'];
    650. 

  650. 						$thisfile_video ['resolution_y'] = $thisfile_riff_video_current ['frame_height'];
    651. 

  651. 					}
    652. 

  652. 					if ($thisfile_riff_raw_avih ['dwTotalFrames'] > 0) {
    653. 

  653. 						$thisfile_riff_video_current ['total_frames'] = $thisfile_riff_raw_avih ['dwTotalFrames'];
    654. 

  654. 						$thisfile_video ['total_frames'] = $thisfile_riff_video_current ['total_frames'];
    655. 

  655. 					}
    656. 

  656. 					
    657. 

  657. 					$thisfile_riff_video_current ['frame_rate'] = round ( 1000000 / $thisfile_riff_raw_avih ['dwMicroSecPerFrame'], 3 );
    658. 

  658. 					$thisfile_video ['frame_rate'] = $thisfile_riff_video_current ['frame_rate'];
    659. 

  659. 				}
    660. 

  660. 				if (isset ( $thisfile_riff ['AVI '] ['hdrl'] ['strl'] ['strh'] [0] ['data'] )) {
    661. 

  661. 					if (is_array ( $thisfile_riff ['AVI '] ['hdrl'] ['strl'] ['strh'] )) {
    662. 

  662. 						for($i = 0; $i < count ( $thisfile_riff ['AVI '] ['hdrl'] ['strl'] ['strh'] ); $i ++) {
    663. 

  663. 							if (isset ( $thisfile_riff ['AVI '] ['hdrl'] ['strl'] ['strh'] [$i] ['data'] )) {
    664. 

  664. 								$strhData = $thisfile_riff ['AVI '] ['hdrl'] ['strl'] ['strh'] [$i] ['data'];
    665. 

  665. 								$strhfccType = substr ( $strhData, 0, 4 );
    666. 

  666. 								
    667. 

  667. 								if (isset ( $thisfile_riff ['AVI '] ['hdrl'] ['strl'] ['strf'] [$i] ['data'] )) {
    668. 

  668. 									$strfData = $thisfile_riff ['AVI '] ['hdrl'] ['strl'] ['strf'] [$i] ['data'];
    669. 

  669. 									
    670. 

  670. 									// shortcut
    671. 

  671. 									$thisfile_riff_raw_strf_strhfccType_streamindex = &$thisfile_riff_raw ['strf'] [$strhfccType] [$streamindex];
    672. 

  672. 									
    673. 

  673. 									switch ($strhfccType) {
    674. 

  674. 										case 'auds' :
    675. 

  675. 											$thisfile_audio ['bitrate_mode'] = 'cbr';
    676. 

  676. 											$thisfile_audio_dataformat = 'wav';
    677. 

  677. 											if (isset ( $thisfile_riff_audio ) && is_array ( $thisfile_riff_audio )) {
    678. 

  678. 												$streamindex = count ( $thisfile_riff_audio );
    679. 

  679. 											}
    680. 

  680. 											
    681. 

  681. 											$thisfile_riff_audio [$streamindex] = getid3_riff::RIFFparseWAVEFORMATex ( $strfData );
    682. 

  682. 											$thisfile_audio ['wformattag'] = $thisfile_riff_audio [$streamindex] ['raw'] ['wFormatTag'];
    683. 

  683. 											
    684. 

  684. 											// shortcut
    685. 

  685. 											$thisfile_audio ['streams'] [$streamindex] = $thisfile_riff_audio [$streamindex];
    686. 

  686. 											$thisfile_audio_streams_currentstream = &$thisfile_audio ['streams'] [$streamindex];
    687. 

  687. 											
    688. 

  688. 											if ($thisfile_audio_streams_currentstream ['bits_per_sample'] == 0) {
    689. 

  689. 												unset ( $thisfile_audio_streams_currentstream ['bits_per_sample'] );
    690. 

  690. 											}
    691. 

  691. 											$thisfile_audio_streams_currentstream ['wformattag'] = $thisfile_audio_streams_currentstream ['raw'] ['wFormatTag'];
    692. 

  692. 											unset ( $thisfile_audio_streams_currentstream ['raw'] );
    693. 

  693. 											
    694. 

  694. 											// shortcut
    695. 

  695. 											$thisfile_riff_raw ['strf'] [$strhfccType] [$streamindex] = $thisfile_riff_audio [$streamindex] ['raw'];
    696. 

  696. 											
    697. 

  697. 											unset ( $thisfile_riff_audio [$streamindex] ['raw'] );
    698. 

  698. 											$thisfile_audio = getid3_lib::array_merge_noclobber ( $thisfile_audio, $thisfile_riff_audio [$streamindex] );
    699. 

  699. 											
    700. 

  700. 											$thisfile_audio ['lossless'] = false;
    701. 

  701. 											switch ($thisfile_riff_raw_strf_strhfccType_streamindex ['wFormatTag']) {
    702. 

  702. 												case 0x0001 : // PCM
    703. 

  703. 													$thisfile_audio_dataformat = 'wav';
    704. 

  704. 													$thisfile_audio ['lossless'] = true;
    705. 

  705. 													break;
    706. 

  706. 												
    707. 

  707. 												case 0x0050 : // MPEG Layer 2 or Layer 1
    708. 

  708. 													$thisfile_audio_dataformat = 'mp2'; // Assume Layer-2
    709. 

  709. 													break;
    710. 

  710. 												
    711. 

  711. 												case 0x0055 : // MPEG Layer 3
    712. 

  712. 													$thisfile_audio_dataformat = 'mp3';
    713. 

  713. 													break;
    714. 

  714. 												
    715. 

  715. 												case 0x00FF : // AAC
    716. 

  716. 													$thisfile_audio_dataformat = 'aac';
    717. 

  717. 													break;
    718. 

  718. 												
    719. 

  719. 												case 0x0161 : // Windows Media v7 / v8 / v9
    720. 

  720. 												case 0x0162 : // Windows Media Professional v9
    721. 

  721. 												case 0x0163 : // Windows Media Lossess v9
    722. 

  722. 													$thisfile_audio_dataformat = 'wma';
    723. 

  723. 													break;
    724. 

  724. 												
    725. 

  725. 												case 0x2000 : // AC-3
    726. 

  726. 													$thisfile_audio_dataformat = 'ac3';
    727. 

  727. 													break;
    728. 

  728. 												
    729. 

  729. 												case 0x2001 : // DTS
    730. 

  730. 													$thisfile_audio_dataformat = 'dts';
    731. 

  731. 													break;
    732. 

  732. 												
    733. 

  733. 												default :
    734. 

  734. 													$thisfile_audio_dataformat = 'wav';
    735. 

  735. 													break;
    736. 

  736. 											}
    737. 

  737. 											$thisfile_audio_streams_currentstream ['dataformat'] = $thisfile_audio_dataformat;
    738. 

  738. 											$thisfile_audio_streams_currentstream ['lossless'] = $thisfile_audio ['lossless'];
    739. 

  739. 											$thisfile_audio_streams_currentstream ['bitrate_mode'] = $thisfile_audio ['bitrate_mode'];
    740. 

  740. 											break;
    741. 

  741. 										
    742. 

  742. 										case 'iavs' :
    743. 

  743. 										case 'vids' :
    744. 

  744. 											// shortcut
    745. 

  745. 											$thisfile_riff_raw ['strh'] [$i] = array ();
    746. 

  746. 											$thisfile_riff_raw_strh_current = &$thisfile_riff_raw ['strh'] [$i];
    747. 

  747. 											
    748. 

  748. 											$thisfile_riff_raw_strh_current ['fccType'] = substr ( $strhData, 0, 4 ); // same as $strhfccType;
    749. 

  749. 											$thisfile_riff_raw_strh_current ['fccHandler'] = substr ( $strhData, 4, 4 );
    750. 

  750. 											$thisfile_riff_raw_strh_current ['dwFlags'] = $this->EitherEndian2Int ( substr ( $strhData, 8, 4 ) ); // Contains AVITF_* flags
    751. 

  751. 											$thisfile_riff_raw_strh_current ['wPriority'] = $this->EitherEndian2Int ( substr ( $strhData, 12, 2 ) );
    752. 

  752. 											$thisfile_riff_raw_strh_current ['wLanguage'] = $this->EitherEndian2Int ( substr ( $strhData, 14, 2 ) );
    753. 

  753. 											$thisfile_riff_raw_strh_current ['dwInitialFrames'] = $this->EitherEndian2Int ( substr ( $strhData, 16, 4 ) );
    754. 

  754. 											$thisfile_riff_raw_strh_current ['dwScale'] = $this->EitherEndian2Int ( substr ( $strhData, 20, 4 ) );
    755. 

  755. 											$thisfile_riff_raw_strh_current ['dwRate'] = $this->EitherEndian2Int ( substr ( $strhData, 24, 4 ) );
    756. 

  756. 											$thisfile_riff_raw_strh_current ['dwStart'] = $this->EitherEndian2Int ( substr ( $strhData, 28, 4 ) );
    757. 

  757. 											$thisfile_riff_raw_strh_current ['dwLength'] = $this->EitherEndian2Int ( substr ( $strhData, 32, 4 ) );
    758. 

  758. 											$thisfile_riff_raw_strh_current ['dwSuggestedBufferSize'] = $this->EitherEndian2Int ( substr ( $strhData, 36, 4 ) );
    759. 

  759. 											$thisfile_riff_raw_strh_current ['dwQuality'] = $this->EitherEndian2Int ( substr ( $strhData, 40, 4 ) );
    760. 

  760. 											$thisfile_riff_raw_strh_current ['dwSampleSize'] = $this->EitherEndian2Int ( substr ( $strhData, 44, 4 ) );
    761. 

  761. 											$thisfile_riff_raw_strh_current ['rcFrame'] = $this->EitherEndian2Int ( substr ( $strhData, 48, 4 ) );
    762. 

  762. 											
    763. 

  763. 											$thisfile_riff_video_current ['codec'] = getid3_riff::RIFFfourccLookup ( $thisfile_riff_raw_strh_current ['fccHandler'] );
    764. 

  764. 											$thisfile_video ['fourcc'] = $thisfile_riff_raw_strh_current ['fccHandler'];
    765. 

  765. 											if (! $thisfile_riff_video_current ['codec'] && isset ( $thisfile_riff_raw_strf_strhfccType_streamindex ['fourcc'] ) && getid3_riff::RIFFfourccLookup ( $thisfile_riff_raw_strf_strhfccType_streamindex ['fourcc'] )) {
    766. 

  766. 												$thisfile_riff_video_current ['codec'] = getid3_riff::RIFFfourccLookup ( $thisfile_riff_raw_strf_strhfccType_streamindex ['fourcc'] );
    767. 

  767. 												$thisfile_video ['fourcc'] = $thisfile_riff_raw_strf_strhfccType_streamindex ['fourcc'];
    768. 

  768. 											}
    769. 

  769. 											$thisfile_video ['codec'] = $thisfile_riff_video_current ['codec'];
    770. 

  770. 											$thisfile_video ['pixel_aspect_ratio'] = ( float ) 1;
    771. 

  771. 											switch ($thisfile_riff_raw_strh_current ['fccHandler']) {
    772. 

  772. 												case 'HFYU' : // Huffman Lossless Codec
    773. 

  773. 												case 'IRAW' : // Intel YUV Uncompressed
    774. 

  774. 												case 'YUY2' : // Uncompressed YUV 4:2:2
    775. 

  775. 													$thisfile_video ['lossless'] = true;
    776. 

  776. 													break;
    777. 

  777. 												
    778. 

  778. 												default :
    779. 

  779. 													$thisfile_video ['lossless'] = false;
    780. 

  780. 													break;
    781. 

  781. 											}
    782. 

  782. 											
    783. 

  783. 											switch ($strhfccType) {
    784. 

  784. 												case 'vids' :
    785. 

  785. 													$thisfile_riff_raw_strf_strhfccType_streamindex = getid3_riff::ParseBITMAPINFOHEADER ( substr ( $strfData, 0, 40 ), ($info ['fileformat'] == 'riff') );
    786. 

  786. 													//echo '<pre>'.print_r($thisfile_riff_raw_strf_strhfccType_streamindex, true).'</pre>';
    787. 

  787. 													$thisfile_video ['bits_per_sample'] = $thisfile_riff_raw_strf_strhfccType_streamindex ['biBitCount'];
    788. 

  788. 													
    789. 

  789. 													if ($thisfile_riff_video_current ['codec'] == 'DV') {
    790. 

  790. 														$thisfile_riff_video_current ['dv_type'] = 2;
    791. 

  791. 													}
    792. 

  792. 													break;
    793. 

  793. 												
    794. 

  794. 												case 'iavs' :
    795. 

  795. 													$thisfile_riff_video_current ['dv_type'] = 1;
    796. 

  796. 													break;
    797. 

  797. 											}
    798. 

  798. 											break;
    799. 

  799. 										
    800. 

  800. 										default :
    801. 

  801. 											$info ['warning'] [] = 'Unhandled fccType for stream (' . $i . '): "' . $strhfccType . '"';
    802. 

  802. 											break;
    803. 

  803. 									
    804. 

  804. 									}
    805. 

  805. 								}
    806. 

  806. 							}
    807. 

  807. 							
    808. 

  808. 							if (isset ( $thisfile_riff_raw_strf_strhfccType_streamindex ['fourcc'] )) {
    809. 

  809. 								
    810. 

  810. 								$thisfile_video ['fourcc'] = $thisfile_riff_raw_strf_strhfccType_streamindex ['fourcc'];
    811. 

  811. 								if (getid3_riff::RIFFfourccLookup ( $thisfile_video ['fourcc'] )) {
    812. 

  812. 									$thisfile_riff_video_current ['codec'] = getid3_riff::RIFFfourccLookup ( $thisfile_video ['fourcc'] );
    813. 

  813. 									$thisfile_video ['codec'] = $thisfile_riff_video_current ['codec'];
    814. 

  814. 								}
    815. 

  815. 								
    816. 

  816. 								switch ($thisfile_riff_raw_strf_strhfccType_streamindex ['fourcc']) {
    817. 

  817. 									case 'HFYU' : // Huffman Lossless Codec
    818. 

  818. 									case 'IRAW' : // Intel YUV Uncompressed
    819. 

  819. 									case 'YUY2' : // Uncompressed YUV 4:2:2
    820. 

  820. 										$thisfile_video ['lossless'] = true;
    821. 

  821. 										//$thisfile_video['bits_per_sample'] = 24;
    822. 

  822. 										break;
    823. 

  823. 									
    824. 

  824. 									default :
    825. 

  825. 										$thisfile_video ['lossless'] = false;
    826. 

  826. 										//$thisfile_video['bits_per_sample'] = 24;
    827. 

  827. 										break;
    828. 

  828. 								}
    829. 

  829. 							
    830. 

  830. 							}
    831. 

  831. 						}
    832. 

  832. 					}
    833. 

  833. 				}
    834. 

  834. 				break;
    835. 

  835. 			
    836. 

  836. 			case 'CDDA' :
    837. 

  837. 				$thisfile_audio ['bitrate_mode'] = 'cbr';
    838. 

  838. 				$thisfile_audio_dataformat = 'cda';
    839. 

  839. 				$thisfile_audio ['lossless'] = true;
    840. 

  840. 				unset ( $info ['mime_type'] );
    841. 

  841. 				
    842. 

  842. 				$info ['avdataoffset'] = 44;
    843. 

  843. 				
    844. 

  844. 				if (isset ( $thisfile_riff ['CDDA'] ['fmt '] [0] ['data'] )) {
    845. 

  845. 					// shortcut
    846. 

  846. 					$thisfile_riff_CDDA_fmt_0 = &$thisfile_riff ['CDDA'] ['fmt '] [0];
    847. 

  847. 					
    848. 

  848. 					$thisfile_riff_CDDA_fmt_0 ['unknown1'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_CDDA_fmt_0 ['data'], 0, 2 ) );
    849. 

  849. 					$thisfile_riff_CDDA_fmt_0 ['track_num'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_CDDA_fmt_0 ['data'], 2, 2 ) );
    850. 

  850. 					$thisfile_riff_CDDA_fmt_0 ['disc_id'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_CDDA_fmt_0 ['data'], 4, 4 ) );
    851. 

  851. 					$thisfile_riff_CDDA_fmt_0 ['start_offset_frame'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_CDDA_fmt_0 ['data'], 8, 4 ) );
    852. 

  852. 					$thisfile_riff_CDDA_fmt_0 ['playtime_frames'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_CDDA_fmt_0 ['data'], 12, 4 ) );
    853. 

  853. 					$thisfile_riff_CDDA_fmt_0 ['unknown6'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_CDDA_fmt_0 ['data'], 16, 4 ) );
    854. 

  854. 					$thisfile_riff_CDDA_fmt_0 ['unknown7'] = $this->EitherEndian2Int ( substr ( $thisfile_riff_CDDA_fmt_0 ['data'], 20, 4 ) );
    855. 

  855. 					
    856. 

  856. 					$thisfile_riff_CDDA_fmt_0 ['start_offset_seconds'] = ( float ) $thisfile_riff_CDDA_fmt_0 ['start_offset_frame'] / 75;
    857. 

  857. 					$thisfile_riff_CDDA_fmt_0 ['playtime_seconds'] = ( float ) $thisfile_riff_CDDA_fmt_0 ['playtime_frames'] / 75;
    858. 

  858. 					$info ['comments'] ['track'] = $thisfile_riff_CDDA_fmt_0 ['track_num'];
    859. 

  859. 					$info ['playtime_seconds'] = $thisfile_riff_CDDA_fmt_0 ['playtime_seconds'];
    860. 

  860. 					
    861. 

  861. 					// hardcoded data for CD-audio
    862. 

  862. 					$thisfile_audio ['sample_rate'] = 44100;
    863. 

  863. 					$thisfile_audio ['channels'] = 2;
    864. 

  864. 					$thisfile_audio ['bits_per_sample'] = 16;
    865. 

  865. 					$thisfile_audio ['bitrate'] = $thisfile_audio ['sample_rate'] * $thisfile_audio ['channels'] * $thisfile_audio ['bits_per_sample'];
    866. 

  866. 					$thisfile_audio ['bitrate_mode'] = 'cbr';
    867. 

  867. 				}
    868. 

  868. 				break;
    869. 

  869. 			
    870. 

  870. 			case 'AIFF' :
    871. 

  871. 			case 'AIFC' :
    872. 

  872. 				$thisfile_audio ['bitrate_mode'] = 'cbr';
    873. 

  873. 				$thisfile_audio_dataformat = 'aiff';
    874. 

  874. 				$thisfile_audio ['lossless'] = true;
    875. 

  875. 				$info ['mime_type'] = 'audio/x-aiff';
    876. 

  876. 				
    877. 

  877. 				if (isset ( $thisfile_riff [$RIFFsubtype] ['SSND'] [0] ['offset'] )) {
    878. 

  878. 					$info ['avdataoffset'] = $thisfile_riff [$RIFFsubtype] ['SSND'] [0] ['offset'] + 8;
    879. 

  879. 					$info ['avdataend'] = $info ['avdataoffset'] + $thisfile_riff [$RIFFsubtype] ['SSND'] [0] ['size'];
    880. 

  880. 					if ($info ['avdataend'] > $info ['filesize']) {
    881. 

  881. 						if (($info ['avdataend'] == ($info ['filesize'] + 1)) && (($info ['filesize'] % 2) == 1)) {
    882. 

  882. 							// structures rounded to 2-byte boundary, but dumb encoders
    883. 

  883. 							// forget to pad end of file to make this actually work
    884. 

  884. 						} else {
    885. 

  885. 							$info ['warning'] [] = 'Probable truncated AIFF file: expecting ' . $thisfile_riff [$RIFFsubtype] ['SSND'] [0] ['size'] . ' bytes of audio data, only ' . ($info ['filesize'] - $info ['avdataoffset']) . ' bytes found';
    886. 

  886. 						}
    887. 

  887. 						$info ['avdataend'] = $info ['filesize'];
    888. 

  888. 					}
    889. 

  889. 				}
    890. 

  890. 				
    891. 

  891. 				if (isset ( $thisfile_riff [$RIFFsubtype] ['COMM'] [0] ['data'] )) {
    892. 

  892. 					
    893. 

  893. 					// shortcut
    894. 

  894. 					$thisfile_riff_RIFFsubtype_COMM_0_data = &$thisfile_riff [$RIFFsubtype] ['COMM'] [0] ['data'];
    895. 

  895. 					
    896. 

  896. 					$thisfile_riff_audio ['channels'] = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_RIFFsubtype_COMM_0_data, 0, 2 ), true );
    897. 

  897. 					$thisfile_riff_audio ['total_samples'] = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_RIFFsubtype_COMM_0_data, 2, 4 ), false );
    898. 

  898. 					$thisfile_riff_audio ['bits_per_sample'] = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_RIFFsubtype_COMM_0_data, 6, 2 ), true );
    899. 

  899. 					$thisfile_riff_audio ['sample_rate'] = ( int ) getid3_lib::BigEndian2Float ( substr ( $thisfile_riff_RIFFsubtype_COMM_0_data, 8, 10 ) );
    900. 

  900. 					
    901. 

  901. 					if ($thisfile_riff [$RIFFsubtype] ['COMM'] [0] ['size'] > 18) {
    902. 

  902. 						$thisfile_riff_audio ['codec_fourcc'] = substr ( $thisfile_riff_RIFFsubtype_COMM_0_data, 18, 4 );
    903. 

  903. 						$CodecNameSize = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_RIFFsubtype_COMM_0_data, 22, 1 ), false );
    904. 

  904. 						$thisfile_riff_audio ['codec_name'] = substr ( $thisfile_riff_RIFFsubtype_COMM_0_data, 23, $CodecNameSize );
    905. 

  905. 						switch ($thisfile_riff_audio ['codec_name']) {
    906. 

  906. 							case 'NONE' :
    907. 

  907. 								$thisfile_audio ['codec'] = 'Pulse Code Modulation (PCM)';
    908. 

  908. 								$thisfile_audio ['lossless'] = true;
    909. 

  909. 								break;
    910. 

  910. 							
    911. 

  911. 							case '' :
    912. 

  912. 								switch ($thisfile_riff_audio ['codec_fourcc']) {
    913. 

  913. 									// http://developer.apple.com/qa/snd/snd07.html
    914. 

  914. 									case 'sowt' :
    915. 

  915. 										$thisfile_riff_audio ['codec_name'] = 'Two\'s Compliment Little-Endian PCM';
    916. 

  916. 										$thisfile_audio ['lossless'] = true;
    917. 

  917. 										break;
    918. 

  918. 									
    919. 

  919. 									case 'twos' :
    920. 

  920. 										$thisfile_riff_audio ['codec_name'] = 'Two\'s Compliment Big-Endian PCM';
    921. 

  921. 										$thisfile_audio ['lossless'] = true;
    922. 

  922. 										break;
    923. 

  923. 									
    924. 

  924. 									default :
    925. 

  925. 										break;
    926. 

  926. 								}
    927. 

  927. 								break;
    928. 

  928. 							
    929. 

  929. 							default :
    930. 

  930. 								$thisfile_audio ['codec'] = $thisfile_riff_audio ['codec_name'];
    931. 

  931. 								$thisfile_audio ['lossless'] = false;
    932. 

  932. 								break;
    933. 

  933. 						}
    934. 

  934. 					}
    935. 

  935. 					
    936. 

  936. 					$thisfile_audio ['channels'] = $thisfile_riff_audio ['channels'];
    937. 

  937. 					if ($thisfile_riff_audio ['bits_per_sample'] > 0) {
    938. 

  938. 						$thisfile_audio ['bits_per_sample'] = $thisfile_riff_audio ['bits_per_sample'];
    939. 

  939. 					}
    940. 

  940. 					$thisfile_audio ['sample_rate'] = $thisfile_riff_audio ['sample_rate'];
    941. 

  941. 					if ($thisfile_audio ['sample_rate'] == 0) {
    942. 

  942. 						$info ['error'] [] = 'Corrupted AIFF file: sample_rate == zero';
    943. 

  943. 						return false;
    944. 

  944. 					}
    945. 

  945. 					$info ['playtime_seconds'] = $thisfile_riff_audio ['total_samples'] / $thisfile_audio ['sample_rate'];
    946. 

  946. 				}
    947. 

  947. 				
    948. 

  948. 				if (isset ( $thisfile_riff [$RIFFsubtype] ['COMT'] )) {
    949. 

  949. 					$offset = 0;
    950. 

  950. 					$CommentCount = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff [$RIFFsubtype] ['COMT'] [0] ['data'], $offset, 2 ), false );
    951. 

  951. 					$offset += 2;
    952. 

  952. 					for($i = 0; $i < $CommentCount; $i ++) {
    953. 

  953. 						$info ['comments_raw'] [$i] ['timestamp'] = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff [$RIFFsubtype] ['COMT'] [0] ['data'], $offset, 4 ), false );
    954. 

  954. 						$offset += 4;
    955. 

  955. 						$info ['comments_raw'] [$i] ['marker_id'] = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff [$RIFFsubtype] ['COMT'] [0] ['data'], $offset, 2 ), true );
    956. 

  956. 						$offset += 2;
    957. 

  957. 						$CommentLength = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff [$RIFFsubtype] ['COMT'] [0] ['data'], $offset, 2 ), false );
    958. 

  958. 						$offset += 2;
    959. 

  959. 						$info ['comments_raw'] [$i] ['comment'] = substr ( $thisfile_riff [$RIFFsubtype] ['COMT'] [0] ['data'], $offset, $CommentLength );
    960. 

  960. 						$offset += $CommentLength;
    961. 

  961. 						
    962. 

  962. 						$info ['comments_raw'] [$i] ['timestamp_unix'] = getid3_lib::DateMac2Unix ( $info ['comments_raw'] [$i] ['timestamp'] );
    963. 

  963. 						$thisfile_riff ['comments'] ['comment'] [] = $info ['comments_raw'] [$i] ['comment'];
    964. 

  964. 					}
    965. 

  965. 				}
    966. 

  966. 				
    967. 

  967. 				$CommentsChunkNames = array (
    968. 

  968. 											'NAME' => 'title', 
    969. 

  969. 											'author' => 'artist', 
    970. 

  970. 											'(c) ' => 'copyright', 
    971. 

  971. 											'ANNO' => 'comment' );
    972. 

  972. 				foreach ( $CommentsChunkNames as $key => $value ) {
    973. 

  973. 					if (isset ( $thisfile_riff [$RIFFsubtype] [$key] [0] ['data'] )) {
    974. 

  974. 						$thisfile_riff ['comments'] [$value] [] = $thisfile_riff [$RIFFsubtype] [$key] [0] ['data'];
    975. 

  975. 					}
    976. 

  976. 				}
    977. 

  977. 				
    978. 

  978. 				if (isset ( $thisfile_riff [$RIFFsubtype] ['ID3 '] )) {
    979. 

  979. 					getid3_lib::IncludeDependency ( GETID3_INCLUDEPATH . 'module.tag.id3v2.php', __FILE__, true );
    980. 

  980. 					$getid3_temp = new getID3 ();
    981. 

  981. 					$getid3_temp->openfile ( $this->getid3->filename );
    982. 

  982. 					$getid3_id3v2 = new getid3_id3v2 ( $getid3_temp );
    983. 

  983. 					$getid3_id3v2->StartingOffset = $thisfile_riff [$RIFFsubtype] ['ID3 '] [0] ['offset'] + 8;
    984. 

  984. 					if (($thisfile_riff [$RIFFsubtype] ['ID3 '] [0] ['valid'] = $getid3_id3v2->Analyze ()) != false) {
    985. 

  985. 						$info ['id3v2'] = $getid3_temp->info ['id3v2'];
    986. 

  986. 					}
    987. 

  987. 					unset ( $getid3_temp, $getid3_id3v2 );
    988. 

  988. 				}
    989. 

  989. 				break;
    990. 

  990. 			
    991. 

  991. 			case '8SVX' :
    992. 

  992. 				$thisfile_audio ['bitrate_mode'] = 'cbr';
    993. 

  993. 				$thisfile_audio_dataformat = '8svx';
    994. 

  994. 				$thisfile_audio ['bits_per_sample'] = 8;
    995. 

  995. 				$thisfile_audio ['channels'] = 1; // overridden below, if need be
    996. 

  996. 				$info ['mime_type'] = 'audio/x-aiff';
    997. 

  997. 				
    998. 

  998. 				if (isset ( $thisfile_riff [$RIFFsubtype] ['BODY'] [0] ['offset'] )) {
    999. 

  999. 					$info ['avdataoffset'] = $thisfile_riff [$RIFFsubtype] ['BODY'] [0] ['offset'] + 8;
    1000. 

  1000. 					$info ['avdataend'] = $info ['avdataoffset'] + $thisfile_riff [$RIFFsubtype] ['BODY'] [0] ['size'];
    1001. 

  1001. 					if ($info ['avdataend'] > $info ['filesize']) {
    1002. 

  1002. 						$info ['warning'] [] = 'Probable truncated AIFF file: expecting ' . $thisfile_riff [$RIFFsubtype] ['BODY'] [0] ['size'] . ' bytes of audio data, only ' . ($info ['filesize'] - $info ['avdataoffset']) . ' bytes found';
    1003. 

  1003. 					}
    1004. 

  1004. 				}
    1005. 

  1005. 				
    1006. 

  1006. 				if (isset ( $thisfile_riff [$RIFFsubtype] ['VHDR'] [0] ['offset'] )) {
    1007. 

  1007. 					// shortcut
    1008. 

  1008. 					$thisfile_riff_RIFFsubtype_VHDR_0 = &$thisfile_riff [$RIFFsubtype] ['VHDR'] [0];
    1009. 

  1009. 					
    1010. 

  1010. 					$thisfile_riff_RIFFsubtype_VHDR_0 ['oneShotHiSamples'] = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_RIFFsubtype_VHDR_0 ['data'], 0, 4 ) );
    1011. 

  1011. 					$thisfile_riff_RIFFsubtype_VHDR_0 ['repeatHiSamples'] = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_RIFFsubtype_VHDR_0 ['data'], 4, 4 ) );
    1012. 

  1012. 					$thisfile_riff_RIFFsubtype_VHDR_0 ['samplesPerHiCycle'] = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_RIFFsubtype_VHDR_0 ['data'], 8, 4 ) );
    1013. 

  1013. 					$thisfile_riff_RIFFsubtype_VHDR_0 ['samplesPerSec'] = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_RIFFsubtype_VHDR_0 ['data'], 12, 2 ) );
    1014. 

  1014. 					$thisfile_riff_RIFFsubtype_VHDR_0 ['ctOctave'] = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_RIFFsubtype_VHDR_0 ['data'], 14, 1 ) );
    1015. 

  1015. 					$thisfile_riff_RIFFsubtype_VHDR_0 ['sCompression'] = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff_RIFFsubtype_VHDR_0 ['data'], 15, 1 ) );
    1016. 

  1016. 					$thisfile_riff_RIFFsubtype_VHDR_0 ['Volume'] = getid3_lib::FixedPoint16_16 ( substr ( $thisfile_riff_RIFFsubtype_VHDR_0 ['data'], 16, 4 ) );
    1017. 

  1017. 					
    1018. 

  1018. 					$thisfile_audio ['sample_rate'] = $thisfile_riff_RIFFsubtype_VHDR_0 ['samplesPerSec'];
    1019. 

  1019. 					
    1020. 

  1020. 					switch ($thisfile_riff_RIFFsubtype_VHDR_0 ['sCompression']) {
    1021. 

  1021. 						case 0 :
    1022. 

  1022. 							$thisfile_audio ['codec'] = 'Pulse Code Modulation (PCM)';
    1023. 

  1023. 							$thisfile_audio ['lossless'] = true;
    1024. 

  1024. 							$ActualBitsPerSample = 8;
    1025. 

  1025. 							break;
    1026. 

  1026. 						
    1027. 

  1027. 						case 1 :
    1028. 

  1028. 							$thisfile_audio ['codec'] = 'Fibonacci-delta encoding';
    1029. 

  1029. 							$thisfile_audio ['lossless'] = false;
    1030. 

  1030. 							$ActualBitsPerSample = 4;
    1031. 

  1031. 							break;
    1032. 

  1032. 						
    1033. 

  1033. 						default :
    1034. 

  1034. 							$info ['warning'] [] = 'Unexpected sCompression value in 8SVX.VHDR chunk - expecting 0 or 1, found "' . sCompression . '"';
    1035. 

  1035. 							break;
    1036. 

  1036. 					}
    1037. 

  1037. 				}
    1038. 

  1038. 				
    1039. 

  1039. 				if (isset ( $thisfile_riff [$RIFFsubtype] ['CHAN'] [0] ['data'] )) {
    1040. 

  1040. 					$ChannelsIndex = getid3_lib::BigEndian2Int ( substr ( $thisfile_riff [$RIFFsubtype] ['CHAN'] [0] ['data'], 0, 4 ) );
    1041. 

  1041. 					switch ($ChannelsIndex) {
    1042. 

  1042. 						case 6 : // Stereo
    1043. 

  1043. 							$thisfile_audio ['channels'] = 2;
    1044. 

  1044. 							break;
    1045. 

  1045. 						
    1046. 

  1046. 						case 2 : // Left channel only
    1047. 

  1047. 						case 4 : // Right channel only
    1048. 

  1048. 							$thisfile_audio ['channels'] = 1;
    1049. 

  1049. 							break;
    1050. 

  1050. 						
    1051. 

  1051. 						default :
    1052. 

  1052. 							$info ['warning'] [] = 'Unexpected value in 8SVX.CHAN chunk - expecting 2 or 4 or 6, found "' . $ChannelsIndex . '"';
    1053. 

  1053. 							break;
    1054. 

  1054. 					}
    1055. 

  1055. 				
    1056. 

  1056. 				}
    1057. 

  1057. 				
    1058. 

  1058. 				$CommentsChunkNames = array (
    1059. 

  1059. 											'NAME' => 'title', 
    1060. 

  1060. 											'author' => 'artist', 
    1061. 

  1061. 											'(c) ' => 'copyright', 
    1062. 

  1062. 											'ANNO' => 'comment' );
    1063. 

  1063. 				foreach ( $CommentsChunkNames as $key => $value ) {
    1064. 

  1064. 					if (isset ( $thisfile_riff [$RIFFsubtype] [$key] [0] ['data'] )) {
    1065. 

  1065. 						$thisfile_riff ['comments'] [$value] [] = $thisfile_riff [$RIFFsubtype] [$key] [0] ['data'];
    1066. 

  1066. 					}
    1067. 

  1067. 				}
    1068. 

  1068. 				
    1069. 

  1069. 				$thisfile_audio ['bitrate'] = $thisfile_audio ['sample_rate'] * $ActualBitsPerSample * $thisfile_audio ['channels'];
    1070. 

  1070. 				if (! empty ( $thisfile_audio ['bitrate'] )) {
    1071. 

  1071. 					$info ['playtime_seconds'] = ($info ['avdataend'] - $info ['avdataoffset']) / ($thisfile_audio ['bitrate'] / 8);
    1072. 

  1072. 				}
    1073. 

  1073. 				break;
    1074. 

  1074. 			
    1075. 

  1075. 			case 'CDXA' :
    1076. 

  1076. 				$info ['mime_type'] = 'video/mpeg';
    1077. 

  1077. 				if (! empty ( $thisfile_riff ['CDXA'] ['data'] [0] ['size'] )) {
    1078. 

  1078. 					if (getid3_lib::IncludeDependency ( GETID3_INCLUDEPATH . 'module.audio-video.mpeg.php', __FILE__, false )) {
    1079. 

  1079. 						$getid3_temp = new getID3 ();
    1080. 

  1080. 						$getid3_temp->openfile ( $this->getid3->filename );
    1081. 

  1081. 						$getid3_mpeg = new getid3_mpeg ( $getid3_temp );
    1082. 

  1082. 						$getid3_mpeg->Analyze ();
    1083. 

  1083. 						if (empty ( $getid3_temp->info ['error'] )) {
    1084. 

  1084. 							$info ['audio'] = $getid3_temp->info ['audio'];
    1085. 

  1085. 							$info ['video'] = $getid3_temp->info ['video'];
    1086. 

  1086. 							$info ['mpeg'] = $getid3_temp->info ['mpeg'];
    1087. 

  1087. 							$info ['warning'] = $getid3_temp->info ['warning'];
    1088. 

  1088. 						}
    1089. 

  1089. 						unset ( $getid3_temp, $getid3_mpeg );
    1090. 

  1090. 					}
    1091. 

  1091. 				}
    1092. 

  1092. 				break;
    1093. 

  1093. 			
    1094. 

  1094. 			default :
    1095. 

  1095. 				$info ['error'] [] = 'Unknown RIFF type: expecting one of (WAVE|RMP3|AVI |CDDA|AIFF|AIFC|8SVX|CDXA), found "' . $RIFFsubtype . '" instead';
    1096. 

  1096. 				unset ( $info ['fileformat'] );
    1097. 

  1097. 				break;
    1098. 

  1098. 		}
    1099. 

  1099. 		
    1100. 

  1100. 		if (isset ( $thisfile_riff_raw ['fmt '] ['wFormatTag'] ) && ($thisfile_riff_raw ['fmt '] ['wFormatTag'] == 1)) {
    1101. 

  1101. 			// http://www.mega-nerd.com/erikd/Blog/Windiots/dts.html
    1102. 

  1102. 			fseek ( $this->getid3->fp, $info ['avdataoffset'], SEEK_SET );
    1103. 

  1103. 			$FirstFourBytes = fread ( $this->getid3->fp, 4 );
    1104. 

  1104. 			if (preg_match ( '/^\xFF\x1F\x00\xE8/s', $FirstFourBytes )) {
    1105. 

  1105. 				// DTSWAV
    1106. 

  1106. 				$thisfile_audio_dataformat = 'dts';
    1107. 

  1107. 			} elseif (preg_match ( '/^\x7F\xFF\x80\x01/s', $FirstFourBytes )) {
    1108. 

  1108. 				// DTS, but this probably shouldn't happen
    1109. 

  1109. 				$thisfile_audio_dataformat = 'dts';
    1110. 

  1110. 			}
    1111. 

  1111. 		}
    1112. 

  1112. 		
    1113. 

  1113. 		if (isset ( $thisfile_riff_WAVE ['DISP'] ) && is_array ( $thisfile_riff_WAVE ['DISP'] )) {
    1114. 

  1114. 			$thisfile_riff ['comments'] ['title'] [] = trim ( substr ( $thisfile_riff_WAVE ['DISP'] [count ( $thisfile_riff_WAVE ['DISP'] ) - 1] ['data'], 4 ) );
    1115. 

  1115. 		}
    1116. 

  1116. 		if (isset ( $thisfile_riff_WAVE ['INFO'] ) && is_array ( $thisfile_riff_WAVE ['INFO'] )) {
    1117. 

  1117. 			$this->RIFFcommentsParse ( $thisfile_riff_WAVE ['INFO'], $thisfile_riff ['comments'] );
    1118. 

  1118. 		}
    1119. 

  1119. 		if (isset ( $thisfile_riff ['AVI '] ['INFO'] ) && is_array ( $thisfile_riff ['AVI '] ['INFO'] )) {
    1120. 

  1120. 			$this->RIFFcommentsParse ( $thisfile_riff ['AVI '] ['INFO'], $thisfile_riff ['comments'] );
    1121. 

  1121. 		}
    1122. 

  1122. 		
    1123. 

  1123. 		if (empty ( $thisfile_audio ['encoder'] ) && ! empty ( $info ['mpeg'] ['audio'] ['LAME'] ['short_version'] )) {
    1124. 

  1124. 			$thisfile_audio ['encoder'] = $info ['mpeg'] ['audio'] ['LAME'] ['short_version'];
    1125. 

  1125. 		}
    1126. 

  1126. 		
    1127. 

  1127. 		if (! isset ( $info ['playtime_seconds'] )) {
    1128. 

  1128. 			$info ['playtime_seconds'] = 0;
    1129. 

  1129. 		}
    1130. 

  1130. 		if (isset ( $thisfile_riff_raw ['strh'] [0] ['dwLength'] ) && isset ( $thisfile_riff_raw ['avih'] ['dwMicroSecPerFrame'] )) {
    1131. 

  1131. 			// needed for >2GB AVIs where 'avih' chunk only lists number of frames in that chunk, not entire movie
    1132. 

  1132. 			$info ['playtime_seconds'] = $thisfile_riff_raw ['strh'] [0] ['dwLength'] * ($thisfile_riff_raw ['avih'] ['dwMicroSecPerFrame'] / 1000000);
    1133. 

  1133. 		} elseif (isset ( $thisfile_riff_raw ['avih'] ['dwTotalFrames'] ) && isset ( $thisfile_riff_raw ['avih'] ['dwMicroSecPerFrame'] )) {
    1134. 

  1134. 			$info ['playtime_seconds'] = $thisfile_riff_raw ['avih'] ['dwTotalFrames'] * ($thisfile_riff_raw ['avih'] ['dwMicroSecPerFrame'] / 1000000);
    1135. 

  1135. 		}
    1136. 

  1136. 		
    1137. 

  1137. 		if ($info ['playtime_seconds'] > 0) {
    1138. 

  1138. 			if (isset ( $thisfile_riff_audio ) && isset ( $thisfile_riff_video )) {
    1139. 

  1139. 				
    1140. 

  1140. 				if (! isset ( $info ['bitrate'] )) {
    1141. 

  1141. 					$info ['bitrate'] = ((($info ['avdataend'] - $info ['avdataoffset']) / $info ['playtime_seconds']) * 8);
    1142. 

  1142. 				}
    1143. 

  1143. 			
    1144. 

  1144. 			} elseif (isset ( $thisfile_riff_audio ) && ! isset ( $thisfile_riff_video )) {
    1145. 

  1145. 				
    1146. 

  1146. 				if (! isset ( $thisfile_audio ['bitrate'] )) {
    1147. 

  1147. 					$thisfile_audio ['bitrate'] = ((($info ['avdataend'] - $info ['avdataoffset']) / $info ['playtime_seconds']) * 8);
    1148. 

  1148. 				}
    1149. 

  1149. 			
    1150. 

  1150. 			} elseif (! isset ( $thisfile_riff_audio ) && isset ( $thisfile_riff_video )) {
    1151. 

  1151. 				
    1152. 

  1152. 				if (! isset ( $thisfile_video ['bitrate'] )) {
    1153. 

  1153. 					$thisfile_video ['bitrate'] = ((($info ['avdataend'] - $info ['avdataoffset']) / $info ['playtime_seconds']) * 8);
    1154. 

  1154. 				}
    1155. 

  1155. 			
    1156. 

  1156. 			}
    1157. 

  1157. 		}
    1158. 

  1158. 		
    1159. 

  1159. 		if (isset ( $thisfile_riff_video ) && isset ( $thisfile_audio ['bitrate'] ) && ($thisfile_audio ['bitrate'] > 0) && ($info ['playtime_seconds'] > 0)) {
    1160. 

  1160. 			
    1161. 

  1161. 			$info ['bitrate'] = ((($info ['avdataend'] - $info ['avdataoffset']) / $info ['playtime_seconds']) * 8);
    1162. 

  1162. 			$thisfile_audio ['bitrate'] = 0;
    1163. 

  1163. 			$thisfile_video ['bitrate'] = $info ['bitrate'];
    1164. 

  1164. 			foreach ( $thisfile_riff_audio as $channelnumber => $audioinfoarray ) {
    1165. 

  1165. 				$thisfile_video ['bitrate'] -= $audioinfoarray ['bitrate'];
    1166. 

  1166. 				$thisfile_audio ['bitrate'] += $audioinfoarray ['bitrate'];
    1167. 

  1167. 			}
    1168. 

  1168. 			if ($thisfile_video ['bitrate'] <= 0) {
    1169. 

  1169. 				unset ( $thisfile_video ['bitrate'] );
    1170. 

  1170. 			}
    1171. 

  1171. 			if ($thisfile_audio ['bitrate'] <= 0) {
    1172. 

  1172. 				unset ( $thisfile_audio ['bitrate'] );
    1173. 

  1173. 			}
    1174. 

  1174. 		}
    1175. 

  1175. 		
    1176. 

  1176. 		if (isset ( $info ['mpeg'] ['audio'] )) {
    1177. 

  1177. 			$thisfile_audio_dataformat = 'mp' . $info ['mpeg'] ['audio'] ['layer'];
    1178. 

  1178. 			$thisfile_audio ['sample_rate'] = $info ['mpeg'] ['audio'] ['sample_rate'];
    1179. 

  1179. 			$thisfile_audio ['channels'] = $info ['mpeg'] ['audio'] ['channels'];
    1180. 

  1180. 			$thisfile_audio ['bitrate'] = $info ['mpeg'] ['audio'] ['bitrate'];
    1181. 

  1181. 			$thisfile_audio ['bitrate_mode'] = strtolower ( $info ['mpeg'] ['audio'] ['bitrate_mode'] );
    1182. 

  1182. 			if (! empty ( $info ['mpeg'] ['audio'] ['codec'] )) {
    1183. 

  1183. 				$thisfile_audio ['codec'] = $info ['mpeg'] ['audio'] ['codec'] . ' ' . $thisfile_audio ['codec'];
    1184. 

  1184. 			}
    1185. 

  1185. 			if (! empty ( $thisfile_audio ['streams'] )) {
    1186. 

  1186. 				foreach ( $thisfile_audio ['streams'] as $streamnumber => $streamdata ) {
    1187. 

  1187. 					if ($streamdata ['dataformat'] == $thisfile_audio_dataformat) {
    1188. 

  1188. 						$thisfile_audio ['streams'] [$streamnumber] ['sample_rate'] = $thisfile_audio ['sample_rate'];
    1189. 

  1189. 						$thisfile_audio ['streams'] [$streamnumber] ['channels'] = $thisfile_audio ['channels'];
    1190. 

  1190. 						$thisfile_audio ['streams'] [$streamnumber] ['bitrate'] = $thisfile_audio ['bitrate'];
    1191. 

  1191. 						$thisfile_audio ['streams'] [$streamnumber] ['bitrate_mode'] = $thisfile_audio ['bitrate_mode'];
    1192. 

  1192. 						$thisfile_audio ['streams'] [$streamnumber] ['codec'] = $thisfile_audio ['codec'];
    1193. 

  1193. 					}
    1194. 

  1194. 				}
    1195. 

  1195. 			}
    1196. 

  1196. 			$getid3_mp3 = new getid3_mp3 ( $this->getid3 );
    1197. 

  1197. 			$thisfile_audio ['encoder_options'] = $getid3_mp3->GuessEncoderOptions ();
    1198. 

  1198. 			unset ( $getid3_mp3 );
    1199. 

  1199. 		}
    1200. 

  1200. 		
    1201. 

  1201. 		if (! empty ( $thisfile_riff_raw ['fmt '] ['wBitsPerSample'] ) && ($thisfile_riff_raw ['fmt '] ['wBitsPerSample'] > 0)) {
    1202. 

  1202. 			switch ($thisfile_audio_dataformat) {
    1203. 

  1203. 				case 'ac3' :
    1204. 

  1204. 					// ignore bits_per_sample
    1205. 

  1205. 					break;
    1206. 

  1206. 				
    1207. 

  1207. 				default :
    1208. 

  1208. 					$thisfile_audio ['bits_per_sample'] = $thisfile_riff_raw ['fmt '] ['wBitsPerSample'];
    1209. 

  1209. 					break;
    1210. 

  1210. 			}
    1211. 

  1211. 		}
    1212. 

  1212. 		
    1213. 

  1213. 		if (empty ( $thisfile_riff_raw )) {
    1214. 

  1214. 			unset ( $thisfile_riff ['raw'] );
    1215. 

  1215. 		}
    1216. 

  1216. 		if (empty ( $thisfile_riff_audio )) {
    1217. 

  1217. 			unset ( $thisfile_riff ['audio'] );
    1218. 

  1218. 		}
    1219. 

  1219. 		if (empty ( $thisfile_riff_video )) {
    1220. 

  1220. 			unset ( $thisfile_riff ['video'] );
    1221. 

  1221. 		}
    1222. 

  1222. 		
    1223. 

  1223. 		return true;
    1224. 

  1224. 	}
    1225. 

  1225. 	
    1226. 

  1226. 	static function RIFFcommentsParse(&$RIFFinfoArray, &$CommentsTargetArray) {
    1227. 

  1227. 		$RIFFinfoKeyLookup = array (
    1228. 

  1228. 									'IARL' => 'archivallocation', 
    1229. 

  1229. 									'IART' => 'artist', 
    1230. 

  1230. 									'ICDS' => 'costumedesigner', 
    1231. 

  1231. 									'ICMS' => 'commissionedby', 
    1232. 

  1232. 									'ICMT' => 'comment', 
    1233. 

  1233. 									'ICNT' => 'country', 
    1234. 

  1234. 									'ICOP' => 'copyright', 
    1235. 

  1235. 									'ICRD' => 'creationdate', 
    1236. 

  1236. 									'IDIM' => 'dimensions', 
    1237. 

  1237. 									'IDIT' => 'digitizationdate', 
    1238. 

  1238. 									'IDPI' => 'resolution', 
    1239. 

  1239. 									'IDST' => 'distributor', 
    1240. 

  1240. 									'IEDT' => 'editor', 
    1241. 

  1241. 									'IENG' => 'engineers', 
    1242. 

  1242. 									'IFRM' => 'accountofparts', 
    1243. 

  1243. 									'IGNR' => 'genre', 
    1244. 

  1244. 									'IKEY' => 'keywords', 
    1245. 

  1245. 									'ILGT' => 'lightness', 
    1246. 

  1246. 									'ILNG' => 'language', 
    1247. 

  1247. 									'IMED' => 'orignalmedium', 
    1248. 

  1248. 									'IMUS' => 'composer', 
    1249. 

  1249. 									'INAM' => 'title', 
    1250. 

  1250. 									'IPDS' => 'productiondesigner', 
    1251. 

  1251. 									'IPLT' => 'palette', 
    1252. 

  1252. 									'IPRD' => 'product', 
    1253. 

  1253. 									'IPRO' => 'producer', 
    1254. 

  1254. 									'IPRT' => 'part', 
    1255. 

  1255. 									'IRTD' => 'rating', 
    1256. 

  1256. 									'ISBJ' => 'subject', 
    1257. 

  1257. 									'ISFT' => 'software', 
    1258. 

  1258. 									'ISGN' => 'secondarygenre', 
    1259. 

  1259. 									'ISHP' => 'sharpness', 
    1260. 

  1260. 									'ISRC' => 'sourcesupplier', 
    1261. 

  1261. 									'ISRF' => 'digitizationsource', 
    1262. 

  1262. 									'ISTD' => 'productionstudio', 
    1263. 

  1263. 									'ISTR' => 'starring', 
    1264. 

  1264. 									'ITCH' => 'encoded_by', 
    1265. 

  1265. 									'IWEB' => 'url', 
    1266. 

  1266. 									'IWRI' => 'writer' );
    1267. 

  1267. 		foreach ( $RIFFinfoKeyLookup as $key => $value ) {
    1268. 

  1268. 			if (isset ( $RIFFinfoArray [$key] )) {
    1269. 

  1269. 				foreach ( $RIFFinfoArray [$key] as $commentid => $commentdata ) {
    1270. 

  1270. 					if (trim ( $commentdata ['data'] ) != '') {
    1271. 

  1271. 						if (isset ( $CommentsTargetArray [$value] )) {
    1272. 

  1272. 							$CommentsTargetArray [$value] [] = trim ( $commentdata ['data'] );
    1273. 

  1273. 						} else {
    1274. 

  1274. 							$CommentsTargetArray [$value] = array (
    1275. 

  1275. 																trim ( $commentdata ['data'] ) );
    1276. 

  1276. 						}
    1277. 

  1277. 					}
    1278. 

  1278. 				}
    1279. 

  1279. 			}
    1280. 

  1280. 		}
    1281. 

  1281. 		return true;
    1282. 

  1282. 	}
    1283. 

  1283. 	
    1284. 

  1284. 	function ParseRIFF($startoffset, $maxoffset) {
    1285. 

  1285. 		$info = &$this->getid3->info;
    1286. 

  1286. 		
    1287. 

  1287. 		$maxoffset = min ( $maxoffset, $info ['avdataend'] );
    1288. 

  1288. 		
    1289. 

  1289. 		$RIFFchunk = false;
    1290. 

  1290. 		$FoundAllChunksWeNeed = false;
    1291. 

  1291. 		
    1292. 

  1292. 		if (($startoffset < 0) || ! getid3_lib::intValueSupported ( $startoffset )) {
    1293. 

  1293. 			$info ['warning'] [] = 'Unable to ParseRIFF() at ' . $startoffset . ' because beyond ' . round ( PHP_INT_MAX / 1073741824 ) . 'GB limit of PHP filesystem functions';
    1294. 

  1294. 			return false;
    1295. 

  1295. 		}
    1296. 

  1296. 		$max_usable_offset = min ( PHP_INT_MAX - 1024, $maxoffset );
    1297. 

  1297. 		if ($maxoffset > $max_usable_offset) {
    1298. 

  1298. 			$info ['warning'] [] = 'ParseRIFF() may return incomplete data for chunk starting at ' . $startoffset . ' because beyond it extends to ' . $maxoffset . ', which is beyond the ' . round ( PHP_INT_MAX / 1073741824 ) . 'GB limit of PHP filesystem functions';
    1299. 

  1299. 		}
    1300. 

  1300. 		fseek ( $this->getid3->fp, $startoffset, SEEK_SET );
    1301. 

  1301. 		
    1302. 

  1302. 		while ( ftell ( $this->getid3->fp ) < $max_usable_offset ) {
    1303. 

  1303. 			$chunknamesize = fread ( $this->getid3->fp, 8 );
    1304. 

  1304. 			$chunkname = substr ( $chunknamesize, 0, 4 );
    1305. 

  1305. 			$chunksize = $this->EitherEndian2Int ( substr ( $chunknamesize, 4, 4 ) );
    1306. 

  1306. 			if (strlen ( $chunkname ) < 4) {
    1307. 

  1307. 				$info ['error'] [] = 'Expecting chunk name at offset ' . (ftell ( $this->getid3->fp ) - 4) . ' but found nothing. Aborting RIFF parsing.';
    1308. 

  1308. 				break;
    1309. 

  1309. 			}
    1310. 

  1310. 			if ($chunksize == 0) {
    1311. 

  1311. 				if ($chunkname == 'JUNK') {
    1312. 

  1312. 					// we'll allow zero-size JUNK frames
    1313. 

  1313. 				} else {
    1314. 

  1314. 					$info ['warning'] [] = 'Chunk size at offset ' . (ftell ( $this->getid3->fp ) - 4) . ' is zero. Aborting RIFF parsing.';
    1315. 

  1315. 					break;
    1316. 

  1316. 				}
    1317. 

  1317. 			}
    1318. 

  1318. 			if (($chunksize % 2) != 0) {
    1319. 

  1319. 				// all structures are packed on word boundaries
    1320. 

  1320. 				$chunksize ++;
    1321. 

  1321. 			}
    1322. 

  1322. 			
    1323. 

  1323. 			switch ($chunkname) {
    1324. 

  1324. 				case 'LIST' :
    1325. 

  1325. 					$listname = fread ( $this->getid3->fp, 4 );
    1326. 

  1326. 					if (preg_match ( '#^(movi|rec )$#i', $listname )) {
    1327. 

  1327. 						$RIFFchunk [$listname] ['offset'] = ftell ( $this->getid3->fp ) - 4;
    1328. 

  1328. 						$RIFFchunk [$listname] ['size'] = $chunksize;
    1329. 

  1329. 						
    1330. 

  1330. 						if ($FoundAllChunksWeNeed) {
    1331. 

  1331. 							
    1332. 

  1332. 							// skip over
    1333. 

  1333. 						
    1334. 

  1334. 

  1335. 						} else {
    1336. 

  1336. 							
    1337. 

  1337. 							$WhereWeWere = ftell ( $this->getid3->fp );
    1338. 

  1338. 							$AudioChunkHeader = fread ( $this->getid3->fp, 12 );
    1339. 

  1339. 							$AudioChunkStreamNum = substr ( $AudioChunkHeader, 0, 2 );
    1340. 

  1340. 							$AudioChunkStreamType = substr ( $AudioChunkHeader, 2, 2 );
    1341. 

  1341. 							$AudioChunkSize = getid3_lib::LittleEndian2Int ( substr ( $AudioChunkHeader, 4, 4 ) );
    1342. 

  1342. 							
    1343. 

  1343. 							if ($AudioChunkStreamType == 'wb') {
    1344. 

  1344. 								$FirstFourBytes = substr ( $AudioChunkHeader, 8, 4 );
    1345. 

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

  1346. 									// MP3
    1347. 

  1347. 									if (getid3_mp3::MPEGaudioHeaderBytesValid ( $FirstFourBytes )) {
    1348. 

  1348. 										$getid3_temp = new getID3 ();
    1349. 

  1349. 										$getid3_temp->openfile ( $this->getid3->filename );
    1350. 

  1350. 										$getid3_temp->info ['avdataoffset'] = ftell ( $this->getid3->fp ) - 4;
    1351. 

  1351. 										$getid3_temp->info ['avdataend'] = ftell ( $this->getid3->fp ) + $AudioChunkSize;
    1352. 

  1352. 										$getid3_mp3 = new getid3_mp3 ( $getid3_temp );
    1353. 

  1353. 										$getid3_mp3->getOnlyMPEGaudioInfo ( $getid3_temp->info ['avdataoffset'], false );
    1354. 

  1354. 										if (isset ( $getid3_temp->info ['mpeg'] ['audio'] )) {
    1355. 

  1355. 											$info ['mpeg'] ['audio'] = $getid3_temp->info ['mpeg'] ['audio'];
    1356. 

  1356. 											$info ['audio'] = $getid3_temp->info ['audio'];
    1357. 

  1357. 											$info ['audio'] ['dataformat'] = 'mp' . $info ['mpeg'] ['audio'] ['layer'];
    1358. 

  1358. 											$info ['audio'] ['sample_rate'] = $info ['mpeg'] ['audio'] ['sample_rate'];
    1359. 

  1359. 											$info ['audio'] ['channels'] = $info ['mpeg'] ['audio'] ['channels'];
    1360. 

  1360. 											$info ['audio'] ['bitrate'] = $info ['mpeg'] ['audio'] ['bitrate'];
    1361. 

  1361. 											$info ['audio'] ['bitrate_mode'] = strtolower ( $info ['mpeg'] ['audio'] ['bitrate_mode'] );
    1362. 

  1362. 											//$info['bitrate']               = $info['audio']['bitrate'];
    1363. 

  1363. 										}
    1364. 

  1364. 										unset ( $getid3_temp, $getid3_mp3 );
    1365. 

  1365. 									}
    1366. 

  1366. 								
    1367. 

  1367. 								} elseif (preg_match ( '/^\x0B\x77/s', $FirstFourBytes )) {
    1368. 

  1368. 									
    1369. 

  1369. 									// AC3
    1370. 

  1370. 									if (getid3_lib::IncludeDependency ( GETID3_INCLUDEPATH . 'module.audio.ac3.php', __FILE__, false )) {
    1371. 

  1371. 										$getid3_temp = new getID3 ();
    1372. 

  1372. 										$getid3_temp->openfile ( $this->getid3->filename );
    1373. 

  1373. 										$getid3_temp->info ['avdataoffset'] = ftell ( $this->getid3->fp ) - 4;
    1374. 

  1374. 										$getid3_temp->info ['avdataend'] = ftell ( $this->getid3->fp ) + $AudioChunkSize;
    1375. 

  1375. 										$getid3_ac3 = new getid3_ac3 ( $getid3_temp );
    1376. 

  1376. 										$getid3_ac3->Analyze ();
    1377. 

  1377. 										if (empty ( $getid3_temp->info ['error'] )) {
    1378. 

  1378. 											$info ['audio'] = $getid3_temp->info ['audio'];
    1379. 

  1379. 											$info ['ac3'] = $getid3_temp->info ['ac3'];
    1380. 

  1380. 											if (! empty ( $getid3_temp->info ['warning'] )) {
    1381. 

  1381. 												foreach ( $getid3_temp->info ['warning'] as $key => $value ) {
    1382. 

  1382. 													$info ['warning'] [] = $value;
    1383. 

  1383. 												}
    1384. 

  1384. 											}
    1385. 

  1385. 										}
    1386. 

  1386. 										unset ( $getid3_temp, $getid3_ac3 );
    1387. 

  1387. 									}
    1388. 

  1388. 								
    1389. 

  1389. 								}
    1390. 

  1390. 							
    1391. 

  1391. 							}
    1392. 

  1392. 							
    1393. 

  1393. 							$FoundAllChunksWeNeed = true;
    1394. 

  1394. 							fseek ( $this->getid3->fp, $WhereWeWere, SEEK_SET );
    1395. 

  1395. 						
    1396. 

  1396. 						}
    1397. 

  1397. 						fseek ( $this->getid3->fp, $chunksize - 4, SEEK_CUR );
    1398. 

  1398. 						
    1399. 

  1399. 						//} elseif (preg_match('#^[0-9]{2}(wb|pc|dc|db)$#i', $listname)) {
    1400. 

  1400. 						//
    1401. 

  1401. 						//	// data chunk, ignore
    1402. 

  1402. 						//
    1403. 

  1403. 					} else {
    1404. 

  1404. 						
    1405. 

  1405. 						if (! isset ( $RIFFchunk [$listname] )) {
    1406. 

  1406. 							$RIFFchunk [$listname] = array ();
    1407. 

  1407. 						}
    1408. 

  1408. 						$LISTchunkParent = $listname;
    1409. 

  1409. 						$LISTchunkMaxOffset = ftell ( $this->getid3->fp ) - 4 + $chunksize;
    1410. 

  1410. 						if (($parsedChunk = $this->ParseRIFF ( ftell ( $this->getid3->fp ), ftell ( $this->getid3->fp ) + $chunksize - 4 )) != false) {
    1411. 

  1411. 							$RIFFchunk [$listname] = array_merge_recursive ( $RIFFchunk [$listname], $parsedChunk );
    1412. 

  1412. 						}
    1413. 

  1413. 					
    1414. 

  1414. 					}
    1415. 

  1415. 					break;
    1416. 

  1416. 				
    1417. 

  1417. 				default :
    1418. 

  1418. 					if (preg_match ( '#^[0-9]{2}(wb|pc|dc|db)$#', $chunkname )) {
    1419. 

  1419. 						$nextoffset = ftell ( $this->getid3->fp ) + $chunksize;
    1420. 

  1420. 						if (($nextoffset < 0) || ! getid3_lib::intValueSupported ( $nextoffset )) {
    1421. 

  1421. 							$info ['warning'] [] = 'Unable to parse chunk at offset ' . $nextoffset . ' because beyond ' . round ( PHP_INT_MAX / 1073741824 ) . 'GB limit of PHP filesystem functions';
    1422. 

  1422. 							break 2;
    1423. 

  1423. 						}
    1424. 

  1424. 						fseek ( $this->getid3->fp, $nextoffset, SEEK_SET );
    1425. 

  1425. 						break;
    1426. 

  1426. 					}
    1427. 

  1427. 					$thisindex = 0;
    1428. 

  1428. 					if (isset ( $RIFFchunk [$chunkname] ) && is_array ( $RIFFchunk [$chunkname] )) {
    1429. 

  1429. 						$thisindex = count ( $RIFFchunk [$chunkname] );
    1430. 

  1430. 					}
    1431. 

  1431. 					$RIFFchunk [$chunkname] [$thisindex] ['offset'] = ftell ( $this->getid3->fp ) - 8;
    1432. 

  1432. 					$RIFFchunk [$chunkname] [$thisindex] ['size'] = $chunksize;
    1433. 

  1433. 					switch ($chunkname) {
    1434. 

  1434. 						case 'data' :
    1435. 

  1435. 							$info ['avdataoffset'] = ftell ( $this->getid3->fp );
    1436. 

  1436. 							$info ['avdataend'] = $info ['avdataoffset'] + $chunksize;
    1437. 

  1437. 							
    1438. 

  1438. 							$RIFFdataChunkContentsTest = fread ( $this->getid3->fp, 36 );
    1439. 

  1439. 							
    1440. 

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

  1441. 								
    1442. 

  1442. 								// Probably is MP3 data
    1443. 

  1443. 								if (getid3_mp3::MPEGaudioHeaderBytesValid ( substr ( $RIFFdataChunkContentsTest, 0, 4 ) )) {
    1444. 

  1444. 									$getid3_temp = new getID3 ();
    1445. 

  1445. 									$getid3_temp->openfile ( $this->getid3->filename );
    1446. 

  1446. 									$getid3_temp->info ['avdataoffset'] = $RIFFchunk [$chunkname] [$thisindex] ['offset'];
    1447. 

  1447. 									$getid3_temp->info ['avdataend'] = $RIFFchunk [$chunkname] [$thisindex] ['offset'] + $RIFFchunk [$chunkname] [$thisindex] ['size'];
    1448. 

  1448. 									$getid3_mp3 = new getid3_mp3 ( $getid3_temp );
    1449. 

  1449. 									$getid3_mp3->getOnlyMPEGaudioInfo ( $RIFFchunk [$chunkname] [$thisindex] ['offset'], false );
    1450. 

  1450. 									if (empty ( $getid3_temp->info ['error'] )) {
    1451. 

  1451. 										$info ['mpeg'] = $getid3_temp->info ['mpeg'];
    1452. 

  1452. 										$info ['audio'] = $getid3_temp->info ['audio'];
    1453. 

  1453. 									}
    1454. 

  1454. 									unset ( $getid3_temp, $getid3_mp3 );
    1455. 

  1455. 								}
    1456. 

  1456. 							
    1457. 

  1457. 							} elseif ((strlen ( $RIFFdataChunkContentsTest ) > 0) && (substr ( $RIFFdataChunkContentsTest, 0, 2 ) == "\x0B\x77")) {
    1458. 

  1458. 								
    1459. 

  1459. 								// This is probably AC-3 data
    1460. 

  1460. 								if (getid3_lib::IncludeDependency ( GETID3_INCLUDEPATH . 'module.audio.ac3.php', __FILE__, false )) {
    1461. 

  1461. 									$getid3_temp = new getID3 ();
    1462. 

  1462. 									$getid3_temp->openfile ( $this->getid3->filename );
    1463. 

  1463. 									$getid3_temp->info ['avdataoffset'] = $RIFFchunk [$chunkname] [$thisindex] ['offset'];
    1464. 

  1464. 									$getid3_temp->info ['avdataend'] = $RIFFchunk [$chunkname] [$thisindex] ['offset'] + $RIFFchunk [$chunkname] [$thisindex] ['size'];
    1465. 

  1465. 									$getid3_ac3 = new getid3_ac3 ( $getid3_temp );
    1466. 

  1466. 									$getid3_ac3->Analyze ();
    1467. 

  1467. 									if (empty ( $getid3_temp->info ['error'] )) {
    1468. 

  1468. 										$info ['audio'] = $getid3_temp->info ['audio'];
    1469. 

  1469. 										$info ['ac3'] = $getid3_temp->info ['ac3'];
    1470. 

  1470. 										$info ['warning'] = $getid3_temp->info ['warning'];
    1471. 

  1471. 									}
    1472. 

  1472. 									unset ( $getid3_temp, $getid3_ac3 );
    1473. 

  1473. 								}
    1474. 

  1474. 							
    1475. 

  1475. 							} elseif ((strlen ( $RIFFdataChunkContentsTest ) > 0) && (substr ( $RIFFdataChunkContentsTest, 8, 2 ) == "\x77\x0B")) {
    1476. 

  1476. 								
    1477. 

  1477. 								// Dolby Digital WAV
    1478. 

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

  1479. 								// For one thing, byte order is swapped
    1480. 

  1480. 								
    1481. 

  1481. 

  1482. 								if (getid3_lib::IncludeDependency ( GETID3_INCLUDEPATH . 'module.audio.ac3.php', __FILE__, false )) {
    1483. 

  1483. 									
    1484. 

  1484. 									// ok to use tmpfile here - only 56 bytes
    1485. 

  1485. 									if (($RIFFtempfilename = tempnam ( GETID3_TEMP_DIR, 'id3' )) != false) {
    1486. 

  1486. 										if (($fd_temp = fopen ( $RIFFtempfilename, 'wb' )) != false) {
    1487. 

  1487. 											for($i = 0; $i < 28; $i += 2) {
    1488. 

  1488. 												// swap byte order
    1489. 

  1489. 												fwrite ( $fd_temp, substr ( $RIFFdataChunkContentsTest, 8 + $i + 1, 1 ) );
    1490. 

  1490. 												fwrite ( $fd_temp, substr ( $RIFFdataChunkContentsTest, 8 + $i + 0, 1 ) );
    1491. 

  1491. 											}
    1492. 

  1492. 											fclose ( $fd_temp );
    1493. 

  1493. 											
    1494. 

  1494. 											$getid3_temp = new getID3 ();
    1495. 

  1495. 											$getid3_temp->openfile ( $RIFFtempfilename );
    1496. 

  1496. 											$getid3_temp->info ['avdataend'] = 20;
    1497. 

  1497. 											$getid3_ac3 = new getid3_ac3 ( $getid3_temp );
    1498. 

  1498. 											$getid3_ac3->Analyze ();
    1499. 

  1499. 											if (empty ( $getid3_temp->info ['error'] )) {
    1500. 

  1500. 												$info ['audio'] = $getid3_temp->info ['audio'];
    1501. 

  1501. 												$info ['ac3'] = $getid3_temp->info ['ac3'];
    1502. 

  1502. 												$info ['warning'] = $getid3_temp->info ['warning'];
    1503. 

  1503. 											} else {
    1504. 

  1504. 												$info ['error'] [] = 'Error parsing Dolby Digital WAV (AC3-in-RIFF): ' . implode ( ';', $getid3_temp->info ['error'] );
    1505. 

  1505. 											}
    1506. 

  1506. 											unset ( $getid3_ac3, $getid3_temp );
    1507. 

  1507. 										} else {
    1508. 

  1508. 											$info ['error'] [] = 'Error parsing Dolby Digital WAV (AC3-in-RIFF): failed to write temp file';
    1509. 

  1509. 										}
    1510. 

  1510. 										unlink ( $RIFFtempfilename );
    1511. 

  1511. 									
    1512. 

  1512. 									} else {
    1513. 

  1513. 										$info ['error'] [] = 'Error parsing Dolby Digital WAV (AC3-in-RIFF): failed to write temp file';
    1514. 

  1514. 									}
    1515. 

  1515. 								
    1516. 

  1516. 								}
    1517. 

  1517. 							
    1518. 

  1518. 							} elseif ((strlen ( $RIFFdataChunkContentsTest ) > 0) && (substr ( $RIFFdataChunkContentsTest, 0, 4 ) == 'wvpk')) {
    1519. 

  1519. 								
    1520. 

  1520. 								// This is WavPack data
    1521. 

  1521. 								$info ['wavpack'] ['offset'] = $RIFFchunk [$chunkname] [$thisindex] ['offset'];
    1522. 

  1522. 								$info ['wavpack'] ['size'] = getid3_lib::LittleEndian2Int ( substr ( $RIFFdataChunkContentsTest, 4, 4 ) );
    1523. 

  1523. 								$this->RIFFparseWavPackHeader ( substr ( $RIFFdataChunkContentsTest, 8, 28 ) );
    1524. 

  1524. 							
    1525. 

  1525. 							} else {
    1526. 

  1526. 								
    1527. 

  1527. 								// This is some other kind of data (quite possibly just PCM)
    1528. 

  1528. 								// do nothing special, just skip it
    1529. 

  1529. 							
    1530. 

  1530. 

  1531. 							}
    1532. 

  1532. 							$nextoffset = $RIFFchunk [$chunkname] [$thisindex] ['offset'] + 8 + $chunksize;
    1533. 

  1533. 							if (($nextoffset < 0) || ! getid3_lib::intValueSupported ( $nextoffset )) {
    1534. 

  1534. 								$info ['warning'] [] = 'Unable to parse chunk at offset ' . $nextoffset . ' because beyond ' . round ( PHP_INT_MAX / 1073741824 ) . 'GB limit of PHP filesystem functions';
    1535. 

  1535. 								break 3;
    1536. 

  1536. 							}
    1537. 

  1537. 							fseek ( $this->getid3->fp, $RIFFchunk [$chunkname] [$thisindex] ['offset'] + 8 + $chunksize, SEEK_SET );
    1538. 

  1538. 							break;
    1539. 

  1539. 						
    1540. 

  1540. 						case 'iXML' :
    1541. 

  1541. 						case 'bext' :
    1542. 

  1542. 						case 'cart' :
    1543. 

  1543. 						case 'fmt ' :
    1544. 

  1544. 						case 'strh' :
    1545. 

  1545. 						case 'strf' :
    1546. 

  1546. 						case 'indx' :
    1547. 

  1547. 						case 'MEXT' :
    1548. 

  1548. 						case 'DISP' :
    1549. 

  1549. 						// always read data in
    1550. 

  1550. 						case 'JUNK' :
    1551. 

  1551. 							// should be: never read data in
    1552. 

  1552. 							// but some programs write their version strings in a JUNK chunk (e.g. VirtualDub, AVIdemux, etc)
    1553. 

  1553. 							if ($chunksize < 1048576) {
    1554. 

  1554. 								if ($chunksize > 0) {
    1555. 

  1555. 									$RIFFchunk [$chunkname] [$thisindex] ['data'] = fread ( $this->getid3->fp, $chunksize );
    1556. 

  1556. 									if ($chunkname == 'JUNK') {
    1557. 

  1557. 										if (preg_match ( '#^([\\x20-\\x7F]+)#', $RIFFchunk [$chunkname] [$thisindex] ['data'], $matches )) {
    1558. 

  1558. 											// only keep text characters [chr(32)-chr(127)]
    1559. 

  1559. 											$info ['riff'] ['comments'] ['junk'] [] = trim ( $matches [1] );
    1560. 

  1560. 										}
    1561. 

  1561. 										// but if nothing there, ignore
    1562. 

  1562. 										// remove the key in either case
    1563. 

  1563. 										unset ( $RIFFchunk [$chunkname] [$thisindex] ['data'] );
    1564. 

  1564. 									}
    1565. 

  1565. 								}
    1566. 

  1566. 							} else {
    1567. 

  1567. 								$info ['warning'] [] = 'chunk "' . $chunkname . '" at offset ' . ftell ( $this->getid3->fp ) . ' is unexpectedly larger than 1MB (claims to be ' . number_format ( $chunksize ) . ' bytes), skipping data';
    1568. 

  1568. 								$nextoffset = ftell ( $this->getid3->fp ) + $chunksize;
    1569. 

  1569. 								if (($nextoffset < 0) || ! getid3_lib::intValueSupported ( $nextoffset )) {
    1570. 

  1570. 									$info ['warning'] [] = 'Unable to parse chunk at offset ' . $nextoffset . ' because beyond ' . round ( PHP_INT_MAX / 1073741824 ) . 'GB limit of PHP filesystem functions';
    1571. 

  1571. 									break 3;
    1572. 

  1572. 								}
    1573. 

  1573. 								fseek ( $this->getid3->fp, $nextoffset, SEEK_SET );
    1574. 

  1574. 							}
    1575. 

  1575. 							break;
    1576. 

  1576. 						
    1577. 

  1577. 						default :
    1578. 

  1578. 							if (! preg_match ( '#^[0-9]{2}(wb|pc|dc|db)$#', $chunkname ) && ! empty ( $LISTchunkParent ) && (($RIFFchunk [$chunkname] [$thisindex] ['offset'] + $RIFFchunk [$chunkname] [$thisindex] ['size']) <= $LISTchunkMaxOffset)) {
    1579. 

  1579. 								$RIFFchunk [$LISTchunkParent] [$chunkname] [$thisindex] ['offset'] = $RIFFchunk [$chunkname] [$thisindex] ['offset'];
    1580. 

  1580. 								$RIFFchunk [$LISTchunkParent] [$chunkname] [$thisindex] ['size'] = $RIFFchunk [$chunkname] [$thisindex] ['size'];
    1581. 

  1581. 								unset ( $RIFFchunk [$chunkname] [$thisindex] ['offset'] );
    1582. 

  1582. 								unset ( $RIFFchunk [$chunkname] [$thisindex] ['size'] );
    1583. 

  1583. 								if (isset ( $RIFFchunk [$chunkname] [$thisindex] ) && empty ( $RIFFchunk [$chunkname] [$thisindex] )) {
    1584. 

  1584. 									unset ( $RIFFchunk [$chunkname] [$thisindex] );
    1585. 

  1585. 								}
    1586. 

  1586. 								if (isset ( $RIFFchunk [$chunkname] ) && empty ( $RIFFchunk [$chunkname] )) {
    1587. 

  1587. 									unset ( $RIFFchunk [$chunkname] );
    1588. 

  1588. 								}
    1589. 

  1589. 								$RIFFchunk [$LISTchunkParent] [$chunkname] [$thisindex] ['data'] = fread ( $this->getid3->fp, $chunksize );
    1590. 

  1590. 								//} elseif (in_array($chunkname, array('ID3 ')) || (($chunksize > 0) && ($chunksize < 2048))) {
    1591. 

  1591. 							} elseif (($chunksize > 0) && ($chunksize < 2048)) {
    1592. 

  1592. 								// only read data in if smaller than 2kB
    1593. 

  1593. 								$RIFFchunk [$chunkname] [$thisindex] ['data'] = fread ( $this->getid3->fp, $chunksize );
    1594. 

  1594. 							} else {
    1595. 

  1595. 								$nextoffset = ftell ( $this->getid3->fp ) + $chunksize;
    1596. 

  1596. 								if (($nextoffset < 0) || ! getid3_lib::intValueSupported ( $nextoffset )) {
    1597. 

  1597. 									$info ['warning'] [] = 'Unable to parse chunk at offset ' . $nextoffset . ' because beyond ' . round ( PHP_INT_MAX / 1073741824 ) . 'GB limit of PHP filesystem functions';
    1598. 

  1598. 									break 3;
    1599. 

  1599. 								}
    1600. 

  1600. 								fseek ( $this->getid3->fp, $nextoffset, SEEK_SET );
    1601. 

  1601. 							}
    1602. 

  1602. 							break;
    1603. 

  1603. 					}
    1604. 

  1604. 					break;
    1605. 

  1605. 			
    1606. 

  1606. 			}
    1607. 

  1607. 		
    1608. 

  1608. 		}
    1609. 

  1609. 		
    1610. 

  1610. 		return $RIFFchunk;
    1611. 

  1611. 	}
    1612. 

  1612. 	
    1613. 

  1613. 	function ParseRIFFdata(&$RIFFdata) {
    1614. 

  1614. 		$info = &$this->getid3->info;
    1615. 

  1615. 		if ($RIFFdata) {
    1616. 

  1616. 			$tempfile = tempnam ( GETID3_TEMP_DIR, 'getID3' );
    1617. 

  1617. 			$fp_temp = fopen ( $tempfile, 'wb' );
    1618. 

  1618. 			$RIFFdataLength = strlen ( $RIFFdata );
    1619. 

  1619. 			$NewLengthString = getid3_lib::LittleEndian2String ( $RIFFdataLength, 4 );
    1620. 

  1620. 			for($i = 0; $i < 4; $i ++) {
    1621. 

  1621. 				$RIFFdata {$i + 4} = $NewLengthString {$i};
    1622. 

  1622. 			}
    1623. 

  1623. 			fwrite ( $fp_temp, $RIFFdata );
    1624. 

  1624. 			fclose ( $fp_temp );
    1625. 

  1625. 			
    1626. 

  1626. 			$getid3_temp = new getID3 ();
    1627. 

  1627. 			$getid3_temp->openfile ( $tempfile );
    1628. 

  1628. 			$getid3_temp->info ['filesize'] = $RIFFdataLength;
    1629. 

  1629. 			$getid3_temp->info ['filenamepath'] = $info ['filenamepath'];
    1630. 

  1630. 			$getid3_temp->info ['tags'] = $info ['tags'];
    1631. 

  1631. 			$getid3_temp->info ['warning'] = $info ['warning'];
    1632. 

  1632. 			$getid3_temp->info ['error'] = $info ['error'];
    1633. 

  1633. 			$getid3_temp->info ['comments'] = $info ['comments'];
    1634. 

  1634. 			$getid3_temp->info ['audio'] = (isset ( $info ['audio'] ) ? $info ['audio'] : array ());
    1635. 

  1635. 			$getid3_temp->info ['video'] = (isset ( $info ['video'] ) ? $info ['video'] : array ());
    1636. 

  1636. 			$getid3_riff = new getid3_riff ( $getid3_temp );
    1637. 

  1637. 			$getid3_riff->Analyze ();
    1638. 

  1638. 			
    1639. 

  1639. 			$info ['riff'] = $getid3_temp->info ['riff'];
    1640. 

  1640. 			$info ['warning'] = $getid3_temp->info ['warning'];
    1641. 

  1641. 			$info ['error'] = $getid3_temp->info ['error'];
    1642. 

  1642. 			$info ['tags'] = $getid3_temp->info ['tags'];
    1643. 

  1643. 			$info ['comments'] = $getid3_temp->info ['comments'];
    1644. 

  1644. 			unset ( $getid3_riff, $getid3_temp );
    1645. 

  1645. 			unlink ( $tempfile );
    1646. 

  1646. 		}
    1647. 

  1647. 		return false;
    1648. 

  1648. 	}
    1649. 

  1649. 	
    1650. 

  1650. 	public static function RIFFparseWAVEFORMATex($WaveFormatExData) {
    1651. 

  1651. 		// shortcut
    1652. 

  1652. 		$WaveFormatEx ['raw'] = array ();
    1653. 

  1653. 		$WaveFormatEx_raw = &$WaveFormatEx ['raw'];
    1654. 

  1654. 		
    1655. 

  1655. 		$WaveFormatEx_raw ['wFormatTag'] = getid3_lib::LittleEndian2Int ( substr ( $WaveFormatExData, 0, 2 ) );
    1656. 

  1656. 		$WaveFormatEx_raw ['nChannels'] = getid3_lib::LittleEndian2Int ( substr ( $WaveFormatExData, 2, 2 ) );
    1657. 

  1657. 		$WaveFormatEx_raw ['nSamplesPerSec'] = getid3_lib::LittleEndian2Int ( substr ( $WaveFormatExData, 4, 4 ) );
    1658. 

  1658. 		$WaveFormatEx_raw ['nAvgBytesPerSec'] = getid3_lib::LittleEndian2Int ( substr ( $WaveFormatExData, 8, 4 ) );
    1659. 

  1659. 		$WaveFormatEx_raw ['nBlockAlign'] = getid3_lib::LittleEndian2Int ( substr ( $WaveFormatExData, 12, 2 ) );
    1660. 

  1660. 		$WaveFormatEx_raw ['wBitsPerSample'] = getid3_lib::LittleEndian2Int ( substr ( $WaveFormatExData, 14, 2 ) );
    1661. 

  1661. 		if (strlen ( $WaveFormatExData ) > 16) {
    1662. 

  1662. 			$WaveFormatEx_raw ['cbSize'] = getid3_lib::LittleEndian2Int ( substr ( $WaveFormatExData, 16, 2 ) );
    1663. 

  1663. 		}
    1664. 

  1664. 		
    1665. 

  1665. 		$WaveFormatEx ['codec'] = getid3_riff::RIFFwFormatTagLookup ( $WaveFormatEx_raw ['wFormatTag'] );
    1666. 

  1666. 		$WaveFormatEx ['channels'] = $WaveFormatEx_raw ['nChannels'];
    1667. 

  1667. 		$WaveFormatEx ['sample_rate'] = $WaveFormatEx_raw ['nSamplesPerSec'];
    1668. 

  1668. 		$WaveFormatEx ['bitrate'] = $WaveFormatEx_raw ['nAvgBytesPerSec'] * 8;
    1669. 

  1669. 		$WaveFormatEx ['bits_per_sample'] = $WaveFormatEx_raw ['wBitsPerSample'];
    1670. 

  1670. 		
    1671. 

  1671. 		return $WaveFormatEx;
    1672. 

  1672. 	}
    1673. 

  1673. 	
    1674. 

  1674. 	function RIFFparseWavPackHeader($WavPackChunkData) {
    1675. 

  1675. 		// typedef struct {
    1676. 

  1676. 		//     char ckID [4];
    1677. 

  1677. 		//     long ckSize;
    1678. 

  1678. 		//     short version;
    1679. 

  1679. 		//     short bits;                // added for version 2.00
    1680. 

  1680. 		//     short flags, shift;        // added for version 3.00
    1681. 

  1681. 		//     long total_samples, crc, crc2;
    1682. 

  1682. 		//     char extension [4], extra_bc, extras [3];
    1683. 

  1683. 		// } WavpackHeader;
    1684. 

  1684. 		
    1685. 

  1685. 

  1686. 		// shortcut
    1687. 

  1687. 		$info = &$this->getid3->info;
    1688. 

  1688. 		$info ['wavpack'] = array ();
    1689. 

  1689. 		$thisfile_wavpack = &$info ['wavpack'];
    1690. 

  1690. 		
    1691. 

  1691. 		$thisfile_wavpack ['version'] = getid3_lib::LittleEndian2Int ( substr ( $WavPackChunkData, 0, 2 ) );
    1692. 

  1692. 		if ($thisfile_wavpack ['version'] >= 2) {
    1693. 

  1693. 			$thisfile_wavpack ['bits'] = getid3_lib::LittleEndian2Int ( substr ( $WavPackChunkData, 2, 2 ) );
    1694. 

  1694. 		}
    1695. 

  1695. 		if ($thisfile_wavpack ['version'] >= 3) {
    1696. 

  1696. 			$thisfile_wavpack ['flags_raw'] = getid3_lib::LittleEndian2Int ( substr ( $WavPackChunkData, 4, 2 ) );
    1697. 

  1697. 			$thisfile_wavpack ['shift'] = getid3_lib::LittleEndian2Int ( substr ( $WavPackChunkData, 6, 2 ) );
    1698. 

  1698. 			$thisfile_wavpack ['total_samples'] = getid3_lib::LittleEndian2Int ( substr ( $WavPackChunkData, 8, 4 ) );
    1699. 

  1699. 			$thisfile_wavpack ['crc1'] = getid3_lib::LittleEndian2Int ( substr ( $WavPackChunkData, 12, 4 ) );
    1700. 

  1700. 			$thisfile_wavpack ['crc2'] = getid3_lib::LittleEndian2Int ( substr ( $WavPackChunkData, 16, 4 ) );
    1701. 

  1701. 			$thisfile_wavpack ['extension'] = substr ( $WavPackChunkData, 20, 4 );
    1702. 

  1702. 			$thisfile_wavpack ['extra_bc'] = getid3_lib::LittleEndian2Int ( substr ( $WavPackChunkData, 24, 1 ) );
    1703. 

  1703. 			for($i = 0; $i <= 2; $i ++) {
    1704. 

  1704. 				$thisfile_wavpack ['extras'] [] = getid3_lib::LittleEndian2Int ( substr ( $WavPackChunkData, 25 + $i, 1 ) );
    1705. 

  1705. 			}
    1706. 

  1706. 			
    1707. 

  1707. 			// shortcut
    1708. 

  1708. 			$thisfile_wavpack ['flags'] = array ();
    1709. 

  1709. 			$thisfile_wavpack_flags = &$thisfile_wavpack ['flags'];
    1710. 

  1710. 			
    1711. 

  1711. 			$thisfile_wavpack_flags ['mono'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000001);
    1712. 

  1712. 			$thisfile_wavpack_flags ['fast_mode'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000002);
    1713. 

  1713. 			$thisfile_wavpack_flags ['raw_mode'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000004);
    1714. 

  1714. 			$thisfile_wavpack_flags ['calc_noise'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000008);
    1715. 

  1715. 			$thisfile_wavpack_flags ['high_quality'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000010);
    1716. 

  1716. 			$thisfile_wavpack_flags ['3_byte_samples'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000020);
    1717. 

  1717. 			$thisfile_wavpack_flags ['over_20_bits'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000040);
    1718. 

  1718. 			$thisfile_wavpack_flags ['use_wvc'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000080);
    1719. 

  1719. 			$thisfile_wavpack_flags ['noiseshaping'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000100);
    1720. 

  1720. 			$thisfile_wavpack_flags ['very_fast_mode'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000200);
    1721. 

  1721. 			$thisfile_wavpack_flags ['new_high_quality'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000400);
    1722. 

  1722. 			$thisfile_wavpack_flags ['cancel_extreme'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x000800);
    1723. 

  1723. 			$thisfile_wavpack_flags ['cross_decorrelation'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x001000);
    1724. 

  1724. 			$thisfile_wavpack_flags ['new_decorrelation'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x002000);
    1725. 

  1725. 			$thisfile_wavpack_flags ['joint_stereo'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x004000);
    1726. 

  1726. 			$thisfile_wavpack_flags ['extra_decorrelation'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x008000);
    1727. 

  1727. 			$thisfile_wavpack_flags ['override_noiseshape'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x010000);
    1728. 

  1728. 			$thisfile_wavpack_flags ['override_jointstereo'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x020000);
    1729. 

  1729. 			$thisfile_wavpack_flags ['copy_source_filetime'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x040000);
    1730. 

  1730. 			$thisfile_wavpack_flags ['create_exe'] = ( bool ) ($thisfile_wavpack ['flags_raw'] & 0x080000);
    1731. 

  1731. 		}
    1732. 

  1732. 		
    1733. 

  1733. 		return true;
    1734. 

  1734. 	}
    1735. 

  1735. 	
    1736. 

  1736. 	public static function ParseBITMAPINFOHEADER($BITMAPINFOHEADER, $littleEndian = true) {
    1737. 

  1737. 		
    1738. 

  1738. 		$functionname = ($littleEndian ? 'LittleEndian2Int' : 'BigEndian2Int');
    1739. 

  1739. 		$parsed ['biSize'] = getid3_lib::$functionname ( substr ( $BITMAPINFOHEADER, 0, 4 ) ); // number of bytes required by the BITMAPINFOHEADER structure
    1740. 

  1740. 		$parsed ['biWidth'] = getid3_lib::$functionname ( substr ( $BITMAPINFOHEADER, 4, 4 ) ); // width of the bitmap in pixels
    1741. 

  1741. 		$parsed ['biHeight'] = getid3_lib::$functionname ( substr ( $BITMAPINFOHEADER, 8, 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
    1742. 

  1742. 		$parsed ['biPlanes'] = getid3_lib::$functionname ( substr ( $BITMAPINFOHEADER, 12, 2 ) ); // number of color planes on the target device. In most cases this value must be set to 1
    1743. 

  1743. 		$parsed ['biBitCount'] = getid3_lib::$functionname ( substr ( $BITMAPINFOHEADER, 14, 2 ) ); // Specifies the number of bits per pixels
    1744. 

  1744. 		$parsed ['fourcc'] = substr ( $BITMAPINFOHEADER, 16, 4 ); // compression identifier
    1745. 

  1745. 		$parsed ['biSizeImage'] = getid3_lib::$functionname ( substr ( $BITMAPINFOHEADER, 20, 4 ) ); // size of the bitmap data section of the image (the actual pixel data, excluding BITMAPINFOHEADER and RGBQUAD structures)
    1746. 

  1746. 		$parsed ['biXPelsPerMeter'] = getid3_lib::$functionname ( substr ( $BITMAPINFOHEADER, 24, 4 ) ); // horizontal resolution, in pixels per metre, of the target device
    1747. 

  1747. 		$parsed ['biYPelsPerMeter'] = getid3_lib::$functionname ( substr ( $BITMAPINFOHEADER, 28, 4 ) ); // vertical resolution, in pixels per metre, of the target device
    1748. 

  1748. 		$parsed ['biClrUsed'] = getid3_lib::$functionname ( substr ( $BITMAPINFOHEADER, 32, 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
    1749. 

  1749. 		$parsed ['biClrImportant'] = getid3_lib::$functionname ( substr ( $BITMAPINFOHEADER, 36, 4 ) ); // number of color indices that are considered important for displaying the bitmap. If this value is zero, all colors are important
    1750. 

  1750. 		
    1751. 

  1751. 

  1752. 		return $parsed;
    1753. 

  1753. 	}
    1754. 

  1754. 	
    1755. 

  1755. 	static function ParseDIVXTAG($DIVXTAG) {
    1756. 

  1756. 		// structure from "IDivX" source, Form1.frm, by "Greg Frazier of Daemonic Software Group", email: gfrazier@icestorm.net, web: http://dsg.cjb.net/
    1757. 

  1757. 		// source available at http://files.divx-digest.com/download/c663efe7ef8ad2e90bf4af4d3ea6188a/on0SWN2r/edit/IDivX.zip
    1758. 

  1758. 		// 'Byte Layout:                   '1111111111111111
    1759. 

  1759. 		// '32 for Movie - 1               '1111111111111111
    1760. 

  1760. 		// '28 for Author - 6              '6666666666666666
    1761. 

  1761. 		// '4  for year - 2                '6666666666662222
    1762. 

  1762. 		// '3  for genre - 3               '7777777777777777
    1763. 

  1763. 		// '48 for Comments - 7            '7777777777777777
    1764. 

  1764. 		// '1  for Rating - 4              '7777777777777777
    1765. 

  1765. 		// '5  for Future Additions - 0    '333400000DIVXTAG
    1766. 

  1766. 		// '128 bytes total
    1767. 

  1767. 		
    1768. 

  1768. 

  1769. 		static $DIVXTAGgenre = array (
    1770. 

  1770. 									0 => 'Action', 
    1771. 

  1771. 									1 => 'Action/Adventure', 
    1772. 

  1772. 									2 => 'Adventure', 
    1773. 

  1773. 									3 => 'Adult', 
    1774. 

  1774. 									4 => 'Anime', 
    1775. 

  1775. 									5 => 'Cartoon', 
    1776. 

  1776. 									6 => 'Claymation', 
    1777. 

  1777. 									7 => 'Comedy', 
    1778. 

  1778. 									8 => 'Commercial', 
    1779. 

  1779. 									9 => 'Documentary', 
    1780. 

  1780. 									10 => 'Drama', 
    1781. 

  1781. 									11 => 'Home Video', 
    1782. 

  1782. 									12 => 'Horror', 
    1783. 

  1783. 									13 => 'Infomercial', 
    1784. 

  1784. 									14 => 'Interactive', 
    1785. 

  1785. 									15 => 'Mystery', 
    1786. 

  1786. 									16 => 'Music Video', 
    1787. 

  1787. 									17 => 'Other', 
    1788. 

  1788. 									18 => 'Religion', 
    1789. 

  1789. 									19 => 'Sci Fi', 
    1790. 

  1790. 									20 => 'Thriller', 
    1791. 

  1791. 									21 => 'Western' );
    1792. 

  1792. 		static $DIVXTAGrating = array (
    1793. 

  1793. 									0 => 'Unrated', 
    1794. 

  1794. 									1 => 'G', 
    1795. 

  1795. 									2 => 'PG', 
    1796. 

  1796. 									3 => 'PG-13', 
    1797. 

  1797. 									4 => 'R', 
    1798. 

  1798. 									5 => 'NC-17' );
    1799. 

  1799. 		
    1800. 

  1800. 		$parsed ['title'] = trim ( substr ( $DIVXTAG, 0, 32 ) );
    1801. 

  1801. 		$parsed ['artist'] = trim ( substr ( $DIVXTAG, 32, 28 ) );
    1802. 

  1802. 		$parsed ['year'] = intval ( trim ( substr ( $DIVXTAG, 60, 4 ) ) );
    1803. 

  1803. 		$parsed ['comment'] = trim ( substr ( $DIVXTAG, 64, 48 ) );
    1804. 

  1804. 		$parsed ['genre_id'] = intval ( trim ( substr ( $DIVXTAG, 112, 3 ) ) );
    1805. 

  1805. 		$parsed ['rating_id'] = ord ( substr ( $DIVXTAG, 115, 1 ) );
    1806. 

  1806. 		//$parsed['padding'] =             substr($DIVXTAG, 116,  5);  // 5-byte null
    1807. 

  1807. 		//$parsed['magic']   =             substr($DIVXTAG, 121,  7);  // "DIVXTAG"
    1808. 

  1808. 		
    1809. 

  1809. 

  1810. 		$parsed ['genre'] = (isset ( $DIVXTAGgenre [$parsed ['genre_id']] ) ? $DIVXTAGgenre [$parsed ['genre_id']] : $parsed ['genre_id']);
    1811. 

  1811. 		$parsed ['rating'] = (isset ( $DIVXTAGrating [$parsed ['rating_id']] ) ? $DIVXTAGrating [$parsed ['rating_id']] : $parsed ['rating_id']);
    1812. 

  1812. 		return $parsed;
    1813. 

  1813. 	}
    1814. 

  1814. 	
    1815. 

  1815. 	static function RIFFwaveSNDMtagLookup($tagshortname) {
    1816. 

  1816. 		$begin = __LINE__;
    1817. 

  1817. 		
    1818. 

  1818. 		/* This is not a comment!
    1819. 

    1820. 

  1820. 			©kwd	keywords
    1821. 

  1821. 			©BPM	bpm
    1822. 

  1822. 			©trt	tracktitle
    1823. 

  1823. 			©des	description
    1824. 

  1824. 			©gen	category
    1825. 

  1825. 			©fin	featuredinstrument
    1826. 

  1826. 			©LID	longid
    1827. 

  1827. 			©bex	bwdescription
    1828. 

  1828. 			©pub	publisher
    1829. 

  1829. 			©cdt	cdtitle
    1830. 

  1830. 			©alb	library
    1831. 

  1831. 			©com	composer
    1832. 

    1833. 

  1833. 		*/
    1834. 

  1834. 		
    1835. 

  1835. 		return getid3_lib::EmbeddedLookup ( $tagshortname, $begin, __LINE__, __FILE__, 'riff-sndm' );
    1836. 

  1836. 	}
    1837. 

  1837. 	
    1838. 

  1838. 	static function RIFFwFormatTagLookup($wFormatTag) {
    1839. 

  1839. 		
    1840. 

  1840. 		$begin = __LINE__;
    1841. 

  1841. 		
    1842. 

  1842. 		/* This is not a comment!
    1843. 

    1844. 

  1844. 			0x0000	Microsoft Unknown Wave Format
    1845. 

  1845. 			0x0001	Pulse Code Modulation (PCM)
    1846. 

  1846. 			0x0002	Microsoft ADPCM
    1847. 

  1847. 			0x0003	IEEE Float
    1848. 

  1848. 			0x0004	Compaq Computer VSELP
    1849. 

  1849. 			0x0005	IBM CVSD
    1850. 

  1850. 			0x0006	Microsoft A-Law
    1851. 

  1851. 			0x0007	Microsoft mu-Law
    1852. 

  1852. 			0x0008	Microsoft DTS
    1853. 

  1853. 			0x0010	OKI ADPCM
    1854. 

  1854. 			0x0011	Intel DVI/IMA ADPCM
    1855. 

  1855. 			0x0012	Videologic MediaSpace ADPCM
    1856. 

  1856. 			0x0013	Sierra Semiconductor ADPCM
    1857. 

  1857. 			0x0014	Antex Electronics G.723 ADPCM
    1858. 

  1858. 			0x0015	DSP Solutions DigiSTD
    1859. 

  1859. 			0x0016	DSP Solutions DigiFIX
    1860. 

  1860. 			0x0017	Dialogic OKI ADPCM
    1861. 

  1861. 			0x0018	MediaVision ADPCM
    1862. 

  1862. 			0x0019	Hewlett-Packard CU
    1863. 

  1863. 			0x0020	Yamaha ADPCM
    1864. 

  1864. 			0x0021	Speech Compression Sonarc
    1865. 

  1865. 			0x0022	DSP Group TrueSpeech
    1866. 

  1866. 			0x0023	Echo Speech EchoSC1
    1867. 

  1867. 			0x0024	Audiofile AF36
    1868. 

  1868. 			0x0025	Audio Processing Technology APTX
    1869. 

  1869. 			0x0026	AudioFile AF10
    1870. 

  1870. 			0x0027	Prosody 1612
    1871. 

  1871. 			0x0028	LRC
    1872. 

  1872. 			0x0030	Dolby AC2
    1873. 

  1873. 			0x0031	Microsoft GSM 6.10
    1874. 

  1874. 			0x0032	MSNAudio
    1875. 

  1875. 			0x0033	Antex Electronics ADPCME
    1876. 

  1876. 			0x0034	Control Resources VQLPC
    1877. 

  1877. 			0x0035	DSP Solutions DigiREAL
    1878. 

  1878. 			0x0036	DSP Solutions DigiADPCM
    1879. 

  1879. 			0x0037	Control Resources CR10
    1880. 

  1880. 			0x0038	Natural MicroSystems VBXADPCM
    1881. 

  1881. 			0x0039	Crystal Semiconductor IMA ADPCM
    1882. 

  1882. 			0x003A	EchoSC3
    1883. 

  1883. 			0x003B	Rockwell ADPCM
    1884. 

  1884. 			0x003C	Rockwell Digit LK
    1885. 

  1885. 			0x003D	Xebec
    1886. 

  1886. 			0x0040	Antex Electronics G.721 ADPCM
    1887. 

  1887. 			0x0041	G.728 CELP
    1888. 

  1888. 			0x0042	MSG723
    1889. 

  1889. 			0x0050	MPEG Layer-2 or Layer-1
    1890. 

  1890. 			0x0052	RT24
    1891. 

  1891. 			0x0053	PAC
    1892. 

  1892. 			0x0055	MPEG Layer-3
    1893. 

  1893. 			0x0059	Lucent G.723
    1894. 

  1894. 			0x0060	Cirrus
    1895. 

  1895. 			0x0061	ESPCM
    1896. 

  1896. 			0x0062	Voxware
    1897. 

  1897. 			0x0063	Canopus Atrac
    1898. 

  1898. 			0x0064	G.726 ADPCM
    1899. 

  1899. 			0x0065	G.722 ADPCM
    1900. 

  1900. 			0x0066	DSAT
    1901. 

  1901. 			0x0067	DSAT Display
    1902. 

  1902. 			0x0069	Voxware Byte Aligned
    1903. 

  1903. 			0x0070	Voxware AC8
    1904. 

  1904. 			0x0071	Voxware AC10
    1905. 

  1905. 			0x0072	Voxware AC16
    1906. 

  1906. 			0x0073	Voxware AC20
    1907. 

  1907. 			0x0074	Voxware MetaVoice
    1908. 

  1908. 			0x0075	Voxware MetaSound
    1909. 

  1909. 			0x0076	Voxware RT29HW
    1910. 

  1910. 			0x0077	Voxware VR12
    1911. 

  1911. 			0x0078	Voxware VR18
    1912. 

  1912. 			0x0079	Voxware TQ40
    1913. 

  1913. 			0x0080	Softsound
    1914. 

  1914. 			0x0081	Voxware TQ60
    1915. 

  1915. 			0x0082	MSRT24
    1916. 

  1916. 			0x0083	G.729A
    1917. 

  1917. 			0x0084	MVI MV12
    1918. 

  1918. 			0x0085	DF G.726
    1919. 

  1919. 			0x0086	DF GSM610
    1920. 

  1920. 			0x0088	ISIAudio
    1921. 

  1921. 			0x0089	Onlive
    1922. 

  1922. 			0x0091	SBC24
    1923. 

  1923. 			0x0092	Dolby AC3 SPDIF
    1924. 

  1924. 			0x0093	MediaSonic G.723
    1925. 

  1925. 			0x0094	Aculab PLC    Prosody 8kbps
    1926. 

  1926. 			0x0097	ZyXEL ADPCM
    1927. 

  1927. 			0x0098	Philips LPCBB
    1928. 

  1928. 			0x0099	Packed
    1929. 

  1929. 			0x00FF	AAC
    1930. 

  1930. 			0x0100	Rhetorex ADPCM
    1931. 

  1931. 			0x0101	IBM mu-law
    1932. 

  1932. 			0x0102	IBM A-law
    1933. 

  1933. 			0x0103	IBM AVC Adaptive Differential Pulse Code Modulation (ADPCM)
    1934. 

  1934. 			0x0111	Vivo G.723
    1935. 

  1935. 			0x0112	Vivo Siren
    1936. 

  1936. 			0x0123	Digital G.723
    1937. 

  1937. 			0x0125	Sanyo LD ADPCM
    1938. 

  1938. 			0x0130	Sipro Lab Telecom ACELP NET
    1939. 

  1939. 			0x0131	Sipro Lab Telecom ACELP 4800
    1940. 

  1940. 			0x0132	Sipro Lab Telecom ACELP 8V3
    1941. 

  1941. 			0x0133	Sipro Lab Telecom G.729
    1942. 

  1942. 			0x0134	Sipro Lab Telecom G.729A
    1943. 

  1943. 			0x0135	Sipro Lab Telecom Kelvin
    1944. 

  1944. 			0x0140	Windows Media Video V8
    1945. 

  1945. 			0x0150	Qualcomm PureVoice
    1946. 

  1946. 			0x0151	Qualcomm HalfRate
    1947. 

  1947. 			0x0155	Ring Zero Systems TUB GSM
    1948. 

  1948. 			0x0160	Microsoft Audio 1
    1949. 

  1949. 			0x0161	Windows Media Audio V7 / V8 / V9
    1950. 

  1950. 			0x0162	Windows Media Audio Professional V9
    1951. 

  1951. 			0x0163	Windows Media Audio Lossless V9
    1952. 

  1952. 			0x0200	Creative Labs ADPCM
    1953. 

  1953. 			0x0202	Creative Labs Fastspeech8
    1954. 

  1954. 			0x0203	Creative Labs Fastspeech10
    1955. 

  1955. 			0x0210	UHER Informatic GmbH ADPCM
    1956. 

  1956. 			0x0220	Quarterdeck
    1957. 

  1957. 			0x0230	I-link Worldwide VC
    1958. 

  1958. 			0x0240	Aureal RAW Sport
    1959. 

  1959. 			0x0250	Interactive Products HSX
    1960. 

  1960. 			0x0251	Interactive Products RPELP
    1961. 

  1961. 			0x0260	Consistent Software CS2
    1962. 

  1962. 			0x0270	Sony SCX
    1963. 

  1963. 			0x0300	Fujitsu FM Towns Snd
    1964. 

  1964. 			0x0400	BTV Digital
    1965. 

  1965. 			0x0401	Intel Music Coder
    1966. 

  1966. 			0x0450	QDesign Music
    1967. 

  1967. 			0x0680	VME VMPCM
    1968. 

  1968. 			0x0681	AT&T Labs TPC
    1969. 

  1969. 			0x08AE	ClearJump LiteWave
    1970. 

  1970. 			0x1000	Olivetti GSM
    1971. 

  1971. 			0x1001	Olivetti ADPCM
    1972. 

  1972. 			0x1002	Olivetti CELP
    1973. 

  1973. 			0x1003	Olivetti SBC
    1974. 

  1974. 			0x1004	Olivetti OPR
    1975. 

  1975. 			0x1100	Lernout & Hauspie Codec (0x1100)
    1976. 

  1976. 			0x1101	Lernout & Hauspie CELP Codec (0x1101)
    1977. 

  1977. 			0x1102	Lernout & Hauspie SBC Codec (0x1102)
    1978. 

  1978. 			0x1103	Lernout & Hauspie SBC Codec (0x1103)
    1979. 

  1979. 			0x1104	Lernout & Hauspie SBC Codec (0x1104)
    1980. 

  1980. 			0x1400	Norris
    1981. 

  1981. 			0x1401	AT&T ISIAudio
    1982. 

  1982. 			0x1500	Soundspace Music Compression
    1983. 

  1983. 			0x181C	VoxWare RT24 Speech
    1984. 

  1984. 			0x1FC4	NCT Soft ALF2CD (www.nctsoft.com)
    1985. 

  1985. 			0x2000	Dolby AC3
    1986. 

  1986. 			0x2001	Dolby DTS
    1987. 

  1987. 			0x2002	WAVE_FORMAT_14_4
    1988. 

  1988. 			0x2003	WAVE_FORMAT_28_8
    1989. 

  1989. 			0x2004	WAVE_FORMAT_COOK
    1990. 

  1990. 			0x2005	WAVE_FORMAT_DNET
    1991. 

  1991. 			0x674F	Ogg Vorbis 1
    1992. 

  1992. 			0x6750	Ogg Vorbis 2
    1993. 

  1993. 			0x6751	Ogg Vorbis 3
    1994. 

  1994. 			0x676F	Ogg Vorbis 1+
    1995. 

  1995. 			0x6770	Ogg Vorbis 2+
    1996. 

  1996. 			0x6771	Ogg Vorbis 3+
    1997. 

  1997. 			0x7A21	GSM-AMR (CBR, no SID)
    1998. 

  1998. 			0x7A22	GSM-AMR (VBR, including SID)
    1999. 

  1999. 			0xFFFE	WAVE_FORMAT_EXTENSIBLE
    2000. 

  2000. 			0xFFFF	WAVE_FORMAT_DEVELOPMENT
    2001. 

    2002. 

  2002. 		*/
    2003. 

  2003. 		
    2004. 

  2004. 		return getid3_lib::EmbeddedLookup ( '0x' . str_pad ( strtoupper ( dechex ( $wFormatTag ) ), 4, '0', STR_PAD_LEFT ), $begin, __LINE__, __FILE__, 'riff-wFormatTag' );
    2005. 

  2005. 	
    2006. 

  2006. 	}
    2007. 

  2007. 	
    2008. 

  2008. 	public static function RIFFfourccLookup($fourcc) {
    2009. 

  2009. 		
    2010. 

  2010. 		$begin = __LINE__;
    2011. 

  2011. 		
    2012. 

  2012. 		/* This is not a comment!
    2013. 

    2014. 

  2014. 			swot	http://developer.apple.com/qa/snd/snd07.html
    2015. 

  2015. 			____	No Codec (____)
    2016. 

  2016. 			_BIT	BI_BITFIELDS (Raw RGB)
    2017. 

  2017. 			_JPG	JPEG compressed
    2018. 

  2018. 			_PNG	PNG compressed W3C/ISO/IEC (RFC-2083)
    2019. 

  2019. 			_RAW	Full Frames (Uncompressed)
    2020. 

  2020. 			_RGB	Raw RGB Bitmap
    2021. 

  2021. 			_RL4	RLE 4bpp RGB
    2022. 

  2022. 			_RL8	RLE 8bpp RGB
    2023. 

  2023. 			3IV1	3ivx MPEG-4 v1
    2024. 

  2024. 			3IV2	3ivx MPEG-4 v2
    2025. 

  2025. 			3IVX	3ivx MPEG-4
    2026. 

  2026. 			AASC	Autodesk Animator
    2027. 

  2027. 			ABYR	Kensington ?ABYR?
    2028. 

  2028. 			AEMI	Array Microsystems VideoONE MPEG1-I Capture
    2029. 

  2029. 			AFLC	Autodesk Animator FLC
    2030. 

  2030. 			AFLI	Autodesk Animator FLI
    2031. 

  2031. 			AMPG	Array Microsystems VideoONE MPEG
    2032. 

  2032. 			ANIM	Intel RDX (ANIM)
    2033. 

  2033. 			AP41	AngelPotion Definitive
    2034. 

  2034. 			ASV1	Asus Video v1
    2035. 

  2035. 			ASV2	Asus Video v2
    2036. 

  2036. 			ASVX	Asus Video 2.0 (audio)
    2037. 

  2037. 			AUR2	AuraVision Aura 2 Codec - YUV 4:2:2
    2038. 

  2038. 			AURA	AuraVision Aura 1 Codec - YUV 4:1:1
    2039. 

  2039. 			AVDJ	Independent JPEG Group\'s codec (AVDJ)
    2040. 

  2040. 			AVRN	Independent JPEG Group\'s codec (AVRN)
    2041. 

  2041. 			AYUV	4:4:4 YUV (AYUV)
    2042. 

  2042. 			AZPR	Quicktime Apple Video (AZPR)
    2043. 

  2043. 			BGR 	Raw RGB32
    2044. 

  2044. 			BLZ0	Blizzard DivX MPEG-4
    2045. 

  2045. 			BTVC	Conexant Composite Video
    2046. 

  2046. 			BINK	RAD Game Tools Bink Video
    2047. 

  2047. 			BT20	Conexant Prosumer Video
    2048. 

  2048. 			BTCV	Conexant Composite Video Codec
    2049. 

  2049. 			BW10	Data Translation Broadway MPEG Capture
    2050. 

  2050. 			CC12	Intel YUV12
    2051. 

  2051. 			CDVC	Canopus DV
    2052. 

  2052. 			CFCC	Digital Processing Systems DPS Perception
    2053. 

  2053. 			CGDI	Microsoft Office 97 Camcorder Video
    2054. 

  2054. 			CHAM	Winnov Caviara Champagne
    2055. 

  2055. 			CJPG	Creative WebCam JPEG
    2056. 

  2056. 			CLJR	Cirrus Logic YUV 4:1:1
    2057. 

  2057. 			CMYK	Common Data Format in Printing (Colorgraph)
    2058. 

  2058. 			CPLA	Weitek 4:2:0 YUV Planar
    2059. 

  2059. 			CRAM	Microsoft Video 1 (CRAM)
    2060. 

  2060. 			cvid	Radius Cinepak
    2061. 

  2061. 			CVID	Radius Cinepak
    2062. 

  2062. 			CWLT	Microsoft Color WLT DIB
    2063. 

  2063. 			CYUV	Creative Labs YUV
    2064. 

  2064. 			CYUY	ATI YUV
    2065. 

  2065. 			D261	H.261
    2066. 

  2066. 			D263	H.263
    2067. 

  2067. 			DIB 	Device Independent Bitmap
    2068. 

  2068. 			DIV1	FFmpeg OpenDivX
    2069. 

  2069. 			DIV2	Microsoft MPEG-4 v1/v2
    2070. 

  2070. 			DIV3	DivX ;-) MPEG-4 v3.x Low-Motion
    2071. 

  2071. 			DIV4	DivX ;-) MPEG-4 v3.x Fast-Motion
    2072. 

  2072. 			DIV5	DivX MPEG-4 v5.x
    2073. 

  2073. 			DIV6	DivX ;-) (MS MPEG-4 v3.x)
    2074. 

  2074. 			DIVX	DivX MPEG-4 v4 (OpenDivX / Project Mayo)
    2075. 

  2075. 			divx	DivX MPEG-4
    2076. 

  2076. 			DMB1	Matrox Rainbow Runner hardware MJPEG
    2077. 

  2077. 			DMB2	Paradigm MJPEG
    2078. 

  2078. 			DSVD	?DSVD?
    2079. 

  2079. 			DUCK	Duck TrueMotion 1.0
    2080. 

  2080. 			DPS0	DPS/Leitch Reality Motion JPEG
    2081. 

  2081. 			DPSC	DPS/Leitch PAR Motion JPEG
    2082. 

  2082. 			DV25	Matrox DVCPRO codec
    2083. 

  2083. 			DV50	Matrox DVCPRO50 codec
    2084. 

  2084. 			DVC 	IEC 61834 and SMPTE 314M (DVC/DV Video)
    2085. 

  2085. 			DVCP	IEC 61834 and SMPTE 314M (DVC/DV Video)
    2086. 

  2086. 			DVHD	IEC Standard DV 1125 lines @ 30fps / 1250 lines @ 25fps
    2087. 

  2087. 			DVMA	Darim Vision DVMPEG (dummy for MPEG compressor) (www.darvision.com)
    2088. 

  2088. 			DVSL	IEC Standard DV compressed in SD (SDL)
    2089. 

  2089. 			DVAN	?DVAN?
    2090. 

  2090. 			DVE2	InSoft DVE-2 Videoconferencing
    2091. 

  2091. 			dvsd	IEC 61834 and SMPTE 314M DVC/DV Video
    2092. 

  2092. 			DVSD	IEC 61834 and SMPTE 314M DVC/DV Video
    2093. 

  2093. 			DVX1	Lucent DVX1000SP Video Decoder
    2094. 

  2094. 			DVX2	Lucent DVX2000S Video Decoder
    2095. 

  2095. 			DVX3	Lucent DVX3000S Video Decoder
    2096. 

  2096. 			DX50	DivX v5
    2097. 

  2097. 			DXT1	Microsoft DirectX Compressed Texture (DXT1)
    2098. 

  2098. 			DXT2	Microsoft DirectX Compressed Texture (DXT2)
    2099. 

  2099. 			DXT3	Microsoft DirectX Compressed Texture (DXT3)
    2100. 

  2100. 			DXT4	Microsoft DirectX Compressed Texture (DXT4)
    2101. 

  2101. 			DXT5	Microsoft DirectX Compressed Texture (DXT5)
    2102. 

  2102. 			DXTC	Microsoft DirectX Compressed Texture (DXTC)
    2103. 

  2103. 			DXTn	Microsoft DirectX Compressed Texture (DXTn)
    2104. 

  2104. 			EM2V	Etymonix MPEG-2 I-frame (www.etymonix.com)
    2105. 

  2105. 			EKQ0	Elsa ?EKQ0?
    2106. 

  2106. 			ELK0	Elsa ?ELK0?
    2107. 

  2107. 			ESCP	Eidos Escape
    2108. 

  2108. 			ETV1	eTreppid Video ETV1
    2109. 

  2109. 			ETV2	eTreppid Video ETV2
    2110. 

  2110. 			ETVC	eTreppid Video ETVC
    2111. 

  2111. 			FLIC	Autodesk FLI/FLC Animation
    2112. 

  2112. 			FLV1	Sorenson Spark
    2113. 

  2113. 			FLV4	On2 TrueMotion VP6
    2114. 

  2114. 			FRWT	Darim Vision Forward Motion JPEG (www.darvision.com)
    2115. 

  2115. 			FRWU	Darim Vision Forward Uncompressed (www.darvision.com)
    2116. 

  2116. 			FLJP	D-Vision Field Encoded Motion JPEG
    2117. 

  2117. 			FPS1	FRAPS v1
    2118. 

  2118. 			FRWA	SoftLab-Nsk Forward Motion JPEG w/ alpha channel
    2119. 

  2119. 			FRWD	SoftLab-Nsk Forward Motion JPEG
    2120. 

  2120. 			FVF1	Iterated Systems Fractal Video Frame
    2121. 

  2121. 			GLZW	Motion LZW (gabest@freemail.hu)
    2122. 

  2122. 			GPEG	Motion JPEG (gabest@freemail.hu)
    2123. 

  2123. 			GWLT	Microsoft Greyscale WLT DIB
    2124. 

  2124. 			H260	Intel ITU H.260 Videoconferencing
    2125. 

  2125. 			H261	Intel ITU H.261 Videoconferencing
    2126. 

  2126. 			H262	Intel ITU H.262 Videoconferencing
    2127. 

  2127. 			H263	Intel ITU H.263 Videoconferencing
    2128. 

  2128. 			H264	Intel ITU H.264 Videoconferencing
    2129. 

  2129. 			H265	Intel ITU H.265 Videoconferencing
    2130. 

  2130. 			H266	Intel ITU H.266 Videoconferencing
    2131. 

  2131. 			H267	Intel ITU H.267 Videoconferencing
    2132. 

  2132. 			H268	Intel ITU H.268 Videoconferencing
    2133. 

  2133. 			H269	Intel ITU H.269 Videoconferencing
    2134. 

  2134. 			HFYU	Huffman Lossless Codec
    2135. 

  2135. 			HMCR	Rendition Motion Compensation Format (HMCR)
    2136. 

  2136. 			HMRR	Rendition Motion Compensation Format (HMRR)
    2137. 

  2137. 			I263	FFmpeg I263 decoder
    2138. 

  2138. 			IF09	Indeo YVU9 ("YVU9 with additional delta-frame info after the U plane")
    2139. 

  2139. 			IUYV	Interlaced version of UYVY (www.leadtools.com)
    2140. 

  2140. 			IY41	Interlaced version of Y41P (www.leadtools.com)
    2141. 

  2141. 			IYU1	12 bit format used in mode 2 of the IEEE 1394 Digital Camera 1.04 spec    IEEE standard
    2142. 

  2142. 			IYU2	24 bit format used in mode 2 of the IEEE 1394 Digital Camera 1.04 spec    IEEE standard
    2143. 

  2143. 			IYUV	Planar YUV format (8-bpp Y plane, followed by 8-bpp 2×2 U and V planes)
    2144. 

  2144. 			i263	Intel ITU H.263 Videoconferencing (i263)
    2145. 

  2145. 			I420	Intel Indeo 4
    2146. 

  2146. 			IAN 	Intel Indeo 4 (RDX)
    2147. 

  2147. 			ICLB	InSoft CellB Videoconferencing
    2148. 

  2148. 			IGOR	Power DVD
    2149. 

  2149. 			IJPG	Intergraph JPEG
    2150. 

  2150. 			ILVC	Intel Layered Video
    2151. 

  2151. 			ILVR	ITU-T H.263+
    2152. 

  2152. 			IPDV	I-O Data Device Giga AVI DV Codec
    2153. 

  2153. 			IR21	Intel Indeo 2.1
    2154. 

  2154. 			IRAW	Intel YUV Uncompressed
    2155. 

  2155. 			IV30	Intel Indeo 3.0
    2156. 

  2156. 			IV31	Intel Indeo 3.1
    2157. 

  2157. 			IV32	Ligos Indeo 3.2
    2158. 

  2158. 			IV33	Ligos Indeo 3.3
    2159. 

  2159. 			IV34	Ligos Indeo 3.4
    2160. 

  2160. 			IV35	Ligos Indeo 3.5
    2161. 

  2161. 			IV36	Ligos Indeo 3.6
    2162. 

  2162. 			IV37	Ligos Indeo 3.7
    2163. 

  2163. 			IV38	Ligos Indeo 3.8
    2164. 

  2164. 			IV39	Ligos Indeo 3.9
    2165. 

  2165. 			IV40	Ligos Indeo Interactive 4.0
    2166. 

  2166. 			IV41	Ligos Indeo Interactive 4.1
    2167. 

  2167. 			IV42	Ligos Indeo Interactive 4.2
    2168. 

  2168. 			IV43	Ligos Indeo Interactive 4.3
    2169. 

  2169. 			IV44	Ligos Indeo Interactive 4.4
    2170. 

  2170. 			IV45	Ligos Indeo Interactive 4.5
    2171. 

  2171. 			IV46	Ligos Indeo Interactive 4.6
    2172. 

  2172. 			IV47	Ligos Indeo Interactive 4.7
    2173. 

  2173. 			IV48	Ligos Indeo Interactive 4.8
    2174. 

  2174. 			IV49	Ligos Indeo Interactive 4.9
    2175. 

  2175. 			IV50	Ligos Indeo Interactive 5.0
    2176. 

  2176. 			JBYR	Kensington ?JBYR?
    2177. 

  2177. 			JPEG	Still Image JPEG DIB
    2178. 

  2178. 			JPGL	Pegasus Lossless Motion JPEG
    2179. 

  2179. 			KMVC	Team17 Software Karl Morton\'s Video Codec
    2180. 

  2180. 			LSVM	Vianet Lighting Strike Vmail (Streaming) (www.vianet.com)
    2181. 

  2181. 			LEAD	LEAD Video Codec
    2182. 

  2182. 			Ljpg	LEAD MJPEG Codec
    2183. 

  2183. 			MDVD	Alex MicroDVD Video (hacked MS MPEG-4) (www.tiasoft.de)
    2184. 

  2184. 			MJPA	Morgan Motion JPEG (MJPA) (www.morgan-multimedia.com)
    2185. 

  2185. 			MJPB	Morgan Motion JPEG (MJPB) (www.morgan-multimedia.com)
    2186. 

  2186. 			MMES	Matrox MPEG-2 I-frame
    2187. 

  2187. 			MP2v	Microsoft S-Mpeg 4 version 1 (MP2v)
    2188. 

  2188. 			MP42	Microsoft S-Mpeg 4 version 2 (MP42)
    2189. 

  2189. 			MP43	Microsoft S-Mpeg 4 version 3 (MP43)
    2190. 

  2190. 			MP4S	Microsoft S-Mpeg 4 version 3 (MP4S)
    2191. 

  2191. 			MP4V	FFmpeg MPEG-4
    2192. 

  2192. 			MPG1	FFmpeg MPEG 1/2
    2193. 

  2193. 			MPG2	FFmpeg MPEG 1/2
    2194. 

  2194. 			MPG3	FFmpeg DivX ;-) (MS MPEG-4 v3)
    2195. 

  2195. 			MPG4	Microsoft MPEG-4
    2196. 

  2196. 			MPGI	Sigma Designs MPEG
    2197. 

  2197. 			MPNG	PNG images decoder
    2198. 

  2198. 			MSS1	Microsoft Windows Screen Video
    2199. 

  2199. 			MSZH	LCL (Lossless Codec Library) (www.geocities.co.jp/Playtown-Denei/2837/LRC.htm)
    2200. 

  2200. 			M261	Microsoft H.261
    2201. 

  2201. 			M263	Microsoft H.263
    2202. 

  2202. 			M4S2	Microsoft Fully Compliant MPEG-4 v2 simple profile (M4S2)
    2203. 

  2203. 			m4s2	Microsoft Fully Compliant MPEG-4 v2 simple profile (m4s2)
    2204. 

  2204. 			MC12	ATI Motion Compensation Format (MC12)
    2205. 

  2205. 			MCAM	ATI Motion Compensation Format (MCAM)
    2206. 

  2206. 			MJ2C	Morgan Multimedia Motion JPEG2000
    2207. 

  2207. 			mJPG	IBM Motion JPEG w/ Huffman Tables
    2208. 

  2208. 			MJPG	Microsoft Motion JPEG DIB
    2209. 

  2209. 			MP42	Microsoft MPEG-4 (low-motion)
    2210. 

  2210. 			MP43	Microsoft MPEG-4 (fast-motion)
    2211. 

  2211. 			MP4S	Microsoft MPEG-4 (MP4S)
    2212. 

  2212. 			mp4s	Microsoft MPEG-4 (mp4s)
    2213. 

  2213. 			MPEG	Chromatic Research MPEG-1 Video I-Frame
    2214. 

  2214. 			MPG4	Microsoft MPEG-4 Video High Speed Compressor
    2215. 

  2215. 			MPGI	Sigma Designs MPEG
    2216. 

  2216. 			MRCA	FAST Multimedia Martin Regen Codec
    2217. 

  2217. 			MRLE	Microsoft Run Length Encoding
    2218. 

  2218. 			MSVC	Microsoft Video 1
    2219. 

  2219. 			MTX1	Matrox ?MTX1?
    2220. 

  2220. 			MTX2	Matrox ?MTX2?
    2221. 

  2221. 			MTX3	Matrox ?MTX3?
    2222. 

  2222. 			MTX4	Matrox ?MTX4?
    2223. 

  2223. 			MTX5	Matrox ?MTX5?
    2224. 

  2224. 			MTX6	Matrox ?MTX6?
    2225. 

  2225. 			MTX7	Matrox ?MTX7?
    2226. 

  2226. 			MTX8	Matrox ?MTX8?
    2227. 

  2227. 			MTX9	Matrox ?MTX9?
    2228. 

  2228. 			MV12	Motion Pixels Codec (old)
    2229. 

  2229. 			MWV1	Aware Motion Wavelets
    2230. 

  2230. 			nAVI	SMR Codec (hack of Microsoft MPEG-4) (IRC #shadowrealm)
    2231. 

  2231. 			NT00	NewTek LightWave HDTV YUV w/ Alpha (www.newtek.com)
    2232. 

  2232. 			NUV1	NuppelVideo
    2233. 

  2233. 			NTN1	Nogatech Video Compression 1
    2234. 

  2234. 			NVS0	nVidia GeForce Texture (NVS0)
    2235. 

  2235. 			NVS1	nVidia GeForce Texture (NVS1)
    2236. 

  2236. 			NVS2	nVidia GeForce Texture (NVS2)
    2237. 

  2237. 			NVS3	nVidia GeForce Texture (NVS3)
    2238. 

  2238. 			NVS4	nVidia GeForce Texture (NVS4)
    2239. 

  2239. 			NVS5	nVidia GeForce Texture (NVS5)
    2240. 

  2240. 			NVT0	nVidia GeForce Texture (NVT0)
    2241. 

  2241. 			NVT1	nVidia GeForce Texture (NVT1)
    2242. 

  2242. 			NVT2	nVidia GeForce Texture (NVT2)
    2243. 

  2243. 			NVT3	nVidia GeForce Texture (NVT3)
    2244. 

  2244. 			NVT4	nVidia GeForce Texture (NVT4)
    2245. 

  2245. 			NVT5	nVidia GeForce Texture (NVT5)
    2246. 

  2246. 			PIXL	MiroXL, Pinnacle PCTV
    2247. 

  2247. 			PDVC	I-O Data Device Digital Video Capture DV codec
    2248. 

  2248. 			PGVV	Radius Video Vision
    2249. 

  2249. 			PHMO	IBM Photomotion
    2250. 

  2250. 			PIM1	MPEG Realtime (Pinnacle Cards)
    2251. 

  2251. 			PIM2	Pegasus Imaging ?PIM2?
    2252. 

  2252. 			PIMJ	Pegasus Imaging Lossless JPEG
    2253. 

  2253. 			PVEZ	Horizons Technology PowerEZ
    2254. 

  2254. 			PVMM	PacketVideo Corporation MPEG-4
    2255. 

  2255. 			PVW2	Pegasus Imaging Wavelet Compression
    2256. 

  2256. 			Q1.0	Q-Team\'s QPEG 1.0 (www.q-team.de)
    2257. 

  2257. 			Q1.1	Q-Team\'s QPEG 1.1 (www.q-team.de)
    2258. 

  2258. 			QPEG	Q-Team QPEG 1.0
    2259. 

  2259. 			qpeq	Q-Team QPEG 1.1
    2260. 

  2260. 			RGB 	Raw BGR32
    2261. 

  2261. 			RGBA	Raw RGB w/ Alpha
    2262. 

  2262. 			RMP4	REALmagic MPEG-4 (unauthorized XVID copy) (www.sigmadesigns.com)
    2263. 

  2263. 			ROQV	Id RoQ File Video Decoder
    2264. 

  2264. 			RPZA	Quicktime Apple Video (RPZA)
    2265. 

  2265. 			RUD0	Rududu video codec (http://rududu.ifrance.com/rududu/)
    2266. 

  2266. 			RV10	RealVideo 1.0 (aka RealVideo 5.0)
    2267. 

  2267. 			RV13	RealVideo 1.0 (RV13)
    2268. 

  2268. 			RV20	RealVideo G2
    2269. 

  2269. 			RV30	RealVideo 8
    2270. 

  2270. 			RV40	RealVideo 9
    2271. 

  2271. 			RGBT	Raw RGB w/ Transparency
    2272. 

  2272. 			RLE 	Microsoft Run Length Encoder
    2273. 

  2273. 			RLE4	Run Length Encoded (4bpp, 16-color)
    2274. 

  2274. 			RLE8	Run Length Encoded (8bpp, 256-color)
    2275. 

  2275. 			RT21	Intel Indeo RealTime Video 2.1
    2276. 

  2276. 			rv20	RealVideo G2
    2277. 

  2277. 			rv30	RealVideo 8
    2278. 

  2278. 			RVX 	Intel RDX (RVX )
    2279. 

  2279. 			SMC 	Apple Graphics (SMC )
    2280. 

  2280. 			SP54	Logitech Sunplus Sp54 Codec for Mustek GSmart Mini 2
    2281. 

  2281. 			SPIG	Radius Spigot
    2282. 

  2282. 			SVQ3	Sorenson Video 3 (Apple Quicktime 5)
    2283. 

  2283. 			s422	Tekram VideoCap C210 YUV 4:2:2
    2284. 

  2284. 			SDCC	Sun Communication Digital Camera Codec
    2285. 

  2285. 			SFMC	CrystalNet Surface Fitting Method
    2286. 

  2286. 			SMSC	Radius SMSC
    2287. 

  2287. 			SMSD	Radius SMSD
    2288. 

  2288. 			smsv	WorldConnect Wavelet Video
    2289. 

  2289. 			SPIG	Radius Spigot
    2290. 

  2290. 			SPLC	Splash Studios ACM Audio Codec (www.splashstudios.net)
    2291. 

  2291. 			SQZ2	Microsoft VXTreme Video Codec V2
    2292. 

  2292. 			STVA	ST Microelectronics CMOS Imager Data (Bayer)
    2293. 

  2293. 			STVB	ST Microelectronics CMOS Imager Data (Nudged Bayer)
    2294. 

  2294. 			STVC	ST Microelectronics CMOS Imager Data (Bunched)
    2295. 

  2295. 			STVX	ST Microelectronics CMOS Imager Data (Extended CODEC Data Format)
    2296. 

  2296. 			STVY	ST Microelectronics CMOS Imager Data (Extended CODEC Data Format with Correction Data)
    2297. 

  2297. 			SV10	Sorenson Video R1
    2298. 

  2298. 			SVQ1	Sorenson Video
    2299. 

  2299. 			T420	Toshiba YUV 4:2:0
    2300. 

  2300. 			TM2A	Duck TrueMotion Archiver 2.0 (www.duck.com)
    2301. 

  2301. 			TVJP	Pinnacle/Truevision Targa 2000 board (TVJP)
    2302. 

  2302. 			TVMJ	Pinnacle/Truevision Targa 2000 board (TVMJ)
    2303. 

  2303. 			TY0N	Tecomac Low-Bit Rate Codec (www.tecomac.com)
    2304. 

  2304. 			TY2C	Trident Decompression Driver
    2305. 

  2305. 			TLMS	TeraLogic Motion Intraframe Codec (TLMS)
    2306. 

  2306. 			TLST	TeraLogic Motion Intraframe Codec (TLST)
    2307. 

  2307. 			TM20	Duck TrueMotion 2.0
    2308. 

  2308. 			TM2X	Duck TrueMotion 2X
    2309. 

  2309. 			TMIC	TeraLogic Motion Intraframe Codec (TMIC)
    2310. 

  2310. 			TMOT	Horizons Technology TrueMotion S
    2311. 

  2311. 			tmot	Horizons TrueMotion Video Compression
    2312. 

  2312. 			TR20	Duck TrueMotion RealTime 2.0
    2313. 

  2313. 			TSCC	TechSmith Screen Capture Codec
    2314. 

  2314. 			TV10	Tecomac Low-Bit Rate Codec
    2315. 

  2315. 			TY2N	Trident ?TY2N?
    2316. 

  2316. 			U263	UB Video H.263/H.263+/H.263++ Decoder
    2317. 

  2317. 			UMP4	UB Video MPEG 4 (www.ubvideo.com)
    2318. 

  2318. 			UYNV	Nvidia UYVY packed 4:2:2
    2319. 

  2319. 			UYVP	Evans & Sutherland YCbCr 4:2:2 extended precision
    2320. 

  2320. 			UCOD	eMajix.com ClearVideo
    2321. 

  2321. 			ULTI	IBM Ultimotion
    2322. 

  2322. 			UYVY	UYVY packed 4:2:2
    2323. 

  2323. 			V261	Lucent VX2000S
    2324. 

  2324. 			VIFP	VFAPI Reader Codec (www.yks.ne.jp/~hori/)
    2325. 

  2325. 			VIV1	FFmpeg H263+ decoder
    2326. 

  2326. 			VIV2	Vivo H.263
    2327. 

  2327. 			VQC2	Vector-quantised codec 2 (research) http://eprints.ecs.soton.ac.uk/archive/00001310/01/VTC97-js.pdf)
    2328. 

  2328. 			VTLP	Alaris VideoGramPiX
    2329. 

  2329. 			VYU9	ATI YUV (VYU9)
    2330. 

  2330. 			VYUY	ATI YUV (VYUY)
    2331. 

  2331. 			V261	Lucent VX2000S
    2332. 

  2332. 			V422	Vitec Multimedia 24-bit YUV 4:2:2 Format
    2333. 

  2333. 			V655	Vitec Multimedia 16-bit YUV 4:2:2 Format
    2334. 

  2334. 			VCR1	ATI Video Codec 1
    2335. 

  2335. 			VCR2	ATI Video Codec 2
    2336. 

  2336. 			VCR3	ATI VCR 3.0
    2337. 

  2337. 			VCR4	ATI VCR 4.0
    2338. 

  2338. 			VCR5	ATI VCR 5.0
    2339. 

  2339. 			VCR6	ATI VCR 6.0
    2340. 

  2340. 			VCR7	ATI VCR 7.0
    2341. 

  2341. 			VCR8	ATI VCR 8.0
    2342. 

  2342. 			VCR9	ATI VCR 9.0
    2343. 

  2343. 			VDCT	Vitec Multimedia Video Maker Pro DIB
    2344. 

  2344. 			VDOM	VDOnet VDOWave
    2345. 

  2345. 			VDOW	VDOnet VDOLive (H.263)
    2346. 

  2346. 			VDTZ	Darim Vison VideoTizer YUV
    2347. 

  2347. 			VGPX	Alaris VideoGramPiX
    2348. 

  2348. 			VIDS	Vitec Multimedia YUV 4:2:2 CCIR 601 for V422
    2349. 

  2349. 			VIVO	Vivo H.263 v2.00
    2350. 

  2350. 			vivo	Vivo H.263
    2351. 

  2351. 			VIXL	Miro/Pinnacle Video XL
    2352. 

  2352. 			VLV1	VideoLogic/PURE Digital Videologic Capture
    2353. 

  2353. 			VP30	On2 VP3.0
    2354. 

  2354. 			VP31	On2 VP3.1
    2355. 

  2355. 			VP6F	On2 TrueMotion VP6
    2356. 

  2356. 			VX1K	Lucent VX1000S Video Codec
    2357. 

  2357. 			VX2K	Lucent VX2000S Video Codec
    2358. 

  2358. 			VXSP	Lucent VX1000SP Video Codec
    2359. 

  2359. 			WBVC	Winbond W9960
    2360. 

  2360. 			WHAM	Microsoft Video 1 (WHAM)
    2361. 

  2361. 			WINX	Winnov Software Compression
    2362. 

  2362. 			WJPG	AverMedia Winbond JPEG
    2363. 

  2363. 			WMV1	Windows Media Video V7
    2364. 

  2364. 			WMV2	Windows Media Video V8
    2365. 

  2365. 			WMV3	Windows Media Video V9
    2366. 

  2366. 			WNV1	Winnov Hardware Compression
    2367. 

  2367. 			XYZP	Extended PAL format XYZ palette (www.riff.org)
    2368. 

  2368. 			x263	Xirlink H.263
    2369. 

  2369. 			XLV0	NetXL Video Decoder
    2370. 

  2370. 			XMPG	Xing MPEG (I-Frame only)
    2371. 

  2371. 			XVID	XviD MPEG-4 (www.xvid.org)
    2372. 

  2372. 			XXAN	?XXAN?
    2373. 

  2373. 			YU92	Intel YUV (YU92)
    2374. 

  2374. 			YUNV	Nvidia Uncompressed YUV 4:2:2
    2375. 

  2375. 			YUVP	Extended PAL format YUV palette (www.riff.org)
    2376. 

  2376. 			Y211	YUV 2:1:1 Packed
    2377. 

  2377. 			Y411	YUV 4:1:1 Packed
    2378. 

  2378. 			Y41B	Weitek YUV 4:1:1 Planar
    2379. 

  2379. 			Y41P	Brooktree PC1 YUV 4:1:1 Packed
    2380. 

  2380. 			Y41T	Brooktree PC1 YUV 4:1:1 with transparency
    2381. 

  2381. 			Y42B	Weitek YUV 4:2:2 Planar
    2382. 

  2382. 			Y42T	Brooktree UYUV 4:2:2 with transparency
    2383. 

  2383. 			Y422	ADS Technologies Copy of UYVY used in Pyro WebCam firewire camera
    2384. 

  2384. 			Y800	Simple, single Y plane for monochrome images
    2385. 

  2385. 			Y8  	Grayscale video
    2386. 

  2386. 			YC12	Intel YUV 12 codec
    2387. 

  2387. 			YUV8	Winnov Caviar YUV8
    2388. 

  2388. 			YUV9	Intel YUV9
    2389. 

  2389. 			YUY2	Uncompressed YUV 4:2:2
    2390. 

  2390. 			YUYV	Canopus YUV
    2391. 

  2391. 			YV12	YVU12 Planar
    2392. 

  2392. 			YVU9	Intel YVU9 Planar (8-bpp Y plane, followed by 8-bpp 4x4 U and V planes)
    2393. 

  2393. 			YVYU	YVYU 4:2:2 Packed
    2394. 

  2394. 			ZLIB	Lossless Codec Library zlib compression (www.geocities.co.jp/Playtown-Denei/2837/LRC.htm)
    2395. 

  2395. 			ZPEG	Metheus Video Zipper
    2396. 

    2397. 

  2397. 		*/
    2398. 

  2398. 		
    2399. 

  2399. 		return getid3_lib::EmbeddedLookup ( $fourcc, $begin, __LINE__, __FILE__, 'riff-fourcc' );
    2400. 

  2400. 	}
    2401. 

  2401. 	
    2402. 

  2402. 	function EitherEndian2Int($byteword, $signed = false) {
    2403. 

  2403. 		if ($this->getid3->info ['fileformat'] == 'riff') {
    2404. 

  2404. 			return getid3_lib::LittleEndian2Int ( $byteword, $signed );
    2405. 

  2405. 		}
    2406. 

  2406. 		return getid3_lib::BigEndian2Int ( $byteword, false, $signed );
    2407. 

  2407. 	}
    2408. 

  2408. 

  2409. }
    2410. 

  2410. 

  2411.