Home | History | Annotate | Download | only in audioflinger
      1 /*
      2 **
      3 ** Copyright 2007, 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 ANDROID_AUDIO_MIXER_H
     19 #define ANDROID_AUDIO_MIXER_H
     20 
     21 #include <stdint.h>
     22 #include <sys/types.h>
     23 
     24 #include <utils/threads.h>
     25 
     26 #include <media/AudioBufferProvider.h>
     27 #include "AudioResampler.h"
     28 
     29 #include <audio_effects/effect_downmix.h>
     30 #include <system/audio.h>
     31 
     32 namespace android {
     33 
     34 // ----------------------------------------------------------------------------
     35 
     36 class AudioMixer
     37 {
     38 public:
     39                             AudioMixer(size_t frameCount, uint32_t sampleRate,
     40                                        uint32_t maxNumTracks = MAX_NUM_TRACKS);
     41 
     42     /*virtual*/             ~AudioMixer();  // non-virtual saves a v-table, restore if sub-classed
     43 
     44     static const uint32_t MAX_NUM_TRACKS = 32;
     45     // maximum number of channels supported by the mixer
     46     static const uint32_t MAX_NUM_CHANNELS = 2;
     47     // maximum number of channels supported for the content
     48     static const uint32_t MAX_NUM_CHANNELS_TO_DOWNMIX = 8;
     49 
     50     static const uint16_t UNITY_GAIN = 0x1000;
     51 
     52     enum { // names
     53 
     54         // track names (MAX_NUM_TRACKS units)
     55         TRACK0          = 0x1000,
     56 
     57         // 0x2000 is unused
     58 
     59         // setParameter targets
     60         TRACK           = 0x3000,
     61         RESAMPLE        = 0x3001,
     62         RAMP_VOLUME     = 0x3002, // ramp to new volume
     63         VOLUME          = 0x3003, // don't ramp
     64 
     65         // set Parameter names
     66         // for target TRACK
     67         CHANNEL_MASK    = 0x4000,
     68         FORMAT          = 0x4001,
     69         MAIN_BUFFER     = 0x4002,
     70         AUX_BUFFER      = 0x4003,
     71         DOWNMIX_TYPE    = 0X4004,
     72         // for target RESAMPLE
     73         SAMPLE_RATE     = 0x4100, // Configure sample rate conversion on this track name;
     74                                   // parameter 'value' is the new sample rate in Hz.
     75                                   // Only creates a sample rate converter the first time that
     76                                   // the track sample rate is different from the mix sample rate.
     77                                   // If the new sample rate is the same as the mix sample rate,
     78                                   // and a sample rate converter already exists,
     79                                   // then the sample rate converter remains present but is a no-op.
     80         RESET           = 0x4101, // Reset sample rate converter without changing sample rate.
     81                                   // This clears out the resampler's input buffer.
     82         REMOVE          = 0x4102, // Remove the sample rate converter on this track name;
     83                                   // the track is restored to the mix sample rate.
     84         // for target RAMP_VOLUME and VOLUME (8 channels max)
     85         VOLUME0         = 0x4200,
     86         VOLUME1         = 0x4201,
     87         AUXLEVEL        = 0x4210,
     88     };
     89 
     90 
     91     // For all APIs with "name": TRACK0 <= name < TRACK0 + MAX_NUM_TRACKS
     92 
     93     // Allocate a track name.  Returns new track name if successful, -1 on failure.
     94     int         getTrackName(audio_channel_mask_t channelMask, int sessionId);
     95 
     96     // Free an allocated track by name
     97     void        deleteTrackName(int name);
     98 
     99     // Enable or disable an allocated track by name
    100     void        enable(int name);
    101     void        disable(int name);
    102 
    103     void        setParameter(int name, int target, int param, void *value);
    104 
    105     void        setBufferProvider(int name, AudioBufferProvider* bufferProvider);
    106     void        process(int64_t pts);
    107 
    108     uint32_t    trackNames() const { return mTrackNames; }
    109 
    110     size_t      getUnreleasedFrames(int name) const;
    111 
    112 private:
    113 
    114     enum {
    115         NEEDS_CHANNEL_COUNT__MASK   = 0x00000007,
    116         NEEDS_FORMAT__MASK          = 0x000000F0,
    117         NEEDS_MUTE__MASK            = 0x00000100,
    118         NEEDS_RESAMPLE__MASK        = 0x00001000,
    119         NEEDS_AUX__MASK             = 0x00010000,
    120     };
    121 
    122     enum {
    123         NEEDS_CHANNEL_1             = 0x00000000,
    124         NEEDS_CHANNEL_2             = 0x00000001,
    125 
    126         NEEDS_FORMAT_16             = 0x00000010,
    127 
    128         NEEDS_MUTE_DISABLED         = 0x00000000,
    129         NEEDS_MUTE_ENABLED          = 0x00000100,
    130 
    131         NEEDS_RESAMPLE_DISABLED     = 0x00000000,
    132         NEEDS_RESAMPLE_ENABLED      = 0x00001000,
    133 
    134         NEEDS_AUX_DISABLED     = 0x00000000,
    135         NEEDS_AUX_ENABLED      = 0x00010000,
    136     };
    137 
    138     struct state_t;
    139     struct track_t;
    140     class DownmixerBufferProvider;
    141 
    142     typedef void (*hook_t)(track_t* t, int32_t* output, size_t numOutFrames, int32_t* temp, int32_t* aux);
    143     static const int BLOCKSIZE = 16; // 4 cache lines
    144 
    145     struct track_t {
    146         uint32_t    needs;
    147 
    148         union {
    149         int16_t     volume[MAX_NUM_CHANNELS]; // [0]3.12 fixed point
    150         int32_t     volumeRL;
    151         };
    152 
    153         int32_t     prevVolume[MAX_NUM_CHANNELS];
    154 
    155         // 16-byte boundary
    156 
    157         int32_t     volumeInc[MAX_NUM_CHANNELS];
    158         int32_t     auxInc;
    159         int32_t     prevAuxLevel;
    160 
    161         // 16-byte boundary
    162 
    163         int16_t     auxLevel;       // 0 <= auxLevel <= MAX_GAIN_INT, but signed for mul performance
    164         uint16_t    frameCount;
    165 
    166         uint8_t     channelCount;   // 1 or 2, redundant with (needs & NEEDS_CHANNEL_COUNT__MASK)
    167         uint8_t     format;         // always 16
    168         uint16_t    enabled;        // actually bool
    169         audio_channel_mask_t channelMask;
    170 
    171         // actual buffer provider used by the track hooks, see DownmixerBufferProvider below
    172         //  for how the Track buffer provider is wrapped by another one when dowmixing is required
    173         AudioBufferProvider*                bufferProvider;
    174 
    175         // 16-byte boundary
    176 
    177         mutable AudioBufferProvider::Buffer buffer; // 8 bytes
    178 
    179         hook_t      hook;
    180         const void* in;             // current location in buffer
    181 
    182         // 16-byte boundary
    183 
    184         AudioResampler*     resampler;
    185         uint32_t            sampleRate;
    186         int32_t*           mainBuffer;
    187         int32_t*           auxBuffer;
    188 
    189         // 16-byte boundary
    190 
    191         uint64_t    localTimeFreq;
    192 
    193         DownmixerBufferProvider* downmixerBufferProvider; // 4 bytes
    194 
    195         int32_t     sessionId;
    196 
    197         // 16-byte boundary
    198 
    199         bool        setResampler(uint32_t sampleRate, uint32_t devSampleRate);
    200         bool        doesResample() const { return resampler != NULL; }
    201         void        resetResampler() { if (resampler != NULL) resampler->reset(); }
    202         void        adjustVolumeRamp(bool aux);
    203         size_t      getUnreleasedFrames() const { return resampler != NULL ?
    204                                                     resampler->getUnreleasedFrames() : 0; };
    205     };
    206 
    207     // pad to 32-bytes to fill cache line
    208     struct state_t {
    209         uint32_t        enabledTracks;
    210         uint32_t        needsChanged;
    211         size_t          frameCount;
    212         void            (*hook)(state_t* state, int64_t pts);   // one of process__*, never NULL
    213         int32_t         *outputTemp;
    214         int32_t         *resampleTemp;
    215         int32_t         reserved[2];
    216         // FIXME allocate dynamically to save some memory when maxNumTracks < MAX_NUM_TRACKS
    217         track_t         tracks[MAX_NUM_TRACKS]; __attribute__((aligned(32)));
    218     };
    219 
    220     // AudioBufferProvider that wraps a track AudioBufferProvider by a call to a downmix effect
    221     class DownmixerBufferProvider : public AudioBufferProvider {
    222     public:
    223         virtual status_t getNextBuffer(Buffer* buffer, int64_t pts);
    224         virtual void releaseBuffer(Buffer* buffer);
    225         DownmixerBufferProvider();
    226         virtual ~DownmixerBufferProvider();
    227 
    228         AudioBufferProvider* mTrackBufferProvider;
    229         effect_handle_t    mDownmixHandle;
    230         effect_config_t    mDownmixConfig;
    231     };
    232 
    233     // bitmask of allocated track names, where bit 0 corresponds to TRACK0 etc.
    234     uint32_t        mTrackNames;
    235 
    236     // bitmask of configured track names; ~0 if maxNumTracks == MAX_NUM_TRACKS,
    237     // but will have fewer bits set if maxNumTracks < MAX_NUM_TRACKS
    238     const uint32_t  mConfiguredNames;
    239 
    240     const uint32_t  mSampleRate;
    241 
    242     state_t         mState __attribute__((aligned(32)));
    243 
    244     // effect descriptor for the downmixer used by the mixer
    245     static effect_descriptor_t dwnmFxDesc;
    246     // indicates whether a downmix effect has been found and is usable by this mixer
    247     static bool                isMultichannelCapable;
    248 
    249     // Call after changing either the enabled status of a track, or parameters of an enabled track.
    250     // OK to call more often than that, but unnecessary.
    251     void invalidateState(uint32_t mask);
    252 
    253     static status_t initTrackDownmix(track_t* pTrack, int trackNum, audio_channel_mask_t mask);
    254     static status_t prepareTrackForDownmix(track_t* pTrack, int trackNum);
    255     static void unprepareTrackForDownmix(track_t* pTrack, int trackName);
    256 
    257     static void track__genericResample(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
    258     static void track__nop(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
    259     static void track__16BitsStereo(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
    260     static void track__16BitsMono(track_t* t, int32_t* out, size_t numFrames, int32_t* temp, int32_t* aux);
    261     static void volumeRampStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux);
    262     static void volumeStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux);
    263 
    264     static void process__validate(state_t* state, int64_t pts);
    265     static void process__nop(state_t* state, int64_t pts);
    266     static void process__genericNoResampling(state_t* state, int64_t pts);
    267     static void process__genericResampling(state_t* state, int64_t pts);
    268     static void process__OneTrack16BitsStereoNoResampling(state_t* state,
    269                                                           int64_t pts);
    270 #if 0
    271     static void process__TwoTracks16BitsStereoNoResampling(state_t* state,
    272                                                            int64_t pts);
    273 #endif
    274 
    275     static int64_t calculateOutputPTS(const track_t& t, int64_t basePTS,
    276                                       int outputFrameIndex);
    277 };
    278 
    279 // ----------------------------------------------------------------------------
    280 }; // namespace android
    281 
    282 #endif // ANDROID_AUDIO_MIXER_H
    283