Mercurial > hg > webaudioevaluationtool
changeset 655:640a8d827e48
Add bibliography file to repo
| author | Brecht De Man <BrechtDeMan@users.noreply.github.com> |
|---|---|
| date | Wed, 22 Apr 2015 10:05:11 +0100 |
| parents | |
| children | 06fbaccf3b58 |
| files | .hgignore ape.css ape.js apeTool.html core.js docs/ProjectSpecificationDocument.pdf docs/ProjectSpecificationDocument.tex docs/ResultsSpecificationDocument.pdf docs/ResultsSpecificationDocument.tex docs/SMC15/IEEEtran.bst docs/SMC15/smc2015.sty docs/SMC15/smc2015template.bbl docs/SMC15/smc2015template.bib docs/SMC15/smc2015template.tex example_eval/0.wav example_eval/1.wav example_eval/10.wav example_eval/2.wav example_eval/3.wav example_eval/4.wav example_eval/5.wav example_eval/6.wav example_eval/7.wav example_eval/8.wav example_eval/9.wav example_eval/project.xml graphics.css pythonServer.py structure.css |
| diffstat | 29 files changed, 4836 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/.hgignore Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,13 @@ +syntax: glob +.project/** +.project +docs/SMC15/smc2015.log +docs/SMC15/smc2015template.aux +docs/SMC15/smc2015template.blg +docs/SMC15/smc2015template.log +docs/SMC15/smc2015template.out +docs/SMC15/smc2015template.pdf +docs/SMC15/smc2015template.synctex.gz +re:^docs/ExperimentVariableControl\.aux$ +re:^docs/ExperimentVariableControl\.log$ +re:^docs/ExperimentVariableControl\.synctex\.gz$
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ape.css Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,101 @@ +/* + * Hold any style information for APE interface. Customise if you like to make the interface your own! + * + */ +body { + /* Set the background colour (note US English spelling) to grey*/ + background-color: #ddd +} + +div.title { + /* Specify any colouring for the title */ +} + +div.pageTitle { + width: auto; + height: 20px; +} + +div.testHalt { + /* Specify any colouring during the test halt for pre/post questions */ + background-color: rgba(0,0,0,0.5); + /* Don't mess with this bit */ + z-index: 2; + width: 100%; + height: 100%; + position: absolute; + left: 0px; + top: 0px; +} + +button { + /* Specify any button structure or style */ + min-width: 20px; + background-color: #ddd +} + +div#slider { + /* Specify any structure for the slider holder interface */ + background-color: #eee; + height: 150px; + margin-bottom: 5px; +} + +div.sliderScale { + width: 100%; + min-height: 20px; +} + +div.sliderScale span { + /* Any formatting of text below scale */ + min-width: 5px; + height: 20px; + height: 100%; + position: absolute; +} + +div.track-slider { + /* Specify any strcture for the slider objects */ + position: absolute; + height: inherit; + width: 12px; + float: left; + background-color: rgb(100,200,100); +} + +div.comment-div { + border:#444444; + border-style:solid; + border-width:1px; + width: 624px; + float: left; + margin: 5px; +} + +div.comment-div span { + margin-left: 15px; +} + +div.popupHolder { + width: 500px; + height: 250px; + background-color: #fff; + border-radius: 10px; + box-shadow: 0px 0px 50px #000; + z-index: 2; +} + +button.popupButton { + /* Button for popup window + */ + width: 50px; + height: 25px; + position: absolute; + left: 440px; + top: 215px; + border-radius: 5px; + border: #444; + border-width: 1px; + border-style: solid; + background-color: #fff; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ape.js Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,875 @@ +/** + * ape.js + * Create the APE interface + */ + +/* + * + * WARNING!!! + * + * YOU ARE VIEWING THE DEV VERSION. THERE IS NO GUARANTEE THIS WILL BE FULLY FUNCTIONAL + * + * WARNING!!! + * + */ + +var currentState; // Keep track of the current state (pre/post test, which test, final test? first test?) +// preTest - In preTest state +// testRun-ID - In test running, test Id number at the end 'testRun-2' +// testRunPost-ID - Post test of test ID +// testRunPre-ID - Pre-test of test ID +// postTest - End of test, final submission! + + +// Once this is loaded and parsed, begin execution +loadInterface(projectXML); + +function loadInterface(xmlDoc) { + + // Get the dimensions of the screen available to the page + var width = window.innerWidth; + var height = window.innerHeight; + + // The injection point into the HTML page + var insertPoint = document.getElementById("topLevelBody"); + var testContent = document.createElement('div'); + testContent.id = 'testContent'; + + + // Decode parts of the xmlDoc that are needed + // xmlDoc MUST already be parsed by jQuery! + var xmlSetup = xmlDoc.find('setup'); + // Should put in an error function here incase of malprocessed or malformed XML + + // Extract the different test XML DOM trees + var audioHolders = xmlDoc.find('audioHolder'); + audioHolders.each(function(index,element) { + var repeatN = element.attributes['repeatCount'].value; + for (var r=0; r<=repeatN; r++) { + testXMLSetups[testXMLSetups.length] = element; + } + }); + + // New check if we need to randomise the test order + var randomise = xmlSetup[0].attributes['randomiseOrder']; + if (randomise != undefined) { + randomise = Boolean(randomise.value); + } else { + randomise = false; + } + if (randomise) + { + testXMLSetups = randomiseOrder(testXMLSetups); + } + + // Obtain the metrics enabled + var metricNode = xmlSetup.find('Metric'); + var metricNode = metricNode.find('metricEnable'); + metricNode.each(function(index,node){ + var enabled = node.textContent; + switch(enabled) + { + case 'testTimer': + sessionMetrics.prototype.enableTestTimer = true; + break; + case 'elementTimer': + sessionMetrics.prototype.enableElementTimer = true; + break; + case 'elementTracker': + sessionMetrics.prototype.enableElementTracker = true; + break; + case 'elementInitalPosition': + sessionMetrics.prototype.enableElementInitialPosition = true; + break; + case 'elementFlagListenedTo': + sessionMetrics.prototype.enableFlagListenedTo = true; + break; + case 'elementFlagMoved': + sessionMetrics.prototype.enableFlagMoved = true; + break; + case 'elementFlagComments': + sessionMetrics.prototype.enableFlagComments = true; + break; + } + }); + + // Create APE specific metric functions + audioEngineContext.metric.initialiseTest = function() + { + var sliders = document.getElementsByClassName('track-slider'); + for (var i=0; i<sliders.length; i++) + { + audioEngineContext.audioObjects[i].metric.initialised(convSliderPosToRate(i)); + } + }; + + audioEngineContext.metric.sliderMoveStart = function(id) + { + if (this.data == -1) + { + this.data = id; + } else { + console.log('ERROR: Metric tracker detecting two moves!'); + this.data = -1; + } + }; + audioEngineContext.metric.sliderMoved = function() + { + var time = audioEngineContext.timer.getTestTime(); + var id = this.data; + this.data = -1; + var position = convSliderPosToRate(id); + if (audioEngineContext.timer.testStarted) + { + audioEngineContext.audioObjects[id].metric.moved(time,position); + } + }; + + audioEngineContext.metric.sliderPlayed = function(id) + { + var time = audioEngineContext.timer.getTestTime(); + if (audioEngineContext.timer.testStarted) + { + if (this.lastClicked >= 0) + { + audioEngineContext.audioObjects[this.lastClicked].metric.listening(time); + } + this.lastClicked = id; + audioEngineContext.audioObjects[id].metric.listening(time); + } + }; + + // Create the top div for the Title element + var titleAttr = xmlSetup[0].attributes['title']; + var title = document.createElement('div'); + title.className = "title"; + title.align = "center"; + var titleSpan = document.createElement('span'); + + // Set title to that defined in XML, else set to default + if (titleAttr != undefined) { + titleSpan.innerHTML = titleAttr.value; + } else { + titleSpan.innerHTML = 'APE Tool'; + } + // Insert the titleSpan element into the title div element. + title.appendChild(titleSpan); + + var pagetitle = document.createElement('div'); + pagetitle.className = "pageTitle"; + pagetitle.align = "center"; + var titleSpan = document.createElement('span'); + titleSpan.id = "pageTitle"; + pagetitle.appendChild(titleSpan); + + // Store the return URL path in global projectReturn + projectReturn = xmlSetup[0].attributes['projectReturn'].value; + + // Create Interface buttons! + var interfaceButtons = document.createElement('div'); + interfaceButtons.id = 'interface-buttons'; + + // MANUAL DOWNLOAD POINT + // If project return is null, this MUST be specified as the location to create the download link + var downloadPoint = document.createElement('div'); + downloadPoint.id = 'download-point'; + + // Create playback start/stop points + var playback = document.createElement("button"); + playback.innerHTML = 'Start'; + playback.id = 'playback-button'; + // onclick function. Check if it is playing or not, call the correct function in the + // audioEngine, change the button text to reflect the next state. + playback.onclick = function() { + if (audioEngineContext.status == 0) { + audioEngineContext.play(); + this.innerHTML = 'Stop'; + } else { + audioEngineContext.stop(); + this.innerHTML = 'Start'; + } + }; + // Create Submit (save) button + var submit = document.createElement("button"); + submit.innerHTML = 'Submit'; + submit.onclick = buttonSubmitClick; + submit.id = 'submit-button'; + // Append the interface buttons into the interfaceButtons object. + interfaceButtons.appendChild(playback); + interfaceButtons.appendChild(submit); + interfaceButtons.appendChild(downloadPoint); + + // Now create the slider and HTML5 canvas boxes + + // Create the div box to center align + var sliderBox = document.createElement('div'); + sliderBox.className = 'sliderCanvasDiv'; + sliderBox.id = 'sliderCanvasHolder'; + sliderBox.align = 'center'; + + // Create the slider box to hold the slider elements + var canvas = document.createElement('div'); + canvas.id = 'slider'; + // Must have a known EXACT width, as this is used later to determine the ratings + canvas.style.width = width - 100 +"px"; + canvas.align = "left"; + sliderBox.appendChild(canvas); + + // Create the div to hold any scale objects + var scale = document.createElement('div'); + scale.className = 'sliderScale'; + scale.id = 'sliderScaleHolder'; + scale.align = 'left'; + sliderBox.appendChild(scale); + + // Global parent for the comment boxes on the page + var feedbackHolder = document.createElement('div'); + feedbackHolder.id = 'feedbackHolder'; + + testContent.style.zIndex = 1; + insertPoint.innerHTML = null; // Clear the current schema + + // Create pre and post test questions + var blank = document.createElement('div'); + blank.className = 'testHalt'; + + var popupHolder = document.createElement('div'); + popupHolder.id = 'popupHolder'; + popupHolder.className = 'popupHolder'; + popupHolder.style.position = 'absolute'; + popupHolder.style.left = (window.innerWidth/2)-250 + 'px'; + popupHolder.style.top = (window.innerHeight/2)-125 + 'px'; + insertPoint.appendChild(popupHolder); + insertPoint.appendChild(blank); + hidePopup(); + + var preTest = xmlSetup.find('PreTest'); + var postTest = xmlSetup.find('PostTest'); + preTest = preTest[0]; + postTest = postTest[0]; + + currentState = 'preTest'; + + // Create Pre-Test Box + if (preTest != undefined && preTest.children.length >= 1) + { + showPopup(); + preTestPopupStart(preTest); + } + + // Inject into HTML + testContent.appendChild(title); // Insert the title + testContent.appendChild(pagetitle); + testContent.appendChild(interfaceButtons); + testContent.appendChild(sliderBox); + testContent.appendChild(feedbackHolder); + insertPoint.appendChild(testContent); + + // Load the full interface + +} + +function loadTest(id) +{ + // Used to load a specific test page + var textXML = testXMLSetups[id]; + + var feedbackHolder = document.getElementById('feedbackHolder'); + var canvas = document.getElementById('slider'); + feedbackHolder.innerHTML = null; + canvas.innerHTML = null; + + // Setup question title + var interfaceObj = $(textXML).find('interface'); + var titleNode = interfaceObj.find('title'); + if (titleNode[0] != undefined) + { + document.getElementById('pageTitle').textContent = titleNode[0].textContent; + } + var positionScale = canvas.style.width.substr(0,canvas.style.width.length-2); + var offset = 50-8; // Half the offset of the slider (window width -100) minus the body padding of 8 + // TODO: AUTOMATE ABOVE!! + var scale = document.getElementById('sliderScaleHolder'); + scale.innerHTML = null; + interfaceObj.find('scale').each(function(index,scaleObj){ + var position = Number(scaleObj.attributes['position'].value)*0.01; + var pixelPosition = (position*positionScale)+offset; + var scaleDOM = document.createElement('span'); + scaleDOM.textContent = scaleObj.textContent; + scale.appendChild(scaleDOM); + scaleDOM.style.left = Math.floor((pixelPosition-($(scaleDOM).width()/2)))+'px'; + }); + + // Extract the hostURL attribute. If not set, create an empty string. + var hostURL = textXML.attributes['hostURL']; + if (hostURL == undefined) { + hostURL = ""; + } else { + hostURL = hostURL.value; + } + // Extract the sampleRate. If set, convert the string to a Number. + var hostFs = textXML.attributes['sampleRate']; + if (hostFs != undefined) { + hostFs = Number(hostFs.value); + } + + /// CHECK FOR SAMPLE RATE COMPATIBILITY + if (hostFs != undefined) { + if (Number(hostFs) != audioContext.sampleRate) { + var errStr = 'Sample rates do not match! Requested '+Number(hostFs)+', got '+audioContext.sampleRate+'. Please set the sample rate to match before completing this test.'; + alert(errStr); + return; + } + } + + var loopPlayback = textXML.attributes['loop']; + if (loopPlayback != undefined) + { + loopPlayback = loopPlayback.value; + if (loopPlayback == 'true') { + loopPlayback = true; + } else { + loopPlayback = false; + } + } else { + loopPlayback = false; + } + audioEngineContext.loopPlayback = loopPlayback; + + // Create AudioEngine bindings for playback + if (loopPlayback) { + audioEngineContext.play = function() { + // Send play command to all playback buffers for synchronised start + // Also start timer callbacks to detect if playback has finished + if (this.status == 0) { + this.timer.startTest(); + // First get current clock + var timer = audioContext.currentTime; + // Add 3 seconds + timer += 3.0; + // Send play to all tracks + for (var i=0; i<this.audioObjects.length; i++) + { + this.audioObjects[i].play(timer); + } + this.status = 1; + } + }; + + audioEngineContext.stop = function() { + // Send stop and reset command to all playback buffers + if (this.status == 1) { + if (this.loopPlayback) { + for (var i=0; i<this.audioObjects.length; i++) + { + this.audioObjects[i].stop(); + } + } + this.status = 0; + } + }; + + audioEngineContext.selectedTrack = function(id) { + for (var i=0; i<this.audioObjects.length; i++) + { + if (id == i) { + this.audioObjects[i].outputGain.gain.value = 1.0; + } else { + this.audioObjects[i].outputGain.gain.value = 0.0; + } + } + }; + } else { + audioEngineContext.play = function() { + // Send play command to all playback buffers for synchronised start + // Also start timer callbacks to detect if playback has finished + if (this.status == 0) { + this.timer.startTest(); + this.status = 1; + } + }; + + audioEngineContext.stop = function() { + // Send stop and reset command to all playback buffers + if (this.status == 1) { + if (this.loopPlayback) { + for (var i=0; i<this.audioObjects.length; i++) + { + this.audioObjects[i].stop(); + } + } + this.status = 0; + } + }; + + audioEngineContext.selectedTrack = function(id) { + for (var i=0; i<this.audioObjects.length; i++) + { + if (id == i) { + this.audioObjects[i].outputGain.gain.value = 1.0; + this.audioObjects[i].play(audioContext.currentTime+0.01); + } else { + this.audioObjects[i].outputGain.gain.value = 0.0; + } + } + }; + } + + currentTestHolder = document.createElement('audioHolder'); + currentTestHolder.id = textXML.id; + currentTestHolder.repeatCount = textXML.attributes['repeatCount'].value; + var currentPreTestHolder = document.createElement('preTest'); + var currentPostTestHolder = document.createElement('postTest'); + currentTestHolder.appendChild(currentPreTestHolder); + currentTestHolder.appendChild(currentPostTestHolder); + + var randomise = textXML.attributes['randomiseOrder']; + if (randomise != undefined) {randomise = randomise.value;} + else {randomise = false;} + + var audioElements = $(textXML).find('audioElements'); + currentTrackOrder = []; + audioElements.each(function(index,element){ + // Find any blind-repeats + // Not implemented yet, but just incase + currentTrackOrder[index] = element; + }); + if (randomise) { + currentTrackOrder = randomiseOrder(currentTrackOrder); + } + + // Delete any previous audioObjects associated with the audioEngine + audioEngineContext.audioObjects = []; + + // Find all the audioElements from the audioHolder + $(currentTrackOrder).each(function(index,element){ + // Find URL of track + // In this jQuery loop, variable 'this' holds the current audioElement. + + // Now load each audio sample. First create the new track by passing the full URL + var trackURL = hostURL + this.attributes['url'].value; + audioEngineContext.newTrack(trackURL); + // Create document objects to hold the comment boxes + var trackComment = document.createElement('div'); + trackComment.className = 'comment-div'; + // Create a string next to each comment asking for a comment + var trackString = document.createElement('span'); + trackString.innerHTML = 'Comment on track '+index; + // Create the HTML5 comment box 'textarea' + var trackCommentBox = document.createElement('textarea'); + trackCommentBox.rows = '4'; + trackCommentBox.cols = '100'; + trackCommentBox.name = 'trackComment'+index; + trackCommentBox.className = 'trackComment'; + var br = document.createElement('br'); + // Add to the holder. + trackComment.appendChild(trackString); + trackComment.appendChild(br); + trackComment.appendChild(trackCommentBox); + feedbackHolder.appendChild(trackComment); + + // Create a slider per track + + var trackSliderObj = document.createElement('div'); + trackSliderObj.className = 'track-slider'; + trackSliderObj.id = 'track-slider-'+index; + // Distribute it randomnly + var w = window.innerWidth - 100; + w = Math.random()*w; + trackSliderObj.style.left = Math.floor(w)+50+'px'; + trackSliderObj.innerHTML = '<span>'+index+'</span>'; + trackSliderObj.draggable = true; + trackSliderObj.ondragend = dragEnd; + trackSliderObj.ondragstart = function() + { + var id = Number(this.id.substr(13,2)); // Maximum theoretical tracks is 99! + audioEngineContext.metric.sliderMoveStart(id); + }; + + // Onclick, switch playback to that track + trackSliderObj.onclick = function() { + // Get the track ID from the object ID + var id = Number(this.id.substr(13,2)); // Maximum theoretical tracks is 99! + audioEngineContext.metric.sliderPlayed(id); + audioEngineContext.selectedTrack(id); + }; + + canvas.appendChild(trackSliderObj); + }); + + // Now process any pre-test commands + + var preTest = $(testXMLSetups[id]).find('PreTest')[0]; + if (preTest.children.length > 0) + { + currentState = 'testRunPre-'+id; + preTestPopupStart(preTest); + showPopup(); + } else { + currentState = 'testRun-'+id; + } +} + +function preTestPopupStart(preTest) +{ + var popupHolder = document.getElementById('popupHolder'); + popupHolder.innerHTML = null; + // Parse the first box + var preTestOption = document.createElement('div'); + preTestOption.id = 'preTest'; + preTestOption.style.marginTop = '25px'; + preTestOption.align = "center"; + var child = preTest.children[0]; + if (child.nodeName == 'statement') + { + preTestOption.innerHTML = '<span>'+child.innerHTML+'</span>'; + } else if (child.nodeName == 'question') + { + var questionId = child.attributes['id'].value; + var textHold = document.createElement('span'); + textHold.innerHTML = child.innerHTML; + textHold.id = questionId + 'response'; + var textEnter = document.createElement('textarea'); + preTestOption.appendChild(textHold); + preTestOption.appendChild(textEnter); + } + var nextButton = document.createElement('button'); + nextButton.className = 'popupButton'; + nextButton.value = '0'; + nextButton.innerHTML = 'Next'; + nextButton.onclick = popupButtonClick; + + popupHolder.appendChild(preTestOption); + popupHolder.appendChild(nextButton); +} + +function popupButtonClick() +{ + // Global call from the 'Next' button click + if (currentState == 'preTest') + { + // At the start of the preTest routine! + var xmlTree = projectXML.find('setup'); + var preTest = xmlTree.find('PreTest')[0]; + this.value = preTestButtonClick(preTest,this.value); + } else if (currentState.substr(0,10) == 'testRunPre') + { + //Specific test pre-test + var testId = currentState.substr(11,currentState.length-10); + var preTest = $(testXMLSetups[testId]).find('PreTest')[0]; + this.value = preTestButtonClick(preTest,this.value); + } else if (currentState.substr(0,11) == 'testRunPost') + { + // Specific test post-test + var testId = currentState.substr(12,currentState.length-11); + var preTest = $(testXMLSetups[testId]).find('PostTest')[0]; + this.value = preTestButtonClick(preTest,this.value); + } else if (currentState == 'postTest') + { + // At the end of the test, running global post test + var xmlTree = projectXML.find('setup'); + var PostTest = xmlTree.find('PostTest')[0]; + this.value = preTestButtonClick(PostTest,this.value); + } +} + +function preTestButtonClick(preTest,index) +{ + // Called on click of pre-test button + // Need to find and parse preTest again! + var preTestOption = document.getElementById('preTest'); + // Check if current state is a question! + if (preTest.children[index].nodeName == 'question') { + var questionId = preTest.children[index].attributes['id'].value; + var questionHold = document.createElement('comment'); + var questionResponse = document.getElementById(questionId + 'response'); + questionHold.id = questionId; + questionHold.innerHTML = questionResponse.value; + postPopupResponse(questionHold); + } + index++; + if (index < preTest.children.length) + { + // More to process + var child = preTest.children[index]; + if (child.nodeName == 'statement') + { + preTestOption.innerHTML = '<span>'+child.innerHTML+'</span>'; + } else if (child.nodeName == 'question') + { + var textHold = document.createElement('span'); + textHold.innerHTML = child.innerHTML; + var textEnter = document.createElement('textarea'); + textEnter.id = child.attributes['id'].value + 'response'; + var br = document.createElement('br'); + preTestOption.innerHTML = null; + preTestOption.appendChild(textHold); + preTestOption.appendChild(br); + preTestOption.appendChild(textEnter); + } + } else { + // Time to clear + preTestOption.innerHTML = null; + if (currentState != 'postTest') { + hidePopup(); + // Progress the state! + advanceState(); + } else { + a = createProjectSave(projectReturn); + preTestOption.appendChild(a); + } + } + return index; +} + +function postPopupResponse(response) +{ + if (currentState == 'preTest') { + preTestQuestions.appendChild(response); + } else if (currentState == 'postTest') { + postTestQuestions.appendChild(response); + } else { + // Inside a specific test + if (currentState.substr(0,10) == 'testRunPre') { + // Pre Test + var store = $(currentTestHolder).find('preTest'); + } else { + // Post Test + var store = $(currentTestHolder).find('postTest'); + } + store[0].appendChild(response); + } +} + +function showPopup() +{ + var popupHolder = document.getElementById('popupHolder'); + popupHolder.style.zIndex = 3; + popupHolder.style.visibility = 'visible'; + var blank = document.getElementsByClassName('testHalt')[0]; + blank.style.zIndex = 2; + blank.style.visibility = 'visible'; +} + +function hidePopup() +{ + var popupHolder = document.getElementById('popupHolder'); + popupHolder.style.zIndex = -1; + popupHolder.style.visibility = 'hidden'; + var blank = document.getElementsByClassName('testHalt')[0]; + blank.style.zIndex = -2; + blank.style.visibility = 'hidden'; +} + +function dragEnd(ev) { + // Function call when a div has been dropped + var slider = document.getElementById('slider'); + var w = slider.style.width; + w = Number(w.substr(0,w.length-2)); + var x = ev.x; + if (x >= 42 && x < w+42) { + this.style.left = (x)+'px'; + } else { + if (x<42) { + this.style.left = '42px'; + } else { + this.style.left = (w+42) + 'px'; + } + } + audioEngineContext.metric.sliderMoved(); +} + +function advanceState() +{ + console.log(currentState); + if (currentState == 'preTest') + { + // End of pre-test, begin the test + loadTest(0); + } else if (currentState.substr(0,10) == 'testRunPre') + { + // Start the test + var testId = currentState.substr(11,currentState.length-10); + currentState = 'testRun-'+testId; + } else if (currentState.substr(0,11) == 'testRunPost') + { + var testId = currentState.substr(12,currentState.length-11); + testEnded(testId); + } else if (currentState.substr(0,7) == 'testRun') + { + var testId = currentState.substr(8,currentState.length-7); + // Check if we have any post tests to perform + var postXML = $(testXMLSetups[testId]).find('PostTest')[0]; + if (postXML.children.length > 0) + { + currentState = 'testRunPost-'+testId; + showPopup(); + preTestPopupStart(postXML); + } + else { + + + // No post tests, check if we have another test to perform instead + testEnded(testId); + } + } + console.log(currentState); +} + +function testEnded(testId) +{ + pageXMLSave(testId); + if (testXMLSetups.length-1 > testId) + { + // Yes we have another test to perform + testId = (Number(testId)+1); + currentState = 'testRun-'+testId; + loadTest(testId); + } else { + console.log('Testing Completed!'); + currentState = 'postTest'; + // Check for any post tests + var xmlSetup = projectXML.find('setup'); + var postTest = xmlSetup.find('PostTest')[0]; + showPopup(); + preTestPopupStart(postTest); + } +} + +function buttonSubmitClick() +{ + if (audioEngineContext.status == 1) { + var playback = document.getElementById('playback-button'); + playback.click(); + // This function is called when the submit button is clicked. Will check for any further tests to perform, or any post-test options + } else + { + if (audioEngineContext.timer.testStarted == false) + { + alert('You have not started the test! Please press start to begin the test!'); + return; + } + } + if (currentState.substr(0,7) == 'testRun') + { + audioEngineContext.timer.stopTest(); + advanceState(); + } +} + +function convSliderPosToRate(id) +{ + var w = document.getElementById('slider').style.width; + var maxPix = w.substr(0,w.length-2); + var slider = document.getElementsByClassName('track-slider')[id]; + var pix = slider.style.left; + pix = pix.substr(0,pix.length-2); + var rate = (pix-42)/maxPix; + return rate; +} + +function pageXMLSave(testId) +{ + // Saves a specific test page + var xmlDoc = currentTestHolder; + // Check if any session wide metrics are enabled + var metric = document.createElement('metric'); + if (audioEngineContext.metric.enableTestTimer) + { + var testTime = document.createElement('metricResult'); + testTime.id = 'testTime'; + testTime.textContent = audioEngineContext.timer.testDuration; + metric.appendChild(testTime); + } + xmlDoc.appendChild(metric); + var trackSliderObjects = document.getElementsByClassName('track-slider'); + var commentObjects = document.getElementsByClassName('comment-div'); + for (var i=0; i<trackSliderObjects.length; i++) + { + var audioElement = document.createElement('audioElement'); + audioElement.id = currentTrackOrder[i].attributes['id'].value; + audioElement.url = currentTrackOrder[i].attributes['url'].value; + var value = document.createElement('value'); + value.innerHTML = convSliderPosToRate(i); + var comment = document.createElement("comment"); + var question = document.createElement("question"); + var response = document.createElement("response"); + question.textContent = commentObjects[i].children[0].textContent; + response.textContent = commentObjects[i].children[2].value; + comment.appendChild(question); + comment.appendChild(response); + audioElement.appendChild(value); + audioElement.appendChild(comment); + // Check for any per element metrics + var metric = document.createElement('metric'); + var elementMetric = audioEngineContext.audioObjects[i].metric; + if (audioEngineContext.metric.enableElementTimer) { + var elementTimer = document.createElement('metricResult'); + elementTimer.id = 'elementTimer'; + elementTimer.textContent = elementMetric.listenedTimer; + metric.appendChild(elementTimer); + } + if (audioEngineContext.metric.enableElementTracker) { + var elementTrackerFull = document.createElement('metricResult'); + elementTrackerFull.id = 'elementTrackerFull'; + var data = elementMetric.movementTracker; + for (var k=0; k<data.length; k++) + { + var timePos = document.createElement('timePos'); + timePos.id = k; + var time = document.createElement('time'); + time.textContent = data[k][0]; + var position = document.createElement('position'); + position.textContent = data[k][1]; + timePos.appendChild(time); + timePos.appendChild(position); + elementTrackerFull.appendChild(timePos); + } + metric.appendChild(elementTrackerFull); + } + if (audioEngineContext.metric.enableElementInitialPosition) { + var elementInitial = document.createElement('metricResult'); + elementInitial.id = 'elementInitialPosition'; + elementInitial.textContent = elementMetric.initialPosition; + metric.appendChild(elementInitial); + } + if (audioEngineContext.metric.enableFlagListenedTo) { + var flagListenedTo = document.createElement('metricResult'); + flagListenedTo.id = 'elementFlagListenedTo'; + flagListenedTo.textContent = elementMetric.wasListenedTo; + metric.appendChild(flagListenedTo); + } + if (audioEngineContext.metric.enableFlagMoved) { + var flagMoved = document.createElement('metricResult'); + flagMoved.id = 'elementFlagMoved'; + flagMoved.textContent = elementMetric.wasMoved; + metric.appendChild(flagMoved); + } + if (audioEngineContext.metric.enableFlagComments) { + var flagComments = document.createElement('metricResult'); + flagComments.id = 'elementFlagComments'; + if (response.textContent.length == 0) {flag.textContent = 'false';} + else {flag.textContet = 'true';} + metric.appendChild(flagComments); + } + audioElement.appendChild(metric); + xmlDoc.appendChild(audioElement); + } + testResultsHolders[testId] = xmlDoc; +} + +// Only other global function which must be defined in the interface class. Determines how to create the XML document. +function interfaceXMLSave(){ + // Create the XML string to be exported with results + var xmlDoc = document.createElement("BrowserEvaluationResult"); + for (var i=0; i<testResultsHolders.length; i++) + { + xmlDoc.appendChild(testResultsHolders[i]); + } + // Append Pre/Post Questions + xmlDoc.appendChild(preTestQuestions); + xmlDoc.appendChild(postTestQuestions); + + return xmlDoc; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/apeTool.html Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,49 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8" /> + +<!-- WARNING!!! + * + * YOU ARE VIEWING THE DEV VERSION. THERE IS NO GUARANTEE THIS WILL BE FULLY FUNCTIONAL + * + * WARNING!!! + * +--> + + + <!-- Always force latest IE rendering engine (even in intranet) & Chrome Frame + Remove this if you use the .htaccess --> + <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" /> + + <title>apeTool</title> + <meta name="description" content="" /> + <meta name="author" content="" /> + + <!-- Load up the default core JS and CSS files--> + <link rel='stylesheet' type='text/css' href='graphics.css'> + <link rel='stylesheet' type='text/css' href='structure.css'> + <!-- Use jQuery hosted from Google CDN --> + <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script> + <script src='core.js'></script> + <script type="text/javascript"> + window.onbeforeunload = function() { + return "Please only leave this page once you have completed the tests. Are you sure you have completed all testing?"; + }; + </script> + <!-- Uncomment the following script for automatic loading of projects --> + <script> + url = 'example_eval/project2.xml'; //Project XML document location + loadProjectSpec(url); + </script> + + </head> + + <body> + <!-- Load up the default page interface allowing for project setting loads, even if hard-coded--> + <!-- Actual test interface design should be contained in the .js for ease of dynamic content--> + <div id='topLevelBody'> + <p>HTML5 APE Tool</p> + </div> + </body> +</html>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/core.js Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,327 @@ +/** + * core.js + * + * Main script to run, calls all other core functions and manages loading/store to backend. + * Also contains all global variables. + */ + + +/* + * + * WARNING!!! + * + * YOU ARE VIEWING THE DEV VERSION. THERE IS NO GUARANTEE THIS WILL BE FULLY FUNCTIONAL + * + * WARNING!!! + * + */ + + + + +/* create the web audio API context and store in audioContext*/ +var audioContext; // Hold the browser web audio API +var projectXML; // Hold the parsed setup XML + +var testXMLSetups = []; // Hold the parsed test instances +var testResultsHolders =[]; // Hold the results from each test for publishing to XML +var currentTrackOrder = []; // Hold the current XML tracks in their (randomised) order +var currentTestHolder; // Hold any intermediate results during test - metrics +var audioEngineContext; // The custome AudioEngine object +var projectReturn; // Hold the URL for the return +var preTestQuestions = document.createElement('PreTest'); // Store any pre-test question response +var postTestQuestions = document.createElement('PostTest'); // Store any post-test question response + +// Add a prototype to the bufferSourceNode to reference to the audioObject holding it +AudioBufferSourceNode.prototype.owner = undefined; + +window.onload = function() { + // Function called once the browser has loaded all files. + // This should perform any initial commands such as structure / loading documents + + // Create a web audio API context + // Fixed for cross-browser support + var AudioContext = window.AudioContext || window.webkitAudioContext; + audioContext = new AudioContext; + + // Create the audio engine object + audioEngineContext = new AudioEngine(); +}; + +function loadProjectSpec(url) { + // Load the project document from the given URL, decode the XML and instruct audioEngine to get audio data + // If url is null, request client to upload project XML document + var r = new XMLHttpRequest(); + r.open('GET',url,true); + r.onload = function() { + loadProjectSpecCallback(r.response); + }; + r.send(); +}; + +function loadProjectSpecCallback(response) { + // Function called after asynchronous download of XML project specification + var decode = $.parseXML(response); + projectXML = $(decode); + + // Now extract the setup tag + var xmlSetup = projectXML.find('setup'); + // Detect the interface to use and load the relevant javascripts. + var interfaceType = xmlSetup[0].attributes['interface']; + var interfaceJS = document.createElement('script'); + interfaceJS.setAttribute("type","text/javascript"); + if (interfaceType.value == 'APE') { + interfaceJS.setAttribute("src","ape.js"); + + // APE comes with a css file + var css = document.createElement('link'); + css.rel = 'stylesheet'; + css.type = 'text/css'; + css.href = 'ape.css'; + + document.getElementsByTagName("head")[0].appendChild(css); + } + document.getElementsByTagName("head")[0].appendChild(interfaceJS); +} + +function createProjectSave(destURL) { + // Save the data from interface into XML and send to destURL + // If destURL is null then download XML in client + // Now time to render file locally + var xmlDoc = interfaceXMLSave(); + if (destURL == "null" || destURL == undefined) { + var parent = document.createElement("div"); + parent.appendChild(xmlDoc); + var file = [parent.innerHTML]; + var bb = new Blob(file,{type : 'application/xml'}); + var dnlk = window.URL.createObjectURL(bb); + var a = document.createElement("a"); + a.hidden = ''; + a.href = dnlk; + a.download = "save.xml"; + a.textContent = "Save File"; + + var submitDiv = document.getElementById('download-point'); + submitDiv.appendChild(a); + } + return submitDiv; +} + +function AudioEngine() { + + // Create two output paths, the main outputGain and fooGain. + // Output gain is default to 1 and any items for playback route here + // Foo gain is used for analysis to ensure paths get processed, but are not heard + // because web audio will optimise and any route which does not go to the destination gets ignored. + this.outputGain = audioContext.createGain(); + this.fooGain = audioContext.createGain(); + this.fooGain.gain = 0; + + // Use this to detect playback state: 0 - stopped, 1 - playing + this.status = 0; + + // Connect both gains to output + this.outputGain.connect(audioContext.destination); + this.fooGain.connect(audioContext.destination); + + // Create the timer Object + this.timer = new timer(); + // Create session metrics + this.metric = new sessionMetrics(this); + + this.loopPlayback = false; + + // Create store for new audioObjects + this.audioObjects = []; + + this.play = function(){}; + + this.stop = function(){}; + + + this.newTrack = function(url) { + // Pull data from given URL into new audio buffer + // URLs must either be from the same source OR be setup to 'Access-Control-Allow-Origin' + + // Create the audioObject with ID of the new track length; + audioObjectId = this.audioObjects.length; + this.audioObjects[audioObjectId] = new audioObject(audioObjectId); + + // AudioObject will get track itself. + this.audioObjects[audioObjectId].constructTrack(url); + }; + +} + +function audioObject(id) { + // The main buffer object with common control nodes to the AudioEngine + + this.id = id; + this.state = 0; // 0 - no data, 1 - ready + this.url = null; // Hold the URL given for the output back to the results. + this.metric = new metricTracker(); + + // Create a buffer and external gain control to allow internal patching of effects and volume leveling. + this.bufferNode = undefined; + this.outputGain = audioContext.createGain(); + + // Default output gain to be zero + this.outputGain.gain.value = 0.0; + + // Connect buffer to the audio graph + this.outputGain.connect(audioEngineContext.outputGain); + + // the audiobuffer is not designed for multi-start playback + // When stopeed, the buffer node is deleted and recreated with the stored buffer. + this.buffer; + + this.play = function(startTime) { + this.bufferNode = audioContext.createBufferSource(); + this.bufferNode.connect(this.outputGain); + this.bufferNode.buffer = this.buffer; + this.bufferNode.loop = audioEngineContext.loopPlayback; + this.bufferNode.start(startTime); + }; + + this.stop = function() { + this.bufferNode.stop(0); + this.bufferNode = undefined; + }; + + this.constructTrack = function(url) { + var request = new XMLHttpRequest(); + this.url = url; + request.open('GET',url,true); + request.responseType = 'arraybuffer'; + + var audioObj = this; + + // Create callback to decode the data asynchronously + request.onloadend = function() { + audioContext.decodeAudioData(request.response, function(decodedData) { + audioObj.buffer = decodedData; + audioObj.state = 1; + }, function(){ + // Should only be called if there was an error, but sometimes gets called continuously + // Check here if the error is genuine + if (audioObj.state == 0 || audioObj.buffer == undefined) { + // Genuine error + console.log('FATAL - Error loading buffer on '+audioObj.id); + } + }); + }; + request.send(); + }; + +} + +function timer() +{ + /* Timer object used in audioEngine to keep track of session timings + * Uses the timer of the web audio API, so sample resolution + */ + this.testStarted = false; + this.testStartTime = 0; + this.testDuration = 0; + this.minimumTestTime = 0; // No minimum test time + this.startTest = function() + { + if (this.testStarted == false) + { + this.testStartTime = audioContext.currentTime; + this.testStarted = true; + this.updateTestTime(); + audioEngineContext.metric.initialiseTest(); + } + }; + this.stopTest = function() + { + if (this.testStarted) + { + this.testDuration = this.getTestTime(); + this.testStarted = false; + } else { + console.log('ERR: Test tried to end before beginning'); + } + }; + this.updateTestTime = function() + { + if (this.testStarted) + { + this.testDuration = audioContext.currentTime - this.testStartTime; + } + }; + this.getTestTime = function() + { + this.updateTestTime(); + return this.testDuration; + }; +} + +function sessionMetrics(engine) +{ + /* Used by audioEngine to link to audioObjects to minimise the timer call timers; + */ + this.engine = engine; + this.lastClicked = -1; + this.data = -1; + this.initialiseTest = function(){}; +} + +function metricTracker() +{ + /* Custom object to track and collect metric data + * Used only inside the audioObjects object. + */ + + this.listenedTimer = 0; + this.listenStart = 0; + this.initialPosition = -1; + this.movementTracker = []; + this.wasListenedTo = false; + this.wasMoved = false; + this.hasComments = false; + + this.initialised = function(position) + { + if (this.initialPosition == -1) { + this.initialPosition = position; + } + }; + + this.moved = function(time,position) + { + this.wasMoved = true; + this.movementTracker[this.movementTracker.length] = [time, position]; + }; + + this.listening = function(time) + { + if (this.listenStart == 0) + { + this.wasListenedTo = true; + this.listenStart = time; + } else { + this.listenedTimer += (time - this.listenStart); + this.listenStart = 0; + } + }; +} + +function randomiseOrder(input) +{ + // This takes an array of information and randomises the order + var N = input.length; + var K = N; + var holdArr = []; + for (var n=0; n<N; n++) + { + // First pick a random number + var r = Math.random(); + // Multiply and floor by the number of elements left + r = Math.floor(r*input.length); + // Pick out that element and delete from the array + holdArr.push(input.splice(r,1)[0]); + } + return holdArr; +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/ProjectSpecificationDocument.tex Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,208 @@ +\documentclass{article} + +\usepackage[margin=2cm]{geometry} +\usepackage{listings} + +\begin{document} + +\large APE Browser Tool - Project Specification Document + +\section{Document} + +An XML file containing all project information to load and execute the project on the client. Certain interfaces are optional, however others are mandatory. This guide should reflect the changes in the XML project and keep track of the versions. Hopwfully this can remain simple! + +\section{Root} + +The XML root must be \texttt{<BrowserEvalProjectDocument>}. This should be sufficiently identifiable in both itself and in the JavaScript decoding as it will create an object called the root name. + +There must also be a \texttt{<version>} tag which has the attribute \texttt{id} containing a numerical representation of the version. Currently everything in this document can be assumed to be version 1. If future updates or corrections are made post delivery this should give the flexibility to ensure past projects still work. + +The root will also contain the following tags: setup and tracks. + +\section{Setup tag} + +The setup tag specifies certain global test settings including: the interface type to use, the project return location and any other setup instructions. +Any general pre/post test questions must be specified in the relevant children tag. Any enabled metrics must also be specified in the metric child node. + +\subsection{Attributes} +\begin{itemize} +\item \texttt{interface} - Mandatory, String. Defaults to APE, otherwise use to load any of the available interfaces. Currently only valid string is APE. +\item \texttt{projectReturn} - Mandatory, String. Specify the URL to return the test results. If null client will generate XML locally and prompt user to return the file. +\item \texttt{randomiseOrder} - Optional, default to false. Specify if the order of the tests can be randomised. +\item \texttt{collectMetrics} - Optional, Boolean. Default to false. Determine if the test metrics should be collected. These include how long each test session took etc. The full metrics list can be modified in the 'metrics' tag. +\end{itemize} + +\subsection{Elements} +None + +\section{AudioHolder tag} + +There should be one audioHolder tag per test session, inside which each audioElement is specified as children. The audioHolder tag can help to generalise certain objects. Each audioHolder instance specifies a separate listening test to be paged, each with their own specific requirements. + +\subsection{Attributes} +\begin{itemize} +\item \texttt{id} - Mandatory, String. Give an ID string or number to identify the test in the result. +\item \texttt{hostURL} - Optional, String. If all tracks are hosted from the same folder on a server, you can put in the lead here. For instance, if loading http://test.com/tracks/track1.wav and http://test.com/tracks/track2.wav, this could equal http://test.com/tracks/ and the url attribute in the track tag can be track1.wav or track2.wav. Equally http://test.com/ and then using tracks/track1.wav and tracks/track2.wav is valid. +\item \texttt{sampleRate} - Optional, Number. If your test requires a specific sample rate, this should be set to the desired sample rate in Hertz. This does not set the browser to the correct sample rate, but forces the browser to check the sample rate matches. If this is undefined, no sample rate matching will occur. +\item \texttt{randomiseOrder} - Optional, Boolean String. Defaults to false. Determine if the track order should be randomised. Must be true or false. +\item \texttt{repeatCount} - Optional, Number. Defaults to 0 (ie: no repeats). The number of times a test should be repeated. +\item \texttt{loop} - Optional, Boolean String. Defaults to false. Enable if audioElements should loop their playback or not. +\end{itemize} + +\subsection{Elements} +Contain the audioElements tags and the interfaceSetup tag. + +\section{audioElements tag} + +This must reside as children in the audioHolder tag. There must be one audioElement tag per sound sample to load into the test. + +\subsection{Attributes} +\begin{itemize} +\item \texttt{id} - Mandatory, String. Must give a string or number to identify each audio element. This id is used in the output to identify each track once randomised. +\item \texttt{url} - Mandatory, String. Contain the full URL to the track. If the Tracks tag hostURL is set, concatenate this tag with the hostURL attribute to obtain the full URL. +\end{itemize} + +\section{interface tag} + +This is contained within the audioHolder tag and outlines test instance specific requirements. These include the following children tags: +\begin{itemize} +\item 'title' - Contains the test title to be shown at the top of the page. Can only be one title node per interface. +\item 'scale' - Takes the attribute position to be a value between 0 and 100 indicating where on the scale to place the text contained inside. Can be multiple scale tags per interface. +\end{itemize} + +\section {CommentQuestion tag} + +This is a 1st level tag (same level as AudioHolder and setup). This allows another question and comment box to be presented on the page. The results of these are passed back in the results XML with both the comment and the question. The id attribute is set to keep track at the results XML. + +\section {PreTest tag and PostTest tag} + +These are 1st level tags. The PreTest tag allows for the specifying of pre test instructions and questions. These appear as a pop-up style window with next buttons and other automatic GUI. The postTest tag allows for specifying post test instructions, questions and resources. These appear as a pop-up style window after the submit button is pressed. + +\subsection{Attributes} +None. + +\subsection{Elements} +Takes the \texttt{statement} and \texttt{question} tags. The order these are presented in the XML define the order they appear on the screen. + +\subsubsection{Statement} + +The statement tag simply prints the included string verbatim on a 'pop-up' window with a next button. + +\subsubsection{Question} + +This allows for a question to be asked pre/post the test. This is added to the response XML in the same location as the other common/global questions. The response includes both the question asked and the response. This takes two attributes, id and mandatory. ID is a mandatory field. The same ID will be used in the results so it is important it is properly entered. Mandatory is optional. True means the field must be entered before continuing. + +\subsubsection{Resource} + +The resource tag is only available in the postTest tag. This allows for the linking to some external resource via the href attribute. + +\section{Metric tag} +A 1st level tag, metrics must be declared in the setup tag. This takes a set of children 'metricEnable' to define which metrics to collect and present. + +\subsection{metricEnable tag} +This takes a single attribute to determine which metric to enable for collection. Some of these are a global, per track or per test instance. +\begin{itemize} +\item testTimer - Return the global test timer and test instance timers. Measures the time between the first start and final submit. +\item elementTimer - Return the total time each audioElement in each test was listened too. Measures time between successive clicks on the track changer +\item elementTracker - Return the initial position of each track +\item elementTrackerFull - Return an enumerated pair of time and position. Track the entire movement of each element position. NOTE: Will override the elementTracker option above and throw an error into the browser console. +\item elementFlagListenedTo - Return a boolean per elementck to see if the element was listened to +\item elementFlagMoved - Return a boolean per element to see if the element slider was moved. +\item elementFlagComments - Return a boolean per element to see if the element has comments. +\end{itemize} + +\section{Feature List} +\begin{itemize} +\item Paging listening tests - eg. Ask multiple questions in each experiment +\item Labels on X axis - scale +\item Input questions/comment at top to guide towards the question being asked. +\item Randomise track numbers -(inc. comment boxes and relate back to correct reference track) +\item Randomise order of individual tests +\item Save output XML file to remote server +\item Tests Metrics +\begin{itemize} +\item Duration of listening to each track +\item Time spent on each individual test +\item Start and end position of every track +\item Flags on each track, to ensure each track (but may not restrict users from submitting) +\begin{itemize} +\item Has been listened to +\item Has been moved +\item Has comments about it +\end{itemize} +\end{itemize} +\end{itemize} + +\subsection{Advanced feature list} +\begin{itemize} +\item Repeat each tests number of times (2 or 3?) to remove learning / experience bias and ensure that the order is consistent +\item Perform Loudness equalisation on all tracks +\item Selection of test type +\item Pre-test of some basic hearing test +\begin{itemize} +\item MUSHRA (with vertical slider per track) +\item APE (Single horizontal slider) +\item AB Test +\end{itemize} +\end{itemize} + + + +\section{Example} + +Here is an example XML structure + +\begin{lstlisting} +<?xml version="1.0" encoding="utf-8"?> +<BrowserEvalProjectDocument> + <setup interface="APE" projectReturn="null" randomiseOrder='true' collectMetrics='true'> + <PreTest> + <statement>Please listen to all mixes</statement> + <question id="location" mandatory="true">Please enter your listening location</question> + </PreTest> + <PostTest> + <statement>Thank you for taking this listening test.</statement> + <question id="SessionID">Please enter your name.</question> + </PostTest> + <Metric> + <metricEnable>testTimer</metricEnable> + <metricEnable>elementTimer</metricEnable> + <metricEnable>elementTracker</metricEnable> + <metricEnable>elementFlagListenedTo</metricEnable> + <metricEnable>elementFlagMoved</metricEnable> + </Metric> + </setup> + <audioHolder id='0' hostURL="example_eval/" sampleRate="44100" randomiseOrder='true' repeatCount='1'> + <interface> + <title>Example Test Question</title> + <scale position="0">Min</scale> + <scale position="100">Max</scale> + <scale position="50">Middle</scale> + <scale position="20">20</scale> + </interface> + <audioElements url="0.wav" id="0"/> + <audioElements url="1.wav" id="1"/> + <audioElements url="2.wav" id="2"/> + <audioElements url="3.wav" id="3"/> + <audioElements url="4.wav" id="4"/> + <audioElements url="5.wav" id="5"/> + <audioElements url="6.wav" id="6"/> + <audioElements url="7.wav" id="7"/> + <audioElements url="8.wav" id="8"/> + <audioElements url="9.wav" id="9"/> + <audioElements url="10.wav" id="10"/> + <CommentQuestion id='mixingExperiance'>What is your mixing experiance</CommentQuestion> + <PreTest> + <statement>Start the Test 3</statement> + </PreTest> + <PostTest> + <statement>Please take a break before the next test</statement> + <question id="testComment">How did you find the test</question> + </PostTest> + </audioHolder> +</BrowserEvalProjectDocument> +\end{lstlisting} + + + +\end{document}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/ResultsSpecificationDocument.tex Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,65 @@ +\documentclass{article} + +\usepackage[margin=2cm]{geometry} +\usepackage{listings} +\usepackage{color} + +\begin{document} + +\large APE Browser Tool - Results Specification Document + +\section{Introduction} +This document outlines the return XML document structure to hold the results from the Browser Evaluation Tool, specifically for the APE Interface. + +\section{Root} +The root of the document is \texttt{BrowserEvaluationResult}. + +\section{testReults} +A 1st level node, contains all the results from a specific test instance defined by the audioHolder objects in the setup XML. Takes the audioElement as its children to define a full test and any test metrics. + +\subsection{Attributes} +\begin{itemize} +\item \texttt{id} - The ID given to audioHolder in the project setup XML. +\item \texttt{repeatCount} - Specifies the repeat count of the test, there will be one testResult per test per repeat, this will help identify which repeat. +\end{itemize} + +\subsection{AudioElement} +A 2nd level node, this contains the results for a specific audioElement. + +\subsubsection{Attributes} +Has the following attributes, depending on the variables set in the Project Specification. +\begin{itemize} +\item \texttt{id} - Mandatory. This returns the ID of the track in question. This is either the value passed in from the project specification, or calculated based on the position in the list. For instance, in the automatic system, the first test sample has ID 0, the second ID 1 and so forth. The value passed in from the project specification can either be a string or a Number. +\item \texttt{url} - Mandatory. Returns the full URL given incase of errors or for later checking. +\end{itemize} + +\subsubsection{Value} +One of these elements per track, containing the floating value between 0 and 1 relating the user rating of the track. This is a mandatory element. + +\subsubsection{Comment} +One of these elements per track, containing any commenting data from the interface text boxes. Has the two following child nodes. +\begin{itemize} +\item \texttt{Question} - Returns the text next to the comment box +\item \texttt{Response} - Returns the text in the comment box +\end{itemize} + +\subsubsection{metrics} +One of these holders per audioElement, containing the results from any of the enabled per element metrics in metricResult tags. The ID of each element represents the metricEnable tag element. The inner value contains the results. + +% Will list specific response structures per metric! + +\subsection{metrics} +One of these holders per testResults tag, containing the results from any of the enabled per test metrics in metricResult tags. The ID of each element represents the metricEnable tag element. The inner value contains the results. + +% Will list specific response structures per metric! + +\section{PreTest and PostTest} +A 1st level node, contains the response to any pre-test questions given in the project specification. These are stored in the same Comment node as outlined in the above audioElement. + +The PostTest is a 1st level node and contains the response to any post-test questions given in the project specification. + +\section{Session Data} +This will contain any captured session data. Currently not implemented but here for future referencing. +% I used to have a 'global' comment for each 'session' as well + +\end{document}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/SMC15/IEEEtran.bst Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,2417 @@ +%% +%% IEEEtran.bst +%% BibTeX Bibliography Style file for IEEE Journals and Conferences (unsorted) +%% Version 1.12 (2007/01/11) +%% +%% Copyright (c) 2003-2007 Michael Shell +%% +%% Original starting code base and algorithms obtained from the output of +%% Patrick W. Daly's makebst package as well as from prior versions of +%% IEEE BibTeX styles: +%% +%% 1. Howard Trickey and Oren Patashnik's ieeetr.bst (1985/1988) +%% 2. Silvano Balemi and Richard H. Roy's IEEEbib.bst (1993) +%% +%% Support sites: +%% http://www.michaelshell.org/tex/ieeetran/ +%% http://www.ctan.org/tex-archive/macros/latex/contrib/IEEEtran/ +%% and/or +%% http://www.ieee.org/ +%% +%% For use with BibTeX version 0.99a or later +%% +%% This is a numerical citation style. +%% +%%************************************************************************* +%% Legal Notice: +%% This code is offered as-is without any warranty either expressed or +%% implied; without even the implied warranty of MERCHANTABILITY or +%% FITNESS FOR A PARTICULAR PURPOSE! +%% User assumes all risk. +%% In no event shall IEEE or any contributor to this code be liable for +%% any damages or losses, including, but not limited to, incidental, +%% consequential, or any other damages, resulting from the use or misuse +%% of any information contained here. +%% +%% All comments are the opinions of their respective authors and are not +%% necessarily endorsed by the IEEE. +%% +%% This work is distributed under the LaTeX Project Public License (LPPL) +%% ( http://www.latex-project.org/ ) version 1.3, and may be freely used, +%% distributed and modified. A copy of the LPPL, version 1.3, is included +%% in the base LaTeX documentation of all distributions of LaTeX released +%% 2003/12/01 or later. +%% Retain all contribution notices and credits. +%% ** Modified files should be clearly indicated as such, including ** +%% ** renaming them and changing author support contact information. ** +%% +%% File list of work: IEEEabrv.bib, IEEEfull.bib, IEEEexample.bib, +%% IEEEtran.bst, IEEEtranS.bst, IEEEtranSA.bst, +%% IEEEtranN.bst, IEEEtranSN.bst, IEEEtran_bst_HOWTO.pdf +%%************************************************************************* +% +% +% Changelog: +% +% 1.00 (2002/08/13) Initial release +% +% 1.10 (2002/09/27) +% 1. Corrected minor bug for improperly formed warning message when a +% book was not given a title. Thanks to Ming Kin Lai for reporting this. +% 2. Added support for CTLname_format_string and CTLname_latex_cmd fields +% in the BST control entry type. +% +% 1.11 (2003/04/02) +% 1. Fixed bug with URLs containing underscores when using url.sty. Thanks +% to Ming Kin Lai for reporting this. +% +% 1.12 (2007/01/11) +% 1. Fixed bug with unwanted comma before "et al." when an entry contained +% more than two author names. Thanks to Pallav Gupta for reporting this. +% 2. Fixed bug with anomalous closing quote in tech reports that have a +% type, but without a number or address. Thanks to Mehrdad Mirreza for +% reporting this. +% 3. Use braces in \providecommand in begin.bib to better support +% latex2html. TeX style length assignments OK with recent versions +% of latex2html - 1.71 (2002/2/1) or later is strongly recommended. +% Use of the language field still causes trouble with latex2html. +% Thanks to Federico Beffa for reporting this. +% 4. Added IEEEtran.bst ID and version comment string to .bbl output. +% 5. Provide a \BIBdecl hook that allows the user to execute commands +% just prior to the first entry. +% 6. Use default urlstyle (is using url.sty) of "same" rather than rm to +% better work with a wider variety of bibliography styles. +% 7. Changed month abbreviations from Sept., July and June to Sep., Jul., +% and Jun., respectively, as IEEE now does. Thanks to Moritz Borgmann +% for reporting this. +% 8. Control entry types should not be considered when calculating longest +% label width. +% 9. Added alias www for electronic/online. +% 10. Added CTLname_url_prefix control entry type. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% DEFAULTS FOR THE CONTROLS OF THE BST STYLE %% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% These are the defaults for the user adjustable controls. The values used +% here can be overridden by the user via IEEEtranBSTCTL entry type. + +% NOTE: The recommended LaTeX command to invoke a control entry type is: +% +%\makeatletter +%\def\bstctlcite{\@ifnextchar[{\@bstctlcite}{\@bstctlcite[@auxout]}} +%\def\@bstctlcite[#1]#2{\@bsphack +% \@for\@citeb:=#2\do{% +% \edef\@citeb{\expandafter\@firstofone\@citeb}% +% \if@filesw\immediate\write\csname #1\endcsname{\string\citation{\@citeb}}\fi}% +% \@esphack} +%\makeatother +% +% It is called at the start of the document, before the first \cite, like: +% \bstctlcite{IEEEexample:BSTcontrol} +% +% IEEEtran.cls V1.6 and later does provide this command. + + + +% #0 turns off the display of the number for articles. +% #1 enables +FUNCTION {default.is.use.number.for.article} { #1 } + + +% #0 turns off the display of the paper and type fields in @inproceedings. +% #1 enables +FUNCTION {default.is.use.paper} { #1 } + + +% #0 turns off the forced use of "et al." +% #1 enables +FUNCTION {default.is.forced.et.al} { #0 } + +% The maximum number of names that can be present beyond which an "et al." +% usage is forced. Be sure that num.names.shown.with.forced.et.al (below) +% is not greater than this value! +% Note: There are many instances of references in IEEE journals which have +% a very large number of authors as well as instances in which "et al." is +% used profusely. +FUNCTION {default.max.num.names.before.forced.et.al} { #10 } + +% The number of names that will be shown with a forced "et al.". +% Must be less than or equal to max.num.names.before.forced.et.al +FUNCTION {default.num.names.shown.with.forced.et.al} { #1 } + + +% #0 turns off the alternate interword spacing for entries with URLs. +% #1 enables +FUNCTION {default.is.use.alt.interword.spacing} { #1 } + +% If alternate interword spacing for entries with URLs is enabled, this is +% the interword spacing stretch factor that will be used. For example, the +% default "4" here means that the interword spacing in entries with URLs can +% stretch to four times normal. Does not have to be an integer. Note that +% the value specified here can be overridden by the user in their LaTeX +% code via a command such as: +% "\providecommand\BIBentryALTinterwordstretchfactor{1.5}" in addition to +% that via the IEEEtranBSTCTL entry type. +FUNCTION {default.ALTinterwordstretchfactor} { "4" } + + +% #0 turns off the "dashification" of repeated (i.e., identical to those +% of the previous entry) names. IEEE normally does this. +% #1 enables +FUNCTION {default.is.dash.repeated.names} { #1 } + + +% The default name format control string. +FUNCTION {default.name.format.string}{ "{f.~}{vv~}{ll}{, jj}" } + + +% The default LaTeX font command for the names. +FUNCTION {default.name.latex.cmd}{ "" } + + +% The default URL prefix. +FUNCTION {default.name.url.prefix}{ "[Online]. Available:" } + + +% Other controls that cannot be accessed via IEEEtranBSTCTL entry type. + +% #0 turns off the terminal startup banner/completed message so as to +% operate more quietly. +% #1 enables +FUNCTION {is.print.banners.to.terminal} { #1 } + + + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% FILE VERSION AND BANNER %% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +FUNCTION{bst.file.version} { "1.12" } +FUNCTION{bst.file.date} { "2007/01/11" } +FUNCTION{bst.file.website} { "http://www.michaelshell.org/tex/ieeetran/bibtex/" } + +FUNCTION {banner.message} +{ is.print.banners.to.terminal + { "-- IEEEtran.bst version" " " * bst.file.version * + " (" * bst.file.date * ") " * "by Michael Shell." * + top$ + "-- " bst.file.website * + top$ + "-- See the " quote$ * "IEEEtran_bst_HOWTO.pdf" * quote$ * " manual for usage information." * + top$ + } + { skip$ } + if$ +} + +FUNCTION {completed.message} +{ is.print.banners.to.terminal + { "" + top$ + "Done." + top$ + } + { skip$ } + if$ +} + + + + +%%%%%%%%%%%%%%%%%%%%%% +%% STRING CONSTANTS %% +%%%%%%%%%%%%%%%%%%%%%% + +FUNCTION {bbl.and}{ "and" } +FUNCTION {bbl.etal}{ "et~al." } +FUNCTION {bbl.editors}{ "eds." } +FUNCTION {bbl.editor}{ "ed." } +FUNCTION {bbl.edition}{ "ed." } +FUNCTION {bbl.volume}{ "vol." } +FUNCTION {bbl.of}{ "of" } +FUNCTION {bbl.number}{ "no." } +FUNCTION {bbl.in}{ "in" } +FUNCTION {bbl.pages}{ "pp." } +FUNCTION {bbl.page}{ "p." } +FUNCTION {bbl.chapter}{ "ch." } +FUNCTION {bbl.paper}{ "paper" } +FUNCTION {bbl.part}{ "pt." } +FUNCTION {bbl.patent}{ "Patent" } +FUNCTION {bbl.patentUS}{ "U.S." } +FUNCTION {bbl.revision}{ "Rev." } +FUNCTION {bbl.series}{ "ser." } +FUNCTION {bbl.standard}{ "Std." } +FUNCTION {bbl.techrep}{ "Tech. Rep." } +FUNCTION {bbl.mthesis}{ "Master's thesis" } +FUNCTION {bbl.phdthesis}{ "Ph.D. dissertation" } +FUNCTION {bbl.st}{ "st" } +FUNCTION {bbl.nd}{ "nd" } +FUNCTION {bbl.rd}{ "rd" } +FUNCTION {bbl.th}{ "th" } + + +% This is the LaTeX spacer that is used when a larger than normal space +% is called for (such as just before the address:publisher). +FUNCTION {large.space} { "\hskip 1em plus 0.5em minus 0.4em\relax " } + +% The LaTeX code for dashes that are used to represent repeated names. +% Note: Some older IEEE journals used something like +% "\rule{0.275in}{0.5pt}\," which is fairly thick and runs right along +% the baseline. However, IEEE now uses a thinner, above baseline, +% six dash long sequence. +FUNCTION {repeated.name.dashes} { "------" } + + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% PREDEFINED STRING MACROS %% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +MACRO {jan} {"Jan."} +MACRO {feb} {"Feb."} +MACRO {mar} {"Mar."} +MACRO {apr} {"Apr."} +MACRO {may} {"May"} +MACRO {jun} {"Jun."} +MACRO {jul} {"Jul."} +MACRO {aug} {"Aug."} +MACRO {sep} {"Sep."} +MACRO {oct} {"Oct."} +MACRO {nov} {"Nov."} +MACRO {dec} {"Dec."} + + + +%%%%%%%%%%%%%%%%%% +%% ENTRY FIELDS %% +%%%%%%%%%%%%%%%%%% + +ENTRY + { address + assignee + author + booktitle + chapter + day + dayfiled + edition + editor + howpublished + institution + intype + journal + key + language + month + monthfiled + nationality + note + number + organization + pages + paper + publisher + school + series + revision + title + type + url + volume + year + yearfiled + CTLuse_article_number + CTLuse_paper + CTLuse_forced_etal + CTLmax_names_forced_etal + CTLnames_show_etal + CTLuse_alt_spacing + CTLalt_stretch_factor + CTLdash_repeated_names + CTLname_format_string + CTLname_latex_cmd + CTLname_url_prefix + } + {} + { label } + + + + +%%%%%%%%%%%%%%%%%%%%%%% +%% INTEGER VARIABLES %% +%%%%%%%%%%%%%%%%%%%%%%% + +INTEGERS { prev.status.punct this.status.punct punct.std + punct.no punct.comma punct.period + prev.status.space this.status.space space.std + space.no space.normal space.large + prev.status.quote this.status.quote quote.std + quote.no quote.close + prev.status.nline this.status.nline nline.std + nline.no nline.newblock + status.cap cap.std + cap.no cap.yes} + +INTEGERS { longest.label.width multiresult nameptr namesleft number.label numnames } + +INTEGERS { is.use.number.for.article + is.use.paper + is.forced.et.al + max.num.names.before.forced.et.al + num.names.shown.with.forced.et.al + is.use.alt.interword.spacing + is.dash.repeated.names} + + +%%%%%%%%%%%%%%%%%%%%%% +%% STRING VARIABLES %% +%%%%%%%%%%%%%%%%%%%%%% + +STRINGS { bibinfo + longest.label + oldname + s + t + ALTinterwordstretchfactor + name.format.string + name.latex.cmd + name.url.prefix} + + + + +%%%%%%%%%%%%%%%%%%%%%%%%% +%% LOW LEVEL FUNCTIONS %% +%%%%%%%%%%%%%%%%%%%%%%%%% + +FUNCTION {initialize.controls} +{ default.is.use.number.for.article 'is.use.number.for.article := + default.is.use.paper 'is.use.paper := + default.is.forced.et.al 'is.forced.et.al := + default.max.num.names.before.forced.et.al 'max.num.names.before.forced.et.al := + default.num.names.shown.with.forced.et.al 'num.names.shown.with.forced.et.al := + default.is.use.alt.interword.spacing 'is.use.alt.interword.spacing := + default.is.dash.repeated.names 'is.dash.repeated.names := + default.ALTinterwordstretchfactor 'ALTinterwordstretchfactor := + default.name.format.string 'name.format.string := + default.name.latex.cmd 'name.latex.cmd := + default.name.url.prefix 'name.url.prefix := +} + + +% This IEEEtran.bst features a very powerful and flexible mechanism for +% controlling the capitalization, punctuation, spacing, quotation, and +% newlines of the formatted entry fields. (Note: IEEEtran.bst does not need +% or use the newline/newblock feature, but it has been implemented for +% possible future use.) The output states of IEEEtran.bst consist of +% multiple independent attributes and, as such, can be thought of as being +% vectors, rather than the simple scalar values ("before.all", +% "mid.sentence", etc.) used in most other .bst files. +% +% The more flexible and complex design used here was motivated in part by +% IEEE's rather unusual bibliography style. For example, IEEE ends the +% previous field item with a period and large space prior to the publisher +% address; the @electronic entry types use periods as inter-item punctuation +% rather than the commas used by the other entry types; and URLs are never +% followed by periods even though they are the last item in the entry. +% Although it is possible to accommodate these features with the conventional +% output state system, the seemingly endless exceptions make for convoluted, +% unreliable and difficult to maintain code. +% +% IEEEtran.bst's output state system can be easily understood via a simple +% illustration of two most recently formatted entry fields (on the stack): +% +% CURRENT_ITEM +% "PREVIOUS_ITEM +% +% which, in this example, is to eventually appear in the bibliography as: +% +% "PREVIOUS_ITEM," CURRENT_ITEM +% +% It is the job of the output routine to take the previous item off of the +% stack (while leaving the current item at the top of the stack), apply its +% trailing punctuation (including closing quote marks) and spacing, and then +% to write the result to BibTeX's output buffer: +% +% "PREVIOUS_ITEM," +% +% Punctuation (and spacing) between items is often determined by both of the +% items rather than just the first one. The presence of quotation marks +% further complicates the situation because, in standard English, trailing +% punctuation marks are supposed to be contained within the quotes. +% +% IEEEtran.bst maintains two output state (aka "status") vectors which +% correspond to the previous and current (aka "this") items. Each vector +% consists of several independent attributes which track punctuation, +% spacing, quotation, and newlines. Capitalization status is handled by a +% separate scalar because the format routines, not the output routine, +% handle capitalization and, therefore, there is no need to maintain the +% capitalization attribute for both the "previous" and "this" items. +% +% When a format routine adds a new item, it copies the current output status +% vector to the previous output status vector and (usually) resets the +% current (this) output status vector to a "standard status" vector. Using a +% "standard status" vector in this way allows us to redefine what we mean by +% "standard status" at the start of each entry handler and reuse the same +% format routines under the various inter-item separation schemes. For +% example, the standard status vector for the @book entry type may use +% commas for item separators, while the @electronic type may use periods, +% yet both entry handlers exploit many of the exact same format routines. +% +% Because format routines have write access to the output status vector of +% the previous item, they can override the punctuation choices of the +% previous format routine! Therefore, it becomes trivial to implement rules +% such as "Always use a period and a large space before the publisher." By +% pushing the generation of the closing quote mark to the output routine, we +% avoid all the problems caused by having to close a quote before having all +% the information required to determine what the punctuation should be. +% +% The IEEEtran.bst output state system can easily be expanded if needed. +% For instance, it is easy to add a "space.tie" attribute value if the +% bibliography rules mandate that two items have to be joined with an +% unbreakable space. + +FUNCTION {initialize.status.constants} +{ #0 'punct.no := + #1 'punct.comma := + #2 'punct.period := + #0 'space.no := + #1 'space.normal := + #2 'space.large := + #0 'quote.no := + #1 'quote.close := + #0 'cap.no := + #1 'cap.yes := + #0 'nline.no := + #1 'nline.newblock := +} + +FUNCTION {std.status.using.comma} +{ punct.comma 'punct.std := + space.normal 'space.std := + quote.no 'quote.std := + nline.no 'nline.std := + cap.no 'cap.std := +} + +FUNCTION {std.status.using.period} +{ punct.period 'punct.std := + space.normal 'space.std := + quote.no 'quote.std := + nline.no 'nline.std := + cap.yes 'cap.std := +} + +FUNCTION {initialize.prev.this.status} +{ punct.no 'prev.status.punct := + space.no 'prev.status.space := + quote.no 'prev.status.quote := + nline.no 'prev.status.nline := + punct.no 'this.status.punct := + space.no 'this.status.space := + quote.no 'this.status.quote := + nline.no 'this.status.nline := + cap.yes 'status.cap := +} + +FUNCTION {this.status.std} +{ punct.std 'this.status.punct := + space.std 'this.status.space := + quote.std 'this.status.quote := + nline.std 'this.status.nline := +} + +FUNCTION {cap.status.std}{ cap.std 'status.cap := } + +FUNCTION {this.to.prev.status} +{ this.status.punct 'prev.status.punct := + this.status.space 'prev.status.space := + this.status.quote 'prev.status.quote := + this.status.nline 'prev.status.nline := +} + + +FUNCTION {not} +{ { #0 } + { #1 } + if$ +} + +FUNCTION {and} +{ { skip$ } + { pop$ #0 } + if$ +} + +FUNCTION {or} +{ { pop$ #1 } + { skip$ } + if$ +} + + +% convert the strings "yes" or "no" to #1 or #0 respectively +FUNCTION {yes.no.to.int} +{ "l" change.case$ duplicate$ + "yes" = + { pop$ #1 } + { duplicate$ "no" = + { pop$ #0 } + { "unknown boolean " quote$ * swap$ * quote$ * + " in " * cite$ * warning$ + #0 + } + if$ + } + if$ +} + + +% pushes true if the single char string on the stack is in the +% range of "0" to "9" +FUNCTION {is.num} +{ chr.to.int$ + duplicate$ "0" chr.to.int$ < not + swap$ "9" chr.to.int$ > not and +} + +% multiplies the integer on the stack by a factor of 10 +FUNCTION {bump.int.mag} +{ #0 'multiresult := + { duplicate$ #0 > } + { #1 - + multiresult #10 + + 'multiresult := + } + while$ +pop$ +multiresult +} + +% converts a single character string on the stack to an integer +FUNCTION {char.to.integer} +{ duplicate$ + is.num + { chr.to.int$ "0" chr.to.int$ - } + {"noninteger character " quote$ * swap$ * quote$ * + " in integer field of " * cite$ * warning$ + #0 + } + if$ +} + +% converts a string on the stack to an integer +FUNCTION {string.to.integer} +{ duplicate$ text.length$ 'namesleft := + #1 'nameptr := + #0 'numnames := + { nameptr namesleft > not } + { duplicate$ nameptr #1 substring$ + char.to.integer numnames bump.int.mag + + 'numnames := + nameptr #1 + + 'nameptr := + } + while$ +pop$ +numnames +} + + + + +% The output routines write out the *next* to the top (previous) item on the +% stack, adding punctuation and such as needed. Since IEEEtran.bst maintains +% the output status for the top two items on the stack, these output +% routines have to consider the previous output status (which corresponds to +% the item that is being output). Full independent control of punctuation, +% closing quote marks, spacing, and newblock is provided. +% +% "output.nonnull" does not check for the presence of a previous empty +% item. +% +% "output" does check for the presence of a previous empty item and will +% remove an empty item rather than outputing it. +% +% "output.warn" is like "output", but will issue a warning if it detects +% an empty item. + +FUNCTION {output.nonnull} +{ swap$ + prev.status.punct punct.comma = + { "," * } + { skip$ } + if$ + prev.status.punct punct.period = + { add.period$ } + { skip$ } + if$ + prev.status.quote quote.close = + { "''" * } + { skip$ } + if$ + prev.status.space space.normal = + { " " * } + { skip$ } + if$ + prev.status.space space.large = + { large.space * } + { skip$ } + if$ + write$ + prev.status.nline nline.newblock = + { newline$ "\newblock " write$ } + { skip$ } + if$ +} + +FUNCTION {output} +{ duplicate$ empty$ + 'pop$ + 'output.nonnull + if$ +} + +FUNCTION {output.warn} +{ 't := + duplicate$ empty$ + { pop$ "empty " t * " in " * cite$ * warning$ } + 'output.nonnull + if$ +} + +% "fin.entry" is the output routine that handles the last item of the entry +% (which will be on the top of the stack when "fin.entry" is called). + +FUNCTION {fin.entry} +{ this.status.punct punct.no = + { skip$ } + { add.period$ } + if$ + this.status.quote quote.close = + { "''" * } + { skip$ } + if$ +write$ +newline$ +} + + +FUNCTION {is.last.char.not.punct} +{ duplicate$ + "}" * add.period$ + #-1 #1 substring$ "." = +} + +FUNCTION {is.multiple.pages} +{ 't := + #0 'multiresult := + { multiresult not + t empty$ not + and + } + { t #1 #1 substring$ + duplicate$ "-" = + swap$ duplicate$ "," = + swap$ "+" = + or or + { #1 'multiresult := } + { t #2 global.max$ substring$ 't := } + if$ + } + while$ + multiresult +} + +FUNCTION {capitalize}{ "u" change.case$ "t" change.case$ } + +FUNCTION {emphasize} +{ duplicate$ empty$ + { pop$ "" } + { "\emph{" swap$ * "}" * } + if$ +} + +FUNCTION {do.name.latex.cmd} +{ name.latex.cmd + empty$ + { skip$ } + { name.latex.cmd "{" * swap$ * "}" * } + if$ +} + +% IEEEtran.bst uses its own \BIBforeignlanguage command which directly +% invokes the TeX hyphenation patterns without the need of the Babel +% package. Babel does a lot more than switch hyphenation patterns and +% its loading can cause unintended effects in many class files (such as +% IEEEtran.cls). +FUNCTION {select.language} +{ duplicate$ empty$ 'pop$ + { language empty$ 'skip$ + { "\BIBforeignlanguage{" language * "}{" * swap$ * "}" * } + if$ + } + if$ +} + +FUNCTION {tie.or.space.prefix} +{ duplicate$ text.length$ #3 < + { "~" } + { " " } + if$ + swap$ +} + +FUNCTION {get.bbl.editor} +{ editor num.names$ #1 > 'bbl.editors 'bbl.editor if$ } + +FUNCTION {space.word}{ " " swap$ * " " * } + + +% Field Conditioners, Converters, Checkers and External Interfaces + +FUNCTION {empty.field.to.null.string} +{ duplicate$ empty$ + { pop$ "" } + { skip$ } + if$ +} + +FUNCTION {either.or.check} +{ empty$ + { pop$ } + { "can't use both " swap$ * " fields in " * cite$ * warning$ } + if$ +} + +FUNCTION {empty.entry.warn} +{ author empty$ title empty$ howpublished empty$ + month empty$ year empty$ note empty$ url empty$ + and and and and and and + { "all relevant fields are empty in " cite$ * warning$ } + 'skip$ + if$ +} + + +% The bibinfo system provides a way for the electronic parsing/acquisition +% of a bibliography's contents as is done by ReVTeX. For example, a field +% could be entered into the bibliography as: +% \bibinfo{volume}{2} +% Only the "2" would show up in the document, but the LaTeX \bibinfo command +% could do additional things with the information. IEEEtran.bst does provide +% a \bibinfo command via "\providecommand{\bibinfo}[2]{#2}". However, it is +% currently not used as the bogus bibinfo functions defined here output the +% entry values directly without the \bibinfo wrapper. The bibinfo functions +% themselves (and the calls to them) are retained for possible future use. +% +% bibinfo.check avoids acting on missing fields while bibinfo.warn will +% issue a warning message if a missing field is detected. Prior to calling +% the bibinfo functions, the user should push the field value and then its +% name string, in that order. + +FUNCTION {bibinfo.check} +{ swap$ duplicate$ missing$ + { pop$ pop$ "" } + { duplicate$ empty$ + { swap$ pop$ } + { swap$ pop$ } + if$ + } + if$ +} + +FUNCTION {bibinfo.warn} +{ swap$ duplicate$ missing$ + { swap$ "missing " swap$ * " in " * cite$ * warning$ pop$ "" } + { duplicate$ empty$ + { swap$ "empty " swap$ * " in " * cite$ * warning$ } + { swap$ pop$ } + if$ + } + if$ +} + + +% IEEE separates large numbers with more than 4 digits into groups of +% three. IEEE uses a small space to separate these number groups. +% Typical applications include patent and page numbers. + +% number of consecutive digits required to trigger the group separation. +FUNCTION {large.number.trigger}{ #5 } + +% For numbers longer than the trigger, this is the blocksize of the groups. +% The blocksize must be less than the trigger threshold, and 2 * blocksize +% must be greater than the trigger threshold (can't do more than one +% separation on the initial trigger). +FUNCTION {large.number.blocksize}{ #3 } + +% What is actually inserted between the number groups. +FUNCTION {large.number.separator}{ "\," } + +% So as to save on integer variables by reusing existing ones, numnames +% holds the current number of consecutive digits read and nameptr holds +% the number that will trigger an inserted space. +FUNCTION {large.number.separate} +{ 't := + "" + #0 'numnames := + large.number.trigger 'nameptr := + { t empty$ not } + { t #-1 #1 substring$ is.num + { numnames #1 + 'numnames := } + { #0 'numnames := + large.number.trigger 'nameptr := + } + if$ + t #-1 #1 substring$ swap$ * + t #-2 global.max$ substring$ 't := + numnames nameptr = + { duplicate$ #1 nameptr large.number.blocksize - substring$ swap$ + nameptr large.number.blocksize - #1 + global.max$ substring$ + large.number.separator swap$ * * + nameptr large.number.blocksize - 'numnames := + large.number.blocksize #1 + 'nameptr := + } + { skip$ } + if$ + } + while$ +} + +% Converts all single dashes "-" to double dashes "--". +FUNCTION {n.dashify} +{ large.number.separate + 't := + "" + { t empty$ not } + { t #1 #1 substring$ "-" = + { t #1 #2 substring$ "--" = not + { "--" * + t #2 global.max$ substring$ 't := + } + { { t #1 #1 substring$ "-" = } + { "-" * + t #2 global.max$ substring$ 't := + } + while$ + } + if$ + } + { t #1 #1 substring$ * + t #2 global.max$ substring$ 't := + } + if$ + } + while$ +} + + +% This function detects entries with names that are identical to that of +% the previous entry and replaces the repeated names with dashes (if the +% "is.dash.repeated.names" user control is nonzero). +FUNCTION {name.or.dash} +{ 's := + oldname empty$ + { s 'oldname := s } + { s oldname = + { is.dash.repeated.names + { repeated.name.dashes } + { s 'oldname := s } + if$ + } + { s 'oldname := s } + if$ + } + if$ +} + +% Converts the number string on the top of the stack to +% "numerical ordinal form" (e.g., "7" to "7th"). There is +% no artificial limit to the upper bound of the numbers as the +% least significant digit always determines the ordinal form. +FUNCTION {num.to.ordinal} +{ duplicate$ #-1 #1 substring$ "1" = + { bbl.st * } + { duplicate$ #-1 #1 substring$ "2" = + { bbl.nd * } + { duplicate$ #-1 #1 substring$ "3" = + { bbl.rd * } + { bbl.th * } + if$ + } + if$ + } + if$ +} + +% If the string on the top of the stack begins with a number, +% (e.g., 11th) then replace the string with the leading number +% it contains. Otherwise retain the string as-is. s holds the +% extracted number, t holds the part of the string that remains +% to be scanned. +FUNCTION {extract.num} +{ duplicate$ 't := + "" 's := + { t empty$ not } + { t #1 #1 substring$ + t #2 global.max$ substring$ 't := + duplicate$ is.num + { s swap$ * 's := } + { pop$ "" 't := } + if$ + } + while$ + s empty$ + 'skip$ + { pop$ s } + if$ +} + +% Converts the word number string on the top of the stack to +% Arabic string form. Will be successful up to "tenth". +FUNCTION {word.to.num} +{ duplicate$ "l" change.case$ 's := + s "first" = + { pop$ "1" } + { skip$ } + if$ + s "second" = + { pop$ "2" } + { skip$ } + if$ + s "third" = + { pop$ "3" } + { skip$ } + if$ + s "fourth" = + { pop$ "4" } + { skip$ } + if$ + s "fifth" = + { pop$ "5" } + { skip$ } + if$ + s "sixth" = + { pop$ "6" } + { skip$ } + if$ + s "seventh" = + { pop$ "7" } + { skip$ } + if$ + s "eighth" = + { pop$ "8" } + { skip$ } + if$ + s "ninth" = + { pop$ "9" } + { skip$ } + if$ + s "tenth" = + { pop$ "10" } + { skip$ } + if$ +} + + +% Converts the string on the top of the stack to numerical +% ordinal (e.g., "11th") form. +FUNCTION {convert.edition} +{ duplicate$ empty$ 'skip$ + { duplicate$ #1 #1 substring$ is.num + { extract.num + num.to.ordinal + } + { word.to.num + duplicate$ #1 #1 substring$ is.num + { num.to.ordinal } + { "edition ordinal word " quote$ * edition * quote$ * + " may be too high (or improper) for conversion" * " in " * cite$ * warning$ + } + if$ + } + if$ + } + if$ +} + + + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% LATEX BIBLIOGRAPHY CODE %% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +FUNCTION {start.entry} +{ newline$ + "\bibitem{" write$ + cite$ write$ + "}" write$ + newline$ + "" + initialize.prev.this.status +} + +% Here we write out all the LaTeX code that we will need. The most involved +% code sequences are those that control the alternate interword spacing and +% foreign language hyphenation patterns. The heavy use of \providecommand +% gives users a way to override the defaults. Special thanks to Javier Bezos, +% Johannes Braams, Robin Fairbairns, Heiko Oberdiek, Donald Arseneau and all +% the other gurus on comp.text.tex for their help and advice on the topic of +% \selectlanguage, Babel and BibTeX. +FUNCTION {begin.bib} +{ "% Generated by IEEEtran.bst, version: " bst.file.version * " (" * bst.file.date * ")" * + write$ newline$ + preamble$ empty$ 'skip$ + { preamble$ write$ newline$ } + if$ + "\begin{thebibliography}{" longest.label * "}" * + write$ newline$ + "\providecommand{\url}[1]{#1}" + write$ newline$ + "\csname url@samestyle\endcsname" + write$ newline$ + "\providecommand{\newblock}{\relax}" + write$ newline$ + "\providecommand{\bibinfo}[2]{#2}" + write$ newline$ + "\providecommand{\BIBentrySTDinterwordspacing}{\spaceskip=0pt\relax}" + write$ newline$ + "\providecommand{\BIBentryALTinterwordstretchfactor}{" + ALTinterwordstretchfactor * "}" * + write$ newline$ + "\providecommand{\BIBentryALTinterwordspacing}{\spaceskip=\fontdimen2\font plus " + write$ newline$ + "\BIBentryALTinterwordstretchfactor\fontdimen3\font minus \fontdimen4\font\relax}" + write$ newline$ + "\providecommand{\BIBforeignlanguage}[2]{{%" + write$ newline$ + "\expandafter\ifx\csname l@#1\endcsname\relax" + write$ newline$ + "\typeout{** WARNING: IEEEtran.bst: No hyphenation pattern has been}%" + write$ newline$ + "\typeout{** loaded for the language `#1'. Using the pattern for}%" + write$ newline$ + "\typeout{** the default language instead.}%" + write$ newline$ + "\else" + write$ newline$ + "\language=\csname l@#1\endcsname" + write$ newline$ + "\fi" + write$ newline$ + "#2}}" + write$ newline$ + "\providecommand{\BIBdecl}{\relax}" + write$ newline$ + "\BIBdecl" + write$ newline$ +} + +FUNCTION {end.bib} +{ newline$ "\end{thebibliography}" write$ newline$ } + +FUNCTION {if.url.alt.interword.spacing} +{ is.use.alt.interword.spacing + {url empty$ 'skip$ {"\BIBentryALTinterwordspacing" write$ newline$} if$} + { skip$ } + if$ +} + +FUNCTION {if.url.std.interword.spacing} +{ is.use.alt.interword.spacing + {url empty$ 'skip$ {"\BIBentrySTDinterwordspacing" write$ newline$} if$} + { skip$ } + if$ +} + + + + +%%%%%%%%%%%%%%%%%%%%%%%% +%% LONGEST LABEL PASS %% +%%%%%%%%%%%%%%%%%%%%%%%% + +FUNCTION {initialize.longest.label} +{ "" 'longest.label := + #1 'number.label := + #0 'longest.label.width := +} + +FUNCTION {longest.label.pass} +{ type$ "ieeetranbstctl" = + { skip$ } + { number.label int.to.str$ 'label := + number.label #1 + 'number.label := + label width$ longest.label.width > + { label 'longest.label := + label width$ 'longest.label.width := + } + { skip$ } + if$ + } + if$ +} + + + + +%%%%%%%%%%%%%%%%%%%%% +%% FORMAT HANDLERS %% +%%%%%%%%%%%%%%%%%%%%% + +%% Lower Level Formats (used by higher level formats) + +FUNCTION {format.address.org.or.pub.date} +{ 't := + "" + year empty$ + { "empty year in " cite$ * warning$ } + { skip$ } + if$ + address empty$ t empty$ and + year empty$ and month empty$ and + { skip$ } + { this.to.prev.status + this.status.std + cap.status.std + address "address" bibinfo.check * + t empty$ + { skip$ } + { punct.period 'prev.status.punct := + space.large 'prev.status.space := + address empty$ + { skip$ } + { ": " * } + if$ + t * + } + if$ + year empty$ month empty$ and + { skip$ } + { t empty$ address empty$ and + { skip$ } + { ", " * } + if$ + month empty$ + { year empty$ + { skip$ } + { year "year" bibinfo.check * } + if$ + } + { month "month" bibinfo.check * + year empty$ + { skip$ } + { " " * year "year" bibinfo.check * } + if$ + } + if$ + } + if$ + } + if$ +} + + +FUNCTION {format.names} +{ 'bibinfo := + duplicate$ empty$ 'skip$ { + this.to.prev.status + this.status.std + 's := + "" 't := + #1 'nameptr := + s num.names$ 'numnames := + numnames 'namesleft := + { namesleft #0 > } + { s nameptr + name.format.string + format.name$ + bibinfo bibinfo.check + 't := + nameptr #1 > + { nameptr num.names.shown.with.forced.et.al #1 + = + numnames max.num.names.before.forced.et.al > + is.forced.et.al and and + { "others" 't := + #1 'namesleft := + } + { skip$ } + if$ + namesleft #1 > + { ", " * t do.name.latex.cmd * } + { s nameptr "{ll}" format.name$ duplicate$ "others" = + { 't := } + { pop$ } + if$ + t "others" = + { " " * bbl.etal emphasize * } + { numnames #2 > + { "," * } + { skip$ } + if$ + bbl.and + space.word * t do.name.latex.cmd * + } + if$ + } + if$ + } + { t do.name.latex.cmd } + if$ + nameptr #1 + 'nameptr := + namesleft #1 - 'namesleft := + } + while$ + cap.status.std + } if$ +} + + + + +%% Higher Level Formats + +%% addresses/locations + +FUNCTION {format.address} +{ address duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + cap.status.std + } + if$ +} + + + +%% author/editor names + +FUNCTION {format.authors}{ author "author" format.names } + +FUNCTION {format.editors} +{ editor "editor" format.names duplicate$ empty$ 'skip$ + { ", " * + get.bbl.editor + capitalize + * + } + if$ +} + + + +%% date + +FUNCTION {format.date} +{ + month "month" bibinfo.check duplicate$ empty$ + year "year" bibinfo.check duplicate$ empty$ + { swap$ 'skip$ + { this.to.prev.status + this.status.std + cap.status.std + "there's a month but no year in " cite$ * warning$ } + if$ + * + } + { this.to.prev.status + this.status.std + cap.status.std + swap$ 'skip$ + { + swap$ + " " * swap$ + } + if$ + * + } + if$ +} + +FUNCTION {format.date.electronic} +{ month "month" bibinfo.check duplicate$ empty$ + year "year" bibinfo.check duplicate$ empty$ + { swap$ + { pop$ } + { "there's a month but no year in " cite$ * warning$ + pop$ ")" * "(" swap$ * + this.to.prev.status + punct.no 'this.status.punct := + space.normal 'this.status.space := + quote.no 'this.status.quote := + cap.yes 'status.cap := + } + if$ + } + { swap$ + { swap$ pop$ ")" * "(" swap$ * } + { "(" swap$ * ", " * swap$ * ")" * } + if$ + this.to.prev.status + punct.no 'this.status.punct := + space.normal 'this.status.space := + quote.no 'this.status.quote := + cap.yes 'status.cap := + } + if$ +} + + + +%% edition/title + +% Note: IEEE considers the edition to be closely associated with +% the title of a book. So, in IEEEtran.bst the edition is normally handled +% within the formatting of the title. The format.edition function is +% retained here for possible future use. +FUNCTION {format.edition} +{ edition duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + convert.edition + status.cap + { "t" } + { "l" } + if$ change.case$ + "edition" bibinfo.check + "~" * bbl.edition * + cap.status.std + } + if$ +} + +% This is used to format the booktitle of a conference proceedings. +% Here we use the "intype" field to provide the user a way to +% override the word "in" (e.g., with things like "presented at") +% Use of intype stops the emphasis of the booktitle to indicate that +% we no longer mean the written conference proceedings, but the +% conference itself. +FUNCTION {format.in.booktitle} +{ booktitle "booktitle" bibinfo.check duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + select.language + intype missing$ + { emphasize + bbl.in " " * + } + { intype " " * } + if$ + swap$ * + cap.status.std + } + if$ +} + +% This is used to format the booktitle of collection. +% Here the "intype" field is not supported, but "edition" is. +FUNCTION {format.in.booktitle.edition} +{ booktitle "booktitle" bibinfo.check duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + select.language + emphasize + edition empty$ 'skip$ + { ", " * + edition + convert.edition + "l" change.case$ + * "~" * bbl.edition * + } + if$ + bbl.in " " * swap$ * + cap.status.std + } + if$ +} + +FUNCTION {format.article.title} +{ title duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + "t" change.case$ + } + if$ + "title" bibinfo.check + duplicate$ empty$ 'skip$ + { quote.close 'this.status.quote := + is.last.char.not.punct + { punct.std 'this.status.punct := } + { punct.no 'this.status.punct := } + if$ + select.language + "``" swap$ * + cap.status.std + } + if$ +} + +FUNCTION {format.article.title.electronic} +{ title duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + cap.status.std + "t" change.case$ + } + if$ + "title" bibinfo.check + duplicate$ empty$ + { skip$ } + { select.language } + if$ +} + +FUNCTION {format.book.title.edition} +{ title "title" bibinfo.check + duplicate$ empty$ + { "empty title in " cite$ * warning$ } + { this.to.prev.status + this.status.std + select.language + emphasize + edition empty$ 'skip$ + { ", " * + edition + convert.edition + status.cap + { "t" } + { "l" } + if$ + change.case$ + * "~" * bbl.edition * + } + if$ + cap.status.std + } + if$ +} + +FUNCTION {format.book.title} +{ title "title" bibinfo.check + duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + cap.status.std + select.language + emphasize + } + if$ +} + + + +%% journal + +FUNCTION {format.journal} +{ journal duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + cap.status.std + select.language + emphasize + } + if$ +} + + + +%% how published + +FUNCTION {format.howpublished} +{ howpublished duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + cap.status.std + } + if$ +} + + + +%% institutions/organization/publishers/school + +FUNCTION {format.institution} +{ institution duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + cap.status.std + } + if$ +} + +FUNCTION {format.organization} +{ organization duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + cap.status.std + } + if$ +} + +FUNCTION {format.address.publisher.date} +{ publisher "publisher" bibinfo.warn format.address.org.or.pub.date } + +FUNCTION {format.address.publisher.date.nowarn} +{ publisher "publisher" bibinfo.check format.address.org.or.pub.date } + +FUNCTION {format.address.organization.date} +{ organization "organization" bibinfo.check format.address.org.or.pub.date } + +FUNCTION {format.school} +{ school duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + cap.status.std + } + if$ +} + + + +%% volume/number/series/chapter/pages + +FUNCTION {format.volume} +{ volume empty.field.to.null.string + duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + bbl.volume + status.cap + { capitalize } + { skip$ } + if$ + swap$ tie.or.space.prefix + "volume" bibinfo.check + * * + cap.status.std + } + if$ +} + +FUNCTION {format.number} +{ number empty.field.to.null.string + duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + status.cap + { bbl.number capitalize } + { bbl.number } + if$ + swap$ tie.or.space.prefix + "number" bibinfo.check + * * + cap.status.std + } + if$ +} + +FUNCTION {format.number.if.use.for.article} +{ is.use.number.for.article + { format.number } + { "" } + if$ +} + +% IEEE does not seem to tie the series so closely with the volume +% and number as is done in other bibliography styles. Instead the +% series is treated somewhat like an extension of the title. +FUNCTION {format.series} +{ series empty$ + { "" } + { this.to.prev.status + this.status.std + bbl.series " " * + series "series" bibinfo.check * + cap.status.std + } + if$ +} + + +FUNCTION {format.chapter} +{ chapter empty$ + { "" } + { this.to.prev.status + this.status.std + type empty$ + { bbl.chapter } + { type "l" change.case$ + "type" bibinfo.check + } + if$ + chapter tie.or.space.prefix + "chapter" bibinfo.check + * * + cap.status.std + } + if$ +} + + +% The intended use of format.paper is for paper numbers of inproceedings. +% The paper type can be overridden via the type field. +% We allow the type to be displayed even if the paper number is absent +% for things like "postdeadline paper" +FUNCTION {format.paper} +{ is.use.paper + { paper empty$ + { type empty$ + { "" } + { this.to.prev.status + this.status.std + type "type" bibinfo.check + cap.status.std + } + if$ + } + { this.to.prev.status + this.status.std + type empty$ + { bbl.paper } + { type "type" bibinfo.check } + if$ + " " * paper + "paper" bibinfo.check + * + cap.status.std + } + if$ + } + { "" } + if$ +} + + +FUNCTION {format.pages} +{ pages duplicate$ empty$ 'skip$ + { this.to.prev.status + this.status.std + duplicate$ is.multiple.pages + { + bbl.pages swap$ + n.dashify + } + { + bbl.page swap$ + } + if$ + tie.or.space.prefix + "pages" bibinfo.check + * * + cap.status.std + } + if$ +} + + + +%% technical report number + +FUNCTION {format.tech.report.number} +{ number "number" bibinfo.check + this.to.prev.status + this.status.std + cap.status.std + type duplicate$ empty$ + { pop$ + bbl.techrep + } + { skip$ } + if$ + "type" bibinfo.check + swap$ duplicate$ empty$ + { pop$ } + { tie.or.space.prefix * * } + if$ +} + + + +%% note + +FUNCTION {format.note} +{ note empty$ + { "" } + { this.to.prev.status + this.status.std + punct.period 'this.status.punct := + note #1 #1 substring$ + duplicate$ "{" = + { skip$ } + { status.cap + { "u" } + { "l" } + if$ + change.case$ + } + if$ + note #2 global.max$ substring$ * "note" bibinfo.check + cap.yes 'status.cap := + } + if$ +} + + + +%% patent + +FUNCTION {format.patent.date} +{ this.to.prev.status + this.status.std + year empty$ + { monthfiled duplicate$ empty$ + { "monthfiled" bibinfo.check pop$ "" } + { "monthfiled" bibinfo.check } + if$ + dayfiled duplicate$ empty$ + { "dayfiled" bibinfo.check pop$ "" * } + { "dayfiled" bibinfo.check + monthfiled empty$ + { "dayfiled without a monthfiled in " cite$ * warning$ + * + } + { " " swap$ * * } + if$ + } + if$ + yearfiled empty$ + { "no year or yearfiled in " cite$ * warning$ } + { yearfiled "yearfiled" bibinfo.check + swap$ + duplicate$ empty$ + { pop$ } + { ", " * swap$ * } + if$ + } + if$ + } + { month duplicate$ empty$ + { "month" bibinfo.check pop$ "" } + { "month" bibinfo.check } + if$ + day duplicate$ empty$ + { "day" bibinfo.check pop$ "" * } + { "day" bibinfo.check + month empty$ + { "day without a month in " cite$ * warning$ + * + } + { " " swap$ * * } + if$ + } + if$ + year "year" bibinfo.check + swap$ + duplicate$ empty$ + { pop$ } + { ", " * swap$ * } + if$ + } + if$ + cap.status.std +} + +FUNCTION {format.patent.nationality.type.number} +{ this.to.prev.status + this.status.std + nationality duplicate$ empty$ + { "nationality" bibinfo.warn pop$ "" } + { "nationality" bibinfo.check + duplicate$ "l" change.case$ "united states" = + { pop$ bbl.patentUS } + { skip$ } + if$ + " " * + } + if$ + type empty$ + { bbl.patent "type" bibinfo.check } + { type "type" bibinfo.check } + if$ + * + number duplicate$ empty$ + { "number" bibinfo.warn pop$ } + { "number" bibinfo.check + large.number.separate + swap$ " " * swap$ * + } + if$ + cap.status.std +} + + + +%% standard + +FUNCTION {format.organization.institution.standard.type.number} +{ this.to.prev.status + this.status.std + organization duplicate$ empty$ + { pop$ + institution duplicate$ empty$ + { "institution" bibinfo.warn } + { "institution" bibinfo.warn " " * } + if$ + } + { "organization" bibinfo.warn " " * } + if$ + type empty$ + { bbl.standard "type" bibinfo.check } + { type "type" bibinfo.check } + if$ + * + number duplicate$ empty$ + { "number" bibinfo.check pop$ } + { "number" bibinfo.check + large.number.separate + swap$ " " * swap$ * + } + if$ + cap.status.std +} + +FUNCTION {format.revision} +{ revision empty$ + { "" } + { this.to.prev.status + this.status.std + bbl.revision + revision tie.or.space.prefix + "revision" bibinfo.check + * * + cap.status.std + } + if$ +} + + +%% thesis + +FUNCTION {format.master.thesis.type} +{ this.to.prev.status + this.status.std + type empty$ + { + bbl.mthesis + } + { + type "type" bibinfo.check + } + if$ +cap.status.std +} + +FUNCTION {format.phd.thesis.type} +{ this.to.prev.status + this.status.std + type empty$ + { + bbl.phdthesis + } + { + type "type" bibinfo.check + } + if$ +cap.status.std +} + + + +%% URL + +FUNCTION {format.url} +{ url empty$ + { "" } + { this.to.prev.status + this.status.std + cap.yes 'status.cap := + name.url.prefix " " * + "\url{" * url * "}" * + punct.no 'this.status.punct := + punct.period 'prev.status.punct := + space.normal 'this.status.space := + space.normal 'prev.status.space := + quote.no 'this.status.quote := + } + if$ +} + + + + +%%%%%%%%%%%%%%%%%%%% +%% ENTRY HANDLERS %% +%%%%%%%%%%%%%%%%%%%% + + +% Note: In many journals, IEEE (or the authors) tend not to show the number +% for articles, so the display of the number is controlled here by the +% switch "is.use.number.for.article" +FUNCTION {article} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors "author" output.warn + name.or.dash + format.article.title "title" output.warn + format.journal "journal" bibinfo.check "journal" output.warn + format.volume output + format.number.if.use.for.article output + format.pages output + format.date "year" output.warn + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {book} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + author empty$ + { format.editors "author and editor" output.warn } + { format.authors output.nonnull } + if$ + name.or.dash + format.book.title.edition output + format.series output + author empty$ + { skip$ } + { format.editors output } + if$ + format.address.publisher.date output + format.volume output + format.number output + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {booklet} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors output + name.or.dash + format.article.title "title" output.warn + format.howpublished "howpublished" bibinfo.check output + format.organization "organization" bibinfo.check output + format.address "address" bibinfo.check output + format.date output + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {electronic} +{ std.status.using.period + start.entry + if.url.alt.interword.spacing + format.authors output + name.or.dash + format.date.electronic output + format.article.title.electronic output + format.howpublished "howpublished" bibinfo.check output + format.organization "organization" bibinfo.check output + format.address "address" bibinfo.check output + format.note output + format.url output + fin.entry + empty.entry.warn + if.url.std.interword.spacing +} + +FUNCTION {inbook} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + author empty$ + { format.editors "author and editor" output.warn } + { format.authors output.nonnull } + if$ + name.or.dash + format.book.title.edition output + format.series output + format.address.publisher.date output + format.volume output + format.number output + format.chapter output + format.pages output + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {incollection} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors "author" output.warn + name.or.dash + format.article.title "title" output.warn + format.in.booktitle.edition "booktitle" output.warn + format.series output + format.editors output + format.address.publisher.date.nowarn output + format.volume output + format.number output + format.chapter output + format.pages output + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {inproceedings} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors "author" output.warn + name.or.dash + format.article.title "title" output.warn + format.in.booktitle "booktitle" output.warn + format.series output + format.editors output + format.volume output + format.number output + publisher empty$ + { format.address.organization.date output } + { format.organization "organization" bibinfo.check output + format.address.publisher.date output + } + if$ + format.paper output + format.pages output + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {manual} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors output + name.or.dash + format.book.title.edition "title" output.warn + format.howpublished "howpublished" bibinfo.check output + format.organization "organization" bibinfo.check output + format.address "address" bibinfo.check output + format.date output + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {mastersthesis} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors "author" output.warn + name.or.dash + format.article.title "title" output.warn + format.master.thesis.type output.nonnull + format.school "school" bibinfo.warn output + format.address "address" bibinfo.check output + format.date "year" output.warn + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {misc} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors output + name.or.dash + format.article.title output + format.howpublished "howpublished" bibinfo.check output + format.organization "organization" bibinfo.check output + format.address "address" bibinfo.check output + format.pages output + format.date output + format.note output + format.url output + fin.entry + empty.entry.warn + if.url.std.interword.spacing +} + +FUNCTION {patent} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors output + name.or.dash + format.article.title output + format.patent.nationality.type.number output + format.patent.date output + format.note output + format.url output + fin.entry + empty.entry.warn + if.url.std.interword.spacing +} + +FUNCTION {periodical} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.editors output + name.or.dash + format.book.title "title" output.warn + format.series output + format.volume output + format.number output + format.organization "organization" bibinfo.check output + format.date "year" output.warn + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {phdthesis} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors "author" output.warn + name.or.dash + format.article.title "title" output.warn + format.phd.thesis.type output.nonnull + format.school "school" bibinfo.warn output + format.address "address" bibinfo.check output + format.date "year" output.warn + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {proceedings} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.editors output + name.or.dash + format.book.title "title" output.warn + format.series output + format.volume output + format.number output + publisher empty$ + { format.address.organization.date output } + { format.organization "organization" bibinfo.check output + format.address.publisher.date output + } + if$ + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {standard} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors output + name.or.dash + format.book.title "title" output.warn + format.howpublished "howpublished" bibinfo.check output + format.organization.institution.standard.type.number output + format.revision output + format.date output + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {techreport} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors "author" output.warn + name.or.dash + format.article.title "title" output.warn + format.howpublished "howpublished" bibinfo.check output + format.institution "institution" bibinfo.warn output + format.address "address" bibinfo.check output + format.tech.report.number output.nonnull + format.date "year" output.warn + format.note output + format.url output + fin.entry + if.url.std.interword.spacing +} + +FUNCTION {unpublished} +{ std.status.using.comma + start.entry + if.url.alt.interword.spacing + format.authors "author" output.warn + name.or.dash + format.article.title "title" output.warn + format.date output + format.note "note" output.warn + format.url output + fin.entry + if.url.std.interword.spacing +} + + +% The special entry type which provides the user interface to the +% BST controls +FUNCTION {IEEEtranBSTCTL} +{ is.print.banners.to.terminal + { "** IEEEtran BST control entry " quote$ * cite$ * quote$ * " detected." * + top$ + } + { skip$ } + if$ + CTLuse_article_number + empty$ + { skip$ } + { CTLuse_article_number + yes.no.to.int + 'is.use.number.for.article := + } + if$ + CTLuse_paper + empty$ + { skip$ } + { CTLuse_paper + yes.no.to.int + 'is.use.paper := + } + if$ + CTLuse_forced_etal + empty$ + { skip$ } + { CTLuse_forced_etal + yes.no.to.int + 'is.forced.et.al := + } + if$ + CTLmax_names_forced_etal + empty$ + { skip$ } + { CTLmax_names_forced_etal + string.to.integer + 'max.num.names.before.forced.et.al := + } + if$ + CTLnames_show_etal + empty$ + { skip$ } + { CTLnames_show_etal + string.to.integer + 'num.names.shown.with.forced.et.al := + } + if$ + CTLuse_alt_spacing + empty$ + { skip$ } + { CTLuse_alt_spacing + yes.no.to.int + 'is.use.alt.interword.spacing := + } + if$ + CTLalt_stretch_factor + empty$ + { skip$ } + { CTLalt_stretch_factor + 'ALTinterwordstretchfactor := + "\renewcommand{\BIBentryALTinterwordstretchfactor}{" + ALTinterwordstretchfactor * "}" * + write$ newline$ + } + if$ + CTLdash_repeated_names + empty$ + { skip$ } + { CTLdash_repeated_names + yes.no.to.int + 'is.dash.repeated.names := + } + if$ + CTLname_format_string + empty$ + { skip$ } + { CTLname_format_string + 'name.format.string := + } + if$ + CTLname_latex_cmd + empty$ + { skip$ } + { CTLname_latex_cmd + 'name.latex.cmd := + } + if$ + CTLname_url_prefix + missing$ + { skip$ } + { CTLname_url_prefix + 'name.url.prefix := + } + if$ + + + num.names.shown.with.forced.et.al max.num.names.before.forced.et.al > + { "CTLnames_show_etal cannot be greater than CTLmax_names_forced_etal in " cite$ * warning$ + max.num.names.before.forced.et.al 'num.names.shown.with.forced.et.al := + } + { skip$ } + if$ +} + + +%%%%%%%%%%%%%%%%%%% +%% ENTRY ALIASES %% +%%%%%%%%%%%%%%%%%%% +FUNCTION {conference}{inproceedings} +FUNCTION {online}{electronic} +FUNCTION {internet}{electronic} +FUNCTION {webpage}{electronic} +FUNCTION {www}{electronic} +FUNCTION {default.type}{misc} + + + +%%%%%%%%%%%%%%%%%% +%% MAIN PROGRAM %% +%%%%%%%%%%%%%%%%%% + +READ + +EXECUTE {initialize.controls} +EXECUTE {initialize.status.constants} +EXECUTE {banner.message} + +EXECUTE {initialize.longest.label} +ITERATE {longest.label.pass} + +EXECUTE {begin.bib} +ITERATE {call.type$} +EXECUTE {end.bib} + +EXECUTE{completed.message} + + +%% That's all folks, mds.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/SMC15/smc2015.sty Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,280 @@ +% Latex Paper Template for SMC 2015 +% slightly adapted version of the templates for SMC 2011, SMC 2010 and ISMIR 2009 +% +% Version 20111229 +% Adapded for Sound And Music computing conference +% The bibliography style is now the most recent IEEEtran.bst + +\def\Hline{\noalign{\hrule height 0.4mm}} +%\newcommand{\bm}[1]{\mbox{\boldmath{$#1$}}} +\newcommand{\figbox}[1]{\fbox{\parbox{\columnwidth}{\centering{ #1 }}}} +\newcommand{\range}[2]{{#1,\cdots,#2\;}} +\newcommand{\secref}[1]{\mbox{Section~\ref{#1}}} +\newcommand{\tabref}[1]{\mbox{Table~\ref{#1}}} +\newcommand{\figref}[1]{\mbox{Figure~\ref{#1}}} +\newcommand{\eqnref}[1]{\mbox{Eq.~(\ref{#1})}} + +\renewcommand{\sfdefault}{phv} +\renewcommand{\rmdefault}{ptm} +\renewcommand{\ttdefault}{pcr} + +\setlength{\paperheight}{297mm} +\setlength{\paperwidth}{210mm} +\setlength{\textheight}{252mm} +\setlength{\textwidth}{172mm} +\setlength{\columnsep}{8mm} +\setlength{\headheight}{0mm} +\setlength{\voffset}{-12mm} +\setlength{\hoffset}{0mm} +\setlength{\marginparwidth}{0mm} +\setlength{\parindent}{2mm} %1pc +\setlength{\topmargin}{-5mm} +\setlength{\oddsidemargin}{-6mm} +\setlength{\evensidemargin}{-6mm} + +\setlength\normallineskip{1\p@} +\setlength\parskip{0\p@ \@plus \p@} +%\def\baselinestretch{0.98} + +\def\normalsize{\@setsize\normalsize{12pt}\xpt\@xpt} +\def\small{\@setsize\small{10pt}\ixpt\@ixpt} +\def\footnotesize{\@setsize\footnotesize{8pt}\viiipt\@viiipt} +\def\scriptsize{\@setsize\scriptsize{8pt}\viipt\@viipt} +\def\tiny{\@setsize\tiny{7pt}\vipt\@vipt} +\def\large{\@setsize\large{14pt}\xiipt\@xiipt} +\def\Large{\@setsize\Large{16pt}\xivpt\@xivpt} +\def\LARGE{\@setsize\LARGE{20pt}\xviipt\@xviipt} +\def\huge{\@setsize\huge{23pt}\xxpt\@xxpt} +\def\Huge{\@setsize\Huge{28pt}\xxvpt\@xxvpt} + +\twocolumn +\pagestyle{empty} + +\def\maketitle{\par + \begingroup + \def\thefootnote{} + \def\@makefnmark{ + \hbox + {$^{\@thefnmark}$\hss} + } + \twocolumn[\@maketitle] + \permission + \@thanks + \endgroup + \setcounter{footnote}{0} + \let\maketitle\relax + \let\@maketitle\relax + \gdef\thefootnote{ + \arabic{footnote} + } + \gdef\@@savethanks{} + \gdef\@thanks{} + \gdef\@author{} + \gdef\@title{} + \let\thanks\relax +} + +\def\@maketitle{ + \newpage + \null + \begin{center} { + \Large \bf \@title \par + } + \vskip 2.0em { + \normalsize \lineskip .5em + \begin{tabular}[t]{c} + \@author \\ + \end{tabular} + \par + } + \end{center} + \par + \vskip 2.0em +} + +\newcommand{\permission}{ +\begin{figure}[b] +{\scriptsize{\it Copyright: \copyright 2015 \firstauthor \hspace*{1 pt} et al. This is an open-access article distributed under the terms of the \href{http://creativecommons.org/licenses/by/3.0/}{\textcolor {magenta} {\underline {Creative Commons Attribution 3.0 Unported License}}}, which permits unrestricted use, distribution, and reproduction in any medium, provided the original author and source are credited.}} +%{\copyright~Copyright notice here} +\end{figure}} + +\def\oneauthor#1#2{ + \gdef\@author{ + \begin{tabular}{@{}c@{}} + {\bf #1} \\ + #2\relax + \end{tabular}\hskip .3in + } +} + +\def\twoauthors#1#2#3#4{ + \gdef\@author{ + \begin{tabular}{@{}c@{}} + {\bf #1} \\ + #2 + \end{tabular}\hskip 1.5in + \begin{tabular}{@{}c@{}} + {\bf #3} \\ + #4\relax + \end{tabular} + } +} + +\def\threeauthors#1#2#3#4#5#6{ + \gdef\@author{ + \begin{tabular}{@{}c@{}} + {\bf #1} \\ + #2 + \end{tabular}\hskip .3in + \begin{tabular}{@{}c@{}} + {\bf #3} \\ + #4 + \end{tabular}\hskip .3in + \begin{tabular}{@{}c@{}} + {\bf #5} \\ + #6\relax + \end{tabular} + } +} + +\def\fourauthors#1#2#3#4#5#6#7#8{ + \gdef\@author{ + \begin{tabular}{@{}c@{}} + {\bf #1} \\ + #2 + \end{tabular}\hskip .2in + \begin{tabular}{@{}c@{}} + {\bf #3} \\ + #4 + \end{tabular}\hskip .2in + \begin{tabular}{@{}c@{}} + {\bf #5} \\ + #6\relax + \end{tabular}\hskip .2in + \begin{tabular}{@{}c@{}} + {\bf #7} \\ + #8\relax + \end{tabular}\\ + Centre for Digital Music, Queen Mary University of London + } +} + +\def\abstract{ + \begin{center}{ + \bf ABSTRACT + } + \end{center} +} +\def\endabstract{\par} + +\def\title#1{\gdef\@title{\uppercase{#1}}} + +\newif\if@smcsection + +\renewcommand\section{ + \@smcsectiontrue + \@startsection + {section} + {1} + {\z@} + {-3.5ex \@plus -1ex \@minus -.2ex} + {6pt \@plus.2ex} + {\large\bf\centering} +} + +\renewcommand\subsection{ + \@smcsectionfalse + \@startsection + {subsection} + {2} + {\z@} + {-2.5ex \@plus -1ex \@minus -.2ex} + {6pt \@plus.2ex} + {\normalsize\bf\raggedright} +} + +\renewcommand\subsubsection{ + \@smcsectionfalse + \@startsection + {subsubsection} + {3} + {\z@} + {-1.5ex \@plus -1ex \@minus -.2ex} + {6pt \@plus.2ex} + {\normalsize\it\raggedright} +} + +\def\@sect#1#2#3#4#5#6[#7]#8{ + \refstepcounter{#1} + \if@smcsection + \edef\@svsec{\csname the#1\endcsname.\hskip 0.6em} + \else + \edef\@svsec{\csname the#1\endcsname\hskip 0.6em} + \fi + \begingroup + \ifnum #2=1 + \bf\centering{\interlinepenalty \@M \@svsec\uppercase{#8}\par} + \else + \ifnum #2=2 + \bf\raggedright + \noindent{\interlinepenalty \@M \@svsec #8\par} + \else + \it\raggedright + \noindent{\interlinepenalty \@M \@svsec #8\par} + \fi + \fi + \endgroup + \csname #1mark\endcsname{#7}\addcontentsline + {toc}{#1}{\protect\numberline + \if@smcsection + {\csname the#1\endcsname.} + \else + {\csname the#1\endcsname} + \fi + #7} + \@tempskipa #5\relax + \@xsect{\@tempskipa} +} + +\newenvironment{acknowledgments}% +{% +\vskip 2.5ex {\normalsize\bf\raggedright Acknowledgments} +\vspace*{6pt} \\ +\noindent +}% +{% +\par +} + + +\bibliographystyle{IEEEtran} + +\def\thebibliography#1{ + \section{References}\list + {[\arabic{enumi}]}{ + \settowidth\labelwidth{[#1]}\leftmargin 1em + \advance\leftmargin\labelsep + \usecounter{enumi} + } + \def\newblock{\hskip .01em plus .01em minus .01em} + \sloppy\clubpenalty4000\widowpenalty4000 + \sfcode`\.=1000\relax +} + +\let\endthebibliography=\endlist + +\long\def\@makecaption#1#2{ + \vskip 10pt + \setbox\@tempboxa\hbox{#1. #2} + \ifdim + \wd\@tempboxa >\hsize #1. #2\par + \else + \hbox + to\hsize{\hfil\box\@tempboxa\hfil} + \fi +} + +\def\fnum@figure{{\bf Figure\ \thefigure}} +\def\fnum@table{{\bf Table \thetable}} + +\flushbottom
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/SMC15/smc2015template.bbl Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,39 @@ +% Generated by IEEEtran.bst, version: 1.12 (2007/01/11) +\begin{thebibliography}{1} +\providecommand{\url}[1]{#1} +\csname url@samestyle\endcsname +\providecommand{\newblock}{\relax} +\providecommand{\bibinfo}[2]{#2} +\providecommand{\BIBentrySTDinterwordspacing}{\spaceskip=0pt\relax} +\providecommand{\BIBentryALTinterwordstretchfactor}{4} +\providecommand{\BIBentryALTinterwordspacing}{\spaceskip=\fontdimen2\font plus +\BIBentryALTinterwordstretchfactor\fontdimen3\font minus + \fontdimen4\font\relax} +\providecommand{\BIBforeignlanguage}[2]{{% +\expandafter\ifx\csname l@#1\endcsname\relax +\typeout{** WARNING: IEEEtran.bst: No hyphenation pattern has been}% +\typeout{** loaded for the language `#1'. Using the pattern for}% +\typeout{** the default language instead.}% +\else +\language=\csname l@#1\endcsname +\fi +#2}} +\providecommand{\BIBdecl}{\relax} +\BIBdecl + +\bibitem{bech} +S.~Bech and N.~Zacharov, \emph{Perceptual Audio Evaluation - Theory, Method and + Application}.\hskip 1em plus 0.5em minus 0.4em\relax John Wiley \& Sons, + 2007. + +\bibitem{deman2014b} +B.~De~Man and J.~D. Reiss, ``{APE}: {A}udio {P}erceptual {E}valuation toolbox + for {MATLAB},'' in \emph{136th Convention of the Audio Engineering Society}, + April 2014. + +\bibitem{mushra} +\emph{Method for the subjective assessment of intermediate quality level of + coding systems}.\hskip 1em plus 0.5em minus 0.4em\relax Recommendation {ITU-R + BS.1534-1}, 2003. + +\end{thebibliography}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/SMC15/smc2015template.bib Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,28 @@ +%% This BibTeX bibliography file was created using BibDesk. +%% http://bibdesk.sourceforge.net/ + +%% Created for Brecht De Man at 2015-04-20 18:22:49 +0100 + + +%% Saved with string encoding Unicode (UTF-8) + + + +@book{bech, + Author = {Bech, S. and Zacharov, N.}, + Publisher = {John Wiley \& Sons}, + Title = {Perceptual Audio Evaluation - Theory, Method and Application}, + Year = {2007}} + +@book{mushra, + Keywords = {standard}, + Publisher = {Recommendation {ITU-R BS.1534-1}}, + Title = {Method for the subjective assessment of intermediate quality level of coding systems}, + Year = {2003}} + +@conference{deman2014b, + Author = {De Man, Brecht and Joshua D. Reiss}, + Booktitle = {136th Convention of the Audio Engineering Society}, + Month = {April}, + Title = {{APE}: {A}udio {P}erceptual {E}valuation toolbox for {MATLAB}}, + Year = {2014}}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/SMC15/smc2015template.tex Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,351 @@ +% ----------------------------------------------- +% Template for SMC 2012 +% adapted from the template for SMC 2011, which was adapted from that of SMC 2010 +% ----------------------------------------------- + +\documentclass{article} +\usepackage{smc2015} +\usepackage{times} +\usepackage{ifpdf} +\usepackage[english]{babel} +\usepackage{cite} + +\hyphenation{Java-script} + +%%%%%%%%%%%%%%%%%%%%%%%% Some useful packages %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%%%%%%%%%%%%%%%%%%%%%%% See related documentation %%%%%%%%%%%%%%%%%%%%%%%%%% +%\usepackage{amsmath} % popular packages from Am. Math. Soc. Please use the +%\usepackage{amssymb} % related math environments (split, subequation, cases, +%\usepackage{amsfonts}% multline, etc.) +%\usepackage{bm} % Bold Math package, defines the command \bf{} +%\usepackage{paralist}% extended list environments +%%subfig.sty is the modern replacement for subfigure.sty. However, subfig.sty +%%requires and automatically loads caption.sty which overrides class handling +%%of captions. To prevent this problem, preload caption.sty with caption=false +%\usepackage[caption=false]{caption} +%\usepackage[font=footnotesize]{subfig} + + +%user defined variables +\def\papertitle{WEB AUDIO EVALUATION TOOL: A BROWSER-BASED LISTENING TEST ENVIRONMENT} %? +\def\firstauthor{Nicholas Jillings} +\def\secondauthor{Brecht De Man} +\def\thirdauthor{David Moffat} +\def\fourthauthor{Joshua D. Reiss} + +% adds the automatic +% Saves a lot of ouptut space in PDF... after conversion with the distiller +% Delete if you cannot get PS fonts working on your system. + +% pdf-tex settings: detect automatically if run by latex or pdflatex +\newif\ifpdf +\ifx\pdfoutput\relax +\else + \ifcase\pdfoutput + \pdffalse + \else + \pdftrue +\fi + +\ifpdf % compiling with pdflatex + \usepackage[pdftex, + pdftitle={\papertitle}, + pdfauthor={\firstauthor, \secondauthor, \thirdauthor}, + bookmarksnumbered, % use section numbers with bookmarks + pdfstartview=XYZ % start with zoom=100% instead of full screen; + % especially useful if working with a big screen :-) + ]{hyperref} + %\pdfcompresslevel=9 + + \usepackage[pdftex]{graphicx} + % declare the path(s) where your graphic files are and their extensions so + %you won't have to specify these with every instance of \includegraphics + \graphicspath{{./figures/}} + \DeclareGraphicsExtensions{.pdf,.jpeg,.png} + + \usepackage[figure,table]{hypcap} + +\else % compiling with latex + \usepackage[dvips, + bookmarksnumbered, % use section numbers with bookmarks + pdfstartview=XYZ % start with zoom=100% instead of full screen + ]{hyperref} % hyperrefs are active in the pdf file after conversion + + \usepackage[dvips]{epsfig,graphicx} + % declare the path(s) where your graphic files are and their extensions so + %you won't have to specify these with every instance of \includegraphics + \graphicspath{{./figures/}} + \DeclareGraphicsExtensions{.eps} + + \usepackage[figure,table]{hypcap} +\fi + +%setup the hyperref package - make the links black without a surrounding frame +\hypersetup{ + colorlinks,% + citecolor=black,% + filecolor=black,% + linkcolor=black,% + urlcolor=black +} + + +% Title. +% ------ +\title{\papertitle} + +% Authors +% Please note that submissions are NOT anonymous, therefore +% authors' names have to be VISIBLE in your manuscript. +% +% Single address +% To use with only one author or several with the same address +% --------------- +%\oneauthor +% {\firstauthor} {Affiliation1 \\ % +% {\tt \href{mailto:author1@smcnetwork.org}{author1@smcnetwork.org}}} + +%Two addresses +%-------------- +% \twoauthors +% {\firstauthor} {Affiliation1 \\ % +% {\tt \href{mailto:author1@smcnetwork.org}{author1@smcnetwork.org}}} +% {\secondauthor} {Affiliation2 \\ % +% {\tt \href{mailto:author2@smcnetwork.org}{author2@smcnetwork.org}}} + + + +% FIX!!! + \fourauthors + {\firstauthor} {%Affiliation1 \\ + {\tt \href{mailto:b.deman@qmul.ac.uk}{n.g.r.jillings@se14.qmul.ac.uk, }}} + {\secondauthor} {%Affiliation2\\ % + {\tt \href{mailto:n.g.r.jillings@se14.qmul.ac.uk}{\{b.deman,}}} + {\thirdauthor} {%Affiliation3\\ % + {\tt \href{mailto:d.j.moffat@qmul.ac.uk}{d.j.moffat, }}} + {\fourthauthor} {%Affiliation4\\ % + {\tt \href{mailto:joshua.reiss@qmul.ac.uk}{joshua.reiss\}@qmul.ac.uk}}} + +% ***************************************** the document starts here *************** +\begin{document} +% +\capstartfalse +\maketitle +\capstarttrue +% +\begin{abstract} +New functionality in HTML5, notably its Web Audio API, allow for increasingly powerful applications in the browser. % is this true? +Perceptual evaluation tests for audio, where the subject assesses certain qualities of different audio fragments through a graphical user interface and/or text boxes, require playback of audio and rapid switching between different files. % what else? +The advantage of a web application is easy deployment on any platform, without requiring any other application or library, easy storing of results on a server. +[...] +%Place your abstract at the top left column on the first page. +%Please write about 150-200 words that specifically highlight the purpose of your work, +%its context, and provide a brief synopsis of your results. +%Avoid equations in this part.\\ + +\end{abstract} +% + +\section{Introduction}\label{sec:introduction} + +TOTAL PAPER: Minimum 4 pages, 6 preferred, max. 8 (6 for demos/posters)\\ + +NICK: examples of what kind of audio applications HTML5 has made possible, with references to publications (or website)\\ + +background (types of research where this type of perceptual evaluation of audio is relevant)\\ + +multiple stimulus perceptual evaluation \cite{bech}\\ + +prior work: \cite{deman2014b} in MATLAB, much less easy to deploy, and often stops working due to version updates \\ + +goal, what are we trying to do? \\ + +other background papers (some SMC?)\\ + +[Previously, due to limited functionality of HTML, ..., it was not possible to design this type of interfaces with such high quality audio... ] + + +%\section{Design considerations}\label{sec:designconsiderations} % not necessary? with next (/previous) section? + +We present a browser-based perceptual evaluation tool for audio that ... \\ + +see \cite{deman2014b}: requirements informed by research on music production (see my work and that of others' in the group), such as randomisation, playback of high quality audio, some degree of flexibility in terms of configuration, ... \\ + + +\section{Implementation}\label{sec:implementation} +%[Nick???] + +%section on overall architecture\\ + +%section with overview of the structure of the input and output files, perhaps with graph or table + +The tool runs entirely inside the browser through the new HTML5 Web Audio API. The API is supported by most major web browsers (with the exception of Internet Explorer) and allows for constructing a chain of audio processing elements to produce a high quality, real time signal process to manipulate audio streams. The API supports multi-channel processing and has an accurate playback timer for precise scheduled playback control. The Web Audio API is controlled through the browser JavaScript and is therefore highly controllable. The Web Audio API processing is all controlled in a separate thread to the main JavaScript thread, meaning there is no blocking due to real time processing. + +\subsection{Interface}\label{sec:interface} %elsewhere? + +At this point, we have implemented the interface of the MATLAB-based APE Perceptual Evaluation for Audio toolbox \cite{deman2014b}, which shows one marker for each simultaneously evaluated audio fragment on one or more horizontal axes (to rate/rank the respective fragments), as well as a comment box for every marker, and one extra text box for extra comments. See \ref{fig:interface} for an example of the interface, with 10 fragments and one axis. However, the back end of this test environment allows for many more established and novel interfaces for listening tests, particularly ones where the subject only assesses audio without manipulating it (i.e. method of adjustment, which would require additional features to be implemented). + +\begin{figure*}[htbp] +\begin{center} +\includegraphics[width=0.9\textwidth]{interface.png} +\caption{Example of interface, with 1 axis and 10 fragments} +\label{fig:interface} +\end{center} +\end{figure*} + + + +\subsection{Architecture}\label{sec:architecture} + +The web tool itself is split into several files to operate: +\begin{itemize} +\item \texttt{apeTool.html}: The main index file to load the scripts, this is the file the browser must request to load. +\item \texttt{core.js}: Contains functions and objects to manage the audio control, audio objects for testing and loading of files. +\item \texttt{ape.js}: Parses setup files to create the interface as instructed, following the same style chain as the MATLAB APE Tool \cite{deman2014b}. +\end{itemize} + +The HTML file loads the \texttt{core.js} file with it along with a few other ancillary files (such as the jQuery JavaScript extensions), at which point the browser JavaScript begins to execute the on-page instructions, which gives the URL of the test setup XML document (outlined in the next section). \texttt{core.js} parses this document and executes the function in \texttt{ape.js} to build the web page with the given audio files. The reason for separating these two files is to allow for further interface designs (such as MUSHRA \cite{mushra} or A-B tests \cite{bech}) to be used, which would still require the same underlying core functions outlined in \texttt{core.js}, see also Section \ref{sec:interface}. + +The \texttt{ape.js} file has only two main functions: \textit{loadInterface(xmlDoc)} and \textit{interfaceXMLSave()}. The first function is called to build the interface once the setup document has been loaded. This includes creating the slider interface to rate the tracks, and creating the comment boxes below it. The markers on the slider at the top of the page are positioned randomly, to minimise the bias that may be introduced when the initial positions are near the beginning, end or middle of the slider. While another approach is to place the markers outside of the slider bar at first and have the subject drag them in, the authors believe this doesn't encourage careful consideration and comparison of the different fragments as the implicit goal of the test becomes to audition and drag each fragment in just once, rather than to compare all fragments rigorously. +\texttt{ape.js} also instructs the audio engine in \texttt{core.js} to create the audio objects. The audio objects are custom built audio nodes built on the Web Audio API. % 'built' twice? +They consist of a \textit{bufferSourceNode} (a node which holds a buffer of audio samples for playback) and a \textit{gainNode}. These are then connected to the \textit{audioEngine} (itself a custom web audio node) containing a \textit{gainNode} (where the various Audio Objects connect to) for summation before passing the output to the \textit{destinationNode}, a fixed node created where %through which? +the browser then passes the audio information to the system sound device. +% audio object/audioObject/Audio Object: consistency? + +When an \textit{audioObject} is created, it is given the URL of the audio sample to load. This is downloaded into the browser asynchronously using the \textit{XMLHttpRequest} object. This allows for downloading of any file into the JavaScript environment for further processing. It is particularly useful for the Web Audio API because it supports downloading of files in their binary form, allowing a perfect copy. % don't quite understand this +Once the asynchronous download is complete, the file is then decoded using the Web Audio API offline decoder. This uses the browser's %browser's? browser-available? available in the browser? + available decoding schemes to decode the audio files into raw float32 arrays, which are in turn passed to the relevant audioObject \textit{bufferSourceNode} for playback. + +% GENERAL QUESTION: would it be hard to support more file types? If so, I think it's much nicer to say 'at the moment we allow ... and ... and ... files' +Browsers support various audio file formats and are not consistent in any format. % 'not consistent in any format'? What do you mean exactly? +However, all browsers support the WAV format. Although not a compact, web friendly format, most transport systems are of a high enough bandwidth this should not be a problem. +However, one problem is that the browser uses the sample rate assigned by the system sound device, % is this problem particular to WAV? Seems that way from the text +and does not have the ability to request a different one. Therefore, the default operation when an audio file is loaded with a different sample rate to that of the system is to convert the sample rate. To provide a check for this, the desired sample rate can be supplied with the setup XML and checked against. If the sample rates do not match, a browser alert window is shown asking for the sample rate to be correctly adjusted. +As this happens before any loading or decoding of audio files, the system will only fetch files as soon as the system's sample rate meets any requirements, avoiding requests for large files until they are actually needed. + +During playback, the playback nodes loop indefinitely until playback is stopped. The gain nodes in the \textit{audioObject}s enable dynamic muting of nodes. When a bar in the sliding ranking is clicked, the audio engine mutes all \textit{audioObject}s and un-mutes the clicked one. Therefore, if the audio samples are perfectly aligned up and of the same sample length, they will remain perfectly aligned with each other. + + +\subsection{Setup and results formats}\label{sec:setupresultsformats} + +Setup and the results both use the common XML document format to outline the various parameters. The setup file contains all the information needed to initialise a test session. Several nodes can be defined to outline the audio samples to use, questions to be asked and any pre- or post-test questions or instructions. Having one document to modify allows for quick manipulation in a `human readable' form to create new tests, or adjust current ones, without needing to edit which web files. % 'which web files'? + +The results file is dynamically generated by the interface upon clicking the `Submit' button. This also executes checks, depending on the setup file, to ensure that all tracks have been played back, rated and commented on. The XML output returned contains a node per audioObject and contains both the corresponding marker's position and any comments written in the associated comment box. The rating returned is normalised to be a value between 0 and 1, normalising the pixel representation of different browser windows. + +Pre- and post-test dialog boxes allow for comments or questions to be presented before or after the test, to convey listening test instructions, and gather information about the subject, listening environment, and overall experience of the test. These are automatically generated from the setup XML and allow nearly any form of question and comment to be included in a window on its own. Questions are stored and presented in the response section labelled `pretest' and `posttest', along with the question ID and its response, and can be made mandatory. +Further options in the setup file are: + +\begin{itemize} +\item \textbf{Snap to corresponding position}: When this is enabled, and a fragment is playing, the playhead skips to the same position in the next fragment that is clicked. If it is not enabled, every fragment is played from the start. +\item \textbf{Loop fragments}: Repeat current fragment when end is reached, until the `Stop audio' or `Submit' button is clicked. +\item \textbf{Comments}: Displays a separate comment box for each fragment in the page. +\item \textbf{General comment}: One comment box, additional to the individual comment boxes, to comment on the test or a feature that some or all of the fragments share. +\item \textbf{Resampling}: When this is enabled, tracks are resampled to match the subject's system's sample rate (a default feature of the Web Audio API). When it is not, an error is shown when the system does not match the requested sample rate. +\item \textbf{Randomise page order}: Randomises the order in which different `pages' are presented. % are we calling this 'pages'? +\item \textbf{Randomise fragment order}: Randomises the order and numbering of the markers and comment boxes corresponding with the fragments. This permutation is stored as well, to be able to interpret references to the numbers in the comments (such as `this is much [brighter] then 4'). +\item \textbf{Require playback}: Require that each fragment has been played at least once, if not in full. +\item \textbf{Require full playback}: If `Require playback' is active, require that each fragment has been played in full. +\item \textbf{Require moving}: Require that each marker is moved (dragged) at least once. +\item \textbf{Require comments}: This option allows requiring the subject to require a comment for each track. +\item \textbf{Repeat test}: Number of times test should be repeated (none by default), to allow familiarisation with the content and experiment, and to investigate consistency of user and variability due to familiarity. +% explanation on how this is implemented? +\end{itemize} + +When one of these options is not included in the setup file, they assume a default value. + +% loop, snap to corresponding position, comments, 'general' comment, require same sampling rate, different types of randomisation + + + +The results will also contain information collected by any defined pre/post questions. These are referenced against the setup XML by using the same ID as well as printing in the same question, so readable responses can be obtained. Future development will also evolve to include any session data, such as the browser the tool was used in, how long the test took and any other metrics. Currently the results files are downloaded on the user side of the browser as a .xml file to be manually returned. However the end goal is to allow the XML files to be submitted over the web to a receiving server to store them, allowing for automated collection. + +Furthermore, each user action (manipulation of any interface element, such as playback or moving a marker) is logged along with a the corresponding time code and stored or sent along with the results. % right? + +%Here is an example of the setup XML and the results XML: % perhaps best to refer to each XML after each section (setup <> results) +% Should we include an Example of the input and output XML structure?? --> Sure. + +ADD XML STRUCTURE EXAMPLE + + +\section{Conclusions and future work}\label{sec:conclusions} + +In this paper we have presented an approach to creating a browser-based listening test environment that can be used for a variety of types of perceptual evaluation of audio. +Specifically, we discussed the use of the toolbox in the context of assessment of preference for different production practices, with identical source material. +The purpose of this paper is to outline the design of this tool, to describe our implementation using basic HTML5 functionality, and to discuss design challenges and limitations of our approach. % or something + +% future work +Further work may include the development of other common test designs, such as MUSHRA \cite{mushra}, AB, ABX and method of adjustment tests. +In addition, [...]. + +%\begin{itemize} +%\item Options for MUSHRA style experiment with vertical slide per track +%\item APE style experiment where all tracks are on a single horizontal axis % isn't that what we're doing now? +%\item AB test +%\item ABX test +%\item Method of adjustment tests +%\end{itemize} + + +The source code of this tool can be found on \url{code.soundsoftware.ac.uk/projects/webaudioevaluationtool}. The repository includes an issue tracker, where bug reports and feature requests can inform further development. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%bibliography here +\bibliography{smc2015template} + + + +\end{document} + + + +% RUBBISH + +%\subsection{Equations} +%Equations of importance, +%or to which you refer later, +%should be placed on separated lines and numbered. +%The number should be on the right side, in parentheses. +%\begin{equation} +%E=mc^{2+\delta}. +%\label{eq:Emc2} +%\end{equation} +%Refer to equations like so: +%As (\ref{eq:Emc2}) shows, +%I do not completely trust Special Relativity. +% +%\subsection{Figures, Tables and Captions} +%\begin{table}[t] +% \begin{center} +% \begin{tabular}{|l|l|} +% \hline +% String value & Numeric value \\ +% \hline +% Hej SMC & 2015 \\ +% \hline +% \end{tabular} +%\end{center} +% \caption{Table captions should be placed below the table, exactly like this, +% but using words different from these.} +% \label{tab:example} +%\end{table} + +%\begin{figure}[t] +%\figbox{ +%\subfloat[][]{\includegraphics[width=60mm]{figure}\label{fig:subfigex_a}}\\ +%\subfloat[][]{\includegraphics[width=80mm]{figure}\label{fig:subfigex_b}} +%} +%\caption{Here's an example using the subfig package.\label{fig:subfigex} } +%\end{figure} + + + + + +%\begin{acknowledgments} +%You may acknowledge people, projects, +%funding agencies, etc. +%which can be included after the second-level heading +%``Acknowledgments'' (with no numbering). +%\end{acknowledgments} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/example_eval/project.xml Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,49 @@ +<?xml version="1.0" encoding="utf-8"?> +<BrowserEvalProjectDocument> + <setup interface="APE" projectReturn="null" randomiseOrder='true' collectMetrics='true'> + <PreTest> + <statement>Please listen to all mixes</statement> + <question id="location" mandatory="true">Please enter your listening location</question> + </PreTest> + <PostTest> + <statement>Thank you for taking this listening test.</statement> + <question id="SessionID">Please enter your name.</question> + </PostTest> + <Metric> + <metricEnable>testTimer</metricEnable> + <metricEnable>elementTimer</metricEnable> + <metricEnable>elementInitalPosition</metricEnable> + <metricEnable>elementTracker</metricEnable> + <metricEnable>elementFlagListenedTo</metricEnable> + <metricEnable>elementFlagMoved</metricEnable> + </Metric> + </setup> + <audioHolder id='0' hostURL="example_eval/" sampleRate="44100" randomiseOrder='true' repeatCount='1' loop='true'> + <interface> + <title>Example Test Question</title> + <scale position="0">Min</scale> + <scale position="100">Max</scale> + <scale position="50">Middle</scale> + <scale position="20">20</scale> + </interface> + <audioElements url="0.wav" id="0"/> + <audioElements url="1.wav" id="1"/> + <audioElements url="2.wav" id="2"/> + <audioElements url="3.wav" id="3"/> + <audioElements url="4.wav" id="4"/> + <audioElements url="5.wav" id="5"/> + <audioElements url="6.wav" id="6"/> + <audioElements url="7.wav" id="7"/> + <audioElements url="8.wav" id="8"/> + <audioElements url="9.wav" id="9"/> + <audioElements url="10.wav" id="10"/> + <CommentQuestion id='mixingExperiance'>What is your mixing experiance</CommentQuestion> + <PreTest> + <statement>Start the Test 3</statement> + </PreTest> + <PostTest> + <statement>Please take a break before the next test</statement> + <question id="testComment">How did you find the test</question> + </PostTest> + </audioHolder> +</BrowserEvalProjectDocument> \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphics.css Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,10 @@ +/* graphics.css + * Define colours and effects for classes and objects + */ + +div.title { + font-size: 2em; +} + +body { +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pythonServer.py Wed Apr 22 10:05:11 2015 +0100 @@ -0,0 +1,11 @@ +import SimpleHTTPServer +import SocketServer + +PORT = 8080 + +Handler = SimpleHTTPServer.SimpleHTTPRequestHandler + +httpd = SocketServer.TCPServer(("", PORT), Handler) + +print "serving at port", PORT +httpd.serve_forever()