Mercurial > hg > webaudioevaluationtool
changeset 938:c3fe29d33643
Currently playing sample red.
| author | Brecht De Man <BrechtDeMan@users.noreply.github.com> |
|---|---|
| date | Sat, 16 May 2015 17:52:51 +0100 |
| parents | |
| children | c2fe27b91359 |
| files | .hgignore ape.css ape.js core.js docs/ProjectSpecificationDocument.pdf docs/ProjectSpecificationDocument.tex docs/ResultsSpecificationDocument.pdf docs/ResultsSpecificationDocument.tex docs/SMC15/IEEEtran.bst docs/SMC15/XMLInput.png docs/SMC15/XMLInput2.png docs/SMC15/XMLOutput.png docs/SMC15/XMLOutput2.png docs/SMC15/interface.png docs/SMC15/interface2.png 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 index.html pythonServer.py structure.css |
| diffstat | 35 files changed, 5157 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/.hgignore Sat May 16 17:52:51 2015 +0100 @@ -0,0 +1,26 @@ +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$ +*.aux +*.bbl +*.gz +*.log +*.blg +*.DS_Store +re:^RealismEval/ +re:^SynthReal/ +re:^SynthRealismTest\.html$ +re:^example_eval/paperExample\.xml$ +re:^example_eval/project\.xml\.orig$ +re:^index2\.html$ +re:^realismTest\.html$
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ape.css Sat May 16 17:52:51 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 structure 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 Sat May 16 17:52:51 2015 +0100 @@ -0,0 +1,941 @@ +/** + * ape.js + * Create the APE interface + */ + +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 = 'Listening test'; + } + // 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 commentShow = textXML.attributes['elementComments']; + if (commentShow != undefined) { + if (commentShow.value == 'false') {commentShow = false;} + else {commentShow = true;} + } else {commentShow = true;} + + 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; + this.audioObjects[i].stop(); + } + } + }; + } + + 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 in case + 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); + + if (commentShow) { + // 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); + // Currently playing track red, rest green + document.getElementById('track-slider-'+index).style.backgroundColor = "#FF0000"; + for (var i = 0; i<$(currentTrackOrder).length; i++) + { + if (i!=index) + { + document.getElementById('track-slider-'+i).style.backgroundColor = "rgb(100,200,100)"; + } + + } + }; + + canvas.appendChild(trackSliderObj); + }); + + // Append any commentQuestion boxes + var commentQuestions = $(textXML).find('CommentQuestion'); + $(commentQuestions).each(function(index,element) { + // Create document objects to hold the comment boxes + var trackComment = document.createElement('div'); + trackComment.className = 'comment-div commentQuestion'; + trackComment.id = element.attributes['id'].value; + // Create a string next to each comment asking for a comment + var trackString = document.createElement('span'); + trackString.innerHTML = element.textContent; + // Create the HTML5 comment box 'textarea' + var trackCommentBox = document.createElement('textarea'); + trackCommentBox.rows = '4'; + trackCommentBox.cols = '100'; + trackCommentBox.name = 'commentQuestion'+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); + }); + + // 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'); + var mandatory = preTest.children[index].attributes['mandatory']; + if (mandatory != undefined){ + if (mandatory.value == 'true') {mandatory = true;} + else {mandatory = false;} + } else {mandatory = false;} + if (mandatory == true && questionResponse.value.length == 0) { + return index; + } + 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 == undefined) { + testEnded(testId); + } + else if (postXML.children.length > 0) + { + currentState = 'testRunPost-'+testId; + showPopup(); + preTestPopupStart(postXML); + } + else { + + + // No post tests, check if we have another test to perform instead + + } + } + 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 commentShow = testXMLSetups[testId].attributes['elementComments']; + if (commentShow != undefined) { + if (commentShow.value == 'false') {commentShow = false;} + else {commentShow = true;} + } else {commentShow = true;} + + 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); + if (commentShow) { + 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(comment); + } + audioElement.appendChild(value); + // 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); + } + var commentQuestion = document.getElementsByClassName('commentQuestion'); + for (var i=0; i<commentQuestion.length; i++) + { + var cqHolder = document.createElement('CommentQuestion'); + var comment = document.createElement('comment'); + var question = document.createElement('question'); + cqHolder.id = commentQuestion[i].id; + comment.textContent = commentQuestion[i].children[2].value; + question.textContent = commentQuestion[i].children[0].textContent; + cqHolder.appendChild(question); + cqHolder.appendChild(comment); + xmlDoc.appendChild(cqHolder); + } + 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; +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/core.js Sat May 16 17:52:51 2015 +0100 @@ -0,0 +1,313 @@ +/** + * core.js + * + * Main script to run, calls all other core functions and manages loading/store to backend. + * Also contains all global variables. + */ + +/* 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 Sat May 16 17:52:51 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 Sat May 16 17:52:51 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 Sat May 16 17:52:51 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 Sat May 16 17:52:51 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 Sat May 16 17:52:51 2015 +0100 @@ -0,0 +1,130 @@ +% Generated by IEEEtran.bst, version: 1.12 (2007/01/11) +\begin{thebibliography}{10} +\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{schoeffler2013impact} +M.~Schoeffler and J.~Herre, ``About the impact of audio quality on overall + listening experience,'' in \emph{Proceedings of the 10th Sound and Music + Computing Conference}, 2013, pp. 48--53. + +\bibitem{repp} +R.~Repp, ``Recording quality ratings by music professionals,'' in + \emph{Proceedings of the 2006 International Computer Music Conference}, 2006, + pp. 468--474. + +\bibitem{de2013real} +A.~de~G{\"o}tzen, E.~Sikstr{\"o}m, F.~Grani, and S.~Serafin, ``Real, foley or + synthetic? {A}n evaluation of everyday walking sounds,'' in \emph{Proceedings + of SMC 2013 : 10th Sound and Music Computing Conference}, 2013. + +\bibitem{durr2015implementation} +G.~Durr, L.~Peixoto, M.~Souza, R.~Tanoue, and J.~D. Reiss, ``Implementation and + evaluation of dynamic level of audio detail,'' in \emph{Audio Engineering + Society Conference: 56th International Conference: Audio for Games}, 2015. + +\bibitem{deman2014a} +B.~De~Man and J.~D. Reiss, ``Adaptive control of amplitude distortion + effects,'' in \emph{Audio Engineering Society Conference: 53rd International + Conference: Semantic Audio}, 2014. + +\bibitem{mushram} +E.~Vincent, M.~G. Jafari, and M.~D. Plumbley, ``Preliminary guidelines for + subjective evalutation of audio source separation algorithms,'' in \emph{UK + ICA Research Network Workshop}, 2006. + +\bibitem{uhlereiss} +J.~D. Reiss and C.~Uhle, ``Determined source separation for microphone + recordings using {IIR} filters,'' in \emph{129th Convention of the Audio + Engineering Society}, 2010. + +\bibitem{song2013a} +Y.~Song, S.~Dixon, M.~T. Pearce, and G.~Fazekas, ``Using tags to select stimuli + in the study of music and emotion,'' \emph{Proceedings of the 3rd + International Conference on Music \& Emotion (ICME)}, 2013. + +\bibitem{eerola2009prediction} +T.~Eerola, O.~Lartillot, and P.~Toiviainen, ``Prediction of multidimensional + emotional ratings in music from audio using multivariate regression models,'' + in \emph{Proceedings of the 10th International Society for Music Information + Retrieval (ISMIR2009)}, 2009, pp. 621--626. + +\bibitem{friberg2011comparison} +A.~Friberg and A.~Hedblad, ``A comparison of perceptual ratings and computed + audio features,'' in \emph{Proceedings of the 8th Sound and Music Computing + Conference}, 2011, pp. 122--127. + +\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}, + 2014. + +\bibitem{beaqlejs} +S.~Kraft and U.~Z{\"o}lzer, ``{BeaqleJS}: {HTML5} and {JavaScript} based + framework for the subjective evaluation of audio quality,'' in \emph{Linux + Audio Conference, Karlsruhe, DE}, 2014. + +\bibitem{hulti-gen} +C.~Gribben and H.~Lee, ``Toward the development of a universal listening test + interface generator in {Max},'' in \emph{138th Convention of the Audio + Engineering Society}, 2015. + +\bibitem{scale} +A.~V. Giner, ``Scale - a software tool for listening experiments,'' in + \emph{AIA/DAGA Conference on Acoustics, Merano (Italy)}, 2013. + +\bibitem{whisper} +S.~Ciba, A.~Wlodarski, and H.-J. Maempel, ``Whis{PER} -- {A} new tool for + performing listening tests,'' in \emph{126th Convention of the Audio + Engineering Society}, 2009. + +\bibitem{opaque} +J.~Berg, ``{OPAQUE} -- {A} tool for the elicitation and grading of audio + quality attributes,'' in \emph{118th Convention of the Audio Engineering + Society}, 2005. + +\bibitem{guineapig} +J.~Hynninen and N.~Zacharov, ``{GuineaPig} - {A} generic subjective test system + for multichannel audio,'' in \emph{106th Convention of the Audio Engineering + Society}, 1999. + +\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. + +\bibitem{mason2015compression} +A.~Mason, N.~Jillings, Z.~Ma, J.~D. Reiss, and F.~Melchior, ``Adaptive audio + reproduction using personalized compression,'' in \emph{Audio Engineering + Society Conference: 57th International Conference: The Future of Audio + Entertainment Technology -- Cinema, Television and the Internet}, 2015. + +\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{deman2015a} +B.~De~Man, M.~Boerum, B.~Leonard, G.~Massenburg, R.~King, and J.~D. Reiss, + ``Perceptual evaluation of music mixing practices,'' in \emph{138th + Convention of the Audio Engineering Society}, 2015. + +\end{thebibliography}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/SMC15/smc2015template.bib Sat May 16 17:52:51 2015 +0100 @@ -0,0 +1,157 @@ +%% 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}, + Title = {{APE}: {A}udio {P}erceptual {E}valuation toolbox for {MATLAB}}, + Year = {2014}} + + +@inproceedings{de2013real, + title={Real, foley or synthetic? {A}n evaluation of everyday walking sounds}, + author={de G{\"o}tzen, Amalia and Sikstr{\"o}m, Erik and Grani, Francesco and Serafin, Stefania}, + year={2013}, + booktitle={Proceedings of SMC 2013 : 10th Sound and Music Computing Conference}, +} + +@inproceedings{friberg2011comparison, + title={A comparison of perceptual ratings and computed audio features}, + author={Friberg, Anders and Hedblad, Anton}, + booktitle={Proceedings of the 8th Sound and Music Computing Conference}, + pages={122--127}, + year={2011} +} + +@conference{mason2015compression, + Author = {Mason, Andrew and Jillings, Nick and Ma, Zheng and Reiss, Joshua D. and Melchior, Frank}, + Booktitle = {Audio Engineering Society Conference: 57th International Conference: The Future of Audio Entertainment Technology -- Cinema, Television and the Internet}, + Title = {Adaptive Audio Reproduction Using Personalized Compression}, + Year = {2015}} + +@inproceedings{beaqlejs, + Author = {Kraft, Sebastian and Z{\"o}lzer, Udo}, + Booktitle = {Linux Audio Conference, Karlsruhe, DE}, + Title = {{BeaqleJS}: {HTML5} and {JavaScript} based framework for the subjective evaluation of audio quality}, + Year = {2014}} + + +@inproceedings{uhlereiss, + Author = {Reiss, Joshua D. and Uhle, Christian}, + Booktitle = {129th Convention of the Audio Engineering Society}, + Title = {Determined Source Separation for Microphone Recordings Using {IIR} Filters}, + Year = {2010}} + + +@conference{deman2014a, + Author = {De Man, Brecht and Joshua D. Reiss}, + Booktitle = {Audio Engineering Society Conference: 53rd International Conference: Semantic Audio}, + Title = {Adaptive Control of Amplitude Distortion Effects}, + Year = {2014}} + +@conference{song2013b, + Author = {Song, Yading and Dixon, Simon and Halpern, Andrea R.}, + Booktitle = {Proceedings of the 14th International Society for Music Information Retrieval (ISMIR2013)}, + Title = {Do online social tags predict perceived or induced emotional responses to music?}, + Year = {2013}} + +@article{song2013a, + Author = {Song, Yading and Dixon, Simon and Pearce, Marcus T. and Fazekas, Gy{\"o}rgy}, + Journal = {Proceedings of the 3rd International Conference on Music \& Emotion (ICME)}, + Title = {Using tags to select stimuli in the study of music and emotion}, + Year = {2013}} + +@conference{whisper, + Author = {Simon Ciba and Andr{\'e} Wlodarski and Hans-Joachim Maempel}, + Booktitle = {126th Convention of the Audio Engineering Society}, + Title = {Whis{PER} -- {A} new tool for performing listening tests}, + Year = {2009}} + +@conference{scale, + Author = {Arnau Vazquez Giner}, + Booktitle = {AIA/DAGA Conference on Acoustics, Merano (Italy)}, + Title = {Scale - A Software Tool for Listening Experiments}, + Year = {2013}} + +@inproceedings{mushram, + Author = {Emmanuel Vincent and Maria G. Jafari and Mark D. Plumbley}, + Booktitle = {UK ICA Research Network Workshop}, + Title = {Preliminary guidelines for subjective evalutation of audio source separation algorithms}, + Year = {2006}} + +@inproceedings{schoeffler2013impact, + Author = {Schoeffler, Michael and Herre, J{\"u}rgen}, + Booktitle = {Proceedings of the 10th Sound and Music Computing Conference}, + Pages = {48--53}, + Title = {About the Impact of Audio Quality on Overall Listening Experience}, + Year = {2013}} + +@conference{repp, + Author = {Richard Repp}, + Booktitle = {Proceedings of the 2006 International Computer Music Conference}, + Pages = {468-474}, + Title = {Recording Quality Ratings by Music Professionals}, + Year = {2006}} + +@conference{durr2015implementation, + Author = {Durr, Gabriel and Peixoto, Lys and Souza, Marcelo and Tanoue, Raisa and Reiss, Joshua D.}, + Booktitle = {Audio Engineering Society Conference: 56th International Conference: Audio for Games}, + Title = {Implementation and Evaluation of Dynamic Level of Audio Detail}, + Year = {2015}} + +@techreport{itu-peaq, + Author = {ITU}, + Institution = {International Telecommunication Union}, + Title = {Recommendation {ITU-R BS.1387-1}: Method for objective measurements of perceived audio quality}, + Year = {2001}} + +@conference{hulti-gen, + Author = {Christopher Gribben and Hyunkook Lee}, + Booktitle = {138th Convention of the Audio Engineering Society}, + Title = {Toward the Development of a Universal Listening Test Interface Generator in {Max}}, + Year = {2015}} + +@conference{guineapig, + Author = {Hynninen, Jussi and Zacharov, Nick}, + Booktitle = {106th Convention of the Audio Engineering Society}, + Title = {{GuineaPig} - {A} generic subjective test system for multichannel audio}, + Year = {1999}} + +@conference{opaque, + Author = {Berg, Jan}, + Booktitle = {118th Convention of the Audio Engineering Society}, + Title = {{OPAQUE} -- {A} Tool for the Elicitation and Grading of Audio Quality Attributes}, + Year = {2005}} + +@conference{deman2015a, + Author = {De Man, Brecht and Boerum, Matt and Leonard, Brett and Massenburg, George and King, Richard and Reiss, Joshua D.}, + Booktitle = {138th Convention of the Audio Engineering Society}, + Title = {Perceptual Evaluation of Music Mixing Practices}, + Year = {2015}} + +@inproceedings{eerola2009prediction, + title={Prediction of Multidimensional Emotional Ratings in Music from Audio Using Multivariate Regression Models}, + author={Eerola, Tuomas and Lartillot, Olivier and Toiviainen, Petri}, + booktitle={Proceedings of the 10th International Society for Music Information Retrieval (ISMIR2009)}, + pages={621--626}, + year={2009} +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docs/SMC15/smc2015template.tex Sat May 16 17:52:51 2015 +0100 @@ -0,0 +1,395 @@ +% ----------------------------------------------- +% 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} +\usepackage{enumitem} +\setitemize{noitemsep,topsep=0pt,parsep=0pt,partopsep=0pt} + +\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 + +%set up 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} +Perceptual evaluation tests where subjects assess certain qualities of different audio fragments are an integral part of audio and music research. These require specialised software, usually custom-made, to collect large amounts of data using meticulously designed interfaces with carefully formulated questions, and play back audio with rapid switching between different samples. +New functionality in HTML5 included in the Web Audio API allows for increasingly powerful media applications in a platform independent environment. The advantage of a web application is easy deployment on any platform, without requiring any other application, enabling multiple tests to be easily conducted across locations. In this paper we propose a tool supporting a wide variety of easily configurable, multi-stimulus perceptual audio evaluation tests over the web with multiple test interfaces, pre- and post-test surveys, custom configuration, collection of test metrics and other features. Test design and setup doesn't require programming background, and results are gathered automatically using web friendly formats for easy storing of results on a server. +% Currently at 150, don't think anything more needs to be done here?? +%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} + +% TOTAL PAPER: Minimum 4 pages, 6 preferred, max. 8 (6 for demos/posters)\\ + +\section{Introduction}\label{sec:introduction} + +%NICK: examples of what kind of audio applications HTML5 has made possible, with references to publications (or website)\\ + +Perceptual evaluation of audio plays an important role in a wide range of research on audio quality \cite{schoeffler2013impact,repp}, sound synthesis \cite{de2013real,durr2015implementation}, audio effect design \cite{deman2014a}, source separation \cite{mushram,uhlereiss}, music and emotion analysis \cite{song2013a,eerola2009prediction}, and many others \cite{friberg2011comparison}. % codec design? + +%This work is based in part on the APE audio perceptual evaluation interface for MATLAB \cite{deman2014b}. An important drawback of this toolbox is the need to have MATLAB to create a test and even to run (barring the use of an executable generated by MATLAB), and limited compatibility with both earlier and newer versions of MATLAB, which makes it hard to maintain. On the other hand, a web application generally has the advantage of running in most browsers on most applications. + +% IMPORTANT +%[TO ADD: other interfaces for perceptual evaluation of audio, browser-based or not!] \\ +%BROWSER-BASED: \cite{song2013b,song2013a,beaqlejs} \\ +%MATLAB: \cite{whisper,mushram,scale} +% to add: OPAQUE, Rumsey's repertory grid technique + + +\begin{table}[htdp] +\caption{Available audio perceptual evaluation tools} +\begin{center} +\begin{tabular}{|*{3}{l|}} +% order? +\hline +\textbf{Name} & \textbf{Language} & \textbf{Ref.}\\ +\hline +APE & MATLAB & \cite{deman2014b} \\ +BeaqleJS & HTML5/JS & \cite{beaqlejs}\\ % ABX, mushra +%C4DM\footnote{http://isophonics.org/test - collection of listening tests developed by Gy\"{o}rgy Fazekas and Thomas Wilmering at Centre for Digital Music.} & JS & \cite{song2013a,song2013b}\\ +HULTI-GEN & Max & \cite{hulti-gen}\\ +MUSHRAM & MATLAB & \cite{mushram}\\ % type: mushra +Scale & MATLAB & \cite{scale} \\ +WhisPER & MATLAB & \cite{whisper}\\ +\hline +\end{tabular} +\end{center} +\label{tab:interfaces} +\end{table}% + +Various listening test design tools are already available, see Table \ref{tab:interfaces}. A few other listening test tools, such as OPAQUE \cite{opaque} and GuineaPig \cite{guineapig}, are described but not available to the public at the time of writing. + +Many are MATLAB-based, useful for easily processing and visualising the data produced by the listening tests, but requiring MATLAB to be installed to run or - in the case of an executable created with MATLAB - at least create the test. +Furthermore, compatibility is usually limited across different versions of MATLAB. +Similarly, Max requires little or no programming background but it is proprietary software as well, which is especially undesirable when tests need to be deployed at different sites. +More recently, BeaqleJS \cite{beaqlejs} makes use of the HTML5 audio capabilities and comes with a number of predefined, established test interfaces such as ABX and MUSHRA \cite{mushra}. % + +A browser-based perceptual evaluation tool for audio has a number of advantages. First of all, it doesn't need any other software than a browser, meaning deployment is very easy and cheap. As such, it can also run on a variety of devices and platforms. The test can be hosted on a central server with subjects all over the world, who can simply go to a webpage. This means that multiple participants can take the test simultaneously, potentially in their usual listening environment if this is beneficial for the test. Naturally, the constraints on the listening environment and other variables still need to be controlled if they are important to the experiment. Depending on the requirements a survey or a variety of tests preceding the experiment could establish whether remote participants and their environments are adequate for the experiment at hand. + +The Web Audio API is a high-level JavaScript Application Programming Interface (API) designed for real-time processing of audio inside the browser through various processing nodes\footnote{http://webaudio.github.io/web-audio-api/}. Various web sites have used the Web Audio API for creative purposes, such as drum machines and score creation tools\footnote{http://webaudio.github.io/demo-list/}, +others from the list show real-time captured audio processing such as room reverberation tools and a phase vocoder from the system microphone. The BBC Radiophonic Workshop shows effects used on famous TV shows such as Doctor Who, being simulated inside the browser\footnote{http://webaudio.prototyping.bbc.co.uk/}. +Another example is the BBC R\&D personalised compressor which applies a dynamic range compressor on a radio station that dynamically adjusts the compressor settings to match the listener's environment \cite{mason2015compression}. + + + +% [How is this one different from all these?] improve + +% FLEXIBLE (reference (not) appropriate) +In contrast with the tools listed above, we aim to provide an environment in which a variety of multi-stimulus tests can be designed, with a wide range of configurability, while keeping setup and collecting results as straightforward as possible. For instance, the option to provide free-text comment fields allows for tests with individual vocabulary methods, as opposed to only allowing quantitative scales associated to a fixed set of descriptors. +% EASE OF USE: no need to go in the code +To make the tool accessible to a wide range of researchers, we aim to offer maximum functionality even to those with little or no programming background. The tool we present can set up a listening test without reading or adjusting any code, provided no new types of interfaces need to be created. + +% ENVIRONMENT %In this paper, we provide a listening test back end that allows for easy set up of a wide variety of listening tests, highly flexible yet very simple and not requiring any programming skills. +Specifically, we present a browser-based perceptual evaluation tool from which any kind of multiple stimulus audio evaluation tool where subjects need to rank, rate, select, or comment on different audio samples can be built. +We also include an example of the multiple stimulus user interface included with the APE tool \cite{deman2014b}, which presents the subject with a number of axes on which a number of markers, corresponding to audio samples, can be moved to reflect any subjective quality, as well as corresponding comment boxes. +However, other graphical user interfaces can be put on top of the engine that we provide with minimal or no modifications. Examples of this are the MUSHRA test \cite{mushra}, single or multiple stimulus evaluation with a two-dimensional interface (such as valence and arousal dimensions), or simple annotation (using free-form text, check boxes, radio buttons or drop-down menus) of one or more audio samples at a time. +In some cases, such as method of adjustment, where the audio is processed by the user, or AB test, where the interface does not show all audio samples to be evaluated at once \cite{bech}, the back end of the tool needs to be modified as well. + +In the following sections, we describe the included interface in more detail, discuss the implementation, and cover considerations that were made in the design process of this tool. + +%\section{Requirements}\label{sec:requirements} +%??? +% +%\begin{itemize} +%\item +%\end{itemize} + + +\section{Interface}\label{sec:interface} + +At this point, we have implemented the interface of the MATLAB-based APE (Audio Perceptual Evaluation) toolbox \cite{deman2014b}. This shows one marker for each simultaneously evaluated audio fragment on one or more horizontal axes, that can be moved to rate or rank the respective fragments in terms of any subjective property, as well as a comment box for every marker, and any extra text boxes for extra comments. +The reason for such an interface, where all stimuli are presented on a single rating axis (or multiple axes if multiple subjective qualities need to be evaluated), is that it urges the subject to consider the rating and/or ranking of the stimuli relative to one another, as opposed to comparing each individual stimulus to a given reference, as is the case with e.g. a MUSHRA test \cite{mushra}. As such, it is ideal for any type of test where the goal is to carefully compare samples against each other, like perceptual evaluation of different mixes of music recordings \cite{deman2015a} or sound synthesis models \cite{durr2015implementation}, as opposed to comparing results of source separation algorithms \cite{mushram} or audio with lower data rate \cite{mushra} to a high quality reference signal. + +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. Another approach is to place the markers outside of the slider bar at first and have the subject drag them in, but 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. + +See Figure \ref{fig:interface} for an example of the interface, with six fragments and one axis. %? change if a new interface is shown + +%Most of these functions are specific to the APE interface design, for instance the AB test will need a different structure for the audio engine and loading of files, since multiple instances of the same file are required. % more generally these pertain to any typeof multi-stimulus test - not quite useful for AB tests, method of adjustment, ABX, and so on. +%There are some areas of the design where certain design choices had to be made such as with the markers. + +%For instance, the option to provide free-text comment fields allows for tests with individual vocabulary methods, as opposed to only allowing quantitative scales associated to a fixed set of descriptors. + +\begin{figure*}[ht] +\begin{center} +\includegraphics[width=1.0\textwidth]{interface2.png} +\caption{Example of interface, with 1 axis, 6 fragments and 1 extra comment in Chrome browser} +\label{fig:interface} +\end{center} +\end{figure*} + + +\section{Architecture}\label{sec:architecture} % or implementation? + +The tool uses entirely client side processing utilising the new HTML5 Web Audio API, supported by most major web browsers. The API allows for constructing audio processing elements and connecting them together to produce a high quality, real time signal process to manipulate audio streams. The API supports multichannel processing and has an accurate playback timer for precise, scheduled playback control. The API is controlled through the browser JavaScript engine and is therefore highly configurable. Processing is all performed in a low latency thread separate from the main JavaScript thread, so there is no blocking due to real time processing. + +The web tool itself is split into several files to operate: +\begin{itemize} +\item \texttt{index.html}: The main index file to load the scripts, this is the file the browser must request to load. +\item \texttt{core.js}: Contains global functions and object prototypes to define the audio playback engine, audio objects and loading media 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 along with a few other ancillary files (such as the jQuery JavaScript extensions\footnote{http://jquery.com/}), 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 Section \ref{sec:setupresultsformats}). \texttt{core.js} parses this document and executes the functions in \texttt{ape.js} to build the web page. The reason for separating these two files is to allow for further interface designs (such as MUSHRA \cite{mushra} or AB tests \cite{bech}) to be used, which would still require the same underlying core functions outlined in \texttt{core.js}. + +The \texttt{ape.js} file has several main functions but the most important are documented here. \textit{loadInterface(xmlDoc)} is called to decode the supplied project document in respect for the interface specified and define any global structures (such as the slider interface). It also identifies the number of pages in the test and randomises the order, if specified to do so. This is the only mandatory function in any of the interface files as this is called by \texttt{core.js} when the document is ready. \texttt{core.js} cannot 'see' any interface specific functions and therefore cannot assume any are available. Therefore \textit{loadInterface(xmlDoc)} is essential to set up the entire test environment. Because the interface files are loaded by \texttt{core.js} and because the functions in \texttt{core.js} are global, the interface files can `see' the \texttt{core.js} file and can therefore not only interact with it, but also modify it. + +Each test page is loaded using \textit{loadTest(id)} which performs two major tasks: to populate the interface with the slider elements and comment boxes; and secondly to instruct the \textit{audioEngine} to load the audio fragments and construct the backend audio graph. \textit{loadTest(id)} also instructs the audio engine in \texttt{core.js} to create the \textit{audioObject}. +These are custom audio nodes, one representing each audio element specified in each page. +They consist of a \textit{bufferSourceNode} (a node which holds a buffer of audio samples for playback) and a \textit{gainNode}, both of which are Web Audio API Nodes. Various functions are applied, depending on which metrics are enabled, to record the interaction with the audio element. These nodes are then connected to the \textit{audioEngine} (itself a custom web audio node) containing a \textit{gainNode} (where the various \textit{audioObject}s connect to) for summation before passing the output to the \textit{destinationNode}, a permanent node of the Web Audio API created as the master output. Here, the browser then passes the audio information to the system sound device. % Does this now make sense? +% audio object/audioObject/Audio Object: -- should always be audioObject if talking about the JavaScript object, otherwise should say audio element or audio fragment. + +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, which downloads any file into the JavaScript environment for further processing. This is particularly useful for the Web Audio API because it supports downloading of files in their binary form for decoding. Once downloaded the file is decoded using the Web Audio API offline decoder. This uses the browser available decoding schemes to decode the audio files into raw float32 arrays, which are in turn passed to the relevant \textit{audioObject} for playback. + +Once each page of the test is completed, identified by pressing the Submit button, the \textit{pageXMLSave(testId)} is called to store all of the collected data until all pages of the test are completed. After the final test and any post-test questions are completed, the \textit{interfaceXMLSave()} function is called. This function generates the final XML file for submission as outlined in Section \ref{sec:setupresultsformats}. + +\section{Support and limitations}\label{sec:support} + +Browsers support various audio file formats and are not consistent in any format. Currently the Web Audio API is best supported in Chrome, Firefox, Opera and Safari. All of these support the use of the uncompressed WAV format. Although not a compact, web friendly format, most transport systems are of a high enough bandwidth this should not be a problem. Ogg Vorbis is another well supported format across the four supported major desktop browsers, as well as MP3 (although Firefox may not support all MP3 types) \footnote{https://developer.mozilla.org/en-US/docs/Web/HTML/\\Supported\_media\_formats}. %https://developer.mozilla.org/en-US/docs/Web/HTML/Supported_media_formats +One issue of the Web Audio API is that the sample rate is assigned by the system sound device, rather than requested and does not have the ability to request a different one. % Does this make sense? The problem is across all audio files. +As the sampling rate and the effect of resampling may be critical for some listening tests, 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. +This happens before any loading or decoding of audio files so the browser will only be instructed to fetch files if the system sample rate meets the requirements, avoiding multiple 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. +% Don't think this is relevant anymore + + +\section{Input and result files}\label{sec:setupresultsformats} + +The setup and result files both use the common XML document format to outline the various parameters. The setup file determines the interface to use, the location of audio files, the number of pages and other parameters to define the testing environment. 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 multiple web files. Furthermore, we also provide a simple web page to enter all these settings without needing to manipulate the raw XML. An example of this XML document is presented in Figure~\ref{fig:xmlIn}. % I mean the .js and .html files, though not sure if any better. + +\subsection{Setup and configurability} + +\begin{figure}[ht] +\begin{center} +\includegraphics[width=0.5\textwidth]{XMLInput2.png} +\caption{An example input XML file} +\label{fig:xmlIn} +\end{center} +\end{figure} + +The setup document has several defined nodes and structure which are documented with the source code. For example, there is a section for general setup options where any pre-test and post-test questions and statements can be defined. Pre- and post-test dialogue 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. In the example in Figure~\ref{fig:xmlIn}, a question box with the id `location' is added, which is set to be mandatory to answer. The question is in the PreTest node meaning it will appear before any testing will begin. When the result for the entire test is shown, the response will appear in the PreTest node with the id `location' allowing it to be found easily, provided the id values are meaningful. + +We try to cater to a diverse audience with this toolbox, while ensuring it is simple, elegant and straightforward. To that end, we currently include the following options that can be easily switched on and off, by setting the value in the input XML file. + +\begin{itemize} %Should have used a description list for this. +\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 to 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 each page in the 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. In the setup, each 'page' can be given a repeat count. These are all gathered before shuffling the order so repeated tests are not back-to-back if possible. +\item \textbf{Returning to previous pages}: Indicates whether it is possible to go back to a previous `page' in the test. +\item \textbf{Lowest rating below [value]}: To enforce a certain use of the rating scale, it can be required to rate at least one sample below a specified value. +\item \textbf{Highest rating above [value]}: To enforce a certain use of the rating scale, it can be required to rate at least one sample above a specified value. +\item \textbf{Reference}: Allows for a separate sample (outside of the axis) to be the `reference', which the subject can play back during the test to help with the task at hand \cite{mushra}. +\item \textbf{Hidden reference}: Whether or not an explicit `reference' is provided, the `hidden reference' should be rated above a certain value \cite{mushra} - this can be enforced. +\item \textbf{Hidden anchor}: The `hidden anchor' should be rated lower than a certain value \cite{mushra} - this can be enforced. +\item \textbf{Show scrub bar}: Display a playhead on a scrub bar to show the position in the current fragment. +\item \textbf{Drag playhead}: If scrub bar is visible, allow dragging to move back or forward in a fragment. +\end{itemize} + +When one of these options is not included in the setup file, they assume a default value. As a result, the input file can be kept very compact if default values suffice for the test. + +% loop, snap to corresponding position, comments, 'general' comment, require same sampling rate, different types of randomisation + +\subsection{Results} + +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. An example output file is presented in Figure~\ref{fig:xmlOut}. + +\begin{figure}[ht] +\begin{center} +\includegraphics[width=0.5\textwidth]{XMLOutput2.png} +\caption{An example output XML file} +\label{fig:xmlOut} +\end{center} +\end{figure} + +The results also contain information collected by any defined pre/post questions. These are referenced against the setup XML by using the same ID so readable responses can be obtained. Taking from the earlier example of setting up a pre-test question, an example response can be seen in Figure \ref{fig:xmlOut}. + +Each page of testing is returned with the results of the entire page included in the structure. One `audioElement' node is created per audio fragment per page, along with its ID. This includes several child nodes including the rating between 0 and 1, the comment, and any other collected metrics including how long the element was listened for, the initial position, boolean flags if the element was listened to, if the element was moved and if the element comment box had any comment. Furthermore, each user action (manipulation of any interface element, such as playback or moving a marker) can be logged along with a the corresponding time code. +We also store session data such as the browser the tool was used in. +We provide the option to store the results locally, and/or to have them sent to a server. + +%Here is an example of the set up XML and the results XML: % perhaps best to refer to each XML after each section (set up <> results) +% Should we include an Example of the input and output XML structure?? --> Sure. + +%An example of the returned \textit{audioElement} node in the results XML file is as follows. +% +%\texttt{<audioelement id="8"> \\ +%<comment> \\ +%<question>Comment on track 0</question> \\ +%<response> The drums were punchy </response> \\ +%</comment> \\ +%<value> 0.25169491525423726 </value> \\ +%<metric> \\ +%<metricresult id="elementTimer"> \\ 2.3278004535147385< /metricresult> \\ +%<metricresult id="elementTrackerFull"> \\ +%<timepos id="0"> \\ +%<time>1.7937414965986385</time> \\ +%<position>0.41694915254237286</position> \\ +%</timepos> \\ +%<timepos id="1"> \\ +%<time>2.6993197278911563</time> \\ +%<position>0.45847457627118643</position> \\ +%</timepos> \\</metricresult> \\ +%<metricresult id="elementInitialPosition"> 0.47796610169491527 </metricresult> \\ +%<metricresult id="elementFlagListenedTo"> true< /metricresult> \\ +%<metricresult id="elementFlagMoved"> true </metricresult> \\ +%</metric> \\ +%</audioelement>} + +The parent tag \texttt{audioelement} holds the ID of the element passed in from the setup document. The first child element is \texttt{comment} and holds both the question shown and the response from the comment box inside. +The child element \texttt{value} holds the normalised ranking value. Next comes the metric node structure, with one metric result node per metric event collected. The id of the node identifies the type of data it contains. For example, the first holds the id \textit{elementTimer} and the data contained represents how long, in seconds, the audio element was listened to. There is one \texttt{audioelement} tag per audio element on each test page. + + +\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. This tool differentiates itself from other perceptual audio tools by enabling web technologies for multiple participants to perform the test without the need for proprietary software such as MATLAB. The tool also allows for any interface to be built using HTML5 elements to create a variety of dynamic, multiple-stimulus listening test interfaces. It enables quick setup of simple tests with the ability to manage complex tests through a single file. Finally it uses the XML document format to store the results allowing for processing and analysis of results in various third party software such as MATLAB or Python. + +% future work +Further work may include the development of other common test designs, such as MUSHRA \cite{mushra}, 2D valence and arousal/activity \cite{ratingeerola2009prediction}, and others. We will add functionality to assist with setting up large-scale tests with remote subjects, so this becomes straightforward and intuitive. +In addition, we will keep on improving and expanding the tool, and highly welcome feedback and contributions from the community. + +The source code of this tool can be found on \\ \texttt{code.soundsoftware.ac.uk/projects/}\\ \texttt{webaudioevaluationtool}. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%bibliography here +\bibliography{smc2015template} + +\end{document}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/example_eval/project.xml Sat May 16 17:52:51 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' elementComments='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 Sat May 16 17:52:51 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/index.html Sat May 16 17:52:51 2015 +0100 @@ -0,0 +1,41 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8" /> + + + <!-- 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/project.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/pythonServer.py Sat May 16 17:52:51 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()