wp-includes/SimplePie/Item.php

   1 <?php
   2 /**
   3  * SimplePie
   4  *
   5  * A PHP-Based RSS and Atom Feed Framework.
   6  * Takes the hard work out of managing a complete RSS/Atom solution.
   7  *
   8  * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without modification, are
  12  * permitted provided that the following conditions are met:
  13  *
  14  *      * Redistributions of source code must retain the above copyright notice, this list of
  15  *        conditions and the following disclaimer.
  16  *
  17  *      * Redistributions in binary form must reproduce the above copyright notice, this list
  18  *        of conditions and the following disclaimer in the documentation and/or other materials
  19  *        provided with the distribution.
  20  *
  21  *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
  22  *        to endorse or promote products derived from this software without specific prior
  23  *        written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
  26  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  27  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
  28  * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  30  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  32  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  * @package SimplePie
  36  * @version 1.3.1
  37  * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
  38  * @author Ryan Parman
  39  * @author Geoffrey Sneddon
  40  * @author Ryan McCue
  41  * @link http://simplepie.org/ SimplePie
  42  * @license http://www.opensource.org/licenses/bsd-license.php BSD License
  43  */
  44
  45
  46 /**
  47  * Manages all item-related data
  48  *
  49  * Used by {@see SimplePie::get_item()} and {@see SimplePie::get_items()}
  50  *
  51  * This class can be overloaded with {@see SimplePie::set_item_class()}
  52  *
  53  * @package SimplePie
  54  * @subpackage API
  55  */
  56 class SimplePie_Item
  57 {
  58         /**
  59          * Parent feed
  60          *
  61          * @access private
  62          * @var SimplePie
  63          */
  64         var $feed;
  65
  66         /**
  67          * Raw data
  68          *
  69          * @access private
  70          * @var array
  71          */
  72         var $data = array();
  73
  74         /**
  75          * Registry object
  76          *
  77          * @see set_registry
  78          * @var SimplePie_Registry
  79          */
  80         protected $registry;
  81
  82         /**
  83          * Create a new item object
  84          *
  85          * This is usually used by {@see SimplePie::get_items} and
  86          * {@see SimplePie::get_item}. Avoid creating this manually.
  87          *
  88          * @param SimplePie $feed Parent feed
  89          * @param array $data Raw data
  90          */
  91         public function __construct($feed, $data)
  92         {
  93                 $this->feed = $feed;
  94                 $this->data = $data;
  95         }
  96
  97         /**
  98          * Set the registry handler
  99          *
 100          * This is usually used by {@see SimplePie_Registry::create}
 101          *
 102          * @since 1.3
 103          * @param SimplePie_Registry $registry
 104          */
 105         public function set_registry(SimplePie_Registry $registry)
 106         {
 107                 $this->registry = $registry;
 108         }
 109
 110         /**
 111          * Get a string representation of the item
 112          *
 113          * @return string
 114          */
 115         public function __toString()
 116         {
 117                 return md5(serialize($this->data));
 118         }
 119
 120         /**
 121          * Remove items that link back to this before destroying this object
 122          */
 123         public function __destruct()
 124         {
 125                 if ((version_compare(PHP_VERSION, '5.3', '<') || !gc_enabled()) && !ini_get('zend.ze1_compatibility_mode'))
 126                 {
 127                         unset($this->feed);
 128                 }
 129         }
 130
 131         /**
 132          * Get data for an item-level element
 133          *
 134          * This method allows you to get access to ANY element/attribute that is a
 135          * sub-element of the item/entry tag.
 136          *
 137          * See {@see SimplePie::get_feed_tags()} for a description of the return value
 138          *
 139          * @since 1.0
 140          * @see http://simplepie.org/wiki/faq/supported_xml_namespaces
 141          * @param string $namespace The URL of the XML namespace of the elements you're trying to access
 142          * @param string $tag Tag name
 143          * @return array
 144          */
 145         public function get_item_tags($namespace, $tag)
 146         {
 147                 if (isset($this->data['child'][$namespace][$tag]))
 148                 {
 149                         return $this->data['child'][$namespace][$tag];
 150                 }
 151                 else
 152                 {
 153                         return null;
 154                 }
 155         }
 156
 157         /**
 158          * Get the base URL value from the parent feed
 159          *
 160          * Uses `<xml:base>`
 161          *
 162          * @param array $element
 163          * @return string
 164          */
 165         public function get_base($element = array())
 166         {
 167                 return $this->feed->get_base($element);
 168         }
 169
 170         /**
 171          * Sanitize feed data
 172          *
 173          * @access private
 174          * @see SimplePie::sanitize()
 175          * @param string $data Data to sanitize
 176          * @param int $type One of the SIMPLEPIE_CONSTRUCT_* constants
 177          * @param string $base Base URL to resolve URLs against
 178          * @return string Sanitized data
 179          */
 180         public function sanitize($data, $type, $base = '')
 181         {
 182                 return $this->feed->sanitize($data, $type, $base);
 183         }
 184
 185         /**
 186          * Get the parent feed
 187          *
 188          * Note: this may not work as you think for multifeeds!
 189          *
 190          * @link http://simplepie.org/faq/typical_multifeed_gotchas#missing_data_from_feed
 191          * @since 1.0
 192          * @return SimplePie
 193          */
 194         public function get_feed()
 195         {
 196                 return $this->feed;
 197         }
 198
 199         /**
 200          * Get the unique identifier for the item
 201          *
 202          * This is usually used when writing code to check for new items in a feed.
 203          *
 204          * Uses `<atom:id>`, `<guid>`, `<dc:identifier>` or the `about` attribute
 205          * for RDF. If none of these are supplied (or `$hash` is true), creates an
 206          * MD5 hash based on the permalink and title. If either of those are not
 207          * supplied, creates a hash based on the full feed data.
 208          *
 209          * @since Beta 2
 210          * @param boolean $hash Should we force using a hash instead of the supplied ID?
 211          * @return string
 212          */
 213         public function get_id($hash = false)
 214         {
 215                 if (!$hash)
 216                 {
 217                         if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'id'))
 218                         {
 219                                 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 220                         }
 221                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'id'))
 222                         {
 223                                 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 224                         }
 225                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'guid'))
 226                         {
 227                                 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 228                         }
 229                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'identifier'))
 230                         {
 231                                 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 232                         }
 233                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'identifier'))
 234                         {
 235                                 return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 236                         }
 237                         elseif (isset($this->data['attribs'][SIMPLEPIE_NAMESPACE_RDF]['about']))
 238                         {
 239                                 return $this->sanitize($this->data['attribs'][SIMPLEPIE_NAMESPACE_RDF]['about'], SIMPLEPIE_CONSTRUCT_TEXT);
 240                         }
 241                         elseif (($return = $this->get_permalink()) !== null)
 242                         {
 243                                 return $return;
 244                         }
 245                         elseif (($return = $this->get_title()) !== null)
 246                         {
 247                                 return $return;
 248                         }
 249                 }
 250                 if ($this->get_permalink() !== null || $this->get_title() !== null)
 251                 {
 252                         return md5($this->get_permalink() . $this->get_title());
 253                 }
 254                 else
 255                 {
 256                         return md5(serialize($this->data));
 257                 }
 258         }
 259
 260         /**
 261          * Get the title of the item
 262          *
 263          * Uses `<atom:title>`, `<title>` or `<dc:title>`
 264          *
 265          * @since Beta 2 (previously called `get_item_title` since 0.8)
 266          * @return string|null
 267          */
 268         public function get_title()
 269         {
 270                 if (!isset($this->data['title']))
 271                 {
 272                         if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'title'))
 273                         {
 274                                 $this->data['title'] = $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 275                         }
 276                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'title'))
 277                         {
 278                                 $this->data['title'] = $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 279                         }
 280                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title'))
 281                         {
 282                                 $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
 283                         }
 284                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title'))
 285                         {
 286                                 $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
 287                         }
 288                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title'))
 289                         {
 290                                 $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
 291                         }
 292                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title'))
 293                         {
 294                                 $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 295                         }
 296                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title'))
 297                         {
 298                                 $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 299                         }
 300                         else
 301                         {
 302                                 $this->data['title'] = null;
 303                         }
 304                 }
 305                 return $this->data['title'];
 306         }
 307
 308         /**
 309          * Get the content for the item
 310          *
 311          * Prefers summaries over full content , but will return full content if a
 312          * summary does not exist.
 313          *
 314          * To prefer full content instead, use {@see get_content}
 315          *
 316          * Uses `<atom:summary>`, `<description>`, `<dc:description>` or
 317          * `<itunes:subtitle>`
 318          *
 319          * @since 0.8
 320          * @param boolean $description_only Should we avoid falling back to the content?
 321          * @return string|null
 322          */
 323         public function get_description($description_only = false)
 324         {
 325                 if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'summary'))
 326                 {
 327                         return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 328                 }
 329                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'summary'))
 330                 {
 331                         return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 332                 }
 333                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'description'))
 334                 {
 335                         return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
 336                 }
 337                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'description'))
 338                 {
 339                         return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
 340                 }
 341                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'description'))
 342                 {
 343                         return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 344                 }
 345                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'description'))
 346                 {
 347                         return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 348                 }
 349                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'summary'))
 350                 {
 351                         return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
 352                 }
 353                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'subtitle'))
 354                 {
 355                         return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 356                 }
 357                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'description'))
 358                 {
 359                         return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML);
 360                 }
 361
 362                 elseif (!$description_only)
 363                 {
 364                         return $this->get_content(true);
 365                 }
 366                 else
 367                 {
 368                         return null;
 369                 }
 370         }
 371
 372         /**
 373          * Get the content for the item
 374          *
 375          * Prefers full content over summaries, but will return a summary if full
 376          * content does not exist.
 377          *
 378          * To prefer summaries instead, use {@see get_description}
 379          *
 380          * Uses `<atom:content>` or `<content:encoded>` (RSS 1.0 Content Module)
 381          *
 382          * @since 1.0
 383          * @param boolean $content_only Should we avoid falling back to the description?
 384          * @return string|null
 385          */
 386         public function get_content($content_only = false)
 387         {
 388                 if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'content'))
 389                 {
 390                         return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_content_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 391                 }
 392                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'content'))
 393                 {
 394                         return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 395                 }
 396                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10_MODULES_CONTENT, 'encoded'))
 397                 {
 398                         return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
 399                 }
 400                 elseif (!$content_only)
 401                 {
 402                         return $this->get_description(true);
 403                 }
 404                 else
 405                 {
 406                         return null;
 407                 }
 408         }
 409
 410         /**
 411          * Get a category for the item
 412          *
 413          * @since Beta 3 (previously called `get_categories()` since Beta 2)
 414          * @param int $key The category that you want to return.  Remember that arrays begin with 0, not 1
 415          * @return SimplePie_Category|null
 416          */
 417         public function get_category($key = 0)
 418         {
 419                 $categories = $this->get_categories();
 420                 if (isset($categories[$key]))
 421                 {
 422                         return $categories[$key];
 423                 }
 424                 else
 425                 {
 426                         return null;
 427                 }
 428         }
 429
 430         /**
 431          * Get all categories for the item
 432          *
 433          * Uses `<atom:category>`, `<category>` or `<dc:subject>`
 434          *
 435          * @since Beta 3
 436          * @return array|null List of {@see SimplePie_Category} objects
 437          */
 438         public function get_categories()
 439         {
 440                 $categories = array();
 441
 442                 foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'category') as $category)
 443                 {
 444                         $term = null;
 445                         $scheme = null;
 446                         $label = null;
 447                         if (isset($category['attribs']['']['term']))
 448                         {
 449                                 $term = $this->sanitize($category['attribs']['']['term'], SIMPLEPIE_CONSTRUCT_TEXT);
 450                         }
 451                         if (isset($category['attribs']['']['scheme']))
 452                         {
 453                                 $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 454                         }
 455                         if (isset($category['attribs']['']['label']))
 456                         {
 457                                 $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
 458                         }
 459                         $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
 460                 }
 461                 foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'category') as $category)
 462                 {
 463                         // This is really the label, but keep this as the term also for BC.
 464                         // Label will also work on retrieving because that falls back to term.
 465                         $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 466                         if (isset($category['attribs']['']['domain']))
 467                         {
 468                                 $scheme = $this->sanitize($category['attribs']['']['domain'], SIMPLEPIE_CONSTRUCT_TEXT);
 469                         }
 470                         else
 471                         {
 472                                 $scheme = null;
 473                         }
 474                         $categories[] = $this->registry->create('Category', array($term, $scheme, null));
 475                 }
 476                 foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'subject') as $category)
 477                 {
 478                         $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
 479                 }
 480                 foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'subject') as $category)
 481                 {
 482                         $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
 483                 }
 484
 485                 if (!empty($categories))
 486                 {
 487                         return array_unique($categories);
 488                 }
 489                 else
 490                 {
 491                         return null;
 492                 }
 493         }
 494
 495         /**
 496          * Get an author for the item
 497          *
 498          * @since Beta 2
 499          * @param int $key The author that you want to return.  Remember that arrays begin with 0, not 1
 500          * @return SimplePie_Author|null
 501          */
 502         public function get_author($key = 0)
 503         {
 504                 $authors = $this->get_authors();
 505                 if (isset($authors[$key]))
 506                 {
 507                         return $authors[$key];
 508                 }
 509                 else
 510                 {
 511                         return null;
 512                 }
 513         }
 514
 515         /**
 516          * Get a contributor for the item
 517          *
 518          * @since 1.1
 519          * @param int $key The contrbutor that you want to return.  Remember that arrays begin with 0, not 1
 520          * @return SimplePie_Author|null
 521          */
 522         public function get_contributor($key = 0)
 523         {
 524                 $contributors = $this->get_contributors();
 525                 if (isset($contributors[$key]))
 526                 {
 527                         return $contributors[$key];
 528                 }
 529                 else
 530                 {
 531                         return null;
 532                 }
 533         }
 534
 535         /**
 536          * Get all contributors for the item
 537          *
 538          * Uses `<atom:contributor>`
 539          *
 540          * @since 1.1
 541          * @return array|null List of {@see SimplePie_Author} objects
 542          */
 543         public function get_contributors()
 544         {
 545                 $contributors = array();
 546                 foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'contributor') as $contributor)
 547                 {
 548                         $name = null;
 549                         $uri = null;
 550                         $email = null;
 551                         if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data']))
 552                         {
 553                                 $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 554                         }
 555                         if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data']))
 556                         {
 557                                 $uri = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]));
 558                         }
 559                         if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data']))
 560                         {
 561                                 $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 562                         }
 563                         if ($name !== null || $email !== null || $uri !== null)
 564                         {
 565                                 $contributors[] = $this->registry->create('Author', array($name, $uri, $email));
 566                         }
 567                 }
 568                 foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'contributor') as $contributor)
 569                 {
 570                         $name = null;
 571                         $url = null;
 572                         $email = null;
 573                         if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data']))
 574                         {
 575                                 $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 576                         }
 577                         if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data']))
 578                         {
 579                                 $url = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]));
 580                         }
 581                         if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data']))
 582                         {
 583                                 $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 584                         }
 585                         if ($name !== null || $email !== null || $url !== null)
 586                         {
 587                                 $contributors[] = $this->registry->create('Author', array($name, $url, $email));
 588                         }
 589                 }
 590
 591                 if (!empty($contributors))
 592                 {
 593                         return array_unique($contributors);
 594                 }
 595                 else
 596                 {
 597                         return null;
 598                 }
 599         }
 600
 601         /**
 602          * Get all authors for the item
 603          *
 604          * Uses `<atom:author>`, `<author>`, `<dc:creator>` or `<itunes:author>`
 605          *
 606          * @since Beta 2
 607          * @return array|null List of {@see SimplePie_Author} objects
 608          */
 609         public function get_authors()
 610         {
 611                 $authors = array();
 612                 foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'author') as $author)
 613                 {
 614                         $name = null;
 615                         $uri = null;
 616                         $email = null;
 617                         if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data']))
 618                         {
 619                                 $name = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 620                         }
 621                         if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data']))
 622                         {
 623                                 $uri = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]));
 624                         }
 625                         if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data']))
 626                         {
 627                                 $email = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 628                         }
 629                         if ($name !== null || $email !== null || $uri !== null)
 630                         {
 631                                 $authors[] = $this->registry->create('Author', array($name, $uri, $email));
 632                         }
 633                 }
 634                 if ($author = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'author'))
 635                 {
 636                         $name = null;
 637                         $url = null;
 638                         $email = null;
 639                         if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data']))
 640                         {
 641                                 $name = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 642                         }
 643                         if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data']))
 644                         {
 645                                 $url = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]));
 646                         }
 647                         if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data']))
 648                         {
 649                                 $email = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 650                         }
 651                         if ($name !== null || $email !== null || $url !== null)
 652                         {
 653                                 $authors[] = $this->registry->create('Author', array($name, $url, $email));
 654                         }
 655                 }
 656                 if ($author = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'author'))
 657                 {
 658                         $authors[] = $this->registry->create('Author', array(null, null, $this->sanitize($author[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT)));
 659                 }
 660                 foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'creator') as $author)
 661                 {
 662                         $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
 663                 }
 664                 foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'creator') as $author)
 665                 {
 666                         $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
 667                 }
 668                 foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'author') as $author)
 669                 {
 670                         $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
 671                 }
 672
 673                 if (!empty($authors))
 674                 {
 675                         return array_unique($authors);
 676                 }
 677                 elseif (($source = $this->get_source()) && ($authors = $source->get_authors()))
 678                 {
 679                         return $authors;
 680                 }
 681                 elseif ($authors = $this->feed->get_authors())
 682                 {
 683                         return $authors;
 684                 }
 685                 else
 686                 {
 687                         return null;
 688                 }
 689         }
 690
 691         /**
 692          * Get the copyright info for the item
 693          *
 694          * Uses `<atom:rights>` or `<dc:rights>`
 695          *
 696          * @since 1.1
 697          * @return string
 698          */
 699         public function get_copyright()
 700         {
 701                 if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'rights'))
 702                 {
 703                         return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 704                 }
 705                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'rights'))
 706                 {
 707                         return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 708                 }
 709                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'rights'))
 710                 {
 711                         return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 712                 }
 713                 else
 714                 {
 715                         return null;
 716                 }
 717         }
 718
 719         /**
 720          * Get the posting date/time for the item
 721          *
 722          * Uses `<atom:published>`, `<atom:updated>`, `<atom:issued>`,
 723          * `<atom:modified>`, `<pubDate>` or `<dc:date>`
 724          *
 725          * Note: obeys PHP's timezone setting. To get a UTC date/time, use
 726          * {@see get_gmdate}
 727          *
 728          * @since Beta 2 (previously called `get_item_date` since 0.8)
 729          *
 730          * @param string $date_format Supports any PHP date format from {@see http://php.net/date} (empty for the raw data)
 731          * @return int|string|null
 732          */
 733         public function get_date($date_format = 'j F Y, g:i a')
 734         {
 735                 if (!isset($this->data['date']))
 736                 {
 737                         if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'published'))
 738                         {
 739                                 $this->data['date']['raw'] = $return[0]['data'];
 740                         }
 741                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'updated'))
 742                         {
 743                                 $this->data['date']['raw'] = $return[0]['data'];
 744                         }
 745                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'issued'))
 746                         {
 747                                 $this->data['date']['raw'] = $return[0]['data'];
 748                         }
 749                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'created'))
 750                         {
 751                                 $this->data['date']['raw'] = $return[0]['data'];
 752                         }
 753                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'modified'))
 754                         {
 755                                 $this->data['date']['raw'] = $return[0]['data'];
 756                         }
 757                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'pubDate'))
 758                         {
 759                                 $this->data['date']['raw'] = $return[0]['data'];
 760                         }
 761                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'date'))
 762                         {
 763                                 $this->data['date']['raw'] = $return[0]['data'];
 764                         }
 765                         elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'date'))
 766                         {
 767                                 $this->data['date']['raw'] = $return[0]['data'];
 768                         }
 769
 770                         if (!empty($this->data['date']['raw']))
 771                         {
 772                                 $parser = $this->registry->call('Parse_Date', 'get');
 773                                 $this->data['date']['parsed'] = $parser->parse($this->data['date']['raw']);
 774                         }
 775                         else
 776                         {
 777                                 $this->data['date'] = null;
 778                         }
 779                 }
 780                 if ($this->data['date'])
 781                 {
 782                         $date_format = (string) $date_format;
 783                         switch ($date_format)
 784                         {
 785                                 case '':
 786                                         return $this->sanitize($this->data['date']['raw'], SIMPLEPIE_CONSTRUCT_TEXT);
 787
 788                                 case 'U':
 789                                         return $this->data['date']['parsed'];
 790
 791                                 default:
 792                                         return date($date_format, $this->data['date']['parsed']);
 793                         }
 794                 }
 795                 else
 796                 {
 797                         return null;
 798                 }
 799         }
 800
 801         /**
 802          * Get the update date/time for the item
 803          *
 804          * Uses `<atom:updated>`
 805          *
 806          * Note: obeys PHP's timezone setting. To get a UTC date/time, use
 807          * {@see get_gmdate}
 808          *
 809          * @param string $date_format Supports any PHP date format from {@see http://php.net/date} (empty for the raw data)
 810          * @return int|string|null
 811          */
 812         public function get_updated_date($date_format = 'j F Y, g:i a')
 813         {
 814                 if (!isset($this->data['updated']))
 815                 {
 816                         if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'updated'))
 817                         {
 818                                 $this->data['updated']['raw'] = $return[0]['data'];
 819                         }
 820
 821                         if (!empty($this->data['updated']['raw']))
 822                         {
 823                                 $parser = $this->registry->call('Parse_Date', 'get');
 824                                 $this->data['updated']['parsed'] = $parser->parse($this->data['date']['raw']);
 825                         }
 826                         else
 827                         {
 828                                 $this->data['updated'] = null;
 829                         }
 830                 }
 831                 if ($this->data['updated'])
 832                 {
 833                         $date_format = (string) $date_format;
 834                         switch ($date_format)
 835                         {
 836                                 case '':
 837                                         return $this->sanitize($this->data['updated']['raw'], SIMPLEPIE_CONSTRUCT_TEXT);
 838
 839                                 case 'U':
 840                                         return $this->data['updated']['parsed'];
 841
 842                                 default:
 843                                         return date($date_format, $this->data['updated']['parsed']);
 844                         }
 845                 }
 846                 else
 847                 {
 848                         return null;
 849                 }
 850         }
 851
 852         /**
 853          * Get the localized posting date/time for the item
 854          *
 855          * Returns the date formatted in the localized language. To display in
 856          * languages other than the server's default, you need to change the locale
 857          * with {@link http://php.net/setlocale setlocale()}. The available
 858          * localizations depend on which ones are installed on your web server.
 859          *
 860          * @since 1.0
 861          *
 862          * @param string $date_format Supports any PHP date format from {@see http://php.net/strftime} (empty for the raw data)
 863          * @return int|string|null
 864          */
 865         public function get_local_date($date_format = '%c')
 866         {
 867                 if (!$date_format)
 868                 {
 869                         return $this->sanitize($this->get_date(''), SIMPLEPIE_CONSTRUCT_TEXT);
 870                 }
 871                 elseif (($date = $this->get_date('U')) !== null && $date !== false)
 872                 {
 873                         return strftime($date_format, $date);
 874                 }
 875                 else
 876                 {
 877                         return null;
 878                 }
 879         }
 880
 881         /**
 882          * Get the posting date/time for the item (UTC time)
 883          *
 884          * @see get_date
 885          * @param string $date_format Supports any PHP date format from {@see http://php.net/date}
 886          * @return int|string|null
 887          */
 888         public function get_gmdate($date_format = 'j F Y, g:i a')
 889         {
 890                 $date = $this->get_date('U');
 891                 if ($date === null)
 892                 {
 893                         return null;
 894                 }
 895
 896                 return gmdate($date_format, $date);
 897         }
 898
 899         /**
 900          * Get the update date/time for the item (UTC time)
 901          *
 902          * @see get_updated_date
 903          * @param string $date_format Supports any PHP date format from {@see http://php.net/date}
 904          * @return int|string|null
 905          */
 906         public function get_updated_gmdate($date_format = 'j F Y, g:i a')
 907         {
 908                 $date = $this->get_updated_date('U');
 909                 if ($date === null)
 910                 {
 911                         return null;
 912                 }
 913
 914                 return gmdate($date_format, $date);
 915         }
 916
 917         /**
 918          * Get the permalink for the item
 919          *
 920          * Returns the first link available with a relationship of "alternate".
 921          * Identical to {@see get_link()} with key 0
 922          *
 923          * @see get_link
 924          * @since 0.8
 925          * @return string|null Permalink URL
 926          */
 927         public function get_permalink()
 928         {
 929                 $link = $this->get_link();
 930                 $enclosure = $this->get_enclosure(0);
 931                 if ($link !== null)
 932                 {
 933                         return $link;
 934                 }
 935                 elseif ($enclosure !== null)
 936                 {
 937                         return $enclosure->get_link();
 938                 }
 939                 else
 940                 {
 941                         return null;
 942                 }
 943         }
 944
 945         /**
 946          * Get a single link for the item
 947          *
 948          * @since Beta 3
 949          * @param int $key The link that you want to return.  Remember that arrays begin with 0, not 1
 950          * @param string $rel The relationship of the link to return
 951          * @return string|null Link URL
 952          */
 953         public function get_link($key = 0, $rel = 'alternate')
 954         {
 955                 $links = $this->get_links($rel);
 956                 if ($links[$key] !== null)
 957                 {
 958                         return $links[$key];
 959                 }
 960                 else
 961                 {
 962                         return null;
 963                 }
 964         }
 965
 966         /**
 967          * Get all links for the item
 968          *
 969          * Uses `<atom:link>`, `<link>` or `<guid>`
 970          *
 971          * @since Beta 2
 972          * @param string $rel The relationship of links to return
 973          * @return array|null Links found for the item (strings)
 974          */
 975         public function get_links($rel = 'alternate')
 976         {
 977                 if (!isset($this->data['links']))
 978                 {
 979                         $this->data['links'] = array();
 980                         foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link') as $link)
 981                         {
 982                                 if (isset($link['attribs']['']['href']))
 983                                 {
 984                                         $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate';
 985                                         $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
 986
 987                                 }
 988                         }
 989                         foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link') as $link)
 990                         {
 991                                 if (isset($link['attribs']['']['href']))
 992                                 {
 993                                         $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate';
 994                                         $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
 995                                 }
 996                         }
 997                         if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link'))
 998                         {
 999                                 $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
1000                         }
1001                         if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link'))
1002                         {
1003                                 $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
1004                         }
1005                         if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link'))
1006                         {
1007                                 $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
1008                         }
1009                         if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'guid'))
1010                         {
1011                                 if (!isset($links[0]['attribs']['']['isPermaLink']) || strtolower(trim($links[0]['attribs']['']['isPermaLink'])) === 'true')
1012                                 {
1013                                         $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
1014                                 }
1015                         }
1016
1017                         $keys = array_keys($this->data['links']);
1018                         foreach ($keys as $key)
1019                         {
1020                                 if ($this->registry->call('Misc', 'is_isegment_nz_nc', array($key)))
1021                                 {
1022                                         if (isset($this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]))
1023                                         {
1024                                                 $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] = array_merge($this->data['links'][$key], $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]);
1025                                                 $this->data['links'][$key] =& $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key];
1026                                         }
1027                                         else
1028                                         {
1029                                                 $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] =& $this->data['links'][$key];
1030                                         }
1031                                 }
1032                                 elseif (substr($key, 0, 41) === SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY)
1033                                 {
1034                                         $this->data['links'][substr($key, 41)] =& $this->data['links'][$key];
1035                                 }
1036                                 $this->data['links'][$key] = array_unique($this->data['links'][$key]);
1037                         }
1038                 }
1039                 if (isset($this->data['links'][$rel]))
1040                 {
1041                         return $this->data['links'][$rel];
1042                 }
1043                 else
1044                 {
1045                         return null;
1046                 }
1047         }
1048
1049         /**
1050          * Get an enclosure from the item
1051          *
1052          * Supports the <enclosure> RSS tag, as well as Media RSS and iTunes RSS.
1053          *
1054          * @since Beta 2
1055          * @todo Add ability to prefer one type of content over another (in a media group).
1056          * @param int $key The enclosure that you want to return.  Remember that arrays begin with 0, not 1
1057          * @return SimplePie_Enclosure|null
1058          */
1059         public function get_enclosure($key = 0, $prefer = null)
1060         {
1061                 $enclosures = $this->get_enclosures();
1062                 if (isset($enclosures[$key]))
1063                 {
1064                         return $enclosures[$key];
1065                 }
1066                 else
1067                 {
1068                         return null;
1069                 }
1070         }
1071
1072         /**
1073          * Get all available enclosures (podcasts, etc.)
1074          *
1075          * Supports the <enclosure> RSS tag, as well as Media RSS and iTunes RSS.
1076          *
1077          * At this point, we're pretty much assuming that all enclosures for an item
1078          * are the same content.  Anything else is too complicated to
1079          * properly support.
1080          *
1081          * @since Beta 2
1082          * @todo Add support for end-user defined sorting of enclosures by type/handler (so we can prefer the faster-loading FLV over MP4).
1083          * @todo If an element exists at a level, but it's value is empty, we should fall back to the value from the parent (if it exists).
1084          * @return array|null List of SimplePie_Enclosure items
1085          */
1086         public function get_enclosures()
1087         {
1088                 if (!isset($this->data['enclosures']))
1089                 {
1090                         $this->data['enclosures'] = array();
1091
1092                         // Elements
1093                         $captions_parent = null;
1094                         $categories_parent = null;
1095                         $copyrights_parent = null;
1096                         $credits_parent = null;
1097                         $description_parent = null;
1098                         $duration_parent = null;
1099                         $hashes_parent = null;
1100                         $keywords_parent = null;
1101                         $player_parent = null;
1102                         $ratings_parent = null;
1103                         $restrictions_parent = null;
1104                         $thumbnails_parent = null;
1105                         $title_parent = null;
1106
1107                         // Let's do the channel and item-level ones first, and just re-use them if we need to.
1108                         $parent = $this->get_feed();
1109
1110                         // CAPTIONS
1111                         if ($captions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'text'))
1112                         {
1113                                 foreach ($captions as $caption)
1114                                 {
1115                                         $caption_type = null;
1116                                         $caption_lang = null;
1117                                         $caption_startTime = null;
1118                                         $caption_endTime = null;
1119                                         $caption_text = null;
1120                                         if (isset($caption['attribs']['']['type']))
1121                                         {
1122                                                 $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
1123                                         }
1124                                         if (isset($caption['attribs']['']['lang']))
1125                                         {
1126                                                 $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
1127                                         }
1128                                         if (isset($caption['attribs']['']['start']))
1129                                         {
1130                                                 $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
1131                                         }
1132                                         if (isset($caption['attribs']['']['end']))
1133                                         {
1134                                                 $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
1135                                         }
1136                                         if (isset($caption['data']))
1137                                         {
1138                                                 $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1139                                         }
1140                                         $captions_parent[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
1141                                 }
1142                         }
1143                         elseif ($captions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'text'))
1144                         {
1145                                 foreach ($captions as $caption)
1146                                 {
1147                                         $caption_type = null;
1148                                         $caption_lang = null;
1149                                         $caption_startTime = null;
1150                                         $caption_endTime = null;
1151                                         $caption_text = null;
1152                                         if (isset($caption['attribs']['']['type']))
1153                                         {
1154                                                 $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
1155                                         }
1156                                         if (isset($caption['attribs']['']['lang']))
1157                                         {
1158                                                 $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
1159                                         }
1160                                         if (isset($caption['attribs']['']['start']))
1161                                         {
1162                                                 $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
1163                                         }
1164                                         if (isset($caption['attribs']['']['end']))
1165                                         {
1166                                                 $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
1167                                         }
1168                                         if (isset($caption['data']))
1169                                         {
1170                                                 $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1171                                         }
1172                                         $captions_parent[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
1173                                 }
1174                         }
1175                         if (is_array($captions_parent))
1176                         {
1177                                 $captions_parent = array_values(array_unique($captions_parent));
1178                         }
1179
1180                         // CATEGORIES
1181                         foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'category') as $category)
1182                         {
1183                                 $term = null;
1184                                 $scheme = null;
1185                                 $label = null;
1186                                 if (isset($category['data']))
1187                                 {
1188                                         $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1189                                 }
1190                                 if (isset($category['attribs']['']['scheme']))
1191                                 {
1192                                         $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
1193                                 }
1194                                 else
1195                                 {
1196                                         $scheme = 'http://search.yahoo.com/mrss/category_schema';
1197                                 }
1198                                 if (isset($category['attribs']['']['label']))
1199                                 {
1200                                         $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
1201                                 }
1202                                 $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
1203                         }
1204                         foreach ((array) $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'category') as $category)
1205                         {
1206                                 $term = null;
1207                                 $scheme = null;
1208                                 $label = null;
1209                                 if (isset($category['data']))
1210                                 {
1211                                         $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1212                                 }
1213                                 if (isset($category['attribs']['']['scheme']))
1214                                 {
1215                                         $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
1216                                 }
1217                                 else
1218                                 {
1219                                         $scheme = 'http://search.yahoo.com/mrss/category_schema';
1220                                 }
1221                                 if (isset($category['attribs']['']['label']))
1222                                 {
1223                                         $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
1224                                 }
1225                                 $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
1226                         }
1227                         foreach ((array) $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'category') as $category)
1228                         {
1229                                 $term = null;
1230                                 $scheme = 'http://www.itunes.com/dtds/podcast-1.0.dtd';
1231                                 $label = null;
1232                                 if (isset($category['attribs']['']['text']))
1233                                 {
1234                                         $label = $this->sanitize($category['attribs']['']['text'], SIMPLEPIE_CONSTRUCT_TEXT);
1235                                 }
1236                                 $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
1237
1238                                 if (isset($category['child'][SIMPLEPIE_NAMESPACE_ITUNES]['category']))
1239                                 {
1240                                         foreach ((array) $category['child'][SIMPLEPIE_NAMESPACE_ITUNES]['category'] as $subcategory)
1241                                         {
1242                                                 if (isset($subcategory['attribs']['']['text']))
1243                                                 {
1244                                                         $label = $this->sanitize($subcategory['attribs']['']['text'], SIMPLEPIE_CONSTRUCT_TEXT);
1245                                                 }
1246                                                 $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
1247                                         }
1248                                 }
1249                         }
1250                         if (is_array($categories_parent))
1251                         {
1252                                 $categories_parent = array_values(array_unique($categories_parent));
1253                         }
1254
1255                         // COPYRIGHT
1256                         if ($copyright = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'copyright'))
1257                         {
1258                                 $copyright_url = null;
1259                                 $copyright_label = null;
1260                                 if (isset($copyright[0]['attribs']['']['url']))
1261                                 {
1262                                         $copyright_url = $this->sanitize($copyright[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
1263                                 }
1264                                 if (isset($copyright[0]['data']))
1265                                 {
1266                                         $copyright_label = $this->sanitize($copyright[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1267                                 }
1268                                 $copyrights_parent = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
1269                         }
1270                         elseif ($copyright = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'copyright'))
1271                         {
1272                                 $copyright_url = null;
1273                                 $copyright_label = null;
1274                                 if (isset($copyright[0]['attribs']['']['url']))
1275                                 {
1276                                         $copyright_url = $this->sanitize($copyright[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
1277                                 }
1278                                 if (isset($copyright[0]['data']))
1279                                 {
1280                                         $copyright_label = $this->sanitize($copyright[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1281                                 }
1282                                 $copyrights_parent = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
1283                         }
1284
1285                         // CREDITS
1286                         if ($credits = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'credit'))
1287                         {
1288                                 foreach ($credits as $credit)
1289                                 {
1290                                         $credit_role = null;
1291                                         $credit_scheme = null;
1292                                         $credit_name = null;
1293                                         if (isset($credit['attribs']['']['role']))
1294                                         {
1295                                                 $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
1296                                         }
1297                                         if (isset($credit['attribs']['']['scheme']))
1298                                         {
1299                                                 $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
1300                                         }
1301                                         else
1302                                         {
1303                                                 $credit_scheme = 'urn:ebu';
1304                                         }
1305                                         if (isset($credit['data']))
1306                                         {
1307                                                 $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1308                                         }
1309                                         $credits_parent[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
1310                                 }
1311                         }
1312                         elseif ($credits = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'credit'))
1313                         {
1314                                 foreach ($credits as $credit)
1315                                 {
1316                                         $credit_role = null;
1317                                         $credit_scheme = null;
1318                                         $credit_name = null;
1319                                         if (isset($credit['attribs']['']['role']))
1320                                         {
1321                                                 $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
1322                                         }
1323                                         if (isset($credit['attribs']['']['scheme']))
1324                                         {
1325                                                 $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
1326                                         }
1327                                         else
1328                                         {
1329                                                 $credit_scheme = 'urn:ebu';
1330                                         }
1331                                         if (isset($credit['data']))
1332                                         {
1333                                                 $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1334                                         }
1335                                         $credits_parent[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
1336                                 }
1337                         }
1338                         if (is_array($credits_parent))
1339                         {
1340                                 $credits_parent = array_values(array_unique($credits_parent));
1341                         }
1342
1343                         // DESCRIPTION
1344                         if ($description_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'description'))
1345                         {
1346                                 if (isset($description_parent[0]['data']))
1347                                 {
1348                                         $description_parent = $this->sanitize($description_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1349                                 }
1350                         }
1351                         elseif ($description_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'description'))
1352                         {
1353                                 if (isset($description_parent[0]['data']))
1354                                 {
1355                                         $description_parent = $this->sanitize($description_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1356                                 }
1357                         }
1358
1359                         // DURATION
1360                         if ($duration_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'duration'))
1361                         {
1362                                 $seconds = null;
1363                                 $minutes = null;
1364                                 $hours = null;
1365                                 if (isset($duration_parent[0]['data']))
1366                                 {
1367                                         $temp = explode(':', $this->sanitize($duration_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
1368                                         if (sizeof($temp) > 0)
1369                                         {
1370                                                 $seconds = (int) array_pop($temp);
1371                                         }
1372                                         if (sizeof($temp) > 0)
1373                                         {
1374                                                 $minutes = (int) array_pop($temp);
1375                                                 $seconds += $minutes * 60;
1376                                         }
1377                                         if (sizeof($temp) > 0)
1378                                         {
1379                                                 $hours = (int) array_pop($temp);
1380                                                 $seconds += $hours * 3600;
1381                                         }
1382                                         unset($temp);
1383                                         $duration_parent = $seconds;
1384                                 }
1385                         }
1386
1387                         // HASHES
1388                         if ($hashes_iterator = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'hash'))
1389                         {
1390                                 foreach ($hashes_iterator as $hash)
1391                                 {
1392                                         $value = null;
1393                                         $algo = null;
1394                                         if (isset($hash['data']))
1395                                         {
1396                                                 $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1397                                         }
1398                                         if (isset($hash['attribs']['']['algo']))
1399                                         {
1400                                                 $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
1401                                         }
1402                                         else
1403                                         {
1404                                                 $algo = 'md5';
1405                                         }
1406                                         $hashes_parent[] = $algo.':'.$value;
1407                                 }
1408                         }
1409                         elseif ($hashes_iterator = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'hash'))
1410                         {
1411                                 foreach ($hashes_iterator as $hash)
1412                                 {
1413                                         $value = null;
1414                                         $algo = null;
1415                                         if (isset($hash['data']))
1416                                         {
1417                                                 $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1418                                         }
1419                                         if (isset($hash['attribs']['']['algo']))
1420                                         {
1421                                                 $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
1422                                         }
1423                                         else
1424                                         {
1425                                                 $algo = 'md5';
1426                                         }
1427                                         $hashes_parent[] = $algo.':'.$value;
1428                                 }
1429                         }
1430                         if (is_array($hashes_parent))
1431                         {
1432                                 $hashes_parent = array_values(array_unique($hashes_parent));
1433                         }
1434
1435                         // KEYWORDS
1436                         if ($keywords = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'keywords'))
1437                         {
1438                                 if (isset($keywords[0]['data']))
1439                                 {
1440                                         $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
1441                                         foreach ($temp as $word)
1442                                         {
1443                                                 $keywords_parent[] = trim($word);
1444                                         }
1445                                 }
1446                                 unset($temp);
1447                         }
1448                         elseif ($keywords = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'keywords'))
1449                         {
1450                                 if (isset($keywords[0]['data']))
1451                                 {
1452                                         $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
1453                                         foreach ($temp as $word)
1454                                         {
1455                                                 $keywords_parent[] = trim($word);
1456                                         }
1457                                 }
1458                                 unset($temp);
1459                         }
1460                         elseif ($keywords = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'keywords'))
1461                         {
1462                                 if (isset($keywords[0]['data']))
1463                                 {
1464                                         $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
1465                                         foreach ($temp as $word)
1466                                         {
1467                                                 $keywords_parent[] = trim($word);
1468                                         }
1469                                 }
1470                                 unset($temp);
1471                         }
1472                         elseif ($keywords = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'keywords'))
1473                         {
1474                                 if (isset($keywords[0]['data']))
1475                                 {
1476                                         $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
1477                                         foreach ($temp as $word)
1478                                         {
1479                                                 $keywords_parent[] = trim($word);
1480                                         }
1481                                 }
1482                                 unset($temp);
1483                         }
1484                         if (is_array($keywords_parent))
1485                         {
1486                                 $keywords_parent = array_values(array_unique($keywords_parent));
1487                         }
1488
1489                         // PLAYER
1490                         if ($player_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'player'))
1491                         {
1492                                 if (isset($player_parent[0]['attribs']['']['url']))
1493                                 {
1494                                         $player_parent = $this->sanitize($player_parent[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
1495                                 }
1496                         }
1497                         elseif ($player_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'player'))
1498                         {
1499                                 if (isset($player_parent[0]['attribs']['']['url']))
1500                                 {
1501                                         $player_parent = $this->sanitize($player_parent[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
1502                                 }
1503                         }
1504
1505                         // RATINGS
1506                         if ($ratings = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'rating'))
1507                         {
1508                                 foreach ($ratings as $rating)
1509                                 {
1510                                         $rating_scheme = null;
1511                                         $rating_value = null;
1512                                         if (isset($rating['attribs']['']['scheme']))
1513                                         {
1514                                                 $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
1515                                         }
1516                                         else
1517                                         {
1518                                                 $rating_scheme = 'urn:simple';
1519                                         }
1520                                         if (isset($rating['data']))
1521                                         {
1522                                                 $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1523                                         }
1524                                         $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
1525                                 }
1526                         }
1527                         elseif ($ratings = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'explicit'))
1528                         {
1529                                 foreach ($ratings as $rating)
1530                                 {
1531                                         $rating_scheme = 'urn:itunes';
1532                                         $rating_value = null;
1533                                         if (isset($rating['data']))
1534                                         {
1535                                                 $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1536                                         }
1537                                         $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
1538                                 }
1539                         }
1540                         elseif ($ratings = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'rating'))
1541                         {
1542                                 foreach ($ratings as $rating)
1543                                 {
1544                                         $rating_scheme = null;
1545                                         $rating_value = null;
1546                                         if (isset($rating['attribs']['']['scheme']))
1547                                         {
1548                                                 $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
1549                                         }
1550                                         else
1551                                         {
1552                                                 $rating_scheme = 'urn:simple';
1553                                         }
1554                                         if (isset($rating['data']))
1555                                         {
1556                                                 $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1557                                         }
1558                                         $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
1559                                 }
1560                         }
1561                         elseif ($ratings = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'explicit'))
1562                         {
1563                                 foreach ($ratings as $rating)
1564                                 {
1565                                         $rating_scheme = 'urn:itunes';
1566                                         $rating_value = null;
1567                                         if (isset($rating['data']))
1568                                         {
1569                                                 $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1570                                         }
1571                                         $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
1572                                 }
1573                         }
1574                         if (is_array($ratings_parent))
1575                         {
1576                                 $ratings_parent = array_values(array_unique($ratings_parent));
1577                         }
1578
1579                         // RESTRICTIONS
1580                         if ($restrictions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'restriction'))
1581                         {
1582                                 foreach ($restrictions as $restriction)
1583                                 {
1584                                         $restriction_relationship = null;
1585                                         $restriction_type = null;
1586                                         $restriction_value = null;
1587                                         if (isset($restriction['attribs']['']['relationship']))
1588                                         {
1589                                                 $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
1590                                         }
1591                                         if (isset($restriction['attribs']['']['type']))
1592                                         {
1593                                                 $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
1594                                         }
1595                                         if (isset($restriction['data']))
1596                                         {
1597                                                 $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1598                                         }
1599                                         $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
1600                                 }
1601                         }
1602                         elseif ($restrictions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'block'))
1603                         {
1604                                 foreach ($restrictions as $restriction)
1605                                 {
1606                                         $restriction_relationship = 'allow';
1607                                         $restriction_type = null;
1608                                         $restriction_value = 'itunes';
1609                                         if (isset($restriction['data']) && strtolower($restriction['data']) === 'yes')
1610                                         {
1611                                                 $restriction_relationship = 'deny';
1612                                         }
1613                                         $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
1614                                 }
1615                         }
1616                         elseif ($restrictions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'restriction'))
1617                         {
1618                                 foreach ($restrictions as $restriction)
1619                                 {
1620                                         $restriction_relationship = null;
1621                                         $restriction_type = null;
1622                                         $restriction_value = null;
1623                                         if (isset($restriction['attribs']['']['relationship']))
1624                                         {
1625                                                 $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
1626                                         }
1627                                         if (isset($restriction['attribs']['']['type']))
1628                                         {
1629                                                 $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
1630                                         }
1631                                         if (isset($restriction['data']))
1632                                         {
1633                                                 $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1634                                         }
1635                                         $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
1636                                 }
1637                         }
1638                         elseif ($restrictions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'block'))
1639                         {
1640                                 foreach ($restrictions as $restriction)
1641                                 {
1642                                         $restriction_relationship = 'allow';
1643                                         $restriction_type = null;
1644                                         $restriction_value = 'itunes';
1645                                         if (isset($restriction['data']) && strtolower($restriction['data']) === 'yes')
1646                                         {
1647                                                 $restriction_relationship = 'deny';
1648                                         }
1649                                         $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
1650                                 }
1651                         }
1652                         if (is_array($restrictions_parent))
1653                         {
1654                                 $restrictions_parent = array_values(array_unique($restrictions_parent));
1655                         }
1656                         else
1657                         {
1658                                 $restrictions_parent = array(new SimplePie_Restriction('allow', null, 'default'));
1659                         }
1660
1661                         // THUMBNAILS
1662                         if ($thumbnails = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'thumbnail'))
1663                         {
1664                                 foreach ($thumbnails as $thumbnail)
1665                                 {
1666                                         if (isset($thumbnail['attribs']['']['url']))
1667                                         {
1668                                                 $thumbnails_parent[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
1669                                         }
1670                                 }
1671                         }
1672                         elseif ($thumbnails = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'thumbnail'))
1673                         {
1674                                 foreach ($thumbnails as $thumbnail)
1675                                 {
1676                                         if (isset($thumbnail['attribs']['']['url']))
1677                                         {
1678                                                 $thumbnails_parent[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
1679                                         }
1680                                 }
1681                         }
1682
1683                         // TITLES
1684                         if ($title_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'title'))
1685                         {
1686                                 if (isset($title_parent[0]['data']))
1687                                 {
1688                                         $title_parent = $this->sanitize($title_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1689                                 }
1690                         }
1691                         elseif ($title_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'title'))
1692                         {
1693                                 if (isset($title_parent[0]['data']))
1694                                 {
1695                                         $title_parent = $this->sanitize($title_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1696                                 }
1697                         }
1698
1699                         // Clear the memory
1700                         unset($parent);
1701
1702                         // Attributes
1703                         $bitrate = null;
1704                         $channels = null;
1705                         $duration = null;
1706                         $expression = null;
1707                         $framerate = null;
1708                         $height = null;
1709                         $javascript = null;
1710                         $lang = null;
1711                         $length = null;
1712                         $medium = null;
1713                         $samplingrate = null;
1714                         $type = null;
1715                         $url = null;
1716                         $width = null;
1717
1718                         // Elements
1719                         $captions = null;
1720                         $categories = null;
1721                         $copyrights = null;
1722                         $credits = null;
1723                         $description = null;
1724                         $hashes = null;
1725                         $keywords = null;
1726                         $player = null;
1727                         $ratings = null;
1728                         $restrictions = null;
1729                         $thumbnails = null;
1730                         $title = null;
1731
1732                         // If we have media:group tags, loop through them.
1733                         foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'group') as $group)
1734                         {
1735                                 if(isset($group['child']) && isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content']))
1736                                 {
1737                                         // If we have media:content tags, loop through them.
1738                                         foreach ((array) $group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content'] as $content)
1739                                         {
1740                                                 if (isset($content['attribs']['']['url']))
1741                                                 {
1742                                                         // Attributes
1743                                                         $bitrate = null;
1744                                                         $channels = null;
1745                                                         $duration = null;
1746                                                         $expression = null;
1747                                                         $framerate = null;
1748                                                         $height = null;
1749                                                         $javascript = null;
1750                                                         $lang = null;
1751                                                         $length = null;
1752                                                         $medium = null;
1753                                                         $samplingrate = null;
1754                                                         $type = null;
1755                                                         $url = null;
1756                                                         $width = null;
1757
1758                                                         // Elements
1759                                                         $captions = null;
1760                                                         $categories = null;
1761                                                         $copyrights = null;
1762                                                         $credits = null;
1763                                                         $description = null;
1764                                                         $hashes = null;
1765                                                         $keywords = null;
1766                                                         $player = null;
1767                                                         $ratings = null;
1768                                                         $restrictions = null;
1769                                                         $thumbnails = null;
1770                                                         $title = null;
1771
1772                                                         // Start checking the attributes of media:content
1773                                                         if (isset($content['attribs']['']['bitrate']))
1774                                                         {
1775                                                                 $bitrate = $this->sanitize($content['attribs']['']['bitrate'], SIMPLEPIE_CONSTRUCT_TEXT);
1776                                                         }
1777                                                         if (isset($content['attribs']['']['channels']))
1778                                                         {
1779                                                                 $channels = $this->sanitize($content['attribs']['']['channels'], SIMPLEPIE_CONSTRUCT_TEXT);
1780                                                         }
1781                                                         if (isset($content['attribs']['']['duration']))
1782                                                         {
1783                                                                 $duration = $this->sanitize($content['attribs']['']['duration'], SIMPLEPIE_CONSTRUCT_TEXT);
1784                                                         }
1785                                                         else
1786                                                         {
1787                                                                 $duration = $duration_parent;
1788                                                         }
1789                                                         if (isset($content['attribs']['']['expression']))
1790                                                         {
1791                                                                 $expression = $this->sanitize($content['attribs']['']['expression'], SIMPLEPIE_CONSTRUCT_TEXT);
1792                                                         }
1793                                                         if (isset($content['attribs']['']['framerate']))
1794                                                         {
1795                                                                 $framerate = $this->sanitize($content['attribs']['']['framerate'], SIMPLEPIE_CONSTRUCT_TEXT);
1796                                                         }
1797                                                         if (isset($content['attribs']['']['height']))
1798                                                         {
1799                                                                 $height = $this->sanitize($content['attribs']['']['height'], SIMPLEPIE_CONSTRUCT_TEXT);
1800                                                         }
1801                                                         if (isset($content['attribs']['']['lang']))
1802                                                         {
1803                                                                 $lang = $this->sanitize($content['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
1804                                                         }
1805                                                         if (isset($content['attribs']['']['fileSize']))
1806                                                         {
1807                                                                 $length = ceil($content['attribs']['']['fileSize']);
1808                                                         }
1809                                                         if (isset($content['attribs']['']['medium']))
1810                                                         {
1811                                                                 $medium = $this->sanitize($content['attribs']['']['medium'], SIMPLEPIE_CONSTRUCT_TEXT);
1812                                                         }
1813                                                         if (isset($content['attribs']['']['samplingrate']))
1814                                                         {
1815                                                                 $samplingrate = $this->sanitize($content['attribs']['']['samplingrate'], SIMPLEPIE_CONSTRUCT_TEXT);
1816                                                         }
1817                                                         if (isset($content['attribs']['']['type']))
1818                                                         {
1819                                                                 $type = $this->sanitize($content['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
1820                                                         }
1821                                                         if (isset($content['attribs']['']['width']))
1822                                                         {
1823                                                                 $width = $this->sanitize($content['attribs']['']['width'], SIMPLEPIE_CONSTRUCT_TEXT);
1824                                                         }
1825                                                         $url = $this->sanitize($content['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
1826
1827                                                         // Checking the other optional media: elements. Priority: media:content, media:group, item, channel
1828
1829                                                         // CAPTIONS
1830                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text']))
1831                                                         {
1832                                                                 foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption)
1833                                                                 {
1834                                                                         $caption_type = null;
1835                                                                         $caption_lang = null;
1836                                                                         $caption_startTime = null;
1837                                                                         $caption_endTime = null;
1838                                                                         $caption_text = null;
1839                                                                         if (isset($caption['attribs']['']['type']))
1840                                                                         {
1841                                                                                 $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
1842                                                                         }
1843                                                                         if (isset($caption['attribs']['']['lang']))
1844                                                                         {
1845                                                                                 $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
1846                                                                         }
1847                                                                         if (isset($caption['attribs']['']['start']))
1848                                                                         {
1849                                                                                 $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
1850                                                                         }
1851                                                                         if (isset($caption['attribs']['']['end']))
1852                                                                         {
1853                                                                                 $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
1854                                                                         }
1855                                                                         if (isset($caption['data']))
1856                                                                         {
1857                                                                                 $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1858                                                                         }
1859                                                                         $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
1860                                                                 }
1861                                                                 if (is_array($captions))
1862                                                                 {
1863                                                                         $captions = array_values(array_unique($captions));
1864                                                                 }
1865                                                         }
1866                                                         elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text']))
1867                                                         {
1868                                                                 foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption)
1869                                                                 {
1870                                                                         $caption_type = null;
1871                                                                         $caption_lang = null;
1872                                                                         $caption_startTime = null;
1873                                                                         $caption_endTime = null;
1874                                                                         $caption_text = null;
1875                                                                         if (isset($caption['attribs']['']['type']))
1876                                                                         {
1877                                                                                 $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
1878                                                                         }
1879                                                                         if (isset($caption['attribs']['']['lang']))
1880                                                                         {
1881                                                                                 $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
1882                                                                         }
1883                                                                         if (isset($caption['attribs']['']['start']))
1884                                                                         {
1885                                                                                 $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
1886                                                                         }
1887                                                                         if (isset($caption['attribs']['']['end']))
1888                                                                         {
1889                                                                                 $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
1890                                                                         }
1891                                                                         if (isset($caption['data']))
1892                                                                         {
1893                                                                                 $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1894                                                                         }
1895                                                                         $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
1896                                                                 }
1897                                                                 if (is_array($captions))
1898                                                                 {
1899                                                                         $captions = array_values(array_unique($captions));
1900                                                                 }
1901                                                         }
1902                                                         else
1903                                                         {
1904                                                                 $captions = $captions_parent;
1905                                                         }
1906
1907                                                         // CATEGORIES
1908                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category']))
1909                                                         {
1910                                                                 foreach ((array) $content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category)
1911                                                                 {
1912                                                                         $term = null;
1913                                                                         $scheme = null;
1914                                                                         $label = null;
1915                                                                         if (isset($category['data']))
1916                                                                         {
1917                                                                                 $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1918                                                                         }
1919                                                                         if (isset($category['attribs']['']['scheme']))
1920                                                                         {
1921                                                                                 $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
1922                                                                         }
1923                                                                         else
1924                                                                         {
1925                                                                                 $scheme = 'http://search.yahoo.com/mrss/category_schema';
1926                                                                         }
1927                                                                         if (isset($category['attribs']['']['label']))
1928                                                                         {
1929                                                                                 $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
1930                                                                         }
1931                                                                         $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
1932                                                                 }
1933                                                         }
1934                                                         if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category']))
1935                                                         {
1936                                                                 foreach ((array) $group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category)
1937                                                                 {
1938                                                                         $term = null;
1939                                                                         $scheme = null;
1940                                                                         $label = null;
1941                                                                         if (isset($category['data']))
1942                                                                         {
1943                                                                                 $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1944                                                                         }
1945                                                                         if (isset($category['attribs']['']['scheme']))
1946                                                                         {
1947                                                                                 $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
1948                                                                         }
1949                                                                         else
1950                                                                         {
1951                                                                                 $scheme = 'http://search.yahoo.com/mrss/category_schema';
1952                                                                         }
1953                                                                         if (isset($category['attribs']['']['label']))
1954                                                                         {
1955                                                                                 $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
1956                                                                         }
1957                                                                         $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
1958                                                                 }
1959                                                         }
1960                                                         if (is_array($categories) && is_array($categories_parent))
1961                                                         {
1962                                                                 $categories = array_values(array_unique(array_merge($categories, $categories_parent)));
1963                                                         }
1964                                                         elseif (is_array($categories))
1965                                                         {
1966                                                                 $categories = array_values(array_unique($categories));
1967                                                         }
1968                                                         elseif (is_array($categories_parent))
1969                                                         {
1970                                                                 $categories = array_values(array_unique($categories_parent));
1971                                                         }
1972
1973                                                         // COPYRIGHTS
1974                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright']))
1975                                                         {
1976                                                                 $copyright_url = null;
1977                                                                 $copyright_label = null;
1978                                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url']))
1979                                                                 {
1980                                                                         $copyright_url = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
1981                                                                 }
1982                                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data']))
1983                                                                 {
1984                                                                         $copyright_label = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1985                                                                 }
1986                                                                 $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
1987                                                         }
1988                                                         elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright']))
1989                                                         {
1990                                                                 $copyright_url = null;
1991                                                                 $copyright_label = null;
1992                                                                 if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url']))
1993                                                                 {
1994                                                                         $copyright_url = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
1995                                                                 }
1996                                                                 if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data']))
1997                                                                 {
1998                                                                         $copyright_label = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
1999                                                                 }
2000                                                                 $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
2001                                                         }
2002                                                         else
2003                                                         {
2004                                                                 $copyrights = $copyrights_parent;
2005                                                         }
2006
2007                                                         // CREDITS
2008                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit']))
2009                                                         {
2010                                                                 foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit)
2011                                                                 {
2012                                                                         $credit_role = null;
2013                                                                         $credit_scheme = null;
2014                                                                         $credit_name = null;
2015                                                                         if (isset($credit['attribs']['']['role']))
2016                                                                         {
2017                                                                                 $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
2018                                                                         }
2019                                                                         if (isset($credit['attribs']['']['scheme']))
2020                                                                         {
2021                                                                                 $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
2022                                                                         }
2023                                                                         else
2024                                                                         {
2025                                                                                 $credit_scheme = 'urn:ebu';
2026                                                                         }
2027                                                                         if (isset($credit['data']))
2028                                                                         {
2029                                                                                 $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2030                                                                         }
2031                                                                         $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
2032                                                                 }
2033                                                                 if (is_array($credits))
2034                                                                 {
2035                                                                         $credits = array_values(array_unique($credits));
2036                                                                 }
2037                                                         }
2038                                                         elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit']))
2039                                                         {
2040                                                                 foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit)
2041                                                                 {
2042                                                                         $credit_role = null;
2043                                                                         $credit_scheme = null;
2044                                                                         $credit_name = null;
2045                                                                         if (isset($credit['attribs']['']['role']))
2046                                                                         {
2047                                                                                 $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
2048                                                                         }
2049                                                                         if (isset($credit['attribs']['']['scheme']))
2050                                                                         {
2051                                                                                 $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
2052                                                                         }
2053                                                                         else
2054                                                                         {
2055                                                                                 $credit_scheme = 'urn:ebu';
2056                                                                         }
2057                                                                         if (isset($credit['data']))
2058                                                                         {
2059                                                                                 $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2060                                                                         }
2061                                                                         $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
2062                                                                 }
2063                                                                 if (is_array($credits))
2064                                                                 {
2065                                                                         $credits = array_values(array_unique($credits));
2066                                                                 }
2067                                                         }
2068                                                         else
2069                                                         {
2070                                                                 $credits = $credits_parent;
2071                                                         }
2072
2073                                                         // DESCRIPTION
2074                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description']))
2075                                                         {
2076                                                                 $description = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2077                                                         }
2078                                                         elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description']))
2079                                                         {
2080                                                                 $description = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2081                                                         }
2082                                                         else
2083                                                         {
2084                                                                 $description = $description_parent;
2085                                                         }
2086
2087                                                         // HASHES
2088                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash']))
2089                                                         {
2090                                                                 foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash)
2091                                                                 {
2092                                                                         $value = null;
2093                                                                         $algo = null;
2094                                                                         if (isset($hash['data']))
2095                                                                         {
2096                                                                                 $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2097                                                                         }
2098                                                                         if (isset($hash['attribs']['']['algo']))
2099                                                                         {
2100                                                                                 $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
2101                                                                         }
2102                                                                         else
2103                                                                         {
2104                                                                                 $algo = 'md5';
2105                                                                         }
2106                                                                         $hashes[] = $algo.':'.$value;
2107                                                                 }
2108                                                                 if (is_array($hashes))
2109                                                                 {
2110                                                                         $hashes = array_values(array_unique($hashes));
2111                                                                 }
2112                                                         }
2113                                                         elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash']))
2114                                                         {
2115                                                                 foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash)
2116                                                                 {
2117                                                                         $value = null;
2118                                                                         $algo = null;
2119                                                                         if (isset($hash['data']))
2120                                                                         {
2121                                                                                 $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2122                                                                         }
2123                                                                         if (isset($hash['attribs']['']['algo']))
2124                                                                         {
2125                                                                                 $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
2126                                                                         }
2127                                                                         else
2128                                                                         {
2129                                                                                 $algo = 'md5';
2130                                                                         }
2131                                                                         $hashes[] = $algo.':'.$value;
2132                                                                 }
2133                                                                 if (is_array($hashes))
2134                                                                 {
2135                                                                         $hashes = array_values(array_unique($hashes));
2136                                                                 }
2137                                                         }
2138                                                         else
2139                                                         {
2140                                                                 $hashes = $hashes_parent;
2141                                                         }
2142
2143                                                         // KEYWORDS
2144                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords']))
2145                                                         {
2146                                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data']))
2147                                                                 {
2148                                                                         $temp = explode(',', $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
2149                                                                         foreach ($temp as $word)
2150                                                                         {
2151                                                                                 $keywords[] = trim($word);
2152                                                                         }
2153                                                                         unset($temp);
2154                                                                 }
2155                                                                 if (is_array($keywords))
2156                                                                 {
2157                                                                         $keywords = array_values(array_unique($keywords));
2158                                                                 }
2159                                                         }
2160                                                         elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords']))
2161                                                         {
2162                                                                 if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data']))
2163                                                                 {
2164                                                                         $temp = explode(',', $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
2165                                                                         foreach ($temp as $word)
2166                                                                         {
2167                                                                                 $keywords[] = trim($word);
2168                                                                         }
2169                                                                         unset($temp);
2170                                                                 }
2171                                                                 if (is_array($keywords))
2172                                                                 {
2173                                                                         $keywords = array_values(array_unique($keywords));
2174                                                                 }
2175                                                         }
2176                                                         else
2177                                                         {
2178                                                                 $keywords = $keywords_parent;
2179                                                         }
2180
2181                                                         // PLAYER
2182                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
2183                                                         {
2184                                                                 $player = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
2185                                                         }
2186                                                         elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
2187                                                         {
2188                                                                 $player = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
2189                                                         }
2190                                                         else
2191                                                         {
2192                                                                 $player = $player_parent;
2193                                                         }
2194
2195                                                         // RATINGS
2196                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating']))
2197                                                         {
2198                                                                 foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating)
2199                                                                 {
2200                                                                         $rating_scheme = null;
2201                                                                         $rating_value = null;
2202                                                                         if (isset($rating['attribs']['']['scheme']))
2203                                                                         {
2204                                                                                 $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
2205                                                                         }
2206                                                                         else
2207                                                                         {
2208                                                                                 $rating_scheme = 'urn:simple';
2209                                                                         }
2210                                                                         if (isset($rating['data']))
2211                                                                         {
2212                                                                                 $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2213                                                                         }
2214                                                                         $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
2215                                                                 }
2216                                                                 if (is_array($ratings))
2217                                                                 {
2218                                                                         $ratings = array_values(array_unique($ratings));
2219                                                                 }
2220                                                         }
2221                                                         elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating']))
2222                                                         {
2223                                                                 foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating)
2224                                                                 {
2225                                                                         $rating_scheme = null;
2226                                                                         $rating_value = null;
2227                                                                         if (isset($rating['attribs']['']['scheme']))
2228                                                                         {
2229                                                                                 $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
2230                                                                         }
2231                                                                         else
2232                                                                         {
2233                                                                                 $rating_scheme = 'urn:simple';
2234                                                                         }
2235                                                                         if (isset($rating['data']))
2236                                                                         {
2237                                                                                 $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2238                                                                         }
2239                                                                         $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
2240                                                                 }
2241                                                                 if (is_array($ratings))
2242                                                                 {
2243                                                                         $ratings = array_values(array_unique($ratings));
2244                                                                 }
2245                                                         }
2246                                                         else
2247                                                         {
2248                                                                 $ratings = $ratings_parent;
2249                                                         }
2250
2251                                                         // RESTRICTIONS
2252                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction']))
2253                                                         {
2254                                                                 foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction)
2255                                                                 {
2256                                                                         $restriction_relationship = null;
2257                                                                         $restriction_type = null;
2258                                                                         $restriction_value = null;
2259                                                                         if (isset($restriction['attribs']['']['relationship']))
2260                                                                         {
2261                                                                                 $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
2262                                                                         }
2263                                                                         if (isset($restriction['attribs']['']['type']))
2264                                                                         {
2265                                                                                 $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
2266                                                                         }
2267                                                                         if (isset($restriction['data']))
2268                                                                         {
2269                                                                                 $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2270                                                                         }
2271                                                                         $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
2272                                                                 }
2273                                                                 if (is_array($restrictions))
2274                                                                 {
2275                                                                         $restrictions = array_values(array_unique($restrictions));
2276                                                                 }
2277                                                         }
2278                                                         elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction']))
2279                                                         {
2280                                                                 foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction)
2281                                                                 {
2282                                                                         $restriction_relationship = null;
2283                                                                         $restriction_type = null;
2284                                                                         $restriction_value = null;
2285                                                                         if (isset($restriction['attribs']['']['relationship']))
2286                                                                         {
2287                                                                                 $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
2288                                                                         }
2289                                                                         if (isset($restriction['attribs']['']['type']))
2290                                                                         {
2291                                                                                 $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
2292                                                                         }
2293                                                                         if (isset($restriction['data']))
2294                                                                         {
2295                                                                                 $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2296                                                                         }
2297                                                                         $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
2298                                                                 }
2299                                                                 if (is_array($restrictions))
2300                                                                 {
2301                                                                         $restrictions = array_values(array_unique($restrictions));
2302                                                                 }
2303                                                         }
2304                                                         else
2305                                                         {
2306                                                                 $restrictions = $restrictions_parent;
2307                                                         }
2308
2309                                                         // THUMBNAILS
2310                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail']))
2311                                                         {
2312                                                                 foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail)
2313                                                                 {
2314                                                                         $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
2315                                                                 }
2316                                                                 if (is_array($thumbnails))
2317                                                                 {
2318                                                                         $thumbnails = array_values(array_unique($thumbnails));
2319                                                                 }
2320                                                         }
2321                                                         elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail']))
2322                                                         {
2323                                                                 foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail)
2324                                                                 {
2325                                                                         $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
2326                                                                 }
2327                                                                 if (is_array($thumbnails))
2328                                                                 {
2329                                                                         $thumbnails = array_values(array_unique($thumbnails));
2330                                                                 }
2331                                                         }
2332                                                         else
2333                                                         {
2334                                                                 $thumbnails = $thumbnails_parent;
2335                                                         }
2336
2337                                                         // TITLES
2338                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title']))
2339                                                         {
2340                                                                 $title = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2341                                                         }
2342                                                         elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title']))
2343                                                         {
2344                                                                 $title = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2345                                                         }
2346                                                         else
2347                                                         {
2348                                                                 $title = $title_parent;
2349                                                         }
2350
2351                                                         $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions, $categories, $channels, $copyrights, $credits, $description, $duration, $expression, $framerate, $hashes, $height, $keywords, $lang, $medium, $player, $ratings, $restrictions, $samplingrate, $thumbnails, $title, $width));
2352                                                 }
2353                                         }
2354                                 }
2355                         }
2356
2357                         // If we have standalone media:content tags, loop through them.
2358                         if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content']))
2359                         {
2360                                 foreach ((array) $this->data['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content'] as $content)
2361                                 {
2362                                         if (isset($content['attribs']['']['url']) || isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
2363                                         {
2364                                                 // Attributes
2365                                                 $bitrate = null;
2366                                                 $channels = null;
2367                                                 $duration = null;
2368                                                 $expression = null;
2369                                                 $framerate = null;
2370                                                 $height = null;
2371                                                 $javascript = null;
2372                                                 $lang = null;
2373                                                 $length = null;
2374                                                 $medium = null;
2375                                                 $samplingrate = null;
2376                                                 $type = null;
2377                                                 $url = null;
2378                                                 $width = null;
2379
2380                                                 // Elements
2381                                                 $captions = null;
2382                                                 $categories = null;
2383                                                 $copyrights = null;
2384                                                 $credits = null;
2385                                                 $description = null;
2386                                                 $hashes = null;
2387                                                 $keywords = null;
2388                                                 $player = null;
2389                                                 $ratings = null;
2390                                                 $restrictions = null;
2391                                                 $thumbnails = null;
2392                                                 $title = null;
2393
2394                                                 // Start checking the attributes of media:content
2395                                                 if (isset($content['attribs']['']['bitrate']))
2396                                                 {
2397                                                         $bitrate = $this->sanitize($content['attribs']['']['bitrate'], SIMPLEPIE_CONSTRUCT_TEXT);
2398                                                 }
2399                                                 if (isset($content['attribs']['']['channels']))
2400                                                 {
2401                                                         $channels = $this->sanitize($content['attribs']['']['channels'], SIMPLEPIE_CONSTRUCT_TEXT);
2402                                                 }
2403                                                 if (isset($content['attribs']['']['duration']))
2404                                                 {
2405                                                         $duration = $this->sanitize($content['attribs']['']['duration'], SIMPLEPIE_CONSTRUCT_TEXT);
2406                                                 }
2407                                                 else
2408                                                 {
2409                                                         $duration = $duration_parent;
2410                                                 }
2411                                                 if (isset($content['attribs']['']['expression']))
2412                                                 {
2413                                                         $expression = $this->sanitize($content['attribs']['']['expression'], SIMPLEPIE_CONSTRUCT_TEXT);
2414                                                 }
2415                                                 if (isset($content['attribs']['']['framerate']))
2416                                                 {
2417                                                         $framerate = $this->sanitize($content['attribs']['']['framerate'], SIMPLEPIE_CONSTRUCT_TEXT);
2418                                                 }
2419                                                 if (isset($content['attribs']['']['height']))
2420                                                 {
2421                                                         $height = $this->sanitize($content['attribs']['']['height'], SIMPLEPIE_CONSTRUCT_TEXT);
2422                                                 }
2423                                                 if (isset($content['attribs']['']['lang']))
2424                                                 {
2425                                                         $lang = $this->sanitize($content['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
2426                                                 }
2427                                                 if (isset($content['attribs']['']['fileSize']))
2428                                                 {
2429                                                         $length = ceil($content['attribs']['']['fileSize']);
2430                                                 }
2431                                                 if (isset($content['attribs']['']['medium']))
2432                                                 {
2433                                                         $medium = $this->sanitize($content['attribs']['']['medium'], SIMPLEPIE_CONSTRUCT_TEXT);
2434                                                 }
2435                                                 if (isset($content['attribs']['']['samplingrate']))
2436                                                 {
2437                                                         $samplingrate = $this->sanitize($content['attribs']['']['samplingrate'], SIMPLEPIE_CONSTRUCT_TEXT);
2438                                                 }
2439                                                 if (isset($content['attribs']['']['type']))
2440                                                 {
2441                                                         $type = $this->sanitize($content['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
2442                                                 }
2443                                                 if (isset($content['attribs']['']['width']))
2444                                                 {
2445                                                         $width = $this->sanitize($content['attribs']['']['width'], SIMPLEPIE_CONSTRUCT_TEXT);
2446                                                 }
2447                                                 if (isset($content['attribs']['']['url']))
2448                                                 {
2449                                                         $url = $this->sanitize($content['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
2450                                                 }
2451                                                 // Checking the other optional media: elements. Priority: media:content, media:group, item, channel
2452
2453                                                 // CAPTIONS
2454                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text']))
2455                                                 {
2456                                                         foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption)
2457                                                         {
2458                                                                 $caption_type = null;
2459                                                                 $caption_lang = null;
2460                                                                 $caption_startTime = null;
2461                                                                 $caption_endTime = null;
2462                                                                 $caption_text = null;
2463                                                                 if (isset($caption['attribs']['']['type']))
2464                                                                 {
2465                                                                         $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
2466                                                                 }
2467                                                                 if (isset($caption['attribs']['']['lang']))
2468                                                                 {
2469                                                                         $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
2470                                                                 }
2471                                                                 if (isset($caption['attribs']['']['start']))
2472                                                                 {
2473                                                                         $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
2474                                                                 }
2475                                                                 if (isset($caption['attribs']['']['end']))
2476                                                                 {
2477                                                                         $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
2478                                                                 }
2479                                                                 if (isset($caption['data']))
2480                                                                 {
2481                                                                         $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2482                                                                 }
2483                                                                 $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
2484                                                         }
2485                                                         if (is_array($captions))
2486                                                         {
2487                                                                 $captions = array_values(array_unique($captions));
2488                                                         }
2489                                                 }
2490                                                 else
2491                                                 {
2492                                                         $captions = $captions_parent;
2493                                                 }
2494
2495                                                 // CATEGORIES
2496                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category']))
2497                                                 {
2498                                                         foreach ((array) $content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category)
2499                                                         {
2500                                                                 $term = null;
2501                                                                 $scheme = null;
2502                                                                 $label = null;
2503                                                                 if (isset($category['data']))
2504                                                                 {
2505                                                                         $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2506                                                                 }
2507                                                                 if (isset($category['attribs']['']['scheme']))
2508                                                                 {
2509                                                                         $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
2510                                                                 }
2511                                                                 else
2512                                                                 {
2513                                                                         $scheme = 'http://search.yahoo.com/mrss/category_schema';
2514                                                                 }
2515                                                                 if (isset($category['attribs']['']['label']))
2516                                                                 {
2517                                                                         $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
2518                                                                 }
2519                                                                 $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
2520                                                         }
2521                                                 }
2522                                                 if (is_array($categories) && is_array($categories_parent))
2523                                                 {
2524                                                         $categories = array_values(array_unique(array_merge($categories, $categories_parent)));
2525                                                 }
2526                                                 elseif (is_array($categories))
2527                                                 {
2528                                                         $categories = array_values(array_unique($categories));
2529                                                 }
2530                                                 elseif (is_array($categories_parent))
2531                                                 {
2532                                                         $categories = array_values(array_unique($categories_parent));
2533                                                 }
2534                                                 else
2535                                                 {
2536                                                         $categories = null;
2537                                                 }
2538
2539                                                 // COPYRIGHTS
2540                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright']))
2541                                                 {
2542                                                         $copyright_url = null;
2543                                                         $copyright_label = null;
2544                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url']))
2545                                                         {
2546                                                                 $copyright_url = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
2547                                                         }
2548                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data']))
2549                                                         {
2550                                                                 $copyright_label = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2551                                                         }
2552                                                         $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
2553                                                 }
2554                                                 else
2555                                                 {
2556                                                         $copyrights = $copyrights_parent;
2557                                                 }
2558
2559                                                 // CREDITS
2560                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit']))
2561                                                 {
2562                                                         foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit)
2563                                                         {
2564                                                                 $credit_role = null;
2565                                                                 $credit_scheme = null;
2566                                                                 $credit_name = null;
2567                                                                 if (isset($credit['attribs']['']['role']))
2568                                                                 {
2569                                                                         $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
2570                                                                 }
2571                                                                 if (isset($credit['attribs']['']['scheme']))
2572                                                                 {
2573                                                                         $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
2574                                                                 }
2575                                                                 else
2576                                                                 {
2577                                                                         $credit_scheme = 'urn:ebu';
2578                                                                 }
2579                                                                 if (isset($credit['data']))
2580                                                                 {
2581                                                                         $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2582                                                                 }
2583                                                                 $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
2584                                                         }
2585                                                         if (is_array($credits))
2586                                                         {
2587                                                                 $credits = array_values(array_unique($credits));
2588                                                         }
2589                                                 }
2590                                                 else
2591                                                 {
2592                                                         $credits = $credits_parent;
2593                                                 }
2594
2595                                                 // DESCRIPTION
2596                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description']))
2597                                                 {
2598                                                         $description = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2599                                                 }
2600                                                 else
2601                                                 {
2602                                                         $description = $description_parent;
2603                                                 }
2604
2605                                                 // HASHES
2606                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash']))
2607                                                 {
2608                                                         foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash)
2609                                                         {
2610                                                                 $value = null;
2611                                                                 $algo = null;
2612                                                                 if (isset($hash['data']))
2613                                                                 {
2614                                                                         $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2615                                                                 }
2616                                                                 if (isset($hash['attribs']['']['algo']))
2617                                                                 {
2618                                                                         $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
2619                                                                 }
2620                                                                 else
2621                                                                 {
2622                                                                         $algo = 'md5';
2623                                                                 }
2624                                                                 $hashes[] = $algo.':'.$value;
2625                                                         }
2626                                                         if (is_array($hashes))
2627                                                         {
2628                                                                 $hashes = array_values(array_unique($hashes));
2629                                                         }
2630                                                 }
2631                                                 else
2632                                                 {
2633                                                         $hashes = $hashes_parent;
2634                                                 }
2635
2636                                                 // KEYWORDS
2637                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords']))
2638                                                 {
2639                                                         if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data']))
2640                                                         {
2641                                                                 $temp = explode(',', $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
2642                                                                 foreach ($temp as $word)
2643                                                                 {
2644                                                                         $keywords[] = trim($word);
2645                                                                 }
2646                                                                 unset($temp);
2647                                                         }
2648                                                         if (is_array($keywords))
2649                                                         {
2650                                                                 $keywords = array_values(array_unique($keywords));
2651                                                         }
2652                                                 }
2653                                                 else
2654                                                 {
2655                                                         $keywords = $keywords_parent;
2656                                                 }
2657
2658                                                 // PLAYER
2659                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
2660                                                 {
2661                                                         $player = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
2662                                                 }
2663                                                 else
2664                                                 {
2665                                                         $player = $player_parent;
2666                                                 }
2667
2668                                                 // RATINGS
2669                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating']))
2670                                                 {
2671                                                         foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating)
2672                                                         {
2673                                                                 $rating_scheme = null;
2674                                                                 $rating_value = null;
2675                                                                 if (isset($rating['attribs']['']['scheme']))
2676                                                                 {
2677                                                                         $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
2678                                                                 }
2679                                                                 else
2680                                                                 {
2681                                                                         $rating_scheme = 'urn:simple';
2682                                                                 }
2683                                                                 if (isset($rating['data']))
2684                                                                 {
2685                                                                         $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2686                                                                 }
2687                                                                 $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
2688                                                         }
2689                                                         if (is_array($ratings))
2690                                                         {
2691                                                                 $ratings = array_values(array_unique($ratings));
2692                                                         }
2693                                                 }
2694                                                 else
2695                                                 {
2696                                                         $ratings = $ratings_parent;
2697                                                 }
2698
2699                                                 // RESTRICTIONS
2700                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction']))
2701                                                 {
2702                                                         foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction)
2703                                                         {
2704                                                                 $restriction_relationship = null;
2705                                                                 $restriction_type = null;
2706                                                                 $restriction_value = null;
2707                                                                 if (isset($restriction['attribs']['']['relationship']))
2708                                                                 {
2709                                                                         $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
2710                                                                 }
2711                                                                 if (isset($restriction['attribs']['']['type']))
2712                                                                 {
2713                                                                         $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
2714                                                                 }
2715                                                                 if (isset($restriction['data']))
2716                                                                 {
2717                                                                         $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2718                                                                 }
2719                                                                 $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
2720                                                         }
2721                                                         if (is_array($restrictions))
2722                                                         {
2723                                                                 $restrictions = array_values(array_unique($restrictions));
2724                                                         }
2725                                                 }
2726                                                 else
2727                                                 {
2728                                                         $restrictions = $restrictions_parent;
2729                                                 }
2730
2731                                                 // THUMBNAILS
2732                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail']))
2733                                                 {
2734                                                         foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail)
2735                                                         {
2736                                                                 $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
2737                                                         }
2738                                                         if (is_array($thumbnails))
2739                                                         {
2740                                                                 $thumbnails = array_values(array_unique($thumbnails));
2741                                                         }
2742                                                 }
2743                                                 else
2744                                                 {
2745                                                         $thumbnails = $thumbnails_parent;
2746                                                 }
2747
2748                                                 // TITLES
2749                                                 if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title']))
2750                                                 {
2751                                                         $title = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
2752                                                 }
2753                                                 else
2754                                                 {
2755                                                         $title = $title_parent;
2756                                                 }
2757
2758                                                 $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions, $categories, $channels, $copyrights, $credits, $description, $duration, $expression, $framerate, $hashes, $height, $keywords, $lang, $medium, $player, $ratings, $restrictions, $samplingrate, $thumbnails, $title, $width));
2759                                         }
2760                                 }
2761                         }
2762
2763                         foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link') as $link)
2764                         {
2765                                 if (isset($link['attribs']['']['href']) && !empty($link['attribs']['']['rel']) && $link['attribs']['']['rel'] === 'enclosure')
2766                                 {
2767                                         // Attributes
2768                                         $bitrate = null;
2769                                         $channels = null;
2770                                         $duration = null;
2771                                         $expression = null;
2772                                         $framerate = null;
2773                                         $height = null;
2774                                         $javascript = null;
2775                                         $lang = null;
2776                                         $length = null;
2777                                         $medium = null;
2778                                         $samplingrate = null;
2779                                         $type = null;
2780                                         $url = null;
2781                                         $width = null;
2782
2783                                         $url = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
2784                                         if (isset($link['attribs']['']['type']))
2785                                         {
2786                                                 $type = $this->sanitize($link['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
2787                                         }
2788                                         if (isset($link['attribs']['']['length']))
2789                                         {
2790                                                 $length = ceil($link['attribs']['']['length']);
2791                                         }
2792
2793                                         // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
2794                                         $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
2795                                 }
2796                         }
2797
2798                         foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link') as $link)
2799                         {
2800                                 if (isset($link['attribs']['']['href']) && !empty($link['attribs']['']['rel']) && $link['attribs']['']['rel'] === 'enclosure')
2801                                 {
2802                                         // Attributes
2803                                         $bitrate = null;
2804                                         $channels = null;
2805                                         $duration = null;
2806                                         $expression = null;
2807                                         $framerate = null;
2808                                         $height = null;
2809                                         $javascript = null;
2810                                         $lang = null;
2811                                         $length = null;
2812                                         $medium = null;
2813                                         $samplingrate = null;
2814                                         $type = null;
2815                                         $url = null;
2816                                         $width = null;
2817
2818                                         $url = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
2819                                         if (isset($link['attribs']['']['type']))
2820                                         {
2821                                                 $type = $this->sanitize($link['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
2822                                         }
2823                                         if (isset($link['attribs']['']['length']))
2824                                         {
2825                                                 $length = ceil($link['attribs']['']['length']);
2826                                         }
2827
2828                                         // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
2829                                         $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
2830                                 }
2831                         }
2832
2833                         if ($enclosure = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'enclosure'))
2834                         {
2835                                 if (isset($enclosure[0]['attribs']['']['url']))
2836                                 {
2837                                         // Attributes
2838                                         $bitrate = null;
2839                                         $channels = null;
2840                                         $duration = null;
2841                                         $expression = null;
2842                                         $framerate = null;
2843                                         $height = null;
2844                                         $javascript = null;
2845                                         $lang = null;
2846                                         $length = null;
2847                                         $medium = null;
2848                                         $samplingrate = null;
2849                                         $type = null;
2850                                         $url = null;
2851                                         $width = null;
2852
2853                                         $url = $this->sanitize($enclosure[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($enclosure[0]));
2854                                         if (isset($enclosure[0]['attribs']['']['type']))
2855                                         {
2856                                                 $type = $this->sanitize($enclosure[0]['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
2857                                         }
2858                                         if (isset($enclosure[0]['attribs']['']['length']))
2859                                         {
2860                                                 $length = ceil($enclosure[0]['attribs']['']['length']);
2861                                         }
2862
2863                                         // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
2864                                         $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
2865                                 }
2866                         }
2867
2868                         if (sizeof($this->data['enclosures']) === 0 && ($url || $type || $length || $bitrate || $captions_parent || $categories_parent || $channels || $copyrights_parent || $credits_parent || $description_parent || $duration_parent || $expression || $framerate || $hashes_parent || $height || $keywords_parent || $lang || $medium || $player_parent || $ratings_parent || $restrictions_parent || $samplingrate || $thumbnails_parent || $title_parent || $width))
2869                         {
2870                                 // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
2871                                 $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
2872                         }
2873
2874                         $this->data['enclosures'] = array_values(array_unique($this->data['enclosures']));
2875                 }
2876                 if (!empty($this->data['enclosures']))
2877                 {
2878                         return $this->data['enclosures'];
2879                 }
2880                 else
2881                 {
2882                         return null;
2883                 }
2884         }
2885
2886         /**
2887          * Get the latitude coordinates for the item
2888          *
2889          * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications
2890          *
2891          * Uses `<geo:lat>` or `<georss:point>`
2892          *
2893          * @since 1.0
2894          * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo
2895          * @link http://www.georss.org/ GeoRSS
2896          * @return string|null
2897          */
2898         public function get_latitude()
2899         {
2900                 if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lat'))
2901                 {
2902                         return (float) $return[0]['data'];
2903                 }
2904                 elseif (($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match))
2905                 {
2906                         return (float) $match[1];
2907                 }
2908                 else
2909                 {
2910                         return null;
2911                 }
2912         }
2913
2914         /**
2915          * Get the longitude coordinates for the item
2916          *
2917          * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications
2918          *
2919          * Uses `<geo:long>`, `<geo:lon>` or `<georss:point>`
2920          *
2921          * @since 1.0
2922          * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo
2923          * @link http://www.georss.org/ GeoRSS
2924          * @return string|null
2925          */
2926         public function get_longitude()
2927         {
2928                 if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'long'))
2929                 {
2930                         return (float) $return[0]['data'];
2931                 }
2932                 elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lon'))
2933                 {
2934                         return (float) $return[0]['data'];
2935                 }
2936                 elseif (($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match))
2937                 {
2938                         return (float) $match[2];
2939                 }
2940                 else
2941                 {
2942                         return null;
2943                 }
2944         }
2945
2946         /**
2947          * Get the `<atom:source>` for the item
2948          *
2949          * @since 1.1
2950          * @return SimplePie_Source|null
2951          */
2952         public function get_source()
2953         {
2954                 if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'source'))
2955                 {
2956                         return $this->registry->create('Source', array($this, $return[0]));
2957                 }
2958                 else
2959                 {
2960                         return null;
2961                 }
2962         }
2963 }
2964