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/>.
  16
  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  */
  34
  35 defined('MOODLE_INTERNAL') || die();
  36
  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 }
  52
  53
  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';
  70
  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';
  82
  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';
  92
  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';
 100
 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();
 119
 120         foreach ($urls as $url) {
 121             $matches = null;
 122
 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             }
 130
 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];
 136
 137                 // Trim from URL.
 138                 $url = str_replace($matches[0], '', $url);
 139             }
 140
 141             // Clean up url.
 142             $url = clean_param($url, PARAM_URL);
 143             if (empty($url)) {
 144                 continue;
 145             }
 146
 147             // Turn it into moodle_url object.
 148             $returnurls[] = new moodle_url($url);
 149         }
 150
 151         return $returnurls;
 152     }
 153
 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 core_text (. 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     }
 168
 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;
 176
 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         }
 183
 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     }
 191
 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     }
 200 }
 201
 202
 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-->';
 229
 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);
 253
 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     }
 267
 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     }
 290
 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();
 314
 315     /**
 316      * @return bool True if player is enabled
 317      */
 318     public function is_enabled() {
 319         global $CFG;
 320
 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     }
 326
 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     }
 344
 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         }
 357
 358         // Get filename of first URL.
 359         $url = reset($urls);
 360         $name = core_media::get_filename($url);
 361
 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         }
 367
 368         return $name;
 369     }
 370
 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     }
 380
 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     }
 394 }
 395
 396
 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;
 413
 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';
 424
 425     public function embed($urls, $name, $width, $height, $options) {
 426         return $this->embed_external(reset($urls), $name, $width, $height, $options);
 427     }
 428
 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);
 439
 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);
 446
 447         // Check against regex.
 448         if (preg_match($this->get_regex(), $url->out(false), $this->matches)) {
 449             return array($url);
 450         }
 451
 452         return array();
 453     }
 454
 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     }
 462
 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     }
 475 }
 476
 477
 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);
 488
 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);
 493
 494         $output = <<<OET
 495 <span class="mediaplugin mediaplugin_vimeo">
 496 <iframe title="$info" src="https://player.vimeo.com/video/$videoid"
 497   width="$width" height="$height" frameborder="0"></iframe>
 498 </span>
 499 OET;
 500
 501         return $output;
 502     }
 503
 504     protected function get_regex() {
 505         // Initial part of link.
 506         $start = '~^https?://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     }
 511
 512     public function get_rank() {
 513         return 1010;
 514     }
 515
 516     public function get_embeddable_markers() {
 517         return array('vimeo.com/');
 518     }
 519 }
 520
 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         $videoid = end($this->matches);
 530
 531         $info = trim($name);
 532         if (empty($info) or strpos($info, 'http') === 0) {
 533             $info = get_string('siteyoutube', 'core_media');
 534         }
 535         $info = s($info);
 536
 537         self::pick_video_size($width, $height);
 538
 539         $params = '';
 540         $start = self::get_start_time($url);
 541         if ($start > 0) {
 542             $params .= "start=$start&";
 543         }
 544
 545         $listid = $url->param('list');
 546         // Check for non-empty but valid playlist ID.
 547         if (!empty($listid) && !preg_match('/[^a-zA-Z0-9\-_]/', $listid)) {
 548             // This video is part of a playlist, and we want to embed it as such.
 549             $params .= "list=$listid&";
 550         }
 551
 552         return <<<OET
 553 <span class="mediaplugin mediaplugin_youtube">
 554 <iframe title="$info" width="$width" height="$height"
 555   src="https://www.youtube.com/embed/$videoid?{$params}rel=0&wmode=transparent" frameborder="0" allowfullscreen="1"></iframe>
 556 </span>
 557 OET;
 558
 559     }
 560
 561     /**
 562      * Check for start time parameter.  Note that it's in hours/mins/secs in the URL,
 563      * but the embedded player takes only a number of seconds as the "start" parameter.
 564      * @param moodle_url $url URL of video to be embedded.
 565      * @return int Number of seconds video should start at.
 566      */
 567     protected static function get_start_time($url) {
 568         $matches = array();
 569         $seconds = 0;
 570
 571         $rawtime = $url->param('t');
 572         if (empty($rawtime)) {
 573             $rawtime = $url->param('start');
 574         }
 575
 576         if (is_numeric($rawtime)) {
 577             // Start time already specified as a number of seconds; ensure it's an integer.
 578             $seconds = $rawtime;
 579         } else if (preg_match('/(\d+?h)?(\d+?m)?(\d+?s)?/i', $rawtime, $matches)) {
 580             // Convert into a raw number of seconds, as that's all embedded players accept.
 581             for ($i = 1; $i < count($matches); $i++) {
 582                 if (empty($matches[$i])) {
 583                     continue;
 584                 }
 585                 $part = str_split($matches[$i], strlen($matches[$i]) - 1);
 586                 switch ($part[1]) {
 587                     case 'h':
 588                         $seconds += 3600 * $part[0];
 589                         break;
 590                     case 'm':
 591                         $seconds += 60 * $part[0];
 592                         break;
 593                     default:
 594                         $seconds += $part[0];
 595                 }
 596             }
 597         }
 598
 599         return intval($seconds);
 600     }
 601
 602     protected function get_regex() {
 603         // Regex for standard youtube link
 604          $link = '(youtube(-nocookie)?\.com/(?:watch\?v=|v/))';
 605         // Regex for shortened youtube link
 606         $shortlink = '((youtu|y2u)\.be/)';
 607
 608         // Initial part of link.
 609          $start = '~^https?://(www\.)?(' . $link . '|' . $shortlink . ')';
 610         // Middle bit: Video key value
 611         $middle = '([a-z0-9\-_]+)';
 612         return $start . $middle . core_media_player_external::END_LINK_REGEX_PART;
 613     }
 614
 615     public function get_rank() {
 616         // I decided to make the link-embedding ones (that don't handle file
 617         // formats) have ranking in the 1000 range.
 618         return 1001;
 619     }
 620
 621     public function get_embeddable_markers() {
 622         return array('youtube.com', 'youtube-nocookie.com', 'youtu.be', 'y2u.be');
 623     }
 624 }
 625
 626
 627 /**
 628  * Player that creates YouTube playlist embedding.
 629  *
 630  * @copyright 2011 The Open University
 631  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 632  */
 633 class core_media_player_youtube_playlist extends core_media_player_external {
 634     public function is_enabled() {
 635         global $CFG;
 636         // Use the youtube on/off flag.
 637         return $CFG->core_media_enable_youtube;
 638     }
 639
 640     protected function embed_external(moodle_url $url, $name, $width, $height, $options) {
 641         $site = $this->matches[1];
 642         $playlist = $this->matches[3];
 643
 644         $info = trim($name);
 645         if (empty($info) or strpos($info, 'http') === 0) {
 646             $info = get_string('siteyoutube', 'core_media');
 647         }
 648         $info = s($info);
 649
 650         self::pick_video_size($width, $height);
 651
 652         return <<<OET
 653 <span class="mediaplugin mediaplugin_youtube">
 654 <iframe width="$width" height="$height" src="https://$site/embed/videoseries?list=$playlist" frameborder="0" allowfullscreen="1"></iframe>
 655 </span>
 656 OET;
 657     }
 658
 659     protected function get_regex() {
 660         // Initial part of link.
 661         $start = '~^https?://(www\.youtube(-nocookie)?\.com)/';
 662         // Middle bit: either view_play_list?p= or p/ (doesn't work on youtube) or playlist?list=.
 663         $middle = '(?:view_play_list\?p=|p/|playlist\?list=)([a-z0-9\-_]+)';
 664         return $start . $middle . core_media_player_external::END_LINK_REGEX_PART;
 665     }
 666
 667     public function get_rank() {
 668         // I decided to make the link-embedding ones (that don't handle file
 669         // formats) have ranking in the 1000 range.
 670         return 1000;
 671     }
 672
 673     public function get_embeddable_markers() {
 674         return array('youtube');
 675     }
 676 }
 677
 678
 679 /**
 680  * MP3 player inserted using JavaScript.
 681  *
 682  * @copyright 2011 The Open University
 683  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 684  */
 685 class core_media_player_mp3 extends core_media_player {
 686     public function embed($urls, $name, $width, $height, $options) {
 687         // Use first url (there can actually be only one unless some idiot
 688         // enters two mp3 files as alternatives).
 689         $url = reset($urls);
 690
 691         // Unique id even across different http requests made at the same time
 692         // (for AJAX, iframes).
 693         $id = 'core_media_mp3_' . md5(time() . '_' . rand());
 694
 695         // When Flash or JavaScript are not available only the fallback is displayed,
 696         // using span not div because players are inline elements.
 697         $spanparams = array('id' => $id, 'class' => 'mediaplugin mediaplugin_mp3');
 698         if ($width) {
 699             $spanparams['style'] = 'width: ' . $width . 'px';
 700         }
 701         $output = html_writer::tag('span', core_media_player::PLACEHOLDER, $spanparams);
 702         // We can not use standard JS init because this may be cached
 703         // note: use 'small' size unless embedding in block mode.
 704         $output .= html_writer::script(js_writer::function_call(
 705                 'M.util.add_audio_player', array($id, $url->out(false),
 706                 empty($options[core_media::OPTION_BLOCK]))));
 707
 708         return $output;
 709     }
 710
 711     public function get_supported_extensions() {
 712         return array('mp3');
 713     }
 714
 715     public function get_rank() {
 716         return 80;
 717     }
 718 }
 719
 720
 721 /**
 722  * Flash video player inserted using JavaScript.
 723  *
 724  * @copyright 2011 The Open University
 725  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 726  */
 727 class core_media_player_flv extends core_media_player {
 728     public function embed($urls, $name, $width, $height, $options) {
 729         // Use first url (there can actually be only one unless some idiot
 730         // enters two mp3 files as alternatives).
 731         $url = reset($urls);
 732
 733         // Unique id even across different http requests made at the same time
 734         // (for AJAX, iframes).
 735         $id = 'core_media_flv_' . md5(time() . '_' . rand());
 736
 737         // Compute width and height.
 738         $autosize = false;
 739         if (!$width && !$height) {
 740             $width = CORE_MEDIA_VIDEO_WIDTH;
 741             $height = CORE_MEDIA_VIDEO_HEIGHT;
 742             $autosize = true;
 743         }
 744
 745         // Fallback span (will normally contain link).
 746         $output = html_writer::tag('span', core_media_player::PLACEHOLDER,
 747                 array('id'=>$id, 'class'=>'mediaplugin mediaplugin_flv'));
 748         // We can not use standard JS init because this may be cached.
 749         $output .= html_writer::script(js_writer::function_call(
 750                 'M.util.add_video_player', array($id, addslashes_js($url->out(false)),
 751                 $width, $height, $autosize)));
 752         return $output;
 753     }
 754
 755     public function get_supported_extensions() {
 756         return array('flv', 'f4v');
 757     }
 758
 759     public function get_rank() {
 760         return 70;
 761     }
 762 }
 763
 764
 765 /**
 766  * Embeds Windows Media Player using object tag.
 767  *
 768  * @copyright 2011 The Open University
 769  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 770  */
 771 class core_media_player_wmp extends core_media_player {
 772     public function embed($urls, $name, $width, $height, $options) {
 773         // Get URL (we just use first, probably there is only one).
 774         $firsturl = reset($urls);
 775         $url = $firsturl->out(false);
 776
 777         // Work out width.
 778         if (!$width || !$height) {
 779             // Object tag has default size.
 780             $mpsize = '';
 781             $size = 'width="' . CORE_MEDIA_VIDEO_WIDTH .
 782                     '" height="' . (CORE_MEDIA_VIDEO_HEIGHT+64) . '"';
 783             $autosize = 'true';
 784         } else {
 785             $size = 'width="' . $width . '" height="' . ($height + 15) . '"';
 786             $mpsize = 'width="' . $width . '" height="' . ($height + 64) . '"';
 787             $autosize = 'false';
 788         }
 789
 790         // MIME type for object tag.
 791         $mimetype = core_media::get_mimetype($firsturl);
 792
 793         $fallback = core_media_player::PLACEHOLDER;
 794
 795         // Embed code.
 796         return <<<OET
 797 <span class="mediaplugin mediaplugin_wmp">
 798     <object classid="CLSID:6BF52A52-394A-11d3-B153-00C04F79FAA6" $mpsize
 799             standby="Loading Microsoft(R) Windows(R) Media Player components..."
 800             type="application/x-oleobject">
 801         <param name="Filename" value="$url" />
 802         <param name="src" value="$url" />
 803         <param name="url" value="$url" />
 804         <param name="ShowControls" value="true" />
 805         <param name="AutoRewind" value="true" />
 806         <param name="AutoStart" value="false" />
 807         <param name="Autosize" value="$autosize" />
 808         <param name="EnableContextMenu" value="true" />
 809         <param name="TransparentAtStart" value="false" />
 810         <param name="AnimationAtStart" value="false" />
 811         <param name="ShowGotoBar" value="false" />
 812         <param name="EnableFullScreenControls" value="true" />
 813         <param name="uimode" value="full" />
 814         <!--[if !IE]>-->
 815         <object data="$url" type="$mimetype" $size>
 816             <param name="src" value="$url" />
 817             <param name="controller" value="true" />
 818             <param name="autoplay" value="false" />
 819             <param name="autostart" value="false" />
 820             <param name="resize" value="scale" />
 821         <!--<![endif]-->
 822             $fallback
 823         <!--[if !IE]>-->
 824         </object>
 825         <!--<![endif]-->
 826     </object>
 827 </span>
 828 OET;
 829     }
 830
 831     public function get_supported_extensions() {
 832         return array('wmv', 'avi');
 833     }
 834
 835     public function get_rank() {
 836         return 60;
 837     }
 838 }
 839
 840
 841 /**
 842  * Media player using object tag and QuickTime player.
 843  *
 844  * @copyright 2011 The Open University
 845  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 846  */
 847 class core_media_player_qt extends core_media_player {
 848     public function embed($urls, $name, $width, $height, $options) {
 849         // Show first URL.
 850         $firsturl = reset($urls);
 851         $url = $firsturl->out(true);
 852
 853         // Work out size.
 854         if (!$width || !$height) {
 855             $size = 'width="' . CORE_MEDIA_VIDEO_WIDTH .
 856                     '" height="' . (CORE_MEDIA_VIDEO_HEIGHT + 15) . '"';
 857         } else {
 858             $size = 'width="' . $width . '" height="' . ($height + 15) . '"';
 859         }
 860
 861         // MIME type for object tag.
 862         $mimetype = core_media::get_mimetype($firsturl);
 863
 864         $fallback = core_media_player::PLACEHOLDER;
 865
 866         // Embed code.
 867         return <<<OET
 868 <span class="mediaplugin mediaplugin_qt">
 869     <object classid="clsid:02BF25D5-8C17-4B23-BC80-D3488ABDDC6B"
 870             codebase="http://www.apple.com/qtactivex/qtplugin.cab" $size>
 871         <param name="pluginspage" value="http://www.apple.com/quicktime/download/" />
 872         <param name="src" value="$url" />
 873         <param name="controller" value="true" />
 874         <param name="loop" value="false" />
 875         <param name="autoplay" value="false" />
 876         <param name="autostart" value="false" />
 877         <param name="scale" value="aspect" />
 878         <!--[if !IE]>-->
 879         <object data="$url" type="$mimetype" $size>
 880             <param name="src" value="$url" />
 881             <param name="pluginurl" value="http://www.apple.com/quicktime/download/" />
 882             <param name="controller" value="true" />
 883             <param name="loop" value="false" />
 884             <param name="autoplay" value="false" />
 885             <param name="autostart" value="false" />
 886             <param name="scale" value="aspect" />
 887         <!--<![endif]-->
 888             $fallback
 889         <!--[if !IE]>-->
 890         </object>
 891         <!--<![endif]-->
 892     </object>
 893 </span>
 894 OET;
 895     }
 896
 897     public function get_supported_extensions() {
 898         return array('mpg', 'mpeg', 'mov', 'mp4', 'm4v', 'm4a');
 899     }
 900
 901     public function get_rank() {
 902         return 10;
 903     }
 904 }
 905
 906
 907 /**
 908  * Media player using object tag and RealPlayer.
 909  *
 910  * Hopefully nobody is using this obsolete format any more!
 911  *
 912  * @copyright 2011 The Open University
 913  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 914  */
 915 class core_media_player_rm extends core_media_player {
 916     public function embed($urls, $name, $width, $height, $options) {
 917         // Show first URL.
 918         $firsturl = reset($urls);
 919         $url = $firsturl->out(true);
 920
 921         // Get name to use as title.
 922         $info = s($this->get_name($name, $urls));
 923
 924         // The previous version of this code has the following comment, which
 925         // I don't understand, but trust it is correct:
 926         // Note: the size is hardcoded intentionally because this does not work anyway!
 927         $width = CORE_MEDIA_VIDEO_WIDTH;
 928         $height = CORE_MEDIA_VIDEO_HEIGHT;
 929
 930         $fallback = core_media_player::PLACEHOLDER;
 931         return <<<OET
 932 <span class="mediaplugin mediaplugin_real">
 933     <object title="$info" classid="clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA"
 934             data="$url" width="$width" height="$height"">
 935         <param name="src" value="$url" />
 936         <param name="controls" value="All" />
 937         <!--[if !IE]>-->
 938         <object title="$info" type="audio/x-pn-realaudio-plugin"
 939                 data="$url" width="$width" height="$height">
 940             <param name="src" value="$url" />
 941             <param name="controls" value="All" />
 942         <!--<![endif]-->
 943             $fallback
 944         <!--[if !IE]>-->
 945         </object>
 946         <!--<![endif]-->
 947   </object>
 948 </span>
 949 OET;
 950     }
 951
 952     public function get_supported_extensions() {
 953         return array('ra', 'ram', 'rm', 'rv');
 954     }
 955
 956     public function get_rank() {
 957         return 40;
 958     }
 959 }
 960
 961
 962 /**
 963  * Media player for Flash SWF files.
 964  *
 965  * This player contains additional security restriction: it will only be used
 966  * if you add option core_media_player_swf::ALLOW = true.
 967  *
 968  * Code should only set this option if it has verified that the data was
 969  * embedded by a trusted user (e.g. in trust text).
 970  *
 971  * @copyright 2011 The Open University
 972  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 973  */
 974 class core_media_player_swf extends core_media_player {
 975     public function embed($urls, $name, $width, $height, $options) {
 976         self::pick_video_size($width, $height);
 977
 978         $firsturl = reset($urls);
 979         $url = $firsturl->out(true);
 980
 981         $fallback = core_media_player::PLACEHOLDER;
 982         $output = <<<OET
 983 <span class="mediaplugin mediaplugin_swf">
 984   <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="$width" height="$height">
 985     <param name="movie" value="$url" />
 986     <param name="autoplay" value="true" />
 987     <param name="loop" value="false" />
 988     <param name="controller" value="true" />
 989     <param name="scale" value="aspect" />
 990     <param name="base" value="." />
 991     <param name="allowscriptaccess" value="never" />
 992 <!--[if !IE]>-->
 993     <object type="application/x-shockwave-flash" data="$url" width="$width" height="$height">
 994       <param name="controller" value="true" />
 995       <param name="autoplay" value="true" />
 996       <param name="loop" value="false" />
 997       <param name="scale" value="aspect" />
 998       <param name="base" value="." />
 999       <param name="allowscriptaccess" value="never" />
1000 <!--<![endif]-->
1001 $fallback
1002 <!--[if !IE]>-->
1003     </object>
1004 <!--<![endif]-->
1005   </object>
1006 </span>
1007 OET;
1008
1009         return $output;
1010     }
1011
1012     public function get_supported_extensions() {
1013         return array('swf');
1014     }
1015
1016     public function list_supported_urls(array $urls, array $options = array()) {
1017         // Not supported unless the creator is trusted.
1018         if (empty($options[core_media::OPTION_TRUSTED])) {
1019             return array();
1020         }
1021         return parent::list_supported_urls($urls, $options);
1022     }
1023
1024     public function get_rank() {
1025         return 30;
1026     }
1027 }
1028
1029
1030 /**
1031  * Player that creates HTML5 <video> tag.
1032  *
1033  * @copyright 2011 The Open University
1034  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1035  */
1036 class core_media_player_html5video extends core_media_player {
1037     public function embed($urls, $name, $width, $height, $options) {
1038         // Special handling to make videos play on Android devices pre 2.3.
1039         // Note: I tested and 2.3.3 (in emulator) works without, is 533.1 webkit.
1040         $oldandroid = core_useragent::is_webkit_android() &&
1041                 !core_useragent::check_webkit_android_version('533.1');
1042
1043         // Build array of source tags.
1044         $sources = array();
1045         foreach ($urls as $url) {
1046             $mimetype = core_media::get_mimetype($url);
1047             $source = html_writer::tag('source', '', array('src' => $url, 'type' => $mimetype));
1048             if ($mimetype === 'video/mp4') {
1049                 if ($oldandroid) {
1050                     // Old Android fails if you specify the type param.
1051                     $source = html_writer::tag('source', '', array('src' => $url));
1052                 }
1053
1054                 // Better add m4v as first source, it might be a bit more
1055                 // compatible with problematic browsers.
1056                 array_unshift($sources, $source);
1057             } else {
1058                 $sources[] = $source;
1059             }
1060         }
1061
1062         $sources = implode("\n", $sources);
1063         $title = s($this->get_name($name, $urls));
1064
1065         if (!$width) {
1066             // No width specified, use system default.
1067             $width = CORE_MEDIA_VIDEO_WIDTH;
1068         }
1069
1070         if (!$height) {
1071             // Let browser choose height automatically.
1072             $size = "width=\"$width\"";
1073         } else {
1074             $size = "width=\"$width\" height=\"$height\"";
1075         }
1076
1077         $sillyscript = '';
1078         $idtag = '';
1079         if ($oldandroid) {
1080             // Old Android does not support 'controls' option.
1081             $id = 'core_media_html5v_' . md5(time() . '_' . rand());
1082             $idtag = 'id="' . $id . '"';
1083             $sillyscript = <<<OET
1084 <script type="text/javascript">
1085 document.getElementById('$id').addEventListener('click', function() {
1086     this.play();
1087 }, false);
1088 </script>
1089 OET;
1090         }
1091
1092         $fallback = core_media_player::PLACEHOLDER;
1093         return <<<OET
1094 <span class="mediaplugin mediaplugin_html5video">
1095 <video $idtag controls="true" $size preload="metadata" title="$title">
1096     $sources
1097     $fallback
1098 </video>
1099 $sillyscript
1100 </span>
1101 OET;
1102     }
1103
1104     public function get_supported_extensions() {
1105         return array('m4v', 'webm', 'ogv', 'mp4');
1106     }
1107
1108     public function list_supported_urls(array $urls, array $options = array()) {
1109         $extensions = $this->get_supported_extensions();
1110         $result = array();
1111         foreach ($urls as $url) {
1112             $ext = core_media::get_extension($url);
1113             if (in_array($ext, $extensions)) {
1114                 // Unfortunately html5 video does not handle fallback properly.
1115                 // https://www.w3.org/Bugs/Public/show_bug.cgi?id=10975
1116                 // That means we need to do browser detect and not use html5 on
1117                 // browsers which do not support the given type, otherwise users
1118                 // will not even see the fallback link.
1119                 // Based on http://en.wikipedia.org/wiki/HTML5_video#Table - this
1120                 // is a simplified version, does not take into account old browser
1121                 // versions or manual plugins.
1122                 if ($ext === 'ogv' || $ext === 'webm') {
1123                     // Formats .ogv and .webm are not supported in IE or Safari.
1124                     if (core_useragent::is_ie() || core_useragent::is_safari()) {
1125                         continue;
1126                     }
1127                 } else {
1128                     // Formats .m4v and .mp4 are not supported in Opera, or in Firefox before 27.
1129                     // https://developer.mozilla.org/en-US/docs/Web/HTML/Supported_media_formats
1130                     // has the details.
1131                     if (core_useragent::is_opera() || (core_useragent::is_firefox() &&
1132                             !core_useragent::check_firefox_version(27))) {
1133                         continue;
1134                     }
1135                 }
1136
1137                 $result[] = $url;
1138             }
1139         }
1140         return $result;
1141     }
1142
1143     public function get_rank() {
1144         return 50;
1145     }
1146 }
1147
1148
1149 /**
1150  * Player that creates HTML5 <audio> tag.
1151  *
1152  * @copyright 2011 The Open University
1153  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1154  */
1155 class core_media_player_html5audio extends core_media_player {
1156     public function embed($urls, $name, $width, $height, $options) {
1157
1158         // Build array of source tags.
1159         $sources = array();
1160         foreach ($urls as $url) {
1161             $mimetype = core_media::get_mimetype($url);
1162             $sources[] = html_writer::tag('source', '', array('src' => $url, 'type' => $mimetype));
1163         }
1164
1165         $sources = implode("\n", $sources);
1166         $title = s($this->get_name($name, $urls));
1167
1168         // Default to not specify size (so it can be changed in css).
1169         $size = '';
1170         if ($width) {
1171             $size = 'width="' . $width . '"';
1172         }
1173
1174         $fallback = core_media_player::PLACEHOLDER;
1175
1176         return <<<OET
1177 <audio controls="true" $size class="mediaplugin mediaplugin_html5audio" preload="no" title="$title">
1178 $sources
1179 $fallback
1180 </audio>
1181 OET;
1182     }
1183
1184     public function get_supported_extensions() {
1185         return array('ogg', 'oga', 'aac', 'm4a', 'mp3');
1186     }
1187
1188     public function list_supported_urls(array $urls, array $options = array()) {
1189         $extensions = $this->get_supported_extensions();
1190         $result = array();
1191         foreach ($urls as $url) {
1192             $ext = core_media::get_extension($url);
1193             if (in_array($ext, $extensions)) {
1194                 if ($ext === 'ogg' || $ext === 'oga') {
1195                     // Formats .ogg and .oga are not supported in IE or Safari.
1196                     if (core_useragent::is_ie() || core_useragent::is_safari()) {
1197                         continue;
1198                     }
1199                 } else {
1200                     // Formats .aac, .mp3, and .m4a are not supported in Opera.
1201                     if (core_useragent::is_opera()) {
1202                         continue;
1203                     }
1204                     // Formats .mp3 and .m4a were not reliably supported in Firefox before 27.
1205                     // https://developer.mozilla.org/en-US/docs/Web/HTML/Supported_media_formats
1206                     // has the details. .aac is still not supported.
1207                     if (core_useragent::is_firefox() && ($ext === 'aac' ||
1208                             !core_useragent::check_firefox_version(27))) {
1209                         continue;
1210                     }
1211                 }
1212                 // Old Android versions (pre 2.3.3) 'support' audio tag but no codecs.
1213                 if (core_useragent::is_webkit_android() &&
1214                         !core_useragent::is_webkit_android('533.1')) {
1215                     continue;
1216                 }
1217
1218                 $result[] = $url;
1219             }
1220         }
1221         return $result;
1222     }
1223
1224     public function get_rank() {
1225         return 20;
1226     }
1227 }
1228
1229
1230 /**
1231  * Special media player class that just puts a link.
1232  *
1233  * Always enabled, used as the last fallback.
1234  *
1235  * @copyright 2011 The Open University
1236  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1237  */
1238 class core_media_player_link extends core_media_player {
1239     public function embed($urls, $name, $width, $height, $options) {
1240         // If link is turned off, return empty.
1241         if (!empty($options[core_media::OPTION_NO_LINK])) {
1242             return '';
1243         }
1244
1245         // Build up link content.
1246         $output = '';
1247         foreach ($urls as $url) {
1248             $title = core_media::get_filename($url);
1249             $printlink = html_writer::link($url, $title, array('class' => 'mediafallbacklink'));
1250             if ($output) {
1251                 // Where there are multiple available formats, there are fallback links
1252                 // for all formats, separated by /.
1253                 $output .= ' / ';
1254             }
1255             $output .= $printlink;
1256         }
1257         return $output;
1258     }
1259
1260     public function list_supported_urls(array $urls, array $options = array()) {
1261         // Supports all URLs.
1262         return $urls;
1263     }
1264
1265     public function is_enabled() {
1266         // Cannot be disabled.
1267         return true;
1268     }
1269
1270     public function get_rank() {
1271         return 0;
1272     }
1273 }