Fix trailing whitespace in .cpp, .h, and .idl files (ex. Source/core)

Source/modules/webaudio/AudioBufferSourceNode.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 98 matching lines @@
             return;
         }
 
         size_t quantumFrameOffset;
         size_t bufferFramesToProcess;
 
         updateSchedulingInfo(framesToProcess,
                              outputBus,
                              quantumFrameOffset,
                              bufferFramesToProcess);
-                             
+
         if (!bufferFramesToProcess) {
             outputBus->zero();
             return;
         }
 
         for (unsigned i = 0; i < outputBus->numberOfChannels(); ++i)
             m_destinationChannels[i] = outputBus->channel(i)->mutableData();
 
         // Render by reading directly from the buffer.
         if (!renderFromBuffer(outputBus, quantumFrameOffset, bufferFramesToProcess)) {
@@ skipping 13 matching lines @@
 
 // Returns true if we're finished.
 bool AudioBufferSourceNode::renderSilenceAndFinishIfNotLooping(AudioBus*, unsigned index, size_t framesToProcess)
 {
     if (!loop()) {
         // If we're not looping, then stop playing when we get to the end.
 
         if (framesToProcess > 0) {
             // We're not looping and we've reached the end of the sample data, but we still need to provide more output,
             // so generate silence for the remaining.
-            for (unsigned i = 0; i < numberOfChannels(); ++i) 
+            for (unsigned i = 0; i < numberOfChannels(); ++i)
                 memset(m_destinationChannels[i] + index, 0, sizeof(float) * framesToProcess);
         }
 
         finish();
         return true;
     }
     return false;
 }
 
 bool AudioBufferSourceNode::renderFromBuffer(AudioBus* bus, unsigned destinationFrameOffset, size_t numberOfFrames)
@@ skipping 22 matching lines @@
     if (!isLengthGood)
         return false;
 
     bool isOffsetGood = destinationFrameOffset <= destinationLength && destinationFrameOffset + numberOfFrames <= destinationLength;
     ASSERT(isOffsetGood);
     if (!isOffsetGood)
         return false;
 
     // Potentially zero out initial frames leading up to the offset.
     if (destinationFrameOffset) {
-        for (unsigned i = 0; i < numberOfChannels; ++i) 
+        for (unsigned i = 0; i < numberOfChannels; ++i)
             memset(m_destinationChannels[i], 0, sizeof(float) * destinationFrameOffset);
     }
 
     // Offset the pointers to the correct offset frame.
     unsigned writeIndex = destinationFrameOffset;
 
     size_t bufferLength = buffer()->length();
     double bufferSampleRate = buffer()->sampleRate();
 
     // Avoid converting from time to sample-frames twice by computing
     // the grain end time first before computing the sample frame.
     unsigned endFrame = m_isGrain ? AudioUtilities::timeToSampleFrame(m_grainOffset + m_grainDuration, bufferSampleRate) : bufferLength;
-    
+
     // This is a HACK to allow for HRTF tail-time - avoids glitch at end.
     // FIXME: implement tailTime for each AudioNode for a more general solution to this problem.
     // https://bugs.webkit.org/show_bug.cgi?id=77224
     if (m_isGrain)
         endFrame += 512;
 
     // Do some sanity checking.
     if (endFrame > bufferLength)
         endFrame = bufferLength;
     if (m_virtualReadIndex >= endFrame)
@@ skipping 35 matching lines @@
         && virtualDeltaFrames == floor(virtualDeltaFrames)
         && virtualEndFrame == floor(virtualEndFrame)) {
         unsigned readIndex = static_cast<unsigned>(virtualReadIndex);
         unsigned deltaFrames = static_cast<unsigned>(virtualDeltaFrames);
         endFrame = static_cast<unsigned>(virtualEndFrame);
         while (framesToProcess > 0) {
             int framesToEnd = endFrame - readIndex;
             int framesThisTime = min(framesToProcess, framesToEnd);
             framesThisTime = max(0, framesThisTime);
 
-            for (unsigned i = 0; i < numberOfChannels; ++i) 
+            for (unsigned i = 0; i < numberOfChannels; ++i)
                 memcpy(destinationChannels[i] + writeIndex, sourceChannels[i] + readIndex, sizeof(float) * framesThisTime);
 
             writeIndex += framesThisTime;
             readIndex += framesThisTime;
             framesToProcess -= framesThisTime;
 
             // Wrap-around.
             if (readIndex >= endFrame) {
                 readIndex -= deltaFrames;
                 if (renderSilenceAndFinishIfNotLooping(bus, writeIndex, framesToProcess))
@@ skipping 55 matching lines @@
 
 void AudioBufferSourceNode::reset()
 {
     m_virtualReadIndex = 0;
     m_lastGain = gain()->value();
 }
 
 bool AudioBufferSourceNode::setBuffer(AudioBuffer* buffer)
 {
     ASSERT(isMainThread());
-    
+
     // The context must be locked since changing the buffer can re-configure the number of channels that are output.
     AudioContext::AutoLocker contextLocker(context());
-    
+
     // This synchronizes with process().
     MutexLocker processLocker(m_processLock);
-    
+
     if (buffer) {
         // Do any necesssary re-configuration to the buffer's number of channels.
         unsigned numberOfChannels = buffer->numberOfChannels();
 
         if (numberOfChannels > AudioContext::maxNumberOfChannels())
             return false;
 
         output(0)->setNumberOfChannels(numberOfChannels);
 
         m_sourceChannels = adoptArrayPtr(new const float* [numberOfChannels]);
         m_destinationChannels = adoptArrayPtr(new float* [numberOfChannels]);
 
-        for (unsigned i = 0; i < numberOfChannels; ++i) 
+        for (unsigned i = 0; i < numberOfChannels; ++i)
             m_sourceChannels[i] = buffer->getChannelData(i)->data();
     }
 
     m_virtualReadIndex = 0;
     m_buffer = buffer;
-    
+
     return true;
 }
 
 unsigned AudioBufferSourceNode::numberOfChannels()
 {
     return output(0)->numberOfChannels();
 }
 
 void AudioBufferSourceNode::startGrain(double when, double grainOffset)
 {
     // Duration of 0 has special value, meaning calculate based on the entire buffer's duration.
     startGrain(when, grainOffset, 0);
 }
 
 void AudioBufferSourceNode::startGrain(double when, double grainOffset, double grainDuration)
 {
     ASSERT(isMainThread());
 
     if (m_playbackState != UNSCHEDULED_STATE)
         return;
 
     if (!buffer())
         return;
-        
+
     // Do sanity checking of grain parameters versus buffer size.
     double bufferDuration = buffer()->duration();
 
     grainOffset = max(0.0, grainOffset);
     grainOffset = min(bufferDuration, grainOffset);
     m_grainOffset = grainOffset;
 
     // Handle default/unspecified duration.
     double maxDuration = bufferDuration - grainOffset;
     if (!grainDuration)
         grainDuration = maxDuration;
 
     grainDuration = max(0.0, grainDuration);
     grainDuration = min(maxDuration, grainDuration);
     m_grainDuration = grainDuration;
 
     m_isGrain = true;
     m_startTime = when;
-    
+
     // We call timeToSampleFrame here since at playbackRate == 1 we don't want to go through linear interpolation
     // at a sub-sample position since it will degrade the quality.
     // When aligned to the sample-frame the playback will be identical to the PCM data stored in the buffer.
     // Since playbackRate == 1 is very common, it's worth considering quality.
     m_virtualReadIndex = AudioUtilities::timeToSampleFrame(m_grainOffset, buffer()->sampleRate());
-    
+
     m_playbackState = SCHEDULED_STATE;
 }
 
 void AudioBufferSourceNode::noteGrainOn(double when, double grainOffset, double grainDuration)
 {
     startGrain(when, grainOffset, grainDuration);
 }
 
 double AudioBufferSourceNode::totalPitchRate()
 {
     double dopplerRate = 1.0;
     if (m_pannerNode)
         dopplerRate = m_pannerNode->dopplerRate();
-    
+
     // Incorporate buffer's sample-rate versus AudioContext's sample-rate.
     // Normally it's not an issue because buffers are loaded at the AudioContext's sample-rate, but we can handle it in any case.
     double sampleRateFactor = 1.0;
     if (buffer())
         sampleRateFactor = buffer()->sampleRate() / sampleRate();
-    
+
     double basePitchRate = playbackRate()->value();
 
     double totalRate = dopplerRate * sampleRateFactor * basePitchRate;
 
     // Sanity check the total rate.  It's very important that the resampler not get any bad rate values.
     totalRate = max(0.0, totalRate);
     if (!totalRate)
         totalRate = 1; // zero rate is considered illegal
     totalRate = min(MaxRate, totalRate);
-    
+
     bool isTotalRateValid = !std::isnan(totalRate) && !std::isinf(totalRate);
     ASSERT(isTotalRateValid);
     if (!isTotalRateValid)
         totalRate = 1.0;
 
     return totalRate;
 }
 
 bool AudioBufferSourceNode::propagatesSilence() const
 {
@@ skipping 23 matching lines @@
 void AudioBufferSourceNode::finish()
 {
     clearPannerNode();
     ASSERT(!m_pannerNode);
     AudioScheduledSourceNode::finish();
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(WEB_AUDIO)