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

Documentation generated on Tue, 19 Dec 2006 01:08:23 +0100 by phpDocumentor 1.3.0 SourceForge.net Logo