Writing meta information is more complicated than it may appear at first glance, which may be one reason why there are very few utilities around that do it. ExifTool uses tag names to identify the different pieces of meta information that can be extracted from a file. There are thousands of different tags that ExifTool recognizes, and many of these tag names are common between different metadata formats (the WhiteBalance tag is the worst offender, and can be found in 65 different places [ExifTool 10.64]), and sometimes the information can even be stored in different places within a single format. Couple this with the fact that many manufacturers store meta information in undocumented formats which must be reverse engineered (and each of which have their particular quirks), and you have a very complex situation.
ExifTool attempts to simplify this situation as much as possible by making reasonable decisions about where to write the information you specify, yet it maintains flexibility by allowing you to configure its priorities if necessary, or even override the decision making process entirely.
For a long time, I resisted adding write abilities to ExifTool even though it was an oft-requested feature. My concerns in adding this feature were:
After thinking about this for a while, I was finally able to come up with some solutions:
1. I designed an interface that I think is easy to use for people who don't want to know the details of the file structure, yet powerful enough for people who want to do very specific things to the information.
2. I isolated all of the writing code as much as possible into separate files which autoload as required. This keeps the compilation fast for people who don't require the write feature. Also, I have left the reading routines unchanged, so they aren't slowed down by the extra code needed when writing information. Unfortunately, this meant I couldn't borrow a lot of code from the read routines (even more work for me!), but it had the advantage that I could perform additional optimizations in the write routines that I couldn't do otherwise. Although the startup costs of this implementation are fairly high (for writing only), it should be quite fast for batch writing of multiple files.
3. I decided to bite the bullet and invest the time required (...guess what I did for my Christmas vacation!). Although I thought that a big project like this would be better suited to C++ (faster execution and a broader potential user base), after programming this so far in Perl I have grown to really appreciate the automatic memory handling and other great features of Perl such as hash lookups and incredible flexibility in text manipulations afforded by regular expressions.
Currently, ExifTool can write most of the EXIF tags that anyone could reasonably want to change (but some tags are protected because they describe physical characteristics of the image that you can not change with ExifTool, eg. Compression). Also, all of the GPS, IPTC and XMP information and most of the MakerNotes information can be edited. This gives you great power, but with great power, comes great responsibility...
It is possible for you to write nonsense into a file, which could cause other image readers to throw up their hands in despair and refuse to read the image. For this reason, it is best to always preserve the original copy of your image file. The "exiftool" script does this for you automatically by renaming the original file and always working on a copy.
The writing logic for ExifTool is the reverse of the reading logic. You provide human-readable values and ExifTool will perform the conversions for you. For instance, you can set "WhiteBalance" to "Daylight" and ExifTool will change the value of WhiteBalance in the image wherever the tag is found provided that "Daylight" is a valid value for that location. ExifTool will even do some simple matching so that you could even just set it to "day", and ExifTool will search through the valid values and will choose the one that contains the string "day". If the value is ambiguous, the tag will not be set. If no tags can be set with the specified value, ExifTool returns an error message.
The tag values can also be specified at a numerical level by disabling the print conversions that are normally applied. This can be done on a tag-by-tag basis or on a global basis through either the application or the API.
As well as changing tag values wherever they are found in the image, exiftool
will also create the tag in the preferred group if it didn't exist there before.
By default, the preferred group is the first of the following where the tag is
found: 1) EXIF, 2) IPTC, 3) XMP. Alternatively, the desired group (in family 0
or 1) can be specified so ExifTool only writes the tag to a single location. For
example, with the command line interface, this is done using an argument like
"-EXIF:WhiteBalance=Manual".
If a tag is added to a group that doesn't exist, the new group is created in the file, and required mandatory tags may be created. Conversely, if the last non-mandatory tag is deleted from a group, the group is removed from the file.
The EXIF and IPTC standards both specify some mandatory tags. ExifTool will automatically create many of these mandatory tags as required when writing new information (and remove them again when deleting information if only mandatory tags remain). However, some mandatory tags (particularly in the IPTC information) can not be easily added automatically, so it is left up to the user to add these tags if required.
Rant: Let me say that the whole concept of mandatory tags is flawed. Instead of mandatory tags, the standard should specify default values to be assumed if the tags don't exist. A robust reader has to do this anyway, so it is redundant to require that this information must be written. In the case where there is no simple default value, the reader must be able to deal with the missing tag, otherwise it places the burden on the writer to magically pull a reasonable value out of thin air. Of course, you may say that the writer could get this information from the user, but conditions like this add an unnecessary level complexity to the user interface.
An unfortunate aspect of the JPEG format is that the size of a single segment is limited to less than 64 kB. With the 2-byte size word at the start of each segment, this leaves 65533 bytes for data. The EXIF specification states that the data must fit within a single APP1 segment (which results in the preview image problem discussed below), however APP13 Photoshop and APP2 ICC Profile and FPXR information may span multiple segments. This multi-segment information is handled properly by ExifTool.
JPEG comments may also exceed the size of a single COM segment. If
necessary, comments are automatically split into separate segments when writing.
However, when reading they are not joined together because some utilities store
distinctly different comments in separate segments. To extract all JPEG
comments into a single file, and combine any comments that may have been split
into multiple segments, use "exiftool -a -b -comment src.jpg >
comment.out".
Writing the preview image in JPEG files poses many problems of its own. These problems stem from the fact that the JPEG standard is inadequate for storing large preview images due to the 64kB limit on segment size as mentioned above. (Note that TIFF images don't have this problem since they have a 4GB limit.) Some manufacturers get around this by appending the preview after the normal end of the JPEG file (JPEG EOI), but this causes complications because it means that the preview image pointers in the EXIF information now point outside the EXIF segment. This is truly unfortunate because it greatly complicates things for image writing software. Most other software can't deal with a preview image and will simply remove a preview like this when rewriting the file.
However, as of ExifTool version 5, the preview images are handled properly when writing EXIF information in JPEG files. But for reasons of efficiency, the EXIF segment is not edited when writing information if no EXIF tags are being changed (eg. if only XMP or IPTC information is being edited). In this case, the preview image pointers could be invalidated because the length of the data between the EXIF segment (which comes near the start of the file) and the preview image (at the end of the file) is likely to change. ExifTool gets around this when reading JPEG images by looking for the preview at the end of the file and updating pointers if necessary, but the preview image may not be readable by other software (it should be noted though that very few image readers even know the preview image exists). However, the preview pointers in such a file can be fixed if necessary by simply using ExifTool to edit any EXIF information.
2009-05-26: New Samsung cameras recently started embedding preview images larger than 64 kB, and of course they created a new technique to do so. If they were smart, they would have developed a simple technique that could be used by others in the future, but of course they were stupid, and didn't think that far ahead. (Such is the normal path of dumb camera manufacturers when it comes to metadata.)
The new Samsung models simply split the preview and write it to separate APP2 segments with no header. If they had written a header (like "PREVIEW\0" for example), then the technique could be portable and useful. But they didn't. Without a header, the data can not easily be distinguished from other random APP2 data, so this technique is not generally useful. Of course, there are disadvantages with splitting up a preview into separate JPEG segments, so this technique in general is not ideal.
2009-06-12: CIPA has recently released a "Multi-Picture Format" standard for storing large images in JPEG files. Again, there is a big problem with this standard: It uses offsets that are relative to the start of the MPF header (in the new MPF APP2 segment) to reference images after the JPEG EOI. These offsets will quickly be broken if any data after the MPF segment changes length. This problem could have been avoided if offsets had been specified relative to the end of file, but it is too late for this now that the specification is public.
The only workable alternative I can see is to enforce the rule that the MPF APP2 segment must come after all other APP segments. (It would have been smart if this was specified in the CIPA standard, but sadly this isn't the case.) If this is done, then metadata in the remaining APP segments (EXIF, IPTC, XMP, etc) can safely be edited without breaking the MPF offsets. I suggest that all metadata editors employ this strategy, regardless of the segment order specified in the standard (which says that the MPF APP2 segment must come immediately after the EXIF APP1 segment).
ExifTool has a preferred location (IFD) where it writes all EXIF tags. However, a number of tags are written to different locations by various digital cameras or image editors. Specifically, the following tags have been observed in both IFD0 and ExifIFD: Make, Model, Software, Artist, DateTimeOriginal, SensingMethod, CustomRendered, ExposureMode, WhiteBalance, DigitalZoomRatio and SceneCaptureType. To handle this ambiguity, ExifTool will delete the tag if it exists in IFD0 when it is written to ExifIFD, and vice versa.