Changeset 4972


Ignore:
Timestamp:
02/27/10 00:44:30 (10 years ago)
Author:
grum
Message:

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

Location:
extensions/AMetaData/JpegMetaData
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • extensions/AMetaData/JpegMetaData/Common/ConvertData.class.php

    r4686 r4972  
    346346     * or 
    347347     * Convert multiples null terminated string into an array of string 
     348     *    ==> if strings are null (eq. "\x00") nothing is added to the array 
    348349     * 
    349350     * Example: 
     
    365366        return(""); 
    366367      } 
    367       elseif($occurs==1) 
    368       { 
    369         return($result[1][0]); 
    370       } 
    371       else 
    372       { 
    373         return($result[1]); 
     368      else 
     369      { 
     370        $returned=Array(); 
     371        foreach($result[1] as $pop) 
     372        { 
     373          if($pop!="") 
     374          { 
     375            $returned[]=$pop; 
     376          } 
     377        } 
     378        if(count($returned)==1) 
     379        { 
     380          return($returned[0]); 
     381        } 
     382        elseif(count($returned)==0) 
     383        { 
     384          return(""); 
     385        } 
     386        else 
     387        { 
     388          return($returned); 
     389        } 
    374390      } 
    375391    } 
  • extensions/AMetaData/JpegMetaData/Readers/AppMarkerSegmentReader.class.php

    r4904 r4972  
    860860          $this->dataLoaded=true; 
    861861          break; 
    862         case self::APP1_EXTENDED: 
    863           $this->data = $this->workData->readASCII(); 
     862        case self::APP1_EXTENDEDXMP: 
     863          /* When Xmp data size exceed 65458 bytes, the Xmp tree is splited. 
     864           * Each chunk is written into the JPEG file within a separate APP1 
     865           * marker segment. 
     866           * 
     867           * Each ExtendedXMP marker segment contains: 
     868           *  - A null-terminated signature string of "http://ns.adobe.com/xmp/extension/". 
     869           *  - A 128-bit GUID stored as a 32-byte ASCII hex string, capital A-F, 
     870           *    no null termination. The GUID is a 128-bit MD5 digest of the 
     871           *    full ExtendedXMP serialization 
     872           *  - The full length of the ExtendedXMP serialization as a 32-bit 
     873           *    unsigned integer 
     874           *  - The offset of this portion as a 32-bit unsigned integer. 
     875           *  - The portion of the ExtendedXMP 
     876           * 
     877           * Each chunck is returned as an array : 
     878           *  - 'uid'    => the 128-bit GUID 
     879           *  - 'offset' => the offset 
     880           *  - 'data'   => xmp data packet 
     881           * 
     882           * Xmp Tree is rebuilded after all extendedXmp chunks are loaded, by 
     883           * the class calling the AppMarkerSegmentReader class (the JpegReader 
     884           * class) 
     885           */ 
     886 
     887          $this->workData->setByteOrder(BYTE_ORDER_BIG_ENDIAN); 
     888          $this->data=Array( 
     889            'uid'    => $this->workData->readASCII(32, 35), 
     890            'offset' => $this->workData->readULong(71), 
     891            'data'   => $this->workData->readASCII(-1, 75) 
     892          ); 
     893 
    864894          $this->dataLoaded=true; 
    865895          break; 
  • extensions/AMetaData/JpegMetaData/Readers/CanonReader.class.php

    r4935 r4972  
    127127          $returned=$values; 
    128128          break; 
     129        case 0x0004: // "CanonShotInfo" 
     130          $this->processSubTag0x0004($values); 
     131          $returned=$values; 
     132          break; 
    129133        case 0x0006: // "CanonImageType" 
    130134        case 0x0007: // "CanonFirmwareVersion" 
     
    135139           * null terminated strings 
    136140           */ 
    137           $tmp=ConvertData::toStrings($values); 
    138           if(is_array($tmp)) 
    139           { 
    140             $returned=$tmp[0]; 
    141           } 
    142           else 
    143           { 
    144             $returned=$tmp; 
    145           } 
     141          $returned=ConvertData::toStrings($values); 
    146142          break; 
    147143        case 0x000c: // "SerialNumber" 
    148144          $returned=$values; 
     145          break; 
     146        case 0x000d: // "CanonCameraInfo" 
     147          $returned=$this->processSubTag0x000d($values); 
    149148          break; 
    150149        case 0x0010: // "CanonModelID" 
     
    167166    /** 
    168167     * this function process the subtag of the 0x0001 "CanonCameraSettings" tag 
    169      */ 
    170     protected function processSubTag0x0001($values) 
     168     * 
     169     * @param Boolean $add : if set to false, the function return the tag value 
     170     *                       otherwise the function adds the tag 
     171     */ 
     172    protected function processSubTag0x0001($values, $add=true) 
    171173    { 
    172174      foreach($values as $key => $val) 
    173175      { 
    174         $tagDef=$this->tagDef->getTagById("0001.$key"); 
     176        $tagDef=$this->tagDef->getTagById("0x0001.$key"); 
    175177 
    176178        if(is_array($tagDef)) 
    177179        { 
    178180          // make a fake IFDEntry 
    179           $entry=new IfdEntryReader("\x01\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF".chr($key), $this->byteOrder, "", 0, null); 
    180  
    181           $entry->getTag()->setId("0001.$key"); 
     181          $entry=new IfdEntryReader("\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\x01\x00".chr($key), $this->byteOrder, "", 0, null); 
     182 
     183          $entry->getTag()->setId("0x0001.$key"); 
    182184          $entry->getTag()->setName($tagDef['tagName']); 
    183185          $entry->getTag()->setValue($val); 
     
    190192            if(array_key_exists($val, $tagDef['tagValues'])) 
    191193            { 
    192               $entry->getTag()->setLabel($tagDef['tagValues'][$val]); 
     194              $returned=$tagDef['tagValues'][$val]; 
    193195            } 
    194196            else 
    195197            { 
    196               $entry->getTag()->setLabel("unknown (".$val.")"); 
     198              $returned="unknown (".$val.")"; 
    197199            } 
    198200          } 
     
    201203            switch($key) 
    202204            { 
     205              case 2: // SelfTimer 
     206                if($val==0) 
     207                { 
     208                  $returned=Array("Off"); 
     209                } 
     210                else 
     211                { 
     212                  $returned=Array((($val & 0xfff) / 10).' s'); 
     213                  if($val & 0x4000) 
     214                    $returned[]="Custom"; 
     215                } 
     216                break; 
     217              case 22: // LensType 
     218                /* in most case, with one Id we have one lens 
     219                 * in some case, with one Id we can have more than one lens 
     220                 * in this case, we made a $focal var like : 
     221                 *             "90 mm" 
     222                 *             "28-300mm" 
     223                 * and try to find a lens with this properties 
     224                 */ 
     225                if(array_key_exists($val, $tagDef['tagValues.special'])) 
     226                { 
     227                  $lens=$tagDef['tagValues.special'][$val]; 
     228 
     229                  if(is_array($lens)) 
     230                  { 
     231                    $focalUnit=(array_key_exists(25, $values))?$values[25]:1; 
     232                    $FocalShort=(array_key_exists(24, $values))?$values[24]/$focalUnit:0; 
     233                    $FocalLong=(array_key_exists(23, $values))?$values[23]/$focalUnit:0; 
     234                    $focal=(($FocalShort==$FocalLong or $FocalLong==0)?$FocalShort:$FocalShort."-".$FocalLong)."mm"; 
     235 
     236                    foreach($lens as $name) 
     237                    { 
     238                      if(preg_match("/.*".$focal.".*/i", $name)) 
     239                        $returned=$name; 
     240                    } 
     241                  } 
     242                  else 
     243                  { 
     244                    $returned=$lens; 
     245                  } 
     246                } 
     247                else 
     248                { 
     249                  $returned=$tagDef['tagValues.special'][0xffff]; 
     250                } 
     251 
     252                break; 
     253              case 23: // LongFocal 
     254              case 24: // ShortFocal 
     255                /* note : the values seems to be divided by the FocalUnit 
     256                 * (subTag #25) 
     257                 */ 
     258                if(array_key_exists(25, $values)) 
     259                { 
     260                  $focalUnit=$values[25]; 
     261                } 
     262                else 
     263                { 
     264                  $focalUnit=1; 
     265                } 
     266 
     267                $returned=ConvertData::toFocalLength($val/$focalUnit); 
     268                break; 
     269              case 25: // FocalUnit 
     270                $returned=$val."/mm"; 
     271                break; 
     272              case 26: // MaxAperture 
     273              case 27: // MinAperture 
     274                $returned=ConvertData::toFNumber(round(exp($this->canonEv($val)*log(2)/2),1)); 
     275                break; 
     276              case 29: // FlashBits 
     277                $returned=Array(); 
     278                foreach($tagDef['tagValues.special'] as $key => $name) 
     279                { 
     280                  if(($key & $val) == $key) 
     281                  { 
     282                    $returned[]=$name; 
     283                  } 
     284                } 
     285                break; 
    203286              default: 
    204                 $entry->getTag()->setLabel("not yet implemented"); 
    205                 break; 
    206             } 
    207           } 
    208  
    209           $this->entries[]=$entry; 
     287                $returned="not yet implemented"; 
     288                break; 
     289            } 
     290          } 
     291 
     292          if($add) 
     293          { 
     294            $entry->getTag()->setLabel($returned); 
     295            $this->entries[]=$entry; 
     296          } 
     297          else 
     298          { 
     299            // only return the value for the asked tag 
     300            unset($entry); 
     301            unset($tagDef); 
     302            return($returned); 
     303          } 
    210304 
    211305          unset($entry); 
     
    214308      } 
    215309    } 
     310 
     311    /** 
     312     * this function process the subtag of the 0x0004 "CanonShotInfo" tag 
     313     * 
     314     * @param Boolean $add : if set to false, the function return the tag value 
     315     *                       otherwise the function adds the tag 
     316     */ 
     317    protected function processSubTag0x0004($values, $add=true) 
     318    { 
     319      foreach($values as $key => $val) 
     320      { 
     321        $tagDef=$this->tagDef->getTagById("0x0004.$key"); 
     322 
     323        if(is_array($tagDef)) 
     324        { 
     325          // make a fake IFDEntry 
     326          $entry=new IfdEntryReader("\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\x04\x00".chr($key), $this->byteOrder, "", 0, null); 
     327 
     328          $entry->getTag()->setId("0x0004.$key"); 
     329          $entry->getTag()->setName($tagDef['tagName']); 
     330          $entry->getTag()->setValue($val); 
     331          $entry->getTag()->setKnown(true); 
     332          $entry->getTag()->setImplemented($tagDef['implemented']); 
     333          $entry->getTag()->setTranslatable($tagDef['translatable']); 
     334 
     335          if(array_key_exists('tagValues', $tagDef)) 
     336          { 
     337            if(array_key_exists($val, $tagDef['tagValues'])) 
     338            { 
     339              $returned=$tagDef['tagValues'][$val]; 
     340            } 
     341            else 
     342            { 
     343              $returned="unknown (".$val.")"; 
     344            } 
     345          } 
     346          else 
     347          { 
     348            switch($key) 
     349            { 
     350              case 1: // AutoISO 
     351                $returned=round(exp($val/32*log(2))*100,0); 
     352                break; 
     353              case 2: // BaseISO 
     354                $returned=exp($this->canonEv($val) * log(2)) * 100 / 32; 
     355                break; 
     356              case 4: // TargetAperture 
     357              case 21: // FNumber 
     358                $returned=ConvertData::toFNumber(round(exp($this->canonEv($val)*log(2)/2), 1)); 
     359                break; 
     360              case 5: // TargetExposureTime 
     361                $returned=ConvertData::toExposureTime(exp(-$this->CanonEv($val)*log(2))); 
     362                break; 
     363              case 6: // ExposureCompensation 
     364              case 15: // FlashExposureComp 
     365              case 17: // AEBBracketValue 
     366                $returned=ConvertData::$this->CanonEv($val); 
     367                break; 
     368              case 9: // SlowShutter 
     369                $returned=$val; 
     370                break; 
     371              case 13: // FlashGuideNumber 
     372                $returned=$val/32; 
     373                break; 
     374              case 23: // MeasuredEV2 
     375                $returned=$val/8-6; 
     376                break; 
     377              case 24: // BulbDuration 
     378              case 29: // SelfTimer2 
     379                $returned=$val/10; 
     380                break; 
     381              default: 
     382                $returned="not yet implemented"; 
     383                break; 
     384            } 
     385          } 
     386 
     387          if($add) 
     388          { 
     389            $entry->getTag()->setLabel($returned); 
     390            $this->entries[]=$entry; 
     391          } 
     392          else 
     393          { 
     394            // only return the value for the asked tag 
     395            unset($entry); 
     396            unset($tagDef); 
     397            return($returned); 
     398          } 
     399 
     400          unset($entry); 
     401        } 
     402        unset($tagDef); 
     403      } 
     404    } 
     405 
     406    /** 
     407     * this function process the subtag of the 0x000d "CanonCameraInfo" tag 
     408     * 
     409     * @param Boolean $add : if set to false, the function return the tag value 
     410     *                       otherwise the function adds the tag 
     411     */ 
     412    protected function processSubTag0x000d($values, $add=true) 
     413    { 
     414      $name=MakerNotesSignatures::getExifMaker(); 
     415 
     416      if(preg_match("/\b1DS?$/", $name)) 
     417      { 
     418 
     419      }/* 
     420      elseif(preg_match("/\b1Ds? Mark II$/", $name)) 
     421      { 
     422 
     423      } 
     424      elseif(preg_match("/\b1Ds? Mark II N$/", $name)) 
     425      { 
     426 
     427      } 
     428      elseif(preg_match("/\b1Ds? Mark III$/", $name)) 
     429      { 
     430 
     431      } 
     432      elseif(preg_match("/EOS 5D$/", $name)) 
     433      { 
     434 
     435      } 
     436      elseif(preg_match("/EOS 5D Mark II$/", $name)) 
     437      { 
     438 
     439      } 
     440      elseif(preg_match("/EOS 7D$/", $name)) 
     441      { 
     442 
     443      }*/ 
     444      elseif(preg_match("/.*\b1D Mark IV/i", $name)) 
     445      { 
     446        $returned=$this->processSubTag0x000d_1DMarkIV($values, $add); 
     447      } 
     448      elseif(preg_match("/.*EOS 40D/i", $name)) 
     449      { 
     450        $returned=$this->processSubTag0x000d_40D($values, $add); 
     451      }/* 
     452      elseif(preg_match("/EOS 50D$/", $name)) 
     453      { 
     454 
     455      } 
     456      elseif(preg_match("/\b(450D|REBEL XSi|Kiss X2)\b/", $name)) 
     457      { 
     458 
     459      } 
     460      elseif(preg_match("/\b(500D|REBEL T1i|Kiss X3)\b/", $name)) 
     461      { 
     462 
     463      } 
     464      elseif(preg_match("/\b(1000D|REBEL XS|Kiss F)\b/", $name)) 
     465      { 
     466 
     467      } 
     468      elseif(preg_match("/\b1DS?/", $name)) 
     469      { 
     470 
     471      }*/ 
     472      else 
     473      { 
     474        /* 
     475         * note : powershot are not implemented, in exiftool condition to 
     476         * determine the model are not very understandable 
     477         */ 
     478        $returned="$name is not yet implemented => ".ConvertData::toHexDump($values, ByteType::ASCII); 
     479      } 
     480      return($returned); 
     481    } 
     482 
     483    /** 
     484     * this function process the subtag of the 0x000d "CanonCameraInfo" tag 
     485     * for the EOS 40D camera 
     486     */ 
     487    protected function processSubTag0x000d_40D($values) 
     488    { 
     489      $tagDef=$this->tagDef->getTagById(0x000d); 
     490      $list=$tagDef['tagValues.special']['40D']; 
     491      $data=new Data($values); 
     492 
     493      foreach($list as $tagIndex) 
     494      { 
     495        $subTagDef=$this->tagDef->getTagById("0x000d.40D.$tagIndex"); 
     496 
     497        if(is_array($subTagDef)) 
     498        { 
     499          $val=$this->readDataFromSubTag($data, $subTagDef); 
     500 
     501          // make a fake IFDEntry 
     502          $entry=new IfdEntryReader("\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\x0d\x00\x00", $this->byteOrder, "", 0, null); 
     503 
     504          $entry->getTag()->setId("0x000d.40D.$tagIndex"); 
     505          $entry->getTag()->setName($subTagDef['tagName']); 
     506          $entry->getTag()->setValue($val); 
     507          $entry->getTag()->setKnown(true); 
     508          $entry->getTag()->setImplemented($subTagDef['implemented']); 
     509          $entry->getTag()->setTranslatable($subTagDef['translatable']); 
     510 
     511          if(array_key_exists('tagValues', $subTagDef)) 
     512          { 
     513            if(array_key_exists($val, $subTagDef['tagValues'])) 
     514            { 
     515              $returned=$subTagDef['tagValues'][$val]; 
     516            } 
     517            else 
     518            { 
     519              $returned="unknown (".$val.")"; 
     520            } 
     521          } 
     522          else 
     523          { 
     524            switch($tagIndex) 
     525            { 
     526              case 24: // CameraTemperature 
     527                $returned=($val-128)."°C"; 
     528                break; 
     529              case 29: // FocalLength 
     530                $returned=ConvertData::toFocalLength($val); 
     531                break; 
     532              case 111: // WhiteBalance 
     533                // same method than the ShotInfo.WhiteBalance tag 
     534                $returned=$this->processSubTag0x0004(Array(7 => $val), false); 
     535                break; 
     536              case 214: // LensType 
     537                // same method than the CanonCameraSettings.LensType tag 
     538                $FocalShort=$this->readDataFromSubTag($data, $this->tagDef->getTagById("0x000d.40D.216")); 
     539                $FocalLong=$this->readDataFromSubTag($data, $this->tagDef->getTagById("0x000d.40D.218")); 
     540 
     541                $returned=$this->processSubTag0x0001(Array(22 => $val, 23 => $FocalLong, 24 => $FocalShort), false); 
     542                break; 
     543              case 216: // ShortFocal 
     544              case 218: // LongFocal 
     545                $returned=ConvertData::toFocalLength($val); 
     546                break; 
     547              case 255: // FirmwareVersion 
     548              case 2347: // LensModel 
     549                $returned=ConvertData::toStrings($val); 
     550                break; 
     551              default: 
     552                $returned="not yet implemented ($tagIndex)"; 
     553                break; 
     554            } 
     555          } 
     556 
     557          $entry->getTag()->setLabel($returned); 
     558          $this->entries[]=$entry; 
     559 
     560          unset($entry); 
     561        } 
     562        unset($subTagDef); 
     563      } 
     564      unset($tagDef); 
     565      unset($list); 
     566      unset($data); 
     567 
     568      return("[EOS 40D]"); 
     569    } 
     570 
     571    /** 
     572     * this function process the subtag of the 0x000d "CanonCameraInfo" tag 
     573     * for the EOS 1D Mark IV camera 
     574     * 
     575     */ 
     576    protected function processSubTag0x000d_1DMarkIV($values) 
     577    { 
     578      $tagDef=$this->tagDef->getTagById(0x000d); 
     579      $list=$tagDef['tagValues.special']['1DMarkIV']; 
     580      $data=new Data($values); 
     581 
     582      foreach($list as $tagIndex) 
     583      { 
     584        $subTagDef=$this->tagDef->getTagById("0x000d.1DMarkIV.$tagIndex"); 
     585 
     586        if(is_array($subTagDef)) 
     587        { 
     588          $val=$this->readDataFromSubTag($data, $subTagDef); 
     589 
     590          // make a fake IFDEntry 
     591          $entry=new IfdEntryReader("\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\x0d\x00\x00", $this->byteOrder, "", 0, null); 
     592 
     593          $entry->getTag()->setId("0x000d.1DMarkIV.$tagIndex"); 
     594          $entry->getTag()->setName($subTagDef['tagName']); 
     595          $entry->getTag()->setValue($val); 
     596          $entry->getTag()->setKnown(true); 
     597          $entry->getTag()->setImplemented($subTagDef['implemented']); 
     598          $entry->getTag()->setTranslatable($subTagDef['translatable']); 
     599 
     600          if(array_key_exists('tagValues', $subTagDef)) 
     601          { 
     602            if(array_key_exists($val, $subTagDef['tagValues'])) 
     603            { 
     604              $returned=$subTagDef['tagValues'][$val]; 
     605            } 
     606            else 
     607            { 
     608              $returned="unknown (".$val.")"; 
     609            } 
     610          } 
     611          else 
     612          { 
     613            switch($tagIndex) 
     614            { 
     615              case 25: // CameraTemperature 
     616                $returned=($val-128)."°C"; 
     617                break; 
     618              case 30: // FocalLength 
     619                $returned=ConvertData::toFocalLength($val); 
     620                break; 
     621              default: 
     622                $returned="not yet implemented ($tagIndex)"; 
     623                break; 
     624            } 
     625          } 
     626 
     627          $entry->getTag()->setLabel($returned); 
     628          $this->entries[]=$entry; 
     629 
     630          unset($entry); 
     631        } 
     632        unset($subTagDef); 
     633      } 
     634      unset($tagDef); 
     635      unset($list); 
     636      unset($data); 
     637 
     638      return("[EOS 1D Mark IV]"); 
     639    } 
     640 
     641 
     642 
     643    /** 
     644     * read datas from a $data object, according to the tag definition 
     645     * 
     646     * @param Data $data : a Data object 
     647     * @param Array $tagDef : the tag definition 
     648     */ 
     649    protected function readDataFromSubTag($data, $tagDef) 
     650    { 
     651      if(!array_key_exists('pos', $tagDef)) 
     652        return("Invalid tagDef (no 'pos')"); 
     653 
     654      $pos=$tagDef['pos']; 
     655 
     656      if(array_key_exists('byteOrder', $tagDef)) 
     657      { 
     658        $data->setByteOrder($tagDef['byteOrder']); 
     659      } 
     660      else 
     661      { 
     662        $data->setByteOrder(BYTE_ORDER_LITTLE_ENDIAN); 
     663      } 
     664 
     665      $returned=""; 
     666      switch($tagDef['type']) 
     667      { 
     668        case ByteType::UNDEFINED: 
     669        case ByteType::UNKNOWN : 
     670        case ByteType::ASCII: 
     671          $nbCar=(array_key_exists('length', $tagDef))?$tagDef['length']:1; 
     672          $returned=$data->readASCII($nbCar, $pos); 
     673          break; 
     674        case ByteType::UBYTE: 
     675          $returned=$data->readUByte($pos); 
     676          break; 
     677        case ByteType::USHORT: 
     678          $returned=$data->readUShort($pos); 
     679          break; 
     680        case ByteType::ULONG: 
     681          $returned=$data->readULong($pos); 
     682          break; 
     683        case ByteType::URATIONAL: 
     684          $returned=$data->readURational($pos); 
     685          break; 
     686        case ByteType::SBYTE: 
     687          $returned=$data->readSByte($pos); 
     688          break; 
     689        case ByteType::SSHORT: 
     690          $returned=$data->readSShort($pos); 
     691          break; 
     692        case ByteType::SLONG: 
     693          $returned=$data->readSLong($pos); 
     694          break; 
     695        case ByteType::SRATIONAL: 
     696          $returned=$data->readSRational($pos); 
     697          break; 
     698        case ByteType::FLOAT: 
     699          $returned=""; 
     700          break; 
     701        case ByteType::DOUBLE: 
     702          $returned=""; 
     703          break; 
     704      } 
     705      return($returned); 
     706    } 
     707 
     708 
     709    /** 
     710     * Convert Canon hex-based EV (modulo 0x20) to real number 
     711     *     0x00 -> 0 
     712     *     0x0c -> 0.33333 
     713     *     0x10 -> 0.5 
     714     *     0x14 -> 0.66666 
     715     *     0x20 -> 1   ...  etc 
     716     * 
     717     * function from exiftool 
     718     * 
     719     * @param Integer $value : the canon EV value 
     720     * @return Float : the converted value 
     721     */ 
     722    protected function canonEv($val) 
     723    { 
     724      //$val=95; 
     725 
     726      if($val<0) 
     727      { 
     728        $val=-$val; 
     729        $sign=-1; 
     730      } 
     731      else 
     732      { 
     733        $sign=1; 
     734      } 
     735      $frac = (float) ($val & 0x1f); //$frac = $val % 0x20; 
     736      $val -= $frac;  // remove fraction 
     737      // Convert 1/3 and 2/3 codes 
     738      if ($frac == 0x0c) 
     739      { 
     740        $frac = 0x20 / 3; 
     741      } 
     742      elseif($frac==0x14) 
     743      { 
     744        $frac = 0x40 / 3; 
     745      } 
     746      return($sign * ($val + $frac) / 0x20); 
     747    } 
    216748  } 
    217749 
  • extensions/AMetaData/JpegMetaData/Readers/JpegReader.class.php

    r4904 r4972  
    152152          { 
    153153            $this->readAppMarkerSegments(); 
     154            $this->processSpecialAppMarkerSegments(); 
    154155            $this->isLoaded=true; 
    155156          } 
     
    225226    /** 
    226227     * 
     228     * This function process special APP marker segment 
     229     * 
     230     * At now, only the extendedXmp segment are managed 
     231     * 
     232     */ 
     233    protected function processSpecialAppMarkerSegments() 
     234    { 
     235      /* 
     236       * process APP extendedXmp segment 
     237       * 
     238       * 1/ read all APP segment and find APP1/EXTENDEDXMP segments 
     239       * 2/ sort APP1/EXTENDEDXMP segments by UID+OFFSET 
     240       * 3/ merge segment data 
     241       * 4/ build a new AppMarkerSegmentReader (as an APP1_XMP segement) 
     242       */ 
     243      $extendedXmp=Array(); 
     244      foreach($this->appMarkerSegmentReader as $marker) 
     245      { 
     246        if($marker->getHeader()==AppMarkerSegmentReader::SEGMENT_APP1 and 
     247           $marker->getSubType()==AppMarkerSegmentReader::APP1_EXTENDEDXMP) 
     248        { 
     249          $extendedXmp[]=$marker->getData(); 
     250        } 
     251      } 
     252      usort($extendedXmp, Array(&$this, "sortExtendedXmp")); 
     253 
     254      $xmp=""; 
     255      foreach($extendedXmp as $marker) 
     256      { 
     257        $xmp.=$marker['data']; 
     258      } 
     259 
     260      $marker=new AppMarkerSegmentReader( 
     261        AppMarkerSegmentReader::SEGMENT_APP1, 
     262        0, 
     263        strlen($xmp), 
     264        AppMarkerSegmentReader::APP1_XMP, 
     265        "http://ns.adobe.com/xap/1.0/\x00".$xmp 
     266      ); 
     267 
     268      if($marker) 
     269      { 
     270        /* 
     271         * if there is a marker returned, push it on the markers array 
     272         */ 
     273        $this->appMarkerSegmentReader[]=$marker; 
     274        unset($marker); 
     275      } 
     276      unset($extendedXmp); 
     277      unset($xmp); 
     278    } 
     279 
     280    /** 
     281     * This function is used to sort the extendedXmp segments 
     282     */ 
     283    protected function sortExtendedXmp($a, $b) 
     284    { 
     285      if (($a['uid'].$a['offset']) == ($b['uid'].$b['offset'])) 
     286      { 
     287        return(0); 
     288      } 
     289      return((($a['uid'].$a['offset']) < ($b['uid'].$b['offset'])) ? -1 : 1); 
     290    } 
     291 
     292 
     293    /** 
     294     * 
    227295     * returns the filename given to the object 
    228296     * 
  • extensions/AMetaData/JpegMetaData/Readers/XmpReader.class.php

    r4931 r4972  
    360360      { 
    361361        case "x:xmptk": 
     362        case "aux:Lens": 
     363        case "aux:Firmware": 
     364        case "aux:SerialNumber": 
    362365        case "dc:coverage": 
    363366        case "dc:format": 
  • extensions/AMetaData/JpegMetaData/TagDefinitions/CanonTags.class.php

    r4935 r4972  
    5454 
    5555  /** 
    56    * Define the tags for Nikon camera 
     56   * Define the tags for Canon camera 
    5757   */ 
    5858  class CanonTags extends KnownTags 
     
    7474 
    7575      /* 
    76        * The 'CanonCameraSettings' tags is composed of 46 sub tags 
     76       * The 'CanonCameraSettings' tags is composed by an array of sub tags 
    7777       * Each subtag name is defined bu the class by the concatenation of 
    78        * "CanonCameraSettings" and the subtag nam 
     78       * "CanonCameraSettings" and the subtag name 
    7979       * 
    8080       * Giving something like : 
     
    8282       * 
    8383       * This kind of data needs a particular algorythm in the CanonReader class 
     84       * provided by the processSubTag0x0001 function 
     85       * 
     86       * Keys are defined by a string build with : 
     87       *  - the tag number in hexa "0x0001" 
     88       *  - a dot "." 
     89       *  - sub tag number in decimal "10" 
     90       *  ==> "0x0001.10" => "CanonCameraSettings.CanonImageSize" 
    8491       * 
    8592       * >>> Begin of CanonCameraSettings subtags 
    8693       * 
    8794       */ 
    88       "0001.1" => Array( 
     95      "0x0001.1" => Array( 
    8996        'tagName'     => "CanonCameraSettings.MacroMode", 
    9097        'schema'      => "Canon", 
     
    98105      ), 
    99106 
    100       "0001.2" => Array( 
     107      "0x0001.2" => Array( 
    101108        'tagName'     => "CanonCameraSettings.SelfTimer", 
    102109        'schema'      => "Canon", 
    103         'translatable'=> false, 
    104         'combiTag'    => 0, 
    105         'implemented' => false, 
    106       ), 
    107  
    108       "0001.3" => Array( 
     110        'translatable'=> true, 
     111        'combiTag'    => 0, 
     112        'implemented' => true, 
     113      ), 
     114 
     115      "0x0001.3" => Array( 
    109116        'tagName'     => "CanonCameraSettings.Quality", 
    110117        'schema'      => "Canon", 
     
    122129      ), 
    123130 
    124       "0001.4" => Array( 
     131      "0x0001.4" => Array( 
    125132        'tagName'     => "CanonCameraSettings.CanonFlashMode", 
    126133        'schema'      => "Canon", 
     
    140147      ), 
    141148 
    142       "0001.5" => Array( 
     149      "0x0001.5" => Array( 
    143150        'tagName'     => "CanonCameraSettings.ContinuousDrive", 
    144151        'schema'      => "Canon", 
     
    156163      ), 
    157164 
    158       "0001.7" => Array( 
     165      "0x0001.7" => Array( 
    159166        'tagName'     => "CanonCameraSettings.FocusMode", 
    160167        'schema'      => "Canon", 
     
    174181      ), 
    175182 
    176       "0001.9" => Array( 
     183      "0x0001.9" => Array( 
    177184        'tagName'     => "CanonCameraSettings.RecordMode", 
    178185        'schema'      => "Canon", 
     
    191198      ), 
    192199 
    193       "0001.10" => Array( 
     200      "0x0001.10" => Array( 
    194201        'tagName'     => "CanonCameraSettings.CanonImageSize", 
    195202        'schema'      => "Canon", 
     
    211218      ), 
    212219 
     220      "0x0001.11" => Array( 
     221        'tagName'     => "CanonCameraSettings.EasyMode", 
     222        'schema'      => "Canon", 
     223        'translatable'=> true, 
     224        'combiTag'    => 0, 
     225        'implemented' => true, 
     226        'tagValues'   => Array( 
     227            0x00 => "Full auto", 
     228            0x01 => "Manual", 
     229            0x02 => "Landscape", 
     230            0x03 => "Fast shutter", 
     231            0x04 => "Slow shutter", 
     232            0x05 => "Night", 
     233            0x06 => "Gray Scale", 
     234            0x07 => "Sepia", 
     235            0x08 => "Portrait", 
     236            0x09 => "Sports", 
     237            0x0a => "Macro", 
     238            0x0b => "Black & White", 
     239            0x0c => "Pan focus", 
     240            0x0d => "Vivid", 
     241            0x0e => "Neutral", 
     242            0x0f => "Flash Off", 
     243            0x10 => "Long Shutter", 
     244            0x11 => "Super Macro", 
     245            0x12 => "Foliage", 
     246            0x13 => "Indoor", 
     247            0x14 => "Fireworks", 
     248            0x15 => "Beach", 
     249            0x16 => "Underwater", 
     250            0x17 => "Snow", 
     251            0x18 => "Kids & Pets", 
     252            0x19 => "Night Snapshot", 
     253            0x1a => "Digital Macro", 
     254            0x1b => "My Colors", 
     255            0x1c => "Still Image", 
     256            0x1d => "Color Accent", 
     257            0x1e => "Color Swap", 
     258            0x20 => "Aquarium", 
     259            0x21 => "ISO 3200", 
     260            0x26 => "Creative Auto", 
     261            0x105 => "Sunset", 
     262          ), 
     263      ), 
     264 
     265      "0x0001.12" => Array( 
     266        'tagName'     => "CanonCameraSettings.DigitalZoom", 
     267        'schema'      => "Canon", 
     268        'translatable'=> true, 
     269        'combiTag'    => 0, 
     270        'implemented' => true, 
     271        'tagValues'   => Array( 
     272            0 => "None", 
     273            1 => "2x", 
     274            2 => "4x", 
     275            3 => "Other", 
     276          ), 
     277      ), 
     278 
     279      "0x0001.13" => Array( 
     280        'tagName'     => "CanonCameraSettings.Contrast", 
     281        'schema'      => "Canon", 
     282        'translatable'=> false, 
     283        'combiTag'    => 0, 
     284        'implemented' => false, 
     285      ), 
     286 
     287      "0x0001.14" => Array( 
     288        'tagName'     => "CanonCameraSettings.Saturation", 
     289        'schema'      => "Canon", 
     290        'translatable'=> false, 
     291        'combiTag'    => 0, 
     292        'implemented' => false, 
     293      ), 
     294 
     295      "0x0001.15" => Array( 
     296        'tagName'     => "CanonCameraSettings.Sharpness", 
     297        'schema'      => "Canon", 
     298        'translatable'=> false, 
     299        'combiTag'    => 0, 
     300        'implemented' => false, 
     301      ), 
     302 
     303      "0x0001.16" => Array( 
     304        'tagName'     => "CanonCameraSettings.CameraISO", 
     305        'schema'      => "Canon", 
     306        'translatable'=> false, 
     307        'combiTag'    => 0, 
     308        'implemented' => false, 
     309      ), 
     310 
     311      "0x0001.17" => Array( 
     312        'tagName'     => "CanonCameraSettings.MeteringMode", 
     313        'schema'      => "Canon", 
     314        'translatable'=> true, 
     315        'combiTag'    => 0, 
     316        'implemented' => true, 
     317        'tagValues'   => Array( 
     318            0x00 => "Default", 
     319            0x01 => "Spot", 
     320            0x02 => "Average", 
     321            0x03 => "Evaluative", 
     322            0x04 => "Partial", 
     323            0x05 => "Center-weighted average", 
     324        ), 
     325      ), 
     326 
     327      "0x0001.18" => Array( 
     328        'tagName'     => "CanonCameraSettings.FocusRange", 
     329        'schema'      => "Canon", 
     330        'translatable'=> true, 
     331        'combiTag'    => 0, 
     332        'implemented' => true, 
     333        'tagValues'   => Array( 
     334            0x00 => "Manual", 
     335            0x01 => "Auto", 
     336            0x02 => "Not Known", 
     337            0x03 => "Macro", 
     338            0x04 => "Very Close", 
     339            0x05 => "Close", 
     340            0x06 => "Middle Range", 
     341            0x07 => "Far Range", 
     342            0x08 => "Pan Focus", 
     343            0x09 => "Super Macro", 
     344            0x0a => "Infinity" 
     345        ), 
     346      ), 
     347 
     348      "0x0001.18" => Array( 
     349        'tagName'     => "CanonCameraSettings.FocusRange", 
     350        'schema'      => "Canon", 
     351        'translatable'=> true, 
     352        'combiTag'    => 0, 
     353        'implemented' => true, 
     354        'tagValues'   => Array( 
     355            0x00 => "Manual", 
     356            0x01 => "Auto", 
     357            0x02 => "Not Known", 
     358            0x03 => "Macro", 
     359            0x04 => "Very Close", 
     360            0x05 => "Close", 
     361            0x06 => "Middle Range", 
     362            0x07 => "Far Range", 
     363            0x08 => "Pan Focus", 
     364            0x09 => "Super Macro", 
     365            0x0a => "Infinity" 
     366        ), 
     367      ), 
     368 
     369      "0x0001.19" => Array( 
     370        'tagName'     => "CanonCameraSettings.AFPoint", 
     371        'schema'      => "Canon", 
     372        'translatable'=> true, 
     373        'combiTag'    => 0, 
     374        'implemented' => true, 
     375        'tagValues'   => Array( 
     376            0x2005 => "Manual AF point selection", 
     377            0x3000 => "None (MF)", 
     378            0x3001 => "Auto AF point selection", 
     379            0x3002 => "Right", 
     380            0x3003 => "Center", 
     381            0x3004 => "Left", 
     382            0x4001 => "Auto AF point selection", 
     383            0x4006 => "Face Detect" 
     384        ), 
     385      ), 
     386 
     387      "0x0001.20" => Array( 
     388        'tagName'     => "CanonCameraSettings.CanonExposureMode", 
     389        'schema'      => "Canon", 
     390        'translatable'=> true, 
     391        'combiTag'    => 0, 
     392        'implemented' => true, 
     393        'tagValues'   => Array( 
     394            0 => "Easy", 
     395            1 => "Program AE", 
     396            2 => "Shutter speed priority AE", 
     397            3 => "Aperture-priority AE", 
     398            4 => "Manual", 
     399            5 => "Depth-of-field AE", 
     400            6 => "M-Dep", 
     401            7 => "Bulb" 
     402        ), 
     403      ), 
     404 
     405      "0x0001.22" => Array( 
     406        'tagName'     => "CanonCameraSettings.LensType", 
     407        'schema'      => "Canon", 
     408        'translatable'=> false, 
     409        'combiTag'    => 0, 
     410        'implemented' => true, 
     411        'tagValues.special' => Array( 
     412              /* some lenses have the same Id. In this case associated name is 
     413               * not a single string, but an Array 
     414               * 
     415               * the lens CanonReader->processSubTag0x0001 function try to find 
     416               * to good lens by looking in each name if the ShortFocal-LongFocal 
     417               * correspond 
     418               */ 
     419         0xffff => "Unknown lens", 
     420              1 => "Canon EF 50mm f/1.8", 
     421              2 => "Canon EF 28mm f/2.8", 
     422              3 => "Canon EF 135mm f/2.8 Soft", 
     423              4 => Array( 
     424                      "Canon EF 35-105mm f/3.5-4.5", 
     425                      "Sigma UC Zoom 35-135mm f/4-5.6", 
     426                    ), 
     427              5 => "Canon EF 35-70mm f/3.5-4.5", 
     428              6 => Array( 
     429                      "Canon EF 28-70mm f/3.5-4.5", 
     430                      "Sigma 18-50mm f/3.5-5.6 DC", 
     431                      "Sigma 18-125mm f/3.5-5.6 DC IF ASP", 
     432                      "Tokina AF193-2 19-35mm f/3.5-4.5", 
     433                    ), 
     434              7 => "Canon EF 100-300mm f/5.6L", 
     435              8 => Array( 
     436                      "Canon EF 100-300mm f/5.6", 
     437                      "Sigma 70-300mm f/4-5.6 DG Macro", 
     438                      "Tokina AT-X242AF 24-200mm f/3.5-5.6", 
     439                    ), 
     440              9 => Array( 
     441                      "Canon EF 70-210mm f/4", 
     442                      "Sigma 55-200mm f/4-5.6 DC", 
     443                    ), 
     444              10 => Array( 
     445                      "Canon EF 50mm f/2.5 Macro", 
     446                      "Sigma 50mm f/2.8 EX", 
     447                      "Sigma 28mm f/1.8", 
     448                      "Sigma 105mm f/2.8 Macro EX", 
     449                    ), 
     450              11 => "Canon EF 35mm f/2", 
     451              13 => "Canon EF 15mm f/2.8 Fisheye", 
     452              14 => "Canon EF 50-200mm f/3.5-4.5L", 
     453              15 => "Canon EF 50-200mm f/3.5-4.5", 
     454              16 => "Canon EF 35-135mm f/3.5-4.5", 
     455              17 => "Canon EF 35-70mm f/3.5-4.5A", 
     456              18 => "Canon EF 28-70mm f/3.5-4.5", 
     457              20 => "Canon EF 100-200mm f/4.5A", 
     458              21 => "Canon EF 80-200mm f/2.8L", 
     459              22 => Array( 
     460                        "Canon EF 20-35mm f/2.8L", 
     461                        "Tokina AT-X280AF PRO 28-80mm f/2.8 Aspherical", 
     462                      ), 
     463              23 => "Canon EF 35-105mm f/3.5-4.5", 
     464              24 => "Canon EF 35-80mm f/4-5.6 Power Zoom", 
     465              25 => "Canon EF 35-80mm f/4-5.6 Power Zoom", 
     466              26 => Array( 
     467                        "Canon EF 100mm f/2.8 Macro", 
     468                        "Cosina 100mm f/3.5 Macro AF", 
     469                        "Tamron SP AF 90mm f/2.8 Di Macro", 
     470                        "Tamron SP AF 180mm f/3.5 Di Macro", 
     471                        "Carl Zeiss Planar T* 50mm f/1.4", 
     472                      ), 
     473              27 => "Canon EF 35-80mm f/4-5.6", 
     474              28 => Array( 
     475                        "Canon EF 80-200mm f/4.5-5.6", 
     476                        "Tamron SP AF 28-105mm f/2.8 LD Aspherical IF", 
     477                        "Tamron SP AF 28-75mm f/2.8 XR Di LD Aspherical [IF] Macro", 
     478                        "Tamron AF 70-300mm f/4.5-5.6 Di LD 1:2 Macro Zoom", 
     479                        "Tamron AF Aspherical 28-200mm f/3.8-5.6", 
     480                      ), 
     481              29 => "Canon EF 50mm f/1.8 MkII", 
     482              30 => "Canon EF 35-105mm f/4.5-5.6", 
     483              31 => Array( 
     484                        "Canon EF 75-300mm f/4-5.6", 
     485                        "Tamron SP AF 300mm f/2.8 LD IF", 
     486                      ), 
     487              32 => Array( 
     488                        "Canon EF 24mm f/2.8", 
     489                        "Sigma 15mm f/2.8 EX Fisheye", 
     490                      ), 
     491              33 => "Voigtlander Ultron 40mm f/2 SLII Aspherical", 
     492              35 => "Canon EF 35-80mm f/4-5.6", 
     493              36 => "Canon EF 38-76mm f/4.5-5.6", 
     494              37 => Array( 
     495                        "Canon EF 35-80mm f/4-5.6", 
     496                        "Tamron 70-200mm f/2.8 Di LD IF Macro", 
     497                        "Tamron AF 28-300mm f/3.5-6.3 XR Di VC LD Aspherical [IF] Macro Model A20", 
     498                      ), 
     499              38 => "Canon EF 80-200mm f/4.5-5.6", 
     500              39 => "Canon EF 75-300mm f/4-5.6", 
     501              40 => "Canon EF 28-80mm f/3.5-5.6", 
     502              41 => "Canon EF 28-90mm f/4-5.6", 
     503              42 => Array( 
     504                        "Canon EF 28-200mm f/3.5-5.6", 
     505                        "Tamron AF 28-300mm f/3.5-6.3 XR Di VC LD Aspherical [IF] Macro Model A20", 
     506                      ), 
     507              43 => "Canon EF 28-105mm f/4-5.6", 
     508              44 => "Canon EF 90-300mm f/4.5-5.6", 
     509              45 => "Canon EF-S 18-55mm f/3.5-5.6", 
     510              46 => "Canon EF 28-90mm f/4-5.6", 
     511              48 => "Canon EF-S 18-55mm f/3.5-5.6 IS", 
     512              49 => "Canon EF-S 55-250mm f/4-5.6 IS", 
     513              50 => "Canon EF-S 18-200mm f/3.5-5.6 IS", 
     514              51 => "Canon EF-S 18-135mm f/3.5-5.6 IS", 
     515              94 => "Canon TS-E 17mm f/4L", 
     516              95 => "Canon TS-E 24.0mm f/3.5 L II", 
     517              124 => "Canon MP-E 65mm f/2.8 1-5x Macro Photo", 
     518              125 => "Canon TS-E 24mm f/3.5L", 
     519              126 => "Canon TS-E 45mm f/2.8", 
     520              127 => "Canon TS-E 90mm f/2.8", 
     521              129 => "Canon EF 300mm f/2.8L", 
     522              130 => "Canon EF 50mm f/1.0L", 
     523              131 => Array( 
     524                        "Canon EF 28-80mm f/2.8-4L", 
     525                        "Sigma 8mm f/3.5 EX DG Circular Fisheye", 
     526                        "Sigma 17-35mm f/2.8-4 EX DG Aspherical HSM", 
     527                        "Sigma 17-70mm f/2.8-4.5 DC Macro", 
     528                        "Sigma APO 50-150mm f/2.8 [II] EX DC HSM", 
     529                        "Sigma APO 120-300mm f/2.8 EX DG HSM", 
     530                      ), 
     531              132 => "Canon EF 1200mm f/5.6L", 
     532              134 => "Canon EF 600mm f/4L IS", 
     533              135 => "Canon EF 200mm f/1.8L", 
     534              136 => "Canon EF 300mm f/2.8L", 
     535              137 => Array( 
     536                        "Canon EF 85mm f/1.2L", 
     537                        "Sigma 18-50mm f/2.8-4.5 DC OS HSM", 
     538                        "Sigma 50-200mm f/4-5.6 DC OS HSM", 
     539                        "Sigma 18-250mm f/3.5-6.3 DC OS HSM", 
     540                        "Sigma 24-70mm f/2.8 IF EX DG HSM", 
     541                        "Sigma 18-125mm f/3.8-5.6 DC OS HSM", 
     542                      ), 
     543              138 => "Canon EF 28-80mm f/2.8-4L", 
     544              139 => "Canon EF 400mm f/2.8L", 
     545              140 => "Canon EF 500mm f/4.5L", 
     546              141 => "Canon EF 500mm f/4.5L", 
     547              142 => "Canon EF 300mm f/2.8L IS", 
     548              143 => "Canon EF 500mm f/4L IS", 
     549              144 => "Canon EF 35-135mm f/4-5.6 USM", 
     550              145 => "Canon EF 100-300mm f/4.5-5.6 USM", 
     551              146 => "Canon EF 70-210mm f/3.5-4.5 USM", 
     552              147 => "Canon EF 35-135mm f/4-5.6 USM", 
     553              148 => "Canon EF 28-80mm f/3.5-5.6 USM", 
     554              149 => "Canon EF 100mm f/2 USM", 
     555              150 => Array( 
     556                        "Canon EF 14mm f/2.8L", 
     557                        "Sigma 20mm EX f/1.8", 
     558                        "Sigma 30mm f/1.4 DC HSM", 
     559                        "Sigma 24mm f/1.8 DG Macro EX", 
     560                      ), 
     561              151 => "Canon EF 200mm f/2.8L", 
     562              152 => Array( 
     563                        "Canon EF 300mm f/4L IS", 
     564                        "Sigma 12-24mm f/4.5-5.6 EX DG ASPHERICAL HSM", 
     565                        "Sigma 14mm f/2.8 EX Aspherical HSM", 
     566                        "Sigma 10-20mm f/4-5.6", 
     567                        "Sigma 100-300mm f/4", 
     568                      ), 
     569              153 => Array( 
     570                        "Canon EF 35-350mm f/3.5-5.6L", 
     571                        "Sigma 50-500mm f/4-6.3 APO HSM EX", 
     572                        "Tamron AF 28-300mm f/3.5-6.3 XR LD Aspherical [IF] Macro", 
     573                        "Tamron AF 18-200mm f/3.5-6.3 XR Di II LD Aspherical [IF] Macro Model A14", 
     574                        "Tamron 18-250mm f/3.5-6.3 Di II LD Aspherical [IF] Macro", 
     575                      ), 
     576              154 => "Canon EF 20mm f/2.8 USM", 
     577              155 => "Canon EF 85mm f/1.8 USM", 
     578              156 => "Canon EF 28-105mm f/3.5-4.5 USM", 
     579              160 => Array( 
     580                        "Canon EF 20-35mm f/3.5-4.5 USM", 
     581                        "Tamron AF 19-35mm f/3.5-4.5", 
     582                      ), 
     583              161 => Array( 
     584                        "Canon EF 28-70mm f/2.8L", 
     585                        "Sigma 24-70mm EX f/2.8", 
     586                        "Tamron 90mm f/2.8", 
     587                        "Tamron AF 17-50mm f/2.8 Di-II LD Aspherical", 
     588                      ), 
     589              162 => "Canon EF 200mm f/2.8L", 
     590              163 => "Canon EF 300mm f/4L", 
     591              164 => "Canon EF 400mm f/5.6L", 
     592              165 => "Canon EF 70-200mm f/2.8 L", 
     593              166 => "Canon EF 70-200mm f/2.8 L + 1.4x", 
     594              167 => "Canon EF 70-200mm f/2.8 L + 2x", 
     595              168 => "Canon EF 28mm f/1.8 USM", 
     596              169 => Array( 
     597                        "Canon EF 17-35mm f/2.8L", 
     598                        "Sigma 18-200mm f/3.5-6.3 DC OS", 
     599                        "Sigma 15-30mm f/3.5-4.5 EX DG Aspherical", 
     600                        "Sigma 18-50mm f/2.8 Macro", 
     601                        "Sigma 50mm f/1.4 EX DG HSM", 
     602                      ), 
     603              170 => "Canon EF 200mm f/2.8L II", 
     604              171 => "Canon EF 300mm f/4L", 
     605              172 => "Canon EF 400mm f/5.6L", 
     606              173 => Array( 
     607                        "Canon EF 180mm Macro f/3.5L", 
     608                        "Sigma 180mm EX HSM Macro f/3.5", 
     609                        "Sigma APO Macro 150mm f/2.8 EX DG HSM", 
     610                      ), 
     611              174 => "Canon EF 135mm f/2L", 
     612              175 => "Canon EF 400mm f/2.8L", 
     613              176 => "Canon EF 24-85mm f/3.5-4.5 USM", 
     614              177 => "Canon EF 300mm f/4L IS", 
     615              178 => "Canon EF 28-135mm f/3.5-5.6 IS", 
     616              179 => "Canon EF 24mm f/1.4L", 
     617              180 => "Canon EF 35mm f/1.4L", 
     618              181 => "Canon EF 100-400mm f/4.5-5.6L IS + 1.4x", 
     619              182 => "Canon EF 100-400mm f/4.5-5.6L IS + 2x", 
     620              183 => "Canon EF 100-400mm f/4.5-5.6L IS", 
     621              184 => "Canon EF 400mm f/2.8L + 2x", 
     622              185 => "Canon EF 600mm f/4L IS", 
     623              186 => "Canon EF 70-200mm f/4L", 
     624              187 => "Canon EF 70-200mm f/4L + 1.4x", 
     625              188 => "Canon EF 70-200mm f/4L + 2x", 
     626              189 => "Canon EF 70-200mm f/4L + 2.8x", 
     627              190 => "Canon EF 100mm f/2.8 Macro", 
     628              191 => "Canon EF 400mm f/4 DO IS", 
     629              193 => "Canon EF 35-80mm f/4-5.6 USM", 
     630              194 => "Canon EF 80-200mm f/4.5-5.6 USM", 
     631              195 => "Canon EF 35-105mm f/4.5-5.6 USM", 
     632              196 => "Canon EF 75-300mm f/4-5.6 USM", 
     633              197 => "Canon EF 75-300mm f/4-5.6 IS USM", 
     634              198 => "Canon EF 50mm f/1.4 USM", 
     635              199 => "Canon EF 28-80mm f/3.5-5.6 USM", 
     636              200 => "Canon EF 75-300mm f/4-5.6 USM", 
     637              201 => "Canon EF 28-80mm f/3.5-5.6 USM", 
     638              202 => "Canon EF 28-80mm f/3.5-5.6 USM IV", 
     639              208 => "Canon EF 22-55mm f/4-5.6 USM", 
     640              209 => "Canon EF 55-200mm f/4.5-5.6", 
     641              210 => "Canon EF 28-90mm f/4-5.6 USM", 
     642              211 => "Canon EF 28-200mm f/3.5-5.6 USM", 
     643              212 => "Canon EF 28-105mm f/4-5.6 USM", 
     644              213 => "Canon EF 90-300mm f/4.5-5.6 USM", 
     645              214 => "Canon EF-S 18-55mm f/3.5-4.5 USM", 
     646              215 => "Canon EF 55-200mm f/4.5-5.6 II USM", 
     647              224 => "Canon EF 70-200mm f/2.8L IS", 
     648              225 => "Canon EF 70-200mm f/2.8L IS + 1.4x", 
     649              226 => "Canon EF 70-200mm f/2.8L IS + 2x", 
     650              227 => "Canon EF 70-200mm f/2.8L IS + 2.8x", 
     651              228 => "Canon EF 28-105mm f/3.5-4.5 USM", 
     652              229 => "Canon EF 16-35mm f/2.8L", 
     653              230 => "Canon EF 24-70mm f/2.8L", 
     654              231 => "Canon EF 17-40mm f/4L", 
     655              232 => "Canon EF 70-300mm f/4.5-5.6 DO IS USM", 
     656              233 => "Canon EF 28-300mm f/3.5-5.6L IS", 
     657              234 => "Canon EF-S 17-85mm f4-5.6 IS USM", 
     658              235 => "Canon EF-S 10-22mm f/3.5-4.5 USM", 
     659              236 => "Canon EF-S 60mm f/2.8 Macro USM", 
     660              237 => "Canon EF 24-105mm f/4L IS", 
     661              238 => "Canon EF 70-300mm f/4-5.6 IS USM", 
     662              239 => "Canon EF 85mm f/1.2L II", 
     663              240 => "Canon EF-S 17-55mm f/2.8 IS USM", 
     664              241 => "Canon EF 50mm f/1.2L", 
     665              242 => "Canon EF 70-200mm f/4L IS", 
     666              243 => "Canon EF 70-200mm f/4L IS + 1.4x", 
     667              244 => "Canon EF 70-200mm f/4L IS + 2x", 
     668              245 => "Canon EF 70-200mm f/4L IS + 2.8x", 
     669              246 => "Canon EF 16-35mm f/2.8L II", 
     670              247 => "Canon EF 14mm f/2.8L II USM", 
     671              248 => "Canon EF 200mm f/2L IS", 
     672              249 => "Canon EF 800mm f/5.6L IS", 
     673              250 => "Canon EF 24 f/1.4L II", 
     674              254 => "Canon EF 100mm f/2.8L Macro IS USM", 
     675              488 => "Canon EF-S 15-85mm f/3.5-5.6 IS USM", 
     676        ), 
     677      ), 
     678 
     679      "0x0001.23" => Array( 
     680        'tagName'     => "CanonCameraSettings.LongFocal", 
     681        'schema'      => "Canon", 
     682        'translatable'=> false, 
     683        'combiTag'    => 0, 
     684        'implemented' => true, 
     685      ), 
     686 
     687      "0x0001.24" => Array( 
     688        'tagName'     => "CanonCameraSettings.ShortFocal", 
     689        'schema'      => "Canon", 
     690        'translatable'=> false, 
     691        'combiTag'    => 0, 
     692        'implemented' => true, 
     693      ), 
     694 
     695      "0x0001.25" => Array( 
     696        'tagName'     => "CanonCameraSettings.FocalUnits", 
     697        'schema'      => "Canon", 
     698        'translatable'=> false, 
     699        'combiTag'    => 0, 
     700        'implemented' => true, 
     701      ), 
     702 
     703      "0x0001.26" => Array( 
     704        'tagName'     => "CanonCameraSettings.MaxAperture", 
     705        'schema'      => "Canon", 
     706        'translatable'=> false, 
     707        'combiTag'    => 0, 
     708        'implemented' => true, 
     709      ), 
     710 
     711      "0x0001.27" => Array( 
     712        'tagName'     => "CanonCameraSettings.MinAperture", 
     713        'schema'      => "Canon", 
     714        'translatable'=> false, 
     715        'combiTag'    => 0, 
     716        'implemented' => true, 
     717      ), 
     718 
     719      "0x0001.28" => Array( 
     720        'tagName'     => "CanonCameraSettings.FlashActivity", 
     721        'schema'      => "Canon", 
     722        'translatable'=> true, 
     723        'combiTag'    => 0, 
     724        'implemented' => true, 
     725        'tagValues'   => Array( 
     726            0x00 => "Did not fire", 
     727            0x01 => "Fired", 
     728        ), 
     729      ), 
     730 
     731      "0x0001.29" => Array( 
     732        'tagName'     => "CanonCameraSettings.FlashBits", 
     733        'schema'      => "Canon", 
     734        'translatable'=> true, 
     735        'combiTag'    => 0, 
     736        'implemented' => true, 
     737        'tagValues.special' => Array( 
     738            0x0001 => "Manual",                  //b0000000000000001 
     739            0x0002 => "TTL",                     //b0000000000000010 
     740            0x0004 => "A-TTL",                   //b0000000000000100 
     741            0x0008 => "E-TTL",                   //b0000000000001000 
     742            0x0010 => "FP sync enabled",         //b0000000000010000 
     743            0x0080 => "2nd-curtain sync used",   //b0000000010000000 
     744            0x0800 => "FP sync used",            //b0000100000000000 
     745            0x2000 => "Built-in",                //b0010000000000000 
     746            0x4000 => "External",                //b0100000000000000 
     747        ), 
     748      ), 
     749 
     750      "0x0001.32" => Array( 
     751        'tagName'     => "CanonCameraSettings.FocusContinuous", 
     752        'schema'      => "Canon", 
     753        'translatable'=> true, 
     754        'combiTag'    => 0, 
     755        'implemented' => true, 
     756        'tagValues'   => Array( 
     757            0x00 => "Single", 
     758            0x01 => "Continuous", 
     759            0x08 => "Manual", 
     760            0xFFFF => "Unknown", 
     761        ), 
     762      ), 
     763 
     764      "0x0001.33" => Array( 
     765        'tagName'     => "CanonCameraSettings.AESetting", 
     766        'schema'      => "Canon", 
     767        'translatable'=> true, 
     768        'combiTag'    => 0, 
     769        'implemented' => true, 
     770        'tagValues'   => Array( 
     771            0x00 => "Normal AE", 
     772            0x01 => "Exposure Compensation", 
     773            0x02 => "AE Lock", 
     774            0x03 => "AE Lock + Exposure Comp.", 
     775            0x04 => "No AE" 
     776        ), 
     777      ), 
     778 
     779      "0x0001.34" => Array( 
     780        'tagName'     => "CanonCameraSettings.ImageStabilization", 
     781        'schema'      => "Canon", 
     782        'translatable'=> true, 
     783        'combiTag'    => 0, 
     784        'implemented' => true, 
     785        'tagValues'   => Array( 
     786            0x00 => "Off", 
     787            0x01 => "On", 
     788            0x02 => "On, Shot Only", 
     789            0x03 => "On, Panning", 
     790            0xFFFF => "Unknown", 
     791        ), 
     792      ), 
     793 
     794      "0x0001.35" => Array( 
     795        'tagName'     => "CanonCameraSettings.DisplayAperture", 
     796        'schema'      => "Canon", 
     797        'translatable'=> false, 
     798        'combiTag'    => 0, 
     799        'implemented' => false, 
     800      ), 
     801 
     802      "0x0001.36" => Array( 
     803        'tagName'     => "CanonCameraSettings.ZoomSourceWidth", 
     804        'schema'      => "Canon", 
     805        'translatable'=> false, 
     806        'combiTag'    => 0, 
     807        'implemented' => false, 
     808      ), 
     809 
     810      "0x0001.37" => Array( 
     811        'tagName'     => "CanonCameraSettings.ZoomTargetWidth", 
     812        'schema'      => "Canon", 
     813        'translatable'=> false, 
     814        'combiTag'    => 0, 
     815        'implemented' => false, 
     816      ), 
     817 
     818      "0x0001.39" => Array( 
     819        'tagName'     => "CanonCameraSettings.SpotMeteringMode", 
     820        'schema'      => "Canon", 
     821        'translatable'=> true, 
     822        'combiTag'    => 0, 
     823        'implemented' => true, 
     824        'tagValues'   => Array( 
     825            0x00 => "Center", 
     826            0x01 => "AF Point", 
     827            0xFFFF => "Unknown", 
     828        ), 
     829      ), 
     830 
     831      "0x0001.40" => Array( 
     832        'tagName'     => "CanonCameraSettings.PhotoEffect", 
     833        'schema'      => "Canon", 
     834        'translatable'=> true, 
     835        'combiTag'    => 0, 
     836        'implemented' => true, 
     837        'tagValues'   => Array( 
     838            0x00 => "Off", 
     839            0x01 => "Vivid", 
     840            0x02 => "Neutral", 
     841            0x03 => "Smooth", 
     842            0x04 => "Sepia", 
     843            0x05 => "B&W", 
     844            0x06 => "Custom", 
     845            0x64 => "My Color Data", 
     846            0xFFFF => "Unknown", 
     847        ), 
     848      ), 
     849 
     850      "0x0001.41" => Array( 
     851        'tagName'     => "CanonCameraSettings.ManualFlashOutput", 
     852        'schema'      => "Canon", 
     853        'translatable'=> true, 
     854        'combiTag'    => 0, 
     855        'implemented' => true, 
     856        'tagValues'   => Array( 
     857            0x0000 => "n/a", 
     858            0x0500 => "Full", 
     859            0x0502 => "Medium", 
     860            0x0504 => "Low", 
     861            0x7fff => "n/a", 
     862        ), 
     863      ), 
     864 
     865      "0x0001.42" => Array( 
     866        'tagName'     => "CanonCameraSettings.ColorTone", 
     867        'schema'      => "Canon", 
     868        'translatable'=> true, 
     869        'combiTag'    => 0, 
     870        'implemented' => true, 
     871        'tagValues'   => Array( 
     872            0x0000 => "Normal", 
     873        ), 
     874      ), 
     875 
     876      "0x0001.46" => Array( 
     877        'tagName'     => "CanonCameraSettings.SRAWQuality", 
     878        'schema'      => "Canon", 
     879        'translatable'=> true, 
     880        'combiTag'    => 0, 
     881        'implemented' => true, 
     882        'tagValues'   => Array( 
     883            0x00 => "n/a", 
     884            0x01 => "sRAW1 (mRAW)", 
     885            0x02 => "sRAW2 (sRAW)" 
     886        ), 
     887      ), 
    213888 
    214889      /* 
     
    243918      ), // < 
    244919 
     920      /* 
     921       * The 'CanonShotInfo' tags is composed by an array of sub tags 
     922       * 
     923       * Like the CanonCameraSettings tag, this kind of data needs a particular 
     924       * algorythm in the CanonReader class, provided by the processSubTag0x0004 
     925       * function 
     926       * 
     927       * >>> Begin of CanonShotInfo subtags 
     928       * 
     929       */ 
     930      "0x0004.1" => Array( 
     931        'tagName'     => "CanonShotInfo.AutoISO", 
     932        'schema'      => "Canon", 
     933        'translatable'=> false, 
     934        'combiTag'    => 0, 
     935        'implemented' => true, 
     936      ), 
     937 
     938      "0x0004.2" => Array( 
     939        'tagName'     => "CanonShotInfo.BaseISO", 
     940        'schema'      => "Canon", 
     941        'translatable'=> false, 
     942        'combiTag'    => 0, 
     943        'implemented' => true, 
     944      ), 
     945 
     946      "0x0004.3" => Array( 
     947        'tagName'     => "CanonShotInfo.MeasuredEV", 
     948        'schema'      => "Canon", 
     949        'translatable'=> false, 
     950        'combiTag'    => 0, 
     951        'implemented' => false, 
     952      ), 
     953 
     954      "0x0004.4" => Array( 
     955        'tagName'     => "CanonShotInfo.TargetAperture", 
     956        'schema'      => "Canon", 
     957        'translatable'=> false, 
     958        'combiTag'    => 0, 
     959        'implemented' => true, 
     960      ), 
     961 
     962      "0x0004.5" => Array( 
     963        'tagName'     => "CanonShotInfo.TargetExposureTime", 
     964        'schema'      => "Canon", 
     965        'translatable'=> false, 
     966        'combiTag'    => 0, 
     967        'implemented' => true, 
     968      ), 
     969 
     970      "0x0004.6" => Array( 
     971        'tagName'     => "CanonShotInfo.ExposureCompensation", 
     972        'schema'      => "Canon", 
     973        'translatable'=> false, 
     974        'combiTag'    => 0, 
     975        'implemented' => true, 
     976      ), 
     977 
     978      "0x0004.7" => Array( 
     979        'tagName'     => "CanonShotInfo.WhiteBalance", 
     980        'schema'      => "Canon", 
     981        'translatable'=> true, 
     982        'combiTag'    => 0, 
     983        'implemented' => true, 
     984        'tagValues'   => Array( 
     985            0x00 => "Auto", 
     986            0x01 => "Daylight", 
     987            0x02 => "Cloudy", 
     988            0x03 => "Tungsten", 
     989            0x04 => "Fluorescent", 
     990            0x05 => "Flash", 
     991            0x06 => "Custom", 
     992            0x07 => "Black & White", 
     993            0x08 => "Shade", 
     994            0x09 => "Manual Temperature (Kelvin)", 
     995            0x0A => "PC Set1", 
     996            0x0B => "PC Set2", 
     997            0x0C => "PC Set3", 
     998            0x0E => "Daylight Fluorescent", 
     999            0x0F => "Custom 1", 
     1000            0x10 => "Custom 2", 
     1001            0x11 => "Underwater", 
     1002            0x12 => "Custom 3", 
     1003            0x13 => "Custom 4", 
     1004            0x14 => "PC Set4", 
     1005            0x15 => "PC Set5", 
     1006        ), 
     1007      ), 
     1008 
     1009      "0x0004.8" => Array( 
     1010        'tagName'     => "CanonShotInfo.SlowShutter", 
     1011        'schema'      => "Canon", 
     1012        'translatable'=> true, 
     1013        'combiTag'    => 0, 
     1014        'implemented' => true, 
     1015        'tagValues'   => Array( 
     1016            0x00 => "Off", 
     1017            0x01 => "Night Scene", 
     1018            0x02 => "On", 
     1019            0x03 => "None", 
     1020        ), 
     1021      ), 
     1022 
     1023      "0x0004.9" => Array( 
     1024        'tagName'     => "CanonShotInfo.SequenceNumber", 
     1025        'schema'      => "Canon", 
     1026        'translatable'=> false, 
     1027        'combiTag'    => 0, 
     1028        'implemented' => true, 
     1029      ), 
     1030 
     1031      "0x0004.10" => Array( 
     1032        'tagName'     => "CanonShotInfo.OpticalZoomCode", 
     1033        'schema'      => "Canon", 
     1034        'translatable'=> false, 
     1035        'combiTag'    => 0, 
     1036        'implemented' => false, 
     1037      ), 
     1038 
     1039      "0x0004.13" => Array( 
     1040        'tagName'     => "CanonShotInfo.FlashGuideNumber", 
     1041        'schema'      => "Canon", 
     1042        'translatable'=> false, 
     1043        'combiTag'    => 0, 
     1044        'implemented' => true, 
     1045      ), 
     1046 
     1047      "0x0004.14" => Array( 
     1048        'tagName'     => "CanonShotInfo.AFPointsInFocus", 
     1049        'schema'      => "Canon", 
     1050        'translatable'=> true, 
     1051        'combiTag'    => 0, 
     1052        'implemented' => false, 
     1053        'tagValues'   => Array( 
     1054            // (used by D30, D60 and some PowerShot/Ixus models) 
     1055            0x3000 => "None (MF)", 
     1056            0x3001 => "Right", 
     1057            0x3002 => "Center", 
     1058            0x3003 => "Center+Right", 
     1059            0x3004 => "Left", 
     1060            0x3005 => "Left+Right", 
     1061            0x3006 => "Left+Center", 
     1062            0x3007 => "All", 
     1063        ), 
     1064      ), 
     1065 
     1066      "0x0004.15" => Array( 
     1067        'tagName'     => "CanonShotInfo.FlashExposureComp", 
     1068        'schema'      => "Canon", 
     1069        'translatable'=> false, 
     1070        'combiTag'    => 0, 
     1071        'implemented' => true, 
     1072      ), 
     1073 
     1074      "0x0004.16" => Array( 
     1075        'tagName'     => "CanonShotInfo.AutoExposureBracketing", 
     1076        'schema'      => "Canon", 
     1077        'translatable'=> true, 
     1078        'combiTag'    => 0, 
     1079        'implemented' => true, 
     1080        'tagValues'   => Array( 
     1081            -1 => "On", 
     1082            0 => "Off", 
     1083            1 => "On (shot 1)", 
     1084            2 => "On (shot 2)", 
     1085            3 => "On (shot 3)", 
     1086        ), 
     1087      ), 
     1088 
     1089      "0x0004.17" => Array( 
     1090        'tagName'     => "CanonShotInfo.AEBBracketValue", 
     1091        'schema'      => "Canon", 
     1092        'translatable'=> false, 
     1093        'combiTag'    => 0, 
     1094        'implemented' => true, 
     1095      ), 
     1096 
     1097      "0x0004.18" => Array( 
     1098        'tagName'     => "CanonShotInfo.ControlMode", 
     1099        'schema'      => "Canon", 
     1100        'translatable'=> true, 
     1101        'combiTag'    => 0, 
     1102        'implemented' => true, 
     1103        'tagValues'   => Array( 
     1104            0 => "n/a", 
     1105            1 => "Camera Local Control", 
     1106            3 => "Computer Remote Control", 
     1107        ), 
     1108      ), 
     1109 
     1110      "0x0004.19" => Array( 
     1111        'tagName'     => "CanonShotInfo.FocusDistanceUpper", 
     1112        'schema'      => "Canon", 
     1113        'translatable'=> false, 
     1114        'combiTag'    => 0, 
     1115        'implemented' => false, 
     1116      ), 
     1117 
     1118      "0x0004.20" => Array( 
     1119        'tagName'     => "CanonShotInfo.FocusDistanceLower", 
     1120        'schema'      => "Canon", 
     1121        'translatable'=> false, 
     1122        'combiTag'    => 0, 
     1123        'implemented' => false, 
     1124      ), 
     1125 
     1126      "0x0004.21" => Array( 
     1127        'tagName'     => "CanonShotInfo.FNumber", 
     1128        'schema'      => "Canon", 
     1129        'translatable'=> false, 
     1130        'combiTag'    => 0, 
     1131        'implemented' => false, 
     1132      ), 
     1133 
     1134      "0x0004.22" => Array( 
     1135        'tagName'     => "CanonShotInfo.ExposureTime", 
     1136        'schema'      => "Canon", 
     1137        'translatable'=> false, 
     1138        'combiTag'    => 0, 
     1139        'implemented' => false, 
     1140      ), 
     1141 
     1142      "0x0004.23" => Array( 
     1143        'tagName'     => "CanonShotInfo.MeasuredEV2", 
     1144        'schema'      => "Canon", 
     1145        'translatable'=> false, 
     1146        'combiTag'    => 0, 
     1147        'implemented' => false, 
     1148      ), 
     1149 
     1150      "0x0004.24" => Array( 
     1151        'tagName'     => "CanonShotInfo.BulbDuration", 
     1152        'schema'      => "Canon", 
     1153        'translatable'=> false, 
     1154        'combiTag'    => 0, 
     1155        'implemented' => false, 
     1156      ), 
     1157 
     1158      "0x0004.26" => Array( 
     1159        'tagName'     => "CanonShotInfo.CameraType", 
     1160        'schema'      => "Canon", 
     1161        'translatable'=> true, 
     1162        'combiTag'    => 0, 
     1163        'implemented' => true, 
     1164        'tagValues'   => Array( 
     1165            248 => "EOS High-end", 
     1166            250 => "Compact", 
     1167            252 => "EOS Mid-range", 
     1168            255 => "DV Camera", 
     1169        ), 
     1170      ), 
     1171 
     1172      "0x0004.27" => Array( 
     1173        'tagName'     => "CanonShotInfo.AutoRotate", 
     1174        'schema'      => "Canon", 
     1175        'translatable'=> true, 
     1176        'combiTag'    => 0, 
     1177        'implemented' => true, 
     1178        'tagValues'   => Array( 
     1179       0xFFFF => "Unknown", 
     1180            0 => "None", 
     1181            1 => "Rotate 90 CW", 
     1182            2 => "Rotate 180", 
     1183            3 => "Rotate 270 CW", 
     1184        ), 
     1185      ), 
     1186 
     1187      "0x0004.28" => Array( 
     1188        'tagName'     => "CanonShotInfo.NDFilter", 
     1189        'schema'      => "Canon", 
     1190        'translatable'=> true, 
     1191        'combiTag'    => 0, 
     1192        'implemented' => true, 
     1193        'tagValues'   => Array( 
     1194            0 => "Off", 
     1195            1 => "On", 
     1196       0xFFFF => "Unknown", 
     1197        ), 
     1198      ), 
     1199 
     1200      "0x0004.29" => Array( 
     1201        'tagName'     => "CanonShotInfo.SelfTimer2", 
     1202        'schema'      => "Canon", 
     1203        'translatable'=> false, 
     1204        'combiTag'    => 0, 
     1205        'implemented' => false, 
     1206      ), 
     1207 
     1208      "0x0004.33" => Array( 
     1209        'tagName'     => "CanonShotInfo.FlashOutput", 
     1210        'schema'      => "Canon", 
     1211        'translatable'=> false, 
     1212        'combiTag'    => 0, 
     1213        'implemented' => false, 
     1214      ), 
     1215 
     1216      /* 
     1217       * <<< Begin of CanonShotInfo subtags 
     1218       * 
     1219       */ 
     1220 
     1221 
    2451222      // CanonPanorama, tag 0x0005 
    2461223      0x0005 => Array( 
     
    3131290        'combiTag'    => 0, 
    3141291        'implemented' => false, 
     1292        'tagValues.special' => Array( 
     1293          '40D'      => Array(3, 4, 6, 21, 24, 27, 29, 48, 67, 69, 111, 115, 214, 216, 218, 255, 307, 319, 2347), 
     1294          '1DMarkIV' => Array(3, 4, 6, 7, 21, 25, 30, 53, 84, 86, 488, 493), 
     1295        ) 
    3151296      ), // < CanonCameraInfo 
     1297 
     1298      /* 
     1299       * The 'CanonCameraInfo' tags structure depends of the camera model 
     1300       * 
     1301       * Like the CanonCameraSettings tag, this kind of data needs a particular 
     1302       * algorythm in the CanonReader class, provided by the processSubTag0x000d 
     1303       * functions 
     1304       * 
     1305       * >>> Begin of CanonCameraInfo subtags 
     1306       * 
     1307       */ 
     1308 
     1309      /* 
     1310       * Canon EOS 40D CameraInfo tags 
     1311       */ 
     1312      "0x000d.40D.3" => Array( 
     1313        'tagName'     => "CanonCameraInfo.FNumber", 
     1314        'schema'      => "Canon", 
     1315        'translatable'=> false, 
     1316        'combiTag'    => 0, 
     1317        'implemented' => false, 
     1318        'pos'         => 3, 
     1319        'type'        => ByteType::UBYTE, 
     1320      ), 
     1321 
     1322      "0x000d.40D.4" => Array( 
     1323        'tagName'     => "CanonCameraInfo.ExposureTime", 
     1324        'schema'      => "Canon", 
     1325        'translatable'=> false, 
     1326        'combiTag'    => 0, 
     1327        'implemented' => false, 
     1328        'pos'         => 4, 
     1329        'type'        => ByteType::UBYTE, 
     1330      ), 
     1331 
     1332      "0x000d.40D.6" => Array( 
     1333        'tagName'     => "CanonCameraInfo.ISO", 
     1334        'schema'      => "Canon", 
     1335        'translatable'=> false, 
     1336        'combiTag'    => 0, 
     1337        'implemented' => false, 
     1338        'pos'         => 6, 
     1339        'type'        => ByteType::UBYTE, 
     1340      ), 
     1341 
     1342      "0x000d.40D.21" => Array( 
     1343        'tagName'     => "CanonCameraInfo.FlashMeteringMode", 
     1344        'schema'      => "Canon", 
     1345        'translatable'=> true, 
     1346        'combiTag'    => 0, 
     1347        'implemented' => true, 
     1348        'pos'         => 21, 
     1349        'type'        => ByteType::UBYTE, 
     1350        'tagValues'   => Array( 
     1351            0 => "E-TTL", 
     1352            3 => "TTL", 
     1353            4 => "External Auto", 
     1354            5 => "External Manual", 
     1355            6 => "Off", 
     1356        ) 
     1357      ), 
     1358 
     1359      "0x000d.40D.24" => Array( 
     1360        'tagName'     => "CanonCameraInfo.CameraTemperature", 
     1361        'schema'      => "Canon", 
     1362        'translatable'=> false, 
     1363        'combiTag'    => 0, 
     1364        'implemented' => true, 
     1365        'pos'         => 24, 
     1366        'type'        => ByteType::UBYTE, 
     1367      ), 
     1368 
     1369      "0x000d.40D.27" => Array( 
     1370        'tagName'     => "CanonCameraInfo.MacroMagnification", 
     1371        'schema'      => "Canon", 
     1372        'translatable'=> false, 
     1373        'combiTag'    => 0, 
     1374        'implemented' => false, 
     1375        'pos'         => 29, 
     1376        'type'        => ByteType::UBYTE, 
     1377      ), 
     1378 
     1379      "0x000d.40D.29" => Array( 
     1380        'tagName'     => "CanonCameraInfo.FocalLength", 
     1381        'schema'      => "Canon", 
     1382        'translatable'=> false, 
     1383        'combiTag'    => 0, 
     1384        'implemented' => true, 
     1385        'pos'         => 29, 
     1386        'type'        => ByteType::USHORT, 
     1387        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN, 
     1388      ), 
     1389 
     1390      "0x000d.40D.48" => Array( 
     1391        'tagName'     => "CanonCameraInfo.CameraOrientation", 
     1392        'schema'      => "Canon", 
     1393        'translatable'=> true, 
     1394        'combiTag'    => 0, 
     1395        'implemented' => true, 
     1396        'pos'         => 48, 
     1397        'type'        => ByteType::UBYTE, 
     1398        'tagValues'   => Array( 
     1399            0 => "Horizontal (normal)", 
     1400            1 => "Rotate 90 CW", 
     1401            2 => "Rotate 270 CW", 
     1402        ) 
     1403      ), 
     1404 
     1405      "0x000d.40D.67" => Array( 
     1406        'tagName'     => "CanonCameraInfo.FocusDistanceUpper", 
     1407        'schema'      => "Canon", 
     1408        'translatable'=> false, 
     1409        'combiTag'    => 0, 
     1410        'implemented' => false, 
     1411        'pos'         => 67, 
     1412        'type'        => ByteType::USHORT, 
     1413        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN, 
     1414      ), 
     1415 
     1416      "0x000d.40D.69" => Array( 
     1417        'tagName'     => "CanonCameraInfo.FocusDistanceLower", 
     1418        'schema'      => "Canon", 
     1419        'translatable'=> false, 
     1420        'combiTag'    => 0, 
     1421        'implemented' => false, 
     1422        'pos'         => 69, 
     1423        'type'        => ByteType::USHORT, 
     1424        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN, 
     1425      ), 
     1426 
     1427      "0x000d.40D.111" => Array( 
     1428        'tagName'     => "CanonCameraInfo.WhiteBalance", 
     1429        'schema'      => "Canon", 
     1430        'translatable'=> false, 
     1431        'combiTag'    => 0, 
     1432        'implemented' => true, 
     1433        'pos'         => 111, 
     1434        'type'        => ByteType::USHORT, 
     1435      ), 
     1436 
     1437      "0x000d.40D.115" => Array( 
     1438        'tagName'     => "CanonCameraInfo.ColorTemperature", 
     1439        'schema'      => "Canon", 
     1440        'translatable'=> false, 
     1441        'combiTag'    => 0, 
     1442        'implemented' => false, 
     1443        'pos'         => 115, 
     1444        'type'        => ByteType::USHORT, 
     1445      ), 
     1446 
     1447      "0x000d.40D.214" => Array( 
     1448        'tagName'     => "CanonCameraInfo.LensType", 
     1449        'schema'      => "Canon", 
     1450        'translatable'=> false, 
     1451        'combiTag'    => 0, 
     1452        'implemented' => true, 
     1453        'pos'         => 214, 
     1454        'type'        => ByteType::USHORT, 
     1455        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN, 
     1456      ), 
     1457 
     1458      "0x000d.40D.216" => Array( 
     1459        'tagName'     => "CanonCameraInfo.ShortFocal", 
     1460        'schema'      => "Canon", 
     1461        'translatable'=> false, 
     1462        'combiTag'    => 0, 
     1463        'implemented' => true, 
     1464        'pos'         => 216, 
     1465        'type'        => ByteType::USHORT, 
     1466        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN, 
     1467      ), 
     1468 
     1469      "0x000d.40D.218" => Array( 
     1470        'tagName'     => "CanonCameraInfo.LongFocal", 
     1471        'schema'      => "Canon", 
     1472        'translatable'=> false, 
     1473        'combiTag'    => 0, 
     1474        'implemented' => true, 
     1475        'pos'         => 218, 
     1476        'type'        => ByteType::UBYTE, 
     1477        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN, 
     1478      ), 
     1479 
     1480      "0x000d.40D.255" => Array( 
     1481        'tagName'     => "CanonCameraInfo.FirmwareVersion", 
     1482        'schema'      => "Canon", 
     1483        'translatable'=> false, 
     1484        'combiTag'    => 0, 
     1485        'implemented' => true, 
     1486        'pos'         => 255, 
     1487        'type'        => ByteType::ASCII, 
     1488        'length'      => 6, 
     1489      ), 
     1490 
     1491      "0x000d.40D.307" => Array( 
     1492        'tagName'     => "CanonCameraInfo.FileIndex", 
     1493        'schema'      => "Canon", 
     1494        'translatable'=> false, 
     1495        'combiTag'    => 0, 
     1496        'implemented' => false, 
     1497        'pos'         => 307, 
     1498        'type'        => ByteType::ULONG, 
     1499      ), 
     1500 
     1501      "0x000d.40D.319" => Array( 
     1502        'tagName'     => "CanonCameraInfo.DirectoryIndex", 
     1503        'schema'      => "Canon", 
     1504        'translatable'=> false, 
     1505        'combiTag'    => 0, 
     1506        'implemented' => false, 
     1507        'pos'         => 319, 
     1508        'type'        => ByteType::ULONG, 
     1509      ), 
     1510 
     1511      "0x000d.40D.2347" => Array( 
     1512        'tagName'     => "CanonCameraInfo.LensModel", 
     1513        'schema'      => "Canon", 
     1514        'translatable'=> false, 
     1515        'combiTag'    => 0, 
     1516        'implemented' => true, 
     1517        'pos'         => 2347, 
     1518        'type'        => ByteType::ASCII, 
     1519        'length'      => 64, 
     1520      ), 
     1521 
     1522 
     1523      /* 
     1524       * Canon EOS 40D CameraInfo tags 
     1525       */ 
     1526      "0x000d.1DMarkIV.3" => Array( 
     1527        'tagName'     => "CanonCameraInfo.FNumber", 
     1528        'schema'      => "Canon", 
     1529        'translatable'=> false, 
     1530        'combiTag'    => 0, 
     1531        'implemented' => false, 
     1532        'pos'         => 3, 
     1533        'type'        => ByteType::UBYTE, 
     1534      ), 
     1535 
     1536      "0x000d.1DMarkIV.4" => Array( 
     1537        'tagName'     => "CanonCameraInfo.ExposureTime", 
     1538        'schema'      => "Canon", 
     1539        'translatable'=> false, 
     1540        'combiTag'    => 0, 
     1541        'implemented' => false, 
     1542        'pos'         => 4, 
     1543        'type'        => ByteType::UBYTE, 
     1544      ), 
     1545 
     1546      "0x000d.1DMarkIV.6" => Array( 
     1547        'tagName'     => "CanonCameraInfo.ISO", 
     1548        'schema'      => "Canon", 
     1549        'translatable'=> false, 
     1550        'combiTag'    => 0, 
     1551        'implemented' => false, 
     1552        'pos'         => 6, 
     1553        'type'        => ByteType::UBYTE, 
     1554      ), 
     1555 
     1556      "0x000d.1DMarkIV.7" => Array( 
     1557        'tagName'     => "CanonCameraInfo.HighlightTonePriority", 
     1558        'schema'      => "Canon", 
     1559        'translatable'=> true, 
     1560        'combiTag'    => 0, 
     1561        'implemented' => true, 
     1562        'pos'         => 7, 
     1563        'type'        => ByteType::UBYTE, 
     1564        'tagValues'   => Array( 
     1565            0 => "Off", 
     1566            1 => "On" 
     1567        ), 
     1568      ), 
     1569 
     1570      "0x000d.1DMarkIV.21" => Array( 
     1571        'tagName'     => "CanonCameraInfo.FlashMeteringMode", 
     1572        'schema'      => "Canon", 
     1573        'translatable'=> true, 
     1574        'combiTag'    => 0, 
     1575        'implemented' => true, 
     1576        'pos'         => 21, 
     1577        'type'        => ByteType::UBYTE, 
     1578        'tagValues'   => Array( 
     1579            0 => "E-TTL", 
     1580            3 => "TTL", 
     1581            4 => "External Auto", 
     1582            5 => "External Manual", 
     1583            6 => "Off", 
     1584        ) 
     1585      ), 
     1586 
     1587      "0x000d.1DMarkIV.25" => Array( 
     1588        'tagName'     => "CanonCameraInfo.CameraTemperature", 
     1589        'schema'      => "Canon", 
     1590        'translatable'=> false, 
     1591        'combiTag'    => 0, 
     1592        'implemented' => true, 
     1593        'pos'         => 25, 
     1594        'type'        => ByteType::UBYTE, 
     1595      ), 
     1596 
     1597      "0x000d.1DMarkIV.30" => Array( 
     1598        'tagName'     => "CanonCameraInfo.FocalLength", 
     1599        'schema'      => "Canon", 
     1600        'translatable'=> false, 
     1601        'combiTag'    => 0, 
     1602        'implemented' => true, 
     1603        'pos'         => 30, 
     1604        'type'        => ByteType::USHORT, 
     1605        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN, 
     1606      ), 
     1607 
     1608      "0x000d.1DMarkIV.53" => Array( 
     1609        'tagName'     => "CanonCameraInfo.CameraOrientation", 
     1610        'schema'      => "Canon", 
     1611        'translatable'=> true, 
     1612        'combiTag'    => 0, 
     1613        'implemented' => true, 
     1614        'pos'         => 53, 
     1615        'type'        => ByteType::UBYTE, 
     1616        'tagValues'   => Array( 
     1617            0 => "Horizontal (normal)", 
     1618            1 => "Rotate 90 CW", 
     1619            2 => "Rotate 270 CW", 
     1620        ) 
     1621      ), 
     1622 
     1623      "0x000d.1DMarkIV.84" => Array( 
     1624        'tagName'     => "CanonCameraInfo.FocusDistanceUpper", 
     1625        'schema'      => "Canon", 
     1626        'translatable'=> false, 
     1627        'combiTag'    => 0, 
     1628        'implemented' => false, 
     1629        'pos'         => 84, 
     1630        'type'        => ByteType::USHORT, 
     1631        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN, 
     1632      ), 
     1633 
     1634      "0x000d.1DMarkIV.86" => Array( 
     1635        'tagName'     => "CanonCameraInfo.FocusDistanceLower", 
     1636        'schema'      => "Canon", 
     1637        'translatable'=> false, 
     1638        'combiTag'    => 0, 
     1639        'implemented' => false, 
     1640        'pos'         => 86, 
     1641        'type'        => ByteType::USHORT, 
     1642        'byteOrder'   => BYTE_ORDER_BIG_ENDIAN, 
     1643      ), 
     1644 
     1645 
     1646      /* 
     1647       * <<< end of CanonCameraInfo subtags 
     1648       * 
     1649       */ 
    3161650 
    3171651      // CanonFileLength, tag 0x000e 
     
    9302264    } 
    9312265 
    932   } // NikonTags 
     2266  } // CanonTags 
    9332267 
    9342268 
  • extensions/AMetaData/JpegMetaData/TagDefinitions/XmpTags.class.php

    r4931 r4972  
    17021702        'schema'       => "xmlns", 
    17031703      ), 
     1704      'aux:Firmware' => Array( 
     1705        'implemented'  => true, 
     1706        'translatable' => false, 
     1707        'type'         => self::TYPE_SIMPLE, 
     1708        'schema'       => "aux", 
     1709      ), 
    17041710      'aux:Lens' => Array( 
    1705         'implemented'  => false, 
     1711        'implemented'  => true, 
    17061712        'translatable' => false, 
    17071713        'type'         => self::TYPE_SIMPLE, 
    17081714        'schema'       => "aux", 
    17091715      ), 
     1716      'aux:LensID' => Array( 
     1717        'implemented'  => false, 
     1718        'translatable' => false, 
     1719        'type'         => self::TYPE_SIMPLE, 
     1720        'schema'       => "aux", 
     1721      ), 
     1722      'aux:LensInfo' => Array( 
     1723        'implemented'  => false, 
     1724        'translatable' => false, 
     1725        'type'         => self::TYPE_SIMPLE, 
     1726        'schema'       => "aux", 
     1727      ), 
    17101728      'aux:SerialNumber' => Array( 
    1711         'implemented'  => false, 
     1729        'implemented'  => true, 
    17121730        'translatable' => false, 
    17131731        'type'         => self::TYPE_SIMPLE, 
     
    18611879        'schema'       => "Iptc4xmpCore", 
    18621880      ), 
     1881 
     1882      /* 
     1883       * Note Schema 
     1884       */ 
     1885      'xmlns:xmpNote' => Array( 
     1886        'implemented'  => false, 
     1887        'translatable' => false, 
     1888        'type'         => self::TYPE_SIMPLE, 
     1889        'schema'       => "xmlns", 
     1890      ), 
     1891 
     1892      'xmpNote:HasExtendedXMP' => Array( 
     1893        'implemented'  => false, 
     1894        'translatable' => false, 
     1895        'type'         => self::TYPE_SIMPLE, 
     1896        'schema'       => "xmpNote", 
     1897      ), 
     1898 
    18631899    ); 
    18641900 
Note: See TracChangeset for help on using the changeset viewer.