1 /*******************************************************************************
2 * Copyright 2016-2019 Intel Corporation.
3 *
4 * This software and the related documents are Intel copyrighted materials, and
5 * your use of them is governed by the express license under which they were
6 * provided to you (License). Unless the License provides otherwise, you may not
7 * use, modify, copy, publish, distribute, disclose or transmit this software or
8 * the related documents without Intel's prior written permission.
9 *
10 * This software and the related documents are provided as is, with no express
11 * or implied warranties, other than those that are expressly stated in the
12 * License.
13 *******************************************************************************/
14
15 #include "iw/iw_image_op.h"
16 #include "iw_owni.h"
17
18 IW_DECL(IppStatus) llwiSet(const double *pValue, void *pDst, int dstStep,
19 IppiSize size, IppDataType dataType, int channels);
20 IW_DECL(IppStatus) llwiSetUniform(double value, void *pDst, int dstStep,
21 IppiSize size, IppDataType dataType, int channels);
22 IW_DECL(IppStatus) llwiSetMask(const double *pValue, void *pDst, int dstStep,
23 IppiSize size, IppDataType dataType, int channels, const Ipp8u *pMask, int maskStep);
24
25 /**/////////////////////////////////////////////////////////////////////////////
26 // iwiSet
27 ///////////////////////////////////////////////////////////////////////////// */
iwiSet_NoMask(const double * pValue,int valuesNum,IwiImage * pDstImage,const IwiTile * pTile)28 static IppStatus iwiSet_NoMask(const double *pValue, int valuesNum, IwiImage *pDstImage, const IwiTile *pTile)
29 {
30 {
31 void* pDst = pDstImage->m_ptr;
32 IwiSize size = pDstImage->m_size;
33
34 if(pTile && pTile->m_initialized != ownTileInitNone)
35 {
36 if(pTile->m_initialized == ownTileInitSimple)
37 {
38 IwiRoi dstRoi = pTile->m_dstRoi;
39
40 if(!owniTile_BoundToSize(&dstRoi, &size))
41 return ippStsNoOperation;
42
43 pDst = iwiImage_GetPtr(pDstImage, dstRoi.y, dstRoi.x, 0);
44 }
45 else if(pTile->m_initialized == ownTileInitPipe)
46 {
47 IwiRoi dstLim; iwiTilePipeline_GetBoundedDstRoi(pTile, &dstLim);
48
49 pDst = iwiImage_GetPtr(pDstImage, dstLim.y, dstLim.x, 0);
50
51 size.width = dstLim.width;
52 size.height = dstLim.height;
53 }
54 else
55 return ippStsContextMatchErr;
56 }
57
58 // Long compatibility check
59 {
60 IppStatus status;
61 IppiSize _size;
62
63 status = ownLongCompatCheckValue(pDstImage->m_step, NULL);
64 if(status < 0)
65 return status;
66
67 status = owniLongCompatCheckSize(size, &_size);
68 if(status < 0)
69 return status;
70
71 if(valuesNum == 1)
72 return llwiSetUniform(*pValue, pDst, (int)pDstImage->m_step, _size, pDstImage->m_dataType, pDstImage->m_channels);
73 else
74 {
75 if(valuesNum < pDstImage->m_channels)
76 {
77 int i;
78 Ipp64f val[4];
79 for(i = 0; i < valuesNum; i++)
80 val[i] = pValue[i];
81 for(i = valuesNum; i < pDstImage->m_channels; i++)
82 val[i] = pValue[valuesNum-1];
83
84 return llwiSet(val, pDst, (int)pDstImage->m_step, _size, pDstImage->m_dataType, pDstImage->m_channels);
85 }
86
87 return llwiSet(pValue, pDst, (int)pDstImage->m_step, _size, pDstImage->m_dataType, pDstImage->m_channels);
88 }
89 }
90 }
91 }
92
iwiSet(const double * pValue,int valuesNum,IwiImage * pDstImage,const IwiImage * pMaskImage,const IwiSetParams * pAuxParams,const IwiTile * pTile)93 IW_DECL(IppStatus) iwiSet(const double *pValue, int valuesNum, IwiImage *pDstImage, const IwiImage *pMaskImage, const IwiSetParams *pAuxParams, const IwiTile *pTile)
94 {
95 IppStatus status;
96
97 (void)pAuxParams;
98
99 if(!pValue)
100 return ippStsNullPtrErr;
101 status = owniCheckImageWrite(pDstImage);
102 if(status)
103 return status;
104
105 if(!pMaskImage || !pMaskImage->m_ptrConst)
106 return iwiSet_NoMask(pValue, valuesNum, pDstImage, pTile);
107
108 status = owniCheckImageRead(pMaskImage);
109 if(status)
110 return status;
111
112 if(pDstImage->m_channels > 4)
113 return ippStsNumChannelsErr;
114
115 if(pMaskImage->m_dataType != ipp8u ||
116 pMaskImage->m_channels != 1)
117 return ippStsBadArgErr;
118
119 {
120 const void* pMask = pMaskImage->m_ptrConst;
121 void* pDst = pDstImage->m_ptr;
122 IwiSize size = owniGetMinSize(&pDstImage->m_size, &pMaskImage->m_size);
123
124 if(pTile && pTile->m_initialized != ownTileInitNone)
125 {
126 if(pTile->m_initialized == ownTileInitSimple)
127 {
128 IwiRoi dstRoi = pTile->m_dstRoi;
129
130 if(!owniTile_BoundToSize(&dstRoi, &size))
131 return ippStsNoOperation;
132
133 pDst = iwiImage_GetPtr(pDstImage, dstRoi.y, dstRoi.x, 0);
134 pMask = iwiImage_GetPtrConst(pMaskImage, dstRoi.y, dstRoi.x, 0);
135 }
136 else if(pTile->m_initialized == ownTileInitPipe)
137 {
138 IwiRoi dstLim; iwiTilePipeline_GetBoundedDstRoi(pTile, &dstLim);
139
140 pDst = iwiImage_GetPtr(pDstImage, dstLim.y, dstLim.x, 0);
141 pMask = iwiImage_GetPtrConst(pMaskImage, dstLim.y, dstLim.x, 0);
142
143 size.width = dstLim.width;
144 size.height = dstLim.height;
145 }
146 else
147 return ippStsContextMatchErr;
148 }
149
150 // Long compatibility check
151 {
152 IppiSize _size;
153
154 status = ownLongCompatCheckValue(pMaskImage->m_step, NULL);
155 if(status < 0)
156 return status;
157
158 status = ownLongCompatCheckValue(pDstImage->m_step, NULL);
159 if(status < 0)
160 return status;
161
162 status = owniLongCompatCheckSize(size, &_size);
163 if(status < 0)
164 return status;
165
166 if(valuesNum < pDstImage->m_channels)
167 {
168 int i;
169 Ipp64f val[4];
170 for(i = 0; i < valuesNum; i++)
171 val[i] = pValue[i];
172 for(i = valuesNum; i < pDstImage->m_channels; i++)
173 val[i] = pValue[valuesNum-1];
174
175 return llwiSetMask(val, pDst, (int)pDstImage->m_step, _size, pDstImage->m_dataType, pDstImage->m_channels, (const Ipp8u*)pMask, (int)pMaskImage->m_step);
176 }
177
178 return llwiSetMask(pValue, pDst, (int)pDstImage->m_step, _size, pDstImage->m_dataType, pDstImage->m_channels, (const Ipp8u*)pMask, (int)pMaskImage->m_step);
179 }
180 }
181 }
182
183 /**/////////////////////////////////////////////////////////////////////////////
184 // Low-Level Wrappers
185 ///////////////////////////////////////////////////////////////////////////// */
llwiSet(const double * pValue,void * pDst,int dstStep,IppiSize size,IppDataType dataType,int channels)186 IW_DECL(IppStatus) llwiSet(const double *pValue, void *pDst, int dstStep,
187 IppiSize size, IppDataType dataType, int channels)
188 {
189 Ipp64f value[4];
190
191 switch(dataType)
192 {
193 case ipp8u:
194 switch(channels)
195 {
196 case 1: return ippiSet_8u_C1R(ownCast_64f8u(*pValue), (Ipp8u*)pDst, dstStep, size);
197 case 3: return ippiSet_8u_C3R(ownCastArray_64f8u(pValue, value, 3), (Ipp8u*)pDst, dstStep, size);
198 case 4: return ippiSet_8u_C4R(ownCastArray_64f8u(pValue, value, 4), (Ipp8u*)pDst, dstStep, size);
199 default: return ippStsNumChannelsErr;
200 }
201 case ipp8s:
202 switch(channels)
203 {
204 case 1: return ippiSet_8u_C1R(ownCast_64f8s(*pValue), (Ipp8u*)pDst, dstStep, size);
205 case 3: return ippiSet_8u_C3R((Ipp8u*)ownCastArray_64f8s(pValue, value, 3), (Ipp8u*)pDst, dstStep, size);
206 case 4: return ippiSet_8u_C4R((Ipp8u*)ownCastArray_64f8s(pValue, value, 4), (Ipp8u*)pDst, dstStep, size);
207 default: return ippStsNumChannelsErr;
208 }
209 case ipp16u:
210 switch(channels)
211 {
212 case 1: return ippiSet_16u_C1R(ownCast_64f16u(*pValue), (Ipp16u*)pDst, dstStep, size);
213 case 3: return ippiSet_16u_C3R(ownCastArray_64f16u(pValue, value, 3), (Ipp16u*)pDst, dstStep, size);
214 case 4: return ippiSet_16u_C4R(ownCastArray_64f16u(pValue, value, 4), (Ipp16u*)pDst, dstStep, size);
215 default: return ippStsNumChannelsErr;
216 }
217 case ipp16s:
218 switch(channels)
219 {
220 case 1: return ippiSet_16u_C1R(ownCast_64f16s(*pValue), (Ipp16u*)pDst, dstStep, size);
221 case 3: return ippiSet_16u_C3R((Ipp16u*)ownCastArray_64f16s(pValue, value, 3), (Ipp16u*)pDst, dstStep, size);
222 case 4: return ippiSet_16u_C4R((Ipp16u*)ownCastArray_64f16s(pValue, value, 4), (Ipp16u*)pDst, dstStep, size);
223 default: return ippStsNumChannelsErr;
224 }
225 case ipp32u:
226 switch(channels)
227 {
228 case 1: return ippiSet_32s_C1R(ownCast_64f32u(*pValue), (Ipp32s*)pDst, dstStep, size);
229 case 3: return ippiSet_32s_C3R((Ipp32s*)ownCastArray_64f32u(pValue, value, 3), (Ipp32s*)pDst, dstStep, size);
230 case 4: return ippiSet_32s_C4R((Ipp32s*)ownCastArray_64f32u(pValue, value, 4), (Ipp32s*)pDst, dstStep, size);
231 default: return ippStsNumChannelsErr;
232 }
233 case ipp32s:
234 switch(channels)
235 {
236 case 1: return ippiSet_32s_C1R(ownCast_64f32s(*pValue), (Ipp32s*)pDst, dstStep, size);
237 case 3: return ippiSet_32s_C3R((Ipp32s*)ownCastArray_64f32s(pValue, value, 3), (Ipp32s*)pDst, dstStep, size);
238 case 4: return ippiSet_32s_C4R((Ipp32s*)ownCastArray_64f32s(pValue, value, 4), (Ipp32s*)pDst, dstStep, size);
239 default: return ippStsNumChannelsErr;
240 }
241 case ipp32f:
242 switch(channels)
243 {
244 case 1: return ippiSet_32f_C1R(ownCast_64f32f(*pValue), (Ipp32f*)pDst, dstStep, size);
245 case 3: return ippiSet_32f_C3R(ownCastArray_64f32f(pValue, value, 3), (Ipp32f*)pDst, dstStep, size);
246 case 4: return ippiSet_32f_C4R(ownCastArray_64f32f(pValue, value, 4), (Ipp32f*)pDst, dstStep, size);
247 default: return ippStsNumChannelsErr;
248 }
249 default: return ippStsDataTypeErr;
250 }
251 }
252
llwiSetUniform(double value,void * pDst,int dstStep,IppiSize size,IppDataType dataType,int channels)253 IW_DECL(IppStatus) llwiSetUniform(double value, void *pDst, int dstStep,
254 IppiSize size, IppDataType dataType, int channels)
255 {
256 size.width = size.width*channels;
257
258 switch(dataType)
259 {
260 case ipp8u: return ippiSet_8u_C1R(ownCast_64f8u(value), (Ipp8u*)pDst, dstStep, size);
261 case ipp8s: return ippiSet_8u_C1R(ownCast_64f8s(value), (Ipp8u*)pDst, dstStep, size);
262 case ipp16u: return ippiSet_16u_C1R(ownCast_64f16u(value), (Ipp16u*)pDst, dstStep, size);
263 case ipp16s: return ippiSet_16u_C1R(ownCast_64f16s(value), (Ipp16u*)pDst, dstStep, size);
264 case ipp32u: return ippiSet_32s_C1R(ownCast_64f32u(value), (Ipp32s*)pDst, dstStep, size);
265 case ipp32s: return ippiSet_32s_C1R(ownCast_64f32s(value), (Ipp32s*)pDst, dstStep, size);
266 case ipp32f: return ippiSet_32f_C1R(ownCast_64f32f(value), (Ipp32f*)pDst, dstStep, size);
267 default: return ippStsDataTypeErr;
268 }
269 }
270
llwiSetMask(const double * pValue,void * pDst,int dstStep,IppiSize size,IppDataType dataType,int channels,const Ipp8u * pMask,int maskStep)271 IW_DECL(IppStatus) llwiSetMask(const double *pValue, void *pDst, int dstStep,
272 IppiSize size, IppDataType dataType, int channels, const Ipp8u *pMask, int maskStep)
273 {
274 Ipp64f value[4];
275
276 switch(dataType)
277 {
278 case ipp8u:
279 switch(channels)
280 {
281 case 1: return ippiSet_8u_C1MR(ownCast_64f8u(*pValue), (Ipp8u*)pDst, dstStep, size, pMask, maskStep);
282 case 3: return ippiSet_8u_C3MR(ownCastArray_64f8u(pValue, value, 3), (Ipp8u*)pDst, dstStep, size, pMask, maskStep);
283 case 4: return ippiSet_8u_C4MR(ownCastArray_64f8u(pValue, value, 4), (Ipp8u*)pDst, dstStep, size, pMask, maskStep);
284 default: return ippStsNumChannelsErr;
285 }
286 case ipp8s:
287 switch(channels)
288 {
289 case 1: return ippiSet_8u_C1MR(ownCast_64f8s(*pValue), (Ipp8u*)pDst, dstStep, size, pMask, maskStep);
290 case 3: return ippiSet_8u_C3MR((Ipp8u*)ownCastArray_64f8s(pValue, value, 3), (Ipp8u*)pDst, dstStep, size, pMask, maskStep);
291 case 4: return ippiSet_8u_C4MR((Ipp8u*)ownCastArray_64f8s(pValue, value, 4), (Ipp8u*)pDst, dstStep, size, pMask, maskStep);
292 default: return ippStsNumChannelsErr;
293 }
294 case ipp16u:
295 switch(channels)
296 {
297 case 1: return ippiSet_16u_C1MR(ownCast_64f16u(*pValue), (Ipp16u*)pDst, dstStep, size, pMask, maskStep);
298 case 3: return ippiSet_16u_C3MR(ownCastArray_64f16u(pValue, value, 3), (Ipp16u*)pDst, dstStep, size, pMask, maskStep);
299 case 4: return ippiSet_16u_C4MR(ownCastArray_64f16u(pValue, value, 4), (Ipp16u*)pDst, dstStep, size, pMask, maskStep);
300 default: return ippStsNumChannelsErr;
301 }
302 case ipp16s:
303 switch(channels)
304 {
305 case 1: return ippiSet_16u_C1MR(ownCast_64f16s(*pValue), (Ipp16u*)pDst, dstStep, size, pMask, maskStep);
306 case 3: return ippiSet_16u_C3MR((Ipp16u*)ownCastArray_64f16s(pValue, value, 3), (Ipp16u*)pDst, dstStep, size, pMask, maskStep);
307 case 4: return ippiSet_16u_C4MR((Ipp16u*)ownCastArray_64f16s(pValue, value, 4), (Ipp16u*)pDst, dstStep, size, pMask, maskStep);
308 default: return ippStsNumChannelsErr;
309 }
310 case ipp32u:
311 switch(channels)
312 {
313 case 1: return ippiSet_32s_C1MR(ownCast_64f32u(*pValue), (Ipp32s*)pDst, dstStep, size, pMask, maskStep);
314 case 3: return ippiSet_32s_C3MR((Ipp32s*)ownCastArray_64f32u(pValue, value, 3), (Ipp32s*)pDst, dstStep, size, pMask, maskStep);
315 case 4: return ippiSet_32s_C4MR((Ipp32s*)ownCastArray_64f32u(pValue, value, 4), (Ipp32s*)pDst, dstStep, size, pMask, maskStep);
316 default: return ippStsNumChannelsErr;
317 }
318 case ipp32s:
319 switch(channels)
320 {
321 case 1: return ippiSet_32s_C1MR(ownCast_64f32s(*pValue), (Ipp32s*)pDst, dstStep, size, pMask, maskStep);
322 case 3: return ippiSet_32s_C3MR(ownCastArray_64f32s(pValue, value, 3), (Ipp32s*)pDst, dstStep, size, pMask, maskStep);
323 case 4: return ippiSet_32s_C4MR(ownCastArray_64f32s(pValue, value, 4), (Ipp32s*)pDst, dstStep, size, pMask, maskStep);
324 default: return ippStsNumChannelsErr;
325 }
326 case ipp32f:
327 switch(channels)
328 {
329 case 1: return ippiSet_32f_C1MR(ownCast_64f32f(*pValue), (Ipp32f*)pDst, dstStep, size, pMask, maskStep);
330 case 3: return ippiSet_32f_C3MR(ownCastArray_64f32f(pValue, value, 3), (Ipp32f*)pDst, dstStep, size, pMask, maskStep);
331 case 4: return ippiSet_32f_C4MR(ownCastArray_64f32f(pValue, value, 4), (Ipp32f*)pDst, dstStep, size, pMask, maskStep);
332 default: return ippStsNumChannelsErr;
333 }
334 default: return ippStsDataTypeErr;
335 }
336 }
337