1/* /android/src/frameworks/base/media/libeffects/AudioFormatAdapter.h
2**
3** Copyright 2009, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#ifndef AUDIOFORMATADAPTER_H_
19#define AUDIOFORMATADAPTER_H_
20
21#include <hardware/audio_effect.h>
22
23
24#define min(x,y) (((x) < (y)) ? (x) : (y))
25
26namespace android {
27
28// An adapter for an audio processor working on audio_sample_t samples with a
29// buffer override behavior to arbitrary sample formats and buffer behaviors.
30// The adapter may work on any processing class which has a processing function
31// with the following signature:
32// void process(const audio_sample_t * pIn,
33//              audio_sample_t * pOut,
34//              int frameCount);
35// It is assumed that the underlying processor works in S7.24 format and an
36// overwrite behavior.
37//
38// Usage is simple: just work with the processor normally, but instead of
39// calling its process() function directly, work with the process() function of
40// the adapter.
41// The adapter supports re-configuration to a different format on the fly.
42//
43// T        The processor class.
44// bufSize  The maximum number of samples (single channel) to process on a
45//          single call to the underlying processor. Setting this to a small
46//          number will save a little memory, but will cost function call
47//          overhead, resulting from multiple calls to the underlying process()
48//          per a single call to this class's process().
49template<class T, size_t bufSize>
50class AudioFormatAdapter {
51public:
52    // Configure the adapter.
53    // processor    The underlying audio processor.
54    // nChannels    Number of input and output channels. The adapter does not do
55    //              channel conversion - this parameter must be in sync with the
56    //              actual processor.
57    // pcmFormat    The desired input/output sample format.
58    // behavior     The desired behavior (overwrite or accumulate).
59    void configure(T & processor, int nChannels, uint8_t pcmFormat,
60                   uint32_t behavior) {
61        mpProcessor = &processor;
62        mNumChannels = nChannels;
63        mPcmFormat = pcmFormat;
64        mBehavior = behavior;
65        mMaxSamplesPerCall = bufSize / nChannels;
66    }
67
68    // Process a block of samples.
69    // pIn          A buffer of samples with the format specified on
70    //              configure().
71    // pOut         A buffer of samples with the format specified on
72    //              configure(). May be the same as pIn.
73    // numSamples   The number of multi-channel samples to process.
74    void process(const void * pIn, void * pOut, uint32_t numSamples) {
75        while (numSamples > 0) {
76            uint32_t numSamplesIter = min(numSamples, mMaxSamplesPerCall);
77            uint32_t nSamplesChannels = numSamplesIter * mNumChannels;
78            // This branch of "if" is untested
79            if (mPcmFormat == AUDIO_FORMAT_PCM_8_24_BIT) {
80                if (mBehavior == EFFECT_BUFFER_ACCESS_WRITE) {
81                    mpProcessor->process(
82                        reinterpret_cast<const audio_sample_t *> (pIn),
83                        reinterpret_cast<audio_sample_t *> (pOut),
84                        numSamplesIter);
85                } else if (mBehavior == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
86                    mpProcessor->process(
87                        reinterpret_cast<const audio_sample_t *> (pIn),
88                        mBuffer, numSamplesIter);
89                    MixOutput(pOut, numSamplesIter);
90                } else {
91                    assert(false);
92                }
93                pIn = reinterpret_cast<const audio_sample_t *> (pIn)
94                        + nSamplesChannels;
95                pOut = reinterpret_cast<audio_sample_t *> (pOut)
96                        + nSamplesChannels;
97            } else {
98                ConvertInput(pIn, nSamplesChannels);
99                mpProcessor->process(mBuffer, mBuffer, numSamplesIter);
100                ConvertOutput(pOut, nSamplesChannels);
101            }
102            numSamples -= numSamplesIter;
103        }
104    }
105
106private:
107    // The underlying processor.
108    T * mpProcessor;
109    // The number of input/output channels.
110    int mNumChannels;
111    // The desired PCM format.
112    uint8_t mPcmFormat;
113    // The desired buffer behavior.
114    uint32_t mBehavior;
115    // An intermediate buffer for processing.
116    audio_sample_t mBuffer[bufSize];
117    // The buffer size, divided by the number of channels - represents the
118    // maximum number of multi-channel samples that can be stored in the
119    // intermediate buffer.
120    size_t mMaxSamplesPerCall;
121
122    // Converts a buffer of input samples to audio_sample_t format.
123    // Output is written to the intermediate buffer.
124    // pIn          The input buffer with the format designated in configure().
125    //              When function exist will point to the next unread input
126    //              sample.
127    // numSamples   The number of single-channel samples to process.
128    void ConvertInput(const void *& pIn, uint32_t numSamples) {
129        if (mPcmFormat == AUDIO_FORMAT_PCM_16_BIT) {
130            const int16_t * pIn16 = reinterpret_cast<const int16_t *>(pIn);
131            audio_sample_t * pOut = mBuffer;
132            while (numSamples-- > 0) {
133                *(pOut++) = s15_to_audio_sample_t(*(pIn16++));
134            }
135            pIn = pIn16;
136        } else {
137            assert(false);
138        }
139    }
140
141    // Converts audio_sample_t samples from the intermediate buffer to the
142    // output buffer, converting to the desired format and buffer behavior.
143    // pOut         The buffer to write the output to.
144    //              When function exist will point to the next output sample.
145    // numSamples   The number of single-channel samples to process.
146    void ConvertOutput(void *& pOut, uint32_t numSamples) {
147        if (mPcmFormat == AUDIO_FORMAT_PCM_16_BIT) {
148            const audio_sample_t * pIn = mBuffer;
149            int16_t * pOut16 = reinterpret_cast<int16_t *>(pOut);
150            if (mBehavior == EFFECT_BUFFER_ACCESS_WRITE) {
151                while (numSamples-- > 0) {
152                    *(pOut16++) = audio_sample_t_to_s15_clip(*(pIn++));
153                }
154            } else if (mBehavior == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
155                while (numSamples-- > 0) {
156                    *(pOut16++) += audio_sample_t_to_s15_clip(*(pIn++));
157                }
158            } else {
159                assert(false);
160            }
161            pOut = pOut16;
162        } else {
163            assert(false);
164        }
165    }
166
167    // Accumulate data from the intermediate buffer to the output. Output is
168    // assumed to be of audio_sample_t type.
169    // pOut         The buffer to mix the output to.
170    //              When function exist will point to the next output sample.
171    // numSamples   The number of single-channel samples to process.
172    void MixOutput(void *& pOut, uint32_t numSamples) {
173        const audio_sample_t * pIn = mBuffer;
174        audio_sample_t * pOut24 = reinterpret_cast<audio_sample_t *>(pOut);
175        numSamples *= mNumChannels;
176        while (numSamples-- > 0) {
177            *(pOut24++) += *(pIn++);
178        }
179        pOut = pOut24;
180    }
181};
182
183}
184
185#endif // AUDIOFORMATADAPTER_H_
186