1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef NU_CACHED_SOURCE_2_H_
#define NU_CACHED_SOURCE_2_H_
#include <media/stagefright/foundation/ABase.h>
#include <media/stagefright/foundation/AHandlerReflector.h>
#include <media/stagefright/DataSource.h>
namespace android {
struct ALooper;
struct PageCache;
struct NuCachedSource2 : public DataSource {
static sp<NuCachedSource2> Create(
const sp<DataSource> &source,
const char *cacheConfig = NULL,
bool disconnectAtHighwatermark = false);
virtual status_t initCheck() const;
virtual ssize_t readAt(off64_t offset, void *data, size_t size);
virtual void disconnect();
virtual status_t getSize(off64_t *size);
virtual uint32_t flags();
virtual sp<DecryptHandle> DrmInitialization(const char* mime);
virtual void getDrmInfo(sp<DecryptHandle> &handle, DrmManagerClient **client);
virtual String8 getUri();
virtual String8 getMIMEType() const;
////////////////////////////////////////////////////////////////////////////
size_t cachedSize();
size_t approxDataRemaining(status_t *finalStatus) const;
void resumeFetchingIfNecessary();
// The following methods are supported only if the
// data source is HTTP-based; otherwise, ERROR_UNSUPPORTED
// is returned.
status_t getEstimatedBandwidthKbps(int32_t *kbps);
status_t setCacheStatCollectFreq(int32_t freqMs);
static void RemoveCacheSpecificHeaders(
KeyedVector<String8, String8> *headers,
String8 *cacheConfig,
bool *disconnectAtHighwatermark);
virtual status_t disconnectWhileSuspend();
virtual status_t connectWhileResume();
protected:
virtual ~NuCachedSource2();
protected:
friend struct AHandlerReflector<NuCachedSource2>;
NuCachedSource2(
const sp<DataSource> &source,
const char *cacheConfig,
bool disconnectAtHighwatermark);
enum {
kPageSize = 65536,
kDefaultHighWaterThreshold = 20 * 1024 * 1024,
kDefaultLowWaterThreshold = 4 * 1024 * 1024,
// Read data after a 15 sec timeout whether we're actively
// fetching or not.
kDefaultKeepAliveIntervalUs = 15000000,
};
enum {
kWhatFetchMore = 'fetc',
kWhatRead = 'read',
};
enum {
kMaxNumRetries = 10,
};
sp<DataSource> mSource;
sp<AHandlerReflector<NuCachedSource2> > mReflector;
sp<ALooper> mLooper;
Mutex mSerializer;
mutable Mutex mLock;
Condition mCondition;
PageCache *mCache;
off64_t mCacheOffset;
status_t mFinalStatus;
off64_t mLastAccessPos;
sp<AMessage> mAsyncResult;
bool mFetching;
bool mDisconnecting;
int64_t mLastFetchTimeUs;
int32_t mNumRetriesLeft;
size_t mHighwaterThresholdBytes;
size_t mLowwaterThresholdBytes;
// If the keep-alive interval is 0, keep-alives are disabled.
int64_t mKeepAliveIntervalUs;
bool mDisconnectAtHighwatermark;
bool mSuspended;
void onMessageReceived(const sp<AMessage> &msg);
void onFetch();
void onRead(const sp<AMessage> &msg);
void fetchInternal();
ssize_t readInternal(off64_t offset, void *data, size_t size);
status_t seekInternal_l(off64_t offset);
size_t approxDataRemaining_l(status_t *finalStatus) const;
void restartPrefetcherIfNecessary_l(
bool ignoreLowWaterThreshold = false, bool force = false);
void updateCacheParamsFromSystemProperty();
void updateCacheParamsFromString(const char *s);
DISALLOW_EVIL_CONSTRUCTORS(NuCachedSource2);
};
} // namespace android
#endif // NU_CACHED_SOURCE_2_H_
|
