1 /*
2 * Copyright (C) 2016 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 //#define LOG_NDEBUG 0
18 #define LOG_TAG "OMXUtils"
19
20 #include <string.h>
21
22 #include <android-base/macros.h>
23 #include <media/stagefright/omx/OMXUtils.h>
24 #include <media/stagefright/foundation/ADebug.h>
25 #include <media/stagefright/foundation/AUtils.h>
26 #include <media/stagefright/foundation/MediaDefs.h>
27 #include <media/stagefright/MediaErrors.h>
28 #include <media/hardware/HardwareAPI.h>
29 #include <system/graphics-base.h>
30
31 namespace android {
32
StatusFromOMXError(OMX_ERRORTYPE err)33 status_t StatusFromOMXError(OMX_ERRORTYPE err) {
34 switch (err) {
35 case OMX_ErrorNone:
36 return OK;
37 case OMX_ErrorNoMore:
38 return NOT_ENOUGH_DATA;
39 case OMX_ErrorUnsupportedSetting:
40 case OMX_ErrorUnsupportedIndex:
41 return ERROR_UNSUPPORTED; // this is a media specific error
42 case OMX_ErrorBadParameter:
43 return BAD_VALUE;
44 case OMX_ErrorInsufficientResources:
45 return NO_MEMORY;
46 case OMX_ErrorInvalidComponentName:
47 case OMX_ErrorComponentNotFound:
48 return NAME_NOT_FOUND;
49 default:
50 return UNKNOWN_ERROR;
51 }
52 }
53
54 /**************************************************************************************************/
55
DescribeColorFormatParams(const DescribeColorFormat2Params & params)56 DescribeColorFormatParams::DescribeColorFormatParams(const DescribeColorFormat2Params ¶ms) {
57 InitOMXParams(this);
58
59 eColorFormat = params.eColorFormat;
60 nFrameWidth = params.nFrameWidth;
61 nFrameHeight = params.nFrameHeight;
62 nStride = params.nStride;
63 nSliceHeight = params.nSliceHeight;
64 bUsingNativeBuffers = params.bUsingNativeBuffers;
65 // we don't copy media images as this conversion is only used pre-query
66 };
67
initFromV1(const DescribeColorFormatParams & params)68 void DescribeColorFormat2Params::initFromV1(const DescribeColorFormatParams ¶ms) {
69 InitOMXParams(this);
70
71 eColorFormat = params.eColorFormat;
72 nFrameWidth = params.nFrameWidth;
73 nFrameHeight = params.nFrameHeight;
74 nStride = params.nStride;
75 nSliceHeight = params.nSliceHeight;
76 bUsingNativeBuffers = params.bUsingNativeBuffers;
77 sMediaImage.initFromV1(params.sMediaImage);
78 };
79
initFromV1(const MediaImage & image)80 void MediaImage2::initFromV1(const MediaImage &image) {
81 memset(this, 0, sizeof(*this));
82
83 if (image.mType != MediaImage::MEDIA_IMAGE_TYPE_YUV) {
84 mType = MediaImage2::MEDIA_IMAGE_TYPE_UNKNOWN;
85 return;
86 }
87
88 for (size_t ix = 0; ix < image.mNumPlanes; ++ix) {
89 if (image.mPlane[ix].mHorizSubsampling > INT32_MAX
90 || image.mPlane[ix].mVertSubsampling > INT32_MAX) {
91 mType = MediaImage2::MEDIA_IMAGE_TYPE_UNKNOWN;
92 return;
93 }
94 }
95
96 mType = (MediaImage2::Type)image.mType;
97 mNumPlanes = image.mNumPlanes;
98 mWidth = image.mWidth;
99 mHeight = image.mHeight;
100 mBitDepth = image.mBitDepth;
101 mBitDepthAllocated = 8;
102 for (size_t ix = 0; ix < image.mNumPlanes; ++ix) {
103 mPlane[ix].mOffset = image.mPlane[ix].mOffset;
104 mPlane[ix].mColInc = image.mPlane[ix].mColInc;
105 mPlane[ix].mRowInc = image.mPlane[ix].mRowInc;
106 mPlane[ix].mHorizSubsampling = (int32_t)image.mPlane[ix].mHorizSubsampling;
107 mPlane[ix].mVertSubsampling = (int32_t)image.mPlane[ix].mVertSubsampling;
108 }
109 }
110
111 /**************************************************************************************************/
112
GetComponentRole(bool isEncoder,const char * mime)113 const char *GetComponentRole(bool isEncoder, const char *mime) {
114 struct MimeToRole {
115 const char *mime;
116 const char *decoderRole;
117 const char *encoderRole;
118 };
119
120 static const MimeToRole kMimeToRole[] = {
121 { MEDIA_MIMETYPE_AUDIO_MPEG,
122 "audio_decoder.mp3", "audio_encoder.mp3" },
123 { MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I,
124 "audio_decoder.mp1", "audio_encoder.mp1" },
125 { MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II,
126 "audio_decoder.mp2", "audio_encoder.mp2" },
127 { MEDIA_MIMETYPE_AUDIO_AMR_NB,
128 "audio_decoder.amrnb", "audio_encoder.amrnb" },
129 { MEDIA_MIMETYPE_AUDIO_AMR_WB,
130 "audio_decoder.amrwb", "audio_encoder.amrwb" },
131 { MEDIA_MIMETYPE_AUDIO_AAC,
132 "audio_decoder.aac", "audio_encoder.aac" },
133 { MEDIA_MIMETYPE_AUDIO_VORBIS,
134 "audio_decoder.vorbis", "audio_encoder.vorbis" },
135 { MEDIA_MIMETYPE_AUDIO_OPUS,
136 "audio_decoder.opus", "audio_encoder.opus" },
137 { MEDIA_MIMETYPE_AUDIO_G711_MLAW,
138 "audio_decoder.g711mlaw", "audio_encoder.g711mlaw" },
139 { MEDIA_MIMETYPE_AUDIO_G711_ALAW,
140 "audio_decoder.g711alaw", "audio_encoder.g711alaw" },
141 { MEDIA_MIMETYPE_VIDEO_AVC,
142 "video_decoder.avc", "video_encoder.avc" },
143 { MEDIA_MIMETYPE_VIDEO_HEVC,
144 "video_decoder.hevc", "video_encoder.hevc" },
145 { MEDIA_MIMETYPE_VIDEO_MPEG4,
146 "video_decoder.mpeg4", "video_encoder.mpeg4" },
147 { MEDIA_MIMETYPE_VIDEO_H263,
148 "video_decoder.h263", "video_encoder.h263" },
149 { MEDIA_MIMETYPE_VIDEO_VP8,
150 "video_decoder.vp8", "video_encoder.vp8" },
151 { MEDIA_MIMETYPE_VIDEO_VP9,
152 "video_decoder.vp9", "video_encoder.vp9" },
153 { MEDIA_MIMETYPE_VIDEO_AV1,
154 "video_decoder.av1", "video_encoder.av1" },
155 { MEDIA_MIMETYPE_AUDIO_RAW,
156 "audio_decoder.raw", "audio_encoder.raw" },
157 { MEDIA_MIMETYPE_VIDEO_DOLBY_VISION,
158 "video_decoder.dolby-vision", "video_encoder.dolby-vision" },
159 { MEDIA_MIMETYPE_AUDIO_FLAC,
160 "audio_decoder.flac", "audio_encoder.flac" },
161 { MEDIA_MIMETYPE_AUDIO_MSGSM,
162 "audio_decoder.gsm", "audio_encoder.gsm" },
163 { MEDIA_MIMETYPE_VIDEO_MPEG2,
164 "video_decoder.mpeg2", "video_encoder.mpeg2" },
165 { MEDIA_MIMETYPE_AUDIO_AC3,
166 "audio_decoder.ac3", "audio_encoder.ac3" },
167 { MEDIA_MIMETYPE_AUDIO_EAC3,
168 "audio_decoder.eac3", "audio_encoder.eac3" },
169 { MEDIA_MIMETYPE_AUDIO_EAC3_JOC,
170 "audio_decoder.eac3_joc", "audio_encoder.eac3_joc" },
171 { MEDIA_MIMETYPE_AUDIO_AC4,
172 "audio_decoder.ac4", "audio_encoder.ac4" },
173 { MEDIA_MIMETYPE_IMAGE_ANDROID_HEIC,
174 "image_decoder.heic", "image_encoder.heic" },
175 };
176
177 static const size_t kNumMimeToRole =
178 sizeof(kMimeToRole) / sizeof(kMimeToRole[0]);
179
180 size_t i;
181 for (i = 0; i < kNumMimeToRole; ++i) {
182 if (!strcasecmp(mime, kMimeToRole[i].mime)) {
183 break;
184 }
185 }
186
187 if (i == kNumMimeToRole) {
188 return NULL;
189 }
190
191 return isEncoder ? kMimeToRole[i].encoderRole
192 : kMimeToRole[i].decoderRole;
193 }
194
SetComponentRole(const sp<IOMXNode> & omxNode,const char * role)195 status_t SetComponentRole(const sp<IOMXNode> &omxNode, const char *role) {
196 OMX_PARAM_COMPONENTROLETYPE roleParams;
197 InitOMXParams(&roleParams);
198
199 strncpy((char *)roleParams.cRole,
200 role, OMX_MAX_STRINGNAME_SIZE - 1);
201
202 roleParams.cRole[OMX_MAX_STRINGNAME_SIZE - 1] = '\0';
203
204 return omxNode->setParameter(
205 OMX_IndexParamStandardComponentRole,
206 &roleParams, sizeof(roleParams));
207 }
208
DescribeDefaultColorFormat(DescribeColorFormat2Params & params)209 bool DescribeDefaultColorFormat(DescribeColorFormat2Params ¶ms) {
210 MediaImage2 &image = params.sMediaImage;
211 memset(&image, 0, sizeof(image));
212
213 image.mType = MediaImage2::MEDIA_IMAGE_TYPE_UNKNOWN;
214 image.mNumPlanes = 0;
215
216 const OMX_COLOR_FORMATTYPE fmt = params.eColorFormat;
217 image.mWidth = params.nFrameWidth;
218 image.mHeight = params.nFrameHeight;
219
220 // only supporting YUV420
221 if (fmt != OMX_COLOR_FormatYUV420Planar &&
222 fmt != OMX_COLOR_FormatYUV420PackedPlanar &&
223 fmt != OMX_COLOR_FormatYUV420SemiPlanar &&
224 fmt != OMX_COLOR_FormatYUV420PackedSemiPlanar &&
225 fmt != (OMX_COLOR_FORMATTYPE)HAL_PIXEL_FORMAT_YV12) {
226 ALOGW("do not know color format 0x%x = %d", fmt, fmt);
227 if (fmt == OMX_COLOR_FormatYUV420Planar16) {
228 ALOGW("Cannot describe color format OMX_COLOR_FormatYUV420Planar16");
229 }
230 return false;
231 }
232
233 // TEMPORARY FIX for some vendors that advertise sliceHeight as 0
234 if (params.nStride != 0 && params.nSliceHeight == 0) {
235 ALOGW("using sliceHeight=%u instead of what codec advertised (=0)",
236 params.nFrameHeight);
237 params.nSliceHeight = params.nFrameHeight;
238 }
239
240 // we need stride and slice-height to be non-zero and sensible. These values were chosen to
241 // prevent integer overflows further down the line, and do not indicate support for
242 // 32kx32k video.
243 if (params.nStride == 0 || params.nSliceHeight == 0
244 || params.nStride > 32768 || params.nSliceHeight > 32768) {
245 ALOGW("cannot describe color format 0x%x = %d with stride=%u and sliceHeight=%u",
246 fmt, fmt, params.nStride, params.nSliceHeight);
247 return false;
248 }
249
250 // set-up YUV format
251 image.mType = MediaImage2::MEDIA_IMAGE_TYPE_YUV;
252 image.mNumPlanes = 3;
253 image.mBitDepth = 8;
254 image.mBitDepthAllocated = 8;
255 image.mPlane[image.Y].mOffset = 0;
256 image.mPlane[image.Y].mColInc = 1;
257 image.mPlane[image.Y].mRowInc = params.nStride;
258 image.mPlane[image.Y].mHorizSubsampling = 1;
259 image.mPlane[image.Y].mVertSubsampling = 1;
260
261 switch ((int)fmt) {
262 case HAL_PIXEL_FORMAT_YV12:
263 if (params.bUsingNativeBuffers) {
264 size_t ystride = align(params.nStride, 16);
265 size_t cstride = align(params.nStride / 2, 16);
266 image.mPlane[image.Y].mRowInc = ystride;
267
268 image.mPlane[image.V].mOffset = ystride * params.nSliceHeight;
269 image.mPlane[image.V].mColInc = 1;
270 image.mPlane[image.V].mRowInc = cstride;
271 image.mPlane[image.V].mHorizSubsampling = 2;
272 image.mPlane[image.V].mVertSubsampling = 2;
273
274 image.mPlane[image.U].mOffset = image.mPlane[image.V].mOffset
275 + (cstride * params.nSliceHeight / 2);
276 image.mPlane[image.U].mColInc = 1;
277 image.mPlane[image.U].mRowInc = cstride;
278 image.mPlane[image.U].mHorizSubsampling = 2;
279 image.mPlane[image.U].mVertSubsampling = 2;
280 break;
281 } else {
282 // fall through as YV12 is used for YUV420Planar by some codecs
283 FALLTHROUGH_INTENDED;
284 }
285
286 case OMX_COLOR_FormatYUV420Planar:
287 case OMX_COLOR_FormatYUV420PackedPlanar:
288 image.mPlane[image.U].mOffset = params.nStride * params.nSliceHeight;
289 image.mPlane[image.U].mColInc = 1;
290 image.mPlane[image.U].mRowInc = params.nStride / 2;
291 image.mPlane[image.U].mHorizSubsampling = 2;
292 image.mPlane[image.U].mVertSubsampling = 2;
293
294 image.mPlane[image.V].mOffset = image.mPlane[image.U].mOffset
295 + (params.nStride * params.nSliceHeight / 4);
296 image.mPlane[image.V].mColInc = 1;
297 image.mPlane[image.V].mRowInc = params.nStride / 2;
298 image.mPlane[image.V].mHorizSubsampling = 2;
299 image.mPlane[image.V].mVertSubsampling = 2;
300 break;
301
302 case OMX_COLOR_FormatYUV420SemiPlanar:
303 // FIXME: NV21 for sw-encoder, NV12 for decoder and hw-encoder
304 case OMX_COLOR_FormatYUV420PackedSemiPlanar:
305 // NV12
306 image.mPlane[image.U].mOffset = params.nStride * params.nSliceHeight;
307 image.mPlane[image.U].mColInc = 2;
308 image.mPlane[image.U].mRowInc = params.nStride;
309 image.mPlane[image.U].mHorizSubsampling = 2;
310 image.mPlane[image.U].mVertSubsampling = 2;
311
312 image.mPlane[image.V].mOffset = image.mPlane[image.U].mOffset + 1;
313 image.mPlane[image.V].mColInc = 2;
314 image.mPlane[image.V].mRowInc = params.nStride;
315 image.mPlane[image.V].mHorizSubsampling = 2;
316 image.mPlane[image.V].mVertSubsampling = 2;
317 break;
318
319 default:
320 TRESPASS();
321 }
322 return true;
323 }
324
DescribeColorFormat(const sp<IOMXNode> & omxNode,DescribeColorFormat2Params & describeParams)325 bool DescribeColorFormat(
326 const sp<IOMXNode> &omxNode,
327 DescribeColorFormat2Params &describeParams)
328 {
329 OMX_INDEXTYPE describeColorFormatIndex;
330 if (omxNode->getExtensionIndex(
331 "OMX.google.android.index.describeColorFormat",
332 &describeColorFormatIndex) == OK) {
333 DescribeColorFormatParams describeParamsV1(describeParams);
334 if (omxNode->getParameter(
335 describeColorFormatIndex,
336 &describeParamsV1, sizeof(describeParamsV1)) == OK) {
337 describeParams.initFromV1(describeParamsV1);
338 return describeParams.sMediaImage.mType != MediaImage2::MEDIA_IMAGE_TYPE_UNKNOWN;
339 }
340 } else if (omxNode->getExtensionIndex(
341 "OMX.google.android.index.describeColorFormat2", &describeColorFormatIndex) == OK
342 && omxNode->getParameter(
343 describeColorFormatIndex, &describeParams, sizeof(describeParams)) == OK) {
344 return describeParams.sMediaImage.mType != MediaImage2::MEDIA_IMAGE_TYPE_UNKNOWN;
345 }
346
347 return DescribeDefaultColorFormat(describeParams);
348 }
349
350 // static
IsFlexibleColorFormat(const sp<IOMXNode> & omxNode,uint32_t colorFormat,bool usingNativeBuffers,OMX_U32 * flexibleEquivalent)351 bool IsFlexibleColorFormat(
352 const sp<IOMXNode> &omxNode,
353 uint32_t colorFormat, bool usingNativeBuffers, OMX_U32 *flexibleEquivalent) {
354 DescribeColorFormat2Params describeParams;
355 InitOMXParams(&describeParams);
356 describeParams.eColorFormat = (OMX_COLOR_FORMATTYPE)colorFormat;
357 // reasonable dummy values
358 describeParams.nFrameWidth = 128;
359 describeParams.nFrameHeight = 128;
360 describeParams.nStride = 128;
361 describeParams.nSliceHeight = 128;
362 describeParams.bUsingNativeBuffers = (OMX_BOOL)usingNativeBuffers;
363
364 CHECK(flexibleEquivalent != NULL);
365
366 if (!DescribeColorFormat(omxNode, describeParams)) {
367 return false;
368 }
369
370 const MediaImage2 &img = describeParams.sMediaImage;
371 if (img.mType == MediaImage2::MEDIA_IMAGE_TYPE_YUV) {
372 if (img.mNumPlanes != 3
373 || img.mPlane[img.Y].mHorizSubsampling != 1
374 || img.mPlane[img.Y].mVertSubsampling != 1) {
375 return false;
376 }
377
378 // YUV 420
379 if (img.mPlane[img.U].mHorizSubsampling == 2
380 && img.mPlane[img.U].mVertSubsampling == 2
381 && img.mPlane[img.V].mHorizSubsampling == 2
382 && img.mPlane[img.V].mVertSubsampling == 2) {
383 // possible flexible YUV420 format
384 if (img.mBitDepth <= 8) {
385 *flexibleEquivalent = OMX_COLOR_FormatYUV420Flexible;
386 return true;
387 }
388 }
389 }
390 return false;
391 }
392
393 } // namespace android
394
395