Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2009 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 AWESOME_PLAYER_H_ |
| 18 | |
| 19 | #define AWESOME_PLAYER_H_ |
| 20 | |
Andreas Huber | 1156dc9 | 2011-03-08 15:59:28 -0800 | [diff] [blame] | 21 | #include "HTTPBase.h" |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 22 | #include "TimedEventQueue.h" |
| 23 | |
| 24 | #include <media/MediaPlayerInterface.h> |
Andreas Huber | fa090f5 | 2010-02-12 14:40:08 -0800 | [diff] [blame] | 25 | #include <media/stagefright/DataSource.h> |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 26 | #include <media/stagefright/OMXClient.h> |
Andreas Huber | 5d2de4d | 2010-07-07 13:35:27 -0700 | [diff] [blame] | 27 | #include <media/stagefright/TimeSource.h> |
Richard Fitzgerald | ad3af33 | 2013-03-25 16:54:37 +0000 | [diff] [blame] | 28 | #include <media/stagefright/MetaData.h> |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 29 | #include <utils/threads.h> |
Gloria Wang | dcd25ef | 2010-06-22 13:55:38 -0700 | [diff] [blame] | 30 | #include <drm/DrmManagerClient.h> |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 31 | |
| 32 | namespace android { |
| 33 | |
Andreas Huber | 66b0a35 | 2010-01-26 16:20:10 -0800 | [diff] [blame] | 34 | struct AudioPlayer; |
Andreas Huber | 7b3396a | 2010-02-12 10:42:02 -0800 | [diff] [blame] | 35 | struct DataSource; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 36 | struct MediaBuffer; |
| 37 | struct MediaExtractor; |
| 38 | struct MediaSource; |
Andreas Huber | 0a5baa9 | 2010-06-10 11:17:50 -0700 | [diff] [blame] | 39 | struct NuCachedSource2; |
Andy McFadden | 8ba0102 | 2012-12-18 09:46:54 -0800 | [diff] [blame] | 40 | struct IGraphicBufferProducer; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 41 | |
Gloria Wang | dcd25ef | 2010-06-22 13:55:38 -0700 | [diff] [blame] | 42 | class DrmManagerClinet; |
| 43 | class DecryptHandle; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 44 | |
Insun Kang | 6655174 | 2012-01-11 22:03:12 +0900 | [diff] [blame] | 45 | class TimedTextDriver; |
Andreas Huber | 681755f | 2011-04-21 10:06:43 -0700 | [diff] [blame] | 46 | struct WVMExtractor; |
Gloria Wang | 7a1e3e8 | 2011-05-03 15:59:03 -0700 | [diff] [blame] | 47 | |
Andreas Huber | 733b772 | 2009-12-14 14:18:22 -0800 | [diff] [blame] | 48 | struct AwesomeRenderer : public RefBase { |
| 49 | AwesomeRenderer() {} |
| 50 | |
| 51 | virtual void render(MediaBuffer *buffer) = 0; |
| 52 | |
| 53 | private: |
| 54 | AwesomeRenderer(const AwesomeRenderer &); |
| 55 | AwesomeRenderer &operator=(const AwesomeRenderer &); |
| 56 | }; |
| 57 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 58 | struct AwesomePlayer { |
| 59 | AwesomePlayer(); |
| 60 | ~AwesomePlayer(); |
| 61 | |
Andreas Huber | 0726045 | 2010-01-21 10:28:45 -0800 | [diff] [blame] | 62 | void setListener(const wp<MediaPlayerBase> &listener); |
Andreas Huber | 9b80c2b | 2011-06-30 15:47:02 -0700 | [diff] [blame] | 63 | void setUID(uid_t uid); |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 64 | |
Andreas Huber | 5561ccf | 2010-01-27 16:49:05 -0800 | [diff] [blame] | 65 | status_t setDataSource( |
| 66 | const char *uri, |
| 67 | const KeyedVector<String8, String8> *headers = NULL); |
| 68 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 69 | status_t setDataSource(int fd, int64_t offset, int64_t length); |
| 70 | |
Andreas Huber | e2b1028 | 2010-11-23 11:41:34 -0800 | [diff] [blame] | 71 | status_t setDataSource(const sp<IStreamSource> &source); |
| 72 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 73 | void reset(); |
| 74 | |
Andreas Huber | c23f12a | 2010-02-08 14:40:30 -0800 | [diff] [blame] | 75 | status_t prepare(); |
Andreas Huber | bd22c52 | 2010-02-09 14:05:43 -0800 | [diff] [blame] | 76 | status_t prepare_l(); |
Andreas Huber | c23f12a | 2010-02-08 14:40:30 -0800 | [diff] [blame] | 77 | status_t prepareAsync(); |
| 78 | status_t prepareAsync_l(); |
| 79 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 80 | status_t play(); |
| 81 | status_t pause(); |
| 82 | |
| 83 | bool isPlaying() const; |
| 84 | |
Andy McFadden | 8ba0102 | 2012-12-18 09:46:54 -0800 | [diff] [blame] | 85 | status_t setSurfaceTexture(const sp<IGraphicBufferProducer> &bufferProducer); |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 86 | void setAudioSink(const sp<MediaPlayerBase::AudioSink> &audioSink); |
| 87 | status_t setLooping(bool shouldLoop); |
| 88 | |
| 89 | status_t getDuration(int64_t *durationUs); |
| 90 | status_t getPosition(int64_t *positionUs); |
| 91 | |
Gloria Wang | 4f9e47f | 2011-04-25 17:28:22 -0700 | [diff] [blame] | 92 | status_t setParameter(int key, const Parcel &request); |
| 93 | status_t getParameter(int key, Parcel *reply); |
Insun Kang | f9d660a | 2012-02-16 20:28:27 +0900 | [diff] [blame] | 94 | status_t invoke(const Parcel &request, Parcel *reply); |
James Dong | 5b1b8a9 | 2011-05-25 19:37:03 -0700 | [diff] [blame] | 95 | status_t setCacheStatCollectFreq(const Parcel &request); |
Gloria Wang | 4f9e47f | 2011-04-25 17:28:22 -0700 | [diff] [blame] | 96 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 97 | status_t seekTo(int64_t timeUs); |
| 98 | |
Andreas Huber | acdd9d0 | 2010-05-06 10:18:05 -0700 | [diff] [blame] | 99 | // This is a mask of MediaExtractor::Flags. |
| 100 | uint32_t flags() const; |
| 101 | |
Andreas Huber | 84b343f | 2011-03-22 10:31:21 -0700 | [diff] [blame] | 102 | void postAudioEOS(int64_t delayUs = 0ll); |
Andreas Huber | ed54ad0 | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 103 | void postAudioSeekComplete(); |
Richard Fitzgerald | ad3af33 | 2013-03-25 16:54:37 +0000 | [diff] [blame] | 104 | void postAudioTearDown(); |
Andreas Huber | a0b1d4b | 2011-06-07 15:52:25 -0700 | [diff] [blame] | 105 | status_t dump(int fd, const Vector<String16> &args) const; |
| 106 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 107 | private: |
| 108 | friend struct AwesomeEvent; |
Dharmaray Kundargi | ccb3506 | 2011-01-16 16:43:20 -0800 | [diff] [blame] | 109 | friend struct PreviewPlayer; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 110 | |
Andreas Huber | acdd9d0 | 2010-05-06 10:18:05 -0700 | [diff] [blame] | 111 | enum { |
Gloria Wang | 7a1e3e8 | 2011-05-03 15:59:03 -0700 | [diff] [blame] | 112 | PLAYING = 0x01, |
| 113 | LOOPING = 0x02, |
| 114 | FIRST_FRAME = 0x04, |
| 115 | PREPARING = 0x08, |
| 116 | PREPARED = 0x10, |
| 117 | AT_EOS = 0x20, |
| 118 | PREPARE_CANCELLED = 0x40, |
| 119 | CACHE_UNDERRUN = 0x80, |
| 120 | AUDIO_AT_EOS = 0x0100, |
| 121 | VIDEO_AT_EOS = 0x0200, |
| 122 | AUTO_LOOPING = 0x0400, |
Andreas Huber | 6a05c9e | 2010-10-19 12:18:51 -0700 | [diff] [blame] | 123 | |
| 124 | // We are basically done preparing but are currently buffering |
| 125 | // sufficient data to begin playback and finish the preparation phase |
| 126 | // for good. |
Gloria Wang | 7a1e3e8 | 2011-05-03 15:59:03 -0700 | [diff] [blame] | 127 | PREPARING_CONNECTED = 0x0800, |
Andreas Huber | 2b1222f | 2011-02-07 11:43:12 -0800 | [diff] [blame] | 128 | |
| 129 | // We're triggering a single video event to display the first frame |
| 130 | // after the seekpoint. |
Gloria Wang | 7a1e3e8 | 2011-05-03 15:59:03 -0700 | [diff] [blame] | 131 | SEEK_PREVIEW = 0x1000, |
Andreas Huber | f030344 | 2011-02-11 13:09:36 -0800 | [diff] [blame] | 132 | |
Gloria Wang | 7a1e3e8 | 2011-05-03 15:59:03 -0700 | [diff] [blame] | 133 | AUDIO_RUNNING = 0x2000, |
| 134 | AUDIOPLAYER_STARTED = 0x4000, |
Andreas Huber | 7314fa1 | 2011-02-24 14:42:48 -0800 | [diff] [blame] | 135 | |
Gloria Wang | 7a1e3e8 | 2011-05-03 15:59:03 -0700 | [diff] [blame] | 136 | INCOGNITO = 0x8000, |
| 137 | |
| 138 | TEXT_RUNNING = 0x10000, |
Insun Kang | f9d660a | 2012-02-16 20:28:27 +0900 | [diff] [blame] | 139 | TEXTPLAYER_INITIALIZED = 0x20000, |
James Dong | 14f9574 | 2011-08-11 17:38:35 -0700 | [diff] [blame] | 140 | |
| 141 | SLOW_DECODER_HACK = 0x40000, |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 142 | }; |
| 143 | |
| 144 | mutable Mutex mLock; |
Andreas Huber | 2415ecb | 2010-03-26 10:17:17 -0700 | [diff] [blame] | 145 | Mutex mMiscStateLock; |
Andreas Huber | a0b1d4b | 2011-06-07 15:52:25 -0700 | [diff] [blame] | 146 | mutable Mutex mStatsLock; |
Andreas Huber | 02f6e98 | 2011-09-01 11:39:11 -0700 | [diff] [blame] | 147 | Mutex mAudioLock; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 148 | |
| 149 | OMXClient mClient; |
| 150 | TimedEventQueue mQueue; |
Andreas Huber | 2e8ffaf | 2010-02-18 16:45:13 -0800 | [diff] [blame] | 151 | bool mQueueStarted; |
Andreas Huber | 0726045 | 2010-01-21 10:28:45 -0800 | [diff] [blame] | 152 | wp<MediaPlayerBase> mListener; |
Andreas Huber | 9b80c2b | 2011-06-30 15:47:02 -0700 | [diff] [blame] | 153 | bool mUIDValid; |
| 154 | uid_t mUID; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 155 | |
Glenn Kasten | 1173118 | 2011-02-08 17:26:17 -0800 | [diff] [blame] | 156 | sp<ANativeWindow> mNativeWindow; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 157 | sp<MediaPlayerBase::AudioSink> mAudioSink; |
| 158 | |
Andreas Huber | 5d2de4d | 2010-07-07 13:35:27 -0700 | [diff] [blame] | 159 | SystemTimeSource mSystemTimeSource; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 160 | TimeSource *mTimeSource; |
| 161 | |
Andreas Huber | bd22c52 | 2010-02-09 14:05:43 -0800 | [diff] [blame] | 162 | String8 mUri; |
| 163 | KeyedVector<String8, String8> mUriHeaders; |
| 164 | |
Andreas Huber | 7b3396a | 2010-02-12 10:42:02 -0800 | [diff] [blame] | 165 | sp<DataSource> mFileSource; |
| 166 | |
Andreas Huber | 88d8a83 | 2010-03-05 10:42:10 -0800 | [diff] [blame] | 167 | sp<MediaSource> mVideoTrack; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 168 | sp<MediaSource> mVideoSource; |
Andreas Huber | 733b772 | 2009-12-14 14:18:22 -0800 | [diff] [blame] | 169 | sp<AwesomeRenderer> mVideoRenderer; |
James Dong | c374dae | 2012-07-19 19:18:06 -0700 | [diff] [blame] | 170 | bool mVideoRenderingStarted; |
Andreas Huber | fa090f5 | 2010-02-12 14:40:08 -0800 | [diff] [blame] | 171 | bool mVideoRendererIsPreview; |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame^] | 172 | int32_t mMediaRenderingStartGeneration; |
| 173 | int32_t mStartGeneration; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 174 | |
James Dong | ab7a2e5 | 2012-04-26 17:11:28 -0700 | [diff] [blame] | 175 | ssize_t mActiveAudioTrackIndex; |
Andreas Huber | 88d8a83 | 2010-03-05 10:42:10 -0800 | [diff] [blame] | 176 | sp<MediaSource> mAudioTrack; |
Richard Fitzgerald | ad3af33 | 2013-03-25 16:54:37 +0000 | [diff] [blame] | 177 | sp<MediaSource> mOmxSource; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 178 | sp<MediaSource> mAudioSource; |
| 179 | AudioPlayer *mAudioPlayer; |
| 180 | int64_t mDurationUs; |
| 181 | |
James Dong | b45c01c | 2011-01-16 11:30:13 -0800 | [diff] [blame] | 182 | int32_t mDisplayWidth; |
| 183 | int32_t mDisplayHeight; |
James Dong | 4f6eed0 | 2012-04-30 14:38:12 -0700 | [diff] [blame] | 184 | int32_t mVideoScalingMode; |
James Dong | b45c01c | 2011-01-16 11:30:13 -0800 | [diff] [blame] | 185 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 186 | uint32_t mFlags; |
Andreas Huber | acdd9d0 | 2010-05-06 10:18:05 -0700 | [diff] [blame] | 187 | uint32_t mExtractorFlags; |
James Dong | 14f9574 | 2011-08-11 17:38:35 -0700 | [diff] [blame] | 188 | uint32_t mSinceLastDropped; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 189 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 190 | int64_t mTimeSourceDeltaUs; |
| 191 | int64_t mVideoTimeUs; |
| 192 | |
Andreas Huber | 64bb698 | 2011-02-24 12:05:40 -0800 | [diff] [blame] | 193 | enum SeekType { |
| 194 | NO_SEEK, |
| 195 | SEEK, |
| 196 | SEEK_VIDEO_ONLY |
| 197 | }; |
| 198 | SeekType mSeeking; |
| 199 | |
Andreas Huber | 1321fdd | 2010-03-31 09:40:15 -0700 | [diff] [blame] | 200 | bool mSeekNotificationSent; |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 201 | int64_t mSeekTimeUs; |
| 202 | |
Andreas Huber | 7fbdb09 | 2010-10-12 16:55:11 -0700 | [diff] [blame] | 203 | int64_t mBitrate; // total bitrate of the file (in bps) or -1 if unknown. |
| 204 | |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 205 | bool mWatchForAudioSeekComplete; |
| 206 | bool mWatchForAudioEOS; |
| 207 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 208 | sp<TimedEventQueue::Event> mVideoEvent; |
| 209 | bool mVideoEventPending; |
| 210 | sp<TimedEventQueue::Event> mStreamDoneEvent; |
| 211 | bool mStreamDoneEventPending; |
Andreas Huber | 66b0a35 | 2010-01-26 16:20:10 -0800 | [diff] [blame] | 212 | sp<TimedEventQueue::Event> mBufferingEvent; |
| 213 | bool mBufferingEventPending; |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 214 | sp<TimedEventQueue::Event> mCheckAudioStatusEvent; |
| 215 | bool mAudioStatusEventPending; |
Andreas Huber | 145e68f | 2011-01-11 15:05:28 -0800 | [diff] [blame] | 216 | sp<TimedEventQueue::Event> mVideoLagEvent; |
| 217 | bool mVideoLagEventPending; |
Richard Fitzgerald | ad3af33 | 2013-03-25 16:54:37 +0000 | [diff] [blame] | 218 | sp<TimedEventQueue::Event> mAudioTearDownEvent; |
| 219 | bool mAudioTearDownEventPending; |
Andreas Huber | c23f12a | 2010-02-08 14:40:30 -0800 | [diff] [blame] | 220 | sp<TimedEventQueue::Event> mAsyncPrepareEvent; |
| 221 | Condition mPreparedCondition; |
Andreas Huber | bd22c52 | 2010-02-09 14:05:43 -0800 | [diff] [blame] | 222 | bool mIsAsyncPrepare; |
| 223 | status_t mPrepareResult; |
Andreas Huber | 5295c0c | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 224 | status_t mStreamDoneStatus; |
Andreas Huber | c23f12a | 2010-02-08 14:40:30 -0800 | [diff] [blame] | 225 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 226 | void postVideoEvent_l(int64_t delayUs = -1); |
Andreas Huber | 66b0a35 | 2010-01-26 16:20:10 -0800 | [diff] [blame] | 227 | void postBufferingEvent_l(); |
Andreas Huber | 5295c0c | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 228 | void postStreamDoneEvent_l(status_t status); |
Andreas Huber | 02f6e98 | 2011-09-01 11:39:11 -0700 | [diff] [blame] | 229 | void postCheckAudioStatusEvent(int64_t delayUs); |
Andreas Huber | 145e68f | 2011-01-11 15:05:28 -0800 | [diff] [blame] | 230 | void postVideoLagEvent_l(); |
Richard Fitzgerald | 94ea60f | 2013-05-14 15:52:03 +0100 | [diff] [blame] | 231 | void postAudioTearDownEvent(int64_t delayUs); |
Richard Fitzgerald | ad3af33 | 2013-03-25 16:54:37 +0000 | [diff] [blame] | 232 | |
Andreas Huber | 7b3396a | 2010-02-12 10:42:02 -0800 | [diff] [blame] | 233 | status_t play_l(); |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 234 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 235 | MediaBuffer *mVideoBuffer; |
| 236 | |
Andreas Huber | 1156dc9 | 2011-03-08 15:59:28 -0800 | [diff] [blame] | 237 | sp<HTTPBase> mConnectingDataSource; |
Andreas Huber | 0a5baa9 | 2010-06-10 11:17:50 -0700 | [diff] [blame] | 238 | sp<NuCachedSource2> mCachedSource; |
Andreas Huber | 66b0a35 | 2010-01-26 16:20:10 -0800 | [diff] [blame] | 239 | |
Gloria Wang | dcd25ef | 2010-06-22 13:55:38 -0700 | [diff] [blame] | 240 | DrmManagerClient *mDrmManagerClient; |
Gloria Wang | b5ce361 | 2011-02-24 16:40:57 -0800 | [diff] [blame] | 241 | sp<DecryptHandle> mDecryptHandle; |
Gloria Wang | dcd25ef | 2010-06-22 13:55:38 -0700 | [diff] [blame] | 242 | |
Andreas Huber | 150694c | 2011-03-14 10:55:40 -0700 | [diff] [blame] | 243 | int64_t mLastVideoTimeUs; |
Insun Kang | 6655174 | 2012-01-11 22:03:12 +0900 | [diff] [blame] | 244 | TimedTextDriver *mTextDriver; |
Andreas Huber | 150694c | 2011-03-14 10:55:40 -0700 | [diff] [blame] | 245 | |
Andreas Huber | 681755f | 2011-04-21 10:06:43 -0700 | [diff] [blame] | 246 | sp<WVMExtractor> mWVMExtractor; |
James Dong | eec46ab | 2012-04-11 17:56:22 -0700 | [diff] [blame] | 247 | sp<MediaExtractor> mExtractor; |
Andreas Huber | 681755f | 2011-04-21 10:06:43 -0700 | [diff] [blame] | 248 | |
Andreas Huber | 7b3396a | 2010-02-12 10:42:02 -0800 | [diff] [blame] | 249 | status_t setDataSource_l( |
| 250 | const char *uri, |
| 251 | const KeyedVector<String8, String8> *headers = NULL); |
| 252 | |
| 253 | status_t setDataSource_l(const sp<DataSource> &dataSource); |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 254 | status_t setDataSource_l(const sp<MediaExtractor> &extractor); |
| 255 | void reset_l(); |
| 256 | status_t seekTo_l(int64_t timeUs); |
Andreas Huber | b2e3954 | 2010-10-05 10:25:34 -0700 | [diff] [blame] | 257 | status_t pause_l(bool at_eos = false); |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 258 | void initRenderer_l(); |
Andreas Huber | 5daeb12 | 2010-08-16 08:49:37 -0700 | [diff] [blame] | 259 | void notifyVideoSize_l(); |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 260 | void seekAudioIfNecessary_l(); |
| 261 | |
Andreas Huber | c34233e | 2011-11-16 10:46:05 -0800 | [diff] [blame] | 262 | void cancelPlayerEvents(bool keepNotifications = false); |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 263 | |
Andreas Huber | 88d8a83 | 2010-03-05 10:42:10 -0800 | [diff] [blame] | 264 | void setAudioSource(sp<MediaSource> source); |
| 265 | status_t initAudioDecoder(); |
| 266 | |
Richard Fitzgerald | ad3af33 | 2013-03-25 16:54:37 +0000 | [diff] [blame] | 267 | |
Andreas Huber | 88d8a83 | 2010-03-05 10:42:10 -0800 | [diff] [blame] | 268 | void setVideoSource(sp<MediaSource> source); |
Andreas Huber | 2a4d22d | 2010-09-08 14:32:20 -0700 | [diff] [blame] | 269 | status_t initVideoDecoder(uint32_t flags = 0); |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 270 | |
Edwin Wong | 6a3969c | 2012-05-02 18:57:12 -0700 | [diff] [blame] | 271 | void addTextSource_l(size_t trackIndex, const sp<MediaSource>& source); |
Gloria Wang | 7a1e3e8 | 2011-05-03 15:59:03 -0700 | [diff] [blame] | 272 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 273 | void onStreamDone(); |
| 274 | |
Andreas Huber | c23f12a | 2010-02-08 14:40:30 -0800 | [diff] [blame] | 275 | void notifyListener_l(int msg, int ext1 = 0, int ext2 = 0); |
Andreas Huber | 66b0a35 | 2010-01-26 16:20:10 -0800 | [diff] [blame] | 276 | |
Andreas Huber | c23f12a | 2010-02-08 14:40:30 -0800 | [diff] [blame] | 277 | void onVideoEvent(); |
Andreas Huber | 66b0a35 | 2010-01-26 16:20:10 -0800 | [diff] [blame] | 278 | void onBufferingUpdate(); |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 279 | void onCheckAudioStatus(); |
Andreas Huber | c23f12a | 2010-02-08 14:40:30 -0800 | [diff] [blame] | 280 | void onPrepareAsyncEvent(); |
Andreas Huber | 88d8a83 | 2010-03-05 10:42:10 -0800 | [diff] [blame] | 281 | void abortPrepare(status_t err); |
Andreas Huber | 8650e19 | 2010-09-03 13:20:33 -0700 | [diff] [blame] | 282 | void finishAsyncPrepare_l(); |
Andreas Huber | 145e68f | 2011-01-11 15:05:28 -0800 | [diff] [blame] | 283 | void onVideoLagUpdate(); |
Richard Fitzgerald | ad3af33 | 2013-03-25 16:54:37 +0000 | [diff] [blame] | 284 | void onAudioTearDownEvent(); |
| 285 | |
| 286 | void beginPrepareAsync_l(); |
Andreas Huber | 8650e19 | 2010-09-03 13:20:33 -0700 | [diff] [blame] | 287 | |
| 288 | bool getCachedDuration_l(int64_t *durationUs, bool *eos); |
Andreas Huber | 88d8a83 | 2010-03-05 10:42:10 -0800 | [diff] [blame] | 289 | |
Andreas Huber | bd22c52 | 2010-02-09 14:05:43 -0800 | [diff] [blame] | 290 | status_t finishSetDataSource_l(); |
Andreas Huber | 0726045 | 2010-01-21 10:28:45 -0800 | [diff] [blame] | 291 | |
Andreas Huber | e966fb0 | 2010-03-24 09:24:40 -0700 | [diff] [blame] | 292 | static bool ContinuePreparation(void *cookie); |
| 293 | |
Andreas Huber | 7fbdb09 | 2010-10-12 16:55:11 -0700 | [diff] [blame] | 294 | bool getBitrate(int64_t *bitrate); |
| 295 | |
Andreas Huber | 4769cc9 | 2010-10-19 09:34:44 -0700 | [diff] [blame] | 296 | void finishSeekIfNecessary(int64_t videoTimeUs); |
Andreas Huber | 34ef0f3 | 2010-11-11 15:37:17 -0800 | [diff] [blame] | 297 | void ensureCacheIsFetching_l(); |
Andreas Huber | 4769cc9 | 2010-10-19 09:34:44 -0700 | [diff] [blame] | 298 | |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame^] | 299 | void notifyIfMediaStarted_l(); |
Richard Fitzgerald | ad3af33 | 2013-03-25 16:54:37 +0000 | [diff] [blame] | 300 | void createAudioPlayer_l(); |
Andreas Huber | 5442cb5 | 2011-07-14 13:02:47 -0700 | [diff] [blame] | 301 | status_t startAudioPlayer_l(bool sendErrorNotification = true); |
Andreas Huber | f030344 | 2011-02-11 13:09:36 -0800 | [diff] [blame] | 302 | |
Andreas Huber | 150694c | 2011-03-14 10:55:40 -0700 | [diff] [blame] | 303 | void shutdownVideoDecoder_l(); |
Andreas Huber | 63970b4 | 2011-08-29 13:01:23 -0700 | [diff] [blame] | 304 | status_t setNativeWindow_l(const sp<ANativeWindow> &native); |
Andreas Huber | 150694c | 2011-03-14 10:55:40 -0700 | [diff] [blame] | 305 | |
Andreas Huber | 681755f | 2011-04-21 10:06:43 -0700 | [diff] [blame] | 306 | bool isStreamingHTTP() const; |
James Dong | 5b1b8a9 | 2011-05-25 19:37:03 -0700 | [diff] [blame] | 307 | void sendCacheStats(); |
James Dong | 9d2f386 | 2012-01-10 08:24:37 -0800 | [diff] [blame] | 308 | void checkDrmStatus(const sp<DataSource>& dataSource); |
Andreas Huber | 681755f | 2011-04-21 10:06:43 -0700 | [diff] [blame] | 309 | |
Andreas Huber | a0b1d4b | 2011-06-07 15:52:25 -0700 | [diff] [blame] | 310 | enum FlagMode { |
| 311 | SET, |
| 312 | CLEAR, |
| 313 | ASSIGN |
| 314 | }; |
| 315 | void modifyFlags(unsigned value, FlagMode mode); |
| 316 | |
| 317 | struct TrackStat { |
| 318 | String8 mMIME; |
| 319 | String8 mDecoderName; |
| 320 | }; |
| 321 | |
| 322 | // protected by mStatsLock |
| 323 | struct Stats { |
| 324 | int mFd; |
| 325 | String8 mURI; |
| 326 | int64_t mBitrate; |
James Dong | ab7a2e5 | 2012-04-26 17:11:28 -0700 | [diff] [blame] | 327 | |
| 328 | // FIXME: |
| 329 | // These two indices are just 0 or 1 for now |
| 330 | // They are not representing the actual track |
| 331 | // indices in the stream. |
Andreas Huber | a0b1d4b | 2011-06-07 15:52:25 -0700 | [diff] [blame] | 332 | ssize_t mAudioTrackIndex; |
| 333 | ssize_t mVideoTrackIndex; |
James Dong | ab7a2e5 | 2012-04-26 17:11:28 -0700 | [diff] [blame] | 334 | |
Andreas Huber | a0b1d4b | 2011-06-07 15:52:25 -0700 | [diff] [blame] | 335 | int64_t mNumVideoFramesDecoded; |
| 336 | int64_t mNumVideoFramesDropped; |
| 337 | int32_t mVideoWidth; |
| 338 | int32_t mVideoHeight; |
| 339 | uint32_t mFlags; |
| 340 | Vector<TrackStat> mTracks; |
| 341 | } mStats; |
| 342 | |
Richard Fitzgerald | ad3af33 | 2013-03-25 16:54:37 +0000 | [diff] [blame] | 343 | bool mOffloadAudio; |
| 344 | bool mAudioTearDown; |
| 345 | |
James Dong | 4f6eed0 | 2012-04-30 14:38:12 -0700 | [diff] [blame] | 346 | status_t setVideoScalingMode(int32_t mode); |
| 347 | status_t setVideoScalingMode_l(int32_t mode); |
James Dong | eec46ab | 2012-04-11 17:56:22 -0700 | [diff] [blame] | 348 | status_t getTrackInfo(Parcel* reply) const; |
| 349 | |
James Dong | ab7a2e5 | 2012-04-26 17:11:28 -0700 | [diff] [blame] | 350 | status_t selectAudioTrack_l(const sp<MediaSource>& source, size_t trackIndex); |
| 351 | |
James Dong | eec46ab | 2012-04-11 17:56:22 -0700 | [diff] [blame] | 352 | // when select is true, the given track is selected. |
| 353 | // otherwise, the given track is unselected. |
| 354 | status_t selectTrack(size_t trackIndex, bool select); |
| 355 | |
| 356 | size_t countTracks() const; |
| 357 | |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 358 | AwesomePlayer(const AwesomePlayer &); |
| 359 | AwesomePlayer &operator=(const AwesomePlayer &); |
| 360 | }; |
| 361 | |
| 362 | } // namespace android |
| 363 | |
| 364 | #endif // AWESOME_PLAYER_H_ |