a77574b37e4cda7f21d0a7baf1c4627afbfe77cd
[moodle.git] / lib / simplepie / library / 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  */
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;
66         /**
67          * Raw data
68          *
69          * @access private
70          * @var array
71          */
72         var $data = array();
74         /**
75          * Registry object
76          *
77          * @see set_registry
78          * @var SimplePie_Registry
79          */
80         protected $registry;
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         }
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         }
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         }
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         }
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         }
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         }
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         }
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         }
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         }
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         }
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                 }
362                 elseif (!$description_only)
363                 {
364                         return $this->get_content(true);
365                 }
366                 else
367                 {
368                         return null;
369                 }
370         }
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         }
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         }
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();
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                 }
485                 if (!empty($categories))
486                 {
487                         return array_unique($categories);
488                 }
489                 else
490                 {
491                         return null;
492                 }
493         }
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         }
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         }
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                 }
591                 if (!empty($contributors))
592                 {
593                         return array_unique($contributors);
594                 }
595                 else
596                 {
597                         return null;
598                 }
599         }
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                 }
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         }
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         }
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                         }
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);
788                                 case 'U':
789                                         return $this->data['date']['parsed'];
791                                 default:
792                                         return date($date_format, $this->data['date']['parsed']);
793                         }
794                 }
795                 else
796                 {
797                         return null;
798                 }
799         }
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                         }
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);
839                                 case 'U':
840                                         return $this->data['updated']['parsed'];
842                                 default:
843                                         return date($date_format, $this->data['updated']['parsed']);
844                         }
845                 }
846                 else
847                 {
848                         return null;
849                 }
850         }
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         }
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                 }
896                 return gmdate($date_format, $date);
897         }
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                 }
914                 return gmdate($date_format, $date);
915         }
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         }
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         }
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));
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                         }
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         }
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         }
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();
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;
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();
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                         }
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));
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                         }
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                         }
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                         }
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                         }
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                         }
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                         }
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                         }
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                         }
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                         }
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                         }
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                         }
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                         }
1699                         // Clear the memory
1700                         unset($parent);
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;
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;
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;
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;
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);
1827                                                         // Checking the other optional media: elements. Priority: media:content, media:group, item, channel
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                                                         }
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                                                         }
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                                                         }
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                                                         }
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                                                         }
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                                                         }
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                                                         }
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                                                         }
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                                                         }
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                                                         }
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                                                         }
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                                                         }
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                         }
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;
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;
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
2453                                                 // CAPTIONS
2454                             &nb