1 // ***************************************************************** -*- C++ -*-
2 /*
3  * Copyright (C) 2004-2021 Exiv2 authors
4  * This program is part of the Exiv2 distribution.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
19  */
20 /*
21   File:      easyaccess.cpp
22  */
23 // *****************************************************************************
24 // included header files
25 #include "easyaccess.hpp"
26 
27 // *****************************************************************************
28 namespace {
29 
30     using namespace Exiv2;
31 
32     /*!
33       @brief Search \em ed for a Metadatum specified by the \em keys.
34              The \em keys are searched in the order of their appearance, the
35              first available Metadatum is returned.
36 
37       @param ed The %Exif metadata container to search
38       @param keys Array of keys to look for
39       @param count Number of elements in the array
40      */
findMetadatum(const ExifData & ed,const char * keys[],int count)41     ExifData::const_iterator findMetadatum(const ExifData& ed,
42                                            const char* keys[],
43                                            int count)
44     {
45         for (int i = 0; i < count; ++i) {
46             ExifData::const_iterator pos = ed.findKey(ExifKey(keys[i]));
47             if (pos != ed.end()) return pos;
48         }
49         return ed.end();
50     } // findMetadatum
51 
52 } // anonymous namespace
53 
54 // *****************************************************************************
55 // class member definitions
56 namespace Exiv2 {
57 
orientation(const ExifData & ed)58     ExifData::const_iterator orientation(const ExifData& ed)
59     {
60         static const char* keys[] = {
61             "Exif.Image.Orientation",
62             "Exif.Panasonic.Rotation",
63             "Exif.MinoltaCs5D.Rotation",
64             "Exif.MinoltaCs5D.Rotation2",
65             "Exif.MinoltaCs7D.Rotation",
66             "Exif.Sony1MltCsA100.Rotation",
67             "Exif.Sony1Cs.Rotation",
68             "Exif.Sony2Cs.Rotation",
69             "Exif.Sony1Cs2.Rotation",
70             "Exif.Sony2Cs2.Rotation",
71             "Exif.Sony1MltCsA100.Rotation"
72         };
73         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
74     }
75 
isoSpeed(const ExifData & ed)76     ExifData::const_iterator isoSpeed(const ExifData& ed)
77     {
78         static const char* keys[] = {
79             "Exif.Photo.ISOSpeedRatings",
80             "Exif.Image.ISOSpeedRatings",
81             "Exif.CanonSi.ISOSpeed",
82             "Exif.CanonCs.ISOSpeed",
83             "Exif.Nikon1.ISOSpeed",
84             "Exif.Nikon2.ISOSpeed",
85             "Exif.Nikon3.ISOSpeed",
86             "Exif.NikonIi.ISO",
87             "Exif.NikonIi.ISO2",
88             "Exif.MinoltaCsNew.ISOSetting",
89             "Exif.MinoltaCsOld.ISOSetting",
90             "Exif.MinoltaCs5D.ISOSpeed",
91             "Exif.MinoltaCs7D.ISOSpeed",
92             "Exif.Sony1Cs.ISOSetting",
93             "Exif.Sony2Cs.ISOSetting",
94             "Exif.Sony1Cs2.ISOSetting",
95             "Exif.Sony2Cs2.ISOSetting",
96             "Exif.Sony1MltCsA100.ISOSetting",
97             "Exif.Pentax.ISO",
98             "Exif.PentaxDng.ISO",
99             "Exif.Olympus.ISOSpeed",
100             "Exif.Samsung2.ISO",
101             "Exif.Casio.ISO",
102             "Exif.Casio2.ISO",
103             "Exif.Casio2.ISOSpeed"
104         };
105 
106         struct SensKeyNameList {
107             int count;
108             const char* keys[3];
109         };
110 
111         // covers Exif.Phot.SensitivityType values 1-7. Note that SOS, REI and
112         // ISO do differ in their meaning. Values coming first in a list (and
113         // existing as a tag) are picked up first and used as the "ISO" value.
114         static const SensKeyNameList sensitivityKey[] = {
115             { 1, { "Exif.Photo.StandardOutputSensitivity" }},
116             { 1, { "Exif.Photo.RecommendedExposureIndex" }},
117             { 1, { "Exif.Photo.ISOSpeed" }},
118             { 2, { "Exif.Photo.RecommendedExposureIndex", "Exif.Photo.StandardOutputSensitivity" }},
119             { 2, { "Exif.Photo.ISOSpeed", "Exif.Photo.StandardOutputSensitivity" }},
120             { 2, { "Exif.Photo.ISOSpeed", "Exif.Photo.RecommendedExposureIndex" }},
121             { 3, { "Exif.Photo.ISOSpeed", "Exif.Photo.RecommendedExposureIndex", "Exif.Photo.StandardOutputSensitivity" }}
122         };
123 
124         static const char* sensitivityType[] = {
125             "Exif.Photo.SensitivityType"
126         };
127 
128         // Find the first ISO value which is not "0"
129         const int cnt = EXV_COUNTOF(keys);
130         ExifData::const_iterator md = ed.end();
131         long iso_val = -1;
132         for (int idx = 0; idx < cnt; ) {
133             md = findMetadatum(ed, keys + idx, cnt - idx);
134             if (md == ed.end()) break;
135             std::ostringstream os;
136             md->write(os, &ed);
137             bool ok = false;
138             iso_val = parseLong(os.str(), ok);
139             if (ok && iso_val > 0) break;
140             while (strcmp(keys[idx++], md->key().c_str()) != 0 && idx < cnt) {}
141             md = ed.end();
142         }
143 
144         // there is either a possible ISO "overflow" or no legacy
145         // ISO tag at all. Check for SensitivityType tag and the referenced
146         // ISO value (see EXIF 2.3 Annex G)
147         long iso_tmp_val = -1;
148         while (iso_tmp_val == -1 && (iso_val == 65535 || md == ed.end())) {
149             ExifData::const_iterator md_st = findMetadatum(ed, sensitivityType, 1);
150             // no SensitivityType? exit with existing data
151             if (md_st == ed.end())
152                 break;
153             // otherwise pick up actual value and grab value accordingly
154             std::ostringstream os;
155             md_st->write(os, &ed);
156             bool ok = false;
157             const long st_val = parseLong(os.str(), ok);
158             // SensivityType out of range or cannot be parsed properly
159             if (!ok || st_val < 1 || st_val > 7)
160                 break;
161             // pick up list of ISO tags, and check for at least one of
162             // them available.
163             const SensKeyNameList *sensKeys = &sensitivityKey[st_val - 1];
164             md_st = ed.end();
165             for (int idx = 0; idx < sensKeys->count; md_st = ed.end()) {
166                 md_st = findMetadatum(ed, const_cast<const char**>(sensKeys->keys), sensKeys->count);
167                 if (md_st == ed.end())
168                     break;
169                 std::ostringstream os_iso;
170                 md_st->write(os_iso, &ed);
171                 ok = false;
172                 iso_tmp_val = parseLong(os_iso.str(), ok);
173                 // something wrong with the value
174                 if (ok || iso_tmp_val > 0) {
175                     md = md_st;
176                     break;
177                 }
178                 while (strcmp(sensKeys->keys[idx++], md_st->key().c_str()) != 0 && idx < sensKeys->count) {}
179             }
180             break;
181         }
182 
183         return md;
184     }
185 
dateTimeOriginal(const ExifData & ed)186     ExifData::const_iterator dateTimeOriginal(const ExifData& ed)
187     {
188         static const char* keys[] = {
189             "Exif.Photo.DateTimeOriginal",
190             "Exif.Image.DateTimeOriginal"
191         };
192         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
193     }
194 
flashBias(const ExifData & ed)195     ExifData::const_iterator flashBias(const ExifData& ed)
196     {
197         static const char* keys[] = {
198             "Exif.CanonSi.FlashBias",
199             "Exif.Panasonic.FlashBias",
200             "Exif.Olympus.FlashBias",
201             "Exif.OlympusCs.FlashExposureComp",
202             "Exif.Minolta.FlashExposureComp",
203             "Exif.SonyMinolta.FlashExposureComp",
204             "Exif.Sony1.FlashExposureComp",
205             "Exif.Sony2.FlashExposureComp"
206         };
207         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
208     }
209 
exposureMode(const ExifData & ed)210     ExifData::const_iterator exposureMode(const ExifData& ed)
211     {
212         static const char* keys[] = {
213             "Exif.Photo.ExposureProgram",
214             "Exif.Image.ExposureProgram",
215             "Exif.CanonCs.ExposureProgram",
216             "Exif.MinoltaCs7D.ExposureMode",
217             "Exif.MinoltaCs5D.ExposureMode",
218             "Exif.MinoltaCsNew.ExposureMode",
219             "Exif.MinoltaCsOld.ExposureMode",
220             "Exif.Sony1MltCsA100.ExposureMode",
221             "Exif.Sony1Cs.ExposureProgram",
222             "Exif.Sony2Cs.ExposureProgram",
223             "Exif.Sigma.ExposureMode"
224         };
225         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
226     }
227 
sceneMode(const ExifData & ed)228     ExifData::const_iterator sceneMode(const ExifData& ed)
229     {
230         static const char* keys[] = {
231             "Exif.CanonCs.EasyMode",
232             "Exif.Fujifilm.PictureMode",
233             "Exif.MinoltaCsNew.SubjectProgram",
234             "Exif.MinoltaCsOld.SubjectProgram",
235             "Exif.Minolta.SceneMode",
236             "Exif.SonyMinolta.SceneMode",
237             "Exif.Sony1.SceneMode",
238             "Exif.Sony2.SceneMode",
239             "Exif.OlympusCs.SceneMode",
240             "Exif.Panasonic.ShootingMode",
241             "Exif.Panasonic.SceneMode",
242             "Exif.Pentax.PictureMode",
243             "Exif.PentaxDng.PictureMode",
244             "Exif.Photo.SceneCaptureType"
245         };
246         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
247     }
248 
macroMode(const ExifData & ed)249     ExifData::const_iterator macroMode(const ExifData& ed)
250     {
251         static const char* keys[] = {
252             "Exif.CanonCs.Macro",
253             "Exif.Fujifilm.Macro",
254             "Exif.Olympus.Macro",
255             "Exif.OlympusCs.MacroMode",
256             "Exif.Panasonic.Macro",
257             "Exif.MinoltaCsNew.MacroMode",
258             "Exif.MinoltaCsOld.MacroMode",
259             "Exif.Sony1.Macro",
260             "Exif.Sony2.Macro"
261         };
262         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
263     }
264 
imageQuality(const ExifData & ed)265     ExifData::const_iterator imageQuality(const ExifData& ed)
266     {
267         static const char* keys[] = {
268             "Exif.CanonCs.Quality",
269             "Exif.Fujifilm.Quality",
270             "Exif.Sigma.Quality",
271             "Exif.Nikon1.Quality",
272             "Exif.Nikon2.Quality",
273             "Exif.Nikon3.Quality",
274             "Exif.Olympus.Quality",
275             "Exif.OlympusCs.Quality",
276             "Exif.Panasonic.Quality",
277             "Exif.Minolta.Quality",
278             "Exif.MinoltaCsNew.Quality",
279             "Exif.MinoltaCsOld.Quality",
280             "Exif.MinoltaCs5D.Quality",
281             "Exif.MinoltaCs7D.Quality",
282             "Exif.Sony1MltCsA100.Quality",
283             "Exif.Sony1.JPEGQuality",
284             "Exif.Sony1.Quality",
285             "Exif.Sony1Cs.Quality",
286             "Exif.Sony2.JPEGQuality",
287             "Exif.Sony2.Quality",
288             "Exif.Sony2Cs.Quality",
289             "Exif.Casio.Quality",
290             "Exif.Casio2.QualityMode",
291             "Exif.Casio2.Quality"
292         };
293         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
294     }
295 
whiteBalance(const ExifData & ed)296     ExifData::const_iterator whiteBalance(const ExifData& ed)
297     {
298         static const char* keys[] = {
299             "Exif.CanonSi.WhiteBalance",
300             "Exif.Fujifilm.WhiteBalance",
301             "Exif.Sigma.WhiteBalance",
302             "Exif.Nikon1.WhiteBalance",
303             "Exif.Nikon2.WhiteBalance",
304             "Exif.Nikon3.WhiteBalance",
305             "Exif.Olympus.WhiteBalance",
306             "Exif.OlympusCs.WhiteBalance",
307             "Exif.Panasonic.WhiteBalance",
308             "Exif.MinoltaCs5D.WhiteBalance",
309             "Exif.MinoltaCs7D.WhiteBalance",
310             "Exif.MinoltaCsNew.WhiteBalance",
311             "Exif.MinoltaCsOld.WhiteBalance",
312             "Exif.Minolta.WhiteBalance",
313             "Exif.Sony1MltCsA100.WhiteBalance",
314             "Exif.SonyMinolta.WhiteBalance",
315             "Exif.Sony1.WhiteBalance",
316             "Exif.Sony2.WhiteBalance",
317             "Exif.Sony1.WhiteBalance2",
318             "Exif.Sony2.WhiteBalance2",
319             "Exif.Casio.WhiteBalance",
320             "Exif.Casio2.WhiteBalance",
321             "Exif.Casio2.WhiteBalance2",
322             "Exif.Photo.WhiteBalance"
323         };
324         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
325     }
326 
lensName(const ExifData & ed)327     ExifData::const_iterator lensName(const ExifData& ed)
328     {
329         static const char* keys[] = {
330             // Exif.Canon.LensModel only reports focal length.
331             // Try Exif.CanonCs.LensType first.
332             "Exif.CanonCs.LensType",
333             "Exif.Photo.LensModel",
334             "Exif.NikonLd1.LensIDNumber",
335             "Exif.NikonLd2.LensIDNumber",
336             "Exif.NikonLd3.LensIDNumber",
337             "Exif.Pentax.LensType",
338             "Exif.PentaxDng.LensType",
339             "Exif.Minolta.LensID",
340             "Exif.SonyMinolta.LensID",
341             "Exif.Sony1.LensID",
342             "Exif.Sony2.LensID",
343             "Exif.OlympusEq.LensType",
344             "Exif.Panasonic.LensType",
345             "Exif.Samsung2.LensType"
346         };
347         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
348     }
349 
saturation(const ExifData & ed)350     ExifData::const_iterator saturation(const ExifData& ed)
351     {
352         static const char* keys[] = {
353             "Exif.Photo.Saturation",
354             "Exif.CanonCs.Saturation",
355             "Exif.MinoltaCsNew.Saturation",
356             "Exif.MinoltaCsOld.Saturation",
357             "Exif.MinoltaCs7D.Saturation",
358             "Exif.MinoltaCs5D.Saturation",
359             "Exif.Fujifilm.Color",
360             "Exif.Nikon3.Saturation",
361             "Exif.Panasonic.Saturation",
362             "Exif.Pentax.Saturation",
363             "Exif.PentaxDng.Saturation",
364             "Exif.Sigma.Saturation",
365             "Exif.Casio.Saturation",
366             "Exif.Casio2.Saturation",
367             "Exif.Casio2.Saturation2"
368         };
369         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
370     }
371 
sharpness(const ExifData & ed)372     ExifData::const_iterator sharpness(const ExifData& ed)
373     {
374         static const char* keys[] = {
375             "Exif.Photo.Sharpness",
376             "Exif.CanonCs.Sharpness",
377             "Exif.Fujifilm.Sharpness",
378             "Exif.MinoltaCsNew.Sharpness",
379             "Exif.MinoltaCsOld.Sharpness",
380             "Exif.MinoltaCs7D.Sharpness",
381             "Exif.MinoltaCs5D.Sharpness",
382             "Exif.Olympus.SharpnessFactor",
383             "Exif.Panasonic.Sharpness",
384             "Exif.Pentax.Sharpness",
385             "Exif.PentaxDng.Sharpness",
386             "Exif.Sigma.Sharpness",
387             "Exif.Casio.Sharpness",
388             "Exif.Casio2.Sharpness",
389             "Exif.Casio2.Sharpness2"
390         };
391         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
392     }
393 
contrast(const ExifData & ed)394     ExifData::const_iterator contrast(const ExifData& ed)
395     {
396         static const char* keys[] = {
397             "Exif.Photo.Contrast",
398             "Exif.CanonCs.Contrast",
399             "Exif.Fujifilm.Tone",
400             "Exif.MinoltaCsNew.Contrast",
401             "Exif.MinoltaCsOld.Contrast",
402             "Exif.MinoltaCs7D.Contrast",
403             "Exif.MinoltaCs5D.Contrast",
404             "Exif.Olympus.Contrast",
405             "Exif.Panasonic.Contrast",
406             "Exif.Pentax.Contrast",
407             "Exif.PentaxDng.Contrast",
408             "Exif.Sigma.Contrast",
409             "Exif.Casio.Contrast",
410             "Exif.Casio2.Contrast",
411             "Exif.Casio2.Contrast2"
412 
413         };
414         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
415     }
416 
sceneCaptureType(const ExifData & ed)417     ExifData::const_iterator sceneCaptureType(const ExifData& ed)
418     {
419         static const char* keys[] = {
420             "Exif.Photo.SceneCaptureType",
421             "Exif.Olympus.SpecialMode"
422         };
423         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
424     }
425 
meteringMode(const ExifData & ed)426     ExifData::const_iterator meteringMode(const ExifData& ed)
427     {
428         static const char* keys[] = {
429             "Exif.Photo.MeteringMode",
430             "Exif.Image.MeteringMode",
431             "Exif.CanonCs.MeteringMode",
432             "Exif.Sony1MltCsA100.MeteringMode"
433         };
434         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
435     }
436 
make(const ExifData & ed)437     ExifData::const_iterator make(const ExifData& ed)
438     {
439         static const char* keys[] = {
440             "Exif.Image.Make"
441         };
442         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
443     }
444 
model(const ExifData & ed)445     ExifData::const_iterator model(const ExifData& ed)
446     {
447         static const char* keys[] = {
448             "Exif.Image.Model"
449         };
450         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
451     }
452 
exposureTime(const ExifData & ed)453     ExifData::const_iterator exposureTime(const ExifData& ed)
454     {
455         static const char* keys[] = {
456             "Exif.Photo.ExposureTime",
457             "Exif.Image.ExposureTime",
458             "Exif.Samsung2.ExposureTime"
459         };
460         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
461     }
462 
fNumber(const ExifData & ed)463     ExifData::const_iterator fNumber(const ExifData& ed)
464     {
465         static const char* keys[] = {
466             "Exif.Photo.FNumber",
467             "Exif.Image.FNumber",
468             "Exif.Samsung2.FNumber"
469         };
470         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
471     }
472 
shutterSpeedValue(const ExifData & ed)473     ExifData::const_iterator shutterSpeedValue(const ExifData& ed)
474     {
475         static const char* keys[] = {
476             "Exif.Photo.ShutterSpeedValue",
477             "Exif.Image.ShutterSpeedValue"
478         };
479         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
480     }
481 
apertureValue(const ExifData & ed)482     ExifData::const_iterator apertureValue(const ExifData& ed)
483     {
484         static const char* keys[] = {
485             "Exif.Photo.ApertureValue",
486             "Exif.Image.ApertureValue"
487         };
488         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
489     }
490 
brightnessValue(const ExifData & ed)491     ExifData::const_iterator brightnessValue(const ExifData& ed)
492     {
493         static const char* keys[] = {
494             "Exif.Photo.BrightnessValue",
495             "Exif.Image.BrightnessValue"
496         };
497         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
498     }
499 
exposureBiasValue(const ExifData & ed)500     ExifData::const_iterator exposureBiasValue(const ExifData& ed)
501     {
502         static const char* keys[] = {
503             "Exif.Photo.ExposureBiasValue",
504             "Exif.Image.ExposureBiasValue"
505         };
506         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
507     }
508 
maxApertureValue(const ExifData & ed)509     ExifData::const_iterator maxApertureValue(const ExifData& ed)
510     {
511         static const char* keys[] = {
512             "Exif.Photo.MaxApertureValue",
513             "Exif.Image.MaxApertureValue"
514         };
515         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
516     }
517 
subjectDistance(const ExifData & ed)518     ExifData::const_iterator subjectDistance(const ExifData& ed)
519     {
520         static const char* keys[] = {
521             "Exif.Photo.SubjectDistance",
522             "Exif.Image.SubjectDistance",
523             "Exif.CanonSi.SubjectDistance",
524             "Exif.CanonFi.FocusDistanceUpper",
525             "Exif.CanonFi.FocusDistanceLower",
526             "Exif.MinoltaCsNew.FocusDistance",
527             "Exif.Nikon1.FocusDistance",
528             "Exif.Nikon3.FocusDistance",
529             "Exif.NikonLd2.FocusDistance",
530             "Exif.NikonLd3.FocusDistance",
531             "Exif.Olympus.FocusDistance",
532             "Exif.OlympusFi.FocusDistance",
533             "Exif.Casio.ObjectDistance",
534             "Exif.Casio2.ObjectDistance"
535         };
536         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
537     }
538 
lightSource(const ExifData & ed)539     ExifData::const_iterator lightSource(const ExifData& ed)
540     {
541         static const char* keys[] = {
542             "Exif.Photo.LightSource",
543             "Exif.Image.LightSource"
544         };
545         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
546     }
547 
flash(const ExifData & ed)548     ExifData::const_iterator flash(const ExifData& ed)
549     {
550         static const char* keys[] = {
551             "Exif.Photo.Flash",
552             "Exif.Image.Flash"
553         };
554         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
555     }
556 
serialNumber(const ExifData & ed)557     ExifData::const_iterator serialNumber(const ExifData& ed)
558     {
559         static const char* keys[] = {
560             "Exif.Image.CameraSerialNumber",
561             "Exif.Canon.SerialNumber",
562             "Exif.Nikon3.SerialNumber",
563             "Exif.Nikon3.SerialNO",
564             "Exif.Fujifilm.SerialNumber",
565             "Exif.Olympus.SerialNumber2",
566             "Exif.Sigma.SerialNumber"
567         };
568         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
569     }
570 
focalLength(const ExifData & ed)571     ExifData::const_iterator focalLength(const ExifData& ed)
572     {
573         static const char* keys[] = {
574             "Exif.Photo.FocalLength",
575             "Exif.Image.FocalLength",
576             "Exif.Canon.FocalLength",
577             "Exif.NikonLd2.FocalLength",
578             "Exif.NikonLd3.FocalLength",
579             "Exif.MinoltaCsNew.FocalLength",
580             "Exif.Pentax.FocalLength",
581             "Exif.PentaxDng.FocalLength",
582             "Exif.Casio2.FocalLength"
583         };
584         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
585     }
586 
subjectArea(const ExifData & ed)587     ExifData::const_iterator subjectArea(const ExifData& ed)
588     {
589         static const char* keys[] = {
590             "Exif.Photo.SubjectArea",
591             "Exif.Image.SubjectLocation"
592         };
593         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
594     }
595 
flashEnergy(const ExifData & ed)596     ExifData::const_iterator flashEnergy(const ExifData& ed)
597     {
598         static const char* keys[] = {
599             "Exif.Photo.FlashEnergy",
600             "Exif.Image.FlashEnergy"
601         };
602         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
603     }
604 
exposureIndex(const ExifData & ed)605     ExifData::const_iterator exposureIndex(const ExifData& ed)
606     {
607         static const char* keys[] = {
608             "Exif.Photo.ExposureIndex",
609             "Exif.Image.ExposureIndex"
610         };
611         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
612     }
613 
sensingMethod(const ExifData & ed)614     ExifData::const_iterator sensingMethod(const ExifData& ed)
615     {
616         static const char* keys[] = {
617             "Exif.Photo.SensingMethod",
618             "Exif.Image.SensingMethod"
619         };
620         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
621     }
622 
afPoint(const ExifData & ed)623     ExifData::const_iterator afPoint(const ExifData& ed)
624     {
625         static const char* keys[] = {
626             "Exif.CanonPi.AFPointsUsed",
627             "Exif.CanonPi.AFPointsUsed20D",
628             "Exif.CanonSi.AFPointUsed",
629             "Exif.CanonCs.AFPoint",
630             "Exif.MinoltaCs7D.AFPoints",
631             "Exif.Nikon1.AFFocusPos",
632             "Exif.NikonAf.AFPoint",
633             "Exif.NikonAf.AFPointsInFocus",
634             "Exif.NikonAf2.AFPointsUsed",
635             "Exif.NikonAf2.PrimaryAFPoint",
636             "Exif.OlympusFi.AFPoint",
637             "Exif.Pentax.AFPoint",
638             "Exif.Pentax.AFPointInFocus",
639             "Exif.PentaxDng.AFPoint",
640             "Exif.PentaxDng.AFPointInFocus",
641             "Exif.Sony1Cs.LocalAFAreaPoint",
642             "Exif.Sony2Cs.LocalAFAreaPoint",
643             "Exif.Sony1Cs2.LocalAFAreaPoint",
644             "Exif.Sony2Cs2.LocalAFAreaPoint",
645             "Exif.Sony1MltCsA100.LocalAFAreaPoint",
646             "Exif.Casio.AFPoint",
647             "Exif.Casio2.AFPointPosition"
648         };
649         return findMetadatum(ed, keys, EXV_COUNTOF(keys));
650     }
651 
652 }                                       // namespace Exiv2
653