1 /** The minplayer namespace. */
  2 var minplayer = minplayer || {};
  3 
  4 /**
  5  * @constructor
  6  * @class A wrapper class used to provide all the data necessary to control an
  7  * individual file within this media player.
  8  *
  9  * @param {object} file A media file object with minimal required information.
 10  */
 11 minplayer.file = function(file) {
 12 
 13   // If there isn't a file provided, then just return null.
 14   if (!file) {
 15     return null;
 16   }
 17 
 18   file = (typeof file === 'string') ? {path: file} : file;
 19 
 20   // If we already are a minplayer file, then just return this file.
 21   if (file.hasOwnProperty('isMinPlayerFile')) {
 22     return file;
 23   }
 24 
 25   this.isMinPlayerFile = true;
 26   this.duration = file.duration || 0;
 27   this.bytesTotal = file.bytesTotal || 0;
 28   this.quality = file.quality || 0;
 29   this.stream = file.stream || '';
 30   this.path = file.path || '';
 31   this.codecs = file.codecs || '';
 32 
 33   // These should be provided, but just in case...
 34   this.extension = file.extension || this.getFileExtension();
 35   this.mimetype = file.mimetype || file.filemime || this.getMimeType();
 36   this.type = file.type || this.getType();
 37 
 38   // Fail safe to try and guess the mimetype and media type.
 39   if (!this.type) {
 40     this.mimetype = this.getMimeType();
 41     this.type = this.getType();
 42   }
 43 
 44   // Get the player.
 45   this.player = minplayer.player || file.player || this.getBestPlayer();
 46   this.priority = file.priority || this.getPriority();
 47   this.id = file.id || this.getId();
 48   if (!this.path) {
 49     this.path = this.id;
 50   }
 51 };
 52 
 53 /** Used to force the player for all media. */
 54 minplayer.player = '';
 55 
 56 /**
 57  * Returns the best player for the job.
 58  *
 59  * @return {string} The best player to play the media file.
 60  */
 61 minplayer.file.prototype.getBestPlayer = function() {
 62   var bestplayer = null, bestpriority = 0;
 63   jQuery.each(minplayer.players, (function(file) {
 64     return function(name, player) {
 65       var priority = player.getPriority(file);
 66       if (player.canPlay(file) && (priority > bestpriority)) {
 67         bestplayer = name;
 68         bestpriority = priority;
 69       }
 70     };
 71   })(this));
 72   return bestplayer;
 73 };
 74 
 75 /**
 76  * The priority of this file is determined by the priority of the best
 77  * player multiplied by the priority of the mimetype.
 78  *
 79  * @return {integer} The priority of the media file.
 80  */
 81 minplayer.file.prototype.getPriority = function() {
 82   var priority = 1;
 83   if (this.player) {
 84     priority = minplayer.players[this.player].getPriority(this);
 85   }
 86   switch (this.mimetype) {
 87     case 'video/x-webm':
 88     case 'video/webm':
 89     case 'application/octet-stream':
 90       return priority * 10;
 91     case 'video/mp4':
 92     case 'audio/mp4':
 93     case 'audio/mpeg':
 94       return priority * 9;
 95     case 'video/ogg':
 96     case 'audio/ogg':
 97     case 'video/quicktime':
 98       return priority * 8;
 99     default:
100       return priority * 5;
101   }
102 };
103 
104 /**
105  * Returns the file extension of the file path.
106  *
107  * @return {string} The file extension.
108  */
109 minplayer.file.prototype.getFileExtension = function() {
110   return this.path.substring(this.path.lastIndexOf('.') + 1).toLowerCase();
111 };
112 
113 /**
114  * Returns the proper mimetype based off of the extension.
115  *
116  * @return {string} The mimetype of the file based off of extension.
117  */
118 minplayer.file.prototype.getMimeType = function() {
119   switch (this.extension) {
120     case 'mp4': case 'm4v': case 'flv': case 'f4v':
121       return 'video/mp4';
122     case'webm':
123       return 'video/webm';
124     case 'ogg': case 'ogv':
125       return 'video/ogg';
126     case '3g2':
127       return 'video/3gpp2';
128     case '3gpp':
129     case '3gp':
130       return 'video/3gpp';
131     case 'mov':
132       return 'video/quicktime';
133     case'swf':
134       return 'application/x-shockwave-flash';
135     case 'oga':
136       return 'audio/ogg';
137     case 'mp3':
138       return 'audio/mpeg';
139     case 'm4a': case 'f4a':
140       return 'audio/mp4';
141     case 'aac':
142       return 'audio/aac';
143     case 'wav':
144       return 'audio/vnd.wave';
145     case 'wma':
146       return 'audio/x-ms-wma';
147     default:
148       return 'unknown';
149   }
150 };
151 
152 /**
153  * The type of media this is: video or audio.
154  *
155  * @return {string} "video" or "audio" based on what the type of media this
156  * is.
157  */
158 minplayer.file.prototype.getType = function() {
159   var type = this.mimetype.match(/([^\/]+)(\/)/);
160   type = (type && (type.length > 1)) ? type[1] : '';
161   if (type == 'video' || this.mimetype == 'application/octet-stream') {
162     return 'video';
163   }
164   if (type == 'audio') {
165     return 'audio';
166   }
167   return '';
168 };
169 
170 /**
171  * Returns the ID for this media file.
172  *
173  * @return {string} The id for this media file which is provided by the player.
174  */
175 minplayer.file.prototype.getId = function() {
176   var player = minplayer.players[this.player];
177   return (player && player.getMediaId) ? player.getMediaId(this) : '';
178 };
179