Changeset 4972

Timestamp:

Feb 27, 2010, 12:44:30 AM (14 years ago)

Author:

grum

Message:

Canon camera's maker note implementation + extended Xmp segments managed

Location:

extensions/AMetaData/JpegMetaData

Files:

• Common/ConvertData.class.php (modified) (2 diffs)
• Readers/AppMarkerSegmentReader.class.php (modified) (1 diff)
• Readers/CanonReader.class.php (modified) (6 diffs)
• Readers/JpegReader.class.php (modified) (2 diffs)
• Readers/XmpReader.class.php (modified) (1 diff)
• TagDefinitions/CanonTags.class.php (modified) (13 diffs)
• TagDefinitions/XmpTags.class.php (modified) (2 diffs)

extensions/AMetaData/JpegMetaData/Common/ConvertData.class.php

@@ -346 +346 @@
      * or
      * Convert multiples null terminated string into an array of string
+     *    ==> if strings are null (eq. "\x00") nothing is added to the array
      *
      * Example:
@@ -365 +366 @@
         return("");
       }
-      elseif($occurs==1)
-      {
-        return($result[1][0]);
-      }
-      else
-      {
-        return($result[1]);
+      else
+      {
+        $returned=Array();
+        foreach($result[1] as $pop)
+        {
+          if($pop!="")
+          {
+            $returned[]=$pop;
+          }
+        }
+        if(count($returned)==1)
+        {
+          return($returned[0]);
+        }
+        elseif(count($returned)==0)
+        {
+          return("");
+        }
+        else
+        {
+          return($returned);
+        }
       }
     }

extensions/AMetaData/JpegMetaData/Readers/AppMarkerSegmentReader.class.php

@@ -860 +860 @@
           $this->dataLoaded=true;
           break;
-        case self::APP1_EXTENDED:
-          $this->data = $this->workData->readASCII();
+        case self::APP1_EXTENDEDXMP:
+          /* When Xmp data size exceed 65458 bytes, the Xmp tree is splited.
+           * Each chunk is written into the JPEG file within a separate APP1
+           * marker segment.
+           *
+           * Each ExtendedXMP marker segment contains:
+           *  - A null-terminated signature string of "http://ns.adobe.com/xmp/extension/".
+           *  - A 128-bit GUID stored as a 32-byte ASCII hex string, capital A-F,
+           *    no null termination. The GUID is a 128-bit MD5 digest of the
+           *    full ExtendedXMP serialization
+           *  - The full length of the ExtendedXMP serialization as a 32-bit
+           *    unsigned integer
+           *  - The offset of this portion as a 32-bit unsigned integer.
+           *  - The portion of the ExtendedXMP
+           *
+           * Each chunck is returned as an array :
+           *  - 'uid'    => the 128-bit GUID
+           *  - 'offset' => the offset
+           *  - 'data'   => xmp data packet
+           *
+           * Xmp Tree is rebuilded after all extendedXmp chunks are loaded, by
+           * the class calling the AppMarkerSegmentReader class (the JpegReader
+           * class)
+           */
+
+          $this->workData->setByteOrder(BYTE_ORDER_BIG_ENDIAN);
+          $this->data=Array(
+            'uid'    => $this->workData->readASCII(32, 35),
+            'offset' => $this->workData->readULong(71),
+            'data'   => $this->workData->readASCII(-1, 75)
+          );
+
           $this->dataLoaded=true;
           break;

extensions/AMetaData/JpegMetaData/Readers/CanonReader.class.php

@@ -127 +127 @@
           $returned=$values;
           break;
+        case 0x0004: // "CanonShotInfo"
+          $this->processSubTag0x0004($values);
+          $returned=$values;
+          break;
         case 0x0006: // "CanonImageType"
         case 0x0007: // "CanonFirmwareVersion"
@@ -135 +139 @@
            * null terminated strings
            */
-          $tmp=ConvertData::toStrings($values);
-          if(is_array($tmp))
-          {
-            $returned=$tmp[0];
-          }
-          else
-          {
-            $returned=$tmp;
-          }
+          $returned=ConvertData::toStrings($values);
           break;
         case 0x000c: // "SerialNumber"
           $returned=$values;
+          break;
+        case 0x000d: // "CanonCameraInfo"
+          $returned=$this->processSubTag0x000d($values);
           break;
         case 0x0010: // "CanonModelID"
@@ -167 +166 @@
     /**
      * this function process the subtag of the 0x0001 "CanonCameraSettings" tag
-     */
-    protected function processSubTag0x0001($values)
+     *
+     * @param Boolean $add : if set to false, the function return the tag value
+     *                       otherwise the function adds the tag
+     */
+    protected function processSubTag0x0001($values, $add=true)
     {
       foreach($values as $key => $val)
       {
-        $tagDef=$this->tagDef->getTagById("0001.$key");
+        $tagDef=$this->tagDef->getTagById("0x0001.$key");
 
         if(is_array($tagDef))
         {
           // make a fake IFDEntry
-          $entry=new IfdEntryReader("\x01\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF".chr($key), $this->byteOrder, "", 0, null);
-
-          $entry->getTag()->setId("0001.$key");
+          $entry=new IfdEntryReader("\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\x01\x00".chr($key), $this->byteOrder, "", 0, null);
+
+          $entry->getTag()->setId("0x0001.$key");
           $entry->getTag()->setName($tagDef['tagName']);
           $entry->getTag()->setValue($val);
@@ -190 +192 @@
             if(array_key_exists($val, $tagDef['tagValues']))
             {
-              $entry->getTag()->setLabel($tagDef['tagValues'][$val]);
+              $returned=$tagDef['tagValues'][$val];
             }
             else
             {
-              $entry->getTag()->setLabel("unknown (".$val.")");
+              $returned="unknown (".$val.")";
             }
           }
@@ -201 +203 @@
             switch($key)
             {
+              case 2: // SelfTimer
+                if($val==0)
+                {
+                  $returned=Array("Off");
+                }
+                else
+                {
+                  $returned=Array((($val & 0xfff) / 10).' s');
+                  if($val & 0x4000)
+                    $returned[]="Custom";
+                }
+                break;
+              case 22: // LensType
+                /* in most case, with one Id we have one lens
+                 * in some case, with one Id we can have more than one lens
+                 * in this case, we made a $focal var like :
+                 *             "90 mm"
+                 *             "28-300mm"
+                 * and try to find a lens with this properties
+                 */
+                if(array_key_exists($val, $tagDef['tagValues.special']))
+                {
+                  $lens=$tagDef['tagValues.special'][$val];
+
+                  if(is_array($lens))
+                  {
+                    $focalUnit=(array_key_exists(25, $values))?$values[25]:1;
+                    $FocalShort=(array_key_exists(24, $values))?$values[24]/$focalUnit:0;
+                    $FocalLong=(array_key_exists(23, $values))?$values[23]/$focalUnit:0;
+                    $focal=(($FocalShort==$FocalLong or $FocalLong==0)?$FocalShort:$FocalShort."-".$FocalLong)."mm";
+
+                    foreach($lens as $name)
+                    {
+                      if(preg_match("/.*".$focal.".*/i", $name))
+                        $returned=$name;
+                    }
+                  }
+                  else
+                  {
+                    $returned=$lens;
+                  }
+                }
+                else
+                {
+                  $returned=$tagDef['tagValues.special'][0xffff];
+                }
+
+                break;
+              case 23: // LongFocal
+              case 24: // ShortFocal
+                /* note : the values seems to be divided by the FocalUnit
+                 * (subTag #25)
+                 */
+                if(array_key_exists(25, $values))
+                {
+                  $focalUnit=$values[25];
+                }
+                else
+                {
+                  $focalUnit=1;
+                }
+
+                $returned=ConvertData::toFocalLength($val/$focalUnit);
+                break;
+              case 25: // FocalUnit
+                $returned=$val."/mm";
+                break;
+              case 26: // MaxAperture
+              case 27: // MinAperture
+                $returned=ConvertData::toFNumber(round(exp($this->canonEv($val)*log(2)/2),1));
+                break;
+              case 29: // FlashBits
+                $returned=Array();
+                foreach($tagDef['tagValues.special'] as $key => $name)
+                {
+                  if(($key & $val) == $key)
+                  {
+                    $returned[]=$name;
+                  }
+                }
+                break;
               default:
-                $entry->getTag()->setLabel("not yet implemented");
-                break;
-            }
-          }
-
-          $this->entries[]=$entry;
+                $returned="not yet implemented";
+                break;
+            }
+          }
+
+          if($add)
+          {
+            $entry->getTag()->setLabel($returned);
+            $this->entries[]=$entry;
+          }
+          else
+          {
+            // only return the value for the asked tag
+            unset($entry);
+            unset($tagDef);
+            return($returned);
+          }
 
           unset($entry);
