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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
/*
* Copyright (c) 2013 - 2015, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of The Linux Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _AV_EXTENSIONS_H_
#define _AV_EXTENSIONS_H_
#include <media/stagefright/DataSource.h>
#include <common/AVExtensionsCommon.h>
#include <system/audio.h>
#include <camera/ICamera.h>
#include <media/mediarecorder.h>
#include <media/IOMX.h>
#include <media/AudioParameter.h>
namespace android {
class MetaData;
class MediaExtractor;
class MPEG4Writer;
struct ABuffer;
struct ACodec;
struct ALooper;
struct IMediaHTTPConnection;
struct MediaCodec;
struct MediaHTTP;
struct NuCachedSource2;
class CameraParameters;
class MediaBuffer;
struct AudioSource;
class CameraSource;
class CameraSourceTimeLapse;
class ICamera;
class ICameraRecordingProxy;
class String16;
class IGraphicBufferProducer;
struct Size;
/*
* Factory to create objects of base-classes in libstagefright
*/
struct AVFactory {
virtual sp<ACodec> createACodec();
virtual MediaExtractor* createExtendedExtractor(
const sp<DataSource> &source, const char *mime,
const sp<AMessage> &meta, const uint32_t flags);
virtual sp<MediaExtractor> updateExtractor(
sp<MediaExtractor> ext, const sp<DataSource> &source,
const char *mime, const sp<AMessage> &meta, const uint32_t flags);
virtual sp<NuCachedSource2> createCachedSource(
const sp<DataSource> &source,
const char *cacheConfig = NULL,
bool disconnectAtHighwatermark = false);
virtual MediaHTTP* createMediaHTTP(
const sp<IMediaHTTPConnection> &conn);
virtual AudioSource* createAudioSource(
audio_source_t inputSource,
const String16 &opPackageName,
uint32_t sampleRate,
uint32_t channels,
uint32_t outSampleRate = 0);
virtual CameraSource *CreateCameraSourceFromCamera(
const sp<ICamera> &camera,
const sp<ICameraRecordingProxy> &proxy,
int32_t cameraId,
const String16& clientName,
uid_t clientUid,
Size videoSize,
int32_t frameRate,
const sp<IGraphicBufferProducer>& surface,
bool storeMetaDataInVideoBuffers = true);
virtual CameraSourceTimeLapse *CreateCameraSourceTimeLapseFromCamera(
const sp<ICamera> &camera,
const sp<ICameraRecordingProxy> &proxy,
int32_t cameraId,
const String16& clientName,
uid_t clientUid,
Size videoSize,
int32_t videoFrameRate,
const sp<IGraphicBufferProducer>& surface,
int64_t timeBetweenFrameCaptureUs,
bool storeMetaDataInVideoBuffers = true);
// ----- NO TRESSPASSING BEYOND THIS LINE ------
DECLARE_LOADABLE_SINGLETON(AVFactory);
};
/*
* Common delegate to the classes in libstagefright
*/
struct AVUtils {
virtual status_t convertMetaDataToMessage(
const sp<MetaData> &meta, sp<AMessage> *format);
virtual DataSource::SnifferFunc getExtendedSniffer();
virtual status_t mapMimeToAudioFormat( audio_format_t& format, const char* mime);
virtual status_t sendMetaDataToHal(const sp<MetaData>& meta, AudioParameter *param);
virtual sp<MediaCodec> createCustomComponentByName(const sp<ALooper> &looper,
const char* mime, bool encoder, const sp<AMessage> &format);
virtual bool isEnhancedExtension(const char *extension);
virtual bool is24bitPCMOffloadEnabled();
virtual bool is16bitPCMOffloadEnabled();
virtual int getAudioSampleBits(const sp<MetaData> &);
virtual int getAudioSampleBits(const sp<AMessage> &);
virtual void setPcmSampleBits(const sp<MetaData> &, int32_t /*bitWidth*/);
virtual void setPcmSampleBits(const sp<AMessage> &, int32_t /*bitWidth*/);
virtual audio_format_t updateAudioFormat(audio_format_t audioFormat,
const sp<MetaData> &);
virtual audio_format_t updateAudioFormat(audio_format_t audioFormat,
const sp<AMessage> &);
virtual bool canOffloadAPE(const sp<MetaData> &meta);
virtual int32_t getAudioMaxInputBufferSize(audio_format_t audioFormat,
const sp<AMessage> &);
virtual bool mapAACProfileToAudioFormat(const sp<MetaData> &,
audio_format_t &,
uint64_t /*eAacProfile*/);
virtual bool mapAACProfileToAudioFormat(const sp<AMessage> &,
audio_format_t &,
uint64_t /*eAacProfile*/);
virtual void extractCustomCameraKeys(
const CameraParameters& /*params*/, sp<MetaData> &/*meta*/) {}
virtual void printFileName(int /*fd*/) {}
virtual void addDecodingTimesFromBatch(MediaBuffer * /*buf*/,
List<int64_t> &/*decodeTimeQueue*/) {}
virtual bool useQCHWEncoder(const sp<AMessage> &, AString &) { return false; }
virtual bool canDeferRelease(const sp<MetaData> &/*meta*/) { return false; }
virtual void setDeferRelease(sp<MetaData> &/*meta*/) {}
struct HEVCMuxer {
virtual bool reassembleHEVCCSD(const AString &mime, sp<ABuffer> csd0, sp<MetaData> &meta);
virtual void writeHEVCFtypBox(MPEG4Writer *writer);
virtual status_t makeHEVCCodecSpecificData(const uint8_t *data,
size_t size, void** codecSpecificData,
size_t *codecSpecificDataSize);
virtual const char *getFourCCForMime(const char *mime);
virtual void writeHvccBox(MPEG4Writer *writer,
void* codecSpecificData, size_t codecSpecificDataSize,
bool useNalLengthFour);
virtual bool isVideoHEVC(const char* mime);
virtual void getHEVCCodecSpecificDataFromInputFormatIfPossible(
sp<MetaData> meta, void **codecSpecificData,
size_t *codecSpecificDataSize, bool *gotAllCodecSpecificData);
protected:
HEVCMuxer() {};
virtual ~HEVCMuxer() {};
friend struct AVUtils;
private:
struct HEVCParamSet {
HEVCParamSet(uint16_t length, const uint8_t *data)
: mLength(length), mData(data) {}
uint16_t mLength;
const uint8_t *mData;
};
status_t extractNALRBSPData(const uint8_t *data, size_t size,
uint8_t **header, bool *alreadyFilled);
status_t parserProfileTierLevel(const uint8_t *data, size_t size,
uint8_t **header, bool *alreadyFilled);
const uint8_t *parseHEVCParamSet(const uint8_t *data, size_t length,
List<HEVCParamSet> ¶mSetList, size_t *paramSetLen);
size_t parseHEVCCodecSpecificData(const uint8_t *data, size_t size,
List<HEVCParamSet> &vidParamSet, List<HEVCParamSet> &seqParamSet,
List<HEVCParamSet> &picParamSet );
};
virtual inline HEVCMuxer& HEVCMuxerUtils() {
return mHEVCMuxer;
}
virtual bool isAudioMuxFormatSupported(const char *mime);
virtual void cacheCaptureBuffers(sp<ICamera> camera, video_encoder encoder);
virtual const char *getCustomCodecsLocation();
virtual void setIntraPeriod(
int nPFrames, int nBFrames, const sp<IOMX> OMXhandle,
IOMX::node_id nodeID);
private:
HEVCMuxer mHEVCMuxer;
// ----- NO TRESSPASSING BEYOND THIS LINE ------
DECLARE_LOADABLE_SINGLETON(AVUtils);
};
}
#endif // _AV_EXTENSIONS__H_
|
