MDL-33116 Media filter broken with slasharguments off
[moodle.git] / lib / medialib.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Classes for handling embedded media (mainly audio and video).
19  *
20  * These are used only from within the core media renderer.
21  *
22  * To embed media from Moodle code, do something like the following:
23  *
24  * $mediarenderer = $PAGE->get_renderer('core', 'media');
25  * echo $mediarenderer->embed_url(new moodle_url('http://example.org/a.mp3'));
26  *
27  * You do not need to require this library file manually. Getting the renderer
28  * (the first line above) requires this library file automatically.
29  *
30  * @package core_media
31  * @copyright 2012 The Open University
32  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
33  */
35 defined('MOODLE_INTERNAL') || die();
37 if (!defined('CORE_MEDIA_VIDEO_WIDTH')) {
38     // Default video width if no width is specified; some players may do something
39     // more intelligent such as use real video width.
40     // May be defined in config.php if required.
41     define('CORE_MEDIA_VIDEO_WIDTH', 400);
42 }
43 if (!defined('CORE_MEDIA_VIDEO_HEIGHT')) {
44     // Default video height. May be defined in config.php if required.
45     define('CORE_MEDIA_VIDEO_HEIGHT', 300);
46 }
47 if (!defined('CORE_MEDIA_AUDIO_WIDTH')) {
48     // Default audio width if no width is specified.
49     // May be defined in config.php if required.
50     define('CORE_MEDIA_AUDIO_WIDTH', 300);
51 }
54 /**
55  * Constants and static utility functions for use with core_media_renderer.
56  *
57  * @copyright 2011 The Open University
58  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
59  */
60 abstract class core_media {
61     /**
62      * Option: Disable text link fallback.
63      *
64      * Use this option if you are going to print a visible link anyway so it is
65      * pointless to have one as fallback.
66      *
67      * To enable, set value to true.
68      */
69     const OPTION_NO_LINK = 'nolink';
71     /**
72      * Option: When embedding, if there is no matching embed, do not use the
73      * default link fallback player; instead return blank.
74      *
75      * This is different from OPTION_NO_LINK because this option still uses the
76      * fallback link if there is some kind of embedding. Use this option if you
77      * are going to check if the return value is blank and handle it specially.
78      *
79      * To enable, set value to true.
80      */
81     const OPTION_FALLBACK_TO_BLANK = 'embedorblank';
83     /**
84      * Option: Enable players which are only suitable for use when we trust the
85      * user who embedded the content.
86      *
87      * At present, this option enables the SWF player.
88      *
89      * To enable, set value to true.
90      */
91     const OPTION_TRUSTED = 'trusted';
93     /**
94      * Option: Put a div around the output (if not blank) so that it displays
95      * as a block using the 'resourcecontent' CSS class.
96      *
97      * To enable, set value to true.
98      */
99     const OPTION_BLOCK = 'block';
101     /**
102      * Given a string containing multiple URLs separated by #, this will split
103      * it into an array of moodle_url objects suitable for using when calling
104      * embed_alternatives.
105      *
106      * Note that the input string should NOT be html-escaped (i.e. if it comes
107      * from html, call html_entity_decode first).
108      *
109      * @param string $combinedurl String of 1 or more alternatives separated by #
110      * @param int $width Output variable: width (will be set to 0 if not specified)
111      * @param int $height Output variable: height (0 if not specified)
112      * @return array Array of 1 or more moodle_url objects
113      */
114     public static function split_alternatives($combinedurl, &$width, &$height) {
115         $urls = explode('#', $combinedurl);
116         $width = 0;
117         $height = 0;
118         $returnurls = array();
120         foreach ($urls as $url) {
121             $matches = null;
123             // You can specify the size as a separate part of the array like
124             // #d=640x480 without actually including a url in it.
125             if (preg_match('/^d=([\d]{1,4})x([\d]{1,4})$/i', $url, $matches)) {
126                 $width  = $matches[1];
127                 $height = $matches[2];
128                 continue;
129             }
131             // Can also include the ?d= as part of one of the URLs (if you use
132             // more than one they will be ignored except the last).
133             if (preg_match('/\?d=([\d]{1,4})x([\d]{1,4})$/i', $url, $matches)) {
134                 $width  = $matches[1];
135                 $height = $matches[2];
137                 // Trim from URL.
138                 $url = str_replace($matches[0], '', $url);
139             }
141             // Clean up url.
142             $url = clean_param($url, PARAM_URL);
143             if (empty($url)) {
144                 continue;
145             }
147             // Turn it into moodle_url object.
148             $returnurls[] = new moodle_url($url);
149         }
151         return $returnurls;
152     }
154     /**
155      * Returns the file extension for a URL.
156      * @param moodle_url $url URL
157      */
158     public static function get_extension(moodle_url $url) {
159         // Note: Does not use textlib (. is UTF8-safe).
160         $filename = self::get_filename($url);
161         $dot = strrpos($filename, '.');
162         if ($dot === false) {
163             return '';
164         } else {
165             return strtolower(substr($filename, $dot + 1));
166         }
167     }
169     /**
170      * Obtains the filename from the moodle_url.
171      * @param moodle_url $url URL
172      * @return string Filename only (not escaped)
173      */
174     public static function get_filename(moodle_url $url) {
175         global $CFG;
177         // Use the 'file' parameter if provided (for links created when
178         // slasharguments was off). If not present, just use URL path.
179         $path = $url->get_param('file');
180         if (!$path) {
181             $path = $url->get_path();
182         }
184         // Remove everything before last / if present. Does not use textlib as / is UTF8-safe.
185         $slash = strrpos($path, '/');
186         if ($slash !== false) {
187             $path = substr($path, $slash + 1);
188         }
189         return $path;
190     }
192     /**
193      * Guesses MIME type for a moodle_url based on file extension.
194      * @param moodle_url $url URL
195      * @return string MIME type
196      */
197     public static function get_mimetype(moodle_url $url) {
198         return mimeinfo('type', self::get_filename($url));
199     }
203 /**
204  * Base class for media players.
205  *
206  * Media players return embed HTML for a particular way of playing back audio
207  * or video (or another file type).
208  *
209  * In order to make the code more lightweight, this is not a plugin type
210  * (players cannot have their own settings, database tables, capabilities, etc).
211  * These classes are used only by core_media_renderer in outputrenderers.php.
212  * If you add a new class here (in core code) you must modify the
213  * get_players_raw function in that file to include it.
214  *
215  * If a Moodle installation wishes to add extra player objects they can do so
216  * by overriding that renderer in theme, and overriding the get_players_raw
217  * function. The new player class should then of course be defined within the
218  * custom theme or other suitable location, not in this file.
219  *
220  * @copyright 2011 The Open University
221  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
222  */
223 abstract class core_media_player {
224     /**
225      * Placeholder text used to indicate where the fallback content is placed
226      * within a result.
227      */
228     const PLACEHOLDER = '<!--FALLBACK-->';
230     /**
231      * Generates code required to embed the player.
232      *
233      * The returned code contains a placeholder comment '<!--FALLBACK-->'
234      * (constant core_media_player::PLACEHOLDER) which indicates the location
235      * where fallback content should be placed in the event that this type of
236      * player is not supported by user browser.
237      *
238      * The $urls parameter includes one or more alternative media formats that
239      * are supported by this player. It does not include formats that aren't
240      * supported (see list_supported_urls).
241      *
242      * The $options array contains key-value pairs. See OPTION_xx constants
243      * for documentation of standard option(s).
244      *
245      * @param array $urls URLs of media files
246      * @param string $name Display name; '' to use default
247      * @param int $width Optional width; 0 to use default
248      * @param int $height Optional height; 0 to use default
249      * @param array $options Options array
250      * @return string HTML code for embed
251      */
252     public abstract function embed($urls, $name, $width, $height, $options);
254     /**
255      * Gets the list of file extensions supported by this media player.
256      *
257      * Note: This is only required for the default implementation of
258      * list_supported_urls. If you override that function to determine
259      * supported URLs in some way other than by extension, then this function
260      * is not necessary.
261      *
262      * @return array Array of strings (extension not including dot e.g. 'mp3')
263      */
264     public function get_supported_extensions() {
265         return array();
266     }
268     /**
269      * Lists keywords that must be included in a url that can be embedded with
270      * this player. Any such keywords should be added to the array.
271      *
272      * For example if this player supports FLV and F4V files then it should add
273      * '.flv' and '.f4v' to the array. (The check is not case-sensitive.)
274      *
275      * Default handling calls the get_supported_extensions function and adds
276      * a dot to each of those values, so players only need to override this
277      * if they don't implement get_supported_extensions.
278      *
279      * This is used to improve performance when matching links in the media filter.
280      *
281      * @return array Array of keywords to add to the embeddable markers list
282      */
283     public function get_embeddable_markers() {
284         $markers = array();
285         foreach ($this->get_supported_extensions() as $extension) {
286             $markers[] = '.' . $extension;
287         }
288         return $markers;
289     }
291     /**
292      * Gets the ranking of this player. This is an integer used to decide which
293      * player to use (after applying other considerations such as which ones
294      * the user has disabled).
295      *
296      * Rank must be unique (no two players should have the same rank).
297      *
298      * Rank zero has a special meaning, indicating that this 'player' does not
299      * really embed the video.
300      *
301      * Rank is not a user-configurable value because it needs to be defined
302      * carefully in order to ensure that the embedding fallbacks actually work.
303      * It might be possible to have some user options which affect rank, but
304      * these would be best defined as e.g. checkboxes in settings that have
305      * a particular effect on the rank of a couple of plugins, rather than
306      * letting users generally alter rank.
307      *
308      * Note: Within medialib.php, players are listed in rank order (highest
309      * rank first).
310      *
311      * @return int Rank (higher is better)
312      */
313     public abstract function get_rank();
315     /**
316      * @return bool True if player is enabled
317      */
318     public function is_enabled() {
319         global $CFG;
321         // With the class core_media_player_html5video it is enabled
322         // based on $CFG->core_media_enable_html5video.
323         $setting = str_replace('_player_', '_enable_', get_class($this));
324         return !empty($CFG->{$setting});
325     }
327     /**
328      * Given a list of URLs, returns a reduced array containing only those URLs
329      * which are supported by this player. (Empty if none.)
330      * @param array $urls Array of moodle_url
331      * @param array $options Options (same as will be passed to embed)
332      * @return array Array of supported moodle_url
333      */
334     public function list_supported_urls(array $urls, array $options = array()) {
335         $extensions = $this->get_supported_extensions();
336         $result = array();
337         foreach ($urls as $url) {
338             if (in_array(core_media::get_extension($url), $extensions)) {
339                 $result[] = $url;
340             }
341         }
342         return $result;
343     }
345     /**
346      * Obtains suitable name for media. Uses specified name if there is one,
347      * otherwise makes one up.
348      * @param string $name User-specified name ('' if none)
349      * @param array $urls Array of moodle_url used to make up name
350      * @return string Name
351      */
352     protected function get_name($name, $urls) {
353         // If there is a specified name, use that.
354         if ($name) {
355             return $name;
356         }
358         // Get filename of first URL.
359         $url = reset($urls);
360         $name = core_media::get_filename($url);
362         // If there is more than one url, strip the extension as we could be
363         // referring to a different one or several at once.
364         if (count($urls) > 1) {
365             $name = preg_replace('~\.[^.]*$~', '', $name);
366         }
368         return $name;
369     }
371     /**
372      * Compares by rank order, highest first. Used for sort functions.
373      * @param core_media_player $a Player A
374      * @param core_media_player $b Player B
375      * @return int Negative if A should go before B, positive for vice versa
376      */
377     public static function compare_by_rank(core_media_player $a, core_media_player $b) {
378         return $b->get_rank() - $a->get_rank();
379     }
381     /**
382      * Utility function that sets width and height to defaults if not specified
383      * as a parameter to the function (will be specified either if, (a) the calling
384      * code passed it, or (b) the URL included it).
385      * @param int $width Width passed to function (updated with final value)
386      * @param int $height Height passed to function (updated with final value)
387      */
388     protected static function pick_video_size(&$width, &$height) {
389         if (!$width) {
390             $width = CORE_MEDIA_VIDEO_WIDTH;
391             $height = CORE_MEDIA_VIDEO_HEIGHT;
392         }
393     }
397 /**
398  * Base class for players which handle external links (YouTube etc).
399  *
400  * As opposed to media files.
401  *
402  * @copyright 2011 The Open University
403  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
404  */
405 abstract class core_media_player_external extends core_media_player {
406     /**
407      * Array of matches from regular expression - subclass can assume these
408      * will be valid when the embed function is called, to save it rerunning
409      * the regex.
410      * @var array
411      */
412     protected $matches;
414     /**
415      * Part of a regular expression, including ending ~ symbol (note: these
416      * regexes use ~ instead of / because URLs and HTML code typically include
417      * / symbol and makes harder to read if you have to escape it).
418      * Matches the end part of a link after you have read the 'important' data
419      * including optional #d=400x300 at end of url, plus content of <a> tag,
420      * up to </a>.
421      * @var string
422      */
423     const END_LINK_REGEX_PART = '[^#]*(#d=([\d]{1,4})x([\d]{1,4}))?~si';
425     public function embed($urls, $name, $width, $height, $options) {
426         return $this->embed_external(reset($urls), $name, $width, $height, $options);
427     }
429     /**
430      * Obtains HTML code to embed the link.
431      * @param moodle_url $url Single URL to embed
432      * @param string $name Display name; '' to use default
433      * @param int $width Optional width; 0 to use default
434      * @param int $height Optional height; 0 to use default
435      * @param array $options Options array
436      * @return string HTML code for embed
437      */
438     protected abstract function embed_external(moodle_url $url, $name, $width, $height, $options);
440     public function list_supported_urls(array $urls, array $options = array()) {
441         // These only work with a SINGLE url (there is no fallback).
442         if (count($urls) != 1) {
443             return array();
444         }
445         $url = reset($urls);
447         // Check against regex.
448         if (preg_match($this->get_regex(), $url->out(false), $this->matches)) {
449             return array($url);
450         }
452         return array();
453     }
455     /**
456      * Returns regular expression used to match URLs that this player handles
457      * @return string PHP regular expression e.g. '~^https?://example.org/~'
458      */
459     protected function get_regex() {
460         return '~^unsupported~';
461     }
463     /**
464      * Annoyingly, preg_match $matches result does not always have the same
465      * number of parameters - it leaves out optional ones at the end. WHAT.
466      * Anyway, this function can be used to fix it.
467      * @param array $matches Array that should be adjusted
468      * @param int $count Number of capturing groups (=6 to make $matches[6] work)
469      */
470     protected static function fix_match_count(&$matches, $count) {
471         for ($i = count($matches); $i <= $count; $i++) {
472             $matches[$i] = false;
473         }
474     }
478 /**
479  * Player that embeds Vimeo links.
480  *
481  * @copyright 2011 The Open University
482  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
483  */
484 class core_media_player_vimeo extends core_media_player_external {
485     protected function embed_external(moodle_url $url, $name, $width, $height, $options) {
486         $videoid = $this->matches[1];
487         $info = s($name);
489         // Note: resizing via url is not supported, user can click the fullscreen
490         // button instead. iframe embedding is not xhtml strict but it is the only
491         // option that seems to work on most devices.
492         self::pick_video_size($width, $height);
494         $output = <<<OET
495 <span class="mediaplugin mediaplugin_vimeo">
496 <iframe title="$info" src="http://player.vimeo.com/video/$videoid"
497   width="$width" height="$height" frameborder="0"></iframe>
498 </span>
499 OET;
501         return $output;
502     }
504     protected function get_regex() {
505         // Initial part of link.
506         $start = '~^http://vimeo\.com/';
507         // Middle bit: either watch?v= or v/.
508         $middle = '([0-9]+)';
509         return $start . $middle . core_media_player_external::END_LINK_REGEX_PART;
510     }
512     public function get_rank() {
513         return 1010;
514     }
516     public function get_embeddable_markers() {
517         return array('vimeo.com/');
518     }
521 /**
522  * Player that creates YouTube embedding.
523  *
524  * @copyright 2011 The Open University
525  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
526  */
527 class core_media_player_youtube extends core_media_player_external {
528     protected function embed_external(moodle_url $url, $name, $width, $height, $options) {
529         global $CFG;
531         $site = $this->matches[1];
532         $videoid = $this->matches[3];
534         $info = trim($name);
535         if (empty($info) or strpos($info, 'http') === 0) {
536             $info = get_string('siteyoutube', 'core_media');
537         }
538         $info = s($info);
540         self::pick_video_size($width, $height);
542         if (empty($CFG->xmlstrictheaders)) {
543             return <<<OET
544 <iframe title="$info" width="$width" height="$height"
545   src="$site/embed/$videoid?rel=0&wmode=transparent" frameborder="0" allowfullscreen></iframe>
546 OET;
547         }
549         // NOTE: we can not use any link fallback because it breaks built-in
550         // player on iOS devices.
551         $output = <<<OET
552 <span class="mediaplugin mediaplugin_youtube">
553 <object title="$info" type="application/x-shockwave-flash"
554   data="$site/v/$videoid&amp;fs=1&amp;rel=0" width="$width" height="$height">
555  <param name="movie" value="$site/v/$videoid&amp;fs=1&amp;rel=0" />
556  <param name="FlashVars" value="playerMode=embedded" />
557  <param name="allowFullScreen" value="true" />
558 </object>
559 </span>
560 OET;
562         return $output;
563     }
565     protected function get_regex() {
566         // Initial part of link.
567         $start = '~^(https?://www\.youtube(-nocookie)?\.com)/';
568         // Middle bit: either watch?v= or v/.
569         $middle = '(?:watch\?v=|v/)([a-z0-9\-_]+)';
570         return $start . $middle . core_media_player_external::END_LINK_REGEX_PART;
571     }
573     public function get_rank() {
574         // I decided to make the link-embedding ones (that don't handle file
575         // formats) have ranking in the 1000 range.
576         return 1001;
577     }
579     public function get_embeddable_markers() {
580         return array('youtube');
581     }
585 /**
586  * Player that creates YouTube playlist embedding.
587  *
588  * @copyright 2011 The Open University
589  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
590  */
591 class core_media_player_youtube_playlist extends core_media_player_external {
592     public function is_enabled() {
593         global $CFG;
594         // Use the youtube on/off flag.
595         return $CFG->core_media_enable_youtube;
596     }
598     protected function embed_external(moodle_url $url, $name, $width, $height, $options) {
599         $site = $this->matches[1];
600         $playlist = $this->matches[3];
602         $info = trim($name);
603         if (empty($info) or strpos($info, 'http') === 0) {
604             $info = get_string('siteyoutube', 'core_media');
605         }
606         $info = s($info);
608         self::pick_video_size($width, $height);
610         // TODO: iframe HTML 5 video not implemented and object does not work
611         // on iOS devices.
612         $fallback = core_media_player::PLACEHOLDER;
613         $output = <<<OET
614 <span class="mediaplugin mediaplugin_youtube">
615 <object title="$info" type="application/x-shockwave-flash"
616   data="$site/p/$playlist&amp;fs=1&amp;rel=0" width="$width" height="$height">
617  <param name="movie" value="$site/v/$playlist&amp;fs=1&amp;rel=0" />
618  <param name="FlashVars" value="playerMode=embedded" />
619  <param name="allowFullScreen" value="true" />
620 $fallback</object>
621 </span>
622 OET;
624         return $output;
625     }
627     protected function get_regex() {
628         // Initial part of link.
629         $start = '~^(https?://www\.youtube(-nocookie)?\.com)/';
630         // Middle bit: either view_play_list?p= or p/ (doesn't work on youtube) or playlist?list=.
631         $middle = '(?:view_play_list\?p=|p/|playlist\?list=)([a-z0-9\-_]+)';
632         return $start . $middle . core_media_player_external::END_LINK_REGEX_PART;
633     }
635     public function get_rank() {
636         // I decided to make the link-embedding ones (that don't handle file
637         // formats) have ranking in the 1000 range.
638         return 1000;
639     }
641     public function get_embeddable_markers() {
642         return array('youtube');
643     }
647 /**
648  * MP3 player inserted using JavaScript.
649  *
650  * @copyright 2011 The Open University
651  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
652  */
653 class core_media_player_mp3 extends core_media_player {
654     public function embed($urls, $name, $width, $height, $options) {
655         // Use first url (there can actually be only one unless some idiot
656         // enters two mp3 files as alternatives).
657         $url = reset($urls);
659         // Unique id even across different http requests made at the same time
660         // (for AJAX, iframes).
661         $id = 'core_media_mp3_' . md5(time() . '_' . rand());
663         // When Flash or JavaScript are not available only the fallback is displayed,
664         // using span not div because players are inline elements.
665         $spanparams = array('id' => $id, 'class' => 'mediaplugin mediaplugin_mp3');
666         if ($width) {
667             $spanparams['style'] = 'width: ' . $width . 'px';
668         }
669         $output = html_writer::tag('span', core_media_player::PLACEHOLDER, $spanparams);
670         // We can not use standard JS init because this may be cached
671         // note: use 'small' size unless embedding in block mode.
672         $output .= html_writer::script(js_writer::function_call(
673                 'M.util.add_audio_player', array($id, $url->out(false),
674                 empty($options[core_media::OPTION_BLOCK]))));
676         return $output;
677     }
679     public function get_supported_extensions() {
680         return array('mp3');
681     }
683     public function get_rank() {
684         return 80;
685     }
689 /**
690  * Flash video player inserted using JavaScript.
691  *
692  * @copyright 2011 The Open University
693  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
694  */
695 class core_media_player_flv extends core_media_player {
696     public function embed($urls, $name, $width, $height, $options) {
697         // Use first url (there can actually be only one unless some idiot
698         // enters two mp3 files as alternatives).
699         $url = reset($urls);
701         // Unique id even across different http requests made at the same time
702         // (for AJAX, iframes).
703         $id = 'core_media_flv_' . md5(time() . '_' . rand());
705         // Compute width and height.
706         $autosize = false;
707         if (!$width && !$height) {
708             $width = CORE_MEDIA_VIDEO_WIDTH;
709             $height = CORE_MEDIA_VIDEO_HEIGHT;
710             $autosize = true;
711         }
713         // Fallback span (will normally contain link).
714         $output = html_writer::tag('span', core_media_player::PLACEHOLDER,
715                 array('id'=>$id, 'class'=>'mediaplugin mediaplugin_flv'));
716         // We can not use standard JS init because this may be cached.
717         $output .= html_writer::script(js_writer::function_call(
718                 'M.util.add_video_player', array($id, addslashes_js($url->out(false)),
719                 $width, $height, $autosize)));
720         return $output;
721     }
723     public function get_supported_extensions() {
724         return array('flv', 'f4v');
725     }
727     public function get_rank() {
728         return 70;
729     }
733 /**
734  * Embeds Windows Media Player using object tag.
735  *
736  * @copyright 2011 The Open University
737  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
738  */
739 class core_media_player_wmp extends core_media_player {
740     public function embed($urls, $name, $width, $height, $options) {
741         // Get URL (we just use first, probably there is only one).
742         $firsturl = reset($urls);
743         $url = $firsturl->out(false);
745         // Work out width.
746         if (!$width || !$height) {
747             // Object tag has default size.
748             $mpsize = '';
749             $size = 'width="' . CORE_MEDIA_VIDEO_WIDTH .
750                     '" height="' . (CORE_MEDIA_VIDEO_HEIGHT+64) . '"';
751             $autosize = 'true';
752         } else {
753             $size = 'width="' . $width . '" height="' . ($height + 15) . '"';
754             $mpsize = 'width="' . $width . '" height="' . ($height + 64) . '"';
755             $autosize = 'false';
756         }
758         // MIME type for object tag.
759         $mimetype = core_media::get_mimetype($firsturl);
761         $fallback = core_media_player::PLACEHOLDER;
763         // Embed code.
764         return <<<OET
765 <span class="mediaplugin mediaplugin_wmp">
766     <object classid="CLSID:6BF52A52-394A-11d3-B153-00C04F79FAA6" $mpsize
767             standby="Loading Microsoft(R) Windows(R) Media Player components..."
768             type="application/x-oleobject">
769         <param name="Filename" value="$url" />
770         <param name="src" value="$url" />
771         <param name="url" value="$url" />
772         <param name="ShowControls" value="true" />
773         <param name="AutoRewind" value="true" />
774         <param name="AutoStart" value="false" />
775         <param name="Autosize" value="$autosize" />
776         <param name="EnableContextMenu" value="true" />
777         <param name="TransparentAtStart" value="false" />
778         <param name="AnimationAtStart" value="false" />
779         <param name="ShowGotoBar" value="false" />
780         <param name="EnableFullScreenControls" value="true" />
781         <param name="uimode" value="full" />
782         <!--[if !IE]>-->
783         <object data="$url" type="$mimetype" $size>
784             <param name="src" value="$url" />
785             <param name="controller" value="true" />
786             <param name="autoplay" value="false" />
787             <param name="autostart" value="false" />
788             <param name="resize" value="scale" />
789         <!--<![endif]-->
790             $fallback
791         <!--[if !IE]>-->
792         </object>
793         <!--<![endif]-->
794     </object>
795 </span>
796 OET;
797     }
799     public function get_supported_extensions() {
800         return array('wmv', 'avi');
801     }
803     public function get_rank() {
804         return 60;
805     }
809 /**
810  * Media player using object tag and QuickTime player.
811  *
812  * @copyright 2011 The Open University
813  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
814  */
815 class core_media_player_qt extends core_media_player {
816     public function embed($urls, $name, $width, $height, $options) {
817         // Show first URL.
818         $firsturl = reset($urls);
819         $url = $firsturl->out(true);
821         // Work out size.
822         if (!$width || !$height) {
823             $size = 'width="' . CORE_MEDIA_VIDEO_WIDTH .
824                     '" height="' . (CORE_MEDIA_VIDEO_HEIGHT + 15) . '"';
825         } else {
826             $size = 'width="' . $width . '" height="' . ($height + 15) . '"';
827         }
829         // MIME type for object tag.
830         $mimetype = core_media::get_mimetype($firsturl);
832         $fallback = core_media_player::PLACEHOLDER;
834         // Embed code.
835         return <<<OET
836 <span class="mediaplugin mediaplugin_qt">
837     <object classid="clsid:02BF25D5-8C17-4B23-BC80-D3488ABDDC6B"
838             codebase="http://www.apple.com/qtactivex/qtplugin.cab" $size>
839         <param name="pluginspage" value="http://www.apple.com/quicktime/download/" />
840         <param name="src" value="$url" />
841         <param name="controller" value="true" />
842         <param name="loop" value="true" />
843         <param name="autoplay" value="false" />
844         <param name="autostart" value="false" />
845         <param name="scale" value="aspect" />
846         <!--[if !IE]>-->
847         <object data="$url" type="$mimetype" $size>
848             <param name="src" value="$url" />
849             <param name="pluginurl" value="http://www.apple.com/quicktime/download/" />
850             <param name="controller" value="true" />
851             <param name="loop" value="true" />
852             <param name="autoplay" value="false" />
853             <param name="autostart" value="false" />
854             <param name="scale" value="aspect" />
855         <!--<![endif]-->
856             $fallback
857         <!--[if !IE]>-->
858         </object>
859         <!--<![endif]-->
860     </object>
861 </span>
862 OET;
863     }
865     public function get_supported_extensions() {
866         return array('mpg', 'mpeg', 'mov', 'mp4', 'm4v', 'm4a');
867     }
869     public function get_rank() {
870         return 50;
871     }
875 /**
876  * Media player using object tag and RealPlayer.
877  *
878  * Hopefully nobody is using this obsolete format any more!
879  *
880  * @copyright 2011 The Open University
881  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
882  */
883 class core_media_player_rm extends core_media_player {
884     public function embed($urls, $name, $width, $height, $options) {
885         // Show first URL.
886         $firsturl = reset($urls);
887         $url = $firsturl->out(true);
889         // Get name to use as title.
890         $info = s($this->get_name($name, $urls));
892         // The previous version of this code has the following comment, which
893         // I don't understand, but trust it is correct:
894         // Note: the size is hardcoded intentionally because this does not work anyway!
895         $width = CORE_MEDIA_VIDEO_WIDTH;
896         $height = CORE_MEDIA_VIDEO_HEIGHT;
898         $fallback = core_media_player::PLACEHOLDER;
899         return <<<OET
900 <span class="mediaplugin mediaplugin_real">
901     <object title="$info" classid="clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA"
902             data="$url" width="$width" height="$height"">
903         <param name="src" value="$url" />
904         <param name="controls" value="All" />
905         <!--[if !IE]>-->
906         <object title="$info" type="audio/x-pn-realaudio-plugin"
907                 data="$url" width="$width" height="$height">
908             <param name="src" value="$url" />
909             <param name="controls" value="All" />
910         <!--<![endif]-->
911             $fallback
912         <!--[if !IE]>-->
913         </object>
914         <!--<![endif]-->
915   </object>
916 </span>
917 OET;
918     }
920     public function get_supported_extensions() {
921         return array('ra', 'ram', 'rm', 'rv');
922     }
924     public function get_rank() {
925         return 40;
926     }
930 /**
931  * Media player for Flash SWF files.
932  *
933  * This player contains additional security restriction: it will only be used
934  * if you add option core_media_player_swf::ALLOW = true.
935  *
936  * Code should only set this option if it has verified that the data was
937  * embedded by a trusted user (e.g. in trust text).
938  *
939  * @copyright 2011 The Open University
940  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
941  */
942 class core_media_player_swf extends core_media_player {
943     public function embed($urls, $name, $width, $height, $options) {
944         self::pick_video_size($width, $height);
946         $firsturl = reset($urls);
947         $url = $firsturl->out(true);
949         $fallback = core_media_player::PLACEHOLDER;
950         $output = <<<OET
951 <span class="mediaplugin mediaplugin_swf">
952   <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="$width" height="$height">
953     <param name="movie" value="$url" />
954     <param name="autoplay" value="true" />
955     <param name="loop" value="true" />
956     <param name="controller" value="true" />
957     <param name="scale" value="aspect" />
958     <param name="base" value="." />
959     <param name="allowscriptaccess" value="never" />
960 <!--[if !IE]>-->
961     <object type="application/x-shockwave-flash" data="$url" width="$width" height="$height">
962       <param name="controller" value="true" />
963       <param name="autoplay" value="true" />
964       <param name="loop" value="true" />
965       <param name="scale" value="aspect" />
966       <param name="base" value="." />
967       <param name="allowscriptaccess" value="never" />
968 <!--<![endif]-->
969 $fallback
970 <!--[if !IE]>-->
971     </object>
972 <!--<![endif]-->
973   </object>
974 </span>
975 OET;
977         return $output;
978     }
980     public function get_supported_extensions() {
981         return array('swf');
982     }
984     public function list_supported_urls(array $urls, array $options = array()) {
985         // Not supported unless the creator is trusted.
986         if (empty($options[core_media::OPTION_TRUSTED])) {
987             return array();
988         }
989         return parent::list_supported_urls($urls, $options);
990     }
992     public function get_rank() {
993         return 30;
994     }
998 /**
999  * Player that creates HTML5 <video> tag.
1000  *
1001  * @copyright 2011 The Open University
1002  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1003  */
1004 class core_media_player_html5video extends core_media_player {
1005     public function embed($urls, $name, $width, $height, $options) {
1006         // Special handling to make videos play on Android devices pre 2.3.
1007         // Note: I tested and 2.3.3 (in emulator) works without, is 533.1 webkit.
1008         $oldandroid = check_browser_version('WebKit Android') &&
1009                 !check_browser_version('WebKit Android', '533.1');
1011         // Build array of source tags.
1012         $sources = array();
1013         foreach ($urls as $url) {
1014             $mimetype = core_media::get_mimetype($url);
1015             $source = html_writer::tag('source', '', array('src' => $url, 'type' => $mimetype));
1016             if ($mimetype === 'video/mp4') {
1017                 if ($oldandroid) {
1018                     // Old Android fails if you specify the type param.
1019                     $source = html_writer::tag('source', '', array('src' => $url));
1020                 }
1022                 // Better add m4v as first source, it might be a bit more
1023                 // compatible with problematic browsers.
1024                 array_unshift($sources, $source);
1025             } else {
1026                 $sources[] = $source;
1027             }
1028         }
1030         $sources = implode("\n", $sources);
1031         $title = s($this->get_name($name, $urls));
1033         if (!$width) {
1034             // No width specified, use system default.
1035             $width = CORE_MEDIA_VIDEO_WIDTH;
1036         }
1038         if (!$height) {
1039             // Let browser choose height automatically.
1040             $size = "width=\"$width\"";
1041         } else {
1042             $size = "width=\"$width\" height=\"$height\"";
1043         }
1045         $sillyscript = '';
1046         $idtag = '';
1047         if ($oldandroid) {
1048             // Old Android does not support 'controls' option.
1049             $id = 'core_media_html5v_' . md5(time() . '_' . rand());
1050             $idtag = 'id="' . $id . '"';
1051             $sillyscript = <<<OET
1052 <script type="text/javascript">
1053 document.getElementById('$id').addEventListener('click', function() {
1054     this.play();
1055 }, false);
1056 </script>
1057 OET;
1058         }
1060         $fallback = core_media_player::PLACEHOLDER;
1061         return <<<OET
1062 <span class="mediaplugin mediaplugin_html5video">
1063 <video $idtag controls="true" $size preload="metadata" title="$title">
1064     $sources
1065     $fallback
1066 </video>
1067 $sillyscript
1068 </span>
1069 OET;
1070     }
1072     public function get_supported_extensions() {
1073         return array('m4v', 'webm', 'ogv', 'mp4');
1074     }
1076     public function list_supported_urls(array $urls, array $options = array()) {
1077         $extensions = $this->get_supported_extensions();
1078         $result = array();
1079         foreach ($urls as $url) {
1080             $ext = core_media::get_extension($url);
1081             if (in_array($ext, $extensions)) {
1082                 // Unfortunately html5 video does not handle fallback properly.
1083                 // https://www.w3.org/Bugs/Public/show_bug.cgi?id=10975
1084                 // That means we need to do browser detect and not use html5 on
1085                 // browsers which do not support the given type, otherwise users
1086                 // will not even see the fallback link.
1087                 // Based on http://en.wikipedia.org/wiki/HTML5_video#Table - this
1088                 // is a simplified version, does not take into account old browser
1089                 // versions or manual plugins.
1090                 if ($ext === 'ogv' || $ext === 'webm') {
1091                     // Formats .ogv and .webm are not supported in IE or Safari.
1092                     if (check_browser_version('MSIE') || check_browser_version('Safari')) {
1093                         continue;
1094                     }
1095                 } else {
1096                     // Formats .m4v and .mp4 are not supported in Firefox or Opera.
1097                     if (check_browser_version('Firefox') || check_browser_version('Opera')) {
1098                         continue;
1099                     }
1100                 }
1102                 $result[] = $url;
1103             }
1104         }
1105         return $result;
1106     }
1108     public function get_rank() {
1109         return 20;
1110     }
1114 /**
1115  * Player that creates HTML5 <audio> tag.
1116  *
1117  * @copyright 2011 The Open University
1118  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1119  */
1120 class core_media_player_html5audio extends core_media_player {
1121     public function embed($urls, $name, $width, $height, $options) {
1123         // Build array of source tags.
1124         $sources = array();
1125         foreach ($urls as $url) {
1126             $mimetype = core_media::get_mimetype($url);
1127             $sources[] = html_writer::tag('source', '', array('src' => $url, 'type' => $mimetype));
1128         }
1130         $sources = implode("\n", $sources);
1131         $title = s($this->get_name($name, $urls));
1133         // Default to not specify size (so it can be changed in css).
1134         $size = '';
1135         if ($width) {
1136             $size = 'width="' . $width . '"';
1137         }
1139         $fallback = core_media_player::PLACEHOLDER;
1141         return <<<OET
1142 <audio controls="true" $size class="mediaplugin mediaplugin_html5audio" preload="no" title="$title">
1143 $sources
1144 $fallback
1145 </audio>
1146 OET;
1147     }
1149     public function get_supported_extensions() {
1150         return array('ogg', 'oga', 'aac', 'm4a', 'mp3');
1151     }
1153     public function list_supported_urls(array $urls, array $options = array()) {
1154         $extensions = $this->get_supported_extensions();
1155         $result = array();
1156         foreach ($urls as $url) {
1157             $ext = core_media::get_extension($url);
1158             if (in_array($ext, $extensions)) {
1159                 if ($ext === 'ogg' || $ext === 'oga') {
1160                     // Formats .ogg and .oga are not supported in IE or Safari.
1161                     if (check_browser_version('MSIE') || check_browser_version('Safari')) {
1162                         continue;
1163                     }
1164                 } else {
1165                     // Formats .aac, .mp3, and .m4a are not supported in Firefox or Opera.
1166                     if (check_browser_version('Firefox') || check_browser_version('Opera')) {
1167                         continue;
1168                     }
1169                 }
1170                 // Old Android versions (pre 2.3.3) 'support' audio tag but no codecs.
1171                 if (check_browser_version('WebKit Android') &&
1172                         !check_browser_version('WebKit Android', '533.1')) {
1173                     continue;
1174                 }
1176                 $result[] = $url;
1177             }
1178         }
1179         return $result;
1180     }
1182     public function get_rank() {
1183         return 10;
1184     }
1188 /**
1189  * Special media player class that just puts a link.
1190  *
1191  * Always enabled, used as the last fallback.
1192  *
1193  * @copyright 2011 The Open University
1194  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1195  */
1196 class core_media_player_link extends core_media_player {
1197     public function embed($urls, $name, $width, $height, $options) {
1198         // If link is turned off, return empty.
1199         if (!empty($options[core_media::OPTION_NO_LINK])) {
1200             return '';
1201         }
1203         // Build up link content.
1204         $output = '';
1205         foreach ($urls as $url) {
1206             $title = core_media::get_filename($url);
1207             $printlink = html_writer::link($url, $title, array('class' => 'mediafallbacklink'));
1208             if ($output) {
1209                 // Where there are multiple available formats, there are fallback links
1210                 // for all formats, separated by /.
1211                 $output .= ' / ';
1212             }
1213             $output .= $printlink;
1214         }
1215         return $output;
1216     }
1218     public function list_supported_urls(array $urls, array $options = array()) {
1219         // Supports all URLs.
1220         return $urls;
1221     }
1223     public function is_enabled() {
1224         // Cannot be disabled.
1225         return true;
1226     }
1228     public function get_rank() {
1229         return 0;
1230     }