PageRenderTime 55ms CodeModel.GetById 24ms RepoModel.GetById 0ms app.codeStats 0ms

/opensource.apple.com/source/WebCore/WebCore-1298.37/webaudio/AudioBufferSourceNode.cpp

#
C++ | 480 lines | 375 code | 84 blank | 21 comment | 21 complexity | eb2a44ab956f32fd4b25175b48ce5395 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, GPL-2.0, BSD-3-Clause, GPL-3.0, MPL-2.0, LGPL-2.0, LGPL-2.1, CC-BY-SA-3.0, IPL-1.0, ISC, AGPL-1.0, AGPL-3.0, JSON, Apache-2.0, 0BSD 
    

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    2. 

  2.     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
    3. 

  3. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
    4. 

  4. <head>
    5. 

  5. <title>AudioBufferSourceNode.cpp</title>
    6. 

  6. <style type="text/css">
    7. 

  7. .enscript-comment { font-style: italic; color: rgb(178,34,34); }
    8. 

  8. .enscript-function-name { font-weight: bold; color: rgb(0,0,255); }
    9. 

  9. .enscript-variable-name { font-weight: bold; color: rgb(184,134,11); }
    10. 

  10. .enscript-keyword { font-weight: bold; color: rgb(160,32,240); }
    11. 

  11. .enscript-reference { font-weight: bold; color: rgb(95,158,160); }
    12. 

  12. .enscript-string { font-weight: bold; color: rgb(188,143,143); }
    13. 

  13. .enscript-builtin { font-weight: bold; color: rgb(218,112,214); }
    14. 

  14. .enscript-type { font-weight: bold; color: rgb(34,139,34); }
    15. 

  15. .enscript-highlight { text-decoration: underline; color: 0; }
    16. 

  16. </style>
    17. 

  17. </head>
    18. 

  18. <body id="top">
    19. 

  19. <h1 style="margin:8px;" id="f1">AudioBufferSourceNode.cpp&nbsp;&nbsp;&nbsp;<span style="font-weight: normal; font-size: 0.5em;">[<a href="?txt">plain text</a>]</span></h1>
    20. 

  20. <hr/>
    21. 

  21. <div></div>
    22. 

  22. <pre>
    23. 

  23. <span class="enscript-comment">/*
    24. 

  24.  * Copyright (C) 2010, Google Inc. All rights reserved.
    25. 

  25.  *
    26. 

  26.  * Redistribution and use in source and binary forms, with or without
    27. 

  27.  * modification, are permitted provided that the following conditions
    28. 

  28.  * are met:
    29. 

  29.  * 1.  Redistributions of source code must retain the above copyright
    30. 

  30.  *    notice, this list of conditions and the following disclaimer.
    31. 

  31.  * 2.  Redistributions in binary form must reproduce the above copyright
    32. 

  32.  *    notice, this list of conditions and the following disclaimer in the
    33. 

  33.  *    documentation and/or other materials provided with the distribution.
    34. 

  34.  *
    35. 

  35.  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
    36. 

  36.  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    37. 

  37.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    38. 

  38.  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
    39. 

  39.  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
    40. 

  40.  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    41. 

  41.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
    42. 

  42.  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    43. 

  43.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    44. 

  44.  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    45. 

  45.  */</span>
    46. 

  46. 

  47. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;config.h&quot;</span>
    48. 

  48. 

  49. #<span class="enscript-reference">if</span> <span class="enscript-variable-name">ENABLE</span>(<span class="enscript-variable-name">WEB_AUDIO</span>)
    50. 

  50. 

  51. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;AudioBufferSourceNode.h&quot;</span>
    52. 

  52. 

  53. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;AudioContext.h&quot;</span>
    54. 

  54. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;AudioNodeOutput.h&quot;</span>
    55. 

  55. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;algorithm&gt;</span>
    56. 

  56. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;wtf/MathExtras.h&gt;</span>
    57. 

  57. 

  58. using namespace std;
    59. 

  59. 

  60. namespace WebCore {
    61. 

  61. 

  62. <span class="enscript-type">const</span> <span class="enscript-type">double</span> DefaultGrainDuration = 0.020; <span class="enscript-comment">// 20ms
    63. 

  63. </span>
    64. 

  64. PassRefPtr&lt;AudioBufferSourceNode&gt; AudioBufferSourceNode::create(AudioContext* context, <span class="enscript-type">double</span> sampleRate)
    65. 

  65. {
    66. 

  66.     <span class="enscript-keyword">return</span> adoptRef(<span class="enscript-keyword">new</span> AudioBufferSourceNode(context, sampleRate));
    67. 

  67. }
    68. 

  68. 

  69. <span class="enscript-function-name">AudioBufferSourceNode::AudioBufferSourceNode</span>(AudioContext* context, <span class="enscript-type">double</span> sampleRate)
    70. 

  70.     : AudioSourceNode(context, sampleRate)
    71. 

  71.     , m_buffer(0)
    72. 

  72.     , m_isPlaying(false)
    73. 

  73.     , m_isLooping(false)
    74. 

  74.     , m_hasFinished(false)
    75. 

  75.     , m_startTime(0.0)
    76. 

  76.     , m_schedulingFrameDelay(0)
    77. 

  77.     , m_readIndex(0)
    78. 

  78.     , m_isGrain(false)
    79. 

  79.     , m_grainOffset(0.0)
    80. 

  80.     , m_grainDuration(DefaultGrainDuration)
    81. 

  81.     , m_grainFrameCount(0)
    82. 

  82.     , m_lastGain(1.0)
    83. 

  83.     , m_pannerNode(0)
    84. 

  84. {
    85. 

  85.     setType(NodeTypeAudioBufferSource);
    86. 

  86. 

  87.     m_gain = AudioGain::create(<span class="enscript-string">&quot;gain&quot;</span>, 1.0, 0.0, 1.0);
    88. 

  88.     m_playbackRate = AudioParam::create(<span class="enscript-string">&quot;playbackRate&quot;</span>, 1.0, 0.0, AudioResampler::MaxRate);
    89. 

  89. 

  90.     <span class="enscript-comment">// Default to mono.  A call to setBuffer() will set the number of output channels to that of the buffer.
    91. 

  91. </span>    addOutput(adoptPtr(<span class="enscript-keyword">new</span> AudioNodeOutput(<span class="enscript-keyword">this</span>, 1)));
    92. 

  92. 

  93.     initialize();
    94. 

  94. }
    95. 

  95. 

  96. <span class="enscript-function-name">AudioBufferSourceNode::~AudioBufferSourceNode</span>()
    97. 

  97. {
    98. 

  98.     uninitialize();
    99. 

  99. }
    100. 

  100. 

  101. <span class="enscript-type">void</span> <span class="enscript-function-name">AudioBufferSourceNode::process</span>(size_t framesToProcess)
    102. 

  102. {
    103. 

  103.     AudioBus* outputBus = output(0)-&gt;bus();
    104. 

  104. 

  105.     <span class="enscript-keyword">if</span> (!isInitialized()) {
    106. 

  106.         outputBus-&gt;zero();
    107. 

  107.         <span class="enscript-keyword">return</span>;
    108. 

  108.     }
    109. 

  109. 

  110.     <span class="enscript-comment">// The audio thread can't block on this lock, so we call tryLock() instead.
    111. 

  111. </span>    <span class="enscript-comment">// Careful - this is a tryLock() and not an autolocker, so we must unlock() before every return.
    112. 

  112. </span>    <span class="enscript-keyword">if</span> (m_processLock.tryLock()) {
    113. 

  113.         <span class="enscript-comment">// Check if it's time to start playing.
    114. 

  114. </span>        <span class="enscript-type">double</span> sampleRate = <span class="enscript-keyword">this</span>-&gt;sampleRate();
    115. 

  115.         <span class="enscript-type">double</span> pitchRate = totalPitchRate();
    116. 

  116.         <span class="enscript-type">double</span> quantumStartTime = context()-&gt;currentTime();
    117. 

  117.         <span class="enscript-type">double</span> quantumEndTime = quantumStartTime + framesToProcess / sampleRate;
    118. 

  118. 

  119.         <span class="enscript-keyword">if</span> (!m_isPlaying || m_hasFinished || !buffer() || m_startTime &gt;= quantumEndTime) {
    120. 

  120.             <span class="enscript-comment">// FIXME: can optimize here by propagating silent hint instead of forcing the whole chain to process silence.
    121. 

  121. </span>            outputBus-&gt;zero();
    122. 

  122.             m_processLock.unlock();
    123. 

  123.             <span class="enscript-keyword">return</span>;
    124. 

  124.         }
    125. 

  125. 

  126.         <span class="enscript-comment">// Handle sample-accurate scheduling so that buffer playback will happen at a very precise time.
    127. 

  127. </span>        m_schedulingFrameDelay = 0;
    128. 

  128.         <span class="enscript-keyword">if</span> (m_startTime &gt;= quantumStartTime) {
    129. 

  129.             <span class="enscript-comment">// m_schedulingFrameDelay is set here only the very first render quantum (because of above check: m_startTime &gt;= quantumEndTime)
    130. 

  130. </span>            <span class="enscript-comment">// So: quantumStartTime &lt;= m_startTime &lt; quantumEndTime
    131. 

  131. </span>            ASSERT(m_startTime &lt; quantumEndTime);
    132. 

  132.             
    133. 

  133.             <span class="enscript-type">double</span> startTimeInQuantum = m_startTime - quantumStartTime;
    134. 

  134.             <span class="enscript-type">double</span> startFrameInQuantum = startTimeInQuantum * sampleRate;
    135. 

  135.             
    136. 

  136.             <span class="enscript-comment">// m_schedulingFrameDelay is used in provideInput(), so factor in the current playback pitch rate.
    137. 

  137. </span>            m_schedulingFrameDelay = static_cast&lt;<span class="enscript-type">int</span>&gt;(pitchRate * startFrameInQuantum);
    138. 

  138.         }
    139. 

  139. 

  140.         <span class="enscript-comment">// FIXME: optimization opportunity:
    141. 

  141. </span>        <span class="enscript-comment">// With a bit of work, it should be possible to avoid going through the resampler completely when the pitchRate == 1,
    142. 

  142. </span>        <span class="enscript-comment">// especially if the pitchRate has never deviated from 1 in the past.
    143. 

  143. </span>
    144. 

  144.         <span class="enscript-comment">// Read the samples through the pitch resampler.  Our provideInput() method will be called by the resampler.
    145. 

  145. </span>        m_resampler.setRate(pitchRate);
    146. 

  146.         m_resampler.process(<span class="enscript-keyword">this</span>, outputBus, framesToProcess);
    147. 

  147. 

  148.         <span class="enscript-comment">// Apply the gain (in-place) to the output bus.
    149. 

  149. </span>        <span class="enscript-type">double</span> totalGain = gain()-&gt;value() * m_buffer-&gt;gain();
    150. 

  150.         outputBus-&gt;copyWithGainFrom(*outputBus, &amp;m_lastGain, totalGain);
    151. 

  151. 

  152.         m_processLock.unlock();
    153. 

  153.     } <span class="enscript-keyword">else</span> {
    154. 

  154.         <span class="enscript-comment">// Too bad - the tryLock() failed.  We must be in the middle of changing buffers and were already outputting silence anyway.
    155. 

  155. </span>        outputBus-&gt;zero();
    156. 

  156.     }
    157. 

  157. }
    158. 

  158. 

  159. <span class="enscript-comment">// The resampler calls us back here to get the input samples from our buffer.
    160. 

  160. </span><span class="enscript-type">void</span> <span class="enscript-function-name">AudioBufferSourceNode::provideInput</span>(AudioBus* bus, size_t numberOfFrames)
    161. 

  161. {
    162. 

  162.     ASSERT(context()-&gt;isAudioThread());
    163. 

  163.     
    164. 

  164.     <span class="enscript-comment">// Basic sanity checking
    165. 

  165. </span>    ASSERT(bus);
    166. 

  166.     ASSERT(buffer());
    167. 

  167.     <span class="enscript-keyword">if</span> (!bus || !buffer())
    168. 

  168.         <span class="enscript-keyword">return</span>;
    169. 

  169. 

  170.     <span class="enscript-type">unsigned</span> numberOfChannels = <span class="enscript-keyword">this</span>-&gt;numberOfChannels();
    171. 

  171.     <span class="enscript-type">unsigned</span> busNumberOfChannels = bus-&gt;numberOfChannels();
    172. 

  172. 

  173.     <span class="enscript-comment">// FIXME: we can add support for sources with more than two channels, but this is not a common case.
    174. 

  174. </span>    <span class="enscript-type">bool</span> channelCountGood = numberOfChannels == busNumberOfChannels &amp;&amp; (numberOfChannels == 1 || numberOfChannels == 2);
    175. 

  175.     ASSERT(channelCountGood);
    176. 

  176.     <span class="enscript-keyword">if</span> (!channelCountGood)
    177. 

  177.         <span class="enscript-keyword">return</span>;
    178. 

  178. 

  179.     <span class="enscript-comment">// Get the destination pointers.
    180. 

  180. </span>    <span class="enscript-type">float</span>* destinationL = bus-&gt;channel(0)-&gt;data();
    181. 

  181.     ASSERT(destinationL);
    182. 

  182.     <span class="enscript-keyword">if</span> (!destinationL)
    183. 

  183.         <span class="enscript-keyword">return</span>;
    184. 

  184.     <span class="enscript-type">float</span>* destinationR = (numberOfChannels &lt; 2) ? 0 : bus-&gt;channel(1)-&gt;data();
    185. 

  185. 

  186.     size_t bufferLength = buffer()-&gt;length();
    187. 

  187.     <span class="enscript-type">double</span> bufferSampleRate = buffer()-&gt;sampleRate();
    188. 

  188. 

  189.     <span class="enscript-comment">// Calculate the start and end frames in our buffer that we want to play.
    190. 

  190. </span>    <span class="enscript-comment">// If m_isGrain is true, then we will be playing a portion of the total buffer.
    191. 

  191. </span>    <span class="enscript-type">unsigned</span> startFrame = m_isGrain ? static_cast&lt;<span class="enscript-type">unsigned</span>&gt;(m_grainOffset * bufferSampleRate) : 0;
    192. 

  192.     <span class="enscript-type">unsigned</span> endFrame = m_isGrain ? static_cast&lt;<span class="enscript-type">unsigned</span>&gt;(startFrame + m_grainDuration * bufferSampleRate) : bufferLength;
    193. 

  193. 

  194.     <span class="enscript-comment">// This is a HACK to allow for HRTF tail-time - avoids glitch at end.
    195. 

  195. </span>    <span class="enscript-comment">// FIXME: implement tailTime for each AudioNode for a more general solution to this problem.
    196. 

  196. </span>    <span class="enscript-keyword">if</span> (m_isGrain)
    197. 

  197.         endFrame += 512;
    198. 

  198. 

  199.     <span class="enscript-comment">// Do some sanity checking.
    200. 

  200. </span>    <span class="enscript-keyword">if</span> (startFrame &gt;= bufferLength)
    201. 

  201.         startFrame = !bufferLength ? 0 : bufferLength - 1;
    202. 

  202.     <span class="enscript-keyword">if</span> (endFrame &gt; bufferLength)
    203. 

  203.         endFrame = bufferLength;
    204. 

  204.     <span class="enscript-keyword">if</span> (m_readIndex &gt;= endFrame)
    205. 

  205.         m_readIndex = startFrame; <span class="enscript-comment">// reset to start
    206. 

  206. </span>    
    207. 

  207.     <span class="enscript-type">int</span> framesToProcess = numberOfFrames;
    208. 

  208. 

  209.     <span class="enscript-comment">// Handle sample-accurate scheduling so that we play the buffer at a very precise time.
    210. 

  210. </span>    <span class="enscript-comment">// m_schedulingFrameDelay will only be non-zero the very first time that provideInput() is called, which corresponds
    211. 

  211. </span>    <span class="enscript-comment">// with the very start of the buffer playback.
    212. 

  212. </span>    <span class="enscript-keyword">if</span> (m_schedulingFrameDelay &gt; 0) {
    213. 

  213.         ASSERT(m_schedulingFrameDelay &lt;= framesToProcess);
    214. 

  214.         <span class="enscript-keyword">if</span> (m_schedulingFrameDelay &lt;= framesToProcess) {
    215. 

  215.             <span class="enscript-comment">// Generate silence for the initial portion of the destination.
    216. 

  216. </span>            memset(destinationL, 0, <span class="enscript-keyword">sizeof</span>(<span class="enscript-type">float</span>) * m_schedulingFrameDelay);
    217. 

  217.             destinationL += m_schedulingFrameDelay;
    218. 

  218.             <span class="enscript-keyword">if</span> (destinationR) {
    219. 

  219.                 memset(destinationR, 0, <span class="enscript-keyword">sizeof</span>(<span class="enscript-type">float</span>) * m_schedulingFrameDelay);
    220. 

  220.                 destinationR += m_schedulingFrameDelay;
    221. 

  221.             }
    222. 

  222. 

  223.             <span class="enscript-comment">// Since we just generated silence for the initial portion, we have fewer frames to provide.
    224. 

  224. </span>            framesToProcess -= m_schedulingFrameDelay;
    225. 

  225.         }
    226. 

  226.     }
    227. 

  227.     
    228. 

  228.     <span class="enscript-comment">// We have to generate a certain number of output sample-frames, but we need to handle the case where we wrap around
    229. 

  229. </span>    <span class="enscript-comment">// from the end of the buffer to the start if playing back with looping and also the case where we simply reach the
    230. 

  230. </span>    <span class="enscript-comment">// end of the sample data, but haven't yet rendered numberOfFrames worth of output.
    231. 

  231. </span>    <span class="enscript-keyword">while</span> (framesToProcess &gt; 0) {
    232. 

  232.         ASSERT(m_readIndex &lt;= endFrame);
    233. 

  233.         <span class="enscript-keyword">if</span> (m_readIndex &gt; endFrame)
    234. 

  234.             <span class="enscript-keyword">return</span>;
    235. 

  235.             
    236. 

  236.         <span class="enscript-comment">// Figure out how many frames we can process this time.
    237. 

  237. </span>        <span class="enscript-type">int</span> framesAvailable = endFrame - m_readIndex;
    238. 

  238.         <span class="enscript-type">int</span> framesThisTime = min(framesToProcess, framesAvailable);
    239. 

  239.         
    240. 

  240.         <span class="enscript-comment">// Create the destination bus for the part of the destination we're processing this time.
    241. 

  241. </span>        AudioBus currentDestinationBus(busNumberOfChannels, framesThisTime, false);
    242. 

  242.         currentDestinationBus.setChannelMemory(0, destinationL, framesThisTime);
    243. 

  243.         <span class="enscript-keyword">if</span> (busNumberOfChannels &gt; 1)
    244. 

  244.             currentDestinationBus.setChannelMemory(1, destinationR, framesThisTime);
    245. 

  245. 

  246.         <span class="enscript-comment">// Generate output from the buffer.
    247. 

  247. </span>        readFromBuffer(&amp;currentDestinationBus, framesThisTime);
    248. 

  248. 

  249.         <span class="enscript-comment">// Update the destination pointers.
    250. 

  250. </span>        destinationL += framesThisTime;
    251. 

  251.         <span class="enscript-keyword">if</span> (busNumberOfChannels &gt; 1)
    252. 

  252.             destinationR += framesThisTime;
    253. 

  253. 

  254.         framesToProcess -= framesThisTime;
    255. 

  255. 

  256.         <span class="enscript-comment">// Handle the case where we reach the end of the part of the sample data we're supposed to play for the buffer.
    257. 

  257. </span>        <span class="enscript-keyword">if</span> (m_readIndex &gt;= endFrame) {
    258. 

  258.             m_readIndex = startFrame;
    259. 

  259.             m_grainFrameCount = 0;
    260. 

  260.             
    261. 

  261.             <span class="enscript-keyword">if</span> (!looping()) {
    262. 

  262.                 <span class="enscript-comment">// If we're not looping, then stop playing when we get to the end.
    263. 

  263. </span>                m_isPlaying = false;
    264. 

  264. 

  265.                 <span class="enscript-keyword">if</span> (framesToProcess &gt; 0) {
    266. 

  266.                     <span class="enscript-comment">// We're not looping and we've reached the end of the sample data, but we still need to provide more output,
    267. 

  267. </span>                    <span class="enscript-comment">// so generate silence for the remaining.
    268. 

  268. </span>                    memset(destinationL, 0, <span class="enscript-keyword">sizeof</span>(<span class="enscript-type">float</span>) * framesToProcess);
    269. 

  269. 

  270.                     <span class="enscript-keyword">if</span> (destinationR)
    271. 

  271.                         memset(destinationR, 0, <span class="enscript-keyword">sizeof</span>(<span class="enscript-type">float</span>) * framesToProcess);
    272. 

  272.                 }
    273. 

  273. 

  274.                 <span class="enscript-keyword">if</span> (!m_hasFinished) {
    275. 

  275.                     <span class="enscript-comment">// Let the context dereference this AudioNode.
    276. 

  276. </span>                    context()-&gt;notifyNodeFinishedProcessing(<span class="enscript-keyword">this</span>);
    277. 

  277.                     m_hasFinished = true;
    278. 

  278.                 }
    279. 

  279.                 <span class="enscript-keyword">return</span>;
    280. 

  280.             }
    281. 

  281.         }
    282. 

  282.     }
    283. 

  283. }
    284. 

  284. 

  285. <span class="enscript-type">void</span> <span class="enscript-function-name">AudioBufferSourceNode::readFromBuffer</span>(AudioBus* destinationBus, size_t framesToProcess)
    286. 

  286. {
    287. 

  287.     <span class="enscript-type">bool</span> isBusGood = destinationBus &amp;&amp; destinationBus-&gt;length() == framesToProcess &amp;&amp; destinationBus-&gt;numberOfChannels() == numberOfChannels();
    288. 

  288.     ASSERT(isBusGood);
    289. 

  289.     <span class="enscript-keyword">if</span> (!isBusGood)
    290. 

  290.         <span class="enscript-keyword">return</span>;
    291. 

  291.     
    292. 

  292.     <span class="enscript-type">unsigned</span> numberOfChannels = <span class="enscript-keyword">this</span>-&gt;numberOfChannels();
    293. 

  293.     <span class="enscript-comment">// FIXME: we can add support for sources with more than two channels, but this is not a common case.
    294. 

  294. </span>    <span class="enscript-type">bool</span> channelCountGood = numberOfChannels == 1 || numberOfChannels == 2;
    295. 

  295.     ASSERT(channelCountGood);
    296. 

  296.     <span class="enscript-keyword">if</span> (!channelCountGood)
    297. 

  297.         <span class="enscript-keyword">return</span>;
    298. 

  298.             
    299. 

  299.     <span class="enscript-comment">// Get pointers to the start of the sample buffer.
    300. 

  300. </span>    <span class="enscript-type">float</span>* sourceL = m_buffer-&gt;getChannelData(0)-&gt;data();
    301. 

  301.     <span class="enscript-type">float</span>* sourceR = m_buffer-&gt;numberOfChannels() == 2 ? m_buffer-&gt;getChannelData(1)-&gt;data() : 0;
    302. 

  302. 

  303.     <span class="enscript-comment">// Sanity check buffer access.
    304. 

  304. </span>    <span class="enscript-type">bool</span> isSourceGood = sourceL &amp;&amp; (numberOfChannels == 1 || sourceR) &amp;&amp; m_readIndex + framesToProcess &lt;= m_buffer-&gt;length();
    305. 

  305.     ASSERT(isSourceGood);
    306. 

  306.     <span class="enscript-keyword">if</span> (!isSourceGood)
    307. 

  307.         <span class="enscript-keyword">return</span>;
    308. 

  308. 

  309.     <span class="enscript-comment">// Offset the pointers to the current read position in the sample buffer.
    310. 

  310. </span>    sourceL += m_readIndex;
    311. 

  311.     sourceR += m_readIndex;
    312. 

  312. 

  313.     <span class="enscript-comment">// Get pointers to the destination.
    314. 

  314. </span>    <span class="enscript-type">float</span>* destinationL = destinationBus-&gt;channel(0)-&gt;data();
    315. 

  315.     <span class="enscript-type">float</span>* destinationR = numberOfChannels == 2 ? destinationBus-&gt;channel(1)-&gt;data() : 0;
    316. 

  316.     <span class="enscript-type">bool</span> isDestinationGood = destinationL &amp;&amp; (numberOfChannels == 1 || destinationR);
    317. 

  317.     ASSERT(isDestinationGood);
    318. 

  318.     <span class="enscript-keyword">if</span> (!isDestinationGood)
    319. 

  319.         <span class="enscript-keyword">return</span>;
    320. 

  320. 

  321.     <span class="enscript-keyword">if</span> (m_isGrain)
    322. 

  322.         readFromBufferWithGrainEnvelope(sourceL, sourceR, destinationL, destinationR, framesToProcess);
    323. 

  323.     <span class="enscript-keyword">else</span> {
    324. 

  324.         <span class="enscript-comment">// Simply copy the data from the source buffer to the destination.
    325. 

  325. </span>        memcpy(destinationL, sourceL, <span class="enscript-keyword">sizeof</span>(<span class="enscript-type">float</span>) * framesToProcess);
    326. 

  326.         <span class="enscript-keyword">if</span> (numberOfChannels == 2)
    327. 

  327.             memcpy(destinationR, sourceR, <span class="enscript-keyword">sizeof</span>(<span class="enscript-type">float</span>) * framesToProcess);
    328. 

  328.     }
    329. 

  329. 

  330.     <span class="enscript-comment">// Advance the buffer's read index.
    331. 

  331. </span>    m_readIndex += framesToProcess;
    332. 

  332. }
    333. 

  333. 

  334. <span class="enscript-type">void</span> <span class="enscript-function-name">AudioBufferSourceNode::readFromBufferWithGrainEnvelope</span>(<span class="enscript-type">float</span>* sourceL, <span class="enscript-type">float</span>* sourceR, <span class="enscript-type">float</span>* destinationL, <span class="enscript-type">float</span>* destinationR, size_t framesToProcess)
    335. 

  335. {
    336. 

  336.     ASSERT(sourceL &amp;&amp; destinationL);
    337. 

  337.     <span class="enscript-keyword">if</span> (!sourceL || !destinationL)
    338. 

  338.         <span class="enscript-keyword">return</span>;
    339. 

  339.         
    340. 

  340.     <span class="enscript-type">int</span> grainFrameLength = static_cast&lt;<span class="enscript-type">int</span>&gt;(m_grainDuration * m_buffer-&gt;sampleRate());
    341. 

  341.     <span class="enscript-type">bool</span> isStereo = sourceR &amp;&amp; destinationR;
    342. 

  342.     
    343. 

  343.     <span class="enscript-type">int</span> n = framesToProcess;
    344. 

  344.     <span class="enscript-keyword">while</span> (n--) {
    345. 

  345.         <span class="enscript-comment">// Apply the grain envelope.
    346. 

  346. </span>        <span class="enscript-type">float</span> x = static_cast&lt;<span class="enscript-type">float</span>&gt;(m_grainFrameCount) / static_cast&lt;<span class="enscript-type">float</span>&gt;(grainFrameLength);
    347. 

  347.         m_grainFrameCount++;
    348. 

  348. 

  349.         x = min(1.0f, x);
    350. 

  350.         <span class="enscript-type">float</span> grainEnvelope = sinf(piFloat * x);
    351. 

  351.         
    352. 

  352.         *destinationL++ = grainEnvelope * *sourceL++;
    353. 

  353. 

  354.         <span class="enscript-keyword">if</span> (isStereo)
    355. 

  355.             *destinationR++ = grainEnvelope * *sourceR++;
    356. 

  356.     }
    357. 

  357. }
    358. 

  358. 

  359. <span class="enscript-type">void</span> <span class="enscript-function-name">AudioBufferSourceNode::reset</span>()
    360. 

  360. {
    361. 

  361.     m_resampler.reset();
    362. 

  362.     m_readIndex = 0;
    363. 

  363.     m_grainFrameCount = 0;
    364. 

  364.     m_lastGain = gain()-&gt;value();
    365. 

  365. }
    366. 

  366. 

  367. <span class="enscript-type">void</span> <span class="enscript-function-name">AudioBufferSourceNode::setBuffer</span>(AudioBuffer* buffer)
    368. 

  368. {
    369. 

  369.     ASSERT(isMainThread());
    370. 

  370.     
    371. 

  371.     <span class="enscript-comment">// The context must be locked since changing the buffer can re-configure the number of channels that are output.
    372. 

  372. </span>    <span class="enscript-reference">AudioContext</span>::AutoLocker contextLocker(context());
    373. 

  373.     
    374. 

  374.     <span class="enscript-comment">// This synchronizes with process().
    375. 

  375. </span>    MutexLocker processLocker(m_processLock);
    376. 

  376.     
    377. 

  377.     <span class="enscript-keyword">if</span> (buffer) {
    378. 

  378.         <span class="enscript-comment">// Do any necesssary re-configuration to the buffer's number of channels.
    379. 

  379. </span>        <span class="enscript-type">unsigned</span> numberOfChannels = buffer-&gt;numberOfChannels();
    380. 

  380.         m_resampler.configureChannels(numberOfChannels);
    381. 

  381.         output(0)-&gt;setNumberOfChannels(numberOfChannels);
    382. 

  382.     }
    383. 

  383. 

  384.     m_readIndex = 0;
    385. 

  385.     m_buffer = buffer;
    386. 

  386. }
    387. 

  387. 

  388. <span class="enscript-type">unsigned</span> <span class="enscript-function-name">AudioBufferSourceNode::numberOfChannels</span>()
    389. 

  389. {
    390. 

  390.     <span class="enscript-keyword">return</span> output(0)-&gt;numberOfChannels();
    391. 

  391. }
    392. 

  392. 

  393. <span class="enscript-type">void</span> <span class="enscript-function-name">AudioBufferSourceNode::noteOn</span>(<span class="enscript-type">double</span> when)
    394. 

  394. {
    395. 

  395.     ASSERT(isMainThread());
    396. 

  396.     <span class="enscript-keyword">if</span> (m_isPlaying)
    397. 

  397.         <span class="enscript-keyword">return</span>;
    398. 

  398. 

  399.     m_isGrain = false;
    400. 

  400.     m_startTime = when;
    401. 

  401.     m_readIndex = 0;
    402. 

  402.     m_isPlaying = true;
    403. 

  403. }
    404. 

  404. 

  405. <span class="enscript-type">void</span> <span class="enscript-function-name">AudioBufferSourceNode::noteGrainOn</span>(<span class="enscript-type">double</span> when, <span class="enscript-type">double</span> grainOffset, <span class="enscript-type">double</span> grainDuration)
    406. 

  406. {
    407. 

  407.     ASSERT(isMainThread());
    408. 

  408.     <span class="enscript-keyword">if</span> (m_isPlaying)
    409. 

  409.         <span class="enscript-keyword">return</span>;
    410. 

  410. 

  411.     <span class="enscript-keyword">if</span> (!buffer())
    412. 

  412.         <span class="enscript-keyword">return</span>;
    413. 

  413.         
    414. 

  414.     <span class="enscript-comment">// Do sanity checking of grain parameters versus buffer size.
    415. 

  415. </span>    <span class="enscript-type">double</span> bufferDuration = buffer()-&gt;duration();
    416. 

  416. 

  417.     <span class="enscript-keyword">if</span> (grainDuration &gt; bufferDuration)
    418. 

  418.         <span class="enscript-keyword">return</span>; <span class="enscript-comment">// FIXME: maybe should throw exception - consider in specification.
    419. 

  419. </span>    
    420. 

  420.     <span class="enscript-type">double</span> maxGrainOffset = bufferDuration - grainDuration;
    421. 

  421.     maxGrainOffset = max(0.0, maxGrainOffset);
    422. 

  422. 

  423.     grainOffset = max(0.0, grainOffset);
    424. 

  424.     grainOffset = min(maxGrainOffset, grainOffset);    
    425. 

  425.     m_grainOffset = grainOffset;
    426. 

  426. 

  427.     m_grainDuration = grainDuration;
    428. 

  428.     m_grainFrameCount = 0;
    429. 

  429.     
    430. 

  430.     m_isGrain = true;
    431. 

  431.     m_startTime = when;
    432. 

  432.     m_readIndex = static_cast&lt;<span class="enscript-type">int</span>&gt;(m_grainOffset * buffer()-&gt;sampleRate());
    433. 

  433.     m_isPlaying = true;
    434. 

  434. }
    435. 

  435. 

  436. <span class="enscript-type">void</span> <span class="enscript-function-name">AudioBufferSourceNode::noteOff</span>(<span class="enscript-type">double</span>)
    437. 

  437. {
    438. 

  438.     ASSERT(isMainThread());
    439. 

  439.     <span class="enscript-keyword">if</span> (!m_isPlaying)
    440. 

  440.         <span class="enscript-keyword">return</span>;
    441. 

  441.         
    442. 

  442.     <span class="enscript-comment">// FIXME: the &quot;when&quot; argument to this method is ignored.
    443. 

  443. </span>    m_isPlaying = false;
    444. 

  444.     m_readIndex = 0;
    445. 

  445. }
    446. 

  446. 

  447. <span class="enscript-type">double</span> <span class="enscript-function-name">AudioBufferSourceNode::totalPitchRate</span>()
    448. 

  448. {
    449. 

  449.     <span class="enscript-type">double</span> dopplerRate = 1.0;
    450. 

  450.     <span class="enscript-keyword">if</span> (m_pannerNode.get())
    451. 

  451.         dopplerRate = m_pannerNode-&gt;dopplerRate();
    452. 

  452.     
    453. 

  453.     <span class="enscript-comment">// Incorporate buffer's sample-rate versus AudioContext's sample-rate.
    454. 

  454. </span>    <span class="enscript-comment">// Normally it's not an issue because buffers are loaded at the AudioContext's sample-rate, but we can handle it in any case.
    455. 

  455. </span>    <span class="enscript-type">double</span> sampleRateFactor = 1.0;
    456. 

  456.     <span class="enscript-keyword">if</span> (buffer())
    457. 

  457.         sampleRateFactor = buffer()-&gt;sampleRate() / sampleRate();
    458. 

  458.     
    459. 

  459.     <span class="enscript-type">double</span> basePitchRate = playbackRate()-&gt;value();
    460. 

  460. 

  461.     <span class="enscript-type">double</span> totalRate = dopplerRate * sampleRateFactor * basePitchRate;
    462. 

  462. 

  463.     <span class="enscript-comment">// Sanity check the total rate.  It's very important that the resampler not get any bad rate values.
    464. 

  464. </span>    totalRate = max(0.0, totalRate);
    465. 

  465.     totalRate = min(AudioResampler::MaxRate, totalRate);
    466. 

  466.     
    467. 

  467.     <span class="enscript-type">bool</span> isTotalRateValid = !isnan(totalRate) &amp;&amp; !isinf(totalRate);
    468. 

  468.     ASSERT(isTotalRateValid);
    469. 

  469.     <span class="enscript-keyword">if</span> (!isTotalRateValid)
    470. 

  470.         totalRate = 1.0;
    471. 

  471.     
    472. 

  472.     <span class="enscript-keyword">return</span> totalRate;
    473. 

  473. }
    474. 

  474. 

  475. } <span class="enscript-comment">// namespace WebCore
    476. 

  476. </span>
    477. 

  477. #<span class="enscript-reference">endif</span> // <span class="enscript-variable-name">ENABLE</span>(<span class="enscript-variable-name">WEB_AUDIO</span>)
    478. 

  478. </pre>
    479. 

  479. <hr />
    480. 

  480. </body></html>
    481.