@@ -214 +308 @@
       }
     }
+
+    /**
+     * this function process the subtag of the 0x0004 "CanonShotInfo" tag
+     *
+     * @param Boolean $add : if set to false, the function return the tag value
+     *                       otherwise the function adds the tag
+     */
+    protected function processSubTag0x0004($values, $add=true)
+    {
+      foreach($values as $key => $val)
+      {
+        $tagDef=$this->tagDef->getTagById("0x0004.$key");
+
+        if(is_array($tagDef))
+        {
+          // make a fake IFDEntry
+          $entry=new IfdEntryReader("\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\x04\x00".chr($key), $this->byteOrder, "", 0, null);
+
+          $entry->getTag()->setId("0x0004.$key");
+          $entry->getTag()->setName($tagDef['tagName']);
+          $entry->getTag()->setValue($val);
+          $entry->getTag()->setKnown(true);
+          $entry->getTag()->setImplemented($tagDef['implemented']);
+          $entry->getTag()->setTranslatable($tagDef['translatable']);
+
+          if(array_key_exists('tagValues', $tagDef))
+          {
+            if(array_key_exists($val, $tagDef['tagValues']))
+            {
+              $returned=$tagDef['tagValues'][$val];
+            }
+            else
+            {
+              $returned="unknown (".$val.")";
+            }
+          }
+          else
+          {
+            switch($key)
+            {
+              case 1: // AutoISO
+                $returned=round(exp($val/32*log(2))*100,0);
+                break;
+              case 2: // BaseISO
+                $returned=exp($this->canonEv($val) * log(2)) * 100 / 32;
+                break;
+              case 4: // TargetAperture
+              case 21: // FNumber
+                $returned=ConvertData::toFNumber(round(exp($this->canonEv($val)*log(2)/2), 1));
+                break;
+              case 5: // TargetExposureTime
+                $returned=ConvertData::toExposureTime(exp(-$this->CanonEv($val)*log(2)));
+                break;
+              case 6: // ExposureCompensation
+              case 15: // FlashExposureComp
+              case 17: // AEBBracketValue
+                $returned=ConvertData::$this->CanonEv($val);
+                break;
+              case 9: // SlowShutter
+                $returned=$val;
+                break;
+              case 13: // FlashGuideNumber
+                $returned=$val/32;
+                break;
+              case 23: // MeasuredEV2
+                $returned=$val/8-6;
+                break;
+              case 24: // BulbDuration
+              case 29: // SelfTimer2
+                $returned=$val/10;
+                break;
+              default:
+                $returned="not yet implemented";
+                break;
+            }
+          }
+
+          if($add)
+          {
+            $entry->getTag()->setLabel($returned);
+            $this->entries[]=$entry;
+          }
+          else
+          {
+            // only return the value for the asked tag
+            unset($entry);
+            unset($tagDef);
+            return($returned);
+          }
+
+          unset($entry);
+        }
+        unset($tagDef);
+      }
+    }
+
+    /**
+     * this function process the subtag of the 0x000d "CanonCameraInfo" tag
+     *
+     * @param Boolean $add : if set to false, the function return the tag value
+     *                       otherwise the function adds the tag
+     */
+    protected function processSubTag0x000d($values, $add=true)
+    {
+      $name=MakerNotesSignatures::getExifMaker();
+
+      if(preg_match("/\b1DS?$/", $name))
+      {
+
+      }/*
+      elseif(preg_match("/\b1Ds? Mark II$/", $name))
+      {
+
+      }
+      elseif(preg_match("/\b1Ds? Mark II N$/", $name))
+      {
+
+      }
+      elseif(preg_match("/\b1Ds? Mark III$/", $name))
+      {
+
+      }
+      elseif(preg_match("/EOS 5D$/", $name))
+      {
+
+      }
+      elseif(preg_match("/EOS 5D Mark II$/", $name))
+      {
+
+      }
+      elseif(preg_match("/EOS 7D$/", $name))
+      {
+
+      }*/
+      elseif(preg_match("/.*\b1D Mark IV/i", $name))
+      {
+        $returned=$this->processSubTag0x000d_1DMarkIV($values, $add);
+      }
+      elseif(preg_match("/.*EOS 40D/i", $name))
+      {
+        $returned=$this->processSubTag0x000d_40D($values, $add);
+      }/*
+      elseif(preg_match("/EOS 50D$/", $name))
+      {
+
+      }
+      elseif(preg_match("/\b(450D|REBEL XSi|Kiss X2)\b/", $name))
+      {
+
+      }
+      elseif(preg_match("/\b(500D|REBEL T1i|Kiss X3)\b/", $name))
+      {
+
+      }
+      elseif(preg_match("/\b(1000D|REBEL XS|Kiss F)\b/", $name))
+      {
+
+      }
+      elseif(preg_match("/\b1DS?/", $name))
+      {
+
+      }*/
+      else
+      {
+        /*
+         * note : powershot are not implemented, in exiftool condition to
+         * determine the model are not very understandable
+         */
+        $returned="$name is not yet implemented => ".ConvertData::toHexDump($values, ByteType::ASCII);
+      }
+      return($returned);
+    }
+
+    /**
+     * this function process the subtag of the 0x000d "CanonCameraInfo" tag
+     * for the EOS 40D camera
+     */
+    protected function processSubTag0x000d_40D($values)
+    {
+      $tagDef=$this->tagDef->getTagById(0x000d);
+      $list=$tagDef['tagValues.special']['40D'];
+      $data=new Data($values);
+
+      foreach($list as $tagIndex)
+      {
+        $subTagDef=$this->tagDef->getTagById("0x000d.40D.$tagIndex");
+
+        if(is_array($subTagDef))
+        {
+          $val=$this->readDataFromSubTag($data, $subTagDef);
+
+          // make a fake IFDEntry
+          $entry=new IfdEntryReader("\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\x0d\x00\x00", $this->byteOrder, "", 0, null);
+
+          $entry->getTag()->setId("0x000d.40D.$tagIndex");
+          $entry->getTag()->setName($subTagDef['tagName']);
+          $entry->getTag()->setValue($val);
+          $entry->getTag()->setKnown(true);
+          $entry->getTag()->setImplemented($subTagDef['implemented']);
+          $entry->getTag()->setTranslatable($subTagDef['translatable']);
+
+          if(array_key_exists('tagValues', $subTagDef))
+          {
+            if(array_key_exists($val, $subTagDef['tagValues']))
+            {
+              $returned=$subTagDef['tagValues'][$val];
+            }
+            else
+            {
+              $returned="unknown (".$val.")";
+            }
+          }
+          else
+          {
+            switch($tagIndex)
+            {
+              case 24: // CameraTemperature
+                $returned=($val-128)."°C";
+                break;
+              case 29: // FocalLength
+                $returned=ConvertData::toFocalLength($val);
+                break;
+              case 111: // WhiteBalance
+                // same method than the ShotInfo.WhiteBalance tag
+                $returned=$this->processSubTag0x0004(Array(7 => $val), false);
+                break;
+              case 214: // LensType
+                // same method than the CanonCameraSettings.LensType tag
+                $FocalShort=$this->readDataFromSubTag($data, $this->tagDef->getTagById("0x000d.40D.216"));
+                $FocalLong=$this->readDataFromSubTag($data, $this->tagDef->getTagById("0x000d.40D.218"));
+
+                $returned=$this->processSubTag0x0001(Array(22 => $val, 23 => $FocalLong, 24 => $FocalShort), false);
+                break;
+              case 216: // ShortFocal
+              case 218: // LongFocal
+                $returned=ConvertData::toFocalLength($val);
+                break;
+              case 255: // FirmwareVersion
+              case 2347: // LensModel
+                $returned=ConvertData::toStrings($val);
+                break;
+              default:
+                $returned="not yet implemented ($tagIndex)";
+                break;
+            }
+          }
+
+          $entry->getTag()->setLabel($returned);
+          $this->entries[]=$entry;
+
+          unset($entry);
+        }
+        unset($subTagDef);
+      }
+      unset($tagDef);
+      unset($list);
+      unset($data);
+
+      return("[EOS 40D]");
+    }
+
+    /**
+     * this function process the subtag of the 0x000d "CanonCameraInfo" tag
+     * for the EOS 1D Mark IV camera
+     *
+     */
+    protected function processSubTag0x000d_1DMarkIV($values)
+    {
+      $tagDef=$this->tagDef->getTagById(0x000d);
+      $list=$tagDef['tagValues.special']['1DMarkIV'];
+      $data=new Data($values);
+
+      foreach($list as $tagIndex)
+      {
+        $subTagDef=$this->tagDef->getTagById("0x000d.1DMarkIV.$tagIndex");
+
+        if(is_array($subTagDef))
+        {
+          $val=$this->readDataFromSubTag($data, $subTagDef);
+
+          // make a fake IFDEntry
+          $entry=new IfdEntryReader("\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\x0d\x00\x00", $this->byteOrder, "", 0, null);
+
+          $entry->getTag()->setId("0x000d.1DMarkIV.$tagIndex");
+          $entry->getTag()->setName($subTagDef['tagName']);
+          $entry->getTag()->setValue($val);
+          $entry->getTag()->setKnown(true);
+          $entry->getTag()->setImplemented($subTagDef['implemented']);
+          $entry->getTag()->setTranslatable($subTagDef['translatable']);
+
+          if(array_key_exists('tagValues', $subTagDef))
+          {
+            if(array_key_exists($val, $subTagDef['tagValues']))
+            {
+              $returned=$subTagDef['tagValues'][$val];
+            }
+            else
+            {
+              $returned="unknown (".$val.")";
+            }
+          }
+          else
+          {
+            switch($tagIndex)
+            {
+              case 25: // CameraTemperature
+                $returned=($val-128)."°C";
+                break;
+              case 30: // FocalLength
+                $returned=ConvertData::toFocalLength($val);
+                break;
+              default:
+                $returned="not yet implemented ($tagIndex)";
+                break;
+            }
+          }
+
+          $entry->getTag()->setLabel($returned);
+          $this->entries[]=$entry;
+
+          unset($entry);
+        }
+        unset($subTagDef);
+      }
+      unset($tagDef);
+      unset($list);
+      unset($data);
+
+      return("[EOS 1D Mark IV]");
+    }
+
+
+
+    /**
+     * read datas from a $data object, according to the tag definition
+     *
+     * @param Data $data : a Data object
+     * @param Array $tagDef : the tag definition
+     */
+    protected function readDataFromSubTag($data, $tagDef)
+    {
+      if(!array_key_exists('pos', $tagDef))
+        return("Invalid tagDef (no 'pos')");
+
+      $pos=$tagDef['pos'];
+
+      if(array_key_exists('byteOrder', $tagDef))
+      {
+        $data->setByteOrder($tagDef['byteOrder']);
+      }
+      else
+      {
+        $data->setByteOrder(BYTE_ORDER_LITTLE_ENDIAN);
+      }
+
+      $returned="";
+      switch($tagDef['type'])
+      {
+        case ByteType::UNDEFINED:
+        case ByteType::UNKNOWN :
+        case ByteType::ASCII:
+          $nbCar=(array_key_exists('length', $tagDef))?$tagDef['length']:1;
+          $returned=$data->readASCII($nbCar, $pos);
+          break;
+        case ByteType::UBYTE:
+          $returned=$data->readUByte($pos);
+          break;
+        case ByteType::USHORT:
+          $returned=$data->readUShort($pos);
+          break;
+        case ByteType::ULONG:
+          $returned=$data->readULong($pos);
+          break;
+        case ByteType::URATIONAL:
+          $returned=$data->readURational($pos);
+          break;
+        case ByteType::SBYTE:
+          $returned=$data->readSByte($pos);
+          break;
+        case ByteType::SSHORT:
+          $returned=$data->readSShort($pos);
+          break;
+        case ByteType::SLONG:
+          $returned=$data->readSLong($pos);
+          break;
+        case ByteType::SRATIONAL:
+          $returned=$data->readSRational($pos);
+          break;
+        case ByteType::FLOAT:
+          $returned="";
+          break;
+        case ByteType::DOUBLE:
+          $returned="";
+          break;
+      }
+      return($returned);
+    }
+
+
+    /**
+     * Convert Canon hex-based EV (modulo 0x20) to real number
+     *     0x00 -> 0
+     *     0x0c -> 0.33333
+     *     0x10 -> 0.5
+     *     0x14 -> 0.66666
+     *     0x20 -> 1   ...  etc
+     *
+     * function from exiftool
+     *
+     * @param Integer $value : the canon EV value
+     * @return Float : the converted value
+     */
+    protected function canonEv($val)
+    {
+      //$val=95;
+
+      if($val<0)
+      {
+        $val=-$val;
+        $sign=-1;
+      }
+      else
+      {
+        $sign=1;
+      }
+      $frac = (float) ($val & 0x1f); //$frac = $val % 0x20;
+      $val -= $frac;  // remove fraction
+      // Convert 1/3 and 2/3 codes
+      if ($frac == 0x0c)
+      {
+        $frac = 0x20 / 3;
+      }
+      elseif($frac==0x14)
+      {
+        $frac = 0x40 / 3;
+      }
+      return($sign * ($val + $frac) / 0x20);
+    }
   }
 

