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

/ext/exif/exif.c

http://github.com/php/php-src
C | 4774 lines | 3938 code | 389 blank | 447 comment | 551 complexity | dcd51ab244edc17aa4832200838a8ba3 MD5 | raw file
Possible License(s): BSD-2-Clause, BSD-3-Clause, MPL-2.0-no-copyleft-exception, LGPL-2.1 
    

  1. /*
    2. 

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

  3.    | Copyright (c) The PHP Group                                          |
    4. 

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

  5.    | This source file is subject to version 3.01 of the PHP license,      |
    6. 

  6.    | that is bundled with this package in the file LICENSE, and is        |
    7. 

  7.    | available through the world-wide-web at the following url:           |
    8. 

  8.    | http://www.php.net/license/3_01.txt                                  |
    9. 

  9.    | If you did not receive a copy of the PHP license and are unable to   |
    10. 

  10.    | obtain it through the world-wide-web, please send a note to          |
    11. 

  11.    | license@php.net so we can mail you a copy immediately.               |
    12. 

  12.    +----------------------------------------------------------------------+
    13. 

  13.    | Authors: Rasmus Lerdorf <rasmus@php.net>                             |
    14. 

  14.    |          Marcus Boerger <helly@php.net>                              |
    15. 

  15.    +----------------------------------------------------------------------+
    16. 

  16.  */
    17. 

  17. 

  18. #ifdef HAVE_CONFIG_H
    19. 

  19. #include "config.h"
    20. 

  20. #endif
    21. 

  21. 

  22. #include "php.h"
    23. 

  23. #include "ext/standard/file.h"
    24. 

  24. 

  25. #if HAVE_EXIF
    26. 

  26. 

  27. /* When EXIF_DEBUG is defined the module generates a lot of debug messages
    28. 

  28.  * that help understanding what is going on. This can and should be used
    29. 

  29.  * while extending the module as it shows if you are at the right position.
    30. 

  30.  * You are always considered to have a copy of TIFF6.0 and EXIF2.10 standard.
    31. 

  31.  */
    32. 

  32. #undef EXIF_DEBUG
    33. 

  33. 

  34. #ifdef EXIF_DEBUG
    35. 

  35. #define EXIFERR_DC , const char *_file, size_t _line
    36. 

  36. #define EXIFERR_CC , __FILE__, __LINE__
    37. 

  37. #else
    38. 

  38. #define EXIFERR_DC
    39. 

  39. #define EXIFERR_CC
    40. 

  40. #endif
    41. 

  41. 

  42. #include "php_exif.h"
    43. 

  43. #include "exif_arginfo.h"
    44. 

  44. #include <math.h>
    45. 

  45. #include "php_ini.h"
    46. 

  46. #include "ext/standard/php_string.h"
    47. 

  47. #include "ext/standard/php_image.h"
    48. 

  48. #include "ext/standard/info.h"
    49. 

  49. 

  50. /* needed for ssize_t definition */
    51. 

  51. #include <sys/types.h>
    52. 

  52. 

  53. #ifdef __SANITIZE_ADDRESS__
    54. 

  54. # include <sanitizer/asan_interface.h>
    55. 

  55. #endif
    56. 

  56. 

  57. typedef unsigned char uchar;
    58. 

  58. 

  59. #ifndef TRUE
    60. 

  60. #	define TRUE 1
    61. 

  61. #	define FALSE 0
    62. 

  62. #endif
    63. 

  63. 

  64. #ifndef max
    65. 

  65. #	define max(a,b) ((a)>(b) ? (a) : (b))
    66. 

  66. #endif
    67. 

  67. 

  68. #define EFREE_IF(ptr)	if (ptr) efree(ptr)
    69. 

  69. 

  70. #define MAX_IFD_NESTING_LEVEL 150
    71. 

  71. 

  72. /* {{{ PHP_MINFO_FUNCTION
    73. 

  73.  */
    74. 

  74. PHP_MINFO_FUNCTION(exif)
    75. 

  75. {
    76. 

  76. 	php_info_print_table_start();
    77. 

  77. 	php_info_print_table_row(2, "EXIF Support", "enabled");
    78. 

  78. 	php_info_print_table_row(2, "Supported EXIF Version", "0220");
    79. 

  79. 	php_info_print_table_row(2, "Supported filetypes", "JPEG, TIFF");
    80. 

  80. 

  81. 	if (zend_hash_str_exists(&module_registry, "mbstring", sizeof("mbstring")-1)) {
    82. 

  82. 		php_info_print_table_row(2, "Multibyte decoding support using mbstring", "enabled");
    83. 

  83. 	} else {
    84. 

  84. 		php_info_print_table_row(2, "Multibyte decoding support using mbstring", "disabled");
    85. 

  85. 	}
    86. 

  86. 

  87. 	php_info_print_table_row(2, "Extended EXIF tag formats", "Canon, Casio, Fujifilm, Nikon, Olympus, Samsung, Panasonic, DJI, Sony, Pentax, Minolta, Sigma, Foveon, Kyocera, Ricoh, AGFA, Epson");
    88. 

  88. 	php_info_print_table_end();
    89. 

  89. 

  90. 	DISPLAY_INI_ENTRIES();
    91. 

  91. }
    92. 

  92. /* }}} */
    93. 

  93. 

  94. ZEND_BEGIN_MODULE_GLOBALS(exif)
    95. 

  95. 	char * encode_unicode;
    96. 

  96. 	char * decode_unicode_be;
    97. 

  97. 	char * decode_unicode_le;
    98. 

  98. 	char * encode_jis;
    99. 

  99. 	char * decode_jis_be;
    100. 

  100. 	char * decode_jis_le;
    101. 

  101. 	HashTable *tag_table_cache;
    102. 

  102. ZEND_END_MODULE_GLOBALS(exif)
    103. 

  103. 

  104. ZEND_DECLARE_MODULE_GLOBALS(exif)
    105. 

  105. #define EXIF_G(v) ZEND_MODULE_GLOBALS_ACCESSOR(exif, v)
    106. 

  106. 

  107. #if defined(ZTS) && defined(COMPILE_DL_EXIF)
    108. 

  108. ZEND_TSRMLS_CACHE_DEFINE()
    109. 

  109. #endif
    110. 

  110. 

  111. /* {{{ PHP_INI
    112. 

  112.  */
    113. 

  113. 

  114. ZEND_INI_MH(OnUpdateEncode)
    115. 

  115. {
    116. 

  116. 	if (new_value && ZSTR_LEN(new_value)) {
    117. 

  117. 		const zend_encoding **return_list;
    118. 

  118. 		size_t return_size;
    119. 

  119. 		if (FAILURE == zend_multibyte_parse_encoding_list(ZSTR_VAL(new_value), ZSTR_LEN(new_value),
    120. 

  120. 	&return_list, &return_size, 0)) {
    121. 

  121. 			php_error_docref(NULL, E_WARNING, "Illegal encoding ignored: '%s'", ZSTR_VAL(new_value));
    122. 

  122. 			return FAILURE;
    123. 

  123. 		}
    124. 

  124. 		pefree((void *) return_list, 0);
    125. 

  125. 	}
    126. 

  126. 	return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
    127. 

  127. }
    128. 

  128. 

  129. ZEND_INI_MH(OnUpdateDecode)
    130. 

  130. {
    131. 

  131. 	if (new_value) {
    132. 

  132. 		const zend_encoding **return_list;
    133. 

  133. 		size_t return_size;
    134. 

  134. 		if (FAILURE == zend_multibyte_parse_encoding_list(ZSTR_VAL(new_value), ZSTR_LEN(new_value),
    135. 

  135. 	&return_list, &return_size, 0)) {
    136. 

  136. 			php_error_docref(NULL, E_WARNING, "Illegal encoding ignored: '%s'", ZSTR_VAL(new_value));
    137. 

  137. 			return FAILURE;
    138. 

  138. 		}
    139. 

  139. 		pefree((void *) return_list, 0);
    140. 

  140. 	}
    141. 

  141. 	return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
    142. 

  142. }
    143. 

  143. 

  144. PHP_INI_BEGIN()
    145. 

  145.     STD_PHP_INI_ENTRY("exif.encode_unicode",          "ISO-8859-15", PHP_INI_ALL, OnUpdateEncode, encode_unicode,    zend_exif_globals, exif_globals)
    146. 

  146.     STD_PHP_INI_ENTRY("exif.decode_unicode_motorola", "UCS-2BE",     PHP_INI_ALL, OnUpdateDecode, decode_unicode_be, zend_exif_globals, exif_globals)
    147. 

  147.     STD_PHP_INI_ENTRY("exif.decode_unicode_intel",    "UCS-2LE",     PHP_INI_ALL, OnUpdateDecode, decode_unicode_le, zend_exif_globals, exif_globals)
    148. 

  148.     STD_PHP_INI_ENTRY("exif.encode_jis",              "",            PHP_INI_ALL, OnUpdateEncode, encode_jis,        zend_exif_globals, exif_globals)
    149. 

  149.     STD_PHP_INI_ENTRY("exif.decode_jis_motorola",     "JIS",         PHP_INI_ALL, OnUpdateDecode, decode_jis_be,     zend_exif_globals, exif_globals)
    150. 

  150.     STD_PHP_INI_ENTRY("exif.decode_jis_intel",        "JIS",         PHP_INI_ALL, OnUpdateDecode, decode_jis_le,     zend_exif_globals, exif_globals)
    151. 

  151. PHP_INI_END()
    152. 

  152. /* }}} */
    153. 

  153. 

  154. /* {{{ PHP_GINIT_FUNCTION
    155. 

  155.  */
    156. 

  156. static PHP_GINIT_FUNCTION(exif)
    157. 

  157. {
    158. 

  158. #if defined(COMPILE_DL_EXIF) && defined(ZTS)
    159. 

  159. 	ZEND_TSRMLS_CACHE_UPDATE();
    160. 

  160. #endif
    161. 

  161. 	exif_globals->encode_unicode    = NULL;
    162. 

  162. 	exif_globals->decode_unicode_be = NULL;
    163. 

  163. 	exif_globals->decode_unicode_le = NULL;
    164. 

  164. 	exif_globals->encode_jis        = NULL;
    165. 

  165. 	exif_globals->decode_jis_be     = NULL;
    166. 

  166. 	exif_globals->decode_jis_le     = NULL;
    167. 

  167. 	exif_globals->tag_table_cache   = NULL;
    168. 

  168. }
    169. 

  169. /* }}} */
    170. 

  170. 

  171. /* {{{ PHP_MINIT_FUNCTION(exif)
    172. 

  172.  */
    173. 

  173. PHP_MINIT_FUNCTION(exif)
    174. 

  174. {
    175. 

  175. 	REGISTER_INI_ENTRIES();
    176. 

  176. 	if (zend_hash_str_exists(&module_registry, "mbstring", sizeof("mbstring")-1)) {
    177. 

  177. 		REGISTER_LONG_CONSTANT("EXIF_USE_MBSTRING", 1, CONST_CS | CONST_PERSISTENT);
    178. 

  178. 	} else {
    179. 

  179. 		REGISTER_LONG_CONSTANT("EXIF_USE_MBSTRING", 0, CONST_CS | CONST_PERSISTENT);
    180. 

  180. 	}
    181. 

  181. 	return SUCCESS;
    182. 

  182. }
    183. 

  183. /* }}} */
    184. 

  184. 

  185. /* {{{ PHP_MSHUTDOWN_FUNCTION
    186. 

  186.  */
    187. 

  187. PHP_MSHUTDOWN_FUNCTION(exif)
    188. 

  188. {
    189. 

  189. 	UNREGISTER_INI_ENTRIES();
    190. 

  190. 	if (EXIF_G(tag_table_cache)) {
    191. 

  191. 		zend_hash_destroy(EXIF_G(tag_table_cache));
    192. 

  192. 		free(EXIF_G(tag_table_cache));
    193. 

  193. 	}
    194. 

  194. 	return SUCCESS;
    195. 

  195. }
    196. 

  196. /* }}} */
    197. 

  197. 

  198. /* {{{ exif dependencies */
    199. 

  199. static const zend_module_dep exif_module_deps[] = {
    200. 

  200. 	ZEND_MOD_REQUIRED("standard")
    201. 

  201. 	ZEND_MOD_OPTIONAL("mbstring")
    202. 

  202. 	ZEND_MOD_END
    203. 

  203. };
    204. 

  204. /* }}} */
    205. 

  205. 

  206. /* {{{ exif_module_entry
    207. 

  207.  */
    208. 

  208. zend_module_entry exif_module_entry = {
    209. 

  209. 	STANDARD_MODULE_HEADER_EX, NULL,
    210. 

  210. 	exif_module_deps,
    211. 

  211. 	"exif",
    212. 

  212. 	ext_functions,
    213. 

  213. 	PHP_MINIT(exif),
    214. 

  214. 	PHP_MSHUTDOWN(exif),
    215. 

  215. 	NULL, NULL,
    216. 

  216. 	PHP_MINFO(exif),
    217. 

  217. 	PHP_EXIF_VERSION,
    218. 

  218. 	PHP_MODULE_GLOBALS(exif),
    219. 

  219. 	PHP_GINIT(exif),
    220. 

  220. 	NULL,
    221. 

  221. 	NULL,
    222. 

  222. 	STANDARD_MODULE_PROPERTIES_EX
    223. 

  223. };
    224. 

  224. /* }}} */
    225. 

  225. 

  226. #ifdef COMPILE_DL_EXIF
    227. 

  227. ZEND_GET_MODULE(exif)
    228. 

  228. #endif
    229. 

  229. 

  230. /* {{{ php_strnlen
    231. 

  231.  * get length of string if buffer if less than buffer size or buffer size */
    232. 

  232. static size_t php_strnlen(char* str, size_t maxlen) {
    233. 

  233. 	size_t len = 0;
    234. 

  234. 

  235. 	if (str && maxlen && *str) {
    236. 

  236. 		do {
    237. 

  237. 			len++;
    238. 

  238. 		} while (--maxlen && *(++str));
    239. 

  239. 	}
    240. 

  240. 	return len;
    241. 

  241. }
    242. 

  242. /* }}} */
    243. 

  243. 

  244. /* {{{ error messages
    245. 

  245. */
    246. 

  246. static const char * EXIF_ERROR_FILEEOF   = "Unexpected end of file reached";
    247. 

  247. static const char * EXIF_ERROR_CORRUPT   = "File structure corrupted";
    248. 

  248. static const char * EXIF_ERROR_THUMBEOF  = "Thumbnail goes IFD boundary or end of file reached";
    249. 

  249. static const char * EXIF_ERROR_FSREALLOC = "Illegal reallocating of undefined file section";
    250. 

  250. 

  251. #define EXIF_ERRLOG_FILEEOF(ImageInfo)    exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "%s", EXIF_ERROR_FILEEOF);
    252. 

  252. #define EXIF_ERRLOG_CORRUPT(ImageInfo)    exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "%s", EXIF_ERROR_CORRUPT);
    253. 

  253. #define EXIF_ERRLOG_THUMBEOF(ImageInfo)   exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "%s", EXIF_ERROR_THUMBEOF);
    254. 

  254. #define EXIF_ERRLOG_FSREALLOC(ImageInfo)  exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "%s", EXIF_ERROR_FSREALLOC);
    255. 

  255. /* }}} */
    256. 

  256. 

  257. /* {{{ format description defines
    258. 

  258.    Describes format descriptor
    259. 

  259. */
    260. 

  260. static int php_tiff_bytes_per_format[] = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 1};
    261. 

  261. #define NUM_FORMATS 13
    262. 

  262. 

  263. #define TAG_FMT_BYTE       1
    264. 

  264. #define TAG_FMT_STRING     2
    265. 

  265. #define TAG_FMT_USHORT     3
    266. 

  266. #define TAG_FMT_ULONG      4
    267. 

  267. #define TAG_FMT_URATIONAL  5
    268. 

  268. #define TAG_FMT_SBYTE      6
    269. 

  269. #define TAG_FMT_UNDEFINED  7
    270. 

  270. #define TAG_FMT_SSHORT     8
    271. 

  271. #define TAG_FMT_SLONG      9
    272. 

  272. #define TAG_FMT_SRATIONAL 10
    273. 

  273. #define TAG_FMT_SINGLE    11
    274. 

  274. #define TAG_FMT_DOUBLE    12
    275. 

  275. #define TAG_FMT_IFD       13
    276. 

  276. 

  277. #ifdef EXIF_DEBUG
    278. 

  278. static char *exif_get_tagformat(int format)
    279. 

  279. {
    280. 

  280. 	switch(format) {
    281. 

  281. 		case TAG_FMT_BYTE:      return "BYTE";
    282. 

  282. 		case TAG_FMT_STRING:    return "STRING";
    283. 

  283. 		case TAG_FMT_USHORT:    return "USHORT";
    284. 

  284. 		case TAG_FMT_ULONG:     return "ULONG";
    285. 

  285. 		case TAG_FMT_URATIONAL: return "URATIONAL";
    286. 

  286. 		case TAG_FMT_SBYTE:     return "SBYTE";
    287. 

  287. 		case TAG_FMT_UNDEFINED: return "UNDEFINED";
    288. 

  288. 		case TAG_FMT_SSHORT:    return "SSHORT";
    289. 

  289. 		case TAG_FMT_SLONG:     return "SLONG";
    290. 

  290. 		case TAG_FMT_SRATIONAL: return "SRATIONAL";
    291. 

  291. 		case TAG_FMT_SINGLE:    return "SINGLE";
    292. 

  292. 		case TAG_FMT_DOUBLE:    return "DOUBLE";
    293. 

  293. 		case TAG_FMT_IFD:       return "IFD";
    294. 

  294. 	}
    295. 

  295. 	return "*Illegal";
    296. 

  296. }
    297. 

  297. #endif
    298. 

  298. 

  299. /* Describes tag values */
    300. 

  300. #define TAG_GPS_VERSION_ID              0x0000
    301. 

  301. #define TAG_GPS_LATITUDE_REF            0x0001
    302. 

  302. #define TAG_GPS_LATITUDE                0x0002
    303. 

  303. #define TAG_GPS_LONGITUDE_REF           0x0003
    304. 

  304. #define TAG_GPS_LONGITUDE               0x0004
    305. 

  305. #define TAG_GPS_ALTITUDE_REF            0x0005
    306. 

  306. #define TAG_GPS_ALTITUDE                0x0006
    307. 

  307. #define TAG_GPS_TIME_STAMP              0x0007
    308. 

  308. #define TAG_GPS_SATELLITES              0x0008
    309. 

  309. #define TAG_GPS_STATUS                  0x0009
    310. 

  310. #define TAG_GPS_MEASURE_MODE            0x000A
    311. 

  311. #define TAG_GPS_DOP                     0x000B
    312. 

  312. #define TAG_GPS_SPEED_REF               0x000C
    313. 

  313. #define TAG_GPS_SPEED                   0x000D
    314. 

  314. #define TAG_GPS_TRACK_REF               0x000E
    315. 

  315. #define TAG_GPS_TRACK                   0x000F
    316. 

  316. #define TAG_GPS_IMG_DIRECTION_REF       0x0010
    317. 

  317. #define TAG_GPS_IMG_DIRECTION           0x0011
    318. 

  318. #define TAG_GPS_MAP_DATUM               0x0012
    319. 

  319. #define TAG_GPS_DEST_LATITUDE_REF       0x0013
    320. 

  320. #define TAG_GPS_DEST_LATITUDE           0x0014
    321. 

  321. #define TAG_GPS_DEST_LONGITUDE_REF      0x0015
    322. 

  322. #define TAG_GPS_DEST_LONGITUDE          0x0016
    323. 

  323. #define TAG_GPS_DEST_BEARING_REF        0x0017
    324. 

  324. #define TAG_GPS_DEST_BEARING            0x0018
    325. 

  325. #define TAG_GPS_DEST_DISTANCE_REF       0x0019
    326. 

  326. #define TAG_GPS_DEST_DISTANCE           0x001A
    327. 

  327. #define TAG_GPS_PROCESSING_METHOD       0x001B
    328. 

  328. #define TAG_GPS_AREA_INFORMATION        0x001C
    329. 

  329. #define TAG_GPS_DATE_STAMP              0x001D
    330. 

  330. #define TAG_GPS_DIFFERENTIAL            0x001E
    331. 

  331. #define TAG_TIFF_COMMENT                0x00FE /* SHOULDN'T HAPPEN */
    332. 

  332. #define TAG_NEW_SUBFILE                 0x00FE /* New version of subfile tag */
    333. 

  333. #define TAG_SUBFILE_TYPE                0x00FF /* Old version of subfile tag */
    334. 

  334. #define TAG_IMAGEWIDTH                  0x0100
    335. 

  335. #define TAG_IMAGEHEIGHT                 0x0101
    336. 

  336. #define TAG_BITS_PER_SAMPLE             0x0102
    337. 

  337. #define TAG_COMPRESSION                 0x0103
    338. 

  338. #define TAG_PHOTOMETRIC_INTERPRETATION  0x0106
    339. 

  339. #define TAG_TRESHHOLDING                0x0107
    340. 

  340. #define TAG_CELL_WIDTH                  0x0108
    341. 

  341. #define TAG_CELL_HEIGHT                 0x0109
    342. 

  342. #define TAG_FILL_ORDER                  0x010A
    343. 

  343. #define TAG_DOCUMENT_NAME               0x010D
    344. 

  344. #define TAG_IMAGE_DESCRIPTION           0x010E
    345. 

  345. #define TAG_MAKE                        0x010F
    346. 

  346. #define TAG_MODEL                       0x0110
    347. 

  347. #define TAG_STRIP_OFFSETS               0x0111
    348. 

  348. #define TAG_ORIENTATION                 0x0112
    349. 

  349. #define TAG_SAMPLES_PER_PIXEL           0x0115
    350. 

  350. #define TAG_ROWS_PER_STRIP              0x0116
    351. 

  351. #define TAG_STRIP_BYTE_COUNTS           0x0117
    352. 

  352. #define TAG_MIN_SAMPPLE_VALUE           0x0118
    353. 

  353. #define TAG_MAX_SAMPLE_VALUE            0x0119
    354. 

  354. #define TAG_X_RESOLUTION                0x011A
    355. 

  355. #define TAG_Y_RESOLUTION                0x011B
    356. 

  356. #define TAG_PLANAR_CONFIGURATION        0x011C
    357. 

  357. #define TAG_PAGE_NAME                   0x011D
    358. 

  358. #define TAG_X_POSITION                  0x011E
    359. 

  359. #define TAG_Y_POSITION                  0x011F
    360. 

  360. #define TAG_FREE_OFFSETS                0x0120
    361. 

  361. #define TAG_FREE_BYTE_COUNTS            0x0121
    362. 

  362. #define TAG_GRAY_RESPONSE_UNIT          0x0122
    363. 

  363. #define TAG_GRAY_RESPONSE_CURVE         0x0123
    364. 

  364. #define TAG_RESOLUTION_UNIT             0x0128
    365. 

  365. #define TAG_PAGE_NUMBER                 0x0129
    366. 

  366. #define TAG_TRANSFER_FUNCTION           0x012D
    367. 

  367. #define TAG_SOFTWARE                    0x0131
    368. 

  368. #define TAG_DATETIME                    0x0132
    369. 

  369. #define TAG_ARTIST                      0x013B
    370. 

  370. #define TAG_HOST_COMPUTER               0x013C
    371. 

  371. #define TAG_PREDICTOR                   0x013D
    372. 

  372. #define TAG_WHITE_POINT                 0x013E
    373. 

  373. #define TAG_PRIMARY_CHROMATICITIES      0x013F
    374. 

  374. #define TAG_COLOR_MAP                   0x0140
    375. 

  375. #define TAG_HALFTONE_HINTS              0x0141
    376. 

  376. #define TAG_TILE_WIDTH                  0x0142
    377. 

  377. #define TAG_TILE_LENGTH                 0x0143
    378. 

  378. #define TAG_TILE_OFFSETS                0x0144
    379. 

  379. #define TAG_TILE_BYTE_COUNTS            0x0145
    380. 

  380. #define TAG_SUB_IFD                     0x014A
    381. 

  381. #define TAG_INK_SETMPUTER               0x014C
    382. 

  382. #define TAG_INK_NAMES                   0x014D
    383. 

  383. #define TAG_NUMBER_OF_INKS              0x014E
    384. 

  384. #define TAG_DOT_RANGE                   0x0150
    385. 

  385. #define TAG_TARGET_PRINTER              0x0151
    386. 

  386. #define TAG_EXTRA_SAMPLE                0x0152
    387. 

  387. #define TAG_SAMPLE_FORMAT               0x0153
    388. 

  388. #define TAG_S_MIN_SAMPLE_VALUE          0x0154
    389. 

  389. #define TAG_S_MAX_SAMPLE_VALUE          0x0155
    390. 

  390. #define TAG_TRANSFER_RANGE              0x0156
    391. 

  391. #define TAG_JPEG_TABLES                 0x015B
    392. 

  392. #define TAG_JPEG_PROC                   0x0200
    393. 

  393. #define TAG_JPEG_INTERCHANGE_FORMAT     0x0201
    394. 

  394. #define TAG_JPEG_INTERCHANGE_FORMAT_LEN 0x0202
    395. 

  395. #define TAG_JPEG_RESTART_INTERVAL       0x0203
    396. 

  396. #define TAG_JPEG_LOSSLESS_PREDICTOR     0x0205
    397. 

  397. #define TAG_JPEG_POINT_TRANSFORMS       0x0206
    398. 

  398. #define TAG_JPEG_Q_TABLES               0x0207
    399. 

  399. #define TAG_JPEG_DC_TABLES              0x0208
    400. 

  400. #define TAG_JPEG_AC_TABLES              0x0209
    401. 

  401. #define TAG_YCC_COEFFICIENTS            0x0211
    402. 

  402. #define TAG_YCC_SUB_SAMPLING            0x0212
    403. 

  403. #define TAG_YCC_POSITIONING             0x0213
    404. 

  404. #define TAG_REFERENCE_BLACK_WHITE       0x0214
    405. 

  405. /* 0x0301 - 0x0302 */
    406. 

  406. /* 0x0320 */
    407. 

  407. /* 0x0343 */
    408. 

  408. /* 0x5001 - 0x501B */
    409. 

  409. /* 0x5021 - 0x503B */
    410. 

  410. /* 0x5090 - 0x5091 */
    411. 

  411. /* 0x5100 - 0x5101 */
    412. 

  412. /* 0x5110 - 0x5113 */
    413. 

  413. /* 0x80E3 - 0x80E6 */
    414. 

  414. /* 0x828d - 0x828F */
    415. 

  415. #define TAG_COPYRIGHT                   0x8298
    416. 

  416. #define TAG_EXPOSURETIME                0x829A
    417. 

  417. #define TAG_FNUMBER                     0x829D
    418. 

  418. #define TAG_EXIF_IFD_POINTER            0x8769
    419. 

  419. #define TAG_ICC_PROFILE                 0x8773
    420. 

  420. #define TAG_EXPOSURE_PROGRAM            0x8822
    421. 

  421. #define TAG_SPECTRAL_SENSITY            0x8824
    422. 

  422. #define TAG_GPS_IFD_POINTER             0x8825
    423. 

  423. #define TAG_ISOSPEED                    0x8827
    424. 

  424. #define TAG_OPTOELECTRIC_CONVERSION_F   0x8828
    425. 

  425. /* 0x8829 - 0x882b */
    426. 

  426. #define TAG_EXIFVERSION                 0x9000
    427. 

  427. #define TAG_DATE_TIME_ORIGINAL          0x9003
    428. 

  428. #define TAG_DATE_TIME_DIGITIZED         0x9004
    429. 

  429. #define TAG_COMPONENT_CONFIG            0x9101
    430. 

  430. #define TAG_COMPRESSED_BITS_PER_PIXEL   0x9102
    431. 

  431. #define TAG_SHUTTERSPEED                0x9201
    432. 

  432. #define TAG_APERTURE                    0x9202
    433. 

  433. #define TAG_BRIGHTNESS_VALUE            0x9203
    434. 

  434. #define TAG_EXPOSURE_BIAS_VALUE         0x9204
    435. 

  435. #define TAG_MAX_APERTURE                0x9205
    436. 

  436. #define TAG_SUBJECT_DISTANCE            0x9206
    437. 

  437. #define TAG_METRIC_MODULE               0x9207
    438. 

  438. #define TAG_LIGHT_SOURCE                0x9208
    439. 

  439. #define TAG_FLASH                       0x9209
    440. 

  440. #define TAG_FOCAL_LENGTH                0x920A
    441. 

  441. /* 0x920B - 0x920D */
    442. 

  442. /* 0x9211 - 0x9216 */
    443. 

  443. #define TAG_SUBJECT_AREA                0x9214
    444. 

  444. #define TAG_MAKER_NOTE                  0x927C
    445. 

  445. #define TAG_USERCOMMENT                 0x9286
    446. 

  446. #define TAG_SUB_SEC_TIME                0x9290
    447. 

  447. #define TAG_SUB_SEC_TIME_ORIGINAL       0x9291
    448. 

  448. #define TAG_SUB_SEC_TIME_DIGITIZED      0x9292
    449. 

  449. /* 0x923F */
    450. 

  450. /* 0x935C */
    451. 

  451. #define TAG_XP_TITLE                    0x9C9B
    452. 

  452. #define TAG_XP_COMMENTS                 0x9C9C
    453. 

  453. #define TAG_XP_AUTHOR                   0x9C9D
    454. 

  454. #define TAG_XP_KEYWORDS                 0x9C9E
    455. 

  455. #define TAG_XP_SUBJECT                  0x9C9F
    456. 

  456. #define TAG_FLASH_PIX_VERSION           0xA000
    457. 

  457. #define TAG_COLOR_SPACE                 0xA001
    458. 

  458. #define TAG_COMP_IMAGE_WIDTH            0xA002 /* compressed images only */
    459. 

  459. #define TAG_COMP_IMAGE_HEIGHT           0xA003
    460. 

  460. #define TAG_RELATED_SOUND_FILE          0xA004
    461. 

  461. #define TAG_INTEROP_IFD_POINTER         0xA005 /* IFD pointer */
    462. 

  462. #define TAG_FLASH_ENERGY                0xA20B
    463. 

  463. #define TAG_SPATIAL_FREQUENCY_RESPONSE  0xA20C
    464. 

  464. #define TAG_FOCALPLANE_X_RES            0xA20E
    465. 

  465. #define TAG_FOCALPLANE_Y_RES            0xA20F
    466. 

  466. #define TAG_FOCALPLANE_RESOLUTION_UNIT  0xA210
    467. 

  467. #define TAG_SUBJECT_LOCATION            0xA214
    468. 

  468. #define TAG_EXPOSURE_INDEX              0xA215
    469. 

  469. #define TAG_SENSING_METHOD              0xA217
    470. 

  470. #define TAG_FILE_SOURCE                 0xA300
    471. 

  471. #define TAG_SCENE_TYPE                  0xA301
    472. 

  472. #define TAG_CFA_PATTERN                 0xA302
    473. 

  473. #define TAG_CUSTOM_RENDERED             0xA401
    474. 

  474. #define TAG_EXPOSURE_MODE               0xA402
    475. 

  475. #define TAG_WHITE_BALANCE               0xA403
    476. 

  476. #define TAG_DIGITAL_ZOOM_RATIO          0xA404
    477. 

  477. #define TAG_FOCAL_LENGTH_IN_35_MM_FILM  0xA405
    478. 

  478. #define TAG_SCENE_CAPTURE_TYPE          0xA406
    479. 

  479. #define TAG_GAIN_CONTROL                0xA407
    480. 

  480. #define TAG_CONTRAST                    0xA408
    481. 

  481. #define TAG_SATURATION                  0xA409
    482. 

  482. #define TAG_SHARPNESS                   0xA40A
    483. 

  483. #define TAG_DEVICE_SETTING_DESCRIPTION  0xA40B
    484. 

  484. #define TAG_SUBJECT_DISTANCE_RANGE      0xA40C
    485. 

  485. #define TAG_IMAGE_UNIQUE_ID             0xA420
    486. 

  486. 

  487. /* Olympus specific tags */
    488. 

  488. #define TAG_OLYMPUS_SPECIALMODE         0x0200
    489. 

  489. #define TAG_OLYMPUS_JPEGQUAL            0x0201
    490. 

  490. #define TAG_OLYMPUS_MACRO               0x0202
    491. 

  491. #define TAG_OLYMPUS_DIGIZOOM            0x0204
    492. 

  492. #define TAG_OLYMPUS_SOFTWARERELEASE     0x0207
    493. 

  493. #define TAG_OLYMPUS_PICTINFO            0x0208
    494. 

  494. #define TAG_OLYMPUS_CAMERAID            0x0209
    495. 

  495. /* end Olympus specific tags */
    496. 

  496. 

  497. /* Internal */
    498. 

  498. #define TAG_NONE               			-1 /* note that -1 <> 0xFFFF */
    499. 

  499. #define TAG_COMPUTED_VALUE     			-2
    500. 

  500. #define TAG_END_OF_LIST                 0xFFFD
    501. 

  501. 

  502. /* Values for TAG_PHOTOMETRIC_INTERPRETATION */
    503. 

  503. #define PMI_BLACK_IS_ZERO       0
    504. 

  504. #define PMI_WHITE_IS_ZERO       1
    505. 

  505. #define PMI_RGB          	    2
    506. 

  506. #define PMI_PALETTE_COLOR       3
    507. 

  507. #define PMI_TRANSPARENCY_MASK   4
    508. 

  508. #define PMI_SEPARATED           5
    509. 

  509. #define PMI_YCBCR               6
    510. 

  510. #define PMI_CIELAB              8
    511. 

  511. 

  512. /* }}} */
    513. 

  513. 

  514. /* {{{ TabTable[]
    515. 

  515.  */
    516. 

  516. typedef const struct {
    517. 

  517. 	unsigned short Tag;
    518. 

  518. 	char *Desc;
    519. 

  519. } tag_info_type;
    520. 

  520. 

  521. typedef tag_info_type  tag_info_array[];
    522. 

  522. typedef tag_info_type  *tag_table_type;
    523. 

  523. 

  524. #define TAG_TABLE_END \
    525. 

  525.   {TAG_NONE,           "No tag value"},\
    526. 

  526.   {TAG_COMPUTED_VALUE, "Computed value"},\
    527. 

  527.   {TAG_END_OF_LIST,    ""}  /* Important for exif_get_tagname() IF value != "" function result is != false */
    528. 

  528. 

  529. static tag_info_array tag_table_IFD = {
    530. 

  530.   { 0x000B, "ACDComment"},
    531. 

  531.   { 0x00FE, "NewSubFile"}, /* better name it 'ImageType' ? */
    532. 

  532.   { 0x00FF, "SubFile"},
    533. 

  533.   { 0x0100, "ImageWidth"},
    534. 

  534.   { 0x0101, "ImageLength"},
    535. 

  535.   { 0x0102, "BitsPerSample"},
    536. 

  536.   { 0x0103, "Compression"},
    537. 

  537.   { 0x0106, "PhotometricInterpretation"},
    538. 

  538.   { 0x010A, "FillOrder"},
    539. 

  539.   { 0x010D, "DocumentName"},
    540. 

  540.   { 0x010E, "ImageDescription"},
    541. 

  541.   { 0x010F, "Make"},
    542. 

  542.   { 0x0110, "Model"},
    543. 

  543.   { 0x0111, "StripOffsets"},
    544. 

  544.   { 0x0112, "Orientation"},
    545. 

  545.   { 0x0115, "SamplesPerPixel"},
    546. 

  546.   { 0x0116, "RowsPerStrip"},
    547. 

  547.   { 0x0117, "StripByteCounts"},
    548. 

  548.   { 0x0118, "MinSampleValue"},
    549. 

  549.   { 0x0119, "MaxSampleValue"},
    550. 

  550.   { 0x011A, "XResolution"},
    551. 

  551.   { 0x011B, "YResolution"},
    552. 

  552.   { 0x011C, "PlanarConfiguration"},
    553. 

  553.   { 0x011D, "PageName"},
    554. 

  554.   { 0x011E, "XPosition"},
    555. 

  555.   { 0x011F, "YPosition"},
    556. 

  556.   { 0x0120, "FreeOffsets"},
    557. 

  557.   { 0x0121, "FreeByteCounts"},
    558. 

  558.   { 0x0122, "GrayResponseUnit"},
    559. 

  559.   { 0x0123, "GrayResponseCurve"},
    560. 

  560.   { 0x0124, "T4Options"},
    561. 

  561.   { 0x0125, "T6Options"},
    562. 

  562.   { 0x0128, "ResolutionUnit"},
    563. 

  563.   { 0x0129, "PageNumber"},
    564. 

  564.   { 0x012D, "TransferFunction"},
    565. 

  565.   { 0x0131, "Software"},
    566. 

  566.   { 0x0132, "DateTime"},
    567. 

  567.   { 0x013B, "Artist"},
    568. 

  568.   { 0x013C, "HostComputer"},
    569. 

  569.   { 0x013D, "Predictor"},
    570. 

  570.   { 0x013E, "WhitePoint"},
    571. 

  571.   { 0x013F, "PrimaryChromaticities"},
    572. 

  572.   { 0x0140, "ColorMap"},
    573. 

  573.   { 0x0141, "HalfToneHints"},
    574. 

  574.   { 0x0142, "TileWidth"},
    575. 

  575.   { 0x0143, "TileLength"},
    576. 

  576.   { 0x0144, "TileOffsets"},
    577. 

  577.   { 0x0145, "TileByteCounts"},
    578. 

  578.   { 0x014A, "SubIFD"},
    579. 

  579.   { 0x014C, "InkSet"},
    580. 

  580.   { 0x014D, "InkNames"},
    581. 

  581.   { 0x014E, "NumberOfInks"},
    582. 

  582.   { 0x0150, "DotRange"},
    583. 

  583.   { 0x0151, "TargetPrinter"},
    584. 

  584.   { 0x0152, "ExtraSample"},
    585. 

  585.   { 0x0153, "SampleFormat"},
    586. 

  586.   { 0x0154, "SMinSampleValue"},
    587. 

  587.   { 0x0155, "SMaxSampleValue"},
    588. 

  588.   { 0x0156, "TransferRange"},
    589. 

  589.   { 0x0157, "ClipPath"},
    590. 

  590.   { 0x0158, "XClipPathUnits"},
    591. 

  591.   { 0x0159, "YClipPathUnits"},
    592. 

  592.   { 0x015A, "Indexed"},
    593. 

  593.   { 0x015B, "JPEGTables"},
    594. 

  594.   { 0x015F, "OPIProxy"},
    595. 

  595.   { 0x0200, "JPEGProc"},
    596. 

  596.   { 0x0201, "JPEGInterchangeFormat"},
    597. 

  597.   { 0x0202, "JPEGInterchangeFormatLength"},
    598. 

  598.   { 0x0203, "JPEGRestartInterval"},
    599. 

  599.   { 0x0205, "JPEGLosslessPredictors"},
    600. 

  600.   { 0x0206, "JPEGPointTransforms"},
    601. 

  601.   { 0x0207, "JPEGQTables"},
    602. 

  602.   { 0x0208, "JPEGDCTables"},
    603. 

  603.   { 0x0209, "JPEGACTables"},
    604. 

  604.   { 0x0211, "YCbCrCoefficients"},
    605. 

  605.   { 0x0212, "YCbCrSubSampling"},
    606. 

  606.   { 0x0213, "YCbCrPositioning"},
    607. 

  607.   { 0x0214, "ReferenceBlackWhite"},
    608. 

  608.   { 0x02BC, "ExtensibleMetadataPlatform"}, /* XAP: Extensible Authoring Publishing, obsoleted by XMP: Extensible Metadata Platform */
    609. 

  609.   { 0x0301, "Gamma"},
    610. 

  610.   { 0x0302, "ICCProfileDescriptor"},
    611. 

  611.   { 0x0303, "SRGBRenderingIntent"},
    612. 

  612.   { 0x0320, "ImageTitle"},
    613. 

  613.   { 0x5001, "ResolutionXUnit"},
    614. 

  614.   { 0x5002, "ResolutionYUnit"},
    615. 

  615.   { 0x5003, "ResolutionXLengthUnit"},
    616. 

  616.   { 0x5004, "ResolutionYLengthUnit"},
    617. 

  617.   { 0x5005, "PrintFlags"},
    618. 

  618.   { 0x5006, "PrintFlagsVersion"},
    619. 

  619.   { 0x5007, "PrintFlagsCrop"},
    620. 

  620.   { 0x5008, "PrintFlagsBleedWidth"},
    621. 

  621.   { 0x5009, "PrintFlagsBleedWidthScale"},
    622. 

  622.   { 0x500A, "HalftoneLPI"},
    623. 

  623.   { 0x500B, "HalftoneLPIUnit"},
    624. 

  624.   { 0x500C, "HalftoneDegree"},
    625. 

  625.   { 0x500D, "HalftoneShape"},
    626. 

  626.   { 0x500E, "HalftoneMisc"},
    627. 

  627.   { 0x500F, "HalftoneScreen"},
    628. 

  628.   { 0x5010, "JPEGQuality"},
    629. 

  629.   { 0x5011, "GridSize"},
    630. 

  630.   { 0x5012, "ThumbnailFormat"},
    631. 

  631.   { 0x5013, "ThumbnailWidth"},
    632. 

  632.   { 0x5014, "ThumbnailHeight"},
    633. 

  633.   { 0x5015, "ThumbnailColorDepth"},
    634. 

  634.   { 0x5016, "ThumbnailPlanes"},
    635. 

  635.   { 0x5017, "ThumbnailRawBytes"},
    636. 

  636.   { 0x5018, "ThumbnailSize"},
    637. 

  637.   { 0x5019, "ThumbnailCompressedSize"},
    638. 

  638.   { 0x501A, "ColorTransferFunction"},
    639. 

  639.   { 0x501B, "ThumbnailData"},
    640. 

  640.   { 0x5020, "ThumbnailImageWidth"},
    641. 

  641.   { 0x5021, "ThumbnailImageHeight"},
    642. 

  642.   { 0x5022, "ThumbnailBitsPerSample"},
    643. 

  643.   { 0x5023, "ThumbnailCompression"},
    644. 

  644.   { 0x5024, "ThumbnailPhotometricInterp"},
    645. 

  645.   { 0x5025, "ThumbnailImageDescription"},
    646. 

  646.   { 0x5026, "ThumbnailEquipMake"},
    647. 

  647.   { 0x5027, "ThumbnailEquipModel"},
    648. 

  648.   { 0x5028, "ThumbnailStripOffsets"},
    649. 

  649.   { 0x5029, "ThumbnailOrientation"},
    650. 

  650.   { 0x502A, "ThumbnailSamplesPerPixel"},
    651. 

  651.   { 0x502B, "ThumbnailRowsPerStrip"},
    652. 

  652.   { 0x502C, "ThumbnailStripBytesCount"},
    653. 

  653.   { 0x502D, "ThumbnailResolutionX"},
    654. 

  654.   { 0x502E, "ThumbnailResolutionY"},
    655. 

  655.   { 0x502F, "ThumbnailPlanarConfig"},
    656. 

  656.   { 0x5030, "ThumbnailResolutionUnit"},
    657. 

  657.   { 0x5031, "ThumbnailTransferFunction"},
    658. 

  658.   { 0x5032, "ThumbnailSoftwareUsed"},
    659. 

  659.   { 0x5033, "ThumbnailDateTime"},
    660. 

  660.   { 0x5034, "ThumbnailArtist"},
    661. 

  661.   { 0x5035, "ThumbnailWhitePoint"},
    662. 

  662.   { 0x5036, "ThumbnailPrimaryChromaticities"},
    663. 

  663.   { 0x5037, "ThumbnailYCbCrCoefficients"},
    664. 

  664.   { 0x5038, "ThumbnailYCbCrSubsampling"},
    665. 

  665.   { 0x5039, "ThumbnailYCbCrPositioning"},
    666. 

  666.   { 0x503A, "ThumbnailRefBlackWhite"},
    667. 

  667.   { 0x503B, "ThumbnailCopyRight"},
    668. 

  668.   { 0x5090, "LuminanceTable"},
    669. 

  669.   { 0x5091, "ChrominanceTable"},
    670. 

  670.   { 0x5100, "FrameDelay"},
    671. 

  671.   { 0x5101, "LoopCount"},
    672. 

  672.   { 0x5110, "PixelUnit"},
    673. 

  673.   { 0x5111, "PixelPerUnitX"},
    674. 

  674.   { 0x5112, "PixelPerUnitY"},
    675. 

  675.   { 0x5113, "PaletteHistogram"},
    676. 

  676.   { 0x1000, "RelatedImageFileFormat"},
    677. 

  677.   { 0x800D, "ImageID"},
    678. 

  678.   { 0x80E3, "Matteing"},   /* obsoleted by ExtraSamples */
    679. 

  679.   { 0x80E4, "DataType"},   /* obsoleted by SampleFormat */
    680. 

  680.   { 0x80E5, "ImageDepth"},
    681. 

  681.   { 0x80E6, "TileDepth"},
    682. 

  682.   { 0x828D, "CFARepeatPatternDim"},
    683. 

  683.   { 0x828E, "CFAPattern"},
    684. 

  684.   { 0x828F, "BatteryLevel"},
    685. 

  685.   { 0x8298, "Copyright"},
    686. 

  686.   { 0x829A, "ExposureTime"},
    687. 

  687.   { 0x829D, "FNumber"},
    688. 

  688.   { 0x83BB, "IPTC/NAA"},
    689. 

  689.   { 0x84E3, "IT8RasterPadding"},
    690. 

  690.   { 0x84E5, "IT8ColorTable"},
    691. 

  691.   { 0x8649, "ImageResourceInformation"}, /* PhotoShop */
    692. 

  692.   { 0x8769, "Exif_IFD_Pointer"},
    693. 

  693.   { 0x8773, "ICC_Profile"},
    694. 

  694.   { 0x8822, "ExposureProgram"},
    695. 

  695.   { 0x8824, "SpectralSensity"},
    696. 

  696.   { 0x8825, "GPS_IFD_Pointer"},
    697. 

  697.   { 0x8827, "ISOSpeedRatings"},
    698. 

  698.   { 0x8828, "OECF"},
    699. 

  699.   { 0x9000, "ExifVersion"},
    700. 

  700.   { 0x9003, "DateTimeOriginal"},
    701. 

  701.   { 0x9004, "DateTimeDigitized"},
    702. 

  702.   { 0x9101, "ComponentsConfiguration"},
    703. 

  703.   { 0x9102, "CompressedBitsPerPixel"},
    704. 

  704.   { 0x9201, "ShutterSpeedValue"},
    705. 

  705.   { 0x9202, "ApertureValue"},
    706. 

  706.   { 0x9203, "BrightnessValue"},
    707. 

  707.   { 0x9204, "ExposureBiasValue"},
    708. 

  708.   { 0x9205, "MaxApertureValue"},
    709. 

  709.   { 0x9206, "SubjectDistance"},
    710. 

  710.   { 0x9207, "MeteringMode"},
    711. 

  711.   { 0x9208, "LightSource"},
    712. 

  712.   { 0x9209, "Flash"},
    713. 

  713.   { 0x920A, "FocalLength"},
    714. 

  714.   { 0x920B, "FlashEnergy"},                 /* 0xA20B  in JPEG   */
    715. 

  715.   { 0x920C, "SpatialFrequencyResponse"},    /* 0xA20C    -  -    */
    716. 

  716.   { 0x920D, "Noise"},
    717. 

  717.   { 0x920E, "FocalPlaneXResolution"},       /* 0xA20E    -  -    */
    718. 

  718.   { 0x920F, "FocalPlaneYResolution"},       /* 0xA20F    -  -    */
    719. 

  719.   { 0x9210, "FocalPlaneResolutionUnit"},    /* 0xA210    -  -    */
    720. 

  720.   { 0x9211, "ImageNumber"},
    721. 

  721.   { 0x9212, "SecurityClassification"},
    722. 

  722.   { 0x9213, "ImageHistory"},
    723. 

  723.   { 0x9214, "SubjectLocation"},             /* 0xA214    -  -    */
    724. 

  724.   { 0x9215, "ExposureIndex"},               /* 0xA215    -  -    */
    725. 

  725.   { 0x9216, "TIFF/EPStandardID"},
    726. 

  726.   { 0x9217, "SensingMethod"},               /* 0xA217    -  -    */
    727. 

  727.   { 0x923F, "StoNits"},
    728. 

  728.   { 0x927C, "MakerNote"},
    729. 

  729.   { 0x9286, "UserComment"},
    730. 

  730.   { 0x9290, "SubSecTime"},
    731. 

  731.   { 0x9291, "SubSecTimeOriginal"},
    732. 

  732.   { 0x9292, "SubSecTimeDigitized"},
    733. 

  733.   { 0x935C, "ImageSourceData"},             /* "Adobe Photoshop Document Data Block": 8BIM... */
    734. 

  734.   { 0x9c9b, "Title" },                      /* Win XP specific, Unicode  */
    735. 

  735.   { 0x9c9c, "Comments" },                   /* Win XP specific, Unicode  */
    736. 

  736.   { 0x9c9d, "Author" },                     /* Win XP specific, Unicode  */
    737. 

  737.   { 0x9c9e, "Keywords" },                   /* Win XP specific, Unicode  */
    738. 

  738.   { 0x9c9f, "Subject" },                    /* Win XP specific, Unicode, not to be confused with SubjectDistance and SubjectLocation */
    739. 

  739.   { 0xA000, "FlashPixVersion"},
    740. 

  740.   { 0xA001, "ColorSpace"},
    741. 

  741.   { 0xA002, "ExifImageWidth"},
    742. 

  742.   { 0xA003, "ExifImageLength"},
    743. 

  743.   { 0xA004, "RelatedSoundFile"},
    744. 

  744.   { 0xA005, "InteroperabilityOffset"},
    745. 

  745.   { 0xA20B, "FlashEnergy"},                 /* 0x920B in TIFF/EP */
    746. 

  746.   { 0xA20C, "SpatialFrequencyResponse"},    /* 0x920C    -  -    */
    747. 

  747.   { 0xA20D, "Noise"},
    748. 

  748.   { 0xA20E, "FocalPlaneXResolution"},    	/* 0x920E    -  -    */
    749. 

  749.   { 0xA20F, "FocalPlaneYResolution"},       /* 0x920F    -  -    */
    750. 

  750.   { 0xA210, "FocalPlaneResolutionUnit"},    /* 0x9210    -  -    */
    751. 

  751.   { 0xA211, "ImageNumber"},
    752. 

  752.   { 0xA212, "SecurityClassification"},
    753. 

  753.   { 0xA213, "ImageHistory"},
    754. 

  754.   { 0xA214, "SubjectLocation"},             /* 0x9214    -  -    */
    755. 

  755.   { 0xA215, "ExposureIndex"},               /* 0x9215    -  -    */
    756. 

  756.   { 0xA216, "TIFF/EPStandardID"},
    757. 

  757.   { 0xA217, "SensingMethod"},               /* 0x9217    -  -    */
    758. 

  758.   { 0xA300, "FileSource"},
    759. 

  759.   { 0xA301, "SceneType"},
    760. 

  760.   { 0xA302, "CFAPattern"},
    761. 

  761.   { 0xA401, "CustomRendered"},
    762. 

  762.   { 0xA402, "ExposureMode"},
    763. 

  763.   { 0xA403, "WhiteBalance"},
    764. 

  764.   { 0xA404, "DigitalZoomRatio"},
    765. 

  765.   { 0xA405, "FocalLengthIn35mmFilm"},
    766. 

  766.   { 0xA406, "SceneCaptureType"},
    767. 

  767.   { 0xA407, "GainControl"},
    768. 

  768.   { 0xA408, "Contrast"},
    769. 

  769.   { 0xA409, "Saturation"},
    770. 

  770.   { 0xA40A, "Sharpness"},
    771. 

  771.   { 0xA40B, "DeviceSettingDescription"},
    772. 

  772.   { 0xA40C, "SubjectDistanceRange"},
    773. 

  773.   { 0xA420, "ImageUniqueID"},
    774. 

  774.   TAG_TABLE_END
    775. 

  775. } ;
    776. 

  776. 

  777. static tag_info_array tag_table_GPS = {
    778. 

  778.   { 0x0000, "GPSVersion"},
    779. 

  779.   { 0x0001, "GPSLatitudeRef"},
    780. 

  780.   { 0x0002, "GPSLatitude"},
    781. 

  781.   { 0x0003, "GPSLongitudeRef"},
    782. 

  782.   { 0x0004, "GPSLongitude"},
    783. 

  783.   { 0x0005, "GPSAltitudeRef"},
    784. 

  784.   { 0x0006, "GPSAltitude"},
    785. 

  785.   { 0x0007, "GPSTimeStamp"},
    786. 

  786.   { 0x0008, "GPSSatellites"},
    787. 

  787.   { 0x0009, "GPSStatus"},
    788. 

  788.   { 0x000A, "GPSMeasureMode"},
    789. 

  789.   { 0x000B, "GPSDOP"},
    790. 

  790.   { 0x000C, "GPSSpeedRef"},
    791. 

  791.   { 0x000D, "GPSSpeed"},
    792. 

  792.   { 0x000E, "GPSTrackRef"},
    793. 

  793.   { 0x000F, "GPSTrack"},
    794. 

  794.   { 0x0010, "GPSImgDirectionRef"},
    795. 

  795.   { 0x0011, "GPSImgDirection"},
    796. 

  796.   { 0x0012, "GPSMapDatum"},
    797. 

  797.   { 0x0013, "GPSDestLatitudeRef"},
    798. 

  798.   { 0x0014, "GPSDestLatitude"},
    799. 

  799.   { 0x0015, "GPSDestLongitudeRef"},
    800. 

  800.   { 0x0016, "GPSDestLongitude"},
    801. 

  801.   { 0x0017, "GPSDestBearingRef"},
    802. 

  802.   { 0x0018, "GPSDestBearing"},
    803. 

  803.   { 0x0019, "GPSDestDistanceRef"},
    804. 

  804.   { 0x001A, "GPSDestDistance"},
    805. 

  805.   { 0x001B, "GPSProcessingMode"},
    806. 

  806.   { 0x001C, "GPSAreaInformation"},
    807. 

  807.   { 0x001D, "GPSDateStamp"},
    808. 

  808.   { 0x001E, "GPSDifferential"},
    809. 

  809.   TAG_TABLE_END
    810. 

  810. };
    811. 

  811. 

  812. static tag_info_array tag_table_IOP = {
    813. 

  813.   { 0x0001, "InterOperabilityIndex"}, /* should be 'R98' or 'THM' */
    814. 

  814.   { 0x0002, "InterOperabilityVersion"},
    815. 

  815.   { 0x1000, "RelatedFileFormat"},
    816. 

  816.   { 0x1001, "RelatedImageWidth"},
    817. 

  817.   { 0x1002, "RelatedImageHeight"},
    818. 

  818.   TAG_TABLE_END
    819. 

  819. };
    820. 

  820. 

  821. static tag_info_array tag_table_VND_CANON = {
    822. 

  822.   { 0x0001, "ModeArray"}, /* guess */
    823. 

  823.   { 0x0004, "ImageInfo"}, /* guess */
    824. 

  824.   { 0x0006, "ImageType"},
    825. 

  825.   { 0x0007, "FirmwareVersion"},
    826. 

  826.   { 0x0008, "ImageNumber"},
    827. 

  827.   { 0x0009, "OwnerName"},
    828. 

  828.   { 0x000C, "Camera"},
    829. 

  829.   { 0x000F, "CustomFunctions"},
    830. 

  830.   TAG_TABLE_END
    831. 

  831. };
    832. 

  832. 

  833. static tag_info_array tag_table_VND_CASIO = {
    834. 

  834.   { 0x0001, "RecordingMode"},
    835. 

  835.   { 0x0002, "Quality"},
    836. 

  836.   { 0x0003, "FocusingMode"},
    837. 

  837.   { 0x0004, "FlashMode"},
    838. 

  838.   { 0x0005, "FlashIntensity"},
    839. 

  839.   { 0x0006, "ObjectDistance"},
    840. 

  840.   { 0x0007, "WhiteBalance"},
    841. 

  841.   { 0x000A, "DigitalZoom"},
    842. 

  842.   { 0x000B, "Sharpness"},
    843. 

  843.   { 0x000C, "Contrast"},
    844. 

  844.   { 0x000D, "Saturation"},
    845. 

  845.   { 0x0014, "CCDSensitivity"},
    846. 

  846.   TAG_TABLE_END
    847. 

  847. };
    848. 

  848. 

  849. static tag_info_array tag_table_VND_FUJI = {
    850. 

  850.   { 0x0000, "Version"},
    851. 

  851.   { 0x1000, "Quality"},
    852. 

  852.   { 0x1001, "Sharpness"},
    853. 

  853.   { 0x1002, "WhiteBalance"},
    854. 

  854.   { 0x1003, "Color"},
    855. 

  855.   { 0x1004, "Tone"},
    856. 

  856.   { 0x1010, "FlashMode"},
    857. 

  857.   { 0x1011, "FlashStrength"},
    858. 

  858.   { 0x1020, "Macro"},
    859. 

  859.   { 0x1021, "FocusMode"},
    860. 

  860.   { 0x1030, "SlowSync"},
    861. 

  861.   { 0x1031, "PictureMode"},
    862. 

  862.   { 0x1100, "ContTake"},
    863. 

  863.   { 0x1300, "BlurWarning"},
    864. 

  864.   { 0x1301, "FocusWarning"},
    865. 

  865.   { 0x1302, "AEWarning "},
    866. 

  866.   TAG_TABLE_END
    867. 

  867. };
    868. 

  868. 

  869. static tag_info_array tag_table_VND_NIKON = {
    870. 

  870.   { 0x0003, "Quality"},
    871. 

  871.   { 0x0004, "ColorMode"},
    872. 

  872.   { 0x0005, "ImageAdjustment"},
    873. 

  873.   { 0x0006, "CCDSensitivity"},
    874. 

  874.   { 0x0007, "WhiteBalance"},
    875. 

  875.   { 0x0008, "Focus"},
    876. 

  876.   { 0x000a, "DigitalZoom"},
    877. 

  877.   { 0x000b, "Converter"},
    878. 

  878.   TAG_TABLE_END
    879. 

  879. };
    880. 

  880. 

  881. static tag_info_array tag_table_VND_NIKON_990 = {
    882. 

  882.   { 0x0001, "Version"},
    883. 

  883.   { 0x0002, "ISOSetting"},
    884. 

  884.   { 0x0003, "ColorMode"},
    885. 

  885.   { 0x0004, "Quality"},
    886. 

  886.   { 0x0005, "WhiteBalance"},
    887. 

  887.   { 0x0006, "ImageSharpening"},
    888. 

  888.   { 0x0007, "FocusMode"},
    889. 

  889.   { 0x0008, "FlashSetting"},
    890. 

  890.   { 0x000F, "ISOSelection"},
    891. 

  891.   { 0x0080, "ImageAdjustment"},
    892. 

  892.   { 0x0082, "AuxiliaryLens"},
    893. 

  893.   { 0x0085, "ManualFocusDistance"},
    894. 

  894.   { 0x0086, "DigitalZoom"},
    895. 

  895.   { 0x0088, "AFFocusPosition"},
    896. 

  896.   { 0x0010, "DataDump"},
    897. 

  897.   TAG_TABLE_END
    898. 

  898. };
    899. 

  899. 

  900. static tag_info_array tag_table_VND_OLYMPUS = {
    901. 

  901.   { 0x0200, "SpecialMode"},
    902. 

  902.   { 0x0201, "JPEGQuality"},
    903. 

  903.   { 0x0202, "Macro"},
    904. 

  904.   { 0x0204, "DigitalZoom"},
    905. 

  905.   { 0x0207, "SoftwareRelease"},
    906. 

  906.   { 0x0208, "PictureInfo"},
    907. 

  907.   { 0x0209, "CameraId"},
    908. 

  908.   { 0x0F00, "DataDump"},
    909. 

  909.   TAG_TABLE_END
    910. 

  910. };
    911. 

  911. 

  912. static tag_info_array tag_table_VND_SAMSUNG = {
    913. 

  913.   { 0x0001, "Version"},
    914. 

  914.   { 0x0021, "PictureWizard"},
    915. 

  915.   { 0x0030, "LocalLocationName"},
    916. 

  916.   { 0x0031, "LocationName"},
    917. 

  917.   { 0x0035, "Preview"},
    918. 

  918.   { 0x0043, "CameraTemperature"},
    919. 

  919.   { 0xa001, "FirmwareName"},
    920. 

  920.   { 0xa003, "LensType"},
    921. 

  921.   { 0xa004, "LensFirmware"},
    922. 

  922.   { 0xa010, "SensorAreas"},
    923. 

  923.   { 0xa011, "ColorSpace"},
    924. 

  924.   { 0xa012, "SmartRange"},
    925. 

  925.   { 0xa013, "ExposureBiasValue"},
    926. 

  926.   { 0xa014, "ISO"},
    927. 

  927.   { 0xa018, "ExposureTime"},
    928. 

  928.   { 0xa019, "FNumber"},
    929. 

  929.   { 0xa01a, "FocalLengthIn35mmFormat"},
    930. 

  930.   { 0xa020, "EncryptionKey"},
    931. 

  931.   { 0xa021, "WB_RGGBLevelsUncorrected"},
    932. 

  932.   { 0xa022, "WB_RGGBLevelsAuto"},
    933. 

  933.   { 0xa023, "WB_RGGBLevelsIlluminator1"},
    934. 

  934.   { 0xa024, "WB_RGGBLevelsIlluminator2"},
    935. 

  935.   { 0xa028, "WB_RGGBLevelsBlack"},
    936. 

  936.   { 0xa030, "ColorMatrix"},
    937. 

  937.   { 0xa031, "ColorMatrixSRGB"},
    938. 

  938.   { 0xa032, "ColorMatrixAdobeRGB"},
    939. 

  939.   { 0xa040, "ToneCurve1"},
    940. 

  940.   { 0xa041, "ToneCurve2"},
    941. 

  941.   { 0xa042, "ToneCurve3"},
    942. 

  942.   { 0xa043, "ToneCurve4"},
    943. 

  943.   TAG_TABLE_END
    944. 

  944. };
    945. 

  945. 

  946. static tag_info_array tag_table_VND_PANASONIC = {
    947. 

  947.   { 0x0001, "Quality"},
    948. 

  948.   { 0x0002, "FirmwareVersion"},
    949. 

  949.   { 0x0003, "WhiteBalance"},
    950. 

  950.   { 0x0007, "FocusMode"},
    951. 

  951.   { 0x000f, "AFMode"},
    952. 

  952.   { 0x001a, "ImageStabilization"},
    953. 

  953.   { 0x001c, "Macro"},
    954. 

  954.   { 0x001f, "ShootingMode"},
    955. 

  955.   { 0x0020, "Audio"},
    956. 

  956.   { 0x0021, "DataDump"},
    957. 

  957.   { 0x0023, "WhiteBalanceBias"},
    958. 

  958.   { 0x0024, "FlashBias"},
    959. 

  959.   { 0x0025, "InternalSerialNumber"},
    960. 

  960.   { 0x0026, "ExifVersion"},
    961. 

  961.   { 0x0028, "ColorEffect"},
    962. 

  962.   { 0x0029, "TimeSincePowerOn"},
    963. 

  963.   { 0x002a, "BurstMode"},
    964. 

  964.   { 0x002b, "SequenceNumber"},
    965. 

  965.   { 0x002c, "Contrast"},
    966. 

  966.   { 0x002d, "NoiseReduction"},
    967. 

  967.   { 0x002e, "SelfTimer"},
    968. 

  968.   { 0x0030, "Rotation"},
    969. 

  969.   { 0x0031, "AFAssistLamp"},
    970. 

  970.   { 0x0032, "ColorMode"},
    971. 

  971.   { 0x0033, "BabyAge1"},
    972. 

  972.   { 0x0034, "OpticalZoomMode"},
    973. 

  973.   { 0x0035, "ConversionLens"},
    974. 

  974.   { 0x0036, "TravelDay"},
    975. 

  975.   { 0x0039, "Contrast"},
    976. 

  976.   { 0x003a, "WorldTimeLocation"},
    977. 

  977.   { 0x003b, "TextStamp1"},
    978. 

  978.   { 0x003c, "ProgramISO"},
    979. 

  979.   { 0x003d, "AdvancedSceneType"},
    980. 

  980.   { 0x003e, "TextStamp2"},
    981. 

  981.   { 0x003f, "FacesDetected"},
    982. 

  982.   { 0x0040, "Saturation"},
    983. 

  983.   { 0x0041, "Sharpness"},
    984. 

  984.   { 0x0042, "FilmMode"},
    985. 

  985.   { 0x0044, "ColorTempKelvin"},
    986. 

  986.   { 0x0045, "BracketSettings"},
    987. 

  987.   { 0x0046, "WBAdjustAB"},
    988. 

  988.   { 0x0047, "WBAdjustGM"},
    989. 

  989.   { 0x0048, "FlashCurtain"},
    990. 

  990.   { 0x0049, "LongShutterNoiseReduction"},
    991. 

  991.   { 0x004b, "ImageWidth"},
    992. 

  992.   { 0x004c, "ImageHeight"},
    993. 

  993.   { 0x004d, "AFPointPosition"},
    994. 

  994.   { 0x004e, "FaceDetInfo"},
    995. 

  995.   { 0x0051, "LensType"},
    996. 

  996.   { 0x0052, "LensSerialNumber"},
    997. 

  997.   { 0x0053, "AccessoryType"},
    998. 

  998.   { 0x0054, "AccessorySerialNumber"},
    999. 

  999.   { 0x0059, "Transform1"},
    1000. 

  1000.   { 0x005d, "IntelligentExposure"},
    1001. 

  1001.   { 0x0060, "LensFirmwareVersion"},
    1002. 

  1002.   { 0x0061, "FaceRecInfo"},
    1003. 

  1003.   { 0x0062, "FlashWarning"},
    1004. 

  1004.   { 0x0065, "Title"},
    1005. 

  1005.   { 0x0066, "BabyName"},
    1006. 

  1006.   { 0x0067, "Location"},
    1007. 

  1007.   { 0x0069, "Country"},
    1008. 

  1008.   { 0x006b, "State"},
    1009. 

  1009.   { 0x006d, "City"},
    1010. 

  1010.   { 0x006f, "Landmark"},
    1011. 

  1011.   { 0x0070, "IntelligentResolution"},
    1012. 

  1012.   { 0x0077, "BurstSheed"},
    1013. 

  1013.   { 0x0079, "IntelligentDRange"},
    1014. 

  1014.   { 0x007c, "ClearRetouch"},
    1015. 

  1015.   { 0x0080, "City2"},
    1016. 

  1016.   { 0x0086, "ManometerPressure"},
    1017. 

  1017.   { 0x0089, "PhotoStyle"},
    1018. 

  1018.   { 0x008a, "ShadingCompensation"},
    1019. 

  1019.   { 0x008c, "AccelerometerZ"},
    1020. 

  1020.   { 0x008d, "AccelerometerX"},
    1021. 

  1021.   { 0x008e, "AccelerometerY"},
    1022. 

  1022.   { 0x008f, "CameraOrientation"},
    1023. 

  1023.   { 0x0090, "RollAngle"},
    1024. 

  1024.   { 0x0091, "PitchAngle"},
    1025. 

  1025.   { 0x0093, "SweepPanoramaDirection"},
    1026. 

  1026.   { 0x0094, "PanoramaFieldOfView"},
    1027. 

  1027.   { 0x0096, "TimerRecording"},
    1028. 

  1028.   { 0x009d, "InternalNDFilter"},
    1029. 

  1029.   { 0x009e, "HDR"},
    1030. 

  1030.   { 0x009f, "ShutterType"},
    1031. 

  1031.   { 0x00a3, "ClearRetouchValue"},
    1032. 

  1032.   { 0x00ab, "TouchAE"},
    1033. 

  1033.   { 0x0e00, "PrintIM"},
    1034. 

  1034.   { 0x8000, "MakerNoteVersion"},
    1035. 

  1035.   { 0x8001, "SceneMode"},
    1036. 

  1036.   { 0x8004, "WBRedLevel"},
    1037. 

  1037.   { 0x8005, "WBGreenLevel"},
    1038. 

  1038.   { 0x8006, "WBBlueLevel"},
    1039. 

  1039.   { 0x8007, "FlashFired"},
    1040. 

  1040.   { 0x8008, "TextStamp3"},
    1041. 

  1041.   { 0x8009, "TextStamp4"},
    1042. 

  1042.   { 0x8010, "BabyAge2"},
    1043. 

  1043.   { 0x8012, "Transform2"},
    1044. 

  1044.   TAG_TABLE_END
    1045. 

  1045. };
    1046. 

  1046. 

  1047. static tag_info_array tag_table_VND_DJI = {
    1048. 

  1048.   { 0x0001, "Make"},
    1049. 

  1049.   { 0x0003, "SpeedX"},
    1050. 

  1050.   { 0x0004, "SpeedY"},
    1051. 

  1051.   { 0x0005, "SpeedZ"},
    1052. 

  1052.   { 0x0006, "Pitch"},
    1053. 

  1053.   { 0x0007, "Yaw"},
    1054. 

  1054.   { 0x0008, "Roll"},
    1055. 

  1055.   { 0x0009, "CameraPitch"},
    1056. 

  1056.   { 0x000a, "CameraYaw"},
    1057. 

  1057.   { 0x000b, "CameraRoll"},
    1058. 

  1058.   TAG_TABLE_END
    1059. 

  1059. };
    1060. 

  1060. 

  1061. static tag_info_array tag_table_VND_SONY = {
    1062. 

  1062.   { 0x0102, "Quality"},
    1063. 

  1063.   { 0x0104, "FlashExposureComp"},
    1064. 

  1064.   { 0x0105, "Teleconverter"},
    1065. 

  1065.   { 0x0112, "WhiteBalanceFineTune"},
    1066. 

  1066.   { 0x0114, "CameraSettings"},
    1067. 

  1067.   { 0x0115, "WhiteBalance"},
    1068. 

  1068.   { 0x0116, "ExtraInfo"},
    1069. 

  1069.   { 0x0e00, "PrintIM"},
    1070. 

  1070.   { 0x1000, "MultiBurstMode"},
    1071. 

  1071.   { 0x1001, "MultiBurstImageWidth"},
    1072. 

  1072.   { 0x1002, "MultiBurstImageHeight"},
    1073. 

  1073.   { 0x1003, "Panorama"},
    1074. 

  1074.   { 0x2001, "PreviewImage"},
    1075. 

  1075.   { 0x2002, "Rating"},
    1076. 

  1076.   { 0x2004, "Contrast"},
    1077. 

  1077.   { 0x2005, "Saturation"},
    1078. 

  1078.   { 0x2006, "Sharpness"},
    1079. 

  1079.   { 0x2007, "Brightness"},
    1080. 

  1080.   { 0x2008, "LongExposureNoiseReduction"},
    1081. 

  1081.   { 0x2009, "HighISONoiseReduction"},
    1082. 

  1082.   { 0x200a, "AutoHDR"},
    1083. 

  1083.   { 0x3000, "ShotInfo"},
    1084. 

  1084.   { 0xb000, "FileFormat"},
    1085. 

  1085.   { 0xb001, "SonyModelID"},
    1086. 

  1086.   { 0xb020, "ColorReproduction"},
    1087. 

  1087.   { 0xb021, "ColorTemperature"},
    1088. 

  1088.   { 0xb022, "ColorCompensationFilter"},
    1089. 

  1089.   { 0xb023, "SceneMode"},
    1090. 

  1090.   { 0xb024, "ZoneMatching"},
    1091. 

  1091.   { 0xb025, "DynamicRangeOptimizer"},
    1092. 

  1092.   { 0xb026, "ImageStabilization"},
    1093. 

  1093.   { 0xb027, "LensID"},
    1094. 

  1094.   { 0xb028, "MinoltaMakerNote"},
    1095. 

  1095.   { 0xb029, "ColorMode"},
    1096. 

  1096.   { 0xb02b, "FullImageSize"},
    1097. 

  1097.   { 0xb02c, "PreviewImageSize"},
    1098. 

  1098.   { 0xb040, "Macro"},
    1099. 

  1099.   { 0xb041, "ExposureMode"},
    1100. 

  1100.   { 0xb042, "FocusMode"},
    1101. 

  1101.   { 0xb043, "AFMode"},
    1102. 

  1102.   { 0xb044, "AFIlluminator"},
    1103. 

  1103.   { 0xb047, "JPEGQuality"},
    1104. 

  1104.   { 0xb048, "FlashLevel"},
    1105. 

  1105.   { 0xb049, "ReleaseMode"},
    1106. 

  1106.   { 0xb04a, "SequenceNumber"},
    1107. 

  1107.   { 0xb04b, "AntiBlur"},
    1108. 

  1108.   { 0xb04e, "FocusMode"},
    1109. 

  1109.   { 0xb04f, "DynamicRangeOptimizer"},
    1110. 

  1110.   { 0xb050, "HighISONoiseReduction2"},
    1111. 

  1111.   { 0xb052, "IntelligentAuto"},
    1112. 

  1112.   { 0xb054, "WhiteBalance2"},
    1113. 

  1113.   TAG_TABLE_END
    1114. 

  1114. };
    1115. 

  1115. 

  1116. static tag_info_array tag_table_VND_PENTAX = {
    1117. 

  1117.   { 0x0000, "Version"},
    1118. 

  1118.   { 0x0001, "Mode"},
    1119. 

  1119.   { 0x0002, "PreviewResolution"},
    1120. 

  1120.   { 0x0003, "PreviewLength"},
    1121. 

  1121.   { 0x0004, "PreviewOffset"},
    1122. 

  1122.   { 0x0005, "ModelID"},
    1123. 

  1123.   { 0x0006, "Date"},
    1124. 

  1124.   { 0x0007, "Time"},
    1125. 

  1125.   { 0x0008, "Quality"},
    1126. 

  1126.   { 0x0009, "Size"},
    1127. 

  1127.   { 0x000c, "Flash"},
    1128. 

  1128.   { 0x000d, "Focus"},
    1129. 

  1129.   { 0x000e, "AFPoint"},
    1130. 

  1130.   { 0x000f, "AFPointInFocus"},
    1131. 

  1131.   { 0x0012, "ExposureTime"},
    1132. 

  1132.   { 0x0013, "FNumber"},
    1133. 

  1133.   { 0x0014, "ISO"},
    1134. 

  1134.   { 0x0016, "ExposureCompensation"},
    1135. 

  1135.   { 0x0017, "MeteringMode"},
    1136. 

  1136.   { 0x0018, "AutoBracketing"},
    1137. 

  1137.   { 0x0019, "WhiteBalance"},
    1138. 

  1138.   { 0x001a, "WhiteBalanceMode"},
    1139. 

  1139.   { 0x001b, "BlueBalance"},
    1140. 

  1140.   { 0x001c, "RedBalance"},
    1141. 

  1141.   { 0x001d, "FocalLength"},
    1142. 

  1142.   { 0x001e, "DigitalZoom"},
    1143. 

  1143.   { 0x001f, "Saturation"},
    1144. 

  1144.   { 0x0020, "Contrast"},
    1145. 

  1145.   { 0x0021, "Sharpness"},
    1146. 

  1146.   { 0x0022, "Location"},
    1147. 

  1147.   { 0x0023, "Hometown"},
    1148. 

  1148.   { 0x0024, "Destination"},
    1149. 

  1149.   { 0x0025, "HometownDST"},
    1150. 

  1150.   { 0x0026, "DestinationDST"},
    1151. 

  1151.   { 0x0027, "DSPFirmwareVersion"},
    1152. 

  1152.   { 0x0028, "CPUFirmwareVersion"},
    1153. 

  1153.   { 0x0029, "FrameNumber"},
    1154. 

  1154.   { 0x002d, "EffectiveLV"},
    1155. 

  1155.   { 0x0032, "ImageProcessing"},
    1156. 

  1156.   { 0x0033, "PictureMode"},
    1157. 

  1157.   { 0x0034, "DriveMode"},
    1158. 

  1158.   { 0x0037, "ColorSpace"},
    1159. 

  1159.   { 0x0038, "ImageAreaOffset"},
    1160. 

  1160.   { 0x0039, "RawImageSize"},
    1161. 

  1161.   { 0x003e, "PreviewImageBorders"},
    1162. 

  1162.   { 0x003f, "LensType"},
    1163. 

  1163.   { 0x0040, "SensitivityAdjust"},
    1164. 

  1164.   { 0x0041, "DigitalFilter"},
    1165. 

  1165.   { 0x0047, "Temperature"},
    1166. 

  1166.   { 0x0048, "AELock"},
    1167. 

  1167.   { 0x0049, "NoiseReduction"},
    1168. 

  1168.   { 0x004d, "FlashExposureCompensation"},
    1169. 

  1169.   { 0x004f, "ImageTone"},
    1170. 

  1170.   { 0x0050, "ColorTemperature"},
    1171. 

  1171.   { 0x005c, "ShakeReduction"},
    1172. 

  1172.   { 0x005d, "ShutterCount"},
    1173. 

  1173.   { 0x0069, "DynamicRangeExpansion"},
    1174. 

  1174.   { 0x0071, "HighISONoiseReduction"},
    1175. 

  1175.   { 0x0072, "AFAdjustment"},
    1176. 

  1176.   { 0x0200, "BlackPoint"},
    1177. 

  1177.   { 0x0201, "WhitePoint"},
    1178. 

  1178.   { 0x0205, "ShotInfo"},
    1179. 

  1179.   { 0x0206, "AEInfo"},
    1180. 

  1180.   { 0x0207, "LensInfo"},
    1181. 

  1181.   { 0x0208, "FlashInfo"},
    1182. 

  1182.   { 0x0209, "AEMeteringSegments"},
    1183. 

  1183.   { 0x020a, "FlashADump"},
    1184. 

  1184.   { 0x020b, "FlashBDump"},
    1185. 

  1185.   { 0x020d, "WB_RGGBLevelsDaylight"},
    1186. 

  1186.   { 0x020e, "WB_RGGBLevelsShade"},
    1187. 

  1187.   { 0x020f, "WB_RGGBLevelsCloudy"},
    1188. 

  1188.   { 0x0210, "WB_RGGBLevelsTungsten"},
    1189. 

  1189.   { 0x0211, "WB_RGGBLevelsFluorescentD"},
    1190. 

  1190.   { 0x0212, "WB_RGGBLevelsFluorescentN"},
    1191. 

  1191.   { 0x0213, "WB_RGGBLevelsFluorescentW"},
    1192. 

  1192.   { 0x0214, "WB_RGGBLevelsFlash"},
    1193. 

  1193.   { 0x0215, "CameraInfo"},
    1194. 

  1194.   { 0x0216, "BatteryInfo"},
    1195. 

  1195.   { 0x021f, "AFInfo"},
    1196. 

  1196.   { 0x0222, "ColorInfo"},
    1197. 

  1197.   { 0x0229, "SerialNumber"},
    1198. 

  1198.   TAG_TABLE_END
    1199. 

  1199. };
    1200. 

  1200. 

  1201. static tag_info_array tag_table_VND_MINOLTA = {
    1202. 

  1202.   { 0x0000, "Version"},
    1203. 

  1203.   { 0x0001, "CameraSettingsStdOld"},
    1204. 

  1204.   { 0x0003, "CameraSettingsStdNew"},
    1205. 

  1205.   { 0x0004, "CameraSettings7D"},
    1206. 

  1206.   { 0x0018, "ImageStabilizationData"},
    1207. 

  1207.   { 0x0020, "WBInfoA100"},
    1208. 

  1208.   { 0x0040, "CompressedImageSize"},
    1209. 

  1209.   { 0x0081, "Thumbnail"},
    1210. 

  1210.   { 0x0088, "ThumbnailOffset"},
    1211. 

  1211.   { 0x0089, "ThumbnailLength"},
    1212. 

  1212.   { 0x0100, "SceneMode"},
    1213. 

  1213.   { 0x0101, "ColorMode"},
    1214. 

  1214.   { 0x0102, "Quality"},
    1215. 

  1215.   { 0x0104, "FlashExposureComp"},
    1216. 

  1216.   { 0x0105, "Teleconverter"},
    1217. 

  1217.   { 0x0107, "ImageStabilization"},
    1218. 

  1218.   { 0x0109, "RawAndJpgRecording"},
    1219. 

  1219.   { 0x010a, "ZoneMatching"},
    1220. 

  1220.   { 0x010b, "ColorTemperature"},
    1221. 

  1221.   { 0x010c, "LensID"},
    1222. 

  1222.   { 0x0111, "ColorCompensationFilter"},
    1223. 

  1223.   { 0x0112, "WhiteBalanceFineTune"},
    1224. 

  1224.   { 0x0113, "ImageStabilizationA100"},
    1225. 

  1225.   { 0x0114, "CameraSettings5D"},
    1226. 

  1226.   { 0x0115, "WhiteBalance"},
    1227. 

  1227.   { 0x0e00, "PrintIM"},
    1228. 

  1228.   { 0x0f00, "CameraSettingsZ1"},
    1229. 

  1229.   TAG_TABLE_END
    1230. 

  1230. };
    1231. 

  1231. 

  1232. static tag_info_array tag_table_VND_SIGMA = {
    1233. 

  1233.   { 0x0002, "SerialNumber"},
    1234. 

  1234.   { 0x0003, "DriveMode"},
    1235. 

  1235.   { 0x0004, "ResolutionMode"},
    1236. 

  1236.   { 0x0005, "AutofocusMode"},
    1237. 

  1237.   { 0x0006, "FocusSetting"},
    1238. 

  1238.   { 0x0007, "WhiteBalance"},
    1239. 

  1239.   { 0x0008, "ExposureMode"},
    1240. 

  1240.   { 0x0009, "MeteringMode"},
    1241. 

  1241.   { 0x000a, "LensRange"},
    1242. 

  1242.   { 0x000b, "ColorSpace"},
    1243. 

  1243.   { 0x000c, "Exposure"},
    1244. 

  1244.   { 0x000d, "Contrast"},
    1245. 

  1245.   { 0x000e, "Shadow"},
    1246. 

  1246.   { 0x000f, "Highlight"},
    1247. 

  1247.   { 0x0010, "Saturation"},
    1248. 

  1248.   { 0x0011, "Sharpness"},
    1249. 

  1249.   { 0x0012, "FillLight"},
    1250. 

  1250.   { 0x0014, "ColorAdjustment"},
    1251. 

  1251.   { 0x0015, "AdjustmentMode"},
    1252. 

  1252.   { 0x0016, "Quality"},
    1253. 

  1253.   { 0x0017, "Firmware"},
    1254. 

  1254.   { 0x0018, "Software"},
    1255. 

  1255.   { 0x0019, "AutoBracket"},
    1256. 

  1256.   TAG_TABLE_END
    1257. 

  1257. };
    1258. 

  1258. 

  1259. static tag_info_array tag_table_VND_KYOCERA = {
    1260. 

  1260.   { 0x0001, "FormatThumbnail"},
    1261. 

  1261.   { 0x0E00, "PrintImageMatchingInfo"},
    1262. 

  1262.   TAG_TABLE_END
    1263. 

  1263. };
    1264. 

  1264. 

  1265. static tag_info_array tag_table_VND_RICOH = {
    1266. 

  1266.   { 0x0001, "MakerNoteDataType"},
    1267. 

  1267.   { 0x0002, "Version"},
    1268. 

  1268.   { 0x0E00, "PrintImageMatchingInfo"},
    1269. 

  1269.   { 0x2001, "RicohCameraInfoMakerNoteSubIFD"},
    1270. 

  1270.   TAG_TABLE_END
    1271. 

  1271. };
    1272. 

  1272. 

  1273. typedef enum mn_byte_order_t {
    1274. 

  1274. 	MN_ORDER_INTEL    = 0,
    1275. 

  1275. 	MN_ORDER_MOTOROLA = 1,
    1276. 

  1276. 	MN_ORDER_NORMAL
    1277. 

  1277. } mn_byte_order_t;
    1278. 

  1278. 

  1279. typedef enum mn_offset_mode_t {
    1280. 

  1280. 	MN_OFFSET_NORMAL,
    1281. 

  1281. 	MN_OFFSET_MAKER
    1282. 

  1282. } mn_offset_mode_t;
    1283. 

  1283. 

  1284. typedef struct {
    1285. 

  1285. 	tag_table_type   tag_table;
    1286. 

  1286. 	char *           make;
    1287. 

  1287. 	char *           id_string;
    1288. 

  1288. 	int              id_string_len;
    1289. 

  1289. 	int              offset;
    1290. 

  1290. 	mn_byte_order_t  byte_order;
    1291. 

  1291. 	mn_offset_mode_t offset_mode;
    1292. 

  1292. } maker_note_type;
    1293. 

  1293. 

  1294. /* Remember to update PHP_MINFO if updated */
    1295. 

  1295. static const maker_note_type maker_note_array[] = {
    1296. 

  1296.   { tag_table_VND_CANON,     "Canon",                   NULL,								0,  0,  MN_ORDER_INTEL,    MN_OFFSET_NORMAL},
    1297. 

  1297.   { tag_table_VND_CASIO,     "CASIO",                   NULL,							 	0,  0,  MN_ORDER_MOTOROLA, MN_OFFSET_NORMAL},
    1298. 

  1298.   { tag_table_VND_FUJI,      "FUJIFILM",                "FUJIFILM\x0C\x00\x00\x00",		 	12, 12, MN_ORDER_INTEL,    MN_OFFSET_MAKER},
    1299. 

  1299.   { tag_table_VND_NIKON,     "NIKON",                   "Nikon\x00\x01\x00",				8,  8,  MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1300. 

  1300.   { tag_table_VND_NIKON_990, "NIKON",                   NULL,								0,  0,  MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1301. 

  1301.   { tag_table_VND_OLYMPUS,   "OLYMPUS OPTICAL CO.,LTD", "OLYMP\x00\x01\x00",				8,  8,  MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1302. 

  1302.   { tag_table_VND_SAMSUNG,   "SAMSUNG",                 NULL,								0,  0,  MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1303. 

  1303.   { tag_table_VND_PANASONIC, "Panasonic",               "Panasonic\x00\x00\x00",			12, 12, MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1304. 

  1304.   { tag_table_VND_DJI,       "DJI",                     NULL,								0,  0,  MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1305. 

  1305.   { tag_table_VND_SONY,      "SONY",                    "SONY DSC \x00\x00\x00",			12, 12, MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1306. 

  1306.   { tag_table_VND_SONY,      "SONY",                    NULL,								0,  0,  MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1307. 

  1307.   { tag_table_VND_PENTAX,    "PENTAX",                  "AOC\x00",						 	6,  6,  MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1308. 

  1308.   { tag_table_VND_MINOLTA,   "Minolta, KONICA MINOLTA", NULL,								0,  0,  MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1309. 

  1309.   { tag_table_VND_SIGMA,     "SIGMA, FOVEON",           "SIGMA\x00\x00\x00",				10, 10, MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1310. 

  1310.   { tag_table_VND_SIGMA,     "SIGMA, FOVEON",           "FOVEON\x00\x00\x00",				10, 10, MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1311. 

  1311.   { tag_table_VND_KYOCERA,   "KYOCERA, CONTAX",			"KYOCERA            \x00\x00\x00",	22, 22, MN_ORDER_NORMAL,   MN_OFFSET_MAKER},
    1312. 

  1312.   { tag_table_VND_RICOH,	 "RICOH",					"Ricoh",							5,  5,  MN_ORDER_MOTOROLA, MN_OFFSET_NORMAL},
    1313. 

  1313.   { tag_table_VND_RICOH,     "RICOH",					"RICOH",							5,  5,  MN_ORDER_MOTOROLA, MN_OFFSET_NORMAL},
    1314. 

  1314. 

  1315.   /* These re-uses existing formats */
    1316. 

  1316.   { tag_table_VND_OLYMPUS,   "AGFA",					"AGFA \x00\x01",					8,  8,  MN_ORDER_NORMAL,   MN_OFFSET_NORMAL},
    1317. 

  1317.   { tag_table_VND_OLYMPUS,   "EPSON",					"EPSON\x00\x01\x00",				8,  8,  MN_ORDER_NORMAL,   MN_OFFSET_NORMAL}
    1318. 

  1318. };
    1319. 

  1319. /* }}} */
    1320. 

  1320. 

  1321. static HashTable *exif_make_tag_ht(tag_info_type *tag_table)
    1322. 

  1322. {
    1323. 

  1323. 	HashTable *ht = malloc(sizeof(HashTable));
    1324. 

  1324. 	zend_hash_init(ht, 0, NULL, NULL, 1);
    1325. 

  1325. 	while (tag_table->Tag != TAG_END_OF_LIST) {
    1326. 

  1326. 		if (!zend_hash_index_add_ptr(ht, tag_table->Tag, tag_table->Desc)) {
    1327. 

  1327. 			zend_error(E_CORE_ERROR, "Duplicate tag %x", tag_table->Tag);
    1328. 

  1328. 		}
    1329. 

  1329. 		tag_table++;
    1330. 

  1330. 	}
    1331. 

  1331. 	return ht;
    1332. 

  1332. }
    1333. 

  1333. 

  1334. static void exif_tag_ht_dtor(zval *zv)
    1335. 

  1335. {
    1336. 

  1336. 	HashTable *ht = Z_PTR_P(zv);
    1337. 

  1337. 	zend_hash_destroy(ht);
    1338. 

  1338. 	free(ht);
    1339. 

  1339. }
    1340. 

  1340. 

  1341. static HashTable *exif_get_tag_ht(tag_info_type *tag_table)
    1342. 

  1342. {
    1343. 

  1343. 	HashTable *ht;
    1344. 

  1344. 

  1345. 	if (!EXIF_G(tag_table_cache)) {
    1346. 

  1346. 		EXIF_G(tag_table_cache) = malloc(sizeof(HashTable));
    1347. 

  1347. 		zend_hash_init(EXIF_G(tag_table_cache), 0, NULL, exif_tag_ht_dtor, 1);
    1348. 

  1348. 	}
    1349. 

  1349. 

  1350. 	ht = zend_hash_index_find_ptr(EXIF_G(tag_table_cache), (uintptr_t) tag_table);
    1351. 

  1351. 	if (ht) {
    1352. 

  1352. 		return ht;
    1353. 

  1353. 	}
    1354. 

  1354. 

  1355. 	ht = exif_make_tag_ht(tag_table);
    1356. 

  1356. 	zend_hash_index_add_new_ptr(EXIF_G(tag_table_cache), (uintptr_t) tag_table, ht);
    1357. 

  1357. 	return ht;
    1358. 

  1358. }
    1359. 

  1359. 

  1360. /* {{{ exif_get_tagname
    1361. 

  1361. 	Get headername for tag_num or NULL if not defined */
    1362. 

  1362. static char *exif_get_tagname(int tag_num, tag_table_type tag_table)
    1363. 

  1363. {
    1364. 

  1364. 	return zend_hash_index_find_ptr(exif_get_tag_ht(tag_table), tag_num);
    1365. 

  1365. }
    1366. 

  1366. /* }}} */
    1367. 

  1367. 

  1368. static char *exif_get_tagname_debug(int tag_num, tag_table_type tag_table)
    1369. 

  1369. {
    1370. 

  1370. 	char *desc = zend_hash_index_find_ptr(exif_get_tag_ht(tag_table), tag_num);
    1371. 

  1371. 	if (desc) {
    1372. 

  1372. 		return desc;
    1373. 

  1373. 	}
    1374. 

  1374. 	return "UndefinedTag";
    1375. 

  1375. }
    1376. 

  1376. 

  1377. static char *exif_get_tagname_key(int tag_num, char *buf, size_t buf_size, tag_table_type tag_table)
    1378. 

  1378. {
    1379. 

  1379. 	char *desc = zend_hash_index_find_ptr(exif_get_tag_ht(tag_table), tag_num);
    1380. 

  1380. 	if (desc) {
    1381. 

  1381. 		return desc;
    1382. 

  1382. 	}
    1383. 

  1383. 	snprintf(buf, buf_size, "UndefinedTag:0x%04X", tag_num);
    1384. 

  1384. 	return buf;
    1385. 

  1385. }
    1386. 

  1386. 

  1387. /* {{{ exif_char_dump
    1388. 

  1388.  * Do not use! This is a debug function... */
    1389. 

  1389. #ifdef EXIF_DEBUG
    1390. 

  1390. static unsigned char* exif_char_dump(unsigned char * addr, int len, int offset)
    1391. 

  1391. {
    1392. 

  1392. 	static unsigned char buf[4096+1];
    1393. 

  1393. 	static unsigned char tmp[20];
    1394. 

  1394. 	int c, i, p=0, n = 5+31;
    1395. 

  1395. 

  1396. 	p += slprintf(buf+p, sizeof(buf)-p, "\nDump Len: %08X (%d)", len, len);
    1397. 

  1397. 	if (len) {
    1398. 

  1398. 		for(i=0; i<len+15 && p+n<=sizeof(buf); i++) {
    1399. 

  1399. 			if (i%16==0) {
    1400. 

  1400. 				p += slprintf(buf+p, sizeof(buf)-p, "\n%08X: ", i+offset);
    1401. 

  1401. 			}
    1402. 

  1402. 			if (i<len) {
    1403. 

  1403. 				c = *addr++;
    1404. 

  1404. 				p += slprintf(buf+p, sizeof(buf)-p, "%02X ", c);
    1405. 

  1405. 				tmp[i%16] = c>=32 ? c : '.';
    1406. 

  1406. 				tmp[(i%16)+1] = '\0';
    1407. 

  1407. 			} else {
    1408. 

  1408. 				p += slprintf(buf+p, sizeof(buf)-p, "   ");
    1409. 

  1409. 			}
    1410. 

  1410. 			if (i%16==15) {
    1411. 

  1411. 				p += slprintf(buf+p, sizeof(buf)-p, "    %s", tmp);
    1412. 

  1412. 				if (i>=len) {
    1413. 

  1413. 					break;
    1414. 

  1414. 				}
    1415. 

  1415. 			}
    1416. 

  1416. 		}
    1417. 

  1417. 	}
    1418. 

  1418. 	buf[sizeof(buf)-1] = '\0';
    1419. 

  1419. 	return buf;
    1420. 

  1420. }
    1421. 

  1421. #endif
    1422. 

  1422. /* }}} */
    1423. 

  1423. 

  1424. /* {{{ php_jpg_get16
    1425. 

  1425.    Get 16 bits motorola order (always) for jpeg header stuff.
    1426. 

  1426. */
    1427. 

  1427. static int php_jpg_get16(void *value)
    1428. 

  1428. {
    1429. 

  1429. 	return (((uchar *)value)[0] << 8) | ((uchar *)value)[1];
    1430. 

  1430. }
    1431. 

  1431. /* }}} */
    1432. 

  1432. 

  1433. /* {{{ php_ifd_get16u
    1434. 

  1434.  * Convert a 16 bit unsigned value from file's native byte order */
    1435. 

  1435. static int php_ifd_get16u(void *value, int motorola_intel)
    1436. 

  1436. {
    1437. 

  1437. 	if (motorola_intel) {
    1438. 

  1438. 		return (((uchar *)value)[0] << 8) | ((uchar *)value)[1];
    1439. 

  1439. 	} else {
    1440. 

  1440. 		return (((uchar *)value)[1] << 8) | ((uchar *)value)[0];
    1441. 

  1441. 	}
    1442. 

  1442. }
    1443. 

  1443. /* }}} */
    1444. 

  1444. 

  1445. /* {{{ php_ifd_get16s
    1446. 

  1446.  * Convert a 16 bit signed value from file's native byte order */
    1447. 

  1447. static signed short php_ifd_get16s(void *value, int motorola_intel)
    1448. 

  1448. {
    1449. 

  1449. 	return (signed short)php_ifd_get16u(value, motorola_intel);
    1450. 

  1450. }
    1451. 

  1451. /* }}} */
    1452. 

  1452. 

  1453. /* {{{ php_ifd_get32u
    1454. 

  1454.  * Convert a 32 bit unsigned value from file's native byte order */
    1455. 

  1455. static unsigned php_ifd_get32u(void *void_value, int motorola_intel)
    1456. 

  1456. {
    1457. 

  1457. 	uchar *value = (uchar *) void_value;
    1458. 

  1458. 	if (motorola_intel) {
    1459. 

  1459. 		return  ((unsigned)value[0] << 24)
    1460. 

  1460. 			  | ((unsigned)value[1] << 16)
    1461. 

  1461. 			  | ((unsigned)value[2] << 8 )
    1462. 

  1462. 			  | ((unsigned)value[3]      );
    1463. 

  1463. 	} else {
    1464. 

  1464. 		return  ((unsigned)value[3] << 24)
    1465. 

  1465. 			  | ((unsigned)value[2] << 16)
    1466. 

  1466. 			  | ((unsigned)value[1] << 8 )
    1467. 

  1467. 			  | ((unsigned)value[0]      );
    1468. 

  1468. 	}
    1469. 

  1469. }
    1470. 

  1470. /* }}} */
    1471. 

  1471. 

  1472. /* {{{ php_ifd_get64u
    1473. 

  1473.  * Convert a 64 bit unsigned value from file's native byte order */
    1474. 

  1474. static uint64_t php_ifd_get64u(void *void_value, int motorola_intel)
    1475. 

  1475. {
    1476. 

  1476. 	uchar *value = (uchar *) void_value;
    1477. 

  1477. 	if (motorola_intel) {
    1478. 

  1478. 		return ((uint64_t)value[0] << 56)
    1479. 

  1479. 			| ((uint64_t)value[1] << 48)
    1480. 

  1480. 			| ((uint64_t)value[2] << 40)
    1481. 

  1481. 			| ((uint64_t)value[3] << 32)
    1482. 

  1482. 			| ((uint64_t)value[4] << 24)
    1483. 

  1483. 			| ((uint64_t)value[5] << 16)
    1484. 

  1484. 			| ((uint64_t)value[6] << 8 )
    1485. 

  1485. 			| ((uint64_t)value[7]      );
    1486. 

  1486. 	} else {
    1487. 

  1487. 		return ((uint64_t)value[7] << 56)
    1488. 

  1488. 			| ((uint64_t)value[6] << 48)
    1489. 

  1489. 			| ((uint64_t)value[5] << 40)
    1490. 

  1490. 			| ((uint64_t)value[4] << 32)
    1491. 

  1491. 			| ((uint64_t)value[3] << 24)
    1492. 

  1492. 			| ((uint64_t)value[2] << 16)
    1493. 

  1493. 			| ((uint64_t)value[1] << 8 )
    1494. 

  1494. 			| ((uint64_t)value[0]      );
    1495. 

  1495. 	}
    1496. 

  1496. }
    1497. 

  1497. /* }}} */
    1498. 

  1498. 

  1499. /* {{{ php_ifd_get32u
    1500. 

  1500.  * Convert a 32 bit signed value from file's native byte order */
    1501. 

  1501. static unsigned php_ifd_get32s(void *value, int motorola_intel)
    1502. 

  1502. {
    1503. 

  1503. 	return (int) php_ifd_get32u(value, motorola_intel);
    1504. 

  1504. }
    1505. 

  1505. /* }}} */
    1506. 

  1506. 

  1507. /* {{{ php_ifd_set16u
    1508. 

  1508.  * Write 16 bit unsigned value to data */
    1509. 

  1509. static void php_ifd_set16u(char *data, unsigned int value, int motorola_intel)
    1510. 

  1510. {
    1511. 

  1511. 	if (motorola_intel) {
    1512. 

  1512. 		data[0] = (value & 0xFF00) >> 8;
    1513. 

  1513. 		data[1] = (value & 0x00FF);
    1514. 

  1514. 	} else {
    1515. 

  1515. 		data[1] = (value & 0xFF00) >> 8;
    1516. 

  1516. 		data[0] = (value & 0x00FF);
    1517. 

  1517. 	}
    1518. 

  1518. }
    1519. 

  1519. /* }}} */
    1520. 

  1520. 

  1521. /* {{{ php_ifd_set32u
    1522. 

  1522.  * Convert a 32 bit unsigned value from file's native byte order */
    1523. 

  1523. static void php_ifd_set32u(char *data, size_t value, int motorola_intel)
    1524. 

  1524. {
    1525. 

  1525. 	if (motorola_intel) {
    1526. 

  1526. 		data[0] = (value & 0xFF000000) >> 24;
    1527. 

  1527. 		data[1] = (char) ((value & 0x00FF0000) >> 16);
    1528. 

  1528. 		data[2] = (value & 0x0000FF00) >>  8;
    1529. 

  1529. 		data[3] = (value & 0x000000FF);
    1530. 

  1530. 	} else {
    1531. 

  1531. 		data[3] = (value & 0xFF000000) >> 24;
    1532. 

  1532. 		data[2] = (char) ((value & 0x00FF0000) >> 16);
    1533. 

  1533. 		data[1] = (value & 0x0000FF00) >>  8;
    1534. 

  1534. 		data[0] = (value & 0x000000FF);
    1535. 

  1535. 	}
    1536. 

  1536. }
    1537. 

  1537. /* }}} */
    1538. 

  1538. 

  1539. static float php_ifd_get_float(char *data) {
    1540. 

  1540. 	union { uint32_t i; float f; } u;
    1541. 

  1541. 	u.i = php_ifd_get32u(data, 0);
    1542. 

  1542. 	return u.f;
    1543. 

  1543. }
    1544. 

  1544. 

  1545. static double php_ifd_get_double(char *data) {
    1546. 

  1546. 	union { uint64_t i; double f; } u;
    1547. 

  1547. 	u.i = php_ifd_get64u(data, 0);
    1548. 

  1548. 	return u.f;
    1549. 

  1549. }
    1550. 

  1550. 

  1551. #ifdef EXIF_DEBUG
    1552. 

  1552. char * exif_dump_data(int *dump_free, int format, int components, int length, int motorola_intel, char *value_ptr) /* {{{ */
    1553. 

  1553. {
    1554. 

  1554. 	char *dump;
    1555. 

  1555. 	int len;
    1556. 

  1556. 

  1557. 	*dump_free = 0;
    1558. 

  1558. 	if (format == TAG_FMT_STRING) {
    1559. 

  1559. 		return value_ptr ? value_ptr : "<no data>";
    1560. 

  1560. 	}
    1561. 

  1561. 	if (format == TAG_FMT_UNDEFINED) {
    1562. 

  1562. 		return "<undefined>";
    1563. 

  1563. 	}
    1564. 

  1564. 	if (format == TAG_FMT_IFD) {
    1565. 

  1565. 		return "";
    1566. 

  1566. 	}
    1567. 

  1567. 	if (format == TAG_FMT_SINGLE || format == TAG_FMT_DOUBLE) {
    1568. 

  1568. 		return "<not implemented>";
    1569. 

  1569. 	}
    1570. 

  1570. 	*dump_free = 1;
    1571. 

  1571. 	if (components > 1) {
    1572. 

  1572. 		len = spprintf(&dump, 0, "(%d,%d) {", components, length);
    1573. 

  1573. 	} else {
    1574. 

  1574. 		len = spprintf(&dump, 0, "{");
    1575. 

  1575. 	}
    1576. 

  1576. 	while(components > 0) {
    1577. 

  1577. 		switch(format) {
    1578. 

  1578. 			case TAG_FMT_BYTE:
    1579. 

  1579. 			case TAG_FMT_UNDEFINED:
    1580. 

  1580. 			case TAG_FMT_STRING:
    1581. 

  1581. 			case TAG_FMT_SBYTE:
    1582. 

  1582. 				dump = erealloc(dump, len + 4 + 1);
    1583. 

  1583. 				snprintf(dump + len, 4 + 1, "0x%02X", *value_ptr);
    1584. 

  1584. 				len += 4;
    1585. 

  1585. 				value_ptr++;
    1586. 

  1586. 				break;
    1587. 

  1587. 			case TAG_FMT_USHORT:
    1588. 

  1588. 			case TAG_FMT_SSHORT:
    1589. 

  1589. 				dump = erealloc(dump, len + 6 + 1);
    1590. 

  1590. 				snprintf(dump + len, 6 + 1, "0x%04X", php_ifd_get16s(value_ptr, motorola_intel));
    1591. 

  1591. 				len += 6;
    1592. 

  1592. 				value_ptr += 2;
    1593. 

  1593. 				break;
    1594. 

  1594. 			case TAG_FMT_ULONG:
    1595. 

  1595. 			case TAG_FMT_SLONG:
    1596. 

  1596. 				dump = erealloc(dump, len + 6 + 1);
    1597. 

  1597. 				snprintf(dump + len, 6 + 1, "0x%04X", php_ifd_get32s(value_ptr, motorola_intel));
    1598. 

  1598. 				len += 6;
    1599. 

  1599. 				value_ptr += 4;
    1600. 

  1600. 				break;
    1601. 

  1601. 			case TAG_FMT_URATIONAL:
    1602. 

  1602. 			case TAG_FMT_SRATIONAL:
    1603. 

  1603. 				dump = erealloc(dump, len + 13 + 1);
    1604. 

  1604. 				snprintf(dump + len, 13 + 1, "0x%04X/0x%04X", php_ifd_get32s(value_ptr, motorola_intel), php_ifd_get32s(value_ptr+4, motorola_intel));
    1605. 

  1605. 				len += 13;
    1606. 

  1606. 				value_ptr += 8;
    1607. 

  1607. 				break;
    1608. 

  1608. 		}
    1609. 

  1609. 		if (components > 0) {
    1610. 

  1610. 			dump = erealloc(dump, len + 2 + 1);
    1611. 

  1611. 			snprintf(dump + len, 2 + 1, ", ");
    1612. 

  1612. 			len += 2;
    1613. 

  1613. 			components--;
    1614. 

  1614. 		} else{
    1615. 

  1615. 			break;
    1616. 

  1616. 		}
    1617. 

  1617. 	}
    1618. 

  1618. 	dump = erealloc(dump, len + 1 + 1);
    1619. 

  1619. 	snprintf(dump + len, 1 + 1, "}");
    1620. 

  1620. 	return dump;
    1621. 

  1621. }
    1622. 

  1622. /* }}} */
    1623. 

  1623. #endif
    1624. 

  1624. 

  1625. /* {{{ exif_convert_any_format
    1626. 

  1626.  * Evaluate number, be it int, rational, or float from directory. */
    1627. 

  1627. static double exif_convert_any_format(void *value, int format, int motorola_intel)
    1628. 

  1628. {
    1629. 

  1629. 	int 		s_den;
    1630. 

  1630. 	unsigned 	u_den;
    1631. 

  1631. 

  1632. 	switch(format) {
    1633. 

  1633. 		case TAG_FMT_SBYTE:     return *(signed char *)value;
    1634. 

  1634. 		case TAG_FMT_BYTE:      return *(uchar *)value;
    1635. 

  1635. 

  1636. 		case TAG_FMT_USHORT:    return php_ifd_get16u(value, motorola_intel);
    1637. 

  1637. 		case TAG_FMT_ULONG:     return php_ifd_get32u(value, motorola_intel);
    1638. 

  1638. 

  1639. 		case TAG_FMT_URATIONAL:
    1640. 

  1640. 			u_den = php_ifd_get32u(4+(char *)value, motorola_intel);
    1641. 

  1641. 			if (u_den == 0) {
    1642. 

  1642. 				return 0;
    1643. 

  1643. 			} else {
    1644. 

  1644. 				return (double)php_ifd_get32u(value, motorola_intel) / u_den;
    1645. 

  1645. 			}
    1646. 

  1646. 

  1647. 		case TAG_FMT_SRATIONAL:
    1648. 

  1648. 			s_den = php_ifd_get32s(4+(char *)value, motorola_intel);
    1649. 

  1649. 			if (s_den == 0) {
    1650. 

  1650. 				return 0;
    1651. 

  1651. 			} else {
    1652. 

  1652. 				return (double)php_ifd_get32s(value, motorola_intel) / s_den;
    1653. 

  1653. 			}
    1654. 

  1654. 

  1655. 		case TAG_FMT_SSHORT:    return (signed short)php_ifd_get16u(value, motorola_intel);
    1656. 

  1656. 		case TAG_FMT_SLONG:     return php_ifd_get32s(value, motorola_intel);
    1657. 

  1657. 

  1658. 		/* Not sure if this is correct (never seen float used in Exif format) */
    1659. 

  1659. 		case TAG_FMT_SINGLE:
    1660. 

  1660. #ifdef EXIF_DEBUG
    1661. 

  1661. 			php_error_docref(NULL, E_NOTICE, "Found value of type single");
    1662. 

  1662. #endif
    1663. 

  1663. 			return (double) php_ifd_get_float(value);
    1664. 

  1664. 		case TAG_FMT_DOUBLE:
    1665. 

  1665. #ifdef EXIF_DEBUG
    1666. 

  1666. 			php_error_docref(NULL, E_NOTICE, "Found value of type double");
    1667. 

  1667. #endif
    1668. 

  1668. 			return php_ifd_get_double(value);
    1669. 

  1669. 	}
    1670. 

  1670. 	return 0;
    1671. 

  1671. }
    1672. 

  1672. /* }}} */
    1673. 

  1673. 

  1674. /* {{{ exif_rewrite_tag_format_to_unsigned
    1675. 

  1675.  * Rewrite format tag so that it specifies an unsigned type for a tag */
    1676. 

  1676. static int exif_rewrite_tag_format_to_unsigned(int format)
    1677. 

  1677. {
    1678. 

  1678. 	switch(format) {
    1679. 

  1679. 		case TAG_FMT_SBYTE: return TAG_FMT_BYTE;
    1680. 

  1680. 		case TAG_FMT_SRATIONAL: return TAG_FMT_URATIONAL;
    1681. 

  1681. 		case TAG_FMT_SSHORT: return TAG_FMT_USHORT;
    1682. 

  1682. 		case TAG_FMT_SLONG: return TAG_FMT_ULONG;
    1683. 

  1683. 	}
    1684. 

  1684. 	return format;
    1685. 

  1685. }
    1686. 

  1686. /* }}} */
    1687. 

  1687. 

  1688. /* Use saturation for out of bounds values to avoid UB */
    1689. 

  1689. static size_t float_to_size_t(float x) {
    1690. 

  1690. 	if (x < 0.0f || zend_isnan(x)) {
    1691. 

  1691. 		return 0;
    1692. 

  1692. 	} else if (x > (float) SIZE_MAX) {
    1693. 

  1693. 		return SIZE_MAX;
    1694. 

  1694. 	} else {
    1695. 

  1695. 		return (size_t) x;
    1696. 

  1696. 	}
    1697. 

  1697. }
    1698. 

  1698. 

  1699. static size_t double_to_size_t(double x) {
    1700. 

  1700. 	if (x < 0.0 || zend_isnan(x)) {
    1701. 

  1701. 		return 0;
    1702. 

  1702. 	} else if (x > (double) SIZE_MAX) {
    1703. 

  1703. 		return SIZE_MAX;
    1704. 

  1704. 	} else {
    1705. 

  1705. 		return (size_t) x;
    1706. 

  1706. 	}
    1707. 

  1707. }
    1708. 

  1708. 

  1709. /* {{{ exif_convert_any_to_int
    1710. 

  1710.  * Evaluate number, be it int, rational, or float from directory. */
    1711. 

  1711. static size_t exif_convert_any_to_int(void *value, int format, int motorola_intel)
    1712. 

  1712. {
    1713. 

  1713. 	int 		s_den;
    1714. 

  1714. 	unsigned 	u_den;
    1715. 

  1715. 

  1716. 	switch(format) {
    1717. 

  1717. 		case TAG_FMT_SBYTE:     return *(signed char *)value;
    1718. 

  1718. 		case TAG_FMT_BYTE:      return *(uchar *)value;
    1719. 

  1719. 

  1720. 		case TAG_FMT_USHORT:    return php_ifd_get16u(value, motorola_intel);
    1721. 

  1721. 		case TAG_FMT_ULONG:     return php_ifd_get32u(value, motorola_intel);
    1722. 

  1722. 

  1723. 		case TAG_FMT_URATIONAL:
    1724. 

  1724. 			u_den = php_ifd_get32u(4+(char *)value, motorola_intel);
    1725. 

  1725. 			if (u_den == 0) {
    1726. 

  1726. 				return 0;
    1727. 

  1727. 			} else {
    1728. 

  1728. 				return php_ifd_get32u(value, motorola_intel) / u_den;
    1729. 

  1729. 			}
    1730. 

  1730. 

  1731. 		case TAG_FMT_SRATIONAL:
    1732. 

  1732. 			s_den = php_ifd_get32s(4+(char *)value, motorola_intel);
    1733. 

  1733. 			if (s_den == 0) {
    1734. 

  1734. 				return 0;
    1735. 

  1735. 			} else {
    1736. 

  1736. 				return (size_t)((double)php_ifd_get32s(value, motorola_intel) / s_den);
    1737. 

  1737. 			}
    1738. 

  1738. 

  1739. 		case TAG_FMT_SSHORT:    return php_ifd_get16u(value, motorola_intel);
    1740. 

  1740. 		case TAG_FMT_SLONG:     return php_ifd_get32s(value, motorola_intel);
    1741. 

  1741. 

  1742. 		/* Not sure if this is correct (never seen float used in Exif format) */
    1743. 

  1743. 		case TAG_FMT_SINGLE:
    1744. 

  1744. #ifdef EXIF_DEBUG
    1745. 

  1745. 			php_error_docref(NULL, E_NOTICE, "Found value of type single");
    1746. 

  1746. #endif
    1747. 

  1747. 			return float_to_size_t(php_ifd_get_float(value));
    1748. 

  1748. 		case TAG_FMT_DOUBLE:
    1749. 

  1749. #ifdef EXIF_DEBUG
    1750. 

  1750. 			php_error_docref(NULL, E_NOTICE, "Found value of type double");
    1751. 

  1751. #endif
    1752. 

  1752. 			return double_to_size_t(php_ifd_get_double(value));
    1753. 

  1753. 	}
    1754. 

  1754. 	return 0;
    1755. 

  1755. }
    1756. 

  1756. /* }}} */
    1757. 

  1757. 

  1758. /* {{{ struct image_info_value, image_info_list
    1759. 

  1759. */
    1760. 

  1760. #ifndef WORD
    1761. 

  1761. #define WORD unsigned short
    1762. 

  1762. #endif
    1763. 

  1763. #ifndef DWORD
    1764. 

  1764. #define DWORD unsigned int
    1765. 

  1765. #endif
    1766. 

  1766. 

  1767. typedef struct {
    1768. 

  1768. 	int             num;
    1769. 

  1769. 	int             den;
    1770. 

  1770. } signed_rational;
    1771. 

  1771. 

  1772. typedef struct {
    1773. 

  1773. 	unsigned int    num;
    1774. 

  1774. 	unsigned int    den;
    1775. 

  1775. } unsigned_rational;
    1776. 

  1776. 

  1777. typedef union _image_info_value {
    1778. 

  1778. 	char 				*s;
    1779. 

  1779. 	unsigned            u;
    1780. 

  1780. 	int 				i;
    1781. 

  1781. 	float               f;
    1782. 

  1782. 	double              d;
    1783. 

  1783. 	signed_rational 	sr;
    1784. 

  1784. 	unsigned_rational 	ur;
    1785. 

  1785. 	union _image_info_value   *list;
    1786. 

  1786. } image_info_value;
    1787. 

  1787. 

  1788. typedef struct {
    1789. 

  1789. 	WORD                tag;
    1790. 

  1790. 	WORD                format;
    1791. 

  1791. 	DWORD               length;
    1792. 

  1792. 	DWORD               dummy;  /* value ptr of tiff directory entry */
    1793. 

  1793. 	char 				*name;
    1794. 

  1794. 	image_info_value    value;
    1795. 

  1795. } image_info_data;
    1796. 

  1796. 

  1797. typedef struct {
    1798. 

  1798. 	int                 count;
    1799. 

  1799. 	int                 alloc_count;
    1800. 

  1800. 	image_info_data 	*list;
    1801. 

  1801. } image_info_list;
    1802. 

  1802. /* }}} */
    1803. 

  1803. 

  1804. /* {{{ exif_get_sectionname
    1805. 

  1805.  Returns the name of a section
    1806. 

  1806. */
    1807. 

  1807. #define SECTION_FILE        0
    1808. 

  1808. #define SECTION_COMPUTED    1
    1809. 

  1809. #define SECTION_ANY_TAG     2
    1810. 

  1810. #define SECTION_IFD0        3
    1811. 

  1811. #define SECTION_THUMBNAIL   4
    1812. 

  1812. #define SECTION_COMMENT     5
    1813. 

  1813. #define SECTION_APP0        6
    1814. 

  1814. #define SECTION_EXIF        7
    1815. 

  1815. #define SECTION_FPIX        8
    1816. 

  1816. #define SECTION_GPS         9
    1817. 

  1817. #define SECTION_INTEROP     10
    1818. 

  1818. #define SECTION_APP12       11
    1819. 

  1819. #define SECTION_WINXP       12
    1820. 

  1820. #define SECTION_MAKERNOTE   13
    1821. 

  1821. #define SECTION_COUNT       14
    1822. 

  1822. 

  1823. #define FOUND_FILE          (1<<SECTION_FILE)
    1824. 

  1824. #define FOUND_COMPUTED      (1<<SECTION_COMPUTED)
    1825. 

  1825. #define FOUND_ANY_TAG       (1<<SECTION_ANY_TAG)
    1826. 

  1826. #define FOUND_IFD0          (1<<SECTION_IFD0)
    1827. 

  1827. #define FOUND_THUMBNAIL     (1<<SECTION_THUMBNAIL)
    1828. 

  1828. #define FOUND_COMMENT       (1<<SECTION_COMMENT)
    1829. 

  1829. #define FOUND_APP0          (1<<SECTION_APP0)
    1830. 

  1830. #define FOUND_EXIF          (1<<SECTION_EXIF)
    1831. 

  1831. #define FOUND_FPIX          (1<<SECTION_FPIX)
    1832. 

  1832. #define FOUND_GPS           (1<<SECTION_GPS)
    1833. 

  1833. #define FOUND_INTEROP       (1<<SECTION_INTEROP)
    1834. 

  1834. #define FOUND_APP12         (1<<SECTION_APP12)
    1835. 

  1835. #define FOUND_WINXP         (1<<SECTION_WINXP)
    1836. 

  1836. #define FOUND_MAKERNOTE     (1<<SECTION_MAKERNOTE)
    1837. 

  1837. 

  1838. static char *exif_get_sectionname(int section)
    1839. 

  1839. {
    1840. 

  1840. 	switch(section) {
    1841. 

  1841. 		case SECTION_FILE:      return "FILE";
    1842. 

  1842. 		case SECTION_COMPUTED:  return "COMPUTED";
    1843. 

  1843. 		case SECTION_ANY_TAG:   return "ANY_TAG";
    1844. 

  1844. 		case SECTION_IFD0:      return "IFD0";
    1845. 

  1845. 		case SECTION_THUMBNAIL: return "THUMBNAIL";
    1846. 

  1846. 		case SECTION_COMMENT:   return "COMMENT";
    1847. 

  1847. 		case SECTION_APP0:      return "APP0";
    1848. 

  1848. 		case SECTION_EXIF:      return "EXIF";
    1849. 

  1849. 		case SECTION_FPIX:      return "FPIX";
    1850. 

  1850. 		case SECTION_GPS:       return "GPS";
    1851. 

  1851. 		case SECTION_INTEROP:   return "INTEROP";
    1852. 

  1852. 		case SECTION_APP12:     return "APP12";
    1853. 

  1853. 		case SECTION_WINXP:     return "WINXP";
    1854. 

  1854. 		case SECTION_MAKERNOTE: return "MAKERNOTE";
    1855. 

  1855. 	}
    1856. 

  1856. 	return "";
    1857. 

  1857. }
    1858. 

  1858. 

  1859. static tag_table_type exif_get_tag_table(int section)
    1860. 

  1860. {
    1861. 

  1861. 	switch(section) {
    1862. 

  1862. 		case SECTION_FILE:      return &tag_table_IFD[0];
    1863. 

  1863. 		case SECTION_COMPUTED:  return &tag_table_IFD[0];
    1864. 

  1864. 		case SECTION_ANY_TAG:   return &tag_table_IFD[0];
    1865. 

  1865. 		case SECTION_IFD0:      return &tag_table_IFD[0];
    1866. 

  1866. 		case SECTION_THUMBNAIL: return &tag_table_IFD[0];
    1867. 

  1867. 		case SECTION_COMMENT:   return &tag_table_IFD[0];
    1868. 

  1868. 		case SECTION_APP0:      return &tag_table_IFD[0];
    1869. 

  1869. 		case SECTION_EXIF:      return &tag_table_IFD[0];
    1870. 

  1870. 		case SECTION_FPIX:      return &tag_table_IFD[0];
    1871. 

  1871. 		case SECTION_GPS:       return &tag_table_GPS[0];
    1872. 

  1872. 		case SECTION_INTEROP:   return &tag_table_IOP[0];
    1873. 

  1873. 		case SECTION_APP12:     return &tag_table_IFD[0];
    1874. 

  1874. 		case SECTION_WINXP:     return &tag_table_IFD[0];
    1875. 

  1875. 	}
    1876. 

  1876. 	return &tag_table_IFD[0];
    1877. 

  1877. }
    1878. 

  1878. /* }}} */
    1879. 

  1879. 

  1880. /* {{{ exif_get_sectionlist
    1881. 

  1881.    Return list of sectionnames specified by sectionlist. Return value must be freed
    1882. 

  1882. */
    1883. 

  1883. static char *exif_get_sectionlist(int sectionlist)
    1884. 

  1884. {
    1885. 

  1885. 	int i, len, ml = 0;
    1886. 

  1886. 	char *sections;
    1887. 

  1887. 

  1888. 	for(i=0; i<SECTION_COUNT; i++) {
    1889. 

  1889. 		ml += strlen(exif_get_sectionname(i))+2;
    1890. 

  1890. 	}
    1891. 

  1891. 	sections = safe_emalloc(ml, 1, 1);
    1892. 

  1892. 	sections[0] = '\0';
    1893. 

  1893. 	len = 0;
    1894. 

  1894. 	for(i=0; i<SECTION_COUNT; i++) {
    1895. 

  1895. 		if (sectionlist&(1<<i)) {
    1896. 

  1896. 			snprintf(sections+len, ml-len, "%s, ", exif_get_sectionname(i));
    1897. 

  1897. 			len = strlen(sections);
    1898. 

  1898. 		}
    1899. 

  1899. 	}
    1900. 

  1900. 	if (len>2)
    1901. 

  1901. 		sections[len-2] = '\0';
    1902. 

  1902. 	return sections;
    1903. 

  1903. }
    1904. 

  1904. /* }}} */
    1905. 

  1905. 

  1906. /* {{{ struct image_info_type
    1907. 

  1907.    This structure stores Exif header image elements in a simple manner
    1908. 

  1908.    Used to store camera data as extracted from the various ways that it can be
    1909. 

  1909.    stored in a nexif header
    1910. 

  1910. */
    1911. 

  1911. 

  1912. typedef struct {
    1913. 

  1913. 	int     type;
    1914. 

  1914. 	size_t  size;
    1915. 

  1915. 	uchar   *data;
    1916. 

  1916. } file_section;
    1917. 

  1917. 

  1918. typedef struct {
    1919. 

  1919. 	int             count;
    1920. 

  1920. 	int             alloc_count;
    1921. 

  1921. 	file_section    *list;
    1922. 

  1922. } file_section_list;
    1923. 

  1923. 

  1924. typedef struct {
    1925. 

  1925. 	image_filetype  filetype;
    1926. 

  1926. 	size_t          width, height;
    1927. 

  1927. 	size_t          size;
    1928. 

  1928. 	size_t          offset;
    1929. 

  1929. 	char 	        *data;
    1930. 

  1930. } thumbnail_data;
    1931. 

  1931. 

  1932. typedef struct {
    1933. 

  1933. 	char			*value;
    1934. 

  1934. 	size_t			size;
    1935. 

  1935. 	int				tag;
    1936. 

  1936. } xp_field_type;
    1937. 

  1937. 

  1938. typedef struct {
    1939. 

  1939. 	int             count;
    1940. 

  1940. 	xp_field_type   *list;
    1941. 

  1941. } xp_field_list;
    1942. 

  1942. 

  1943. /* This structure is used to store a section of a Jpeg file. */
    1944. 

  1944. typedef struct {
    1945. 

  1945. 	php_stream      *infile;
    1946. 

  1946. 	char            *FileName;
    1947. 

  1947. 	time_t          FileDateTime;
    1948. 

  1948. 	size_t          FileSize;
    1949. 

  1949. 	image_filetype  FileType;
    1950. 

  1950. 	int             Height, Width;
    1951. 

  1951. 	int             IsColor;
    1952. 

  1952. 

  1953. 	char            *make;
    1954. 

  1954. 	char            *model;
    1955. 

  1955. 

  1956. 	float           ApertureFNumber;
    1957. 

  1957. 	float           ExposureTime;
    1958. 

  1958. 	double          FocalplaneUnits;
    1959. 

  1959. 	float           CCDWidth;
    1960. 

  1960. 	double          FocalplaneXRes;
    1961. 

  1961. 	size_t          ExifImageWidth;
    1962. 

  1962. 	float           FocalLength;
    1963. 

  1963. 	float           Distance;
    1964. 

  1964. 

  1965. 	int             motorola_intel; /* 1 Motorola; 0 Intel */
    1966. 

  1966. 

  1967. 	char            *UserComment;
    1968. 

  1968. 	int             UserCommentLength;
    1969. 

  1969. 	char            *UserCommentEncoding;
    1970. 

  1970. 	char            *encode_unicode;
    1971. 

  1971. 	char            *decode_unicode_be;
    1972. 

  1972. 	char            *decode_unicode_le;
    1973. 

  1973. 	char            *encode_jis;
    1974. 

  1974. 	char            *decode_jis_be;
    1975. 

  1975. 	char            *decode_jis_le;
    1976. 

  1976. 	char            *Copyright;/* EXIF standard defines Copyright as "<Photographer> [ '\0' <Editor> ] ['\0']" */
    1977. 

  1977. 	char            *CopyrightPhotographer;
    1978. 

  1978. 	char            *CopyrightEditor;
    1979. 

  1979. 

  1980. 	xp_field_list   xp_fields;
    1981. 

  1981. 

  1982. 	thumbnail_data  Thumbnail;
    1983. 

  1983. 	/* other */
    1984. 

  1984. 	int             sections_found; /* FOUND_<marker> */
    1985. 

  1985. 	image_info_list info_list[SECTION_COUNT];
    1986. 

  1986. 	/* for parsing */
    1987. 

  1987. 	int             read_thumbnail;
    1988. 

  1988. 	int             read_all;
    1989. 

  1989. 	int             ifd_nesting_level;
    1990. 

  1990. 	int             num_errors;
    1991. 

  1991. 	/* internal */
    1992. 

  1992. 	file_section_list 	file;
    1993. 

  1993. } image_info_type;
    1994. 

  1994. /* }}} */
    1995. 

  1995. 

  1996. #define EXIF_MAX_ERRORS 10
    1997. 

  1997. 

  1998. /* {{{ exif_error_docref */
    1999. 

  1999. static void exif_error_docref(const char *docref EXIFERR_DC, image_info_type *ImageInfo, int type, const char *format, ...)
    2000. 

  2000. {
    2001. 

  2001. 	va_list args;
    2002. 

  2002. 

  2003. 	if (ImageInfo) {
    2004. 

  2004. 		if (++ImageInfo->num_errors > EXIF_MAX_ERRORS) {
    2005. 

  2005. 			if (ImageInfo->num_errors == EXIF_MAX_ERRORS+1) {
    2006. 

  2006. 				php_error_docref(docref, type,
    2007. 

  2007. 					"Further exif parsing errors have been suppressed");
    2008. 

  2008. 			}
    2009. 

  2009. 			return;
    2010. 

  2010. 		}
    2011. 

  2011. 	}
    2012. 

  2012. 

  2013. 	va_start(args, format);
    2014. 

  2014. #ifdef EXIF_DEBUG
    2015. 

  2015. 	{
    2016. 

  2016. 		char *buf;
    2017. 

  2017. 

  2018. 		spprintf(&buf, 0, "%s(%d): %s", _file, _line, format);
    2019. 

  2019. 		php_verror(docref, ImageInfo && ImageInfo->FileName ? ImageInfo->FileName:"", type, buf, args);
    2020. 

  2020. 		efree(buf);
    2021. 

  2021. 	}
    2022. 

  2022. #else
    2023. 

  2023. 	php_verror(docref, ImageInfo && ImageInfo->FileName ? ImageInfo->FileName:"", type, format, args);
    2024. 

  2024. #endif
    2025. 

  2025. 	va_end(args);
    2026. 

  2026. }
    2027. 

  2027. /* }}} */
    2028. 

  2028. 

  2029. /* {{{ jpeg_sof_info
    2030. 

  2030.  */
    2031. 

  2031. typedef struct {
    2032. 

  2032. 	int     bits_per_sample;
    2033. 

  2033. 	size_t  width;
    2034. 

  2034. 	size_t  height;
    2035. 

  2035. 	int     num_components;
    2036. 

  2036. } jpeg_sof_info;
    2037. 

  2037. /* }}} */
    2038. 

  2038. 

  2039. /* Base address for offset references, together with valid memory range.
    2040. 

  2040.  * The valid range does not necessarily include the offset base. */
    2041. 

  2041. typedef struct {
    2042. 

  2042. 	char *offset_base;
    2043. 

  2043. 	char *valid_start; /* inclusive */
    2044. 

  2044. 	char *valid_end;   /* exclusive */
    2045. 

  2045. } exif_offset_info;
    2046. 

  2046. 

  2047. static zend_always_inline zend_bool ptr_offset_overflows(char *ptr, size_t offset) {
    2048. 

  2048. 	return UINTPTR_MAX - (uintptr_t) ptr < offset;
    2049. 

  2049. }
    2050. 

  2050. 

  2051. static inline void exif_offset_info_init(
    2052. 

  2052. 		exif_offset_info *info, char *offset_base, char *valid_start, size_t valid_length) {
    2053. 

  2053. 	ZEND_ASSERT(!ptr_offset_overflows(valid_start, valid_length));
    2054. 

  2054. #ifdef __SANITIZE_ADDRESS__
    2055. 

  2055. 	ZEND_ASSERT(!__asan_region_is_poisoned(valid_start, valid_length));
    2056. 

  2056. #endif
    2057. 

  2057. 	info->offset_base = offset_base;
    2058. 

  2058. 	info->valid_start = valid_start;
    2059. 

  2059. 	info->valid_end = valid_start + valid_length;
    2060. 

  2060. }
    2061. 

  2061. 

  2062. /* Try to get a pointer at offset_base+offset with length dereferenceable bytes. */
    2063. 

  2063. static inline char *exif_offset_info_try_get(
    2064. 

  2064. 		const exif_offset_info *info, size_t offset, size_t length) {
    2065. 

  2065. 	char *start, *end;
    2066. 

  2066. 	if (ptr_offset_overflows(info->offset_base, offset)) {
    2067. 

  2067. 		return NULL;
    2068. 

  2068. 	}
    2069. 

  2069. 

  2070. 	start = info->offset_base + offset;
    2071. 

  2071. 	if (ptr_offset_overflows(start, length)) {
    2072. 

  2072. 		return NULL;
    2073. 

  2073. 	}
    2074. 

  2074. 

  2075. 	end = start + length;
    2076. 

  2076. 	if (start < info->valid_start || end > info->valid_end) {
    2077. 

  2077. 		return NULL;
    2078. 

  2078. 	}
    2079. 

  2079. 

  2080. 	return start;
    2081. 

  2081. }
    2082. 

  2082. 

  2083. static inline zend_bool exif_offset_info_contains(
    2084. 

  2084. 		const exif_offset_info *info, char *start, size_t length) {
    2085. 

  2085. 	char *end;
    2086. 

  2086. 	if (ptr_offset_overflows(start, length)) {
    2087. 

  2087. 		return 0;
    2088. 

  2088. 	}
    2089. 

  2089. 

  2090. 	/* start and valid_start are both inclusive, end and valid_end are both exclusive,
    2091. 

  2091. 	 * so we use >= and <= to do the checks, respectively. */
    2092. 

  2092. 	end = start + length;
    2093. 

  2093. 	return start >= info->valid_start && end <= info->valid_end;
    2094. 

  2094. }
    2095. 

  2095. 

  2096. /* {{{ exif_file_sections_add
    2097. 

  2097.  Add a file_section to image_info
    2098. 

  2098.  returns the used block or -1. if size>0 and data == NULL buffer of size is allocated
    2099. 

  2099. */
    2100. 

  2100. static int exif_file_sections_add(image_info_type *ImageInfo, int type, size_t size, uchar *data)
    2101. 

  2101. {
    2102. 

  2102. 	int count = ImageInfo->file.count;
    2103. 

  2103. 	if (count == ImageInfo->file.alloc_count) {
    2104. 

  2104. 		int new_alloc_count = ImageInfo->file.alloc_count ? ImageInfo->file.alloc_count * 2 : 1;
    2105. 

  2105. 		ImageInfo->file.list = safe_erealloc(
    2106. 

  2106. 			ImageInfo->file.list, new_alloc_count, sizeof(file_section), 0);
    2107. 

  2107. 		ImageInfo->file.alloc_count = new_alloc_count;
    2108. 

  2108. 	}
    2109. 

  2109. 

  2110. 	ImageInfo->file.list[count].type = 0xFFFF;
    2111. 

  2111. 	ImageInfo->file.list[count].data = NULL;
    2112. 

  2112. 	ImageInfo->file.list[count].size = 0;
    2113. 

  2113. 	ImageInfo->file.count = count+1;
    2114. 

  2114. 	if (!size) {
    2115. 

  2115. 		data = NULL;
    2116. 

  2116. 	} else if (data == NULL) {
    2117. 

  2117. 		data = safe_emalloc(size, 1, 0);
    2118. 

  2118. 	}
    2119. 

  2119. 	ImageInfo->file.list[count].type = type;
    2120. 

  2120. 	ImageInfo->file.list[count].data = data;
    2121. 

  2121. 	ImageInfo->file.list[count].size = size;
    2122. 

  2122. 	return count;
    2123. 

  2123. }
    2124. 

  2124. /* }}} */
    2125. 

  2125. 

  2126. /* {{{ exif_file_sections_realloc
    2127. 

  2127.  Reallocate a file section returns 0 on success and -1 on failure
    2128. 

  2128. */
    2129. 

  2129. static int exif_file_sections_realloc(image_info_type *ImageInfo, int section_index, size_t size)
    2130. 

  2130. {
    2131. 

  2131. 	void *tmp;
    2132. 

  2132. 

  2133. 	/* This is not a malloc/realloc check. It is a plausibility check for the
    2134. 

  2134. 	 * function parameters (requirements engineering).
    2135. 

  2135. 	 */
    2136. 

  2136. 	if (section_index >= ImageInfo->file.count) {
    2137. 

  2137. 		EXIF_ERRLOG_FSREALLOC(ImageInfo)
    2138. 

  2138. 		return -1;
    2139. 

  2139. 	}
    2140. 

  2140. 	tmp = safe_erealloc(ImageInfo->file.list[section_index].data, 1, size, 0);
    2141. 

  2141. 	ImageInfo->file.list[section_index].data = tmp;
    2142. 

  2142. 	ImageInfo->file.list[section_index].size = size;
    2143. 

  2143. 	return 0;
    2144. 

  2144. }
    2145. 

  2145. /* }}} */
    2146. 

  2146. 

  2147. /* {{{ exif_file_section_free
    2148. 

  2148.    Discard all file_sections in ImageInfo
    2149. 

  2149. */
    2150. 

  2150. static int exif_file_sections_free(image_info_type *ImageInfo)
    2151. 

  2151. {
    2152. 

  2152. 	int i;
    2153. 

  2153. 

  2154. 	if (ImageInfo->file.count) {
    2155. 

  2155. 		for (i=0; i<ImageInfo->file.count; i++) {
    2156. 

  2156. 			EFREE_IF(ImageInfo->file.list[i].data);
    2157. 

  2157. 		}
    2158. 

  2158. 	}
    2159. 

  2159. 	EFREE_IF(ImageInfo->file.list);
    2160. 

  2160. 	ImageInfo->file.count = 0;
    2161. 

  2161. 	return TRUE;
    2162. 

  2162. }
    2163. 

  2163. /* }}} */
    2164. 

  2164. 

  2165. static image_info_data *exif_alloc_image_info_data(image_info_list *info_list) {
    2166. 

  2166. 	if (info_list->count == info_list->alloc_count) {
    2167. 

  2167. 		int new_alloc_count = info_list->alloc_count ? info_list->alloc_count * 2 : 1;
    2168. 

  2168. 		info_list->list = safe_erealloc(
    2169. 

  2169. 			info_list->list, new_alloc_count, sizeof(image_info_data), 0);
    2170. 

  2170. 		info_list->alloc_count = new_alloc_count;
    2171. 

  2171. 	}
    2172. 

  2172. 	return &info_list->list[info_list->count++];
    2173. 

  2173. }
    2174. 

  2174. 

  2175. /* {{{ exif_iif_add_value
    2176. 

  2176.  Add a value to image_info
    2177. 

  2177. */
    2178. 

  2178. static void exif_iif_add_value(image_info_type *image_info, int section_index, char *name, int tag, int format, int length, void* value, size_t value_len, int motorola_intel)
    2179. 

  2179. {
    2180. 

  2180. 	size_t idex;
    2181. 

  2181. 	void *vptr, *vptr_end;
    2182. 

  2182. 	image_info_value *info_value;
    2183. 

  2183. 	image_info_data  *info_data;
    2184. 

  2184. 

  2185. 	if (length < 0) {
    2186. 

  2186. 		return;
    2187. 

  2187. 	}
    2188. 

  2188. 

  2189. 	info_data = exif_alloc_image_info_data(&image_info->info_list[section_index]);
    2190. 

  2190. 	memset(info_data, 0, sizeof(image_info_data));
    2191. 

  2191. 	info_data->tag    = tag;
    2192. 

  2192. 	info_data->format = format;
    2193. 

  2193. 	info_data->length = length;
    2194. 

  2194. 	info_data->name   = estrdup(name);
    2195. 

  2195. 	info_value        = &info_data->value;
    2196. 

  2196. 

  2197. 	switch (format) {
    2198. 

  2198. 		case TAG_FMT_STRING:
    2199. 

  2199. 			if (length > value_len) {
    2200. 

  2200. 				exif_error_docref("exif_iif_add_value" EXIFERR_CC, image_info, E_WARNING, "length > value_len: %d > %zu", length, value_len);
    2201. 

  2201. 				value = NULL;
    2202. 

  2202. 			}
    2203. 

  2203. 			if (value) {
    2204. 

  2204. 				length = (int)php_strnlen(value, length);
    2205. 

  2205. 				info_value->s = estrndup(value, length);
    2206. 

  2206. 				info_data->length = length;
    2207. 

  2207. 			} else {
    2208. 

  2208. 				info_data->length = 0;
    2209. 

  2209. 				info_value->s = estrdup("");
    2210. 

  2210. 			}
    2211. 

  2211. 			break;
    2212. 

  2212. 

  2213. 		default:
    2214. 

  2214. 			/* Standard says more types possible but skip them...
    2215. 

  2215. 			 * but allow users to handle data if they know how to
    2216. 

  2216. 			 * So not return but use type UNDEFINED
    2217. 

  2217. 			 * return;
    2218. 

  2218. 			 */
    2219. 

  2219. 			info_data->tag = TAG_FMT_UNDEFINED;/* otherwise not freed from memory */
    2220. 

  2220. 		case TAG_FMT_SBYTE:
    2221. 

  2221. 		case TAG_FMT_BYTE:
    2222. 

  2222. 		/* in contrast to strings bytes do not need to allocate buffer for NULL if length==0 */
    2223. 

  2223. 			if (!length)
    2224. 

  2224. 				break;
    2225. 

  2225. 		case TAG_FMT_UNDEFINED:
    2226. 

  2226. 			if (length > value_len) {
    2227. 

  2227. 				exif_error_docref("exif_iif_add_value" EXIFERR_CC, image_info, E_WARNING, "length > value_len: %d > %zu", length, value_len);
    2228. 

  2228. 				value = NULL;
    2229. 

  2229. 			}
    2230. 

  2230. 			if (value) {
    2231. 

  2231. 				if (tag == TAG_MAKER_NOTE) {
    2232. 

  2232. 					length = (int) php_strnlen(value, length);
    2233. 

  2233. 				}
    2234. 

  2234. 

  2235. 				/* do not recompute length here */
    2236. 

  2236. 				info_value->s = estrndup(value, length);
    2237. 

  2237. 				info_data->length = length;
    2238. 

  2238. 			} else {
    2239. 

  2239. 				info_data->length = 0;
    2240. 

  2240. 				info_value->s = estrdup("");
    2241. 

  2241. 			}
    2242. 

  2242. 			break;
    2243. 

  2243. 

  2244. 		case TAG_FMT_USHORT:
    2245. 

  2245. 		case TAG_FMT_ULONG:
    2246. 

  2246. 		case TAG_FMT_URATIONAL:
    2247. 

  2247. 		case TAG_FMT_SSHORT:
    2248. 

  2248. 		case TAG_FMT_SLONG:
    2249. 

  2249. 		case TAG_FMT_SRATIONAL:
    2250. 

  2250. 		case TAG_FMT_SINGLE:
    2251. 

  2251. 		case TAG_FMT_DOUBLE:
    2252. 

  2252. 			if (length==0) {
    2253. 

  2253. 				break;
    2254. 

  2254. 			} else
    2255. 

  2255. 			if (length>1) {
    2256. 

  2256. 				info_value->list = safe_emalloc(length, sizeof(image_info_value), 0);
    2257. 

  2257. 			} else {
    2258. 

  2258. 				info_value = &info_data->value;
    2259. 

  2259. 			}
    2260. 

  2260. 			vptr_end = (char *) value + value_len;
    2261. 

  2261. 			for (idex=0,vptr=value; idex<(size_t)length; idex++,vptr=(char *) vptr + php_tiff_bytes_per_format[format]) {
    2262. 

  2262. 				if ((char *) vptr_end - (char *) vptr < php_tiff_bytes_per_format[format]) {
    2263. 

  2263. 					exif_error_docref("exif_iif_add_value" EXIFERR_CC, image_info, E_WARNING, "Value too short");
    2264. 

  2264. 					break;
    2265. 

  2265. 				}
    2266. 

  2266. 				if (length>1) {
    2267. 

  2267. 					info_value = &info_data->value.list[idex];
    2268. 

  2268. 				}
    2269. 

  2269. 				switch (format) {
    2270. 

  2270. 					case TAG_FMT_USHORT:
    2271. 

  2271. 						info_value->u = php_ifd_get16u(vptr, motorola_intel);
    2272. 

  2272. 						break;
    2273. 

  2273. 

  2274. 					case TAG_FMT_ULONG:
    2275. 

  2275. 						info_value->u = php_ifd_get32u(vptr, motorola_intel);
    2276. 

  2276. 						break;
    2277. 

  2277. 

  2278. 					case TAG_FMT_URATIONAL:
    2279. 

  2279. 						info_value->ur.num = php_ifd_get32u(vptr, motorola_intel);
    2280. 

  2280. 						info_value->ur.den = php_ifd_get32u(4+(char *)vptr, motorola_intel);
    2281. 

  2281. 						break;
    2282. 

  2282. 

  2283. 					case TAG_FMT_SSHORT:
    2284. 

  2284. 						info_value->i = php_ifd_get16s(vptr, motorola_intel);
    2285. 

  2285. 						break;
    2286. 

  2286. 

  2287. 					case TAG_FMT_SLONG:
    2288. 

  2288. 						info_value->i = php_ifd_get32s(vptr, motorola_intel);
    2289. 

  2289. 						break;
    2290. 

  2290. 

  2291. 					case TAG_FMT_SRATIONAL:
    2292. 

  2292. 						info_value->sr.num = php_ifd_get32u(vptr, motorola_intel);
    2293. 

  2293. 						info_value->sr.den = php_ifd_get32u(4+(char *)vptr, motorola_intel);
    2294. 

  2294. 						break;
    2295. 

  2295. 

  2296. 					case TAG_FMT_SINGLE:
    2297. 

  2297. #ifdef EXIF_DEBUG
    2298. 

  2298. 						php_error_docref(NULL, E_WARNING, "Found value of type single");
    2299. 

  2299. #endif
    2300. 

  2300. 						info_value->f = php_ifd_get_float(value);
    2301. 

  2301. 						break;
    2302. 

  2302. 					case TAG_FMT_DOUBLE:
    2303. 

  2303. #ifdef EXIF_DEBUG
    2304. 

  2304. 						php_error_docref(NULL, E_WARNING, "Found value of type double");
    2305. 

  2305. #endif
    2306. 

  2306. 						info_value->d = php_ifd_get_double(value);
    2307. 

  2307. 						break;
    2308. 

  2308. 				}
    2309. 

  2309. 			}
    2310. 

  2310. 	}
    2311. 

  2311. 	image_info->sections_found |= 1<<section_index;
    2312. 

  2312. }
    2313. 

  2313. /* }}} */
    2314. 

  2314. 

  2315. /* {{{ exif_iif_add_tag
    2316. 

  2316.  Add a tag from IFD to image_info
    2317. 

  2317. */
    2318. 

  2318. static void exif_iif_add_tag(image_info_type *image_info, int section_index, char *name, int tag, int format, size_t length, void* value, size_t value_len)
    2319. 

  2319. {
    2320. 

  2320. 	exif_iif_add_value(image_info, section_index, name, tag, format, (int)length, value, value_len, image_info->motorola_intel);
    2321. 

  2321. }
    2322. 

  2322. /* }}} */
    2323. 

  2323. 

  2324. /* {{{ exif_iif_add_int
    2325. 

  2325.  Add an int value to image_info
    2326. 

  2326. */
    2327. 

  2327. static void exif_iif_add_int(image_info_type *image_info, int section_index, char *name, int value)
    2328. 

  2328. {
    2329. 

  2329. 	image_info_data *info_data = exif_alloc_image_info_data(&image_info->info_list[section_index]);
    2330. 

  2330. 	info_data->tag    = TAG_NONE;
    2331. 

  2331. 	info_data->format = TAG_FMT_SLONG;
    2332. 

  2332. 	info_data->length = 1;
    2333. 

  2333. 	info_data->name   = estrdup(name);
    2334. 

  2334. 	info_data->value.i = value;
    2335. 

  2335. 	image_info->sections_found |= 1<<section_index;
    2336. 

  2336. }
    2337. 

  2337. /* }}} */
    2338. 

  2338. 

  2339. /* {{{ exif_iif_add_str
    2340. 

  2340.  Add a string value to image_info MUST BE NUL TERMINATED
    2341. 

  2341. */
    2342. 

  2342. static void exif_iif_add_str(image_info_type *image_info, int section_index, char *name, char *value)
    2343. 

  2343. {
    2344. 

  2344. 	if (value) {
    2345. 

  2345. 		image_info_data *info_data =
    2346. 

  2346. 			exif_alloc_image_info_data(&image_info->info_list[section_index]);
    2347. 

  2347. 		info_data->tag    = TAG_NONE;
    2348. 

  2348. 		info_data->format = TAG_FMT_STRING;
    2349. 

  2349. 		info_data->length = 1;
    2350. 

  2350. 		info_data->name   = estrdup(name);
    2351. 

  2351. 		info_data->value.s = estrdup(value);
    2352. 

  2352. 		image_info->sections_found |= 1<<section_index;
    2353. 

  2353. 	}
    2354. 

  2354. }
    2355. 

  2355. /* }}} */
    2356. 

  2356. 

  2357. /* {{{ exif_iif_add_fmt
    2358. 

  2358.  Add a format string value to image_info MUST BE NUL TERMINATED
    2359. 

  2359. */
    2360. 

  2360. static void exif_iif_add_fmt(image_info_type *image_info, int section_index, char *name, char *value, ...)
    2361. 

  2361. {
    2362. 

  2362. 	char             *tmp;
    2363. 

  2363. 	va_list 		 arglist;
    2364. 

  2364. 

  2365. 	va_start(arglist, value);
    2366. 

  2366. 	if (value) {
    2367. 

  2367. 		vspprintf(&tmp, 0, value, arglist);
    2368. 

  2368. 		exif_iif_add_str(image_info, section_index, name, tmp);
    2369. 

  2369. 		efree(tmp);
    2370. 

  2370. 	}
    2371. 

  2371. 	va_end(arglist);
    2372. 

  2372. }
    2373. 

  2373. /* }}} */
    2374. 

  2374. 

  2375. /* {{{ exif_iif_add_str
    2376. 

  2376.  Add a string value to image_info MUST BE NUL TERMINATED
    2377. 

  2377. */
    2378. 

  2378. static void exif_iif_add_buffer(image_info_type *image_info, int section_index, char *name, int length, char *value)
    2379. 

  2379. {
    2380. 

  2380. 	if (value) {
    2381. 

  2381. 		image_info_data *info_data =
    2382. 

  2382. 			exif_alloc_image_info_data(&image_info->info_list[section_index]);
    2383. 

  2383. 		info_data->tag    = TAG_NONE;
    2384. 

  2384. 		info_data->format = TAG_FMT_UNDEFINED;
    2385. 

  2385. 		info_data->length = length;
    2386. 

  2386. 		info_data->name   = estrdup(name);
    2387. 

  2387. 		info_data->value.s = safe_emalloc(length, 1, 1);
    2388. 

  2388. 		memcpy(info_data->value.s, value, length);
    2389. 

  2389. 		info_data->value.s[length] = 0;
    2390. 

  2390. 		image_info->sections_found |= 1<<section_index;
    2391. 

  2391. 	}
    2392. 

  2392. }
    2393. 

  2393. /* }}} */
    2394. 

  2394. 

  2395. /* {{{ exif_iif_free
    2396. 

  2396.  Free memory allocated for image_info
    2397. 

  2397. */
    2398. 

  2398. static void exif_iif_free(image_info_type *image_info, int section_index) {
    2399. 

  2399. 	int  i;
    2400. 

  2400. 	void *f; /* faster */
    2401. 

  2401. 

  2402. 	if (image_info->info_list[section_index].count) {
    2403. 

  2403. 		for (i=0; i < image_info->info_list[section_index].count; i++) {
    2404. 

  2404. 			if ((f=image_info->info_list[section_index].list[i].name) != NULL) {
    2405. 

  2405. 				efree(f);
    2406. 

  2406. 			}
    2407. 

  2407. 			switch(image_info->info_list[section_index].list[i].format) {
    2408. 

  2408. 				case TAG_FMT_UNDEFINED:
    2409. 

  2409. 				case TAG_FMT_STRING:
    2410. 

  2410. 				case TAG_FMT_SBYTE:
    2411. 

  2411. 				case TAG_FMT_BYTE:
    2412. 

  2412. 				default:
    2413. 

  2413. 					if ((f=image_info->info_list[section_index].list[i].value.s) != NULL) {
    2414. 

  2414. 						efree(f);
    2415. 

  2415. 					}
    2416. 

  2416. 					break;
    2417. 

  2417. 

  2418. 				case TAG_FMT_USHORT:
    2419. 

  2419. 				case TAG_FMT_ULONG:
    2420. 

  2420. 				case TAG_FMT_URATIONAL:
    2421. 

  2421. 				case TAG_FMT_SSHORT:
    2422. 

  2422. 				case TAG_FMT_SLONG:
    2423. 

  2423. 				case TAG_FMT_SRATIONAL:
    2424. 

  2424. 				case TAG_FMT_SINGLE:
    2425. 

  2425. 				case TAG_FMT_DOUBLE:
    2426. 

  2426. 					/* nothing to do here */
    2427. 

  2427. 					if (image_info->info_list[section_index].list[i].length > 1) {
    2428. 

  2428. 						if ((f=image_info->info_list[section_index].list[i].value.list) != NULL) {
    2429. 

  2429. 							efree(f);
    2430. 

  2430. 						}
    2431. 

  2431. 					}
    2432. 

  2432. 					break;
    2433. 

  2433. 			}
    2434. 

  2434. 		}
    2435. 

  2435. 	}
    2436. 

  2436. 	EFREE_IF(image_info->info_list[section_index].list);
    2437. 

  2437. }
    2438. 

  2438. /* }}} */
    2439. 

  2439. 

  2440. /* {{{ add_assoc_image_info
    2441. 

  2441.  * Add image_info to associative array value. */
    2442. 

  2442. static void add_assoc_image_info(zval *value, int sub_array, image_info_type *image_info, int section_index)
    2443. 

  2443. {
    2444. 

  2444. 	char    buffer[64], *val, *name, uname[64];
    2445. 

  2445. 	int     i, ap, l, b, idx=0, unknown=0;
    2446. 

  2446. #ifdef EXIF_DEBUG
    2447. 

  2447. 	int     info_tag;
    2448. 

  2448. #endif
    2449. 

  2449. 	image_info_value *info_value;
    2450. 

  2450. 	image_info_data  *info_data;
    2451. 

  2451. 	zval 			 tmpi, array;
    2452. 

  2452. 

  2453. 	if (image_info->info_list[section_index].count) {
    2454. 

  2454. 		if (sub_array) {
    2455. 

  2455. 			array_init(&tmpi);
    2456. 

  2456. 		} else {
    2457. 

  2457. 			ZVAL_COPY_VALUE(&tmpi, value);
    2458. 

  2458. 		}
    2459. 

  2459. 

  2460. 		for(i=0; i<image_info->info_list[section_index].count; i++) {
    2461. 

  2461. 			info_data  = &image_info->info_list[section_index].list[i];
    2462. 

  2462. #ifdef EXIF_DEBUG
    2463. 

  2463. 			info_tag   = info_data->tag; /* conversion */
    2464. 

  2464. #endif
    2465. 

  2465. 			info_value = &info_data->value;
    2466. 

  2466. 			if (!(name = info_data->name)) {
    2467. 

  2467. 				snprintf(uname, sizeof(uname), "%d", unknown++);
    2468. 

  2468. 				name = uname;
    2469. 

  2469. 			}
    2470. 

  2470. 

  2471. 			if (info_data->length==0) {
    2472. 

  2472. 				add_assoc_null(&tmpi, name);
    2473. 

  2473. 			} else {
    2474. 

  2474. 				switch (info_data->format) {
    2475. 

  2475. 					default:
    2476. 

  2476. 						/* Standard says more types possible but skip them...
    2477. 

  2477. 						 * but allow users to handle data if they know how to
    2478. 

  2478. 						 * So not return but use type UNDEFINED
    2479. 

  2479. 						 * return;
    2480. 

  2480. 						 */
    2481. 

  2481. 					case TAG_FMT_BYTE:
    2482. 

  2482. 					case TAG_FMT_SBYTE:
    2483. 

  2483. 					case TAG_FMT_UNDEFINED:
    2484. 

  2484. 						if (!info_value->s) {
    2485. 

  2485. 							add_assoc_stringl(&tmpi, name, "", 0);
    2486. 

  2486. 						} else {
    2487. 

  2487. 							add_assoc_stringl(&tmpi, name, info_value->s, info_data->length);
    2488. 

  2488. 						}
    2489. 

  2489. 						break;
    2490. 

  2490. 

  2491. 					case TAG_FMT_STRING:
    2492. 

  2492. 						if (!(val = info_value->s)) {
    2493. 

  2493. 							val = "";
    2494. 

  2494. 						}
    2495. 

  2495. 						if (section_index==SECTION_COMMENT) {
    2496. 

  2496. 							add_index_string(&tmpi, idx++, val);
    2497. 

  2497. 						} else {
    2498. 

  2498. 							add_assoc_string(&tmpi, name, val);
    2499. 

  2499. 						}
    2500. 

  2500. 						break;
    2501. 

  2501. 

  2502. 					case TAG_FMT_URATIONAL:
    2503. 

  2503. 					case TAG_FMT_SRATIONAL:
    2504. 

  2504. 					case TAG_FMT_USHORT:
    2505. 

  2505. 					case TAG_FMT_SSHORT:
    2506. 

  2506. 					case TAG_FMT_SINGLE:
    2507. 

  2507. 					case TAG_FMT_DOUBLE:
    2508. 

  2508. 					case TAG_FMT_ULONG:
    2509. 

  2509. 					case TAG_FMT_SLONG:
    2510. 

  2510. 						/* now the rest, first see if it becomes an array */
    2511. 

  2511. 						if ((l = info_data->length) > 1) {
    2512. 

  2512. 							array_init(&array);
    2513. 

  2513. 						}
    2514. 

  2514. 						for(ap=0; ap<l; ap++) {
    2515. 

  2515. 							if (l>1) {
    2516. 

  2516. 								info_value = &info_data->value.list[ap];
    2517. 

  2517. 							}
    2518. 

  2518. 							switch (info_data->format) {
    2519. 

  2519. 								case TAG_FMT_BYTE:
    2520. 

  2520. 									if (l>1) {
    2521. 

  2521. 										info_value = &info_data->value;
    2522. 

  2522. 										for (b=0;b<l;b++) {
    2523. 

  2523. 											add_index_long(&array, b, (int)(info_value->s[b]));
    2524. 

  2524. 										}
    2525. 

  2525. 										break;
    2526. 

  2526. 									}
    2527. 

  2527. 								case TAG_FMT_USHORT:
    2528. 

  2528. 								case TAG_FMT_ULONG:
    2529. 

  2529. 									if (l==1) {
    2530. 

  2530. 										add_assoc_long(&tmpi, name, (int)info_value->u);
    2531. 

  2531. 									} else {
    2532. 

  2532. 										add_index_long(&array, ap, (int)info_value->u);
    2533. 

  2533. 									}
    2534. 

  2534. 									break;
    2535. 

  2535. 

  2536. 								case TAG_FMT_URATIONAL:
    2537. 

  2537. 									snprintf(buffer, sizeof(buffer), "%u/%u", info_value->ur.num, info_value->ur.den);
    2538. 

  2538. 									if (l==1) {
    2539. 

  2539. 										add_assoc_string(&tmpi, name, buffer);
    2540. 

  2540. 									} else {
    2541. 

  2541. 										add_index_string(&array, ap, buffer);
    2542. 

  2542. 									}
    2543. 

  2543. 									break;
    2544. 

  2544. 

  2545. 								case TAG_FMT_SBYTE:
    2546. 

  2546. 									if (l>1) {
    2547. 

  2547. 										info_value = &info_data->value;
    2548. 

  2548. 										for (b=0;b<l;b++) {
    2549. 

  2549. 											add_index_long(&array, ap, (int)info_value->s[b]);
    2550. 

  2550. 										}
    2551. 

  2551. 										break;
    2552. 

  2552. 									}
    2553. 

  2553. 								case TAG_FMT_SSHORT:
    2554. 

  2554. 								case TAG_FMT_SLONG:
    2555. 

  2555. 									if (l==1) {
    2556. 

  2556. 										add_assoc_long(&tmpi, name, info_value->i);
    2557. 

  2557. 									} else {
    2558. 

  2558. 										add_index_long(&array, ap, info_value->i);
    2559. 

  2559. 									}
    2560. 

  2560. 									break;
    2561. 

  2561. 

  2562. 								case TAG_FMT_SRATIONAL:
    2563. 

  2563. 									snprintf(buffer, sizeof(buffer), "%i/%i", info_value->sr.num, info_value->sr.den);
    2564. 

  2564. 									if (l==1) {
    2565. 

  2565. 										add_assoc_string(&tmpi, name, buffer);
    2566. 

  2566. 									} else {
    2567. 

  2567. 										add_index_string(&array, ap, buffer);
    2568. 

  2568. 									}
    2569. 

  2569. 									break;
    2570. 

  2570. 

  2571. 								case TAG_FMT_SINGLE:
    2572. 

  2572. 									if (l==1) {
    2573. 

  2573. 										add_assoc_double(&tmpi, name, info_value->f);
    2574. 

  2574. 									} else {
    2575. 

  2575. 										add_index_double(&array, ap, info_value->f);
    2576. 

  2576. 									}
    2577. 

  2577. 									break;
    2578. 

  2578. 

  2579. 								case TAG_FMT_DOUBLE:
    2580. 

  2580. 									if (l==1) {
    2581. 

  2581. 										add_assoc_double(&tmpi, name, info_value->d);
    2582. 

  2582. 									} else {
    2583. 

  2583. 										add_index_double(&array, ap, info_value->d);
    2584. 

  2584. 									}
    2585. 

  2585. 									break;
    2586. 

  2586. 							}
    2587. 

  2587. 							info_value = &info_data->value.list[ap];
    2588. 

  2588. 						}
    2589. 

  2589. 						if (l>1) {
    2590. 

  2590. 							add_assoc_zval(&tmpi, name, &array);
    2591. 

  2591. 						}
    2592. 

  2592. 						break;
    2593. 

  2593. 				}
    2594. 

  2594. 			}
    2595. 

  2595. 		}
    2596. 

  2596. 		if (sub_array) {
    2597. 

  2597. 			add_assoc_zval(value, exif_get_sectionname(section_index), &tmpi);
    2598. 

  2598. 		}
    2599. 

  2599. 	}
    2600. 

  2600. }
    2601. 

  2601. /* }}} */
    2602. 

  2602. 

  2603. /* {{{ Markers
    2604. 

  2604.    JPEG markers consist of one or more 0xFF bytes, followed by a marker
    2605. 

  2605.    code byte (which is not an FF).  Here are the marker codes of interest
    2606. 

  2606.    in this program.  (See jdmarker.c for a more complete list.)
    2607. 

  2607. */
    2608. 

  2608. 

  2609. #define M_TEM   0x01    /* temp for arithmetic coding              */
    2610. 

  2610. #define M_RES   0x02    /* reserved                                */
    2611. 

  2611. #define M_SOF0  0xC0    /* Start Of Frame N                        */
    2612. 

  2612. #define M_SOF1  0xC1    /* N indicates which compression process   */
    2613. 

  2613. #define M_SOF2  0xC2    /* Only SOF0-SOF2 are now in common use    */
    2614. 

  2614. #define M_SOF3  0xC3
    2615. 

  2615. #define M_DHT   0xC4
    2616. 

  2616. #define M_SOF5  0xC5    /* NB: codes C4 and CC are NOT SOF markers */
    2617. 

  2617. #define M_SOF6  0xC6
    2618. 

  2618. #define M_SOF7  0xC7
    2619. 

  2619. #define M_JPEG  0x08    /* reserved for extensions                 */
    2620. 

  2620. #define M_SOF9  0xC9
    2621. 

  2621. #define M_SOF10 0xCA
    2622. 

  2622. #define M_SOF11 0xCB
    2623. 

  2623. #define M_DAC   0xCC    /* arithmetic table                         */
    2624. 

  2624. #define M_SOF13 0xCD
    2625. 

  2625. #define M_SOF14 0xCE
    2626. 

  2626. #define M_SOF15 0xCF
    2627. 

  2627. #define M_RST0  0xD0    /* restart segment                          */
    2628. 

  2628. #define M_RST1  0xD1
    2629. 

  2629. #define M_RST2  0xD2
    2630. 

  2630. #define M_RST3  0xD3
    2631. 

  2631. #define M_RST4  0xD4
    2632. 

  2632. #define M_RST5  0xD5
    2633. 

  2633. #define M_RST6  0xD6
    2634. 

  2634. #define M_RST7  0xD7
    2635. 

  2635. #define M_SOI   0xD8    /* Start Of Image (beginning of datastream) */
    2636. 

  2636. #define M_EOI   0xD9    /* End Of Image (end of datastream)         */
    2637. 

  2637. #define M_SOS   0xDA    /* Start Of Scan (begins compressed data)   */
    2638. 

  2638. #define M_DQT   0xDB
    2639. 

  2639. #define M_DNL   0xDC
    2640. 

  2640. #define M_DRI   0xDD
    2641. 

  2641. #define M_DHP   0xDE
    2642. 

  2642. #define M_EXP   0xDF
    2643. 

  2643. #define M_APP0  0xE0    /* JPEG: 'JFIFF' AND (additional 'JFXX')    */
    2644. 

  2644. #define M_EXIF  0xE1    /* Exif Attribute Information               */
    2645. 

  2645. #define M_APP2  0xE2    /* Flash Pix Extension Data?                */
    2646. 

  2646. #define M_APP3  0xE3
    2647. 

  2647. #define M_APP4  0xE4
    2648. 

  2648. #define M_APP5  0xE5
    2649. 

  2649. #define M_APP6  0xE6
    2650. 

  2650. #define M_APP7  0xE7
    2651. 

  2651. #define M_APP8  0xE8
    2652. 

  2652. #define M_APP9  0xE9
    2653. 

  2653. #define M_APP10 0xEA
    2654. 

  2654. #define M_APP11 0xEB
    2655. 

  2655. #define M_APP12 0xEC
    2656. 

  2656. #define M_APP13 0xED    /* IPTC International Press Telecommunications Council */
    2657. 

  2657. #define M_APP14 0xEE    /* Software, Copyright?                     */
    2658. 

  2658. #define M_APP15 0xEF
    2659. 

  2659. #define M_JPG0  0xF0
    2660. 

  2660. #define M_JPG1  0xF1
    2661. 

  2661. #define M_JPG2  0xF2
    2662. 

  2662. #define M_JPG3  0xF3
    2663. 

  2663. #define M_JPG4  0xF4
    2664. 

  2664. #define M_JPG5  0xF5
    2665. 

  2665. #define M_JPG6  0xF6
    2666. 

  2666. #define M_JPG7  0xF7
    2667. 

  2667. #define M_JPG8  0xF8
    2668. 

  2668. #define M_JPG9  0xF9
    2669. 

  2669. #define M_JPG10 0xFA
    2670. 

  2670. #define M_JPG11 0xFB
    2671. 

  2671. #define M_JPG12 0xFC
    2672. 

  2672. #define M_JPG13 0xFD
    2673. 

  2673. #define M_COM   0xFE    /* COMment                                  */
    2674. 

  2674. 

  2675. #define M_PSEUDO 0x123 	/* Extra value.                             */
    2676. 

  2676. /* }}} */
    2677. 

  2677. 

  2678. /* {{{ exif_process_COM
    2679. 

  2679.    Process a COM marker.
    2680. 

  2680.    We want to print out the marker contents as legible text;
    2681. 

  2681.    we must guard against random junk and varying newline representations.
    2682. 

  2682. */
    2683. 

  2683. static void exif_process_COM (image_info_type *image_info, char *value, size_t length)
    2684. 

  2684. {
    2685. 

  2685. 	exif_iif_add_tag(image_info, SECTION_COMMENT, "Comment", TAG_COMPUTED_VALUE, TAG_FMT_STRING, length-2, value+2, length-2);
    2686. 

  2686. }
    2687. 

  2687. /* }}} */
    2688. 

  2688. 

  2689. /* {{{ exif_process_SOFn
    2690. 

  2690.  * Process a SOFn marker.  This is useful for the image dimensions */
    2691. 

  2691. static void exif_process_SOFn (uchar *Data, int marker, jpeg_sof_info *result)
    2692. 

  2692. {
    2693. 

  2693. 	/* 0xFF SOSn SectLen(2) Bits(1) Height(2) Width(2) Channels(1)  3*Channels (1)  */
    2694. 

  2694. 	result->bits_per_sample = Data[2];
    2695. 

  2695. 	result->height          = php_jpg_get16(Data+3);
    2696. 

  2696. 	result->width           = php_jpg_get16(Data+5);
    2697. 

  2697. 	result->num_components  = Data[7];
    2698. 

  2698. }
    2699. 

  2699. /* }}} */
    2700. 

  2700. 

  2701. /* forward declarations */
    2702. 

  2702. static int exif_process_IFD_in_JPEG(image_info_type *ImageInfo, char *dir_start, const exif_offset_info *info, size_t displacement, int section_index, int tag);
    2703. 

  2703. static int exif_process_IFD_TAG(image_info_type *ImageInfo, char *dir_entry, const exif_offset_info *info, size_t displacement, int section_index, int ReadNextIFD, tag_table_type tag_table);
    2704. 

  2704. 

  2705. /* {{{ exif_get_markername
    2706. 

  2706. 	Get name of marker */
    2707. 

  2707. #ifdef EXIF_DEBUG
    2708. 

  2708. static char * exif_get_markername(int marker)
    2709. 

  2709. {
    2710. 

  2710. 	switch(marker) {
    2711. 

  2711. 		case 0xC0: return "SOF0";
    2712. 

  2712. 		case 0xC1: return "SOF1";
    2713. 

  2713. 		case 0xC2: return "SOF2";
    2714. 

  2714. 		case 0xC3: return "SOF3";
    2715. 

  2715. 		case 0xC4: return "DHT";
    2716. 

  2716. 		case 0xC5: return "SOF5";
    2717. 

  2717. 		case 0xC6: return "SOF6";
    2718. 

  2718. 		case 0xC7: return "SOF7";
    2719. 

  2719. 		case 0xC9: return "SOF9";
    2720. 

  2720. 		case 0xCA: return "SOF10";
    2721. 

  2721. 		case 0xCB: return "SOF11";
    2722. 

  2722. 		case 0xCD: return "SOF13";
    2723. 

  2723. 		case 0xCE: return "SOF14";
    2724. 

  2724. 		case 0xCF: return "SOF15";
    2725. 

  2725. 		case 0xD8: return "SOI";
    2726. 

  2726. 		case 0xD9: return "EOI";
    2727. 

  2727. 		case 0xDA: return "SOS";
    2728. 

  2728. 		case 0xDB: return "DQT";
    2729. 

  2729. 		case 0xDC: return "DNL";
    2730. 

  2730. 		case 0xDD: return "DRI";
    2731. 

  2731. 		case 0xDE: return "DHP";
    2732. 

  2732. 		case 0xDF: return "EXP";
    2733. 

  2733. 		case 0xE0: return "APP0";
    2734. 

  2734. 		case 0xE1: return "EXIF";
    2735. 

  2735. 		case 0xE2: return "FPIX";
    2736. 

  2736. 		case 0xE3: return "APP3";
    2737. 

  2737. 		case 0xE4: return "APP4";
    2738. 

  2738. 		case 0xE5: return "APP5";
    2739. 

  2739. 		case 0xE6: return "APP6";
    2740. 

  2740. 		case 0xE7: return "APP7";
    2741. 

  2741. 		case 0xE8: return "APP8";
    2742. 

  2742. 		case 0xE9: return "APP9";
    2743. 

  2743. 		case 0xEA: return "APP10";
    2744. 

  2744. 		case 0xEB: return "APP11";
    2745. 

  2745. 		case 0xEC: return "APP12";
    2746. 

  2746. 		case 0xED: return "APP13";
    2747. 

  2747. 		case 0xEE: return "APP14";
    2748. 

  2748. 		case 0xEF: return "APP15";
    2749. 

  2749. 		case 0xF0: return "JPG0";
    2750. 

  2750. 		case 0xFD: return "JPG13";
    2751. 

  2751. 		case 0xFE: return "COM";
    2752. 

  2752. 		case 0x01: return "TEM";
    2753. 

  2753. 	}
    2754. 

  2754. 	return "Unknown";
    2755. 

  2755. }
    2756. 

  2756. #endif
    2757. 

  2757. /* }}} */
    2758. 

  2758. 

  2759. /* {{{ proto string exif_tagname(int index)
    2760. 

  2760. 	Get headername for index or false if not defined */
    2761. 

  2761. PHP_FUNCTION(exif_tagname)
    2762. 

  2762. {
    2763. 

  2763. 	zend_long tag;
    2764. 

  2764. 	char *szTemp;
    2765. 

  2765. 

  2766. 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &tag) == FAILURE) {
    2767. 

  2767. 		RETURN_THROWS();
    2768. 

  2768. 	}
    2769. 

  2769. 

  2770. 	szTemp = exif_get_tagname(tag, tag_table_IFD);
    2771. 

  2771. 	if (tag < 0 || !szTemp) {
    2772. 

  2772. 		RETURN_FALSE;
    2773. 

  2773. 	}
    2774. 

  2774. 

  2775. 	RETURN_STRING(szTemp);
    2776. 

  2776. }
    2777. 

  2777. /* }}} */
    2778. 

  2778. 

  2779. /* {{{ exif_ifd_make_value
    2780. 

  2780.  * Create a value for an ifd from an info_data pointer */
    2781. 

  2781. static void* exif_ifd_make_value(image_info_data *info_data, int motorola_intel) {
    2782. 

  2782. 	size_t  byte_count;
    2783. 

  2783. 	char    *value_ptr, *data_ptr;
    2784. 

  2784. 	size_t  i;
    2785. 

  2785. 

  2786. 	image_info_value  *info_value;
    2787. 

  2787. 

  2788. 	byte_count = php_tiff_bytes_per_format[info_data->format] * info_data->length;
    2789. 

  2789. 	value_ptr = safe_emalloc(max(byte_count, 4), 1, 0);
    2790. 

  2790. 	memset(value_ptr, 0, 4);
    2791. 

  2791. 	if (!info_data->length) {
    2792. 

  2792. 		return value_ptr;
    2793. 

  2793. 	}
    2794. 

  2794. 	if (info_data->format == TAG_FMT_UNDEFINED || info_data->format == TAG_FMT_STRING
    2795. 

  2795. 	  || (byte_count>1 && (info_data->format == TAG_FMT_BYTE || info_data->format == TAG_FMT_SBYTE))
    2796. 

  2796. 	) {
    2797. 

  2797. 		memmove(value_ptr, info_data->value.s, byte_count);
    2798. 

  2798. 		return value_ptr;
    2799. 

  2799. 	} else if (info_data->format == TAG_FMT_BYTE) {
    2800. 

  2800. 		*value_ptr = info_data->value.u;
    2801. 

  2801. 		return value_ptr;
    2802. 

  2802. 	} else if (info_data->format == TAG_FMT_SBYTE) {
    2803. 

  2803. 		*value_ptr = info_data->value.i;
    2804. 

  2804. 		return value_ptr;
    2805. 

  2805. 	} else {
    2806. 

  2806. 		data_ptr = value_ptr;
    2807. 

  2807. 		for(i=0; i<info_data->length; i++) {
    2808. 

  2808. 			if (info_data->length==1) {
    2809. 

  2809. 				info_value = &info_data->value;
    2810. 

  2810. 			} else {
    2811. 

  2811. 				info_value = &info_data->value.list[i];
    2812. 

  2812. 			}
    2813. 

  2813. 			switch(info_data->format) {
    2814. 

  2814. 				case TAG_FMT_USHORT:
    2815. 

  2815. 					php_ifd_set16u(data_ptr, info_value->u, motorola_intel);
    2816. 

  2816. 					data_ptr += 2;
    2817. 

  2817. 					break;
    2818. 

  2818. 				case TAG_FMT_ULONG:
    2819. 

  2819. 					php_ifd_set32u(data_ptr, info_value->u, motorola_intel);
    2820. 

  2820. 					data_ptr += 4;
    2821. 

  2821. 					break;
    2822. 

  2822. 				case TAG_FMT_SSHORT:
    2823. 

  2823. 					php_ifd_set16u(data_ptr, info_value->i, motorola_intel);
    2824. 

  2824. 					data_ptr += 2;
    2825. 

  2825. 					break;
    2826. 

  2826. 				case TAG_FMT_SLONG:
    2827. 

  2827. 					php_ifd_set32u(data_ptr, info_value->i, motorola_intel);
    2828. 

  2828. 					data_ptr += 4;
    2829. 

  2829. 					break;
    2830. 

  2830. 				case TAG_FMT_URATIONAL:
    2831. 

  2831. 					php_ifd_set32u(data_ptr,   info_value->sr.num, motorola_intel);
    2832. 

  2832. 					php_ifd_set32u(data_ptr+4, info_value->sr.den, motorola_intel);
    2833. 

  2833. 					data_ptr += 8;
    2834. 

  2834. 					break;
    2835. 

  2835. 				case TAG_FMT_SRATIONAL:
    2836. 

  2836. 					php_ifd_set32u(data_ptr,   info_value->ur.num, motorola_intel);
    2837. 

  2837. 					php_ifd_set32u(data_ptr+4, info_value->ur.den, motorola_intel);
    2838. 

  2838. 					data_ptr += 8;
    2839. 

  2839. 					break;
    2840. 

  2840. 				case TAG_FMT_SINGLE:
    2841. 

  2841. 					memmove(data_ptr, &info_value->f, 4);
    2842. 

  2842. 					data_ptr += 4;
    2843. 

  2843. 					break;
    2844. 

  2844. 				case TAG_FMT_DOUBLE:
    2845. 

  2845. 					memmove(data_ptr, &info_value->d, 8);
    2846. 

  2846. 					data_ptr += 8;
    2847. 

  2847. 					break;
    2848. 

  2848. 			}
    2849. 

  2849. 		}
    2850. 

  2850. 	}
    2851. 

  2851. 	return value_ptr;
    2852. 

  2852. }
    2853. 

  2853. /* }}} */
    2854. 

  2854. 

  2855. /* {{{ exif_thumbnail_build
    2856. 

  2856.  * Check and build thumbnail */
    2857. 

  2857. static void exif_thumbnail_build(image_info_type *ImageInfo) {
    2858. 

  2858. 	size_t            new_size, new_move, new_value;
    2859. 

  2859. 	char              *new_data;
    2860. 

  2860. 	void              *value_ptr;
    2861. 

  2861. 	int               i, byte_count;
    2862. 

  2862. 	image_info_list   *info_list;
    2863. 

  2863. 	image_info_data   *info_data;
    2864. 

  2864. #ifdef EXIF_DEBUG
    2865. 

  2865. 	char              tagname[64];
    2866. 

  2866. #endif
    2867. 

  2867. 

  2868. 	if (!ImageInfo->read_thumbnail || !ImageInfo->Thumbnail.offset || !ImageInfo->Thumbnail.size) {
    2869. 

  2869. 		return; /* ignore this call */
    2870. 

  2870. 	}
    2871. 

  2871. #ifdef EXIF_DEBUG
    2872. 

  2872. 	exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Thumbnail: filetype = %d", ImageInfo->Thumbnail.filetype);
    2873. 

  2873. #endif
    2874. 

  2874. 	switch(ImageInfo->Thumbnail.filetype) {
    2875. 

  2875. 		default:
    2876. 

  2876. 		case IMAGE_FILETYPE_JPEG:
    2877. 

  2877. 			/* done */
    2878. 

  2878. 			break;
    2879. 

  2879. 		case IMAGE_FILETYPE_TIFF_II:
    2880. 

  2880. 		case IMAGE_FILETYPE_TIFF_MM:
    2881. 

  2881. 			info_list = &ImageInfo->info_list[SECTION_THUMBNAIL];
    2882. 

  2882. 			new_size  = 8 + 2 + info_list->count * 12 + 4;
    2883. 

  2883. #ifdef EXIF_DEBUG
    2884. 

  2884. 			exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Thumbnail: size of signature + directory(%d): 0x%02X", info_list->count, new_size);
    2885. 

  2885. #endif
    2886. 

  2886. 			new_value= new_size; /* offset for ifd values outside ifd directory */
    2887. 

  2887. 			for (i=0; i<info_list->count; i++) {
    2888. 

  2888. 				info_data  = &info_list->list[i];
    2889. 

  2889. 				byte_count = php_tiff_bytes_per_format[info_data->format] * info_data->length;
    2890. 

  2890. 				if (byte_count > 4) {
    2891. 

  2891. 					new_size += byte_count;
    2892. 

  2892. 				}
    2893. 

  2893. 			}
    2894. 

  2894. 			new_move = new_size;
    2895. 

  2895. 			new_data = safe_erealloc(ImageInfo->Thumbnail.data, 1, ImageInfo->Thumbnail.size, new_size);
    2896. 

  2896. 			ImageInfo->Thumbnail.data = new_data;
    2897. 

  2897. 			memmove(ImageInfo->Thumbnail.data + new_move, ImageInfo->Thumbnail.data, ImageInfo->Thumbnail.size);
    2898. 

  2898. 			ImageInfo->Thumbnail.size += new_size;
    2899. 

  2899. 			/* fill in data */
    2900. 

  2900. 			if (ImageInfo->motorola_intel) {
    2901. 

  2901. 				memmove(new_data, "MM\x00\x2a\x00\x00\x00\x08", 8);
    2902. 

  2902. 			} else {
    2903. 

  2903. 				memmove(new_data, "II\x2a\x00\x08\x00\x00\x00", 8);
    2904. 

  2904. 			}
    2905. 

  2905. 			new_data += 8;
    2906. 

  2906. 			php_ifd_set16u(new_data, info_list->count, ImageInfo->motorola_intel);
    2907. 

  2907. 			new_data += 2;
    2908. 

  2908. 			for (i=0; i<info_list->count; i++) {
    2909. 

  2909. 				info_data  = &info_list->list[i];
    2910. 

  2910. 				byte_count = php_tiff_bytes_per_format[info_data->format] * info_data->length;
    2911. 

  2911. #ifdef EXIF_DEBUG
    2912. 

  2912. 				exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Thumbnail: process tag(x%04X=%s): %s%s (%d bytes)", info_data->tag, exif_get_tagname_debug(info_data->tag, tag_table_IFD), (info_data->length>1)&&info_data->format!=TAG_FMT_UNDEFINED&&info_data->format!=TAG_FMT_STRING?"ARRAY OF ":"", exif_get_tagformat(info_data->format), byte_count);
    2913. 

  2913. #endif
    2914. 

  2914. 				if (info_data->tag==TAG_STRIP_OFFSETS || info_data->tag==TAG_JPEG_INTERCHANGE_FORMAT) {
    2915. 

  2915. 					php_ifd_set16u(new_data + 0, info_data->tag,    ImageInfo->motorola_intel);
    2916. 

  2916. 					php_ifd_set16u(new_data + 2, TAG_FMT_ULONG,     ImageInfo->motorola_intel);
    2917. 

  2917. 					php_ifd_set32u(new_data + 4, 1,                 ImageInfo->motorola_intel);
    2918. 

  2918. 					php_ifd_set32u(new_data + 8, new_move,          ImageInfo->motorola_intel);
    2919. 

  2919. 				} else {
    2920. 

  2920. 					php_ifd_set16u(new_data + 0, info_data->tag,    ImageInfo->motorola_intel);
    2921. 

  2921. 					php_ifd_set16u(new_data + 2, info_data->format, ImageInfo->motorola_intel);
    2922. 

  2922. 					php_ifd_set32u(new_data + 4, info_data->length, ImageInfo->motorola_intel);
    2923. 

  2923. 					value_ptr  = exif_ifd_make_value(info_data, ImageInfo->motorola_intel);
    2924. 

  2924. 					if (byte_count <= 4) {
    2925. 

  2925. 						memmove(new_data+8, value_ptr, 4);
    2926. 

  2926. 					} else {
    2927. 

  2927. 						php_ifd_set32u(new_data+8, new_value, ImageInfo->motorola_intel);
    2928. 

  2928. #ifdef EXIF_DEBUG
    2929. 

  2929. 						exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Thumbnail: writing with value offset: 0x%04X + 0x%02X", new_value, byte_count);
    2930. 

  2930. #endif
    2931. 

  2931. 						memmove(ImageInfo->Thumbnail.data+new_value, value_ptr, byte_count);
    2932. 

  2932. 						new_value += byte_count;
    2933. 

  2933. 					}
    2934. 

  2934. 					efree(value_ptr);
    2935. 

  2935. 				}
    2936. 

  2936. 				new_data += 12;
    2937. 

  2937. 			}
    2938. 

  2938. 			memset(new_data, 0, 4); /* next ifd pointer */
    2939. 

  2939. #ifdef EXIF_DEBUG
    2940. 

  2940. 			exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Thumbnail: created");
    2941. 

  2941. #endif
    2942. 

  2942. 			break;
    2943. 

  2943. 	}
    2944. 

  2944. }
    2945. 

  2945. /* }}} */
    2946. 

  2946. 

  2947. /* {{{ exif_thumbnail_extract
    2948. 

  2948.  * Grab the thumbnail, corrected */
    2949. 

  2949. static void exif_thumbnail_extract(image_info_type *ImageInfo, const exif_offset_info *info) {
    2950. 

  2950. 	if (ImageInfo->Thumbnail.data) {
    2951. 

  2951. 		exif_error_docref("exif_read_data#error_mult_thumb" EXIFERR_CC, ImageInfo, E_WARNING, "Multiple possible thumbnails");
    2952. 

  2952. 		return; /* Should not happen */
    2953. 

  2953. 	}
    2954. 

  2954. 	if (!ImageInfo->read_thumbnail)	{
    2955. 

  2955. 		return; /* ignore this call */
    2956. 

  2956. 	}
    2957. 

  2957. 	/* according to exif2.1, the thumbnail is not supposed to be greater than 64K */
    2958. 

  2958. 	if (ImageInfo->Thumbnail.size >= 65536
    2959. 

  2959. 	 || ImageInfo->Thumbnail.size <= 0
    2960. 

  2960. 	 || ImageInfo->Thumbnail.offset <= 0
    2961. 

  2961. 	) {
    2962. 

  2962. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Illegal thumbnail size/offset");
    2963. 

  2963. 		return;
    2964. 

  2964. 	}
    2965. 

  2965. 	/* Check to make sure we are not going to go past the ExifLength */
    2966. 

  2966. 	char *thumbnail = exif_offset_info_try_get(
    2967. 

  2967. 		info, ImageInfo->Thumbnail.offset, ImageInfo->Thumbnail.size);
    2968. 

  2968. 	if (!thumbnail) {
    2969. 

  2969. 		EXIF_ERRLOG_THUMBEOF(ImageInfo)
    2970. 

  2970. 		return;
    2971. 

  2971. 	}
    2972. 

  2972. 	ImageInfo->Thumbnail.data = estrndup(thumbnail, ImageInfo->Thumbnail.size);
    2973. 

  2973. 	exif_thumbnail_build(ImageInfo);
    2974. 

  2974. }
    2975. 

  2975. /* }}} */
    2976. 

  2976. 

  2977. /* {{{ exif_process_undefined
    2978. 

  2978.  * Copy a string/buffer in Exif header to a character string and return length of allocated buffer if any. */
    2979. 

  2979. static int exif_process_undefined(char **result, char *value, size_t byte_count) {
    2980. 

  2980. 	/* we cannot use strlcpy - here the problem is that we have to copy NUL
    2981. 

  2981. 	 * chars up to byte_count, we also have to add a single NUL character to
    2982. 

  2982. 	 * force end of string.
    2983. 

  2983. 	 * estrndup does not return length
    2984. 

  2984. 	 */
    2985. 

  2985. 	if (byte_count) {
    2986. 

  2986. 		(*result) = estrndup(value, byte_count); /* NULL @ byte_count!!! */
    2987. 

  2987. 		return byte_count+1;
    2988. 

  2988. 	}
    2989. 

  2989. 	return 0;
    2990. 

  2990. }
    2991. 

  2991. /* }}} */
    2992. 

  2992. 

  2993. /* {{{ exif_process_string_raw
    2994. 

  2994.  * Copy a string in Exif header to a character string returns length of allocated buffer if any. */
    2995. 

  2995. static int exif_process_string_raw(char **result, char *value, size_t byte_count) {
    2996. 

  2996. 	/* we cannot use strlcpy - here the problem is that we have to copy NUL
    2997. 

  2997. 	 * chars up to byte_count, we also have to add a single NUL character to
    2998. 

  2998. 	 * force end of string.
    2999. 

  2999. 	 */
    3000. 

  3000. 	if (byte_count) {
    3001. 

  3001. 		(*result) = safe_emalloc(byte_count, 1, 1);
    3002. 

  3002. 		memcpy(*result, value, byte_count);
    3003. 

  3003. 		(*result)[byte_count] = '\0';
    3004. 

  3004. 		return byte_count+1;
    3005. 

  3005. 	}
    3006. 

  3006. 	return 0;
    3007. 

  3007. }
    3008. 

  3008. /* }}} */
    3009. 

  3009. 

  3010. /* {{{ exif_process_string
    3011. 

  3011.  * Copy a string in Exif header to a character string and return length of allocated buffer if any.
    3012. 

  3012.  * In contrast to exif_process_string this function does always return a string buffer */
    3013. 

  3013. static int exif_process_string(char **result, char *value, size_t byte_count) {
    3014. 

  3014. 	/* we cannot use strlcpy - here the problem is that we cannot use strlen to
    3015. 

  3015. 	 * determine length of string and we cannot use strlcpy with len=byte_count+1
    3016. 

  3016. 	 * because then we might get into an EXCEPTION if we exceed an allocated
    3017. 

  3017. 	 * memory page...so we use php_strnlen in conjunction with memcpy and add the NUL
    3018. 

  3018. 	 * char.
    3019. 

  3019. 	 * estrdup would sometimes allocate more memory and does not return length
    3020. 

  3020. 	 */
    3021. 

  3021. 	if ((byte_count=php_strnlen(value, byte_count)) > 0) {
    3022. 

  3022. 		return exif_process_undefined(result, value, byte_count);
    3023. 

  3023. 	}
    3024. 

  3024. 	(*result) = estrndup("", 1); /* force empty string */
    3025. 

  3025. 	return byte_count+1;
    3026. 

  3026. }
    3027. 

  3027. /* }}} */
    3028. 

  3028. 

  3029. /* {{{ exif_process_user_comment
    3030. 

  3030.  * Process UserComment in IFD. */
    3031. 

  3031. static int exif_process_user_comment(image_info_type *ImageInfo, char **pszInfoPtr, char **pszEncoding, char *szValuePtr, int ByteCount)
    3032. 

  3032. {
    3033. 

  3033. 	int   a;
    3034. 

  3034. 	char  *decode;
    3035. 

  3035. 	size_t len;
    3036. 

  3036. 

  3037. 	*pszEncoding = NULL;
    3038. 

  3038. 	/* Copy the comment */
    3039. 

  3039. 	if (ByteCount>=8) {
    3040. 

  3040. 		const zend_encoding *from, *to;
    3041. 

  3041. 		if (!memcmp(szValuePtr, "UNICODE\0", 8)) {
    3042. 

  3042. 			*pszEncoding = estrdup((const char*)szValuePtr);
    3043. 

  3043. 			szValuePtr = szValuePtr+8;
    3044. 

  3044. 			ByteCount -= 8;
    3045. 

  3045. 			/* First try to detect BOM: ZERO WIDTH NOBREAK SPACE (FEFF 16)
    3046. 

  3046. 			 * since we have no encoding support for the BOM yet we skip that.
    3047. 

  3047. 			 */
    3048. 

  3048. 			if (ByteCount >=2 && !memcmp(szValuePtr, "\xFE\xFF", 2)) {
    3049. 

  3049. 				decode = "UCS-2BE";
    3050. 

  3050. 				szValuePtr = szValuePtr+2;
    3051. 

  3051. 				ByteCount -= 2;
    3052. 

  3052. 			} else if (ByteCount >=2 && !memcmp(szValuePtr, "\xFF\xFE", 2)) {
    3053. 

  3053. 				decode = "UCS-2LE";
    3054. 

  3054. 				szValuePtr = szValuePtr+2;
    3055. 

  3055. 				ByteCount -= 2;
    3056. 

  3056. 			} else if (ImageInfo->motorola_intel) {
    3057. 

  3057. 				decode = ImageInfo->decode_unicode_be;
    3058. 

  3058. 			} else {
    3059. 

  3059. 				decode = ImageInfo->decode_unicode_le;
    3060. 

  3060. 			}
    3061. 

  3061. 			to = zend_multibyte_fetch_encoding(ImageInfo->encode_unicode);
    3062. 

  3062. 			from = zend_multibyte_fetch_encoding(decode);
    3063. 

  3063. 			/* XXX this will fail again if encoding_converter returns on error something different than SIZE_MAX   */
    3064. 

  3064. 			if (!to || !from || zend_multibyte_encoding_converter(
    3065. 

  3065. 					(unsigned char**)pszInfoPtr,
    3066. 

  3066. 					&len,
    3067. 

  3067. 					(unsigned char*)szValuePtr,
    3068. 

  3068. 					ByteCount,
    3069. 

  3069. 					to,
    3070. 

  3070. 					from) == (size_t)-1) {
    3071. 

  3071. 				len = exif_process_string_raw(pszInfoPtr, szValuePtr, ByteCount);
    3072. 

  3072. 			}
    3073. 

  3073. 			return len;
    3074. 

  3074. 		} else if (!memcmp(szValuePtr, "ASCII\0\0\0", 8)) {
    3075. 

  3075. 			*pszEncoding = estrdup((const char*)szValuePtr);
    3076. 

  3076. 			szValuePtr = szValuePtr+8;
    3077. 

  3077. 			ByteCount -= 8;
    3078. 

  3078. 		} else if (!memcmp(szValuePtr, "JIS\0\0\0\0\0", 8)) {
    3079. 

  3079. 			/* JIS should be translated to MB or we leave it to the user - leave it to the user */
    3080. 

  3080. 			*pszEncoding = estrdup((const char*)szValuePtr);
    3081. 

  3081. 			szValuePtr = szValuePtr+8;
    3082. 

  3082. 			ByteCount -= 8;
    3083. 

  3083. 			/* XXX this will fail again if encoding_converter returns on error something different than SIZE_MAX   */
    3084. 

  3084. 			to = zend_multibyte_fetch_encoding(ImageInfo->encode_jis);
    3085. 

  3085. 			from = zend_multibyte_fetch_encoding(ImageInfo->motorola_intel ? ImageInfo->decode_jis_be : ImageInfo->decode_jis_le);
    3086. 

  3086. 			if (!to || !from || zend_multibyte_encoding_converter(
    3087. 

  3087. 					(unsigned char**)pszInfoPtr,
    3088. 

  3088. 					&len,
    3089. 

  3089. 					(unsigned char*)szValuePtr,
    3090. 

  3090. 					ByteCount,
    3091. 

  3091. 					to,
    3092. 

  3092. 					from) == (size_t)-1) {
    3093. 

  3093. 				len = exif_process_string_raw(pszInfoPtr, szValuePtr, ByteCount);
    3094. 

  3094. 			}
    3095. 

  3095. 			return len;
    3096. 

  3096. 		} else if (!memcmp(szValuePtr, "\0\0\0\0\0\0\0\0", 8)) {
    3097. 

  3097. 			/* 8 NULL means undefined and should be ASCII... */
    3098. 

  3098. 			*pszEncoding = estrdup("UNDEFINED");
    3099. 

  3099. 			szValuePtr = szValuePtr+8;
    3100. 

  3100. 			ByteCount -= 8;
    3101. 

  3101. 		}
    3102. 

  3102. 	}
    3103. 

  3103. 

  3104. 	/* Olympus has this padded with trailing spaces.  Remove these first. */
    3105. 

  3105. 	if (ByteCount>0) {
    3106. 

  3106. 		for (a=ByteCount-1;a && szValuePtr[a]==' ';a--) {
    3107. 

  3107. 			(szValuePtr)[a] = '\0';
    3108. 

  3108. 		}
    3109. 

  3109. 	}
    3110. 

  3110. 

  3111. 	/* normal text without encoding */
    3112. 

  3112. 	exif_process_string(pszInfoPtr, szValuePtr, ByteCount);
    3113. 

  3113. 	return strlen(*pszInfoPtr);
    3114. 

  3114. }
    3115. 

  3115. /* }}} */
    3116. 

  3116. 

  3117. /* {{{ exif_process_unicode
    3118. 

  3118.  * Process unicode field in IFD. */
    3119. 

  3119. static int exif_process_unicode(image_info_type *ImageInfo, xp_field_type *xp_field, int tag, char *szValuePtr, int ByteCount)
    3120. 

  3120. {
    3121. 

  3121. 	xp_field->tag = tag;
    3122. 

  3122. 	xp_field->value = NULL;
    3123. 

  3123. 	/* XXX this will fail again if encoding_converter returns on error something different than SIZE_MAX   */
    3124. 

  3124. 	if (zend_multibyte_encoding_converter(
    3125. 

  3125. 			(unsigned char**)&xp_field->value,
    3126. 

  3126. 			&xp_field->size,
    3127. 

  3127. 			(unsigned char*)szValuePtr,
    3128. 

  3128. 			ByteCount,
    3129. 

  3129. 			zend_multibyte_fetch_encoding(ImageInfo->encode_unicode),
    3130. 

  3130. 			zend_multibyte_fetch_encoding(ImageInfo->motorola_intel ? ImageInfo->decode_unicode_be : ImageInfo->decode_unicode_le)
    3131. 

  3131. 			) == (size_t)-1) {
    3132. 

  3132. 		xp_field->size = exif_process_string_raw(&xp_field->value, szValuePtr, ByteCount);
    3133. 

  3133. 	}
    3134. 

  3134. 	return xp_field->size;
    3135. 

  3135. }
    3136. 

  3136. /* }}} */
    3137. 

  3137. 

  3138. /* {{{ exif_process_IFD_in_MAKERNOTE
    3139. 

  3139.  * Process nested IFDs directories in Maker Note. */
    3140. 

  3140. static int exif_process_IFD_in_MAKERNOTE(image_info_type *ImageInfo, char * value_ptr, int value_len, const exif_offset_info *info, size_t displacement)
    3141. 

  3141. {
    3142. 

  3142. 	size_t i;
    3143. 

  3143. 	int de, section_index = SECTION_MAKERNOTE;
    3144. 

  3144. 	int NumDirEntries, old_motorola_intel;
    3145. 

  3145. 	const maker_note_type *maker_note;
    3146. 

  3146. 	char *dir_start;
    3147. 

  3147. 	exif_offset_info new_info;
    3148. 

  3148. 

  3149. 	for (i=0; i<=sizeof(maker_note_array)/sizeof(maker_note_type); i++) {
    3150. 

  3150. 		if (i==sizeof(maker_note_array)/sizeof(maker_note_type)) {
    3151. 

  3151. #ifdef EXIF_DEBUG
    3152. 

  3152. 			exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "No maker note data found. Detected maker: %s (length = %d)", ImageInfo->make, strlen(ImageInfo->make));
    3153. 

  3153. #endif
    3154. 

  3154. 			/* unknown manufacturer, not an error, use it as a string */
    3155. 

  3155. 			return TRUE;
    3156. 

  3156. 		}
    3157. 

  3157. 

  3158. 		maker_note = maker_note_array+i;
    3159. 

  3159. 

  3160. 		if (maker_note->make && (!ImageInfo->make || strcmp(maker_note->make, ImageInfo->make)))
    3161. 

  3161. 			continue;
    3162. 

  3162. 		if (maker_note->id_string && value_len >= maker_note->id_string_len
    3163. 

  3163. 				&& strncmp(maker_note->id_string, value_ptr, maker_note->id_string_len))
    3164. 

  3164. 			continue;
    3165. 

  3165. 		break;
    3166. 

  3166. 	}
    3167. 

  3167. 

  3168. 	if (value_len < 2 || maker_note->offset >= value_len - 1) {
    3169. 

  3169. 		/* Do not go past the value end */
    3170. 

  3170. 		exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "IFD data too short: 0x%04X offset 0x%04X", value_len, maker_note->offset);
    3171. 

  3171. 		return FALSE;
    3172. 

  3172. 	}
    3173. 

  3173. 

  3174. 	dir_start = value_ptr + maker_note->offset;
    3175. 

  3175. 

  3176. #ifdef EXIF_DEBUG
    3177. 

  3177. 	exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Process %s @x%04X + 0x%04X=%d: %s", exif_get_sectionname(section_index), (int)dir_start-(int)offset_base+maker_note->offset+displacement, value_len, value_len, exif_char_dump(value_ptr, value_len, (int)dir_start-(int)offset_base+maker_note->offset+displacement));
    3178. 

  3178. #endif
    3179. 

  3179. 

  3180. 	ImageInfo->sections_found |= FOUND_MAKERNOTE;
    3181. 

  3181. 

  3182. 	old_motorola_intel = ImageInfo->motorola_intel;
    3183. 

  3183. 	switch (maker_note->byte_order) {
    3184. 

  3184. 		case MN_ORDER_INTEL:
    3185. 

  3185. 			ImageInfo->motorola_intel = 0;
    3186. 

  3186. 			break;
    3187. 

  3187. 		case MN_ORDER_MOTOROLA:
    3188. 

  3188. 			ImageInfo->motorola_intel = 1;
    3189. 

  3189. 			break;
    3190. 

  3190. 		default:
    3191. 

  3191. 		case MN_ORDER_NORMAL:
    3192. 

  3192. 			break;
    3193. 

  3193. 	}
    3194. 

  3194. 

  3195. 	NumDirEntries = php_ifd_get16u(dir_start, ImageInfo->motorola_intel);
    3196. 

  3196. 

  3197. 	switch (maker_note->offset_mode) {
    3198. 

  3198. 		case MN_OFFSET_MAKER:
    3199. 

  3199. 			exif_offset_info_init(&new_info, value_ptr, value_ptr, value_len);
    3200. 

  3200. 			info = &new_info;
    3201. 

  3201. 			break;
    3202. 

  3202. 		default:
    3203. 

  3203. 		case MN_OFFSET_NORMAL:
    3204. 

  3204. 			break;
    3205. 

  3205. 	}
    3206. 

  3206. 

  3207. 	if ((2+NumDirEntries*12) > value_len) {
    3208. 

  3208. 		exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Illegal IFD size: 2 + 0x%04X*12 = 0x%04X > 0x%04X", NumDirEntries, 2+NumDirEntries*12, value_len);
    3209. 

  3209. 		return FALSE;
    3210. 

  3210. 	}
    3211. 

  3211. 	if ((dir_start - value_ptr) > value_len - (2+NumDirEntries*12)) {
    3212. 

  3212. 		exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Illegal IFD size: 0x%04X > 0x%04X", (dir_start - value_ptr) + (2+NumDirEntries*12), value_len);
    3213. 

  3213. 		return FALSE;
    3214. 

  3214. 	}
    3215. 

  3215. 

  3216. 	for (de=0;de<NumDirEntries;de++) {
    3217. 

  3217. 		size_t offset = 2 + 12 * de;
    3218. 

  3218. 		if (!exif_process_IFD_TAG(ImageInfo, dir_start + offset,
    3219. 

  3219. 								  info, displacement, section_index, 0, maker_note->tag_table)) {
    3220. 

  3220. 			return FALSE;
    3221. 

  3221. 		}
    3222. 

  3222. 	}
    3223. 

  3223. 	ImageInfo->motorola_intel = old_motorola_intel;
    3224. 

  3224. /*	NextDirOffset (must be NULL) = php_ifd_get32u(dir_start+2+12*de, ImageInfo->motorola_intel);*/
    3225. 

  3225. #ifdef EXIF_DEBUG
    3226. 

  3226. 	exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Subsection %s done", exif_get_sectionname(SECTION_MAKERNOTE));
    3227. 

  3227. #endif
    3228. 

  3228. 	return TRUE;
    3229. 

  3229. }
    3230. 

  3230. /* }}} */
    3231. 

  3231. 

  3232. #define REQUIRE_NON_EMPTY() do { \
    3233. 

  3233. 	if (byte_count == 0) { \
    3234. 

  3234. 		exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Process tag(x%04X=%s): Cannot be empty", tag, exif_get_tagname_debug(tag, tag_table)); \
    3235. 

  3235. 		return FALSE; \
    3236. 

  3236. 	} \
    3237. 

  3237. } while (0)
    3238. 

  3238. 

  3239. 

  3240. /* {{{ exif_process_IFD_TAG
    3241. 

  3241.  * Process one of the nested IFDs directories. */
    3242. 

  3242. static int exif_process_IFD_TAG(image_info_type *ImageInfo, char *dir_entry, const exif_offset_info *info, size_t displacement, int section_index, int ReadNextIFD, tag_table_type tag_table)
    3243. 

  3243. {
    3244. 

  3244. 	size_t length;
    3245. 

  3245. 	unsigned int tag, format, components;
    3246. 

  3246. 	char *value_ptr, tagname[64], cbuf[32], *outside=NULL;
    3247. 

  3247. 	size_t byte_count, offset_val, fpos, fgot;
    3248. 

  3248. 	int64_t byte_count_signed;
    3249. 

  3249. 	xp_field_type *tmp_xp;
    3250. 

  3250. #ifdef EXIF_DEBUG
    3251. 

  3251. 	char *dump_data;
    3252. 

  3252. 	int dump_free;
    3253. 

  3253. #endif /* EXIF_DEBUG */
    3254. 

  3254. 

  3255. 	/* Protect against corrupt headers */
    3256. 

  3256. 	if (ImageInfo->ifd_nesting_level > MAX_IFD_NESTING_LEVEL) {
    3257. 

  3257. 		exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "corrupt EXIF header: maximum directory nesting level reached");
    3258. 

  3258. 		return FALSE;
    3259. 

  3259. 	}
    3260. 

  3260. 	ImageInfo->ifd_nesting_level++;
    3261. 

  3261. 

  3262. 	tag = php_ifd_get16u(dir_entry, ImageInfo->motorola_intel);
    3263. 

  3263. 	format = php_ifd_get16u(dir_entry+2, ImageInfo->motorola_intel);
    3264. 

  3264. 	components = php_ifd_get32u(dir_entry+4, ImageInfo->motorola_intel);
    3265. 

  3265. 

  3266. 	if (!format || format > NUM_FORMATS) {
    3267. 

  3267. 		/* (-1) catches illegal zero case as unsigned underflows to positive large. */
    3268. 

  3268. 		exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Process tag(x%04X=%s): Illegal format code 0x%04X, suppose BYTE", tag, exif_get_tagname_debug(tag, tag_table), format);
    3269. 

  3269. 		format = TAG_FMT_BYTE;
    3270. 

  3270. 	}
    3271. 

  3271. 

  3272. 	byte_count_signed = (int64_t)components * php_tiff_bytes_per_format[format];
    3273. 

  3273. 

  3274. 	if (byte_count_signed < 0 || (byte_count_signed > INT32_MAX)) {
    3275. 

  3275. 		exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Process tag(x%04X=%s): Illegal byte_count", tag, exif_get_tagname_debug(tag, tag_table));
    3276. 

  3276. 		return FALSE;
    3277. 

  3277. 	}
    3278. 

  3278. 

  3279. 	byte_count = (size_t)byte_count_signed;
    3280. 

  3280. 

  3281. 	if (byte_count > 4) {
    3282. 

  3282. 		/* If its bigger than 4 bytes, the dir entry contains an offset. */
    3283. 

  3283. 		offset_val = php_ifd_get32u(dir_entry+8, ImageInfo->motorola_intel);
    3284. 

  3284. 		value_ptr = exif_offset_info_try_get(info, offset_val, byte_count);
    3285. 

  3285. 		if (!value_ptr) {
    3286. 

  3286. 			/* It is important to check for IMAGE_FILETYPE_TIFF
    3287. 

  3287. 			 * JPEG does not use absolute pointers instead its pointers are
    3288. 

  3288. 			 * relative to the start of the TIFF header in APP1 section. */
    3289. 

  3289. 			// TODO: Shouldn't we also be taking "displacement" into account here?
    3290. 

  3290. 			if (byte_count > ImageInfo->FileSize || offset_val>ImageInfo->FileSize-byte_count || (ImageInfo->FileType!=IMAGE_FILETYPE_TIFF_II && ImageInfo->FileType!=IMAGE_FILETYPE_TIFF_MM && ImageInfo->FileType!=IMAGE_FILETYPE_JPEG)) {
    3291. 

  3291. 				exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Process tag(x%04X=%s): Illegal pointer offset(x%04X + x%04X = x%04X > x%04X)", tag, exif_get_tagname_debug(tag, tag_table), offset_val, byte_count, offset_val+byte_count, ImageInfo->FileSize);
    3292. 

  3292. 				return FALSE;
    3293. 

  3293. 			}
    3294. 

  3294. 			if (byte_count>sizeof(cbuf)) {
    3295. 

  3295. 				/* mark as outside range and get buffer */
    3296. 

  3296. 				value_ptr = safe_emalloc(byte_count, 1, 0);
    3297. 

  3297. 				outside = value_ptr;
    3298. 

  3298. 			} else {
    3299. 

  3299. 				/* In most cases we only access a small range so
    3300. 

  3300. 				 * it is faster to use a static buffer there
    3301. 

  3301. 				 * BUT it offers also the possibility to have
    3302. 

  3302. 				 * pointers read without the need to free them
    3303. 

  3303. 				 * explicitley before returning. */
    3304. 

  3304. 				memset(&cbuf, 0, sizeof(cbuf));
    3305. 

  3305. 				value_ptr = cbuf;
    3306. 

  3306. 			}
    3307. 

  3307. 

  3308. 			fpos = php_stream_tell(ImageInfo->infile);
    3309. 

  3309. 			php_stream_seek(ImageInfo->infile, displacement+offset_val, SEEK_SET);
    3310. 

  3310. 			fgot = php_stream_tell(ImageInfo->infile);
    3311. 

  3311. 			if (fgot!=displacement+offset_val) {
    3312. 

  3312. 				EFREE_IF(outside);
    3313. 

  3313. 				exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Wrong file pointer: 0x%08X != 0x%08X", fgot, displacement+offset_val);
    3314. 

  3314. 				return FALSE;
    3315. 

  3315. 			}
    3316. 

  3316. 			fgot = php_stream_read(ImageInfo->infile, value_ptr, byte_count);
    3317. 

  3317. 			php_stream_seek(ImageInfo->infile, fpos, SEEK_SET);
    3318. 

  3318. 			if (fgot != byte_count) {
    3319. 

  3319. 				EFREE_IF(outside);
    3320. 

  3320. 				EXIF_ERRLOG_FILEEOF(ImageInfo)
    3321. 

  3321. 				return FALSE;
    3322. 

  3322. 			}
    3323. 

  3323. 		}
    3324. 

  3324. 	} else {
    3325. 

  3325. 		/* 4 bytes or less and value is in the dir entry itself */
    3326. 

  3326. 		value_ptr = dir_entry+8;
    3327. 

  3327. 		// TODO: This is dubious, but the value is only used for debugging.
    3328. 

  3328. 		offset_val = value_ptr-info->offset_base;
    3329. 

  3329. 	}
    3330. 

  3330. 

  3331. 	ImageInfo->sections_found |= FOUND_ANY_TAG;
    3332. 

  3332. #ifdef EXIF_DEBUG
    3333. 

  3333. 	dump_data = exif_dump_data(&dump_free, format, components, length, ImageInfo->motorola_intel, value_ptr);
    3334. 

  3334. 	exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Process tag(x%04X=%s,@x%04X + x%04X(=%d)): %s%s %s", tag, exif_get_tagname_debug(tag, tag_table), offset_val+displacement, byte_count, byte_count, (components>1)&&format!=TAG_FMT_UNDEFINED&&format!=TAG_FMT_STRING?"ARRAY OF ":"", exif_get_tagformat(format), dump_data);
    3335. 

  3335. 	if (dump_free) {
    3336. 

  3336. 		efree(dump_data);
    3337. 

  3337. 	}
    3338. 

  3338. #endif
    3339. 

  3339. 

  3340. 	/* NB: The following code may not assume that there is at least one component!
    3341. 

  3341. 	 * byte_count may be zero! */
    3342. 

  3342. 

  3343. 	if (section_index==SECTION_THUMBNAIL) {
    3344. 

  3344. 		if (!ImageInfo->Thumbnail.data) {
    3345. 

  3345. 			REQUIRE_NON_EMPTY();
    3346. 

  3346. 			switch(tag) {
    3347. 

  3347. 				case TAG_IMAGEWIDTH:
    3348. 

  3348. 				case TAG_COMP_IMAGE_WIDTH:
    3349. 

  3349. 					ImageInfo->Thumbnail.width = exif_convert_any_to_int(value_ptr, exif_rewrite_tag_format_to_unsigned(format), ImageInfo->motorola_intel);
    3350. 

  3350. 					break;
    3351. 

  3351. 

  3352. 				case TAG_IMAGEHEIGHT:
    3353. 

  3353. 				case TAG_COMP_IMAGE_HEIGHT:
    3354. 

  3354. 					ImageInfo->Thumbnail.height = exif_convert_any_to_int(value_ptr, exif_rewrite_tag_format_to_unsigned(format), ImageInfo->motorola_intel);
    3355. 

  3355. 					break;
    3356. 

  3356. 

  3357. 				case TAG_STRIP_OFFSETS:
    3358. 

  3358. 				case TAG_JPEG_INTERCHANGE_FORMAT:
    3359. 

  3359. 					/* accept both formats */
    3360. 

  3360. 					ImageInfo->Thumbnail.offset = exif_convert_any_to_int(value_ptr, exif_rewrite_tag_format_to_unsigned(format), ImageInfo->motorola_intel);
    3361. 

  3361. 					break;
    3362. 

  3362. 

  3363. 				case TAG_STRIP_BYTE_COUNTS:
    3364. 

  3364. 					if (ImageInfo->FileType == IMAGE_FILETYPE_TIFF_II || ImageInfo->FileType == IMAGE_FILETYPE_TIFF_MM) {
    3365. 

  3365. 						ImageInfo->Thumbnail.filetype = ImageInfo->FileType;
    3366. 

  3366. 					} else {
    3367. 

  3367. 						/* motorola is easier to read */
    3368. 

  3368. 						ImageInfo->Thumbnail.filetype = IMAGE_FILETYPE_TIFF_MM;
    3369. 

  3369. 					}
    3370. 

  3370. 					ImageInfo->Thumbnail.size = exif_convert_any_to_int(value_ptr, exif_rewrite_tag_format_to_unsigned(format), ImageInfo->motorola_intel);
    3371. 

  3371. 					break;
    3372. 

  3372. 

  3373. 				case TAG_JPEG_INTERCHANGE_FORMAT_LEN:
    3374. 

  3374. 					if (ImageInfo->Thumbnail.filetype == IMAGE_FILETYPE_UNKNOWN) {
    3375. 

  3375. 						ImageInfo->Thumbnail.filetype = IMAGE_FILETYPE_JPEG;
    3376. 

  3376. 						ImageInfo->Thumbnail.size = exif_convert_any_to_int(value_ptr, exif_rewrite_tag_format_to_unsigned(format), ImageInfo->motorola_intel);
    3377. 

  3377. 					}
    3378. 

  3378. 					break;
    3379. 

  3379. 			}
    3380. 

  3380. 		}
    3381. 

  3381. 	} else {
    3382. 

  3382. 		if (section_index==SECTION_IFD0 || section_index==SECTION_EXIF)
    3383. 

  3383. 		switch(tag) {
    3384. 

  3384. 			case TAG_COPYRIGHT:
    3385. 

  3385. 				/* check for "<photographer> NUL <editor> NUL" */
    3386. 

  3386. 				if (byte_count>1 && (length=php_strnlen(value_ptr, byte_count)) > 0) {
    3387. 

  3387. 					if (length<byte_count-1) {
    3388. 

  3388. 						/* When there are any characters after the first NUL */
    3389. 

  3389. 						EFREE_IF(ImageInfo->CopyrightPhotographer);
    3390. 

  3390. 						EFREE_IF(ImageInfo->CopyrightEditor);
    3391. 

  3391. 						EFREE_IF(ImageInfo->Copyright);
    3392. 

  3392. 						ImageInfo->CopyrightPhotographer  = estrdup(value_ptr);
    3393. 

  3393. 						ImageInfo->CopyrightEditor        = estrndup(value_ptr+length+1, byte_count-length-1);
    3394. 

  3394. 						spprintf(&ImageInfo->Copyright, 0, "%s, %s", ImageInfo->CopyrightPhotographer, ImageInfo->CopyrightEditor);
    3395. 

  3395. 						/* format = TAG_FMT_UNDEFINED; this mustn't be ASCII         */
    3396. 

  3396. 						/* but we are not supposed to change this                   */
    3397. 

  3397. 						/* keep in mind that image_info does not store editor value */
    3398. 

  3398. 					} else {
    3399. 

  3399. 						EFREE_IF(ImageInfo->Copyright);
    3400. 

  3400. 						ImageInfo->Copyright = estrndup(value_ptr, byte_count);
    3401. 

  3401. 					}
    3402. 

  3402. 				}
    3403. 

  3403. 				break;
    3404. 

  3404. 

  3405. 			case TAG_USERCOMMENT:
    3406. 

  3406. 				EFREE_IF(ImageInfo->UserComment);
    3407. 

  3407. 				ImageInfo->UserComment = NULL;
    3408. 

  3408. 				EFREE_IF(ImageInfo->UserCommentEncoding);
    3409. 

  3409. 				ImageInfo->UserCommentEncoding = NULL;
    3410. 

  3410. 				ImageInfo->UserCommentLength = exif_process_user_comment(ImageInfo, &(ImageInfo->UserComment), &(ImageInfo->UserCommentEncoding), value_ptr, byte_count);
    3411. 

  3411. 				break;
    3412. 

  3412. 

  3413. 			case TAG_XP_TITLE:
    3414. 

  3414. 			case TAG_XP_COMMENTS:
    3415. 

  3415. 			case TAG_XP_AUTHOR:
    3416. 

  3416. 			case TAG_XP_KEYWORDS:
    3417. 

  3417. 			case TAG_XP_SUBJECT:
    3418. 

  3418. 				tmp_xp = (xp_field_type*)safe_erealloc(ImageInfo->xp_fields.list, (ImageInfo->xp_fields.count+1), sizeof(xp_field_type), 0);
    3419. 

  3419. 				ImageInfo->sections_found |= FOUND_WINXP;
    3420. 

  3420. 				ImageInfo->xp_fields.list = tmp_xp;
    3421. 

  3421. 				ImageInfo->xp_fields.count++;
    3422. 

  3422. 				exif_process_unicode(ImageInfo, &(ImageInfo->xp_fields.list[ImageInfo->xp_fields.count-1]), tag, value_ptr, byte_count);
    3423. 

  3423. 				break;
    3424. 

  3424. 

  3425. 			case TAG_FNUMBER:
    3426. 

  3426. 				/* Simplest way of expressing aperture, so I trust it the most.
    3427. 

  3427. 				   (overwrite previously computed value if there is one) */
    3428. 

  3428. 				REQUIRE_NON_EMPTY();
    3429. 

  3429. 				ImageInfo->ApertureFNumber = (float)exif_convert_any_format(value_ptr, format, ImageInfo->motorola_intel);
    3430. 

  3430. 				break;
    3431. 

  3431. 

  3432. 			case TAG_APERTURE:
    3433. 

  3433. 			case TAG_MAX_APERTURE:
    3434. 

  3434. 				/* More relevant info always comes earlier, so only use this field if we don't
    3435. 

  3435. 				   have appropriate aperture information yet. */
    3436. 

  3436. 				if (ImageInfo->ApertureFNumber == 0) {
    3437. 

  3437. 					REQUIRE_NON_EMPTY();
    3438. 

  3438. 					ImageInfo->ApertureFNumber
    3439. 

  3439. 						= expf(exif_convert_any_format(value_ptr, format, ImageInfo->motorola_intel)*logf(2.0)*0.5);
    3440. 

  3440. 				}
    3441. 

  3441. 				break;
    3442. 

  3442. 

  3443. 			case TAG_SHUTTERSPEED:
    3444. 

  3444. 				/* More complicated way of expressing exposure time, so only use
    3445. 

  3445. 				   this value if we don't already have it from somewhere else.
    3446. 

  3446. 				   SHUTTERSPEED comes after EXPOSURE TIME
    3447. 

  3447. 				  */
    3448. 

  3448. 				if (ImageInfo->ExposureTime == 0) {
    3449. 

  3449. 					REQUIRE_NON_EMPTY();
    3450. 

  3450. 					ImageInfo->ExposureTime
    3451. 

  3451. 						= expf(-exif_convert_any_format(value_ptr, format, ImageInfo->motorola_intel)*logf(2.0));
    3452. 

  3452. 				}
    3453. 

  3453. 				break;
    3454. 

  3454. 			case TAG_EXPOSURETIME:
    3455. 

  3455. 				ImageInfo->ExposureTime = -1;
    3456. 

  3456. 				break;
    3457. 

  3457. 

  3458. 			case TAG_COMP_IMAGE_WIDTH:
    3459. 

  3459. 				REQUIRE_NON_EMPTY();
    3460. 

  3460. 				ImageInfo->ExifImageWidth = exif_convert_any_to_int(value_ptr, exif_rewrite_tag_format_to_unsigned(format), ImageInfo->motorola_intel);
    3461. 

  3461. 				break;
    3462. 

  3462. 

  3463. 			case TAG_FOCALPLANE_X_RES:
    3464. 

  3464. 				REQUIRE_NON_EMPTY();
    3465. 

  3465. 				ImageInfo->FocalplaneXRes = exif_convert_any_format(value_ptr, format, ImageInfo->motorola_intel);
    3466. 

  3466. 				break;
    3467. 

  3467. 

  3468. 			case TAG_SUBJECT_DISTANCE:
    3469. 

  3469. 				/* Inidcates the distacne the autofocus camera is focused to.
    3470. 

  3470. 				   Tends to be less accurate as distance increases. */
    3471. 

  3471. 				REQUIRE_NON_EMPTY();
    3472. 

  3472. 				ImageInfo->Distance = (float)exif_convert_any_format(value_ptr, format, ImageInfo->motorola_intel);
    3473. 

  3473. 				break;
    3474. 

  3474. 

  3475. 			case TAG_FOCALPLANE_RESOLUTION_UNIT:
    3476. 

  3476. 				REQUIRE_NON_EMPTY();
    3477. 

  3477. 				switch((int)exif_convert_any_format(value_ptr, format, ImageInfo->motorola_intel)) {
    3478. 

  3478. 					case 1: ImageInfo->FocalplaneUnits = 25.4; break; /* inch */
    3479. 

  3479. 					case 2:
    3480. 

  3480. 						/* According to the information I was using, 2 measn meters.
    3481. 

  3481. 						   But looking at the Cannon powershot's files, inches is the only
    3482. 

  3482. 						   sensible value. */
    3483. 

  3483. 						ImageInfo->FocalplaneUnits = 25.4;
    3484. 

  3484. 						break;
    3485. 

  3485. 

  3486. 					case 3: ImageInfo->FocalplaneUnits = 10;   break;  /* centimeter */
    3487. 

  3487. 					case 4: ImageInfo->FocalplaneUnits = 1;    break;  /* milimeter  */
    3488. 

  3488. 					case 5: ImageInfo->FocalplaneUnits = .001; break;  /* micrometer */
    3489. 

  3489. 				}
    3490. 

  3490. 				break;
    3491. 

  3491. 

  3492. 			case TAG_SUB_IFD:
    3493. 

  3493. 				if (format==TAG_FMT_IFD) {
    3494. 

  3494. 					/* If this is called we are either in a TIFFs thumbnail or a JPEG where we cannot handle it */
    3495. 

  3495. 					/* TIFF thumbnail: our data structure cannot store a thumbnail of a thumbnail */
    3496. 

  3496. 					/* JPEG do we have the data area and what to do with it */
    3497. 

  3497. 					exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Skip SUB IFD");
    3498. 

  3498. 				}
    3499. 

  3499. 				break;
    3500. 

  3500. 

  3501. 			case TAG_MAKE:
    3502. 

  3502. 				EFREE_IF(ImageInfo->make);
    3503. 

  3503. 				ImageInfo->make = estrndup(value_ptr, byte_count);
    3504. 

  3504. 				break;
    3505. 

  3505. 			case TAG_MODEL:
    3506. 

  3506. 				EFREE_IF(ImageInfo->model);
    3507. 

  3507. 				ImageInfo->model = estrndup(value_ptr, byte_count);
    3508. 

  3508. 				break;
    3509. 

  3509. 

  3510. 			case TAG_MAKER_NOTE:
    3511. 

  3511. 				if (!exif_process_IFD_in_MAKERNOTE(ImageInfo, value_ptr, byte_count, info, displacement)) {
    3512. 

  3512. 					EFREE_IF(outside);
    3513. 

  3513. 					return FALSE;
    3514. 

  3514. 				}
    3515. 

  3515. 				break;
    3516. 

  3516. 

  3517. 			case TAG_EXIF_IFD_POINTER:
    3518. 

  3518. 			case TAG_GPS_IFD_POINTER:
    3519. 

  3519. 			case TAG_INTEROP_IFD_POINTER:
    3520. 

  3520. 				if (ReadNextIFD) {
    3521. 

  3521. 					REQUIRE_NON_EMPTY();
    3522. 

  3522. 					char *Subdir_start;
    3523. 

  3523. 					int sub_section_index = 0;
    3524. 

  3524. 					switch(tag) {
    3525. 

  3525. 						case TAG_EXIF_IFD_POINTER:
    3526. 

  3526. #ifdef EXIF_DEBUG
    3527. 

  3527. 							exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Found EXIF");
    3528. 

  3528. #endif
    3529. 

  3529. 							ImageInfo->sections_found |= FOUND_EXIF;
    3530. 

  3530. 							sub_section_index = SECTION_EXIF;
    3531. 

  3531. 							break;
    3532. 

  3532. 						case TAG_GPS_IFD_POINTER:
    3533. 

  3533. #ifdef EXIF_DEBUG
    3534. 

  3534. 							exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Found GPS");
    3535. 

  3535. #endif
    3536. 

  3536. 							ImageInfo->sections_found |= FOUND_GPS;
    3537. 

  3537. 							sub_section_index = SECTION_GPS;
    3538. 

  3538. 							break;
    3539. 

  3539. 						case TAG_INTEROP_IFD_POINTER:
    3540. 

  3540. #ifdef EXIF_DEBUG
    3541. 

  3541. 							exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Found INTEROPERABILITY");
    3542. 

  3542. #endif
    3543. 

  3543. 							ImageInfo->sections_found |= FOUND_INTEROP;
    3544. 

  3544. 							sub_section_index = SECTION_INTEROP;
    3545. 

  3545. 							break;
    3546. 

  3546. 					}
    3547. 

  3547. 					offset_val = php_ifd_get32u(value_ptr, ImageInfo->motorola_intel);
    3548. 

  3548. 					Subdir_start = exif_offset_info_try_get(info, offset_val, 0);
    3549. 

  3549. 					if (!Subdir_start) {
    3550. 

  3550. 						exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Illegal IFD Pointer");
    3551. 

  3551. 						EFREE_IF(outside);
    3552. 

  3552. 						return FALSE;
    3553. 

  3553. 					}
    3554. 

  3554. 					if (!exif_process_IFD_in_JPEG(ImageInfo, Subdir_start, info, displacement, sub_section_index, tag)) {
    3555. 

  3555. 						EFREE_IF(outside);
    3556. 

  3556. 						return FALSE;
    3557. 

  3557. 					}
    3558. 

  3558. #ifdef EXIF_DEBUG
    3559. 

  3559. 					exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Subsection %s done", exif_get_sectionname(sub_section_index));
    3560. 

  3560. #endif
    3561. 

  3561. 				}
    3562. 

  3562. 		}
    3563. 

  3563. 	}
    3564. 

  3564. 	exif_iif_add_tag(ImageInfo, section_index, exif_get_tagname_key(tag, tagname, sizeof(tagname), tag_table), tag, format, components, value_ptr, byte_count);
    3565. 

  3565. 	EFREE_IF(outside);
    3566. 

  3566. 	return TRUE;
    3567. 

  3567. }
    3568. 

  3568. /* }}} */
    3569. 

  3569. 

  3570. /* {{{ exif_process_IFD_in_JPEG
    3571. 

  3571.  * Process one of the nested IFDs directories. */
    3572. 

  3572. static int exif_process_IFD_in_JPEG(image_info_type *ImageInfo, char *dir_start, const exif_offset_info *info, size_t displacement, int section_index, int tag)
    3573. 

  3573. {
    3574. 

  3574. 	int de;
    3575. 

  3575. 	int NumDirEntries;
    3576. 

  3576. 	int NextDirOffset = 0;
    3577. 

  3577. 

  3578. #ifdef EXIF_DEBUG
    3579. 

  3579. 	exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Process %s (x%04X(=%d))", exif_get_sectionname(section_index), IFDlength, IFDlength);
    3580. 

  3580. #endif
    3581. 

  3581. 

  3582. 	ImageInfo->sections_found |= FOUND_IFD0;
    3583. 

  3583. 

  3584. 	if (!exif_offset_info_contains(info, dir_start, 2)) {
    3585. 

  3585. 		exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Illegal IFD size");
    3586. 

  3586. 		return FALSE;
    3587. 

  3587. 	}
    3588. 

  3588. 

  3589. 	NumDirEntries = php_ifd_get16u(dir_start, ImageInfo->motorola_intel);
    3590. 

  3590. 

  3591. 	if (!exif_offset_info_contains(info, dir_start+2, NumDirEntries*12)) {
    3592. 

  3592. 		exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Illegal IFD size: x%04X + 2 + x%04X*12 = x%04X > x%04X", (int)((size_t)dir_start+2-(size_t)info->valid_start), NumDirEntries, (int)((size_t)dir_start+2+NumDirEntries*12-(size_t)info->valid_start), info->valid_end - info->valid_start);
    3593. 

  3593. 		return FALSE;
    3594. 

  3594. 	}
    3595. 

  3595. 

  3596. 	for (de=0;de<NumDirEntries;de++) {
    3597. 

  3597. 		if (!exif_process_IFD_TAG(ImageInfo, dir_start + 2 + 12 * de,
    3598. 

  3598. 								  info, displacement, section_index, 1, exif_get_tag_table(section_index))) {
    3599. 

  3599. 			return FALSE;
    3600. 

  3600. 		}
    3601. 

  3601. 	}
    3602. 

  3602. 	/*
    3603. 

  3603. 	 * Ignore IFD2 if it purportedly exists
    3604. 

  3604. 	 */
    3605. 

  3605. 	if (section_index == SECTION_THUMBNAIL) {
    3606. 

  3606. 		return TRUE;
    3607. 

  3607. 	}
    3608. 

  3608. 	/*
    3609. 

  3609. 	 * Hack to make it process IDF1 I hope
    3610. 

  3610. 	 * There are 2 IDFs, the second one holds the keys (0x0201 and 0x0202) to the thumbnail
    3611. 

  3611. 	 */
    3612. 

  3612. 	if (!exif_offset_info_contains(info, dir_start+2+NumDirEntries*12, 4)) {
    3613. 

  3613. 		exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Illegal IFD size");
    3614. 

  3614. 		return FALSE;
    3615. 

  3615. 	}
    3616. 

  3616. 

  3617. 	if (tag != TAG_EXIF_IFD_POINTER && tag != TAG_GPS_IFD_POINTER) {
    3618. 

  3618. 		NextDirOffset = php_ifd_get32u(dir_start+2+12*de, ImageInfo->motorola_intel);
    3619. 

  3619. 	}
    3620. 

  3620. 

  3621. 	if (NextDirOffset) {
    3622. 

  3622. 		char *next_dir_start = exif_offset_info_try_get(info, NextDirOffset, 0);
    3623. 

  3623. 		if (!next_dir_start) {
    3624. 

  3624. 			exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Illegal IFD offset");
    3625. 

  3625. 			return FALSE;
    3626. 

  3626. 		}
    3627. 

  3627. 		/* That is the IFD for the first thumbnail */
    3628. 

  3628. #ifdef EXIF_DEBUG
    3629. 

  3629. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Expect next IFD to be thumbnail");
    3630. 

  3630. #endif
    3631. 

  3631. 		if (exif_process_IFD_in_JPEG(ImageInfo, next_dir_start, info, displacement, SECTION_THUMBNAIL, 0)) {
    3632. 

  3632. #ifdef EXIF_DEBUG
    3633. 

  3633. 			exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Thumbnail size: 0x%04X", ImageInfo->Thumbnail.size);
    3634. 

  3634. #endif
    3635. 

  3635. 			if (ImageInfo->Thumbnail.filetype != IMAGE_FILETYPE_UNKNOWN
    3636. 

  3636. 			&&  ImageInfo->Thumbnail.size
    3637. 

  3637. 			&&  ImageInfo->Thumbnail.offset
    3638. 

  3638. 			&&  ImageInfo->read_thumbnail
    3639. 

  3639. 			) {
    3640. 

  3640. 				exif_thumbnail_extract(ImageInfo, info);
    3641. 

  3641. 			}
    3642. 

  3642. 			return TRUE;
    3643. 

  3643. 		} else {
    3644. 

  3644. 			return FALSE;
    3645. 

  3645. 		}
    3646. 

  3646. 	}
    3647. 

  3647. 	return TRUE;
    3648. 

  3648. }
    3649. 

  3649. /* }}} */
    3650. 

  3650. 

  3651. /* {{{ exif_process_TIFF_in_JPEG
    3652. 

  3652.    Process a TIFF header in a JPEG file
    3653. 

  3653. */
    3654. 

  3654. static void exif_process_TIFF_in_JPEG(image_info_type *ImageInfo, char *CharBuf, size_t length, size_t displacement)
    3655. 

  3655. {
    3656. 

  3656. 	unsigned exif_value_2a, offset_of_ifd;
    3657. 

  3657. 	exif_offset_info info;
    3658. 

  3658. 

  3659. 	if (length < 2) {
    3660. 

  3660. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Missing TIFF alignment marker");
    3661. 

  3661. 		return;
    3662. 

  3662. 	}
    3663. 

  3663. 

  3664. 	if (length < 2) {
    3665. 

  3665. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Missing TIFF alignment marker");
    3666. 

  3666. 		return;
    3667. 

  3667. 	}
    3668. 

  3668. 

  3669. 	/* set the thumbnail stuff to nothing so we can test to see if they get set up */
    3670. 

  3670. 	if (memcmp(CharBuf, "II", 2) == 0) {
    3671. 

  3671. 		ImageInfo->motorola_intel = 0;
    3672. 

  3672. 	} else if (memcmp(CharBuf, "MM", 2) == 0) {
    3673. 

  3673. 		ImageInfo->motorola_intel = 1;
    3674. 

  3674. 	} else {
    3675. 

  3675. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Invalid TIFF alignment marker");
    3676. 

  3676. 		return;
    3677. 

  3677. 	}
    3678. 

  3678. 

  3679. 	/* Check the next two values for correctness. */
    3680. 

  3680. 	if (length < 8) {
    3681. 

  3681. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Invalid TIFF start (1)");
    3682. 

  3682. 		return;
    3683. 

  3683. 	}
    3684. 

  3684. 	exif_value_2a = php_ifd_get16u(CharBuf+2, ImageInfo->motorola_intel);
    3685. 

  3685. 	offset_of_ifd = php_ifd_get32u(CharBuf+4, ImageInfo->motorola_intel);
    3686. 

  3686. 	if (exif_value_2a != 0x2a || offset_of_ifd < 0x08) {
    3687. 

  3687. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Invalid TIFF start (1)");
    3688. 

  3688. 		return;
    3689. 

  3689. 	}
    3690. 

  3690. 	if (offset_of_ifd > length) {
    3691. 

  3691. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Invalid IFD start");
    3692. 

  3692. 		return;
    3693. 

  3693. 	}
    3694. 

  3694. 

  3695. 	ImageInfo->sections_found |= FOUND_IFD0;
    3696. 

  3696. 	/* First directory starts at offset 8. Offsets starts at 0. */
    3697. 

  3697. 	exif_offset_info_init(&info, CharBuf, CharBuf, length/*-14*/);
    3698. 

  3698. 	exif_process_IFD_in_JPEG(ImageInfo, CharBuf+offset_of_ifd, &info, displacement, SECTION_IFD0, 0);
    3699. 

  3699. 

  3700. #ifdef EXIF_DEBUG
    3701. 

  3701. 	exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Process TIFF in JPEG done");
    3702. 

  3702. #endif
    3703. 

  3703. 

  3704. 	/* Compute the CCD width, in millimeters. */
    3705. 

  3705. 	if (ImageInfo->FocalplaneXRes != 0) {
    3706. 

  3706. 		ImageInfo->CCDWidth = (float)(ImageInfo->ExifImageWidth * ImageInfo->FocalplaneUnits / ImageInfo->FocalplaneXRes);
    3707. 

  3707. 	}
    3708. 

  3708. }
    3709. 

  3709. /* }}} */
    3710. 

  3710. 

  3711. /* {{{ exif_process_APP1
    3712. 

  3712.    Process an JPEG APP1 block marker
    3713. 

  3713.    Describes all the drivel that most digital cameras include...
    3714. 

  3714. */
    3715. 

  3715. static void exif_process_APP1(image_info_type *ImageInfo, char *CharBuf, size_t length, size_t displacement)
    3716. 

  3716. {
    3717. 

  3717. 	/* Check the APP1 for Exif Identifier Code */
    3718. 

  3718. 	static const uchar ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
    3719. 

  3719. 	if (length <= 8 || memcmp(CharBuf+2, ExifHeader, 6)) {
    3720. 

  3720. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Incorrect APP1 Exif Identifier Code");
    3721. 

  3721. 		return;
    3722. 

  3722. 	}
    3723. 

  3723. 	exif_process_TIFF_in_JPEG(ImageInfo, CharBuf + 8, length - 8, displacement+8);
    3724. 

  3724. #ifdef EXIF_DEBUG
    3725. 

  3725. 	exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Process APP1/EXIF done");
    3726. 

  3726. #endif
    3727. 

  3727. }
    3728. 

  3728. /* }}} */
    3729. 

  3729. 

  3730. /* {{{ exif_process_APP12
    3731. 

  3731.    Process an JPEG APP12 block marker used by OLYMPUS
    3732. 

  3732. */
    3733. 

  3733. static void exif_process_APP12(image_info_type *ImageInfo, char *buffer, size_t length)
    3734. 

  3734. {
    3735. 

  3735. 	size_t l1, l2=0;
    3736. 

  3736. 

  3737. 	if ((l1 = php_strnlen(buffer+2, length-2)) > 0) {
    3738. 

  3738. 		exif_iif_add_tag(ImageInfo, SECTION_APP12, "Company", TAG_NONE, TAG_FMT_STRING, l1, buffer+2, l1);
    3739. 

  3739. 		if (length > 2+l1+1) {
    3740. 

  3740. 			l2 = php_strnlen(buffer+2+l1+1, length-2-l1-1);
    3741. 

  3741. 			exif_iif_add_tag(ImageInfo, SECTION_APP12, "Info", TAG_NONE, TAG_FMT_STRING, l2, buffer+2+l1+1, l2);
    3742. 

  3742. 		}
    3743. 

  3743. 	}
    3744. 

  3744. #ifdef EXIF_DEBUG
    3745. 

  3745. 	exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Process section APP12 with l1=%d, l2=%d done", l1, l2);
    3746. 

  3746. #endif
    3747. 

  3747. }
    3748. 

  3748. /* }}} */
    3749. 

  3749. 

  3750. /* {{{ exif_scan_JPEG_header
    3751. 

  3751.  * Parse the marker stream until SOS or EOI is seen; */
    3752. 

  3752. static int exif_scan_JPEG_header(image_info_type *ImageInfo)
    3753. 

  3753. {
    3754. 

  3754. 	int section, sn;
    3755. 

  3755. 	int marker = 0, last_marker = M_PSEUDO, comment_correction=1;
    3756. 

  3756. 	unsigned int ll, lh;
    3757. 

  3757. 	uchar *Data;
    3758. 

  3758. 	size_t fpos, size, got, itemlen;
    3759. 

  3759. 	jpeg_sof_info sof_info;
    3760. 

  3760. 

  3761. 	for(section=0;;section++) {
    3762. 

  3762. #ifdef EXIF_DEBUG
    3763. 

  3763. 		fpos = php_stream_tell(ImageInfo->infile);
    3764. 

  3764. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Needing section %d @ 0x%08X", ImageInfo->file.count, fpos);
    3765. 

  3765. #endif
    3766. 

  3766. 

  3767. 		/* get marker byte, swallowing possible padding                           */
    3768. 

  3768. 		/* some software does not count the length bytes of COM section           */
    3769. 

  3769. 		/* one company doing so is very much involved in JPEG... so we accept too */
    3770. 

  3770. 		if (last_marker==M_COM && comment_correction) {
    3771. 

  3771. 			comment_correction = 2;
    3772. 

  3772. 		}
    3773. 

  3773. 		do {
    3774. 

  3774. 			if ((marker = php_stream_getc(ImageInfo->infile)) == EOF) {
    3775. 

  3775. 				EXIF_ERRLOG_CORRUPT(ImageInfo)
    3776. 

  3776. 				return FALSE;
    3777. 

  3777. 			}
    3778. 

  3778. 			if (last_marker==M_COM && comment_correction>0) {
    3779. 

  3779. 				if (marker!=0xFF) {
    3780. 

  3780. 					marker = 0xff;
    3781. 

  3781. 					comment_correction--;
    3782. 

  3782. 				} else  {
    3783. 

  3783. 					last_marker = M_PSEUDO; /* stop skipping 0 for M_COM */
    3784. 

  3784. 				}
    3785. 

  3785. 			}
    3786. 

  3786. 		} while (marker == 0xff);
    3787. 

  3787. 		if (last_marker==M_COM && !comment_correction) {
    3788. 

  3788. 			exif_error_docref("exif_read_data#error_mcom" EXIFERR_CC, ImageInfo, E_NOTICE, "Image has corrupt COM section: some software set wrong length information");
    3789. 

  3789. 		}
    3790. 

  3790. 		if (last_marker==M_COM && comment_correction)
    3791. 

  3791. 			return M_EOI; /* ah illegal: char after COM section not 0xFF */
    3792. 

  3792. 

  3793. 		fpos = php_stream_tell(ImageInfo->infile);
    3794. 

  3794. 

  3795. 		if (marker == 0xff) {
    3796. 

  3796. 			/* 0xff is legal padding, but if we get that many, something's wrong. */
    3797. 

  3797. 			exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "To many padding bytes");
    3798. 

  3798. 			return FALSE;
    3799. 

  3799. 		}
    3800. 

  3800. 

  3801. 		/* Read the length of the section. */
    3802. 

  3802. 		if ((lh = php_stream_getc(ImageInfo->infile)) == (unsigned int)EOF) {
    3803. 

  3803. 			EXIF_ERRLOG_CORRUPT(ImageInfo)
    3804. 

  3804. 			return FALSE;
    3805. 

  3805. 		}
    3806. 

  3806. 		if ((ll = php_stream_getc(ImageInfo->infile)) == (unsigned int)EOF) {
    3807. 

  3807. 			EXIF_ERRLOG_CORRUPT(ImageInfo)
    3808. 

  3808. 			return FALSE;
    3809. 

  3809. 		}
    3810. 

  3810. 

  3811. 		itemlen = (lh << 8) | ll;
    3812. 

  3812. 

  3813. 		if (itemlen < 2) {
    3814. 

  3814. #ifdef EXIF_DEBUG
    3815. 

  3815. 			exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "%s, Section length: 0x%02X%02X", EXIF_ERROR_CORRUPT, lh, ll);
    3816. 

  3816. #else
    3817. 

  3817. 			EXIF_ERRLOG_CORRUPT(ImageInfo)
    3818. 

  3818. #endif
    3819. 

  3819. 			return FALSE;
    3820. 

  3820. 		}
    3821. 

  3821. 

  3822. 		sn = exif_file_sections_add(ImageInfo, marker, itemlen, NULL);
    3823. 

  3823. 		Data = ImageInfo->file.list[sn].data;
    3824. 

  3824. 

  3825. 		/* Store first two pre-read bytes. */
    3826. 

  3826. 		Data[0] = (uchar)lh;
    3827. 

  3827. 		Data[1] = (uchar)ll;
    3828. 

  3828. 

  3829. 		got = php_stream_read(ImageInfo->infile, (char*)(Data+2), itemlen-2); /* Read the whole section. */
    3830. 

  3830. 		if (got != itemlen-2) {
    3831. 

  3831. 			exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Error reading from file: got=x%04X(=%d) != itemlen-2=x%04X(=%d)", got, got, itemlen-2, itemlen-2);
    3832. 

  3832. 			return FALSE;
    3833. 

  3833. 		}
    3834. 

  3834. 

  3835. #ifdef EXIF_DEBUG
    3836. 

  3836. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Process section(x%02X=%s) @ x%04X + x%04X(=%d)", marker, exif_get_markername(marker), fpos, itemlen, itemlen);
    3837. 

  3837. #endif
    3838. 

  3838. 		switch(marker) {
    3839. 

  3839. 			case M_SOS:   /* stop before hitting compressed data  */
    3840. 

  3840. 				/* If reading entire image is requested, read the rest of the data. */
    3841. 

  3841. 				if (ImageInfo->read_all) {
    3842. 

  3842. 					/* Determine how much file is left. */
    3843. 

  3843. 					fpos = php_stream_tell(ImageInfo->infile);
    3844. 

  3844. 					size = ImageInfo->FileSize - fpos;
    3845. 

  3845. 					sn = exif_file_sections_add(ImageInfo, M_PSEUDO, size, NULL);
    3846. 

  3846. 					Data = ImageInfo->file.list[sn].data;
    3847. 

  3847. 					got = php_stream_read(ImageInfo->infile, (char*)Data, size);
    3848. 

  3848. 					if (got != size) {
    3849. 

  3849. 						EXIF_ERRLOG_FILEEOF(ImageInfo)
    3850. 

  3850. 						return FALSE;
    3851. 

  3851. 					}
    3852. 

  3852. 				}
    3853. 

  3853. 				return TRUE;
    3854. 

  3854. 

  3855. 			case M_EOI:   /* in case it's a tables-only JPEG stream */
    3856. 

  3856. 				exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "No image in jpeg!");
    3857. 

  3857. 				return (ImageInfo->sections_found&(~FOUND_COMPUTED)) ? TRUE : FALSE;
    3858. 

  3858. 

  3859. 			case M_COM: /* Comment section */
    3860. 

  3860. 				exif_process_COM(ImageInfo, (char *)Data, itemlen);
    3861. 

  3861. 				break;
    3862. 

  3862. 

  3863. 			case M_EXIF:
    3864. 

  3864. 				if (!(ImageInfo->sections_found&FOUND_IFD0)) {
    3865. 

  3865. 					/*ImageInfo->sections_found |= FOUND_EXIF;*/
    3866. 

  3866. 					/* Seen files from some 'U-lead' software with Vivitar scanner
    3867. 

  3867. 					   that uses marker 31 later in the file (no clue what for!) */
    3868. 

  3868. 					exif_process_APP1(ImageInfo, (char *)Data, itemlen, fpos);
    3869. 

  3869. 				}
    3870. 

  3870. 				break;
    3871. 

  3871. 

  3872. 			case M_APP12:
    3873. 

  3873. 				exif_process_APP12(ImageInfo, (char *)Data, itemlen);
    3874. 

  3874. 				break;
    3875. 

  3875. 

  3876. 

  3877. 			case M_SOF0:
    3878. 

  3878. 			case M_SOF1:
    3879. 

  3879. 			case M_SOF2:
    3880. 

  3880. 			case M_SOF3:
    3881. 

  3881. 			case M_SOF5:
    3882. 

  3882. 			case M_SOF6:
    3883. 

  3883. 			case M_SOF7:
    3884. 

  3884. 			case M_SOF9:
    3885. 

  3885. 			case M_SOF10:
    3886. 

  3886. 			case M_SOF11:
    3887. 

  3887. 			case M_SOF13:
    3888. 

  3888. 			case M_SOF14:
    3889. 

  3889. 			case M_SOF15:
    3890. 

  3890. 				if ((itemlen - 2) < 6) {
    3891. 

  3891. 					return FALSE;
    3892. 

  3892. 				}
    3893. 

  3893. 

  3894. 				exif_process_SOFn(Data, marker, &sof_info);
    3895. 

  3895. 				ImageInfo->Width  = sof_info.width;
    3896. 

  3896. 				ImageInfo->Height = sof_info.height;
    3897. 

  3897. 				if (sof_info.num_components == 3) {
    3898. 

  3898. 					ImageInfo->IsColor = 1;
    3899. 

  3899. 				} else {
    3900. 

  3900. 					ImageInfo->IsColor = 0;
    3901. 

  3901. 				}
    3902. 

  3902. 				break;
    3903. 

  3903. 			default:
    3904. 

  3904. 				/* skip any other marker silently. */
    3905. 

  3905. 				break;
    3906. 

  3906. 		}
    3907. 

  3907. 

  3908. 		/* keep track of last marker */
    3909. 

  3909. 		last_marker = marker;
    3910. 

  3910. 	}
    3911. 

  3911. #ifdef EXIF_DEBUG
    3912. 

  3912. 	exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Done");
    3913. 

  3913. #endif
    3914. 

  3914. 	return TRUE;
    3915. 

  3915. }
    3916. 

  3916. /* }}} */
    3917. 

  3917. 

  3918. /* {{{ exif_scan_thumbnail
    3919. 

  3919.  * scan JPEG in thumbnail (memory) */
    3920. 

  3920. static int exif_scan_thumbnail(image_info_type *ImageInfo)
    3921. 

  3921. {
    3922. 

  3922. 	uchar           c, *data = (uchar*)ImageInfo->Thumbnail.data;
    3923. 

  3923. 	int             n, marker;
    3924. 

  3924. 	size_t          length=2, pos=0;
    3925. 

  3925. 	jpeg_sof_info   sof_info;
    3926. 

  3926. 

  3927. 	if (!data || ImageInfo->Thumbnail.size < 4) {
    3928. 

  3928. 		return FALSE; /* nothing to do here */
    3929. 

  3929. 	}
    3930. 

  3930. 	if (memcmp(data, "\xFF\xD8\xFF", 3)) {
    3931. 

  3931. 		if (!ImageInfo->Thumbnail.width && !ImageInfo->Thumbnail.height) {
    3932. 

  3932. 			exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Thumbnail is not a JPEG image");
    3933. 

  3933. 		}
    3934. 

  3934. 		return FALSE;
    3935. 

  3935. 	}
    3936. 

  3936. 	for (;;) {
    3937. 

  3937. 		pos += length;
    3938. 

  3938. 		if (pos>=ImageInfo->Thumbnail.size)
    3939. 

  3939. 			return FALSE;
    3940. 

  3940. 		c = data[pos++];
    3941. 

  3941. 		if (pos>=ImageInfo->Thumbnail.size)
    3942. 

  3942. 			return FALSE;
    3943. 

  3943. 		if (c != 0xFF) {
    3944. 

  3944. 			return FALSE;
    3945. 

  3945. 		}
    3946. 

  3946. 		n = 8;
    3947. 

  3947. 		while ((c = data[pos++]) == 0xFF && n--) {
    3948. 

  3948. 			if (pos+3>=ImageInfo->Thumbnail.size)
    3949. 

  3949. 				return FALSE;
    3950. 

  3950. 			/* +3 = pos++ of next check when reaching marker + 2 bytes for length */
    3951. 

  3951. 		}
    3952. 

  3952. 		if (c == 0xFF)
    3953. 

  3953. 			return FALSE;
    3954. 

  3954. 		marker = c;
    3955. 

  3955. 		if (pos>=ImageInfo->Thumbnail.size)
    3956. 

  3956. 			return FALSE;
    3957. 

  3957. 		length = php_jpg_get16(data+pos);
    3958. 

  3958. 		if (length > ImageInfo->Thumbnail.size || pos >= ImageInfo->Thumbnail.size - length) {
    3959. 

  3959. 			return FALSE;
    3960. 

  3960. 		}
    3961. 

  3961. #ifdef EXIF_DEBUG
    3962. 

  3962. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Thumbnail: process section(x%02X=%s) @ x%04X + x%04X", marker, exif_get_markername(marker), pos, length);
    3963. 

  3963. #endif
    3964. 

  3964. 		switch (marker) {
    3965. 

  3965. 			case M_SOF0:
    3966. 

  3966. 			case M_SOF1:
    3967. 

  3967. 			case M_SOF2:
    3968. 

  3968. 			case M_SOF3:
    3969. 

  3969. 			case M_SOF5:
    3970. 

  3970. 			case M_SOF6:
    3971. 

  3971. 			case M_SOF7:
    3972. 

  3972. 			case M_SOF9:
    3973. 

  3973. 			case M_SOF10:
    3974. 

  3974. 			case M_SOF11:
    3975. 

  3975. 			case M_SOF13:
    3976. 

  3976. 			case M_SOF14:
    3977. 

  3977. 			case M_SOF15:
    3978. 

  3978. 				/* handle SOFn block */
    3979. 

  3979. 				if (length < 8 || ImageInfo->Thumbnail.size - 8 < pos) {
    3980. 

  3980. 					/* exif_process_SOFn needs 8 bytes */
    3981. 

  3981. 					return FALSE;
    3982. 

  3982. 				}
    3983. 

  3983. 				exif_process_SOFn(data+pos, marker, &sof_info);
    3984. 

  3984. 				ImageInfo->Thumbnail.height   = sof_info.height;
    3985. 

  3985. 				ImageInfo->Thumbnail.width    = sof_info.width;
    3986. 

  3986. #ifdef EXIF_DEBUG
    3987. 

  3987. 				exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Thumbnail: size: %d * %d", sof_info.width, sof_info.height);
    3988. 

  3988. #endif
    3989. 

  3989. 				return TRUE;
    3990. 

  3990. 

  3991. 			case M_SOS:
    3992. 

  3992. 			case M_EOI:
    3993. 

  3993. 				exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Could not compute size of thumbnail");
    3994. 

  3994. 				return FALSE;
    3995. 

  3995. 				break;
    3996. 

  3996. 

  3997. 			default:
    3998. 

  3998. 				/* just skip */
    3999. 

  3999. 				break;
    4000. 

  4000. 		}
    4001. 

  4001. 	}
    4002. 

  4002. 

  4003. 	exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Could not compute size of thumbnail");
    4004. 

  4004. 	return FALSE;
    4005. 

  4005. }
    4006. 

  4006. /* }}} */
    4007. 

  4007. 

  4008. /* {{{ exif_process_IFD_in_TIFF
    4009. 

  4009.  * Parse the TIFF header; */
    4010. 

  4010. static int exif_process_IFD_in_TIFF(image_info_type *ImageInfo, size_t dir_offset, int section_index)
    4011. 

  4011. {
    4012. 

  4012. 	int i, sn, num_entries, sub_section_index = 0;
    4013. 

  4013. 	unsigned char *dir_entry;
    4014. 

  4014. 	size_t ifd_size, dir_size, entry_offset, next_offset, entry_length, entry_value=0, fgot;
    4015. 

  4015. 	int entry_tag , entry_type;
    4016. 

  4016. 	tag_table_type tag_table = exif_get_tag_table(section_index);
    4017. 

  4017. 

  4018. 	if (ImageInfo->ifd_nesting_level > MAX_IFD_NESTING_LEVEL) {
    4019. 

  4019. 		return FALSE;
    4020. 

  4020. 	}
    4021. 

  4021. 

  4022. 	if (ImageInfo->FileSize >= 2 && ImageInfo->FileSize - 2 >= dir_offset) {
    4023. 

  4023. 		sn = exif_file_sections_add(ImageInfo, M_PSEUDO, 2, NULL);
    4024. 

  4024. #ifdef EXIF_DEBUG
    4025. 

  4025. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Read from TIFF: filesize(x%04X), IFD dir(x%04X + x%04X)", ImageInfo->FileSize, dir_offset, 2);
    4026. 

  4026. #endif
    4027. 

  4027. 		php_stream_seek(ImageInfo->infile, dir_offset, SEEK_SET); /* we do not know the order of sections */
    4028. 

  4028. 		php_stream_read(ImageInfo->infile, (char*)ImageInfo->file.list[sn].data, 2);
    4029. 

  4029. 		num_entries = php_ifd_get16u(ImageInfo->file.list[sn].data, ImageInfo->motorola_intel);
    4030. 

  4030. 		dir_size = 2/*num dir entries*/ +12/*length of entry*/*(size_t)num_entries +4/* offset to next ifd (points to thumbnail or NULL)*/;
    4031. 

  4031. 		if (ImageInfo->FileSize >= dir_size && ImageInfo->FileSize - dir_size >= dir_offset) {
    4032. 

  4032. #ifdef EXIF_DEBUG
    4033. 

  4033. 			exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Read from TIFF: filesize(x%04X), IFD dir(x%04X + x%04X), IFD entries(%d)", ImageInfo->FileSize, dir_offset+2, dir_size-2, num_entries);
    4034. 

  4034. #endif
    4035. 

  4035. 			if (exif_file_sections_realloc(ImageInfo, sn, dir_size)) {
    4036. 

  4036. 				return FALSE;
    4037. 

  4037. 			}
    4038. 

  4038. 			php_stream_read(ImageInfo->infile, (char*)(ImageInfo->file.list[sn].data+2), dir_size-2);
    4039. 

  4039. 			next_offset = php_ifd_get32u(ImageInfo->file.list[sn].data + dir_size - 4, ImageInfo->motorola_intel);
    4040. 

  4040. #ifdef EXIF_DEBUG
    4041. 

  4041. 			exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Read from TIFF done, next offset x%04X", next_offset);
    4042. 

  4042. #endif
    4043. 

  4043. 			/* now we have the directory we can look how long it should be */
    4044. 

  4044. 			ifd_size = dir_size;
    4045. 

  4045. 			for(i=0;i<num_entries;i++) {
    4046. 

  4046. 				dir_entry 	 = ImageInfo->file.list[sn].data+2+i*12;
    4047. 

  4047. 				entry_tag    = php_ifd_get16u(dir_entry+0, ImageInfo->motorola_intel);
    4048. 

  4048. 				entry_type   = php_ifd_get16u(dir_entry+2, ImageInfo->motorola_intel);
    4049. 

  4049. 				if (entry_type > NUM_FORMATS) {
    4050. 

  4050. 					exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Read from TIFF: tag(0x%04X,%12s): Illegal format code 0x%04X, switching to BYTE", entry_tag, exif_get_tagname_debug(entry_tag, tag_table), entry_type);
    4051. 

  4051. 					/* Since this is repeated in exif_process_IFD_TAG make it a notice here */
    4052. 

  4052. 					/* and make it a warning in the exif_process_IFD_TAG which is called    */
    4053. 

  4053. 					/* elsewhere. */
    4054. 

  4054. 					entry_type = TAG_FMT_BYTE;
    4055. 

  4055. 					/*The next line would break the image on writeback: */
    4056. 

  4056. 					/* php_ifd_set16u(dir_entry+2, entry_type, ImageInfo->motorola_intel);*/
    4057. 

  4057. 				}
    4058. 

  4058. 				entry_length = php_ifd_get32u(dir_entry+4, ImageInfo->motorola_intel) * php_tiff_bytes_per_format[entry_type];
    4059. 

  4059. 				if (entry_length <= 4) {
    4060. 

  4060. 					switch(entry_type) {
    4061. 

  4061. 						case TAG_FMT_USHORT:
    4062. 

  4062. 							entry_value  = php_ifd_get16u(dir_entry+8, ImageInfo->motorola_intel);
    4063. 

  4063. 							break;
    4064. 

  4064. 						case TAG_FMT_SSHORT:
    4065. 

  4065. 							entry_value  = php_ifd_get16s(dir_entry+8, ImageInfo->motorola_intel);
    4066. 

  4066. 							break;
    4067. 

  4067. 						case TAG_FMT_ULONG:
    4068. 

  4068. 							entry_value  = php_ifd_get32u(dir_entry+8, ImageInfo->motorola_intel);
    4069. 

  4069. 							break;
    4070. 

  4070. 						case TAG_FMT_SLONG:
    4071. 

  4071. 							entry_value  = php_ifd_get32s(dir_entry+8, ImageInfo->motorola_intel);
    4072. 

  4072. 							break;
    4073. 

  4073. 					}
    4074. 

  4074. 					switch(entry_tag) {
    4075. 

  4075. 						case TAG_IMAGEWIDTH:
    4076. 

  4076. 						case TAG_COMP_IMAGE_WIDTH:
    4077. 

  4077. 							ImageInfo->Width  = entry_value;
    4078. 

  4078. 							break;
    4079. 

  4079. 						case TAG_IMAGEHEIGHT:
    4080. 

  4080. 						case TAG_COMP_IMAGE_HEIGHT:
    4081. 

  4081. 							ImageInfo->Height = entry_value;
    4082. 

  4082. 							break;
    4083. 

  4083. 						case TAG_PHOTOMETRIC_INTERPRETATION:
    4084. 

  4084. 							switch (entry_value) {
    4085. 

  4085. 								case PMI_BLACK_IS_ZERO:
    4086. 

  4086. 								case PMI_WHITE_IS_ZERO:
    4087. 

  4087. 								case PMI_TRANSPARENCY_MASK:
    4088. 

  4088. 									ImageInfo->IsColor = 0;
    4089. 

  4089. 									break;
    4090. 

  4090. 								case PMI_RGB:
    4091. 

  4091. 								case PMI_PALETTE_COLOR:
    4092. 

  4092. 								case PMI_SEPARATED:
    4093. 

  4093. 								case PMI_YCBCR:
    4094. 

  4094. 								case PMI_CIELAB:
    4095. 

  4095. 									ImageInfo->IsColor = 1;
    4096. 

  4096. 									break;
    4097. 

  4097. 							}
    4098. 

  4098. 							break;
    4099. 

  4099. 					}
    4100. 

  4100. 				} else {
    4101. 

  4101. 					entry_offset = php_ifd_get32u(dir_entry+8, ImageInfo->motorola_intel);
    4102. 

  4102. 					/* if entry needs expading ifd cache and entry is at end of current ifd cache. */
    4103. 

  4103. 					/* otherwise there may be huge holes between two entries */
    4104. 

  4104. 					if (entry_offset + entry_length > dir_offset + ifd_size
    4105. 

  4105. 					  && entry_offset == dir_offset + ifd_size) {
    4106. 

  4106. 						ifd_size = entry_offset + entry_length - dir_offset;
    4107. 

  4107. #ifdef EXIF_DEBUG
    4108. 

  4108. 						exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Resize struct: x%04X + x%04X - x%04X = x%04X", entry_offset, entry_length, dir_offset, ifd_size);
    4109. 

  4109. #endif
    4110. 

  4110. 					}
    4111. 

  4111. 				}
    4112. 

  4112. 			}
    4113. 

  4113. 			if (ImageInfo->FileSize >= ImageInfo->file.list[sn].size && ImageInfo->FileSize - ImageInfo->file.list[sn].size >= dir_offset) {
    4114. 

  4114. 				if (ifd_size > dir_size) {
    4115. 

  4115. 					if (ImageInfo->FileSize < ifd_size || dir_offset > ImageInfo->FileSize - ifd_size) {
    4116. 

  4116. 						exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Error in TIFF: filesize(x%04X) less than size of IFD(x%04X + x%04X)", ImageInfo->FileSize, dir_offset, ifd_size);
    4117. 

  4117. 						return FALSE;
    4118. 

  4118. 					}
    4119. 

  4119. 					if (exif_file_sections_realloc(ImageInfo, sn, ifd_size)) {
    4120. 

  4120. 						return FALSE;
    4121. 

  4121. 					}
    4122. 

  4122. 					/* read values not stored in directory itself */
    4123. 

  4123. #ifdef EXIF_DEBUG
    4124. 

  4124. 					exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Read from TIFF: filesize(x%04X), IFD(x%04X + x%04X)", ImageInfo->FileSize, dir_offset, ifd_size);
    4125. 

  4125. #endif
    4126. 

  4126. 					php_stream_read(ImageInfo->infile, (char*)(ImageInfo->file.list[sn].data+dir_size), ifd_size-dir_size);
    4127. 

  4127. #ifdef EXIF_DEBUG
    4128. 

  4128. 					exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Read from TIFF, done");
    4129. 

  4129. #endif
    4130. 

  4130. 				}
    4131. 

  4131. 				/* now process the tags */
    4132. 

  4132. 				for(i=0;i<num_entries;i++) {
    4133. 

  4133. 					dir_entry 	 = ImageInfo->file.list[sn].data+2+i*12;
    4134. 

  4134. 					entry_tag    = php_ifd_get16u(dir_entry+0, ImageInfo->motorola_intel);
    4135. 

  4135. 					entry_type   = php_ifd_get16u(dir_entry+2, ImageInfo->motorola_intel);
    4136. 

  4136. 					/*entry_length = php_ifd_get32u(dir_entry+4, ImageInfo->motorola_intel);*/
    4137. 

  4137. 					if (entry_tag == TAG_EXIF_IFD_POINTER ||
    4138. 

  4138. 						entry_tag == TAG_INTEROP_IFD_POINTER ||
    4139. 

  4139. 						entry_tag == TAG_GPS_IFD_POINTER ||
    4140. 

  4140. 						entry_tag == TAG_SUB_IFD
    4141. 

  4141. 					) {
    4142. 

  4142. 						switch(entry_tag) {
    4143. 

  4143. 							case TAG_EXIF_IFD_POINTER:
    4144. 

  4144. 								ImageInfo->sections_found |= FOUND_EXIF;
    4145. 

  4145. 								sub_section_index = SECTION_EXIF;
    4146. 

  4146. 								break;
    4147. 

  4147. 							case TAG_GPS_IFD_POINTER:
    4148. 

  4148. 								ImageInfo->sections_found |= FOUND_GPS;
    4149. 

  4149. 								sub_section_index = SECTION_GPS;
    4150. 

  4150. 								break;
    4151. 

  4151. 							case TAG_INTEROP_IFD_POINTER:
    4152. 

  4152. 								ImageInfo->sections_found |= FOUND_INTEROP;
    4153. 

  4153. 								sub_section_index = SECTION_INTEROP;
    4154. 

  4154. 								break;
    4155. 

  4155. 							case TAG_SUB_IFD:
    4156. 

  4156. 								ImageInfo->sections_found |= FOUND_THUMBNAIL;
    4157. 

  4157. 								sub_section_index = SECTION_THUMBNAIL;
    4158. 

  4158. 								break;
    4159. 

  4159. 						}
    4160. 

  4160. 						entry_offset = php_ifd_get32u(dir_entry+8, ImageInfo->motorola_intel);
    4161. 

  4161. #ifdef EXIF_DEBUG
    4162. 

  4162. 						exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Next IFD: %s @x%04X", exif_get_sectionname(sub_section_index), entry_offset);
    4163. 

  4163. #endif
    4164. 

  4164. 						ImageInfo->ifd_nesting_level++;
    4165. 

  4165. 						exif_process_IFD_in_TIFF(ImageInfo, entry_offset, sub_section_index);
    4166. 

  4166. 						if (section_index!=SECTION_THUMBNAIL && entry_tag==TAG_SUB_IFD) {
    4167. 

  4167. 							if (ImageInfo->Thumbnail.filetype != IMAGE_FILETYPE_UNKNOWN
    4168. 

  4168. 							&&  ImageInfo->Thumbnail.size
    4169. 

  4169. 							&&  ImageInfo->Thumbnail.offset
    4170. 

  4170. 							&&  ImageInfo->read_thumbnail
    4171. 

  4171. 							) {
    4172. 

  4172. #ifdef EXIF_DEBUG
    4173. 

  4173. 								exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "%s THUMBNAIL @0x%04X + 0x%04X", ImageInfo->Thumbnail.data ? "Ignore" : "Read", ImageInfo->Thumbnail.offset, ImageInfo->Thumbnail.size);
    4174. 

  4174. #endif
    4175. 

  4175. 								if (!ImageInfo->Thumbnail.data) {
    4176. 

  4176. 									ImageInfo->Thumbnail.data = safe_emalloc(ImageInfo->Thumbnail.size, 1, 0);
    4177. 

  4177. 									php_stream_seek(ImageInfo->infile, ImageInfo->Thumbnail.offset, SEEK_SET);
    4178. 

  4178. 									fgot = php_stream_read(ImageInfo->infile, ImageInfo->Thumbnail.data, ImageInfo->Thumbnail.size);
    4179. 

  4179. 									if (fgot != ImageInfo->Thumbnail.size) {
    4180. 

  4180. 										EXIF_ERRLOG_THUMBEOF(ImageInfo)
    4181. 

  4181. 										efree(ImageInfo->Thumbnail.data);
    4182. 

  4182. 

  4183. 										ImageInfo->Thumbnail.data = NULL;
    4184. 

  4184. 									} else {
    4185. 

  4185. 										exif_thumbnail_build(ImageInfo);
    4186. 

  4186. 									}
    4187. 

  4187. 								}
    4188. 

  4188. 							}
    4189. 

  4189. 						}
    4190. 

  4190. #ifdef EXIF_DEBUG
    4191. 

  4191. 						exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Next IFD: %s done", exif_get_sectionname(sub_section_index));
    4192. 

  4192. #endif
    4193. 

  4193. 					} else {
    4194. 

  4194. 						exif_offset_info info;
    4195. 

  4195. 						exif_offset_info_init(&info,
    4196. 

  4196. 							(char *) (ImageInfo->file.list[sn].data - dir_offset),
    4197. 

  4197. 							(char *) ImageInfo->file.list[sn].data, ifd_size);
    4198. 

  4198. 						if (!exif_process_IFD_TAG(ImageInfo, (char*)dir_entry, &info,
    4199. 

  4199. 												  0, section_index, 0, tag_table)) {
    4200. 

  4200. 							return FALSE;
    4201. 

  4201. 						}
    4202. 

  4202. 					}
    4203. 

  4203. 				}
    4204. 

  4204. 				/* If we had a thumbnail in a SUB_IFD we have ANOTHER image in NEXT IFD */
    4205. 

  4205. 				if (next_offset && section_index != SECTION_THUMBNAIL) {
    4206. 

  4206. 					/* this should be a thumbnail IFD */
    4207. 

  4207. 					/* the thumbnail itself is stored at Tag=StripOffsets */
    4208. 

  4208. #ifdef EXIF_DEBUG
    4209. 

  4209. 					exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Read next IFD (THUMBNAIL) at x%04X", next_offset);
    4210. 

  4210. #endif
    4211. 

  4211. 					ImageInfo->ifd_nesting_level++;
    4212. 

  4212. 					exif_process_IFD_in_TIFF(ImageInfo, next_offset, SECTION_THUMBNAIL);
    4213. 

  4213. #ifdef EXIF_DEBUG
    4214. 

  4214. 					exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "%s THUMBNAIL @0x%04X + 0x%04X", ImageInfo->Thumbnail.data ? "Ignore" : "Read", ImageInfo->Thumbnail.offset, ImageInfo->Thumbnail.size);
    4215. 

  4215. #endif
    4216. 

  4216. 					if (!ImageInfo->Thumbnail.data && ImageInfo->Thumbnail.offset && ImageInfo->Thumbnail.size && ImageInfo->read_thumbnail) {
    4217. 

  4217. 						ImageInfo->Thumbnail.data = safe_emalloc(ImageInfo->Thumbnail.size, 1, 0);
    4218. 

  4218. 						php_stream_seek(ImageInfo->infile, ImageInfo->Thumbnail.offset, SEEK_SET);
    4219. 

  4219. 						fgot = php_stream_read(ImageInfo->infile, ImageInfo->Thumbnail.data, ImageInfo->Thumbnail.size);
    4220. 

  4220. 						if (fgot != ImageInfo->Thumbnail.size) {
    4221. 

  4221. 							EXIF_ERRLOG_THUMBEOF(ImageInfo)
    4222. 

  4222. 							efree(ImageInfo->Thumbnail.data);
    4223. 

  4223. 							ImageInfo->Thumbnail.data = NULL;
    4224. 

  4224. 						} else {
    4225. 

  4225. 							exif_thumbnail_build(ImageInfo);
    4226. 

  4226. 						}
    4227. 

  4227. 					}
    4228. 

  4228. #ifdef EXIF_DEBUG
    4229. 

  4229. 					exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "Read next IFD (THUMBNAIL) done");
    4230. 

  4230. #endif
    4231. 

  4231. 				}
    4232. 

  4232. 				return TRUE;
    4233. 

  4233. 			} else {
    4234. 

  4234. 				exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Error in TIFF: filesize(x%04X) less than size of IFD(x%04X)", ImageInfo->FileSize, dir_offset+ImageInfo->file.list[sn].size);
    4235. 

  4235. 				return FALSE;
    4236. 

  4236. 			}
    4237. 

  4237. 		} else {
    4238. 

  4238. 			exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Error in TIFF: filesize(x%04X) less than size of IFD dir(x%04X)", ImageInfo->FileSize, dir_offset+dir_size);
    4239. 

  4239. 			return FALSE;
    4240. 

  4240. 		}
    4241. 

  4241. 	} else {
    4242. 

  4242. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Error in TIFF: filesize(x%04X) less than start of IFD dir(x%04X)", ImageInfo->FileSize, dir_offset+2);
    4243. 

  4243. 		return FALSE;
    4244. 

  4244. 	}
    4245. 

  4245. }
    4246. 

  4246. /* }}} */
    4247. 

  4247. 

  4248. /* {{{ exif_scan_FILE_header
    4249. 

  4249.  * Parse the marker stream until SOS or EOI is seen; */
    4250. 

  4250. static int exif_scan_FILE_header(image_info_type *ImageInfo)
    4251. 

  4251. {
    4252. 

  4252. 	unsigned char file_header[8];
    4253. 

  4253. 	int ret = FALSE;
    4254. 

  4254. 

  4255. 	ImageInfo->FileType = IMAGE_FILETYPE_UNKNOWN;
    4256. 

  4256. 

  4257. 	if (ImageInfo->FileSize >= 2) {
    4258. 

  4258. 		php_stream_seek(ImageInfo->infile, 0, SEEK_SET);
    4259. 

  4259. 		if (php_stream_read(ImageInfo->infile, (char*)file_header, 2) != 2) {
    4260. 

  4260. 			return FALSE;
    4261. 

  4261. 		}
    4262. 

  4262. 		if ((file_header[0]==0xff) && (file_header[1]==M_SOI)) {
    4263. 

  4263. 			ImageInfo->FileType = IMAGE_FILETYPE_JPEG;
    4264. 

  4264. 			if (exif_scan_JPEG_header(ImageInfo)) {
    4265. 

  4265. 				ret = TRUE;
    4266. 

  4266. 			} else {
    4267. 

  4267. 				exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Invalid JPEG file");
    4268. 

  4268. 			}
    4269. 

  4269. 		} else if (ImageInfo->FileSize >= 8) {
    4270. 

  4270. 			if (php_stream_read(ImageInfo->infile, (char*)(file_header+2), 6) != 6) {
    4271. 

  4271. 				return FALSE;
    4272. 

  4272. 			}
    4273. 

  4273. 			if (!memcmp(file_header, "II\x2A\x00", 4)) {
    4274. 

  4274. 				ImageInfo->FileType = IMAGE_FILETYPE_TIFF_II;
    4275. 

  4275. 				ImageInfo->motorola_intel = 0;
    4276. 

  4276. #ifdef EXIF_DEBUG
    4277. 

  4277. 				exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "File has TIFF/II format");
    4278. 

  4278. #endif
    4279. 

  4279. 				ImageInfo->sections_found |= FOUND_IFD0;
    4280. 

  4280. 				if (exif_process_IFD_in_TIFF(ImageInfo,
    4281. 

  4281. 											 php_ifd_get32u(file_header + 4, ImageInfo->motorola_intel),
    4282. 

  4282. 											 SECTION_IFD0)) {
    4283. 

  4283. 					ret = TRUE;
    4284. 

  4284. 				} else {
    4285. 

  4285. 					exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Invalid TIFF file");
    4286. 

  4286. 				}
    4287. 

  4287. 			} else if (!memcmp(file_header, "MM\x00\x2a", 4)) {
    4288. 

  4288. 				ImageInfo->FileType = IMAGE_FILETYPE_TIFF_MM;
    4289. 

  4289. 				ImageInfo->motorola_intel = 1;
    4290. 

  4290. #ifdef EXIF_DEBUG
    4291. 

  4291. 				exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_NOTICE, "File has TIFF/MM format");
    4292. 

  4292. #endif
    4293. 

  4293. 				ImageInfo->sections_found |= FOUND_IFD0;
    4294. 

  4294. 				if (exif_process_IFD_in_TIFF(ImageInfo,
    4295. 

  4295. 											 php_ifd_get32u(file_header + 4, ImageInfo->motorola_intel),
    4296. 

  4296. 											 SECTION_IFD0)) {
    4297. 

  4297. 					ret = TRUE;
    4298. 

  4298. 				} else {
    4299. 

  4299. 					exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Invalid TIFF file");
    4300. 

  4300. 				}
    4301. 

  4301. 			} else {
    4302. 

  4302. 				exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "File not supported");
    4303. 

  4303. 				return FALSE;
    4304. 

  4304. 			}
    4305. 

  4305. 		}
    4306. 

  4306. 	} else {
    4307. 

  4307. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "File too small (%d)", ImageInfo->FileSize);
    4308. 

  4308. 	}
    4309. 

  4309. 	return ret;
    4310. 

  4310. }
    4311. 

  4311. /* }}} */
    4312. 

  4312. 

  4313. /* {{{ exif_discard_imageinfo
    4314. 

  4314.    Discard data scanned by exif_read_file.
    4315. 

  4315. */
    4316. 

  4316. static int exif_discard_imageinfo(image_info_type *ImageInfo)
    4317. 

  4317. {
    4318. 

  4318. 	int i;
    4319. 

  4319. 

  4320. 	EFREE_IF(ImageInfo->FileName);
    4321. 

  4321. 	EFREE_IF(ImageInfo->UserComment);
    4322. 

  4322. 	EFREE_IF(ImageInfo->UserCommentEncoding);
    4323. 

  4323. 	EFREE_IF(ImageInfo->Copyright);
    4324. 

  4324. 	EFREE_IF(ImageInfo->CopyrightPhotographer);
    4325. 

  4325. 	EFREE_IF(ImageInfo->CopyrightEditor);
    4326. 

  4326. 	EFREE_IF(ImageInfo->Thumbnail.data);
    4327. 

  4327. 	EFREE_IF(ImageInfo->encode_unicode);
    4328. 

  4328. 	EFREE_IF(ImageInfo->decode_unicode_be);
    4329. 

  4329. 	EFREE_IF(ImageInfo->decode_unicode_le);
    4330. 

  4330. 	EFREE_IF(ImageInfo->encode_jis);
    4331. 

  4331. 	EFREE_IF(ImageInfo->decode_jis_be);
    4332. 

  4332. 	EFREE_IF(ImageInfo->decode_jis_le);
    4333. 

  4333. 	EFREE_IF(ImageInfo->make);
    4334. 

  4334. 	EFREE_IF(ImageInfo->model);
    4335. 

  4335. 	for (i=0; i<ImageInfo->xp_fields.count; i++) {
    4336. 

  4336. 		EFREE_IF(ImageInfo->xp_fields.list[i].value);
    4337. 

  4337. 	}
    4338. 

  4338. 	EFREE_IF(ImageInfo->xp_fields.list);
    4339. 

  4339. 	for (i=0; i<SECTION_COUNT; i++) {
    4340. 

  4340. 		exif_iif_free(ImageInfo, i);
    4341. 

  4341. 	}
    4342. 

  4342. 	exif_file_sections_free(ImageInfo);
    4343. 

  4343. 	memset(ImageInfo, 0, sizeof(*ImageInfo));
    4344. 

  4344. 	return TRUE;
    4345. 

  4345. }
    4346. 

  4346. /* }}} */
    4347. 

  4347. 

  4348. /* {{{ exif_read_from_impl
    4349. 

  4349.  */
    4350. 

  4350. static int exif_read_from_impl(image_info_type *ImageInfo, php_stream *stream, int read_thumbnail, int read_all)
    4351. 

  4351. {
    4352. 

  4352. 	int ret;
    4353. 

  4353. 	zend_stat_t st;
    4354. 

  4354. 

  4355. 	/* Start with an empty image information structure. */
    4356. 

  4356. 	memset(ImageInfo, 0, sizeof(*ImageInfo));
    4357. 

  4357. 

  4358. 	ImageInfo->motorola_intel	= -1; /* flag as unknown */
    4359. 

  4359. 	ImageInfo->infile			= stream;
    4360. 

  4360. 	ImageInfo->FileName			= NULL;
    4361. 

  4361. 

  4362. 	if (php_stream_is(ImageInfo->infile, PHP_STREAM_IS_STDIO)) {
    4363. 

  4363. 		if (VCWD_STAT(stream->orig_path, &st) >= 0) {
    4364. 

  4364. 			zend_string *base;
    4365. 

  4365. 			if ((st.st_mode & S_IFMT) != S_IFREG) {
    4366. 

  4366. 				exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Not a file");
    4367. 

  4367. 				ImageInfo->infile = NULL;
    4368. 

  4368. 				return FALSE;
    4369. 

  4369. 			}
    4370. 

  4370. 

  4371. 			/* Store file name */
    4372. 

  4372. 			base = php_basename(stream->orig_path, strlen(stream->orig_path), NULL, 0);
    4373. 

  4373. 			ImageInfo->FileName = estrndup(ZSTR_VAL(base), ZSTR_LEN(base));
    4374. 

  4374. 

  4375. 			zend_string_release_ex(base, 0);
    4376. 

  4376. 

  4377. 			/* Store file date/time. */
    4378. 

  4378. 			ImageInfo->FileDateTime = st.st_mtime;
    4379. 

  4379. 			ImageInfo->FileSize = st.st_size;
    4380. 

  4380. 		}
    4381. 

  4381. 	} else {
    4382. 

  4382. 		if (!ImageInfo->FileSize) {
    4383. 

  4383. 			php_stream_seek(ImageInfo->infile, 0, SEEK_END);
    4384. 

  4384. 			ImageInfo->FileSize = php_stream_tell(ImageInfo->infile);
    4385. 

  4385. 			php_stream_seek(ImageInfo->infile, 0, SEEK_SET);
    4386. 

  4386. 		}
    4387. 

  4387. 	}
    4388. 

  4388. 

  4389. 	ImageInfo->read_thumbnail		= read_thumbnail;
    4390. 

  4390. 	ImageInfo->read_all				= read_all;
    4391. 

  4391. 	ImageInfo->Thumbnail.filetype	= IMAGE_FILETYPE_UNKNOWN;
    4392. 

  4392. 

  4393. 	ImageInfo->encode_unicode		= estrdup(EXIF_G(encode_unicode));
    4394. 

  4394. 	ImageInfo->decode_unicode_be	= estrdup(EXIF_G(decode_unicode_be));
    4395. 

  4395. 	ImageInfo->decode_unicode_le	= estrdup(EXIF_G(decode_unicode_le));
    4396. 

  4396. 	ImageInfo->encode_jis			= estrdup(EXIF_G(encode_jis));
    4397. 

  4397. 	ImageInfo->decode_jis_be	 	= estrdup(EXIF_G(decode_jis_be));
    4398. 

  4398. 	ImageInfo->decode_jis_le		= estrdup(EXIF_G(decode_jis_le));
    4399. 

  4399. 

  4400. 

  4401. 	ImageInfo->ifd_nesting_level = 0;
    4402. 

  4402. 	ImageInfo->num_errors = 0;
    4403. 

  4403. 

  4404. 	/* Scan the headers */
    4405. 

  4405. 	ret = exif_scan_FILE_header(ImageInfo);
    4406. 

  4406. 

  4407. 	return ret;
    4408. 

  4408. }
    4409. 

  4409. /* }}} */
    4410. 

  4410. 

  4411. /* {{{ exif_read_from_stream
    4412. 

  4412.  */
    4413. 

  4413. static int exif_read_from_stream(image_info_type *ImageInfo, php_stream *stream, int read_thumbnail, int read_all)
    4414. 

  4414. {
    4415. 

  4415. 	int ret;
    4416. 

  4416. 	off_t old_pos = php_stream_tell(stream);
    4417. 

  4417. 

  4418. 	if (old_pos) {
    4419. 

  4419. 		php_stream_seek(stream, 0, SEEK_SET);
    4420. 

  4420. 	}
    4421. 

  4421. 

  4422. 	ret = exif_read_from_impl(ImageInfo, stream, read_thumbnail, read_all);
    4423. 

  4423. 

  4424. 	if (old_pos) {
    4425. 

  4425. 		php_stream_seek(stream, old_pos, SEEK_SET);
    4426. 

  4426. 	}
    4427. 

  4427. 

  4428. 	return ret;
    4429. 

  4429. }
    4430. 

  4430. /* }}} */
    4431. 

  4431. 

  4432. /* {{{ exif_read_from_file
    4433. 

  4433.  */
    4434. 

  4434. static int exif_read_from_file(image_info_type *ImageInfo, char *FileName, int read_thumbnail, int read_all)
    4435. 

  4435. {
    4436. 

  4436. 	int ret;
    4437. 

  4437. 	php_stream *stream;
    4438. 

  4438. 

  4439. 	stream = php_stream_open_wrapper(FileName, "rb", STREAM_MUST_SEEK | IGNORE_PATH, NULL);
    4440. 

  4440. 

  4441. 	if (!stream) {
    4442. 

  4442. 		memset(&ImageInfo, 0, sizeof(ImageInfo));
    4443. 

  4443. 

  4444. 		exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Unable to open file");
    4445. 

  4445. 

  4446. 		return FALSE;
    4447. 

  4447. 	}
    4448. 

  4448. 

  4449. 	ret = exif_read_from_stream(ImageInfo, stream, read_thumbnail, read_all);
    4450. 

  4450. 

  4451. 	php_stream_close(stream);
    4452. 

  4452. 

  4453. 	return ret;
    4454. 

  4454. }
    4455. 

  4455. /* }}} */
    4456. 

  4456. 

  4457. /* {{{ proto array exif_read_data(mixed stream [, string sections_needed [, bool sub_arrays[, bool read_thumbnail]]])
    4458. 

  4458.    Reads header data from an image and optionally reads the internal thumbnails */
    4459. 

  4459. PHP_FUNCTION(exif_read_data)
    4460. 

  4460. {
    4461. 

  4461. 	zend_string *z_sections_needed = NULL;
    4462. 

  4462. 	zend_bool sub_arrays = 0, read_thumbnail = 0, read_all = 0;
    4463. 

  4463. 	zval *stream;
    4464. 

  4464. 	int i, ret, sections_needed = 0;
    4465. 

  4465. 	image_info_type ImageInfo;
    4466. 

  4466. 	char tmp[64], *sections_str, *s;
    4467. 

  4467. 

  4468. 	/* Parse arguments */
    4469. 

  4469. 	ZEND_PARSE_PARAMETERS_START(1, 4)
    4470. 

  4470. 		Z_PARAM_ZVAL(stream)
    4471. 

  4471. 		Z_PARAM_OPTIONAL
    4472. 

  4472. 		Z_PARAM_STR_EX(z_sections_needed, 1, 0)
    4473. 

  4473. 		Z_PARAM_BOOL(sub_arrays)
    4474. 

  4474. 		Z_PARAM_BOOL(read_thumbnail)
    4475. 

  4475. 	ZEND_PARSE_PARAMETERS_END();
    4476. 

  4476. 

  4477. 	memset(&ImageInfo, 0, sizeof(ImageInfo));
    4478. 

  4478. 

  4479. 	if (z_sections_needed) {
    4480. 

  4480. 		spprintf(&sections_str, 0, ",%s,", ZSTR_VAL(z_sections_needed));
    4481. 

  4481. 		/* sections_str DOES start with , and SPACES are NOT allowed in names */
    4482. 

  4482. 		s = sections_str;
    4483. 

  4483. 		while (*++s) {
    4484. 

  4484. 			if (*s == ' ') {
    4485. 

  4485. 				*s = ',';
    4486. 

  4486. 			}
    4487. 

  4487. 		}
    4488. 

  4488. 

  4489. 		for (i = 0; i < SECTION_COUNT; i++) {
    4490. 

  4490. 			snprintf(tmp, sizeof(tmp), ",%s,", exif_get_sectionname(i));
    4491. 

  4491. 			if (strstr(sections_str, tmp)) {
    4492. 

  4492. 				sections_needed |= 1<<i;
    4493. 

  4493. 			}
    4494. 

  4494. 		}
    4495. 

  4495. 		EFREE_IF(sections_str);
    4496. 

  4496. 		/* now see what we need */
    4497. 

  4497. #ifdef EXIF_DEBUG
    4498. 

  4498. 		sections_str = exif_get_sectionlist(sections_needed);
    4499. 

  4499. 		if (!sections_str) {
    4500. 

  4500. 			RETURN_FALSE;
    4501. 

  4501. 		}
    4502. 

  4502. 		exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Sections needed: %s", sections_str[0] ? sections_str : "None");
    4503. 

  4503. 		EFREE_IF(sections_str);
    4504. 

  4504. #endif
    4505. 

  4505. 	}
    4506. 

  4506. 

  4507. 	if (Z_TYPE_P(stream) == IS_RESOURCE) {
    4508. 

  4508. 		php_stream *p_stream = NULL;
    4509. 

  4509. 

  4510. 		php_stream_from_res(p_stream, Z_RES_P(stream));
    4511. 

  4511. 

  4512. 		ret = exif_read_from_stream(&ImageInfo, p_stream, read_thumbnail, read_all);
    4513. 

  4513. 	} else {
    4514. 

  4514. 		if (!try_convert_to_string(stream)) {
    4515. 

  4515. 			RETURN_THROWS();
    4516. 

  4516. 		}
    4517. 

  4517. 

  4518. 		if (!Z_STRLEN_P(stream)) {
    4519. 

  4519. 			exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_WARNING, "Filename cannot be empty");
    4520. 

  4520. 

  4521. 			RETURN_FALSE;
    4522. 

  4522. 		}
    4523. 

  4523. 

  4524. 		ret = exif_read_from_file(&ImageInfo, Z_STRVAL_P(stream), read_thumbnail, read_all);
    4525. 

  4525. 	}
    4526. 

  4526. 

  4527. 	sections_str = exif_get_sectionlist(ImageInfo.sections_found);
    4528. 

  4528. 

  4529. #ifdef EXIF_DEBUG
    4530. 

  4530. 	if (sections_str) {
    4531. 

  4531. 		exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Sections found: %s", sections_str[0] ? sections_str : "None");
    4532. 

  4532. 	}
    4533. 

  4533. #endif
    4534. 

  4534. 

  4535. 	ImageInfo.sections_found |= FOUND_COMPUTED|FOUND_FILE;/* do not inform about in debug*/
    4536. 

  4536. 

  4537. 	if (ret == FALSE || (sections_needed && !(sections_needed&ImageInfo.sections_found))) {
    4538. 

  4538. 		/* array_init must be checked at last! otherwise the array must be freed if a later test fails. */
    4539. 

  4539. 		exif_discard_imageinfo(&ImageInfo);
    4540. 

  4540. 	   	EFREE_IF(sections_str);
    4541. 

  4541. 		RETURN_FALSE;
    4542. 

  4542. 	}
    4543. 

  4543. 

  4544. 	array_init(return_value);
    4545. 

  4545. 

  4546. #ifdef EXIF_DEBUG
    4547. 

  4547. 	exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Generate section FILE");
    4548. 

  4548. #endif
    4549. 

  4549. 

  4550. 	/* now we can add our information */
    4551. 

  4551. 	exif_iif_add_str(&ImageInfo, SECTION_FILE, "FileName",      ImageInfo.FileName);
    4552. 

  4552. 	exif_iif_add_int(&ImageInfo, SECTION_FILE, "FileDateTime",  ImageInfo.FileDateTime);
    4553. 

  4553. 	exif_iif_add_int(&ImageInfo, SECTION_FILE, "FileSize",      ImageInfo.FileSize);
    4554. 

  4554. 	exif_iif_add_int(&ImageInfo, SECTION_FILE, "FileType",      ImageInfo.FileType);
    4555. 

  4555. 	exif_iif_add_str(&ImageInfo, SECTION_FILE, "MimeType",      (char*)php_image_type_to_mime_type(ImageInfo.FileType));
    4556. 

  4556. 	exif_iif_add_str(&ImageInfo, SECTION_FILE, "SectionsFound", sections_str ? sections_str : "NONE");
    4557. 

  4557. 

  4558. #ifdef EXIF_DEBUG
    4559. 

  4559. 	exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Generate section COMPUTED");
    4560. 

  4560. #endif
    4561. 

  4561. 

  4562. 	if (ImageInfo.Width>0 &&  ImageInfo.Height>0) {
    4563. 

  4563. 		exif_iif_add_fmt(&ImageInfo, SECTION_COMPUTED, "html"   , "width=\"%d\" height=\"%d\"", ImageInfo.Width, ImageInfo.Height);
    4564. 

  4564. 		exif_iif_add_int(&ImageInfo, SECTION_COMPUTED, "Height", ImageInfo.Height);
    4565. 

  4565. 		exif_iif_add_int(&ImageInfo, SECTION_COMPUTED, "Width",  ImageInfo.Width);
    4566. 

  4566. 	}
    4567. 

  4567. 	exif_iif_add_int(&ImageInfo, SECTION_COMPUTED, "IsColor", ImageInfo.IsColor);
    4568. 

  4568. 	if (ImageInfo.motorola_intel != -1) {
    4569. 

  4569. 		exif_iif_add_int(&ImageInfo, SECTION_COMPUTED, "ByteOrderMotorola", ImageInfo.motorola_intel);
    4570. 

  4570. 	}
    4571. 

  4571. 	if (ImageInfo.FocalLength) {
    4572. 

  4572. 		exif_iif_add_fmt(&ImageInfo, SECTION_COMPUTED, "FocalLength", "%4.1Fmm", ImageInfo.FocalLength);
    4573. 

  4573. 		if(ImageInfo.CCDWidth) {
    4574. 

  4574. 			exif_iif_add_fmt(&ImageInfo, SECTION_COMPUTED, "35mmFocalLength", "%dmm", (int)(ImageInfo.FocalLength/ImageInfo.CCDWidth*35+0.5));
    4575. 

  4575. 		}
    4576. 

  4576. 	}
    4577. 

  4577. 	if(ImageInfo.CCDWidth) {
    4578. 

  4578. 		exif_iif_add_fmt(&ImageInfo, SECTION_COMPUTED, "CCDWidth", "%dmm", (int)ImageInfo.CCDWidth);
    4579. 

  4579. 	}
    4580. 

  4580. 	if(ImageInfo.ExposureTime>0) {
    4581. 

  4581. 		float recip_exposure_time = 0.5f + 1.0f/ImageInfo.ExposureTime;
    4582. 

  4582. 		if (ImageInfo.ExposureTime <= 0.5 && recip_exposure_time < INT_MAX) {
    4583. 

  4583. 			exif_iif_add_fmt(&ImageInfo, SECTION_COMPUTED, "ExposureTime", "%0.3F s (1/%d)", ImageInfo.ExposureTime, (int) recip_exposure_time);
    4584. 

  4584. 		} else {
    4585. 

  4585. 			exif_iif_add_fmt(&ImageInfo, SECTION_COMPUTED, "ExposureTime", "%0.3F s", ImageInfo.ExposureTime);
    4586. 

  4586. 		}
    4587. 

  4587. 	}
    4588. 

  4588. 	if(ImageInfo.ApertureFNumber) {
    4589. 

  4589. 		exif_iif_add_fmt(&ImageInfo, SECTION_COMPUTED, "ApertureFNumber", "f/%.1F", ImageInfo.ApertureFNumber);
    4590. 

  4590. 	}
    4591. 

  4591. 	if(ImageInfo.Distance) {
    4592. 

  4592. 		if(ImageInfo.Distance<0) {
    4593. 

  4593. 			exif_iif_add_str(&ImageInfo, SECTION_COMPUTED, "FocusDistance", "Infinite");
    4594. 

  4594. 		} else {
    4595. 

  4595. 			exif_iif_add_fmt(&ImageInfo, SECTION_COMPUTED, "FocusDistance", "%0.2Fm", ImageInfo.Distance);
    4596. 

  4596. 		}
    4597. 

  4597. 	}
    4598. 

  4598. 	if (ImageInfo.UserComment) {
    4599. 

  4599. 		exif_iif_add_buffer(&ImageInfo, SECTION_COMPUTED, "UserComment", ImageInfo.UserCommentLength, ImageInfo.UserComment);
    4600. 

  4600. 		if (ImageInfo.UserCommentEncoding && strlen(ImageInfo.UserCommentEncoding)) {
    4601. 

  4601. 			exif_iif_add_str(&ImageInfo, SECTION_COMPUTED, "UserCommentEncoding", ImageInfo.UserCommentEncoding);
    4602. 

  4602. 		}
    4603. 

  4603. 	}
    4604. 

  4604. 

  4605. 	exif_iif_add_str(&ImageInfo, SECTION_COMPUTED, "Copyright",              ImageInfo.Copyright);
    4606. 

  4606. 	exif_iif_add_str(&ImageInfo, SECTION_COMPUTED, "Copyright.Photographer", ImageInfo.CopyrightPhotographer);
    4607. 

  4607. 	exif_iif_add_str(&ImageInfo, SECTION_COMPUTED, "Copyright.Editor",       ImageInfo.CopyrightEditor);
    4608. 

  4608. 

  4609. 	for (i=0; i<ImageInfo.xp_fields.count; i++) {
    4610. 

  4610. 		exif_iif_add_str(&ImageInfo, SECTION_WINXP, exif_get_tagname_debug(ImageInfo.xp_fields.list[i].tag, exif_get_tag_table(SECTION_WINXP)), ImageInfo.xp_fields.list[i].value);
    4611. 

  4611. 	}
    4612. 

  4612. 	if (ImageInfo.Thumbnail.size) {
    4613. 

  4613. 		if (read_thumbnail) {
    4614. 

  4614. 			/* not exif_iif_add_str : this is a buffer */
    4615. 

  4615. 			exif_iif_add_tag(&ImageInfo, SECTION_THUMBNAIL, "THUMBNAIL", TAG_NONE, TAG_FMT_UNDEFINED, ImageInfo.Thumbnail.size, ImageInfo.Thumbnail.data, ImageInfo.Thumbnail.size);
    4616. 

  4616. 		}
    4617. 

  4617. 		if (!ImageInfo.Thumbnail.width || !ImageInfo.Thumbnail.height) {
    4618. 

  4618. 			/* try to evaluate if thumbnail data is present */
    4619. 

  4619. 			exif_scan_thumbnail(&ImageInfo);
    4620. 

  4620. 		}
    4621. 

  4621. 		exif_iif_add_int(&ImageInfo, SECTION_COMPUTED, "Thumbnail.FileType", ImageInfo.Thumbnail.filetype);
    4622. 

  4622. 		exif_iif_add_str(&ImageInfo, SECTION_COMPUTED, "Thumbnail.MimeType", (char*)php_image_type_to_mime_type(ImageInfo.Thumbnail.filetype));
    4623. 

  4623. 	}
    4624. 

  4624. 	if (ImageInfo.Thumbnail.width && ImageInfo.Thumbnail.height) {
    4625. 

  4625. 		exif_iif_add_int(&ImageInfo, SECTION_COMPUTED, "Thumbnail.Height", ImageInfo.Thumbnail.height);
    4626. 

  4626. 		exif_iif_add_int(&ImageInfo, SECTION_COMPUTED, "Thumbnail.Width",  ImageInfo.Thumbnail.width);
    4627. 

  4627. 	}
    4628. 

  4628.    	EFREE_IF(sections_str);
    4629. 

  4629. 

  4630. #ifdef EXIF_DEBUG
    4631. 

  4631. 	exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Adding image infos");
    4632. 

  4632. #endif
    4633. 

  4633. 

  4634. 	add_assoc_image_info(return_value, sub_arrays, &ImageInfo, SECTION_FILE      );
    4635. 

  4635. 	add_assoc_image_info(return_value, 1,          &ImageInfo, SECTION_COMPUTED  );
    4636. 

  4636. 	add_assoc_image_info(return_value, sub_arrays, &ImageInfo, SECTION_ANY_TAG   );
    4637. 

  4637. 	add_assoc_image_info(return_value, sub_arrays, &ImageInfo, SECTION_IFD0      );
    4638. 

  4638. 	add_assoc_image_info(return_value, 1,          &ImageInfo, SECTION_THUMBNAIL );
    4639. 

  4639. 	add_assoc_image_info(return_value, 1,          &ImageInfo, SECTION_COMMENT   );
    4640. 

  4640. 	add_assoc_image_info(return_value, sub_arrays, &ImageInfo, SECTION_EXIF      );
    4641. 

  4641. 	add_assoc_image_info(return_value, sub_arrays, &ImageInfo, SECTION_GPS       );
    4642. 

  4642. 	add_assoc_image_info(return_value, sub_arrays, &ImageInfo, SECTION_INTEROP   );
    4643. 

  4643. 	add_assoc_image_info(return_value, sub_arrays, &ImageInfo, SECTION_FPIX      );
    4644. 

  4644. 	add_assoc_image_info(return_value, sub_arrays, &ImageInfo, SECTION_APP12     );
    4645. 

  4645. 	add_assoc_image_info(return_value, sub_arrays, &ImageInfo, SECTION_WINXP     );
    4646. 

  4646. 	add_assoc_image_info(return_value, sub_arrays, &ImageInfo, SECTION_MAKERNOTE );
    4647. 

  4647. 

  4648. #ifdef EXIF_DEBUG
    4649. 

  4649. 	exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Discarding info");
    4650. 

  4650. #endif
    4651. 

  4651. 

  4652. 	exif_discard_imageinfo(&ImageInfo);
    4653. 

  4653. 

  4654. #ifdef EXIF_DEBUG
    4655. 

  4655. 	php_error_docref1(NULL, (Z_TYPE_P(stream) == IS_RESOURCE ? "<stream>" : Z_STRVAL_P(stream)), E_NOTICE, "Done");
    4656. 

  4656. #endif
    4657. 

  4657. }
    4658. 

  4658. /* }}} */
    4659. 

  4659. 

  4660. /* {{{ proto string exif_thumbnail(string filename [, &width, &height [, &imagetype]])
    4661. 

  4661.    Reads the embedded thumbnail */
    4662. 

  4662. PHP_FUNCTION(exif_thumbnail)
    4663. 

  4663. {
    4664. 

  4664. 	int ret, arg_c = ZEND_NUM_ARGS();
    4665. 

  4665. 	image_info_type ImageInfo;
    4666. 

  4666. 	zval *stream;
    4667. 

  4667. 	zval *z_width = NULL, *z_height = NULL, *z_imagetype = NULL;
    4668. 

  4668. 

  4669. 	/* Parse arguments */
    4670. 

  4670. 	ZEND_PARSE_PARAMETERS_START(1, 4)
    4671. 

  4671. 		Z_PARAM_ZVAL(stream)
    4672. 

  4672. 		Z_PARAM_OPTIONAL
    4673. 

  4673. 		Z_PARAM_ZVAL(z_width)
    4674. 

  4674. 		Z_PARAM_ZVAL(z_height)
    4675. 

  4675. 		Z_PARAM_ZVAL(z_imagetype)
    4676. 

  4676. 	ZEND_PARSE_PARAMETERS_END();
    4677. 

  4677. 

  4678. 	memset(&ImageInfo, 0, sizeof(ImageInfo));
    4679. 

  4679. 

  4680. 	if (Z_TYPE_P(stream) == IS_RESOURCE) {
    4681. 

  4681. 		php_stream *p_stream = NULL;
    4682. 

  4682. 

  4683. 		php_stream_from_res(p_stream, Z_RES_P(stream));
    4684. 

  4684. 

  4685. 		ret = exif_read_from_stream(&ImageInfo, p_stream, 1, 0);
    4686. 

  4686. 	} else {
    4687. 

  4687. 		if (!try_convert_to_string(stream)) {
    4688. 

  4688. 			RETURN_THROWS();
    4689. 

  4689. 		}
    4690. 

  4690. 

  4691. 		if (!Z_STRLEN_P(stream)) {
    4692. 

  4692. 			exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_WARNING, "Filename cannot be empty");
    4693. 

  4693. 

  4694. 			RETURN_FALSE;
    4695. 

  4695. 		}
    4696. 

  4696. 

  4697. 		ret = exif_read_from_file(&ImageInfo, Z_STRVAL_P(stream), 1, 0);
    4698. 

  4698. 	}
    4699. 

  4699. 

  4700. 	if (ret == FALSE) {
    4701. 

  4701. 		exif_discard_imageinfo(&ImageInfo);
    4702. 

  4702. 		RETURN_FALSE;
    4703. 

  4703. 	}
    4704. 

  4704. 

  4705. #ifdef EXIF_DEBUG
    4706. 

  4706. 	exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Thumbnail data %d %d %d, %d x %d", ImageInfo.Thumbnail.data, ImageInfo.Thumbnail.size, ImageInfo.Thumbnail.filetype, ImageInfo.Thumbnail.width, ImageInfo.Thumbnail.height);
    4707. 

  4707. #endif
    4708. 

  4708. 	if (!ImageInfo.Thumbnail.data || !ImageInfo.Thumbnail.size) {
    4709. 

  4709. 		exif_discard_imageinfo(&ImageInfo);
    4710. 

  4710. 		RETURN_FALSE;
    4711. 

  4711. 	}
    4712. 

  4712. 

  4713. #ifdef EXIF_DEBUG
    4714. 

  4714. 	exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Returning thumbnail(%d)", ImageInfo.Thumbnail.size);
    4715. 

  4715. #endif
    4716. 

  4716. 

  4717. 	ZVAL_STRINGL(return_value, ImageInfo.Thumbnail.data, ImageInfo.Thumbnail.size);
    4718. 

  4718. 	if (arg_c >= 3) {
    4719. 

  4719. 		if (!ImageInfo.Thumbnail.width || !ImageInfo.Thumbnail.height) {
    4720. 

  4720. 			if (!exif_scan_thumbnail(&ImageInfo)) {
    4721. 

  4721. 				ImageInfo.Thumbnail.width = ImageInfo.Thumbnail.height = 0;
    4722. 

  4722. 			}
    4723. 

  4723. 		}
    4724. 

  4724. 		ZEND_TRY_ASSIGN_REF_LONG(z_width,  ImageInfo.Thumbnail.width);
    4725. 

  4725. 		ZEND_TRY_ASSIGN_REF_LONG(z_height, ImageInfo.Thumbnail.height);
    4726. 

  4726. 	}
    4727. 

  4727. 	if (arg_c >= 4)	{
    4728. 

  4728. 		ZEND_TRY_ASSIGN_REF_LONG(z_imagetype, ImageInfo.Thumbnail.filetype);
    4729. 

  4729. 	}
    4730. 

  4730. 

  4731. #ifdef EXIF_DEBUG
    4732. 

  4732. 	exif_error_docref(NULL EXIFERR_CC, &ImageInfo, E_NOTICE, "Discarding info");
    4733. 

  4733. #endif
    4734. 

  4734. 

  4735. 	exif_discard_imageinfo(&ImageInfo);
    4736. 

  4736. 

  4737. #ifdef EXIF_DEBUG
    4738. 

  4738. 	php_error_docref1(NULL, (Z_TYPE_P(stream) == IS_RESOURCE ? "<stream>" : Z_STRVAL_P(stream)), E_NOTICE, "Done");
    4739. 

  4739. #endif
    4740. 

  4740. }
    4741. 

  4741. /* }}} */
    4742. 

  4742. 

  4743. /* {{{ proto int exif_imagetype(string imagefile)
    4744. 

  4744.    Get the type of an image */
    4745. 

  4745. PHP_FUNCTION(exif_imagetype)
    4746. 

  4746. {
    4747. 

  4747. 	char *imagefile;
    4748. 

  4748. 	size_t imagefile_len;
    4749. 

  4749. 	php_stream * stream;
    4750. 

  4750.  	int itype = 0;
    4751. 

  4751. 

  4752. 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "p", &imagefile, &imagefile_len) == FAILURE) {
    4753. 

  4753. 		RETURN_THROWS();
    4754. 

  4754. 	}
    4755. 

  4755. 

  4756. 	stream = php_stream_open_wrapper(imagefile, "rb", IGNORE_PATH|REPORT_ERRORS, NULL);
    4757. 

  4757. 

  4758. 	if (stream == NULL) {
    4759. 

  4759. 		RETURN_FALSE;
    4760. 

  4760. 	}
    4761. 

  4761. 

  4762. 	itype = php_getimagetype(stream, imagefile, NULL);
    4763. 

  4763. 

  4764. 	php_stream_close(stream);
    4765. 

  4765. 

  4766. 	if (itype == IMAGE_FILETYPE_UNKNOWN) {
    4767. 

  4767. 		RETURN_FALSE;
    4768. 

  4768. 	} else {
    4769. 

  4769. 		ZVAL_LONG(return_value, itype);
    4770. 

  4770. 	}
    4771. 

  4771. }
    4772. 

  4772. /* }}} */
    4773. 

  4773. 

  4774. #endif
    4775. 

  4775.