Context Navigation

source: extensions/edit_gmaps/admin/include/EXIF.php @ 9412

Last change on this file since 9412 was 9412, checked in by cljosse, 14 years ago

File size: 119.2 KB

Line
1	<?php
2
3	/******************************************************************************
4	*
5	* Filename: EXIF.php
6	*
7	* Description: Provides functions for reading and writing EXIF Information
8	* to/from an APP1 segment of a JPEG file
9	* Unfortunately, because EXIF data may be distributed anywhere
10	* throughout an image file, rather than just being in one block,
11	* it is impossible to pass just a string containing only the EXIF
12	* information. Hence it is neccessary to be able to seek to
13	* any point in the file. This causes the HTTP and FTP wrappers
14	* not to work - i.e. the EXIF functions will only work with local
15	* files.
16	* To work on an internet file, copy it locally to start with:
17	*
18	* $newfilename = tempnam ( $dir, "tmpexif" );
19	* copy ( "http://whatever.com", $newfilename );
20	*
21	*
22	* Author: Evan Hunter
23	*
24	* Date: 30/7/2004
25	*
26	* Project: PHP JPEG Metadata Toolkit
27	*
28	* Revision: 1.11
29	*
30	* Changes: 1.00 -> 1.10 : added function get_EXIF_TIFF to allow extracting EXIF from a TIFF file
31	* 1.10 -> 1.11 : added functionality to allow decoding of XMP and Photoshop IRB information
32	* embedded within the EXIF data
33	* added checks for http and ftp wrappers, as these are not supported
34	* changed interpret_IFD to allow thumbnail links to work when
35	* toolkit is portable across directories
36	*
37	*
38	* URL: http://electronics.ozhiker.com
39	*
40	* Copyright: Copyright " . $auteur . " 2004
41	*
42	* License: This file is part of the PHP JPEG Metadata Toolkit.
43	*
44	* The PHP JPEG Metadata Toolkit is free software; you can
45	* redistribute it and/or modify it under the terms of the
46	* GNU General Public License as published by the Free Software
47	* Foundation; either version 2 of the License, or (at your
48	* option) any later version.
49	*
50	* The PHP JPEG Metadata Toolkit is distributed in the hope
51	* that it will be useful, but WITHOUT ANY WARRANTY; without
52	* even the implied warranty of MERCHANTABILITY or FITNESS
53	* FOR A PARTICULAR PURPOSE. See the GNU General Public License
54	* for more details.
55	*
56	* You should have received a copy of the GNU General Public
57	* License along with the PHP JPEG Metadata Toolkit; if not,
58	* write to the Free Software Foundation, Inc., 59 Temple
59	* Place, Suite 330, Boston, MA 02111-1307 USA
60	*
61	* If you require a different license for commercial or other
62	* purposes, please contact the author: evan@ozhiker.com
63	*
64	******************************************************************************/
65
66
67	// TODO : Thoroughly test the functions for writing EXIF segments
68	// TODO : Figure out a way to allow EXIF to function normally with HTTP and FTP wrappers
69	// TODO : Implement EXIF decoding of Device Setting Description field
70	// TODO : Implement EXIF decoding of SpatialFrequencyResponse field
71	// TODO : Implement EXIF decoding of OECF field
72	// TODO : Implement EXIF decoding of SubjectArea field
73	// TODO : Add a put_EXIF_TIFF function
74
75	/******************************************************************************
76	*
77	* Initialisation
78	*
79	******************************************************************************/
80
81
82	if ( !isset( $GLOBALS['HIDE_UNKNOWN_TAGS'] ) ) $GLOBALS['HIDE_UNKNOWN_TAGS']= FALSE;
83	if ( !isset( $GLOBALS['SHOW_BINARY_DATA_HEX'] ) ) $GLOBALS['SHOW_BINARY_DATA_HEX'] = FALSE;
84	if ( !isset( $GLOBALS['SHOW_BINARY_DATA_TEXT'] ) ) $GLOBALS['SHOW_BINARY_DATA_TEXT'] = FALSE;
85
86
87	include_once INCLUDE_PATH.'EXIF_Tags.php';
88	include_once INCLUDE_PATH.'EXIF_Makernote.php';
89	include_once INCLUDE_PATH.'PIM.php';
90	include_once INCLUDE_PATH.'Unicode.php';
91	include_once INCLUDE_PATH.'JPEG.php';
92	include_once INCLUDE_PATH.'IPTC.php';
93	//include_once INCLUDE_PATH.'Photoshop_IRB.php'; // Change: as of version 1.11 - Required for TIFF with embedded IRB
94	include_once INCLUDE_PATH.'XMP.php'; // Change: as of version 1.11 - Required for TIFF with embedded XMP
95	include_once INCLUDE_PATH.'pjmt_utils.php'; // Change: as of version 1.11 - Required for directory portability
96
97
98
99
100
101
102
103
104	/******************************************************************************
105	*
106	* Function: get_EXIF_JPEG
107	*
108	* Description: Retrieves information from a Exchangeable Image File Format (EXIF)
109	* APP1 segment and returns it in an array.
110	*
111	* Parameters: filename - the filename of the JPEG image to process
112	*
113	* Returns: OutputArray - Array of EXIF records
114	* FALSE - If an error occured in decoding
115	*
116	******************************************************************************/
117
118	function get_EXIF_JPEG( $filename )
119	{
120	// Change: Added as of version 1.11
121	// Check if a wrapper is being used - these are not currently supported (see notes at top of file)
122	if ( ( stristr ( $filename, "http://" ) != FALSE ) \|\| ( stristr ( $filename, "ftp://" ) != FALSE ) )
123	{
124	// A HTTP or FTP wrapper is being used - show a warning and abort
125	echo "HTTP and FTP wrappers are currently not supported with EXIF - See EXIF functionality documentation - a local file must be specified<br>";
126	echo "To work on an internet file, copy it locally to start with:<br><br>\n";
127	echo "\$newfilename = tempnam ( \$dir, \"tmpexif\" );<br>\n";
128	echo "copy ( \"http://whatever.com\", \$newfilename );<br><br>\n";
129	return FALSE;
130	}
131
132	// get the JPEG headers
133	$jpeg_header_data = get_jpeg_header_data( $filename );
134
135
136	// Flag that an EXIF segment has not been found yet
137	$EXIF_Location = -1;
138
139	//Cycle through the header segments
140	for( $i = 0; $i < count( $jpeg_header_data ); $i++ )
141	{
142	// If we find an APP1 header,
143	if ( strcmp ( $jpeg_header_data[$i]['SegName'], "APP1" ) == 0 )
144	{
145	// And if it has the EXIF label,
146	if ( ( strncmp ( $jpeg_header_data[$i]['SegData'], "Exif\x00\x00", 6) == 0 ) \|\|
147	( strncmp ( $jpeg_header_data[$i]['SegData'], "Exif\x00\xFF", 6) == 0 ) ) // For some reason, some files have a faulty EXIF name which has a 0xFF in it
148	{
149	// Save the location of the EXIF segment
150	$EXIF_Location = $i;
151	}
152	}
153
154	}
155
156	// Check if an EXIF segment was found
157	if ( $EXIF_Location == -1 )
158	{
159	// Couldn't find any EXIF block to decode
160	return FALSE;
161	}
162
163	$filehnd = @fopen($filename, 'rb');
164
165	// Check if the file opened successfully
166	if ( ! $filehnd )
167	{
168	// Could't open the file - exit
169	echo "<p>Could not open file $filename</p>\n";
170	return FALSE;
171	}
172
173	fseek( $filehnd, $jpeg_header_data[$EXIF_Location]['SegDataStart'] + 6 );
174
175	// Decode the Exif segment into an array and return it
176	$exif_data = process_TIFF_Header( $filehnd, "TIFF" );
177
178
179
180	// Close File
181	fclose($filehnd);
182	return $exif_data;
183	}
184
185	/******************************************************************************
186	* End of Function: get_EXIF_JPEG
187	******************************************************************************/
188
189
190
191	/******************************************************************************
192	*
193	* Function: put_EXIF_JPEG
194	*
195	* Description: Stores information into a Exchangeable Image File Format (EXIF)
196	* APP1 segment from an EXIF array.
197	*
198	* WARNING: Because the EXIF standard allows pointers to data
199	* outside the APP1 segment, if there are any such pointers in
200	* a makernote, this function will DAMAGE them since it will not
201	* be aware that there is an external pointer. This will often
202	* happen with Makernotes that include an embedded thumbnail.
203	* This damage could be prevented where makernotes can be decoded,
204	* but currently this is not implemented.
205	*
206	*
207	* Parameters: exif_data - The array of EXIF data to insert into the JPEG header
208	* jpeg_header_data - The JPEG header into which the EXIF data
209	* should be stored, as from get_jpeg_header_data
210	*
211	* Returns: jpeg_header_data - JPEG header array with the EXIF segment inserted
212	* FALSE - If an error occured
213	*
214	******************************************************************************/
215
216	function put_EXIF_JPEG( $exif_data, $jpeg_header_data )
217	{
218	// pack the EXIF data into its proper format for a JPEG file
219	$packed_data = get_TIFF_Packed_Data( $exif_data );
220	if ( $packed_data === FALSE )
221	{
222	return $jpeg_header_data;
223	}
224
225	$packed_data = "Exif\x00\x00$packed_data";
226
227	//Cycle through the header segments
228	for( $i = 0; $i < count( $jpeg_header_data ); $i++ )
229	{
230	// If we find an APP1 header,
231	if ( strcmp ( $jpeg_header_data[$i]['SegName'], "APP1" ) == 0 )
232	{
233	// And if it has the EXIF label,
234	if ( ( strncmp ( $jpeg_header_data[$i]['SegData'], "Exif\x00\x00", 6) == 0 ) \|\|
235	( strncmp ( $jpeg_header_data[$i]['SegData'], "Exif\x00\xFF", 6) == 0 ) ) // For some reason, some files have a faulty EXIF name which has a 0xFF in it
236	{
237	// Found a preexisting EXIF block - Replace it with the new one and return.
238	$jpeg_header_data[$i]['SegData'] = $packed_data;
239	return $jpeg_header_data;
240	}
241	}
242	}
243
244	// No preexisting segment segment found, insert a new one at the start of the header data.
245
246	// Determine highest position of an APP segment at or below APP3, so we can put the
247	// new APP3 at this position
248
249
250	$highest_APP = -1;
251
252	//Cycle through the header segments
253	for( $i = 0; $i < count( $jpeg_header_data ); $i++ )
254	{
255	// Check if we have found an APP segment at or below APP3,
256	if ( ( $jpeg_header_data[$i]['SegType'] >= 0xE0 ) && ( $jpeg_header_data[$i]['SegType'] <= 0xE3 ) )
257	{
258	// Found an APP segment at or below APP12
259	$highest_APP = $i;
260	}
261	}
262
263	// No preexisting EXIF block found, insert a new one at the start of the header data.
264	array_splice($jpeg_header_data, $highest_APP + 1 , 0, array( array( "SegType" => 0xE1,
265	"SegName" => "APP1",
266	"SegDesc" => $GLOBALS[ "JPEG_Segment_Descriptions" ][ 0xE1 ],
267	"SegData" => $packed_data ) ) );
268	return $jpeg_header_data;
269
270	}
271
272	/******************************************************************************
273	* End of Function: put_EXIF_JPEG
274	******************************************************************************/
275
276
277
278
279	/******************************************************************************
280	*
281	* Function: get_Meta_JPEG
282	*
283	* Description: Retrieves information from a Meta APP3 segment and returns it
284	* in an array. Uses information supplied by the
285	* get_jpeg_header_data function.
286	* The Meta segment has the same format as an EXIF segment, but
287	* uses different tags
288	*
289	* Parameters: filename - the filename of the JPEG image to process
290	*
291	* Returns: OutputArray - Array of Meta records
292	* FALSE - If an error occured in decoding
293	*
294	******************************************************************************/
295
296	function get_Meta_JPEG( $filename )
297	{
298	// Change: Added as of version 1.11
299	// Check if a wrapper is being used - these are not currently supported (see notes at top of file)
300	if ( ( stristr ( $filename, "http://" ) != FALSE ) \|\| ( stristr ( $filename, "ftp://" ) != FALSE ) )
301	{
302	// A HTTP or FTP wrapper is being used - show a warning and abort
303	echo "HTTP and FTP wrappers are currently not supported with Meta - See EXIF/Meta functionality documentation - a local file must be specified<br>";
304	echo "To work on an internet file, copy it locally to start with:<br><br>\n";
305	echo "\$newfilename = tempnam ( \$dir, \"tmpmeta\" );<br>\n";
306	echo "copy ( \"http://whatever.com\", \$newfilename );<br><br>\n";
307	return FALSE;
308	}
309
310	// get the JPEG headers
311	$jpeg_header_data = get_jpeg_header_data( $filename );
312
313
314	// Flag that an Meta segment has not been found yet
315	$Meta_Location = -1;
316
317	//Cycle through the header segments
318	for( $i = 0; $i < count( $jpeg_header_data ); $i++ )
319	{
320	// If we find an APP3 header,
321	if ( strcmp ( $jpeg_header_data[$i]['SegName'], "APP3" ) == 0 )
322	{
323	// And if it has the Meta label,
324	if ( ( strncmp ( $jpeg_header_data[$i]['SegData'], "Meta\x00\x00", 6) == 0 ) \|\|
325	( strncmp ( $jpeg_header_data[$i]['SegData'], "META\x00\x00", 6) == 0 ) )
326	{
327	// Save the location of the Meta segment
328	$Meta_Location = $i;
329	}
330	}
331	}
332
333	// Check if an EXIF segment was found
334	if ( $Meta_Location == -1 )
335	{
336	// Couldn't find any Meta block to decode
337	return FALSE;
338	}
339
340
341	$filehnd = @fopen($filename, 'rb');
342
343	// Check if the file opened successfully
344	if ( ! $filehnd )
345	{
346	// Could't open the file - exit
347	echo "<p>Could not open file $filename</p>\n";
348	return FALSE;
349	}
350
351	fseek( $filehnd, $jpeg_header_data[$Meta_Location]['SegDataStart'] + 6 );
352
353	// Decode the Meta segment into an array and return it
354	$meta = process_TIFF_Header( $filehnd, "Meta" );
355
356	// Close File
357	fclose($filehnd);
358
359	return $meta;
360	}
361
362	/******************************************************************************
363	* End of Function: get_Meta
364	******************************************************************************/
365
366
367
368
369
370
371
372	/******************************************************************************
373	*
374	* Function: put_Meta_JPEG
375	*
376	* Description: Stores information into a Meta APP3 segment from a Meta array.
377	*
378	*
379	* WARNING: Because the Meta (EXIF) standard allows pointers to data
380	* outside the APP1 segment, if there are any such pointers in
381	* a makernote, this function will DAMAGE them since it will not
382	* be aware that there is an external pointer. This will often
383	* happen with Makernotes that include an embedded thumbnail.
384	* This damage could be prevented where makernotes can be decoded,
385	* but currently this is not implemented.
386	*
387	*
388	* Parameters: meta_data - The array of Meta data to insert into the JPEG header
389	* jpeg_header_data - The JPEG header into which the Meta data
390	* should be stored, as from get_jpeg_header_data
391	*
392	* Returns: jpeg_header_data - JPEG header array with the Meta segment inserted
393	* FALSE - If an error occured
394	*
395	******************************************************************************/
396
397	function put_Meta_JPEG( $meta_data, $jpeg_header_data )
398	{
399	// pack the Meta data into its proper format for a JPEG file
400	$packed_data = get_TIFF_Packed_Data( $meta_data );
401	if ( $packed_data === FALSE )
402	{
403	return $jpeg_header_data;
404	}
405
406	$packed_data = "Meta\x00\x00$packed_data";
407
408	//Cycle through the header segments
409	for( $i = 0; $i < count( $jpeg_header_data ); $i++ )
410	{
411	// If we find an APP1 header,
412	if ( strcmp ( $jpeg_header_data[$i]['SegName'], "APP3" ) == 0 )
413	{
414	// And if it has the Meta label,
415	if ( ( strncmp ( $jpeg_header_data[$i]['SegData'], "Meta\x00\x00", 6) == 0 ) \|\|
416	( strncmp ( $jpeg_header_data[$i]['SegData'], "META\x00\x00", 6) == 0 ) )
417	{
418	// Found a preexisting Meta block - Replace it with the new one and return.
419	$jpeg_header_data[$i]['SegData'] = $packed_data;
420	return $jpeg_header_data;
421	}
422	}
423	}
424	// No preexisting segment segment found, insert a new one at the start of the header data.
425
426	// Determine highest position of an APP segment at or below APP3, so we can put the
427	// new APP3 at this position
428
429
430	$highest_APP = -1;
431
432	//Cycle through the header segments
433	for( $i = 0; $i < count( $jpeg_header_data ); $i++ )
434	{
435	// Check if we have found an APP segment at or below APP3,
436	if ( ( $jpeg_header_data[$i]['SegType'] >= 0xE0 ) && ( $jpeg_header_data[$i]['SegType'] <= 0xE3 ) )
437	{
438	// Found an APP segment at or below APP12
439	$highest_APP = $i;
440	}
441	}
442
443	// No preexisting Meta block found, insert a new one at the start of the header data.
444	array_splice($jpeg_header_data, $highest_APP + 1 , 0, array( array( "SegType" => 0xE3,
445	"SegName" => "APP3",
446	"SegDesc" => $GLOBALS[ "JPEG_Segment_Descriptions" ][ 0xE1 ],
447	"SegData" => $packed_data ) ) );
448	return $jpeg_header_data;
449
450	}
451
452	/******************************************************************************
453	* End of Function: put_Meta_JPEG
454	******************************************************************************/
455
456
457
458	/******************************************************************************
459	*
460	* Function: get_EXIF_TIFF
461	*
462	* Description: Retrieves information from a Exchangeable Image File Format (EXIF)
463	* within a TIFF file and returns it in an array.
464	*
465	* Parameters: filename - the filename of the TIFF image to process
466	*
467	* Returns: OutputArray - Array of EXIF records
468	* FALSE - If an error occured in decoding
469	*
470	******************************************************************************/
471
472	function get_EXIF_TIFF( $filename )
473	{
474	// Change: Added as of version 1.11
475	// Check if a wrapper is being used - these are not currently supported (see notes at top of file)
476	if ( ( stristr ( $filename, "http://" ) != FALSE ) \|\| ( stristr ( $filename, "ftp://" ) != FALSE ) )
477	{
478	// A HTTP or FTP wrapper is being used - show a warning and abort
479	echo "HTTP and FTP wrappers are currently not supported with TIFF - See EXIF/TIFF functionality documentation - a local file must be specified<br>";
480	echo "To work on an internet file, copy it locally to start with:<br><br>\n";
481	echo "\$newfilename = tempnam ( \$dir, \"tmptiff\" );<br>\n";
482	echo "copy ( \"http://whatever.com\", \$newfilename );<br><br>\n";
483	return FALSE;
484	}
485
486
487	$filehnd = @fopen($filename, 'rb');
488
489	// Check if the file opened successfully
490	if ( ! $filehnd )
491	{
492	// Could't open the file - exit
493	echo "<p>Could not open file $filename</p>\n";
494	return FALSE;
495	}
496
497	// Decode the Exif segment into an array and return it
498	$exif_data = process_TIFF_Header( $filehnd, "TIFF" );
499
500	// Close File
501	fclose($filehnd);
502	return $exif_data;
503	}
504
505	/******************************************************************************
506	* End of Function: get_EXIF_TIFF
507	******************************************************************************/
508
509
510
511
512	/******************************************************************************
513	*
514	* Function: Interpret_EXIF_to_HTML
515	*
516	* Description: Generates html detailing the contents an APP1 EXIF array
517	* which was retrieved with a get_EXIF_.... function.
518	* Can also be used for APP3 Meta arrays.
519	*
520	* Parameters: Exif_array - the EXIF array,as read from get_EXIF_....
521	* filename - the name of the Image file being processed ( used
522	* by scripts which displays EXIF thumbnails)
523	*
524	* Returns: output_str - A string containing the HTML
525	*
526	******************************************************************************/
527
528	function Interpret_EXIF_to_HTML( $Exif_array, $filename )
529	{
530	// Create the string to receive the html output
531	$output_str = "";
532
533	// Check if the array to process is valid
534	if ( $Exif_array === FALSE )
535	{ // Exif Array is not valid - abort processing
536	return $output_str;
537	}
538	$output_str .= "<fieldset><legend>Contains " . $Exif_array[ 'Tags Name' ];
539	// Ouput the heading according to what type of tags were used in processing
540	if ( $Exif_array[ 'Tags Name' ] == "TIFF" ) {
541	$output_str .= " Exchangeable Image File Format (EXIF) " . $Exif_array[ 'Tags Name' ] . " Information</legend>";
542	} else if ( $Exif_array[ 'Tags Name' ] == "Meta" ) {
543	$output_str .= " Information (APP3)</legend>";
544	} else {
545	$output_str .= " Information </legend>";
546	}
547
548
549	// Check that there are actually items to process in the array
550	if ( count( $Exif_array ) < 1 )
551	{ // No items to process in array - abort processing
552	return $output_str."</fieldset>" ;
553	}
554
555	// Output secondary heading
556	$output_str .="<fieldset id='".$Exif_array[ 'Tags Name' ]."_0' class='fieldset'> <legend>Main Image Information</legend>";
557	// Interpret the zeroth IFD to html
558	$output_str .= interpret_IFD( $Exif_array[0], $filename, $Exif_array['Byte_Align'] );
559
560
561	// Check if there is a first IFD to process
562	if ( array_key_exists( 1, $Exif_array ) )
563	{
564	// There is a first IFD for a thumbnail
565	// Add a heading for it to the output
566	$output_str .= "<fieldset id='".$Exif_array[ 'Tags Name' ]."_1' class='fieldset'> <legend>Thumbnail Information</legend>";
567	// Interpret the IFD to html and add it to the output
568	$output_str .= interpret_IFD( $Exif_array[1], $filename, $Exif_array['Byte_Align'] );
569
570	}
571
572	// Cycle through any other IFD's
573	$i = 2;
574	while ( array_key_exists( $i, $Exif_array ) )
575	{
576	// Add a heading for the IFD
577	$output_str .= "<fieldset id='".$Exif_array[ 'Tags Name' ]."_".$i."' class='fieldset' > <legend>Image File Directory (IFD) $i Information</legend>";
578	// Interpret the IFD to html and add it to the output
579	$output_str .= interpret_IFD( $Exif_array[$i], $filename, $Exif_array['Byte_Align'] );
580
581	$i++;
582	}
583	$output_str .="</fieldset>";
584	// Return the resulting HTML
585	return $output_str;
586	}
587
588	/******************************************************************************
589	* End of Function: Interpret_EXIF_to_HTML
590	******************************************************************************/
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607	/******************************************************************************
608	*
609	* INTERNAL FUNCTIONS
610	*
611	******************************************************************************/
612
613
614
615
616
617
618
619
620
621
622
623	/******************************************************************************
624	*
625	* Internal Function: get_TIFF_Packed_Data
626	*
627	* Description: Packs TIFF IFD data from EXIF or Meta into a form ready for
628	* either a JPEG EXIF/Meta segment or a TIFF file
629	* This function attempts to protect the contents of an EXIF makernote,
630	* by ensuring that it remains in the same position relative to the
631	* TIFF header
632	*
633	* Parameters: tiff_data - the EXIF array,as read from get_EXIF_JPEG or get_Meta_JPEG
634	*
635	* Returns: packed_data - A string containing packed segment
636	*
637	******************************************************************************/
638
639	function get_TIFF_Packed_Data( $tiff_data )
640	{
641	// Check that the segment is valid
642	if ( $tiff_data === FALSE )
643	{
644	return FALSE;
645	}
646
647	// Get the byte alignment
648	$Byte_Align = $tiff_data['Byte_Align'];
649
650	// Add the Byte Alignment to the Packed data
651	$packed_data = $Byte_Align;
652
653	// Add the TIFF ID to the Packed Data
654	$packed_data .= put_IFD_Data_Type( 42, 3, $Byte_Align );
655
656	// Create a string for the makernote
657	$makernote = "";
658
659	// Check if the makernote exists
660	if ( $tiff_data[ 'Makernote_Tag' ] !== FALSE )
661	{
662	// A makernote exists - We need to ensure that it stays in the same position as it was
663	// Put the Makernote before any of the IFD's by padding zeros to the correct offset
664	$makernote .= str_repeat("\x00",( $tiff_data[ 'Makernote_Tag' ][ 'Offset' ] - 8 ) );
665	$makernote .= $tiff_data[ 'Makernote_Tag' ]['Data'];
666	}
667
668	// Calculage where the zeroth ifd will be
669	$ifd_offset = strlen( $makernote ) + 8;
670
671	// Add the Zeroth IFD pointer to the packed data
672	$packed_data .= put_IFD_Data_Type( $ifd_offset, 4, $Byte_Align );
673
674	// Add the makernote to the packed data (if there was one)
675	$packed_data .= $makernote;
676
677	//Add the IFD's to the packed data
678	$packed_data .= get_IFD_Array_Packed_Data( $tiff_data, $ifd_offset, $Byte_Align );
679
680	// Return the result
681	return $packed_data;
682	}
683
684	/******************************************************************************
685	* End of Function: get_TIFF_Packed_Data
686	******************************************************************************/
687
688
689
690
691	/******************************************************************************
692	*
693	* Internal Function: get_IFD_Array_Packed_Data
694	*
695	* Description: Packs a chain of IFD's from EXIF or Meta segments into a form
696	* ready for either a JPEG EXIF/Meta segment or a TIFF file
697	*
698	* Parameters: ifd_data - the IFD chain array, as read from get_EXIF_JPEG or get_Meta_JPEG
699	* Zero_IFD_offset - The offset to the first IFD from the start of the TIFF header
700	* Byte_Align - the Byte alignment to use - "MM" or "II"
701	*
702	* Returns: packed_data - A string containing packed IFD's
703	*
704	******************************************************************************/
705
706	function get_IFD_Array_Packed_Data( $ifd_data, $Zero_IFD_offset, $Byte_Align )
707	{
708	// Create a string to receive the packed output
709	$packed_data = "";
710
711	// Count the IFDs
712	$ifd_count = 0;
713	foreach( $ifd_data as $key => $IFD )
714	{
715	// Make sure we only count the IFD's, not other information keys
716	if ( is_numeric( $key ) )
717	{
718	$ifd_count++;
719	}
720	}
721
722
723	// Cycle through each IFD,
724	for ( $ifdno = 0; $ifdno < $ifd_count; $ifdno++ )
725	{
726	// Check if this IFD is the last one
727	if ( $ifdno == $ifd_count - 1 )
728	{
729	// This IFD is the last one, get it's packed data
730	$packed_data .= get_IFD_Packed_Data( $ifd_data[ $ifdno ], $Zero_IFD_offset +strlen($packed_data), $Byte_Align, FALSE );
731	}
732	else
733	{
734	// This IFD is NOT the last one, get it's packed data
735	$packed_data .= get_IFD_Packed_Data( $ifd_data[ $ifdno ], $Zero_IFD_offset +strlen($packed_data), $Byte_Align, TRUE );
736	}
737
738	}
739
740	// Return the packed output
741	return $packed_data;
742	}
743
744	/******************************************************************************
745	* End of Function: get_IFD_Array_Packed_Data
746	******************************************************************************/
747
748
749
750	/******************************************************************************
751	*
752	* Internal Function: get_IFD_Packed_Data
753	*
754	* Description: Packs an IFD from EXIF or Meta segments into a form
755	* ready for either a JPEG EXIF/Meta segment or a TIFF file
756	*
757	* Parameters: ifd_data - the IFD chain array, as read from get_EXIF_JPEG or get_Meta_JPEG
758	* IFD_offset - The offset to the IFD from the start of the TIFF header
759	* Byte_Align - the Byte alignment to use - "MM" or "II"
760	* Another_IFD - boolean - false if this is the last IFD in the chain
761	* - true if it is not the last
762	*
763	* Returns: packed_data - A string containing packed IFD's
764	*
765	******************************************************************************/
766
767	function get_IFD_Packed_Data( $ifd_data, $IFD_offset, $Byte_Align, $Another_IFD )
768	{
769
770	$ifd_body_str = "";
771	$ifd_data_str = "";
772
773	$Tag_Definitions_Name = $ifd_data[ 'Tags Name' ];
774
775
776	// Count the Tags in this IFD
777	$tag_count = 0;
778	foreach( $ifd_data as $key => $tag )
779	{
780	// Make sure we only count the Tags, not other information keys
781	if ( is_numeric( $key ) )
782	{
783	$tag_count++;
784	}
785	}
786
787	// Add the Tag count to the packed data
788	$packed_data = put_IFD_Data_Type( $tag_count, 3, $Byte_Align );
789
790	// Calculate the total length of the IFD (without the offset data)
791	$IFD_len = 2 + $tag_count * 12 + 4;
792
793
794	// Cycle through each tag
795	foreach( $ifd_data as $key => $tag )
796	{
797	// Make sure this is a tag, not another information key
798	if ( is_numeric( $key ) )
799	{
800
801	// Add the tag number to the packed data
802	$ifd_body_str .= put_IFD_Data_Type( $tag[ 'Tag Number' ], 3, $Byte_Align );
803
804	// Add the Data type to the packed data
805	$ifd_body_str .= put_IFD_Data_Type( $tag['Data Type'], 3, $Byte_Align );
806
807	// Check if this is a Print Image Matching entry
808	if ( $tag['Type'] == "PIM" )
809	{
810	// This is a Print Image Matching entry,
811	// encode it
812	$data = Encode_PIM( $tag, $Byte_Align );
813	}
814	// Check if this is a IPTC/NAA Record within the EXIF IFD
815	else if ( ( ( $Tag_Definitions_Name == "EXIF" ) \|\| ( $Tag_Definitions_Name == "TIFF" ) ) &&
816	( $tag[ 'Tag Number' ] == 33723 ) )
817	{
818	// This is a IPTC/NAA Record, encode it
819	$data = put_IPTC( $tag['Data'] );
820	}
821	// Change: Check for embedded XMP as of version 1.11
822	// Check if this is a XMP Record within the EXIF IFD
823	else if ( ( ( $Tag_Definitions_Name == "EXIF" ) \|\| ( $Tag_Definitions_Name == "TIFF" ) ) &&
824	( $tag[ 'Tag Number' ] == 700 ) )
825	{
826	// This is a XMP Record, encode it
827	$data = write_XMP_array_to_text( $tag['Data'] );
828	}
829	// Change: Check for embedded IRB as of version 1.11
830	// Check if this is a Photoshop IRB Record within the EXIF IFD
831	else if ( ( ( $Tag_Definitions_Name == "EXIF" ) \|\| ( $Tag_Definitions_Name == "TIFF" ) ) &&
832	( $tag[ 'Tag Number' ] == 34377 ) )
833	{
834	// This is a Photoshop IRB Record, encode it
835	$data = pack_Photoshop_IRB_Data( $tag['Data'] );
836	}
837	// Exif Thumbnail Offset
838	else if ( ( $tag[ 'Tag Number' ] == 513 ) && ( $Tag_Definitions_Name == "TIFF" ) )
839	{
840	// The Exif Thumbnail Offset is a pointer but of type Long, not Unknown
841	// Hence we need to put the data into the packed string separately
842	// Calculate the thumbnail offset
843	$data_offset = $IFD_offset + $IFD_len + strlen($ifd_data_str);
844
845	// Create the Offset for the IFD
846	$data = put_IFD_Data_Type( $data_offset, 4, $Byte_Align );
847
848	// Store the thumbnail
849	$ifd_data_str .= $tag['Data'];
850	}
851	// Exif Thumbnail Length
852	else if ( ( $tag[ 'Tag Number' ] == 514 ) && ( $Tag_Definitions_Name == "TIFF" ) )
853	{
854	// Encode the Thumbnail Length
855	$data = put_IFD_Data_Type( strlen($ifd_data[513]['Data']), 4, $Byte_Align );
856	}
857	// Sub-IFD
858	else if ( $tag['Type'] == "SubIFD" )
859	{
860	// This is a Sub-IFD
861	// Calculate the offset to the start of the Sub-IFD
862	$data_offset = $IFD_offset + $IFD_len + strlen($ifd_data_str);
863	// Get the packed data for the IFD chain as the data for this tag
864	$data = get_IFD_Array_Packed_Data( $tag['Data'], $data_offset, $Byte_Align );
865	}
866	else
867	{
868	// Not a special tag
869
870	// Create a string to receive the data
871	$data = "";
872
873	// Check if this is a type Unknown tag
874	if ( $tag['Data Type'] != 7 )
875	{
876	// NOT type Unknown
877	// Cycle through each data value and add it to the data string
878	foreach( $tag[ 'Data' ] as $data_val )
879	{
880	$data .= put_IFD_Data_Type( $data_val, $tag['Data Type'], $Byte_Align );
881	}
882	}
883	else
884	{
885	// This is a type Unknown - just add the data as is to the data string
886	$data .= $tag[ 'Data' ];
887	}
888	}
889
890	// Pad the data string out to at least 4 bytes
891	$data = str_pad ( $data, 4, "\x00" );
892
893
894	// Check if the data type is an ASCII String or type Unknown
895	if ( ( $tag['Data Type'] == 2 ) \|\| ( $tag['Data Type'] == 7 ) )
896	{
897	// This is an ASCII String or type Unknown
898	// Add the Length of the string to the packed data as the Count
899	$ifd_body_str .= put_IFD_Data_Type( strlen($data), 4, $Byte_Align );
900	}
901	else
902	{
903	// Add the array count to the packed data as the Count
904	$ifd_body_str .= put_IFD_Data_Type( count($tag[ 'Data' ]), 4, $Byte_Align );
905	}
906
907
908	// Check if the data is over 4 bytes long
909	if ( strlen( $data ) > 4 )
910	{
911	// Data is longer than 4 bytes - it needs to be offset
912	// Check if this entry is the Maker Note
913	if ( ( $Tag_Definitions_Name == "EXIF" ) && ( $tag[ 'Tag Number' ] == 37500 ) )
914	{
915	// This is the makernote - It will have already been stored
916	// at its original offset to help preserve it
917	// all we need to do is add the Offset to the IFD packed data
918	$data_offset = $tag[ 'Offset' ];
919
920	$ifd_body_str .= put_IFD_Data_Type( $data_offset, 4, $Byte_Align );
921	}
922	else
923	{
924	// This is NOT the makernote
925	// Calculate the data offset
926	$data_offset = $IFD_offset + $IFD_len + strlen($ifd_data_str);
927
928	// Add the offset to the IFD packed data
929	$ifd_body_str .= put_IFD_Data_Type( $data_offset, 4, $Byte_Align );
930
931	// Add the data to the offset packed data
932	$ifd_data_str .= $data;
933	}
934	}
935	else
936	{
937	// Data is less than or equal to 4 bytes - Add it to the packed IFD data as is
938	$ifd_body_str .= $data;
939	}
940
941	}
942	}
943
944	// Assemble the IFD body onto the packed data
945	$packed_data .= $ifd_body_str;
946
947	// Check if there is another IFD after this one
948	if( $Another_IFD === TRUE )
949	{
950	// There is another IFD after this
951	// Calculate the Next-IFD offset so that it goes immediately after this IFD
952	$next_ifd_offset = $IFD_offset + $IFD_len + strlen($ifd_data_str);
953	}
954	else
955	{
956	// There is NO IFD after this - indicate with offset=0
957	$next_ifd_offset = 0;
958	}
959
960	// Add the Next-IFD offset to the packed data
961	$packed_data .= put_IFD_Data_Type( $next_ifd_offset, 4, $Byte_Align );
962
963	// Add the offset data to the packed data
964	$packed_data .= $ifd_data_str;
965
966	// Return the resulting packed data
967	return $packed_data;
968	}
969
970	/******************************************************************************
971	* End of Function: get_IFD_Packed_Data
972	******************************************************************************/
973
974
975
976
977
978	/******************************************************************************
979	*
980	* Internal Function: process_TIFF_Header
981	*
982	* Description: Decodes the information stored in a TIFF header and it's
983	* Image File Directories (IFD's). This information is returned
984	* in an array
985	*
986	* Parameters: filehnd - The handle of a open image file, positioned at the
987	* start of the TIFF header
988	* Tag_Definitions_Name - The name of the Tag Definitions group
989	* within the global array IFD_Tag_Definitions
990	*
991	*
992	* Returns: OutputArray - Array of IFD records
993	* FALSE - If an error occured in decoding
994	*
995	******************************************************************************/
996
997	function process_TIFF_Header( $filehnd, $Tag_Definitions_Name )
998	{
999
1000
1001	// Save the file position where the TIFF header starts, as offsets are relative to this position
1002	$Tiff_start_pos = ftell( $filehnd );
1003
1004
1005
1006	// Read the eight bytes of the TIFF header
1007	$DataStr = network_safe_fread( $filehnd, 8 );
1008
1009	// Check that we did get all eight bytes
1010	if ( strlen( $DataStr ) != 8 )
1011	{
1012	return FALSE; // Couldn't read the TIFF header properly
1013	}
1014
1015	$pos = 0;
1016	// First two bytes indicate the byte alignment - should be 'II' or 'MM'
1017	// II = Intel (LSB first, MSB last - Little Endian)
1018	// MM = Motorola (MSB first, LSB last - Big Endian)
1019	$Byte_Align = substr( $DataStr, $pos, 2 );
1020
1021
1022
1023	// Check the Byte Align Characters for validity
1024	if ( ( $Byte_Align != "II" ) && ( $Byte_Align != "MM" ) )
1025	{
1026	// Byte align field is invalid - we won't be able to decode file
1027	return FALSE;
1028	}
1029
1030	// Skip over the Byte Align field which was just read
1031	$pos += 2;
1032
1033	// Next two bytes are TIFF ID - should be value 42 with the appropriate byte alignment
1034	$TIFF_ID = substr( $DataStr, $pos, 2 );
1035
1036	if ( get_IFD_Data_Type( $TIFF_ID, 3, $Byte_Align ) != 42 )
1037	{
1038	// TIFF header ID not found
1039	return FALSE;
1040	}
1041
1042	// Skip over the TIFF ID field which was just read
1043	$pos += 2;
1044
1045
1046	// Next four bytes are the offset to the first IFD
1047	$offset_str = substr( $DataStr, $pos, 4 );
1048	$offset = get_IFD_Data_Type( $offset_str, 4, $Byte_Align );
1049
1050	// Done reading TIFF Header
1051
1052
1053	// Move to first IFD
1054
1055	if ( fseek( $filehnd, $Tiff_start_pos + $offset ) !== 0 )
1056	{
1057	// Error seeking to position of first IFD
1058	return FALSE;
1059	}
1060
1061
1062
1063	// Flag that a makernote has not been found yet
1064	$GLOBALS[ "Maker_Note_Tag" ] = FALSE;
1065
1066	// Read the IFD chain into an array
1067	$Output_Array = read_Multiple_IFDs( $filehnd, $Tiff_start_pos, $Byte_Align, $Tag_Definitions_Name );
1068
1069	// Check if a makernote was found
1070	if ( $GLOBALS[ "Maker_Note_Tag" ] != FALSE )
1071	{
1072	// Makernote was found - Process it
1073	// The makernote needs to be processed after all other
1074	// tags as it may require some of the other tags in order
1075	// to be processed properly
1076	$GLOBALS[ "Maker_Note_Tag" ] = Read_Makernote_Tag( $GLOBALS[ "Maker_Note_Tag" ], $Output_Array, $filehnd );
1077
1078	}
1079
1080	$Output_Array[ 'Makernote_Tag' ] = $GLOBALS[ "Maker_Note_Tag" ];
1081
1082	// Save the Name of the Tags used in the output array
1083	$Output_Array[ 'Tags Name' ] = $Tag_Definitions_Name;
1084
1085
1086
1087	// Save the Byte alignment
1088	$Output_Array['Byte_Align'] = $Byte_Align;
1089
1090
1091	// Return the output array
1092	return $Output_Array ;
1093	}
1094
1095	/******************************************************************************
1096	* End of Function: process_TIFF_Header
1097	******************************************************************************/
1098
1099
1100
1101
1102
1103
1104	/******************************************************************************
1105	*
1106	* Internal Function: read_Multiple_IFDs
1107	*
1108	* Description: Reads and interprets a chain of standard Image File Directories (IFD's),
1109	* and returns the entries in an array. This chain is made up from IFD's
1110	* which have a pointer to the next IFD. IFD's are read until the next
1111	* pointer indicates there are no more
1112	*
1113	* Parameters: filehnd - a handle for the image file being read, positioned at the
1114	* start of the IFD chain
1115	* Tiff_offset - The offset of the TIFF header from the start of the file
1116	* Byte_Align - either "MM" or "II" indicating Motorola or Intel Byte alignment
1117	* Tag_Definitions_Name - The name of the Tag Definitions group within the global array IFD_Tag_Definitions
1118	* local_offsets - True indicates that offset data should be interpreted as being relative to the start of the currrent entry
1119	* False (normal) indicates offests are relative to start of Tiff header as per IFD standard
1120	* read_next_ptr - True (normal) indicates that a pointer to the next IFD should be read at the end of the IFD
1121	* False indicates that no pointer follows the IFD
1122	*
1123	*
1124	* Returns: OutputArray - Array of IFD entries
1125	*
1126	******************************************************************************/
1127
1128	function read_Multiple_IFDs( $filehnd, $Tiff_offset, $Byte_Align, $Tag_Definitions_Name, $local_offsets = FALSE, $read_next_ptr = TRUE )
1129	{
1130	// Start at the offset of the first IFD
1131	$Next_Offset = 0;
1132
1133	do
1134	{
1135	// Read an IFD
1136	list($IFD_Array , $Next_Offset) = read_IFD_universal( $filehnd, $Tiff_offset, $Byte_Align, $Tag_Definitions_Name, $local_offsets, $read_next_ptr );
1137
1138	// Move to the position of the next IFD
1139	if ( fseek( $filehnd, $Tiff_offset + $Next_Offset ) !== 0 )
1140	{
1141	// Error seeking to position of next IFD
1142	echo "<p>Error: Corrupted EXIF</p>\n";
1143	return FALSE;
1144	}
1145
1146	$Output_Array[] = $IFD_Array;
1147
1148
1149	} while ( $Next_Offset != 0 ); // Until the Next IFD Offset is zero
1150
1151
1152	// return resulting array
1153
1154	return $Output_Array ;
1155	}
1156
1157	/******************************************************************************
1158	* End of Function: read_Multiple_IFDs
1159	******************************************************************************/
1160
1161
1162
1163
1164
1165
1166
1167	/******************************************************************************
1168	*
1169	* Internal Function: read_IFD_universal
1170	*
1171	* Description: Reads and interprets a standard or Non-standard Image File
1172	* Directory (IFD), and returns the entries in an array
1173	*
1174	* Parameters: filehnd - a handle for the image file being read, positioned at the start
1175	* of the IFD
1176	* Tiff_offset - The offset of the TIFF header from the start of the file
1177	* Byte_Align - either "MM" or "II" indicating Motorola or Intel Byte alignment
1178	* Tag_Definitions_Name - The name of the Tag Definitions group within the global array IFD_Tag_Definitions
1179	* local_offsets - True indicates that offset data should be interpreted as being relative to the start of the currrent entry
1180	* False (normal) indicates offests are relative to start of Tiff header as per IFD standard
1181	* read_next_ptr - True (normal) indicates that a pointer to the next IFD should be read at the end of the IFD
1182	* False indicates that no pointer follows the IFD
1183	*
1184	* Returns: OutputArray - Array of IFD entries
1185	* Next_Offset - Offset to next IFD (zero = no next IFD)
1186	*
1187	******************************************************************************/
1188
1189	function read_IFD_universal( $filehnd, $Tiff_offset, $Byte_Align, $Tag_Definitions_Name, $local_offsets = FALSE, $read_next_ptr = TRUE )
1190	{
1191	if ( ( $filehnd == NULL ) \|\| ( feof( $filehnd ) ) )
1192	{
1193	return array (FALSE , 0);
1194	}
1195
1196	// Record the Name of the Tag Group used for this IFD in the output array
1197	$OutputArray[ 'Tags Name' ] = $Tag_Definitions_Name;
1198
1199	// Record the offset of the TIFF header in the output array
1200	$OutputArray[ 'Tiff Offset' ] = $Tiff_offset;
1201
1202	// First 2 bytes of IFD are number of entries in the IFD
1203	$No_Entries_str = network_safe_fread( $filehnd, 2 );
1204	$No_Entries = get_IFD_Data_Type( $No_Entries_str, 3, $Byte_Align );
1205
1206
1207	// If the data is corrupt, the number of entries may be huge, which will cause errors
1208	// This is often caused by a lack of a Next-IFD pointer
1209	if ( $No_Entries> 10000 )
1210	{
1211	// Huge number of entries - abort
1212	echo "<p>Error: huge number of EXIF entries - EXIF is probably Corrupted</p>\n";
1213
1214	return array ( FALSE , 0);
1215	}
1216
1217	// If the data is corrupt or just stupid, the number of entries may zero,
1218	// Indicate this by returning false
1219	if ( $No_Entries === 0 )
1220	{
1221	// No entries - abort
1222	return array ( FALSE , 0);
1223	}
1224
1225	// Save the file position where first IFD record starts as non-standard offsets
1226	// need to know this to calculate an absolute offset
1227	$IFD_first_rec_pos = ftell( $filehnd );
1228
1229
1230	// Read in the IFD structure
1231	$IFD_Data = network_safe_fread( $filehnd, 12 * $No_Entries );
1232
1233	// Check if the entire IFD was able to be read
1234	if ( strlen( $IFD_Data ) != (12 * $No_Entries) )
1235	{
1236	// Couldn't read the IFD Data properly, Some Casio files have no Next IFD pointer, hence cause this error
1237	echo "<p>Error: EXIF Corrupted</p>\n";
1238	return array(FALSE, 0);
1239	}
1240
1241
1242	// Last 4 bytes of a standard IFD are the offset to the next IFD
1243	// Some NON-Standard IFD implementations do not have this, hence causing problems if it is read
1244
1245	// If the Next IFD pointer has been requested to be read,
1246	if ( $read_next_ptr )
1247	{
1248	// Read the pointer to the next IFD
1249
1250	$Next_Offset_str = network_safe_fread( $filehnd, 4 );
1251	$Next_Offset = get_IFD_Data_Type( $Next_Offset_str, 4, $Byte_Align );
1252	}
1253	else
1254	{
1255	// Otherwise set the pointer to zero ( no next IFD )
1256	$Next_Offset = 0;
1257	}
1258
1259
1260
1261	// Initialise current position to the start
1262	$pos = 0;
1263
1264
1265	// Loop for reading IFD entries
1266
1267	for ( $i = 0; $i < $No_Entries; $i++ )
1268	{
1269	// First 2 bytes of IFD entry are the tag number ( Unsigned Short )
1270	$Tag_No_str = substr( $IFD_Data, $pos, 2 );
1271	$Tag_No = get_IFD_Data_Type( $Tag_No_str, 3, $Byte_Align );
1272	$pos += 2;
1273
1274	// Next 2 bytes of IFD entry are the data format ( Unsigned Short )
1275	$Data_Type_str = substr( $IFD_Data, $pos, 2 );
1276	$Data_Type = get_IFD_Data_Type( $Data_Type_str, 3, $Byte_Align );
1277	$pos += 2;
1278
1279	// If Datatype is not between 1 and 12, then skip this entry, it is probably corrupted or custom
1280	if (( $Data_Type > 12 ) \|\| ( $Data_Type < 1 ) )
1281	{
1282	$pos += 8;
1283	continue 1; // Stop trying to process the tag any further and skip to the next one
1284	}
1285
1286	// Next 4 bytes of IFD entry are the data count ( Unsigned Long )
1287	$Data_Count_str = substr( $IFD_Data, $pos, 4 );
1288	$Data_Count = get_IFD_Data_Type( $Data_Count_str, 4, $Byte_Align );
1289	$pos += 4;
1290
1291	if ( $Data_Count > 100000 )
1292	{
1293	// echo "<p>Error: huge EXIF data count - EXIF is probably Corrupted</p>\n";
1294
1295	// Some Casio files have no Next IFD pointer, hence cause errors
1296
1297	return array ( FALSE , 0);
1298	}
1299
1300	// Total Data size is the Data Count multiplied by the size of the Data Type
1301	$Total_Data_Size = $GLOBALS['IFD_Data_Sizes'][ $Data_Type ] * $Data_Count;
1302
1303	$Data_Start_pos = -1;
1304
1305	// If the total data size is larger than 4 bytes, then the data part is the offset to the real data
1306	if ( $Total_Data_Size > 4 )
1307	{
1308	// Not enough room for data - offset provided instead
1309	$Data_Offset_str = substr( $IFD_Data, $pos, 4 );
1310	$Data_Start_pos = get_IFD_Data_Type( $Data_Offset_str, 4, $Byte_Align );
1311
1312
1313	// In some NON-STANDARD makernotes, the offset is relative to the start of the current IFD entry
1314	if ( $local_offsets )
1315	{
1316	// This is a NON-Standard IFD, seek relative to the start of the current tag
1317	fseek( $filehnd, $IFD_first_rec_pos + $pos - 8 + $Data_Start_pos );
1318	}
1319	else
1320	{
1321	// This is a normal IFD, seek relative to the start of the TIFF header
1322	fseek( $filehnd, $Tiff_offset + $Data_Start_pos );
1323	}
1324
1325	// Read the data block from the offset position
1326	$DataStr = network_safe_fread( $filehnd, $Total_Data_Size );
1327	}
1328	else
1329	{
1330	// The data block is less than 4 bytes, and is provided in the IFD entry, so read it
1331	$DataStr = substr( $IFD_Data, $pos, $Total_Data_Size );
1332	}
1333
1334	// Increment the position past the data
1335	$pos += 4;
1336
1337
1338	// Now create the entry for output array
1339
1340	$Data_Array = array( );
1341
1342
1343	// Read the data items from the data block
1344
1345	if ( ( $Data_Type != 2 ) && ( $Data_Type != 7 ) )
1346	{
1347	// The data type is Numerical, Read the data items from the data block
1348	for ( $j = 0; $j < $Data_Count; $j++ )
1349	{
1350	$Part_Data_Str = substr( $DataStr, $j * $GLOBALS['IFD_Data_Sizes'][ $Data_Type ], $GLOBALS['IFD_Data_Sizes'][ $Data_Type ] );
1351	$Data_Array[] = get_IFD_Data_Type( $Part_Data_Str, $Data_Type, $Byte_Align );
1352	}
1353	}
1354	elseif ( $Data_Type == 2 )
1355	{
1356	// The data type is String(s) (type 2)
1357
1358	// Strip the last terminating Null
1359	$DataStr = substr( $DataStr, 0, strlen($DataStr)-1 );
1360
1361	// Split the data block into multiple strings whereever there is a Null
1362	$Data_Array = explode( "\x00", $DataStr );
1363	}
1364	else
1365	{
1366	// The data type is Unknown (type 7)
1367	// Do nothing to data
1368	$Data_Array = $DataStr;
1369	}
1370
1371
1372	// If this is a Sub-IFD entry,
1373	if ( ( array_key_exists( $Tag_No, $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name] ) ) &&
1374	( "SubIFD" == $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag_No ]['Type'] ) )
1375	{
1376	// This is a Sub-IFD entry, go and process the data forming Sub-IFD and use its output array as the new data for this entry
1377	fseek( $filehnd, $Tiff_offset + $Data_Array[0] );
1378	$Data_Array = read_Multiple_IFDs( $filehnd, $Tiff_offset, $Byte_Align, $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag_No ]['Tags Name'] );
1379	}
1380
1381	$desc = "";
1382	$units = "";
1383
1384	// Check if this tag exists in the list of tag definitions,
1385
1386	if ( array_key_exists ( $Tag_No, $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name]) )
1387	{
1388
1389	if ( array_key_exists ( 'Description', $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag_No ] ) )
1390	{
1391	$desc = $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag_No ]['Description'];
1392	}
1393
1394	if ( array_key_exists ( 'Units', $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag_No ] ) )
1395	{
1396	$units = $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag_No ]['Units'];
1397	}
1398
1399	// Tag exists in definitions, append details to output array
1400	$OutputArray[ $Tag_No ] = array ( "Tag Number" => $Tag_No,
1401	"Tag Name" => $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag_No ]['Name'],
1402	"Tag Description" => $desc,
1403	"Data Type" => $Data_Type,
1404	"Type" => $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag_No ]['Type'],
1405	"Units" => $units,
1406	"Data" => $Data_Array );
1407
1408	}
1409	else
1410	{
1411	// Tag doesnt exist in definitions, append unknown details to output array
1412
1413	$OutputArray[ $Tag_No ] = array ( "Tag Number" => $Tag_No,
1414	"Tag Name" => "Unknown Tag #" . $Tag_No,
1415	"Tag Description" => "",
1416	"Data Type" => $Data_Type,
1417	"Type" => "Unknown",
1418	"Units" => "",
1419	"Data" => $Data_Array );
1420	}
1421
1422
1423
1424	// Some information of type "Unknown" (type 7) might require information about
1425	// how it's position and byte alignment in order to be decoded
1426	if ( $Data_Type == 7 )
1427	{
1428	$OutputArray[ $Tag_No ]['Offset'] = $Data_Start_pos;
1429	$OutputArray[ $Tag_No ]['Byte Align'] = $Byte_Align;
1430	}
1431
1432
1433	////////////////////////////////////////////////////////////////////////
1434	// Special Data handling
1435	////////////////////////////////////////////////////////////////////////
1436
1437
1438	// Check if this is a Print Image Matching entry
1439	if ( $OutputArray[ $Tag_No ]['Type'] == "PIM" )
1440	{
1441	// This is a Print Image Matching entry, decode it.
1442	$OutputArray[ $Tag_No ] = Decode_PIM( $OutputArray[ $Tag_No ], $Tag_Definitions_Name );
1443	}
1444
1445
1446	// Interpret the entry into a text string using a custom interpreter
1447	$text_val = get_Tag_Text_Value( $OutputArray[ $Tag_No ], $Tag_Definitions_Name );
1448
1449	// Check if a text string was generated
1450	if ( $text_val !== FALSE )
1451	{
1452	// A string was generated, append it to the output array entry
1453	$OutputArray[ $Tag_No ]['Text Value'] = $text_val;
1454	$OutputArray[ $Tag_No ]['Decoded'] = TRUE;
1455	}
1456	else
1457	{
1458	// A string was NOT generated, append a generic string to the output array entry
1459	$OutputArray[ $Tag_No ]['Text Value'] = get_IFD_value_as_text( $OutputArray[ $Tag_No ] ) . " " . $units;
1460	$OutputArray[ $Tag_No ]['Decoded'] = FALSE;
1461	}
1462
1463
1464
1465
1466	// Check if this entry is the Maker Note
1467	if ( ( $Tag_Definitions_Name == "EXIF" ) && ( $Tag_No == 37500 ) )
1468	{
1469
1470	// Save some extra information which will allow Makernote Decoding with the output array entry
1471	$OutputArray[ $Tag_No ]['Offset'] = $Data_Start_pos;
1472	$OutputArray[ $Tag_No ][ 'Tiff Offset' ] = $Tiff_offset;
1473	$OutputArray[ $Tag_No ]['ByteAlign'] = $Byte_Align;
1474
1475	// Save a pointer to this entry for Maker note processing later
1476	$GLOBALS[ "Maker_Note_Tag" ] = & $OutputArray[ $Tag_No ];
1477	}
1478
1479
1480	// Check if this is a IPTC/NAA Record within the EXIF IFD
1481	if ( ( ( $Tag_Definitions_Name == "EXIF" ) \|\| ( $Tag_Definitions_Name == "TIFF" ) ) &&
1482	( $Tag_No == 33723 ) )
1483	{
1484	// This is a IPTC/NAA Record, interpret it and put result in the data for this entry
1485	$OutputArray[ $Tag_No ]['Data'] = get_IPTC( $DataStr );
1486	$OutputArray[ $Tag_No ]['Decoded'] = TRUE;
1487	}
1488	// Change: Check for embedded XMP as of version 1.11
1489	// Check if this is a XMP Record within the EXIF IFD
1490	if ( ( ( $Tag_Definitions_Name == "EXIF" ) \|\| ( $Tag_Definitions_Name == "TIFF" ) ) &&
1491	( $Tag_No == 700 ) )
1492	{
1493	// This is a XMP Record, interpret it and put result in the data for this entry
1494	$OutputArray[ $Tag_No ]['Data'] = read_XMP_array_from_text( $DataStr );
1495	$OutputArray[ $Tag_No ]['Decoded'] = TRUE;
1496	}
1497
1498	// Change: Check for embedded IRB as of version 1.11
1499	// Check if this is a Photoshop IRB Record within the EXIF IFD
1500	if ( ( ( $Tag_Definitions_Name == "EXIF" ) \|\| ( $Tag_Definitions_Name == "TIFF" ) ) &&
1501	( $Tag_No == 34377 ) )
1502	{
1503	// This is a Photoshop IRB Record, interpret it and put result in the data for this entry
1504	$OutputArray[ $Tag_No ]['Data'] = unpack_Photoshop_IRB_Data( $DataStr );
1505	$OutputArray[ $Tag_No ]['Decoded'] = TRUE;
1506	}
1507
1508	// Exif Thumbnail
1509	// Check that both the thumbnail length and offset entries have been processed,
1510	// and that this is one of them
1511	if ( ( ( ( $Tag_No == 513 ) && ( array_key_exists( 514, $OutputArray ) ) ) \|\|
1512	( ( $Tag_No == 514 ) && ( array_key_exists( 513, $OutputArray ) ) ) ) &&
1513	( $Tag_Definitions_Name == "TIFF" ) )
1514	{
1515	// Seek to the start of the thumbnail using the offset entry
1516	fseek( $filehnd, $Tiff_offset + $OutputArray[513]['Data'][0] );
1517
1518	// Read the thumbnail data, and replace the offset data with the thumbnail
1519	$OutputArray[513]['Data'] = network_safe_fread( $filehnd, $OutputArray[514]['Data'][0] );
1520	}
1521
1522
1523	// Casio Thumbnail
1524	// Check that both the thumbnail length and offset entries have been processed,
1525	// and that this is one of them
1526	if ( ( ( ( $Tag_No == 0x0004 ) && ( array_key_exists( 0x0003, $OutputArray ) ) ) \|\|
1527	( ( $Tag_No == 0x0003 ) && ( array_key_exists( 0x0004, $OutputArray ) ) ) ) &&
1528	( $Tag_Definitions_Name == "Casio Type 2" ) )
1529	{
1530	// Seek to the start of the thumbnail using the offset entry
1531	fseek( $filehnd, $Tiff_offset + $OutputArray[0x0004]['Data'][0] );
1532
1533	// Read the thumbnail data, and replace the offset data with the thumbnail
1534	$OutputArray[0x0004]['Data'] = network_safe_fread( $filehnd, $OutputArray[0x0003]['Data'][0] );
1535	}
1536
1537	// Minolta Thumbnail
1538	// Check that both the thumbnail length and offset entries have been processed,
1539	// and that this is one of them
1540	if ( ( ( ( $Tag_No == 0x0088 ) && ( array_key_exists( 0x0089, $OutputArray ) ) ) \|\|
1541	( ( $Tag_No == 0x0089 ) && ( array_key_exists( 0x0088, $OutputArray ) ) ) ) &&
1542	( $Tag_Definitions_Name == "Olympus" ) )
1543	{
1544
1545	// Seek to the start of the thumbnail using the offset entry
1546	fseek( $filehnd, $Tiff_offset + $OutputArray[0x0088]['Data'][0] );
1547
1548	// Read the thumbnail data, and replace the offset data with the thumbnail
1549	$OutputArray[0x0088]['Data'] = network_safe_fread( $filehnd, $OutputArray[0x0089]['Data'][0] );
1550
1551	// Sometimes the minolta thumbnail data is empty (or the offset is corrupt, which results in the same thing)
1552
1553	// Check if the thumbnail data exists
1554	if ( $OutputArray[0x0088]['Data'] != "" )
1555	{
1556	// Thumbnail exists
1557
1558	// Minolta Thumbnails are missing their first 0xFF for some reason,
1559	// which is replaced with some weird character, so fix this
1560	$OutputArray[0x0088]['Data']{0} = "\xFF";
1561	}
1562	else
1563	{
1564	// Thumbnail doesnt exist - make it obvious
1565	$OutputArray[0x0088]['Data'] = FALSE;
1566	}
1567	}
1568
1569	}
1570
1571
1572
1573
1574
1575
1576
1577	// Return the array of IFD entries and the offset to the next IFD
1578
1579	return array ($OutputArray , $Next_Offset);
1580	}
1581
1582
1583
1584	/******************************************************************************
1585	* End of Function: read_IFD_universal
1586	******************************************************************************/
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599	/******************************************************************************
1600	*
1601	* Internal Function: get_Tag_Text_Value
1602	*
1603	* Description: Attempts to interpret an IFD entry into a text string using the
1604	* information in the IFD_Tag_Definitions global array.
1605	*
1606	* Parameters: Tag - The IFD entry to process
1607	* Tag_Definitions_Name - The name of the tag definitions to use from within the IFD_Tag_Definitions global array
1608	*
1609	* Returns: String - if the tag was successfully decoded into a text string
1610	* FALSE - if the tag could not be decoded using the information
1611	* in the IFD_Tag_Definitions global array
1612	*
1613	******************************************************************************/
1614
1615	function get_Tag_Text_Value( $Tag, $Tag_Definitions_Name )
1616	{
1617	// Check what format the entry is specified as
1618
1619	if ( $Tag['Type'] == "String" )
1620	{
1621	// Format is Text String
1622
1623	// If "Unknown" (type 7) data type,
1624	if ( $Tag['Data Type'] == 7 )
1625	{
1626	// Return data as is.
1627	return $Tag['Data'];
1628	}
1629	else
1630	{
1631	// Otherwise return the default string value of the datatype
1632	return get_IFD_value_as_text( $Tag );
1633	}
1634	}
1635	else if ( $Tag['Type'] == "Character Coded String" )
1636	{
1637	// Format is Character Coded String (First 8 characters indicate coding scheme)
1638
1639	// Convert Data to a string
1640	if ( $Tag['Data Type'] == 7 )
1641	{
1642	// If it is type "Unknown" (type 7) use data as is
1643	$data = $Tag['Data'];
1644	}
1645	else
1646	{
1647	// Otherwise use the default string value of the datatype
1648	$data = get_IFD_value_as_text( $Tag );
1649	}
1650
1651	// Some implementations allow completely data with no Coding Scheme Name,
1652	// so we need to handle this to avoid errors
1653	if ( trim( $data ) == "" )
1654	{
1655	return "";
1656	}
1657
1658	// Extract the Coding Scheme Name from the first 8 characters
1659	$char_code = substr( $data, 0, 8 );
1660
1661	// Extract the Data part from after the first 8 characters
1662	$characters = substr( $data, 8 );
1663
1664	// Check coding scheme and interpret as neccessary
1665
1666	if ( $char_code === "ASCII\x00\x00\x00" )
1667	{
1668	// ASCII coding - return data as is.
1669	return $characters;
1670	}
1671	elseif ( ( $char_code === "UNICODE\x00" ) \|\|
1672	( $char_code === "Unicode\x00" ) ) // Note lowercase is non standard
1673	{
1674	// Unicode coding - interpret and return result.
1675	return xml_UTF16_clean( $characters, TRUE );
1676	}
1677	else
1678	{
1679	// Unknown coding - return string indicating this
1680	return "Unsupported character coding : \"$char_code\"\n\"" . trim($characters) . "\"";
1681	}
1682	break;
1683	}
1684	else if ( $Tag['Type'] == "Numeric" )
1685	{
1686	// Format is numeric - return default text value with any required units text appended
1687	if ( array_key_exists ( 'Units', $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag["Tag Number"] ] ) )
1688	{
1689	$units = $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag["Tag Number"] ]['Units'];
1690	}
1691	else
1692	{
1693	$units = "";
1694	}
1695	return get_IFD_value_as_text( $Tag ) . " " . $units;
1696	}
1697	else if ( $Tag['Type'] == "Lookup" )
1698	{
1699	// Format is a Lookup Table
1700
1701	// Get a numeric value to use in lookup
1702
1703	if ( is_array( $Tag['Data'] ) )
1704	{
1705	// If data is an array, use first element
1706	$first_val = $Tag['Data'][0];
1707	}
1708	else if ( is_string( $Tag['Data'] ) )
1709	{
1710	// If data is a string, use the first character
1711	$first_val = ord($Tag['Data']{0});
1712	}
1713	else
1714	{
1715	// Otherwise use the data as is
1716	$first_val = $Tag['Data'];
1717	}
1718
1719	// Check if the data value exists in the lookup table for this IFD entry
1720	if ( array_key_exists( $first_val, $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag["Tag Number"] ] ) )
1721	{
1722	// Data value exists in lookup table - return the matching string
1723	return $GLOBALS[ "IFD_Tag_Definitions" ][$Tag_Definitions_Name][ $Tag["Tag Number"] ][ $first_val ];
1724	}
1725	else
1726	{
1727	// Data value doesnt exist in lookup table - return explanation string
1728	return "Unknown Reserved value $first_val ";
1729	}
1730	}
1731	else if ( $Tag['Type'] == "Special" )
1732	{
1733	// Format is special - interpret to text with special handlers
1734	return get_Special_Tag_Text_Value( $Tag, $Tag_Definitions_Name );
1735	}
1736	else if ( $Tag['Type'] == "PIM" )
1737	{
1738	// Format is Print Image Matching info - interpret with custom handler
1739	return get_PIM_Text_Value( $Tag, $Tag_Definitions_Name );
1740	}
1741	else if ( $Tag['Type'] == "SubIFD" )
1742	{
1743	// Format is a Sub-IFD - this has no text value
1744	return "";
1745	}
1746	else
1747	{
1748	// Unknown Format - Couldn't interpret using the IFD_Tag_Definitions global array information
1749	return FALSE;
1750	}
1751	}
1752
1753	/******************************************************************************
1754	* End of Function: get_Tag_Text_Value
1755	******************************************************************************/
1756
1757
1758
1759
1760
1761
1762	/******************************************************************************
1763	*
1764	* Internal Function: get_Special_Tag_Text_Value
1765	*
1766	* Description: Interprets an IFD entry marked as "Special" in the IFD_Tag_Definitions
1767	* global array into a text string using custom handlers
1768	*
1769	* Parameters: Tag - The IFD entry to process
1770	* Tag_Definitions_Name - The name of the tag definitions to use from within the IFD_Tag_Definitions global array
1771	*
1772	* Returns: String - if the tag was successfully decoded into a text string
1773	* FALSE - if the tag could not be decoded
1774	*
1775	******************************************************************************/
1776
1777	function get_Special_Tag_Text_Value( $Tag, $Tag_Definitions_Name )
1778	{
1779	// Check what type of IFD is being decoded
1780
1781	if ( $Tag_Definitions_Name == "TIFF" )
1782	{
1783	// This is a TIFF IFD (bottom level)
1784
1785	// Check what tag number the IFD entry has.
1786	switch ( $Tag['Tag Number'] )
1787	{
1788	case 530: // YCbCr Sub Sampling Entry
1789
1790	// Data contains two numerical values
1791
1792	if ( ( $Tag['Data'][0] == 2 ) && ( $Tag['Data'][1] == 1 ) )
1793	{
1794	// Values are 2,1 - hence YCbCr 4:2:2
1795	return "YCbCr 4:2:2 ratio of chrominance components to the luminance components";
1796	}
1797	elseif ( ( $Tag['Data'][0] == 2 ) && ( $Tag['Data'][1] == 2 ) )
1798	{
1799	// Values are 2,2 - hence YCbCr 4:2:0
1800	return "YCbCr 4:2:0 ratio of chrominance components to the luminance components";
1801	}
1802	else
1803	{
1804	// Other values are unknown
1805	return "Unknown Reserved value (" . $Tag['Data'][0] . ")";
1806	}
1807	break;
1808
1809	default:
1810	return FALSE;
1811	}
1812	}
1813	else if ( $Tag_Definitions_Name == "EXIF" )
1814	{
1815	// This is an EXIF IFD
1816
1817	// Check what tag number the IFD entry has.
1818	switch ( $Tag['Tag Number'] )
1819	{
1820
1821	case 37121: // Components configuration
1822
1823	// Data contains 4 numerical values indicating component type
1824
1825	$output_str = "";
1826
1827	// Cycle through each component
1828	for ( $Num = 0; $Num < 4; $Num++ )
1829	{
1830	// Construct first part of text string
1831	$output_str .= "Component " . ( $Num + 1 ) . ": ";
1832
1833	// Construct second part of text string via
1834	// lookup using numerical value
1835
1836	$value = ord( $Tag['Data']{$Num} );
1837	switch( $value )
1838	{
1839	case 0:
1840	$output_str .= "Does not exist\n";
1841	break;
1842	case 1:
1843	$output_str .= "Y (Luminance)\n";
1844	break;
1845	case 2:
1846	$output_str .= "Cb (Chroma minus Blue)\n";
1847	break;
1848	case 3:
1849	$output_str .= "Cr (Chroma minus Red)\n";
1850	break;
1851	case 4:
1852	$output_str .= "Red\n";
1853	break;
1854	case 5:
1855	$output_str .= "Green\n";
1856	break;
1857	case 6:
1858	$output_str .= "Blue\n";
1859	break;
1860	default:
1861	$output_str .= "Unknown value $value\n";
1862	};
1863	}
1864
1865	// Return the completed string
1866
1867	return $output_str;
1868	break;
1869
1870
1871
1872	case 41730: // Colour Filter Array Pattern
1873
1874	// The first two characters are a SHORT for Horizontal repeat pixel unit -
1875	$n_max = get_IFD_Data_Type( substr( $Tag['Data'], 0, 2 ), 3, $Tag['Byte Align'] );
1876
1877	// The next two characters are a SHORT for Vertical repeat pixel unit -
1878	$m_max = get_IFD_Data_Type( substr( $Tag['Data'], 2, 2 ), 3, $Tag['Byte Align'] );
1879
1880
1881	// At least one camera type appears to have byte reversed values for N_Max and M_Max
1882	// Check if they need reversing
1883	if ( $n_max > 256 )
1884	{
1885	$n_max = $n_max/256 + 256*($n_max%256);
1886	}
1887
1888	if ( $m_max > 256 )
1889	{
1890	$m_max = $m_max/256 + 256*($m_max%256);
1891	}
1892
1893
1894	$output_str = "";
1895
1896
1897	// Cycle through all the elements in the resulting 2 dimensional array,
1898	for( $m = 1; $m <= $m_max; $m++ )
1899	{
1900	for( $n = 1; $n <= $n_max; $n++ )
1901	{
1902
1903	// Append text from a lookup table according to
1904	// the value read for this element
1905
1906	switch ( ord($Tag['Data']{($n_max*($m-1)+$n+3)}) )
1907	{
1908	case 0:
1909	$output_str .= "RED ";
1910	break;
1911	case 1:
1912	$output_str .= "GREEN ";
1913	break;
1914	case 2:
1915	$output_str .= "BLUE ";
1916	break;
1917	case 3:
1918	$output_str .= "CYAN ";
1919	break;
1920	case 4:
1921	$output_str .= "MAGENTA ";
1922	break;
1923	case 5:
1924	$output_str .= "YELLOW ";
1925	break;
1926	case 6:
1927	$output_str .= "WHITE ";
1928	break;
1929	default:
1930	$output_str .= "Unknown ";
1931	break;
1932	};
1933	};
1934	$output_str .= "\n";
1935	};
1936
1937	// Return the resulting string
1938	return $output_str;
1939	break;
1940
1941	default:
1942	return FALSE;
1943	}
1944	}
1945	else
1946	{
1947	// Unknown IFD type, see if it is part of a makernote
1948	return get_Makernote_Text_Value( $Tag, $Tag_Definitions_Name );
1949	}
1950
1951
1952	}
1953
1954	/******************************************************************************
1955	* End of Function: get_Tag_Text_Value
1956	******************************************************************************/
1957
1958
1959
1960
1961
1962
1963
1964
1965	/******************************************************************************
1966	*
1967	* Function: interpret_IFD
1968	*
1969	* Description: Generates html detailing the contents a single IFD.
1970	*
1971	* Parameters: IFD_array - the array containing an IFD
1972	* filename - the name of the Image file being processed ( used
1973	* by scripts which displays EXIF thumbnails)
1974	*
1975	* Returns: output_str - A string containing the HTML
1976	*
1977	******************************************************************************/
1978
1979	function interpret_IFD( $IFD_array, $filename )
1980	{
1981	// Create the output string with the table tag
1982	$output_str = "<table class=\"EXIF_Table\" border=1>\n";
1983
1984	// Create an extra output string to receive any supplementary html
1985	// which cannot go inside the table
1986	$extra_IFD_str = "";
1987
1988	// Check that the IFD array is valid
1989	if ( ( $IFD_array === FALSE ) \|\| ( $IFD_array === NULL ) )
1990	{
1991	// the IFD array is NOT valid - exit
1992	return "";
1993	}
1994
1995	// Check if this is an EXIF IFD and if there is a makernote present
1996	if ( ( $IFD_array['Tags Name'] === "EXIF" ) &&
1997	( ! array_key_exists( 37500, $IFD_array ) ) )
1998	{
1999
2000	// This is an EXIF IFD but NO makernote is present - Add a message to the output
2001	// $extra_IFD_str .= "No Makernote Present";
2002	}
2003
2004	// Cycle through each tag in the IFD
2005
2006	foreach( $IFD_array as $Tag_ID => $Exif_Tag )
2007	{
2008	$Exif_Tag['Type_src']="exif";
2009	// Ignore the non numeric elements - they aren't tags
2010	if ( ! is_numeric ( $Tag_ID ) )
2011	{
2012	// Skip Tags Name
2013	}
2014	// Check if the Tag has been decoded successfully
2015	else if ( $Exif_Tag['Decoded'] == TRUE )
2016	{
2017	// This tag has been successfully decoded
2018
2019	// Table cells won't get drawn with nothing in them -
2020	// Ensure that at least a non breaking space exists in them
2021
2022	if ( trim($Exif_Tag['Text Value']) == "" )
2023	{
2024	$Exif_Tag['Text Value'] = " ";
2025	}
2026
2027	// Check if the tag is a sub-IFD
2028	if ( $Exif_Tag['Type'] == "SubIFD" )
2029	{
2030	// This is a sub-IFD tag
2031	// Add a sub-heading for the sub-IFD
2032	$recordname=str_replace(" ","_",$Exif_Tag['Tag Name']);
2033	$recordname=str_replace("_(IFD)","", $recordname);
2034	$entete = "<fieldset id='" . $recordname . "' class='fieldset' ><legend>";
2035	$extra_IFD_str .= $entete . $Exif_Tag['Tag Name'] . " contents</legend>";
2036	// Cycle through each sub-IFD in the chain
2037	foreach ( $Exif_Tag['Data'] as $subIFD )
2038	{
2039	// Interpret this sub-IFD and add the html to the secondary output
2040	$extra_IFD_str .= interpret_IFD( $subIFD, $filename );
2041
2042	}
2043
2044	}
2045	// Check if the tag is a makernote
2046	else if ( $Exif_Tag['Type'] == "Maker Note" )
2047	{
2048	// This is a Makernote Tag
2049	// Add a sub-heading for the Makernote
2050	$extra_IFD_str .= "<h3 class=\"EXIF_Secondary_Heading\">Maker Note Contents</h3>";
2051
2052	// Interpret the Makernote and add the html to the secondary output
2053	$extra_IFD_str .= Interpret_Makernote_to_HTML( $Exif_Tag, $filename );
2054	}
2055	// Check if this is a IPTC/NAA Record within the EXIF IFD
2056	else if ( $Exif_Tag['Type'] == "IPTC" )
2057	{
2058	// This is a IPTC/NAA Record, interpret it and output to the secondary html
2059	$extra_IFD_str .= "<h3 class=\"EXIF_Secondary_Heading\">Contains IPTC/NAA Embedded in EXIF</h3>";
2060	$extra_IFD_str .=Interpret_IPTC_to_HTML( $Exif_Tag['Data'] );
2061	}
2062	// Change: Check for embedded XMP as of version 1.11
2063	// Check if this is a XMP Record within the EXIF IFD
2064	else if ( $Exif_Tag['Type'] == "XMP" )
2065	{
2066	// This is a XMP Record, interpret it and output to the secondary html
2067	$extra_IFD_str .= "<h3 class=\"EXIF_Secondary_Heading\">Contains XMP Embedded in EXIF</h3>";
2068	$extra_IFD_str .= Interpret_XMP_to_HTML( $Exif_Tag['Data'] );
2069	}
2070	// Change: Check for embedded IRB as of version 1.11
2071	// Check if this is a Photoshop IRB Record within the EXIF IFD
2072	else if ( $Exif_Tag['Type'] == "IRB" )
2073	{
2074	// This is a Photoshop IRB Record, interpret it and output to the secondary html
2075	$extra_IFD_str .= "<h3 class=\"EXIF_Secondary_Heading\">Contains Photoshop IRB Embedded in EXIF</h3>";
2076	$extra_IFD_str .= Interpret_IRB_to_HTML( $Exif_Tag['Data'], $filename );
2077	}
2078	// Check if the tag is Numeric
2079	else if ( $Exif_Tag['Type'] == "Numeric" )
2080	{
2081
2082	$output_str .= OutPut_exif($Exif_Tag);
2083	// Numeric Tag - Output text value as is.
2084	}
2085	else
2086	{
2087	$output_str .= OutPut_exif($Exif_Tag);
2088	// Other tag - Output text as preformatted
2089	}
2090
2091	}
2092	else
2093	{
2094	// Tag has NOT been decoded successfully
2095	// Hence it is either an unknown tag, or one which
2096	// requires processing at the time of html construction
2097
2098	// Table cells won't get drawn with nothing in them -
2099	// Ensure that at least a non breaking space exists in them
2100
2101	if ( trim($Exif_Tag['Text Value']) == "" )
2102	{
2103	$Exif_Tag['Text Value'] = " ";
2104	}
2105
2106	// Check if this tag is the first IFD Thumbnail
2107	if ( ( $IFD_array['Tags Name'] == "TIFF" ) &&
2108	( $Tag_ID == 513 ) )
2109	{
2110	// This is the first IFD thumbnail - Add html to the output
2111
2112	// Change: as of version 1.11 - Changed to make thumbnail link portable across directories
2113	// Build the path of the thumbnail script and its filename parameter to put in a url
2114	$link_str = get_relative_path( dirname(__FILE__) . "/get_exif_thumb.php" , getcwd ( ) );
2115	$link_str .= "?filename=";
2116	$link_str .= get_relative_path( $filename, dirname(__FILE__) );
2117
2118	// Add thumbnail link to html
2119	$output_str .= "<tr class=\"EXIF_Table_Row\"><td class=\"EXIF_Caption_Cell\">" . $Exif_Tag['Tag Name'] . "</td><td class=\"EXIF_Value_Cell\"><a class=\"EXIF_First_IFD_Thumb_Link\" href=\"$link_str\"><img class=\"EXIF_First_IFD_Thumb\" src=\"$link_str\"></a></td></tr>\n";
2120	}
2121	// Check if this is the Makernote
2122	else if ( $Exif_Tag['Type'] == "Maker Note" )
2123	{
2124	// This is the makernote, but has not been decoded
2125	// Add a message to the secondary output
2126	$extra_IFD_str .= "<h3 class=\"EXIF_Secondary_Heading\">Makernote Coding Unknown</h3>\n";
2127	}
2128	else
2129	{
2130	// This is an Unknown Tag
2131
2132	// Check if the user wants to hide unknown tags
2133	if ( $GLOBALS['HIDE_UNKNOWN_TAGS'] === FALSE )
2134	{
2135	// User wants to display unknown tags
2136	$output_str .= OutPut_exif($tabval);
2137
2138	}
2139	}
2140	}
2141	}
2142
2143	// Close the table in the output
2144	$output_str .= "</table>\n</fieldset>";
2145
2146	// Add the secondary output at the end of the main output
2147	$output_str .= "$extra_IFD_str";
2148
2149	// Return the resulting html
2150	return $output_str;
2151	}
2152
2153	/******************************************************************************
2154	* End of Function: interpret_IFD
2155	******************************************************************************/
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171	/******************************************************************************
2172	*
2173	* Function: get_IFD_Data_Type
2174	*
2175	* Description: Decodes an IFD field value from a binary data string, using
2176	* information supplied about the data type and byte alignment of
2177	* the stored data.
2178	* This function should be used for all datatypes except ASCII strings
2179	*
2180	* Parameters: input_data - a binary data string containing the IFD value,
2181	* must be exact length of the value
2182	* data_type - a number representing the IFD datatype as per the
2183	* TIFF 6.0 specification:
2184	* 1 = Unsigned 8-bit Byte
2185	* 2 = ASCII String
2186	* 3 = Unsigned 16-bit Short
2187	* 4 = Unsigned 32-bit Long
2188	* 5 = Unsigned 2x32-bit Rational
2189	* 6 = Signed 8-bit Byte
2190	* 7 = Undefined
2191	* 8 = Signed 16-bit Short
2192	* 9 = Signed 32-bit Long
2193	* 10 = Signed 2x32-bit Rational
2194	* 11 = 32-bit Float
2195	* 12 = 64-bit Double
2196	* Byte_Align - Indicates the byte alignment of the data.
2197	* MM = Motorola, MSB first, Big Endian
2198	* II = Intel, LSB first, Little Endian
2199	*
2200	* Returns: output - the value of the data (string or numeric)
2201	*
2202	******************************************************************************/
2203
2204	function get_IFD_Data_Type( $input_data, $data_type, $Byte_Align )
2205	{
2206	// Check if this is a Unsigned Byte, Unsigned Short or Unsigned Long
2207	if (( $data_type == 1 ) \|\| ( $data_type == 3 ) \|\| ( $data_type == 4 ))
2208	{
2209	// This is a Unsigned Byte, Unsigned Short or Unsigned Long
2210
2211	// Check the byte alignment to see if the bytes need tp be reversed
2212	if ( $Byte_Align == "II" )
2213	{
2214	// This is in Intel format, reverse it
2215	$input_data = strrev ( $input_data );
2216	}
2217
2218	// Convert the binary string to a number and return it
2219	return hexdec( bin2hex( $input_data ) );
2220	}
2221	// Check if this is a ASCII string type
2222	elseif ( $data_type == 2 )
2223	{
2224	// Null terminated ASCII string(s)
2225	// The input data may represent multiple strings, as the
2226	// 'count' field represents the total bytes, not the number of strings
2227	// Hence this should not be processed here, as it would have
2228	// to return multiple values instead of a single value
2229
2230	echo "<p>Error - ASCII Strings should not be processed in get_IFD_Data_Type</p>\n";
2231	return "Error Should never get here"; //explode( "\x00", $input_data );
2232	}
2233	// Check if this is a Unsigned rational type
2234	elseif ( $data_type == 5 )
2235	{
2236	// This is a Unsigned rational type
2237
2238	// Check the byte alignment to see if the bytes need to be reversed
2239	if ( $Byte_Align == "MM" )
2240	{
2241	// Motorola MSB first byte aligment
2242	// Unpack the Numerator and denominator and return them
2243	return unpack( 'NNumerator/NDenominator', $input_data );
2244	}
2245	else
2246	{
2247	// Intel LSB first byte aligment
2248	// Unpack the Numerator and denominator and return them
2249	return unpack( 'VNumerator/VDenominator', $input_data );
2250	}
2251	}
2252	// Check if this is a Signed Byte, Signed Short or Signed Long
2253	elseif ( ( $data_type == 6 ) \|\| ( $data_type == 8 ) \|\| ( $data_type == 9 ) )
2254	{
2255	// This is a Signed Byte, Signed Short or Signed Long
2256
2257	// Check the byte alignment to see if the bytes need to be reversed
2258	if ( $Byte_Align == "II" )
2259	{
2260	//Intel format, reverse the bytes
2261	$input_data = strrev ( $input_data );
2262	}
2263
2264	// Convert the binary string to an Unsigned number
2265	$value = hexdec( bin2hex( $input_data ) );
2266
2267	// Convert to signed number
2268
2269	// Check if it is a Byte above 128 (i.e. a negative number)
2270	if ( ( $data_type == 6 ) && ( $value > 128 ) )
2271	{
2272	// number should be negative - make it negative
2273	return $value - 256;
2274	}
2275
2276	// Check if it is a Short above 32767 (i.e. a negative number)
2277	if ( ( $data_type == 8 ) && ( $value > 32767 ) )
2278	{
2279	// number should be negative - make it negative
2280	return $value - 65536;
2281	}
2282
2283	// Check if it is a Long above 2147483648 (i.e. a negative number)
2284	if ( ( $data_type == 9 ) && ( $value > 2147483648 ) )
2285	{
2286	// number should be negative - make it negative
2287	return $value - 4294967296;
2288	}
2289
2290	// Return the signed number
2291	return $value;
2292	}
2293	// Check if this is Undefined type
2294	elseif ( $data_type == 7 )
2295	{
2296	// Custom Data - Do nothing
2297	return $input_data;
2298	}
2299	// Check if this is a Signed Rational type
2300	elseif ( $data_type == 10 )
2301	{
2302	// This is a Signed Rational type
2303
2304	// Signed Long not available with endian in unpack , use unsigned and convert
2305
2306	// Check the byte alignment to see if the bytes need to be reversed
2307	if ( $Byte_Align == "MM" )
2308	{
2309	// Motorola MSB first byte aligment
2310	// Unpack the Numerator and denominator
2311	$value = unpack( 'NNumerator/NDenominator', $input_data );
2312	}
2313	else
2314	{
2315	// Intel LSB first byte aligment
2316	// Unpack the Numerator and denominator
2317	$value = unpack( 'VNumerator/VDenominator', $input_data );
2318	}
2319
2320	// Convert the numerator to a signed number
2321	// Check if it is above 2147483648 (i.e. a negative number)
2322	if ( $value['Numerator'] > 2147483648 )
2323	{
2324	// number is negative
2325	$value['Numerator'] -= 4294967296;
2326	}
2327
2328	// Convert the denominator to a signed number
2329	// Check if it is above 2147483648 (i.e. a negative number)
2330	if ( $value['Denominator'] > 2147483648 )
2331	{
2332	// number is negative
2333	$value['Denominator'] -= 4294967296;
2334	}
2335
2336	// Return the Signed Rational value
2337	return $value;
2338	}
2339	// Check if this is a Float type
2340	elseif ( $data_type == 11 )
2341	{
2342	// IEEE 754 Float
2343	// TODO - EXIF - IFD datatype Float not implemented yet
2344	return "FLOAT NOT IMPLEMENTED YET";
2345	}
2346	// Check if this is a Double type
2347	elseif ( $data_type == 12 )
2348	{
2349	// IEEE 754 Double
2350	// TODO - EXIF - IFD datatype Double not implemented yet
2351	return "DOUBLE NOT IMPLEMENTED YET";
2352	}
2353	else
2354	{
2355	// Error - Invalid Datatype
2356	return "Invalid Datatype $data_type";
2357
2358	}
2359
2360	}
2361
2362	/******************************************************************************
2363	* End of Function: get_IFD_Data_Type
2364	******************************************************************************/
2365
2366
2367
2368
2369
2370
2371	/******************************************************************************
2372	*
2373	* Function: put_IFD_Data_Type
2374	*
2375	* Description: Encodes an IFD field from a value to a binary data string, using
2376	* information supplied about the data type and byte alignment of
2377	* the stored data.
2378	*
2379	* Parameters: input_data - an IFD data value, numeric or string
2380	* data_type - a number representing the IFD datatype as per the
2381	* TIFF 6.0 specification:
2382	* 1 = Unsigned 8-bit Byte
2383	* 2 = ASCII String
2384	* 3 = Unsigned 16-bit Short
2385	* 4 = Unsigned 32-bit Long
2386	* 5 = Unsigned 2x32-bit Rational
2387	* 6 = Signed 8-bit Byte
2388	* 7 = Undefined
2389	* 8 = Signed 16-bit Short
2390	* 9 = Signed 32-bit Long
2391	* 10 = Signed 2x32-bit Rational
2392	* 11 = 32-bit Float
2393	* 12 = 64-bit Double
2394	* Byte_Align - Indicates the byte alignment of the data.
2395	* MM = Motorola, MSB first, Big Endian
2396	* II = Intel, LSB first, Little Endian
2397	*
2398	* Returns: output - the packed binary string of the data
2399	*
2400	******************************************************************************/
2401
2402	function put_IFD_Data_Type( $input_data, $data_type, $Byte_Align )
2403	{
2404	// Process according to the datatype
2405	switch ( $data_type )
2406	{
2407	case 1: // Unsigned Byte - return character as is
2408	return chr($input_data);
2409	break;
2410
2411	case 2: // ASCII String
2412	// Return the string with terminating null
2413	return $input_data . "\x00";
2414	break;
2415
2416	case 3: // Unsigned Short
2417	// Check byte alignment
2418	if ( $Byte_Align == "II" )
2419	{
2420	// Intel/Little Endian - pack the short and return
2421	return pack( "v", $input_data );
2422	}
2423	else
2424	{
2425	// Motorola/Big Endian - pack the short and return
2426	return pack( "n", $input_data );
2427	}
2428	break;
2429
2430	case 4: // Unsigned Long
2431	// Check byte alignment
2432	if ( $Byte_Align == "II" )
2433	{
2434	// Intel/Little Endian - pack the long and return
2435	return pack( "V", $input_data );
2436	}
2437	else
2438	{
2439	// Motorola/Big Endian - pack the long and return
2440	return pack( "N", $input_data );
2441	}
2442	break;
2443
2444	case 5: // Unsigned Rational
2445	// Check byte alignment
2446	if ( $Byte_Align == "II" )
2447	{
2448	// Intel/Little Endian - pack the two longs and return
2449	return pack( "VV", $input_data['Numerator'], $input_data['Denominator'] );
2450	}
2451	else
2452	{
2453	// Motorola/Big Endian - pack the two longs and return
2454	return pack( "NN", $input_data['Numerator'], $input_data['Denominator'] );
2455	}
2456	break;
2457
2458	case 6: // Signed Byte
2459	// Check if number is negative
2460	if ( $input_data < 0 )
2461	{
2462	// Number is negative - return signed character
2463	return chr( $input_data + 256 );
2464	}
2465	else
2466	{
2467	// Number is positive - return character
2468	return chr( $input_data );
2469	}
2470	break;
2471
2472	case 7: // Unknown - return as is
2473	return $input_data;
2474	break;
2475
2476	case 8: // Signed Short
2477	// Check if number is negative
2478	if ( $input_data < 0 )
2479	{
2480	// Number is negative - make signed value
2481	$input_data = $input_data + 65536;
2482	}
2483	// Check byte alignment
2484	if ( $Byte_Align == "II" )
2485	{
2486	// Intel/Little Endian - pack the short and return
2487	return pack( "v", $input_data );
2488	}
2489	else
2490	{
2491	// Motorola/Big Endian - pack the short and return
2492	return pack( "n", $input_data );
2493	}
2494	break;
2495
2496	case 9: // Signed Long
2497	// Check if number is negative
2498	if ( $input_data < 0 )
2499	{
2500	// Number is negative - make signed value
2501	$input_data = $input_data + 4294967296;
2502	}
2503	// Check byte alignment
2504	if ( $Byte_Align == "II" )
2505	{
2506	// Intel/Little Endian - pack the long and return
2507	return pack( "v", $input_data );
2508	}
2509	else
2510	{
2511	// Motorola/Big Endian - pack the long and return
2512	return pack( "n", $input_data );
2513	}
2514	break;
2515
2516	case 10: // Signed Rational
2517	// Check if numerator is negative
2518	if ( $input_data['Numerator'] < 0 )
2519	{
2520	// Number is numerator - make signed value
2521	$input_data['Numerator'] = $input_data['Numerator'] + 4294967296;
2522	}
2523	// Check if denominator is negative
2524	if ( $input_data['Denominator'] < 0 )
2525	{
2526	// Number is denominator - make signed value
2527	$input_data['Denominator'] = $input_data['Denominator'] + 4294967296;
2528	}
2529	// Check byte alignment
2530	if ( $Byte_Align == "II" )
2531	{
2532	// Intel/Little Endian - pack the two longs and return
2533	return pack( "VV", $input_data['Numerator'], $input_data['Denominator'] );
2534	}
2535	else
2536	{
2537	// Motorola/Big Endian - pack the two longs and return
2538	return pack( "NN", $input_data['Numerator'], $input_data['Denominator'] );
2539	}
2540	break;
2541
2542	case 11: // Float
2543	// IEEE 754 Float
2544	// TODO - EXIF - IFD datatype Float not implemented yet
2545	return "FLOAT NOT IMPLEMENTED YET";
2546	break;
2547
2548	case 12: // Double
2549	// IEEE 754 Double
2550	// TODO - EXIF - IFD datatype Double not implemented yet
2551	return "DOUBLE NOT IMPLEMENTED YET";
2552	break;
2553
2554	default:
2555	// Error - Invalid Datatype
2556	return "Invalid Datatype $data_type";
2557	break;
2558
2559	}
2560
2561	// Shouldn't get here
2562	return FALSE;
2563	}
2564
2565	/******************************************************************************
2566	* End of Function: put_IFD_Data_Type
2567	******************************************************************************/
2568
2569
2570
2571
2572
2573	/******************************************************************************
2574	*
2575	* Function: get_IFD_value_as_text
2576	*
2577	* Description: Decodes an IFD field value from a binary data string, using
2578	* information supplied about the data type and byte alignment of
2579	* the stored data.
2580	* This function should be used for all datatypes except ASCII strings
2581	*
2582	* Parameters: input_data - a binary data string containing the IFD value,
2583	* must be exact length of the value
2584	* data_type - a number representing the IFD datatype as per the
2585	* TIFF 6.0 specification:
2586	* 1 = Unsigned 8-bit Byte
2587	* 2 = ASCII String
2588	* 3 = Unsigned 16-bit Short
2589	* 4 = Unsigned 32-bit Long
2590	* 5 = Unsigned 2x32-bit Rational
2591	* 6 = Signed 8-bit Byte
2592	* 7 = Undefined
2593	* 8 = Signed 16-bit Short
2594	* 9 = Signed 32-bit Long
2595	* 10 = Signed 2x32-bit Rational
2596	* 11 = 32-bit Float
2597	* 12 = 64-bit Double
2598	* Byte_Align - Indicates the byte alignment of the data.
2599	* MM = Motorola, MSB first, Big Endian
2600	* II = Intel, LSB first, Little Endian
2601	*
2602	* Returns: output - the value of the data (string or numeric)
2603	*
2604	******************************************************************************/
2605
2606	function get_IFD_value_as_text( $Exif_Tag )
2607	{
2608	// Create a string to receive the output text
2609	$output_str = "";
2610
2611	// Select Processing method according to the datatype
2612	switch ($Exif_Tag['Data Type'])
2613	{
2614	case 1 : // Unsigned Byte
2615	case 3 : // Unsigned Short
2616	case 4 : // Unsigned Long
2617	case 6 : // Signed Byte
2618	case 8 : // Signed Short
2619	case 9 : // Signed Long
2620
2621	// Cycle through each of the values for this tag
2622	foreach ( $Exif_Tag['Data'] as $val )
2623	{
2624	// Check that this isn't the first value,
2625	if ( $output_str != "" )
2626	{
2627	// This isn't the first value, Add a Comma and Newline to the output
2628	$output_str .= ",\n";
2629	}
2630	// Add the Value to the output
2631	$output_str .= $val;
2632	}
2633	break;
2634
2635	case 2 : // ASCII
2636	// Append all the strings together, separated by Newlines
2637	$output_str .= implode ( "\n", $Exif_Tag['Data']);
2638	break;
2639
2640	case 5 : // Unsigned Rational
2641	case 10: // Signed Rational
2642
2643	// Cycle through each of the values for this tag
2644	foreach ( $Exif_Tag['Data'] as $val )
2645	{
2646	// Check that this isn't the first value,
2647	if ( $output_str != "" )
2648	{
2649	// This isn't the first value, Add a Comma and Newline to the output
2650	$output_str .= ",\n";
2651	}
2652
2653	// Add the Full Value to the output
2654	$output_str .= $val['Numerator'] ."/" . $val['Denominator'];
2655
2656	// Check if division by zero might be a problem
2657	if ( $val['Denominator'] != 0 )
2658	{
2659	// Denominator is not zero, Add the Decimal Value to the output text
2660	$output_str .= " (" . ($val['Numerator'] / $val['Denominator']) . ")";
2661	}
2662	}
2663	break;
2664
2665	case 11: // Float
2666	case 12: // Double
2667	// TODO - EXIF - IFD datatype Double and Float not implemented yet
2668	$output_str .= "Float and Double not implemented yet";
2669	break;
2670
2671	case 7 : // Undefined
2672	// Unless the User has asked to see the raw binary data, this
2673	// type should not be displayed
2674
2675	// Check if the user has requested to see the binary data in hex
2676	if ( $GLOBALS['SHOW_BINARY_DATA_HEX'] == TRUE)
2677	{
2678	// User has requested to see the binary data in hex
2679	// Add the value in hex
2680	$output_str .= "( " . strlen( $Exif_Tag['Data'] ) . " bytes of binary data ): " . bin2hex( $Exif_Tag['Data'] ) ;
2681	}
2682	// Check if the user has requested to see the binary data as is
2683	else if ( $GLOBALS['SHOW_BINARY_DATA_TEXT'] == TRUE)
2684	{
2685	// User has requested to see the binary data as is
2686	// Add the value as is
2687	$output_str .= "( " . strlen( $Exif_Tag['Data'] ) . " bytes of binary data ): " . $Exif_Tag['Data'] ;
2688	}
2689	else
2690	{
2691	// User has NOT requested to see binary data,
2692	// Add a message indicating the number of bytes to the output
2693	$output_str .= "( " . strlen( $Exif_Tag['Data'] ) . " bytes of binary data ) " ;
2694	}
2695	break;
2696
2697	default :
2698	// Error - Unknown IFD datatype
2699	$output_str .= "Error - Exif tag data type (" . $Exif_Tag['Data Type'] .") is invalid";
2700	break;
2701	}
2702
2703	// Return the resulting text string
2704	return $output_str;
2705	}
2706
2707	/******************************************************************************
2708	* End of Function: get_IFD_value_as_text
2709	******************************************************************************/
2710
2711
2712
2713
2714	/******************************************************************************
2715	* Global Variable: IFD_Data_Sizes
2716	*
2717	* Contents: The sizes (in bytes) of each EXIF IFD Datatype, indexed by
2718	* their datatype number
2719	*
2720	******************************************************************************/
2721
2722	$GLOBALS['IFD_Data_Sizes'] = array( 1 => 1, // Unsigned Byte
2723	2 => 1, // ASCII String
2724	3 => 2, // Unsigned Short
2725	4 => 4, // Unsigned Long
2726	5 => 8, // Unsigned Rational
2727	6 => 1, // Signed Byte
2728	7 => 1, // Undefined
2729	8 => 2, // Signed Short
2730	9 => 4, // Signed Long
2731	10 => 8, // Signed Rational
2732	11 => 4, // Float
2733	12 => 8 ); // Double
2734
2735	/******************************************************************************
2736	* End of Global Variable: IFD_Data_Sizes
2737	******************************************************************************/
2738
2739
2740	function OutPut_exif($tabval) {
2741
2742	$retour = "<tr align='left' ><td>".$tabval['Type_src'] ."</td><td style='border:solid red 2px' >" .$tabval['Tag Name']. "</td><td><input size=90 name='" .$tabval['Tag Name']."' id='" .$tabval['Tag Name']. "' type='text' style='border:solid green 2px' value=' ". trim( $tabval['Text Value'] ) . "'/></td></tr>";
2743
2744	return $retour;
2745	}
2746	?>

Note: See TracBrowser for help on using the repository browser.

Download in other formats: