1Image::ExifTool(3) User Contributed Perl Documentation Image::ExifTool(3)
2
6 Image::ExifTool - Read and write meta information
7
9 use Image::ExifTool qw(:Public);
10 # ---- Simple procedural usage ----
12 # Get hash of meta information tag names/values from an image
14 $info = ImageInfo('a.jpg');
15 # ---- Object-oriented usage ----
17 # Create a new Image::ExifTool object
19 $exifTool = new Image::ExifTool;
20 # Extract meta information from an image
22 $exifTool->ExtractInfo($file, \%options);
23 # Get list of tags in the order they were found in the file
25 @tagList = $exifTool->GetFoundTags('File');
26 # Get the value of a specified tag
28 $value = $exifTool->GetValue($tag, $type);
29 # Get a tag description
31 $description = $exifTool->GetDescription($tag);
32 # Get the group name associated with this tag
34 $group = $exifTool->GetGroup($tag, $family);
35 # Set a new value for a tag
37 $exifTool->SetNewValue($tag, $newValue);
38 # Write new meta information to a file
40 $success = $exifTool->WriteInfo($srcfile, $dstfile);
41 # ...plus a host of other useful methods...
43
45 ExifTool provides an extensible set of perl modules to read and write
46 meta information in a wide variety of files, including the maker note
47 information of many digital cameras by various manufacturers such as
48 Canon, Casio, FujiFilm, GE, HP, JVC/Victor, Kodak, Leaf,
49 Minolta/Konica-Minolta, Nikon, Olympus/Epson, Panasonic/Leica,
50 Pentax/Asahi, Reconyx, Ricoh, Samsung, Sanyo, Sigma/Foveon and Sony.
51 Below is a list of file types and meta information formats currently
53 supported by ExifTool (r = read, w = write, c = create):
54 File Types
56 ------------+-------------+-------------+-------------+------------
57 3FR r | DVB r | M4A/V r | PBM r/w | RWZ r
58 3G2 r | DYLIB r | MEF r/w | PDF r/w | RM r
59 3GP r | EIP r | MIE r/w/c | PEF r/w | SO r
60 ACR r | EPS r/w | MIFF r | PFA r | SR2 r/w
61 AFM r | ERF r/w | MKA r | PFB r | SRF r
62 AI r/w | EXE r | MKS r | PFM r | SRW r/w
63 AIFF r | EXIF r/w/c | MKV r | PGF r | SVG r
64 APE r | F4A/V r | MNG r/w | PGM r/w | SWF r
65 ARW r/w | FLA r | MOS r/w | PICT r | THM r/w
66 ASF r | FLAC r | MOV r | PMP r | TIFF r/w
67 AVI r | FLV r | MP3 r | PNG r/w | TTC r
68 BMP r | FPX r | MP4 r | PPM r/w | TTF r
69 BTF r | GIF r/w | MPC r | PPT r | VRD r/w/c
70 CHM r | GZ r | MPG r | PPTX r | VSD r
71 COS r | HDP r/w | MPO r/w | PS r/w | WAV r
72 CR2 r/w | HTML r | MQV r | PSB r/w | WDP r/w
73 CRW r/w | ICC r/w/c | MRW r/w | PSD r/w | WEBP r
74 CS1 r/w | IIQ r/w | MXF r | PSP r | WEBM r
75 DCM r | IND r/w | NEF r/w | QTIF r | WMA r
76 DCP r/w | ITC r | NRW r/w | RA r | WMV r
77 DCR r | J2C r | NUMBERS r | RAF r/w | X3F r/w
78 DFONT r | JNG r/w | ODP r | RAM r | XCF r
79 DIVX r | JP2 r/w | ODS r | RAR r | XLS r
80 DJVU r | JPEG r/w | ODT r | RAW r/w | XLSX r
81 DLL r | K25 r | OGG r | RIFF r | XMP r/w/c
82 DNG r/w | KDC r | OGV r | RSRC r | ZIP r
83 DOC r | KEY r | ORF r/w | RTF r |
84 DOCX r | LNK r | OTF r | RW2 r/w |
85 DV r | M2TS r | PAGES r | RWL r/w |
86 Meta Information
88 ----------------------+----------------------+---------------------
89 EXIF r/w/c | CIFF r/w | Ricoh RMETA r
90 GPS r/w/c | AFCP r/w | Picture Info r
91 IPTC r/w/c | Kodak Meta r/w | Adobe APP14 r
92 XMP r/w/c | FotoStation r/w | MPF r
93 MakerNotes r/w/c | PhotoMechanic r/w | Stim r
94 Photoshop IRB r/w/c | JPEG 2000 r | APE r
95 ICC Profile r/w/c | DICOM r | Vorbis r
96 MIE r/w/c | Flash r | SPIFF r
97 JFIF r/w/c | FlashPix r | DjVu r
98 Ducky APP12 r/w/c | QuickTime r | M2TS r
99 PDF r/w/c | Matroska r | PE/COFF r
100 PNG r/w/c | GeoTIFF r | AVCHD r
101 Canon VRD r/w/c | PrintIM r | ZIP r
102 Nikon Capture r/w/c | ID3 r | (and more)
103
105 User-defined tags can be added via the ExifTool configuration file, or
106 by defining the %Image::ExifTool::UserDefined hash before calling any
107 ExifTool methods. See "ExifTool_config" in the ExifTool distribution
108 for more details.
109 By default ExifTool looks for a configuration file named
111 ".ExifTool_config" first in your home directory, then in the directory
112 of the application script, but a different file may be specified by
113 setting the ExifTool "configFile" variable before using
114 Image::ExifTool. For example:
115 BEGIN { $Image::ExifTool::configFile = '/Users/phil/myconfig.cfg' }
117 use Image::ExifTool;
118 or the configuration feature may be disabled by setting "configFile" to
120 an empty string:
121 BEGIN { $Image::ExifTool::configFile = '' }
123 use Image::ExifTool;
124
126 Exports nothing by default, but "ImageInfo" and all static methods may
127 be exported with the ":Public" export list.
128
130 All ExifTool features are accessed through the methods of the public
131 interface listed below. Other Image::ExifTool methods and modules
132 should not be accessed directly because their interface may change with
133 future versions.
134 None of these methods should ever die or issue warnings to STDERR if
136 called with the proper arguments (with the exception of "SetNewValue"
137 which may send an error message to STDERR, but only when called in
138 scalar context). Error and warning messages that occur during
139 processing are stored in the values of the Error and Warning tags, and
140 are accessible via the "GetValue" method.
141 new
143 Creates a new ExifTool object.
144 $exifTool = new Image::ExifTool;
146 Note that ExifTool uses AUTOLOAD to load non-member methods, so any
148 class using Image::ExifTool as a base class must define an AUTOLOAD
149 which calls Image::ExifTool::DoAutoLoad(). ie)
150 sub AUTOLOAD
152 {
153 Image::ExifTool::DoAutoLoad($AUTOLOAD, @_);
154 }
155 ImageInfo
157 Read image file and return meta information. This is the one step
158 function for retrieving meta information from an image. Internally,
159 "ImageInfo" calls "ExtractInfo" to extract the information, "GetInfo"
160 to generate the information hash, and "GetTagList" for the returned tag
161 list.
162 # return meta information for 2 tags only (procedural)
164 $info = ImageInfo($filename, $tag1, $tag2);
165 # return information about an open image file (object-oriented)
167 $info = $exifTool->ImageInfo(\*FILE);
168 # return information from image data in memory for specified tags
170 %options = (PrintConv => 0);
171 @tagList = qw(filename imagesize xmp:creator exif:* -ifd1:*);
172 $info = ImageInfo(\$imageData, \@tagList, \%options);
173 # extract information from an embedded thumbnail image
175 $info = ImageInfo('image.jpg', 'thumbnailimage');
176 $thumbInfo = ImageInfo($$info{ThumbnailImage});
177 Inputs:
179 "ImageInfo" is very flexible about the input arguments, and
180 interprets them based on their type. It may be called with one or
181 more arguments. The one required argument is either a SCALAR (the
182 image file name), a file reference (a reference to the image file)
183 or a SCALAR reference (a reference to the image in memory). Other
184 arguments are optional. The order of the arguments is not
185 significant, except that the first SCALAR is taken to be the file
186 name unless a file reference or scalar reference comes earlier in
187 the argument list.
188 Below is an explanation of how the "ImageInfo" function arguments
190 are interpreted:
191 ExifTool ref
193 "ImageInfo" may be called with an ExifTool object if desired.
194 The advantage of using the object-oriented form is that the
195 options may be set before calling "ImageInfo", and the object
196 may be used afterward to access member functions. Must be the
197 first argument if used.
198 SCALAR
200 The first scalar argument is taken to be the file name unless
201 an earlier argument specified the image data via a file
202 reference (file ref) or data reference (SCALAR ref). The
203 remaining scalar arguments are names of tags for requested
204 information. All tags are returned if no tags are specified.
205 Tag names are case-insensitive and may be prefixed by optional
207 group names separated by colons. A group name may begin with a
208 family number (ie. '1IPTC:Keywords'), to restrict matches to a
209 specific family. In the tag name, a '?' matches any single
210 character and a '*' matches zero or more characters. Thus
211 'GROUP:*' represents all tags in a specific group. Wildcards
212 may not be used in group names, with the exception that a group
213 name of '*' may be used to extract all available instances of a
214 tag regardless of the "Duplicates" setting (ie.
215 '*:WhiteBalance'). Multiple groups may be specified (ie.
216 'EXIF:Time:*' extracts all EXIF Time tags). And finally, a
217 leading '-' indicates a tag to be excluded (ie. '-IFD1:*'), or
218 a trailing '#' causes the ValueConv value to be returned for
219 this tag.
220 Note that keys in the returned information hash and elements of
222 the returned tag list are not necessarily the same as these tag
223 names because group names are removed, the case may be changed,
224 and an instance number may be added. For this reason it is
225 best to use either the keys of the returned hash or the
226 elements of the tag array when accessing the tag values.
227 See Image::ExifTool::TagNames for a complete list of ExifTool
229 tag names.
230 File ref
232 A reference to an open image file. If you use this method (or
233 a SCALAR reference) to access information in an image, the
234 FileName and Directory tags will not be returned. (Also, the
235 FileSize, FileModifyDate and FilePermissions tags will not be
236 returned unless it is a plain file.) Image processing begins
237 at the current file position, and on return the file position
238 is unspecified. May be either a standard filehandle, or a
239 reference to a File::RandomAccess object. Note that the file
240 remains open and must be closed by the caller after "ImageInfo"
241 returns.
242 [Advanced: To allow a non-rewindable stream (ie. a network
244 socket) to be re-read after processing with ExifTool, first
245 wrap the file reference in a File::RandomAccess object, then
246 pass this object to "ImageInfo". The File::RandomAccess object
247 will buffer the file if necessary, and may be used to re-read
248 the file after "ImageInfo" returns.]
249 SCALAR ref
251 A reference to image data in memory.
252 ARRAY ref
254 Reference to a list of tag names. On entry, any elements in
255 the list are added to the list of requested tags. Tags with
256 names beginning with '-' are excluded. On return, this list is
257 updated to contain an ordered list of tag keys for the returned
258 information.
259 There will be 1:1 correspondence between the requested tags and
261 the returned tag keys only if the "Duplicates" option is 0 and
262 "Sort" is 'Input'. (With "Duplicates" enabled, there may be
263 more entries in the returned list of tag keys, and with other
264 "Sort" settings the entries may not be in the same order as
265 requested.)
266 HASH ref
268 Reference to a hash containing the options settings. See
269 "Options" documentation below for a list of available options.
270 Options specified as arguments to "ImageInfo" take precedence
271 over "Options" settings.
272 Return Values:
274 "ImageInfo" returns a reference to a hash of tag key/value pairs.
275 The tag keys are identifiers, which are similar to the tag names
276 but may have an embedded instance number if multiple tags with the
277 same name were extracted from the image. Many of the ExifTool
278 functions require a tag key as an argument. Use "GetTagName
279 [static]" to get the tag name for a given tag key. Note that the
280 case of the tag names may not be the same as requested. Here is a
281 simple example to print out the information returned by
282 "ImageInfo":
283 foreach (sort keys %$info) {
285 print "$_ => $$info{$_}\n";
286 }
287 Values of the returned hash are usually simple scalars, but a
289 scalar reference is used to indicate binary data and an array
290 reference may be used to indicate a list. Also, a hash reference
291 may be returned if the "Struct" option is used. Lists of values
292 are joined by commas into a single string only if the PrintConv
293 option is enabled and the List option is disabled (which are the
294 defaults). Note that binary values are not necessarily extracted
295 unless specifically requested or the Binary option is set. If not
296 extracted the value is a reference to a string of the form "Binary
297 data ##### bytes".
298 The code below gives an example of how to handle these return
300 values, as well as illustrating the use of other ExifTool
301 functions:
302 use Image::ExifTool;
304 my $exifTool = new Image::ExifTool;
305 $exifTool->Options(Unknown => 1);
306 my $info = $exifTool->ImageInfo('a.jpg');
307 my $group = '';
308 my $tag;
309 foreach $tag ($exifTool->GetFoundTags('Group0')) {
310 if ($group ne $exifTool->GetGroup($tag)) {
311 $group = $exifTool->GetGroup($tag);
312 print "---- $group ----\n";
313 }
314 my $val = $info->{$tag};
315 if (ref $val eq 'SCALAR') {
316 if ($$val =~ /^Binary data/) {
317 $val = "($$val)";
318 } else {
319 my $len = length($$val);
320 $val = "(Binary data $len bytes)";
321 }
322 }
323 printf("%-32s : %s\n", $exifTool->GetDescription($tag), $val);
324 }
325 Notes:
327 ExifTool returns all values as byte strings of encoded characters.
328 Perl wide characters are not used. See "CHARACTER ENCODINGS" for
329 details about the encodings.
330 As well as tags representing information extracted from the image,
332 the following tags generated by ExifTool may be returned:
333 ExifToolVersion - The ExifTool version number.
335 Error - An error message if the image could not be processed.
337 Warning - A warning message if problems were encountered while
339 processing the image.
340 Options
342 Get/set ExifTool options. This function can be called to set the
343 default options for an ExifTool object. Options set this way are in
344 effect for all function calls but may be overridden by options passed
345 as arguments to some functions.
346 The initial default options are obtained from values in the
348 %Image::ExifTool::UserDefined::Options hash if it exists. See the
349 .ExifTool_config file in the full ExifTool distribution for details.
350 # exclude the 'OwnerName' tag from returned information
352 $exifTool->Options(Exclude => 'OwnerName');
353 # only get information in EXIF or MakerNotes groups
355 $exifTool->Options(Group0 => ['EXIF', 'MakerNotes']);
356 # ignore information from IFD1
358 $exifTool->Options(Group1 => '-IFD1');
359 # sort by groups in family 2, and extract unknown tags
361 $exifTool->Options(Sort => 'Group2', Unknown => 1);
362 # reset DateFormat option
364 $exifTool->Options(DateFormat => undef);
365 # do not extract duplicate tag names
367 $oldSetting = $exifTool->Options(Duplicates => 0);
368 # get current Verbose setting
370 $isVerbose = $exifTool->Options('Verbose');
371 Inputs:
373 0) ExifTool object reference.
374 1) Option parameter name.
376 2) [optional] Option parameter value (may be undef to clear
378 option).
379 3-N) [optional] Additional parameter/value pairs.
381 Option Parameters:
383 Binary
384 Flag to extract the value data for all binary tags. Tag values
385 representing large binary data blocks (ie. ThumbnailImage) are
386 not necessarily extracted unless this option is set or the tag
387 is specifically requested by name. Default is 0.
388 ByteOrder
390 The byte order for newly created EXIF segments when writing.
391 Note that if EXIF information already exists, the existing
392 order is maintained. Valid values are 'MM', 'II' and undef.
393 If ByteOrder is not defined (the default), then the maker note
394 byte order is used (if they are being copied), otherwise big-
395 endian ('MM') order is assumed. This can also be set via the
396 ExifByteOrder tag, but the ByteOrder option takes precedence if
397 both are set.
398 Charset
400 Character set for encoding character strings passed to/from
401 ExifTool with code points above U+007F. Default is UTF8.
402 Valid values are listed below, case is not significant:
403 Value Alias(es) Description
405 ----------- --------------- ----------------------------------
406 UTF8 cp65001, UTF-8 UTF-8 characters
407 Latin cp1252, Latin1 Windows Latin1 (West European)
408 Latin2 cp1250 Windows Latin2 (Central European)
409 Cyrillic cp1251, Russian Windows Cyrillic
410 Greek cp1253 Windows Greek
411 Turkish cp1254 Windows Turkish
412 Hebrew cp1255 Windows Hebrew
413 Arabic cp1256 Windows Arabic
414 Baltic cp1257 Windows Baltic
415 Vietnam cp1258 Windows Vietnamese
416 Thai cp874 Windows Thai
417 MacRoman cp10000, Roman Macintosh Roman
418 MacLatin2 cp10029 Macintosh Latin2 (Central Europe)
419 MacCyrillic cp10007 Macintosh Cyrillic
420 MacGreek cp10006 Macintosh Greek
421 MacTurkish cp10081 Macintosh Turkish
422 MacRomanian cp10010 Macintosh Romanian
423 MacIceland cp10079 Macintosh Icelandic
424 MacCroatian cp10082 Macintosh Croatian
425 Note that this option affects some types of information when
427 reading/writing the file and other types when getting/setting
428 tag values, so it must be defined for both types of access.
429 CharsetID3
431 Character encoding to assume for ID3v1 strings. By the
432 specification ID3v1 strings should be encoded in ISO 8859-1
433 (essentially Latin), but some applications may use local
434 encoding instead. Default is Latin.
435 CharsetIPTC
437 Fallback IPTC character set to assume if IPTC information
438 contains no CodedCharacterSet tag. Possible values are the
439 same as the "Charset" option. Default is Latin.
440 Note that this option affects some types of information when
442 reading/writing the file and other types when getting/setting
443 tag values, so it must be defined for both types of access.
444 CharsetPhotoshop
446 Character encoding to assume for Photoshop IRB resource names.
447 Default is Latin.
448 Compact
450 Flag to write compact output. Default is 0. The XMP
451 specification suggests that the data be padded with blanks to
452 allow in-place editing. With this flag set the 2kB of padding
453 is not written. Note that this only effects embedded XMP since
454 padding is never written for stand-alone XMP files.
455 Composite
457 Flag to calculate Composite tags automatically. Default is 1.
458 Compress
460 Flag to write new values in compressed format if possible. Has
461 no effect unless Compress::Zlib is installed. Default is 0.
462 CoordFormat
464 Format for printing GPS coordinates. This is a printf format
465 string with specifiers for degrees, minutes and seconds in that
466 order, however minutes and seconds may be omitted. For
467 example, the following table gives the output for the same
468 coordinate using various formats:
469 CoordFormat Example Output
471 ------------------- ------------------
472 q{%d deg %d' %.2f"} 54 deg 59' 22.80" (default for reading)
473 q{%d %d %.8f} 54 59 22.80000000 (default for copying)
474 q{%d deg %.4f min} 54 deg 59.3800 min
475 q{%.6f degrees} 54.989667 degrees
476 Note: To avoid loss of precision, the default coordinate
478 format is different when copying tags with
479 "SetNewValuesFromFile".
480 DateFormat
482 Format for printing date/time values. See "strftime" in the
483 POSIX package for details about the format string. The default
484 is similar to a format of "%Y:%m:%d %H:%M:%S". If date can not
485 be converted, value is left unchanged unless the StrictDate
486 option is set. Timezones are ignored.
487 Duplicates
489 Flag to return values from tags with duplicate names when
490 extracting information. Default is 1.
491 Escape
493 Escape special characters in extracted values for HTML or XML.
494 Also unescapes HTML or XML character entities in input values
495 passed to "SetNewValue". Valid settings are 'HTML', 'XML' or
496 undef. Default is undef.
497 Exclude
499 Exclude specified tags from tags extracted from an image. The
500 option value is either a tag name or reference to a list of tag
501 names to exclude. The case of tag names is not significant.
502 This option is ignored for specifically requested tags. Tags
503 may also be excluded by preceeding their name with a '-' in the
504 arguments to "ImageInfo".
505 ExtractEmbedded
507 Flag to extract information from embedded documents in EPS and
508 PDF files, embedded MPF images in JPEG and MPO files, streaming
509 metadata in AVCHD videos, and the resource fork of Mac OS
510 files. Default is 0.
511 FastScan
513 Flag to increase speed of extracting information from JPEG
514 images. With this option set to 1, ExifTool will not scan to
515 the end of a JPEG image to check for an AFCP, CanonVRD,
516 FotoStation, PhotoMechanic, MIE or PreviewImage trailer. This
517 also stops the parsing after the first comment in GIF images,
518 and at the audio/video data with RIFF-format files (AVI, WAV,
519 etc), so any trailing metadata (ie. XMP written by some
520 utilities) may be missed. When combined with the ScanForXMP
521 option, prevents scanning for XMP in recognized file types.
522 With a value of 2, ExifTool will also avoid extracting any EXIF
523 MakerNote information. Default is 0.
524 FixBase
526 Fix maker notes base offset. A common problem with image
527 editing software is that offsets in the maker notes are not
528 adjusted properly when the file is modified. This may cause
529 the wrong values to be extracted for some maker note entries
530 when reading the edited file. FixBase specifies an integer
531 value to be added to the maker notes base offset. It may also
532 be set to the empty string ('') for ExifTool will take its best
533 guess at the correct base, or undef (the default) for no base
534 adjustment.
535 GeoMaxIntSecs
537 Maximum interpolation time in seconds for geotagging.
538 Geotagging fails if the Geotime value lies between two fixes in
539 the same track which are separated by a number of seconds
540 greater than this. Default is 1800.
541 GeoMaxExtSecs
543 Maximum extrapolation time in seconds for geotagging.
544 Geotagging fails if the Geotime value lies outside a GPS track
545 by a number of seconds greater than this. Default is 1800.
546 GeoMaxHDOP
548 Maximum Horizontal (2D) Dilution Of Precision for geotagging.
549 GPS fixes are ignored if the HDOP is greater than this.
550 Default is undef.
551 GeoMaxPDOP
553 Maximum Position (3D) Dilution Of Precision for geotagging.
554 GPS fixes are ignored if the PDOP is greater than this.
555 Default is undef.
556 GeoMinSats
558 Minimum number of satellites for geotagging. GPS fixes are
559 ignored if the number of acquired satellites is less than this.
560 Default is undef.
561 Group#
563 Extract tags only for specified groups in family # (Group0
564 assumed if # not given). The option value may be a single
565 group name or a reference to a list of groups. Case is
566 significant in group names. Specify a group to be excluded by
567 preceding group name with a '-'. See "GetGroup" for a
568 description of group families, and "GetAllGroups [static]" for
569 lists of group names.
570 HtmlDump
572 Dump information in hex to dynamic HTML web page. The value
573 may be 0-3 for increasingly larger limits on the maximum block
574 size. Default is 0. Output goes to the file specified by the
575 TextOut option (\*STDOUT by default).
576 HtmlDumpBase
578 Specifies base for HTML dump offsets. If not defined, the
579 EXIF/TIFF base offset is used. Set to 0 for absolute offsets.
580 Default is undef.
581 IgnoreMinorErrors
583 Flag to ignore minor errors. Causes minor errors to be
584 downgraded to warnings, and minor warnings to be ignored. This
585 option is provided mainly to allow writing of files when minor
586 errors occur, but by ignoring some minor warnings the behaviour
587 of ExifTool may be changed to allow some questionable
588 operations to proceed (such as extracting thumbnail and preview
589 images even if they don't have a recognizable header). Minor
590 errors/warnings are denoted by '[minor]' at the start of the
591 message.
592 Lang
594 Localized language for exiftool tag descriptions, etc.
595 Available languages are given by the Image::ExifTool::Lang
596 module names (ie. 'fr'). If the specified language isn't
597 available, the option is not changed. May be set to undef to
598 select the built-in default language. Default is 'en'.
599 LargeFileSupport
601 Flag to indicate that 64-bit file offsets are supported on this
602 system. Default is 0.
603 List
605 Flag to extract lists of PrintConv values into arrays instead
606 of joining them into a string of values. The "ListSep" option
607 specifies the separator used when combining values. Default is
608 0.
609 ListSep
611 Separator string used to join lists of PrintConv values when
612 "List" option is not set. Default is ', '.
613 ListSplit
615 Regular expression used to split values of list-type tags into
616 individual items when writing. (ie. use ',\\s*' to split a
617 comma-separated list.) Default is undef.
618 MakerNotes
620 Option to extract MakerNotes and other writable subdirectories
621 (such as PrintIM) as a data block. Normally when the
622 MakerNotes are extracted they are rebuilt to include data
623 outside the boundaries of the original maker note data block,
624 but a value of 2 disables this feature. Possible values are:
625 0 - Do not extract writable subdirectories (default)
627 1 - Extract and rebuild maker notes into self-contained block
628 2 - Extract without rebuilding maker notes
629 MissingTagValue
631 Value for missing tags in expressions evaluated by
632 "SetNewValuesFromFile". If not set, a minor error is issued
633 for missing values, or the value is set to '' if
634 "IgnoreMinorErrors" is set. Default is undef.
635 Password
637 Password for processing password-protected PDF documents.
638 Ignored if a password is not required. Character encoding of
639 the password is determined by the value of the Charset option
640 at processing time. Default is undef.
641 PrintConv
643 Flag to enable automatic print conversion. Also enables
644 inverse print conversion for writing. Default is 1.
645 QuickTimeUTC
647 Flag set to assume that QuickTime date/time values are stored
648 as UTC, causing conversion to local time when they are
649 extracted. According to the QuickTime specification date/time
650 values should be UTC, but many digital cameras store local time
651 instead (presumably because they don't know the time zone), so
652 the default is 0.
653 ScanForXMP
655 Flag for scan all files (even unrecognized formats) for XMP
656 information unless XMP was already found in the file. When
657 combined with the FastScan option, only unrecognized file types
658 are scanned for XMP. Default is 0.
659 Sort
661 Specifies order to sort tags in returned list:
662 Input - Sort in same order as input tag arguments (default)
664 Alpha - Sort alphabetically
665 File - Sort in order that tags were found in the file
666 Group# - Sort by tag group, where # is zero or more family
667 numbers separated by colons. If # is not specified,
668 Group0 is assumed. See GetGroup for a description
669 of group families.
670 StrictDate
672 Flag to return undefined value for any date which can't be
673 converted when the DateFormat option is used. Default is
674 undef.
675 Struct
677 Flag to return XMP structures as hash references instead of
678 flattening into individual tags. If not defined (the default),
679 tags are flattened when reading (with ExtractInfo), and
680 structured when copying (with "SetNewValuesFromFile"). Has no
681 effect when writing since both flattened and structured tags
682 may always be written. Possible values are:
683 undef - Read flattened tags, copy structured tags (default)
685 0 - Read and copy flattened tags
686 1 - Read and copy structured tags
687 TextOut
689 Output file reference for Verbose and HtmlDump options.
690 Default is \*STDOUT.
691 Unknown
693 Flag to get the values of unknown tags. If set to 1, unknown
694 tags are extracted from EXIF (or other tagged-format)
695 directories. If set to 2, unknown tags are also extracted from
696 binary data blocks. Default is 0.
697 Verbose
699 Print verbose messages to file specified by TextOut option.
700 Value may be from 0 to 5 for increasingly verbose messages.
701 Default is 0. With the verbose option set, messages are
702 printed to the console as the file is parsed. Level 1 prints
703 the tag names and raw values. Level 2 adds more details about
704 the tags. Level 3 adds a hex dump of the tag data, but with
705 limits on the number of bytes dumped. Levels 4 and 5 remove
706 the dump limit on tag values and JPEG segment data
707 respectively.
708 Return Values:
710 The original value of the last specified parameter.
711 ClearOptions
713 Reset all options to their default values. Loads user-defined default
714 option values from the %Image::ExifTool::UserDefined::Options hash in
715 the .ExifTool_config file if it exists.
716 $exifTool->ClearOptions();
718 Inputs:
720 0) ExifTool object reference
721 Return Values:
723 (none)
724 ExtractInfo
726 Extract all meta information from an image.
727 $success = $exifTool->ExtractInfo('image.jpg', \%options);
729 Inputs:
731 "ExtractInfo" takes exactly the same arguments as "ImageInfo". The
732 only difference is that a list of tag keys is not returned if an
733 ARRAY reference is given. The following options are effective in
734 the call to "ExtractInfo":
735 Binary, Charset, CharsetID3, CharsetIPTC, Composite,
737 ExtractEmbedded, FastScan, FixBase, HtmlDump, HtmlDumpBase,
738 IgnoreMinorErrors, Lang, LargeFileSupport, MakerNotes, ScanForXMP,
739 Struct, TextOut, Unknown and Verbose.
740 Return Value:
742 1 if this was a recognized file format, 0 otherwise (and 'Error'
743 tag set).
744 GetInfo
746 "GetInfo" is called to return meta information after it has been
747 extracted from the image by a previous call to "ExtractInfo" or
748 "ImageInfo". This function may be called repeatedly after a single call
749 to "ExtractInfo" or "ImageInfo".
750 # get image width and hieght only
752 $info = $exifTool->GetInfo('ImageWidth', 'ImageHeight');
753 # get information for all tags in list (list updated with tags found)
755 $info = $exifTool->GetInfo(\@ioTagList);
756 # get all information in Author or Location groups
758 $info = $exifTool->GetInfo({Group2 => ['Author', 'Location']});
759 Inputs:
761 Inputs are the same as "ExtractInfo" and "ImageInfo" except that an
762 image can not be specified. Options in effect are:
763 Charset, CoordFormat, DateFormat, Duplicates, Escape, Exclude,
765 Group#, Lang, List, ListSep, PrintConv, Sort (if a tag list
766 reference is given) and StrictDate.
767 Return Value:
769 Reference to information hash, the same as with "ImageInfo".
770 WriteInfo
772 Write meta information to a file. The specified source file is
773 rewritten to the same-type destination file with new information as
774 specified by previous calls to "SetNewValue". The necessary segments
775 and/or directories are created in the destination file as required to
776 store the specified information. May be called repeatedly to write the
777 same information to additional files without the need to call
778 "SetNewValue" again.
779 # add information to a source file, writing output to new file
781 $exifTool->WriteInfo($srcfile, $dstfile);
782 # create XMP data file from scratch
784 $exifTool->WriteInfo(undef, $dstfile, 'XMP');
785 # overwrite file (you do have backups, right?)
787 $exifTool->WriteInfo($srcfile);
788 Inputs:
790 0) ExifTool object reference
791 1) Source file name, file reference, scalar reference, or undef to
793 create a file from scratch
794 2) [optional] Destination file name, file reference, scalar
796 reference, or undef to overwrite the original file
797 3) [optional] Destination file type
799 Return Value:
801 1 if file was written OK, 2 if file was written but no changes
802 made, 0 on file write error.
803 If an error code is returned, an Error tag is set and
805 GetValue('Error') can be called to obtain the error description. A
806 Warning tag may be set even if this routine is successful. Calling
807 WriteInfo clears any pre-existing Error and Warning tags.
808 $errorMessage = $exifTool->GetValue('Error');
810 $warningMessage = $exifTool->GetValue('Warning');
811 Notes:
813 The source file name may be undefined to create a file from scratch
814 (currently only XMP, MIE, ICC, VRD and EXIF files can be created in
815 this way -- see "CanCreate" for details). If undefined, the
816 destination file type is required unless the type can be determined
817 from the destination file name.
818 If a destination file name is given, the specified file must not
820 exist because an existing destination file will not be overwritten.
821 The destination file name may be undefined to overwrite the
822 original file (make sure you have backups!). In this case, if a
823 source file name is provided, a temporary file is created and
824 renamed to replace the source file if no errors occurred while
825 writing. Otherwise, if a source file reference or scalar reference
826 is used, the image is first written to memory then copied back to
827 replace the original if there were no errors.
828 The destination file type is only used if the source file is
830 undefined.
831 On Mac OS systems, the file resource fork is preserved if this
833 routine is called with a source file name.
834 The following ExifTool options are effective in the call to
836 "WriteInfo":
837 ByteOrder, Charset, CharsetID3, CharsetIPTC, Compact, Compress,
839 FixBase, IgnoreMinorErrors and Verbose.
840 CombineInfo
842 Combine information from more than one information hash into a single
843 hash.
844 $info = $exifTool->CombineInfo($info1, $info2, $info3);
846 Inputs:
848 0) ExifTool object reference
849 1-N) Information hash references
851 If the Duplicates option is disabled and duplicate tags exist, the
853 order of the hashes is significant. In this case, the value used is
854 the first value found as the hashes are scanned in order of input. The
855 Duplicates option is the only option that is in effect for this
856 function.
857 GetTagList
859 Get a sorted list of tags from the specified information hash or tag
860 list.
861 @tags = $exifTool->GetTagList($info, 'Group0');
863 Inputs:
865 0) ExifTool object reference,
866 1) [optional] Information hash reference or tag list reference,
868 2) [optional] Sort order ('File', 'Input', 'Alpha' or 'Group#').
870 If the information hash or tag list reference is not provided, then
872 the list of found tags from the last call to "ImageInfo",
873 "ExtractInfo" or "GetInfo" is used instead, and the result is the
874 same as if "GetFoundTags" was called. If sort order is not
875 specified, the sort order is taken from the current options
876 settings.
877 Return Values:
879 A list of tag keys in the specified order.
880 GetFoundTags
882 Get list of found tags in specified sort order. The found tags are the
883 tags for the information obtained from the most recent call to
884 "ImageInfo", "ExtractInfo" or "GetInfo" for this object.
885 @tags = $exifTool->GetFoundTags('File');
887 Inputs:
889 0) ExifTool object reference
890 1) [optional] Sort order ('File', 'Input', 'Alpha' or 'Group#')
892 If sort order is not specified, the sort order from the ExifTool
894 options is used.
895 Return Values:
897 A list of tag keys in the specified order.
898 GetRequestedTags
900 Get list of requested tags. These are the tags that were specified in
901 the arguments of the most recent call to "ImageInfo", "ExtractInfo" or
902 "GetInfo", including tags specified via a tag list reference. Shortcut
903 tags are expanded in the list.
904 @tags = $exifTool->GetRequestedTags();
906 Inputs:
908 (none)
909 Return Values:
911 List of requested tag keys in the same order that the tags were
912 specified. Note that this list will be empty if tags were not
913 specifically requested (ie. If extracting all tags).
914 GetValue
916 Get the value of a specified tag. The returned value is either the
917 human-readable (PrintConv) value, the converted machine-readable
918 (ValueConv) value, or the original raw (Raw) value. If the value type
919 is not specified, the PrintConv value is returned if the PrintConv
920 option is set, otherwise the ValueConv value is returned. The
921 PrintConv values are same as the values returned by "ImageInfo" and
922 "GetInfo" in the tag/value hash unless the PrintConv option is
923 disabled.
924 Tags which represent lists of multiple values (as may happen with
926 'Keywords' for example) are handled specially. In scalar context, the
927 returned PrintConv value for these tags is either a string of values or
928 a list reference (depending on the List option setting), and the
929 ValueConv value is always a list reference. But in list context,
930 "GetValue" always returns the list itself.
931 Note that "GetValue" requires a case-sensitive tag key as an argument.
933 To retrieve tag information based on a case-insensitive tag name (with
934 an optional group specifier), use "GetInfo" instead.
935 # PrintConv example
937 my $val = $exifTool->GetValue($tag);
938 if (ref $val eq 'SCALAR') {
939 print "$tag = (unprintable value)\n";
940 } else {
941 print "$tag = $val\n";
942 }
943 # ValueConv examples
945 my $val = $exifTool->GetValue($tag, 'ValueConv');
946 if (ref $val eq 'ARRAY') {
947 print "$tag is a list of values\n";
948 } elsif (ref $val eq 'SCALAR') {
949 print "$tag represents binary data\n";
950 } else {
951 print "$tag is a simple scalar\n";
952 }
953 my @keywords = $exifTool->GetValue('Keywords', 'ValueConv');
955 The following options are in effect when <L/GetValue> is called:
957 Charset, CoordFormat, DateFormat, Escape, Lang, List, ListSep,
959 PrintConv and StrictDate.
960 Inputs:
962 0) ExifTool object reference
963 1) Tag key
965 2) [optional] Value type, 'PrintConv', 'ValueConv', 'Both' or 'Raw'
967 The default value type is 'PrintConv' if the PrintConv option is
969 set, otherwise the default is 'ValueConv'. A value type of 'Both'
970 returns both ValueConv and PrintConv values as a list.
971 Return Values:
973 The value of the specified tag. If the tag represents a list of
974 values and the List option is disabled then PrintConv returns a
975 string of values, otherwise a reference to the list is returned in
976 scalar context. The list itself is returned in list context.
977 Values may also be scalar references to binary data, or hash
978 references if the Struct option is set.
979 Note: It is possible for "GetValue" to return an undefined
981 ValueConv or PrintConv value (or an empty list in list context)
982 even if the tag exists, since it is possible for these conversions
983 to yield undefined values.
984 SetNewValue
986 Set the new value for a tag. The routine may be called multiple times
987 to set the values of many tags before using "WriteInfo" to write the
988 new values to an image.
989 For list-type tags (like Keywords), either call repeatedly with the
991 same tag name for each value, or call with a reference to the list of
992 values.
993 # set a new value for a tag (errors go to STDERR)
995 $success = $exifTool->SetNewValue($tag, $value);
996 # set a new value and capture any error message
998 ($success, $errStr) = $exifTool->SetNewValue($tag, $value);
999 # delete information for specified tag if it exists in image
1001 # (also resets AddValue and DelValue options for this tag)
1002 $exifTool->SetNewValue($tag);
1003 # reset all values from previous calls to SetNewValue()
1005 $exifTool->SetNewValue();
1006 # delete a specific keyword
1008 $exifTool->SetNewValue('Keywords', $word, DelValue => 1);
1009 # set keywords (a list-type tag) with two new values
1011 $exifTool->SetNewValue(Keywords => 'word1');
1012 $exifTool->SetNewValue(Keywords => 'word2');
1013 # equivalent, but set both in one call using an array reference
1014 $exifTool->SetNewValue(Keywords => ['word1','word2']);
1015 # add a keyword without replacing existing keywords in the file
1017 $exifTool->SetNewValue(Keywords => $word, AddValue => 1);
1018 # set a tag in a specific group
1020 $exifTool->SetNewValue(Headline => $val, Group => 'XMP');
1021 $exifTool->SetNewValue('XMP:Headline' => $val); # (equivalent)
1022 # shift original date/time back by 2.5 hours
1024 $exifTool->SetNewValue(DateTimeOriginal => '2:30', Shift => -1);
1025 # write a tag only if it had a specific value
1027 # (the order of the following calls is not significant)
1028 $exifTool->SetNewValue(Title => $oldVal, DelValue => 1);
1029 $exifTool->SetNewValue(Title => $newVal);
1030 # write tag by numerical value
1032 $exifTool->SetNewValue(Orientation => 6, Type => 'ValueConv');
1033 $exifTool->SetNewValue('Orientation#' => 6); # (equivalent)
1034 # delete all but EXIF tags
1036 $exifTool->SetNewValue('*'); # delete all...
1037 $exifTool->SetNewValue('EXIF:*', undef, Replace => 2); # ...but EXIF
1038 # write structured information as a HASH reference
1040 $exifTool->SetNewValue('XMP:Flash' => {
1041 mode => 'on',
1042 fired => 'true',
1043 return => 'not'
1044 });
1045 # write structured information as a serialized string
1047 $exifTool->SetNewValue('XMP:Flash'=>'{mode=on,fired=true,return=not}');
1048 (See <http://owl.phy.queensu.ca/~phil/exiftool/struct.html#Serialize>
1050 for a description of the structure serialization technique.)
1051 Inputs:
1053 0) ExifTool object reference
1054 1) [optional] Tag key or tag name, or undef to clear all new
1056 values. A tag name of '*' can be used when deleting tags to delete
1057 all tags, or all tags in a specified group. The tag name may be
1058 prefixed by group name, separated by a colon (ie. 'EXIF:Artist'),
1059 which is equivalent to using a Group option argument. Also, a '#'
1060 may be appended to the tag name (ie. 'EXIF:Orientation#'), with
1061 the same effect as setting Type to 'ValueConv'.
1062 2) [optional] New value for tag. Undefined to delete tag from
1064 file. May be a scalar, scalar reference, list reference to set a
1065 list of values, or hash reference for a structure. Integer values
1066 may be specified as a hexadecimal string (with a leading '0x'), and
1067 simple rational values may be specified in fractional form (ie.
1068 '4/10'). Structure tags may be specified either as a hash
1069 reference or a serialized string (see the last two examples above).
1070 3-N) [optional] SetNewValue option/value pairs (see below).
1072 SetNewValue Options:
1074 AddValue
1075 Specifies that the value be added to an existing list rather
1076 than replacing the list. Valid values are 0 or 1. Default is
1077 0.
1078 DelValue
1080 Delete the existing tag if it has the specified value. Valid
1081 values are 0 or 1. Default is 0.
1082 EditGroup
1084 Create tags in existing groups only. Don't create new group.
1085 Valid values are 0 and 1. Default is 0.
1086 EditOnly
1088 Edit tag only if it already exists. Don't create new tag.
1089 Valid values are 0 and 1. Default is 0.
1090 Group
1092 Specifies group name where tag should be written. If not
1093 specified, tag is written to highest priority group as
1094 specified by "SetNewGroups". Any family 0 or 1 group name may
1095 be used. Case is not significant.
1096 NoShortcut
1098 Disables default behaviour of looking up tag in shortcuts if
1099 not found otherwise.
1100 Protected
1102 Bit mask for tag protection levels to write. Bit 0x01 allows
1103 writing of 'unsafe' tags (ie. tags not copied automatically via
1104 "SetNewValuesFromFile"). Bit 0x02 allows writing of
1105 'protected' tags, and should only be used internally by
1106 ExifTool. See Image::ExifTool::TagNames, for a list of tag
1107 names indicating 'unsafe' and 'protected' tags. Default is 0.
1108 Replace
1110 Flag to replace the previous new values for this tag (ie.
1111 replace the values set in previous calls to "SetNewValue").
1112 This option is most commonly used to replace previously-set new
1113 values for list-type tags. Valid values are 0 (set new value
1114 normally -- adds to new values for list-type tags), 1 (reset
1115 previous new values for this tag and replace with the specified
1116 new value) or 2 (reset previous new values only).
1117 Shift
1119 Shift the tag by the specified value. Currently only date/time
1120 tags and tags with numerical values may be shifted. Undefined
1121 for no shift, 1 for a positive shift, or -1 for a negative
1122 shift. A value of 0 causes a positive shift to be applied if
1123 the tag is shiftable and AddValue is set, or a negative shift
1124 for date/time tags only if DelValue is set. Default is undef.
1125 See Image::ExifTool::Shift.pl for more information.
1126 Type
1128 The type of value being set. Valid values are PrintConv,
1129 ValueConv or Raw. Default is PrintConv if the "PrintConv"
1130 Option is set, otherwise ValueConv.
1131 Return Values:
1133 In scalar context, returns the number of tags set and error
1134 messages are printed to STDERR. In list context, returns the
1135 number of tags set, and the error string (which is undefined if
1136 there was no error).
1137 Note:
1139 When deleting groups of tags, the Replace option may be used as in
1140 the last example above to exclude specific groups from a mass
1141 delete. However, this technique may not be used to exclude
1142 individual tags. Instead, use "SetNewValuesFromFile" to recover
1143 the values of individual tags after deleting a group.
1144 The following ExifTool options are effective in the call to
1146 "SetNewValue":
1147 Charset, Escape, IgnoreMinorErrors, Lang, ListSep, ListSplit, PrintConv
1149 and Verbose.
1150 SetNewValuesFromFile
1152 A very powerful routine that sets new values for tags from information
1153 found in a specified file.
1154 # set new values from all information in a file...
1156 my $info = $exifTool->SetNewValuesFromFile($srcFile);
1157 # ...then write these values to another image
1158 my $result = $exifTool->WriteInfo($file2, $outFile);
1159 # set all new values, preserving original groups
1161 $exifTool->SetNewValuesFromFile($srcFile, '*:*');
1162 # set specific information
1164 $exifTool->SetNewValuesFromFile($srcFile, @tags);
1165 # set new value from a different tag in specific group
1167 $exifTool->SetNewValuesFromFile($fp, 'IPTC:Keywords>XMP-dc:Subject');
1168 # add all IPTC keywords to XMP subject list
1170 $exifTool->SetNewValuesFromFile($fp, 'IPTC:Keywords+>XMP-dc:Subject');
1171 # set new value from an expression involving other tags
1173 $exifTool->SetNewValuesFromFile($file,
1174 'Comment<ISO=$ISO Aperture=$aperture Exposure=$shutterSpeed');
1175 # set keywords list from the values of multiple tags
1177 $exifTool->SetNewValuesFromFile($file, { Replace => 0 },
1178 'keywords<xmp:subject', 'keywords<filename');
1179 # copy all EXIF information, preserving the original IFD
1181 # (without '>*.*' tags would be copied to the preferred EXIF IFD)
1182 $exifTool->SetNewValuesFromFile($file, 'EXIF:*>*:*');
1183 Inputs:
1185 0) ExifTool object reference
1186 1) File name, file reference, or scalar reference
1188 2-N) [optional] List of tag names to set or options hash
1190 references. All writable tags are set if none are specified. The
1191 tag names are not case sensitive, and may be prefixed by an
1192 optional family 0 or 1 group name, separated by a colon (ie.
1193 'exif:iso'). A leading '-' indicates tags to be excluded (ie.
1194 '-comment'), or a trailing '#' causes the ValueConv value to be
1195 copied (same as setting the Type option to 'ValueConv' for this tag
1196 only). An asterisk ('*') may be used for the tag name, and is
1197 useful when a group is specified to set all tags from a group (ie.
1198 'XMP:*'). A special feature allows tag names of the form
1199 'SRCTAG>DSTTAG' (or 'DSTTAG<SRCTAG') to be specified to copy
1200 information to a tag with a different name or a specified group.
1201 Both 'SRCTAG' and 'DSTTAG' may use '*' and/or be prefixed by a
1202 group name (ie. 'modifyDate>fileModifyDate' or '*>xmp:*'). Copied
1203 tags may also be added or deleted from a list with arguments of the
1204 form 'SRCTAG+>DSTTAG' or 'SRCTAG->DSTTAG'. Tags are evaluated in
1205 order, so exclusions apply only to tags included earlier in the
1206 list. An extension of this feature allows the tag value to be set
1207 from an expression containing tag names with leading '$' symbols
1208 (ie. 'Comment<the file is $filename'). Braces '{}' may be used
1209 around the tag name to separate it from subsequent text, and a '$$'
1210 is used to to represent a '$' symbol. (The behaviour for missing
1211 tags in expressions is defined by the "MissingTagValue" option.)
1212 Multiple options hash references may be passed to set different
1213 options for different tags. Options apply to subsequent tags in the
1214 argument list.
1215 By default, this routine will commute information between same-
1217 named tags in different groups, allowing information to be
1218 translated between images with different formats. This behaviour
1219 may be modified by specifying a group name for extracted tags (even
1220 if '*' is used as a group name), in which case the information is
1221 written to the original group, unless redirected to a different
1222 group. When '*' is used for a group name, the family 1 group of
1223 the original tag is preserved. (For example, specifying '*:*'
1224 copies all information while preserving the original family 1
1225 groups.)
1226 SetNewValuesFromFile Options:
1228 The options are the same was for "SetNewValue", and are passed
1229 directly to "SetNewValue" internally, with a few exceptions:
1230 - The Replace option defaults to 1 instead of 0 as with
1232 "SetNewValue".
1233 - The AddValue or DelValue option is set for individual tags if
1235 '+>' or '->' (or '+<' or '-<') are used.
1236 - The Group option is set for tags where a group name is given.
1238 - The Protected flag is set to 1 for individually specified tags.
1240 - The Type option also applies to extracted tags.
1242 Return Values:
1244 A hash of information that was set successfully. May include
1245 Warning or Error entries if there were problems reading the input
1246 file.
1247 Notes:
1249 The PrintConv option applies to this routine, but it normally
1250 should be left on to provide more reliable transfer of information
1251 between groups.
1252 If a preview image exists, it is not copied. The preview image
1254 must be transferred separately if desired, in a separate call to
1255 "WriteInfo"
1256 When simply copying all information between files of the same type,
1258 it is usually desirable to preserve the original groups by
1259 specifying '*:*' for the tags to set.
1260 The "Duplicates" option is always in effect for tags extracted from
1262 the source file using this routine.
1263 The "Struct" option is enabled by default for tags extracted by
1265 this routine. This allows the hierarchy of complex structures to
1266 be preserved when copying, but the Struct option may be set to 0 to
1267 override this behaviour and copy as flattened tags instead.
1268 GetNewValues
1270 Get list of new Raw values for the specified tag. These are the values
1271 that will be written to file. Only tags which support a 'List' may
1272 return more than one value.
1273 $rawVal = $exifTool->GetNewValues($tag);
1275 @rawVals = $exifTool->GetNewValues($tag);
1277 Inputs:
1279 0) ExifTool object reference
1280 1) Tag name (case sensitive, may be prefixed by family 0 or 1 group
1282 name)
1283 Return Values:
1285 List of new Raw tag values, or first value in list when called in
1286 scalar context. The list may be empty either if the tag isn't
1287 being written, or if it is being deleted (ie. if "SetNewValue" was
1288 called without a value).
1289 CountNewValues
1291 Return the total number of new values set.
1292 $numSet = $exifTool->CountNewValues();
1294 ($numSet, $numPseudo) = $exifTool->CountNewValues();
1295 Inputs:
1297 0) ExifTool object reference
1298 Return Values:
1300 In scalar context, returns the total number of tags with new values
1301 set. In list context, also returns the number of "pseudo" tag
1302 values which have been set. "Pseudo" tags are tags like FileName
1303 and FileModifyDate which are not contained within the file and can
1304 be changed without rewriting the file.
1305 SaveNewValues
1307 Save state of new values to be later restored by "RestoreNewValues".
1308 $exifTool->SaveNewValues(); # save state of new values
1310 $exifTool->SetNewValue(ISO => 100); # set new value for ISO
1311 $exifTool->WriteInfo($src, $dst1); # write ISO + previous new values
1312 $exifTool->RestoreNewValues(); # restore previous new values
1313 $exifTool->WriteInfo($src, $dst2); # write previous new values only
1314 Inputs:
1316 0) ExifTool object reference
1317 Return Value:
1319 None.
1320 RestoreNewValues
1322 Restore new values to the settings that existed when "SaveNewValues"
1323 was last called. May be called repeatedly after a single call to
1324 "SaveNewValues". See "SaveNewValues" above for an example.
1325 Inputs:
1327 0) ExifTool object reference
1328 Return Value:
1330 None.
1331 SetFileModifyDate
1333 Set the file modification time from the new value of the FileModifyDate
1334 tag.
1335 $exifTool->SetNewValue(FileModifyDate => '2000:01:02 03:04:05-05:00',
1337 Protected => 1);
1338 $result = $exifTool->SetFileModifyDate($file);
1339 Inputs:
1341 0) ExifTool object reference
1342 1) File name
1344 2) [optional] Base time if applying shift (days before $^T)
1346 Return Value:
1348 1 if the time was changed, 0 if nothing was done, or -1 if there
1349 was an error setting the time.
1350 Notes:
1352 Equivalent to, but more efficient than calling "WriteInfo" when
1353 only the FileModifyDate tag has been set. If a timezone is not
1354 specified in the FileModifyDate value, local time is assumed. When
1355 shifting FileModifyDate, the time of the original file is used
1356 unless an optional base time is specified.
1357 SetFileName
1359 Set the file name and directory. If not specified, the new file name
1360 is derived from the new values of the FileName and Directory tags. If
1361 the FileName tag contains a '/', then the file is renamed into a new
1362 directory. If FileName ends with '/', then it is taken as a directory
1363 name and the file is moved into the new directory. The new value for
1364 the Directory tag takes precedence over any directory specified in
1365 FileName.
1366 $result = $exifTool->SetFileName($file);
1368 $result = $exifTool->SetFileName($file, $newName);
1369 Inputs:
1371 0) ExifTool object reference
1372 1) Current file name
1374 2) [optional] New file name
1376 Return Value:
1378 1 if the file name or directory was changed, 0 if nothing was done,
1379 or -1 if there was an error renaming the file.
1380 Notes:
1382 Will not overwrite existing files. New directories are created as
1383 necessary.
1384 SetNewGroups
1386 Set the order of the preferred groups when adding new information. In
1387 subsequent calls to "SetNewValue", new information will be created in
1388 the first valid group of this list. This has an impact only if the
1389 group is not specified when calling "SetNewValue" and if the tag name
1390 exists in more than one group. The default order is EXIF, IPTC then
1391 XMP. Any family 0 group name may be used. Case is not significant.
1392 $exifTool->SetNewGroups('XMP','EXIF','IPTC');
1394 Inputs:
1396 0) ExifTool object reference
1397 1-N) Groups in order of priority. If no groups are specified, the
1399 priorities are reset to the defaults.
1400 Return Value:
1402 None.
1403 GetNewGroups
1405 Get current group priority list.
1406 @groups = $exifTool->GetNewGroups();
1408 Inputs:
1410 0) ExifTool object reference
1411 Return Values:
1413 List of group names in order of write priority. Highest priority
1414 first.
1415 GetTagID
1417 Get the ID for the specified tag. The ID is the IFD tag number in EXIF
1418 information, the property name in XMP information, or the data offset
1419 in a binary data block. For some tags, such as Composite tags where
1420 there is no ID, an empty string is returned. In list context, also
1421 returns a language code for the tag if available and different from the
1422 default language (ie. with alternate language entries for XMP "lang-
1423 alt" tags).
1424 $id = $exifTool->GetTagID($tag);
1426 ($id, $lang) = $exifTool->GetTagID($tag);
1427 Inputs:
1429 0) ExifTool object reference
1430 1) Tag key
1432 Return Values:
1434 In scalar context, returns the tag ID or '' if there is no ID for
1435 this tag. In list context, returns the tag ID (or '') and the
1436 language code (or undef).
1437 GetDescription
1439 Get description for specified tag. This function will always return a
1440 defined value. In the case where the description doesn't exist, one is
1441 generated from the tag name.
1442 Inputs:
1444 0) ExifTool object reference
1445 1) Tag key
1447 Return Values:
1449 A description for the specified tag.
1450 GetGroup
1452 Get group name(s) for a specified tag.
1453 # return family 0 group name (ie. 'EXIF');
1455 $group = $exifTool->GetGroup($tag, 0);
1456 # return all groups (ie. qw{EXIF IFD0 Author Main})
1458 @groups = $exifTool->GetGroup($tag);
1459 # return groups as a string (ie. 'Main:IFD0:Author')
1461 $group = $exifTool->GetGroup($tag, ':3:1:2');
1462 # return groups as a simplified string (ie. 'IFD0:Author')
1464 $group = $exifTool->GetGroup($tag, '3:1:2');
1465 Inputs:
1467 0) ExifTool object reference
1468 1) Tag key
1470 2) [optional] Group family number, or string of numbers separated
1472 by colons
1473 Return Values:
1475 Group name (or '' if tag has no group). If no group family is
1476 specified, "GetGroup" returns the name of the group in family 0
1477 when called in scalar context, or the names of groups for all
1478 families in list context. Returns a string of group names
1479 separated by colons if the input group family contains a colon.
1480 The string is simplified to remove a leading 'Main:' and adjacent
1481 identical group names unless the family string begins with a colon.
1482 Notes:
1484 The group family numbers are currently available:
1485 0) Information Type (ie. EXIF, XMP, IPTC)
1487 1) Specific Location (ie. IFD0, XMP-dc)
1488 2) Category (ie. Author, Time)
1489 3) Document Number (ie. Main, Doc1, Doc3-2)
1490 4) Instance Number (ie. Copy1, Copy2, Copy3...)
1491 Families 0 and 1 are based on the file structure, and are similar
1493 except that family 1 is more specific and sub-divides some groups
1494 to give more detail about the specific location where the
1495 information was found. For example, the EXIF group is split up
1496 based on the specific IFD (Image File Directory), the MakerNotes
1497 group is divided into groups for each manufacturer, and the XMP
1498 group is separated based on the XMP namespace prefix. Note that
1499 only common XMP namespaces are listed in the GetAllGroups
1500 documentation, but additional namespaces may be present in some XMP
1501 data. Also note that the 'XMP-xmp...' group names may appear in
1502 the older form 'XMP-xap...' since these names evolved as the XMP
1503 standard was developed. The ICC_Profile group is broken down to
1504 give information about the specific ICC_Profile tag from which
1505 multiple values were extracted. As well, information extracted
1506 from the ICC_Profile header is separated into the ICC-header group.
1507 Family 2 classifies information based on the logical category to
1509 which the information refers.
1510 Family 3 gives the document number for tags extracted from embedded
1512 documents, or 'Main' for tags from the main document. (See the
1513 "ExtractEmbedded" option for extracting tags from embedded
1514 documents.) Nested sub-documents (if they exist) are indicated by
1515 numbers separated with dashes in the group name, to an arbitrary
1516 depth. (ie. 'Doc2-3-1' is the 1st sub-sub-document of the 3rd sub-
1517 document of the 2nd embedded document of the main file.)
1518 Family 4 provides a method for differentiating tags when multiple
1520 tags exist with the same name in the same location. The primary
1521 instance of a tag (the tag extracted when the Duplicates option is
1522 disabled and no group is specified) has no family 4 group name, but
1523 additional instances have have family 4 group names of 'Copy1',
1524 'Copy2', 'Copy3', etc.
1525 See "GetAllGroups [static]" for complete lists of group names.
1527 GetGroups
1529 Get list of group names that exist in the specified information.
1530 @groups = $exifTool->GetGroups($info, 2);
1532 @groups = $exifTool->GetGroups('3:1');
1533 Inputs:
1535 0) ExifTool object reference
1536 1) [optional] Info hash ref (default is all extracted info)
1538 2) [optional] Group family number, or string of numbers (default 0)
1540 Return Values:
1542 List of group names in alphabetical order. If information hash is
1543 not specified, the group names are returned for all extracted
1544 information. See "GetGroup" for an description of family numbers
1545 and family number strings.
1546 BuildCompositeTags
1548 Builds composite tags from required tags. The composite tags are
1549 convenience tags which are derived from the values of other tags. This
1550 routine is called automatically by "ImageInfo" and "ExtractInfo" if the
1551 Composite option is set.
1552 Inputs:
1554 0) ExifTool object reference
1555 Return Values:
1557 (none)
1558 Notes:
1560 Tag values are calculated in alphabetical order unless a tag
1561 Require's or Desire's another composite tag, in which case the
1562 calculation is deferred until after the other tag is calculated.
1563 Composite tags may need to read data from the image for their value
1564 to be determined, so for these "BuildCompositeTags" must be called
1565 while the image is available. This is only a problem if
1566 "ImageInfo" is called with a filename (as opposed to a file
1567 reference or scalar reference) since in this case the file is
1568 closed before "ImageInfo" returns. However if you enable the
1569 Composite option, "BuildCompositeTags" is called from within
1570 "ImageInfo" before the file is closed.
1571 GetTagName [static]
1573 Get name of tag from tag key. This is a convenience function that
1574 strips the embedded instance number, if it exists, from the tag key.
1575 Note: "static" in the heading above indicates that the function does
1577 not require an ExifTool object reference as the first argument. All
1578 functions documented below are also static.
1579 $tagName = Image::ExifTool::GetTagName($tag);
1581 Inputs:
1583 0) Tag key
1584 Return Value:
1586 Tag name. This is the same as the tag key but has the instance
1587 number removed.
1588 GetShortcuts [static]
1590 Get a list of shortcut tags.
1591 Inputs:
1593 (none)
1594 Return Values:
1596 List of shortcut tags (as defined in Image::ExifTool::Shortcuts).
1597 GetAllTags [static]
1599 Get list of all available tag names.
1600 @tagList = Image::ExifTool::GetAllTags($group);
1602 Inputs:
1604 0) [optional] Group name, or string of group names separated by
1605 colons
1606 Return Values:
1608 A list of all available tags in alphabetical order, or all tags in
1609 a specified group or intersection of groups. The group name is
1610 case insensitive, and any group in families 0-2 may be used except
1611 for EXIF family 1 groups (ie. the specific IFD).
1612 GetWritableTags [static]
1614 Get list of all writable tag names.
1615 @tagList = Image::ExifTool::GetWritableTags($group);
1617 Inputs:
1619 0) [optional] Group name, or string of group names separated by
1620 colons
1621 Return Values:
1623 A list of all writable tags in alphabetical order. These are the
1624 tags for which values may be set through "SetNewValue". If a group
1625 name is given, returns only writable tags in specified group(s).
1626 The group name is case insensitive, and any group in families 0-2
1627 may be used except for EXIF family 1 groups (ie. the specific IFD).
1628 GetAllGroups [static]
1630 Get list of all group names in specified family.
1631 @groupList = Image::ExifTool::GetAllGroups($family);
1633 Inputs:
1635 0) Group family number (0-4)
1636 Return Values:
1638 A list of all groups in the specified family in alphabetical order.
1639 Here is a complete list of groups for each of these families:
1641 Family 0 (Information Type):
1643 AFCP, AIFF, APE, APP0, APP12, APP13, APP14, APP15, APP4, APP5,
1644 APP6, APP8, ASF, CanonVRD, Composite, DICOM, DNG, DV, DjVu, Ducky,
1645 EXE, EXIF, ExifTool, FLAC, File, Flash, FlashPix, Font,
1646 FotoStation, GIF, GIMP, GeoTiff, H264, HTML, ICC_Profile, ID3,
1647 IPTC, ITC, JFIF, JPEG, Jpeg2000, LNK, Leaf, M2TS, MIE, MIFF, MNG,
1648 MPC, MPEG, MPF, MXF, MakerNotes, Matroska, Meta, Ogg, PDF, PICT,
1649 PNG, PSP, PhotoMechanic, Photoshop, PostScript, PrintIM, QuickTime,
1650 RAF, RIFF, RSRC, RTF, Rawzor, Real, SVG, SigmaRaw, Stim, Theora,
1651 Vorbis, XML, XMP, ZIP
1652 Family 1 (Specific Location):
1654 AC3, AFCP, AIFF, APE, ASF, AVI1, Adobe, AdobeCM, CIFF, Canon,
1655 CanonCustom, CanonRaw, CanonVRD, Casio, Chapter#, Composite, DICOM,
1656 DNG, DV, DjVu, DjVu-Meta, Ducky, EPPIM, EXE, EXIF, ExifIFD,
1657 ExifTool, FLAC, File, Flash, FlashPix, Font, FotoStation, FujiFilm,
1658 GE, GIF, GIMP, GPS, GeoTiff, GlobParamIFD, GraphConv, H264, HP,
1659 HTML, HTML-dc, HTML-ncc, HTML-office, HTML-prod, HTML-vw96, HTTP-
1660 equiv, ICC-chrm, ICC-clrt, ICC-header, ICC-meas, ICC-meta, ICC-
1661 view, ICC_Profile, ICC_Profile#, ID3, ID3v1, ID3v1_Enh, ID3v2_2,
1662 ID3v2_3, ID3v2_4, IFD0, IFD1, IPTC, IPTC#, ITC, InteropIFD, JFIF,
1663 JPEG, JVC, Jpeg2000, KDC_IFD, Kodak, KodakBordersIFD,
1664 KodakEffectsIFD, KodakIFD, KyoceraRaw, LNK, Leaf, LeafSubIFD,
1665 Leica, M2TS, MAC, MIE-Audio, MIE-Camera, MIE-Canon, MIE-Doc, MIE-
1666 Extender, MIE-Flash, MIE-GPS, MIE-Geo, MIE-Image, MIE-Lens, MIE-
1667 Main, MIE-MakerNotes, MIE-Meta, MIE-Orient, MIE-Preview, MIE-
1668 Thumbnail, MIE-UTM, MIE-Unknown, MIE-Video, MIFF, MNG, MPC, MPEG,
1669 MPF0, MPImage, MXF, MakerNotes, MakerUnknown, Matroska, MetaIFD,
1670 Microsoft, Minolta, MinoltaRaw, NITF, Nikon, NikonCapture,
1671 NikonCustom, NikonScan, Ocad, Ogg, Olympus, PDF, PICT, PNG, PSP,
1672 Panasonic, Pentax, PhotoMechanic, Photoshop, PictureInfo,
1673 PostScript, PreviewIFD, PrintIM, ProfileIFD, QuickTime, RAF, RAF2,
1674 RIFF, RMETA, RSRC, RTF, Rawzor, Real, Real-CONT, Real-MDPR, Real-
1675 PROP, Real-RA3, Real-RA4, Real-RA5, Real-RJMD, Reconyx, Ricoh,
1676 SPIFF, SR2, SR2DataIFD, SR2SubIFD, SRF#, SVG, Samsung, Sanyo,
1677 Scalado, Sigma, SigmaRaw, Sony, SonyIDC, Stim, SubIFD, System,
1678 Theora, Track#, Version0, Vorbis, XML, XMP, XMP-DICOM, XMP-MP,
1679 XMP-MP1, XMP-PixelLive, XMP-acdsee, XMP-album, XMP-aux, XMP-cc,
1680 XMP-cell, XMP-crs, XMP-dc, XMP-dex, XMP-digiKam, XMP-exif, XMP-
1681 extensis, XMP-iptcCore, XMP-iptcExt, XMP-lr, XMP-mediapro, XMP-
1682 microsoft, XMP-mwg-coll, XMP-mwg-kw, XMP-mwg-rs, XMP-pdf, XMP-pdfx,
1683 XMP-photomech, XMP-photoshop, XMP-plus, XMP-prism, XMP-prl, XMP-
1684 pur, XMP-rdf, XMP-swf, XMP-tiff, XMP-x, XMP-xmp, XMP-xmpBJ, XMP-
1685 xmpDM, XMP-xmpMM, XMP-xmpNote, XMP-xmpPLUS, XMP-xmpRights, XMP-
1686 xmpTPg, ZIP
1687 Family 2 (Category):
1689 Audio, Author, Camera, Document, ExifTool, Image, Location, Other,
1690 Printing, Time, Unknown, Video
1691 Family 3 (Document Number):
1693 Doc#, Main
1694 Family 4 (Instance Number):
1696 Copy#
1697 GetDeleteGroups [static]
1699 Get list of all deletable group names.
1700 @delGroups = Image::ExifTool::GetDeleteGroups();
1702 Inputs:
1704 None.
1705 Return Values:
1707 A list of deletable group names in alphabetical order. The current
1708 list of deletable group names is:
1709 AFCP, CIFF, CanonVRD, EXIF, ExifIFD, Ducky, File, FlashPix,
1711 FotoStation, GlobParamIFD, GPS, IFD0, IFD1, InteropIFD,
1712 ICC_Profile, IPTC, JFIF, MakerNotes, Meta, MetaIFD, MIE,
1713 PhotoMechanic, Photoshop, PNG, PrintIM, RMETA, SubIFD, Trailer, XMP
1714 All names in this list are either family 0 or family 1 group names,
1716 with the exception of 'Trailer' which allows all trailers in JPEG
1717 and TIFF-format images to be deleted at once, including unknown
1718 trailers. To schedule a group for deletion, call "SetNewValue"
1719 with an undefined value and a tag name like 'Trailer:*'.
1720 GetFileType [static]
1722 Get type of file given file name.
1723 my $type = Image::ExifTool::GetFileType($filename);
1725 my $desc = Image::ExifTool::GetFileType($filename, 1);
1726 Inputs:
1728 0) [optional] File name (or just an extension)
1729 1) [optional] Flag to return a description instead of a type. Set
1731 to 0 to return type for recognized but unsupported files (otherwise
1732 the return value for unsupported files is undef).
1733 Return Value:
1735 A string, based on the file extension, which indicates the basic
1736 format of the file. Note that some files may be based on other
1737 formats (like many RAW image formats are based on TIFF). In array
1738 context, may return more than one file type if the file may be
1739 based on different formats. Returns undef if files with this
1740 extension are not yet supported by ExifTool. Returns a list of
1741 extensions for all supported file types if no input extension is
1742 specified (or all recognized file types if the description flag is
1743 set to 0). Returns a more detailed description of the specific
1744 file format when the description flag is set.
1745 CanWrite [static]
1747 Can the specified file be written?
1748 my $writable = Image::ExifTool::CanWrite($filename);
1750 Inputs:
1752 0) File name or extension
1753 Return Value:
1755 True if ExifTool supports writing files of this type (based on the
1756 file extension).
1757 CanCreate [static]
1759 Can the specified file be created?
1760 my $creatable = Image::ExifTool::CanCreate($filename);
1762 Inputs:
1764 0) File name or extension
1765 Return Value:
1767 True if ExifTool can create files with this extension from scratch.
1768 Currently, this can only be done with XMP, MIE, ICC, VRD and EXIF
1769 files.
1770
1772 Certain meta information formats allow coded character sets other than
1773 plain ASCII. When reading, 8-bit encodings are passed straight through
1774 ExifTool without re-coding unless specified otherwise below, and multi-
1775 byte encodings are converted according to the "Charset" option ('UTF8'
1776 by default). When writing, the inverse conversions are performed. See
1777 the "Charset" option for a list of valid character sets.
1778 More specific details are given below about how character coding is
1780 handled for EXIF, IPTC, XMP, PNG, ID3, PDF, Photoshop, QuickTime, MIE
1781 and Vorbis information:
1782 EXIF
1784 Most textual information in EXIF is stored in ASCII format, and
1785 ExifTool does not convert these tags. However it is not uncommon for
1786 applications to write UTF-8 or other encodings where ASCII is expected,
1787 and ExifTool will quite happily read/write any encoding without
1788 conversion. For a few EXIF tags (UserComment, GPSProcessingMethod and
1789 GPSAreaInformation) the stored text may be encoded either in ASCII,
1790 Unicode (UCS-2) or JIS. When reading these tags, Unicode and JIS are
1791 converted to the character set specified by the "Charset" option.
1792 Other encodings are not converted. When writing, text is stored as
1793 ASCII unless the string contains special characters, in which case it
1794 is converted from the specified character set and stored as Unicode.
1795 ExifTool writes Unicode in native EXIF byte ordering by default, but
1796 this may be changed by setting the ExifUnicodeByteOrder tag. The EXIF
1797 "XP" tags (XPTitle, XPComment, etc) are always stored as little-endian
1798 Unicode, and are read and written using the specified character set.
1799 IPTC
1801 The value of the IPTC:CodedCharacterSet tag determines how the internal
1802 IPTC string values are interpreted. If CodedCharacterSet exists and
1803 has a value of 'UTF8' (or 'ESC % G') then string values are assumed to
1804 be stored as UTF-8, otherwise Windows Latin1 (cp1252, 'Latin') coding
1805 is assumed by default, but this can be changed with the "CharsetIPTC"
1806 option. When reading, these strings are converted to the character set
1807 specified by the "Charset" option. When writing, the inverse
1808 conversions are performed. No conversion is done if the internal
1809 (IPTC) and external (ExifTool) character sets are the same. Note that
1810 ISO 2022 character set shifting is not supported. Instead, a warning
1811 is issued and the string is not converted if an ISO 2022 shift code is
1812 encountered. See <http://www.iptc.org/IIM/> for the official IPTC
1813 specification.
1814 (Note: Here, "IPTC" Refers to the older IPTC IIM format. The more
1816 recent IPTC Core and Extension specifications actually use the XMP
1817 format.)
1818 XMP
1820 Exiftool reads XMP encoded as UTF-8, UTF-16 or UTF-32, and converts
1821 them all to UTF-8 internally. Also, all XML character entity
1822 references and numeric character references are converted. When
1823 writing, ExifTool always encodes XMP as UTF-8, converting the following
1824 5 characters to XML character references: & < > ' ". By default no
1825 further conversion is performed, however if the "Charset" option is
1826 other than 'UTF8' then text is converted to/from a specified character
1827 set when reading/writing.
1828 PNG
1830 PNG TextualData tags are stored as tEXt, zTXt and iTXt chunks in PNG
1831 images. The tEXt and zTXt chunks use ISO 8859-1 encoding, while iTXt
1832 uses UTF-8. When reading, ExifTool converts all PNG textual data to
1833 the character set specified by the "Charset" option. When writing,
1834 ExifTool generates a tEXt chunk (or zTXt with the "Compress" option) if
1835 the text doesn't contain special characters or if Latin encoding is
1836 specified; otherwise an iTXt chunk is used and the text is converted
1837 from the specified character set and stored as UTF-8.
1838 ID3
1840 The ID3v1 specification officially supports only ISO 8859-1 encoding (a
1841 subset of Windows Latin1), although some applications may incorrectly
1842 use other character sets. By default ExifTool converts ID3v1 text from
1843 Latin to the character set specified by the </Charset> option.
1844 However, the internal ID3v1 charset may be specified with the
1845 "CharsetID3" option. The encoding for ID3v2 information is stored in
1846 the file, so ExifTool converts ID3v2 text from this encoding to the
1847 character set specified by the "Charset" option. ExifTool does not
1848 currently write ID3 information.
1849 PDF
1851 PDF text strings are stored in either PDFDocEncoding (similar to
1852 Windows Latin1) or Unicode (UCS-2). When reading, ExifTool converts to
1853 the character set specified by the "Charset" option. When writing,
1854 ExifTool encodes input text from the specified character set as Unicode
1855 only if the string contains special characters, otherwise
1856 PDFDocEncoding is used.
1857 Photoshop
1859 Some Photoshop resource names are stored as Pascal strings with unknown
1860 encoding. By default, ExifTool assumes MacRoman encoding and converts
1861 this to UTF-8, but the internal and external character sets may be
1862 specified with "CharsetPhotoshop" and "Charset" options respectively.
1863 QuickTime
1865 QuickTime text strings may be stored in a variety of poorly document
1866 formats. ExifTool does its best to decode these according to the
1867 "Charset" option setting.
1868 MIE
1870 MIE strings are stored as either UTF-8 or ISO 8859-1. When reading,
1871 UTF-8 strings are converted according to the "Charset" option, and ISO
1872 8859-1 strings are never converted. When writing, input strings are
1873 converted from the specified character set to UTF-8. The resulting
1874 strings are stored as UTF-8 if they contain multi-byte UTF-8 character
1875 sequences, otherwise they are stored as ISO 8859-1.
1876 Vorbis
1878 Vorbis comments are stored as UTF-8, and are converted to the character
1879 set specified by the "Charset" option.
1880
1882 Copyright 2003-2011, Phil Harvey
1883 This library is free software; you can redistribute it and/or modify it
1885 under the same terms as Perl itself.
1886
1888 Many people have helped in the development of ExifTool through their
1889 bug reports, comments and suggestions, and/or additions to the code.
1890 See the ACKNOWLEDGEMENTS in the individual Image::ExifTool modules and
1891 in html/index.html of the Image::ExifTool distribution package for a
1892 list of people who have contributed to this project.
1893
1895 exiftool(1), Image::ExifTool::TagNames(3pm),
1896 Image::ExifTool::Shortcuts(3pm), Image::ExifTool::Shift.pl,
1897 Image::Info(3pm), Image::MetaData::JPEG(3pm)
1898perl v5.12.4 2011-08-24 Image::ExifTool(3)