PageRenderTime 41ms CodeModel.GetById 13ms RepoModel.GetById 1ms app.codeStats 0ms

/add-ons/pjmt/Photoshop_File_Info.php

https://github.com/jcplat/console-seolan
PHP | 2498 lines | 1215 code | 514 blank | 769 comment | 221 complexity | 97e084ed80b56ce2e576afed3824bafe MD5 | raw file
Possible License(s): LGPL-2.0, LGPL-2.1, GPL-3.0, Apache-2.0, BSD-3-Clause 
    

  1. <?php

    2. 

  2. 

    3. 

  3. /******************************************************************************

    4. 

  4. *

    5. 

  5. * Filename:     Photoshop_File_Info.php

    6. 

  6. *

    7. 

  7. * Description:  Provides functions that mimic the way Photoshop reads and writes

    8. 

  8. *               metadata in it's 'File Info' dialog

    9. 

  9. *

    10. 

  10. * Author:       Evan Hunter

    11. 

  11. *

    12. 

  12. * Date:         11/11/2004

    13. 

  13. *

    14. 

  14. * Project:      JPEG Metadata

    15. 

  15. *

    16. 

  16. * Revision:     1.11

    17. 

  17. * Changes:      1.10 -> 1.11 : Changed displayed toolkit version numbers to reference Toolkit_Version.php

    18. 

  18. *

    19. 

  19. * URL:          http://electronics.ozhiker.com

    20. 

  20. *

    21. 

  21. * License:      This file is part of the PHP JPEG Metadata Toolkit.

    22. 

  22. *

    23. 

  23. *               The PHP JPEG Metadata Toolkit is free software; you can

    24. 

  24. *               redistribute it and/or modify it under the terms of the

    25. 

  25. *               GNU General Public License as published by the Free Software

    26. 

  26. *               Foundation; either version 2 of the License, or (at your

    27. 

  27. *               option) any later version.

    28. 

  28. *

    29. 

  29. *               The PHP JPEG Metadata Toolkit is distributed in the hope

    30. 

  30. *               that it will be useful, but WITHOUT ANY WARRANTY; without

    31. 

  31. *               even the implied warranty of MERCHANTABILITY or FITNESS

    32. 

  32. *               FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    33. 

  33. *               for more details.

    34. 

  34. *

    35. 

  35. *               You should have received a copy of the GNU General Public

    36. 

  36. *               License along with the PHP JPEG Metadata Toolkit; if not,

    37. 

  37. *               write to the Free Software Foundation, Inc., 59 Temple

    38. 

  38. *               Place, Suite 330, Boston, MA  02111-1307  USA

    39. 

  39. *

    40. 

  40. *               If you require a different license for commercial or other

    41. 

  41. *               purposes, please contact the author: evan@ozhiker.com

    42. 

  42. *

    43. 

  43. ******************************************************************************/

    44. 

  44. 

    45. 

  45. // TODO: XMP sections: XAPMM, TIFF, EXIF

    46. 

  46. 

    47. 

  47. 

    48. 

  48. include 'Toolkit_Version.php';          // Change: added as of version 1.11

    49. 

  49. 

    50. 

  50. 

    51. 

  51. /******************************************************************************

    52. 

  52. * Global Variable:      Software Name

    53. 

  53. *

    54. 

  54. * Contents:     The string that is appended to fields which store the name of

    55. 

  55. *               the software editor.

    56. 

  56. *

    57. 

  57. ******************************************************************************/

    58. 

  58. 

    59. 

  59. $GLOBALS[ "Software Name" ] = "(PHP JPEG Metadata Toolkit v" . $GLOBALS['Toolkit_Version'] . ")";          // Change:  Changed version numbers to reference Toolkit_Version.php - as of version 1.11

    60. 

  60. 

    61. 

  61. /******************************************************************************

    62. 

  62. * End of Global Variable:     Software Name

    63. 

  63. ******************************************************************************/

    64. 

  64. 

    65. 

  65. 

    66. 

  66. 

    67. 

  67. 

    68. 

  68. 

    69. 

  69. 

    70. 

  70. /******************************************************************************

    71. 

  71. *

    72. 

  72. * Function:     get_photoshop_file_info

    73. 

  73. *

    74. 

  74. * Description:  Retrieves Photoshop 'File Info' metadata in the same way that Photoshop

    75. 

  75. *               does. The results are returned in an array as below:

    76. 

  76. *

    77. 

  77. *               $file_info_array = array(

    78. 

  78. *                       "title"                  => "",

    79. 

  79. *                       "author"                 => "",

    80. 

  80. *                       "authorsposition"        => "",      // Note: Not used in Photoshop 7 or higher

    81. 

  81. *                       "caption"                => "",

    82. 

  82. *                       "captionwriter"          => "",

    83. 

  83. *                       "jobname"                => "",      // Note: Not used in Photoshop CS

    84. 

  84. *                       "copyrightstatus"        => "",

    85. 

  85. *                       "copyrightnotice"        => "",

    86. 

  86. *                       "ownerurl"               => "",

    87. 

  87. *                       "keywords"               => array( 0 => "", 1 => "", ... ),

    88. 

  88. *                       "category"               => "",     // Note: Max 3 characters

    89. 

  89. *                       "supplementalcategories" => array( 0 => "", 1 => "", ... ),

    90. 

  90. *                       "date"                   => "",     // Note: DATE MUST BE IN YYYY-MM-DD format

    91. 

  91. *                       "city"                   => "",

    92. 

  92. *                       "state"                  => "",

    93. 

  93. *                       "country"                => "",

    94. 

  94. *                       "credit"                 => "",

    95. 

  95. *                       "source"                 => "",

    96. 

  96. *                       "headline"               => "",

    97. 

  97. *                       "instructions"           => "",

    98. 

  98. *                       "transmissionreference"  => "",

    99. 

  99. *                       "urgency"                => "" );

    100. 

  100. *

    101. 

  101. * Parameters:   Exif_array - an array containing the EXIF information to be

    102. 

  102. *                            searched, as retrieved by get_EXIF_JPEG. (saves having to parse the EXIF again)

    103. 

  103. *               XMP_array - an array containing the XMP information to be

    104. 

  104. *                           searched, as retrieved by read_XMP_array_from_text. (saves having to parse the XMP again)

    105. 

  105. *               IRB_array - an array containing the Photoshop IRB information

    106. 

  106. *                           to be searched, as retrieved by get_Photoshop_IRB. (saves having to parse the IRB again)

    107. 

  107. *

    108. 

  108. * Returns:      outputarray - an array as above, containing the Photoshop File Info data

    109. 

  109. *

    110. 

  110. ******************************************************************************/

    111. 

  111. 

    112. 

  112. function get_photoshop_file_info( $Exif_array, $XMP_array, $IRB_array )

    113. 

  113. {

    114. 

  114. 

    115. 

  115.         // Create a blank array to receive the output

    116. 

  116.         $outputarray = array(

    117. 

  117.                 "title" => "",

    118. 

  118.                 "author" => "",

    119. 

  119.                 "authorsposition" => "",

    120. 

  120.                 "caption" => "",

    121. 

  121.                 "captionwriter" => "",

    122. 

  122.                 "jobname" => "",

    123. 

  123.                 "copyrightstatus" => "",

    124. 

  124.                 "copyrightnotice" => "",

    125. 

  125.                 "ownerurl" => "",

    126. 

  126.                 "keywords" => array(),

    127. 

  127.                 "category" => "",

    128. 

  128.                 "supplementalcategories" => array(),

    129. 

  129.                 "date" => "",

    130. 

  130.                 "city" => "",

    131. 

  131.                 "state" => "",

    132. 

  132.                 "country" => "",

    133. 

  133.                 "credit" => "",

    134. 

  134.                 "source" => "",

    135. 

  135.                 "headline" => "",

    136. 

  136.                 "instructions" => "",

    137. 

  137.                 "transmissionreference" => "",

    138. 

  138.                 "urgency" => "" );

    139. 

  139. 

    140. 

  140. 

    141. 

  141.         /***************************************/

    142. 

  142. 

    143. 

  143.         // XMP Processing

    144. 

  144. 

    145. 

  145. 

    146. 

  146.         // Retrieve the dublin core section from the XMP header

    147. 

  147. 

    148. 

  148.         // Extract the Dublin Core section from the XMP

    149. 

  149.         $dublincore_block = find_XMP_block( $XMP_array, "dc" );

    150. 

  150. 

    151. 

  151.         // Check that the Dublin Core section exists

    152. 

  152.         if ( $dublincore_block != FALSE )

    153. 

  153.         {

    154. 

  154.                 // Dublin Core Description Field contains caption

    155. 

  155.                 // Extract Description

    156. 

  156.                 $Item = find_XMP_item( $dublincore_block, "dc:description" );

    157. 

  157. 

    158. 

  158.                 // Check if Description Tag existed

    159. 

  159.                 if ( $Item != FALSE )

    160. 

  160.                 {

    161. 

  161.                         // Ensure that the Description value exists and save it.

    162. 

  162.                         if  ( ( array_key_exists( 'children', $Item ) ) &&

    163. 

  163.                               ( $Item['children'][0]['tag'] == "rdf:Alt" ) &&

    164. 

  164.                               ( array_key_exists( 'value', $Item['children'][0]['children'][0] ) ) )

    165. 

  165.                         {

    166. 

  166.                                 $outputarray = add_to_field( $outputarray, 'caption' , HTML_UTF8_Escape( $Item['children'][0]['children'][0]['value'] ), "\n" );

    167. 

  167.                         }

    168. 

  168.                 }

    169. 

  169. 

    170. 

  170.                 /***************************************/

    171. 

  171. 

    172. 

  172.                 // Dublin Core Creator Field contains author

    173. 

  173.                 // Extract Description

    174. 

  174.                 $Item = find_XMP_item( $dublincore_block, "dc:creator" );

    175. 

  175. 

    176. 

  176.                 // Check if Creator Tag existed

    177. 

  177.                 if ( $Item != FALSE )

    178. 

  178.                 {

    179. 

  179.                         // Ensure that the Creator value exists and save it.

    180. 

  180.                         if  ( ( array_key_exists( 'children', $Item ) ) &&

    181. 

  181.                               ( $Item['children'][0]['tag'] =="rdf:Seq" ) &&

    182. 

  182.                               ( array_key_exists( 'value', $Item['children'][0]['children'][0] ) ) )

    183. 

  183.                         {

    184. 

  184.                                 $outputarray = add_to_field( $outputarray, 'author' , HTML_UTF8_Escape( $Item['children'][0]['children'][0]['value'] ), "\n" );

    185. 

  185.                         }

    186. 

  186.                 }

    187. 

  187. 

    188. 

  188.                 /***************************************/

    189. 

  189. 

    190. 

  190.                 // Dublin Core Title Field contains title

    191. 

  191.                 // Extract Title

    192. 

  192.                 $Item = find_XMP_item( $dublincore_block, "dc:title" );

    193. 

  193. 

    194. 

  194.                 // Check if Title Tag existed

    195. 

  195.                 if ( $Item != FALSE )

    196. 

  196.                 {

    197. 

  197.                         // Ensure that the Title value exists and save it.

    198. 

  198.                         if  ( ( array_key_exists( 'children', $Item ) ) &&

    199. 

  199.                               ( $Item['children'][0]['tag'] =="rdf:Alt" ) &&

    200. 

  200.                               ( array_key_exists( 'value', $Item['children'][0]['children'][0] ) ) )

    201. 

  201.                         {

    202. 

  202. 

    203. 

  203.                                 $outputarray = add_to_field( $outputarray, 'title' , HTML_UTF8_Escape( $Item['children'][0]['children'][0]['value'] ), "," );

    204. 

  204.                         }

    205. 

  205.                 }

    206. 

  206. 

    207. 

  207.                 /***************************************/

    208. 

  208. 

    209. 

  209.                 // Dublin Core Rights Field contains copyrightnotice

    210. 

  210.                 // Extract Rights

    211. 

  211.                 $Item = find_XMP_item( $dublincore_block, "dc:rights" );

    212. 

  212. 

    213. 

  213.                 // Check if Rights Tag existed

    214. 

  214.                 if ( $Item != FALSE )

    215. 

  215.                 {

    216. 

  216.                         // Ensure that the Rights value exists and save it.

    217. 

  217.                         if  ( ( array_key_exists( 'children', $Item ) ) &&

    218. 

  218.                               ( $Item['children'][0]['tag'] =="rdf:Alt" ) &&

    219. 

  219.                               ( array_key_exists( 'value', $Item['children'][0]['children'][0] ) ) )

    220. 

  220.                         {

    221. 

  221. 

    222. 

  222.                                 $outputarray = add_to_field( $outputarray, 'copyrightnotice' , HTML_UTF8_Escape( $Item['children'][0]['children'][0]['value'] ), "," );

    223. 

  223.                         }

    224. 

  224.                 }

    225. 

  225. 

    226. 

  226.                 /***************************************/

    227. 

  227. 

    228. 

  228.                 // Dublin Core Subject Field contains keywords

    229. 

  229.                 // Extract Subject

    230. 

  230.                 $Item = find_XMP_item( $dublincore_block, "dc:subject" );

    231. 

  231. 

    232. 

  232.                 // Check if Subject Tag existed

    233. 

  233.                 if ( $Item != FALSE )

    234. 

  234.                 {

    235. 

  235.                         // Ensure that the Subject values exist

    236. 

  236.                         if  ( ( array_key_exists( 'children', $Item ) ) && ( $Item['children'][0]['tag'] =="rdf:Bag" ) )

    237. 

  237.                         {

    238. 

  238.                                 // Cycle through each Subject value and save them

    239. 

  239.                                 foreach ( $Item['children'][0]['children'] as $keywords )

    240. 

  240.                                 {

    241. 

  241.                                         if ( ! in_array ( HTML_UTF8_Escape( $keywords['value'] ), $outputarray['keywords']))

    242. 

  242.                                         {

    243. 

  243.                                                 if  ( array_key_exists( 'value', $keywords ) )

    244. 

  244.                                                 {

    245. 

  245.                                                         $outputarray['keywords'][] = HTML_UTF8_Escape( $keywords['value'] );

    246. 

  246.                                                 }

    247. 

  247.                                         }

    248. 

  248.                                 }

    249. 

  249.                         }

    250. 

  250.                 }

    251. 

  251. 

    252. 

  252. 

    253. 

  253.         }

    254. 

  254. 

    255. 

  255.         /***************************************/

    256. 

  256. 

    257. 

  257.         // Find the Photoshop Information within the XMP block

    258. 

  258.         $photoshop_block = find_XMP_block( $XMP_array, "photoshop" );

    259. 

  259. 

    260. 

  260.         // Check that the Photoshop Information exists

    261. 

  261.         if ( $photoshop_block != FALSE )

    262. 

  262.         {

    263. 

  263.                 // The Photoshop CaptionWriter tag contains captionwriter - Find it

    264. 

  264.                 $Item = find_XMP_item( $photoshop_block, "photoshop:CaptionWriter" );

    265. 

  265. 

    266. 

  266.                 // Check that the CaptionWriter Field exists and save the value

    267. 

  267.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    268. 

  268.                 {

    269. 

  269.                         $outputarray = add_to_field( $outputarray, 'captionwriter' , HTML_UTF8_Escape( $Item['value'] ), "," );

    270. 

  270.                 }

    271. 

  271. 

    272. 

  272.                 /***************************************/

    273. 

  273. 

    274. 

  274.                 // The Photoshop Headline tag contains headline - Find it

    275. 

  275.                 $Item = find_XMP_item( $photoshop_block, "photoshop:Headline" );

    276. 

  276. 

    277. 

  277.                 // Check that the Headline Field exists and save the value

    278. 

  278.                 if ( ( $Item != FALSE )  && ( array_key_exists( 'value', $Item ) ) )

    279. 

  279.                 {

    280. 

  280.                         $outputarray = add_to_field( $outputarray, 'headline' , HTML_UTF8_Escape( $Item['value'] ), "," );

    281. 

  281.                 }

    282. 

  282. 

    283. 

  283.                 /***************************************/

    284. 

  284. 

    285. 

  285.                 // The Photoshop Instructions tag contains instructions - Find it

    286. 

  286.                 $Item = find_XMP_item( $photoshop_block, "photoshop:Instructions" );

    287. 

  287. 

    288. 

  288.                 // Check that the Instructions Field exists and save the value

    289. 

  289.                 if ( ( $Item != FALSE )  && ( array_key_exists( 'value', $Item ) ) )

    290. 

  290.                 {

    291. 

  291.                         $outputarray = add_to_field( $outputarray, 'instructions' , HTML_UTF8_Escape( $Item['value'] ), "\n" );

    292. 

  292.                 }

    293. 

  293. 

    294. 

  294.                 /***************************************/

    295. 

  295. 

    296. 

  296.                 // The Photoshop AuthorsPosition tag contains authorsposition - Find it

    297. 

  297.                 $Item = find_XMP_item( $photoshop_block, "photoshop:AuthorsPosition" );

    298. 

  298. 

    299. 

  299.                 // Check that the AuthorsPosition Field exists and save the value

    300. 

  300.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    301. 

  301.                 {

    302. 

  302.                         $outputarray = add_to_field( $outputarray, 'authorsposition' , HTML_UTF8_Escape( $Item['value'] ), "," );

    303. 

  303.                 }

    304. 

  304. 

    305. 

  305.                 /***************************************/

    306. 

  306. 

    307. 

  307.                 // The Photoshop Credit tag contains credit - Find it

    308. 

  308.                 $Item = find_XMP_item( $photoshop_block, "photoshop:Credit" );

    309. 

  309. 

    310. 

  310.                 // Check that the Credit Field exists and save the value

    311. 

  311.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    312. 

  312.                 {

    313. 

  313.                         $outputarray = add_to_field( $outputarray, 'credit' , HTML_UTF8_Escape( $Item['value'] ), "," );

    314. 

  314.                 }

    315. 

  315. 

    316. 

  316.                 /***************************************/

    317. 

  317. 

    318. 

  318.                 // The Photoshop Source tag contains source - Find it

    319. 

  319.                 $Item = find_XMP_item( $photoshop_block, "photoshop:Source" );

    320. 

  320. 

    321. 

  321.                 // Check that the Credit Field exists and save the value

    322. 

  322.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    323. 

  323.                 {

    324. 

  324.                         $outputarray = add_to_field( $outputarray, 'source' , HTML_UTF8_Escape( $Item['value'] ), "," );

    325. 

  325.                 }

    326. 

  326. 

    327. 

  327.                 /***************************************/

    328. 

  328. 

    329. 

  329.                 // The Photoshop City tag contains city - Find it

    330. 

  330.                 $Item = find_XMP_item( $photoshop_block, "photoshop:City" );

    331. 

  331. 

    332. 

  332.                 // Check that the City Field exists and save the value

    333. 

  333.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    334. 

  334.                 {

    335. 

  335.                         $outputarray = add_to_field( $outputarray, 'city' , HTML_UTF8_Escape( $Item['value'] ), "," );

    336. 

  336.                 }

    337. 

  337. 

    338. 

  338.                 /***************************************/

    339. 

  339. 

    340. 

  340.                 // The Photoshop State tag contains state - Find it

    341. 

  341.                 $Item = find_XMP_item( $photoshop_block, "photoshop:State" );

    342. 

  342. 

    343. 

  343.                 // Check that the State Field exists and save the value

    344. 

  344.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    345. 

  345.                 {

    346. 

  346.                         $outputarray = add_to_field( $outputarray, 'state' , HTML_UTF8_Escape( $Item['value'] ), "," );

    347. 

  347.                 }

    348. 

  348. 

    349. 

  349.                 /***************************************/

    350. 

  350. 

    351. 

  351.                 // The Photoshop Country tag contains country - Find it

    352. 

  352.                 $Item = find_XMP_item( $photoshop_block, "photoshop:Country" );

    353. 

  353. 

    354. 

  354.                 // Check that the Country Field exists and save the value

    355. 

  355.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    356. 

  356.                 {

    357. 

  357.                         $outputarray = add_to_field( $outputarray, 'country' , HTML_UTF8_Escape( $Item['value'] ), "," );

    358. 

  358.                 }

    359. 

  359. 

    360. 

  360.                 /***************************************/

    361. 

  361. 

    362. 

  362.                 // The Photoshop TransmissionReference tag contains transmissionreference - Find it

    363. 

  363.                 $Item = find_XMP_item( $photoshop_block, "photoshop:TransmissionReference" );

    364. 

  364. 

    365. 

  365.                 // Check that the TransmissionReference Field exists and save the value

    366. 

  366.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    367. 

  367.                 {

    368. 

  368.                         $outputarray = add_to_field( $outputarray, 'transmissionreference' , HTML_UTF8_Escape( $Item['value'] ), "," );

    369. 

  369.                 }

    370. 

  370. 

    371. 

  371.                 /***************************************/

    372. 

  372. 

    373. 

  373.                 // The Photoshop Category tag contains category - Find it

    374. 

  374.                 $Item = find_XMP_item( $photoshop_block, "photoshop:Category" );

    375. 

  375. 

    376. 

  376.                 // Check that the TransmissionReference Field exists and save the value

    377. 

  377.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    378. 

  378.                 {

    379. 

  379.                         $outputarray = add_to_field( $outputarray, 'category' , HTML_UTF8_Escape( $Item['value'] ), "," );

    380. 

  380.                 }

    381. 

  381. 

    382. 

  382.                 /***************************************/

    383. 

  383. 

    384. 

  384.                 // The Photoshop DateCreated tag contains date - Find it

    385. 

  385.                 $Item = find_XMP_item( $photoshop_block, "photoshop:DateCreated" );

    386. 

  386. 

    387. 

  387.                 // Check that the DateCreated Field exists and save the value

    388. 

  388.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    389. 

  389.                 {

    390. 

  390.                         $outputarray = add_to_field( $outputarray, 'date' , HTML_UTF8_Escape( $Item['value'] ), "," );

    391. 

  391.                 }

    392. 

  392. 

    393. 

  393.                 /***************************************/

    394. 

  394. 

    395. 

  395.                 // The Photoshop Urgency tag contains urgency - Find it

    396. 

  396.                 $Item = find_XMP_item( $photoshop_block, "photoshop:Urgency" );

    397. 

  397. 

    398. 

  398.                 // Check that the Urgency Field exists and save the value

    399. 

  399.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    400. 

  400.                 {

    401. 

  401.                         $outputarray = add_to_field( $outputarray, 'urgency' , HTML_UTF8_Escape( $Item['value'] ), "," );

    402. 

  402.                 }

    403. 

  403. 

    404. 

  404.                 /***************************************/

    405. 

  405. 

    406. 

  406.                 // The Photoshop SupplementalCategories tag contains supplementalcategories - Find it

    407. 

  407.                 $Item = find_XMP_item( $photoshop_block, "photoshop:SupplementalCategories" );

    408. 

  408. 

    409. 

  409.                 // Check that the SupplementalCategories Field exists

    410. 

  410.                 if ( $Item != FALSE )

    411. 

  411.                 {

    412. 

  412.                         // Check that the values exist

    413. 

  413.                         if  ( ( array_key_exists( 'children', $Item ) ) && ( $Item['children'][0]['tag'] =="rdf:Bag" ) )

    414. 

  414.                         {

    415. 

  415.                                 // Cycle through the values and save them

    416. 

  416.                                 foreach ( $Item['children'][0]['children'] as $sup_category )

    417. 

  417.                                 {

    418. 

  418.                                         if ( ( array_key_exists( 'value', $sup_category ) ) &&

    419. 

  419.                                              ( ! in_array ( HTML_UTF8_Escape( $sup_category['value'] ), $outputarray['supplementalcategories'])) )

    420. 

  420.                                         {

    421. 

  421.                                                 if ( array_key_exists( 'value', $sup_category ) )

    422. 

  422.                                                 {

    423. 

  423.                                                         $outputarray['supplementalcategories'][] = HTML_UTF8_Escape( $sup_category['value'] );

    424. 

  424.                                                 }

    425. 

  425.                                         }

    426. 

  426.                                 }

    427. 

  427.                         }

    428. 

  428.                 }

    429. 

  429. 

    430. 

  430.         }

    431. 

  431. 

    432. 

  432.         /***************************************/

    433. 

  433. 

    434. 

  434.         // Find the Job Reference Information within the XMP block

    435. 

  435.         $job_block = find_XMP_block( $XMP_array, "xapBJ" );

    436. 

  436. 

    437. 

  437.         // Check that the Job Reference Information exists

    438. 

  438.         if ( $job_block != FALSE )

    439. 

  439.         {

    440. 

  440.                 // The JobRef Field contains jobname - Find it

    441. 

  441.                 $Item = find_XMP_item( $job_block, "xapBJ:JobRef" );

    442. 

  442. 

    443. 

  443.                 // Check that the JobRef Field exists

    444. 

  444.                 if ( $Item != FALSE )

    445. 

  445.                 {

    446. 

  446.                         // Check that the value exists and save it

    447. 

  447.                         if ( ( array_key_exists( 'children', $Item ) ) &&

    448. 

  448.                              ( $Item['children'][0]['tag'] =="rdf:Bag" ) &&

    449. 

  449.                              ( array_key_exists( 'children', $Item['children'][0] ) ) &&

    450. 

  450.                              ( $Item['children'][0]['children'][0]['tag'] =="rdf:li" ) &&

    451. 

  451.                              ( array_key_exists( 'children', $Item['children'][0]['children'][0] ) ) &&

    452. 

  452.                              ( $Item['children'][0]['children'][0]['children'][0]['tag'] =="stJob:name" ) &&

    453. 

  453.                              ( array_key_exists( 'value', $Item['children'][0]['children'][0]['children'][0] ) ) )

    454. 

  454.                         {

    455. 

  455.                                 $outputarray = add_to_field( $outputarray, 'jobname' , HTML_UTF8_Escape( $Item['children'][0]['children'][0]['children'][0]['value'] ), "," );

    456. 

  456.                         }

    457. 

  457.                 }

    458. 

  458.         }

    459. 

  459. 

    460. 

  460. 

    461. 

  461.         /***************************************/

    462. 

  462. 

    463. 

  463.         // Find the Rights Information within the XMP block

    464. 

  464.         $rights_block = find_XMP_block( $XMP_array, "xapRights" );

    465. 

  465. 

    466. 

  466.         // Check that the Rights Information exists

    467. 

  467.         if ( $rights_block != FALSE )

    468. 

  468.         {

    469. 

  469.                 // The WebStatement Field contains ownerurl - Find it

    470. 

  470.                 $Item = find_XMP_item( $rights_block, "xapRights:WebStatement" );

    471. 

  471. 

    472. 

  472.                 // Check that the WebStatement Field exists and save the value

    473. 

  473.                 if ( ( $Item != FALSE )  && ( array_key_exists( 'value', $Item ) ) )

    474. 

  474.                 {

    475. 

  475.                         $outputarray = add_to_field( $outputarray, 'ownerurl' , HTML_UTF8_Escape( $Item['value'] ), "\n" );

    476. 

  476.                 }

    477. 

  477. 

    478. 

  478.                 /***************************************/

    479. 

  479. 

    480. 

  480.                 // The Marked Field contains copyrightstatus - Find it

    481. 

  481.                 $Item = find_XMP_item( $rights_block, "xapRights:Marked" );

    482. 

  482. 

    483. 

  483.                 // Check that the Marked Field exists and save the value

    484. 

  484.                 if ( ( $Item != FALSE ) && ( array_key_exists( 'value', $Item ) ) )

    485. 

  485.                 {

    486. 

  486.                         if ( $Item['value'] == "True" )

    487. 

  487.                         {

    488. 

  488.                                 $outputarray = add_to_field( $outputarray, 'copyrightstatus' , "Copyrighted Work", "," );

    489. 

  489.                         }

    490. 

  490.                         else

    491. 

  491.                         {

    492. 

  492.                                 $outputarray = add_to_field( $outputarray, 'copyrightstatus' , "Public Domain", "," );

    493. 

  493.                         }

    494. 

  494.                 }

    495. 

  495. 

    496. 

  496.         }

    497. 

  497. 

    498. 

  498. 

    499. 

  499. 

    500. 

  500. 

    501. 

  501. 

    502. 

  502.         /***************************************/

    503. 

  503. 

    504. 

  504.         // Photoshop IRB Processing

    505. 

  505. 

    506. 

  506.         // Check that the Photoshop IRB exists

    507. 

  507.         if ( $IRB_array != FALSE )

    508. 

  508.         {

    509. 

  509.                 // Create a translation table to convert carriage returns to linefeeds

    510. 

  510.                 $irbtrans = array("\x0d" => "\x0a");

    511. 

  511. 

    512. 

  512.                 // The Photoshop IRB Copyright flag (0x040A) contains copyrightstatus - find it

    513. 

  513.                 $IRB_copyright_flag = find_Photoshop_IRB_Resource( $IRB_array, 0x040A );

    514. 

  514. 

    515. 

  515.                 // Check if the Copyright flag Field exists, and save the value

    516. 

  516.                 if( $IRB_copyright_flag != FALSE )

    517. 

  517.                 {

    518. 

  518.                         // Check the value of the copyright flag

    519. 

  519.                         if ( hexdec( bin2hex( $IRB_copyright_flag['ResData'] ) ) == 1 )

    520. 

  520.                         {

    521. 

  521.                                 // Save the value

    522. 

  522.                                 $outputarray = add_to_field( $outputarray, 'copyrightstatus' , "Copyrighted Work", "," );

    523. 

  523.                         }

    524. 

  524.                         else

    525. 

  525.                         {

    526. 

  526.                                 // Do nothing - copyrightstatus will be set to unmarked if still blank at end

    527. 

  527.                         }

    528. 

  528.                 }

    529. 

  529. 

    530. 

  530.                 /***************************************/

    531. 

  531. 

    532. 

  532.                 // The Photoshop IRB URL (0x040B) contains ownerurl - find it

    533. 

  533.                 $IRB_url = find_Photoshop_IRB_Resource( $IRB_array, 0x040B );

    534. 

  534. 

    535. 

  535.                 // Check if the URL Field exists and save the value

    536. 

  536.                 if( $IRB_url != FALSE )

    537. 

  537.                 {

    538. 

  538.                         $outputarray = add_to_field( $outputarray, 'ownerurl' , strtr( $IRB_url['ResData'], $irbtrans ), "\n" );

    539. 

  539.                 }

    540. 

  540. 

    541. 

  541.                 /***************************************/

    542. 

  542. 

    543. 

  543.                 // Extract any IPTC block from the Photoshop IRB information

    544. 

  544.                 $IPTC_array = get_Photoshop_IPTC( $IRB_array );

    545. 

  545. 

    546. 

  546.                 // Check if the IPTC block exits

    547. 

  547.                 if ( ( $IPTC_array != FALSE ) && ( count( $IPTC_array ) != 0 ) )

    548. 

  548.                 {

    549. 

  549.                         // The IPTC Caption/Abstract Field contains caption - find it

    550. 

  550.                         $record = find_IPTC_Resource( $IPTC_array, "2:120" );

    551. 

  551. 

    552. 

  552.                         // Check if the Caption/Abstract Field exists and save the value

    553. 

  553.                         if ( $record != FALSE  )

    554. 

  554.                         {

    555. 

  555.                                 $outputarray = add_to_field( $outputarray, 'caption' , strtr( $record['RecData'], $irbtrans ), "\n" );

    556. 

  556.                         }

    557. 

  557. 

    558. 

  558.                         /***************************************/

    559. 

  559. 

    560. 

  560.                         // The IPTC Caption Writer/Editor Field contains captionwriter - find it

    561. 

  561.                         $record = find_IPTC_Resource( $IPTC_array, "2:122" );

    562. 

  562. 

    563. 

  563.                         // Check if the Caption Writer/Editor Field exists and save the value

    564. 

  564.                         if ( $record != FALSE  )

    565. 

  565.                         {

    566. 

  566.                                 $outputarray = add_to_field( $outputarray, 'captionwriter' , strtr( $record['RecData'], $irbtrans ), "\n" );

    567. 

  567.                         }

    568. 

  568. 

    569. 

  569.                         /***************************************/

    570. 

  570. 

    571. 

  571.                         // The IPTC Headline Field contains headline - find it

    572. 

  572.                         $record = find_IPTC_Resource( $IPTC_array, "2:105" );

    573. 

  573. 

    574. 

  574.                         // Check if the Headline Field exists and save the value

    575. 

  575.                         if ( $record != FALSE  )

    576. 

  576.                         {

    577. 

  577.                                 $outputarray = add_to_field( $outputarray, 'headline' , strtr( $record['RecData'], $irbtrans ), "\n" );

    578. 

  578.                         }

    579. 

  579. 

    580. 

  580.                         /***************************************/

    581. 

  581. 

    582. 

  582.                         // The IPTC Special Instructions Field contains instructions - find it

    583. 

  583.                         $record = find_IPTC_Resource( $IPTC_array, "2:40" );

    584. 

  584. 

    585. 

  585.                         // Check if the Special Instructions Field exists and save the value

    586. 

  586.                         if ( $record != FALSE  )

    587. 

  587.                         {

    588. 

  588.                                 $outputarray = add_to_field( $outputarray, 'instructions' , strtr( $record['RecData'], $irbtrans ), "\n" );

    589. 

  589.                         }

    590. 

  590. 

    591. 

  591.                         /***************************************/

    592. 

  592. 

    593. 

  593.                         // The IPTC By-Line Field contains author - find it

    594. 

  594.                         $record = find_IPTC_Resource( $IPTC_array, "2:80" );

    595. 

  595. 

    596. 

  596.                         // Check if the By-Line Field exists and save the value

    597. 

  597.                         if ( $record != FALSE  )

    598. 

  598.                         {

    599. 

  599.                                 $outputarray = add_to_field( $outputarray, 'author' , strtr( $record['RecData'], $irbtrans ), "\n" );

    600. 

  600.                         }

    601. 

  601. 

    602. 

  602.                         /***************************************/

    603. 

  603. 

    604. 

  604.                         // The IPTC By-Line Title Field contains authorsposition - find it

    605. 

  605.                         $record = find_IPTC_Resource( $IPTC_array, "2:85" );

    606. 

  606. 

    607. 

  607.                         // Check if the By-Line Title Field exists and save the value

    608. 

  608.                         if ( $record != FALSE  )

    609. 

  609.                         {

    610. 

  610.                                 $outputarray = add_to_field( $outputarray, 'authorsposition' , strtr( $record['RecData'], $irbtrans ), "\n" );

    611. 

  611.                         }

    612. 

  612. 

    613. 

  613.                         /***************************************/

    614. 

  614. 

    615. 

  615.                         // The IPTC Credit Field contains credit - find it

    616. 

  616.                         $record = find_IPTC_Resource( $IPTC_array, "2:110" );

    617. 

  617. 

    618. 

  618.                         // Check if the Credit Field exists and save the value

    619. 

  619.                         if ( $record != FALSE  )

    620. 

  620.                         {

    621. 

  621.                                 $outputarray = add_to_field( $outputarray, 'credit' , strtr( $record['RecData'], $irbtrans ), "\n" );

    622. 

  622.                         }

    623. 

  623. 

    624. 

  624.                         /***************************************/

    625. 

  625. 

    626. 

  626.                         // The IPTC Source Field contains source - find it

    627. 

  627.                         $record = find_IPTC_Resource( $IPTC_array, "2:115" );

    628. 

  628. 

    629. 

  629.                         // Check if the Source Field exists and save the value

    630. 

  630.                         if ( $record != FALSE  )

    631. 

  631.                         {

    632. 

  632.                                 $outputarray = add_to_field( $outputarray, 'source' , strtr( $record['RecData'], $irbtrans ), "\n" );

    633. 

  633.                         }

    634. 

  634. 

    635. 

  635.                         /***************************************/

    636. 

  636. 

    637. 

  637.                         // The IPTC Object Name Field contains title - find it

    638. 

  638.                         $record = find_IPTC_Resource( $IPTC_array, "2:05" );

    639. 

  639. 

    640. 

  640.                         // Check if the Object Name Field exists and save the value

    641. 

  641.                         if ( $record != FALSE  )

    642. 

  642.                         {

    643. 

  643.                                 $outputarray = add_to_field( $outputarray, 'title' , strtr( $record['RecData'], $irbtrans ), "\n" );

    644. 

  644.                         }

    645. 

  645. 

    646. 

  646.                         /***************************************/

    647. 

  647. 

    648. 

  648.                         // The IPTC Date Created Field contains date - find it

    649. 

  649.                         $record = find_IPTC_Resource( $IPTC_array, "2:55" );

    650. 

  650. 

    651. 

  651.                         // Check if the Date Created Field exists and save the value

    652. 

  652.                         if ( $record != FALSE  )

    653. 

  653.                         {

    654. 

  654.                                 $date_array = unpack( "a4Year/a2Month/A2Day", $record['RecData'] );

    655. 

  655.                                 $tmpdate = $date_array['Year'] . "-" . $date_array['Month'] . "-" . $date_array['Day'];

    656. 

  656.                                 $outputarray = add_to_field( $outputarray, 'date' , strtr( $tmpdate, $irbtrans ), "," );

    657. 

  657. 

    658. 

  658.                         }

    659. 

  659. 

    660. 

  660.                         /***************************************/

    661. 

  661. 

    662. 

  662.                         // The IPTC City Field contains city - find it

    663. 

  663.                         $record = find_IPTC_Resource( $IPTC_array, "2:90" );

    664. 

  664. 

    665. 

  665.                         // Check if the City Field exists and save the value

    666. 

  666.                         if ( $record != FALSE  )

    667. 

  667.                         {

    668. 

  668.                                 $outputarray = add_to_field( $outputarray, 'city' , strtr( $record['RecData'], $irbtrans ), "\n" );

    669. 

  669.                         }

    670. 

  670. 

    671. 

  671.                         /***************************************/

    672. 

  672. 

    673. 

  673.                         // The IPTC Province/State Field contains state - find it

    674. 

  674.                         $record = find_IPTC_Resource( $IPTC_array, "2:95" );

    675. 

  675. 

    676. 

  676.                         // Check if the Province/State Field exists and save the value

    677. 

  677.                         if ( $record != FALSE  )

    678. 

  678.                         {

    679. 

  679.                                 $outputarray = add_to_field( $outputarray, 'state' , strtr( $record['RecData'], $irbtrans ), "\n" );

    680. 

  680.                         }

    681. 

  681. 

    682. 

  682.                         /***************************************/

    683. 

  683. 

    684. 

  684.                         // The IPTC Country/Primary Location Name Field contains country - find it

    685. 

  685.                         $record = find_IPTC_Resource( $IPTC_array, "2:101" );

    686. 

  686. 

    687. 

  687.                         // Check if the Country/Primary Location Name Field exists and save the value

    688. 

  688.                         if ( $record != FALSE  )

    689. 

  689.                         {

    690. 

  690.                                 $outputarray = add_to_field( $outputarray, 'country' , strtr( $record['RecData'], $irbtrans ), "\n" );

    691. 

  691.                         }

    692. 

  692. 

    693. 

  693.                         /***************************************/

    694. 

  694. 

    695. 

  695.                         // The IPTC Original Transmission Reference Field contains transmissionreference - find it

    696. 

  696.                         $record = find_IPTC_Resource( $IPTC_array, "2:103" );

    697. 

  697. 

    698. 

  698.                         // Check if the Original Transmission Reference Field exists and save the value

    699. 

  699.                         if ( $record != FALSE  )

    700. 

  700.                         {

    701. 

  701.                                 $outputarray = add_to_field( $outputarray, 'transmissionreference' , strtr( $record['RecData'], $irbtrans ), "\n" );

    702. 

  702.                         }

    703. 

  703. 

    704. 

  704.                         /***************************************/

    705. 

  705. 

    706. 

  706.                         // The IPTC Category Field contains category - find it

    707. 

  707.                         $record = find_IPTC_Resource( $IPTC_array, "2:15" );

    708. 

  708. 

    709. 

  709.                         // Check if the Category Field exists and save the value

    710. 

  710.                         if ( $record != FALSE  )

    711. 

  711.                         {

    712. 

  712.                                 $outputarray = add_to_field( $outputarray, 'category' , strtr( $record['RecData'], $irbtrans ), "\n" );

    713. 

  713.                         }

    714. 

  714. 

    715. 

  715. 

    716. 

  716.                         /***************************************/

    717. 

  717. 

    718. 

  718.                         // Cycle through the IPTC records looking for Supplemental Category records

    719. 

  719.                         foreach ($IPTC_array as $record)

    720. 

  720.                         {

    721. 

  721.                                 // Check if a Supplemental Category record has been found

    722. 

  722.                                 if ( $record['IPTC_Type'] == "2:20" )

    723. 

  723.                                 {

    724. 

  724.                                         // A Supplemental Category record has been found, save it's value if the value doesn't already exist

    725. 

  725.                                         if ( ! in_array ( $record['RecData'], $outputarray['supplementalcategories']))

    726. 

  726.                                         {

    727. 

  727.                                                 $outputarray['supplementalcategories'][] = strtr( $record['RecData'], array("\x0a" => "", "\x0d" => "&#xA;") ) ;

    728. 

  728.                                         }

    729. 

  729.                                 }

    730. 

  730.                         }

    731. 

  731. 

    732. 

  732. 

    733. 

  733.                         /***************************************/

    734. 

  734. 

    735. 

  735.                         // The IPTC Urgency Field contains urgency - find it

    736. 

  736.                         $record = find_IPTC_Resource( $IPTC_array, "2:10" );

    737. 

  737. 

    738. 

  738.                         // Check if the Urgency Field exists and save the value

    739. 

  739.                         if ( $record != FALSE  )

    740. 

  740.                         {

    741. 

  741.                                 $outputarray = add_to_field( $outputarray, 'urgency' , strtr( $record['RecData'], $irbtrans ), "\n" );

    742. 

  742.                         }

    743. 

  743. 

    744. 

  744. 

    745. 

  745. 

    746. 

  746.                         /***************************************/

    747. 

  747. 

    748. 

  748.                         // Cycle through the IPTC records looking for Keywords records

    749. 

  749.                         foreach ($IPTC_array as $record)

    750. 

  750.                         {

    751. 

  751.                                 // Check if a Keywords record has been found

    752. 

  752.                                 if ( $record['IPTC_Type'] == "2:25" )

    753. 

  753.                                 {

    754. 

  754.                                         // A Keywords record has been found, save it's value if the value doesn't already exist

    755. 

  755.                                         if ( ! in_array ( $record['RecData'], $outputarray['keywords']))

    756. 

  756.                                         {

    757. 

  757.                                                 $outputarray['keywords'][] = strtr( $record['RecData'], array("\x0a" => "", "\x0d" => "&#xA;") ) ;

    758. 

  758.                                         }

    759. 

  759.                                 }

    760. 

  760.                         }

    761. 

  761. 

    762. 

  762. 

    763. 

  763.                         /***************************************/

    764. 

  764. 

    765. 

  765.                         // The IPTC Copyright Notice Field contains copyrightnotice - find it

    766. 

  766.                         $record = find_IPTC_Resource( $IPTC_array, "2:116" );

    767. 

  767. 

    768. 

  768.                         // Check if the Copyright Field exists and save the value

    769. 

  769.                         if ( $record != FALSE  )

    770. 

  770.                         {

    771. 

  771.                                 $outputarray = add_to_field( $outputarray, 'copyrightnotice' , strtr( $record['RecData'], $irbtrans ), "\n" );

    772. 

  772.                         }

    773. 

  773. 

    774. 

  774.                 }

    775. 

  775.         }

    776. 

  776. 

    777. 

  777. 

    778. 

  778. 

    779. 

  779. 

    780. 

  780.         /***************************************/

    781. 

  781. 

    782. 

  782.         // EXIF Processing

    783. 

  783. 

    784. 

  784. 

    785. 

  785.         // Retreive Information from the EXIF data if it exists

    786. 

  786. 

    787. 

  787.         if ( ( $Exif_array != FALSE ) || ( count( $Exif_array ) == 0 ) )

    788. 

  788.         {

    789. 

  789.                 // Check the Image Description Tag - it can contain the caption

    790. 

  790.                 if ( array_key_exists( 270, $Exif_array[0] ) )

    791. 

  791.                 {

    792. 

  792.                         $outputarray = add_to_field( $outputarray, 'caption' , $Exif_array[0][270]['Data'][0], "\n" );

    793. 

  793.                 }

    794. 

  794. 

    795. 

  795.                 /***************************************/

    796. 

  796. 

    797. 

  797.                 // Check the Copyright Information Tag - it contains the copyrightnotice

    798. 

  798.                 if ( array_key_exists( 33432, $Exif_array[0] ) )

    799. 

  799.                 {

    800. 

  800.                         $outputarray = add_to_field( $outputarray, 'copyrightnotice' , HTML_UTF8_UnEscape( $Exif_array[0][33432]['Data'][0] ), "\n" );

    801. 

  801.                 }

    802. 

  802. 

    803. 

  803.                 /***************************************/

    804. 

  804. 

    805. 

  805.                 // Check the Artist Name Tag - it contains the author

    806. 

  806.                 if ( array_key_exists( 315, $Exif_array[0] ) )

    807. 

  807.                 {

    808. 

  808.                         $outputarray = add_to_field( $outputarray, 'author' , HTML_UTF8_UnEscape( $Exif_array[0][315]['Data'][0] ), "\n" );

    809. 

  809.                 }

    810. 

  810. 

    811. 

  811.         }

    812. 

  812. 

    813. 

  813. 

    814. 

  814.         /***************************/

    815. 

  815. 

    816. 

  816.         // FINISHED RETRIEVING INFORMATION

    817. 

  817. 

    818. 

  818.         // Perform final processing

    819. 

  819. 

    820. 

  820. 

    821. 

  821.         // Check if any urgency information was found

    822. 

  822.         if ( $outputarray["urgency"] == "" )

    823. 

  823.         {

    824. 

  824.                 // No urgency information was found - set it to default (None)

    825. 

  825.                 $outputarray["urgency"] = "none";

    826. 

  826.         }

    827. 

  827. 

    828. 

  828.         // Check if any copyrightstatus information was found

    829. 

  829.         if ( $outputarray["copyrightstatus"] == "" )

    830. 

  830.         {

    831. 

  831.                 // No copyrightstatus information was found - set it to default (Unmarked)

    832. 

  832.                 $outputarray["copyrightstatus"] = "unmarked";

    833. 

  833.         }

    834. 

  834. 

    835. 

  835.         // Return the resulting Photoshop File Info Array

    836. 

  836.         return $outputarray;

    837. 

  837. 

    838. 

  838. }

    839. 

  839. 

    840. 

  840. /******************************************************************************

    841. 

  841. * End of Function:     get_photoshop_file_info

    842. 

  842. ******************************************************************************/

    843. 

  843. 

    844. 

  844. 

    845. 

  845. 

    846. 

  846. 

    847. 

  847. 

    848. 

  848. 

    849. 

  849. /******************************************************************************

    850. 

  850. *

    851. 

  851. * Function:     put_photoshop_file_info

    852. 

  852. *

    853. 

  853. * Description:  Stores Photoshop 'File Info' metadata in the same way that Photoshop

    854. 

  854. *               does. The 'File Info' metadata must be in an array similar to that

    855. 

  855. *               returned by get_photoshop_file_info, as follows:

    856. 

  856. *

    857. 

  857. *               $file_info_array = array(

    858. 

  858. *                       "title"                  => "",

    859. 

  859. *                       "author"                 => "",

    860. 

  860. *                       "authorsposition"        => "",      // Note: Not used in Photoshop 7 or higher

    861. 

  861. *                       "caption"                => "",

    862. 

  862. *                       "captionwriter"          => "",

    863. 

  863. *                       "jobname"                => "",      // Note: Not used in Photoshop CS

    864. 

  864. *                       "copyrightstatus"        => "",

    865. 

  865. *                       "copyrightnotice"        => "",

    866. 

  866. *                       "ownerurl"               => "",

    867. 

  867. *                       "keywords"               => array( 0 => "", 1 => "", ... ),

    868. 

  868. *                       "category"               => "",     // Note: Max 3 characters

    869. 

  869. *                        "supplementalcategories" => array( 0 => "", 1 => "", ... ),

    870. 

  870. *                       "date"                   => "",     // Note: DATE MUST BE IN YYYY-MM-DD format

    871. 

  871. *                       "city"                   => "",

    872. 

  872. *                       "state"                  => "",

    873. 

  873. *                       "country"                => "",

    874. 

  874. *                       "credit"                 => "",

    875. 

  875. *                       "source"                 => "",

    876. 

  876. *                       "headline"               => "",

    877. 

  877. *                       "instructions"           => "",

    878. 

  878. *                       "transmissionreference"  => "",

    879. 

  879. *                       "urgency"                => "" );

    880. 

  880. *

    881. 

  881. * Parameters:   jpeg_header_data - a JPEG header data array in the same format

    882. 

  882. *                                  as from get_jpeg_header_data. This contains the

    883. 

  883. *                                  header information which is to be updated.

    884. 

  884. *               new_ps_file_info_array - An array as above, which contains the

    885. 

  885. *                                        'File Info' metadata information to be

    886. 

  886. *                                        written.

    887. 

  887. *               Old_Exif_array - an array containing the EXIF information to be

    888. 

  888. *                                updated, as retrieved by get_EXIF_JPEG. (saves having to parse the EXIF again)

    889. 

  889. *               Old_XMP_array - an array containing the XMP information to be

    890. 

  890. *                               updated, as retrieved by read_XMP_array_from_text. (saves having to parse the XMP again)

    891. 

  891. *               Old_IRB_array - an array containing the Photoshop IRB information

    892. 

  892. *                                to be updated, as retrieved by get_Photoshop_IRB. (saves having to parse the IRB again)

    893. 

  893. *

    894. 

  894. * Returns:      jpeg_header_data - a JPEG header data array in the same format

    895. 

  895. *                                  as from get_jpeg_header_data, containing the

    896. 

  896. *                                  Photshop 'File Info' metadata. This can then

    897. 

  897. *                                  be written to a file using put_jpeg_header_data.

    898. 

  898. *

    899. 

  899. ******************************************************************************/

    900. 

  900. 

    901. 

  901. function put_photoshop_file_info( $jpeg_header_data, $new_ps_file_info_array, $Old_Exif_array, $Old_XMP_array, $Old_IRB_array )

    902. 

  902. {

    903. 

  903.         /*******************************************/

    904. 

  904.         // PREPROCESSING

    905. 

  905. 

    906. 

  906.         // Check that the date is in the correct format (YYYY-MM-DD)

    907. 

  907. 

    908. 

  908.         // Explode the date into pieces using the - symbol

    909. 

  909.         $date_pieces = explode( "-", $new_ps_file_info_array[ 'date' ] );

    910. 

  910. 

    911. 

  911.         // If there are not 3 pieces to the date, it is invalid

    912. 

  912.         if ( count( $date_pieces ) != 3 )

    913. 

  913.         {

    914. 

  914.                 // INVALID DATE

    915. 

  915.                 echo "Invalid Date - must be YYYY-MM-DD format<br>";

    916. 

  916.                 return FALSE;

    917. 

  917.         }

    918. 

  918. 

    919. 

  919.         // Cycle through each piece of the date

    920. 

  920.         foreach( $date_pieces as $piece )

    921. 

  921.         {

    922. 

  922.                 // If the piece is not numeric, then the date is invalid.

    923. 

  923.                 if ( ! is_numeric( $piece ) )

    924. 

  924.                 {

    925. 

  925.                         // INVALID DATE

    926. 

  926.                         echo "Invalid Date - must be YYYY-MM-DD format<br>";

    927. 

  927.                         return FALSE;

    928. 

  928.                 }

    929. 

  929.         }

    930. 

  930. 

    931. 

  931.         // Make a unix timestamp at midnight on the date specified

    932. 

  932.         $date_stamp = mktime( 0,0,0, $date_pieces[1], $date_pieces[2], $date_pieces[0] );

    933. 

  933. 

    934. 

  934. 

    935. 

  935. 

    936. 

  936. 

    937. 

  937.         // Create a translation table to remove carriage return characters

    938. 

  938.         $trans = array( "\x0d" => "" );

    939. 

  939. 

    940. 

  940.         // Cycle through each of the File Info elements

    941. 

  941.         foreach( $new_ps_file_info_array as $valkey => $val )

    942. 

  942.         {

    943. 

  943.                 // If the element is 'Keywords' or 'Supplemental Categories', then

    944. 

  944.                 // it is an array, and needs to be treated as one

    945. 

  945.                 if ( ( $valkey != 'supplementalcategories' ) && ( $valkey != 'keywords' ) )

    946. 

  946.                 {

    947. 

  947.                         // Not Keywords or Supplemental Categories

    948. 

  948.                         // Convert escaped HTML characters to UTF8 and remove carriage returns

    949. 

  949.                         $new_ps_file_info_array[ $valkey ] = strtr( HTML_UTF8_UnEscape( $val ), $trans );

    950. 

  950.                 }

    951. 

  951.                 else

    952. 

  952.                 {

    953. 

  953.                         // Either Keywords or Supplemental Categories

    954. 

  954.                         // Cycle through the array,

    955. 

  955.                         foreach( $val as $subvalkey => $subval )

    956. 

  956.                         {

    957. 

  957.                                 // Convert escaped HTML characters to UTF8 and remove carriage returns

    958. 

  958.                                 $new_ps_file_info_array[ $valkey ][ $subvalkey ] = strtr( HTML_UTF8_UnEscape( $subval ), $trans );

    959. 

  959.                         }

    960. 

  960.                 }

    961. 

  961.         }

    962. 

  962. 

    963. 

  963. 

    964. 

  964. 

    965. 

  965. 

    966. 

  966. 

    967. 

  967.         /*******************************************/

    968. 

  968. 

    969. 

  969.         // EXIF Processing

    970. 

  970. 

    971. 

  971. 

    972. 

  972.         // Check if the EXIF array exists

    973. 

  973.         if( $Old_Exif_array == FALSE )

    974. 

  974.         {

    975. 

  975.                 // EXIF Array doesn't exist - create a new one

    976. 

  976.                 $new_Exif_array = array (       'Byte_Align' => "MM",

    977. 

  977.                                                 'Makernote_Tag' => false,

    978. 

  978.                                                 'Tags Name' => "TIFF",

    979. 

  979.                                                  0 => array( "Tags Name" => "TIFF" ) );

    980. 

  980.         }

    981. 

  981.         else

    982. 

  982.         {

    983. 

  983.                 // EXIF Array Does Exist - use it

    984. 

  984.                 $new_Exif_array = $Old_Exif_array;

    985. 

  985.         }

    986. 

  986. 

    987. 

  987. 

    988. 

  988. 

    989. 

  989.         // Update the EXIF Image Description Tag with the new value

    990. 

  990.         $new_Exif_array[0][270] = array (       "Tag Name"   => $GLOBALS[ "IFD_Tag_Definitions" ]['TIFF'][ 270 ]['Name'],

    991. 

  991.                                                 "Tag Number" => 270,

    992. 

  992.                                                 "Data Type"  => 2,

    993. 

  993.                                                 "Type"       => $GLOBALS[ "IFD_Tag_Definitions" ]['TIFF'][ 270 ]['Type'],

    994. 

  994.                                                 "Data"       => array( HTML_UTF8_Escape( $new_ps_file_info_array[ 'caption' ]) ));

    995. 

  995. 

    996. 

  996.         // Update the EXIF Artist Name Tag with the new value

    997. 

  997.         $new_Exif_array[0][315] = array (       "Tag Name"   => $GLOBALS[ "IFD_Tag_Definitions" ]['TIFF'][ 315 ]['Name'],

    998. 

  998.                                                 "Tag Number" => 315,

    999. 

  999.                                                 "Data Type"  => 2,

    1000. 

  1000.                                                 "Type"       => $GLOBALS[ "IFD_Tag_Definitions" ]['TIFF'][ 315 ]['Type'],

    1001. 

  1001.                                                 "Data"       => array( HTML_UTF8_Escape( $new_ps_file_info_array[ 'author' ] ) ) );

    1002. 

  1002. 

    1003. 

  1003.         // Update the EXIF Copyright Information Tag with the new value

    1004. 

  1004.         $new_Exif_array[0][33432] = array (     "Tag Name"   => $GLOBALS[ "IFD_Tag_Definitions" ]['TIFF'][ 33432 ]['Name'],

    1005. 

  1005.                                                 "Tag Number" => 33432,

    1006. 

  1006.                                                 "Data Type"  => 2,

    1007. 

  1007.                                                 "Type"       => $GLOBALS[ "IFD_Tag_Definitions" ]['TIFF'][ 33432 ]['Type'],

    1008. 

  1008.                                                 "Data"       => array( HTML_UTF8_Escape( $new_ps_file_info_array[ 'copyrightnotice' ]) ) );

    1009. 

  1009. 

    1010. 

  1010. 

    1011. 

  1011.         // Photoshop checks if the "Date and Time of Original" and "Date and Time when Digitized" tags exist

    1012. 

  1012.         // If they don't exist, it means that the EXIF date may be wiped out if it is changed, so Photoshop

    1013. 

  1013.         // copies the EXIF date to these two tags

    1014. 

  1014. 

    1015. 

  1015.         if ( ( array_key_exists( 306, $new_Exif_array[0] ) )&&

    1016. 

  1016.              ( array_key_exists( 34665, $new_Exif_array[0] ) ) &&

    1017. 

  1017.              ( array_key_exists( 0, $new_Exif_array[0][34665] ) ) )

    1018. 

  1018.         {

    1019. 

  1019.                 // Replace "Date and Time of Original" if it doesn't exist

    1020. 

  1020.                 if ( ! array_key_exists( 36867, $new_Exif_array[0][34665][0] ) )

    1021. 

  1021.                 {

    1022. 

  1022.                         $new_Exif_array[0][34665][0][36867] = array (       "Tag Name"   => $GLOBALS[ "IFD_Tag_Definitions" ]['EXIF'][ 36867 ]['Name'],

    1023. 

  1023.                                                 "Tag Number" => 36867,

    1024. 

  1024.                                                 "Data Type"  => 2,

    1025. 

  1025.                                                 "Type"       => $GLOBALS[ "IFD_Tag_Definitions" ]['EXIF'][ 36867 ]['Type'],

    1026. 

  1026.                                                 "Data"       => $new_Exif_array[0][306]['Data'] );

    1027. 

  1027.                 }

    1028. 

  1028. 

    1029. 

  1029.                 // Replace "Date and Time when Digitized" if it doesn't exist

    1030. 

  1030.                 if ( ! array_key_exists( 36868, $new_Exif_array[0][34665][0] ) )

    1031. 

  1031.                 {

    1032. 

  1032.                         $new_Exif_array[0][34665][0][36868] = array (       "Tag Name"   => $GLOBALS[ "IFD_Tag_Definitions" ]['EXIF'][ 36868 ]['Name'],

    1033. 

  1033.                                                 "Tag Number" => 36868,

    1034. 

  1034.                                                 "Data Type"  => 2,

    1035. 

  1035.                                                 "Type"       => $GLOBALS[ "IFD_Tag_Definitions" ]['EXIF'][ 36868 ]['Type'],

    1036. 

  1036.                                                 "Data"       => $new_Exif_array[0][306]['Data'] );

    1037. 

  1037.                 }

    1038. 

  1038.         }

    1039. 

  1039. 

    1040. 

  1040. 

    1041. 

  1041.         // Photoshop changes the EXIF date Tag (306) to the current date, not the date that was entered in File Info

    1042. 

  1042.         $exif_date = date ( "Y:m:d H:i:s" );

    1043. 

  1043. 

    1044. 

  1044.         // Update the EXIF Date and Time Tag with the new value

    1045. 

  1045.         $new_Exif_array[0][306] = array (       "Tag Name"   => $GLOBALS[ "IFD_Tag_Definitions" ]['TIFF'][ 306 ]['Name'],

    1046. 

  1046.                                                 "Tag Number" => 306,

    1047. 

  1047.                                                 "Data Type"  => 2,

    1048. 

  1048.                                                 "Type"       => $GLOBALS[ "IFD_Tag_Definitions" ]['TIFF'][ 306 ]['Type'],

    1049. 

  1049.                                                 "Data"       => array( $exif_date ) );

    1050. 

  1050. 

    1051. 

  1051. 

    1052. 

  1052. 

    1053. 

  1053.         // Photoshop replaces the EXIF Software or Firmware Tag with "Adobe Photoshop ..."

    1054. 

  1054.         // This toolkit instead preserves existing value and appends the toolkit name to the end of it

    1055. 

  1055. 

    1056. 

  1056.         // Check if the EXIF Software or Firmware Tag exists

    1057. 

  1057.         if ( array_key_exists( 305, $new_Exif_array[0] ) )

    1058. 

  1058.         {

    1059. 

  1059.                 // An existing EXIF Software or Firmware Tag was found

    1060. 

  1060.                 // Check if the existing Software or Firmware Tag already contains the Toolkit's name

    1061. 

  1061.                 if ( stristr ( $new_Exif_array[0][305]['Data'][0], $GLOBALS[ "Software Name" ]) == FALSE )

    1062. 

  1062.                 {

    1063. 

  1063.                         // Toolkit Name string not found in the existing Software/Firmware string - append it.

    1064. 

  1064.                         $firmware_str = $new_Exif_array[0][305]['Data'][0] . " " . $GLOBALS[ "Software Name" ];

    1065. 

  1065.                 }

    1066. 

  1066.                 else

    1067. 

  1067.                 {

    1068. 

  1068.                         // Toolkit name already exists in Software/Firmware string - don't put another copy in the string

    1069. 

  1069.                         $firmware_str = $new_Exif_array[0][305]['Data'][0];

    1070. 

  1070.                 }

    1071. 

  1071.         }

    1072. 

  1072.         else

    1073. 

  1073.         {

    1074. 

  1074.                 // No Software/Firmware string exists - create one

    1075. 

  1075.                 $firmware_str = $GLOBALS[ "Software Name" ];

    1076. 

  1076.         }

    1077. 

  1077. 

    1078. 

  1078.         // Update the EXIF Software/Firmware Tag with the new value

    1079. 

  1079.         $new_Exif_array[0][305] = array(        "Tag Name"   => $GLOBALS[ "IFD_Tag_Definitions" ]['TIFF'][ 305 ]['Name'],

    1080. 

  1080.                                                 "Tag Number" => 305,

    1081. 

  1081.                                                 "Data Type"  => 2,

    1082. 

  1082.                                                 "Type"       => $GLOBALS[ "IFD_Tag_Definitions" ]['TIFF'][ 305 ]['Type'],

    1083. 

  1083.                                                 "Data"       => array( HTML_UTF8_Escape( $firmware_str ) ) );

    1084. 

  1084. 

    1085. 

  1085. 

    1086. 

  1086. 

    1087. 

  1087. 

    1088. 

  1088. 

    1089. 

  1089.         /*******************************************/

    1090. 

  1090. 

    1091. 

  1091.         // Photoshop IRB Processing

    1092. 

  1092. 

    1093. 

  1093. 

    1094. 

  1094.         // Check if there is an existing Photoshop IRB array

    1095. 

  1095.         if ($Old_IRB_array == FALSE )

    1096. 

  1096.         {

    1097. 

  1097.                 // No existing IRB array - create one

    1098. 

  1098.                 $new_IRB_array = array();

    1099. 

  1099.         }

    1100. 

  1100.         else

    1101. 

  1101.         {

    1102. 

  1102.                 // There is an existing Photoshop IRB array - use it

    1103. 

  1103.                 $new_IRB_array = $Old_IRB_array;

    1104. 

  1104.         }

    1105. 

  1105. 

    1106. 

  1106.         // Remove any existing Copyright Flag, URL, or IPTC resources - these will be re-written

    1107. 

  1107.         foreach( $new_IRB_array as  $resno => $res )

    1108. 

  1108.         {

    1109. 

  1109.                 if ( ( $res[ 'ResID' ] == 0x040A ) ||

    1110. 

  1110.                      ( $res[ 'ResID' ] == 0x040B ) ||

    1111. 

  1111.                      ( $res[ 'ResID' ] == 0x0404 ) )

    1112. 

  1112.                 {

    1113. 

  1113.                         array_splice( $new_IRB_array, $resno, 1 );

    1114. 

  1114.                 }

    1115. 

  1115.         }

    1116. 

  1116. 

    1117. 

  1117. 

    1118. 

  1118.         // Add a new Copyright Flag resource

    1119. 

  1119.         if ( $new_ps_file_info_array[ 'copyrightstatus' ] == "Copyrighted Work" )

    1120. 

  1120.         {

    1121. 

  1121.                 $PS_copyright_flag = "\x01"; // Copyrighted

    1122. 

  1122.         }

    1123. 

  1123.         else

    1124. 

  1124.         {

    1125. 

  1125.                 $PS_copyright_flag = "\x00"; // Public domain or Unmarked

    1126. 

  1126.         }

    1127. 

  1127.         $new_IRB_array[] = array(       'ResID' => 0x040A,

    1128. 

  1128.                                         'ResName' => $GLOBALS[ "Photoshop_ID_Names" ][0x040A],

    1129. 

  1129.                                         'ResDesc' => $GLOBALS[ "Photoshop_ID_Descriptions" ][0x040A],

    1130. 

  1130.                                         'ResEmbeddedName' => "",

    1131. 

  1131.                                         'ResData' => $PS_copyright_flag );

    1132. 

  1132. 

    1133. 

  1133. 

    1134. 

  1134. 

    1135. 

  1135.         // Add a new URL resource

    1136. 

  1136.         $new_IRB_array[] = array(       'ResID' => 0x040B,

    1137. 

  1137.                                         'ResName' => $GLOBALS[ "Photoshop_ID_Names" ][0x040B],

    1138. 

  1138.                                         'ResDesc' => $GLOBALS[ "Photoshop_ID_Descriptions" ][0x040B],

    1139. 

  1139.                                         'ResEmbeddedName' => "",

    1140. 

  1140.                                         'ResData' => $new_ps_file_info_array[ 'ownerurl' ] );

    1141. 

  1141. 

    1142. 

  1142. 

    1143. 

  1143. 

    1144. 

  1144.         // Create IPTC resource

    1145. 

  1145. 

    1146. 

  1146.         // IPTC requires date to be in the following format YYYYMMDD

    1147. 

  1147.         $iptc_date = date( "Ymd", $date_stamp );

    1148. 

  1148. 

    1149. 

  1149.         // Create the new IPTC array

    1150. 

  1150.         $new_IPTC_array = array (

    1151. 

  1151.                                   0 =>

    1152. 

  1152.                                   array (

    1153. 

  1153.                                     'IPTC_Type' => '2:00',

    1154. 

  1154.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:00'],

    1155. 

  1155.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:00'],

    1156. 

  1156.                                     'RecData' => "\x00\x02",

    1157. 

  1157.                                   ),

    1158. 

  1158.                                   1 =>

    1159. 

  1159.                                   array (

    1160. 

  1160.                                     'IPTC_Type' => '2:120',

    1161. 

  1161.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:120'],

    1162. 

  1162.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:120'],

    1163. 

  1163.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'caption' ] ), 0 , 2000 ),

    1164. 

  1164.                                   ),

    1165. 

  1165.                                   2 =>

    1166. 

  1166.                                   array (

    1167. 

  1167.                                     'IPTC_Type' => '2:122',

    1168. 

  1168.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:122'],

    1169. 

  1169.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:122'],

    1170. 

  1170.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'captionwriter' ] ), 0 , 32 ),

    1171. 

  1171.                                   ),

    1172. 

  1172.                                   3 =>

    1173. 

  1173.                                   array (

    1174. 

  1174.                                     'IPTC_Type' => '2:105',

    1175. 

  1175.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:105'],

    1176. 

  1176.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:105'],

    1177. 

  1177.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'headline' ] ), 0 , 256 ),

    1178. 

  1178.                                   ),

    1179. 

  1179.                                   4 =>

    1180. 

  1180.                                   array (

    1181. 

  1181.                                     'IPTC_Type' => '2:40',

    1182. 

  1182.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:40'],

    1183. 

  1183.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:40'],

    1184. 

  1184.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'instructions' ] ), 0, 256 ),

    1185. 

  1185.                                   ),

    1186. 

  1186.                                   5 =>

    1187. 

  1187.                                   array (

    1188. 

  1188.                                     'IPTC_Type' => '2:80',

    1189. 

  1189.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:80'],

    1190. 

  1190.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:80'],

    1191. 

  1191.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'author' ] ), 0, 32 ),

    1192. 

  1192.                                   ),

    1193. 

  1193.                                   6 =>

    1194. 

  1194.                                   array (

    1195. 

  1195.                                     'IPTC_Type' => '2:85',

    1196. 

  1196.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:85'],

    1197. 

  1197.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:85'],

    1198. 

  1198.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'authorsposition' ] ), 0, 32 ),

    1199. 

  1199.                                   ),

    1200. 

  1200.                                   7 =>

    1201. 

  1201.                                   array (

    1202. 

  1202.                                     'IPTC_Type' => '2:110',

    1203. 

  1203.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:110'],

    1204. 

  1204.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:110'],

    1205. 

  1205.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'credit' ] ), 0, 32 ),

    1206. 

  1206.                                   ),

    1207. 

  1207.                                   8 =>

    1208. 

  1208.                                   array (

    1209. 

  1209.                                     'IPTC_Type' => '2:115',

    1210. 

  1210.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:115'],

    1211. 

  1211.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:115'],

    1212. 

  1212.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'source' ] ), 0, 32 ),

    1213. 

  1213.                                   ),

    1214. 

  1214.                                   9 =>

    1215. 

  1215.                                   array (

    1216. 

  1216.                                     'IPTC_Type' => '2:05',

    1217. 

  1217.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:05'],

    1218. 

  1218.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:05'],

    1219. 

  1219.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'title' ] ), 0, 64 ),

    1220. 

  1220.                                   ),

    1221. 

  1221.                                   10 =>

    1222. 

  1222.                                   array (

    1223. 

  1223.                                     'IPTC_Type' => '2:55',

    1224. 

  1224.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:55'],

    1225. 

  1225.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:55'],

    1226. 

  1226.                                     'RecData' => "$iptc_date",

    1227. 

  1227.                                   ),

    1228. 

  1228.                                   11 =>

    1229. 

  1229.                                   array (

    1230. 

  1230.                                     'IPTC_Type' => '2:90',

    1231. 

  1231.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:90'],

    1232. 

  1232.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:90'],

    1233. 

  1233.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'city' ] ), 0, 32 ),

    1234. 

  1234.                                   ),

    1235. 

  1235.                                   12 =>

    1236. 

  1236.                                   array (

    1237. 

  1237.                                     'IPTC_Type' => '2:95',

    1238. 

  1238.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:95'],

    1239. 

  1239.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:95'],

    1240. 

  1240.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'state' ] ), 0, 32 ),

    1241. 

  1241.                                   ),

    1242. 

  1242.                                   13 =>

    1243. 

  1243.                                   array (

    1244. 

  1244.                                     'IPTC_Type' => '2:101',

    1245. 

  1245.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:101'],

    1246. 

  1246.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:101'],

    1247. 

  1247.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'country' ] ), 0, 64 ),

    1248. 

  1248.                                   ),

    1249. 

  1249.                                   14 =>

    1250. 

  1250.                                   array (

    1251. 

  1251.                                     'IPTC_Type' => '2:103',

    1252. 

  1252.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:103'],

    1253. 

  1253.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:103'],

    1254. 

  1254.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'transmissionreference' ] ), 0, 32 ),

    1255. 

  1255.                                   ),

    1256. 

  1256.                                   15 =>

    1257. 

  1257.                                   array (

    1258. 

  1258.                                     'IPTC_Type' => '2:15',

    1259. 

  1259.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:15'],

    1260. 

  1260.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:15'],

    1261. 

  1261.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'category' ] ), 0, 3 ),

    1262. 

  1262.                                   ),

    1263. 

  1263.                                   21 =>

    1264. 

  1264.                                   array (

    1265. 

  1265.                                     'IPTC_Type' => '2:116',

    1266. 

  1266.                                     'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:10'],

    1267. 

  1267.                                     'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:10'],

    1268. 

  1268.                                     'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'copyrightnotice' ] ), 0, 128 ),

    1269. 

  1269.                                   ),

    1270. 

  1270.                                 );

    1271. 

  1271. 

    1272. 

  1272.         // Check the value of urgency is valid

    1273. 

  1273.         if ( ( $new_ps_file_info_array[ 'urgency' ] > 0 ) && ( $new_ps_file_info_array[ 'urgency' ] < 9 ) )

    1274. 

  1274.         {

    1275. 

  1275.                 // Add the Urgency item to the IPTC array

    1276. 

  1276.                 $new_IPTC_array[] = array (

    1277. 

  1277.                                                 'IPTC_Type' => '2:10',

    1278. 

  1278.                                                 'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:10'],

    1279. 

  1279.                                                 'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:10'],

    1280. 

  1280.                                                 'RecData' => substr( HTML_UTF8_Escape( $new_ps_file_info_array[ 'urgency' ] ), 0, 1 ),

    1281. 

  1281.                                           );

    1282. 

  1282.         }

    1283. 

  1283. 

    1284. 

  1284.         // Cycle through the Supplemental Categories,

    1285. 

  1285.         foreach( $new_ps_file_info_array[ 'supplementalcategories' ] as $supcat )

    1286. 

  1286.         {

    1287. 

  1287.                 // Add this Supplemental Category to the IPTC array

    1288. 

  1288.                 $new_IPTC_array[] = array (

    1289. 

  1289.                                             'IPTC_Type' => '2:20',

    1290. 

  1290.                                             'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:20'],

    1291. 

  1291.                                             'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:20'],

    1292. 

  1292.                                             'RecData' => HTML_UTF8_Escape( $supcat ),

    1293. 

  1293.                                           );

    1294. 

  1294.         }

    1295. 

  1295. 

    1296. 

  1296. 

    1297. 

  1297.         // Cycle through the Keywords,

    1298. 

  1298.         foreach( $new_ps_file_info_array[ 'keywords' ] as $keyword )

    1299. 

  1299.         {

    1300. 

  1300.                 // Add this Keyword to the IPTC array

    1301. 

  1301.                 $new_IPTC_array[] = array (

    1302. 

  1302.                                             'IPTC_Type' => '2:25',

    1303. 

  1303.                                             'RecName' => $GLOBALS[ "IPTC_Entry_Names" ]['2:25'],

    1304. 

  1304.                                             'RecDesc' => $GLOBALS[ "IPTC_Entry_Descriptions" ]['2:25'],

    1305. 

  1305.                                             'RecData' => $keyword,

    1306. 

  1306.                                           );

    1307. 

  1307.         }

    1308. 

  1308. 

    1309. 

  1309. 

    1310. 

  1310.         /***********************************/

    1311. 

  1311. 

    1312. 

  1312.         // XMP Processing

    1313. 

  1313. 

    1314. 

  1314.         // Check if XMP existed previously

    1315. 

  1315.         if ($Old_XMP_array == FALSE )

    1316. 

  1316.         {

    1317. 

  1317.                 // XMP didn't exist - create a new one based on a blank structure

    1318. 

  1318.                 $new_XMP_array = XMP_Check( $GLOBALS[ 'Blank XMP Structure' ], array( ) );

    1319. 

  1319.         }

    1320. 

  1320.         else

    1321. 

  1321.         {

    1322. 

  1322.                 // XMP does exist

    1323. 

  1323.                 // Some old XMP processors used x:xapmeta, check for this

    1324. 

  1324.                 if ( $Old_XMP_array[0]['tag'] == 'x:xapmeta' )

    1325. 

  1325.                 {

    1326. 

  1326.                         // x:xapmeta found - change it to x:xmpmeta

    1327. 

  1327.                         $Old_XMP_array[0]['tag'] = 'x:xmpmeta';

    1328. 

  1328.                 }

    1329. 

  1329. 

    1330. 

  1330.                 // Ensure that the existing XMP has all required fields, and add any that are missing

    1331. 

  1331.                 $new_XMP_array = XMP_Check( $GLOBALS[ 'Blank XMP Structure' ], $Old_XMP_array );

    1332. 

  1332.         }

    1333. 

  1333. 

    1334. 

  1334. 

    1335. 

  1335.         // Process the XMP Photoshop block

    1336. 

  1336. 

    1337. 

  1337.         // Find the Photoshop Information within the XMP block

    1338. 

  1338.         $photoshop_block = & find_XMP_block( $new_XMP_array, "photoshop" );

    1339. 

  1339. 

    1340. 

  1340.         // The Photoshop CaptionWriter tag contains captionwriter - Find it and Update the value

    1341. 

  1341.         $Item = & find_XMP_item( $photoshop_block, "photoshop:CaptionWriter" );

    1342. 

  1342.         $Item[ 'value' ] = $new_ps_file_info_array[ 'captionwriter' ];

    1343. 

  1343. 

    1344. 

  1344.         // The Photoshop Category tag contains category - Find it and Update the value

    1345. 

  1345.         $Item = & find_XMP_item( $photoshop_block, "photoshop:Category" );

    1346. 

  1346.         $Item[ 'value' ] = $new_ps_file_info_array[ 'category' ];

    1347. 

  1347. 

    1348. 

  1348.         // The Photoshop DateCreated tag contains date - Find it and Update the value

    1349. 

  1349.         $Item = & find_XMP_item( $photoshop_block, "photoshop:DateCreated" );

    1350. 

  1350.         $Item[ 'value' ] = $new_ps_file_info_array[ 'date' ];

    1351. 

  1351. 

    1352. 

  1352.         // The Photoshop City tag contains city - Find it and Update the value

    1353. 

  1353.         $Item = & find_XMP_item( $photoshop_block, "photoshop:City" );

    1354. 

  1354.         $Item[ 'value' ] = $new_ps_file_info_array[ 'city' ];

    1355. 

  1355. 

    1356. 

  1356.         // The Photoshop State tag contains state - Find it and Update the value

    1357. 

  1357.         $Item = & find_XMP_item( $photoshop_block, "photoshop:State" );

    1358. 

  1358.         $Item[ 'value' ] = $new_ps_file_info_array[ 'state' ];

    1359. 

  1359. 

    1360. 

  1360.         // The Photoshop Country tag contains country - Find it and Update the value

    1361. 

  1361.         $Item = & find_XMP_item( $photoshop_block, "photoshop:Country" );

    1362. 

  1362.         $Item[ 'value' ] = $new_ps_file_info_array[ 'country' ];

    1363. 

  1363. 

    1364. 

  1364.         // The Photoshop AuthorsPosition tag contains authorsposition - Find it and Update the value

    1365. 

  1365.         $Item = & find_XMP_item( $photoshop_block, "photoshop:AuthorsPosition" );

    1366. 

  1366.         $Item[ 'value' ] = $new_ps_file_info_array[ 'authorsposition' ];

    1367. 

  1367. 

    1368. 

  1368.         // The Photoshop Credit tag contains credit - Find it and Update the value

    1369. 

  1369.         $Item = & find_XMP_item( $photoshop_block, "photoshop:Credit" );

    1370. 

  1370.         $Item[ 'value' ] = $new_ps_file_info_array[ 'credit' ];

    1371. 

  1371. 

    1372. 

  1372.         // The Photoshop Source tag contains source - Find it and Update the value

    1373. 

  1373.         $Item = & find_XMP_item( $photoshop_block, "photoshop:Source" );

    1374. 

  1374.         $Item[ 'value' ] = $new_ps_file_info_array[ 'source' ];

    1375. 

  1375. 

    1376. 

  1376.         // The Photoshop Headline tag contains headline - Find it and Update the value

    1377. 

  1377.         $Item = & find_XMP_item( $photoshop_block, "photoshop:Headline" );

    1378. 

  1378.         $Item[ 'value' ] = $new_ps_file_info_array[ 'headline' ];

    1379. 

  1379. 

    1380. 

  1380.         // The Photoshop Instructions tag contains instructions - Find it and Update the value

    1381. 

  1381.         $Item = & find_XMP_item( $photoshop_block, "photoshop:Instructions" );

    1382. 

  1382.         $Item[ 'value' ] = $new_ps_file_info_array[ 'instructions' ];

    1383. 

  1383. 

    1384. 

  1384.         // The Photoshop TransmissionReference tag contains transmissionreference - Find it and Update the value

    1385. 

  1385.         $Item = & find_XMP_item( $photoshop_block, "photoshop:TransmissionReference" );

    1386. 

  1386.         $Item[ 'value' ] = $new_ps_file_info_array[ 'transmissionreference' ];

    1387. 

  1387. 

    1388. 

  1388.         // The Photoshop Urgency tag contains urgency - Find it and Update the value

    1389. 

  1389.         $Item = & find_XMP_item( $photoshop_block, "photoshop:Urgency" );

    1390. 

  1390.         $Item[ 'value' ] = $new_ps_file_info_array[ 'urgency' ];

    1391. 

  1391. 

    1392. 

  1392.         // The Photoshop SupplementalCategories tag contains supplementalcategories - Find it

    1393. 

  1393.         $Item = & find_XMP_item( $photoshop_block, "photoshop:SupplementalCategories" );

    1394. 

  1394. 

    1395. 

  1395.         // Create an array to receive the XML list items for the Supplemental Categories

    1396. 

  1396.         $new_supcat_array = array( );

    1397. 

  1397. 

    1398. 

  1398.         // Cycle through the Supplemental Categories

    1399. 

  1399.         foreach ( $new_ps_file_info_array[ 'supplementalcategories' ] as $sup_category )

    1400. 

  1400.         {

    1401. 

  1401.                 // Add a new list item for this Supplemental Category

    1402. 

  1402.                 $new_supcat_array[] = array( 'tag' => 'rdf:li', 'value' => $sup_category );

    1403. 

  1403.         }

    1404. 

  1404. 

    1405. 

  1405.         // Add the array of Supplemental Category List Items to the Photoshop SupplementalCategories tag

    1406. 

  1406.         $Item[ 'children' ][ 0 ][ 'children' ] = $new_supcat_array;

    1407. 

  1407. 

    1408. 

  1408. 

    1409. 

  1409. 

    1410. 

  1410.         // Process the XMP XAP block

    1411. 

  1411. 

    1412. 

  1412.         // Find the XAP Information within the XMP block

    1413. 

  1413.         $XAP_block = & find_XMP_block( $new_XMP_array, "xap" );

    1414. 

  1414. 

    1415. 

  1415.         // The XAP CreateDate tag contains date XMP was first created - Find it and Update the value

    1416. 

  1416.         $Item = & find_XMP_item( $XAP_block, "xap:CreateDate" );

    1417. 

  1417. 

    1418. 

  1418.         // Check if the CreateDate is blank

    1419. 

  1419.         if ( $Item[ 'value' ] == "" )

    1420. 

  1420.         {

    1421. 

  1421.                 // CreateDate is blank - we must have just added it - set it to the current date

    1422. 

  1422.                 $Item[ 'value' ] = date( "Y-m-d\TH:i:s" );

    1423. 

  1423.                 $Item[ 'value' ] .= get_Local_Timezone_Offset( );

    1424. 

  1424.         }

    1425. 

  1425. 

    1426. 

  1426. 

    1427. 

  1427.         // The XAP ModifyDate tag contains last resource change date  - Find it and Update the value to the current date

    1428. 

  1428.         $Item = & find_XMP_item( $XAP_block, "xap:ModifyDate" );

    1429. 

  1429.         $Item[ 'value' ] = date( "Y-m-d\TH:i:s" );

    1430. 

  1430.         $Item[ 'value' ] .= get_Local_Timezone_Offset( );

    1431. 

  1431. 

    1432. 

  1432.         // The XAP ModifyDate tag contains last XMP change date  - Find it and Update the value to the current date

    1433. 

  1433.         $Item = & find_XMP_item( $XAP_block, "xap:MetadataDate" );

    1434. 

  1434.         $Item[ 'value' ] = date( "Y-m-d\TH:i:s" );

    1435. 

  1435.         $Item[ 'value' ] .= get_Local_Timezone_Offset( );

    1436. 

  1436. 

    1437. 

  1437. 

    1438. 

  1438. 

    1439. 

  1439.         // The XAP CreatorTool tag contains name of the software editor  - Find it

    1440. 

  1440.         $Item = & find_XMP_item( $XAP_block, "xap:CreatorTool" );

    1441. 

  1441. 

    1442. 

  1442.         // Photoshop replaces the CreatorTool with "Adobe Photoshop ..."

    1443. 

  1443.         // This toolkit instead preserves existing value and appends the toolkit name to the end of it

    1444. 

  1444. 

    1445. 

  1445.         // Check if a CreatorTool already exists

    1446. 

  1446.         if ( $Item[ 'value' ] != "" )

    1447. 

  1447.         {

    1448. 

  1448.                 // An existing CreatorTool was found

    1449. 

  1449.                 // Check if the existing CreatorTool already contains the Toolkit's name

    1450. 

  1450.                 if ( stristr ( $Item[ 'value' ], $GLOBALS[ "Software Name" ]) == FALSE )

    1451. 

  1451.                 {

    1452. 

  1452.                         // Toolkit Name string not found in the existing CreatorTool string - append it.

    1453. 

  1453.                         $Item[ 'value' ] = $Item[ 'value' ] . " " . $GLOBALS[ "Software Name" ];

    1454. 

  1454.                 }

    1455. 

  1455.                 else

    1456. 

  1456.                 {

    1457. 

  1457.                         // Toolkit name already exists in CreatorTool string - leave as is

    1458. 

  1458.                 }

    1459. 

  1459.         }

    1460. 

  1460.         else

    1461. 

  1461.         {

    1462. 

  1462.                 // No CreatorTool string exists - create one

    1463. 

  1463.                 $Item[ 'value' ] = $GLOBALS[ "Software Name" ];

    1464. 

  1464.         }

    1465. 

  1465. 

    1466. 

  1466. 

    1467. 

  1467. 

    1468. 

  1468. 

    1469. 

  1469.         // Process the XMP Basic Job Information block

    1470. 

  1470. 

    1471. 

  1471.         // Find the XAP Basic Job Information within the XMP block

    1472. 

  1472.         $XAPBJ_block = & find_XMP_block( $new_XMP_array, "xapBJ" );

    1473. 

  1473. 

    1474. 

  1474.         // The XAP Basic Job JobRef tag contains urgency - Find it and Update the value

    1475. 

  1475.         $Item = & find_XMP_item( $XAPBJ_block, "xapBJ:JobRef" );

    1476. 

  1476.         $Item[ 'children' ][ 0 ][ 'children' ] =

    1477. 

  1477.                 array( array (  'tag'        => 'rdf:li',

    1478. 

  1478.                                 'attributes' => array ( 'rdf:parseType' => 'Resource' ),

    1479. 

  1479.                                 'children'   => array ( 0 => array (    'tag'   => 'stJob:name',

    1480. 

  1480.                                                                         'value' => $new_ps_file_info_array[ 'jobname' ] ),

    1481. 

  1481.                                                       ),

    1482. 

  1482.                              ),

    1483. 

  1483.                      );

    1484. 

  1484. 

    1485. 

  1485. 

    1486. 

  1486. 

    1487. 

  1487. 

    1488. 

  1488.         // Process the XMP XAP Rights Information block

    1489. 

  1489. 

    1490. 

  1490.         // Find the XAP Rights Information within the XMP block

    1491. 

  1491.         $XAPRights_block = & find_XMP_block( $new_XMP_array, "xapRights" );

    1492. 

  1492. 

    1493. 

  1493. 

    1494. 

  1494. 

    1495. 

  1495.         // The XAP Rights Marked tag should only be present if copyrightstatus is 'Copyrighted Work' or 'Public Domain'

    1496. 

  1496.         // If copyrightstatus 'Unmarked' or anything else, the XAP Rights Marked tag should be missing

    1497. 

  1497. 

    1498. 

  1498. 

    1499. 

  1499.         // Remove any existing XAP Rights Marked tags - they will be replaced

    1500. 

  1500.         foreach( $XAPRights_block as  $tagno => $tag )

    1501. 

  1501.         {

    1502. 

  1502.                 if ( $tag[ 'tag' ] == "xapRights:Marked" )

    1503. 

  1503.                 {

    1504. 

  1504.                         array_splice( $XAPRights_block, $tagno, 1 );

    1505. 

  1505.                 }

    1506. 

  1506.         }

    1507. 

  1507. 

    1508. 

  1508.         // Check the value of the copyrightstatus flag

    1509. 

  1509.         if ( $new_ps_file_info_array[ 'copyrightstatus' ] == "Copyrighted Work" )

    1510. 

  1510.         {

    1511. 

  1511.                 // Copyrighted - add the tag

    1512. 

  1512.                 $XAPRights_block[] = array ( 'tag' => 'xapRights:Marked', 'value' => 'True' );

    1513. 

  1513.         }

    1514. 

  1514.         else if ( $new_ps_file_info_array[ 'copyrightstatus' ] == "Public Domain" )

    1515. 

  1515.         {

    1516. 

  1516.                 // Public domain - add the tag

    1517. 

  1517.                 $XAPRights_block[] = array ( 'tag' => 'xapRights:Marked', 'value' => 'False' );

    1518. 

  1518.         }

    1519. 

  1519.         else

    1520. 

  1520.         {

    1521. 

  1521.                 // Unmarked or Other - Do nothing - don't add a Marked tag

    1522. 

  1522.         }

    1523. 

  1523. 

    1524. 

  1524. 

    1525. 

  1525.         // The XAP Rights WebStatement tag contains ownerurl - Find it and Update the value

    1526. 

  1526.         $Item = & find_XMP_item( $XAPRights_block, "xapRights:WebStatement" );

    1527. 

  1527.         $Item[ 'value' ] = $new_ps_file_info_array[ 'ownerurl' ];

    1528. 

  1528. 

    1529. 

  1529. 

    1530. 

  1530. 

    1531. 

  1531. 

    1532. 

  1532.         // Process the XMP Dublin Core block

    1533. 

  1533. 

    1534. 

  1534.         // Find the Dublin Core Information within the XMP block

    1535. 

  1535.         $DC_block = & find_XMP_block( $new_XMP_array, "dc" );

    1536. 

  1536. 

    1537. 

  1537. 

    1538. 

  1538.         // The Dublin Core description tag contains caption - Find it and Update the value

    1539. 

  1539.         $Item = & find_XMP_item( $DC_block, "dc:description" );

    1540. 

  1540.         $Item[ 'children' ][ 0 ][ 'children' ] = array( array(  'tag'   => "rdf:li",

    1541. 

  1541.                                                                 'value' => $new_ps_file_info_array[ 'caption' ],

    1542. 

  1542.                                                                 'attributes' => array( 'xml:lang' => "x-default" ) ) );

    1543. 

  1543. 

    1544. 

  1544. 

    1545. 

  1545.         // The Dublin Core title tag contains title - Find it and Update the value

    1546. 

  1546.         $Item = & find_XMP_item( $DC_block, "dc:title" );

    1547. 

  1547.         $Item[ 'children' ][ 0 ][ 'children' ] = array( array(  'tag'   => "rdf:li",

    1548. 

  1548.                                                                 'value' => $new_ps_file_info_array[ 'title' ],

    1549. 

  1549.                                                                 'attributes' => array( 'xml:lang' => "x-default" ) ) );

    1550. 

  1550. 

    1551. 

  1551. 

    1552. 

  1552.         // The Dublin Core rights tag contains copyrightnotice - Find it and Update the value

    1553. 

  1553.         $Item = & find_XMP_item( $DC_block, "dc:rights" );

    1554. 

  1554.         $Item[ 'children' ][ 0 ][ 'children' ] = array( array(  'tag'   => "rdf:li",

    1555. 

  1555.                                                                 'value' => $new_ps_file_info_array[ 'copyrightnotice' ],

    1556. 

  1556.                                                                 'attributes' => array( 'xml:lang' => "x-default" ) ) );

    1557. 

  1557. 

    1558. 

  1558.         // The Dublin Core creator tag contains author - Find it and Update the value

    1559. 

  1559.         $Item = & find_XMP_item( $DC_block, "dc:creator" );

    1560. 

  1560.         $Item[ 'children' ][ 0 ][ 'children' ] = array( array(  'tag'   => "rdf:li",

    1561. 

  1561.                                                                 'value' => $new_ps_file_info_array[ 'author' ]) );

    1562. 

  1562. 

    1563. 

  1563.         // The Dublin Core subject tag contains keywords - Find it

    1564. 

  1564.         $Item = & find_XMP_item( $DC_block, "dc:subject" );

    1565. 

  1565. 

    1566. 

  1566.         // Create an array to receive the Keywords List Items

    1567. 

  1567.         $new_keywords_array = array( );

    1568. 

  1568. 

    1569. 

  1569.         // Cycle through each keyword

    1570. 

  1570.         foreach( $new_ps_file_info_array[ 'keywords' ] as $keyword )

    1571. 

  1571.         {

    1572. 

  1572.                 // Add a List item for this keyword

    1573. 

  1573.                 $new_keywords_array[] = array(  'tag'   => "rdf:li", 'value' => $keyword );

    1574. 

  1574.         }

    1575. 

  1575.         // Add the Keywords List Items array to the Dublin Core subject tag

    1576. 

  1576.         $Item[ 'children' ][ 0 ][ 'children' ] = $new_keywords_array;

    1577. 

  1577. 

    1578. 

  1578. 

    1579. 

  1579. 

    1580. 

  1580.         /***************************************/

    1581. 

  1581. 

    1582. 

  1582.         // FINISHED UPDATING VALUES

    1583. 

  1583. 

    1584. 

  1584.         // Insert the new IPTC array into the Photoshop IRB array

    1585. 

  1585.         $new_IRB_array = put_Photoshop_IPTC( $new_IRB_array, $new_IPTC_array );

    1586. 

  1586. 

    1587. 

  1587.         // Write the EXIF array to the JPEG header

    1588. 

  1588.         $jpeg_header_data = put_EXIF_JPEG( $new_Exif_array, $jpeg_header_data );

    1589. 

  1589. 

    1590. 

  1590.         // Convert the XMP array to XMP text

    1591. 

  1591.         $xmp_text = write_XMP_array_to_text( $new_XMP_array );

    1592. 

  1592. 

    1593. 

  1593.         // Write the XMP text to the JPEG Header

    1594. 

  1594.         $jpeg_header_data = put_XMP_text( $jpeg_header_data, $xmp_text );

    1595. 

  1595. 

    1596. 

  1596.         // Write the Photoshop IRB array to the JPEG header

    1597. 

  1597.         $jpeg_header_data = put_Photoshop_IRB( $jpeg_header_data, $new_IRB_array );

    1598. 

  1598. 

    1599. 

  1599.         return $jpeg_header_data;

    1600. 

  1600. 

    1601. 

  1601. }

    1602. 

  1602. 

    1603. 

  1603. /******************************************************************************

    1604. 

  1604. * End of Function:     put_photoshop_file_info

    1605. 

  1605. ******************************************************************************/

    1606. 

  1606. 

    1607. 

  1607. 

    1608. 

  1608. 

    1609. 

  1609. 

    1610. 

  1610. 

    1611. 

  1611. 

    1612. 

  1612. 

    1613. 

  1613. 

    1614. 

  1614. 

    1615. 

  1615. 

    1616. 

  1616. 

    1617. 

  1617. 

    1618. 

  1618. 

    1619. 

  1619. 

    1620. 

  1620. 

    1621. 

  1621. 

    1622. 

  1622. 

    1623. 

  1623. 

    1624. 

  1624. 

    1625. 

  1625. 

    1626. 

  1626. 

    1627. 

  1627. 

    1628. 

  1628. 

    1629. 

  1629. 

    1630. 

  1630. 

    1631. 

  1631. 

    1632. 

  1632. 

    1633. 

  1633. 

    1634. 

  1634. 

    1635. 

  1635. 

    1636. 

  1636. 

    1637. 

  1637. 

    1638. 

  1638. 

    1639. 

  1639. 

    1640. 

  1640. 

    1641. 

  1641. /******************************************************************************

    1642. 

  1642. *

    1643. 

  1643. *         INTERNAL FUNCTIONS

    1644. 

  1644. *

    1645. 

  1645. ******************************************************************************/

    1646. 

  1646. 

    1647. 

  1647. 

    1648. 

  1648. 

    1649. 

  1649. 

    1650. 

  1650. 

    1651. 

  1651. 

    1652. 

  1652. 

    1653. 

  1653. 

    1654. 

  1654. 

    1655. 

  1655. 

    1656. 

  1656. 

    1657. 

  1657. 

    1658. 

  1658. 

    1659. 

  1659. 

    1660. 

  1660. 

    1661. 

  1661. 

    1662. 

  1662. 

    1663. 

  1663. 

    1664. 

  1664. 

    1665. 

  1665. 

    1666. 

  1666. 

    1667. 

  1667. 

    1668. 

  1668. 

    1669. 

  1669. 

    1670. 

  1670. 

    1671. 

  1671. 

    1672. 

  1672. 

    1673. 

  1673. 

    1674. 

  1674. 

    1675. 

  1675. 

    1676. 

  1676. 

    1677. 

  1677. 

    1678. 

  1678. 

    1679. 

  1679. 

    1680. 

  1680. /******************************************************************************

    1681. 

  1681. *

    1682. 

  1682. * Function:     get_Local_Timezone_Offset

    1683. 

  1683. *

    1684. 

  1684. * Description:  Returns a string indicating the time difference between the local

    1685. 

  1685. *               timezone and GMT in hours and minutes, e.g.  +10:00 or -06:30

    1686. 

  1686. *

    1687. 

  1687. * Parameters:   None

    1688. 

  1688. *

    1689. 

  1689. * Returns:      $tz_str - a string containing the timezone offset

    1690. 

  1690. *

    1691. 

  1691. ******************************************************************************/

    1692. 

  1692. 

    1693. 

  1693. function get_Local_Timezone_Offset( )

    1694. 

  1694. {

    1695. 

  1695.         // Retrieve the Timezone offset in seconds

    1696. 

  1696.         $tz_seconds = date( "Z" );

    1697. 

  1697. 

    1698. 

  1698.         // Check if the offset is less than zero

    1699. 

  1699.         if ( $tz_seconds < 0 )

    1700. 

  1700.         {

    1701. 

  1701.                 // Offset is less than zero - add a Minus sign to the output

    1702. 

  1702.                 $tz_str = "-";

    1703. 

  1703.         }

    1704. 

  1704.         else

    1705. 

  1705.         {

    1706. 

  1706.                 // Offset is greater than or equal to zero - add a Plus sign to the output

    1707. 

  1707.                 $tz_str = "+";

    1708. 

  1708.         }

    1709. 

  1709. 

    1710. 

  1710.         // Add the absolute offset to the output, formatted as HH:MM

    1711. 

  1711.         $tz_str .= gmdate( "H:i", abs($tz_seconds) );

    1712. 

  1712. 

    1713. 

  1713.         // Return the result

    1714. 

  1714.         return $tz_str;

    1715. 

  1715. }

    1716. 

  1716. 

    1717. 

  1717. /******************************************************************************

    1718. 

  1718. * End of Function:     get_Local_Timezone_Offset

    1719. 

  1719. ******************************************************************************/

    1720. 

  1720. 

    1721. 

  1721. 

    1722. 

  1722. 

    1723. 

  1723. /******************************************************************************

    1724. 

  1724. *

    1725. 

  1725. * Function:     XMP_Check

    1726. 

  1726. *

    1727. 

  1727. * Description:  Checks a given XMP array against a reference array, and adds any

    1728. 

  1728. *               missing blocks and tags

    1729. 

  1729. *

    1730. 

  1730. *               NOTE: This is a recursive function

    1731. 

  1731. *

    1732. 

  1732. * Parameters:   reference_array - The standard XMP array which contains all required tags

    1733. 

  1733. *               check_array - The XMP array to check

    1734. 

  1734. *

    1735. 

  1735. * Returns:      output - a string containing the timezone offset

    1736. 

  1736. *

    1737. 

  1737. ******************************************************************************/

    1738. 

  1738. 

    1739. 

  1739. function XMP_Check( $reference_array, $check_array)

    1740. 

  1740. {

    1741. 

  1741.         // Cycle through each of the elements of the reference XMP array

    1742. 

  1742.         foreach( $reference_array as $valkey => $val )

    1743. 

  1743.         {

    1744. 

  1744. 

    1745. 

  1745.                 // Search for the current reference tag within the XMP array to be checked

    1746. 

  1746.                 $tagpos = find_XMP_Tag( $check_array,  $val );

    1747. 

  1747. 

    1748. 

  1748.                 // Check if the tag was found

    1749. 

  1749.                 if ( $tagpos === FALSE )

    1750. 

  1750.                 {

    1751. 

  1751.                         // Tag not found - Add tag to array being checked

    1752. 

  1752.                         $tagpos = count( $check_array );

    1753. 

  1753.                         $check_array[ $tagpos ] = $val;

    1754. 

  1754.                 }

    1755. 

  1755. 

    1756. 

  1756.                 // Check if the reference tag has children

    1757. 

  1757.                 if ( array_key_exists( 'children', $val ) )

    1758. 

  1758.                 {

    1759. 

  1759.                         // Reference tag has children - these need to be checked too

    1760. 

  1760. 

    1761. 

  1761.                         // Determine if the array being checked has children for this tag

    1762. 

  1762.                         if ( ! array_key_exists( 'children', $check_array[ $tagpos ] ) )

    1763. 

  1763.                         {

    1764. 

  1764.                                 // Array being checked has no children - add a blank children array

    1765. 

  1765.                                 $check_array[ $tagpos ][ 'children' ] = array( );

    1766. 

  1766.                         }

    1767. 

  1767. 

    1768. 

  1768.                         // Recurse, checking the children tags against the reference children

    1769. 

  1769.                         $check_array[ $tagpos ][ 'children' ] = XMP_Check( $val[ 'children' ] , $check_array[ $tagpos ][ 'children' ] );

    1770. 

  1770.                 }

    1771. 

  1771.                 else

    1772. 

  1772.                 {

    1773. 

  1773.                         // No children - don't need to check anything else

    1774. 

  1774.                 }

    1775. 

  1775.         }

    1776. 

  1776. 

    1777. 

  1777.         // Return the checked XMP array

    1778. 

  1778.         return $check_array;

    1779. 

  1779. }

    1780. 

  1780. 

    1781. 

  1781. 

    1782. 

  1782. /******************************************************************************

    1783. 

  1783. * End of Function:     XMP_Check

    1784. 

  1784. ******************************************************************************/

    1785. 

  1785. 

    1786. 

  1786. 

    1787. 

  1787. 

    1788. 

  1788. 

    1789. 

  1789. /******************************************************************************

    1790. 

  1790. *

    1791. 

  1791. * Function:     find_XMP_Tag

    1792. 

  1792. *

    1793. 

  1793. * Description:  Searches one level of an XMP array for a specific tag, and

    1794. 

  1794. *               returns the tag position. Does not descend the XMP tree.

    1795. 

  1795. *

    1796. 

  1796. * Parameters:   XMP_array - The XMP array which should be searched

    1797. 

  1797. *               tag - The XMP tag to search for (in same format as would be found in XMP array)

    1798. 

  1798. *

    1799. 

  1799. * Returns:      output - a string containing the timezone offset

    1800. 

  1800. *

    1801. 

  1801. ******************************************************************************/

    1802. 

  1802. 

    1803. 

  1803. function find_XMP_Tag( $XMP_array, $tag )

    1804. 

  1804. {

    1805. 

  1805.         $namespacestr = "";

    1806. 

  1806. 

    1807. 

  1807.         // Some tags have a namespace attribute which defines them (i.e. rdf:Description tags)

    1808. 

  1808. 

    1809. 

  1809.         // Check if the tag being searched for has attributs

    1810. 

  1810.         if ( array_key_exists( 'attributes', $tag ) )

    1811. 

  1811.         {

    1812. 

  1812.                 // Tag has attributes - cycle through them

    1813. 

  1813.                 foreach( $tag['attributes'] as $key => $val )

    1814. 

  1814.                 {

    1815. 

  1815.                         // Check if the current attribute is the namespace attribute - i.e. starts with xmlns:

    1816. 

  1816.                         if ( strcasecmp( substr($key,0,6), "xmlns:" ) == 0 )

    1817. 

  1817.                         {

    1818. 

  1818.                                 // Found a namespace attribute - save it for later.

    1819. 

  1819.                                 $namespacestr = $key;

    1820. 

  1820.                         }

    1821. 

  1821.                 }

    1822. 

  1822.         }

    1823. 

  1823. 

    1824. 

  1824. 

    1825. 

  1825. 

    1826. 

  1826.         // Cycle through the elements of the XMP array to be searched.

    1827. 

  1827.         foreach( $XMP_array as $valkey => $val )

    1828. 

  1828.         {

    1829. 

  1829. 

    1830. 

  1830.                 // Check if the current element is a rdf:Description tag

    1831. 

  1831.                 if ( strcasecmp ( $tag[ 'tag' ], 'rdf:Description' ) == 0 )

    1832. 

  1832.                 {

    1833. 

  1833.                         // Current element is a rdf:Description tag

    1834. 

  1834.                         // Check if the namespace attribute is the same as in the tag that is being searched for

    1835. 

  1835.                         if ( array_key_exists( $namespacestr, $val['attributes'] ) )

    1836. 

  1836.                         {

    1837. 

  1837.                                 // Namespace is the same - this is the correct tag - return it's position

    1838. 

  1838.                                 return $valkey;

    1839. 

  1839.                         }

    1840. 

  1840.                 }

    1841. 

  1841.                 // Otherwise check if the current element has the same name as the tag in question

    1842. 

  1842.                 else if ( strcasecmp ( $val[ 'tag' ], $tag[ 'tag' ] ) == 0 )

    1843. 

  1843.                 {

    1844. 

  1844.                         // Tags have same name - this is the correct tag - return it's position

    1845. 

  1845.                         return $valkey;

    1846. 

  1846.                 }

    1847. 

  1847.         }

    1848. 

  1848. 

    1849. 

  1849.         // Cycled through all tags without finding the correct one - return error value

    1850. 

  1850.         return FALSE;

    1851. 

  1851. }

    1852. 

  1852. 

    1853. 

  1853. /******************************************************************************

    1854. 

  1854. * End of Function:     find_XMP_Tag

    1855. 

  1855. ******************************************************************************/

    1856. 

  1856. 

    1857. 

  1857. 

    1858. 

  1858. 

    1859. 

  1859. 

    1860. 

  1860. /******************************************************************************

    1861. 

  1861. *

    1862. 

  1862. * Function:     create_GUID

    1863. 

  1863. *

    1864. 

  1864. * Description:  Creates a Globally Unique IDentifier, in the format that is used

    1865. 

  1865. *               by XMP (and Windows). This value is not guaranteed to be 100% unique,

    1866. 

  1866. *               but it is ridiculously unlikely that two identical values will be produced

    1867. 

  1867. *

    1868. 

  1868. * Parameters:   none

    1869. 

  1869. *

    1870. 

  1870. * Returns:      output - a string containing the timezone offset

    1871. 

  1871. *

    1872. 

  1872. ******************************************************************************/

    1873. 

  1873. 

    1874. 

  1874. function create_GUID( )

    1875. 

  1875. {

    1876. 

  1876.         // Create a md5 sum of a random number - this is a 32 character hex string

    1877. 

  1877.         $raw_GUID = md5( uniqid( getmypid() . rand( ) . (double)microtime()*1000000, TRUE ) );

    1878. 

  1878. 

    1879. 

  1879.         // Format the string into 8-4-4-4-12 (numbers are the number of characters in each block)

    1880. 

  1880.         return  substr($raw_GUID,0,8) . "-" . substr($raw_GUID,8,4) . "-" . substr($raw_GUID,12,4) . "-" . substr($raw_GUID,16,4) . "-" . substr($raw_GUID,20,12);

    1881. 

  1881. }

    1882. 

  1882. 

    1883. 

  1883. /******************************************************************************

    1884. 

  1884. * End of Function:     create_GUID

    1885. 

  1885. ******************************************************************************/

    1886. 

  1886. 

    1887. 

  1887. 

    1888. 

  1888. 

    1889. 

  1889. 

    1890. 

  1890. 

    1891. 

  1891. /******************************************************************************

    1892. 

  1892. *

    1893. 

  1893. * Function:     add_to_field

    1894. 

  1894. *

    1895. 

  1895. * Description:  Adds a value to a particular field in a Photoshop File Info array,

    1896. 

  1896. *               first checking whether the value is already there. If the value is

    1897. 

  1897. *               already in the array, it is not changed, otherwise the value is appended

    1898. 

  1898. *               to whatever is already in that field of the array

    1899. 

  1899. *

    1900. 

  1900. * Parameters:   field_array - The Photoshop File Info array to receive the new value

    1901. 

  1901. *               field - The File Info field which the value is for

    1902. 

  1902. *               value - The value to be written into the File Info

    1903. 

  1903. *               separator - The string to place between values when having to append the value

    1904. 

  1904. *

    1905. 

  1905. * Returns:      output - the Photoshop File Info array with the value added

    1906. 

  1906. *

    1907. 

  1907. ******************************************************************************/

    1908. 

  1908. 

    1909. 

  1909. function add_to_field( $field_array, $field, $value, $separator )

    1910. 

  1910. {

    1911. 

  1911.         // Check if the value is blank

    1912. 

  1912.         if ( $value == "" )

    1913. 

  1913.         {

    1914. 

  1914.                 // Value is blank - return File Info array unchanged

    1915. 

  1915.                 return $field_array;

    1916. 

  1916.         }

    1917. 

  1917. 

    1918. 

  1918.         // Check if the value can be found anywhere within the existing value for this field

    1919. 

  1919.         if ( stristr ( $field_array[ $field ], $value ) == FALSE)

    1920. 

  1920.         {

    1921. 

  1921.                 // Value could not be found

    1922. 

  1922.                 // Check if the existing value for the field is blank

    1923. 

  1923.                 if ( $field_array[$field] != "" )

    1924. 

  1924.                 {

    1925. 

  1925.                         // Existing value for field is not blank - append a separator

    1926. 

  1926.                         $field_array[$field] .= $separator;

    1927. 

  1927.                 }

    1928. 

  1928.                 // Append the value to the field

    1929. 

  1929.                 $field_array[$field] .= $value;

    1930. 

  1930.         }

    1931. 

  1931. 

    1932. 

  1932.         // Return the File Info Array

    1933. 

  1933.         return $field_array;

    1934. 

  1934. }

    1935. 

  1935. 

    1936. 

  1936. /******************************************************************************

    1937. 

  1937. * End of Function:     add_to_field

    1938. 

  1938. ******************************************************************************/

    1939. 

  1939. 

    1940. 

  1940. 

    1941. 

  1941. 

    1942. 

  1942. /******************************************************************************

    1943. 

  1943. *

    1944. 

  1944. * Function:     find_IPTC_Resource

    1945. 

  1945. *

    1946. 

  1946. * Description:  Searches an IPTC array for a particular record, and returns it if found

    1947. 

  1947. *

    1948. 

  1948. * Parameters:   IPTC_array - The IPTC array to search

    1949. 

  1949. *               record_type - The IPTC record number to search for (e.g.  2:151 )

    1950. 

  1950. *

    1951. 

  1951. * Returns:      output - the contents of the record if found

    1952. 

  1952. *               FALSE - otherwise

    1953. 

  1953. *

    1954. 

  1954. ******************************************************************************/

    1955. 

  1955. 

    1956. 

  1956. function find_IPTC_Resource( $IPTC_array, $record_type )

    1957. 

  1957. {

    1958. 

  1958.         // Cycle through the ITPC records

    1959. 

  1959.         foreach ($IPTC_array as $record)

    1960. 

  1960.         {

    1961. 

  1961.                 // Check the IPTC type against the required type

    1962. 

  1962.                 if ( $record['IPTC_Type'] == $record_type )

    1963. 

  1963.                 {

    1964. 

  1964.                         // IPTC type matches - return this record

    1965. 

  1965.                         return $record;

    1966. 

  1966.                 }

    1967. 

  1967.         }

    1968. 

  1968. 

    1969. 

  1969.         // No matching record found - return error code

    1970. 

  1970.         return FALSE;

    1971. 

  1971. }

    1972. 

  1972. 

    1973. 

  1973. /******************************************************************************

    1974. 

  1974. * End of Function:     find_IPTC_Resource

    1975. 

  1975. ******************************************************************************/

    1976. 

  1976. 

    1977. 

  1977. 

    1978. 

  1978. 

    1979. 

  1979. 

    1980. 

  1980. /******************************************************************************

    1981. 

  1981. *

    1982. 

  1982. * Function:     find_Photoshop_IRB_Resource

    1983. 

  1983. *

    1984. 

  1984. * Description:  Searches a Photoshop IRB array for a particular resource, and returns it if found

    1985. 

  1985. *

    1986. 

  1986. * Parameters:   IRB_array - The IRB array to search

    1987. 

  1987. *               resource_ID - The IRB resource number to search for (e.g.  0x03F9 )

    1988. 

  1988. *

    1989. 

  1989. * Returns:      output - the contents of the resource if found

    1990. 

  1990. *               FALSE - otherwise

    1991. 

  1991. *

    1992. 

  1992. ******************************************************************************/

    1993. 

  1993. 

    1994. 

  1994. function find_Photoshop_IRB_Resource( $IRB_array, $resource_ID )

    1995. 

  1995. {

    1996. 

  1996.         // Cycle through the IRB resources

    1997. 

  1997.         foreach( $IRB_array as $IRB_Resource )

    1998. 

  1998.         {

    1999. 

  1999.                 // Check the IRB resource ID against the required ID

    2000. 

  2000.                 if ( $resource_ID == $IRB_Resource['ResID'] )

    2001. 

  2001.                 {

    2002. 

  2002.                         // Resource ID matches - return this resource

    2003. 

  2003.                         return $IRB_Resource;

    2004. 

  2004.                 }

    2005. 

  2005.         }

    2006. 

  2006. 

    2007. 

  2007.         // No matching resource found - return error code

    2008. 

  2008.         return FALSE;

    2009. 

  2009. }

    2010. 

  2010. 

    2011. 

  2011. /******************************************************************************

    2012. 

  2012. * End of Function:     find_Photoshop_IRB_Resource

    2013. 

  2013. ******************************************************************************/

    2014. 

  2014. 

    2015. 

  2015. 

    2016. 

  2016. 

    2017. 

  2017. 

    2018. 

  2018. 

    2019. 

  2019. 

    2020. 

  2020. 

    2021. 

  2021. 

    2022. 

  2022. /******************************************************************************

    2023. 

  2023. *

    2024. 

  2024. * Function:     find_XMP_item

    2025. 

  2025. *

    2026. 

  2026. * Description:  Searches a one level of a XMP array for a particular item by name, and returns it if found.

    2027. 

  2027. *               Does not descend through the XMP array

    2028. 

  2028. *

    2029. 

  2029. * Parameters:   Item_Array - The XMP array to search

    2030. 

  2030. *               item_name - The name of the tag to serch for (e.g.  photoshop:CaptionWriter )

    2031. 

  2031. *

    2032. 

  2032. * Returns:      output - the contents of the tag if found

    2033. 

  2033. *               FALSE - otherwise

    2034. 

  2034. *

    2035. 

  2035. ******************************************************************************/

    2036. 

  2036. 

    2037. 

  2037. function & find_XMP_item( & $Item_Array, $item_name )

    2038. 

  2038. {

    2039. 

  2039.         // Cycle through the top level of the XMP array

    2040. 

  2040.         foreach( $Item_Array as $Item_Key => $Item )

    2041. 

  2041.         {

    2042. 

  2042.                 // Check this tag name against the required tag name

    2043. 

  2043.                 if( $Item['tag'] == $item_name )

    2044. 

  2044.                 {

    2045. 

  2045.                         // The tag names match - return the item

    2046. 

  2046.                         return $Item_Array[ $Item_Key ];

    2047. 

  2047.                 }

    2048. 

  2048.         }

    2049. 

  2049. 

    2050. 

  2050.         // No matching tag found - return error code

    2051. 

  2051.         return FALSE;

    2052. 

  2052. }

    2053. 

  2053. 

    2054. 

  2054. /******************************************************************************

    2055. 

  2055. * End of Function:     find_XMP_item

    2056. 

  2056. ******************************************************************************/

    2057. 

  2057. 

    2058. 

  2058. 

    2059. 

  2059. 

    2060. 

  2060. 

    2061. 

  2061. 

    2062. 

  2062. /******************************************************************************

    2063. 

  2063. *

    2064. 

  2064. * Function:     find_XMP_block

    2065. 

  2065. *

    2066. 

  2066. * Description:  Searches a for a particular rdf:Description block within a XMP array, and returns its children if found.

    2067. 

  2067. *

    2068. 

  2068. * Parameters:   XMP_array - The XMP array to search as returned by read_XMP_array_from_text

    2069. 

  2069. *               block_name - The namespace of the XMP block to be found (e.g.  photoshop or xapRights )

    2070. 

  2070. *

    2071. 

  2071. * Returns:      output - the children of the tag if found

    2072. 

  2072. *               FALSE - otherwise

    2073. 

  2073. *

    2074. 

  2074. ******************************************************************************/

    2075. 

  2075. 

    2076. 

  2076. function & find_XMP_block( & $XMP_array, $block_name )

    2077. 

  2077. {

    2078. 

  2078.         // Check that the rdf:RDF section can be found (which contains the rdf:Description tags

    2079. 

  2079.         if ( ( $XMP_array !== FALSE ) &&

    2080. 

  2080.              ( ( $XMP_array[0]['tag'] ==  "x:xapmeta" ) ||

    2081. 

  2081.                ( $XMP_array[0]['tag'] ==  "x:xmpmeta" ) ) &&

    2082. 

  2082.              ( $XMP_array[0]['children'][0]['tag'] ==  "rdf:RDF" ) )

    2083. 

  2083.         {

    2084. 

  2084.                 // Found rdf:RDF

    2085. 

  2085.                 // Make it's children easily accessible

    2086. 

  2086.                 $RDF_Contents = $XMP_array[0]['children'][0]['children'];

    2087. 

  2087. 

    2088. 

  2088.                 // Cycle through the children (rdf:Description tags)

    2089. 

  2089.                 foreach ($RDF_Contents as $RDF_Key => $RDF_Item)

    2090. 

  2090.                 {

    2091. 

  2091.                         // Check if this is a rdf:description tag that has children

    2092. 

  2092.                         if ( ( $RDF_Item['tag'] == "rdf:Description" ) &&

    2093. 

  2093.                              ( array_key_exists( 'children', $RDF_Item ) ) )

    2094. 

  2094.                         {

    2095. 

  2095.                                 // RDF Description tag has children,

    2096. 

  2096.                                 // Cycle through it's attributes

    2097. 

  2097.                                 foreach( $RDF_Item['attributes'] as $key => $val )

    2098. 

  2098.                                 {

    2099. 

  2099.                                         // Check if this attribute matches the namespace block name required

    2100. 

  2100.                                         if ( $key == "xmlns:$block_name" )

    2101. 

  2101.                                         {

    2102. 

  2102.                                                 // Namespace matches required block name - return it's children

    2103. 

  2103.                                                 return  $XMP_array[0]['children'][0]['children'][ $RDF_Key ]['children'];

    2104. 

  2104.                                         }

    2105. 

  2105.                                 }

    2106. 

  2106.                         }

    2107. 

  2107.                 }

    2108. 

  2108.         }

    2109. 

  2109. 

    2110. 

  2110.         // No matching rdf:Description block found

    2111. 

  2111.         return FALSE;

    2112. 

  2112. }

    2113. 

  2113. 

    2114. 

  2114. /******************************************************************************

    2115. 

  2115. * End of Function:     find_XMP_block

    2116. 

  2116. ******************************************************************************/

    2117. 

  2117. 

    2118. 

  2118. 

    2119. 

  2119. 

    2120. 

  2120. 

    2121. 

  2121. 

    2122. 

  2122. 

    2123. 

  2123. 

    2124. 

  2124. 

    2125. 

  2125. 

    2126. 

  2126. /******************************************************************************

    2127. 

  2127. * Global Variable:      Blank XMP Structure

    2128. 

  2128. *

    2129. 

  2129. * Contents:     A template XMP array which can be used to create a new XMP segment

    2130. 

  2130. *

    2131. 

  2131. ******************************************************************************/

    2132. 

  2132. 

    2133. 

  2133. // Create a GUID to be used in this template array

    2134. 

  2134. $new_GUID = create_GUID( );

    2135. 

  2135. 

    2136. 

  2136. $GLOBALS[ 'Blank XMP Structure' ] =

    2137. 

  2137. array (

    2138. 

  2138.   0 =>

    2139. 

  2139.   array (

    2140. 

  2140.     'tag' => 'x:xmpmeta',

    2141. 

  2141.     'attributes' =>

    2142. 

  2142.     array (

    2143. 

  2143.       'xmlns:x' => 'adobe:ns:meta/',

    2144. 

  2144.       'x:xmptk' => 'XMP toolkit 3.0-28, framework 1.6',

    2145. 

  2145.     ),

    2146. 

  2146.     'children' =>

    2147. 

  2147.     array (

    2148. 

  2148.       0 =>

    2149. 

  2149.       array (

    2150. 

  2150.         'tag' => 'rdf:RDF',

    2151. 

  2151.         'attributes' =>

    2152. 

  2152.         array (

    2153. 

  2153.           'xmlns:rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',

    2154. 

  2154.           'xmlns:iX' => 'http://ns.adobe.com/iX/1.0/',

    2155. 

  2155.         ),

    2156. 

  2156.         'children' =>

    2157. 

  2157.         array (

    2158. 

  2158.           1 =>

    2159. 

  2159.           array (

    2160. 

  2160.             'tag' => 'rdf:Description',

    2161. 

  2161.             'attributes' =>

    2162. 

  2162.             array (

    2163. 

  2163.               'rdf:about' => "uuid:$new_GUID",

    2164. 

  2164.               'xmlns:pdf' => 'http://ns.adobe.com/pdf/1.3/',

    2165. 

  2165.             ),

    2166. 

  2166.           ),

    2167. 

  2167.           2 =>

    2168. 

  2168.           array (

    2169. 

  2169.             'tag' => 'rdf:Description',

    2170. 

  2170.             'attributes' =>

    2171. 

  2171.             array (

    2172. 

  2172.               'rdf:about' => "uuid:$new_GUID",

    2173. 

  2173.               'xmlns:photoshop' => 'http://ns.adobe.com/photoshop/1.0/',

    2174. 

  2174.             ),

    2175. 

  2175.             'children' =>

    2176. 

  2176.             array (

    2177. 

  2177.               0 =>

    2178. 

  2178.               array (

    2179. 

  2179.                 'tag' => 'photoshop:CaptionWriter',

    2180. 

  2180.                 'value' => '',

    2181. 

  2181.               ),

    2182. 

  2182.               1 =>

    2183. 

  2183.               array (

    2184. 

  2184.                 'tag' => 'photoshop:Category',

    2185. 

  2185.                 'value' => '',

    2186. 

  2186.               ),

    2187. 

  2187.               2 =>

    2188. 

  2188.               array (

    2189. 

  2189.                 'tag' => 'photoshop:DateCreated',

    2190. 

  2190.                 'value' => '',

    2191. 

  2191.               ),

    2192. 

  2192.               3 =>

    2193. 

  2193.               array (

    2194. 

  2194.                 'tag' => 'photoshop:City',

    2195. 

  2195.                 'value' => '',

    2196. 

  2196.               ),

    2197. 

  2197.               4 =>

    2198. 

  2198.               array (

    2199. 

  2199.                 'tag' => 'photoshop:State',

    2200. 

  2200.                 'value' => '',

    2201. 

  2201.               ),

    2202. 

  2202.               5 =>

    2203. 

  2203.               array (

    2204. 

  2204.                 'tag' => 'photoshop:Country',

    2205. 

  2205.                 'value' => '',

    2206. 

  2206.               ),

    2207. 

  2207.               6 =>

    2208. 

  2208.               array (

    2209. 

  2209.                 'tag' => 'photoshop:Credit',

    2210. 

  2210.                 'value' => '',

    2211. 

  2211.               ),

    2212. 

  2212.               7 =>

    2213. 

  2213.               array (

    2214. 

  2214.                 'tag' => 'photoshop:Source',

    2215. 

  2215.                 'value' => '',

    2216. 

  2216.               ),

    2217. 

  2217.               8 =>

    2218. 

  2218.               array (

    2219. 

  2219.                 'tag' => 'photoshop:Headline',

    2220. 

  2220.                 'value' => '',

    2221. 

  2221.               ),

    2222. 

  2222.               9 =>

    2223. 

  2223.               array (

    2224. 

  2224.                 'tag' => 'photoshop:Instructions',

    2225. 

  2225.                 'value' => '',

    2226. 

  2226.               ),

    2227. 

  2227.               10 =>

    2228. 

  2228.               array (

    2229. 

  2229.                 'tag' => 'photoshop:TransmissionReference',

    2230. 

  2230.                 'value' => '',

    2231. 

  2231.               ),

    2232. 

  2232.               11 =>

    2233. 

  2233.               array (

    2234. 

  2234.                 'tag' => 'photoshop:Urgency',

    2235. 

  2235.                 'value' => '',

    2236. 

  2236.               ),

    2237. 

  2237.               12 =>

    2238. 

  2238.               array (

    2239. 

  2239.                 'tag' => 'photoshop:SupplementalCategories',

    2240. 

  2240.                 'children' =>

    2241. 

  2241.                 array (

    2242. 

  2242.                   0 =>

    2243. 

  2243.                   array (

    2244. 

  2244.                     'tag' => 'rdf:Bag',

    2245. 

  2245.                   ),

    2246. 

  2246.                 ),

    2247. 

  2247.               ),

    2248. 

  2248.               13 =>

    2249. 

  2249.               array (

    2250. 

  2250.                 'tag' => 'photoshop:AuthorsPosition',

    2251. 

  2251.                 'value' => '',

    2252. 

  2252.               ),

    2253. 

  2253.             ),

    2254. 

  2254.           ),

    2255. 

  2255.           4 =>

    2256. 

  2256.           array (

    2257. 

  2257.             'tag' => 'rdf:Description',

    2258. 

  2258.             'attributes' =>

    2259. 

  2259.             array (

    2260. 

  2260.               'rdf:about' => "uuid:$new_GUID",

    2261. 

  2261.               'xmlns:xap' => 'http://ns.adobe.com/xap/1.0/',

    2262. 

  2262.             ),

    2263. 

  2263.             'children' =>

    2264. 

  2264.             array (

    2265. 

  2265.               0 =>

    2266. 

  2266.               array (

    2267. 

  2267.                 'tag' => 'xap:CreateDate',

    2268. 

  2268.                 'value' => '',

    2269. 

  2269.               ),

    2270. 

  2270.               1 =>

    2271. 

  2271.               array (

    2272. 

  2272.                 'tag' => 'xap:ModifyDate',

    2273. 

  2273.                 'value' => '',

    2274. 

  2274.               ),

    2275. 

  2275.               2 =>

    2276. 

  2276.               array (

    2277. 

  2277.                 'tag' => 'xap:MetadataDate',

    2278. 

  2278.                 'value' => '',

    2279. 

  2279.               ),

    2280. 

  2280.               3 =>

    2281. 

  2281.               array (

    2282. 

  2282.                 'tag' => 'xap:CreatorTool',

    2283. 

  2283.                 'value' => '',

    2284. 

  2284.               ),

    2285. 

  2285.             ),

    2286. 

  2286.           ),

    2287. 

  2287.           5 =>

    2288. 

  2288.           array (

    2289. 

  2289.             'tag' => 'rdf:Description',

    2290. 

  2290.             'attributes' =>

    2291. 

  2291.             array (

    2292. 

  2292.               'about' => "uuid:$new_GUID",

    2293. 

  2293.               'xmlns:stJob' => 'http://ns.adobe.com/xap/1.0/sType/Job#',

    2294. 

  2294.               'xmlns:xapBJ' => 'http://ns.adobe.com/xap/1.0/bj/',

    2295. 

  2295.             ),

    2296. 

  2296.             'children' =>

    2297. 

  2297.             array (

    2298. 

  2298.               0 =>

    2299. 

  2299.               array (

    2300. 

  2300.                 'tag' => 'xapBJ:JobRef',

    2301. 

  2301.                 'children' =>

    2302. 

  2302.                 array (

    2303. 

  2303.                   0 =>

    2304. 

  2304.                   array (

    2305. 

  2305.                     'tag' => 'rdf:Bag',

    2306. 

  2306.                     'children' =>

    2307. 

  2307.                     array (

    2308. 

  2308.                     ),

    2309. 

  2309.                   ),

    2310. 

  2310.                 ),

    2311. 

  2311.               ),

    2312. 

  2312.             ),

    2313. 

  2313.           ),

    2314. 

  2314.           6 =>

    2315. 

  2315.           array (

    2316. 

  2316.             'tag' => 'rdf:Description',

    2317. 

  2317.             'attributes' =>

    2318. 

  2318.             array (

    2319. 

  2319.               'rdf:about' => "uuid:$new_GUID",

    2320. 

  2320.               'xmlns:xapRights' => 'http://ns.adobe.com/xap/1.0/rights/',

    2321. 

  2321.             ),

    2322. 

  2322.             'children' =>

    2323. 

  2323.             array (

    2324. 

  2324.               1 =>

    2325. 

  2325.               array (

    2326. 

  2326.                 'tag' => 'xapRights:WebStatement',

    2327. 

  2327.                 'value' => '',

    2328. 

  2328.               ),

    2329. 

  2329.             ),

    2330. 

  2330.           ),

    2331. 

  2331.           7 =>

    2332. 

  2332.           array (

    2333. 

  2333.             'tag' => 'rdf:Description',

    2334. 

  2334.             'attributes' =>

    2335. 

  2335.             array (

    2336. 

  2336.               'rdf:about' => "uuid:$new_GUID",

    2337. 

  2337.               'xmlns:dc' => 'http://purl.org/dc/elements/1.1/',

    2338. 

  2338.             ),

    2339. 

  2339.             'children' =>

    2340. 

  2340.             array (

    2341. 

  2341.               0 =>

    2342. 

  2342.               array (

    2343. 

  2343.                 'tag' => 'dc:format',

    2344. 

  2344.                 'value' => 'image/jpeg',

    2345. 

  2345.               ),

    2346. 

  2346.               1 =>

    2347. 

  2347.               array (

    2348. 

  2348.                 'tag' => 'dc:title',

    2349. 

  2349.                 'children' =>

    2350. 

  2350.                 array (

    2351. 

  2351.                   0 =>

    2352. 

  2352.                   array (

    2353. 

  2353.                     'tag' => 'rdf:Alt',

    2354. 

  2354.                   ),

    2355. 

  2355.                 ),

    2356. 

  2356.               ),

    2357. 

  2357.               2 =>

    2358. 

  2358.               array (

    2359. 

  2359.                 'tag' => 'dc:description',

    2360. 

  2360.                 'children' =>

    2361. 

  2361.                 array (

    2362. 

  2362.                   0 =>

    2363. 

  2363.                   array (

    2364. 

  2364.                     'tag' => 'rdf:Alt',

    2365. 

  2365.                   ),

    2366. 

  2366.                 ),

    2367. 

  2367.               ),

    2368. 

  2368.               3 =>

    2369. 

  2369.               array (

    2370. 

  2370.                 'tag' => 'dc:rights',

    2371. 

  2371.                 'children' =>

    2372. 

  2372.                 array (

    2373. 

  2373.                   0 =>

    2374. 

  2374.                   array (

    2375. 

  2375.                     'tag' => 'rdf:Alt',

    2376. 

  2376.                   ),

    2377. 

  2377.                 ),

    2378. 

  2378.               ),

    2379. 

  2379.               4 =>

    2380. 

  2380.               array (

    2381. 

  2381.                 'tag' => 'dc:creator',

    2382. 

  2382.                 'children' =>

    2383. 

  2383.                 array (

    2384. 

  2384.                   0 =>

    2385. 

  2385.                   array (

    2386. 

  2386.                     'tag' => 'rdf:Seq',

    2387. 

  2387.                   ),

    2388. 

  2388.                 ),

    2389. 

  2389.               ),

    2390. 

  2390.               5 =>

    2391. 

  2391.               array (

    2392. 

  2392.                 'tag' => 'dc:subject',

    2393. 

  2393.                 'children' =>

    2394. 

  2394.                 array (

    2395. 

  2395.                   0 =>

    2396. 

  2396.                   array (

    2397. 

  2397.                     'tag' => 'rdf:Bag',

    2398. 

  2398.                   ),

    2399. 

  2399.                 ),

    2400. 

  2400.               ),

    2401. 

  2401.             ),

    2402. 

  2402.           ),

    2403. 

  2403. 

    2404. 

  2404. /*          0 =>

    2405. 

  2405.           array (

    2406. 

  2406.             'tag' => 'rdf:Description',

    2407. 

  2407.             'attributes' =>

    2408. 

  2408.             array (

    2409. 

  2409.               'rdf:about' => "uuid:$new_GUID",

    2410. 

  2410.               'xmlns:exif' => 'http://ns.adobe.com/exif/1.0/',

    2411. 

  2411.             ),

    2412. 

  2412.             'children' =>

    2413. 

  2413.             array (

    2414. 

  2414. 

    2415. 

  2415. //EXIF DATA GOES HERE - Not Implemented yet

    2416. 

  2416.             ),

    2417. 

  2417.           ),

    2418. 

  2418. */

    2419. 

  2419. /*

    2420. 

  2420.           2 =>

    2421. 

  2421.           array (

    2422. 

  2422.             'tag' => 'rdf:Description',

    2423. 

  2423.             'attributes' =>

    2424. 

  2424.             array (

    2425. 

  2425.               'rdf:about' => "uuid:$new_GUID",

    2426. 

  2426.               'xmlns:tiff' => 'http://ns.adobe.com/tiff/1.0/',

    2427. 

  2427.             ),

    2428. 

  2428.             'children' =>

    2429. 

  2429.             array (

    2430. 

  2430. // TIFF DATA GOES HERE - Not Implemented yet

    2431. 

  2431.               0 =>

    2432. 

  2432.               array (

    2433. 

  2433.                 'tag' => 'tiff:Make',

    2434. 

  2434.                 'value' => 'NIKON CORPORATION',

    2435. 

  2435.               ),

    2436. 

  2436.             ),

    2437. 

  2437.           ),

    2438. 

  2438. */

    2439. 

  2439. /*

    2440. 

  2440.           3 =>

    2441. 

  2441.           array (

    2442. 

  2442.             'tag' => 'rdf:Description',

    2443. 

  2443.             'attributes' =>

    2444. 

  2444.             array (

    2445. 

  2445.               'rdf:about' => "uuid:$new_GUID",

    2446. 

  2446.               'xmlns:stRef' => 'http://ns.adobe.com/xap/1.0/sType/ResourceRef#',

    2447. 

  2447.               'xmlns:xapMM' => 'http://ns.adobe.com/xap/1.0/mm/',

    2448. 

  2448.             ),

    2449. 

  2449.             'children' =>

    2450. 

  2450.             array (

    2451. 

  2451. // XAPMM DATA GOES HERE - Not Implemented yet

    2452. 

  2452.               0 =>

    2453. 

  2453.               array (

    2454. 

  2454.                 'tag' => 'xapMM:DocumentID',

    2455. 

  2455.                 'value' => 'adobe:docid:photoshop:dceba4c2-e699-11d8-94b2-b6ec48319f2d',

    2456. 

  2456.               ),

    2457. 

  2457.               1 =>

    2458. 

  2458.               array (

    2459. 

  2459.                 'tag' => 'xapMM:DerivedFrom',

    2460. 

  2460.                 'attributes' =>

    2461. 

  2461.                 array (

    2462. 

  2462.                   'rdf:parseType' => 'Resource',

    2463. 

  2463.                 ),

    2464. 

  2464.                 'children' =>

    2465. 

  2465.                 array (

    2466. 

  2466.                   0 =>

    2467. 

  2467.                   array (

    2468. 

  2468.                     'tag' => 'stRef:documentID',

    2469. 

  2469.                     'value' => 'adobe:docid:photoshop:5144475b-e698-11d8-94b2-b6ec48319f2d',

    2470. 

  2470.                   ),

    2471. 

  2471.                   1 =>

    2472. 

  2472.                   array (

    2473. 

  2473.                     'tag' => 'stRef:instanceID',

    2474. 

  2474.                     'value' => "uuid:$new_GUID",

    2475. 

  2475.                   ),

    2476. 

  2476.                 ),

    2477. 

  2477.               ),

    2478. 

  2478.             ),

    2479. 

  2479.           ),

    2480. 

  2480. */

    2481. 

  2481. 

    2482. 

  2482.         ),

    2483. 

  2483.       ),

    2484. 

  2484.     ),

    2485. 

  2485.   ),

    2486. 

  2486. );

    2487. 

  2487. 

    2488. 

  2488. 

    2489. 

  2489. 

    2490. 

  2490. /******************************************************************************

    2491. 

  2491. * End of Global Variable:     Blank XMP Structure

    2492. 

  2492. ******************************************************************************/

    2493. 

  2493. 

    2494. 

  2494. 

    2495. 

  2495. 

    2496. 

  2496. 

    2497. 

  2497. 

    2498. 

  2498. ?>
    2499.