extensions/AMetaData/JpegMetaData/Readers/JpegReader.class.php

@@ -152 +152 @@
           {
             $this->readAppMarkerSegments();
+            $this->processSpecialAppMarkerSegments();
             $this->isLoaded=true;
           }
@@ -225 +226 @@
     /**
      *
+     * This function process special APP marker segment
+     *
+     * At now, only the extendedXmp segment are managed
+     *
+     */
+    protected function processSpecialAppMarkerSegments()
+    {
+      /*
+       * process APP extendedXmp segment
+       *
+       * 1/ read all APP segment and find APP1/EXTENDEDXMP segments
+       * 2/ sort APP1/EXTENDEDXMP segments by UID+OFFSET
+       * 3/ merge segment data
+       * 4/ build a new AppMarkerSegmentReader (as an APP1_XMP segement)
+       */
+      $extendedXmp=Array();
+      foreach($this->appMarkerSegmentReader as $marker)
+      {
+        if($marker->getHeader()==AppMarkerSegmentReader::SEGMENT_APP1 and
+           $marker->getSubType()==AppMarkerSegmentReader::APP1_EXTENDEDXMP)
+        {
+          $extendedXmp[]=$marker->getData();
+        }
+      }
+      usort($extendedXmp, Array(&$this, "sortExtendedXmp"));
+
+      $xmp="";
+      foreach($extendedXmp as $marker)
+      {
+        $xmp.=$marker['data'];
+      }
+
+      $marker=new AppMarkerSegmentReader(
+        AppMarkerSegmentReader::SEGMENT_APP1,
+        0,
+        strlen($xmp),
+        AppMarkerSegmentReader::APP1_XMP,
+        "http://ns.adobe.com/xap/1.0/\x00".$xmp
+      );
+
+      if($marker)
+      {
+        /*
+         * if there is a marker returned, push it on the markers array
+         */
+        $this->appMarkerSegmentReader[]=$marker;
+        unset($marker);
+      }
+      unset($extendedXmp);
+      unset($xmp);
+    }
+
+    /**
+     * This function is used to sort the extendedXmp segments
+     */
+    protected function sortExtendedXmp($a, $b)
+    {
+      if (($a['uid'].$a['offset']) == ($b['uid'].$b['offset']))
+      {
+        return(0);
+      }
+      return((($a['uid'].$a['offset']) < ($b['uid'].$b['offset'])) ? -1 : 1);
+    }
+
+
+    /**
+     *
      * returns the filename given to the object
      *

extensions/AMetaData/JpegMetaData/Readers/XmpReader.class.php

@@ -360 +360 @@
       {
         case "x:xmptk":
+        case "aux:Lens":
+        case "aux:Firmware":
+        case "aux:SerialNumber":
         case "dc:coverage":
         case "dc:format":

extensions/AMetaData/JpegMetaData/TagDefinitions/CanonTags.class.php

@@ -54 +54 @@
 
   /**
-   * Define the tags for Nikon camera
+   * Define the tags for Canon camera
    */
   class CanonTags extends KnownTags
