| /* |
| 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; |
| }; |
| |
| } |