1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef FRAMEWORKS_EX_VARIABLESPEED_JNI_VARIABLESPEED_H_
18#define FRAMEWORKS_EX_VARIABLESPEED_JNI_VARIABLESPEED_H_
19
20#include <jni.h>
21
22#include <SLES/OpenSLES.h>
23#include <SLES/OpenSLES_Android.h>
24#include <SLES/OpenSLES_AndroidConfiguration.h>
25
26#include <integral_types.h>
27#include <utils/threads.h>
28
29#include <profile_timer.h>
30#include <decode_buffer.h>
31
32#include <queue>
33#include <stack>
34
35namespace video_editing {
36  class SolaTimeScaler;
37}
38
39// This is the audio engine class.
40// It forms the bulk  of the variablespeed library.
41// It should not be used directly, but rather used indirectly from the java
42// native methods.
43class AudioEngine {
44 public:
45  AudioEngine(size_t targetFrames, float windowDuration,
46      float windowOverlapDuration, size_t maxPlayBufferCount,
47      float initialRate, size_t decodeInitialSize, size_t decodeMaxSize,
48      size_t startPositionMillis, int audioStreamType);
49  virtual ~AudioEngine();
50
51  bool PlayUri(const char* uri);
52  bool PlayFileDescriptor(int fd, int64 offset, int64 length);
53  void SetVariableSpeed(float speed);
54  void RequestStart();
55  void RequestStop();
56  int GetCurrentPosition();
57  int GetTotalDuration();
58
59  void DecodingBufferQueueCallback(
60      SLAndroidSimpleBufferQueueItf queueItf, void *context);
61  void DecodingEventCallback(SLPlayItf caller, SLuint32 event);
62  void PrefetchEventCallback(SLPrefetchStatusItf caller, SLuint32 event);
63  void PlayingBufferQueueCallback();
64
65  static AudioEngine* GetEngine();
66  static void SetEngine(AudioEngine* engine);
67  static bool CompareAndSetEngine(AudioEngine* expect, AudioEngine* update);
68  static void DeleteEngine();
69
70 private:
71  bool PlayFromThisSource(const SLDataSource& audioSrc);
72  void EnqueueMoreAudioIfNecessary(SLAndroidSimpleBufferQueueItf bufferQueue);
73  bool EnqueueNextBufferOfAudio(SLAndroidSimpleBufferQueueItf bufferQueue);
74  void PrefetchDurationSampleRateAndChannels(
75      SLPlayItf playItf, SLPrefetchStatusItf prefetchItf);
76  video_editing::SolaTimeScaler* GetTimeScaler();
77  bool Finished();
78  bool GetWasStartRequested();
79  bool GetWasStopRequested();
80  void ClearRequestStart();
81  void SetEndOfDecoderReached();
82  bool GetEndOfDecoderReached();
83  bool DecodeBufferTooFull();
84  void ClearDecodeBuffer();
85  bool IsDecodeBufferEmpty();
86  bool GetHasReachedPlayingBuffersLimit();
87  bool HasSampleRateAndChannels();
88  SLuint32 GetSLSampleRate();
89  SLuint32 GetSLChannels();
90  SLuint32 GetChannelCount();
91
92  // The single global audio engine instance.
93  static AudioEngine* audioEngine_;
94
95  // Protects access to the shared decode buffer.
96  android::Mutex decodeBufferLock_;
97  // Buffer into which we put the audio data as we decode.
98  // Protected by decodeBufferLock_.
99  DecodeBuffer decodeBuffer_;
100
101  // Protects access to the playingBuffers_ and freeBuffers_.
102  android::Mutex playBufferLock_;
103  // The buffers we're using for playback.
104  std::queue<int16*> playingBuffers_;
105  std::stack<int16*> freeBuffers_;
106
107  // The time scaler.
108  video_editing::SolaTimeScaler* timeScaler_;
109
110  // The frame buffer, used for converting between PCM data and float for
111  // time scaler.
112  float* floatBuffer_;
113  float* injectBuffer_;
114
115  // Required when we create the audio player.
116  // Set during the first callback from the decoder.
117  // Guarded by callbackLock_.
118  SLuint32 mSampleRate;
119  SLuint32 mChannels;
120
121  size_t targetFrames_;
122  float windowDuration_;
123  float windowOverlapDuration_;
124  size_t maxPlayBufferCount_;
125  float initialRate_;
126  size_t startPositionMillis_;
127  // The type of audio stream as defined by the STREAM_XXX constants in
128  // android.media.AudioManager. These constant values actually match the
129  // corresponding SL_ANDROID_STREAM_XXX constants defined by
130  // include/SLES/OpenSLES_AndroidConfiguration.h
131  int audioStreamType_;
132
133  // The prefetch callback signal, for letting the prefetch callback method
134  // indicate when it is done.
135  android::Mutex prefetchLock_;
136  android::Condition prefetchCondition_;
137
138  // Protects access to the CallbackContext object.
139  // I don't believe this to be necessary, I think that it's thread-confined,
140  // but it also won't do any harm.
141  android::Mutex callbackLock_;
142
143  // Protects access to the shared member variables below.
144  android::Mutex lock_;
145  // Protected by lock_.
146  // Stores the total duration of the track.
147  SLmillisecond totalDurationMs_;
148  // Protected by lock_.
149  // Stores the current position of the decoder head.
150  SLmillisecond decoderCurrentPosition_;
151  // Protected by lock_.
152  // Set externally via RequestStart(), this determines when we begin to
153  // playback audio.
154  // Until this is set to true, our audio player will remain stopped.
155  bool startRequested_;
156  // Protected by lock_.
157  // Set externally via RequestStop(), this tells us top stop playing
158  // and therefore shut everything down.
159  bool stopRequested_;
160  // Protected by lock_.
161  // This is set to true once we reach the end of the decoder stream.
162  bool finishedDecoding_;
163
164  DISALLOW_COPY_AND_ASSIGN(AudioEngine);
165};
166
167#endif  // FRAMEWORKS_EX_VARIABLESPEED_JNI_VARIABLESPEED_H_
168