Source for file PelEntryUndefined.php

Documentation is available at PelEntryUndefined.php

  1. <?php
  2.  
  3. /*  PEL: PHP Exif Library.  A library with support for reading and
  4.  *  writing all Exif headers in JPEG and TIFF images using PHP.
  5.  *
  6.  *  Copyright (C) 2004, 2005  Martin Geisler.
  7.  *
  8.  *  This program is free software; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License as published by
  10.  *  the Free Software Foundation; either version 2 of the License, or
  11.  *  (at your option) any later version.
  12.  *
  13.  *  This program is distributed in the hope that it will be useful,
  14.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *  GNU General Public License for more details.
  17.  *
  18.  *  You should have received a copy of the GNU General Public License
  19.  *  along with this program in the file COPYING; if not, write to the
  20.  *  Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  21.  *  Boston, MA 02110-1301 USA
  22.  */
  23.  
  24. /* $Id$ */
  25.  
  26.  
  27. /**
  28.  * Classes used to hold data for Exif tags of format undefined.
  29.  *
  30.  * This file contains the base class {@link PelEntryUndefined} and
  31.  * the subclasses {@link PelEntryUserComment} which should be used
  32.  * to manage the {@link PelTag::USER_COMMENT} tag, and {@link }
  33.  * PelEntryVersion} which is used to manage entries with version
  34.  * information.
  35.  *
  36.  * @author Martin Geisler <mgeisler@users.sourceforge.net>
  37.  * @version $Revision$
  38.  * @date $Date$
  39.  * @license http://www.gnu.org/licenses/gpl.html GNU General Public
  40.  *  License (GPL)
  41.  * @package PEL
  42.  */
  43.  
  44. /**#@+ Required class definitions. */
  45. require_once('PelEntry.php');
  46. /**#@-*/
  47.  
  48.  
  49. /**
  50.  * Class for holding data of any kind.
  51.  *
  52.  * This class can hold bytes of undefined format.
  53.  *
  54.  * @author Martin Geisler <mgeisler@users.sourceforge.net>
  55.  * @package PEL
  56.  */
  57. class PelEntryUndefined extends PelEntry {
  58.  
  59.   /**
  60.    * Make a new PelEntry that can hold undefined data.
  61.    *
  62.    * @param PelTag the tag which this entry represents.  This
  63.    *  should be one of the constants defined in {@link PelTag},
  64.    *  e.g., {@link PelTag::SCENE_TYPE}, {@link }
  65.    *  PelTag::MAKER_NOTE} or any other tag with format {@link }
  66.    *  PelFormat::UNDEFINED}.
  67.    *
  68.    * @param string the data that this entry will be holding.  Since
  69.    *  the format is undefined, no checking will be done on the data.
  70.    */
  71.   function __construct($tag, $data = '') {
  72.     $this->tag        = $tag;
  73.     $this->format     = PelFormat::UNDEFINED;
  74.     $this->setValue($data);
  75.   }
  76.  
  77.  
  78.   /**
  79.    * Set the data of this undefined entry.
  80.    *
  81.    * @param string the data that this entry will be holding.  Since
  82.    *  the format is undefined, no checking will be done on the data.
  83.    */
  84.   function setValue($data) {
  85.     $this->components = strlen($data);
  86.     $this->bytes      = $data;
  87.   }
  88.  
  89.  
  90.   /**
  91.    * Get the data of this undefined entry.
  92.    *
  93.    * @return string the data that this entry is holding.
  94.    */
  95.   function getValue() {
  96.     return $this->bytes;
  97.   }
  98.  
  99.  
  100.   /**
  101.    * Get the value of this entry as text.
  102.    *
  103.    * The value will be returned in a format suitable for presentation.
  104.    *
  105.    * @param boolean some values can be returned in a long or more
  106.    *  brief form, and this parameter controls that.
  107.    *
  108.    * @return string the value as text.
  109.    */
  110.   function getText($brief = false) {
  111.     switch ($this->tag) {
  112.     case PelTag::FILE_SOURCE:
  113.       //CC (e->components, 1, v);
  114.       switch (ord($this->bytes{0})) {
  115.       case 0x03:
  116.         return 'DSC';
  117.       default:
  118.         return sprintf('0x%02X', ord($this->bytes{0}));
  119.       }
  120.    
  121.     case PelTag::SCENE_TYPE:
  122.       //CC (e->components, 1, v);
  123.       switch (ord($this->bytes{0})) {
  124.       case 0x01:
  125.         return 'Directly photographed';
  126.       default:
  127.         return sprintf('0x%02X', ord($this->bytes{0}));
  128.       }
  129.    
  130.     case PelTag::COMPONENTS_CONFIGURATION:
  131.       //CC (e->components, 4, v);
  132.       $v = '';
  133.       for ($i = 0; $i < 4; $i++) {
  134.         switch (ord($this->bytes{$i})) {
  135.         case 0:
  136.           $v .= '-';
  137.           break;
  138.         case 1:
  139.           $v .= 'Y';
  140.           break;
  141.         case 2:
  142.           $v .= 'Cb';
  143.           break;
  144.         case 3:
  145.           $v .= 'Cr';
  146.           break;
  147.         case 4:
  148.           $v .= 'R';
  149.           break;
  150.         case 5:
  151.           $v .= 'G';
  152.           break;
  153.         case 6:
  154.           $v .= 'B';
  155.           break;
  156.         default:
  157.           $v .= 'reserved';
  158.           break;
  159.         }
  160.         if ($i < 3) $v .= ' ';
  161.       }
  162.       return $v;
  163.  
  164.     case PelTag::MAKER_NOTE:
  165.       // TODO: handle maker notes.
  166.       return $this->components . ' bytes unknown MakerNote data';
  167.  
  168.     default:
  169.       return '(undefined)';
  170.     }
  171.   }
  172.  
  173. }
  174.  
  175.  
  176. /**
  177.  * Class for a user comment.
  178.  *
  179.  * This class is used to hold user comments, which can come in several
  180.  * different character encodings.  The Exif standard specifies a
  181.  * certain format of the {@link PelTag::USER_COMMENT user comment}
  182.  * tag}, and this class will make sure that the format is kept.
  183.  *
  184.  * The most basic use of this class simply stores an ASCII encoded
  185.  * string for later retrieval using {@link getValue}:
  186.  *
  187.  * <code>
  188.  * $entry = new PelEntryUserComment('An ASCII string');
  189.  * echo $entry->getValue();
  190.  * </code>
  191.  *
  192.  * The string can be encoded with a different encoding, and if so, the
  193.  * encoding must be given using the second argument.  The Exif
  194.  * standard specifies three known encodings: 'ASCII', 'JIS', and
  195.  * 'Unicode'.  If the user comment is encoded using a character
  196.  * encoding different from the tree known encodings, then the empty
  197.  * string should be passed as encoding, thereby specifying that the
  198.  * encoding is undefined.
  199.  *
  200.  * @author Martin Geisler <mgeisler@users.sourceforge.net>
  201.  * @package PEL
  202.  */
  203. class PelEntryUserComment extends PelEntryUndefined {
  204.  
  205.   /**
  206.    * The user comment.
  207.    *
  208.    * @var string 
  209.    */
  210.   private $comment;
  211.  
  212.   /**
  213.    * The encoding.
  214.    *
  215.    * This should be one of 'ASCII', 'JIS', 'Unicode', or ''.
  216.    *
  217.    * @var string 
  218.    */
  219.   private $encoding;
  220.  
  221.   /**
  222.    * Make a new entry for holding a user comment.
  223.    *
  224.    * @param string the new user comment.
  225.    *
  226.    * @param string the encoding of the comment.  This should be either
  227.    *  'ASCII', 'JIS', 'Unicode', or the empty string specifying an
  228.    *  undefined encoding.
  229.    */
  230.   function __construct($comment = '', $encoding = 'ASCII') {
  231.     parent::__construct(PelTag::USER_COMMENT);
  232.     $this->setValue($comment, $encoding);
  233.   }
  234.  
  235.   
  236.   /**
  237.    * Set the user comment.
  238.    *
  239.    * @param string the new user comment.
  240.    *
  241.    * @param string the encoding of the comment.  This should be either
  242.    *  'ASCII', 'JIS', 'Unicode', or the empty string specifying an
  243.    *  unknown encoding.
  244.    */
  245.   function setValue($comment = '', $encoding = 'ASCII') {
  246.     $this->comment  = $comment;
  247.     $this->encoding = $encoding;
  248.     parent::setValue(str_pad($encoding, 8, chr(0)) . $comment);
  249.   }
  250.  
  251.  
  252.   /**
  253.    * Returns the user comment.
  254.    *
  255.    * The comment is returned with the same character encoding as when
  256.    * it was set using {@link setValue} or {@link __construct the}
  257.    * constructor}.
  258.    *
  259.    * @return string the user comment.
  260.    */
  261.   function getValue() {
  262.     return $this->comment;
  263.   }
  264.  
  265.  
  266.   /**
  267.    * Returns the encoding.
  268.    *
  269.    * @return string the encoding of the user comment.
  270.    */
  271.   function getEncoding() {
  272.     return $this->encoding;
  273.   }
  274.  
  275.  
  276.   /**
  277.    * Returns the user comment.
  278.    *
  279.    * @return string the user comment.
  280.    */
  281.   function getText($brief = false) {
  282.     return $this->comment;
  283.   }
  284.  
  285. }
  286.  
  287.  
  288. /**
  289.  * Class to hold version information.
  290.  *
  291.  * There are three Exif entries that hold version information: the
  292.  * {@link PelTag::EXIF_VERSION}, {@link }
  293.  * PelTag::FLASH_PIX_VERSION}, and {@link }
  294.  * PelTag::INTEROPERABILITY_VERSION} tags.  This class manages
  295.  * those tags.
  296.  *
  297.  * The class is used in a very straight-forward way:
  298.  * <code>
  299.  * $entry = new PelEntryVersion(PelTag::EXIF_VERSION, 2.2);
  300.  * </code>
  301.  * This creates an entry for an file complying to the Exif 2.2
  302.  * standard.  It is easy to test for standards level of an unknown
  303.  * entry:
  304.  * <code>
  305.  * if ($entry->getTag() == PelTag::EXIF_VERSION &&
  306.  *     $entry->getValue() > 2.0) {
  307.  *   echo 'Recent Exif version.';
  308.  * }
  309.  * </code>
  310.  *
  311.  * @author Martin Geisler <mgeisler@users.sourceforge.net>
  312.  * @package PEL
  313.  */
  314. class PelEntryVersion extends PelEntryUndefined {
  315.  
  316.   /**
  317.    * The version held by this entry.
  318.    *
  319.    * @var float 
  320.    */
  321.   private $version;
  322.  
  323.  
  324.   /**
  325.    * Make a new entry for holding a version.
  326.    *
  327.    * @param PelTag the tag.  This should be one of {@link }
  328.    *  PelTag::EXIF_VERSION}, {@link PelTag::FLASH_PIX_VERSION},
  329.    *  or {@link PelTag::INTEROPERABILITY_VERSION}.
  330.    *
  331.    * @param float the version.  The size of the entries leave room for
  332.    *  exactly four digits: two digits on either side of the decimal
  333.    *  point.
  334.    */
  335.   function __construct($tag, $version = 0.0) {
  336.     parent::__construct($tag);
  337.     $this->setValue($version);
  338.   }
  339.  
  340.  
  341.   /**
  342.    * Set the version held by this entry.
  343.    *
  344.    * @param float the version.  The size of the entries leave room for
  345.    *  exactly four digits: two digits on either side of the decimal
  346.    *  point.
  347.    */
  348.   function setValue($version = 0.0) {
  349.     $this->version = $version;
  350.     $major = floor($version);
  351.     $minor = ($version - $major)*100;
  352.     parent::setValue(sprintf('%02.0f%02.0f', $major, $minor));
  353.   }
  354.  
  355.  
  356.   /**
  357.    * Return the version held by this entry.
  358.    *
  359.    * @return float the version.  This will be the same as the value
  360.    *  given to {@link setValue} or {@link __construct the}
  361.    *  constructor}.
  362.    */
  363.   function getValue() {
  364.     return $this->version;
  365.   }
  366.  
  367.  
  368.   /**
  369.    * Return a text string with the version.
  370.    *
  371.    * @param boolean controls if the output should be brief.  Brief
  372.    *  output omits the word 'Version' so the result is just 'Exif x.y'
  373.    *  instead of 'Exif Version x.y' if the entry holds information
  374.    *  about the Exif version --- the output for FlashPix is similar.
  375.    *
  376.    * @return string the version number with the type of the tag,
  377.    *  either 'Exif' or 'FlashPix'.
  378.    */
  379.   function getText($brief = false) {
  380.     $v = $this->version;
  381.  
  382.     /* Versions numbers like 2.0 would be output as just 2 if we don't
  383.      * add the '.0' ourselves. */
  384.     if (floor($this->version) == $this->version)
  385.       $v .= '.0';
  386.  
  387.     switch ($this->tag) {
  388.     case PelTag::EXIF_VERSION:
  389.       if ($brief)
  390.         return Pel::fmt('Exif %s', $v);
  391.       else
  392.         return Pel::fmt('Exif Version %s', $v);
  393.       
  394.     case PelTag::FLASH_PIX_VERSION:
  395.       if ($brief)
  396.         return Pel::fmt('FlashPix %s', $v);
  397.       else
  398.         return Pel::fmt('FlashPix Version %s', $v);
  399.       
  400.     case PelTag::INTEROPERABILITY_VERSION:
  401.       if ($brief)
  402.         return Pel::fmt('Interoperability %s', $v);
  403.       else
  404.         return Pel::fmt('Interoperability Version %s', $v);
  405.     }
  406.  
  407.     if ($brief)
  408.       return $v;
  409.     else
  410.       return Pel::fmt('Version %s', $v);
  411.     
  412.   }
  413.  
  414. }
  415.  
  416. ?>

Documentation generated on Thu, 05 May 2011 07:19:10 +0200 by phpDocumentor 1.4.3