1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim:set ts=2 sw=2 sts=2 et cindent: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4  * License, v. 2.0. If a copy of the MPL was not distributed with this
5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 #ifndef MOZILLA_AUDIOBLOCK_H_
7 #define MOZILLA_AUDIOBLOCK_H_
8 
9 #include "AudioSegment.h"
10 
11 namespace mozilla {
12 
13 /**
14  * An AudioChunk whose buffer contents need to be valid only for one
15  * processing block iteration, after which contents can be overwritten if the
16  * buffer has not been passed to longer term storage or to another thread,
17  * which may happen though AsAudioChunk() or AsMutableChunk().
18  *
19  * Use on graph thread only.
20  */
21 class AudioBlock : private AudioChunk {
22  public:
AudioBlock()23   AudioBlock() {
24     mDuration = WEBAUDIO_BLOCK_SIZE;
25     mBufferFormat = AUDIO_FORMAT_SILENCE;
26   }
27   // No effort is made in constructors to ensure that mBufferIsDownstreamRef
28   // is set because the block is expected to be a temporary and so the
29   // reference will be released before the next iteration.
30   // The custom copy constructor is required so as not to set
31   // mBufferIsDownstreamRef without notifying AudioBlockBuffer.
AudioBlock(const AudioBlock & aBlock)32   AudioBlock(const AudioBlock& aBlock) : AudioChunk(aBlock.AsAudioChunk()) {}
AudioBlock(const AudioChunk & aChunk)33   explicit AudioBlock(const AudioChunk& aChunk) : AudioChunk(aChunk) {
34     MOZ_ASSERT(aChunk.mDuration == WEBAUDIO_BLOCK_SIZE);
35   }
36   ~AudioBlock();
37 
38   using AudioChunk::ChannelCount;
39   using AudioChunk::ChannelData;
40   using AudioChunk::GetDuration;
41   using AudioChunk::IsNull;
42   using AudioChunk::SizeOfExcludingThis;
43   using AudioChunk::SizeOfExcludingThisIfUnshared;
44   // mDuration is not exposed.  Use GetDuration().
45   // mBuffer is not exposed.  Use Get/SetBuffer().
46   using AudioChunk::mBufferFormat;
47   using AudioChunk::mChannelData;
48   using AudioChunk::mVolume;
49 
AsAudioChunk()50   const AudioChunk& AsAudioChunk() const { return *this; }
AsMutableChunk()51   AudioChunk* AsMutableChunk() {
52     ClearDownstreamMark();
53     return this;
54   }
55 
56   /**
57    * Allocates, if necessary, aChannelCount buffers of WEBAUDIO_BLOCK_SIZE float
58    * samples for writing.
59    */
60   void AllocateChannels(uint32_t aChannelCount);
61 
62   /**
63    * ChannelFloatsForWrite() should only be used when the buffers have been
64    * created with AllocateChannels().
65    */
ChannelFloatsForWrite(size_t aChannel)66   float* ChannelFloatsForWrite(size_t aChannel) {
67     MOZ_ASSERT(mBufferFormat == AUDIO_FORMAT_FLOAT32);
68     MOZ_ASSERT(CanWrite());
69     return static_cast<float*>(const_cast<void*>(mChannelData[aChannel]));
70   }
71 
GetBuffer()72   ThreadSharedObject* GetBuffer() const { return mBuffer; }
73   void SetBuffer(ThreadSharedObject* aNewBuffer);
SetNull(TrackTime aDuration)74   void SetNull(TrackTime aDuration) {
75     MOZ_ASSERT(aDuration == WEBAUDIO_BLOCK_SIZE);
76     SetBuffer(nullptr);
77     mChannelData.Clear();
78     mVolume = 1.0f;
79     mBufferFormat = AUDIO_FORMAT_SILENCE;
80   }
81 
82   AudioBlock& operator=(const AudioBlock& aBlock) {
83     // Instead of just copying, mBufferIsDownstreamRef must be first cleared
84     // if set.  It is set again for the new mBuffer if possible.  This happens
85     // in SetBuffer().
86     return *this = aBlock.AsAudioChunk();
87   }
88   AudioBlock& operator=(const AudioChunk& aChunk) {
89     MOZ_ASSERT(aChunk.mDuration == WEBAUDIO_BLOCK_SIZE);
90     SetBuffer(aChunk.mBuffer);
91     mChannelData = aChunk.mChannelData;
92     mVolume = aChunk.mVolume;
93     mBufferFormat = aChunk.mBufferFormat;
94     return *this;
95   }
96 
IsMuted()97   bool IsMuted() const { return mVolume == 0.0f; }
98 
IsSilentOrSubnormal()99   bool IsSilentOrSubnormal() const {
100     if (!mBuffer) {
101       return true;
102     }
103 
104     for (uint32_t i = 0, length = mChannelData.Length(); i < length; ++i) {
105       const float* channel = static_cast<const float*>(mChannelData[i]);
106       for (TrackTime frame = 0; frame < mDuration; ++frame) {
107         if (fabs(channel[frame]) >= FLT_MIN) {
108           return false;
109         }
110       }
111     }
112 
113     return true;
114   }
115 
116  private:
117   void ClearDownstreamMark();
118   bool CanWrite();
119 
120   // mBufferIsDownstreamRef is set only when mBuffer references an
121   // AudioBlockBuffer created in a different AudioBlock.  That can happen when
122   // this AudioBlock is on a node downstream from the node which created the
123   // buffer.  When this is set, the AudioBlockBuffer is notified that this
124   // reference does not prevent the upstream node from re-using the buffer next
125   // iteration and modifying its contents.  The AudioBlockBuffer is also
126   // notified when mBuffer releases this reference.
127   bool mBufferIsDownstreamRef = false;
128 };
129 
130 }  // namespace mozilla
131 
132 MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(mozilla::AudioBlock)
133 
134 #endif  // MOZILLA_AUDIOBLOCK_H_
135