NuPlayerRenderer.h revision c387f2b719a1a26c8306f77d79cc9a6f26b36813 
1/*
2 * Copyright (C) 2010 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 NUPLAYER_RENDERER_H_
18
19#define NUPLAYER_RENDERER_H_
20
21#include <media/AudioResamplerPublic.h>
22#include <media/AVSyncSettings.h>
23
24#include "NuPlayer.h"
25
26namespace android {
27
28class  AWakeLock;
29struct MediaClock;
30class MediaCodecBuffer;
31struct VideoFrameScheduler;
32
33struct NuPlayer::Renderer : public AHandler {
34    enum Flags {
35        FLAG_REAL_TIME = 1,
36        FLAG_OFFLOAD_AUDIO = 2,
37    };
38    Renderer(const sp<MediaPlayerBase::AudioSink> &sink,
39             const sp<AMessage> &notify,
40             uint32_t flags = 0);
41
42    static size_t AudioSinkCallback(
43            MediaPlayerBase::AudioSink *audioSink,
44            void *data, size_t size, void *me,
45            MediaPlayerBase::AudioSink::cb_event_t event);
46
47    void queueBuffer(
48            bool audio,
49            const sp<MediaCodecBuffer> &buffer,
50            const sp<AMessage> &notifyConsumed);
51
52    void queueEOS(bool audio, status_t finalResult);
53
54    status_t setPlaybackSettings(const AudioPlaybackRate &rate /* sanitized */);
55    status_t getPlaybackSettings(AudioPlaybackRate *rate /* nonnull */);
56    status_t setSyncSettings(const AVSyncSettings &sync, float videoFpsHint);
57    status_t getSyncSettings(AVSyncSettings *sync /* nonnull */, float *videoFps /* nonnull */);
58
59    void flush(bool audio, bool notifyComplete);
60
61    void signalTimeDiscontinuity();
62
63    void signalDisableOffloadAudio();
64    void signalEnableOffloadAudio();
65
66    void pause();
67    void resume();
68
69    void setVideoFrameRate(float fps);
70
71    status_t getCurrentPosition(int64_t *mediaUs);
72    int64_t getVideoLateByUs();
73
74    status_t openAudioSink(
75            const sp<AMessage> &format,
76            bool offloadOnly,
77            bool hasVideo,
78            uint32_t flags,
79            bool *isOffloaded,
80            bool isStreaming);
81    void closeAudioSink();
82
83    // re-open audio sink after all pending audio buffers played.
84    void changeAudioFormat(
85            const sp<AMessage> &format,
86            bool offloadOnly,
87            bool hasVideo,
88            uint32_t flags,
89            bool isStreaming,
90            const sp<AMessage> &notify);
91
92    enum {
93        kWhatEOS                      = 'eos ',
94        kWhatFlushComplete            = 'fluC',
95        kWhatPosition                 = 'posi',
96        kWhatVideoRenderingStart      = 'vdrd',
97        kWhatMediaRenderingStart      = 'mdrd',
98        kWhatAudioTearDown            = 'adTD',
99        kWhatAudioOffloadPauseTimeout = 'aOPT',
100    };
101
102    enum AudioTearDownReason {
103        kDueToError = 0,   // Could restart with either offload or non-offload.
104        kDueToTimeout,
105        kForceNonOffload,  // Restart only with non-offload.
106    };
107
108protected:
109    virtual ~Renderer();
110
111    virtual void onMessageReceived(const sp<AMessage> &msg);
112
113private:
114    enum {
115        kWhatDrainAudioQueue     = 'draA',
116        kWhatDrainVideoQueue     = 'draV',
117        kWhatPostDrainVideoQueue = 'pDVQ',
118        kWhatQueueBuffer         = 'queB',
119        kWhatQueueEOS            = 'qEOS',
120        kWhatConfigPlayback      = 'cfPB',
121        kWhatConfigSync          = 'cfSy',
122        kWhatGetPlaybackSettings = 'gPbS',
123        kWhatGetSyncSettings     = 'gSyS',
124        kWhatFlush               = 'flus',
125        kWhatPause               = 'paus',
126        kWhatResume              = 'resm',
127        kWhatOpenAudioSink       = 'opnA',
128        kWhatCloseAudioSink      = 'clsA',
129        kWhatChangeAudioFormat   = 'chgA',
130        kWhatStopAudioSink       = 'stpA',
131        kWhatDisableOffloadAudio = 'noOA',
132        kWhatEnableOffloadAudio  = 'enOA',
133        kWhatSetVideoFrameRate   = 'sVFR',
134    };
135
136    // if mBuffer != nullptr, it's a buffer containing real data.
137    // else if mNotifyConsumed == nullptr, it's EOS.
138    // else it's a tag for re-opening audio sink in different format.
139    struct QueueEntry {
140        sp<MediaCodecBuffer> mBuffer;
141        sp<AMessage> mMeta;
142        sp<AMessage> mNotifyConsumed;
143        size_t mOffset;
144        status_t mFinalResult;
145        int32_t mBufferOrdinal;
146    };
147
148    static const int64_t kMinPositionUpdateDelayUs;
149
150    sp<MediaPlayerBase::AudioSink> mAudioSink;
151    bool mUseVirtualAudioSink;
152    sp<AMessage> mNotify;
153    Mutex mLock;
154    uint32_t mFlags;
155    List<QueueEntry> mAudioQueue;
156    List<QueueEntry> mVideoQueue;
157    uint32_t mNumFramesWritten;
158    sp<VideoFrameScheduler> mVideoScheduler;
159
160    bool mDrainAudioQueuePending;
161    bool mDrainVideoQueuePending;
162    int32_t mAudioQueueGeneration;
163    int32_t mVideoQueueGeneration;
164    int32_t mAudioDrainGeneration;
165    int32_t mVideoDrainGeneration;
166    int32_t mAudioEOSGeneration;
167
168    sp<MediaClock> mMediaClock;
169    float mPlaybackRate; // audio track rate
170
171    AudioPlaybackRate mPlaybackSettings;
172    AVSyncSettings mSyncSettings;
173    float mVideoFpsHint;
174
175    int64_t mAudioFirstAnchorTimeMediaUs;
176    int64_t mAnchorTimeMediaUs;
177    int64_t mAnchorNumFramesWritten;
178    int64_t mVideoLateByUs;
179    bool mHasAudio;
180    bool mHasVideo;
181
182    bool mNotifyCompleteAudio;
183    bool mNotifyCompleteVideo;
184
185    bool mSyncQueues;
186
187    // modified on only renderer's thread.
188    bool mPaused;
189    int64_t mPauseDrainAudioAllowedUs; // time when we can drain/deliver audio in pause mode.
190
191    bool mVideoSampleReceived;
192    bool mVideoRenderingStarted;
193    int32_t mVideoRenderingStartGeneration;
194    int32_t mAudioRenderingStartGeneration;
195    bool mRenderingDataDelivered;
196
197    int64_t mNextAudioClockUpdateTimeUs;
198    // the media timestamp of last audio sample right before EOS.
199    int64_t mLastAudioMediaTimeUs;
200
201    int32_t mAudioOffloadPauseTimeoutGeneration;
202    bool mAudioTornDown;
203    audio_offload_info_t mCurrentOffloadInfo;
204
205    struct PcmInfo {
206        audio_channel_mask_t mChannelMask;
207        audio_output_flags_t mFlags;
208        audio_format_t mFormat;
209        int32_t mNumChannels;
210        int32_t mSampleRate;
211    };
212    PcmInfo mCurrentPcmInfo;
213    static const PcmInfo AUDIO_PCMINFO_INITIALIZER;
214
215    int32_t mTotalBuffersQueued;
216    int32_t mLastAudioBufferDrained;
217    bool mUseAudioCallback;
218
219    sp<AWakeLock> mWakeLock;
220
221    status_t getCurrentPositionOnLooper(int64_t *mediaUs);
222    status_t getCurrentPositionOnLooper(
223            int64_t *mediaUs, int64_t nowUs, bool allowPastQueuedVideo = false);
224    bool getCurrentPositionIfPaused_l(int64_t *mediaUs);
225    status_t getCurrentPositionFromAnchor(
226            int64_t *mediaUs, int64_t nowUs, bool allowPastQueuedVideo = false);
227
228    void notifyEOSCallback();
229    size_t fillAudioBuffer(void *buffer, size_t size);
230
231    bool onDrainAudioQueue();
232    void drainAudioQueueUntilLastEOS();
233    int64_t getPendingAudioPlayoutDurationUs(int64_t nowUs);
234    void postDrainAudioQueue_l(int64_t delayUs = 0);
235
236    void clearAnchorTime();
237    void clearAudioFirstAnchorTime_l();
238    void setAudioFirstAnchorTimeIfNeeded_l(int64_t mediaUs);
239    void setVideoLateByUs(int64_t lateUs);
240
241    void onNewAudioMediaTime(int64_t mediaTimeUs);
242    int64_t getRealTimeUs(int64_t mediaTimeUs, int64_t nowUs);
243
244    void onDrainVideoQueue();
245    void postDrainVideoQueue();
246
247    void prepareForMediaRenderingStart_l();
248    void notifyIfMediaRenderingStarted_l();
249
250    void onQueueBuffer(const sp<AMessage> &msg);
251    void onQueueEOS(const sp<AMessage> &msg);
252    void onFlush(const sp<AMessage> &msg);
253    void onAudioSinkChanged();
254    void onDisableOffloadAudio();
255    void onEnableOffloadAudio();
256    status_t onConfigPlayback(const AudioPlaybackRate &rate /* sanitized */);
257    status_t onGetPlaybackSettings(AudioPlaybackRate *rate /* nonnull */);
258    status_t onConfigSync(const AVSyncSettings &sync, float videoFpsHint);
259    status_t onGetSyncSettings(AVSyncSettings *sync /* nonnull */, float *videoFps /* nonnull */);
260
261    void onPause();
262    void onResume();
263    void onSetVideoFrameRate(float fps);
264    int32_t getQueueGeneration(bool audio);
265    int32_t getDrainGeneration(bool audio);
266    bool getSyncQueues();
267    void onAudioTearDown(AudioTearDownReason reason);
268    status_t onOpenAudioSink(
269            const sp<AMessage> &format,
270            bool offloadOnly,
271            bool hasVideo,
272            uint32_t flags,
273            bool isStreaming);
274    void onCloseAudioSink();
275    void onChangeAudioFormat(const sp<AMessage> &meta, const sp<AMessage> &notify);
276
277    void notifyEOS(bool audio, status_t finalResult, int64_t delayUs = 0);
278    void notifyFlushComplete(bool audio);
279    void notifyPosition();
280    void notifyVideoLateBy(int64_t lateByUs);
281    void notifyVideoRenderingStart();
282    void notifyAudioTearDown(AudioTearDownReason reason);
283
284    void flushQueue(List<QueueEntry> *queue);
285    bool dropBufferIfStale(bool audio, const sp<AMessage> &msg);
286    void syncQueuesDone_l();
287
288    bool offloadingAudio() const { return (mFlags & FLAG_OFFLOAD_AUDIO) != 0; }
289
290    void startAudioOffloadPauseTimeout();
291    void cancelAudioOffloadPauseTimeout();
292
293    int64_t getDurationUsIfPlayedAtSampleRate(uint32_t numFrames);
294
295    DISALLOW_EVIL_CONSTRUCTORS(Renderer);
296};
297
298} // namespace android
299
300#endif  // NUPLAYER_RENDERER_H_
301