@@ -74 +74 @@
 
       /*
-       * The 'CanonCameraSettings' tags is composed of 46 sub tags
+       * The 'CanonCameraSettings' tags is composed by an array of sub tags
        * Each subtag name is defined bu the class by the concatenation of
-       * "CanonCameraSettings" and the subtag nam
+       * "CanonCameraSettings" and the subtag name
        *
        * Giving something like :
@@ -82 +82 @@
        *
        * This kind of data needs a particular algorythm in the CanonReader class
+       * provided by the processSubTag0x0001 function
+       *
+       * Keys are defined by a string build with :
+       *  - the tag number in hexa "0x0001"
+       *  - a dot "."
+       *  - sub tag number in decimal "10"
+       *  ==> "0x0001.10" => "CanonCameraSettings.CanonImageSize"
        *
        * >>> Begin of CanonCameraSettings subtags
        *
        */
-      "0001.1" => Array(
+      "0x0001.1" => Array(
         'tagName'     => "CanonCameraSettings.MacroMode",
         'schema'      => "Canon",
@@ -98 +105 @@
       ),
 
-      "0001.2" => Array(
+      "0x0001.2" => Array(
         'tagName'     => "CanonCameraSettings.SelfTimer",
         'schema'      => "Canon",
-        'translatable'=> false,
-        'combiTag'    => 0,
-        'implemented' => false,
-      ),
-
-      "0001.3" => Array(
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0001.3" => Array(
         'tagName'     => "CanonCameraSettings.Quality",
         'schema'      => "Canon",
@@ -122 +129 @@
       ),
 
-      "0001.4" => Array(
+      "0x0001.4" => Array(
         'tagName'     => "CanonCameraSettings.CanonFlashMode",
         'schema'      => "Canon",
@@ -140 +147 @@
       ),
 
-      "0001.5" => Array(
+      "0x0001.5" => Array(
         'tagName'     => "CanonCameraSettings.ContinuousDrive",
         'schema'      => "Canon",
@@ -156 +163 @@
       ),
 
-      "0001.7" => Array(
+      "0x0001.7" => Array(
         'tagName'     => "CanonCameraSettings.FocusMode",
         'schema'      => "Canon",
@@ -174 +181 @@
       ),
 
-      "0001.9" => Array(
+      "0x0001.9" => Array(
         'tagName'     => "CanonCameraSettings.RecordMode",
         'schema'      => "Canon",
@@ -191 +198 @@
       ),
 
-      "0001.10" => Array(
+      "0x0001.10" => Array(
         'tagName'     => "CanonCameraSettings.CanonImageSize",
         'schema'      => "Canon",
@@ -211 +218 @@
       ),
 
+      "0x0001.11" => Array(
+        'tagName'     => "CanonCameraSettings.EasyMode",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Full auto",
+            0x01 => "Manual",
+            0x02 => "Landscape",
+            0x03 => "Fast shutter",
+            0x04 => "Slow shutter",
+            0x05 => "Night",
+            0x06 => "Gray Scale",
+            0x07 => "Sepia",
+            0x08 => "Portrait",
+            0x09 => "Sports",
+            0x0a => "Macro",
+            0x0b => "Black & White",
+            0x0c => "Pan focus",
+            0x0d => "Vivid",
+            0x0e => "Neutral",
+            0x0f => "Flash Off",
+            0x10 => "Long Shutter",
+            0x11 => "Super Macro",
+            0x12 => "Foliage",
+            0x13 => "Indoor",
+            0x14 => "Fireworks",
+            0x15 => "Beach",
+            0x16 => "Underwater",
+            0x17 => "Snow",
+            0x18 => "Kids & Pets",
+            0x19 => "Night Snapshot",
+            0x1a => "Digital Macro",
+            0x1b => "My Colors",
+            0x1c => "Still Image",
+            0x1d => "Color Accent",
+            0x1e => "Color Swap",
+            0x20 => "Aquarium",
+            0x21 => "ISO 3200",
+            0x26 => "Creative Auto",
+            0x105 => "Sunset",
+          ),
+      ),
+
+      "0x0001.12" => Array(
+        'tagName'     => "CanonCameraSettings.DigitalZoom",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0 => "None",
+            1 => "2x",
+            2 => "4x",
+            3 => "Other",
+          ),
+      ),
+
+      "0x0001.13" => Array(
+        'tagName'     => "CanonCameraSettings.Contrast",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0001.14" => Array(
+        'tagName'     => "CanonCameraSettings.Saturation",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0001.15" => Array(
+        'tagName'     => "CanonCameraSettings.Sharpness",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0001.16" => Array(
+        'tagName'     => "CanonCameraSettings.CameraISO",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0001.17" => Array(
+        'tagName'     => "CanonCameraSettings.MeteringMode",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Default",
+            0x01 => "Spot",
+            0x02 => "Average",
+            0x03 => "Evaluative",
+            0x04 => "Partial",
+            0x05 => "Center-weighted average",
+        ),
+      ),
+
+      "0x0001.18" => Array(
+        'tagName'     => "CanonCameraSettings.FocusRange",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Manual",
+            0x01 => "Auto",
+            0x02 => "Not Known",
+            0x03 => "Macro",
+            0x04 => "Very Close",
+            0x05 => "Close",
+            0x06 => "Middle Range",
+            0x07 => "Far Range",
+            0x08 => "Pan Focus",
+            0x09 => "Super Macro",
+            0x0a => "Infinity"
+        ),
+      ),
+
+      "0x0001.18" => Array(
+        'tagName'     => "CanonCameraSettings.FocusRange",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Manual",
+            0x01 => "Auto",
+            0x02 => "Not Known",
+            0x03 => "Macro",
+            0x04 => "Very Close",
+            0x05 => "Close",
+            0x06 => "Middle Range",
+            0x07 => "Far Range",
+            0x08 => "Pan Focus",
+            0x09 => "Super Macro",
+            0x0a => "Infinity"
+        ),
+      ),
+
+      "0x0001.19" => Array(
+        'tagName'     => "CanonCameraSettings.AFPoint",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x2005 => "Manual AF point selection",
+            0x3000 => "None (MF)",
+            0x3001 => "Auto AF point selection",
+            0x3002 => "Right",
+            0x3003 => "Center",
+            0x3004 => "Left",
+            0x4001 => "Auto AF point selection",
+            0x4006 => "Face Detect"
+        ),
+      ),
+
+      "0x0001.20" => Array(
+        'tagName'     => "CanonCameraSettings.CanonExposureMode",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0 => "Easy",
+            1 => "Program AE",
+            2 => "Shutter speed priority AE",
+            3 => "Aperture-priority AE",
+            4 => "Manual",
+            5 => "Depth-of-field AE",
+            6 => "M-Dep",
+            7 => "Bulb"
+        ),
+      ),
+
+      "0x0001.22" => Array(
+        'tagName'     => "CanonCameraSettings.LensType",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues.special' => Array(
+              /* some lenses have the same Id. In this case associated name is
+               * not a single string, but an Array
+               *
+               * the lens CanonReader->processSubTag0x0001 function try to find
+               * to good lens by looking in each name if the ShortFocal-LongFocal
+               * correspond
+               */
+         0xffff => "Unknown lens",
+              1 => "Canon EF 50mm f/1.8",
+              2 => "Canon EF 28mm f/2.8",
+              3 => "Canon EF 135mm f/2.8 Soft",
+              4 => Array(
+                      "Canon EF 35-105mm f/3.5-4.5",
+                      "Sigma UC Zoom 35-135mm f/4-5.6",
+                    ),
+              5 => "Canon EF 35-70mm f/3.5-4.5",
+              6 => Array(
+                      "Canon EF 28-70mm f/3.5-4.5",
+                      "Sigma 18-50mm f/3.5-5.6 DC",
+                      "Sigma 18-125mm f/3.5-5.6 DC IF ASP",
+                      "Tokina AF193-2 19-35mm f/3.5-4.5",
+                    ),
+              7 => "Canon EF 100-300mm f/5.6L",
+              8 => Array(
+                      "Canon EF 100-300mm f/5.6",
+                      "Sigma 70-300mm f/4-5.6 DG Macro",
+                      "Tokina AT-X242AF 24-200mm f/3.5-5.6",
+                    ),
+              9 => Array(
+                      "Canon EF 70-210mm f/4",
+                      "Sigma 55-200mm f/4-5.6 DC",
+                    ),
+              10 => Array(
+                      "Canon EF 50mm f/2.5 Macro",
+                      "Sigma 50mm f/2.8 EX",
+                      "Sigma 28mm f/1.8",
+                      "Sigma 105mm f/2.8 Macro EX",
+                    ),
+              11 => "Canon EF 35mm f/2",
+              13 => "Canon EF 15mm f/2.8 Fisheye",
+              14 => "Canon EF 50-200mm f/3.5-4.5L",
+              15 => "Canon EF 50-200mm f/3.5-4.5",
+              16 => "Canon EF 35-135mm f/3.5-4.5",
+              17 => "Canon EF 35-70mm f/3.5-4.5A",
+              18 => "Canon EF 28-70mm f/3.5-4.5",
+              20 => "Canon EF 100-200mm f/4.5A",
+              21 => "Canon EF 80-200mm f/2.8L",
+              22 => Array(
+                        "Canon EF 20-35mm f/2.8L",
+                        "Tokina AT-X280AF PRO 28-80mm f/2.8 Aspherical",
+                      ),
+              23 => "Canon EF 35-105mm f/3.5-4.5",
+              24 => "Canon EF 35-80mm f/4-5.6 Power Zoom",
+              25 => "Canon EF 35-80mm f/4-5.6 Power Zoom",
+              26 => Array(
+                        "Canon EF 100mm f/2.8 Macro",
+                        "Cosina 100mm f/3.5 Macro AF",
+                        "Tamron SP AF 90mm f/2.8 Di Macro",
+                        "Tamron SP AF 180mm f/3.5 Di Macro",
+                        "Carl Zeiss Planar T* 50mm f/1.4",
+                      ),
+              27 => "Canon EF 35-80mm f/4-5.6",
+              28 => Array(
+                        "Canon EF 80-200mm f/4.5-5.6",
+                        "Tamron SP AF 28-105mm f/2.8 LD Aspherical IF",
+                        "Tamron SP AF 28-75mm f/2.8 XR Di LD Aspherical [IF] Macro",
+                        "Tamron AF 70-300mm f/4.5-5.6 Di LD 1:2 Macro Zoom",
+                        "Tamron AF Aspherical 28-200mm f/3.8-5.6",
+                      ),
+              29 => "Canon EF 50mm f/1.8 MkII",
+              30 => "Canon EF 35-105mm f/4.5-5.6",
+              31 => Array(
+                        "Canon EF 75-300mm f/4-5.6",
+                        "Tamron SP AF 300mm f/2.8 LD IF",
+                      ),
+              32 => Array(
+                        "Canon EF 24mm f/2.8",
+                        "Sigma 15mm f/2.8 EX Fisheye",
+                      ),
+              33 => "Voigtlander Ultron 40mm f/2 SLII Aspherical",
+              35 => "Canon EF 35-80mm f/4-5.6",
+              36 => "Canon EF 38-76mm f/4.5-5.6",
+              37 => Array(
+                        "Canon EF 35-80mm f/4-5.6",
+                        "Tamron 70-200mm f/2.8 Di LD IF Macro",
+                        "Tamron AF 28-300mm f/3.5-6.3 XR Di VC LD Aspherical [IF] Macro Model A20",
+                      ),
+              38 => "Canon EF 80-200mm f/4.5-5.6",
+              39 => "Canon EF 75-300mm f/4-5.6",
+              40 => "Canon EF 28-80mm f/3.5-5.6",
+              41 => "Canon EF 28-90mm f/4-5.6",
+              42 => Array(
+                        "Canon EF 28-200mm f/3.5-5.6",
+                        "Tamron AF 28-300mm f/3.5-6.3 XR Di VC LD Aspherical [IF] Macro Model A20",
+                      ),
+              43 => "Canon EF 28-105mm f/4-5.6",
+              44 => "Canon EF 90-300mm f/4.5-5.6",
+              45 => "Canon EF-S 18-55mm f/3.5-5.6",
+              46 => "Canon EF 28-90mm f/4-5.6",
+              48 => "Canon EF-S 18-55mm f/3.5-5.6 IS",
+              49 => "Canon EF-S 55-250mm f/4-5.6 IS",
+              50 => "Canon EF-S 18-200mm f/3.5-5.6 IS",
+              51 => "Canon EF-S 18-135mm f/3.5-5.6 IS",
+              94 => "Canon TS-E 17mm f/4L",
+              95 => "Canon TS-E 24.0mm f/3.5 L II",
+              124 => "Canon MP-E 65mm f/2.8 1-5x Macro Photo",
+              125 => "Canon TS-E 24mm f/3.5L",
+              126 => "Canon TS-E 45mm f/2.8",
+              127 => "Canon TS-E 90mm f/2.8",
+              129 => "Canon EF 300mm f/2.8L",
+              130 => "Canon EF 50mm f/1.0L",
+              131 => Array(
+                        "Canon EF 28-80mm f/2.8-4L",
+                        "Sigma 8mm f/3.5 EX DG Circular Fisheye",
+                        "Sigma 17-35mm f/2.8-4 EX DG Aspherical HSM",
+                        "Sigma 17-70mm f/2.8-4.5 DC Macro",
+                        "Sigma APO 50-150mm f/2.8 [II] EX DC HSM",
+                        "Sigma APO 120-300mm f/2.8 EX DG HSM",
+                      ),
+              132 => "Canon EF 1200mm f/5.6L",
+              134 => "Canon EF 600mm f/4L IS",
+              135 => "Canon EF 200mm f/1.8L",
+              136 => "Canon EF 300mm f/2.8L",
+              137 => Array(
+                        "Canon EF 85mm f/1.2L",
+                        "Sigma 18-50mm f/2.8-4.5 DC OS HSM",
+                        "Sigma 50-200mm f/4-5.6 DC OS HSM",
+                        "Sigma 18-250mm f/3.5-6.3 DC OS HSM",
+                        "Sigma 24-70mm f/2.8 IF EX DG HSM",
+                        "Sigma 18-125mm f/3.8-5.6 DC OS HSM",
+                      ),
+              138 => "Canon EF 28-80mm f/2.8-4L",
+              139 => "Canon EF 400mm f/2.8L",
+              140 => "Canon EF 500mm f/4.5L",
+              141 => "Canon EF 500mm f/4.5L",
+              142 => "Canon EF 300mm f/2.8L IS",
+              143 => "Canon EF 500mm f/4L IS",
+              144 => "Canon EF 35-135mm f/4-5.6 USM",
+              145 => "Canon EF 100-300mm f/4.5-5.6 USM",
+              146 => "Canon EF 70-210mm f/3.5-4.5 USM",
+              147 => "Canon EF 35-135mm f/4-5.6 USM",
+              148 => "Canon EF 28-80mm f/3.5-5.6 USM",
+              149 => "Canon EF 100mm f/2 USM",
+              150 => Array(
+                        "Canon EF 14mm f/2.8L",
+                        "Sigma 20mm EX f/1.8",
+                        "Sigma 30mm f/1.4 DC HSM",
+                        "Sigma 24mm f/1.8 DG Macro EX",
+                      ),
+              151 => "Canon EF 200mm f/2.8L",
+              152 => Array(
+                        "Canon EF 300mm f/4L IS",
+                        "Sigma 12-24mm f/4.5-5.6 EX DG ASPHERICAL HSM",
+                        "Sigma 14mm f/2.8 EX Aspherical HSM",
+                        "Sigma 10-20mm f/4-5.6",
+                        "Sigma 100-300mm f/4",
+                      ),
+              153 => Array(
+                        "Canon EF 35-350mm f/3.5-5.6L",
+                        "Sigma 50-500mm f/4-6.3 APO HSM EX",
+                        "Tamron AF 28-300mm f/3.5-6.3 XR LD Aspherical [IF] Macro",
+                        "Tamron AF 18-200mm f/3.5-6.3 XR Di II LD Aspherical [IF] Macro Model A14",
+                        "Tamron 18-250mm f/3.5-6.3 Di II LD Aspherical [IF] Macro",
+                      ),
+              154 => "Canon EF 20mm f/2.8 USM",
+              155 => "Canon EF 85mm f/1.8 USM",
+              156 => "Canon EF 28-105mm f/3.5-4.5 USM",
+              160 => Array(
+                        "Canon EF 20-35mm f/3.5-4.5 USM",
+                        "Tamron AF 19-35mm f/3.5-4.5",
+                      ),
+              161 => Array(
+                        "Canon EF 28-70mm f/2.8L",
+                        "Sigma 24-70mm EX f/2.8",
+                        "Tamron 90mm f/2.8",
+                        "Tamron AF 17-50mm f/2.8 Di-II LD Aspherical",
+                      ),
+              162 => "Canon EF 200mm f/2.8L",
+              163 => "Canon EF 300mm f/4L",
+              164 => "Canon EF 400mm f/5.6L",
+              165 => "Canon EF 70-200mm f/2.8 L",
+              166 => "Canon EF 70-200mm f/2.8 L + 1.4x",
+              167 => "Canon EF 70-200mm f/2.8 L + 2x",
+              168 => "Canon EF 28mm f/1.8 USM",
+              169 => Array(
+                        "Canon EF 17-35mm f/2.8L",
+                        "Sigma 18-200mm f/3.5-6.3 DC OS",
+                        "Sigma 15-30mm f/3.5-4.5 EX DG Aspherical",
+                        "Sigma 18-50mm f/2.8 Macro",
+                        "Sigma 50mm f/1.4 EX DG HSM",
+                      ),
+              170 => "Canon EF 200mm f/2.8L II",
+              171 => "Canon EF 300mm f/4L",
+              172 => "Canon EF 400mm f/5.6L",
+              173 => Array(
+                        "Canon EF 180mm Macro f/3.5L",
+                        "Sigma 180mm EX HSM Macro f/3.5",
+                        "Sigma APO Macro 150mm f/2.8 EX DG HSM",
+                      ),
+              174 => "Canon EF 135mm f/2L",
+              175 => "Canon EF 400mm f/2.8L",
+              176 => "Canon EF 24-85mm f/3.5-4.5 USM",
+              177 => "Canon EF 300mm f/4L IS",
+              178 => "Canon EF 28-135mm f/3.5-5.6 IS",
+              179 => "Canon EF 24mm f/1.4L",
+              180 => "Canon EF 35mm f/1.4L",
+              181 => "Canon EF 100-400mm f/4.5-5.6L IS + 1.4x",
+              182 => "Canon EF 100-400mm f/4.5-5.6L IS + 2x",
+              183 => "Canon EF 100-400mm f/4.5-5.6L IS",
+              184 => "Canon EF 400mm f/2.8L + 2x",
+              185 => "Canon EF 600mm f/4L IS",
+              186 => "Canon EF 70-200mm f/4L",
+              187 => "Canon EF 70-200mm f/4L + 1.4x",
+              188 => "Canon EF 70-200mm f/4L + 2x",
+              189 => "Canon EF 70-200mm f/4L + 2.8x",
+              190 => "Canon EF 100mm f/2.8 Macro",
+              191 => "Canon EF 400mm f/4 DO IS",
+              193 => "Canon EF 35-80mm f/4-5.6 USM",
+              194 => "Canon EF 80-200mm f/4.5-5.6 USM",
+              195 => "Canon EF 35-105mm f/4.5-5.6 USM",
+              196 => "Canon EF 75-300mm f/4-5.6 USM",
+              197 => "Canon EF 75-300mm f/4-5.6 IS USM",
+              198 => "Canon EF 50mm f/1.4 USM",
+              199 => "Canon EF 28-80mm f/3.5-5.6 USM",
+              200 => "Canon EF 75-300mm f/4-5.6 USM",
+              201 => "Canon EF 28-80mm f/3.5-5.6 USM",
+              202 => "Canon EF 28-80mm f/3.5-5.6 USM IV",
+              208 => "Canon EF 22-55mm f/4-5.6 USM",
+              209 => "Canon EF 55-200mm f/4.5-5.6",
+              210 => "Canon EF 28-90mm f/4-5.6 USM",
+              211 => "Canon EF 28-200mm f/3.5-5.6 USM",
+              212 => "Canon EF 28-105mm f/4-5.6 USM",
+              213 => "Canon EF 90-300mm f/4.5-5.6 USM",
+              214 => "Canon EF-S 18-55mm f/3.5-4.5 USM",
+              215 => "Canon EF 55-200mm f/4.5-5.6 II USM",
+              224 => "Canon EF 70-200mm f/2.8L IS",
+              225 => "Canon EF 70-200mm f/2.8L IS + 1.4x",
+              226 => "Canon EF 70-200mm f/2.8L IS + 2x",
+              227 => "Canon EF 70-200mm f/2.8L IS + 2.8x",
+              228 => "Canon EF 28-105mm f/3.5-4.5 USM",
+              229 => "Canon EF 16-35mm f/2.8L",
+              230 => "Canon EF 24-70mm f/2.8L",
+              231 => "Canon EF 17-40mm f/4L",
+              232 => "Canon EF 70-300mm f/4.5-5.6 DO IS USM",
+              233 => "Canon EF 28-300mm f/3.5-5.6L IS",
+              234 => "Canon EF-S 17-85mm f4-5.6 IS USM",
+              235 => "Canon EF-S 10-22mm f/3.5-4.5 USM",
+              236 => "Canon EF-S 60mm f/2.8 Macro USM",
+              237 => "Canon EF 24-105mm f/4L IS",
+              238 => "Canon EF 70-300mm f/4-5.6 IS USM",
+              239 => "Canon EF 85mm f/1.2L II",
+              240 => "Canon EF-S 17-55mm f/2.8 IS USM",
+              241 => "Canon EF 50mm f/1.2L",
+              242 => "Canon EF 70-200mm f/4L IS",
+              243 => "Canon EF 70-200mm f/4L IS + 1.4x",
+              244 => "Canon EF 70-200mm f/4L IS + 2x",
+              245 => "Canon EF 70-200mm f/4L IS + 2.8x",
+              246 => "Canon EF 16-35mm f/2.8L II",
+              247 => "Canon EF 14mm f/2.8L II USM",
+              248 => "Canon EF 200mm f/2L IS",
+              249 => "Canon EF 800mm f/5.6L IS",
+              250 => "Canon EF 24 f/1.4L II",
+              254 => "Canon EF 100mm f/2.8L Macro IS USM",
+              488 => "Canon EF-S 15-85mm f/3.5-5.6 IS USM",
+        ),
+      ),
+
+      "0x0001.23" => Array(
+        'tagName'     => "CanonCameraSettings.LongFocal",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0001.24" => Array(
+        'tagName'     => "CanonCameraSettings.ShortFocal",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0001.25" => Array(
+        'tagName'     => "CanonCameraSettings.FocalUnits",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0001.26" => Array(
+        'tagName'     => "CanonCameraSettings.MaxAperture",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0001.27" => Array(
+        'tagName'     => "CanonCameraSettings.MinAperture",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0001.28" => Array(
+        'tagName'     => "CanonCameraSettings.FlashActivity",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Did not fire",
+            0x01 => "Fired",
+        ),
+      ),
+
+      "0x0001.29" => Array(
+        'tagName'     => "CanonCameraSettings.FlashBits",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues.special' => Array(
+            0x0001 => "Manual",                  //b0000000000000001
+            0x0002 => "TTL",                     //b0000000000000010
+            0x0004 => "A-TTL",                   //b0000000000000100
+            0x0008 => "E-TTL",                   //b0000000000001000
+            0x0010 => "FP sync enabled",         //b0000000000010000
+            0x0080 => "2nd-curtain sync used",   //b0000000010000000
+            0x0800 => "FP sync used",            //b0000100000000000
+            0x2000 => "Built-in",                //b0010000000000000
+            0x4000 => "External",                //b0100000000000000
+        ),
+      ),
+
+      "0x0001.32" => Array(
+        'tagName'     => "CanonCameraSettings.FocusContinuous",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Single",
+            0x01 => "Continuous",
+            0x08 => "Manual",
+            0xFFFF => "Unknown",
+        ),
+      ),
+
+      "0x0001.33" => Array(
+        'tagName'     => "CanonCameraSettings.AESetting",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Normal AE",
+            0x01 => "Exposure Compensation",
+            0x02 => "AE Lock",
+            0x03 => "AE Lock + Exposure Comp.",
+            0x04 => "No AE"
+        ),
+      ),
+
+      "0x0001.34" => Array(
+        'tagName'     => "CanonCameraSettings.ImageStabilization",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Off",
+            0x01 => "On",
+            0x02 => "On, Shot Only",
+            0x03 => "On, Panning",
+            0xFFFF => "Unknown",
+        ),
+      ),
+
+      "0x0001.35" => Array(
+        'tagName'     => "CanonCameraSettings.DisplayAperture",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0001.36" => Array(
+        'tagName'     => "CanonCameraSettings.ZoomSourceWidth",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0001.37" => Array(
+        'tagName'     => "CanonCameraSettings.ZoomTargetWidth",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0001.39" => Array(
+        'tagName'     => "CanonCameraSettings.SpotMeteringMode",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Center",
+            0x01 => "AF Point",
+            0xFFFF => "Unknown",
+        ),
+      ),
+
+      "0x0001.40" => Array(
+        'tagName'     => "CanonCameraSettings.PhotoEffect",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Off",
+            0x01 => "Vivid",
+            0x02 => "Neutral",
+            0x03 => "Smooth",
+            0x04 => "Sepia",
+            0x05 => "B&W",
+            0x06 => "Custom",
+            0x64 => "My Color Data",
+            0xFFFF => "Unknown",
+        ),
+      ),
+
+      "0x0001.41" => Array(
+        'tagName'     => "CanonCameraSettings.ManualFlashOutput",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x0000 => "n/a",
+            0x0500 => "Full",
+            0x0502 => "Medium",
+            0x0504 => "Low",
+            0x7fff => "n/a",
+        ),
+      ),
+
+      "0x0001.42" => Array(
+        'tagName'     => "CanonCameraSettings.ColorTone",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x0000 => "Normal",
+        ),
+      ),
+
+      "0x0001.46" => Array(
+        'tagName'     => "CanonCameraSettings.SRAWQuality",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "n/a",
+            0x01 => "sRAW1 (mRAW)",
+            0x02 => "sRAW2 (sRAW)"
+        ),
+      ),
 
       /*
@@ -243 +918 @@
       ), // <
 
+      /*
+       * The 'CanonShotInfo' tags is composed by an array of sub tags
+       *
+       * Like the CanonCameraSettings tag, this kind of data needs a particular
+       * algorythm in the CanonReader class, provided by the processSubTag0x0004
+       * function
+       *
+       * >>> Begin of CanonShotInfo subtags
+       *
+       */
+      "0x0004.1" => Array(
+        'tagName'     => "CanonShotInfo.AutoISO",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0004.2" => Array(
+        'tagName'     => "CanonShotInfo.BaseISO",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0004.3" => Array(
+        'tagName'     => "CanonShotInfo.MeasuredEV",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0004.4" => Array(
+        'tagName'     => "CanonShotInfo.TargetAperture",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0004.5" => Array(
+        'tagName'     => "CanonShotInfo.TargetExposureTime",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0004.6" => Array(
+        'tagName'     => "CanonShotInfo.ExposureCompensation",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0004.7" => Array(
+        'tagName'     => "CanonShotInfo.WhiteBalance",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Auto",
+            0x01 => "Daylight",
+            0x02 => "Cloudy",
+            0x03 => "Tungsten",
+            0x04 => "Fluorescent",
+            0x05 => "Flash",
+            0x06 => "Custom",
+            0x07 => "Black & White",
+            0x08 => "Shade",
+            0x09 => "Manual Temperature (Kelvin)",
+            0x0A => "PC Set1",
+            0x0B => "PC Set2",
+            0x0C => "PC Set3",
+            0x0E => "Daylight Fluorescent",
+            0x0F => "Custom 1",
+            0x10 => "Custom 2",
+            0x11 => "Underwater",
+            0x12 => "Custom 3",
+            0x13 => "Custom 4",
+            0x14 => "PC Set4",
+            0x15 => "PC Set5",
+        ),
+      ),
+
+      "0x0004.8" => Array(
+        'tagName'     => "CanonShotInfo.SlowShutter",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0x00 => "Off",
+            0x01 => "Night Scene",
+            0x02 => "On",
+            0x03 => "None",
+        ),
+      ),
+
+      "0x0004.9" => Array(
+        'tagName'     => "CanonShotInfo.SequenceNumber",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0004.10" => Array(
+        'tagName'     => "CanonShotInfo.OpticalZoomCode",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0004.13" => Array(
+        'tagName'     => "CanonShotInfo.FlashGuideNumber",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0004.14" => Array(
+        'tagName'     => "CanonShotInfo.AFPointsInFocus",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'tagValues'   => Array(
+            // (used by D30, D60 and some PowerShot/Ixus models)
+            0x3000 => "None (MF)",
+            0x3001 => "Right",
+            0x3002 => "Center",
+            0x3003 => "Center+Right",
+            0x3004 => "Left",
+            0x3005 => "Left+Right",
+            0x3006 => "Left+Center",
+            0x3007 => "All",
+        ),
+      ),
+
+      "0x0004.15" => Array(
+        'tagName'     => "CanonShotInfo.FlashExposureComp",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0004.16" => Array(
+        'tagName'     => "CanonShotInfo.AutoExposureBracketing",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            -1 => "On",
+            0 => "Off",
+            1 => "On (shot 1)",
+            2 => "On (shot 2)",
+            3 => "On (shot 3)",
+        ),
+      ),
+
+      "0x0004.17" => Array(
+        'tagName'     => "CanonShotInfo.AEBBracketValue",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+      ),
+
+      "0x0004.18" => Array(
+        'tagName'     => "CanonShotInfo.ControlMode",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0 => "n/a",
+            1 => "Camera Local Control",
+            3 => "Computer Remote Control",
+        ),
+      ),
+
+      "0x0004.19" => Array(
+        'tagName'     => "CanonShotInfo.FocusDistanceUpper",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0004.20" => Array(
+        'tagName'     => "CanonShotInfo.FocusDistanceLower",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0004.21" => Array(
+        'tagName'     => "CanonShotInfo.FNumber",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0004.22" => Array(
+        'tagName'     => "CanonShotInfo.ExposureTime",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0004.23" => Array(
+        'tagName'     => "CanonShotInfo.MeasuredEV2",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0004.24" => Array(
+        'tagName'     => "CanonShotInfo.BulbDuration",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0004.26" => Array(
+        'tagName'     => "CanonShotInfo.CameraType",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            248 => "EOS High-end",
+            250 => "Compact",
+            252 => "EOS Mid-range",
+            255 => "DV Camera",
+        ),
+      ),
+
+      "0x0004.27" => Array(
+        'tagName'     => "CanonShotInfo.AutoRotate",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+       0xFFFF => "Unknown",
+            0 => "None",
+            1 => "Rotate 90 CW",
+            2 => "Rotate 180",
+            3 => "Rotate 270 CW",
+        ),
+      ),
+
+      "0x0004.28" => Array(
+        'tagName'     => "CanonShotInfo.NDFilter",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'tagValues'   => Array(
+            0 => "Off",
+            1 => "On",
+       0xFFFF => "Unknown",
+        ),
+      ),
+
+      "0x0004.29" => Array(
+        'tagName'     => "CanonShotInfo.SelfTimer2",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      "0x0004.33" => Array(
+        'tagName'     => "CanonShotInfo.FlashOutput",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+      ),
+
+      /*
+       * <<< Begin of CanonShotInfo subtags
+       *
+       */
+
+
       // CanonPanorama, tag 0x0005
       0x0005 => Array(
@@ -313 +1290 @@
         'combiTag'    => 0,
         'implemented' => false,
+        'tagValues.special' => Array(
+          '40D'      => Array(3, 4, 6, 21, 24, 27, 29, 48, 67, 69, 111, 115, 214, 216, 218, 255, 307, 319, 2347),
+          '1DMarkIV' => Array(3, 4, 6, 7, 21, 25, 30, 53, 84, 86, 488, 493),
+        )
       ), // < CanonCameraInfo
+
+      /*
+       * The 'CanonCameraInfo' tags structure depends of the camera model
+       *
+       * Like the CanonCameraSettings tag, this kind of data needs a particular
+       * algorythm in the CanonReader class, provided by the processSubTag0x000d
+       * functions
+       *
+       * >>> Begin of CanonCameraInfo subtags
+       *
+       */
+
+      /*
+       * Canon EOS 40D CameraInfo tags
+       */
+      "0x000d.40D.3" => Array(
+        'tagName'     => "CanonCameraInfo.FNumber",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 3,
+        'type'        => ByteType::UBYTE,
+      ),
+
+      "0x000d.40D.4" => Array(
+        'tagName'     => "CanonCameraInfo.ExposureTime",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 4,
+        'type'        => ByteType::UBYTE,
+      ),
+
+      "0x000d.40D.6" => Array(
+        'tagName'     => "CanonCameraInfo.ISO",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 6,
+        'type'        => ByteType::UBYTE,
+      ),
+
+      "0x000d.40D.21" => Array(
+        'tagName'     => "CanonCameraInfo.FlashMeteringMode",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 21,
+        'type'        => ByteType::UBYTE,
+        'tagValues'   => Array(
+            0 => "E-TTL",
+            3 => "TTL",
+            4 => "External Auto",
+            5 => "External Manual",
+            6 => "Off",
+        )
+      ),
+
+      "0x000d.40D.24" => Array(
+        'tagName'     => "CanonCameraInfo.CameraTemperature",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 24,
+        'type'        => ByteType::UBYTE,
+      ),
+
+      "0x000d.40D.27" => Array(
+        'tagName'     => "CanonCameraInfo.MacroMagnification",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 29,
+        'type'        => ByteType::UBYTE,
+      ),
+
+      "0x000d.40D.29" => Array(
+        'tagName'     => "CanonCameraInfo.FocalLength",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 29,
+        'type'        => ByteType::USHORT,
+        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN,
+      ),
+
+      "0x000d.40D.48" => Array(
+        'tagName'     => "CanonCameraInfo.CameraOrientation",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 48,
+        'type'        => ByteType::UBYTE,
+        'tagValues'   => Array(
+            0 => "Horizontal (normal)",
+            1 => "Rotate 90 CW",
+            2 => "Rotate 270 CW",
+        )
+      ),
+
+      "0x000d.40D.67" => Array(
+        'tagName'     => "CanonCameraInfo.FocusDistanceUpper",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 67,
+        'type'        => ByteType::USHORT,
+        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN,
+      ),
+
+      "0x000d.40D.69" => Array(
+        'tagName'     => "CanonCameraInfo.FocusDistanceLower",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 69,
+        'type'        => ByteType::USHORT,
+        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN,
+      ),
+
+      "0x000d.40D.111" => Array(
+        'tagName'     => "CanonCameraInfo.WhiteBalance",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 111,
+        'type'        => ByteType::USHORT,
+      ),
+
+      "0x000d.40D.115" => Array(
+        'tagName'     => "CanonCameraInfo.ColorTemperature",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 115,
+        'type'        => ByteType::USHORT,
+      ),
+
+      "0x000d.40D.214" => Array(
+        'tagName'     => "CanonCameraInfo.LensType",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 214,
+        'type'        => ByteType::USHORT,
+        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN,
+      ),
+
+      "0x000d.40D.216" => Array(
+        'tagName'     => "CanonCameraInfo.ShortFocal",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 216,
+        'type'        => ByteType::USHORT,
+        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN,
+      ),
+
+      "0x000d.40D.218" => Array(
+        'tagName'     => "CanonCameraInfo.LongFocal",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 218,
+        'type'        => ByteType::UBYTE,
+        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN,
+      ),
+
+      "0x000d.40D.255" => Array(
+        'tagName'     => "CanonCameraInfo.FirmwareVersion",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 255,
+        'type'        => ByteType::ASCII,
+        'length'      => 6,
+      ),
+
+      "0x000d.40D.307" => Array(
+        'tagName'     => "CanonCameraInfo.FileIndex",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 307,
+        'type'        => ByteType::ULONG,
+      ),
+
+      "0x000d.40D.319" => Array(
+        'tagName'     => "CanonCameraInfo.DirectoryIndex",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 319,
+        'type'        => ByteType::ULONG,
+      ),
+
+      "0x000d.40D.2347" => Array(
+        'tagName'     => "CanonCameraInfo.LensModel",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 2347,
+        'type'        => ByteType::ASCII,
+        'length'      => 64,
+      ),
+
+
+      /*
+       * Canon EOS 40D CameraInfo tags
+       */
+      "0x000d.1DMarkIV.3" => Array(
+        'tagName'     => "CanonCameraInfo.FNumber",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 3,
+        'type'        => ByteType::UBYTE,
+      ),
+
+      "0x000d.1DMarkIV.4" => Array(
+        'tagName'     => "CanonCameraInfo.ExposureTime",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 4,
+        'type'        => ByteType::UBYTE,
+      ),
+
+      "0x000d.1DMarkIV.6" => Array(
+        'tagName'     => "CanonCameraInfo.ISO",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 6,
+        'type'        => ByteType::UBYTE,
+      ),
+
+      "0x000d.1DMarkIV.7" => Array(
+        'tagName'     => "CanonCameraInfo.HighlightTonePriority",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 7,
+        'type'        => ByteType::UBYTE,
+        'tagValues'   => Array(
+            0 => "Off",
+            1 => "On"
+        ),
+      ),
+
+      "0x000d.1DMarkIV.21" => Array(
+        'tagName'     => "CanonCameraInfo.FlashMeteringMode",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 21,
+        'type'        => ByteType::UBYTE,
+        'tagValues'   => Array(
+            0 => "E-TTL",
+            3 => "TTL",
+            4 => "External Auto",
+            5 => "External Manual",
+            6 => "Off",
+        )
+      ),
+
+      "0x000d.1DMarkIV.25" => Array(
+        'tagName'     => "CanonCameraInfo.CameraTemperature",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 25,
+        'type'        => ByteType::UBYTE,
+      ),
+
+      "0x000d.1DMarkIV.30" => Array(
+        'tagName'     => "CanonCameraInfo.FocalLength",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 30,
+        'type'        => ByteType::USHORT,
+        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN,
+      ),
+
+      "0x000d.1DMarkIV.53" => Array(
+        'tagName'     => "CanonCameraInfo.CameraOrientation",
+        'schema'      => "Canon",
+        'translatable'=> true,
+        'combiTag'    => 0,
+        'implemented' => true,
+        'pos'         => 53,
+        'type'        => ByteType::UBYTE,
+        'tagValues'   => Array(
+            0 => "Horizontal (normal)",
+            1 => "Rotate 90 CW",
+            2 => "Rotate 270 CW",
+        )
+      ),
+
+      "0x000d.1DMarkIV.84" => Array(
+        'tagName'     => "CanonCameraInfo.FocusDistanceUpper",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 84,
+        'type'        => ByteType::USHORT,
+        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN,
+      ),
+
+      "0x000d.1DMarkIV.86" => Array(
+        'tagName'     => "CanonCameraInfo.FocusDistanceLower",
+        'schema'      => "Canon",
+        'translatable'=> false,
+        'combiTag'    => 0,
+        'implemented' => false,
+        'pos'         => 86,
+        'type'        => ByteType::USHORT,
+        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN,
+      ),
+
+
+      /*
+       * <<< end of CanonCameraInfo subtags
+       *
+       */
 
       // CanonFileLength, tag 0x000e
@@ -930 +2264 @@
     }
 
