Upgrade to ExtJS 3.2.2 - Released 06/02/2010
[extjs.git] / examples / image-organizer / SWFUpload / plugins / swfupload.speed.js
index 3699b12..a66a824 100644 (file)
 /*!
- * Ext JS Library 3.1.1
- * Copyright(c) 2006-2010 Ext JS, LLC
+ * Ext JS Library 3.2.2
+ * Copyright(c) 2006-2010 Ext JS, Inc.
  * licensing@extjs.com
  * http://www.extjs.com/license
  */
-/*\r
-       Speed Plug-in\r
-       \r
-       Features:\r
-               *Adds several properties to the 'file' object indicated upload speed, time left, upload time, etc.\r
-                       - currentSpeed -- String indicating the upload speed, bytes per second\r
-                       - averageSpeed -- Overall average upload speed, bytes per second\r
-                       - movingAverageSpeed -- Speed over averaged over the last several measurements, bytes per second\r
-                       - timeRemaining -- Estimated remaining upload time in seconds\r
-                       - timeElapsed -- Number of seconds passed for this upload\r
-                       - percentUploaded -- Percentage of the file uploaded (0 to 100)\r
-                       - sizeUploaded -- Formatted size uploaded so far, bytes\r
-               \r
-               *Adds setting 'moving_average_history_size' for defining the window size used to calculate the moving average speed.\r
-               \r
-               *Adds several Formatting functions for formatting that values provided on the file object.\r
-                       - SWFUpload.speed.formatBPS(bps) -- outputs string formatted in the best units (Gbps, Mbps, Kbps, bps)\r
-                       - SWFUpload.speed.formatTime(seconds) -- outputs string formatted in the best units (x Hr y M z S)\r
-                       - SWFUpload.speed.formatSize(bytes) -- outputs string formatted in the best units (w GB x MB y KB z B )\r
-                       - SWFUpload.speed.formatPercent(percent) -- outputs string formatted with a percent sign (x.xx %)\r
-                       - SWFUpload.speed.formatUnits(baseNumber, divisionArray, unitLabelArray, fractionalBoolean)\r
-                               - Formats a number using the division array to determine how to apply the labels in the Label Array\r
-                               - factionalBoolean indicates whether the number should be returned as a single fractional number with a unit (speed)\r
-                                   or as several numbers labeled with units (time)\r
-       */\r
-\r
-var SWFUpload;\r
-if (typeof(SWFUpload) === "function") {\r
-       SWFUpload.speed = {};\r
-       \r
-       SWFUpload.prototype.initSettings = (function (oldInitSettings) {\r
-               return function () {\r
-                       if (typeof(oldInitSettings) === "function") {\r
-                               oldInitSettings.call(this);\r
-                       }\r
-                       \r
-                       this.ensureDefault = function (settingName, defaultValue) {\r
-                               this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];\r
-                       };\r
-\r
-                       // List used to keep the speed stats for the files we are tracking\r
-                       this.fileSpeedStats = {};\r
-                       this.speedSettings = {};\r
-\r
-                       this.ensureDefault("moving_average_history_size", "10");\r
-                       \r
-                       this.speedSettings.user_file_queued_handler = this.settings.file_queued_handler;\r
-                       this.speedSettings.user_file_queue_error_handler = this.settings.file_queue_error_handler;\r
-                       this.speedSettings.user_upload_start_handler = this.settings.upload_start_handler;\r
-                       this.speedSettings.user_upload_error_handler = this.settings.upload_error_handler;\r
-                       this.speedSettings.user_upload_progress_handler = this.settings.upload_progress_handler;\r
-                       this.speedSettings.user_upload_success_handler = this.settings.upload_success_handler;\r
-                       this.speedSettings.user_upload_complete_handler = this.settings.upload_complete_handler;\r
-                       \r
-                       this.settings.file_queued_handler = SWFUpload.speed.fileQueuedHandler;\r
-                       this.settings.file_queue_error_handler = SWFUpload.speed.fileQueueErrorHandler;\r
-                       this.settings.upload_start_handler = SWFUpload.speed.uploadStartHandler;\r
-                       this.settings.upload_error_handler = SWFUpload.speed.uploadErrorHandler;\r
-                       this.settings.upload_progress_handler = SWFUpload.speed.uploadProgressHandler;\r
-                       this.settings.upload_success_handler = SWFUpload.speed.uploadSuccessHandler;\r
-                       this.settings.upload_complete_handler = SWFUpload.speed.uploadCompleteHandler;\r
-                       \r
-                       delete this.ensureDefault;\r
-               };\r
-       })(SWFUpload.prototype.initSettings);\r
-\r
-       \r
-       SWFUpload.speed.fileQueuedHandler = function (file) {\r
-               if (typeof this.speedSettings.user_file_queued_handler === "function") {\r
-                       file = SWFUpload.speed.extendFile(file);\r
-                       \r
-                       return this.speedSettings.user_file_queued_handler.call(this, file);\r
-               }\r
-       };\r
-       \r
-       SWFUpload.speed.fileQueueErrorHandler = function (file, errorCode, message) {\r
-               if (typeof this.speedSettings.user_file_queue_error_handler === "function") {\r
-                       file = SWFUpload.speed.extendFile(file);\r
-                       \r
-                       return this.speedSettings.user_file_queue_error_handler.call(this, file, errorCode, message);\r
-               }\r
-       };\r
-\r
-       SWFUpload.speed.uploadStartHandler = function (file) {\r
-               if (typeof this.speedSettings.user_upload_start_handler === "function") {\r
-                       file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);\r
-                       return this.speedSettings.user_upload_start_handler.call(this, file);\r
-               }\r
-       };\r
-       \r
-       SWFUpload.speed.uploadErrorHandler = function (file, errorCode, message) {\r
-               file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);\r
-               SWFUpload.speed.removeTracking(file, this.fileSpeedStats);\r
-\r
-               if (typeof this.speedSettings.user_upload_error_handler === "function") {\r
-                       return this.speedSettings.user_upload_error_handler.call(this, file, errorCode, message);\r
-               }\r
-       };\r
-       SWFUpload.speed.uploadProgressHandler = function (file, bytesComplete, bytesTotal) {\r
-               this.updateTracking(file, bytesComplete);\r
-               file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);\r
-\r
-               if (typeof this.speedSettings.user_upload_progress_handler === "function") {\r
-                       return this.speedSettings.user_upload_progress_handler.call(this, file, bytesComplete, bytesTotal);\r
-               }\r
-       };\r
-       \r
-       SWFUpload.speed.uploadSuccessHandler = function (file, serverData) {\r
-               if (typeof this.speedSettings.user_upload_success_handler === "function") {\r
-                       file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);\r
-                       return this.speedSettings.user_upload_success_handler.call(this, file, serverData);\r
-               }\r
-       };\r
-       SWFUpload.speed.uploadCompleteHandler = function (file) {\r
-               file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);\r
-               SWFUpload.speed.removeTracking(file, this.fileSpeedStats);\r
-\r
-               if (typeof this.speedSettings.user_upload_complete_handler === "function") {\r
-                       return this.speedSettings.user_upload_complete_handler.call(this, file);\r
-               }\r
-       };\r
-       \r
-       // Private: extends the file object with the speed plugin values\r
-       SWFUpload.speed.extendFile = function (file, trackingList) {\r
-               var tracking;\r
-               \r
-               if (trackingList) {\r
-                       tracking = trackingList[file.id];\r
-               }\r
-               \r
-               if (tracking) {\r
-                       file.currentSpeed = tracking.currentSpeed;\r
-                       file.averageSpeed = tracking.averageSpeed;\r
-                       file.movingAverageSpeed = tracking.movingAverageSpeed;\r
-                       file.timeRemaining = tracking.timeRemaining;\r
-                       file.timeElapsed = tracking.timeElapsed;\r
-                       file.percentUploaded = tracking.percentUploaded;\r
-                       file.sizeUploaded = tracking.bytesUploaded;\r
-\r
-               } else {\r
-                       file.currentSpeed = 0;\r
-                       file.averageSpeed = 0;\r
-                       file.movingAverageSpeed = 0;\r
-                       file.timeRemaining = 0;\r
-                       file.timeElapsed = 0;\r
-                       file.percentUploaded = 0;\r
-                       file.sizeUploaded = 0;\r
-               }\r
-               \r
-               return file;\r
-       };\r
-       \r
-       // Private: Updates the speed tracking object, or creates it if necessary\r
-       SWFUpload.prototype.updateTracking = function (file, bytesUploaded) {\r
-               var tracking = this.fileSpeedStats[file.id];\r
-               if (!tracking) {\r
-                       this.fileSpeedStats[file.id] = tracking = {};\r
-               }\r
-               \r
-               // Sanity check inputs\r
-               bytesUploaded = bytesUploaded || tracking.bytesUploaded || 0;\r
-               if (bytesUploaded < 0) {\r
-                       bytesUploaded = 0;\r
-               }\r
-               if (bytesUploaded > file.size) {\r
-                       bytesUploaded = file.size;\r
-               }\r
-               \r
-               var tickTime = (new Date()).getTime();\r
-               if (!tracking.startTime) {\r
-                       tracking.startTime = (new Date()).getTime();\r
-                       tracking.lastTime = tracking.startTime;\r
-                       tracking.currentSpeed = 0;\r
-                       tracking.averageSpeed = 0;\r
-                       tracking.movingAverageSpeed = 0;\r
-                       tracking.movingAverageHistory = [];\r
-                       tracking.timeRemaining = 0;\r
-                       tracking.timeElapsed = 0;\r
-                       tracking.percentUploaded = bytesUploaded / file.size;\r
-                       tracking.bytesUploaded = bytesUploaded;\r
-               } else if (tracking.startTime > tickTime) {\r
-                       this.debug("When backwards in time");\r
-               } else {\r
-                       // Get time and deltas\r
-                       var now = (new Date()).getTime();\r
-                       var lastTime = tracking.lastTime;\r
-                       var deltaTime = now - lastTime;\r
-                       var deltaBytes = bytesUploaded - tracking.bytesUploaded;\r
-                       \r
-                       if (deltaBytes === 0 || deltaTime === 0) {\r
-                               return tracking;\r
-                       }\r
-                       \r
-                       // Update tracking object\r
-                       tracking.lastTime = now;\r
-                       tracking.bytesUploaded = bytesUploaded;\r
-                       \r
-                       // Calculate speeds\r
-                       tracking.currentSpeed = (deltaBytes * 8 ) / (deltaTime / 1000);\r
-                       tracking.averageSpeed = (tracking.bytesUploaded * 8) / ((now - tracking.startTime) / 1000);\r
-\r
-                       // Calculate moving average\r
-                       tracking.movingAverageHistory.push(tracking.currentSpeed);\r
-                       if (tracking.movingAverageHistory.length > this.settings.moving_average_history_size) {\r
-                               tracking.movingAverageHistory.shift();\r
-                       }\r
-                       \r
-                       tracking.movingAverageSpeed = SWFUpload.speed.calculateMovingAverage(tracking.movingAverageHistory);\r
-                       \r
-                       // Update times\r
-                       tracking.timeRemaining = (file.size - tracking.bytesUploaded) * 8 / tracking.movingAverageSpeed;\r
-                       tracking.timeElapsed = (now - tracking.startTime) / 1000;\r
-                       \r
-                       // Update percent\r
-                       tracking.percentUploaded = (tracking.bytesUploaded / file.size * 100);\r
-               }\r
-               \r
-               return tracking;\r
-       };\r
-       SWFUpload.speed.removeTracking = function (file, trackingList) {\r
-               try {\r
-                       trackingList[file.id] = null;\r
-                       delete trackingList[file.id];\r
-               } catch (ex) {\r
-               }\r
-       };\r
-       \r
-       SWFUpload.speed.formatUnits = function (baseNumber, unitDivisors, unitLabels, singleFractional) {\r
-               var i, unit, unitDivisor, unitLabel;\r
-\r
-               if (baseNumber === 0) {\r
-                       return "0 " + unitLabels[unitLabels.length - 1];\r
-               }\r
-               \r
-               if (singleFractional) {\r
-                       unit = baseNumber;\r
-                       unitLabel = unitLabels.length >= unitDivisors.length ? unitLabels[unitDivisors.length - 1] : "";\r
-                       for (i = 0; i < unitDivisors.length; i++) {\r
-                               if (baseNumber >= unitDivisors[i]) {\r
-                                       unit = (baseNumber / unitDivisors[i]).toFixed(2);\r
-                                       unitLabel = unitLabels.length >= i ? " " + unitLabels[i] : "";\r
-                                       break;\r
-                               }\r
-                       }\r
-                       \r
-                       return unit + unitLabel;\r
-               } else {\r
-                       var formattedStrings = [];\r
-                       var remainder = baseNumber;\r
-                       \r
-                       for (i = 0; i < unitDivisors.length; i++) {\r
-                               unitDivisor = unitDivisors[i];\r
-                               unitLabel = unitLabels.length > i ? " " + unitLabels[i] : "";\r
-                               \r
-                               unit = remainder / unitDivisor;\r
-                               if (i < unitDivisors.length -1) {\r
-                                       unit = Math.floor(unit);\r
-                               } else {\r
-                                       unit = unit.toFixed(2);\r
-                               }\r
-                               if (unit > 0) {\r
-                                       remainder = remainder % unitDivisor;\r
-                                       \r
-                                       formattedStrings.push(unit + unitLabel);\r
-                               }\r
-                       }\r
-                       \r
-                       return formattedStrings.join(" ");\r
-               }\r
-       };\r
-       \r
-       SWFUpload.speed.formatBPS = function (baseNumber) {\r
-               var bpsUnits = [1073741824, 1048576, 1024, 1], bpsUnitLabels = ["Gbps", "Mbps", "Kbps", "bps"];\r
-               return SWFUpload.speed.formatUnits(baseNumber, bpsUnits, bpsUnitLabels, true);\r
-       \r
-       };\r
-       SWFUpload.speed.formatTime = function (baseNumber) {\r
-               var timeUnits = [86400, 3600, 60, 1], timeUnitLabels = ["d", "h", "m", "s"];\r
-               return SWFUpload.speed.formatUnits(baseNumber, timeUnits, timeUnitLabels, false);\r
-       \r
-       };\r
-       SWFUpload.speed.formatBytes = function (baseNumber) {\r
-               var sizeUnits = [1073741824, 1048576, 1024, 1], sizeUnitLabels = ["GB", "MB", "KB", "bytes"];\r
-               return SWFUpload.speed.formatUnits(baseNumber, sizeUnits, sizeUnitLabels, true);\r
-       \r
-       };\r
-       SWFUpload.speed.formatPercent = function (baseNumber) {\r
-               return baseNumber.toFixed(2) + " %";\r
-       };\r
-       \r
-       SWFUpload.speed.calculateMovingAverage = function (history) {\r
-               var vals = [], size, sum = 0.0, mean = 0.0, varianceTemp = 0.0, variance = 0.0, standardDev = 0.0;\r
-               var i;\r
-               var mSum = 0, mCount = 0;\r
-               \r
-               size = history.length;\r
-               \r
-               // Check for sufficient data\r
-               if (size >= 8) {\r
-                       // Clone the array and Calculate sum of the values \r
-                       for (i = 0; i < size; i++) {\r
-                               vals[i] = history[i];\r
-                               sum += vals[i];\r
-                       }\r
-\r
-                       mean = sum / size;\r
-\r
-                       // Calculate variance for the set\r
-                       for (i = 0; i < size; i++) {\r
-                               varianceTemp += Math.pow((vals[i] - mean), 2);\r
-                       }\r
-\r
-                       variance = varianceTemp / size;\r
-                       standardDev = Math.sqrt(variance);\r
-                       \r
-                       //Standardize the Data\r
-                       for (i = 0; i < size; i++) {\r
-                               vals[i] = (vals[i] - mean) / standardDev;\r
-                       }\r
-\r
-                       // Calculate the average excluding outliers\r
-                       var deviationRange = 2.0;\r
-                       for (i = 0; i < size; i++) {\r
-                               \r
-                               if (vals[i] <= deviationRange && vals[i] >= -deviationRange) {\r
-                                       mCount++;\r
-                                       mSum += history[i];\r
-                               }\r
-                       }\r
-                       \r
-               } else {\r
-                       // Calculate the average (not enough data points to remove outliers)\r
-                       mCount = size;\r
-                       for (i = 0; i < size; i++) {\r
-                               mSum += history[i];\r
-                       }\r
-               }\r
-\r
-               return mSum / mCount;\r
-       };\r
-       \r
+/*
+       Speed Plug-in
+       
+       Features:
+               *Adds several properties to the 'file' object indicated upload speed, time left, upload time, etc.
+                       - currentSpeed -- String indicating the upload speed, bytes per second
+                       - averageSpeed -- Overall average upload speed, bytes per second
+                       - movingAverageSpeed -- Speed over averaged over the last several measurements, bytes per second
+                       - timeRemaining -- Estimated remaining upload time in seconds
+                       - timeElapsed -- Number of seconds passed for this upload
+                       - percentUploaded -- Percentage of the file uploaded (0 to 100)
+                       - sizeUploaded -- Formatted size uploaded so far, bytes
+               
+               *Adds setting 'moving_average_history_size' for defining the window size used to calculate the moving average speed.
+               
+               *Adds several Formatting functions for formatting that values provided on the file object.
+                       - SWFUpload.speed.formatBPS(bps) -- outputs string formatted in the best units (Gbps, Mbps, Kbps, bps)
+                       - SWFUpload.speed.formatTime(seconds) -- outputs string formatted in the best units (x Hr y M z S)
+                       - SWFUpload.speed.formatSize(bytes) -- outputs string formatted in the best units (w GB x MB y KB z B )
+                       - SWFUpload.speed.formatPercent(percent) -- outputs string formatted with a percent sign (x.xx %)
+                       - SWFUpload.speed.formatUnits(baseNumber, divisionArray, unitLabelArray, fractionalBoolean)
+                               - Formats a number using the division array to determine how to apply the labels in the Label Array
+                               - factionalBoolean indicates whether the number should be returned as a single fractional number with a unit (speed)
+                                   or as several numbers labeled with units (time)
+       */
+
+var SWFUpload;
+if (typeof(SWFUpload) === "function") {
+       SWFUpload.speed = {};
+       
+       SWFUpload.prototype.initSettings = (function (oldInitSettings) {
+               return function () {
+                       if (typeof(oldInitSettings) === "function") {
+                               oldInitSettings.call(this);
+                       }
+                       
+                       this.ensureDefault = function (settingName, defaultValue) {
+                               this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];
+                       };
+
+                       // List used to keep the speed stats for the files we are tracking
+                       this.fileSpeedStats = {};
+                       this.speedSettings = {};
+
+                       this.ensureDefault("moving_average_history_size", "10");
+                       
+                       this.speedSettings.user_file_queued_handler = this.settings.file_queued_handler;
+                       this.speedSettings.user_file_queue_error_handler = this.settings.file_queue_error_handler;
+                       this.speedSettings.user_upload_start_handler = this.settings.upload_start_handler;
+                       this.speedSettings.user_upload_error_handler = this.settings.upload_error_handler;
+                       this.speedSettings.user_upload_progress_handler = this.settings.upload_progress_handler;
+                       this.speedSettings.user_upload_success_handler = this.settings.upload_success_handler;
+                       this.speedSettings.user_upload_complete_handler = this.settings.upload_complete_handler;
+                       
+                       this.settings.file_queued_handler = SWFUpload.speed.fileQueuedHandler;
+                       this.settings.file_queue_error_handler = SWFUpload.speed.fileQueueErrorHandler;
+                       this.settings.upload_start_handler = SWFUpload.speed.uploadStartHandler;
+                       this.settings.upload_error_handler = SWFUpload.speed.uploadErrorHandler;
+                       this.settings.upload_progress_handler = SWFUpload.speed.uploadProgressHandler;
+                       this.settings.upload_success_handler = SWFUpload.speed.uploadSuccessHandler;
+                       this.settings.upload_complete_handler = SWFUpload.speed.uploadCompleteHandler;
+                       
+                       delete this.ensureDefault;
+               };
+       })(SWFUpload.prototype.initSettings);
+
+       
+       SWFUpload.speed.fileQueuedHandler = function (file) {
+               if (typeof this.speedSettings.user_file_queued_handler === "function") {
+                       file = SWFUpload.speed.extendFile(file);
+                       
+                       return this.speedSettings.user_file_queued_handler.call(this, file);
+               }
+       };
+       
+       SWFUpload.speed.fileQueueErrorHandler = function (file, errorCode, message) {
+               if (typeof this.speedSettings.user_file_queue_error_handler === "function") {
+                       file = SWFUpload.speed.extendFile(file);
+                       
+                       return this.speedSettings.user_file_queue_error_handler.call(this, file, errorCode, message);
+               }
+       };
+
+       SWFUpload.speed.uploadStartHandler = function (file) {
+               if (typeof this.speedSettings.user_upload_start_handler === "function") {
+                       file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
+                       return this.speedSettings.user_upload_start_handler.call(this, file);
+               }
+       };
+       
+       SWFUpload.speed.uploadErrorHandler = function (file, errorCode, message) {
+               file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
+               SWFUpload.speed.removeTracking(file, this.fileSpeedStats);
+
+               if (typeof this.speedSettings.user_upload_error_handler === "function") {
+                       return this.speedSettings.user_upload_error_handler.call(this, file, errorCode, message);
+               }
+       };
+       SWFUpload.speed.uploadProgressHandler = function (file, bytesComplete, bytesTotal) {
+               this.updateTracking(file, bytesComplete);
+               file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
+
+               if (typeof this.speedSettings.user_upload_progress_handler === "function") {
+                       return this.speedSettings.user_upload_progress_handler.call(this, file, bytesComplete, bytesTotal);
+               }
+       };
+       
+       SWFUpload.speed.uploadSuccessHandler = function (file, serverData) {
+               if (typeof this.speedSettings.user_upload_success_handler === "function") {
+                       file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
+                       return this.speedSettings.user_upload_success_handler.call(this, file, serverData);
+               }
+       };
+       SWFUpload.speed.uploadCompleteHandler = function (file) {
+               file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
+               SWFUpload.speed.removeTracking(file, this.fileSpeedStats);
+
+               if (typeof this.speedSettings.user_upload_complete_handler === "function") {
+                       return this.speedSettings.user_upload_complete_handler.call(this, file);
+               }
+       };
+       
+       // Private: extends the file object with the speed plugin values
+       SWFUpload.speed.extendFile = function (file, trackingList) {
+               var tracking;
+               
+               if (trackingList) {
+                       tracking = trackingList[file.id];
+               }
+               
+               if (tracking) {
+                       file.currentSpeed = tracking.currentSpeed;
+                       file.averageSpeed = tracking.averageSpeed;
+                       file.movingAverageSpeed = tracking.movingAverageSpeed;
+                       file.timeRemaining = tracking.timeRemaining;
+                       file.timeElapsed = tracking.timeElapsed;
+                       file.percentUploaded = tracking.percentUploaded;
+                       file.sizeUploaded = tracking.bytesUploaded;
+
+               } else {
+                       file.currentSpeed = 0;
+                       file.averageSpeed = 0;
+                       file.movingAverageSpeed = 0;
+                       file.timeRemaining = 0;
+                       file.timeElapsed = 0;
+                       file.percentUploaded = 0;
+                       file.sizeUploaded = 0;
+               }
+               
+               return file;
+       };
+       
+       // Private: Updates the speed tracking object, or creates it if necessary
+       SWFUpload.prototype.updateTracking = function (file, bytesUploaded) {
+               var tracking = this.fileSpeedStats[file.id];
+               if (!tracking) {
+                       this.fileSpeedStats[file.id] = tracking = {};
+               }
+               
+               // Sanity check inputs
+               bytesUploaded = bytesUploaded || tracking.bytesUploaded || 0;
+               if (bytesUploaded < 0) {
+                       bytesUploaded = 0;
+               }
+               if (bytesUploaded > file.size) {
+                       bytesUploaded = file.size;
+               }
+               
+               var tickTime = (new Date()).getTime();
+               if (!tracking.startTime) {
+                       tracking.startTime = (new Date()).getTime();
+                       tracking.lastTime = tracking.startTime;
+                       tracking.currentSpeed = 0;
+                       tracking.averageSpeed = 0;
+                       tracking.movingAverageSpeed = 0;
+                       tracking.movingAverageHistory = [];
+                       tracking.timeRemaining = 0;
+                       tracking.timeElapsed = 0;
+                       tracking.percentUploaded = bytesUploaded / file.size;
+                       tracking.bytesUploaded = bytesUploaded;
+               } else if (tracking.startTime > tickTime) {
+                       this.debug("When backwards in time");
+               } else {
+                       // Get time and deltas
+                       var now = (new Date()).getTime();
+                       var lastTime = tracking.lastTime;
+                       var deltaTime = now - lastTime;
+                       var deltaBytes = bytesUploaded - tracking.bytesUploaded;
+                       
+                       if (deltaBytes === 0 || deltaTime === 0) {
+                               return tracking;
+                       }
+                       
+                       // Update tracking object
+                       tracking.lastTime = now;
+                       tracking.bytesUploaded = bytesUploaded;
+                       
+                       // Calculate speeds
+                       tracking.currentSpeed = (deltaBytes * 8 ) / (deltaTime / 1000);
+                       tracking.averageSpeed = (tracking.bytesUploaded * 8) / ((now - tracking.startTime) / 1000);
+
+                       // Calculate moving average
+                       tracking.movingAverageHistory.push(tracking.currentSpeed);
+                       if (tracking.movingAverageHistory.length > this.settings.moving_average_history_size) {
+                               tracking.movingAverageHistory.shift();
+                       }
+                       
+                       tracking.movingAverageSpeed = SWFUpload.speed.calculateMovingAverage(tracking.movingAverageHistory);
+                       
+                       // Update times
+                       tracking.timeRemaining = (file.size - tracking.bytesUploaded) * 8 / tracking.movingAverageSpeed;
+                       tracking.timeElapsed = (now - tracking.startTime) / 1000;
+                       
+                       // Update percent
+                       tracking.percentUploaded = (tracking.bytesUploaded / file.size * 100);
+               }
+               
+               return tracking;
+       };
+       SWFUpload.speed.removeTracking = function (file, trackingList) {
+               try {
+                       trackingList[file.id] = null;
+                       delete trackingList[file.id];
+               } catch (ex) {
+               }
+       };
+       
+       SWFUpload.speed.formatUnits = function (baseNumber, unitDivisors, unitLabels, singleFractional) {
+               var i, unit, unitDivisor, unitLabel;
+
+               if (baseNumber === 0) {
+                       return "0 " + unitLabels[unitLabels.length - 1];
+               }
+               
+               if (singleFractional) {
+                       unit = baseNumber;
+                       unitLabel = unitLabels.length >= unitDivisors.length ? unitLabels[unitDivisors.length - 1] : "";
+                       for (i = 0; i < unitDivisors.length; i++) {
+                               if (baseNumber >= unitDivisors[i]) {
+                                       unit = (baseNumber / unitDivisors[i]).toFixed(2);
+                                       unitLabel = unitLabels.length >= i ? " " + unitLabels[i] : "";
+                                       break;
+                               }
+                       }
+                       
+                       return unit + unitLabel;
+               } else {
+                       var formattedStrings = [];
+                       var remainder = baseNumber;
+                       
+                       for (i = 0; i < unitDivisors.length; i++) {
+                               unitDivisor = unitDivisors[i];
+                               unitLabel = unitLabels.length > i ? " " + unitLabels[i] : "";
+                               
+                               unit = remainder / unitDivisor;
+                               if (i < unitDivisors.length -1) {
+                                       unit = Math.floor(unit);
+                               } else {
+                                       unit = unit.toFixed(2);
+                               }
+                               if (unit > 0) {
+                                       remainder = remainder % unitDivisor;
+                                       
+                                       formattedStrings.push(unit + unitLabel);
+                               }
+                       }
+                       
+                       return formattedStrings.join(" ");
+               }
+       };
+       
+       SWFUpload.speed.formatBPS = function (baseNumber) {
+               var bpsUnits = [1073741824, 1048576, 1024, 1], bpsUnitLabels = ["Gbps", "Mbps", "Kbps", "bps"];
+               return SWFUpload.speed.formatUnits(baseNumber, bpsUnits, bpsUnitLabels, true);
+       
+       };
+       SWFUpload.speed.formatTime = function (baseNumber) {
+               var timeUnits = [86400, 3600, 60, 1], timeUnitLabels = ["d", "h", "m", "s"];
+               return SWFUpload.speed.formatUnits(baseNumber, timeUnits, timeUnitLabels, false);
+       
+       };
+       SWFUpload.speed.formatBytes = function (baseNumber) {
+               var sizeUnits = [1073741824, 1048576, 1024, 1], sizeUnitLabels = ["GB", "MB", "KB", "bytes"];
+               return SWFUpload.speed.formatUnits(baseNumber, sizeUnits, sizeUnitLabels, true);
+       
+       };
+       SWFUpload.speed.formatPercent = function (baseNumber) {
+               return baseNumber.toFixed(2) + " %";
+       };
+       
+       SWFUpload.speed.calculateMovingAverage = function (history) {
+               var vals = [], size, sum = 0.0, mean = 0.0, varianceTemp = 0.0, variance = 0.0, standardDev = 0.0;
+               var i;
+               var mSum = 0, mCount = 0;
+               
+               size = history.length;
+               
+               // Check for sufficient data
+               if (size >= 8) {
+                       // Clone the array and Calculate sum of the values 
+                       for (i = 0; i < size; i++) {
+                               vals[i] = history[i];
+                               sum += vals[i];
+                       }
+
+                       mean = sum / size;
+
+                       // Calculate variance for the set
+                       for (i = 0; i < size; i++) {
+                               varianceTemp += Math.pow((vals[i] - mean), 2);
+                       }
+
+                       variance = varianceTemp / size;
+                       standardDev = Math.sqrt(variance);
+                       
+                       //Standardize the Data
+                       for (i = 0; i < size; i++) {
+                               vals[i] = (vals[i] - mean) / standardDev;
+                       }
+
+                       // Calculate the average excluding outliers
+                       var deviationRange = 2.0;
+                       for (i = 0; i < size; i++) {
+                               
+                               if (vals[i] <= deviationRange && vals[i] >= -deviationRange) {
+                                       mCount++;
+                                       mSum += history[i];
+                               }
+                       }
+                       
+               } else {
+                       // Calculate the average (not enough data points to remove outliers)
+                       mCount = size;
+                       for (i = 0; i < size; i++) {
+                               mSum += history[i];
+                       }
+               }
+
+               return mSum / mCount;
+       };
+       
 }
\ No newline at end of file