1 /*--------------------------------------------------------------------------
2 Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
3
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions are
6 met:
7 * Redistributions of source code must retain the above copyright
8 notice, this list of conditions and the following disclaimer.
9 * Redistributions in binary form must reproduce the above
10 copyright notice, this list of conditions and the following
11 disclaimer in the documentation and/or other materials provided
12 with the distribution.
13 * Neither the name of The Linux Foundation nor the names of its
14 contributors may be used to endorse or promote products derived
15 from this software without specific prior written permission.
16
17 THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
18 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
20 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
21 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
24 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
26 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 --------------------------------------------------------------------------*/
29
init_vendor_extensions(VendorExtensionStore & store)30 void omx_video::init_vendor_extensions(VendorExtensionStore &store) {
31
32 //TODO: add extensions based on Codec, m_platform and/or other capability queries
33
34 ADD_EXTENSION("qti-ext-enc-preprocess-rotate", OMX_IndexConfigCommonRotate, OMX_DirOutput)
35 ADD_PARAM_END("angle", OMX_AndroidVendorValueInt32)
36
37 ADD_EXTENSION("qti-ext-enc-preprocess-mirror", OMX_IndexConfigCommonMirror, OMX_DirOutput)
38 ADD_PARAM_END("flip", OMX_AndroidVendorValueInt32)
39
40 ADD_EXTENSION("qti-ext-enc-avc-intra-period", QOMX_IndexConfigVideoIntraperiod, OMX_DirOutput)
41 ADD_PARAM ("n-pframes", OMX_AndroidVendorValueInt32)
42 ADD_PARAM_END("n-idr-period", OMX_AndroidVendorValueInt32)
43
44 ADD_EXTENSION("qti-ext-enc-intra-period", QOMX_IndexConfigVideoIntraperiod, OMX_DirOutput)
45 ADD_PARAM ("n-pframes", OMX_AndroidVendorValueInt32)
46 ADD_PARAM ("n-bframes", OMX_AndroidVendorValueInt32)
47 ADD_PARAM_END("n-idr-period", OMX_AndroidVendorValueInt32)
48
49 ADD_EXTENSION("qti-ext-enc-error-correction", OMX_QcomIndexParamVideoSliceSpacing, OMX_DirOutput)
50 ADD_PARAM_END("resync-marker-spacing-bits", OMX_AndroidVendorValueInt32)
51
52 ADD_EXTENSION("qti-ext-enc-slice", OMX_QcomIndexParamVideoSliceSpacing, OMX_DirOutput)
53 ADD_PARAM_END("spacing", OMX_AndroidVendorValueInt32)
54
55 ADD_EXTENSION("qti-ext-enc-custom-profile-level", OMX_IndexParamVideoProfileLevelCurrent, OMX_DirOutput)
56 ADD_PARAM ("profile", OMX_AndroidVendorValueInt32)
57 ADD_PARAM_END("level", OMX_AndroidVendorValueInt32)
58
59 ADD_EXTENSION("qti-ext-enc-timestamp-source-avtimer", OMX_QTIIndexParamEnableAVTimerTimestamps, OMX_DirInput)
60 ADD_PARAM_END("enable", OMX_AndroidVendorValueInt32)
61
62 ADD_EXTENSION("qti-ext-enc-frame-qp", OMX_QcomIndexConfigQp, OMX_DirOutput)
63 ADD_PARAM_END("value", OMX_AndroidVendorValueInt32)
64
65 ADD_EXTENSION("qti-ext-down-scalar", OMX_QcomIndexParamVideoDownScalar, OMX_DirOutput)
66 ADD_PARAM ("output-width", OMX_AndroidVendorValueInt32)
67 ADD_PARAM_END("output-height", OMX_AndroidVendorValueInt32)
68
69 ADD_EXTENSION("qti-ext-enc-app-input-control", OMX_QcomIndexParamVencControlInputQueue, OMX_DirInput)
70 ADD_PARAM_END("enable", OMX_AndroidVendorValueInt32)
71
72 ADD_EXTENSION("qti-ext-enc-input-trigger", OMX_IndexConfigTimePosition, OMX_DirInput)
73 ADD_PARAM_END("timestamp", OMX_AndroidVendorValueInt64)
74
75 ADD_EXTENSION("qti-ext-enc-low-latency", OMX_QTIIndexParamLowLatencyMode, OMX_DirInput)
76 ADD_PARAM_END("enable", OMX_AndroidVendorValueInt32)
77
78 ADD_EXTENSION("qti-ext-enc-base-layer-pid", OMX_QcomIndexConfigBaseLayerId, OMX_DirInput)
79 ADD_PARAM_END("value", OMX_AndroidVendorValueInt32)
80
81 ADD_EXTENSION("qti-ext-enc-ltr-count", OMX_QcomIndexParamVideoLTRCount, OMX_DirOutput)
82 ADD_PARAM_END("num-ltr-frames", OMX_AndroidVendorValueInt32)
83
84 ADD_EXTENSION("qti-ext-enc-ltr", OMX_QcomIndexConfigVideoLTRUse, OMX_DirInput)
85 ADD_PARAM_END("use-frame", OMX_AndroidVendorValueInt32)
86
87 ADD_EXTENSION("qti-ext-enc-ltr", OMX_QcomIndexConfigVideoLTRMark, OMX_DirInput)
88 ADD_PARAM_END("mark-frame", OMX_AndroidVendorValueInt32)
89
90 ADD_EXTENSION("qti-ext-enc-dynamic-frame-rate", OMX_IndexConfigVideoFramerate, OMX_DirOutput)
91 ADD_PARAM_END("frame-rate", OMX_AndroidVendorValueInt32)
92
93 ADD_EXTENSION("qti-ext-extradata-enable", OMX_QcomIndexParamIndexExtraDataType, OMX_DirOutput)
94 ADD_PARAM_END("types", OMX_AndroidVendorValueString)
95
96 ADD_EXTENSION("qti-ext-enc-caps-vt-driver-version", OMX_QTIIndexParamCapabilitiesVTDriverVersion, OMX_DirOutput)
97 ADD_PARAM_END("number", OMX_AndroidVendorValueInt32)
98
99 ADD_EXTENSION("qti-ext-enc-caps-preprocess", OMX_QTIIndexParamCapabilitiesMaxDownScaleRatio, OMX_DirOutput)
100 ADD_PARAM_END("max-downscale-factor", OMX_AndroidVendorValueInt32)
101
102 ADD_EXTENSION("qti-ext-enc-caps-preprocess", OMX_QTIIndexParamCapabilitiesRotationSupport, OMX_DirOutput)
103 ADD_PARAM_END("rotation", OMX_AndroidVendorValueInt32)
104
105 ADD_EXTENSION("qti-ext-enc-caps-ltr", OMX_QTIIndexParamCapabilitiesMaxLTR, OMX_DirOutput)
106 ADD_PARAM_END("max-count", OMX_AndroidVendorValueInt32)
107
108 ADD_EXTENSION("qti-ext-enc-caps-temporal-layers", OMX_QTIIndexParamCapabilitiesMaxTemporalLayers, OMX_DirInput)
109 ADD_PARAM ("max-p-count", OMX_AndroidVendorValueInt32)
110 ADD_PARAM_END("max-b-count", OMX_AndroidVendorValueInt32)
111
112 ADD_EXTENSION("qti-ext-enc-colorspace-conversion", OMX_QTIIndexParamColorSpaceConversion, OMX_DirInput)
113 ADD_PARAM_END("enable", OMX_AndroidVendorValueInt32)
114
115 ADD_EXTENSION("qti-ext-enc-initial-qp", QOMX_IndexParamVideoInitialQp, OMX_DirOutput)
116 ADD_PARAM ("qp-i", OMX_AndroidVendorValueInt32)
117 ADD_PARAM ("qp-i-enable", OMX_AndroidVendorValueInt32)
118 ADD_PARAM ("qp-p", OMX_AndroidVendorValueInt32)
119 ADD_PARAM ("qp-p-enable", OMX_AndroidVendorValueInt32)
120 ADD_PARAM ("qp-b", OMX_AndroidVendorValueInt32)
121 ADD_PARAM_END("qp-b-enable", OMX_AndroidVendorValueInt32)
122
123 ADD_EXTENSION("qti-ext-enc-blurinfo", OMX_QTIIndexConfigVideoBlurResolution, OMX_DirInput)
124 ADD_PARAM_END("info", OMX_AndroidVendorValueInt32)
125
126 ADD_EXTENSION("qti-ext-enc-qp-range", OMX_QcomIndexParamVideoIPBQPRange, OMX_DirOutput)
127 ADD_PARAM ("qp-i-min", OMX_AndroidVendorValueInt32)
128 ADD_PARAM ("qp-i-max", OMX_AndroidVendorValueInt32)
129 ADD_PARAM ("qp-p-min", OMX_AndroidVendorValueInt32)
130 ADD_PARAM ("qp-p-max", OMX_AndroidVendorValueInt32)
131 ADD_PARAM ("qp-b-min", OMX_AndroidVendorValueInt32)
132 ADD_PARAM_END("qp-b-max", OMX_AndroidVendorValueInt32)
133
134 ADD_EXTENSION("qti-ext-enc-bitrate-mode", OMX_IndexParamVideoBitrate, OMX_DirOutput)
135 ADD_PARAM_END("value", OMX_AndroidVendorValueInt32)
136
137 ADD_EXTENSION("qti-ext-enc-linear-color-format", OMX_QTIIndexParamEnableLinearColorFormat, OMX_DirInput)
138 ADD_PARAM_END("value", OMX_AndroidVendorValueInt32)
139
140 ADD_EXTENSION("qti-ext-enc-vbvdelay", OMX_QTIIndexParamVbvDelay, OMX_DirInput)
141 ADD_PARAM_END("value", OMX_AndroidVendorValueInt32)
142 ADD_EXTENSION("qti-ext-enc-roiinfo", OMX_QTIIndexConfigVideoRoiRectRegionInfo, OMX_DirInput)
143 ADD_PARAM ("timestamp", OMX_AndroidVendorValueInt64)
144 ADD_PARAM ("type", OMX_AndroidVendorValueString)
145 ADD_PARAM ("rect-payload", OMX_AndroidVendorValueString)
146 ADD_PARAM_END("rect-payload-ext", OMX_AndroidVendorValueString)
147
148 ADD_EXTENSION("qti-ext-enc-roiinfo-rect-mode", OMX_QTIIndexConfigVideoRoiRectRegionInfo, OMX_DirOutput)
149 ADD_PARAM_END("enable", OMX_AndroidVendorValueInt32)
150
151 ADD_EXTENSION("qti-ext-enc-content-adaptive-mode", OMX_QTIIndexConfigContentAdaptiveCoding, OMX_DirInput)
152 ADD_PARAM_END("value", OMX_AndroidVendorValueInt32)
153 }
154
get_vendor_extension_config(OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE * ext)155 OMX_ERRORTYPE omx_video::get_vendor_extension_config(
156 OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *ext) {
157 if (ext->nIndex >= mVendorExtensionStore.size()) {
158 return OMX_ErrorNoMore;
159 }
160
161 const VendorExtension& vExt = mVendorExtensionStore[ext->nIndex];
162 DEBUG_PRINT_LOW("VendorExt: getConfig: index=%u (%s)", ext->nIndex, vExt.name());
163
164 vExt.copyInfoTo(ext);
165 if (ext->nParamSizeUsed < vExt.paramCount()) {
166 // this happens during initial getConfig to query only extension-name and param-count
167 return OMX_ErrorNone;
168 }
169
170 // We now have sufficient params allocated in extension data passed.
171 // Following code is to set the extension-specific data
172
173 bool setStatus = true;
174
175 switch ((OMX_U32)vExt.extensionIndex()) {
176 case OMX_IndexConfigCommonRotate:
177 {
178 setStatus &= vExt.setParamInt32(ext, "angle", m_sConfigFrameRotation.nRotation);
179 break;
180 }
181 case OMX_IndexConfigCommonMirror:
182 {
183 setStatus &= vExt.setParamInt32(ext, "flip", m_sConfigFrameMirror.eMirror);
184 break;
185 }
186 case QOMX_IndexConfigVideoIntraperiod:
187 {
188 if (vExt.isConfigKey(ext, "qti-ext-enc-avc-intra-period")) {
189 setStatus &= vExt.setParamInt32(ext, "n-pframes", m_sIntraperiod.nPFrames);
190 setStatus &= vExt.setParamInt32(ext, "n-idr-period", m_sIntraperiod.nIDRPeriod);
191 } else if (vExt.isConfigKey(ext, "qti-ext-enc-intra-period")) {
192 setStatus &= vExt.setParamInt32(ext, "n-pframes", m_sIntraperiod.nPFrames);
193 setStatus &= vExt.setParamInt32(ext, "n-bframes", m_sIntraperiod.nBFrames);
194 setStatus &= vExt.setParamInt32(ext, "n-idr-period", m_sIntraperiod.nIDRPeriod);
195 }
196 break;
197 }
198 case OMX_QcomIndexParamVideoSliceSpacing:
199 {
200 if (vExt.isConfigKey(ext, "qti-ext-enc-error-correction")) {
201 setStatus &= vExt.setParamInt32(ext,
202 "resync-marker-spacing-bits", m_sSliceSpacing.nSliceSize);
203 } else if (vExt.isConfigKey(ext, "qti-ext-enc-slice")) {
204 setStatus &= vExt.setParamInt32(ext, "spacing", m_sSliceSpacing.nSliceSize);
205 }
206 break;
207 }
208 case OMX_IndexParamVideoProfileLevelCurrent:
209 {
210 setStatus &= vExt.setParamInt32(ext, "profile", m_sParamProfileLevel.eProfile);
211 setStatus &= vExt.setParamInt32(ext, "level", m_sParamProfileLevel.eLevel);
212
213 break;
214 }
215 case OMX_QTIIndexParamEnableAVTimerTimestamps:
216 {
217 setStatus &= vExt.setParamInt32(ext, "enable", m_sParamAVTimerTimestampMode.bEnable);
218 break;
219 }
220 case OMX_QcomIndexConfigQp:
221 {
222 setStatus &= vExt.setParamInt32(ext, "value", m_sConfigQP.nQP);
223 break;
224 }
225 case OMX_QcomIndexParamVideoDownScalar:
226 {
227 setStatus &= vExt.setParamInt32(ext, "output-width", m_sParamDownScalar.nOutputWidth);
228 setStatus &= vExt.setParamInt32(ext, "output-height", m_sParamDownScalar.nOutputHeight);
229 break;
230 }
231 case OMX_QcomIndexParamVencControlInputQueue:
232 {
233 setStatus &= vExt.setParamInt32(ext, "enable", m_sParamControlInputQueue.bEnable);
234 break;
235 }
236 case OMX_IndexConfigTimePosition:
237 {
238 setStatus &= vExt.setParamInt64(ext, "timestamp", m_sConfigInputTrigTS.nTimestamp);
239 break;
240 }
241 case OMX_QTIIndexParamLowLatencyMode:
242 {
243 setStatus &= vExt.setParamInt32(ext, "enable", m_sParamLowLatency.bEnableLowLatencyMode);
244 break;
245 }
246 case OMX_QcomIndexConfigBaseLayerId:
247 {
248 setStatus &= vExt.setParamInt32(ext, "value", m_sBaseLayerID.nPID);
249 break;
250 }
251 case OMX_QcomIndexParamVideoLTRCount:
252 {
253 setStatus &= vExt.setParamInt32(ext, "num-ltr-frames", m_sParamLTRCount.nCount);
254 break;
255 }
256 case OMX_QcomIndexConfigVideoLTRUse:
257 {
258 setStatus &= vExt.setParamInt32(ext, "use-frame", m_sConfigLTRUse.nID);
259 break;
260 }
261 case OMX_QcomIndexConfigVideoLTRMark:
262 {
263 setStatus &= vExt.setParamInt32(ext, "mark-frame", m_sConfigLTRMark.nID);
264 break;
265 }
266 case OMX_IndexConfigVideoFramerate:
267 {
268 setStatus &= vExt.setParamInt32(ext, "frame-rate", m_sConfigFramerate.xEncodeFramerate);
269 break;
270 }
271 case OMX_QcomIndexParamIndexExtraDataType:
272 {
273 char exType[OMX_MAX_STRINGVALUE_SIZE+1];
274 memset (exType,0, (sizeof(char)*OMX_MAX_STRINGVALUE_SIZE));
275 if ((OMX_BOOL)(m_sExtraData & EXTRADATA_ADVANCED)) {
276 strlcat(exType, "advanced", OMX_MAX_STRINGVALUE_SIZE);
277 }
278 if ((OMX_BOOL)(m_sExtraData & EXTRADATA_ENC_INPUT_ROI)) {
279 if (exType[0]!=0) {
280 strlcat(exType,"|", OMX_MAX_STRINGVALUE_SIZE);
281 }
282 strlcat(exType, "roiinfo", OMX_MAX_STRINGVALUE_SIZE);
283 }
284 setStatus &= vExt.setParamString(ext, "types", exType);
285 DEBUG_PRINT_LOW("VendorExt: getparam: Extradata %s",exType);
286 break;
287 }
288 case OMX_QTIIndexParamCapabilitiesVTDriverVersion:
289 {
290 setStatus &= vExt.setParamInt32(ext, "number", VT_DRIVER_VERSION);
291 break;
292 }
293 case OMX_QTIIndexParamCapabilitiesMaxLTR:
294 {
295 setStatus &= vExt.setParamInt32(ext, "max-count", 3);
296 break;
297 }
298 case OMX_QTIIndexParamCapabilitiesMaxDownScaleRatio:
299 {
300 setStatus &= vExt.setParamInt32(ext, "max-downscale-factor", 8);
301 break;
302 }
303 case OMX_QTIIndexParamCapabilitiesRotationSupport:
304 {
305 setStatus &= vExt.setParamInt32(ext, "rotation",1);
306 break;
307 }
308 case OMX_QTIIndexParamCapabilitiesMaxTemporalLayers:
309 {
310 OMX_U32 nPLayerCountMax , nBLayerCountMax;
311 OMX_VIDEO_ANDROID_TEMPORALLAYERINGPATTERNTYPE SupportedPattern;
312 if (!dev_get_temporal_layer_caps(&nPLayerCountMax,
313 &nBLayerCountMax, &SupportedPattern)) {
314 DEBUG_PRINT_ERROR("Failed to get temporal layer capabilities");
315 break;
316 }
317 setStatus &= vExt.setParamInt32(ext, "max-p-count",nPLayerCountMax);
318 setStatus &= vExt.setParamInt32(ext, "max-b-count",nBLayerCountMax);
319 break;
320 }
321 case OMX_QTIIndexParamColorSpaceConversion:
322 {
323 setStatus &= vExt.setParamInt32(ext, "enable", m_sParamColorSpaceConversion.bEnable);
324 break;
325 }
326 case QOMX_IndexParamVideoInitialQp:
327 {
328 setStatus &= vExt.setParamInt32(ext, "qp-i", m_sSessionQuantization.nQpI);
329 setStatus &= vExt.setParamInt32(ext, "qp-p", m_sSessionQuantization.nQpP);
330 setStatus &= vExt.setParamInt32(ext, "qp-b", m_sSessionQuantization.nQpB);
331 setStatus &= vExt.setParamInt32(ext, "qp-i-enable", (m_QPSet & 0x1));
332 setStatus &= vExt.setParamInt32(ext, "qp-p-enable", ((m_QPSet >> 0x1) & 0x1));
333 setStatus &= vExt.setParamInt32(ext, "qp-b-enable", ((m_QPSet >> 0x2) & 0x1));
334 break;
335 }
336 case OMX_QTIIndexParamVideoEnableBlur:
337 case OMX_QTIIndexConfigVideoBlurResolution:
338 case OMX_QTIIndexConfigContentAdaptiveCoding:
339 {
340 break;
341 }
342 case OMX_QcomIndexParamVideoIPBQPRange:
343 {
344 setStatus &= vExt.setParamInt32(ext, "qp-i-min", m_sSessionQPRange.minIQP);
345 setStatus &= vExt.setParamInt32(ext, "qp-i-max", m_sSessionQPRange.maxIQP);
346 setStatus &= vExt.setParamInt32(ext, "qp-p-min", m_sSessionQPRange.minPQP);
347 setStatus &= vExt.setParamInt32(ext, "qp-p-max", m_sSessionQPRange.maxPQP);
348 setStatus &= vExt.setParamInt32(ext, "qp-b-min", m_sSessionQPRange.minBQP);
349 setStatus &= vExt.setParamInt32(ext, "qp-b-max", m_sSessionQPRange.maxBQP);
350 break;
351 }
352 case OMX_IndexParamVideoBitrate:
353 {
354 setStatus &= vExt.setParamInt32(ext, "value", m_sParamBitrate.eControlRate);
355 break;
356 }
357 case OMX_QTIIndexParamEnableLinearColorFormat:
358 {
359 setStatus &= vExt.setParamInt32(ext, "value", m_sParamLinearColorFormat.bEnable);
360 break;
361 }
362 case OMX_QTIIndexParamVbvDelay:
363 {
364 setStatus &= vExt.setParamInt32(ext, "value", m_sParamVbvDelay.nVbvDelay);
365 break;
366 }
367 case OMX_QTIIndexConfigVideoRoiRectRegionInfo:
368 {
369 if (vExt.paramCount() == 1) {
370 setStatus &= vExt.setParamInt32(ext, "enable", 1);
371 } else {
372 setStatus &= vExt.setParamInt64(ext, "timestamp", 0);
373 setStatus &= vExt.setParamString(ext, "type", "rect");
374 setStatus &= vExt.setParamString(ext, "rect-payload", "");
375 setStatus &= vExt.setParamString(ext, "rect-payload-ext", "");
376 }
377 break;
378 }
379 default:
380 {
381 return OMX_ErrorNotImplemented;
382 }
383 }
384 return setStatus ? OMX_ErrorNone : OMX_ErrorUndefined;
385 }
386
set_vendor_extension_config(OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE * ext)387 OMX_ERRORTYPE omx_video::set_vendor_extension_config(
388 OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *ext) {
389
390 DEBUG_PRINT_LOW("set_vendor_extension_config");
391 if (ext->nIndex >= mVendorExtensionStore.size()) {
392 DEBUG_PRINT_ERROR("unrecognized vendor extension index (%u) max(%u)",
393 ext->nIndex, mVendorExtensionStore.size());
394 return OMX_ErrorBadParameter;
395 }
396
397 const VendorExtension& vExt = mVendorExtensionStore[ext->nIndex];
398 DEBUG_PRINT_LOW("VendorExt: setConfig: index=%u (%s)", ext->nIndex, vExt.name());
399
400 OMX_ERRORTYPE err = OMX_ErrorNone;
401 err = vExt.isConfigValid(ext);
402 if (err != OMX_ErrorNone) {
403 return err;
404 }
405
406 // mark this as set, regardless of set_config succeeding/failing.
407 // App will know by inconsistent values in output-format
408 vExt.set();
409
410 bool valueSet = false;
411 switch ((OMX_U32)vExt.extensionIndex()) {
412 case OMX_IndexConfigCommonRotate:
413 {
414 OMX_CONFIG_ROTATIONTYPE rotationParam;
415 memcpy(&rotationParam, &m_sConfigFrameRotation, sizeof(OMX_CONFIG_ROTATIONTYPE));
416 valueSet |= vExt.readParamInt32(ext, "angle", &rotationParam.nRotation);
417 if (!valueSet) {
418 break;
419 }
420
421 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: OMX_IndexConfigCommonRotate : %d",
422 rotationParam.nRotation);
423
424 err = set_config(
425 NULL, OMX_IndexConfigCommonRotate, &rotationParam);
426 if (err != OMX_ErrorNone) {
427 DEBUG_PRINT_ERROR("set_config: OMX_IndexConfigCommonRotate failed !");
428 }
429 break;
430 }
431 case OMX_IndexConfigCommonMirror:
432 {
433 OMX_CONFIG_MIRRORTYPE mirrorParam;
434 memcpy(&mirrorParam, &m_sConfigFrameMirror, sizeof(OMX_CONFIG_MIRRORTYPE));
435 valueSet |= vExt.readParamInt32(ext, "flip", (OMX_S32*)&mirrorParam.eMirror);
436 if (!valueSet) {
437 break;
438 }
439
440 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: OMX_IndexConfigCommonMirror : %d",
441 mirrorParam.eMirror);
442
443 err = set_config(
444 NULL, OMX_IndexConfigCommonMirror, &mirrorParam);
445 if (err != OMX_ErrorNone) {
446 DEBUG_PRINT_ERROR("set_config: OMX_IndexConfigCommonMirror failed !");
447 }
448 break;
449 }
450 case QOMX_IndexConfigVideoIntraperiod:
451 {
452 QOMX_VIDEO_INTRAPERIODTYPE intraPeriodConfig;
453 memcpy(&intraPeriodConfig, &m_sIntraperiod, sizeof(QOMX_VIDEO_INTRAPERIODTYPE));
454
455 if (vExt.isConfigKey(ext, "qti-ext-enc-avc-intra-period")) {
456 valueSet |= vExt.readParamInt32(ext, "n-pframes", (OMX_S32 *)&(intraPeriodConfig.nPFrames));
457 valueSet |= vExt.readParamInt32(ext, "n-idr-period", (OMX_S32 *)&(intraPeriodConfig.nIDRPeriod));
458
459 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: AVC-intra-period : nP=%d, nIDR=%d",
460 intraPeriodConfig.nPFrames, intraPeriodConfig.nIDRPeriod);
461 } else if (vExt.isConfigKey(ext, "qti-ext-enc-intra-period")) {
462 valueSet |= vExt.readParamInt32(ext, "n-bframes", (OMX_S32 *)&(intraPeriodConfig.nBFrames));
463 valueSet |= vExt.readParamInt32(ext, "n-pframes", (OMX_S32 *)&(intraPeriodConfig.nPFrames));
464 valueSet |= vExt.readParamInt32(ext, "n-idr-period", (OMX_S32 *)&(intraPeriodConfig.nIDRPeriod));
465
466 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: intra-period : nIDR=%d, nP=%d, nB=%d",
467 intraPeriodConfig.nIDRPeriod, intraPeriodConfig.nPFrames, intraPeriodConfig.nBFrames);
468 }
469 if (!valueSet) {
470 break;
471 }
472
473 err = set_config(
474 NULL, (OMX_INDEXTYPE)QOMX_IndexConfigVideoIntraperiod, &intraPeriodConfig);
475 if (err != OMX_ErrorNone) {
476 DEBUG_PRINT_ERROR("set_config: QOMX_IndexConfigVideoIntraperiod failed !");
477 }
478 break;
479 }
480 case OMX_QcomIndexParamVideoSliceSpacing:
481 {
482 QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE sliceSpacing;
483 memcpy(&sliceSpacing, &m_sSliceSpacing, sizeof(QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE));
484
485 if (vExt.isConfigKey(ext, "qti-ext-enc-error-correction")) {
486 sliceSpacing.eSliceMode = QOMX_SLICEMODE_BYTE_COUNT;
487 valueSet |= vExt.readParamInt32(ext,
488 "resync-marker-spacing-bits", (OMX_S32 *)&(sliceSpacing.nSliceSize));
489 sliceSpacing.nSliceSize = ALIGN(sliceSpacing.nSliceSize, 8) >> 3;
490 } else if (vExt.isConfigKey(ext, "qti-ext-enc-slice")) {
491 sliceSpacing.eSliceMode = QOMX_SLICEMODE_MB_COUNT;
492 valueSet |= vExt.readParamInt32(ext,
493 "spacing", (OMX_S32 *)&(sliceSpacing.nSliceSize));
494 } else {
495 DEBUG_PRINT_ERROR("VENDOR-EXT: set_config: Slice Spacing : Incorrect Mode !");
496 break;
497 }
498
499 if (!valueSet) {
500 break;
501 }
502
503 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: slice spacing : mode %d size %d",
504 sliceSpacing.eSliceMode, sliceSpacing.nSliceSize);
505
506 err = set_parameter(
507 NULL, (OMX_INDEXTYPE)OMX_QcomIndexParamVideoSliceSpacing, &sliceSpacing);
508 if (err != OMX_ErrorNone) {
509 DEBUG_PRINT_ERROR("set_config: OMX_QcomIndexParamVideoSliceSpacing failed !");
510 }
511 break;
512 }
513 case OMX_IndexParamVideoProfileLevelCurrent:
514 {
515 OMX_VIDEO_PARAM_PROFILELEVELTYPE profileParam;
516 memcpy(&profileParam, &m_sParamProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
517 valueSet |= vExt.readParamInt32(ext, "profile", (OMX_S32 *)&(profileParam.eProfile));
518 valueSet |= vExt.readParamInt32(ext, "level", (OMX_S32 *)&(profileParam.eLevel));
519 if (!valueSet) {
520 break;
521 }
522
523 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: custom-profile/level : profile=%u level=%u",
524 (OMX_U32)profileParam.eProfile, (OMX_U32)profileParam.eLevel);
525
526 err = set_parameter(
527 NULL, OMX_IndexParamVideoProfileLevelCurrent, &profileParam);
528 if (err != OMX_ErrorNone) {
529 DEBUG_PRINT_ERROR("set_config: OMX_IndexParamVideoProfileLevelCurrent failed !");
530 }
531
532 break;
533 }
534 case OMX_QTIIndexParamEnableAVTimerTimestamps:
535 {
536 QOMX_ENABLETYPE avTimerEnableParam;
537 memcpy(&avTimerEnableParam, &m_sParamAVTimerTimestampMode, sizeof(QOMX_ENABLETYPE));
538 valueSet |= vExt.readParamInt32(ext, "enable", (OMX_S32 *)&(avTimerEnableParam.bEnable));
539 if (!valueSet) {
540 break;
541 }
542
543 DEBUG_PRINT_HIGH("VENDOR-EXT: AV-timer timestamp mode enable=%u", avTimerEnableParam.bEnable);
544
545 err = set_parameter(
546 NULL, (OMX_INDEXTYPE)OMX_QTIIndexParamEnableAVTimerTimestamps, &avTimerEnableParam);
547 if (err != OMX_ErrorNone) {
548 DEBUG_PRINT_ERROR("set_param: OMX_QTIIndexParamEnableAVTimerTimestamps failed !");
549 }
550
551 break;
552 }
553 case OMX_QcomIndexConfigQp:
554 {
555 OMX_QCOM_VIDEO_CONFIG_QP qpConfig;
556 memcpy(&qpConfig, &m_sConfigQP, sizeof(OMX_QCOM_VIDEO_CONFIG_QP));
557 valueSet |= vExt.readParamInt32(ext, "value", (OMX_S32 *)&(qpConfig.nQP));
558 if (!valueSet) {
559 break;
560 }
561
562 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: nQP =%u", qpConfig.nQP);
563
564 err = set_config(
565 NULL, (OMX_INDEXTYPE)OMX_QcomIndexConfigQp, &qpConfig);
566 if (err != OMX_ErrorNone) {
567 DEBUG_PRINT_ERROR("set_config: OMX_QcomIndexConfigQp failed !");
568 }
569
570 break;
571 }
572 case OMX_QcomIndexParamVideoDownScalar:
573 {
574 QOMX_INDEXDOWNSCALAR downScalarParam;
575 memcpy(&downScalarParam, &m_sParamDownScalar, sizeof(QOMX_INDEXDOWNSCALAR));
576 downScalarParam.bEnable = OMX_TRUE;
577 valueSet |= vExt.readParamInt32(ext, "output-width", (OMX_S32 *)&(downScalarParam.nOutputWidth));
578 valueSet |= vExt.readParamInt32(ext, "output-height", (OMX_S32 *)&(downScalarParam.nOutputHeight));
579 if(!valueSet) {
580 break;
581 }
582
583 DEBUG_PRINT_HIGH("VENDOR-EXT: Downscalar Enable = %u Output Width = %u Output Height = %u",
584 downScalarParam.bEnable, downScalarParam.nOutputWidth, downScalarParam.nOutputHeight);
585
586 err = set_parameter(NULL, (OMX_INDEXTYPE)OMX_QcomIndexParamVideoDownScalar, &downScalarParam);
587 if (err != OMX_ErrorNone) {
588 DEBUG_PRINT_ERROR("set_param: OMX_QcomIndexParamVideoDownScalar failed !");
589 }
590 break;
591 }
592 case OMX_QcomIndexParamVencControlInputQueue:
593 {
594 QOMX_ENABLETYPE controlInputQueueParam;
595 memcpy(&controlInputQueueParam, &m_sParamControlInputQueue, sizeof(QOMX_ENABLETYPE));
596 valueSet |= vExt.readParamInt32(ext, "enable", (OMX_S32 *)&(controlInputQueueParam.bEnable));
597 if (!valueSet) {
598 break;
599 }
600
601 DEBUG_PRINT_HIGH("VENDOR-EXT: set_param: control input queue enable=%u", controlInputQueueParam.bEnable);
602
603 err = set_parameter(
604 NULL, (OMX_INDEXTYPE)OMX_QcomIndexParamVencControlInputQueue, &controlInputQueueParam);
605 if (err != OMX_ErrorNone) {
606 DEBUG_PRINT_ERROR("set_param: OMX_QcomIndexParamVencControlInputQueue failed !");
607 }
608
609 break;
610 }
611 case OMX_IndexConfigTimePosition:
612 {
613 OMX_TIME_CONFIG_TIMESTAMPTYPE triggerTimeStamp;
614 memcpy(&triggerTimeStamp, &m_sConfigInputTrigTS, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
615 valueSet |= vExt.readParamInt64(ext, "timestamp", (OMX_S64 *)&(triggerTimeStamp.nTimestamp));
616 if (!valueSet) {
617 break;
618 }
619
620 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: trigger timestamp =%lld", triggerTimeStamp.nTimestamp);
621
622 err = set_config(
623 NULL, (OMX_INDEXTYPE)OMX_IndexConfigTimePosition, &triggerTimeStamp);
624 if (err != OMX_ErrorNone) {
625 DEBUG_PRINT_ERROR("set_config: OMX_IndexConfigTimePosition failed !");
626 }
627
628 break;
629 }
630 case OMX_QTIIndexParamLowLatencyMode:
631 {
632 QOMX_EXTNINDEX_VIDEO_LOW_LATENCY_MODE lowLatency;
633 memcpy(&lowLatency, &m_sParamLowLatency, sizeof(QOMX_EXTNINDEX_VIDEO_LOW_LATENCY_MODE));
634 valueSet |= vExt.readParamInt32(ext, "enable", (OMX_S32 *)&(lowLatency.bEnableLowLatencyMode));
635 if (!valueSet) {
636 break;
637 }
638
639 DEBUG_PRINT_HIGH("VENDOR-EXT: set_param: low latency mode =%u", lowLatency.bEnableLowLatencyMode);
640
641 err = set_parameter(
642 NULL, (OMX_INDEXTYPE)OMX_QTIIndexParamLowLatencyMode, &lowLatency);
643 if (err != OMX_ErrorNone) {
644 DEBUG_PRINT_ERROR("set_param: OMX_QTIIndexParamLowLatencyMode failed !");
645 }
646
647 break;
648 }
649 case OMX_QcomIndexConfigBaseLayerId:
650 {
651 OMX_SKYPE_VIDEO_CONFIG_BASELAYERPID baselayerPID;
652 memcpy(&baselayerPID, &m_sBaseLayerID, sizeof(OMX_SKYPE_VIDEO_CONFIG_BASELAYERPID));
653 valueSet |= vExt.readParamInt32(ext, "value", (OMX_S32 *)&(baselayerPID.nPID));
654 if (!valueSet) {
655 break;
656 }
657
658 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: base layer pid =%u", baselayerPID.nPID);
659
660 err = set_config(
661 NULL, (OMX_INDEXTYPE)OMX_QcomIndexConfigBaseLayerId, &baselayerPID);
662 if (err != OMX_ErrorNone) {
663 DEBUG_PRINT_ERROR("set_config: OMX_QcomIndexConfigBaseLayerId failed !");
664 }
665
666 break;
667 }
668 case OMX_QcomIndexParamVideoLTRCount:
669 {
670 QOMX_VIDEO_PARAM_LTRCOUNT_TYPE ltrCount;
671 memcpy(<rCount, &m_sParamLTRCount, sizeof(QOMX_VIDEO_PARAM_LTRCOUNT_TYPE));
672 valueSet |= vExt.readParamInt32(ext, "num-ltr-frames", (OMX_S32 *)&(ltrCount.nCount));
673 if (!valueSet) {
674 break;
675 }
676
677 DEBUG_PRINT_HIGH("VENDOR-EXT: set_parameter: ltr count =%u", ltrCount.nCount);
678
679 err = set_parameter(
680 NULL, (OMX_INDEXTYPE)QOMX_IndexParamVideoLTRCount, <rCount);
681 if (err != OMX_ErrorNone) {
682 DEBUG_PRINT_ERROR("set_parameter: OMX_QcomIndexParamVideoLTRCount failed !");
683 }
684
685 break;
686 }
687 case OMX_QcomIndexConfigVideoLTRUse:
688 {
689 QOMX_VIDEO_CONFIG_LTRUSE_TYPE ltrUse;
690 memcpy(<rUse, &m_sConfigLTRUse, sizeof(QOMX_VIDEO_CONFIG_LTRUSE_TYPE));
691 valueSet |= vExt.readParamInt32(ext, "use-frame", (OMX_S32 *)&(ltrUse.nID));
692 if (!valueSet) {
693 break;
694 }
695
696 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: ltr use =%u", ltrUse.nID);
697
698 err = set_config(
699 NULL, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRUse, <rUse);
700 if (err != OMX_ErrorNone) {
701 DEBUG_PRINT_ERROR("set_config: OMX_QcomIndexConfigVideoLTRUse failed !");
702 }
703
704 break;
705 }
706 case OMX_QcomIndexConfigVideoLTRMark:
707 {
708 QOMX_VIDEO_CONFIG_LTRMARK_TYPE ltrMark;
709 memcpy(<rMark, &m_sConfigLTRMark, sizeof(QOMX_VIDEO_CONFIG_LTRMARK_TYPE));
710 valueSet |= vExt.readParamInt32(ext, "mark-frame", (OMX_S32 *)&(ltrMark.nID));
711 if (!valueSet) {
712 break;
713 }
714
715 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: ltr mark =%u", ltrMark.nID);
716
717 err = set_config(
718 NULL, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRMark, <rMark);
719 if (err != OMX_ErrorNone) {
720 DEBUG_PRINT_ERROR("set_config: OMX_QcomIndexConfigVideoLTRMark failed !");
721 }
722
723 break;
724 }
725 case OMX_IndexConfigVideoFramerate:
726 {
727 OMX_CONFIG_FRAMERATETYPE rateParam;
728 memcpy(&rateParam, &m_sConfigFramerate, sizeof(OMX_CONFIG_FRAMERATETYPE));
729 valueSet |= vExt.readParamInt32(ext, "frame-rate", (OMX_S32 *)&rateParam.xEncodeFramerate);
730 if (!valueSet) {
731 break;
732 }
733 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: OMX_IndexConfigVideoFramerate : %d",
734 rateParam.xEncodeFramerate);
735
736 err = set_config(
737 NULL, OMX_IndexConfigVideoFramerate, &rateParam);
738 if (err != OMX_ErrorNone) {
739 DEBUG_PRINT_ERROR("set_config: OMX_IndexConfigVideoFramerate failed !");
740 }
741 break;
742 }
743 case OMX_QcomIndexParamIndexExtraDataType:
744 {
745 QOMX_INDEXEXTRADATATYPE extraDataParam;
746 char exType[OMX_MAX_STRINGVALUE_SIZE];
747 OMX_INIT_STRUCT(&extraDataParam, QOMX_INDEXEXTRADATATYPE);
748 valueSet |= vExt.readParamString(ext, "types", exType);
749 if (!valueSet) {
750 break;
751 }
752 char *rest = exType;
753 char *token = NULL;
754 while ((token = strtok_r(rest, "|", &rest))) {
755 extraDataParam.bEnabled = OMX_TRUE;
756 if (!strcmp(token, "advanced")) {
757 extraDataParam.nIndex = (OMX_INDEXTYPE)OMX_QTI_ExtraDataCategory_Advanced;
758 extraDataParam.nPortIndex = (OMX_U32)PORT_INDEX_OUT;
759 } else if (!strcmp(token, "roiinfo")) {
760 extraDataParam.nIndex = (OMX_INDEXTYPE)OMX_QTI_ExtraDataCategory_Enc_ROI;
761 extraDataParam.nPortIndex = (OMX_U32)PORT_INDEX_IN;
762 } else {
763 DEBUG_PRINT_HIGH("extradata %s not supported ", token);
764 continue;
765 }
766 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: extradata: enable for index = %d",
767 extraDataParam.nIndex);
768 err = set_parameter(
769 NULL, (OMX_INDEXTYPE)OMX_QcomIndexParamIndexExtraDataType, &extraDataParam);
770 if (err != OMX_ErrorNone) {
771 DEBUG_PRINT_ERROR("set_config: OMX_QcomIndexParamIndexExtraDataType failed !");
772 }
773 }
774 break;
775 }
776 case OMX_QTIIndexParamColorSpaceConversion:
777 {
778 QOMX_ENABLETYPE colorspaceConversionParam;
779 memcpy(&colorspaceConversionParam, &m_sParamColorSpaceConversion, sizeof(QOMX_ENABLETYPE));
780 valueSet |= vExt.readParamInt32(ext, "enable", (OMX_S32 *)&(colorspaceConversionParam.bEnable));
781 if (!valueSet) {
782 break;
783 }
784
785 DEBUG_PRINT_HIGH("VENDOR-EXT: set_param: color space conversion enable=%u", colorspaceConversionParam.bEnable);
786
787 err = set_parameter(
788 NULL, (OMX_INDEXTYPE)OMX_QTIIndexParamColorSpaceConversion, &colorspaceConversionParam);
789 if (err != OMX_ErrorNone) {
790 DEBUG_PRINT_ERROR("set_param: OMX_QTIIndexParamColorSpaceConversion failed !");
791 }
792
793 break;
794 }
795 case OMX_QTIIndexParamCapabilitiesVTDriverVersion:
796 case OMX_QTIIndexParamCapabilitiesMaxLTR:
797 case OMX_QTIIndexParamCapabilitiesMaxDownScaleRatio:
798 case OMX_QTIIndexParamCapabilitiesRotationSupport:
799 case OMX_QTIIndexParamCapabilitiesMaxTemporalLayers:
800 {
801 break;
802 }
803 case QOMX_IndexParamVideoInitialQp:
804 {
805 QOMX_EXTNINDEX_VIDEO_INITIALQP initQP;
806 OMX_INIT_STRUCT(&initQP, QOMX_EXTNINDEX_VIDEO_INITIALQP);
807 initQP.nPortIndex = (OMX_U32)PORT_INDEX_OUT;
808 OMX_S32 enableIQp = (m_QPSet & 0x1);
809 OMX_S32 enablePQp = ((m_QPSet >> 0x1) & 0x1);
810 OMX_S32 enableBQp = ((m_QPSet >> 0x2) & 0x1);
811 initQP.nQpI = m_sSessionQuantization.nQpI;
812 initQP.nQpP = m_sSessionQuantization.nQpP;
813 initQP.nQpB = m_sSessionQuantization.nQpB;
814 initQP.bEnableInitQp = m_QPSet;
815 valueSet |= vExt.readParamInt32(ext, "qp-i", (OMX_S32 *)&(initQP.nQpI));
816 valueSet |= vExt.readParamInt32(ext, "qp-b", (OMX_S32 *)&(initQP.nQpB));
817 valueSet |= vExt.readParamInt32(ext, "qp-p", (OMX_S32 *)&(initQP.nQpP));
818 valueSet |= vExt.readParamInt32(ext, "qp-i-enable", (OMX_S32 *)&enableIQp);
819 valueSet |= vExt.readParamInt32(ext, "qp-p-enable", (OMX_S32 *)&enablePQp);
820 valueSet |= vExt.readParamInt32(ext, "qp-b-enable", (OMX_S32 *)&enableBQp);
821 initQP.bEnableInitQp = (((enableIQp == 0x1) << 0x0 ) | ((enablePQp == 0x1) << 0x1 ) | ((enableBQp == 0x1) << 0x2 ));
822 if (!valueSet) {
823 break;
824 }
825
826 DEBUG_PRINT_HIGH("VENDOR-EXT: set_param: QOMX_IndexParamVideoInitialQp I/B/P value: %d %d %d",
827 initQP.nQpI,initQP.nQpB,initQP.nQpP);
828
829 err = set_parameter(
830 NULL, (OMX_INDEXTYPE)QOMX_IndexParamVideoInitialQp, &initQP);
831 if (err != OMX_ErrorNone) {
832 DEBUG_PRINT_ERROR("set_param: QOMX_IndexParamVideoInitialQp failed !");
833 }
834 break;
835 }
836 case OMX_QTIIndexConfigVideoBlurResolution:
837 {
838 OMX_QTI_VIDEO_CONFIG_BLURINFO blurInfo;
839
840 memcpy(&blurInfo, &m_blurInfo, sizeof(OMX_QTI_VIDEO_CONFIG_BLURINFO));
841
842 valueSet |= vExt.readParamInt32(ext, "info", (OMX_S32 *)&(blurInfo.nBlurInfo));
843 if (!valueSet) {
844 break;
845 }
846
847 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: OMX_QTIIndexConfigVideoBlurResolution : %u",
848 blurInfo.nBlurInfo);
849
850 err = set_config(
851 NULL, (OMX_INDEXTYPE)OMX_QTIIndexConfigVideoBlurResolution, &blurInfo);
852 if (err != OMX_ErrorNone) {
853 DEBUG_PRINT_ERROR("set_config: OMX_QTIIndexConfigVideoBlurResolution failed !");
854 }
855 break;
856 }
857 case OMX_QcomIndexParamVideoIPBQPRange:
858 {
859 OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE qpRange;
860 memcpy(&qpRange, &m_sSessionQPRange, sizeof(OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE));
861 valueSet |= vExt.readParamInt32(ext, "qp-i-min", (OMX_S32 *)&(qpRange.minIQP));
862 valueSet |= vExt.readParamInt32(ext, "qp-i-max", (OMX_S32 *)&(qpRange.maxIQP));
863 valueSet |= vExt.readParamInt32(ext, "qp-p-min", (OMX_S32 *)&(qpRange.minPQP));
864 valueSet |= vExt.readParamInt32(ext, "qp-p-max", (OMX_S32 *)&(qpRange.maxPQP));
865 valueSet |= vExt.readParamInt32(ext, "qp-b-min", (OMX_S32 *)&(qpRange.minBQP));
866 valueSet |= vExt.readParamInt32(ext, "qp-b-max", (OMX_S32 *)&(qpRange.maxBQP));
867 if (!valueSet) {
868 break;
869 }
870
871 DEBUG_PRINT_HIGH("VENDOR-EXT: set_param: OMX_QcomIndexParamVideoIPBQPRange for min/max value for I/P/B: %d-%d / %d-%d / %d-%d"
872 ,qpRange.minIQP,qpRange.maxIQP,qpRange.minPQP,qpRange.maxPQP,qpRange.minBQP,qpRange.maxBQP);
873
874 err = set_parameter(
875 NULL, (OMX_INDEXTYPE)OMX_QcomIndexParamVideoIPBQPRange, &qpRange);
876 if (err != OMX_ErrorNone) {
877 DEBUG_PRINT_ERROR("set_param: OMX_QcomIndexParamVideoIPBQPRange failed !");
878 }
879 break;
880 }
881 case OMX_IndexParamVideoBitrate:
882 {
883 OMX_VIDEO_PARAM_BITRATETYPE bitRateParam;
884 memcpy(&bitRateParam, &m_sParamBitrate, sizeof(OMX_VIDEO_PARAM_BITRATETYPE));
885 valueSet |= vExt.readParamInt32(ext, "value", (OMX_S32 *)&(bitRateParam.eControlRate));
886 if (!valueSet) {
887 break;
888 }
889 DEBUG_PRINT_HIGH("VENDOR-EXT: set_param: ControlRate = %d",
890 bitRateParam.eControlRate);
891
892 err = set_parameter(
893 NULL, (OMX_INDEXTYPE)OMX_IndexParamVideoBitrate, &bitRateParam);
894 if (err != OMX_ErrorNone) {
895 DEBUG_PRINT_ERROR("set_param: OMX_IndexParamVideoBitrate failed !");
896 }
897
898 break;
899 }
900 case OMX_QTIIndexParamEnableLinearColorFormat:
901 {
902 QOMX_ENABLETYPE linearColor;
903 memcpy(&linearColor, &m_sParamLinearColorFormat, sizeof(QOMX_ENABLETYPE));
904 valueSet |= vExt.readParamInt32(ext, "value", (OMX_S32 *)&(linearColor.bEnable));
905 if (!valueSet) {
906 break;
907 }
908
909 DEBUG_PRINT_HIGH("VENDOR-EXT: set_param: OMX_QTIIndexParamEnableLinearColorFormat : %d",
910 linearColor.bEnable);
911
912 err = set_parameter(
913 NULL, (OMX_INDEXTYPE)OMX_QTIIndexParamEnableLinearColorFormat, &linearColor);
914 if (err != OMX_ErrorNone) {
915 DEBUG_PRINT_ERROR("set_param: OMX_QTIIndexParamEnableLinearColorFormat failed !");
916 }
917 break;
918 }
919 case OMX_QTIIndexParamVbvDelay:
920 {
921 OMX_EXTNINDEX_VIDEO_VBV_DELAY vbvDelay;
922 memcpy(&vbvDelay, &m_sParamVbvDelay, sizeof(OMX_EXTNINDEX_VIDEO_VBV_DELAY));
923 valueSet |= vExt.readParamInt32(ext, "value", (OMX_S32 *)&(vbvDelay.nVbvDelay));
924 if (!valueSet) {
925 break;
926 }
927
928 DEBUG_PRINT_HIGH("VENDOR-EXT: set_param: OMX_QTIIndexParamVbvDelay : %d",
929 vbvDelay.nVbvDelay);
930
931 err = set_parameter(
932 NULL, (OMX_INDEXTYPE)OMX_QTIIndexParamVbvDelay, &vbvDelay);
933 if (err != OMX_ErrorNone) {
934 DEBUG_PRINT_ERROR("set_param: OMX_QTIIndexParamVbvDelay failed !");
935 }
936 break;
937 }
938 case OMX_QTIIndexConfigVideoRoiRectRegionInfo:
939 {
940 if (vExt.paramCount() == 1) {
941 break;
942 }
943 uint32_t format = m_sOutPortDef.format.video.eCompressionFormat;
944 if (format != OMX_VIDEO_CodingHEVC && format != OMX_VIDEO_CodingAVC) {
945 DEBUG_PRINT_ERROR("ROI-Ext: only support avc or hevc");
946 break;
947 }
948 char type[OMX_MAX_STRINGVALUE_SIZE];
949 valueSet = vExt.readParamString(ext, "type", type);
950 if (!valueSet || strncmp(type, "rect", 4)) {
951 DEBUG_PRINT_ERROR("ROI-Ext: type is invalid");
952 break;
953 }
954 int64_t timestamp;
955 valueSet = vExt.readParamInt64(ext, "timestamp", (OMX_S64 *)×tamp);
956 if (!valueSet) {
957 DEBUG_PRINT_ERROR("ROI-Ext: timestamp is invalid");
958 break;
959 }
960 char rawData[OMX_MAX_STRINGVALUE_SIZE * 2] = {0};
961 valueSet = vExt.readParamString(ext, "rect-payload", rawData);
962 if (!valueSet) {
963 DEBUG_PRINT_ERROR("ROI-Ext: payload is invalid");
964 break;
965 }
966 uint32_t size = strlen(rawData);
967 if (size == 0 || size > (OMX_MAX_STRINGVALUE_SIZE -1)) {
968 DEBUG_PRINT_ERROR("ROI-Ext: payload size is invalid : %u", size);
969 break;
970 }
971 // "payload-ext" is optional, if it's set by the client, joint this string
972 // with the "payload" string and seperate them with ';'
973 if (vExt.readParamString(ext, "rect-payload-ext", rawData + size + 1)) {
974 rawData[size] = ';';
975 size = strlen(rawData);
976 }
977 uint32_t width = m_sOutPortDef.format.video.nFrameWidth;
978 uint32_t height = m_sOutPortDef.format.video.nFrameHeight;
979 DEBUG_PRINT_LOW("ROI-Ext: clip(%ux%u), ts(%lld), payload(%u):%s",
980 width, height, (long long)timestamp, size, rawData);
981
982 OMX_QTI_VIDEO_CONFIG_ROI_RECT_REGION_INFO roiInfo;
983 OMX_INIT_STRUCT(&roiInfo, OMX_QTI_VIDEO_CONFIG_ROI_RECT_REGION_INFO);
984 roiInfo.nTimeStamp = timestamp;
985 roiInfo.nPortIndex = PORT_INDEX_IN;
986
987 // The pattern to parse the String: "top,left-bottom,right=deltaQp;"
988 // each rectangle region string is seperated by ";"
989 // For example, the rectangle region is: top: 128, left:96, bottom:336, right:272
990 // and delta QP is -9, the string is "128,96-336,272=-9;".
991 uint32_t index = 0;
992 int top, left, bottom, right, deltaQp;
993 char *save = rawData;
994 char *rect = strtok_r(rawData, ";", &save);
995 const char* patternString = "%d,%d-%d,%d=%d";
996 while (rect != NULL) {
997 int tags = sscanf(rect, patternString, &top, &left, &bottom, &right, &deltaQp);
998 if (tags == 5) {
999 // sanity check
1000 if (top > bottom || left > right || top < 0 || left < 0
1001 || bottom >= (int32_t)height || right >= (int32_t)width
1002 || index == MAX_RECT_ROI_NUM) {
1003 DEBUG_PRINT_ERROR("ROI-Ext: invalid roi info with deltaQp");
1004 } else {
1005 // delta QP range is (-32, 31)
1006 if (deltaQp < -31) {
1007 deltaQp = -31;
1008 }
1009 if (deltaQp > 30) {
1010 deltaQp = 30;
1011 }
1012 roiInfo.nRegions[index].nLeft = (uint32_t)left;
1013 roiInfo.nRegions[index].nTop = (uint32_t)top;
1014 roiInfo.nRegions[index].nRight = (uint32_t)right;
1015 roiInfo.nRegions[index].nBottom = (uint32_t)bottom;
1016 roiInfo.nRegions[index].nDeltaQP = (int8_t)deltaQp;
1017 DEBUG_PRINT_LOW("ROI-Ext: region(%u): t%d-l%d-b%d-r%d: qp:%d",
1018 index, top, left, bottom, right, deltaQp);
1019 index++;
1020 }
1021 } else {
1022 DEBUG_PRINT_LOW("error rect : %s", rect);
1023 }
1024 rect = strtok_r(NULL, ";", &save);
1025 }
1026 if (index > 0) {
1027 roiInfo.nRegionNum = index;
1028 err = set_config(NULL, (OMX_INDEXTYPE)OMX_QTIIndexConfigVideoRoiRectRegionInfo,
1029 &roiInfo);
1030 if (err != OMX_ErrorNone) {
1031 DEBUG_PRINT_ERROR("ROI-Ext: failed to set roi region info");
1032 } else {
1033 DEBUG_PRINT_LOW("ROI-Ext: set %u number of roi region info", index);
1034 }
1035 } else {
1036 DEBUG_PRINT_LOW("ROI-Ext: none valid roi region info");
1037 }
1038 break;
1039 }
1040 case OMX_QTIIndexConfigContentAdaptiveCoding:
1041 {
1042 OMX_U32 bitrateSavingsMode;
1043 valueSet |= vExt.readParamInt32(ext, "value", (OMX_S32 *)&(bitrateSavingsMode));
1044 if (!valueSet) {
1045 break;
1046 }
1047 DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: OMX_QTIIndexConfigContentAdaptiveCoding : %u",
1048 bitrateSavingsMode);
1049
1050 err = set_config(
1051 NULL, (OMX_INDEXTYPE)OMX_QTIIndexConfigContentAdaptiveCoding, &bitrateSavingsMode);
1052 if (err != OMX_ErrorNone) {
1053 DEBUG_PRINT_ERROR("set_config: OMX_QTIIndexConfigContentAdaptiveCoding failed !");
1054 }
1055 break;
1056 }
1057 default:
1058 {
1059 return OMX_ErrorNotImplemented;
1060 }
1061 }
1062 return err;
1063 }
1064