-  } // NikonTags
+  } // CanonTags
 
 

extensions/AMetaData/JpegMetaData/TagDefinitions/XmpTags.class.php

@@ -1702 +1702 @@
         'schema'       => "xmlns",
       ),
+      'aux:Firmware' => Array(
+        'implemented'  => true,
+        'translatable' => false,
+        'type'         => self::TYPE_SIMPLE,
+        'schema'       => "aux",
+      ),
       'aux:Lens' => Array(
-        'implemented'  => false,
+        'implemented'  => true,
         'translatable' => false,
         'type'         => self::TYPE_SIMPLE,
         'schema'       => "aux",
       ),
+      'aux:LensID' => Array(
+        'implemented'  => false,
+        'translatable' => false,
+        'type'         => self::TYPE_SIMPLE,
+        'schema'       => "aux",
+      ),
+      'aux:LensInfo' => Array(
+        'implemented'  => false,
+        'translatable' => false,
+        'type'         => self::TYPE_SIMPLE,
+        'schema'       => "aux",
+      ),
       'aux:SerialNumber' => Array(
-        'implemented'  => false,
+        'implemented'  => true,
         'translatable' => false,
         'type'         => self::TYPE_SIMPLE,
@@ -1861 +1879 @@
         'schema'       => "Iptc4xmpCore",
       ),
+
+      /*
+       * Note Schema
+       */
+      'xmlns:xmpNote' => Array(
+        'implemented'  => false,
+        'translatable' => false,
+        'type'         => self::TYPE_SIMPLE,
+        'schema'       => "xmlns",
+      ),
+
+      'xmpNote:HasExtendedXMP' => Array(
+        'implemented'  => false,
+        'translatable' => false,
+        'type'         => self::TYPE_SIMPLE,
+        'schema'       => "xmpNote",
+      ),
+
     );