|
1 /* |
|
2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 #include <stdio.h> |
|
19 #include <stdlib.h> |
|
20 #include "Colorconversion.h" |
|
21 |
|
22 /* |
|
23 ****************************************************************************** |
|
24 Name : Emz_VDec_gColorConv_YUVtoRGB |
|
25 Description : Converts YUV picture data to RGB data. |
|
26 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
27 uint8 *dstImage : Pointer to rgb data (o/p). |
|
28 tWndParam *srcWindow : Pointer to structure containing source window |
|
29 parameters like xOffset,yOffset,cropWidth, |
|
30 cropHeight. (i/p) |
|
31 tWndParam *dstWindow : Pointer to structure containing destination window |
|
32 parameters like xOffset,yOffset,windWidth, |
|
33 windHeight. (i/p) |
|
34 uint8 srcImageFmt : Specifies the color format of src data (i/p, o/p). |
|
35 uint8 dstImageFmt : Specifies the color format of dst data (i/p, o/p). |
|
36 uint8 colorConvScheme : Specifies the color conversion standard.(i/p) |
|
37 Return Value : int32 |
|
38 ****************************************************************************** |
|
39 */ |
|
40 int32 Emz_VDec_gColorConv_YUVtoRGB |
|
41 (tBaseVideoFrame *srcImage, uint8 *dstImage, tWndParam *srcWindow, |
|
42 tWndParam *dstWindow, uint8 srcImageFmt, uint8 dstImageFmt, |
|
43 uint8 colorConvScheme) |
|
44 { |
|
45 tWndParam lSrcWindow, lDstWindow; |
|
46 |
|
47 if( (NULL == srcImage) || (NULL == srcImage->lum) || |
|
48 (NULL == dstImage) || (srcWindow == NULL)|| (dstWindow == NULL) ) |
|
49 |
|
50 { |
|
51 return E_OUT_OF_MEMORY; |
|
52 } |
|
53 |
|
54 if( (EYuv422Chroma2_BE != srcImageFmt) && (EYuv422Chroma2_LE != srcImageFmt) |
|
55 && (EYuv422Chroma1_BE != srcImageFmt) && (EYuv422Chroma1_LE != srcImageFmt)) |
|
56 { |
|
57 if( (NULL == srcImage->cb) || (NULL == srcImage->cr) ) |
|
58 { |
|
59 return E_OUT_OF_MEMORY; |
|
60 } |
|
61 } |
|
62 |
|
63 lSrcWindow.xOffset = srcWindow->xOffset; |
|
64 lSrcWindow.yOffset = srcWindow->yOffset; |
|
65 lSrcWindow.wndWidth = srcWindow->wndWidth; |
|
66 lSrcWindow.wndHeight = srcWindow->wndHeight; |
|
67 |
|
68 lDstWindow.xOffset = dstWindow->xOffset; |
|
69 lDstWindow.yOffset = dstWindow->yOffset; |
|
70 lDstWindow.wndWidth = dstWindow->wndWidth; |
|
71 lDstWindow.wndHeight = dstWindow->wndHeight; |
|
72 |
|
73 lSrcWindow.xOffset = (uint16) ((lSrcWindow.xOffset >> 1) << 1); |
|
74 lSrcWindow.yOffset = (uint16) ((lSrcWindow.yOffset >> 1) << 1); |
|
75 lDstWindow.wndWidth = (lDstWindow.wndWidth >> 1) << 1; |
|
76 lDstWindow.wndHeight = (lDstWindow.wndHeight >> 1) << 1; |
|
77 |
|
78 switch (srcImageFmt) |
|
79 { |
|
80 |
|
81 case EYuv420Chroma1_Planar : |
|
82 |
|
83 switch (dstImageFmt) |
|
84 { |
|
85 |
|
86 case EBitmapColor4k_DitherOrdered : |
|
87 |
|
88 switch (colorConvScheme) |
|
89 { |
|
90 case EB709_FULLRANGE : |
|
91 sEmz_VDec_YUV420Chr1toColor4k_Ordered_709_FR |
|
92 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
93 break; |
|
94 |
|
95 case EITU601_5_FULLRANGE : |
|
96 sEmz_VDec_YUV420Chr1toColor4k_Ordered_601_5_FR |
|
97 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
98 break; |
|
99 |
|
100 case EB709_REDUCEDRANGE : |
|
101 sEmz_VDec_YUV420Chr1toColor4k_Ordered_709_RR |
|
102 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
103 break; |
|
104 |
|
105 case EITU601_5_REDUCEDRANGE : |
|
106 sEmz_VDec_YUV420Chr1toColor4k_Ordered_601_5_RR |
|
107 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
108 break; |
|
109 |
|
110 default : |
|
111 return E_FAILURE; |
|
112 } |
|
113 break; |
|
114 |
|
115 case EBitmapColor4k_DitherErrDiff : |
|
116 |
|
117 switch (colorConvScheme) |
|
118 { |
|
119 case EB709_FULLRANGE : |
|
120 sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_709_FR |
|
121 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
122 break; |
|
123 |
|
124 case EITU601_5_FULLRANGE : |
|
125 sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_601_5_FR |
|
126 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
127 break; |
|
128 |
|
129 case EB709_REDUCEDRANGE : |
|
130 sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_709_RR |
|
131 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
132 break; |
|
133 |
|
134 case EITU601_5_REDUCEDRANGE : |
|
135 sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_601_5_RR |
|
136 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
137 break; |
|
138 |
|
139 default : |
|
140 return E_FAILURE; |
|
141 } |
|
142 break; |
|
143 |
|
144 case EBitmapColor64k_DitherOrdered : |
|
145 |
|
146 switch (colorConvScheme) |
|
147 { |
|
148 case EB709_FULLRANGE : |
|
149 sEmz_VDec_YUV420Chr1toColor64k_Ordered_709_FR |
|
150 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
151 break; |
|
152 |
|
153 case EITU601_5_FULLRANGE : |
|
154 sEmz_VDec_YUV420Chr1toColor64k_Ordered_601_5_FR |
|
155 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
156 break; |
|
157 |
|
158 case EB709_REDUCEDRANGE : |
|
159 sEmz_VDec_YUV420Chr1toColor64k_Ordered_709_RR |
|
160 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
161 break; |
|
162 |
|
163 case EITU601_5_REDUCEDRANGE : |
|
164 sEmz_VDec_YUV420Chr1toColor64k_Ordered_601_5_RR |
|
165 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
166 break; |
|
167 |
|
168 default : |
|
169 return E_FAILURE; |
|
170 } |
|
171 break; |
|
172 |
|
173 case EBitmapColor64k_DitherErrDiff : |
|
174 |
|
175 switch (colorConvScheme) |
|
176 { |
|
177 case EB709_FULLRANGE : |
|
178 sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_709_FR |
|
179 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
180 break; |
|
181 |
|
182 case EITU601_5_FULLRANGE : |
|
183 sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_601_5_FR |
|
184 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
185 break; |
|
186 |
|
187 case EB709_REDUCEDRANGE : |
|
188 sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_709_RR |
|
189 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
190 break; |
|
191 |
|
192 case EITU601_5_REDUCEDRANGE : |
|
193 sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_601_5_RR |
|
194 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
195 break; |
|
196 |
|
197 default : |
|
198 return E_FAILURE; |
|
199 } |
|
200 break; |
|
201 |
|
202 case EBitmapColor16M : |
|
203 |
|
204 switch (colorConvScheme) |
|
205 { |
|
206 case EB709_FULLRANGE : |
|
207 sEmz_VDec_YUV420Chr1toColor16M_709_FR |
|
208 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
209 break; |
|
210 |
|
211 case EITU601_5_FULLRANGE : |
|
212 sEmz_VDec_YUV420Chr1toColor16M_601_5_FR |
|
213 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
214 break; |
|
215 |
|
216 case EB709_REDUCEDRANGE : |
|
217 sEmz_VDec_YUV420Chr1toColor16M_709_RR |
|
218 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
219 break; |
|
220 |
|
221 case EITU601_5_REDUCEDRANGE : |
|
222 sEmz_VDec_YUV420Chr1toColor16M_601_5_RR |
|
223 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
224 break; |
|
225 |
|
226 default : |
|
227 return E_FAILURE; |
|
228 } |
|
229 break; |
|
230 |
|
231 case EBitmapColor16MU : |
|
232 |
|
233 switch (colorConvScheme) |
|
234 { |
|
235 case EB709_FULLRANGE : |
|
236 sEmz_VDec_YUV420Chr1toColor16MU_709_FR |
|
237 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
238 break; |
|
239 |
|
240 case EITU601_5_FULLRANGE : |
|
241 sEmz_VDec_YUV420Chr1toColor16MU_601_5_FR |
|
242 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
243 break; |
|
244 |
|
245 case EB709_REDUCEDRANGE : |
|
246 sEmz_VDec_YUV420Chr1toColor16MU_709_RR |
|
247 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
248 break; |
|
249 |
|
250 case EITU601_5_REDUCEDRANGE : |
|
251 sEmz_VDec_YUV420Chr1toColor16MU_601_5_RR |
|
252 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
253 break; |
|
254 |
|
255 default : |
|
256 return E_FAILURE; |
|
257 } |
|
258 break; |
|
259 |
|
260 default : |
|
261 return E_FAILURE; |
|
262 } |
|
263 |
|
264 break; |
|
265 |
|
266 case EYuv420Chroma2_Planar : |
|
267 |
|
268 switch (dstImageFmt) |
|
269 { |
|
270 case EBitmapColor4k_DitherOrdered : |
|
271 |
|
272 switch (colorConvScheme) |
|
273 { |
|
274 case EB709_FULLRANGE : |
|
275 sEmz_VDec_YUV420Chr2toColor4k_Ordered_709_FR |
|
276 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
277 break; |
|
278 |
|
279 case EITU601_5_FULLRANGE : |
|
280 sEmz_VDec_YUV420Chr2toColor4k_Ordered_601_5_FR |
|
281 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
282 break; |
|
283 |
|
284 case EB709_REDUCEDRANGE : |
|
285 sEmz_VDec_YUV420Chr2toColor4k_Ordered_709_RR |
|
286 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
287 break; |
|
288 |
|
289 case EITU601_5_REDUCEDRANGE : |
|
290 sEmz_VDec_YUV420Chr2toColor4k_Ordered_601_5_RR |
|
291 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
292 break; |
|
293 |
|
294 default : |
|
295 return E_FAILURE; |
|
296 } |
|
297 break; |
|
298 |
|
299 case EBitmapColor4k_DitherErrDiff : |
|
300 |
|
301 switch (colorConvScheme) |
|
302 { |
|
303 case EB709_FULLRANGE : |
|
304 sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_709_FR |
|
305 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
306 break; |
|
307 |
|
308 case EITU601_5_FULLRANGE : |
|
309 sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_601_5_FR |
|
310 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
311 break; |
|
312 |
|
313 case EB709_REDUCEDRANGE : |
|
314 sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_709_RR |
|
315 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
316 break; |
|
317 |
|
318 case EITU601_5_REDUCEDRANGE : |
|
319 sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_601_5_RR |
|
320 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
321 break; |
|
322 |
|
323 default : |
|
324 return E_FAILURE; |
|
325 } |
|
326 break; |
|
327 |
|
328 case EBitmapColor64k_DitherOrdered : |
|
329 |
|
330 switch (colorConvScheme) |
|
331 { |
|
332 case EB709_FULLRANGE : |
|
333 sEmz_VDec_YUV420Chr2toColor64k_Ordered_709_FR |
|
334 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
335 break; |
|
336 |
|
337 case EITU601_5_FULLRANGE : |
|
338 sEmz_VDec_YUV420Chr2toColor64k_Ordered_601_5_FR |
|
339 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
340 break; |
|
341 |
|
342 case EB709_REDUCEDRANGE : |
|
343 sEmz_VDec_YUV420Chr2toColor64k_Ordered_709_RR |
|
344 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
345 break; |
|
346 |
|
347 case EITU601_5_REDUCEDRANGE : |
|
348 sEmz_VDec_YUV420Chr2toColor64k_Ordered_601_5_RR |
|
349 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
350 break; |
|
351 |
|
352 default : |
|
353 return E_FAILURE; |
|
354 } |
|
355 break; |
|
356 |
|
357 case EBitmapColor64k_DitherErrDiff : |
|
358 |
|
359 switch (colorConvScheme) |
|
360 { |
|
361 case EB709_FULLRANGE : |
|
362 sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_709_FR |
|
363 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
364 break; |
|
365 |
|
366 case EITU601_5_FULLRANGE : |
|
367 sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_601_5_FR |
|
368 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
369 break; |
|
370 |
|
371 case EB709_REDUCEDRANGE : |
|
372 sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_709_RR |
|
373 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
374 break; |
|
375 |
|
376 case EITU601_5_REDUCEDRANGE : |
|
377 sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_601_5_RR |
|
378 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
379 break; |
|
380 |
|
381 default : |
|
382 return E_FAILURE; |
|
383 } |
|
384 break; |
|
385 |
|
386 case EBitmapColor16M : |
|
387 |
|
388 switch (colorConvScheme) |
|
389 { |
|
390 case EB709_FULLRANGE : |
|
391 sEmz_VDec_YUV420Chr2toColor16M_709_FR |
|
392 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
393 break; |
|
394 |
|
395 case EITU601_5_FULLRANGE : |
|
396 sEmz_VDec_YUV420Chr2toColor16M_601_5_FR |
|
397 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
398 break; |
|
399 |
|
400 case EB709_REDUCEDRANGE : |
|
401 sEmz_VDec_YUV420Chr2toColor16M_709_RR |
|
402 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
403 break; |
|
404 |
|
405 case EITU601_5_REDUCEDRANGE : |
|
406 sEmz_VDec_YUV420Chr2toColor16M_601_5_RR |
|
407 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
408 break; |
|
409 |
|
410 default : |
|
411 return E_FAILURE; |
|
412 } |
|
413 break; |
|
414 |
|
415 case EBitmapColor16MU : |
|
416 |
|
417 switch (colorConvScheme) |
|
418 { |
|
419 case EB709_FULLRANGE : |
|
420 sEmz_VDec_YUV420Chr2toColor16MU_709_FR |
|
421 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
422 break; |
|
423 |
|
424 case EITU601_5_FULLRANGE : |
|
425 sEmz_VDec_YUV420Chr2toColor16MU_601_5_FR |
|
426 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
427 break; |
|
428 |
|
429 case EB709_REDUCEDRANGE : |
|
430 sEmz_VDec_YUV420Chr2toColor16MU_709_RR |
|
431 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
432 break; |
|
433 |
|
434 case EITU601_5_REDUCEDRANGE : |
|
435 sEmz_VDec_YUV420Chr2toColor16MU_601_5_RR |
|
436 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
437 break; |
|
438 |
|
439 default : |
|
440 return E_FAILURE; |
|
441 } |
|
442 break; |
|
443 |
|
444 default : |
|
445 return E_FAILURE; |
|
446 } |
|
447 |
|
448 break; |
|
449 |
|
450 case EYuv420Chroma3_Planar : |
|
451 |
|
452 switch (dstImageFmt) |
|
453 { |
|
454 case EBitmapColor4k_DitherOrdered : |
|
455 |
|
456 switch (colorConvScheme) |
|
457 { |
|
458 case EB709_FULLRANGE : |
|
459 sEmz_VDec_YUV420Chr3toColor4k_Ordered_709_FR |
|
460 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
461 break; |
|
462 |
|
463 case EITU601_5_FULLRANGE : |
|
464 sEmz_VDec_YUV420Chr3toColor4k_Ordered_601_5_FR |
|
465 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
466 break; |
|
467 |
|
468 case EB709_REDUCEDRANGE : |
|
469 sEmz_VDec_YUV420Chr3toColor4k_Ordered_709_RR |
|
470 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
471 break; |
|
472 |
|
473 case EITU601_5_REDUCEDRANGE : |
|
474 sEmz_VDec_YUV420Chr3toColor4k_Ordered_601_5_RR |
|
475 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
476 break; |
|
477 |
|
478 default : |
|
479 return E_FAILURE; |
|
480 } |
|
481 break; |
|
482 |
|
483 case EBitmapColor4k_DitherErrDiff : |
|
484 |
|
485 switch (colorConvScheme) |
|
486 { |
|
487 case EB709_FULLRANGE : |
|
488 sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_709_FR |
|
489 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
490 break; |
|
491 |
|
492 case EITU601_5_FULLRANGE : |
|
493 sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_601_5_FR |
|
494 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
495 break; |
|
496 |
|
497 case EB709_REDUCEDRANGE : |
|
498 sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_709_RR |
|
499 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
500 break; |
|
501 |
|
502 case EITU601_5_REDUCEDRANGE : |
|
503 sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_601_5_RR |
|
504 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
505 break; |
|
506 |
|
507 default : |
|
508 return E_FAILURE; |
|
509 } |
|
510 break; |
|
511 |
|
512 case EBitmapColor64k_DitherOrdered : |
|
513 |
|
514 switch (colorConvScheme) |
|
515 { |
|
516 case EB709_FULLRANGE : |
|
517 sEmz_VDec_YUV420Chr3toColor64k_Ordered_709_FR |
|
518 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
519 break; |
|
520 |
|
521 case EITU601_5_FULLRANGE : |
|
522 sEmz_VDec_YUV420Chr3toColor64k_Ordered_601_5_FR |
|
523 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
524 break; |
|
525 |
|
526 case EB709_REDUCEDRANGE : |
|
527 sEmz_VDec_YUV420Chr3toColor64k_Ordered_709_RR |
|
528 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
529 break; |
|
530 |
|
531 case EITU601_5_REDUCEDRANGE : |
|
532 sEmz_VDec_YUV420Chr3toColor64k_Ordered_601_5_RR |
|
533 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
534 break; |
|
535 |
|
536 default : |
|
537 return E_FAILURE; |
|
538 } |
|
539 break; |
|
540 |
|
541 case EBitmapColor64k_DitherErrDiff : |
|
542 |
|
543 switch (colorConvScheme) |
|
544 { |
|
545 case EB709_FULLRANGE : |
|
546 sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_709_FR |
|
547 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
548 break; |
|
549 |
|
550 case EITU601_5_FULLRANGE : |
|
551 sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_601_5_FR |
|
552 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
553 break; |
|
554 |
|
555 case EB709_REDUCEDRANGE : |
|
556 sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_709_RR |
|
557 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
558 break; |
|
559 |
|
560 case EITU601_5_REDUCEDRANGE : |
|
561 sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_601_5_RR |
|
562 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
563 break; |
|
564 |
|
565 default : |
|
566 return E_FAILURE; |
|
567 } |
|
568 break; |
|
569 |
|
570 case EBitmapColor16M : |
|
571 |
|
572 switch (colorConvScheme) |
|
573 { |
|
574 case EB709_FULLRANGE : |
|
575 sEmz_VDec_YUV420Chr3toColor16M_709_FR |
|
576 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
577 break; |
|
578 |
|
579 case EITU601_5_FULLRANGE : |
|
580 sEmz_VDec_YUV420Chr3toColor16M_601_5_FR |
|
581 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
582 break; |
|
583 |
|
584 case EB709_REDUCEDRANGE : |
|
585 sEmz_VDec_YUV420Chr3toColor16M_709_RR |
|
586 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
587 break; |
|
588 |
|
589 case EITU601_5_REDUCEDRANGE : |
|
590 sEmz_VDec_YUV420Chr3toColor16M_601_5_RR |
|
591 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
592 break; |
|
593 |
|
594 default : |
|
595 return E_FAILURE; |
|
596 } |
|
597 break; |
|
598 |
|
599 case EBitmapColor16MU : |
|
600 |
|
601 switch (colorConvScheme) |
|
602 { |
|
603 case EB709_FULLRANGE : |
|
604 sEmz_VDec_YUV420Chr3toColor16MU_709_FR |
|
605 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
606 break; |
|
607 |
|
608 case EITU601_5_FULLRANGE : |
|
609 sEmz_VDec_YUV420Chr3toColor16MU_601_5_FR |
|
610 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
611 break; |
|
612 |
|
613 case EB709_REDUCEDRANGE : |
|
614 sEmz_VDec_YUV420Chr3toColor16MU_709_RR |
|
615 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
616 break; |
|
617 |
|
618 case EITU601_5_REDUCEDRANGE : |
|
619 sEmz_VDec_YUV420Chr3toColor16MU_601_5_RR |
|
620 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
621 break; |
|
622 |
|
623 default : |
|
624 return E_FAILURE; |
|
625 } |
|
626 break; |
|
627 |
|
628 default : |
|
629 return E_FAILURE; |
|
630 } |
|
631 |
|
632 break; |
|
633 |
|
634 case EYuv422Chroma1_BE : |
|
635 |
|
636 switch (dstImageFmt) |
|
637 { |
|
638 case EBitmapColor4k_DitherOrdered : |
|
639 |
|
640 switch (colorConvScheme) |
|
641 { |
|
642 case EB709_FULLRANGE : |
|
643 sEmz_VDec_YUV422BEChr1toColor4k_Ordered_709_FR |
|
644 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
645 break; |
|
646 |
|
647 case EITU601_5_FULLRANGE : |
|
648 sEmz_VDec_YUV422BEChr1toColor4k_Ordered_601_5_FR |
|
649 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
650 break; |
|
651 |
|
652 case EB709_REDUCEDRANGE : |
|
653 sEmz_VDec_YUV422BEChr1toColor4k_Ordered_709_RR |
|
654 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
655 break; |
|
656 |
|
657 case EITU601_5_REDUCEDRANGE : |
|
658 sEmz_VDec_YUV422BEChr1toColor4k_Ordered_601_5_RR |
|
659 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
660 break; |
|
661 |
|
662 default : |
|
663 return E_FAILURE; |
|
664 } |
|
665 break; |
|
666 |
|
667 case EBitmapColor4k_DitherErrDiff : |
|
668 |
|
669 switch (colorConvScheme) |
|
670 { |
|
671 case EB709_FULLRANGE : |
|
672 sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_709_FR |
|
673 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
674 break; |
|
675 |
|
676 case EITU601_5_FULLRANGE : |
|
677 sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_601_5_FR |
|
678 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
679 break; |
|
680 |
|
681 case EB709_REDUCEDRANGE : |
|
682 sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_709_RR |
|
683 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
684 break; |
|
685 |
|
686 case EITU601_5_REDUCEDRANGE : |
|
687 sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_601_5_RR |
|
688 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
689 break; |
|
690 |
|
691 default : |
|
692 return E_FAILURE; |
|
693 } |
|
694 break; |
|
695 |
|
696 case EBitmapColor64k_DitherOrdered : |
|
697 |
|
698 switch (colorConvScheme) |
|
699 { |
|
700 case EB709_FULLRANGE : |
|
701 sEmz_VDec_YUV422BEChr1toColor64k_Ordered_709_FR |
|
702 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
703 break; |
|
704 |
|
705 case EITU601_5_FULLRANGE : |
|
706 sEmz_VDec_YUV422BEChr1toColor64k_Ordered_601_5_FR |
|
707 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
708 break; |
|
709 |
|
710 case EB709_REDUCEDRANGE : |
|
711 sEmz_VDec_YUV422BEChr1toColor64k_Ordered_709_RR |
|
712 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
713 break; |
|
714 |
|
715 case EITU601_5_REDUCEDRANGE : |
|
716 sEmz_VDec_YUV422BEChr1toColor64k_Ordered_601_5_RR |
|
717 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
718 break; |
|
719 |
|
720 default : |
|
721 return E_FAILURE; |
|
722 } |
|
723 break; |
|
724 |
|
725 case EBitmapColor64k_DitherErrDiff : |
|
726 |
|
727 switch (colorConvScheme) |
|
728 { |
|
729 case EB709_FULLRANGE : |
|
730 sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_709_FR |
|
731 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
732 break; |
|
733 |
|
734 case EITU601_5_FULLRANGE : |
|
735 sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_601_5_FR |
|
736 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
737 break; |
|
738 |
|
739 case EB709_REDUCEDRANGE : |
|
740 sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_709_RR |
|
741 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
742 break; |
|
743 |
|
744 case EITU601_5_REDUCEDRANGE : |
|
745 sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_601_5_RR |
|
746 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
747 break; |
|
748 |
|
749 default : |
|
750 return E_FAILURE; |
|
751 } |
|
752 break; |
|
753 |
|
754 case EBitmapColor16M : |
|
755 |
|
756 switch (colorConvScheme) |
|
757 { |
|
758 case EB709_FULLRANGE : |
|
759 sEmz_VDec_YUV422BEChr1toColor16M_709_FR |
|
760 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
761 break; |
|
762 |
|
763 case EITU601_5_FULLRANGE : |
|
764 sEmz_VDec_YUV422BEChr1toColor16M_601_5_FR |
|
765 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
766 break; |
|
767 |
|
768 case EB709_REDUCEDRANGE : |
|
769 sEmz_VDec_YUV422BEChr1toColor16M_709_RR |
|
770 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
771 break; |
|
772 |
|
773 case EITU601_5_REDUCEDRANGE : |
|
774 sEmz_VDec_YUV422BEChr1toColor16M_601_5_RR |
|
775 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
776 break; |
|
777 |
|
778 default : |
|
779 return E_FAILURE; |
|
780 } |
|
781 break; |
|
782 |
|
783 case EBitmapColor16MU : |
|
784 |
|
785 switch (colorConvScheme) |
|
786 { |
|
787 case EB709_FULLRANGE : |
|
788 sEmz_VDec_YUV422BEChr1toColor16MU_709_FR |
|
789 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
790 break; |
|
791 |
|
792 case EITU601_5_FULLRANGE : |
|
793 sEmz_VDec_YUV422BEChr1toColor16MU_601_5_FR |
|
794 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
795 break; |
|
796 |
|
797 case EB709_REDUCEDRANGE : |
|
798 sEmz_VDec_YUV422BEChr1toColor16MU_709_RR |
|
799 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
800 break; |
|
801 |
|
802 case EITU601_5_REDUCEDRANGE : |
|
803 sEmz_VDec_YUV422BEChr1toColor16MU_601_5_RR |
|
804 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
805 break; |
|
806 |
|
807 default : |
|
808 return E_FAILURE; |
|
809 } |
|
810 break; |
|
811 |
|
812 default : |
|
813 return E_FAILURE; |
|
814 } |
|
815 |
|
816 break; |
|
817 |
|
818 case EYuv422Chroma2_BE : |
|
819 |
|
820 switch (dstImageFmt) |
|
821 { |
|
822 case EBitmapColor4k_DitherOrdered : |
|
823 |
|
824 switch (colorConvScheme) |
|
825 { |
|
826 case EB709_FULLRANGE : |
|
827 sEmz_VDec_YUV422BEChr2toColor4k_Ordered_709_FR |
|
828 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
829 break; |
|
830 |
|
831 case EITU601_5_FULLRANGE : |
|
832 sEmz_VDec_YUV422BEChr2toColor4k_Ordered_601_5_FR |
|
833 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
834 break; |
|
835 |
|
836 case EB709_REDUCEDRANGE : |
|
837 sEmz_VDec_YUV422BEChr2toColor4k_Ordered_709_RR |
|
838 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
839 break; |
|
840 |
|
841 case EITU601_5_REDUCEDRANGE : |
|
842 sEmz_VDec_YUV422BEChr2toColor4k_Ordered_601_5_RR |
|
843 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
844 break; |
|
845 |
|
846 default : |
|
847 return E_FAILURE; |
|
848 } |
|
849 break; |
|
850 |
|
851 case EBitmapColor4k_DitherErrDiff : |
|
852 |
|
853 switch (colorConvScheme) |
|
854 { |
|
855 case EB709_FULLRANGE : |
|
856 sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_709_FR |
|
857 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
858 break; |
|
859 |
|
860 case EITU601_5_FULLRANGE : |
|
861 sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_601_5_FR |
|
862 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
863 break; |
|
864 |
|
865 case EB709_REDUCEDRANGE : |
|
866 sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_709_RR |
|
867 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
868 break; |
|
869 |
|
870 case EITU601_5_REDUCEDRANGE : |
|
871 sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_601_5_RR |
|
872 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
873 break; |
|
874 |
|
875 default : |
|
876 return E_FAILURE; |
|
877 } |
|
878 break; |
|
879 |
|
880 case EBitmapColor64k_DitherOrdered : |
|
881 |
|
882 switch (colorConvScheme) |
|
883 { |
|
884 case EB709_FULLRANGE : |
|
885 sEmz_VDec_YUV422BEChr2toColor64k_Ordered_709_FR |
|
886 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
887 break; |
|
888 |
|
889 case EITU601_5_FULLRANGE : |
|
890 sEmz_VDec_YUV422BEChr2toColor64k_Ordered_601_5_FR |
|
891 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
892 break; |
|
893 |
|
894 case EB709_REDUCEDRANGE : |
|
895 sEmz_VDec_YUV422BEChr2toColor64k_Ordered_709_RR |
|
896 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
897 break; |
|
898 |
|
899 case EITU601_5_REDUCEDRANGE : |
|
900 sEmz_VDec_YUV422BEChr2toColor64k_Ordered_601_5_RR |
|
901 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
902 break; |
|
903 |
|
904 default : |
|
905 return E_FAILURE; |
|
906 } |
|
907 break; |
|
908 |
|
909 case EBitmapColor64k_DitherErrDiff : |
|
910 |
|
911 switch (colorConvScheme) |
|
912 { |
|
913 case EB709_FULLRANGE : |
|
914 sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_709_FR |
|
915 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
916 break; |
|
917 |
|
918 case EITU601_5_FULLRANGE : |
|
919 sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_601_5_FR |
|
920 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
921 break; |
|
922 |
|
923 case EB709_REDUCEDRANGE : |
|
924 sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_709_RR |
|
925 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
926 break; |
|
927 |
|
928 case EITU601_5_REDUCEDRANGE : |
|
929 sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_601_5_RR |
|
930 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
931 break; |
|
932 |
|
933 default : |
|
934 return E_FAILURE; |
|
935 } |
|
936 break; |
|
937 |
|
938 case EBitmapColor16M : |
|
939 |
|
940 switch (colorConvScheme) |
|
941 { |
|
942 case EB709_FULLRANGE : |
|
943 sEmz_VDec_YUV422BEChr2toColor16M_709_FR |
|
944 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
945 break; |
|
946 |
|
947 case EITU601_5_FULLRANGE : |
|
948 sEmz_VDec_YUV422BEChr2toColor16M_601_5_FR |
|
949 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
950 break; |
|
951 |
|
952 case EB709_REDUCEDRANGE : |
|
953 sEmz_VDec_YUV422BEChr2toColor16M_709_RR |
|
954 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
955 break; |
|
956 |
|
957 case EITU601_5_REDUCEDRANGE : |
|
958 sEmz_VDec_YUV422BEChr2toColor16M_601_5_RR |
|
959 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
960 break; |
|
961 |
|
962 default : |
|
963 return E_FAILURE; |
|
964 } |
|
965 break; |
|
966 |
|
967 case EBitmapColor16MU : |
|
968 |
|
969 switch (colorConvScheme) |
|
970 { |
|
971 case EB709_FULLRANGE : |
|
972 sEmz_VDec_YUV422BEChr2toColor16MU_709_FR |
|
973 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
974 break; |
|
975 |
|
976 case EITU601_5_FULLRANGE : |
|
977 sEmz_VDec_YUV422BEChr2toColor16MU_601_5_FR |
|
978 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
979 break; |
|
980 |
|
981 case EB709_REDUCEDRANGE : |
|
982 sEmz_VDec_YUV422BEChr2toColor16MU_709_RR |
|
983 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
984 break; |
|
985 |
|
986 case EITU601_5_REDUCEDRANGE : |
|
987 sEmz_VDec_YUV422BEChr2toColor16MU_601_5_RR |
|
988 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
989 break; |
|
990 |
|
991 default : |
|
992 return E_FAILURE; |
|
993 } |
|
994 break; |
|
995 |
|
996 default : |
|
997 return E_FAILURE; |
|
998 } |
|
999 |
|
1000 break; |
|
1001 |
|
1002 case EYuv422Chroma1_LE : |
|
1003 |
|
1004 switch (dstImageFmt) |
|
1005 { |
|
1006 case EBitmapColor4k_DitherOrdered : |
|
1007 |
|
1008 switch (colorConvScheme) |
|
1009 { |
|
1010 case EB709_FULLRANGE : |
|
1011 sEmz_VDec_YUV422LEChr1toColor4k_Ordered_709_FR |
|
1012 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1013 break; |
|
1014 |
|
1015 case EITU601_5_FULLRANGE : |
|
1016 sEmz_VDec_YUV422LEChr1toColor4k_Ordered_601_5_FR |
|
1017 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1018 break; |
|
1019 |
|
1020 case EB709_REDUCEDRANGE : |
|
1021 sEmz_VDec_YUV422LEChr1toColor4k_Ordered_709_RR |
|
1022 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1023 break; |
|
1024 |
|
1025 case EITU601_5_REDUCEDRANGE : |
|
1026 sEmz_VDec_YUV422LEChr1toColor4k_Ordered_601_5_RR |
|
1027 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1028 break; |
|
1029 |
|
1030 default : |
|
1031 return E_FAILURE; |
|
1032 } |
|
1033 break; |
|
1034 |
|
1035 case EBitmapColor4k_DitherErrDiff : |
|
1036 |
|
1037 switch (colorConvScheme) |
|
1038 { |
|
1039 case EB709_FULLRANGE : |
|
1040 sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_709_FR |
|
1041 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1042 break; |
|
1043 |
|
1044 case EITU601_5_FULLRANGE : |
|
1045 sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_601_5_FR |
|
1046 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1047 break; |
|
1048 |
|
1049 case EB709_REDUCEDRANGE : |
|
1050 sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_709_RR |
|
1051 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1052 break; |
|
1053 |
|
1054 case EITU601_5_REDUCEDRANGE : |
|
1055 sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_601_5_RR |
|
1056 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1057 break; |
|
1058 |
|
1059 default : |
|
1060 return E_FAILURE; |
|
1061 } |
|
1062 break; |
|
1063 |
|
1064 case EBitmapColor64k_DitherOrdered : |
|
1065 |
|
1066 switch (colorConvScheme) |
|
1067 { |
|
1068 case EB709_FULLRANGE : |
|
1069 sEmz_VDec_YUV422LEChr1toColor64k_Ordered_709_FR |
|
1070 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1071 break; |
|
1072 |
|
1073 case EITU601_5_FULLRANGE : |
|
1074 sEmz_VDec_YUV422LEChr1toColor64k_Ordered_601_5_FR |
|
1075 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1076 break; |
|
1077 |
|
1078 case EB709_REDUCEDRANGE : |
|
1079 sEmz_VDec_YUV422LEChr1toColor64k_Ordered_709_RR |
|
1080 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1081 break; |
|
1082 |
|
1083 case EITU601_5_REDUCEDRANGE : |
|
1084 sEmz_VDec_YUV422LEChr1toColor64k_Ordered_601_5_RR |
|
1085 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1086 break; |
|
1087 |
|
1088 default : |
|
1089 return E_FAILURE; |
|
1090 } |
|
1091 break; |
|
1092 |
|
1093 case EBitmapColor64k_DitherErrDiff : |
|
1094 |
|
1095 switch (colorConvScheme) |
|
1096 { |
|
1097 case EB709_FULLRANGE : |
|
1098 sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_709_FR |
|
1099 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1100 break; |
|
1101 |
|
1102 case EITU601_5_FULLRANGE : |
|
1103 sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_601_5_FR |
|
1104 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1105 break; |
|
1106 |
|
1107 case EB709_REDUCEDRANGE : |
|
1108 sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_709_RR |
|
1109 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1110 break; |
|
1111 |
|
1112 case EITU601_5_REDUCEDRANGE : |
|
1113 sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_601_5_RR |
|
1114 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1115 break; |
|
1116 |
|
1117 default : |
|
1118 return E_FAILURE; |
|
1119 } |
|
1120 break; |
|
1121 |
|
1122 case EBitmapColor16M : |
|
1123 |
|
1124 switch (colorConvScheme) |
|
1125 { |
|
1126 case EB709_FULLRANGE : |
|
1127 sEmz_VDec_YUV422LEChr1toColor16M_709_FR |
|
1128 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1129 break; |
|
1130 |
|
1131 case EITU601_5_FULLRANGE : |
|
1132 sEmz_VDec_YUV422LEChr1toColor16M_601_5_FR |
|
1133 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1134 break; |
|
1135 |
|
1136 case EB709_REDUCEDRANGE : |
|
1137 sEmz_VDec_YUV422LEChr1toColor16M_709_RR |
|
1138 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1139 break; |
|
1140 |
|
1141 case EITU601_5_REDUCEDRANGE : |
|
1142 sEmz_VDec_YUV422LEChr1toColor16M_601_5_RR |
|
1143 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1144 break; |
|
1145 |
|
1146 default : |
|
1147 return E_FAILURE; |
|
1148 } |
|
1149 break; |
|
1150 |
|
1151 case EBitmapColor16MU : |
|
1152 |
|
1153 switch (colorConvScheme) |
|
1154 { |
|
1155 case EB709_FULLRANGE : |
|
1156 sEmz_VDec_YUV422LEChr1toColor16MU_709_FR |
|
1157 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1158 break; |
|
1159 |
|
1160 case EITU601_5_FULLRANGE : |
|
1161 sEmz_VDec_YUV422LEChr1toColor16MU_601_5_FR |
|
1162 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1163 break; |
|
1164 |
|
1165 case EB709_REDUCEDRANGE : |
|
1166 sEmz_VDec_YUV422LEChr1toColor16MU_709_RR |
|
1167 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1168 break; |
|
1169 |
|
1170 case EITU601_5_REDUCEDRANGE : |
|
1171 sEmz_VDec_YUV422LEChr1toColor16MU_601_5_RR |
|
1172 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1173 break; |
|
1174 |
|
1175 default : |
|
1176 return E_FAILURE; |
|
1177 } |
|
1178 break; |
|
1179 |
|
1180 default : |
|
1181 return E_FAILURE; |
|
1182 } |
|
1183 |
|
1184 break; |
|
1185 |
|
1186 case EYuv422Chroma2_LE : |
|
1187 |
|
1188 switch (dstImageFmt) |
|
1189 { |
|
1190 case EBitmapColor4k_DitherOrdered : |
|
1191 |
|
1192 switch (colorConvScheme) |
|
1193 { |
|
1194 case EB709_FULLRANGE : |
|
1195 sEmz_VDec_YUV422LEChr2toColor4k_Ordered_709_FR |
|
1196 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1197 break; |
|
1198 |
|
1199 case EITU601_5_FULLRANGE : |
|
1200 sEmz_VDec_YUV422LEChr2toColor4k_Ordered_601_5_FR |
|
1201 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1202 break; |
|
1203 |
|
1204 case EB709_REDUCEDRANGE : |
|
1205 sEmz_VDec_YUV422LEChr2toColor4k_Ordered_709_RR |
|
1206 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1207 break; |
|
1208 |
|
1209 case EITU601_5_REDUCEDRANGE : |
|
1210 sEmz_VDec_YUV422LEChr2toColor4k_Ordered_601_5_RR |
|
1211 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1212 break; |
|
1213 |
|
1214 default : |
|
1215 return E_FAILURE; |
|
1216 } |
|
1217 break; |
|
1218 |
|
1219 case EBitmapColor4k_DitherErrDiff : |
|
1220 |
|
1221 switch (colorConvScheme) |
|
1222 { |
|
1223 case EB709_FULLRANGE : |
|
1224 sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_709_FR |
|
1225 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1226 break; |
|
1227 |
|
1228 case EITU601_5_FULLRANGE : |
|
1229 sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_601_5_FR |
|
1230 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1231 break; |
|
1232 |
|
1233 case EB709_REDUCEDRANGE : |
|
1234 sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_709_RR |
|
1235 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1236 break; |
|
1237 |
|
1238 case EITU601_5_REDUCEDRANGE : |
|
1239 sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_601_5_RR |
|
1240 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1241 break; |
|
1242 |
|
1243 default : |
|
1244 return E_FAILURE; |
|
1245 } |
|
1246 break; |
|
1247 |
|
1248 case EBitmapColor64k_DitherOrdered : |
|
1249 |
|
1250 switch (colorConvScheme) |
|
1251 { |
|
1252 case EB709_FULLRANGE : |
|
1253 sEmz_VDec_YUV422LEChr2toColor64k_Ordered_709_FR |
|
1254 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1255 break; |
|
1256 |
|
1257 case EITU601_5_FULLRANGE : |
|
1258 sEmz_VDec_YUV422LEChr2toColor64k_Ordered_601_5_FR |
|
1259 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1260 break; |
|
1261 |
|
1262 case EB709_REDUCEDRANGE : |
|
1263 sEmz_VDec_YUV422LEChr2toColor64k_Ordered_709_RR |
|
1264 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1265 break; |
|
1266 |
|
1267 case EITU601_5_REDUCEDRANGE : |
|
1268 sEmz_VDec_YUV422LEChr2toColor64k_Ordered_601_5_RR |
|
1269 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1270 break; |
|
1271 |
|
1272 default : |
|
1273 return E_FAILURE; |
|
1274 } |
|
1275 break; |
|
1276 |
|
1277 case EBitmapColor64k_DitherErrDiff : |
|
1278 |
|
1279 switch (colorConvScheme) |
|
1280 { |
|
1281 case EB709_FULLRANGE : |
|
1282 sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_709_FR |
|
1283 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1284 break; |
|
1285 |
|
1286 case EITU601_5_FULLRANGE : |
|
1287 sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_601_5_FR |
|
1288 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1289 break; |
|
1290 |
|
1291 case EB709_REDUCEDRANGE : |
|
1292 sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_709_RR |
|
1293 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1294 break; |
|
1295 |
|
1296 case EITU601_5_REDUCEDRANGE : |
|
1297 sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_601_5_RR |
|
1298 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1299 break; |
|
1300 |
|
1301 default : |
|
1302 return E_FAILURE; |
|
1303 } |
|
1304 break; |
|
1305 |
|
1306 case EBitmapColor16M : |
|
1307 |
|
1308 switch (colorConvScheme) |
|
1309 { |
|
1310 case EB709_FULLRANGE : |
|
1311 sEmz_VDec_YUV422LEChr2toColor16M_709_FR |
|
1312 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1313 break; |
|
1314 |
|
1315 case EITU601_5_FULLRANGE : |
|
1316 sEmz_VDec_YUV422LEChr2toColor16M_601_5_FR |
|
1317 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1318 break; |
|
1319 |
|
1320 case EB709_REDUCEDRANGE : |
|
1321 sEmz_VDec_YUV422LEChr2toColor16M_709_RR |
|
1322 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1323 break; |
|
1324 |
|
1325 case EITU601_5_REDUCEDRANGE : |
|
1326 sEmz_VDec_YUV422LEChr2toColor16M_601_5_RR |
|
1327 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1328 break; |
|
1329 |
|
1330 default : |
|
1331 return E_FAILURE; |
|
1332 } |
|
1333 break; |
|
1334 |
|
1335 case EBitmapColor16MU : |
|
1336 |
|
1337 switch (colorConvScheme) |
|
1338 { |
|
1339 case EB709_FULLRANGE : |
|
1340 sEmz_VDec_YUV422LEChr2toColor16MU_709_FR |
|
1341 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1342 break; |
|
1343 |
|
1344 case EITU601_5_FULLRANGE : |
|
1345 sEmz_VDec_YUV422LEChr2toColor16MU_601_5_FR |
|
1346 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1347 break; |
|
1348 |
|
1349 case EB709_REDUCEDRANGE : |
|
1350 sEmz_VDec_YUV422LEChr2toColor16MU_709_RR |
|
1351 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1352 break; |
|
1353 |
|
1354 case EITU601_5_REDUCEDRANGE : |
|
1355 sEmz_VDec_YUV422LEChr2toColor16MU_601_5_RR |
|
1356 (srcImage, dstImage, &lSrcWindow, &lDstWindow); |
|
1357 break; |
|
1358 |
|
1359 default : |
|
1360 return E_FAILURE; |
|
1361 } |
|
1362 break; |
|
1363 |
|
1364 default : |
|
1365 return E_FAILURE; |
|
1366 } |
|
1367 |
|
1368 break; |
|
1369 |
|
1370 default : |
|
1371 return E_FAILURE; |
|
1372 } |
|
1373 |
|
1374 return E_SUCCESS; |
|
1375 } |
|
1376 |
|
1377 |
|
1378 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
1379 /**************** Start of Chroma2 format *******************/ |
|
1380 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
1381 |
|
1382 |
|
1383 |
|
1384 |
|
1385 /****** Functions for YUV420 input *******/ |
|
1386 /* |
|
1387 ****************************************************************************** |
|
1388 Name : sEmz_VDec_YUV420Chr2toColor64k_Ordered_709_FR |
|
1389 Description : Converts YUV420 Chroma2 Planar to RGB565 Interleaved format |
|
1390 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
1391 uint8 *dstImage : Pointer to rgb data (o/p). |
|
1392 tWndParam *srcWindow : Pointer to structure containing source window |
|
1393 parameters like xOffset,yOffset,cropWidth, |
|
1394 cropHeight. (i/p) |
|
1395 tWndParam *dstWindow : Pointer to structure containing destination window |
|
1396 parameters like xOffset,yOffset,windWidth, |
|
1397 windHeight. (i/p) |
|
1398 Return Value : void |
|
1399 ****************************************************************************** |
|
1400 */ |
|
1401 |
|
1402 void sEmz_VDec_YUV420Chr2toColor64k_Ordered_709_FR |
|
1403 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
1404 tWndParam* srcWindow, tWndParam* dstWindow) |
|
1405 { |
|
1406 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
1407 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
1408 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
1409 int32 lY1, lCr, lCb; |
|
1410 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
1411 int32 i, j, extraRow, extraCol; |
|
1412 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
1413 cropWidth,cropHeight,wndWidth,wndHeight; |
|
1414 |
|
1415 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
1416 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
1417 |
|
1418 | {0,3,2} {4,0,6} | |
|
1419 | {6,1,4} {2,2,0} | */ |
|
1420 |
|
1421 srcXOffset = srcWindow->xOffset; |
|
1422 srcYOffset = srcWindow->yOffset; |
|
1423 cropWidth = srcWindow->wndWidth; |
|
1424 cropHeight = srcWindow->wndHeight; |
|
1425 |
|
1426 dstXOffset = dstWindow->xOffset; |
|
1427 dstYOffset = dstWindow->yOffset; |
|
1428 wndWidth = dstWindow->wndWidth; |
|
1429 wndHeight = dstWindow->wndHeight; |
|
1430 |
|
1431 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
1432 { |
|
1433 lWidth = cropWidth; |
|
1434 } |
|
1435 else |
|
1436 { |
|
1437 lWidth = srcImage->width - srcXOffset; |
|
1438 } |
|
1439 |
|
1440 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
1441 { |
|
1442 lHeight = cropHeight; |
|
1443 } |
|
1444 else |
|
1445 { |
|
1446 lHeight = srcImage->height - srcYOffset; |
|
1447 } |
|
1448 |
|
1449 if (lWidth > (wndWidth - dstXOffset)) |
|
1450 { |
|
1451 lWidth = wndWidth - dstXOffset; |
|
1452 } |
|
1453 |
|
1454 if (lHeight > (wndHeight - dstYOffset)) |
|
1455 { |
|
1456 lHeight = wndHeight - dstYOffset; |
|
1457 } |
|
1458 |
|
1459 extraCol = lWidth & 0x01; |
|
1460 extraRow = lHeight & 0x01; |
|
1461 |
|
1462 lTempWidth = lWidth; |
|
1463 lWidth = (lWidth >> 1) << 1; |
|
1464 lHeight = (lHeight >> 1) << 1; |
|
1465 |
|
1466 lLumWidth = (srcImage->width >> 1) << 1; |
|
1467 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
1468 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
1469 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
1470 |
|
1471 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
1472 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
1473 |
|
1474 for(i = 0; i < lHeight; i += 2) |
|
1475 { |
|
1476 for(j = 0; j < lWidth; j += 2) |
|
1477 { |
|
1478 lCr = lCrPtr[j >> 1]; |
|
1479 lCb = lCbPtr[j >> 1]; |
|
1480 |
|
1481 lCr -= 128; |
|
1482 lCb -= 128; |
|
1483 |
|
1484 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
1485 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
1486 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
1487 |
|
1488 /*First Pixel*/ |
|
1489 lY1 = lLumPtr[j]; |
|
1490 |
|
1491 /*B component*/ |
|
1492 lTemp = lY1 + lTemp3; |
|
1493 if (lTemp < 0) |
|
1494 lTemp = 0; |
|
1495 if (lTemp > 255) |
|
1496 lTemp = 255; |
|
1497 lTemp4 = (lTemp >> 3); |
|
1498 |
|
1499 /*G component*/ |
|
1500 lTemp = lY1 - lTemp2 + 3; |
|
1501 if (lTemp < 0) |
|
1502 lTemp = 0; |
|
1503 if (lTemp > 255) |
|
1504 lTemp = 255; |
|
1505 lTemp4 |= (lTemp >> 2) << 5; |
|
1506 |
|
1507 /*R component*/ |
|
1508 lTemp = lY1 + lTemp1 + 2; |
|
1509 if (lTemp < 0) |
|
1510 lTemp = 0; |
|
1511 if (lTemp > 255) |
|
1512 lTemp = 255; |
|
1513 lTemp4 |= (lTemp >> 3) << 11; |
|
1514 |
|
1515 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
1516 |
|
1517 /*Second Pixel*/ |
|
1518 lY1 = lLumPtr[j + 1]; |
|
1519 |
|
1520 /*B component*/ |
|
1521 lTemp = lY1 + lTemp3 + 4; |
|
1522 if (lTemp < 0) |
|
1523 lTemp = 0; |
|
1524 if (lTemp > 255) |
|
1525 lTemp = 255; |
|
1526 lTemp4 = (lTemp >> 3); |
|
1527 |
|
1528 /*G component*/ |
|
1529 lTemp = lY1 - lTemp2; |
|
1530 if (lTemp < 0) |
|
1531 lTemp = 0; |
|
1532 if (lTemp > 255) |
|
1533 lTemp = 255; |
|
1534 lTemp4 |= (lTemp >> 2) << 5; |
|
1535 |
|
1536 /*R component*/ |
|
1537 lTemp = lY1 + lTemp1 + 6; |
|
1538 if (lTemp < 0) |
|
1539 lTemp = 0; |
|
1540 if (lTemp > 255) |
|
1541 lTemp = 255; |
|
1542 lTemp4 |= (lTemp >> 3) << 11; |
|
1543 |
|
1544 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
1545 |
|
1546 |
|
1547 /*Third Pixel*/ |
|
1548 lY1 = lLumPtr[j + lLumWidth]; |
|
1549 |
|
1550 /*B component*/ |
|
1551 lTemp = lY1 + lTemp3 + 6; |
|
1552 if (lTemp < 0) |
|
1553 lTemp = 0; |
|
1554 if (lTemp > 255) |
|
1555 lTemp = 255; |
|
1556 lTemp4 = (lTemp >> 3); |
|
1557 |
|
1558 /*G component*/ |
|
1559 lTemp = lY1 - lTemp2 + 1; |
|
1560 if (lTemp < 0) |
|
1561 lTemp = 0; |
|
1562 if (lTemp > 255) |
|
1563 lTemp = 255; |
|
1564 lTemp4 |= (lTemp >> 2) << 5; |
|
1565 |
|
1566 /*R component*/ |
|
1567 lTemp = lY1 + lTemp1 + 4; |
|
1568 if (lTemp < 0) |
|
1569 lTemp = 0; |
|
1570 if (lTemp > 255) |
|
1571 lTemp = 255; |
|
1572 lTemp4 |= (lTemp >> 3) << 11; |
|
1573 |
|
1574 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
1575 |
|
1576 /*Fourth Pixel*/ |
|
1577 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
1578 |
|
1579 /*B component*/ |
|
1580 lTemp = lY1 + lTemp3 + 2; |
|
1581 if (lTemp < 0) |
|
1582 lTemp = 0; |
|
1583 if (lTemp > 255) |
|
1584 lTemp = 255; |
|
1585 lTemp4 = (lTemp >> 3); |
|
1586 |
|
1587 /*G component*/ |
|
1588 lTemp = lY1 - lTemp2 + 2; |
|
1589 if (lTemp < 0) |
|
1590 lTemp = 0; |
|
1591 if (lTemp > 255) |
|
1592 lTemp = 255; |
|
1593 lTemp4 |= (lTemp >> 2) << 5; |
|
1594 |
|
1595 /*R component*/ |
|
1596 lTemp = lY1 + lTemp1; |
|
1597 if (lTemp < 0) |
|
1598 lTemp = 0; |
|
1599 if (lTemp > 255) |
|
1600 lTemp = 255; |
|
1601 lTemp4 |= (lTemp >> 3) << 11; |
|
1602 |
|
1603 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
1604 |
|
1605 lRGBFramePtr += 2; |
|
1606 lRGBFramePtr1 += 2; |
|
1607 } |
|
1608 if(extraCol) |
|
1609 { |
|
1610 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
1611 lRGBFramePtr++; |
|
1612 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
1613 lRGBFramePtr1++; |
|
1614 } |
|
1615 |
|
1616 lLumPtr += (lLumWidth << 1); |
|
1617 lCrPtr += (lLumWidth >> 1); |
|
1618 lCbPtr += (lLumWidth >> 1); |
|
1619 |
|
1620 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
1621 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
1622 } |
|
1623 |
|
1624 if(extraRow) |
|
1625 { |
|
1626 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
1627 for(j = 0; j < lWidth; j += 2) |
|
1628 { |
|
1629 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
1630 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
1631 } |
|
1632 if(extraCol) |
|
1633 { |
|
1634 *lRGBFramePtr = *lRGBFramePtr1; |
|
1635 } |
|
1636 } |
|
1637 return; |
|
1638 } |
|
1639 |
|
1640 /* |
|
1641 ****************************************************************************** |
|
1642 Name : sEmz_VDec_YUV420Chr2toColor64k_Ordered_601_5_FR |
|
1643 Description : Converts YUV420 Chroma2 Planar to RGB565 Interleaved format |
|
1644 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
1645 uint8 *dstImage : Pointer to rgb data (o/p). |
|
1646 tWndParam *srcWindow : Pointer to structure containing source window |
|
1647 parameters like xOffset,yOffset,cropWidth, |
|
1648 cropHeight. (i/p) |
|
1649 tWndParam *dstWindow : Pointer to structure containing destination window |
|
1650 parameters like xOffset,yOffset,windWidth, |
|
1651 windHeight. (i/p) |
|
1652 Return Value : void |
|
1653 ****************************************************************************** |
|
1654 */ |
|
1655 |
|
1656 void sEmz_VDec_YUV420Chr2toColor64k_Ordered_601_5_FR |
|
1657 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
1658 tWndParam* srcWindow, tWndParam* dstWindow) |
|
1659 { |
|
1660 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
1661 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
1662 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
1663 int32 lY1, lCr, lCb; |
|
1664 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
1665 int32 i, j, extraRow, extraCol; |
|
1666 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
1667 cropWidth,cropHeight,wndWidth,wndHeight; |
|
1668 |
|
1669 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
1670 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
1671 |
|
1672 | {0,3,2} {4,0,6} | |
|
1673 | {6,1,4} {2,2,0} | */ |
|
1674 |
|
1675 srcXOffset = srcWindow->xOffset; |
|
1676 srcYOffset = srcWindow->yOffset; |
|
1677 cropWidth = srcWindow->wndWidth; |
|
1678 cropHeight = srcWindow->wndHeight; |
|
1679 |
|
1680 dstXOffset = dstWindow->xOffset; |
|
1681 dstYOffset = dstWindow->yOffset; |
|
1682 wndWidth = dstWindow->wndWidth; |
|
1683 wndHeight = dstWindow->wndHeight; |
|
1684 |
|
1685 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
1686 { |
|
1687 lWidth = cropWidth; |
|
1688 } |
|
1689 else |
|
1690 { |
|
1691 lWidth = srcImage->width - srcXOffset; |
|
1692 } |
|
1693 |
|
1694 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
1695 { |
|
1696 lHeight = cropHeight; |
|
1697 } |
|
1698 else |
|
1699 { |
|
1700 lHeight = srcImage->height - srcYOffset; |
|
1701 } |
|
1702 |
|
1703 if (lWidth > (wndWidth - dstXOffset)) |
|
1704 { |
|
1705 lWidth = wndWidth - dstXOffset; |
|
1706 } |
|
1707 |
|
1708 if (lHeight > (wndHeight - dstYOffset)) |
|
1709 { |
|
1710 lHeight = wndHeight - dstYOffset; |
|
1711 } |
|
1712 |
|
1713 extraCol = lWidth & 0x01; |
|
1714 extraRow = lHeight & 0x01; |
|
1715 |
|
1716 lTempWidth = lWidth; |
|
1717 lWidth = (lWidth >> 1) << 1; |
|
1718 lHeight = (lHeight >> 1) << 1; |
|
1719 |
|
1720 lLumWidth = (srcImage->width >> 1) << 1; |
|
1721 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
1722 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
1723 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
1724 |
|
1725 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
1726 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
1727 |
|
1728 for(i = 0; i < lHeight; i += 2) |
|
1729 { |
|
1730 for(j = 0; j < lWidth; j += 2) |
|
1731 { |
|
1732 lCr = lCrPtr[j >> 1]; |
|
1733 lCb = lCbPtr[j >> 1]; |
|
1734 |
|
1735 lCr -= 128; |
|
1736 lCb -= 128; |
|
1737 |
|
1738 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
1739 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
1740 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
1741 |
|
1742 /*First Pixel*/ |
|
1743 lY1 = lLumPtr[j]; |
|
1744 |
|
1745 /*B component*/ |
|
1746 lTemp = lY1 + lTemp3; |
|
1747 if (lTemp < 0) |
|
1748 lTemp = 0; |
|
1749 if (lTemp > 255) |
|
1750 lTemp = 255; |
|
1751 lTemp4 = (lTemp >> 3); |
|
1752 |
|
1753 /*G component*/ |
|
1754 lTemp = lY1 - lTemp2 + 3; |
|
1755 if (lTemp < 0) |
|
1756 lTemp = 0; |
|
1757 if (lTemp > 255) |
|
1758 lTemp = 255; |
|
1759 lTemp4 |= (lTemp >> 2) << 5; |
|
1760 |
|
1761 /*R component*/ |
|
1762 lTemp = lY1 + lTemp1 + 2; |
|
1763 if (lTemp < 0) |
|
1764 lTemp = 0; |
|
1765 if (lTemp > 255) |
|
1766 lTemp = 255; |
|
1767 lTemp4 |= (lTemp >> 3) << 11; |
|
1768 |
|
1769 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
1770 |
|
1771 /*Second Pixel*/ |
|
1772 lY1 = lLumPtr[j + 1]; |
|
1773 |
|
1774 /*B component*/ |
|
1775 lTemp = lY1 + lTemp3 + 4; |
|
1776 if (lTemp < 0) |
|
1777 lTemp = 0; |
|
1778 if (lTemp > 255) |
|
1779 lTemp = 255; |
|
1780 lTemp4 = (lTemp >> 3); |
|
1781 |
|
1782 /*G component*/ |
|
1783 lTemp = lY1 - lTemp2; |
|
1784 if (lTemp < 0) |
|
1785 lTemp = 0; |
|
1786 if (lTemp > 255) |
|
1787 lTemp = 255; |
|
1788 lTemp4 |= (lTemp >> 2) << 5; |
|
1789 |
|
1790 /*R component*/ |
|
1791 lTemp = lY1 + lTemp1 + 6; |
|
1792 if (lTemp < 0) |
|
1793 lTemp = 0; |
|
1794 if (lTemp > 255) |
|
1795 lTemp = 255; |
|
1796 lTemp4 |= (lTemp >> 3) << 11; |
|
1797 |
|
1798 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
1799 |
|
1800 |
|
1801 /*Third Pixel*/ |
|
1802 lY1 = lLumPtr[j + lLumWidth]; |
|
1803 |
|
1804 /*B component*/ |
|
1805 lTemp = lY1 + lTemp3 + 6; |
|
1806 if (lTemp < 0) |
|
1807 lTemp = 0; |
|
1808 if (lTemp > 255) |
|
1809 lTemp = 255; |
|
1810 lTemp4 = (lTemp >> 3); |
|
1811 |
|
1812 /*G component*/ |
|
1813 lTemp = lY1 - lTemp2 + 1; |
|
1814 if (lTemp < 0) |
|
1815 lTemp = 0; |
|
1816 if (lTemp > 255) |
|
1817 lTemp = 255; |
|
1818 lTemp4 |= (lTemp >> 2) << 5; |
|
1819 |
|
1820 /*R component*/ |
|
1821 lTemp = lY1 + lTemp1 + 4; |
|
1822 if (lTemp < 0) |
|
1823 lTemp = 0; |
|
1824 if (lTemp > 255) |
|
1825 lTemp = 255; |
|
1826 lTemp4 |= (lTemp >> 3) << 11; |
|
1827 |
|
1828 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
1829 |
|
1830 /*Fourth Pixel*/ |
|
1831 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
1832 |
|
1833 /*B component*/ |
|
1834 lTemp = lY1 + lTemp3 + 2; |
|
1835 if (lTemp < 0) |
|
1836 lTemp = 0; |
|
1837 if (lTemp > 255) |
|
1838 lTemp = 255; |
|
1839 lTemp4 = (lTemp >> 3); |
|
1840 |
|
1841 /*G component*/ |
|
1842 lTemp = lY1 - lTemp2 + 2; |
|
1843 if (lTemp < 0) |
|
1844 lTemp = 0; |
|
1845 if (lTemp > 255) |
|
1846 lTemp = 255; |
|
1847 lTemp4 |= (lTemp >> 2) << 5; |
|
1848 |
|
1849 /*R component*/ |
|
1850 lTemp = lY1 + lTemp1; |
|
1851 if (lTemp < 0) |
|
1852 lTemp = 0; |
|
1853 if (lTemp > 255) |
|
1854 lTemp = 255; |
|
1855 lTemp4 |= (lTemp >> 3) << 11; |
|
1856 |
|
1857 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
1858 |
|
1859 lRGBFramePtr += 2; |
|
1860 lRGBFramePtr1 += 2; |
|
1861 } |
|
1862 if(extraCol) |
|
1863 { |
|
1864 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
1865 lRGBFramePtr++; |
|
1866 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
1867 lRGBFramePtr1++; |
|
1868 } |
|
1869 |
|
1870 lLumPtr += (lLumWidth << 1); |
|
1871 lCrPtr += (lLumWidth >> 1); |
|
1872 lCbPtr += (lLumWidth >> 1); |
|
1873 |
|
1874 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
1875 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
1876 } |
|
1877 |
|
1878 if(extraRow) |
|
1879 { |
|
1880 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
1881 for(j = 0; j < lWidth; j += 2) |
|
1882 { |
|
1883 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
1884 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
1885 } |
|
1886 if(extraCol) |
|
1887 { |
|
1888 *lRGBFramePtr = *lRGBFramePtr1; |
|
1889 } |
|
1890 } |
|
1891 return; |
|
1892 } |
|
1893 |
|
1894 /* |
|
1895 ****************************************************************************** |
|
1896 Name : sEmz_VDec_YUV420Chr2toColor64k_Ordered_709_RR |
|
1897 Description : Converts YUV420 Chroma2 Planar to RGB565 Interleaved format |
|
1898 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
1899 uint8 *dstImage : Pointer to rgb data (o/p). |
|
1900 tWndParam *srcWindow : Pointer to structure containing source window |
|
1901 parameters like xOffset,yOffset,cropWidth, |
|
1902 cropHeight. (i/p) |
|
1903 tWndParam *dstWindow : Pointer to structure containing destination window |
|
1904 parameters like xOffset,yOffset,windWidth, |
|
1905 windHeight. (i/p) |
|
1906 Return Value : void |
|
1907 ****************************************************************************** |
|
1908 */ |
|
1909 |
|
1910 void sEmz_VDec_YUV420Chr2toColor64k_Ordered_709_RR |
|
1911 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
1912 tWndParam* srcWindow, tWndParam* dstWindow) |
|
1913 { |
|
1914 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
1915 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
1916 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
1917 int32 lY1, lCr, lCb; |
|
1918 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
1919 int32 i, j, extraRow, extraCol; |
|
1920 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
1921 cropWidth,cropHeight,wndWidth,wndHeight; |
|
1922 |
|
1923 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
1924 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
1925 |
|
1926 | {0,3,2} {4,0,6} | |
|
1927 | {6,1,4} {2,2,0} | */ |
|
1928 |
|
1929 srcXOffset = srcWindow->xOffset; |
|
1930 srcYOffset = srcWindow->yOffset; |
|
1931 cropWidth = srcWindow->wndWidth; |
|
1932 cropHeight = srcWindow->wndHeight; |
|
1933 |
|
1934 dstXOffset = dstWindow->xOffset; |
|
1935 dstYOffset = dstWindow->yOffset; |
|
1936 wndWidth = dstWindow->wndWidth; |
|
1937 wndHeight = dstWindow->wndHeight; |
|
1938 |
|
1939 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
1940 { |
|
1941 lWidth = cropWidth; |
|
1942 } |
|
1943 else |
|
1944 { |
|
1945 lWidth = srcImage->width - srcXOffset; |
|
1946 } |
|
1947 |
|
1948 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
1949 { |
|
1950 lHeight = cropHeight; |
|
1951 } |
|
1952 else |
|
1953 { |
|
1954 lHeight = srcImage->height - srcYOffset; |
|
1955 } |
|
1956 |
|
1957 if (lWidth > (wndWidth - dstXOffset)) |
|
1958 { |
|
1959 lWidth = wndWidth - dstXOffset; |
|
1960 } |
|
1961 |
|
1962 if (lHeight > (wndHeight - dstYOffset)) |
|
1963 { |
|
1964 lHeight = wndHeight - dstYOffset; |
|
1965 } |
|
1966 |
|
1967 extraCol = lWidth & 0x01; |
|
1968 extraRow = lHeight & 0x01; |
|
1969 |
|
1970 lTempWidth = lWidth; |
|
1971 lWidth = (lWidth >> 1) << 1; |
|
1972 lHeight = (lHeight >> 1) << 1; |
|
1973 |
|
1974 lLumWidth = (srcImage->width >> 1) << 1; |
|
1975 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
1976 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
1977 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
1978 |
|
1979 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
1980 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
1981 |
|
1982 for(i = 0; i < lHeight; i += 2) |
|
1983 { |
|
1984 for(j = 0; j < lWidth; j += 2) |
|
1985 { |
|
1986 lCr = lCrPtr[j >> 1]; |
|
1987 lCb = lCbPtr[j >> 1]; |
|
1988 |
|
1989 lCr -= 128; |
|
1990 lCb -= 128; |
|
1991 |
|
1992 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
1993 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
1994 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
1995 |
|
1996 /*First Pixel*/ |
|
1997 lY1 = lLumPtr[j]; |
|
1998 lY1 -= 16; |
|
1999 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
2000 |
|
2001 /*B component*/ |
|
2002 lTemp = lY1 + lTemp3; |
|
2003 if (lTemp < 0) |
|
2004 lTemp = 0; |
|
2005 if (lTemp > 255) |
|
2006 lTemp = 255; |
|
2007 lTemp4 = (lTemp >> 3); |
|
2008 |
|
2009 /*G component*/ |
|
2010 lTemp = lY1 - lTemp2 + 3; |
|
2011 if (lTemp < 0) |
|
2012 lTemp = 0; |
|
2013 if (lTemp > 255) |
|
2014 lTemp = 255; |
|
2015 lTemp4 |= (lTemp >> 2) << 5; |
|
2016 |
|
2017 /*R component*/ |
|
2018 lTemp = lY1 + lTemp1 + 2; |
|
2019 if (lTemp < 0) |
|
2020 lTemp = 0; |
|
2021 if (lTemp > 255) |
|
2022 lTemp = 255; |
|
2023 lTemp4 |= (lTemp >> 3) << 11; |
|
2024 |
|
2025 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
2026 |
|
2027 /*Second Pixel*/ |
|
2028 lY1 = lLumPtr[j + 1]; |
|
2029 lY1 -= 16; |
|
2030 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
2031 |
|
2032 /*B component*/ |
|
2033 lTemp = lY1 + lTemp3 + 4; |
|
2034 if (lTemp < 0) |
|
2035 lTemp = 0; |
|
2036 if (lTemp > 255) |
|
2037 lTemp = 255; |
|
2038 lTemp4 = (lTemp >> 3); |
|
2039 |
|
2040 /*G component*/ |
|
2041 lTemp = lY1 - lTemp2; |
|
2042 if (lTemp < 0) |
|
2043 lTemp = 0; |
|
2044 if (lTemp > 255) |
|
2045 lTemp = 255; |
|
2046 lTemp4 |= (lTemp >> 2) << 5; |
|
2047 |
|
2048 /*R component*/ |
|
2049 lTemp = lY1 + lTemp1 + 6; |
|
2050 if (lTemp < 0) |
|
2051 lTemp = 0; |
|
2052 if (lTemp > 255) |
|
2053 lTemp = 255; |
|
2054 lTemp4 |= (lTemp >> 3) << 11; |
|
2055 |
|
2056 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
2057 |
|
2058 |
|
2059 /*Third Pixel*/ |
|
2060 lY1 = lLumPtr[j + lLumWidth]; |
|
2061 lY1 -= 16; |
|
2062 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
2063 |
|
2064 /*B component*/ |
|
2065 lTemp = lY1 + lTemp3 + 6; |
|
2066 if (lTemp < 0) |
|
2067 lTemp = 0; |
|
2068 if (lTemp > 255) |
|
2069 lTemp = 255; |
|
2070 lTemp4 = (lTemp >> 3); |
|
2071 |
|
2072 /*G component*/ |
|
2073 lTemp = lY1 - lTemp2 + 1; |
|
2074 if (lTemp < 0) |
|
2075 lTemp = 0; |
|
2076 if (lTemp > 255) |
|
2077 lTemp = 255; |
|
2078 lTemp4 |= (lTemp >> 2) << 5; |
|
2079 |
|
2080 /*R component*/ |
|
2081 lTemp = lY1 + lTemp1 + 4; |
|
2082 if (lTemp < 0) |
|
2083 lTemp = 0; |
|
2084 if (lTemp > 255) |
|
2085 lTemp = 255; |
|
2086 lTemp4 |= (lTemp >> 3) << 11; |
|
2087 |
|
2088 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
2089 |
|
2090 /*Fourth Pixel*/ |
|
2091 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
2092 lY1 -= 16; |
|
2093 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
2094 |
|
2095 /*B component*/ |
|
2096 lTemp = lY1 + lTemp3 + 2; |
|
2097 if (lTemp < 0) |
|
2098 lTemp = 0; |
|
2099 if (lTemp > 255) |
|
2100 lTemp = 255; |
|
2101 lTemp4 = (lTemp >> 3); |
|
2102 |
|
2103 /*G component*/ |
|
2104 lTemp = lY1 - lTemp2 + 2; |
|
2105 if (lTemp < 0) |
|
2106 lTemp = 0; |
|
2107 if (lTemp > 255) |
|
2108 lTemp = 255; |
|
2109 lTemp4 |= (lTemp >> 2) << 5; |
|
2110 |
|
2111 /*R component*/ |
|
2112 lTemp = lY1 + lTemp1; |
|
2113 if (lTemp < 0) |
|
2114 lTemp = 0; |
|
2115 if (lTemp > 255) |
|
2116 lTemp = 255; |
|
2117 lTemp4 |= (lTemp >> 3) << 11; |
|
2118 |
|
2119 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
2120 |
|
2121 lRGBFramePtr += 2; |
|
2122 lRGBFramePtr1 += 2; |
|
2123 } |
|
2124 if(extraCol) |
|
2125 { |
|
2126 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
2127 lRGBFramePtr++; |
|
2128 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
2129 lRGBFramePtr1++; |
|
2130 } |
|
2131 |
|
2132 lLumPtr += (lLumWidth << 1); |
|
2133 lCrPtr += (lLumWidth >> 1); |
|
2134 lCbPtr += (lLumWidth >> 1); |
|
2135 |
|
2136 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
2137 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
2138 } |
|
2139 |
|
2140 if(extraRow) |
|
2141 { |
|
2142 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
2143 for(j = 0; j < lWidth; j += 2) |
|
2144 { |
|
2145 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2146 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2147 } |
|
2148 if(extraCol) |
|
2149 { |
|
2150 *lRGBFramePtr = *lRGBFramePtr1; |
|
2151 } |
|
2152 } |
|
2153 return; |
|
2154 } |
|
2155 |
|
2156 /* |
|
2157 ****************************************************************************** |
|
2158 Name : sEmz_VDec_YUV420Chr2toColor64k_Ordered_601_5_RR |
|
2159 Description : Converts YUV420 Chroma2 Planar to RGB565 Interleaved format |
|
2160 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
2161 uint8 *dstImage : Pointer to rgb data (o/p). |
|
2162 tWndParam *srcWindow : Pointer to structure containing source window |
|
2163 parameters like xOffset,yOffset,cropWidth, |
|
2164 cropHeight. (i/p) |
|
2165 tWndParam *dstWindow : Pointer to structure containing destination window |
|
2166 parameters like xOffset,yOffset,windWidth, |
|
2167 windHeight. (i/p) |
|
2168 Return Value : void |
|
2169 ****************************************************************************** |
|
2170 */ |
|
2171 |
|
2172 void sEmz_VDec_YUV420Chr2toColor64k_Ordered_601_5_RR |
|
2173 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
2174 tWndParam* srcWindow, tWndParam* dstWindow) |
|
2175 { |
|
2176 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
2177 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
2178 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
2179 int32 lY1, lCr, lCb; |
|
2180 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
2181 int32 i, j, extraRow, extraCol; |
|
2182 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
2183 cropWidth,cropHeight,wndWidth,wndHeight; |
|
2184 |
|
2185 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
2186 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
2187 |
|
2188 | {0,3,2} {4,0,6} | |
|
2189 | {6,1,4} {2,2,0} | */ |
|
2190 |
|
2191 srcXOffset = srcWindow->xOffset; |
|
2192 srcYOffset = srcWindow->yOffset; |
|
2193 cropWidth = srcWindow->wndWidth; |
|
2194 cropHeight = srcWindow->wndHeight; |
|
2195 |
|
2196 dstXOffset = dstWindow->xOffset; |
|
2197 dstYOffset = dstWindow->yOffset; |
|
2198 wndWidth = dstWindow->wndWidth; |
|
2199 wndHeight = dstWindow->wndHeight; |
|
2200 |
|
2201 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
2202 { |
|
2203 lWidth = cropWidth; |
|
2204 } |
|
2205 else |
|
2206 { |
|
2207 lWidth = srcImage->width - srcXOffset; |
|
2208 } |
|
2209 |
|
2210 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
2211 { |
|
2212 lHeight = cropHeight; |
|
2213 } |
|
2214 else |
|
2215 { |
|
2216 lHeight = srcImage->height - srcYOffset; |
|
2217 } |
|
2218 |
|
2219 if (lWidth > (wndWidth - dstXOffset)) |
|
2220 { |
|
2221 lWidth = wndWidth - dstXOffset; |
|
2222 } |
|
2223 |
|
2224 if (lHeight > (wndHeight - dstYOffset)) |
|
2225 { |
|
2226 lHeight = wndHeight - dstYOffset; |
|
2227 } |
|
2228 |
|
2229 extraCol = lWidth & 0x01; |
|
2230 extraRow = lHeight & 0x01; |
|
2231 |
|
2232 lTempWidth = lWidth; |
|
2233 lWidth = (lWidth >> 1) << 1; |
|
2234 lHeight = (lHeight >> 1) << 1; |
|
2235 |
|
2236 lLumWidth = (srcImage->width >> 1) << 1; |
|
2237 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
2238 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
2239 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
2240 |
|
2241 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
2242 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
2243 |
|
2244 for(i = 0; i < lHeight; i += 2) |
|
2245 { |
|
2246 for(j = 0; j < lWidth; j += 2) |
|
2247 { |
|
2248 lCr = lCrPtr[j >> 1]; |
|
2249 lCb = lCbPtr[j >> 1]; |
|
2250 |
|
2251 lCr -= 128; |
|
2252 lCb -= 128; |
|
2253 |
|
2254 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
2255 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
2256 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
2257 |
|
2258 /*First Pixel*/ |
|
2259 lY1 = lLumPtr[j]; |
|
2260 lY1 -= 16; |
|
2261 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
2262 |
|
2263 /*B component*/ |
|
2264 lTemp = lY1 + lTemp3; |
|
2265 if (lTemp < 0) |
|
2266 lTemp = 0; |
|
2267 if (lTemp > 255) |
|
2268 lTemp = 255; |
|
2269 lTemp4 = (lTemp >> 3); |
|
2270 |
|
2271 /*G component*/ |
|
2272 lTemp = lY1 - lTemp2 + 3; |
|
2273 if (lTemp < 0) |
|
2274 lTemp = 0; |
|
2275 if (lTemp > 255) |
|
2276 lTemp = 255; |
|
2277 lTemp4 |= (lTemp >> 2) << 5; |
|
2278 |
|
2279 /*R component*/ |
|
2280 lTemp = lY1 + lTemp1 + 2; |
|
2281 if (lTemp < 0) |
|
2282 lTemp = 0; |
|
2283 if (lTemp > 255) |
|
2284 lTemp = 255; |
|
2285 lTemp4 |= (lTemp >> 3) << 11; |
|
2286 |
|
2287 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
2288 |
|
2289 /*Second Pixel*/ |
|
2290 lY1 = lLumPtr[j + 1]; |
|
2291 lY1 -= 16; |
|
2292 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
2293 |
|
2294 /*B component*/ |
|
2295 lTemp = lY1 + lTemp3 + 4; |
|
2296 if (lTemp < 0) |
|
2297 lTemp = 0; |
|
2298 if (lTemp > 255) |
|
2299 lTemp = 255; |
|
2300 lTemp4 = (lTemp >> 3); |
|
2301 |
|
2302 /*G component*/ |
|
2303 lTemp = lY1 - lTemp2; |
|
2304 if (lTemp < 0) |
|
2305 lTemp = 0; |
|
2306 if (lTemp > 255) |
|
2307 lTemp = 255; |
|
2308 lTemp4 |= (lTemp >> 2) << 5; |
|
2309 |
|
2310 /*R component*/ |
|
2311 lTemp = lY1 + lTemp1 + 6; |
|
2312 if (lTemp < 0) |
|
2313 lTemp = 0; |
|
2314 if (lTemp > 255) |
|
2315 lTemp = 255; |
|
2316 lTemp4 |= (lTemp >> 3) << 11; |
|
2317 |
|
2318 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
2319 |
|
2320 |
|
2321 /*Third Pixel*/ |
|
2322 lY1 = lLumPtr[j + lLumWidth]; |
|
2323 lY1 -= 16; |
|
2324 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
2325 |
|
2326 /*B component*/ |
|
2327 lTemp = lY1 + lTemp3 + 6; |
|
2328 if (lTemp < 0) |
|
2329 lTemp = 0; |
|
2330 if (lTemp > 255) |
|
2331 lTemp = 255; |
|
2332 lTemp4 = (lTemp >> 3); |
|
2333 |
|
2334 /*G component*/ |
|
2335 lTemp = lY1 - lTemp2 + 1; |
|
2336 if (lTemp < 0) |
|
2337 lTemp = 0; |
|
2338 if (lTemp > 255) |
|
2339 lTemp = 255; |
|
2340 lTemp4 |= (lTemp >> 2) << 5; |
|
2341 |
|
2342 /*R component*/ |
|
2343 lTemp = lY1 + lTemp1 + 4; |
|
2344 if (lTemp < 0) |
|
2345 lTemp = 0; |
|
2346 if (lTemp > 255) |
|
2347 lTemp = 255; |
|
2348 lTemp4 |= (lTemp >> 3) << 11; |
|
2349 |
|
2350 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
2351 |
|
2352 /*Fourth Pixel*/ |
|
2353 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
2354 lY1 -= 16; |
|
2355 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
2356 |
|
2357 /*B component*/ |
|
2358 lTemp = lY1 + lTemp3 + 2; |
|
2359 if (lTemp < 0) |
|
2360 lTemp = 0; |
|
2361 if (lTemp > 255) |
|
2362 lTemp = 255; |
|
2363 lTemp4 = (lTemp >> 3); |
|
2364 |
|
2365 /*G component*/ |
|
2366 lTemp = lY1 - lTemp2 + 2; |
|
2367 if (lTemp < 0) |
|
2368 lTemp = 0; |
|
2369 if (lTemp > 255) |
|
2370 lTemp = 255; |
|
2371 lTemp4 |= (lTemp >> 2) << 5; |
|
2372 |
|
2373 /*R component*/ |
|
2374 lTemp = lY1 + lTemp1; |
|
2375 if (lTemp < 0) |
|
2376 lTemp = 0; |
|
2377 if (lTemp > 255) |
|
2378 lTemp = 255; |
|
2379 lTemp4 |= (lTemp >> 3) << 11; |
|
2380 |
|
2381 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
2382 |
|
2383 lRGBFramePtr += 2; |
|
2384 lRGBFramePtr1 += 2; |
|
2385 } |
|
2386 if(extraCol) |
|
2387 { |
|
2388 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
2389 lRGBFramePtr++; |
|
2390 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
2391 lRGBFramePtr1++; |
|
2392 } |
|
2393 |
|
2394 lLumPtr += (lLumWidth << 1); |
|
2395 lCrPtr += (lLumWidth >> 1); |
|
2396 lCbPtr += (lLumWidth >> 1); |
|
2397 |
|
2398 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
2399 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
2400 } |
|
2401 |
|
2402 if(extraRow) |
|
2403 { |
|
2404 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
2405 for(j = 0; j < lWidth; j += 2) |
|
2406 { |
|
2407 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2408 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2409 } |
|
2410 if(extraCol) |
|
2411 { |
|
2412 *lRGBFramePtr = *lRGBFramePtr1; |
|
2413 } |
|
2414 } |
|
2415 return; |
|
2416 } |
|
2417 |
|
2418 /* |
|
2419 ****************************************************************************** |
|
2420 Name : sEmz_VDec_YUV420Chr2toColor16M_709_FR |
|
2421 Description : Converts YUV420 Chroma2 Planar to RGB888 Interleaved format |
|
2422 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
2423 uint8 *dstImage : Pointer to rgb data (o/p). |
|
2424 tWndParam *srcWindow : Pointer to structure containing source window |
|
2425 parameters like xOffset,yOffset,cropWidth, |
|
2426 cropHeight. (i/p) |
|
2427 tWndParam *dstWindow : Pointer to structure containing destination window |
|
2428 parameters like xOffset,yOffset,windWidth, |
|
2429 windHeight. (i/p) |
|
2430 Return Value : void |
|
2431 ****************************************************************************** |
|
2432 */ |
|
2433 |
|
2434 void sEmz_VDec_YUV420Chr2toColor16M_709_FR |
|
2435 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
2436 tWndParam* srcWindow, tWndParam* dstWindow) |
|
2437 { |
|
2438 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
2439 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
2440 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
2441 int32 lY1, lCr, lCb; |
|
2442 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
2443 int32 i, j, extraRow, extraCol; |
|
2444 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
2445 cropWidth,cropHeight,wndWidth,wndHeight; |
|
2446 |
|
2447 srcXOffset = srcWindow->xOffset; |
|
2448 srcYOffset = srcWindow->yOffset; |
|
2449 cropWidth = srcWindow->wndWidth; |
|
2450 cropHeight = srcWindow->wndHeight; |
|
2451 |
|
2452 dstXOffset = dstWindow->xOffset; |
|
2453 dstYOffset = dstWindow->yOffset; |
|
2454 wndWidth = dstWindow->wndWidth; |
|
2455 wndHeight = dstWindow->wndHeight; |
|
2456 |
|
2457 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
2458 { |
|
2459 lWidth = cropWidth; |
|
2460 } |
|
2461 else |
|
2462 { |
|
2463 lWidth = srcImage->width - srcXOffset; |
|
2464 } |
|
2465 |
|
2466 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
2467 { |
|
2468 lHeight = cropHeight; |
|
2469 } |
|
2470 else |
|
2471 { |
|
2472 lHeight = srcImage->height - srcYOffset; |
|
2473 } |
|
2474 |
|
2475 if (lWidth > (wndWidth - dstXOffset)) |
|
2476 { |
|
2477 lWidth = wndWidth - dstXOffset; |
|
2478 } |
|
2479 |
|
2480 if (lHeight > (wndHeight - dstYOffset)) |
|
2481 { |
|
2482 lHeight = wndHeight - dstYOffset; |
|
2483 } |
|
2484 |
|
2485 extraCol = lWidth & 0x01; |
|
2486 extraRow = lHeight & 0x01; |
|
2487 |
|
2488 lTempWidth = lWidth * 3; |
|
2489 lWidth = (lWidth >> 1) << 1; |
|
2490 lHeight = (lHeight >> 1) << 1; |
|
2491 |
|
2492 dstXOffset *= 3; |
|
2493 wndWidth *= 3; |
|
2494 |
|
2495 lLumWidth = (srcImage->width >> 1) << 1; |
|
2496 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
2497 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
2498 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
2499 |
|
2500 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
2501 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
2502 |
|
2503 for(i = 0; i < lHeight; i += 2) |
|
2504 { |
|
2505 for(j = 0; j < lWidth; j += 2) |
|
2506 { |
|
2507 lCr = lCrPtr[j >> 1]; |
|
2508 lCb = lCbPtr[j >> 1]; |
|
2509 |
|
2510 lCr -= 128; |
|
2511 lCb -= 128; |
|
2512 |
|
2513 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
2514 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
2515 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
2516 |
|
2517 /*First Pixel*/ |
|
2518 lY1 = lLumPtr[j]; |
|
2519 |
|
2520 /*R component*/ |
|
2521 lTemp = lY1 + lTemp1; |
|
2522 if (lTemp < 0) |
|
2523 lTemp = 0; |
|
2524 if (lTemp > 255) |
|
2525 lTemp = 255; |
|
2526 |
|
2527 lRGBFramePtr[0] = (uint8) lTemp; |
|
2528 |
|
2529 /*G component*/ |
|
2530 lTemp = lY1 - lTemp2; |
|
2531 if (lTemp < 0) |
|
2532 lTemp = 0; |
|
2533 if (lTemp > 255) |
|
2534 lTemp = 255; |
|
2535 |
|
2536 lRGBFramePtr[1] = (uint8) lTemp; |
|
2537 |
|
2538 /*B component*/ |
|
2539 lTemp = lY1 + lTemp3; |
|
2540 if (lTemp < 0) |
|
2541 lTemp = 0; |
|
2542 if (lTemp > 255) |
|
2543 lTemp = 255; |
|
2544 |
|
2545 lRGBFramePtr[2] = (uint8) lTemp; |
|
2546 |
|
2547 /*Second Pixel*/ |
|
2548 |
|
2549 lY1 = lLumPtr[j + 1]; |
|
2550 |
|
2551 /*R component*/ |
|
2552 lTemp = lY1 + lTemp1; |
|
2553 if (lTemp < 0) |
|
2554 lTemp = 0; |
|
2555 if (lTemp > 255) |
|
2556 lTemp = 255; |
|
2557 |
|
2558 lRGBFramePtr[3] = (uint8) lTemp; |
|
2559 |
|
2560 /*G component*/ |
|
2561 lTemp = lY1 - lTemp2; |
|
2562 if (lTemp < 0) |
|
2563 lTemp = 0; |
|
2564 if (lTemp > 255) |
|
2565 lTemp = 255; |
|
2566 |
|
2567 lRGBFramePtr[4] = (uint8) lTemp; |
|
2568 |
|
2569 |
|
2570 /*B component*/ |
|
2571 lTemp = lY1 + lTemp3; |
|
2572 |
|
2573 if (lTemp < 0) |
|
2574 lTemp = 0; |
|
2575 if (lTemp > 255) |
|
2576 lTemp = 255; |
|
2577 |
|
2578 lRGBFramePtr[5] = (uint8) lTemp; |
|
2579 |
|
2580 |
|
2581 /*Third Pixel*/ |
|
2582 lY1 = lLumPtr[j + lLumWidth]; |
|
2583 |
|
2584 /*R component*/ |
|
2585 lTemp = lY1 + lTemp1; |
|
2586 if (lTemp < 0) |
|
2587 lTemp = 0; |
|
2588 if (lTemp > 255) |
|
2589 lTemp = 255; |
|
2590 lRGBFramePtr1[0] = (uint8) lTemp; |
|
2591 |
|
2592 /*G component*/ |
|
2593 lTemp = lY1 - lTemp2; |
|
2594 if (lTemp < 0) |
|
2595 lTemp = 0; |
|
2596 if (lTemp > 255) |
|
2597 lTemp = 255; |
|
2598 |
|
2599 lRGBFramePtr1[1] = (uint8) lTemp; |
|
2600 |
|
2601 /*B component*/ |
|
2602 lTemp = lY1 + lTemp3; |
|
2603 if (lTemp < 0) |
|
2604 lTemp = 0; |
|
2605 if (lTemp > 255) |
|
2606 lTemp = 255; |
|
2607 |
|
2608 lRGBFramePtr1[2] = (uint8) lTemp; |
|
2609 |
|
2610 /*Fourth Pixel*/ |
|
2611 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
2612 |
|
2613 /*R component*/ |
|
2614 lTemp = lY1 + lTemp1; |
|
2615 if (lTemp < 0) |
|
2616 lTemp = 0; |
|
2617 if (lTemp > 255) |
|
2618 lTemp = 255; |
|
2619 lRGBFramePtr1[3] = (uint8) lTemp; |
|
2620 |
|
2621 /*G component*/ |
|
2622 lTemp = lY1 - lTemp2; |
|
2623 if (lTemp < 0) |
|
2624 lTemp = 0; |
|
2625 if (lTemp > 255) |
|
2626 lTemp = 255; |
|
2627 lRGBFramePtr1[4] = (uint8) lTemp; |
|
2628 |
|
2629 /*B component*/ |
|
2630 lTemp = lY1 + lTemp3; |
|
2631 if (lTemp < 0) |
|
2632 lTemp = 0; |
|
2633 if (lTemp > 255) |
|
2634 lTemp = 255; |
|
2635 |
|
2636 lRGBFramePtr1[5] = (uint8) lTemp; |
|
2637 |
|
2638 lRGBFramePtr += 6; |
|
2639 lRGBFramePtr1 += 6; |
|
2640 } |
|
2641 if(extraCol) |
|
2642 { |
|
2643 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
2644 lRGBFramePtr++; |
|
2645 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
2646 lRGBFramePtr++; |
|
2647 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
2648 lRGBFramePtr++; |
|
2649 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
2650 lRGBFramePtr1++; |
|
2651 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
2652 lRGBFramePtr1++; |
|
2653 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
2654 lRGBFramePtr1++; |
|
2655 |
|
2656 } |
|
2657 |
|
2658 lLumPtr += (lLumWidth << 1); |
|
2659 lCrPtr += (lLumWidth >> 1); |
|
2660 lCbPtr += (lLumWidth >> 1); |
|
2661 |
|
2662 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
2663 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
2664 } |
|
2665 |
|
2666 if(extraRow) |
|
2667 { |
|
2668 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
2669 for(j = 0; j < lWidth * 3; j += 2) |
|
2670 { |
|
2671 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2672 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2673 } |
|
2674 if(extraCol) |
|
2675 { |
|
2676 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2677 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2678 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2679 } |
|
2680 } |
|
2681 return; |
|
2682 } |
|
2683 |
|
2684 /* |
|
2685 ****************************************************************************** |
|
2686 Name : sEmz_VDec_YUV420Chr2toColor16M_601_5_FR |
|
2687 Description : Converts YUV420 Chroma2 Planar to RGB888 Interleaved format |
|
2688 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
2689 uint8 *dstImage : Pointer to rgb data (o/p). |
|
2690 tWndParam *srcWindow : Pointer to structure containing source window |
|
2691 parameters like xOffset,yOffset,cropWidth, |
|
2692 cropHeight. (i/p) |
|
2693 tWndParam *dstWindow : Pointer to structure containing destination window |
|
2694 parameters like xOffset,yOffset,windWidth, |
|
2695 windHeight. (i/p) |
|
2696 Return Value : void |
|
2697 ****************************************************************************** |
|
2698 */ |
|
2699 |
|
2700 void sEmz_VDec_YUV420Chr2toColor16M_601_5_FR |
|
2701 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
2702 tWndParam* srcWindow, tWndParam* dstWindow) |
|
2703 { |
|
2704 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
2705 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
2706 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
2707 int32 lY1, lCr, lCb; |
|
2708 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
2709 int32 i, j, extraRow, extraCol; |
|
2710 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
2711 cropWidth,cropHeight,wndWidth,wndHeight; |
|
2712 |
|
2713 srcXOffset = srcWindow->xOffset; |
|
2714 srcYOffset = srcWindow->yOffset; |
|
2715 cropWidth = srcWindow->wndWidth; |
|
2716 cropHeight = srcWindow->wndHeight; |
|
2717 |
|
2718 |
|
2719 dstXOffset = dstWindow->xOffset; |
|
2720 dstYOffset = dstWindow->yOffset; |
|
2721 wndWidth = dstWindow->wndWidth; |
|
2722 wndHeight = dstWindow->wndHeight; |
|
2723 |
|
2724 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
2725 { |
|
2726 lWidth = cropWidth; |
|
2727 } |
|
2728 else |
|
2729 { |
|
2730 lWidth = srcImage->width - srcXOffset; |
|
2731 } |
|
2732 |
|
2733 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
2734 { |
|
2735 lHeight = cropHeight; |
|
2736 } |
|
2737 else |
|
2738 { |
|
2739 lHeight = srcImage->height - srcYOffset; |
|
2740 } |
|
2741 |
|
2742 if (lWidth > (wndWidth - dstXOffset)) |
|
2743 { |
|
2744 lWidth = wndWidth - dstXOffset; |
|
2745 } |
|
2746 |
|
2747 if (lHeight > (wndHeight - dstYOffset)) |
|
2748 { |
|
2749 lHeight = wndHeight - dstYOffset; |
|
2750 } |
|
2751 |
|
2752 extraCol = lWidth & 0x01; |
|
2753 extraRow = lHeight & 0x01; |
|
2754 |
|
2755 lTempWidth = lWidth * 3; |
|
2756 lWidth = (lWidth >> 1) << 1; |
|
2757 lHeight = (lHeight >> 1) << 1; |
|
2758 |
|
2759 dstXOffset *= 3; |
|
2760 wndWidth *= 3; |
|
2761 |
|
2762 lLumWidth = (srcImage->width >> 1) << 1; |
|
2763 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
2764 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
2765 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
2766 |
|
2767 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
2768 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
2769 |
|
2770 for(i = 0; i < lHeight; i += 2) |
|
2771 { |
|
2772 for(j = 0; j < lWidth; j += 2) |
|
2773 { |
|
2774 lCr = lCrPtr[j >> 1]; |
|
2775 lCb = lCbPtr[j >> 1]; |
|
2776 |
|
2777 lCr -= 128; |
|
2778 lCb -= 128; |
|
2779 |
|
2780 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
2781 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
2782 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
2783 |
|
2784 /*First Pixel*/ |
|
2785 lY1 = lLumPtr[j]; |
|
2786 |
|
2787 /*R component*/ |
|
2788 lTemp = lY1 + lTemp1; |
|
2789 if (lTemp < 0) |
|
2790 lTemp = 0; |
|
2791 if (lTemp > 255) |
|
2792 lTemp = 255; |
|
2793 |
|
2794 lRGBFramePtr[0] = (uint8) lTemp; |
|
2795 |
|
2796 /*G component*/ |
|
2797 lTemp = lY1 - lTemp2; |
|
2798 if (lTemp < 0) |
|
2799 lTemp = 0; |
|
2800 if (lTemp > 255) |
|
2801 lTemp = 255; |
|
2802 |
|
2803 lRGBFramePtr[1] = (uint8) lTemp; |
|
2804 |
|
2805 /*B component*/ |
|
2806 lTemp = lY1 + lTemp3; |
|
2807 if (lTemp < 0) |
|
2808 lTemp = 0; |
|
2809 if (lTemp > 255) |
|
2810 lTemp = 255; |
|
2811 |
|
2812 lRGBFramePtr[2] = (uint8) lTemp; |
|
2813 |
|
2814 /*Second Pixel*/ |
|
2815 |
|
2816 lY1 = lLumPtr[j + 1]; |
|
2817 |
|
2818 /*R component*/ |
|
2819 lTemp = lY1 + lTemp1; |
|
2820 if (lTemp < 0) |
|
2821 lTemp = 0; |
|
2822 if (lTemp > 255) |
|
2823 lTemp = 255; |
|
2824 |
|
2825 lRGBFramePtr[3] = (uint8) lTemp; |
|
2826 |
|
2827 /*G component*/ |
|
2828 lTemp = lY1 - lTemp2; |
|
2829 if (lTemp < 0) |
|
2830 lTemp = 0; |
|
2831 if (lTemp > 255) |
|
2832 lTemp = 255; |
|
2833 |
|
2834 lRGBFramePtr[4] = (uint8) lTemp; |
|
2835 |
|
2836 |
|
2837 /*B component*/ |
|
2838 lTemp = lY1 + lTemp3; |
|
2839 |
|
2840 if (lTemp < 0) |
|
2841 lTemp = 0; |
|
2842 if (lTemp > 255) |
|
2843 lTemp = 255; |
|
2844 |
|
2845 lRGBFramePtr[5] = (uint8) lTemp; |
|
2846 |
|
2847 |
|
2848 /*Third Pixel*/ |
|
2849 lY1 = lLumPtr[j + lLumWidth]; |
|
2850 |
|
2851 /*R component*/ |
|
2852 lTemp = lY1 + lTemp1; |
|
2853 if (lTemp < 0) |
|
2854 lTemp = 0; |
|
2855 if (lTemp > 255) |
|
2856 lTemp = 255; |
|
2857 lRGBFramePtr1[0] = (uint8) lTemp; |
|
2858 |
|
2859 /*G component*/ |
|
2860 lTemp = lY1 - lTemp2; |
|
2861 if (lTemp < 0) |
|
2862 lTemp = 0; |
|
2863 if (lTemp > 255) |
|
2864 lTemp = 255; |
|
2865 |
|
2866 lRGBFramePtr1[1] = (uint8) lTemp; |
|
2867 |
|
2868 /*B component*/ |
|
2869 lTemp = lY1 + lTemp3; |
|
2870 if (lTemp < 0) |
|
2871 lTemp = 0; |
|
2872 if (lTemp > 255) |
|
2873 lTemp = 255; |
|
2874 |
|
2875 lRGBFramePtr1[2] = (uint8) lTemp; |
|
2876 |
|
2877 /*Fourth Pixel*/ |
|
2878 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
2879 |
|
2880 /*R component*/ |
|
2881 lTemp = lY1 + lTemp1; |
|
2882 if (lTemp < 0) |
|
2883 lTemp = 0; |
|
2884 if (lTemp > 255) |
|
2885 lTemp = 255; |
|
2886 lRGBFramePtr1[3] = (uint8) lTemp; |
|
2887 |
|
2888 /*G component*/ |
|
2889 lTemp = lY1 - lTemp2; |
|
2890 if (lTemp < 0) |
|
2891 lTemp = 0; |
|
2892 if (lTemp > 255) |
|
2893 lTemp = 255; |
|
2894 lRGBFramePtr1[4] = (uint8) lTemp; |
|
2895 |
|
2896 /*B component*/ |
|
2897 lTemp = lY1 + lTemp3; |
|
2898 if (lTemp < 0) |
|
2899 lTemp = 0; |
|
2900 if (lTemp > 255) |
|
2901 lTemp = 255; |
|
2902 |
|
2903 lRGBFramePtr1[5] = (uint8) lTemp; |
|
2904 |
|
2905 lRGBFramePtr += 6; |
|
2906 lRGBFramePtr1 += 6; |
|
2907 } |
|
2908 if(extraCol) |
|
2909 { |
|
2910 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
2911 lRGBFramePtr++; |
|
2912 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
2913 lRGBFramePtr++; |
|
2914 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
2915 lRGBFramePtr++; |
|
2916 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
2917 lRGBFramePtr1++; |
|
2918 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
2919 lRGBFramePtr1++; |
|
2920 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
2921 lRGBFramePtr1++; |
|
2922 |
|
2923 } |
|
2924 |
|
2925 lLumPtr += (lLumWidth << 1); |
|
2926 lCrPtr += (lLumWidth >> 1); |
|
2927 lCbPtr += (lLumWidth >> 1); |
|
2928 |
|
2929 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
2930 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
2931 } |
|
2932 |
|
2933 if(extraRow) |
|
2934 { |
|
2935 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
2936 for(j = 0; j < lWidth * 3; j += 2) |
|
2937 { |
|
2938 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2939 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2940 } |
|
2941 if(extraCol) |
|
2942 { |
|
2943 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2944 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2945 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
2946 } |
|
2947 } |
|
2948 return; |
|
2949 } |
|
2950 |
|
2951 /* |
|
2952 ****************************************************************************** |
|
2953 Name : sEmz_VDec_YUV420Chr2toColor16M_709_RR |
|
2954 Description : Converts YUV420 Chroma2 Planar to RGB888 Interleaved format |
|
2955 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
2956 uint8 *dstImage : Pointer to rgb data (o/p). |
|
2957 tWndParam *srcWindow : Pointer to structure containing source window |
|
2958 parameters like xOffset,yOffset,cropWidth, |
|
2959 cropHeight. (i/p) |
|
2960 tWndParam *dstWindow : Pointer to structure containing destination window |
|
2961 parameters like xOffset,yOffset,windWidth, |
|
2962 windHeight. (i/p) |
|
2963 Return Value : void |
|
2964 ****************************************************************************** |
|
2965 */ |
|
2966 |
|
2967 void sEmz_VDec_YUV420Chr2toColor16M_709_RR |
|
2968 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
2969 tWndParam* srcWindow, tWndParam* dstWindow) |
|
2970 { |
|
2971 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
2972 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
2973 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
2974 int32 lY1, lCr, lCb; |
|
2975 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
2976 int32 i, j, extraRow, extraCol; |
|
2977 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
2978 cropWidth,cropHeight,wndWidth,wndHeight; |
|
2979 |
|
2980 srcXOffset = srcWindow->xOffset; |
|
2981 srcYOffset = srcWindow->yOffset; |
|
2982 cropWidth = srcWindow->wndWidth; |
|
2983 cropHeight = srcWindow->wndHeight; |
|
2984 |
|
2985 |
|
2986 dstXOffset = dstWindow->xOffset; |
|
2987 dstYOffset = dstWindow->yOffset; |
|
2988 wndWidth = dstWindow->wndWidth; |
|
2989 wndHeight = dstWindow->wndHeight; |
|
2990 |
|
2991 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
2992 { |
|
2993 lWidth = cropWidth; |
|
2994 } |
|
2995 else |
|
2996 { |
|
2997 lWidth = srcImage->width - srcXOffset; |
|
2998 } |
|
2999 |
|
3000 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
3001 { |
|
3002 lHeight = cropHeight; |
|
3003 } |
|
3004 else |
|
3005 { |
|
3006 lHeight = srcImage->height - srcYOffset; |
|
3007 } |
|
3008 |
|
3009 if (lWidth > (wndWidth - dstXOffset)) |
|
3010 { |
|
3011 lWidth = wndWidth - dstXOffset; |
|
3012 } |
|
3013 |
|
3014 if (lHeight > (wndHeight - dstYOffset)) |
|
3015 { |
|
3016 lHeight = wndHeight - dstYOffset; |
|
3017 } |
|
3018 |
|
3019 extraCol = lWidth & 0x01; |
|
3020 extraRow = lHeight & 0x01; |
|
3021 |
|
3022 lTempWidth = lWidth * 3; |
|
3023 lWidth = (lWidth >> 1) << 1; |
|
3024 lHeight = (lHeight >> 1) << 1; |
|
3025 |
|
3026 dstXOffset *= 3; |
|
3027 wndWidth *= 3; |
|
3028 |
|
3029 lLumWidth = (srcImage->width >> 1) << 1; |
|
3030 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
3031 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
3032 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
3033 |
|
3034 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
3035 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
3036 |
|
3037 for(i = 0; i < lHeight; i += 2) |
|
3038 { |
|
3039 for(j = 0; j < lWidth; j += 2) |
|
3040 { |
|
3041 lCr = lCrPtr[j >> 1]; |
|
3042 lCb = lCbPtr[j >> 1]; |
|
3043 |
|
3044 lCr -= 128; |
|
3045 lCb -= 128; |
|
3046 |
|
3047 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
3048 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
3049 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
3050 |
|
3051 /*First Pixel*/ |
|
3052 lY1 = lLumPtr[j]; |
|
3053 lY1 -= 16; |
|
3054 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
3055 |
|
3056 /*R component*/ |
|
3057 lTemp = lY1 + lTemp1; |
|
3058 if (lTemp < 0) |
|
3059 lTemp = 0; |
|
3060 if (lTemp > 255) |
|
3061 lTemp = 255; |
|
3062 |
|
3063 lRGBFramePtr[0] = (uint8) lTemp; |
|
3064 |
|
3065 /*G component*/ |
|
3066 lTemp = lY1 - lTemp2; |
|
3067 if (lTemp < 0) |
|
3068 lTemp = 0; |
|
3069 if (lTemp > 255) |
|
3070 lTemp = 255; |
|
3071 |
|
3072 lRGBFramePtr[1] = (uint8) lTemp; |
|
3073 |
|
3074 /*B component*/ |
|
3075 lTemp = lY1 + lTemp3; |
|
3076 if (lTemp < 0) |
|
3077 lTemp = 0; |
|
3078 if (lTemp > 255) |
|
3079 lTemp = 255; |
|
3080 |
|
3081 lRGBFramePtr[2] = (uint8) lTemp; |
|
3082 |
|
3083 /*Second Pixel*/ |
|
3084 |
|
3085 lY1 = lLumPtr[j + 1]; |
|
3086 lY1 -= 16; |
|
3087 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
3088 |
|
3089 /*R component*/ |
|
3090 lTemp = lY1 + lTemp1; |
|
3091 if (lTemp < 0) |
|
3092 lTemp = 0; |
|
3093 if (lTemp > 255) |
|
3094 lTemp = 255; |
|
3095 |
|
3096 lRGBFramePtr[3] = (uint8) lTemp; |
|
3097 |
|
3098 /*G component*/ |
|
3099 lTemp = lY1 - lTemp2; |
|
3100 if (lTemp < 0) |
|
3101 lTemp = 0; |
|
3102 if (lTemp > 255) |
|
3103 lTemp = 255; |
|
3104 |
|
3105 lRGBFramePtr[4] = (uint8) lTemp; |
|
3106 |
|
3107 /*B component*/ |
|
3108 lTemp = lY1 + lTemp3; |
|
3109 if (lTemp < 0) |
|
3110 lTemp = 0; |
|
3111 if (lTemp > 255) |
|
3112 lTemp = 255; |
|
3113 |
|
3114 lRGBFramePtr[5] = (uint8) lTemp; |
|
3115 |
|
3116 |
|
3117 /*Third Pixel*/ |
|
3118 lY1 = lLumPtr[j + lLumWidth]; |
|
3119 lY1 -= 16; |
|
3120 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
3121 |
|
3122 /*R component*/ |
|
3123 lTemp = lY1 + lTemp1; |
|
3124 if (lTemp < 0) |
|
3125 lTemp = 0; |
|
3126 if (lTemp > 255) |
|
3127 lTemp = 255; |
|
3128 lRGBFramePtr1[0] = (uint8) lTemp; |
|
3129 |
|
3130 /*G component*/ |
|
3131 lTemp = lY1 - lTemp2; |
|
3132 if (lTemp < 0) |
|
3133 lTemp = 0; |
|
3134 if (lTemp > 255) |
|
3135 lTemp = 255; |
|
3136 |
|
3137 lRGBFramePtr1[1] = (uint8) lTemp; |
|
3138 |
|
3139 /*B component*/ |
|
3140 lTemp = lY1 + lTemp3; |
|
3141 if (lTemp < 0) |
|
3142 lTemp = 0; |
|
3143 if (lTemp > 255) |
|
3144 lTemp = 255; |
|
3145 |
|
3146 lRGBFramePtr1[2] = (uint8) lTemp; |
|
3147 |
|
3148 /*Fourth Pixel*/ |
|
3149 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
3150 lY1 -= 16; |
|
3151 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
3152 |
|
3153 /*R component*/ |
|
3154 lTemp = lY1 + lTemp1; |
|
3155 if (lTemp < 0) |
|
3156 lTemp = 0; |
|
3157 if (lTemp > 255) |
|
3158 lTemp = 255; |
|
3159 |
|
3160 lRGBFramePtr1[3] = (uint8) lTemp; |
|
3161 |
|
3162 /*G component*/ |
|
3163 lTemp = lY1 - lTemp2; |
|
3164 if (lTemp < 0) |
|
3165 lTemp = 0; |
|
3166 if (lTemp > 255) |
|
3167 lTemp = 255; |
|
3168 lRGBFramePtr1[4] = (uint8) lTemp; |
|
3169 |
|
3170 /*B component*/ |
|
3171 lTemp = lY1 + lTemp3; |
|
3172 if (lTemp < 0) |
|
3173 lTemp = 0; |
|
3174 if (lTemp > 255) |
|
3175 lTemp = 255; |
|
3176 |
|
3177 lRGBFramePtr1[5] = (uint8) lTemp; |
|
3178 |
|
3179 lRGBFramePtr += 6; |
|
3180 lRGBFramePtr1 += 6; |
|
3181 } |
|
3182 if(extraCol) |
|
3183 { |
|
3184 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
3185 lRGBFramePtr++; |
|
3186 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
3187 lRGBFramePtr++; |
|
3188 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
3189 lRGBFramePtr++; |
|
3190 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
3191 lRGBFramePtr1++; |
|
3192 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
3193 lRGBFramePtr1++; |
|
3194 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
3195 lRGBFramePtr1++; |
|
3196 |
|
3197 } |
|
3198 |
|
3199 lLumPtr += (lLumWidth << 1); |
|
3200 lCrPtr += (lLumWidth >> 1); |
|
3201 lCbPtr += (lLumWidth >> 1); |
|
3202 |
|
3203 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
3204 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
3205 } |
|
3206 |
|
3207 if(extraRow) |
|
3208 { |
|
3209 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
3210 for(j = 0; j < lWidth * 3; j += 2) |
|
3211 { |
|
3212 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3213 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3214 } |
|
3215 if(extraCol) |
|
3216 { |
|
3217 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3218 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3219 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3220 } |
|
3221 } |
|
3222 return; |
|
3223 } |
|
3224 |
|
3225 /* |
|
3226 ****************************************************************************** |
|
3227 Name : sEmz_VDec_YUV420Chr2toColor16M_601_5_RR |
|
3228 Description : Converts YUV420 Chroma2 Planar to RGB888 Interleaved format |
|
3229 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
3230 uint8 *dstImage : Pointer to rgb data (o/p). |
|
3231 tWndParam *srcWindow : Pointer to structure containing source window |
|
3232 parameters like xOffset,yOffset,cropWidth, |
|
3233 cropHeight. (i/p) |
|
3234 tWndParam *dstWindow : Pointer to structure containing destination window |
|
3235 parameters like xOffset,yOffset,windWidth, |
|
3236 windHeight. (i/p) |
|
3237 Return Value : void |
|
3238 ****************************************************************************** |
|
3239 */ |
|
3240 |
|
3241 void sEmz_VDec_YUV420Chr2toColor16M_601_5_RR |
|
3242 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
3243 tWndParam* srcWindow, tWndParam* dstWindow) |
|
3244 { |
|
3245 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
3246 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
3247 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
3248 int32 lY1, lCr, lCb; |
|
3249 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
3250 int32 i, j, extraRow, extraCol; |
|
3251 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
3252 cropWidth,cropHeight,wndWidth,wndHeight; |
|
3253 |
|
3254 srcXOffset = srcWindow->xOffset; |
|
3255 srcYOffset = srcWindow->yOffset; |
|
3256 cropWidth = srcWindow->wndWidth; |
|
3257 cropHeight = srcWindow->wndHeight; |
|
3258 |
|
3259 |
|
3260 dstXOffset = dstWindow->xOffset; |
|
3261 dstYOffset = dstWindow->yOffset; |
|
3262 wndWidth = dstWindow->wndWidth; |
|
3263 wndHeight = dstWindow->wndHeight; |
|
3264 |
|
3265 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
3266 { |
|
3267 lWidth = cropWidth; |
|
3268 } |
|
3269 else |
|
3270 { |
|
3271 lWidth = srcImage->width - srcXOffset; |
|
3272 } |
|
3273 |
|
3274 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
3275 { |
|
3276 lHeight = cropHeight; |
|
3277 } |
|
3278 else |
|
3279 { |
|
3280 lHeight = srcImage->height - srcYOffset; |
|
3281 } |
|
3282 |
|
3283 if (lWidth > (wndWidth - dstXOffset)) |
|
3284 { |
|
3285 lWidth = wndWidth - dstXOffset; |
|
3286 } |
|
3287 |
|
3288 if (lHeight > (wndHeight - dstYOffset)) |
|
3289 { |
|
3290 lHeight = wndHeight - dstYOffset; |
|
3291 } |
|
3292 |
|
3293 extraCol = lWidth & 0x01; |
|
3294 extraRow = lHeight & 0x01; |
|
3295 |
|
3296 lTempWidth = lWidth * 3; |
|
3297 lWidth = (lWidth >> 1) << 1; |
|
3298 lHeight = (lHeight >> 1) << 1; |
|
3299 |
|
3300 dstXOffset *= 3; |
|
3301 wndWidth *= 3; |
|
3302 |
|
3303 lLumWidth = (srcImage->width >> 1) << 1; |
|
3304 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
3305 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
3306 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
3307 |
|
3308 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
3309 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
3310 |
|
3311 for(i = 0; i < lHeight; i += 2) |
|
3312 { |
|
3313 for(j = 0; j < lWidth; j += 2) |
|
3314 { |
|
3315 lCr = lCrPtr[j >> 1]; |
|
3316 lCb = lCbPtr[j >> 1]; |
|
3317 |
|
3318 lCr -= 128; |
|
3319 lCb -= 128; |
|
3320 |
|
3321 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
3322 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
3323 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
3324 |
|
3325 /*First Pixel*/ |
|
3326 lY1 = lLumPtr[j]; |
|
3327 lY1 -= 16; |
|
3328 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
3329 |
|
3330 /*R component*/ |
|
3331 lTemp = lY1 + lTemp1; |
|
3332 if (lTemp < 0) |
|
3333 lTemp = 0; |
|
3334 if (lTemp > 255) |
|
3335 lTemp = 255; |
|
3336 |
|
3337 lRGBFramePtr[0] = (uint8) lTemp; |
|
3338 |
|
3339 /*G component*/ |
|
3340 lTemp = lY1 - lTemp2; |
|
3341 if (lTemp < 0) |
|
3342 lTemp = 0; |
|
3343 if (lTemp > 255) |
|
3344 lTemp = 255; |
|
3345 |
|
3346 lRGBFramePtr[1] = (uint8) lTemp; |
|
3347 |
|
3348 /*B component*/ |
|
3349 lTemp = lY1 + lTemp3; |
|
3350 if (lTemp < 0) |
|
3351 lTemp = 0; |
|
3352 if (lTemp > 255) |
|
3353 lTemp = 255; |
|
3354 |
|
3355 lRGBFramePtr[2] = (uint8) lTemp; |
|
3356 |
|
3357 /*Second Pixel*/ |
|
3358 |
|
3359 lY1 = lLumPtr[j + 1]; |
|
3360 lY1 -= 16; |
|
3361 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
3362 |
|
3363 /*R component*/ |
|
3364 lTemp = lY1 + lTemp1; |
|
3365 if (lTemp < 0) |
|
3366 lTemp = 0; |
|
3367 if (lTemp > 255) |
|
3368 lTemp = 255; |
|
3369 |
|
3370 lRGBFramePtr[3] = (uint8) lTemp; |
|
3371 |
|
3372 /*G component*/ |
|
3373 lTemp = lY1 - lTemp2; |
|
3374 if (lTemp < 0) |
|
3375 lTemp = 0; |
|
3376 if (lTemp > 255) |
|
3377 lTemp = 255; |
|
3378 |
|
3379 lRGBFramePtr[4] = (uint8) lTemp; |
|
3380 |
|
3381 /*B component*/ |
|
3382 lTemp = lY1 + lTemp3; |
|
3383 if (lTemp < 0) |
|
3384 lTemp = 0; |
|
3385 if (lTemp > 255) |
|
3386 lTemp = 255; |
|
3387 |
|
3388 lRGBFramePtr[5] = (uint8) lTemp; |
|
3389 |
|
3390 |
|
3391 /*Third Pixel*/ |
|
3392 lY1 = lLumPtr[j + lLumWidth]; |
|
3393 lY1 -= 16; |
|
3394 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
3395 |
|
3396 /*R component*/ |
|
3397 lTemp = lY1 + lTemp1; |
|
3398 if (lTemp < 0) |
|
3399 lTemp = 0; |
|
3400 if (lTemp > 255) |
|
3401 lTemp = 255; |
|
3402 lRGBFramePtr1[0] = (uint8) lTemp; |
|
3403 |
|
3404 /*G component*/ |
|
3405 lTemp = lY1 - lTemp2; |
|
3406 if (lTemp < 0) |
|
3407 lTemp = 0; |
|
3408 if (lTemp > 255) |
|
3409 lTemp = 255; |
|
3410 |
|
3411 lRGBFramePtr1[1] = (uint8) lTemp; |
|
3412 |
|
3413 /*B component*/ |
|
3414 lTemp = lY1 + lTemp3; |
|
3415 if (lTemp < 0) |
|
3416 lTemp = 0; |
|
3417 if (lTemp > 255) |
|
3418 lTemp = 255; |
|
3419 |
|
3420 lRGBFramePtr1[2] = (uint8) lTemp; |
|
3421 |
|
3422 /*Fourth Pixel*/ |
|
3423 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
3424 lY1 -= 16; |
|
3425 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
3426 |
|
3427 /*R component*/ |
|
3428 lTemp = lY1 + lTemp1; |
|
3429 if (lTemp < 0) |
|
3430 lTemp = 0; |
|
3431 if (lTemp > 255) |
|
3432 lTemp = 255; |
|
3433 |
|
3434 lRGBFramePtr1[3] = (uint8) lTemp; |
|
3435 |
|
3436 /*G component*/ |
|
3437 lTemp = lY1 - lTemp2; |
|
3438 if (lTemp < 0) |
|
3439 lTemp = 0; |
|
3440 if (lTemp > 255) |
|
3441 lTemp = 255; |
|
3442 lRGBFramePtr1[4] = (uint8) lTemp; |
|
3443 |
|
3444 /*B component*/ |
|
3445 lTemp = lY1 + lTemp3; |
|
3446 if (lTemp < 0) |
|
3447 lTemp = 0; |
|
3448 if (lTemp > 255) |
|
3449 lTemp = 255; |
|
3450 |
|
3451 lRGBFramePtr1[5] = (uint8) lTemp; |
|
3452 |
|
3453 lRGBFramePtr += 6; |
|
3454 lRGBFramePtr1 += 6; |
|
3455 } |
|
3456 if(extraCol) |
|
3457 { |
|
3458 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
3459 lRGBFramePtr++; |
|
3460 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
3461 lRGBFramePtr++; |
|
3462 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
3463 lRGBFramePtr++; |
|
3464 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
3465 lRGBFramePtr1++; |
|
3466 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
3467 lRGBFramePtr1++; |
|
3468 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
3469 lRGBFramePtr1++; |
|
3470 |
|
3471 } |
|
3472 |
|
3473 lLumPtr += (lLumWidth << 1); |
|
3474 lCrPtr += (lLumWidth >> 1); |
|
3475 lCbPtr += (lLumWidth >> 1); |
|
3476 |
|
3477 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
3478 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
3479 } |
|
3480 |
|
3481 if(extraRow) |
|
3482 { |
|
3483 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
3484 for(j = 0; j < lWidth * 3; j += 2) |
|
3485 { |
|
3486 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3487 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3488 } |
|
3489 if(extraCol) |
|
3490 { |
|
3491 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3492 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3493 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3494 } |
|
3495 } |
|
3496 return; |
|
3497 } |
|
3498 |
|
3499 |
|
3500 /* |
|
3501 ****************************************************************************** |
|
3502 Name : sEmz_VDec_YUV420Chr2toColor4k_Ordered_709_FR |
|
3503 Description : Converts YUV420 Chroma2 Planar to XRGB (4:4:4:4) Interleaved format |
|
3504 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
3505 uint8 *dstImage : Pointer to rgb data (o/p). |
|
3506 tWndParam *srcWindow : Pointer to structure containing source window |
|
3507 parameters like xOffset,yOffset,cropWidth, |
|
3508 cropHeight. (i/p) |
|
3509 tWndParam *dstWindow : Pointer to structure containing destination window |
|
3510 parameters like xOffset,yOffset,windWidth, |
|
3511 windHeight. (i/p) |
|
3512 Return Value : void |
|
3513 ****************************************************************************** |
|
3514 */ |
|
3515 |
|
3516 void sEmz_VDec_YUV420Chr2toColor4k_Ordered_709_FR |
|
3517 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
3518 tWndParam* srcWindow, tWndParam* dstWindow) |
|
3519 { |
|
3520 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
3521 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
3522 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
3523 int32 lY1, lCr, lCb; |
|
3524 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
3525 int32 i, j, extraRow, extraCol; |
|
3526 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
3527 cropWidth,cropHeight,wndWidth,wndHeight; |
|
3528 |
|
3529 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
3530 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
3531 |
|
3532 | {0,15,5} {10,0,15} | |
|
3533 | {15,5,10} {5,10,0} | */ |
|
3534 |
|
3535 srcXOffset = srcWindow->xOffset; |
|
3536 srcYOffset = srcWindow->yOffset; |
|
3537 cropWidth = srcWindow->wndWidth; |
|
3538 cropHeight = srcWindow->wndHeight; |
|
3539 |
|
3540 dstXOffset = dstWindow->xOffset; |
|
3541 dstYOffset = dstWindow->yOffset; |
|
3542 wndWidth = dstWindow->wndWidth; |
|
3543 wndHeight = dstWindow->wndHeight; |
|
3544 |
|
3545 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
3546 { |
|
3547 lWidth = cropWidth; |
|
3548 } |
|
3549 else |
|
3550 { |
|
3551 lWidth = srcImage->width - srcXOffset; |
|
3552 } |
|
3553 |
|
3554 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
3555 { |
|
3556 lHeight = cropHeight; |
|
3557 } |
|
3558 else |
|
3559 { |
|
3560 lHeight = srcImage->height - srcYOffset; |
|
3561 } |
|
3562 |
|
3563 if (lWidth > (wndWidth - dstXOffset)) |
|
3564 { |
|
3565 lWidth = wndWidth - dstXOffset; |
|
3566 } |
|
3567 |
|
3568 if (lHeight > (wndHeight - dstYOffset)) |
|
3569 { |
|
3570 lHeight = wndHeight - dstYOffset; |
|
3571 } |
|
3572 |
|
3573 extraCol = lWidth & 0x01; |
|
3574 extraRow = lHeight & 0x01; |
|
3575 |
|
3576 lTempWidth = lWidth; |
|
3577 lWidth = (lWidth >> 1) << 1; |
|
3578 lHeight = (lHeight >> 1) << 1; |
|
3579 |
|
3580 lLumWidth = (srcImage->width >> 1) << 1; |
|
3581 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
3582 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
3583 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
3584 |
|
3585 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
3586 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
3587 |
|
3588 for(i = 0; i < lHeight; i += 2) |
|
3589 { |
|
3590 for(j = 0; j < lWidth; j += 2) |
|
3591 { |
|
3592 lCr = lCrPtr[j >> 1]; |
|
3593 lCb = lCbPtr[j >> 1]; |
|
3594 |
|
3595 lCr -= 128; |
|
3596 lCb -= 128; |
|
3597 |
|
3598 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
3599 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
3600 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
3601 |
|
3602 /*First Pixel*/ |
|
3603 lY1 = lLumPtr[j]; |
|
3604 |
|
3605 /*B component*/ |
|
3606 lTemp = lY1 + lTemp3; |
|
3607 if (lTemp < 0) |
|
3608 lTemp = 0; |
|
3609 if (lTemp > 255) |
|
3610 lTemp = 255; |
|
3611 lTemp4 = (lTemp >> 4); |
|
3612 |
|
3613 /*G component*/ |
|
3614 lTemp = lY1 - lTemp2 + 15; |
|
3615 if (lTemp < 0) |
|
3616 lTemp = 0; |
|
3617 if (lTemp > 255) |
|
3618 lTemp = 255; |
|
3619 lTemp4 |= (lTemp >> 4) << 4; |
|
3620 |
|
3621 /*R component*/ |
|
3622 lTemp = lY1 + lTemp1 + 5; |
|
3623 if (lTemp < 0) |
|
3624 lTemp = 0; |
|
3625 if (lTemp > 255) |
|
3626 lTemp = 255; |
|
3627 lTemp4 |= (lTemp >> 4) << 8; |
|
3628 |
|
3629 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
3630 |
|
3631 /*Second Pixel*/ |
|
3632 lY1 = lLumPtr[j + 1]; |
|
3633 |
|
3634 /*B component*/ |
|
3635 lTemp = lY1 + lTemp3 + 10; |
|
3636 if (lTemp < 0) |
|
3637 lTemp = 0; |
|
3638 if (lTemp > 255) |
|
3639 lTemp = 255; |
|
3640 lTemp4 = (lTemp >> 4); |
|
3641 |
|
3642 /*G component*/ |
|
3643 lTemp = lY1 - lTemp2; |
|
3644 if (lTemp < 0) |
|
3645 lTemp = 0; |
|
3646 if (lTemp > 255) |
|
3647 lTemp = 255; |
|
3648 lTemp4 |= (lTemp >> 4) << 4; |
|
3649 |
|
3650 /*R component*/ |
|
3651 lTemp = lY1 + lTemp1 + 15; |
|
3652 if (lTemp < 0) |
|
3653 lTemp = 0; |
|
3654 if (lTemp > 255) |
|
3655 lTemp = 255; |
|
3656 lTemp4 |= (lTemp >> 4) << 8; |
|
3657 |
|
3658 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
3659 |
|
3660 |
|
3661 /*Third Pixel*/ |
|
3662 lY1 = lLumPtr[j + lLumWidth]; |
|
3663 |
|
3664 /*B component*/ |
|
3665 lTemp = lY1 + lTemp3 + 15; |
|
3666 if (lTemp < 0) |
|
3667 lTemp = 0; |
|
3668 if (lTemp > 255) |
|
3669 lTemp = 255; |
|
3670 lTemp4 = (lTemp >> 4); |
|
3671 |
|
3672 /*G component*/ |
|
3673 lTemp = lY1 - lTemp2 + 5; |
|
3674 if (lTemp < 0) |
|
3675 lTemp = 0; |
|
3676 if (lTemp > 255) |
|
3677 lTemp = 255; |
|
3678 lTemp4 |= (lTemp >> 4) << 4; |
|
3679 |
|
3680 /*R component*/ |
|
3681 lTemp = lY1 + lTemp1 + 10; |
|
3682 if (lTemp < 0) |
|
3683 lTemp = 0; |
|
3684 if (lTemp > 255) |
|
3685 lTemp = 255; |
|
3686 lTemp4 |= (lTemp >> 4) << 8; |
|
3687 |
|
3688 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
3689 |
|
3690 /*Fourth Pixel*/ |
|
3691 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
3692 |
|
3693 /*B component*/ |
|
3694 lTemp = lY1 + lTemp3 + 5; |
|
3695 if (lTemp < 0) |
|
3696 lTemp = 0; |
|
3697 if (lTemp > 255) |
|
3698 lTemp = 255; |
|
3699 lTemp4 = (lTemp >> 4); |
|
3700 |
|
3701 /*G component*/ |
|
3702 lTemp = lY1 - lTemp2 + 10; |
|
3703 if (lTemp < 0) |
|
3704 lTemp = 0; |
|
3705 if (lTemp > 255) |
|
3706 lTemp = 255; |
|
3707 lTemp4 |= (lTemp >> 4) << 4; |
|
3708 |
|
3709 /*R component*/ |
|
3710 lTemp = lY1 + lTemp1; |
|
3711 if (lTemp < 0) |
|
3712 lTemp = 0; |
|
3713 if (lTemp > 255) |
|
3714 lTemp = 255; |
|
3715 lTemp4 |= (lTemp >> 4) << 8; |
|
3716 |
|
3717 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
3718 |
|
3719 lRGBFramePtr += 2; |
|
3720 lRGBFramePtr1 += 2; |
|
3721 } |
|
3722 if(extraCol) |
|
3723 { |
|
3724 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
3725 lRGBFramePtr++; |
|
3726 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
3727 lRGBFramePtr1++; |
|
3728 } |
|
3729 |
|
3730 lLumPtr += (lLumWidth << 1); |
|
3731 lCrPtr += (lLumWidth >> 1); |
|
3732 lCbPtr += (lLumWidth >> 1); |
|
3733 |
|
3734 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
3735 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
3736 } |
|
3737 |
|
3738 if(extraRow) |
|
3739 { |
|
3740 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
3741 for(j = 0; j < lWidth; j += 2) |
|
3742 { |
|
3743 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3744 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3745 } |
|
3746 if(extraCol) |
|
3747 { |
|
3748 *lRGBFramePtr = *lRGBFramePtr1; |
|
3749 } |
|
3750 } |
|
3751 return; |
|
3752 } |
|
3753 |
|
3754 /* |
|
3755 ****************************************************************************** |
|
3756 Name : sEmz_VDec_YUV420Chr2toColor4k_Ordered_601_5_FR |
|
3757 Description : Converts YUV420 Chroma2 Planar to XRGB (4:4:4:4) Interleaved format |
|
3758 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
3759 uint8 *dstImage : Pointer to rgb data (o/p). |
|
3760 tWndParam *srcWindow : Pointer to structure containing source window |
|
3761 parameters like xOffset,yOffset,cropWidth, |
|
3762 cropHeight. (i/p) |
|
3763 tWndParam *dstWindow : Pointer to structure containing destination window |
|
3764 parameters like xOffset,yOffset,windWidth, |
|
3765 windHeight. (i/p) |
|
3766 Return Value : void |
|
3767 ****************************************************************************** |
|
3768 */ |
|
3769 |
|
3770 void sEmz_VDec_YUV420Chr2toColor4k_Ordered_601_5_FR |
|
3771 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
3772 tWndParam* srcWindow, tWndParam* dstWindow) |
|
3773 { |
|
3774 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
3775 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
3776 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
3777 int32 lY1, lCr, lCb; |
|
3778 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
3779 int32 i, j, extraRow, extraCol; |
|
3780 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
3781 cropWidth,cropHeight,wndWidth,wndHeight; |
|
3782 |
|
3783 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
3784 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
3785 |
|
3786 | {0,15,5} {10,0,15} | |
|
3787 | {15,5,10} {5,10,0} | */ |
|
3788 |
|
3789 srcXOffset = srcWindow->xOffset; |
|
3790 srcYOffset = srcWindow->yOffset; |
|
3791 cropWidth = srcWindow->wndWidth; |
|
3792 cropHeight = srcWindow->wndHeight; |
|
3793 |
|
3794 dstXOffset = dstWindow->xOffset; |
|
3795 dstYOffset = dstWindow->yOffset; |
|
3796 wndWidth = dstWindow->wndWidth; |
|
3797 wndHeight = dstWindow->wndHeight; |
|
3798 |
|
3799 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
3800 { |
|
3801 lWidth = cropWidth; |
|
3802 } |
|
3803 else |
|
3804 { |
|
3805 lWidth = srcImage->width - srcXOffset; |
|
3806 } |
|
3807 |
|
3808 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
3809 { |
|
3810 lHeight = cropHeight; |
|
3811 } |
|
3812 else |
|
3813 { |
|
3814 lHeight = srcImage->height - srcYOffset; |
|
3815 } |
|
3816 |
|
3817 if (lWidth > (wndWidth - dstXOffset)) |
|
3818 { |
|
3819 lWidth = wndWidth - dstXOffset; |
|
3820 } |
|
3821 |
|
3822 if (lHeight > (wndHeight - dstYOffset)) |
|
3823 { |
|
3824 lHeight = wndHeight - dstYOffset; |
|
3825 } |
|
3826 |
|
3827 extraCol = lWidth & 0x01; |
|
3828 extraRow = lHeight & 0x01; |
|
3829 |
|
3830 lTempWidth = lWidth; |
|
3831 lWidth = (lWidth >> 1) << 1; |
|
3832 lHeight = (lHeight >> 1) << 1; |
|
3833 |
|
3834 lLumWidth = (srcImage->width >> 1) << 1; |
|
3835 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
3836 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
3837 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
3838 |
|
3839 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
3840 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
3841 |
|
3842 for(i = 0; i < lHeight; i += 2) |
|
3843 { |
|
3844 for(j = 0; j < lWidth; j += 2) |
|
3845 { |
|
3846 lCr = lCrPtr[j >> 1]; |
|
3847 lCb = lCbPtr[j >> 1]; |
|
3848 |
|
3849 lCr -= 128; |
|
3850 lCb -= 128; |
|
3851 |
|
3852 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
3853 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
3854 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
3855 |
|
3856 /*First Pixel*/ |
|
3857 lY1 = lLumPtr[j]; |
|
3858 |
|
3859 /*B component*/ |
|
3860 lTemp = lY1 + lTemp3; |
|
3861 if (lTemp < 0) |
|
3862 lTemp = 0; |
|
3863 if (lTemp > 255) |
|
3864 lTemp = 255; |
|
3865 lTemp4 = (lTemp >> 4); |
|
3866 |
|
3867 /*G component*/ |
|
3868 lTemp = lY1 - lTemp2 + 15; |
|
3869 if (lTemp < 0) |
|
3870 lTemp = 0; |
|
3871 if (lTemp > 255) |
|
3872 lTemp = 255; |
|
3873 lTemp4 |= (lTemp >> 4) << 4; |
|
3874 |
|
3875 /*R component*/ |
|
3876 lTemp = lY1 + lTemp1 + 5; |
|
3877 if (lTemp < 0) |
|
3878 lTemp = 0; |
|
3879 if (lTemp > 255) |
|
3880 lTemp = 255; |
|
3881 lTemp4 |= (lTemp >> 4) << 8; |
|
3882 |
|
3883 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
3884 |
|
3885 /*Second Pixel*/ |
|
3886 lY1 = lLumPtr[j + 1]; |
|
3887 |
|
3888 /*B component*/ |
|
3889 lTemp = lY1 + lTemp3 + 10; |
|
3890 if (lTemp < 0) |
|
3891 lTemp = 0; |
|
3892 if (lTemp > 255) |
|
3893 lTemp = 255; |
|
3894 lTemp4 = (lTemp >> 4); |
|
3895 |
|
3896 /*G component*/ |
|
3897 lTemp = lY1 - lTemp2; |
|
3898 if (lTemp < 0) |
|
3899 lTemp = 0; |
|
3900 if (lTemp > 255) |
|
3901 lTemp = 255; |
|
3902 lTemp4 |= (lTemp >> 4) << 4; |
|
3903 |
|
3904 /*R component*/ |
|
3905 lTemp = lY1 + lTemp1 + 15; |
|
3906 if (lTemp < 0) |
|
3907 lTemp = 0; |
|
3908 if (lTemp > 255) |
|
3909 lTemp = 255; |
|
3910 lTemp4 |= (lTemp >> 4) << 8; |
|
3911 |
|
3912 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
3913 |
|
3914 |
|
3915 /*Third Pixel*/ |
|
3916 lY1 = lLumPtr[j + lLumWidth]; |
|
3917 |
|
3918 /*B component*/ |
|
3919 lTemp = lY1 + lTemp3 + 15; |
|
3920 if (lTemp < 0) |
|
3921 lTemp = 0; |
|
3922 if (lTemp > 255) |
|
3923 lTemp = 255; |
|
3924 lTemp4 = (lTemp >> 4); |
|
3925 |
|
3926 /*G component*/ |
|
3927 lTemp = lY1 - lTemp2 + 5; |
|
3928 if (lTemp < 0) |
|
3929 lTemp = 0; |
|
3930 if (lTemp > 255) |
|
3931 lTemp = 255; |
|
3932 lTemp4 |= (lTemp >> 4) << 4; |
|
3933 |
|
3934 /*R component*/ |
|
3935 lTemp = lY1 + lTemp1 + 10; |
|
3936 if (lTemp < 0) |
|
3937 lTemp = 0; |
|
3938 if (lTemp > 255) |
|
3939 lTemp = 255; |
|
3940 lTemp4 |= (lTemp >> 4) << 8; |
|
3941 |
|
3942 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
3943 |
|
3944 /*Fourth Pixel*/ |
|
3945 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
3946 |
|
3947 /*B component*/ |
|
3948 lTemp = lY1 + lTemp3 + 5; |
|
3949 if (lTemp < 0) |
|
3950 lTemp = 0; |
|
3951 if (lTemp > 255) |
|
3952 lTemp = 255; |
|
3953 lTemp4 = (lTemp >> 4); |
|
3954 |
|
3955 /*G component*/ |
|
3956 lTemp = lY1 - lTemp2 + 10; |
|
3957 if (lTemp < 0) |
|
3958 lTemp = 0; |
|
3959 if (lTemp > 255) |
|
3960 lTemp = 255; |
|
3961 lTemp4 |= (lTemp >> 4) << 4; |
|
3962 |
|
3963 /*R component*/ |
|
3964 lTemp = lY1 + lTemp1; |
|
3965 if (lTemp < 0) |
|
3966 lTemp = 0; |
|
3967 if (lTemp > 255) |
|
3968 lTemp = 255; |
|
3969 lTemp4 |= (lTemp >> 4) << 8; |
|
3970 |
|
3971 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
3972 |
|
3973 lRGBFramePtr += 2; |
|
3974 lRGBFramePtr1 += 2; |
|
3975 } |
|
3976 if(extraCol) |
|
3977 { |
|
3978 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
3979 lRGBFramePtr++; |
|
3980 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
3981 lRGBFramePtr1++; |
|
3982 } |
|
3983 |
|
3984 lLumPtr += (lLumWidth << 1); |
|
3985 lCrPtr += (lLumWidth >> 1); |
|
3986 lCbPtr += (lLumWidth >> 1); |
|
3987 |
|
3988 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
3989 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
3990 } |
|
3991 |
|
3992 if(extraRow) |
|
3993 { |
|
3994 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
3995 for(j = 0; j < lWidth; j += 2) |
|
3996 { |
|
3997 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3998 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
3999 } |
|
4000 if(extraCol) |
|
4001 { |
|
4002 *lRGBFramePtr = *lRGBFramePtr1; |
|
4003 } |
|
4004 } |
|
4005 return; |
|
4006 } |
|
4007 |
|
4008 /* |
|
4009 ****************************************************************************** |
|
4010 Name : sEmz_VDec_YUV420Chr2toColor4k_Ordered_709_RR |
|
4011 Description : Converts YUV420 Chroma2 Planar to XRGB (4:4:4:4) Interleaved format |
|
4012 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
4013 uint8 *dstImage : Pointer to rgb data (o/p). |
|
4014 tWndParam *srcWindow : Pointer to structure containing source window |
|
4015 parameters like xOffset,yOffset,cropWidth, |
|
4016 cropHeight. (i/p) |
|
4017 tWndParam *dstWindow : Pointer to structure containing destination window |
|
4018 parameters like xOffset,yOffset,windWidth, |
|
4019 windHeight. (i/p) |
|
4020 Return Value : void |
|
4021 ****************************************************************************** |
|
4022 */ |
|
4023 |
|
4024 void sEmz_VDec_YUV420Chr2toColor4k_Ordered_709_RR |
|
4025 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
4026 tWndParam* srcWindow, tWndParam* dstWindow) |
|
4027 { |
|
4028 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
4029 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
4030 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
4031 int32 lY1, lCr, lCb; |
|
4032 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
4033 int32 i, j, extraRow, extraCol; |
|
4034 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
4035 cropWidth,cropHeight,wndWidth,wndHeight; |
|
4036 |
|
4037 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
4038 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
4039 |
|
4040 | {0,15,5} {10,0,15} | |
|
4041 | {15,5,10} {5,10,0} | */ |
|
4042 |
|
4043 srcXOffset = srcWindow->xOffset; |
|
4044 srcYOffset = srcWindow->yOffset; |
|
4045 cropWidth = srcWindow->wndWidth; |
|
4046 cropHeight = srcWindow->wndHeight; |
|
4047 |
|
4048 dstXOffset = dstWindow->xOffset; |
|
4049 dstYOffset = dstWindow->yOffset; |
|
4050 wndWidth = dstWindow->wndWidth; |
|
4051 wndHeight = dstWindow->wndHeight; |
|
4052 |
|
4053 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
4054 { |
|
4055 lWidth = cropWidth; |
|
4056 } |
|
4057 else |
|
4058 { |
|
4059 lWidth = srcImage->width - srcXOffset; |
|
4060 } |
|
4061 |
|
4062 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
4063 { |
|
4064 lHeight = cropHeight; |
|
4065 } |
|
4066 else |
|
4067 { |
|
4068 lHeight = srcImage->height - srcYOffset; |
|
4069 } |
|
4070 |
|
4071 if (lWidth > (wndWidth - dstXOffset)) |
|
4072 { |
|
4073 lWidth = wndWidth - dstXOffset; |
|
4074 } |
|
4075 |
|
4076 if (lHeight > (wndHeight - dstYOffset)) |
|
4077 { |
|
4078 lHeight = wndHeight - dstYOffset; |
|
4079 } |
|
4080 |
|
4081 extraCol = lWidth & 0x01; |
|
4082 extraRow = lHeight & 0x01; |
|
4083 |
|
4084 lTempWidth = lWidth; |
|
4085 lWidth = (lWidth >> 1) << 1; |
|
4086 lHeight = (lHeight >> 1) << 1; |
|
4087 |
|
4088 lLumWidth = (srcImage->width >> 1) << 1; |
|
4089 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
4090 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
4091 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
4092 |
|
4093 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
4094 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
4095 |
|
4096 for(i = 0; i < lHeight; i += 2) |
|
4097 { |
|
4098 for(j = 0; j < lWidth; j += 2) |
|
4099 { |
|
4100 lCr = lCrPtr[j >> 1]; |
|
4101 lCb = lCbPtr[j >> 1]; |
|
4102 |
|
4103 lCr -= 128; |
|
4104 lCb -= 128; |
|
4105 |
|
4106 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
4107 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
4108 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
4109 |
|
4110 /*First Pixel*/ |
|
4111 lY1 = lLumPtr[j]; |
|
4112 lY1 -= 16; |
|
4113 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
4114 |
|
4115 /*B component*/ |
|
4116 lTemp = lY1 + lTemp3; |
|
4117 if (lTemp < 0) |
|
4118 lTemp = 0; |
|
4119 if (lTemp > 255) |
|
4120 lTemp = 255; |
|
4121 lTemp4 = (lTemp >> 4); |
|
4122 |
|
4123 /*G component*/ |
|
4124 lTemp = lY1 - lTemp2 + 15; |
|
4125 if (lTemp < 0) |
|
4126 lTemp = 0; |
|
4127 if (lTemp > 255) |
|
4128 lTemp = 255; |
|
4129 lTemp4 |= (lTemp >> 4) << 4; |
|
4130 |
|
4131 /*R component*/ |
|
4132 lTemp = lY1 + lTemp1 + 5; |
|
4133 if (lTemp < 0) |
|
4134 lTemp = 0; |
|
4135 if (lTemp > 255) |
|
4136 lTemp = 255; |
|
4137 lTemp4 |= (lTemp >> 4) << 8; |
|
4138 |
|
4139 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
4140 |
|
4141 /*Second Pixel*/ |
|
4142 lY1 = lLumPtr[j + 1]; |
|
4143 lY1 -= 16; |
|
4144 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
4145 |
|
4146 /*B component*/ |
|
4147 lTemp = lY1 + lTemp3 + 10; |
|
4148 if (lTemp < 0) |
|
4149 lTemp = 0; |
|
4150 if (lTemp > 255) |
|
4151 lTemp = 255; |
|
4152 lTemp4 = (lTemp >> 4); |
|
4153 |
|
4154 /*G component*/ |
|
4155 lTemp = lY1 - lTemp2; |
|
4156 if (lTemp < 0) |
|
4157 lTemp = 0; |
|
4158 if (lTemp > 255) |
|
4159 lTemp = 255; |
|
4160 lTemp4 |= (lTemp >> 4) << 4; |
|
4161 |
|
4162 /*R component*/ |
|
4163 lTemp = lY1 + lTemp1 + 15; |
|
4164 if (lTemp < 0) |
|
4165 lTemp = 0; |
|
4166 if (lTemp > 255) |
|
4167 lTemp = 255; |
|
4168 lTemp4 |= (lTemp >> 4) << 8; |
|
4169 |
|
4170 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
4171 |
|
4172 |
|
4173 /*Third Pixel*/ |
|
4174 lY1 = lLumPtr[j + lLumWidth]; |
|
4175 lY1 -= 16; |
|
4176 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
4177 |
|
4178 /*B component*/ |
|
4179 lTemp = lY1 + lTemp3 + 15; |
|
4180 if (lTemp < 0) |
|
4181 lTemp = 0; |
|
4182 if (lTemp > 255) |
|
4183 lTemp = 255; |
|
4184 lTemp4 = (lTemp >> 4); |
|
4185 |
|
4186 /*G component*/ |
|
4187 lTemp = lY1 - lTemp2 + 5; |
|
4188 if (lTemp < 0) |
|
4189 lTemp = 0; |
|
4190 if (lTemp > 255) |
|
4191 lTemp = 255; |
|
4192 lTemp4 |= (lTemp >> 4) << 4; |
|
4193 |
|
4194 /*R component*/ |
|
4195 lTemp = lY1 + lTemp1 + 10; |
|
4196 if (lTemp < 0) |
|
4197 lTemp = 0; |
|
4198 if (lTemp > 255) |
|
4199 lTemp = 255; |
|
4200 lTemp4 |= (lTemp >> 4) << 8; |
|
4201 |
|
4202 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
4203 |
|
4204 /*Fourth Pixel*/ |
|
4205 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
4206 lY1 -= 16; |
|
4207 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
4208 |
|
4209 /*B component*/ |
|
4210 lTemp = lY1 + lTemp3 + 5; |
|
4211 if (lTemp < 0) |
|
4212 lTemp = 0; |
|
4213 if (lTemp > 255) |
|
4214 lTemp = 255; |
|
4215 lTemp4 = (lTemp >> 4); |
|
4216 |
|
4217 /*G component*/ |
|
4218 lTemp = lY1 - lTemp2 + 10; |
|
4219 if (lTemp < 0) |
|
4220 lTemp = 0; |
|
4221 if (lTemp > 255) |
|
4222 lTemp = 255; |
|
4223 lTemp4 |= (lTemp >> 4) << 4; |
|
4224 |
|
4225 /*R component*/ |
|
4226 lTemp = lY1 + lTemp1; |
|
4227 if (lTemp < 0) |
|
4228 lTemp = 0; |
|
4229 if (lTemp > 255) |
|
4230 lTemp = 255; |
|
4231 lTemp4 |= (lTemp >> 4) << 8; |
|
4232 |
|
4233 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
4234 |
|
4235 lRGBFramePtr += 2; |
|
4236 lRGBFramePtr1 += 2; |
|
4237 } |
|
4238 if(extraCol) |
|
4239 { |
|
4240 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
4241 lRGBFramePtr++; |
|
4242 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
4243 lRGBFramePtr1++; |
|
4244 } |
|
4245 |
|
4246 lLumPtr += (lLumWidth << 1); |
|
4247 lCrPtr += (lLumWidth >> 1); |
|
4248 lCbPtr += (lLumWidth >> 1); |
|
4249 |
|
4250 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
4251 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
4252 } |
|
4253 |
|
4254 if(extraRow) |
|
4255 { |
|
4256 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
4257 for(j = 0; j < lWidth; j += 2) |
|
4258 { |
|
4259 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
4260 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
4261 } |
|
4262 if(extraCol) |
|
4263 { |
|
4264 *lRGBFramePtr = *lRGBFramePtr1; |
|
4265 } |
|
4266 } |
|
4267 return; |
|
4268 } |
|
4269 |
|
4270 /* |
|
4271 ****************************************************************************** |
|
4272 Name : sEmz_VDec_YUV420Chr2toColor4k_Ordered_601_5_RR |
|
4273 Description : Converts YUV420 Chroma2 Planar to XRGB (4:4:4:4) Interleaved format |
|
4274 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
4275 uint8 *dstImage : Pointer to rgb data (o/p). |
|
4276 tWndParam *srcWindow : Pointer to structure containing source window |
|
4277 parameters like xOffset,yOffset,cropWidth, |
|
4278 cropHeight. (i/p) |
|
4279 tWndParam *dstWindow : Pointer to structure containing destination window |
|
4280 parameters like xOffset,yOffset,windWidth, |
|
4281 windHeight. (i/p) |
|
4282 Return Value : void |
|
4283 ****************************************************************************** |
|
4284 */ |
|
4285 |
|
4286 void sEmz_VDec_YUV420Chr2toColor4k_Ordered_601_5_RR |
|
4287 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
4288 tWndParam* srcWindow, tWndParam* dstWindow) |
|
4289 { |
|
4290 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
4291 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
4292 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
4293 int32 lY1, lCr, lCb; |
|
4294 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
4295 int32 i, j, extraRow, extraCol; |
|
4296 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
4297 cropWidth,cropHeight,wndWidth,wndHeight; |
|
4298 |
|
4299 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
4300 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
4301 |
|
4302 | {0,15,5} {10,0,15} | |
|
4303 | {15,5,10} {5,10,0} | */ |
|
4304 |
|
4305 srcXOffset = srcWindow->xOffset; |
|
4306 srcYOffset = srcWindow->yOffset; |
|
4307 cropWidth = srcWindow->wndWidth; |
|
4308 cropHeight = srcWindow->wndHeight; |
|
4309 |
|
4310 dstXOffset = dstWindow->xOffset; |
|
4311 dstYOffset = dstWindow->yOffset; |
|
4312 wndWidth = dstWindow->wndWidth; |
|
4313 wndHeight = dstWindow->wndHeight; |
|
4314 |
|
4315 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
4316 { |
|
4317 lWidth = cropWidth; |
|
4318 } |
|
4319 else |
|
4320 { |
|
4321 lWidth = srcImage->width - srcXOffset; |
|
4322 } |
|
4323 |
|
4324 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
4325 { |
|
4326 lHeight = cropHeight; |
|
4327 } |
|
4328 else |
|
4329 { |
|
4330 lHeight = srcImage->height - srcYOffset; |
|
4331 } |
|
4332 |
|
4333 if (lWidth > (wndWidth - dstXOffset)) |
|
4334 { |
|
4335 lWidth = wndWidth - dstXOffset; |
|
4336 } |
|
4337 |
|
4338 if (lHeight > (wndHeight - dstYOffset)) |
|
4339 { |
|
4340 lHeight = wndHeight - dstYOffset; |
|
4341 } |
|
4342 |
|
4343 extraCol = lWidth & 0x01; |
|
4344 extraRow = lHeight & 0x01; |
|
4345 |
|
4346 lTempWidth = lWidth; |
|
4347 lWidth = (lWidth >> 1) << 1; |
|
4348 lHeight = (lHeight >> 1) << 1; |
|
4349 |
|
4350 lLumWidth = (srcImage->width >> 1) << 1; |
|
4351 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
4352 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
4353 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
4354 |
|
4355 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
4356 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
4357 |
|
4358 for(i = 0; i < lHeight; i += 2) |
|
4359 { |
|
4360 for(j = 0; j < lWidth; j += 2) |
|
4361 { |
|
4362 lCr = lCrPtr[j >> 1]; |
|
4363 lCb = lCbPtr[j >> 1]; |
|
4364 |
|
4365 lCr -= 128; |
|
4366 lCb -= 128; |
|
4367 |
|
4368 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
4369 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
4370 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
4371 |
|
4372 /*First Pixel*/ |
|
4373 lY1 = lLumPtr[j]; |
|
4374 lY1 -= 16; |
|
4375 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
4376 |
|
4377 /*B component*/ |
|
4378 lTemp = lY1 + lTemp3; |
|
4379 if (lTemp < 0) |
|
4380 lTemp = 0; |
|
4381 if (lTemp > 255) |
|
4382 lTemp = 255; |
|
4383 lTemp4 = (lTemp >> 4); |
|
4384 |
|
4385 /*G component*/ |
|
4386 lTemp = lY1 - lTemp2 + 15; |
|
4387 if (lTemp < 0) |
|
4388 lTemp = 0; |
|
4389 if (lTemp > 255) |
|
4390 lTemp = 255; |
|
4391 lTemp4 |= (lTemp >> 4) << 4; |
|
4392 |
|
4393 /*R component*/ |
|
4394 lTemp = lY1 + lTemp1 + 5; |
|
4395 if (lTemp < 0) |
|
4396 lTemp = 0; |
|
4397 if (lTemp > 255) |
|
4398 lTemp = 255; |
|
4399 lTemp4 |= (lTemp >> 4) << 8; |
|
4400 |
|
4401 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
4402 |
|
4403 /*Second Pixel*/ |
|
4404 lY1 = lLumPtr[j + 1]; |
|
4405 lY1 -= 16; |
|
4406 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
4407 |
|
4408 /*B component*/ |
|
4409 lTemp = lY1 + lTemp3 + 10; |
|
4410 if (lTemp < 0) |
|
4411 lTemp = 0; |
|
4412 if (lTemp > 255) |
|
4413 lTemp = 255; |
|
4414 lTemp4 = (lTemp >> 4); |
|
4415 |
|
4416 /*G component*/ |
|
4417 lTemp = lY1 - lTemp2; |
|
4418 if (lTemp < 0) |
|
4419 lTemp = 0; |
|
4420 if (lTemp > 255) |
|
4421 lTemp = 255; |
|
4422 lTemp4 |= (lTemp >> 4) << 4; |
|
4423 |
|
4424 /*R component*/ |
|
4425 lTemp = lY1 + lTemp1 + 15; |
|
4426 if (lTemp < 0) |
|
4427 lTemp = 0; |
|
4428 if (lTemp > 255) |
|
4429 lTemp = 255; |
|
4430 lTemp4 |= (lTemp >> 4) << 8; |
|
4431 |
|
4432 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
4433 |
|
4434 |
|
4435 /*Third Pixel*/ |
|
4436 lY1 = lLumPtr[j + lLumWidth]; |
|
4437 lY1 -= 16; |
|
4438 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
4439 |
|
4440 /*B component*/ |
|
4441 lTemp = lY1 + lTemp3 + 15; |
|
4442 if (lTemp < 0) |
|
4443 lTemp = 0; |
|
4444 if (lTemp > 255) |
|
4445 lTemp = 255; |
|
4446 lTemp4 = (lTemp >> 4); |
|
4447 |
|
4448 /*G component*/ |
|
4449 lTemp = lY1 - lTemp2 + 5; |
|
4450 if (lTemp < 0) |
|
4451 lTemp = 0; |
|
4452 if (lTemp > 255) |
|
4453 lTemp = 255; |
|
4454 lTemp4 |= (lTemp >> 4) << 4; |
|
4455 |
|
4456 /*R component*/ |
|
4457 lTemp = lY1 + lTemp1 + 10; |
|
4458 if (lTemp < 0) |
|
4459 lTemp = 0; |
|
4460 if (lTemp > 255) |
|
4461 lTemp = 255; |
|
4462 lTemp4 |= (lTemp >> 4) << 8; |
|
4463 |
|
4464 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
4465 |
|
4466 /*Fourth Pixel*/ |
|
4467 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
4468 lY1 -= 16; |
|
4469 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
4470 |
|
4471 /*B component*/ |
|
4472 lTemp = lY1 + lTemp3 + 5; |
|
4473 if (lTemp < 0) |
|
4474 lTemp = 0; |
|
4475 if (lTemp > 255) |
|
4476 lTemp = 255; |
|
4477 lTemp4 = (lTemp >> 4); |
|
4478 |
|
4479 /*G component*/ |
|
4480 lTemp = lY1 - lTemp2 + 10; |
|
4481 if (lTemp < 0) |
|
4482 lTemp = 0; |
|
4483 if (lTemp > 255) |
|
4484 lTemp = 255; |
|
4485 lTemp4 |= (lTemp >> 4) << 4; |
|
4486 |
|
4487 /*R component*/ |
|
4488 lTemp = lY1 + lTemp1; |
|
4489 if (lTemp < 0) |
|
4490 lTemp = 0; |
|
4491 if (lTemp > 255) |
|
4492 lTemp = 255; |
|
4493 lTemp4 |= (lTemp >> 4) << 8; |
|
4494 |
|
4495 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
4496 |
|
4497 lRGBFramePtr += 2; |
|
4498 lRGBFramePtr1 += 2; |
|
4499 } |
|
4500 if(extraCol) |
|
4501 { |
|
4502 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
4503 lRGBFramePtr++; |
|
4504 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
4505 lRGBFramePtr1++; |
|
4506 } |
|
4507 |
|
4508 lLumPtr += (lLumWidth << 1); |
|
4509 lCrPtr += (lLumWidth >> 1); |
|
4510 lCbPtr += (lLumWidth >> 1); |
|
4511 |
|
4512 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
4513 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
4514 } |
|
4515 |
|
4516 if(extraRow) |
|
4517 { |
|
4518 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
4519 for(j = 0; j < lWidth; j += 2) |
|
4520 { |
|
4521 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
4522 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
4523 } |
|
4524 if(extraCol) |
|
4525 { |
|
4526 *lRGBFramePtr = *lRGBFramePtr1; |
|
4527 } |
|
4528 } |
|
4529 return; |
|
4530 } |
|
4531 |
|
4532 |
|
4533 /* |
|
4534 ****************************************************************************** |
|
4535 Name : sEmz_VDec_YUV420Chr2toColor16MU_709_FR |
|
4536 Description : Converts YUV420 Chroma2 Planar to XRGB (8:8:8:8) Interleaved format |
|
4537 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
4538 uint8 *dstImage : Pointer to rgb data (o/p). |
|
4539 tWndParam *srcWindow : Pointer to structure containing source window |
|
4540 parameters like xOffset,yOffset,cropWidth, |
|
4541 cropHeight. (i/p) |
|
4542 tWndParam *dstWindow : Pointer to structure containing destination window |
|
4543 parameters like xOffset,yOffset,windWidth, |
|
4544 windHeight. (i/p) |
|
4545 Return Value : void |
|
4546 ****************************************************************************** |
|
4547 */ |
|
4548 |
|
4549 void sEmz_VDec_YUV420Chr2toColor16MU_709_FR |
|
4550 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
4551 tWndParam* srcWindow, tWndParam* dstWindow) |
|
4552 { |
|
4553 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
4554 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
4555 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
4556 int32 lY1, lCr, lCb; |
|
4557 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
4558 int32 i, j, extraRow, extraCol; |
|
4559 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
4560 cropWidth,cropHeight,wndWidth,wndHeight; |
|
4561 |
|
4562 srcXOffset = srcWindow->xOffset; |
|
4563 srcYOffset = srcWindow->yOffset; |
|
4564 cropWidth = srcWindow->wndWidth; |
|
4565 cropHeight = srcWindow->wndHeight; |
|
4566 |
|
4567 dstXOffset = dstWindow->xOffset; |
|
4568 dstYOffset = dstWindow->yOffset; |
|
4569 wndWidth = dstWindow->wndWidth; |
|
4570 wndHeight = dstWindow->wndHeight; |
|
4571 |
|
4572 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
4573 { |
|
4574 lWidth = cropWidth; |
|
4575 } |
|
4576 else |
|
4577 { |
|
4578 lWidth = srcImage->width - srcXOffset; |
|
4579 } |
|
4580 |
|
4581 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
4582 { |
|
4583 lHeight = cropHeight; |
|
4584 } |
|
4585 else |
|
4586 { |
|
4587 lHeight = srcImage->height - srcYOffset; |
|
4588 } |
|
4589 |
|
4590 if (lWidth > (wndWidth - dstXOffset)) |
|
4591 { |
|
4592 lWidth = wndWidth - dstXOffset; |
|
4593 } |
|
4594 |
|
4595 if (lHeight > (wndHeight - dstYOffset)) |
|
4596 { |
|
4597 lHeight = wndHeight - dstYOffset; |
|
4598 } |
|
4599 |
|
4600 extraCol = lWidth & 0x01; |
|
4601 extraRow = lHeight & 0x01; |
|
4602 |
|
4603 lTempWidth = lWidth; |
|
4604 lWidth = (lWidth >> 1) << 1; |
|
4605 lHeight = (lHeight >> 1) << 1; |
|
4606 |
|
4607 lLumWidth = (srcImage->width >> 1) << 1; |
|
4608 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
4609 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
4610 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
4611 |
|
4612 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
4613 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
4614 |
|
4615 for(i = 0; i < lHeight; i += 2) |
|
4616 { |
|
4617 for(j = 0; j < lWidth; j += 2) |
|
4618 { |
|
4619 lCr = lCrPtr[j >> 1]; |
|
4620 lCb = lCbPtr[j >> 1]; |
|
4621 |
|
4622 lCr -= 128; |
|
4623 lCb -= 128; |
|
4624 |
|
4625 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
4626 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
4627 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
4628 |
|
4629 /*First Pixel*/ |
|
4630 lY1 = lLumPtr[j]; |
|
4631 |
|
4632 /*B component*/ |
|
4633 lTemp = lY1 + lTemp3; |
|
4634 if (lTemp < 0) |
|
4635 lTemp = 0; |
|
4636 if (lTemp > 255) |
|
4637 lTemp = 255; |
|
4638 lTemp4 = (uint8) lTemp; |
|
4639 |
|
4640 /*G component*/ |
|
4641 lTemp = lY1 - lTemp2; |
|
4642 if (lTemp < 0) |
|
4643 lTemp = 0; |
|
4644 if (lTemp > 255) |
|
4645 lTemp = 255; |
|
4646 lTemp4 |= lTemp << 8; |
|
4647 |
|
4648 /*R component*/ |
|
4649 lTemp = lY1 + lTemp1; |
|
4650 if (lTemp < 0) |
|
4651 lTemp = 0; |
|
4652 if (lTemp > 255) |
|
4653 lTemp = 255; |
|
4654 lTemp4 |= lTemp << 16; |
|
4655 |
|
4656 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
4657 |
|
4658 /*Second Pixel*/ |
|
4659 lY1 = lLumPtr[j + 1]; |
|
4660 |
|
4661 /*B component*/ |
|
4662 lTemp = lY1 + lTemp3; |
|
4663 if (lTemp < 0) |
|
4664 lTemp = 0; |
|
4665 if (lTemp > 255) |
|
4666 lTemp = 255; |
|
4667 lTemp4 = (uint8) lTemp; |
|
4668 |
|
4669 /*G component*/ |
|
4670 lTemp = lY1 - lTemp2; |
|
4671 if (lTemp < 0) |
|
4672 lTemp = 0; |
|
4673 if (lTemp > 255) |
|
4674 lTemp = 255; |
|
4675 lTemp4 |= lTemp << 8; |
|
4676 |
|
4677 /*R component*/ |
|
4678 lTemp = lY1 + lTemp1; |
|
4679 if (lTemp < 0) |
|
4680 lTemp = 0; |
|
4681 if (lTemp > 255) |
|
4682 lTemp = 255; |
|
4683 lTemp4 |= lTemp << 16; |
|
4684 |
|
4685 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
4686 |
|
4687 |
|
4688 /*Third Pixel*/ |
|
4689 lY1 = lLumPtr[j + lLumWidth]; |
|
4690 |
|
4691 /*B component*/ |
|
4692 lTemp = lY1 + lTemp3; |
|
4693 if (lTemp < 0) |
|
4694 lTemp = 0; |
|
4695 if (lTemp > 255) |
|
4696 lTemp = 255; |
|
4697 lTemp4 = (uint8) lTemp; |
|
4698 |
|
4699 /*G component*/ |
|
4700 lTemp = lY1 - lTemp2; |
|
4701 if (lTemp < 0) |
|
4702 lTemp = 0; |
|
4703 if (lTemp > 255) |
|
4704 lTemp = 255; |
|
4705 lTemp4 |= lTemp << 8; |
|
4706 |
|
4707 /*R component*/ |
|
4708 lTemp = lY1 + lTemp1; |
|
4709 if (lTemp < 0) |
|
4710 lTemp = 0; |
|
4711 if (lTemp > 255) |
|
4712 lTemp = 255; |
|
4713 lTemp4 |= lTemp << 16; |
|
4714 |
|
4715 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
4716 |
|
4717 /*Fourth Pixel*/ |
|
4718 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
4719 |
|
4720 /*B component*/ |
|
4721 lTemp = lY1 + lTemp3; |
|
4722 if (lTemp < 0) |
|
4723 lTemp = 0; |
|
4724 if (lTemp > 255) |
|
4725 lTemp = 255; |
|
4726 lTemp4 = (uint8) lTemp; |
|
4727 |
|
4728 /*G component*/ |
|
4729 lTemp = lY1 - lTemp2; |
|
4730 if (lTemp < 0) |
|
4731 lTemp = 0; |
|
4732 if (lTemp > 255) |
|
4733 lTemp = 255; |
|
4734 lTemp4 |= lTemp << 8; |
|
4735 |
|
4736 /*R component*/ |
|
4737 lTemp = lY1 + lTemp1; |
|
4738 if (lTemp < 0) |
|
4739 lTemp = 0; |
|
4740 if (lTemp > 255) |
|
4741 lTemp = 255; |
|
4742 lTemp4 |= lTemp << 16; |
|
4743 |
|
4744 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
4745 |
|
4746 lRGBFramePtr += 2; |
|
4747 lRGBFramePtr1 += 2; |
|
4748 } |
|
4749 if(extraCol) |
|
4750 { |
|
4751 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
4752 lRGBFramePtr++; |
|
4753 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
4754 lRGBFramePtr1++; |
|
4755 } |
|
4756 |
|
4757 lLumPtr += (lLumWidth << 1); |
|
4758 lCrPtr += (lLumWidth >> 1); |
|
4759 lCbPtr += (lLumWidth >> 1); |
|
4760 |
|
4761 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
4762 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
4763 } |
|
4764 |
|
4765 if(extraRow) |
|
4766 { |
|
4767 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
4768 for(j = 0; j < lWidth; j += 2) |
|
4769 { |
|
4770 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
4771 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
4772 } |
|
4773 if(extraCol) |
|
4774 { |
|
4775 *lRGBFramePtr = *lRGBFramePtr1; |
|
4776 } |
|
4777 } |
|
4778 return; |
|
4779 } |
|
4780 |
|
4781 /* |
|
4782 ****************************************************************************** |
|
4783 Name : sEmz_VDec_YUV420Chr2toColor16MU_601_5_FR |
|
4784 Description : Converts YUV420 Chroma2 Planar to XRGB (8:8:8:8) Interleaved format |
|
4785 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
4786 uint8 *dstImage : Pointer to rgb data (o/p). |
|
4787 tWndParam *srcWindow : Pointer to structure containing source window |
|
4788 parameters like xOffset,yOffset,cropWidth, |
|
4789 cropHeight. (i/p) |
|
4790 tWndParam *dstWindow : Pointer to structure containing destination window |
|
4791 parameters like xOffset,yOffset,windWidth, |
|
4792 windHeight. (i/p) |
|
4793 Return Value : void |
|
4794 ****************************************************************************** |
|
4795 */ |
|
4796 |
|
4797 void sEmz_VDec_YUV420Chr2toColor16MU_601_5_FR |
|
4798 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
4799 tWndParam* srcWindow, tWndParam* dstWindow) |
|
4800 { |
|
4801 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
4802 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
4803 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
4804 int32 lY1, lCr, lCb; |
|
4805 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
4806 int32 i, j, extraRow, extraCol; |
|
4807 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
4808 cropWidth,cropHeight,wndWidth,wndHeight; |
|
4809 |
|
4810 srcXOffset = srcWindow->xOffset; |
|
4811 srcYOffset = srcWindow->yOffset; |
|
4812 cropWidth = srcWindow->wndWidth; |
|
4813 cropHeight = srcWindow->wndHeight; |
|
4814 |
|
4815 dstXOffset = dstWindow->xOffset; |
|
4816 dstYOffset = dstWindow->yOffset; |
|
4817 wndWidth = dstWindow->wndWidth; |
|
4818 wndHeight = dstWindow->wndHeight; |
|
4819 |
|
4820 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
4821 { |
|
4822 lWidth = cropWidth; |
|
4823 } |
|
4824 else |
|
4825 { |
|
4826 lWidth = srcImage->width - srcXOffset; |
|
4827 } |
|
4828 |
|
4829 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
4830 { |
|
4831 lHeight = cropHeight; |
|
4832 } |
|
4833 else |
|
4834 { |
|
4835 lHeight = srcImage->height - srcYOffset; |
|
4836 } |
|
4837 |
|
4838 if (lWidth > (wndWidth - dstXOffset)) |
|
4839 { |
|
4840 lWidth = wndWidth - dstXOffset; |
|
4841 } |
|
4842 |
|
4843 if (lHeight > (wndHeight - dstYOffset)) |
|
4844 { |
|
4845 lHeight = wndHeight - dstYOffset; |
|
4846 } |
|
4847 |
|
4848 extraCol = lWidth & 0x01; |
|
4849 extraRow = lHeight & 0x01; |
|
4850 |
|
4851 lTempWidth = lWidth; |
|
4852 lWidth = (lWidth >> 1) << 1; |
|
4853 lHeight = (lHeight >> 1) << 1; |
|
4854 |
|
4855 lLumWidth = (srcImage->width >> 1) << 1; |
|
4856 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
4857 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
4858 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
4859 |
|
4860 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
4861 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
4862 |
|
4863 for(i = 0; i < lHeight; i += 2) |
|
4864 { |
|
4865 for(j = 0; j < lWidth; j += 2) |
|
4866 { |
|
4867 lCr = lCrPtr[j >> 1]; |
|
4868 lCb = lCbPtr[j >> 1]; |
|
4869 |
|
4870 lCr -= 128; |
|
4871 lCb -= 128; |
|
4872 |
|
4873 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
4874 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
4875 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
4876 |
|
4877 /*First Pixel*/ |
|
4878 lY1 = lLumPtr[j]; |
|
4879 |
|
4880 /*B component*/ |
|
4881 lTemp = lY1 + lTemp3; |
|
4882 if (lTemp < 0) |
|
4883 lTemp = 0; |
|
4884 if (lTemp > 255) |
|
4885 lTemp = 255; |
|
4886 lTemp4 = (uint8) lTemp; |
|
4887 |
|
4888 /*G component*/ |
|
4889 lTemp = lY1 - lTemp2; |
|
4890 if (lTemp < 0) |
|
4891 lTemp = 0; |
|
4892 if (lTemp > 255) |
|
4893 lTemp = 255; |
|
4894 lTemp4 |= lTemp << 8; |
|
4895 |
|
4896 /*R component*/ |
|
4897 lTemp = lY1 + lTemp1; |
|
4898 if (lTemp < 0) |
|
4899 lTemp = 0; |
|
4900 if (lTemp > 255) |
|
4901 lTemp = 255; |
|
4902 lTemp4 |= lTemp << 16; |
|
4903 |
|
4904 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
4905 |
|
4906 /*Second Pixel*/ |
|
4907 lY1 = lLumPtr[j + 1]; |
|
4908 |
|
4909 /*B component*/ |
|
4910 lTemp = lY1 + lTemp3; |
|
4911 if (lTemp < 0) |
|
4912 lTemp = 0; |
|
4913 if (lTemp > 255) |
|
4914 lTemp = 255; |
|
4915 lTemp4 = (uint8) lTemp; |
|
4916 |
|
4917 /*G component*/ |
|
4918 lTemp = lY1 - lTemp2; |
|
4919 if (lTemp < 0) |
|
4920 lTemp = 0; |
|
4921 if (lTemp > 255) |
|
4922 lTemp = 255; |
|
4923 lTemp4 |= lTemp << 8; |
|
4924 |
|
4925 /*R component*/ |
|
4926 lTemp = lY1 + lTemp1; |
|
4927 if (lTemp < 0) |
|
4928 lTemp = 0; |
|
4929 if (lTemp > 255) |
|
4930 lTemp = 255; |
|
4931 lTemp4 |= lTemp << 16; |
|
4932 |
|
4933 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
4934 |
|
4935 |
|
4936 /*Third Pixel*/ |
|
4937 lY1 = lLumPtr[j + lLumWidth]; |
|
4938 |
|
4939 /*B component*/ |
|
4940 lTemp = lY1 + lTemp3; |
|
4941 if (lTemp < 0) |
|
4942 lTemp = 0; |
|
4943 if (lTemp > 255) |
|
4944 lTemp = 255; |
|
4945 lTemp4 = (uint8) lTemp; |
|
4946 |
|
4947 /*G component*/ |
|
4948 lTemp = lY1 - lTemp2; |
|
4949 if (lTemp < 0) |
|
4950 lTemp = 0; |
|
4951 if (lTemp > 255) |
|
4952 lTemp = 255; |
|
4953 lTemp4 |= lTemp << 8; |
|
4954 |
|
4955 /*R component*/ |
|
4956 lTemp = lY1 + lTemp1; |
|
4957 if (lTemp < 0) |
|
4958 lTemp = 0; |
|
4959 if (lTemp > 255) |
|
4960 lTemp = 255; |
|
4961 lTemp4 |= lTemp << 16; |
|
4962 |
|
4963 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
4964 |
|
4965 /*Fourth Pixel*/ |
|
4966 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
4967 |
|
4968 /*B component*/ |
|
4969 lTemp = lY1 + lTemp3; |
|
4970 if (lTemp < 0) |
|
4971 lTemp = 0; |
|
4972 if (lTemp > 255) |
|
4973 lTemp = 255; |
|
4974 lTemp4 = (uint8) lTemp; |
|
4975 |
|
4976 /*G component*/ |
|
4977 lTemp = lY1 - lTemp2; |
|
4978 if (lTemp < 0) |
|
4979 lTemp = 0; |
|
4980 if (lTemp > 255) |
|
4981 lTemp = 255; |
|
4982 lTemp4 |= lTemp << 8; |
|
4983 |
|
4984 /*R component*/ |
|
4985 lTemp = lY1 + lTemp1; |
|
4986 if (lTemp < 0) |
|
4987 lTemp = 0; |
|
4988 if (lTemp > 255) |
|
4989 lTemp = 255; |
|
4990 lTemp4 |= lTemp << 16; |
|
4991 |
|
4992 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
4993 |
|
4994 lRGBFramePtr += 2; |
|
4995 lRGBFramePtr1 += 2; |
|
4996 } |
|
4997 if(extraCol) |
|
4998 { |
|
4999 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
5000 lRGBFramePtr++; |
|
5001 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
5002 lRGBFramePtr1++; |
|
5003 } |
|
5004 |
|
5005 lLumPtr += (lLumWidth << 1); |
|
5006 lCrPtr += (lLumWidth >> 1); |
|
5007 lCbPtr += (lLumWidth >> 1); |
|
5008 |
|
5009 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
5010 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
5011 } |
|
5012 |
|
5013 if(extraRow) |
|
5014 { |
|
5015 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
5016 for(j = 0; j < lWidth; j += 2) |
|
5017 { |
|
5018 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
5019 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
5020 } |
|
5021 if(extraCol) |
|
5022 { |
|
5023 *lRGBFramePtr = *lRGBFramePtr1; |
|
5024 } |
|
5025 } |
|
5026 return; |
|
5027 } |
|
5028 |
|
5029 /* |
|
5030 ****************************************************************************** |
|
5031 Name : sEmz_VDec_YUV420Chr2toColor16MU_709_RR |
|
5032 Description : Converts YUV420 Chroma2 Planar to XRGB (8:8:8:8) Interleaved format |
|
5033 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
5034 uint8 *dstImage : Pointer to rgb data (o/p). |
|
5035 tWndParam *srcWindow : Pointer to structure containing source window |
|
5036 parameters like xOffset,yOffset,cropWidth, |
|
5037 cropHeight. (i/p) |
|
5038 tWndParam *dstWindow : Pointer to structure containing destination window |
|
5039 parameters like xOffset,yOffset,windWidth, |
|
5040 windHeight. (i/p) |
|
5041 Return Value : void |
|
5042 ****************************************************************************** |
|
5043 */ |
|
5044 |
|
5045 void sEmz_VDec_YUV420Chr2toColor16MU_709_RR |
|
5046 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
5047 tWndParam* srcWindow, tWndParam* dstWindow) |
|
5048 { |
|
5049 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
5050 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
5051 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
5052 int32 lY1, lCr, lCb; |
|
5053 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
5054 int32 i, j, extraRow, extraCol; |
|
5055 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
5056 cropWidth,cropHeight,wndWidth,wndHeight; |
|
5057 |
|
5058 srcXOffset = srcWindow->xOffset; |
|
5059 srcYOffset = srcWindow->yOffset; |
|
5060 cropWidth = srcWindow->wndWidth; |
|
5061 cropHeight = srcWindow->wndHeight; |
|
5062 |
|
5063 dstXOffset = dstWindow->xOffset; |
|
5064 dstYOffset = dstWindow->yOffset; |
|
5065 wndWidth = dstWindow->wndWidth; |
|
5066 wndHeight = dstWindow->wndHeight; |
|
5067 |
|
5068 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
5069 { |
|
5070 lWidth = cropWidth; |
|
5071 } |
|
5072 else |
|
5073 { |
|
5074 lWidth = srcImage->width - srcXOffset; |
|
5075 } |
|
5076 |
|
5077 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
5078 { |
|
5079 lHeight = cropHeight; |
|
5080 } |
|
5081 else |
|
5082 { |
|
5083 lHeight = srcImage->height - srcYOffset; |
|
5084 } |
|
5085 |
|
5086 if (lWidth > (wndWidth - dstXOffset)) |
|
5087 { |
|
5088 lWidth = wndWidth - dstXOffset; |
|
5089 } |
|
5090 |
|
5091 if (lHeight > (wndHeight - dstYOffset)) |
|
5092 { |
|
5093 lHeight = wndHeight - dstYOffset; |
|
5094 } |
|
5095 |
|
5096 extraCol = lWidth & 0x01; |
|
5097 extraRow = lHeight & 0x01; |
|
5098 |
|
5099 lTempWidth = lWidth; |
|
5100 lWidth = (lWidth >> 1) << 1; |
|
5101 lHeight = (lHeight >> 1) << 1; |
|
5102 |
|
5103 lLumWidth = (srcImage->width >> 1) << 1; |
|
5104 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
5105 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
5106 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
5107 |
|
5108 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
5109 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
5110 |
|
5111 for(i = 0; i < lHeight; i += 2) |
|
5112 { |
|
5113 for(j = 0; j < lWidth; j += 2) |
|
5114 { |
|
5115 lCr = lCrPtr[j >> 1]; |
|
5116 lCb = lCbPtr[j >> 1]; |
|
5117 |
|
5118 lCr -= 128; |
|
5119 lCb -= 128; |
|
5120 |
|
5121 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
5122 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
5123 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
5124 |
|
5125 /*First Pixel*/ |
|
5126 lY1 = lLumPtr[j]; |
|
5127 lY1 -= 16; |
|
5128 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
5129 |
|
5130 /*B component*/ |
|
5131 lTemp = lY1 + lTemp3; |
|
5132 if (lTemp < 0) |
|
5133 lTemp = 0; |
|
5134 if (lTemp > 255) |
|
5135 lTemp = 255; |
|
5136 lTemp4 = (uint8) lTemp; |
|
5137 |
|
5138 /*G component*/ |
|
5139 lTemp = lY1 - lTemp2; |
|
5140 if (lTemp < 0) |
|
5141 lTemp = 0; |
|
5142 if (lTemp > 255) |
|
5143 lTemp = 255; |
|
5144 lTemp4 |= lTemp << 8; |
|
5145 |
|
5146 /*R component*/ |
|
5147 lTemp = lY1 + lTemp1; |
|
5148 if (lTemp < 0) |
|
5149 lTemp = 0; |
|
5150 if (lTemp > 255) |
|
5151 lTemp = 255; |
|
5152 lTemp4 |= lTemp << 16; |
|
5153 |
|
5154 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
5155 |
|
5156 /*Second Pixel*/ |
|
5157 lY1 = lLumPtr[j + 1]; |
|
5158 lY1 -= 16; |
|
5159 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
5160 |
|
5161 /*B component*/ |
|
5162 lTemp = lY1 + lTemp3; |
|
5163 if (lTemp < 0) |
|
5164 lTemp = 0; |
|
5165 if (lTemp > 255) |
|
5166 lTemp = 255; |
|
5167 lTemp4 = (uint8) lTemp; |
|
5168 |
|
5169 /*G component*/ |
|
5170 lTemp = lY1 - lTemp2; |
|
5171 if (lTemp < 0) |
|
5172 lTemp = 0; |
|
5173 if (lTemp > 255) |
|
5174 lTemp = 255; |
|
5175 lTemp4 |= lTemp << 8; |
|
5176 |
|
5177 /*R component*/ |
|
5178 lTemp = lY1 + lTemp1; |
|
5179 if (lTemp < 0) |
|
5180 lTemp = 0; |
|
5181 if (lTemp > 255) |
|
5182 lTemp = 255; |
|
5183 lTemp4 |= lTemp << 16; |
|
5184 |
|
5185 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
5186 |
|
5187 |
|
5188 /*Third Pixel*/ |
|
5189 lY1 = lLumPtr[j + lLumWidth]; |
|
5190 lY1 -= 16; |
|
5191 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
5192 |
|
5193 /*B component*/ |
|
5194 lTemp = lY1 + lTemp3; |
|
5195 if (lTemp < 0) |
|
5196 lTemp = 0; |
|
5197 if (lTemp > 255) |
|
5198 lTemp = 255; |
|
5199 lTemp4 = (uint8) lTemp; |
|
5200 |
|
5201 /*G component*/ |
|
5202 lTemp = lY1 - lTemp2; |
|
5203 if (lTemp < 0) |
|
5204 lTemp = 0; |
|
5205 if (lTemp > 255) |
|
5206 lTemp = 255; |
|
5207 lTemp4 |= lTemp << 8; |
|
5208 |
|
5209 /*R component*/ |
|
5210 lTemp = lY1 + lTemp1; |
|
5211 if (lTemp < 0) |
|
5212 lTemp = 0; |
|
5213 if (lTemp > 255) |
|
5214 lTemp = 255; |
|
5215 lTemp4 |= lTemp << 16; |
|
5216 |
|
5217 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
5218 |
|
5219 /*Fourth Pixel*/ |
|
5220 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
5221 lY1 -= 16; |
|
5222 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
5223 |
|
5224 /*B component*/ |
|
5225 lTemp = lY1 + lTemp3; |
|
5226 if (lTemp < 0) |
|
5227 lTemp = 0; |
|
5228 if (lTemp > 255) |
|
5229 lTemp = 255; |
|
5230 lTemp4 = (uint8) lTemp; |
|
5231 |
|
5232 /*G component*/ |
|
5233 lTemp = lY1 - lTemp2; |
|
5234 if (lTemp < 0) |
|
5235 lTemp = 0; |
|
5236 if (lTemp > 255) |
|
5237 lTemp = 255; |
|
5238 lTemp4 |= lTemp << 8; |
|
5239 |
|
5240 /*R component*/ |
|
5241 lTemp = lY1 + lTemp1; |
|
5242 if (lTemp < 0) |
|
5243 lTemp = 0; |
|
5244 if (lTemp > 255) |
|
5245 lTemp = 255; |
|
5246 lTemp4 |= lTemp << 16; |
|
5247 |
|
5248 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
5249 |
|
5250 lRGBFramePtr += 2; |
|
5251 lRGBFramePtr1 += 2; |
|
5252 } |
|
5253 if(extraCol) |
|
5254 { |
|
5255 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
5256 lRGBFramePtr++; |
|
5257 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
5258 lRGBFramePtr1++; |
|
5259 } |
|
5260 |
|
5261 lLumPtr += (lLumWidth << 1); |
|
5262 lCrPtr += (lLumWidth >> 1); |
|
5263 lCbPtr += (lLumWidth >> 1); |
|
5264 |
|
5265 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
5266 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
5267 } |
|
5268 |
|
5269 if(extraRow) |
|
5270 { |
|
5271 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
5272 for(j = 0; j < lWidth; j += 2) |
|
5273 { |
|
5274 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
5275 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
5276 } |
|
5277 if(extraCol) |
|
5278 { |
|
5279 *lRGBFramePtr = *lRGBFramePtr1; |
|
5280 } |
|
5281 } |
|
5282 return; |
|
5283 } |
|
5284 |
|
5285 /* |
|
5286 ****************************************************************************** |
|
5287 Name : sEmz_VDec_YUV420Chr2toColor16MU_601_5_RR |
|
5288 Description : Converts YUV420 Chroma2 Planar to XRGB (8:8:8:8) Interleaved format |
|
5289 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
5290 uint8 *dstImage : Pointer to rgb data (o/p). |
|
5291 tWndParam *srcWindow : Pointer to structure containing source window |
|
5292 parameters like xOffset,yOffset,cropWidth, |
|
5293 cropHeight. (i/p) |
|
5294 tWndParam *dstWindow : Pointer to structure containing destination window |
|
5295 parameters like xOffset,yOffset,windWidth, |
|
5296 windHeight. (i/p) |
|
5297 Return Value : void |
|
5298 ****************************************************************************** |
|
5299 */ |
|
5300 |
|
5301 void sEmz_VDec_YUV420Chr2toColor16MU_601_5_RR |
|
5302 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
5303 tWndParam* srcWindow, tWndParam* dstWindow) |
|
5304 { |
|
5305 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
5306 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
5307 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
5308 int32 lY1, lCr, lCb; |
|
5309 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
5310 int32 i, j, extraRow, extraCol; |
|
5311 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
5312 cropWidth,cropHeight,wndWidth,wndHeight; |
|
5313 |
|
5314 srcXOffset = srcWindow->xOffset; |
|
5315 srcYOffset = srcWindow->yOffset; |
|
5316 cropWidth = srcWindow->wndWidth; |
|
5317 cropHeight = srcWindow->wndHeight; |
|
5318 |
|
5319 dstXOffset = dstWindow->xOffset; |
|
5320 dstYOffset = dstWindow->yOffset; |
|
5321 wndWidth = dstWindow->wndWidth; |
|
5322 wndHeight = dstWindow->wndHeight; |
|
5323 |
|
5324 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
5325 { |
|
5326 lWidth = cropWidth; |
|
5327 } |
|
5328 else |
|
5329 { |
|
5330 lWidth = srcImage->width - srcXOffset; |
|
5331 } |
|
5332 |
|
5333 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
5334 { |
|
5335 lHeight = cropHeight; |
|
5336 } |
|
5337 else |
|
5338 { |
|
5339 lHeight = srcImage->height - srcYOffset; |
|
5340 } |
|
5341 |
|
5342 if (lWidth > (wndWidth - dstXOffset)) |
|
5343 { |
|
5344 lWidth = wndWidth - dstXOffset; |
|
5345 } |
|
5346 |
|
5347 if (lHeight > (wndHeight - dstYOffset)) |
|
5348 { |
|
5349 lHeight = wndHeight - dstYOffset; |
|
5350 } |
|
5351 |
|
5352 extraCol = lWidth & 0x01; |
|
5353 extraRow = lHeight & 0x01; |
|
5354 |
|
5355 lTempWidth = lWidth; |
|
5356 lWidth = (lWidth >> 1) << 1; |
|
5357 lHeight = (lHeight >> 1) << 1; |
|
5358 |
|
5359 lLumWidth = (srcImage->width >> 1) << 1; |
|
5360 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
5361 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
5362 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
5363 |
|
5364 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
5365 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
5366 |
|
5367 for(i = 0; i < lHeight; i += 2) |
|
5368 { |
|
5369 for(j = 0; j < lWidth; j += 2) |
|
5370 { |
|
5371 lCr = lCrPtr[j >> 1]; |
|
5372 lCb = lCbPtr[j >> 1]; |
|
5373 |
|
5374 lCr -= 128; |
|
5375 lCb -= 128; |
|
5376 |
|
5377 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
5378 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
5379 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
5380 |
|
5381 /*First Pixel*/ |
|
5382 lY1 = lLumPtr[j]; |
|
5383 lY1 -= 16; |
|
5384 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
5385 |
|
5386 /*B component*/ |
|
5387 lTemp = lY1 + lTemp3; |
|
5388 if (lTemp < 0) |
|
5389 lTemp = 0; |
|
5390 if (lTemp > 255) |
|
5391 lTemp = 255; |
|
5392 lTemp4 = (uint8) lTemp; |
|
5393 |
|
5394 /*G component*/ |
|
5395 lTemp = lY1 - lTemp2; |
|
5396 if (lTemp < 0) |
|
5397 lTemp = 0; |
|
5398 if (lTemp > 255) |
|
5399 lTemp = 255; |
|
5400 lTemp4 |= lTemp << 8; |
|
5401 |
|
5402 /*R component*/ |
|
5403 lTemp = lY1 + lTemp1; |
|
5404 if (lTemp < 0) |
|
5405 lTemp = 0; |
|
5406 if (lTemp > 255) |
|
5407 lTemp = 255; |
|
5408 lTemp4 |= lTemp << 16; |
|
5409 |
|
5410 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
5411 |
|
5412 /*Second Pixel*/ |
|
5413 lY1 = lLumPtr[j + 1]; |
|
5414 lY1 -= 16; |
|
5415 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
5416 |
|
5417 /*B component*/ |
|
5418 lTemp = lY1 + lTemp3; |
|
5419 if (lTemp < 0) |
|
5420 lTemp = 0; |
|
5421 if (lTemp > 255) |
|
5422 lTemp = 255; |
|
5423 lTemp4 = (uint8) lTemp; |
|
5424 |
|
5425 /*G component*/ |
|
5426 lTemp = lY1 - lTemp2; |
|
5427 if (lTemp < 0) |
|
5428 lTemp = 0; |
|
5429 if (lTemp > 255) |
|
5430 lTemp = 255; |
|
5431 lTemp4 |= lTemp << 8; |
|
5432 |
|
5433 /*R component*/ |
|
5434 lTemp = lY1 + lTemp1; |
|
5435 if (lTemp < 0) |
|
5436 lTemp = 0; |
|
5437 if (lTemp > 255) |
|
5438 lTemp = 255; |
|
5439 lTemp4 |= lTemp << 16; |
|
5440 |
|
5441 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
5442 |
|
5443 |
|
5444 /*Third Pixel*/ |
|
5445 lY1 = lLumPtr[j + lLumWidth]; |
|
5446 lY1 -= 16; |
|
5447 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
5448 |
|
5449 /*B component*/ |
|
5450 lTemp = lY1 + lTemp3; |
|
5451 if (lTemp < 0) |
|
5452 lTemp = 0; |
|
5453 if (lTemp > 255) |
|
5454 lTemp = 255; |
|
5455 lTemp4 = (uint8) lTemp; |
|
5456 |
|
5457 /*G component*/ |
|
5458 lTemp = lY1 - lTemp2; |
|
5459 if (lTemp < 0) |
|
5460 lTemp = 0; |
|
5461 if (lTemp > 255) |
|
5462 lTemp = 255; |
|
5463 lTemp4 |= lTemp << 8; |
|
5464 |
|
5465 /*R component*/ |
|
5466 lTemp = lY1 + lTemp1; |
|
5467 if (lTemp < 0) |
|
5468 lTemp = 0; |
|
5469 if (lTemp > 255) |
|
5470 lTemp = 255; |
|
5471 lTemp4 |= lTemp << 16; |
|
5472 |
|
5473 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
5474 |
|
5475 /*Fourth Pixel*/ |
|
5476 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
5477 lY1 -= 16; |
|
5478 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
5479 |
|
5480 /*B component*/ |
|
5481 lTemp = lY1 + lTemp3; |
|
5482 if (lTemp < 0) |
|
5483 lTemp = 0; |
|
5484 if (lTemp > 255) |
|
5485 lTemp = 255; |
|
5486 lTemp4 = (uint8) lTemp; |
|
5487 |
|
5488 /*G component*/ |
|
5489 lTemp = lY1 - lTemp2; |
|
5490 if (lTemp < 0) |
|
5491 lTemp = 0; |
|
5492 if (lTemp > 255) |
|
5493 lTemp = 255; |
|
5494 lTemp4 |= lTemp << 8; |
|
5495 |
|
5496 /*R component*/ |
|
5497 lTemp = lY1 + lTemp1; |
|
5498 if (lTemp < 0) |
|
5499 lTemp = 0; |
|
5500 if (lTemp > 255) |
|
5501 lTemp = 255; |
|
5502 lTemp4 |= lTemp << 16; |
|
5503 |
|
5504 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
5505 |
|
5506 lRGBFramePtr += 2; |
|
5507 lRGBFramePtr1 += 2; |
|
5508 } |
|
5509 if(extraCol) |
|
5510 { |
|
5511 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
5512 lRGBFramePtr++; |
|
5513 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
5514 lRGBFramePtr1++; |
|
5515 } |
|
5516 |
|
5517 lLumPtr += (lLumWidth << 1); |
|
5518 lCrPtr += (lLumWidth >> 1); |
|
5519 lCbPtr += (lLumWidth >> 1); |
|
5520 |
|
5521 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
5522 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
5523 } |
|
5524 |
|
5525 if(extraRow) |
|
5526 { |
|
5527 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
5528 for(j = 0; j < lWidth; j += 2) |
|
5529 { |
|
5530 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
5531 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
5532 } |
|
5533 if(extraCol) |
|
5534 { |
|
5535 *lRGBFramePtr = *lRGBFramePtr1; |
|
5536 } |
|
5537 } |
|
5538 return; |
|
5539 } |
|
5540 |
|
5541 /**** End of YUV420 input *****/ |
|
5542 |
|
5543 |
|
5544 |
|
5545 /**** Start of YUV422BE input *****/ |
|
5546 /* |
|
5547 ****************************************************************************** |
|
5548 Name : sEmz_VDec_YUV422BEChr2toColor64k_Ordered_709_FR |
|
5549 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
5550 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
5551 uint8 *dstImage : Pointer to rgb data (o/p). |
|
5552 tWndParam *srcWindow : Pointer to structure containing source window |
|
5553 parameters like xOffset,yOffset,cropWidth, |
|
5554 cropHeight. (i/p) |
|
5555 tWndParam *dstWindow : Pointer to structure containing destination window |
|
5556 parameters like xOffset,yOffset,windWidth, |
|
5557 windHeight. (i/p) |
|
5558 Return Value : void |
|
5559 ****************************************************************************** |
|
5560 */ |
|
5561 |
|
5562 void sEmz_VDec_YUV422BEChr2toColor64k_Ordered_709_FR |
|
5563 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
5564 tWndParam* srcWindow, tWndParam* dstWindow) |
|
5565 { |
|
5566 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
5567 uint8 *lYuyvPtr; |
|
5568 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
5569 int32 lY1, lCr, lCb; |
|
5570 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
5571 int32 i, j, extraCol, extraRow; |
|
5572 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
5573 cropWidth,cropHeight,wndWidth,wndHeight; |
|
5574 |
|
5575 srcXOffset = srcWindow->xOffset; |
|
5576 srcYOffset = srcWindow->yOffset; |
|
5577 cropWidth = srcWindow->wndWidth; |
|
5578 cropHeight = srcWindow->wndHeight; |
|
5579 |
|
5580 dstXOffset = dstWindow->xOffset; |
|
5581 dstYOffset = dstWindow->yOffset; |
|
5582 wndWidth = dstWindow->wndWidth; |
|
5583 wndHeight = dstWindow->wndHeight; |
|
5584 |
|
5585 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
5586 { |
|
5587 lWidth = cropWidth; |
|
5588 } |
|
5589 else |
|
5590 { |
|
5591 lWidth = srcImage->width - srcXOffset; |
|
5592 } |
|
5593 |
|
5594 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
5595 { |
|
5596 lHeight = cropHeight; |
|
5597 } |
|
5598 else |
|
5599 { |
|
5600 lHeight = srcImage->height - srcYOffset; |
|
5601 } |
|
5602 |
|
5603 if (lWidth > (wndWidth - dstXOffset)) |
|
5604 { |
|
5605 lWidth = wndWidth - dstXOffset; |
|
5606 } |
|
5607 |
|
5608 if (lHeight > (wndHeight - dstYOffset)) |
|
5609 { |
|
5610 lHeight = wndHeight - dstYOffset; |
|
5611 } |
|
5612 |
|
5613 extraCol = lWidth & 0x01; |
|
5614 extraRow = lHeight & 0x01; |
|
5615 |
|
5616 lTempWidth = lWidth; |
|
5617 lWidth = (lWidth >> 1) << 1; |
|
5618 lHeight = (lHeight >> 1) << 1; |
|
5619 |
|
5620 lLumWidth = (srcImage->width >> 1) << 1; |
|
5621 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
5622 |
|
5623 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
5624 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
5625 |
|
5626 lLumWidth <<= 1; |
|
5627 |
|
5628 for(i = 0; i < lHeight; i += 2) |
|
5629 { |
|
5630 for(j = 0; j < lWidth; j += 2) |
|
5631 { |
|
5632 lCb = lYuyvPtr[0]; |
|
5633 lCr = lYuyvPtr[2]; |
|
5634 |
|
5635 lCr -= 128; |
|
5636 lCb -= 128; |
|
5637 |
|
5638 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
5639 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
5640 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
5641 |
|
5642 /*First Pixel*/ |
|
5643 lY1 = lYuyvPtr[1]; |
|
5644 |
|
5645 /*B component*/ |
|
5646 lTemp = lY1 + lTemp3; |
|
5647 if (lTemp < 0) |
|
5648 lTemp = 0; |
|
5649 if (lTemp > 255) |
|
5650 lTemp = 255; |
|
5651 lTemp4 = (lTemp >> 3); |
|
5652 |
|
5653 /*G component*/ |
|
5654 lTemp = lY1 - lTemp2 + 3; |
|
5655 if (lTemp < 0) |
|
5656 lTemp = 0; |
|
5657 if (lTemp > 255) |
|
5658 lTemp = 255; |
|
5659 lTemp4 |= (lTemp >> 2) << 5; |
|
5660 |
|
5661 /*R component*/ |
|
5662 lTemp = lY1 + lTemp1 + 2; |
|
5663 if (lTemp < 0) |
|
5664 lTemp = 0; |
|
5665 if (lTemp > 255) |
|
5666 lTemp = 255; |
|
5667 lTemp4 |= (lTemp >> 3) << 11; |
|
5668 |
|
5669 lRGBFramePtr[0] = (uint16)lTemp4; |
|
5670 |
|
5671 /*Second Pixel*/ |
|
5672 lY1 = lYuyvPtr[3]; |
|
5673 |
|
5674 /*B component*/ |
|
5675 lTemp = lY1 + lTemp3 + 4; |
|
5676 if (lTemp < 0) |
|
5677 lTemp = 0; |
|
5678 if (lTemp > 255) |
|
5679 lTemp = 255; |
|
5680 lTemp4 = (lTemp >> 3); |
|
5681 |
|
5682 /*G component*/ |
|
5683 lTemp = lY1 - lTemp2; |
|
5684 if (lTemp < 0) |
|
5685 lTemp = 0; |
|
5686 if (lTemp > 255) |
|
5687 lTemp = 255; |
|
5688 lTemp4 |= (lTemp >> 2) << 5; |
|
5689 |
|
5690 /*R component*/ |
|
5691 lTemp = lY1 + lTemp1 + 6; |
|
5692 if (lTemp < 0) |
|
5693 lTemp = 0; |
|
5694 if (lTemp > 255) |
|
5695 lTemp = 255; |
|
5696 lTemp4 |= (lTemp >> 3) << 11; |
|
5697 |
|
5698 lRGBFramePtr[1] = (uint16)lTemp4; |
|
5699 |
|
5700 |
|
5701 lCb = lYuyvPtr[lLumWidth]; |
|
5702 lCr = lYuyvPtr[lLumWidth + 2]; |
|
5703 |
|
5704 lCr -= 128; |
|
5705 lCb -= 128; |
|
5706 |
|
5707 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
5708 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
5709 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
5710 |
|
5711 /*Third Pixel*/ |
|
5712 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
5713 |
|
5714 /*B component*/ |
|
5715 lTemp = lY1 + lTemp3 + 6; |
|
5716 if (lTemp < 0) |
|
5717 lTemp = 0; |
|
5718 if (lTemp > 255) |
|
5719 lTemp = 255; |
|
5720 lTemp4 = (lTemp >> 3); |
|
5721 |
|
5722 /*G component*/ |
|
5723 lTemp = lY1 - lTemp2 + 1; |
|
5724 if (lTemp < 0) |
|
5725 lTemp = 0; |
|
5726 if (lTemp > 255) |
|
5727 lTemp = 255; |
|
5728 lTemp4 |= (lTemp >> 2) << 5; |
|
5729 |
|
5730 /*R component*/ |
|
5731 lTemp = lY1 + lTemp1 + 4; |
|
5732 if (lTemp < 0) |
|
5733 lTemp = 0; |
|
5734 if (lTemp > 255) |
|
5735 lTemp = 255; |
|
5736 lTemp4 |= (lTemp >> 3) << 11; |
|
5737 |
|
5738 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
5739 |
|
5740 /*Fourth Pixel*/ |
|
5741 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
5742 |
|
5743 /*B component*/ |
|
5744 lTemp = lY1 + lTemp3 + 2; |
|
5745 if (lTemp < 0) |
|
5746 lTemp = 0; |
|
5747 if (lTemp > 255) |
|
5748 lTemp = 255; |
|
5749 lTemp4 = (lTemp >> 3); |
|
5750 |
|
5751 /*G component*/ |
|
5752 lTemp = lY1 - lTemp2 + 2; |
|
5753 if (lTemp < 0) |
|
5754 lTemp = 0; |
|
5755 if (lTemp > 255) |
|
5756 lTemp = 255; |
|
5757 lTemp4 |= (lTemp >> 2) << 5; |
|
5758 |
|
5759 /*R component*/ |
|
5760 lTemp = lY1 + lTemp1; |
|
5761 if (lTemp < 0) |
|
5762 lTemp = 0; |
|
5763 if (lTemp > 255) |
|
5764 lTemp = 255; |
|
5765 lTemp4 |= (lTemp >> 3) << 11; |
|
5766 |
|
5767 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
5768 |
|
5769 lYuyvPtr += 4; |
|
5770 lRGBFramePtr += 2; |
|
5771 lRGBFramePtr1 += 2; |
|
5772 } |
|
5773 if(extraCol) |
|
5774 { |
|
5775 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
5776 lRGBFramePtr++; |
|
5777 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
5778 lRGBFramePtr1++; |
|
5779 } |
|
5780 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
5781 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
5782 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
5783 } |
|
5784 |
|
5785 if(extraRow) |
|
5786 { |
|
5787 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
5788 for(j = 0; j < lWidth; j += 2) |
|
5789 { |
|
5790 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
5791 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
5792 } |
|
5793 if(extraCol) |
|
5794 { |
|
5795 *lRGBFramePtr = *lRGBFramePtr1; |
|
5796 } |
|
5797 } |
|
5798 return; |
|
5799 } |
|
5800 |
|
5801 /* |
|
5802 ****************************************************************************** |
|
5803 Name : sEmz_VDec_YUV422BEChr2toColor64k_Ordered_601_5_FR |
|
5804 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
5805 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
5806 uint8 *dstImage : Pointer to rgb data (o/p). |
|
5807 tWndParam *srcWindow : Pointer to structure containing source window |
|
5808 parameters like xOffset,yOffset,cropWidth, |
|
5809 cropHeight. (i/p) |
|
5810 tWndParam *dstWindow : Pointer to structure containing destination window |
|
5811 parameters like xOffset,yOffset,windWidth, |
|
5812 windHeight. (i/p) |
|
5813 Return Value : void |
|
5814 ****************************************************************************** |
|
5815 */ |
|
5816 |
|
5817 void sEmz_VDec_YUV422BEChr2toColor64k_Ordered_601_5_FR |
|
5818 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
5819 tWndParam* srcWindow, tWndParam* dstWindow) |
|
5820 { |
|
5821 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
5822 uint8 *lYuyvPtr; |
|
5823 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
5824 int32 lY1, lCr, lCb; |
|
5825 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
5826 int32 i, j, extraCol, extraRow; |
|
5827 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
5828 cropWidth,cropHeight,wndWidth,wndHeight; |
|
5829 |
|
5830 srcXOffset = srcWindow->xOffset; |
|
5831 srcYOffset = srcWindow->yOffset; |
|
5832 cropWidth = srcWindow->wndWidth; |
|
5833 cropHeight = srcWindow->wndHeight; |
|
5834 |
|
5835 dstXOffset = dstWindow->xOffset; |
|
5836 dstYOffset = dstWindow->yOffset; |
|
5837 wndWidth = dstWindow->wndWidth; |
|
5838 wndHeight = dstWindow->wndHeight; |
|
5839 |
|
5840 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
5841 { |
|
5842 lWidth = cropWidth; |
|
5843 } |
|
5844 else |
|
5845 { |
|
5846 lWidth = srcImage->width - srcXOffset; |
|
5847 } |
|
5848 |
|
5849 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
5850 { |
|
5851 lHeight = cropHeight; |
|
5852 } |
|
5853 else |
|
5854 { |
|
5855 lHeight = srcImage->height - srcYOffset; |
|
5856 } |
|
5857 |
|
5858 if (lWidth > (wndWidth - dstXOffset)) |
|
5859 { |
|
5860 lWidth = wndWidth - dstXOffset; |
|
5861 } |
|
5862 |
|
5863 if (lHeight > (wndHeight - dstYOffset)) |
|
5864 { |
|
5865 lHeight = wndHeight - dstYOffset; |
|
5866 } |
|
5867 |
|
5868 extraCol = lWidth & 0x01; |
|
5869 extraRow = lHeight & 0x01; |
|
5870 |
|
5871 lTempWidth = lWidth; |
|
5872 lWidth = (lWidth >> 1) << 1; |
|
5873 lHeight = (lHeight >> 1) << 1; |
|
5874 |
|
5875 lLumWidth = (srcImage->width >> 1) << 1; |
|
5876 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
5877 |
|
5878 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
5879 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
5880 |
|
5881 lLumWidth <<= 1; |
|
5882 |
|
5883 for(i = 0; i < lHeight; i += 2) |
|
5884 { |
|
5885 for(j = 0; j < lWidth; j += 2) |
|
5886 { |
|
5887 lCb = lYuyvPtr[0]; |
|
5888 lCr = lYuyvPtr[2]; |
|
5889 |
|
5890 lCr -= 128; |
|
5891 lCb -= 128; |
|
5892 |
|
5893 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
5894 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
5895 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
5896 |
|
5897 /*First Pixel*/ |
|
5898 lY1 = lYuyvPtr[1]; |
|
5899 |
|
5900 /*B component*/ |
|
5901 lTemp = lY1 + lTemp3; |
|
5902 if (lTemp < 0) |
|
5903 lTemp = 0; |
|
5904 if (lTemp > 255) |
|
5905 lTemp = 255; |
|
5906 lTemp4 = (lTemp >> 3); |
|
5907 |
|
5908 /*G component*/ |
|
5909 lTemp = lY1 - lTemp2 + 3; |
|
5910 if (lTemp < 0) |
|
5911 lTemp = 0; |
|
5912 if (lTemp > 255) |
|
5913 lTemp = 255; |
|
5914 lTemp4 |= (lTemp >> 2) << 5; |
|
5915 |
|
5916 /*R component*/ |
|
5917 lTemp = lY1 + lTemp1 + 2; |
|
5918 if (lTemp < 0) |
|
5919 lTemp = 0; |
|
5920 if (lTemp > 255) |
|
5921 lTemp = 255; |
|
5922 lTemp4 |= (lTemp >> 3) << 11; |
|
5923 |
|
5924 lRGBFramePtr[0] = (uint16)lTemp4; |
|
5925 |
|
5926 /*Second Pixel*/ |
|
5927 lY1 = lYuyvPtr[3]; |
|
5928 |
|
5929 /*B component*/ |
|
5930 lTemp = lY1 + lTemp3 + 4; |
|
5931 if (lTemp < 0) |
|
5932 lTemp = 0; |
|
5933 if (lTemp > 255) |
|
5934 lTemp = 255; |
|
5935 lTemp4 = (lTemp >> 3); |
|
5936 |
|
5937 /*G component*/ |
|
5938 lTemp = lY1 - lTemp2; |
|
5939 if (lTemp < 0) |
|
5940 lTemp = 0; |
|
5941 if (lTemp > 255) |
|
5942 lTemp = 255; |
|
5943 lTemp4 |= (lTemp >> 2) << 5; |
|
5944 |
|
5945 /*R component*/ |
|
5946 lTemp = lY1 + lTemp1 + 6; |
|
5947 if (lTemp < 0) |
|
5948 lTemp = 0; |
|
5949 if (lTemp > 255) |
|
5950 lTemp = 255; |
|
5951 lTemp4 |= (lTemp >> 3) << 11; |
|
5952 |
|
5953 lRGBFramePtr[1] = (uint16)lTemp4; |
|
5954 |
|
5955 |
|
5956 lCb = lYuyvPtr[lLumWidth]; |
|
5957 lCr = lYuyvPtr[lLumWidth + 2]; |
|
5958 |
|
5959 lCr -= 128; |
|
5960 lCb -= 128; |
|
5961 |
|
5962 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
5963 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
5964 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
5965 |
|
5966 /*Third Pixel*/ |
|
5967 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
5968 |
|
5969 /*B component*/ |
|
5970 lTemp = lY1 + lTemp3 + 6; |
|
5971 if (lTemp < 0) |
|
5972 lTemp = 0; |
|
5973 if (lTemp > 255) |
|
5974 lTemp = 255; |
|
5975 lTemp4 = (lTemp >> 3); |
|
5976 |
|
5977 /*G component*/ |
|
5978 lTemp = lY1 - lTemp2 + 1; |
|
5979 if (lTemp < 0) |
|
5980 lTemp = 0; |
|
5981 if (lTemp > 255) |
|
5982 lTemp = 255; |
|
5983 lTemp4 |= (lTemp >> 2) << 5; |
|
5984 |
|
5985 /*R component*/ |
|
5986 lTemp = lY1 + lTemp1 + 4; |
|
5987 if (lTemp < 0) |
|
5988 lTemp = 0; |
|
5989 if (lTemp > 255) |
|
5990 lTemp = 255; |
|
5991 lTemp4 |= (lTemp >> 3) << 11; |
|
5992 |
|
5993 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
5994 |
|
5995 /*Fourth Pixel*/ |
|
5996 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
5997 |
|
5998 /*B component*/ |
|
5999 lTemp = lY1 + lTemp3 + 2; |
|
6000 if (lTemp < 0) |
|
6001 lTemp = 0; |
|
6002 if (lTemp > 255) |
|
6003 lTemp = 255; |
|
6004 lTemp4 = (lTemp >> 3); |
|
6005 |
|
6006 /*G component*/ |
|
6007 lTemp = lY1 - lTemp2 + 2; |
|
6008 if (lTemp < 0) |
|
6009 lTemp = 0; |
|
6010 if (lTemp > 255) |
|
6011 lTemp = 255; |
|
6012 lTemp4 |= (lTemp >> 2) << 5; |
|
6013 |
|
6014 /*R component*/ |
|
6015 lTemp = lY1 + lTemp1; |
|
6016 if (lTemp < 0) |
|
6017 lTemp = 0; |
|
6018 if (lTemp > 255) |
|
6019 lTemp = 255; |
|
6020 lTemp4 |= (lTemp >> 3) << 11; |
|
6021 |
|
6022 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
6023 |
|
6024 lYuyvPtr += 4; |
|
6025 lRGBFramePtr += 2; |
|
6026 lRGBFramePtr1 += 2; |
|
6027 } |
|
6028 if(extraCol) |
|
6029 { |
|
6030 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
6031 lRGBFramePtr++; |
|
6032 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
6033 lRGBFramePtr1++; |
|
6034 } |
|
6035 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
6036 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
6037 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
6038 } |
|
6039 |
|
6040 if(extraRow) |
|
6041 { |
|
6042 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
6043 for(j = 0; j < lWidth; j += 2) |
|
6044 { |
|
6045 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6046 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6047 } |
|
6048 if(extraCol) |
|
6049 { |
|
6050 *lRGBFramePtr = *lRGBFramePtr1; |
|
6051 } |
|
6052 } |
|
6053 return; |
|
6054 } |
|
6055 |
|
6056 /* |
|
6057 ****************************************************************************** |
|
6058 Name : sEmz_VDec_YUV422BEChr2toColor64k_Ordered_709_RR |
|
6059 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
6060 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
6061 uint8 *dstImage : Pointer to rgb data (o/p). |
|
6062 tWndParam *srcWindow : Pointer to structure containing source window |
|
6063 parameters like xOffset,yOffset,cropWidth, |
|
6064 cropHeight. (i/p) |
|
6065 tWndParam *dstWindow : Pointer to structure containing destination window |
|
6066 parameters like xOffset,yOffset,windWidth, |
|
6067 windHeight. (i/p) |
|
6068 Return Value : void |
|
6069 ****************************************************************************** |
|
6070 */ |
|
6071 |
|
6072 void sEmz_VDec_YUV422BEChr2toColor64k_Ordered_709_RR |
|
6073 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
6074 tWndParam* srcWindow, tWndParam* dstWindow) |
|
6075 { |
|
6076 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
6077 uint8 *lYuyvPtr; |
|
6078 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
6079 int32 lY1, lCr, lCb; |
|
6080 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
6081 int32 i, j, extraCol, extraRow; |
|
6082 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
6083 cropWidth,cropHeight,wndWidth,wndHeight; |
|
6084 |
|
6085 srcXOffset = srcWindow->xOffset; |
|
6086 srcYOffset = srcWindow->yOffset; |
|
6087 cropWidth = srcWindow->wndWidth; |
|
6088 cropHeight = srcWindow->wndHeight; |
|
6089 |
|
6090 dstXOffset = dstWindow->xOffset; |
|
6091 dstYOffset = dstWindow->yOffset; |
|
6092 wndWidth = dstWindow->wndWidth; |
|
6093 wndHeight = dstWindow->wndHeight; |
|
6094 |
|
6095 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
6096 { |
|
6097 lWidth = cropWidth; |
|
6098 } |
|
6099 else |
|
6100 { |
|
6101 lWidth = srcImage->width - srcXOffset; |
|
6102 } |
|
6103 |
|
6104 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
6105 { |
|
6106 lHeight = cropHeight; |
|
6107 } |
|
6108 else |
|
6109 { |
|
6110 lHeight = srcImage->height - srcYOffset; |
|
6111 } |
|
6112 |
|
6113 if (lWidth > (wndWidth - dstXOffset)) |
|
6114 { |
|
6115 lWidth = wndWidth - dstXOffset; |
|
6116 } |
|
6117 |
|
6118 if (lHeight > (wndHeight - dstYOffset)) |
|
6119 { |
|
6120 lHeight = wndHeight - dstYOffset; |
|
6121 } |
|
6122 |
|
6123 extraCol = lWidth & 0x01; |
|
6124 extraRow = lHeight & 0x01; |
|
6125 |
|
6126 lTempWidth = lWidth; |
|
6127 lWidth = (lWidth >> 1) << 1; |
|
6128 lHeight = (lHeight >> 1) << 1; |
|
6129 |
|
6130 lLumWidth = (srcImage->width >> 1) << 1; |
|
6131 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
6132 |
|
6133 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
6134 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
6135 |
|
6136 lLumWidth <<= 1; |
|
6137 |
|
6138 for(i = 0; i < lHeight; i += 2) |
|
6139 { |
|
6140 for(j = 0; j < lWidth; j += 2) |
|
6141 { |
|
6142 lCb = lYuyvPtr[0]; |
|
6143 lCr = lYuyvPtr[2]; |
|
6144 |
|
6145 lCr -= 128; |
|
6146 lCb -= 128; |
|
6147 |
|
6148 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
6149 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
6150 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
6151 |
|
6152 /*First Pixel*/ |
|
6153 lY1 = lYuyvPtr[1]; |
|
6154 lY1 -= 16; |
|
6155 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
6156 |
|
6157 /*B component*/ |
|
6158 lTemp = lY1 + lTemp3; |
|
6159 if (lTemp < 0) |
|
6160 lTemp = 0; |
|
6161 if (lTemp > 255) |
|
6162 lTemp = 255; |
|
6163 lTemp4 = (lTemp >> 3); |
|
6164 |
|
6165 /*G component*/ |
|
6166 lTemp = lY1 - lTemp2 + 3; |
|
6167 if (lTemp < 0) |
|
6168 lTemp = 0; |
|
6169 if (lTemp > 255) |
|
6170 lTemp = 255; |
|
6171 lTemp4 |= (lTemp >> 2) << 5; |
|
6172 |
|
6173 /*R component*/ |
|
6174 lTemp = lY1 + lTemp1 + 2; |
|
6175 if (lTemp < 0) |
|
6176 lTemp = 0; |
|
6177 if (lTemp > 255) |
|
6178 lTemp = 255; |
|
6179 lTemp4 |= (lTemp >> 3) << 11; |
|
6180 |
|
6181 lRGBFramePtr[0] = (uint16)lTemp4; |
|
6182 |
|
6183 /*Second Pixel*/ |
|
6184 lY1 = lYuyvPtr[3]; |
|
6185 lY1 -= 16; |
|
6186 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
6187 |
|
6188 /*B component*/ |
|
6189 lTemp = lY1 + lTemp3 + 4; |
|
6190 if (lTemp < 0) |
|
6191 lTemp = 0; |
|
6192 if (lTemp > 255) |
|
6193 lTemp = 255; |
|
6194 lTemp4 = (lTemp >> 3); |
|
6195 |
|
6196 /*G component*/ |
|
6197 lTemp = lY1 - lTemp2; |
|
6198 if (lTemp < 0) |
|
6199 lTemp = 0; |
|
6200 if (lTemp > 255) |
|
6201 lTemp = 255; |
|
6202 lTemp4 |= (lTemp >> 2) << 5; |
|
6203 |
|
6204 /*R component*/ |
|
6205 lTemp = lY1 + lTemp1 + 6; |
|
6206 if (lTemp < 0) |
|
6207 lTemp = 0; |
|
6208 if (lTemp > 255) |
|
6209 lTemp = 255; |
|
6210 lTemp4 |= (lTemp >> 3) << 11; |
|
6211 |
|
6212 lRGBFramePtr[1] = (uint16)lTemp4; |
|
6213 |
|
6214 |
|
6215 lCb = lYuyvPtr[lLumWidth]; |
|
6216 lCr = lYuyvPtr[lLumWidth + 2]; |
|
6217 |
|
6218 lCr -= 128; |
|
6219 lCb -= 128; |
|
6220 |
|
6221 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
6222 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
6223 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
6224 |
|
6225 /*Third Pixel*/ |
|
6226 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
6227 lY1 -= 16; |
|
6228 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
6229 |
|
6230 /*B component*/ |
|
6231 lTemp = lY1 + lTemp3 + 6; |
|
6232 if (lTemp < 0) |
|
6233 lTemp = 0; |
|
6234 if (lTemp > 255) |
|
6235 lTemp = 255; |
|
6236 lTemp4 = (lTemp >> 3); |
|
6237 |
|
6238 /*G component*/ |
|
6239 lTemp = lY1 - lTemp2 + 1; |
|
6240 if (lTemp < 0) |
|
6241 lTemp = 0; |
|
6242 if (lTemp > 255) |
|
6243 lTemp = 255; |
|
6244 lTemp4 |= (lTemp >> 2) << 5; |
|
6245 |
|
6246 /*R component*/ |
|
6247 lTemp = lY1 + lTemp1 + 4; |
|
6248 if (lTemp < 0) |
|
6249 lTemp = 0; |
|
6250 if (lTemp > 255) |
|
6251 lTemp = 255; |
|
6252 lTemp4 |= (lTemp >> 3) << 11; |
|
6253 |
|
6254 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
6255 |
|
6256 /*Fourth Pixel*/ |
|
6257 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
6258 lY1 -= 16; |
|
6259 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
6260 |
|
6261 /*B component*/ |
|
6262 lTemp = lY1 + lTemp3 + 2; |
|
6263 if (lTemp < 0) |
|
6264 lTemp = 0; |
|
6265 if (lTemp > 255) |
|
6266 lTemp = 255; |
|
6267 lTemp4 = (lTemp >> 3); |
|
6268 |
|
6269 /*G component*/ |
|
6270 lTemp = lY1 - lTemp2 + 2; |
|
6271 if (lTemp < 0) |
|
6272 lTemp = 0; |
|
6273 if (lTemp > 255) |
|
6274 lTemp = 255; |
|
6275 lTemp4 |= (lTemp >> 2) << 5; |
|
6276 |
|
6277 /*R component*/ |
|
6278 lTemp = lY1 + lTemp1; |
|
6279 if (lTemp < 0) |
|
6280 lTemp = 0; |
|
6281 if (lTemp > 255) |
|
6282 lTemp = 255; |
|
6283 lTemp4 |= (lTemp >> 3) << 11; |
|
6284 |
|
6285 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
6286 |
|
6287 lYuyvPtr += 4; |
|
6288 lRGBFramePtr += 2; |
|
6289 lRGBFramePtr1 += 2; |
|
6290 } |
|
6291 if(extraCol) |
|
6292 { |
|
6293 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
6294 lRGBFramePtr++; |
|
6295 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
6296 lRGBFramePtr1++; |
|
6297 } |
|
6298 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
6299 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
6300 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
6301 } |
|
6302 |
|
6303 if(extraRow) |
|
6304 { |
|
6305 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
6306 for(j = 0; j < lWidth; j += 2) |
|
6307 { |
|
6308 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6309 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6310 } |
|
6311 if(extraCol) |
|
6312 { |
|
6313 *lRGBFramePtr = *lRGBFramePtr1; |
|
6314 } |
|
6315 } |
|
6316 return; |
|
6317 } |
|
6318 |
|
6319 /* |
|
6320 ****************************************************************************** |
|
6321 Name : sEmz_VDec_YUV422BEChr2toColor64k_Ordered_601_5_RR |
|
6322 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
6323 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
6324 uint8 *dstImage : Pointer to rgb data (o/p). |
|
6325 tWndParam *srcWindow : Pointer to structure containing source window |
|
6326 parameters like xOffset,yOffset,cropWidth, |
|
6327 cropHeight. (i/p) |
|
6328 tWndParam *dstWindow : Pointer to structure containing destination window |
|
6329 parameters like xOffset,yOffset,windWidth, |
|
6330 windHeight. (i/p) |
|
6331 Return Value : void |
|
6332 ****************************************************************************** |
|
6333 */ |
|
6334 |
|
6335 void sEmz_VDec_YUV422BEChr2toColor64k_Ordered_601_5_RR |
|
6336 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
6337 tWndParam* srcWindow, tWndParam* dstWindow) |
|
6338 { |
|
6339 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
6340 uint8 *lYuyvPtr; |
|
6341 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
6342 int32 lY1, lCr, lCb; |
|
6343 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
6344 int32 i, j, extraCol, extraRow; |
|
6345 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
6346 cropWidth,cropHeight,wndWidth,wndHeight; |
|
6347 |
|
6348 srcXOffset = srcWindow->xOffset; |
|
6349 srcYOffset = srcWindow->yOffset; |
|
6350 cropWidth = srcWindow->wndWidth; |
|
6351 cropHeight = srcWindow->wndHeight; |
|
6352 |
|
6353 dstXOffset = dstWindow->xOffset; |
|
6354 dstYOffset = dstWindow->yOffset; |
|
6355 wndWidth = dstWindow->wndWidth; |
|
6356 wndHeight = dstWindow->wndHeight; |
|
6357 |
|
6358 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
6359 { |
|
6360 lWidth = cropWidth; |
|
6361 } |
|
6362 else |
|
6363 { |
|
6364 lWidth = srcImage->width - srcXOffset; |
|
6365 } |
|
6366 |
|
6367 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
6368 { |
|
6369 lHeight = cropHeight; |
|
6370 } |
|
6371 else |
|
6372 { |
|
6373 lHeight = srcImage->height - srcYOffset; |
|
6374 } |
|
6375 |
|
6376 if (lWidth > (wndWidth - dstXOffset)) |
|
6377 { |
|
6378 lWidth = wndWidth - dstXOffset; |
|
6379 } |
|
6380 |
|
6381 if (lHeight > (wndHeight - dstYOffset)) |
|
6382 { |
|
6383 lHeight = wndHeight - dstYOffset; |
|
6384 } |
|
6385 |
|
6386 extraCol = lWidth & 0x01; |
|
6387 extraRow = lHeight & 0x01; |
|
6388 |
|
6389 lTempWidth = lWidth; |
|
6390 lWidth = (lWidth >> 1) << 1; |
|
6391 lHeight = (lHeight >> 1) << 1; |
|
6392 |
|
6393 lLumWidth = (srcImage->width >> 1) << 1; |
|
6394 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
6395 |
|
6396 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
6397 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
6398 |
|
6399 lLumWidth <<= 1; |
|
6400 |
|
6401 for(i = 0; i < lHeight; i += 2) |
|
6402 { |
|
6403 for(j = 0; j < lWidth; j += 2) |
|
6404 { |
|
6405 lCb = lYuyvPtr[0]; |
|
6406 lCr = lYuyvPtr[2]; |
|
6407 |
|
6408 lCr -= 128; |
|
6409 lCb -= 128; |
|
6410 |
|
6411 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
6412 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
6413 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
6414 |
|
6415 /*First Pixel*/ |
|
6416 lY1 = lYuyvPtr[1]; |
|
6417 lY1 -= 16; |
|
6418 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
6419 |
|
6420 /*B component*/ |
|
6421 lTemp = lY1 + lTemp3; |
|
6422 if (lTemp < 0) |
|
6423 lTemp = 0; |
|
6424 if (lTemp > 255) |
|
6425 lTemp = 255; |
|
6426 lTemp4 = (lTemp >> 3); |
|
6427 |
|
6428 /*G component*/ |
|
6429 lTemp = lY1 - lTemp2 + 3; |
|
6430 if (lTemp < 0) |
|
6431 lTemp = 0; |
|
6432 if (lTemp > 255) |
|
6433 lTemp = 255; |
|
6434 lTemp4 |= (lTemp >> 2) << 5; |
|
6435 |
|
6436 /*R component*/ |
|
6437 lTemp = lY1 + lTemp1 + 2; |
|
6438 if (lTemp < 0) |
|
6439 lTemp = 0; |
|
6440 if (lTemp > 255) |
|
6441 lTemp = 255; |
|
6442 lTemp4 |= (lTemp >> 3) << 11; |
|
6443 |
|
6444 lRGBFramePtr[0] = (uint16)lTemp4; |
|
6445 |
|
6446 /*Second Pixel*/ |
|
6447 lY1 = lYuyvPtr[3]; |
|
6448 lY1 -= 16; |
|
6449 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
6450 |
|
6451 /*B component*/ |
|
6452 lTemp = lY1 + lTemp3 + 4; |
|
6453 if (lTemp < 0) |
|
6454 lTemp = 0; |
|
6455 if (lTemp > 255) |
|
6456 lTemp = 255; |
|
6457 lTemp4 = (lTemp >> 3); |
|
6458 |
|
6459 /*G component*/ |
|
6460 lTemp = lY1 - lTemp2; |
|
6461 if (lTemp < 0) |
|
6462 lTemp = 0; |
|
6463 if (lTemp > 255) |
|
6464 lTemp = 255; |
|
6465 lTemp4 |= (lTemp >> 2) << 5; |
|
6466 |
|
6467 /*R component*/ |
|
6468 lTemp = lY1 + lTemp1 + 6; |
|
6469 if (lTemp < 0) |
|
6470 lTemp = 0; |
|
6471 if (lTemp > 255) |
|
6472 lTemp = 255; |
|
6473 lTemp4 |= (lTemp >> 3) << 11; |
|
6474 |
|
6475 lRGBFramePtr[1] = (uint16)lTemp4; |
|
6476 |
|
6477 |
|
6478 lCb = lYuyvPtr[lLumWidth]; |
|
6479 lCr = lYuyvPtr[lLumWidth + 2]; |
|
6480 |
|
6481 lCr -= 128; |
|
6482 lCb -= 128; |
|
6483 |
|
6484 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
6485 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
6486 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
6487 |
|
6488 /*Third Pixel*/ |
|
6489 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
6490 lY1 -= 16; |
|
6491 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
6492 |
|
6493 /*B component*/ |
|
6494 lTemp = lY1 + lTemp3 + 6; |
|
6495 if (lTemp < 0) |
|
6496 lTemp = 0; |
|
6497 if (lTemp > 255) |
|
6498 lTemp = 255; |
|
6499 lTemp4 = (lTemp >> 3); |
|
6500 |
|
6501 /*G component*/ |
|
6502 lTemp = lY1 - lTemp2 + 1; |
|
6503 if (lTemp < 0) |
|
6504 lTemp = 0; |
|
6505 if (lTemp > 255) |
|
6506 lTemp = 255; |
|
6507 lTemp4 |= (lTemp >> 2) << 5; |
|
6508 |
|
6509 /*R component*/ |
|
6510 lTemp = lY1 + lTemp1 + 4; |
|
6511 if (lTemp < 0) |
|
6512 lTemp = 0; |
|
6513 if (lTemp > 255) |
|
6514 lTemp = 255; |
|
6515 lTemp4 |= (lTemp >> 3) << 11; |
|
6516 |
|
6517 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
6518 |
|
6519 /*Fourth Pixel*/ |
|
6520 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
6521 lY1 -= 16; |
|
6522 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
6523 |
|
6524 /*B component*/ |
|
6525 lTemp = lY1 + lTemp3 + 2; |
|
6526 if (lTemp < 0) |
|
6527 lTemp = 0; |
|
6528 if (lTemp > 255) |
|
6529 lTemp = 255; |
|
6530 lTemp4 = (lTemp >> 3); |
|
6531 |
|
6532 /*G component*/ |
|
6533 lTemp = lY1 - lTemp2 + 2; |
|
6534 if (lTemp < 0) |
|
6535 lTemp = 0; |
|
6536 if (lTemp > 255) |
|
6537 lTemp = 255; |
|
6538 lTemp4 |= (lTemp >> 2) << 5; |
|
6539 |
|
6540 /*R component*/ |
|
6541 lTemp = lY1 + lTemp1; |
|
6542 if (lTemp < 0) |
|
6543 lTemp = 0; |
|
6544 if (lTemp > 255) |
|
6545 lTemp = 255; |
|
6546 lTemp4 |= (lTemp >> 3) << 11; |
|
6547 |
|
6548 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
6549 |
|
6550 lYuyvPtr += 4; |
|
6551 lRGBFramePtr += 2; |
|
6552 lRGBFramePtr1 += 2; |
|
6553 } |
|
6554 if(extraCol) |
|
6555 { |
|
6556 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
6557 lRGBFramePtr++; |
|
6558 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
6559 lRGBFramePtr1++; |
|
6560 } |
|
6561 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
6562 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
6563 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
6564 } |
|
6565 |
|
6566 if(extraRow) |
|
6567 { |
|
6568 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
6569 for(j = 0; j < lWidth; j += 2) |
|
6570 { |
|
6571 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6572 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6573 } |
|
6574 if(extraCol) |
|
6575 { |
|
6576 *lRGBFramePtr = *lRGBFramePtr1; |
|
6577 } |
|
6578 } |
|
6579 return; |
|
6580 } |
|
6581 |
|
6582 /* |
|
6583 ****************************************************************************** |
|
6584 Name : sEmz_VDec_YUV422BEChr2toColor16M_709_FR |
|
6585 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB888 Interleaved format. |
|
6586 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
6587 uint8 *dstImage : Pointer to rgb data (o/p). |
|
6588 tWndParam *srcWindow : Pointer to structure containing source window |
|
6589 parameters like xOffset,yOffset,cropWidth, |
|
6590 cropHeight. (i/p) |
|
6591 tWndParam *dstWindow : Pointer to structure containing destination window |
|
6592 parameters like xOffset,yOffset,windWidth, |
|
6593 windHeight. (i/p) |
|
6594 Return Value : void |
|
6595 ****************************************************************************** |
|
6596 */ |
|
6597 |
|
6598 void sEmz_VDec_YUV422BEChr2toColor16M_709_FR |
|
6599 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
6600 tWndParam* srcWindow, tWndParam* dstWindow) |
|
6601 { |
|
6602 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
6603 uint8 *lYuyvPtr; |
|
6604 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
6605 int32 lY1, lCr, lCb; |
|
6606 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
6607 int32 i, j, extraCol, extraRow; |
|
6608 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
6609 cropWidth,cropHeight,wndWidth,wndHeight; |
|
6610 |
|
6611 srcXOffset = srcWindow->xOffset; |
|
6612 srcYOffset = srcWindow->yOffset; |
|
6613 cropWidth = srcWindow->wndWidth; |
|
6614 cropHeight = srcWindow->wndHeight; |
|
6615 |
|
6616 |
|
6617 dstXOffset = dstWindow->xOffset; |
|
6618 dstYOffset = dstWindow->yOffset; |
|
6619 wndWidth = dstWindow->wndWidth; |
|
6620 wndHeight = dstWindow->wndHeight; |
|
6621 |
|
6622 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
6623 { |
|
6624 lWidth = cropWidth; |
|
6625 } |
|
6626 else |
|
6627 { |
|
6628 lWidth = srcImage->width - srcXOffset; |
|
6629 } |
|
6630 |
|
6631 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
6632 { |
|
6633 lHeight = cropHeight; |
|
6634 } |
|
6635 else |
|
6636 { |
|
6637 lHeight = srcImage->height - srcYOffset; |
|
6638 } |
|
6639 |
|
6640 if (lWidth > (wndWidth - dstXOffset)) |
|
6641 { |
|
6642 lWidth = wndWidth - dstXOffset; |
|
6643 } |
|
6644 |
|
6645 if (lHeight > (wndHeight - dstYOffset)) |
|
6646 { |
|
6647 lHeight = wndHeight - dstYOffset; |
|
6648 } |
|
6649 |
|
6650 extraCol = lWidth & 0x01; |
|
6651 extraRow = lHeight & 0x01; |
|
6652 |
|
6653 lTempWidth = lWidth * 3; |
|
6654 lWidth = (lWidth >> 1) << 1; |
|
6655 lHeight = (lHeight >> 1) << 1; |
|
6656 |
|
6657 dstXOffset *= 3; |
|
6658 wndWidth *= 3; |
|
6659 |
|
6660 lLumWidth = (srcImage->width >> 1) << 1 ; |
|
6661 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
6662 |
|
6663 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
6664 |
|
6665 for(i = 0; i < lHeight; i++) |
|
6666 { |
|
6667 for(j = 0; j < lWidth; j += 2) |
|
6668 { |
|
6669 lCb = lYuyvPtr[0]; |
|
6670 lCr = lYuyvPtr[2]; |
|
6671 |
|
6672 lCb -= 128; |
|
6673 lCr -= 128; |
|
6674 |
|
6675 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
6676 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
6677 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
6678 |
|
6679 /*First Pixel*/ |
|
6680 lY1 = lYuyvPtr[1]; |
|
6681 |
|
6682 /*R component*/ |
|
6683 lTemp = (lY1 + lTemp1); |
|
6684 if (lTemp < 0) |
|
6685 lTemp = 0; |
|
6686 if (lTemp > 255) |
|
6687 lTemp = 255; |
|
6688 lRGBFramePtr[0] = (uint8) lTemp; |
|
6689 |
|
6690 /*G component*/ |
|
6691 lTemp = (lY1 - lTemp2); |
|
6692 if (lTemp < 0) |
|
6693 lTemp = 0; |
|
6694 if (lTemp > 255) |
|
6695 lTemp = 255; |
|
6696 lRGBFramePtr[1] = (uint8) lTemp; |
|
6697 |
|
6698 /*B component*/ |
|
6699 lTemp = (lY1 + lTemp3); |
|
6700 if (lTemp < 0) |
|
6701 lTemp = 0; |
|
6702 if (lTemp > 255) |
|
6703 lTemp = 255; |
|
6704 |
|
6705 lRGBFramePtr[2] = (uint8) lTemp; |
|
6706 |
|
6707 /*Second Pixel*/ |
|
6708 lY1 = lYuyvPtr[3]; |
|
6709 |
|
6710 /*R component*/ |
|
6711 lTemp = (lY1 + lTemp1); |
|
6712 if (lTemp < 0) |
|
6713 lTemp = 0; |
|
6714 if (lTemp > 255) |
|
6715 lTemp = 255; |
|
6716 lRGBFramePtr[3] = (uint8) lTemp; |
|
6717 |
|
6718 /*G component*/ |
|
6719 lTemp = (lY1 - lTemp2); |
|
6720 if (lTemp < 0) |
|
6721 lTemp = 0; |
|
6722 if (lTemp > 255) |
|
6723 lTemp = 255; |
|
6724 lRGBFramePtr[4] = (uint8) lTemp; |
|
6725 |
|
6726 /*B component*/ |
|
6727 lTemp = (lY1 + lTemp3); |
|
6728 if (lTemp < 0) |
|
6729 lTemp = 0; |
|
6730 if (lTemp > 255) |
|
6731 lTemp = 255; |
|
6732 lRGBFramePtr[5] = (uint8) lTemp; |
|
6733 |
|
6734 lYuyvPtr += 4; |
|
6735 lRGBFramePtr += 6; |
|
6736 } |
|
6737 if(extraCol) |
|
6738 { |
|
6739 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
6740 lRGBFramePtr++; |
|
6741 |
|
6742 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
6743 lRGBFramePtr++; |
|
6744 |
|
6745 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
6746 lRGBFramePtr++; |
|
6747 } |
|
6748 |
|
6749 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
6750 lRGBFramePtr += (wndWidth - lTempWidth); |
|
6751 } |
|
6752 |
|
6753 if(extraRow) |
|
6754 { |
|
6755 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
6756 for(j = 0; j < lWidth * 3; j += 2) |
|
6757 { |
|
6758 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6759 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6760 } |
|
6761 if(extraCol) |
|
6762 { |
|
6763 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6764 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6765 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6766 } |
|
6767 } |
|
6768 return; |
|
6769 } |
|
6770 |
|
6771 /* |
|
6772 ****************************************************************************** |
|
6773 Name : sEmz_VDec_YUV422BEChr2toColor16M_601_5_FR |
|
6774 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB888 Interleaved format. |
|
6775 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
6776 uint8 *dstImage : Pointer to rgb data (o/p). |
|
6777 tWndParam *srcWindow : Pointer to structure containing source window |
|
6778 parameters like xOffset,yOffset,cropWidth, |
|
6779 cropHeight. (i/p) |
|
6780 tWndParam *dstWindow : Pointer to structure containing destination window |
|
6781 parameters like xOffset,yOffset,windWidth, |
|
6782 windHeight. (i/p) |
|
6783 Return Value : void |
|
6784 ****************************************************************************** |
|
6785 */ |
|
6786 |
|
6787 void sEmz_VDec_YUV422BEChr2toColor16M_601_5_FR |
|
6788 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
6789 tWndParam* srcWindow, tWndParam* dstWindow) |
|
6790 { |
|
6791 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
6792 uint8 *lYuyvPtr; |
|
6793 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
6794 int32 lY1, lCr, lCb; |
|
6795 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
6796 int32 i, j, extraCol, extraRow; |
|
6797 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
6798 cropWidth,cropHeight,wndWidth,wndHeight; |
|
6799 |
|
6800 srcXOffset = srcWindow->xOffset; |
|
6801 srcYOffset = srcWindow->yOffset; |
|
6802 cropWidth = srcWindow->wndWidth; |
|
6803 cropHeight = srcWindow->wndHeight; |
|
6804 |
|
6805 dstXOffset = dstWindow->xOffset; |
|
6806 dstYOffset = dstWindow->yOffset; |
|
6807 wndWidth = dstWindow->wndWidth; |
|
6808 wndHeight = dstWindow->wndHeight; |
|
6809 |
|
6810 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
6811 { |
|
6812 lWidth = cropWidth; |
|
6813 } |
|
6814 else |
|
6815 { |
|
6816 lWidth = srcImage->width - srcXOffset; |
|
6817 } |
|
6818 |
|
6819 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
6820 { |
|
6821 lHeight = cropHeight; |
|
6822 } |
|
6823 else |
|
6824 { |
|
6825 lHeight = srcImage->height - srcYOffset; |
|
6826 } |
|
6827 |
|
6828 if (lWidth > (wndWidth - dstXOffset)) |
|
6829 { |
|
6830 lWidth = wndWidth - dstXOffset; |
|
6831 } |
|
6832 |
|
6833 if (lHeight > (wndHeight - dstYOffset)) |
|
6834 { |
|
6835 lHeight = wndHeight - dstYOffset; |
|
6836 } |
|
6837 |
|
6838 extraCol = lWidth & 0x01; |
|
6839 extraRow = lHeight & 0x01; |
|
6840 |
|
6841 lTempWidth = lWidth * 3; |
|
6842 lWidth = (lWidth >> 1) << 1; |
|
6843 lHeight = (lHeight >> 1) << 1; |
|
6844 |
|
6845 dstXOffset *= 3; |
|
6846 wndWidth *= 3; |
|
6847 |
|
6848 lLumWidth = (srcImage->width >> 1) << 1; |
|
6849 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
6850 |
|
6851 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
6852 |
|
6853 for(i = 0; i < lHeight; i++) |
|
6854 { |
|
6855 for(j = 0; j < lWidth; j += 2) |
|
6856 { |
|
6857 lCb = lYuyvPtr[0]; |
|
6858 lCr = lYuyvPtr[2]; |
|
6859 |
|
6860 lCb -= 128; |
|
6861 lCr -= 128; |
|
6862 |
|
6863 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
6864 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
6865 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
6866 |
|
6867 /*First Pixel*/ |
|
6868 lY1 = lYuyvPtr[1]; |
|
6869 |
|
6870 /*R component*/ |
|
6871 lTemp = (lY1 + lTemp1); |
|
6872 if (lTemp < 0) |
|
6873 lTemp = 0; |
|
6874 if (lTemp > 255) |
|
6875 lTemp = 255; |
|
6876 lRGBFramePtr[0] = (uint8) lTemp; |
|
6877 |
|
6878 /*G component*/ |
|
6879 lTemp = (lY1 - lTemp2); |
|
6880 if (lTemp < 0) |
|
6881 lTemp = 0; |
|
6882 if (lTemp > 255) |
|
6883 lTemp = 255; |
|
6884 lRGBFramePtr[1] = (uint8) lTemp; |
|
6885 |
|
6886 /*B component*/ |
|
6887 lTemp = (lY1 + lTemp3); |
|
6888 if (lTemp < 0) |
|
6889 lTemp = 0; |
|
6890 if (lTemp > 255) |
|
6891 lTemp = 255; |
|
6892 |
|
6893 lRGBFramePtr[2] = (uint8) lTemp; |
|
6894 |
|
6895 /*Second Pixel*/ |
|
6896 lY1 = lYuyvPtr[3]; |
|
6897 |
|
6898 /*R component*/ |
|
6899 lTemp = (lY1 + lTemp1); |
|
6900 if (lTemp < 0) |
|
6901 lTemp = 0; |
|
6902 if (lTemp > 255) |
|
6903 lTemp = 255; |
|
6904 lRGBFramePtr[3] = (uint8) lTemp; |
|
6905 |
|
6906 /*G component*/ |
|
6907 lTemp = (lY1 - lTemp2); |
|
6908 if (lTemp < 0) |
|
6909 lTemp = 0; |
|
6910 if (lTemp > 255) |
|
6911 lTemp = 255; |
|
6912 lRGBFramePtr[4] = (uint8) lTemp; |
|
6913 |
|
6914 /*B component*/ |
|
6915 lTemp = (lY1 + lTemp3); |
|
6916 if (lTemp < 0) |
|
6917 lTemp = 0; |
|
6918 if (lTemp > 255) |
|
6919 lTemp = 255; |
|
6920 lRGBFramePtr[5] = (uint8) lTemp; |
|
6921 |
|
6922 lYuyvPtr += 4; |
|
6923 lRGBFramePtr += 6; |
|
6924 } |
|
6925 if(extraCol) |
|
6926 { |
|
6927 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
6928 lRGBFramePtr++; |
|
6929 |
|
6930 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
6931 lRGBFramePtr++; |
|
6932 |
|
6933 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
6934 lRGBFramePtr++; |
|
6935 } |
|
6936 |
|
6937 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
6938 lRGBFramePtr += (wndWidth - lTempWidth); |
|
6939 } |
|
6940 |
|
6941 if(extraRow) |
|
6942 { |
|
6943 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
6944 for(j = 0; j < lWidth * 3; j += 2) |
|
6945 { |
|
6946 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6947 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6948 } |
|
6949 if(extraCol) |
|
6950 { |
|
6951 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6952 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6953 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
6954 } |
|
6955 } |
|
6956 return; |
|
6957 } |
|
6958 |
|
6959 /* |
|
6960 ****************************************************************************** |
|
6961 Name : sEmz_VDec_YUV422BEChr2toColor16M_709_RR |
|
6962 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB888 Interleaved format. |
|
6963 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
6964 uint8 *dstImage : Pointer to rgb data (o/p). |
|
6965 tWndParam *srcWindow : Pointer to structure containing source window |
|
6966 parameters like xOffset,yOffset,cropWidth, |
|
6967 cropHeight. (i/p) |
|
6968 tWndParam *dstWindow : Pointer to structure containing destination window |
|
6969 parameters like xOffset,yOffset,windWidth, |
|
6970 windHeight. (i/p) |
|
6971 Return Value : void |
|
6972 ****************************************************************************** |
|
6973 */ |
|
6974 |
|
6975 void sEmz_VDec_YUV422BEChr2toColor16M_709_RR |
|
6976 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
6977 tWndParam* srcWindow, tWndParam* dstWindow) |
|
6978 { |
|
6979 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
6980 uint8 *lYuyvPtr; |
|
6981 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
6982 int32 lY1, lCr, lCb; |
|
6983 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
6984 int32 i, j, extraCol, extraRow; |
|
6985 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
6986 cropWidth,cropHeight,wndWidth,wndHeight; |
|
6987 |
|
6988 srcXOffset = srcWindow->xOffset; |
|
6989 srcYOffset = srcWindow->yOffset; |
|
6990 cropWidth = srcWindow->wndWidth; |
|
6991 cropHeight = srcWindow->wndHeight; |
|
6992 |
|
6993 dstXOffset = dstWindow->xOffset; |
|
6994 dstYOffset = dstWindow->yOffset; |
|
6995 wndWidth = dstWindow->wndWidth; |
|
6996 wndHeight = dstWindow->wndHeight; |
|
6997 |
|
6998 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
6999 { |
|
7000 lWidth = cropWidth; |
|
7001 } |
|
7002 else |
|
7003 { |
|
7004 lWidth = srcImage->width - srcXOffset; |
|
7005 } |
|
7006 |
|
7007 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
7008 { |
|
7009 lHeight = cropHeight; |
|
7010 } |
|
7011 else |
|
7012 { |
|
7013 lHeight = srcImage->height - srcYOffset; |
|
7014 } |
|
7015 |
|
7016 if (lWidth > (wndWidth - dstXOffset)) |
|
7017 { |
|
7018 lWidth = wndWidth - dstXOffset; |
|
7019 } |
|
7020 |
|
7021 if (lHeight > (wndHeight - dstYOffset)) |
|
7022 { |
|
7023 lHeight = wndHeight - dstYOffset; |
|
7024 } |
|
7025 |
|
7026 extraCol = lWidth & 0x01; |
|
7027 extraRow = lHeight & 0x01; |
|
7028 |
|
7029 lTempWidth = lWidth * 3; |
|
7030 lWidth = (lWidth >> 1) << 1; |
|
7031 lHeight = (lHeight >> 1) << 1; |
|
7032 |
|
7033 dstXOffset *= 3; |
|
7034 wndWidth *= 3; |
|
7035 |
|
7036 lLumWidth = (srcImage->width >> 1) << 1; |
|
7037 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
7038 |
|
7039 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
7040 |
|
7041 for(i = 0; i < lHeight; i++) |
|
7042 { |
|
7043 for(j = 0; j < lWidth; j += 2) |
|
7044 { |
|
7045 lCb = lYuyvPtr[0]; |
|
7046 lCr = lYuyvPtr[2]; |
|
7047 |
|
7048 lCb -= 128; |
|
7049 lCr -= 128; |
|
7050 |
|
7051 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
7052 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
7053 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
7054 |
|
7055 /*First Pixel*/ |
|
7056 lY1 = lYuyvPtr[1]; |
|
7057 lY1 -= 16; |
|
7058 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
7059 |
|
7060 /*R component*/ |
|
7061 lTemp = (lY1 + lTemp1); |
|
7062 if (lTemp < 0) |
|
7063 lTemp = 0; |
|
7064 if (lTemp > 255) |
|
7065 lTemp = 255; |
|
7066 lRGBFramePtr[0] = (uint8) lTemp; |
|
7067 |
|
7068 /*G component*/ |
|
7069 lTemp = (lY1 - lTemp2); |
|
7070 if (lTemp < 0) |
|
7071 lTemp = 0; |
|
7072 if (lTemp > 255) |
|
7073 lTemp = 255; |
|
7074 lRGBFramePtr[1] = (uint8) lTemp; |
|
7075 |
|
7076 /*B component*/ |
|
7077 lTemp = (lY1 + lTemp3); |
|
7078 if (lTemp < 0) |
|
7079 lTemp = 0; |
|
7080 if (lTemp > 255) |
|
7081 lTemp = 255; |
|
7082 |
|
7083 lRGBFramePtr[2] = (uint8) lTemp; |
|
7084 |
|
7085 /*Second Pixel*/ |
|
7086 lY1 = lYuyvPtr[3]; |
|
7087 lY1 -= 16; |
|
7088 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
7089 |
|
7090 /*R component*/ |
|
7091 lTemp = (lY1 + lTemp1); |
|
7092 if (lTemp < 0) |
|
7093 lTemp = 0; |
|
7094 if (lTemp > 255) |
|
7095 lTemp = 255; |
|
7096 lRGBFramePtr[3] = (uint8) lTemp; |
|
7097 |
|
7098 /*G component*/ |
|
7099 lTemp = (lY1 - lTemp2); |
|
7100 if (lTemp < 0) |
|
7101 lTemp = 0; |
|
7102 if (lTemp > 255) |
|
7103 lTemp = 255; |
|
7104 lRGBFramePtr[4] = (uint8) lTemp; |
|
7105 |
|
7106 /*B component*/ |
|
7107 lTemp = (lY1 + lTemp3); |
|
7108 if (lTemp < 0) |
|
7109 lTemp = 0; |
|
7110 if (lTemp > 255) |
|
7111 lTemp = 255; |
|
7112 lRGBFramePtr[5] = (uint8) lTemp; |
|
7113 |
|
7114 lYuyvPtr += 4; |
|
7115 lRGBFramePtr += 6; |
|
7116 } |
|
7117 if(extraCol) |
|
7118 { |
|
7119 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
7120 lRGBFramePtr++; |
|
7121 |
|
7122 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
7123 lRGBFramePtr++; |
|
7124 |
|
7125 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
7126 lRGBFramePtr++; |
|
7127 } |
|
7128 |
|
7129 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
7130 lRGBFramePtr += (wndWidth - lTempWidth); |
|
7131 } |
|
7132 |
|
7133 if(extraRow) |
|
7134 { |
|
7135 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
7136 for(j = 0; j < lWidth * 3; j += 2) |
|
7137 { |
|
7138 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7139 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7140 } |
|
7141 if(extraCol) |
|
7142 { |
|
7143 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7144 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7145 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7146 } |
|
7147 } |
|
7148 return; |
|
7149 } |
|
7150 |
|
7151 /* |
|
7152 ****************************************************************************** |
|
7153 Name : sEmz_VDec_YUV422BEChr2toColor16M_601_5_RR |
|
7154 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB888 Interleaved format. |
|
7155 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
7156 uint8 *dstImage : Pointer to rgb data (o/p). |
|
7157 tWndParam *srcWindow : Pointer to structure containing source window |
|
7158 parameters like xOffset,yOffset,cropWidth, |
|
7159 cropHeight. (i/p) |
|
7160 tWndParam *dstWindow : Pointer to structure containing destination window |
|
7161 parameters like xOffset,yOffset,windWidth, |
|
7162 windHeight. (i/p) |
|
7163 Return Value : void |
|
7164 ****************************************************************************** |
|
7165 */ |
|
7166 |
|
7167 void sEmz_VDec_YUV422BEChr2toColor16M_601_5_RR |
|
7168 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
7169 tWndParam* srcWindow, tWndParam* dstWindow) |
|
7170 { |
|
7171 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
7172 uint8 *lYuyvPtr; |
|
7173 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
7174 int32 lY1, lCr, lCb; |
|
7175 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
7176 int32 i, j, extraCol, extraRow; |
|
7177 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
7178 cropWidth,cropHeight,wndWidth,wndHeight; |
|
7179 |
|
7180 srcXOffset = srcWindow->xOffset; |
|
7181 srcYOffset = srcWindow->yOffset; |
|
7182 cropWidth = srcWindow->wndWidth; |
|
7183 cropHeight = srcWindow->wndHeight; |
|
7184 |
|
7185 dstXOffset = dstWindow->xOffset; |
|
7186 dstYOffset = dstWindow->yOffset; |
|
7187 wndWidth = dstWindow->wndWidth; |
|
7188 wndHeight = dstWindow->wndHeight; |
|
7189 |
|
7190 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
7191 { |
|
7192 lWidth = cropWidth; |
|
7193 } |
|
7194 else |
|
7195 { |
|
7196 lWidth = srcImage->width - srcXOffset; |
|
7197 } |
|
7198 |
|
7199 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
7200 { |
|
7201 lHeight = cropHeight; |
|
7202 } |
|
7203 else |
|
7204 { |
|
7205 lHeight = srcImage->height - srcYOffset; |
|
7206 } |
|
7207 |
|
7208 if (lWidth > (wndWidth - dstXOffset)) |
|
7209 { |
|
7210 lWidth = wndWidth - dstXOffset; |
|
7211 } |
|
7212 |
|
7213 if (lHeight > (wndHeight - dstYOffset)) |
|
7214 { |
|
7215 lHeight = wndHeight - dstYOffset; |
|
7216 } |
|
7217 |
|
7218 extraCol = lWidth & 0x01; |
|
7219 extraRow = lHeight & 0x01; |
|
7220 |
|
7221 lTempWidth = lWidth * 3; |
|
7222 lWidth = (lWidth >> 1) << 1; |
|
7223 lHeight = (lHeight >> 1) << 1; |
|
7224 |
|
7225 dstXOffset *= 3; |
|
7226 wndWidth *= 3; |
|
7227 |
|
7228 lLumWidth = (srcImage->width >> 1) << 1; |
|
7229 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
7230 |
|
7231 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
7232 |
|
7233 for(i = 0; i < lHeight; i++) |
|
7234 { |
|
7235 for(j = 0; j < lWidth; j += 2) |
|
7236 { |
|
7237 lCb = lYuyvPtr[0]; |
|
7238 lCr = lYuyvPtr[2]; |
|
7239 |
|
7240 lCb -= 128; |
|
7241 lCr -= 128; |
|
7242 |
|
7243 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
7244 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
7245 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
7246 |
|
7247 /*First Pixel*/ |
|
7248 lY1 = lYuyvPtr[1]; |
|
7249 lY1 -= 16; |
|
7250 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
7251 |
|
7252 /*R component*/ |
|
7253 lTemp = (lY1 + lTemp1); |
|
7254 if (lTemp < 0) |
|
7255 lTemp = 0; |
|
7256 if (lTemp > 255) |
|
7257 lTemp = 255; |
|
7258 lRGBFramePtr[0] = (uint8) lTemp; |
|
7259 |
|
7260 /*G component*/ |
|
7261 lTemp = (lY1 - lTemp2); |
|
7262 if (lTemp < 0) |
|
7263 lTemp = 0; |
|
7264 if (lTemp > 255) |
|
7265 lTemp = 255; |
|
7266 lRGBFramePtr[1] = (uint8) lTemp; |
|
7267 |
|
7268 /*B component*/ |
|
7269 lTemp = (lY1 + lTemp3); |
|
7270 if (lTemp < 0) |
|
7271 lTemp = 0; |
|
7272 if (lTemp > 255) |
|
7273 lTemp = 255; |
|
7274 |
|
7275 lRGBFramePtr[2] = (uint8) lTemp; |
|
7276 |
|
7277 /*Second Pixel*/ |
|
7278 lY1 = lYuyvPtr[3]; |
|
7279 lY1 -= 16; |
|
7280 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
7281 |
|
7282 /*R component*/ |
|
7283 lTemp = (lY1 + lTemp1); |
|
7284 if (lTemp < 0) |
|
7285 lTemp = 0; |
|
7286 if (lTemp > 255) |
|
7287 lTemp = 255; |
|
7288 lRGBFramePtr[3] = (uint8) lTemp; |
|
7289 |
|
7290 /*G component*/ |
|
7291 lTemp = (lY1 - lTemp2); |
|
7292 if (lTemp < 0) |
|
7293 lTemp = 0; |
|
7294 if (lTemp > 255) |
|
7295 lTemp = 255; |
|
7296 lRGBFramePtr[4] = (uint8) lTemp; |
|
7297 |
|
7298 /*B component*/ |
|
7299 lTemp = (lY1 + lTemp3); |
|
7300 if (lTemp < 0) |
|
7301 lTemp = 0; |
|
7302 if (lTemp > 255) |
|
7303 lTemp = 255; |
|
7304 lRGBFramePtr[5] = (uint8) lTemp; |
|
7305 |
|
7306 lYuyvPtr += 4; |
|
7307 lRGBFramePtr += 6; |
|
7308 } |
|
7309 if(extraCol) |
|
7310 { |
|
7311 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
7312 lRGBFramePtr++; |
|
7313 |
|
7314 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
7315 lRGBFramePtr++; |
|
7316 |
|
7317 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
7318 lRGBFramePtr++; |
|
7319 } |
|
7320 |
|
7321 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
7322 lRGBFramePtr += (wndWidth - lTempWidth); |
|
7323 } |
|
7324 |
|
7325 if(extraRow) |
|
7326 { |
|
7327 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
7328 for(j = 0; j < lWidth * 3; j += 2) |
|
7329 { |
|
7330 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7331 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7332 } |
|
7333 if(extraCol) |
|
7334 { |
|
7335 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7336 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7337 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7338 } |
|
7339 } |
|
7340 return; |
|
7341 } |
|
7342 |
|
7343 |
|
7344 /* |
|
7345 ****************************************************************************** |
|
7346 Name : sEmz_VDec_YUV422BEChr2toColor4k_Ordered_709_FR |
|
7347 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
7348 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
7349 uint8 *dstImage : Pointer to rgb data (o/p). |
|
7350 tWndParam *srcWindow : Pointer to structure containing source window |
|
7351 parameters like xOffset,yOffset,cropWidth, |
|
7352 cropHeight. (i/p) |
|
7353 tWndParam *dstWindow : Pointer to structure containing destination window |
|
7354 parameters like xOffset,yOffset,windWidth, |
|
7355 windHeight. (i/p) |
|
7356 Return Value : void |
|
7357 ****************************************************************************** |
|
7358 */ |
|
7359 |
|
7360 void sEmz_VDec_YUV422BEChr2toColor4k_Ordered_709_FR |
|
7361 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
7362 tWndParam* srcWindow, tWndParam* dstWindow) |
|
7363 { |
|
7364 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
7365 uint8 *lYuyvPtr; |
|
7366 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
7367 int32 lY1, lCr, lCb; |
|
7368 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
7369 int32 i, j, extraCol, extraRow; |
|
7370 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
7371 cropWidth,cropHeight,wndWidth,wndHeight; |
|
7372 |
|
7373 srcXOffset = srcWindow->xOffset; |
|
7374 srcYOffset = srcWindow->yOffset; |
|
7375 cropWidth = srcWindow->wndWidth; |
|
7376 cropHeight = srcWindow->wndHeight; |
|
7377 |
|
7378 dstXOffset = dstWindow->xOffset; |
|
7379 dstYOffset = dstWindow->yOffset; |
|
7380 wndWidth = dstWindow->wndWidth; |
|
7381 wndHeight = dstWindow->wndHeight; |
|
7382 |
|
7383 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
7384 { |
|
7385 lWidth = cropWidth; |
|
7386 } |
|
7387 else |
|
7388 { |
|
7389 lWidth = srcImage->width - srcXOffset; |
|
7390 } |
|
7391 |
|
7392 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
7393 { |
|
7394 lHeight = cropHeight; |
|
7395 } |
|
7396 else |
|
7397 { |
|
7398 lHeight = srcImage->height - srcYOffset; |
|
7399 } |
|
7400 |
|
7401 if (lWidth > (wndWidth - dstXOffset)) |
|
7402 { |
|
7403 lWidth = wndWidth - dstXOffset; |
|
7404 } |
|
7405 |
|
7406 if (lHeight > (wndHeight - dstYOffset)) |
|
7407 { |
|
7408 lHeight = wndHeight - dstYOffset; |
|
7409 } |
|
7410 |
|
7411 extraCol = lWidth & 0x01; |
|
7412 extraRow = lHeight & 0x01; |
|
7413 |
|
7414 lTempWidth = lWidth; |
|
7415 lWidth = (lWidth >> 1) << 1; |
|
7416 lHeight = (lHeight >> 1) << 1; |
|
7417 |
|
7418 lLumWidth = (srcImage->width >> 1) << 1; |
|
7419 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
7420 |
|
7421 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
7422 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
7423 |
|
7424 lLumWidth <<= 1; |
|
7425 |
|
7426 for(i = 0; i < lHeight; i += 2) |
|
7427 { |
|
7428 for(j = 0; j < lWidth; j += 2) |
|
7429 { |
|
7430 lCb = lYuyvPtr[0]; |
|
7431 lCr = lYuyvPtr[2]; |
|
7432 |
|
7433 lCr -= 128; |
|
7434 lCb -= 128; |
|
7435 |
|
7436 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
7437 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
7438 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
7439 |
|
7440 /*First Pixel*/ |
|
7441 lY1 = lYuyvPtr[1]; |
|
7442 |
|
7443 /*B component*/ |
|
7444 lTemp = lY1 + lTemp3; |
|
7445 if (lTemp < 0) |
|
7446 lTemp = 0; |
|
7447 if (lTemp > 255) |
|
7448 lTemp = 255; |
|
7449 lTemp4 = (lTemp >> 4); |
|
7450 |
|
7451 /*G component*/ |
|
7452 lTemp = lY1 - lTemp2 + 15; |
|
7453 if (lTemp < 0) |
|
7454 lTemp = 0; |
|
7455 if (lTemp > 255) |
|
7456 lTemp = 255; |
|
7457 lTemp4 |= (lTemp >> 4) << 4; |
|
7458 |
|
7459 /*R component*/ |
|
7460 lTemp = lY1 + lTemp1 + 5; |
|
7461 if (lTemp < 0) |
|
7462 lTemp = 0; |
|
7463 if (lTemp > 255) |
|
7464 lTemp = 255; |
|
7465 lTemp4 |= (lTemp >> 4) << 8; |
|
7466 |
|
7467 lRGBFramePtr[0] = (uint16)lTemp4; |
|
7468 |
|
7469 /*Second Pixel*/ |
|
7470 lY1 = lYuyvPtr[3]; |
|
7471 |
|
7472 /*B component*/ |
|
7473 lTemp = lY1 + lTemp3 + 10; |
|
7474 if (lTemp < 0) |
|
7475 lTemp = 0; |
|
7476 if (lTemp > 255) |
|
7477 lTemp = 255; |
|
7478 lTemp4 = (lTemp >> 4); |
|
7479 |
|
7480 /*G component*/ |
|
7481 lTemp = lY1 - lTemp2; |
|
7482 if (lTemp < 0) |
|
7483 lTemp = 0; |
|
7484 if (lTemp > 255) |
|
7485 lTemp = 255; |
|
7486 lTemp4 |= (lTemp >> 4) << 4; |
|
7487 |
|
7488 /*R component*/ |
|
7489 lTemp = lY1 + lTemp1 + 15; |
|
7490 if (lTemp < 0) |
|
7491 lTemp = 0; |
|
7492 if (lTemp > 255) |
|
7493 lTemp = 255; |
|
7494 lTemp4 |= (lTemp >> 4) << 8; |
|
7495 |
|
7496 lRGBFramePtr[1] = (uint16)lTemp4; |
|
7497 |
|
7498 |
|
7499 lCb = lYuyvPtr[lLumWidth]; |
|
7500 lCr = lYuyvPtr[lLumWidth + 2]; |
|
7501 |
|
7502 lCr -= 128; |
|
7503 lCb -= 128; |
|
7504 |
|
7505 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
7506 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
7507 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
7508 |
|
7509 /*Third Pixel*/ |
|
7510 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
7511 |
|
7512 /*B component*/ |
|
7513 lTemp = lY1 + lTemp3 + 15; |
|
7514 if (lTemp < 0) |
|
7515 lTemp = 0; |
|
7516 if (lTemp > 255) |
|
7517 lTemp = 255; |
|
7518 lTemp4 = (lTemp >> 4); |
|
7519 |
|
7520 /*G component*/ |
|
7521 lTemp = lY1 - lTemp2 + 5; |
|
7522 if (lTemp < 0) |
|
7523 lTemp = 0; |
|
7524 if (lTemp > 255) |
|
7525 lTemp = 255; |
|
7526 lTemp4 |= (lTemp >> 4) << 4; |
|
7527 |
|
7528 /*R component*/ |
|
7529 lTemp = lY1 + lTemp1 + 10; |
|
7530 if (lTemp < 0) |
|
7531 lTemp = 0; |
|
7532 if (lTemp > 255) |
|
7533 lTemp = 255; |
|
7534 lTemp4 |= (lTemp >> 4) << 8; |
|
7535 |
|
7536 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
7537 |
|
7538 /*Fourth Pixel*/ |
|
7539 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
7540 |
|
7541 /*B component*/ |
|
7542 lTemp = lY1 + lTemp3 + 5; |
|
7543 if (lTemp < 0) |
|
7544 lTemp = 0; |
|
7545 if (lTemp > 255) |
|
7546 lTemp = 255; |
|
7547 lTemp4 = (lTemp >> 4); |
|
7548 |
|
7549 /*G component*/ |
|
7550 lTemp = lY1 - lTemp2 + 10; |
|
7551 if (lTemp < 0) |
|
7552 lTemp = 0; |
|
7553 if (lTemp > 255) |
|
7554 lTemp = 255; |
|
7555 lTemp4 |= (lTemp >> 4) << 4; |
|
7556 |
|
7557 /*R component*/ |
|
7558 lTemp = lY1 + lTemp1; |
|
7559 if (lTemp < 0) |
|
7560 lTemp = 0; |
|
7561 if (lTemp > 255) |
|
7562 lTemp = 255; |
|
7563 lTemp4 |= (lTemp >> 4) << 8; |
|
7564 |
|
7565 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
7566 |
|
7567 lYuyvPtr += 4; |
|
7568 lRGBFramePtr += 2; |
|
7569 lRGBFramePtr1 += 2; |
|
7570 } |
|
7571 if(extraCol) |
|
7572 { |
|
7573 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
7574 lRGBFramePtr++; |
|
7575 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
7576 lRGBFramePtr1++; |
|
7577 } |
|
7578 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
7579 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
7580 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
7581 } |
|
7582 |
|
7583 if(extraRow) |
|
7584 { |
|
7585 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
7586 for(j = 0; j < lWidth; j += 2) |
|
7587 { |
|
7588 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7589 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7590 } |
|
7591 if(extraCol) |
|
7592 { |
|
7593 *lRGBFramePtr = *lRGBFramePtr1; |
|
7594 } |
|
7595 } |
|
7596 return; |
|
7597 } |
|
7598 |
|
7599 /* |
|
7600 ****************************************************************************** |
|
7601 Name : sEmz_VDec_YUV422BEChr2toColor4k_Ordered_601_5_FR |
|
7602 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
7603 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
7604 uint8 *dstImage : Pointer to rgb data (o/p). |
|
7605 tWndParam *srcWindow : Pointer to structure containing source window |
|
7606 parameters like xOffset,yOffset,cropWidth, |
|
7607 cropHeight. (i/p) |
|
7608 tWndParam *dstWindow : Pointer to structure containing destination window |
|
7609 parameters like xOffset,yOffset,windWidth, |
|
7610 windHeight. (i/p) |
|
7611 Return Value : void |
|
7612 ****************************************************************************** |
|
7613 */ |
|
7614 |
|
7615 void sEmz_VDec_YUV422BEChr2toColor4k_Ordered_601_5_FR |
|
7616 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
7617 tWndParam* srcWindow, tWndParam* dstWindow) |
|
7618 { |
|
7619 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
7620 uint8 *lYuyvPtr; |
|
7621 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
7622 int32 lY1, lCr, lCb; |
|
7623 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
7624 int32 i, j, extraCol, extraRow; |
|
7625 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
7626 cropWidth,cropHeight,wndWidth,wndHeight; |
|
7627 |
|
7628 srcXOffset = srcWindow->xOffset; |
|
7629 srcYOffset = srcWindow->yOffset; |
|
7630 cropWidth = srcWindow->wndWidth; |
|
7631 cropHeight = srcWindow->wndHeight; |
|
7632 |
|
7633 dstXOffset = dstWindow->xOffset; |
|
7634 dstYOffset = dstWindow->yOffset; |
|
7635 wndWidth = dstWindow->wndWidth; |
|
7636 wndHeight = dstWindow->wndHeight; |
|
7637 |
|
7638 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
7639 { |
|
7640 lWidth = cropWidth; |
|
7641 } |
|
7642 else |
|
7643 { |
|
7644 lWidth = srcImage->width - srcXOffset; |
|
7645 } |
|
7646 |
|
7647 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
7648 { |
|
7649 lHeight = cropHeight; |
|
7650 } |
|
7651 else |
|
7652 { |
|
7653 lHeight = srcImage->height - srcYOffset; |
|
7654 } |
|
7655 |
|
7656 if (lWidth > (wndWidth - dstXOffset)) |
|
7657 { |
|
7658 lWidth = wndWidth - dstXOffset; |
|
7659 } |
|
7660 |
|
7661 if (lHeight > (wndHeight - dstYOffset)) |
|
7662 { |
|
7663 lHeight = wndHeight - dstYOffset; |
|
7664 } |
|
7665 |
|
7666 extraCol = lWidth & 0x01; |
|
7667 extraRow = lHeight & 0x01; |
|
7668 |
|
7669 lTempWidth = lWidth; |
|
7670 lWidth = (lWidth >> 1) << 1; |
|
7671 lHeight = (lHeight >> 1) << 1; |
|
7672 |
|
7673 lLumWidth = (srcImage->width >> 1) << 1; |
|
7674 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
7675 |
|
7676 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
7677 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
7678 |
|
7679 lLumWidth <<= 1; |
|
7680 |
|
7681 for(i = 0; i < lHeight; i += 2) |
|
7682 { |
|
7683 for(j = 0; j < lWidth; j += 2) |
|
7684 { |
|
7685 lCb = lYuyvPtr[0]; |
|
7686 lCr = lYuyvPtr[2]; |
|
7687 |
|
7688 lCr -= 128; |
|
7689 lCb -= 128; |
|
7690 |
|
7691 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
7692 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
7693 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
7694 |
|
7695 /*First Pixel*/ |
|
7696 lY1 = lYuyvPtr[1]; |
|
7697 |
|
7698 /*B component*/ |
|
7699 lTemp = lY1 + lTemp3; |
|
7700 if (lTemp < 0) |
|
7701 lTemp = 0; |
|
7702 if (lTemp > 255) |
|
7703 lTemp = 255; |
|
7704 lTemp4 = (lTemp >> 4); |
|
7705 |
|
7706 /*G component*/ |
|
7707 lTemp = lY1 - lTemp2 + 15; |
|
7708 if (lTemp < 0) |
|
7709 lTemp = 0; |
|
7710 if (lTemp > 255) |
|
7711 lTemp = 255; |
|
7712 lTemp4 |= (lTemp >> 4) << 4; |
|
7713 |
|
7714 /*R component*/ |
|
7715 lTemp = lY1 + lTemp1 + 5; |
|
7716 if (lTemp < 0) |
|
7717 lTemp = 0; |
|
7718 if (lTemp > 255) |
|
7719 lTemp = 255; |
|
7720 lTemp4 |= (lTemp >> 4) << 8; |
|
7721 |
|
7722 lRGBFramePtr[0] = (uint16)lTemp4; |
|
7723 |
|
7724 /*Second Pixel*/ |
|
7725 lY1 = lYuyvPtr[3]; |
|
7726 |
|
7727 /*B component*/ |
|
7728 lTemp = lY1 + lTemp3 + 10; |
|
7729 if (lTemp < 0) |
|
7730 lTemp = 0; |
|
7731 if (lTemp > 255) |
|
7732 lTemp = 255; |
|
7733 lTemp4 = (lTemp >> 4); |
|
7734 |
|
7735 /*G component*/ |
|
7736 lTemp = lY1 - lTemp2; |
|
7737 if (lTemp < 0) |
|
7738 lTemp = 0; |
|
7739 if (lTemp > 255) |
|
7740 lTemp = 255; |
|
7741 lTemp4 |= (lTemp >> 4) << 4; |
|
7742 |
|
7743 /*R component*/ |
|
7744 lTemp = lY1 + lTemp1 + 15; |
|
7745 if (lTemp < 0) |
|
7746 lTemp = 0; |
|
7747 if (lTemp > 255) |
|
7748 lTemp = 255; |
|
7749 lTemp4 |= (lTemp >> 4) << 8; |
|
7750 |
|
7751 lRGBFramePtr[1] = (uint16)lTemp4; |
|
7752 |
|
7753 |
|
7754 lCb = lYuyvPtr[lLumWidth]; |
|
7755 lCr = lYuyvPtr[lLumWidth + 2]; |
|
7756 |
|
7757 lCr -= 128; |
|
7758 lCb -= 128; |
|
7759 |
|
7760 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
7761 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
7762 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
7763 |
|
7764 /*Third Pixel*/ |
|
7765 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
7766 |
|
7767 /*B component*/ |
|
7768 lTemp = lY1 + lTemp3 + 15; |
|
7769 if (lTemp < 0) |
|
7770 lTemp = 0; |
|
7771 if (lTemp > 255) |
|
7772 lTemp = 255; |
|
7773 lTemp4 = (lTemp >> 4); |
|
7774 |
|
7775 /*G component*/ |
|
7776 lTemp = lY1 - lTemp2 + 5; |
|
7777 if (lTemp < 0) |
|
7778 lTemp = 0; |
|
7779 if (lTemp > 255) |
|
7780 lTemp = 255; |
|
7781 lTemp4 |= (lTemp >> 4) << 4; |
|
7782 |
|
7783 /*R component*/ |
|
7784 lTemp = lY1 + lTemp1 + 10; |
|
7785 if (lTemp < 0) |
|
7786 lTemp = 0; |
|
7787 if (lTemp > 255) |
|
7788 lTemp = 255; |
|
7789 lTemp4 |= (lTemp >> 4) << 8; |
|
7790 |
|
7791 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
7792 |
|
7793 /*Fourth Pixel*/ |
|
7794 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
7795 |
|
7796 /*B component*/ |
|
7797 lTemp = lY1 + lTemp3 + 5; |
|
7798 if (lTemp < 0) |
|
7799 lTemp = 0; |
|
7800 if (lTemp > 255) |
|
7801 lTemp = 255; |
|
7802 lTemp4 = (lTemp >> 4); |
|
7803 |
|
7804 /*G component*/ |
|
7805 lTemp = lY1 - lTemp2 + 10; |
|
7806 if (lTemp < 0) |
|
7807 lTemp = 0; |
|
7808 if (lTemp > 255) |
|
7809 lTemp = 255; |
|
7810 lTemp4 |= (lTemp >> 4) << 4; |
|
7811 |
|
7812 /*R component*/ |
|
7813 lTemp = lY1 + lTemp1; |
|
7814 if (lTemp < 0) |
|
7815 lTemp = 0; |
|
7816 if (lTemp > 255) |
|
7817 lTemp = 255; |
|
7818 lTemp4 |= (lTemp >> 4) << 8; |
|
7819 |
|
7820 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
7821 |
|
7822 lYuyvPtr += 4; |
|
7823 lRGBFramePtr += 2; |
|
7824 lRGBFramePtr1 += 2; |
|
7825 } |
|
7826 if(extraCol) |
|
7827 { |
|
7828 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
7829 lRGBFramePtr++; |
|
7830 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
7831 lRGBFramePtr1++; |
|
7832 } |
|
7833 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
7834 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
7835 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
7836 } |
|
7837 |
|
7838 if(extraRow) |
|
7839 { |
|
7840 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
7841 for(j = 0; j < lWidth; j += 2) |
|
7842 { |
|
7843 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7844 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
7845 } |
|
7846 if(extraCol) |
|
7847 { |
|
7848 *lRGBFramePtr = *lRGBFramePtr1; |
|
7849 } |
|
7850 } |
|
7851 return; |
|
7852 } |
|
7853 |
|
7854 /* |
|
7855 ****************************************************************************** |
|
7856 Name : sEmz_VDec_YUV422BEChr2toColor4k_Ordered_709_RR |
|
7857 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
7858 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
7859 uint8 *dstImage : Pointer to rgb data (o/p). |
|
7860 tWndParam *srcWindow : Pointer to structure containing source window |
|
7861 parameters like xOffset,yOffset,cropWidth, |
|
7862 cropHeight. (i/p) |
|
7863 tWndParam *dstWindow : Pointer to structure containing destination window |
|
7864 parameters like xOffset,yOffset,windWidth, |
|
7865 windHeight. (i/p) |
|
7866 Return Value : void |
|
7867 ****************************************************************************** |
|
7868 */ |
|
7869 |
|
7870 void sEmz_VDec_YUV422BEChr2toColor4k_Ordered_709_RR |
|
7871 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
7872 tWndParam* srcWindow, tWndParam* dstWindow) |
|
7873 { |
|
7874 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
7875 uint8 *lYuyvPtr; |
|
7876 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
7877 int32 lY1, lCr, lCb; |
|
7878 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
7879 int32 i, j, extraCol, extraRow; |
|
7880 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
7881 cropWidth,cropHeight,wndWidth,wndHeight; |
|
7882 |
|
7883 srcXOffset = srcWindow->xOffset; |
|
7884 srcYOffset = srcWindow->yOffset; |
|
7885 cropWidth = srcWindow->wndWidth; |
|
7886 cropHeight = srcWindow->wndHeight; |
|
7887 |
|
7888 dstXOffset = dstWindow->xOffset; |
|
7889 dstYOffset = dstWindow->yOffset; |
|
7890 wndWidth = dstWindow->wndWidth; |
|
7891 wndHeight = dstWindow->wndHeight; |
|
7892 |
|
7893 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
7894 { |
|
7895 lWidth = cropWidth; |
|
7896 } |
|
7897 else |
|
7898 { |
|
7899 lWidth = srcImage->width - srcXOffset; |
|
7900 } |
|
7901 |
|
7902 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
7903 { |
|
7904 lHeight = cropHeight; |
|
7905 } |
|
7906 else |
|
7907 { |
|
7908 lHeight = srcImage->height - srcYOffset; |
|
7909 } |
|
7910 |
|
7911 if (lWidth > (wndWidth - dstXOffset)) |
|
7912 { |
|
7913 lWidth = wndWidth - dstXOffset; |
|
7914 } |
|
7915 |
|
7916 if (lHeight > (wndHeight - dstYOffset)) |
|
7917 { |
|
7918 lHeight = wndHeight - dstYOffset; |
|
7919 } |
|
7920 |
|
7921 extraCol = lWidth & 0x01; |
|
7922 extraRow = lHeight & 0x01; |
|
7923 |
|
7924 lTempWidth = lWidth; |
|
7925 lWidth = (lWidth >> 1) << 1; |
|
7926 lHeight = (lHeight >> 1) << 1; |
|
7927 |
|
7928 lLumWidth = (srcImage->width >> 1) << 1; |
|
7929 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
7930 |
|
7931 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
7932 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
7933 |
|
7934 lLumWidth <<= 1; |
|
7935 |
|
7936 for(i = 0; i < lHeight; i += 2) |
|
7937 { |
|
7938 for(j = 0; j < lWidth; j += 2) |
|
7939 { |
|
7940 lCb = lYuyvPtr[0]; |
|
7941 lCr = lYuyvPtr[2]; |
|
7942 |
|
7943 lCr -= 128; |
|
7944 lCb -= 128; |
|
7945 |
|
7946 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
7947 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
7948 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
7949 |
|
7950 /*First Pixel*/ |
|
7951 lY1 = lYuyvPtr[1]; |
|
7952 lY1 -= 16; |
|
7953 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
7954 |
|
7955 /*B component*/ |
|
7956 lTemp = lY1 + lTemp3; |
|
7957 if (lTemp < 0) |
|
7958 lTemp = 0; |
|
7959 if (lTemp > 255) |
|
7960 lTemp = 255; |
|
7961 lTemp4 = (lTemp >> 4); |
|
7962 |
|
7963 /*G component*/ |
|
7964 lTemp = lY1 - lTemp2 + 15; |
|
7965 if (lTemp < 0) |
|
7966 lTemp = 0; |
|
7967 if (lTemp > 255) |
|
7968 lTemp = 255; |
|
7969 lTemp4 |= (lTemp >> 4) << 4; |
|
7970 |
|
7971 /*R component*/ |
|
7972 lTemp = lY1 + lTemp1 + 5; |
|
7973 if (lTemp < 0) |
|
7974 lTemp = 0; |
|
7975 if (lTemp > 255) |
|
7976 lTemp = 255; |
|
7977 lTemp4 |= (lTemp >> 4) << 8; |
|
7978 |
|
7979 lRGBFramePtr[0] = (uint16)lTemp4; |
|
7980 |
|
7981 /*Second Pixel*/ |
|
7982 lY1 = lYuyvPtr[3]; |
|
7983 lY1 -= 16; |
|
7984 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
7985 |
|
7986 /*B component*/ |
|
7987 lTemp = lY1 + lTemp3 + 10; |
|
7988 if (lTemp < 0) |
|
7989 lTemp = 0; |
|
7990 if (lTemp > 255) |
|
7991 lTemp = 255; |
|
7992 lTemp4 = (lTemp >> 4); |
|
7993 |
|
7994 /*G component*/ |
|
7995 lTemp = lY1 - lTemp2; |
|
7996 if (lTemp < 0) |
|
7997 lTemp = 0; |
|
7998 if (lTemp > 255) |
|
7999 lTemp = 255; |
|
8000 lTemp4 |= (lTemp >> 4) << 4; |
|
8001 |
|
8002 /*R component*/ |
|
8003 lTemp = lY1 + lTemp1 + 15; |
|
8004 if (lTemp < 0) |
|
8005 lTemp = 0; |
|
8006 if (lTemp > 255) |
|
8007 lTemp = 255; |
|
8008 lTemp4 |= (lTemp >> 4) << 8; |
|
8009 |
|
8010 lRGBFramePtr[1] = (uint16)lTemp4; |
|
8011 |
|
8012 |
|
8013 lCb = lYuyvPtr[lLumWidth]; |
|
8014 lCr = lYuyvPtr[lLumWidth + 2]; |
|
8015 |
|
8016 lCr -= 128; |
|
8017 lCb -= 128; |
|
8018 |
|
8019 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
8020 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
8021 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
8022 |
|
8023 /*Third Pixel*/ |
|
8024 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
8025 lY1 -= 16; |
|
8026 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
8027 |
|
8028 /*B component*/ |
|
8029 lTemp = lY1 + lTemp3 + 15; |
|
8030 if (lTemp < 0) |
|
8031 lTemp = 0; |
|
8032 if (lTemp > 255) |
|
8033 lTemp = 255; |
|
8034 lTemp4 = (lTemp >> 4); |
|
8035 |
|
8036 /*G component*/ |
|
8037 lTemp = lY1 - lTemp2 + 5; |
|
8038 if (lTemp < 0) |
|
8039 lTemp = 0; |
|
8040 if (lTemp > 255) |
|
8041 lTemp = 255; |
|
8042 lTemp4 |= (lTemp >> 4) << 4; |
|
8043 |
|
8044 /*R component*/ |
|
8045 lTemp = lY1 + lTemp1 + 10; |
|
8046 if (lTemp < 0) |
|
8047 lTemp = 0; |
|
8048 if (lTemp > 255) |
|
8049 lTemp = 255; |
|
8050 lTemp4 |= (lTemp >> 4) << 8; |
|
8051 |
|
8052 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
8053 |
|
8054 /*Fourth Pixel*/ |
|
8055 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
8056 lY1 -= 16; |
|
8057 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
8058 |
|
8059 /*B component*/ |
|
8060 lTemp = lY1 + lTemp3 + 5; |
|
8061 if (lTemp < 0) |
|
8062 lTemp = 0; |
|
8063 if (lTemp > 255) |
|
8064 lTemp = 255; |
|
8065 lTemp4 = (lTemp >> 4); |
|
8066 |
|
8067 /*G component*/ |
|
8068 lTemp = lY1 - lTemp2 + 10; |
|
8069 if (lTemp < 0) |
|
8070 lTemp = 0; |
|
8071 if (lTemp > 255) |
|
8072 lTemp = 255; |
|
8073 lTemp4 |= (lTemp >> 4) << 4; |
|
8074 |
|
8075 /*R component*/ |
|
8076 lTemp = lY1 + lTemp1; |
|
8077 if (lTemp < 0) |
|
8078 lTemp = 0; |
|
8079 if (lTemp > 255) |
|
8080 lTemp = 255; |
|
8081 lTemp4 |= (lTemp >> 4) << 8; |
|
8082 |
|
8083 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
8084 |
|
8085 lYuyvPtr += 4; |
|
8086 lRGBFramePtr += 2; |
|
8087 lRGBFramePtr1 += 2; |
|
8088 } |
|
8089 if(extraCol) |
|
8090 { |
|
8091 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
8092 lRGBFramePtr++; |
|
8093 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
8094 lRGBFramePtr1++; |
|
8095 } |
|
8096 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
8097 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
8098 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
8099 } |
|
8100 |
|
8101 if(extraRow) |
|
8102 { |
|
8103 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
8104 for(j = 0; j < lWidth; j += 2) |
|
8105 { |
|
8106 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
8107 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
8108 } |
|
8109 if(extraCol) |
|
8110 { |
|
8111 *lRGBFramePtr = *lRGBFramePtr1; |
|
8112 } |
|
8113 } |
|
8114 return; |
|
8115 } |
|
8116 |
|
8117 /* |
|
8118 ****************************************************************************** |
|
8119 Name : sEmz_VDec_YUV422BEChr2toColor4k_Ordered_601_5_RR |
|
8120 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
8121 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
8122 uint8 *dstImage : Pointer to rgb data (o/p). |
|
8123 tWndParam *srcWindow : Pointer to structure containing source window |
|
8124 parameters like xOffset,yOffset,cropWidth, |
|
8125 cropHeight. (i/p) |
|
8126 tWndParam *dstWindow : Pointer to structure containing destination window |
|
8127 parameters like xOffset,yOffset,windWidth, |
|
8128 windHeight. (i/p) |
|
8129 Return Value : void |
|
8130 ****************************************************************************** |
|
8131 */ |
|
8132 |
|
8133 void sEmz_VDec_YUV422BEChr2toColor4k_Ordered_601_5_RR |
|
8134 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
8135 tWndParam* srcWindow, tWndParam* dstWindow) |
|
8136 { |
|
8137 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
8138 uint8 *lYuyvPtr; |
|
8139 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
8140 int32 lY1, lCr, lCb; |
|
8141 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
8142 int32 i, j, extraCol, extraRow; |
|
8143 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
8144 cropWidth,cropHeight,wndWidth,wndHeight; |
|
8145 |
|
8146 srcXOffset = srcWindow->xOffset; |
|
8147 srcYOffset = srcWindow->yOffset; |
|
8148 cropWidth = srcWindow->wndWidth; |
|
8149 cropHeight = srcWindow->wndHeight; |
|
8150 |
|
8151 dstXOffset = dstWindow->xOffset; |
|
8152 dstYOffset = dstWindow->yOffset; |
|
8153 wndWidth = dstWindow->wndWidth; |
|
8154 wndHeight = dstWindow->wndHeight; |
|
8155 |
|
8156 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
8157 { |
|
8158 lWidth = cropWidth; |
|
8159 } |
|
8160 else |
|
8161 { |
|
8162 lWidth = srcImage->width - srcXOffset; |
|
8163 } |
|
8164 |
|
8165 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
8166 { |
|
8167 lHeight = cropHeight; |
|
8168 } |
|
8169 else |
|
8170 { |
|
8171 lHeight = srcImage->height - srcYOffset; |
|
8172 } |
|
8173 |
|
8174 if (lWidth > (wndWidth - dstXOffset)) |
|
8175 { |
|
8176 lWidth = wndWidth - dstXOffset; |
|
8177 } |
|
8178 |
|
8179 if (lHeight > (wndHeight - dstYOffset)) |
|
8180 { |
|
8181 lHeight = wndHeight - dstYOffset; |
|
8182 } |
|
8183 |
|
8184 extraCol = lWidth & 0x01; |
|
8185 extraRow = lHeight & 0x01; |
|
8186 |
|
8187 lTempWidth = lWidth; |
|
8188 lWidth = (lWidth >> 1) << 1; |
|
8189 lHeight = (lHeight >> 1) << 1; |
|
8190 |
|
8191 lLumWidth = (srcImage->width >> 1) << 1; |
|
8192 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
8193 |
|
8194 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
8195 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
8196 |
|
8197 lLumWidth <<= 1; |
|
8198 |
|
8199 for(i = 0; i < lHeight; i += 2) |
|
8200 { |
|
8201 for(j = 0; j < lWidth; j += 2) |
|
8202 { |
|
8203 lCb = lYuyvPtr[0]; |
|
8204 lCr = lYuyvPtr[2]; |
|
8205 |
|
8206 lCr -= 128; |
|
8207 lCb -= 128; |
|
8208 |
|
8209 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
8210 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
8211 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
8212 |
|
8213 /*First Pixel*/ |
|
8214 lY1 = lYuyvPtr[1]; |
|
8215 lY1 -= 16; |
|
8216 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
8217 |
|
8218 /*B component*/ |
|
8219 lTemp = lY1 + lTemp3; |
|
8220 if (lTemp < 0) |
|
8221 lTemp = 0; |
|
8222 if (lTemp > 255) |
|
8223 lTemp = 255; |
|
8224 lTemp4 = (lTemp >> 4); |
|
8225 |
|
8226 /*G component*/ |
|
8227 lTemp = lY1 - lTemp2 + 15; |
|
8228 if (lTemp < 0) |
|
8229 lTemp = 0; |
|
8230 if (lTemp > 255) |
|
8231 lTemp = 255; |
|
8232 lTemp4 |= (lTemp >> 4) << 4; |
|
8233 |
|
8234 /*R component*/ |
|
8235 lTemp = lY1 + lTemp1 + 5; |
|
8236 if (lTemp < 0) |
|
8237 lTemp = 0; |
|
8238 if (lTemp > 255) |
|
8239 lTemp = 255; |
|
8240 lTemp4 |= (lTemp >> 4) << 8; |
|
8241 |
|
8242 lRGBFramePtr[0] = (uint16)lTemp4; |
|
8243 |
|
8244 /*Second Pixel*/ |
|
8245 lY1 = lYuyvPtr[3]; |
|
8246 lY1 -= 16; |
|
8247 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
8248 |
|
8249 /*B component*/ |
|
8250 lTemp = lY1 + lTemp3 + 10; |
|
8251 if (lTemp < 0) |
|
8252 lTemp = 0; |
|
8253 if (lTemp > 255) |
|
8254 lTemp = 255; |
|
8255 lTemp4 = (lTemp >> 4); |
|
8256 |
|
8257 /*G component*/ |
|
8258 lTemp = lY1 - lTemp2; |
|
8259 if (lTemp < 0) |
|
8260 lTemp = 0; |
|
8261 if (lTemp > 255) |
|
8262 lTemp = 255; |
|
8263 lTemp4 |= (lTemp >> 4) << 4; |
|
8264 |
|
8265 /*R component*/ |
|
8266 lTemp = lY1 + lTemp1 + 15; |
|
8267 if (lTemp < 0) |
|
8268 lTemp = 0; |
|
8269 if (lTemp > 255) |
|
8270 lTemp = 255; |
|
8271 lTemp4 |= (lTemp >> 4) << 8; |
|
8272 |
|
8273 lRGBFramePtr[1] = (uint16)lTemp4; |
|
8274 |
|
8275 |
|
8276 lCb = lYuyvPtr[lLumWidth]; |
|
8277 lCr = lYuyvPtr[lLumWidth + 2]; |
|
8278 |
|
8279 lCr -= 128; |
|
8280 lCb -= 128; |
|
8281 |
|
8282 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
8283 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
8284 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
8285 |
|
8286 /*Third Pixel*/ |
|
8287 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
8288 lY1 -= 16; |
|
8289 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
8290 |
|
8291 /*B component*/ |
|
8292 lTemp = lY1 + lTemp3 + 15; |
|
8293 if (lTemp < 0) |
|
8294 lTemp = 0; |
|
8295 if (lTemp > 255) |
|
8296 lTemp = 255; |
|
8297 lTemp4 = (lTemp >> 4); |
|
8298 |
|
8299 /*G component*/ |
|
8300 lTemp = lY1 - lTemp2 + 5; |
|
8301 if (lTemp < 0) |
|
8302 lTemp = 0; |
|
8303 if (lTemp > 255) |
|
8304 lTemp = 255; |
|
8305 lTemp4 |= (lTemp >> 4) << 4; |
|
8306 |
|
8307 /*R component*/ |
|
8308 lTemp = lY1 + lTemp1 + 10; |
|
8309 if (lTemp < 0) |
|
8310 lTemp = 0; |
|
8311 if (lTemp > 255) |
|
8312 lTemp = 255; |
|
8313 lTemp4 |= (lTemp >> 4) << 8; |
|
8314 |
|
8315 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
8316 |
|
8317 /*Fourth Pixel*/ |
|
8318 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
8319 lY1 -= 16; |
|
8320 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
8321 |
|
8322 /*B component*/ |
|
8323 lTemp = lY1 + lTemp3 + 5; |
|
8324 if (lTemp < 0) |
|
8325 lTemp = 0; |
|
8326 if (lTemp > 255) |
|
8327 lTemp = 255; |
|
8328 lTemp4 = (lTemp >> 4); |
|
8329 |
|
8330 /*G component*/ |
|
8331 lTemp = lY1 - lTemp2 + 10; |
|
8332 if (lTemp < 0) |
|
8333 lTemp = 0; |
|
8334 if (lTemp > 255) |
|
8335 lTemp = 255; |
|
8336 lTemp4 |= (lTemp >> 4) << 4; |
|
8337 |
|
8338 /*R component*/ |
|
8339 lTemp = lY1 + lTemp1; |
|
8340 if (lTemp < 0) |
|
8341 lTemp = 0; |
|
8342 if (lTemp > 255) |
|
8343 lTemp = 255; |
|
8344 lTemp4 |= (lTemp >> 4) << 8; |
|
8345 |
|
8346 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
8347 |
|
8348 lYuyvPtr += 4; |
|
8349 lRGBFramePtr += 2; |
|
8350 lRGBFramePtr1 += 2; |
|
8351 } |
|
8352 if(extraCol) |
|
8353 { |
|
8354 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
8355 lRGBFramePtr++; |
|
8356 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
8357 lRGBFramePtr1++; |
|
8358 } |
|
8359 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
8360 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
8361 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
8362 } |
|
8363 |
|
8364 if(extraRow) |
|
8365 { |
|
8366 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
8367 for(j = 0; j < lWidth; j += 2) |
|
8368 { |
|
8369 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
8370 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
8371 } |
|
8372 if(extraCol) |
|
8373 { |
|
8374 *lRGBFramePtr = *lRGBFramePtr1; |
|
8375 } |
|
8376 } |
|
8377 return; |
|
8378 } |
|
8379 |
|
8380 /* |
|
8381 ****************************************************************************** |
|
8382 Name : sEmz_VDec_YUV422BEChr2toColor16MU_709_FR |
|
8383 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
8384 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
8385 uint8 *dstImage : Pointer to rgb data (o/p). |
|
8386 tWndParam *srcWindow : Pointer to structure containing source window |
|
8387 parameters like xOffset,yOffset,cropWidth, |
|
8388 cropHeight. (i/p) |
|
8389 tWndParam *dstWindow : Pointer to structure containing destination window |
|
8390 parameters like xOffset,yOffset,windWidth, |
|
8391 windHeight. (i/p) |
|
8392 Return Value : void |
|
8393 ****************************************************************************** |
|
8394 */ |
|
8395 |
|
8396 void sEmz_VDec_YUV422BEChr2toColor16MU_709_FR |
|
8397 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
8398 tWndParam* srcWindow, tWndParam* dstWindow) |
|
8399 { |
|
8400 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
8401 uint8 *lYuyvPtr; |
|
8402 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
8403 int32 lY1, lCr, lCb; |
|
8404 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
8405 int32 i, j, extraCol, extraRow; |
|
8406 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
8407 cropWidth,cropHeight,wndWidth,wndHeight; |
|
8408 |
|
8409 srcXOffset = srcWindow->xOffset; |
|
8410 srcYOffset = srcWindow->yOffset; |
|
8411 cropWidth = srcWindow->wndWidth; |
|
8412 cropHeight = srcWindow->wndHeight; |
|
8413 |
|
8414 dstXOffset = dstWindow->xOffset; |
|
8415 dstYOffset = dstWindow->yOffset; |
|
8416 wndWidth = dstWindow->wndWidth; |
|
8417 wndHeight = dstWindow->wndHeight; |
|
8418 |
|
8419 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
8420 { |
|
8421 lWidth = cropWidth; |
|
8422 } |
|
8423 else |
|
8424 { |
|
8425 lWidth = srcImage->width - srcXOffset; |
|
8426 } |
|
8427 |
|
8428 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
8429 { |
|
8430 lHeight = cropHeight; |
|
8431 } |
|
8432 else |
|
8433 { |
|
8434 lHeight = srcImage->height - srcYOffset; |
|
8435 } |
|
8436 |
|
8437 if (lWidth > (wndWidth - dstXOffset)) |
|
8438 { |
|
8439 lWidth = wndWidth - dstXOffset; |
|
8440 } |
|
8441 |
|
8442 if (lHeight > (wndHeight - dstYOffset)) |
|
8443 { |
|
8444 lHeight = wndHeight - dstYOffset; |
|
8445 } |
|
8446 |
|
8447 extraCol = lWidth & 0x01; |
|
8448 extraRow = lHeight & 0x01; |
|
8449 |
|
8450 lTempWidth = lWidth; |
|
8451 lWidth = (lWidth >> 1) << 1; |
|
8452 lHeight = (lHeight >> 1) << 1; |
|
8453 |
|
8454 lLumWidth = (srcImage->width >> 1) << 1; |
|
8455 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
8456 |
|
8457 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
8458 |
|
8459 for(i = 0; i < lHeight; i++) |
|
8460 { |
|
8461 for(j = 0; j < lWidth; j += 2) |
|
8462 { |
|
8463 lCb = lYuyvPtr[0]; |
|
8464 lCr = lYuyvPtr[2]; |
|
8465 |
|
8466 lCr -= 128; |
|
8467 lCb -= 128; |
|
8468 |
|
8469 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
8470 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
8471 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
8472 |
|
8473 /*First Pixel*/ |
|
8474 lY1 = lYuyvPtr[1]; |
|
8475 |
|
8476 /*B component*/ |
|
8477 lTemp = lY1 + lTemp3; |
|
8478 if (lTemp < 0) |
|
8479 lTemp = 0; |
|
8480 if (lTemp > 255) |
|
8481 lTemp = 255; |
|
8482 lTemp4 = (uint8) lTemp; |
|
8483 |
|
8484 /*G component*/ |
|
8485 lTemp = lY1 - lTemp2; |
|
8486 if (lTemp < 0) |
|
8487 lTemp = 0; |
|
8488 if (lTemp > 255) |
|
8489 lTemp = 255; |
|
8490 lTemp4 |= lTemp << 8; |
|
8491 |
|
8492 /*R component*/ |
|
8493 lTemp = lY1 + lTemp1; |
|
8494 if (lTemp < 0) |
|
8495 lTemp = 0; |
|
8496 if (lTemp > 255) |
|
8497 lTemp = 255; |
|
8498 lTemp4 |= lTemp << 16; |
|
8499 |
|
8500 lRGBFramePtr[0] = (uint32)lTemp4; |
|
8501 |
|
8502 /*Second Pixel*/ |
|
8503 lY1 = lYuyvPtr[3]; |
|
8504 |
|
8505 /*B component*/ |
|
8506 lTemp = lY1 + lTemp3; |
|
8507 if (lTemp < 0) |
|
8508 lTemp = 0; |
|
8509 if (lTemp > 255) |
|
8510 lTemp = 255; |
|
8511 lTemp4 = (uint8) lTemp; |
|
8512 |
|
8513 /*G component*/ |
|
8514 lTemp = lY1 - lTemp2; |
|
8515 if (lTemp < 0) |
|
8516 lTemp = 0; |
|
8517 if (lTemp > 255) |
|
8518 lTemp = 255; |
|
8519 lTemp4 |= lTemp << 8; |
|
8520 |
|
8521 /*R component*/ |
|
8522 lTemp = lY1 + lTemp1; |
|
8523 if (lTemp < 0) |
|
8524 lTemp = 0; |
|
8525 if (lTemp > 255) |
|
8526 lTemp = 255; |
|
8527 lTemp4 |= lTemp << 16; |
|
8528 |
|
8529 lRGBFramePtr[1] = (uint32)lTemp4; |
|
8530 |
|
8531 lYuyvPtr += 4; |
|
8532 lRGBFramePtr += 2; |
|
8533 } |
|
8534 if(extraCol) |
|
8535 { |
|
8536 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
8537 lRGBFramePtr++; |
|
8538 } |
|
8539 |
|
8540 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
8541 lRGBFramePtr += (wndWidth - lTempWidth); |
|
8542 } |
|
8543 |
|
8544 if(extraRow) |
|
8545 { |
|
8546 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
8547 for(j = 0; j < lWidth; j += 2) |
|
8548 { |
|
8549 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
8550 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
8551 } |
|
8552 if(extraCol) |
|
8553 { |
|
8554 *lRGBFramePtr = *lRGBFramePtr1; |
|
8555 } |
|
8556 } |
|
8557 return; |
|
8558 } |
|
8559 |
|
8560 /* |
|
8561 ****************************************************************************** |
|
8562 Name : sEmz_VDec_YUV422BEChr2toColor16MU_601_5_FR |
|
8563 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
8564 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
8565 uint8 *dstImage : Pointer to rgb data (o/p). |
|
8566 tWndParam *srcWindow : Pointer to structure containing source window |
|
8567 parameters like xOffset,yOffset,cropWidth, |
|
8568 cropHeight. (i/p) |
|
8569 tWndParam *dstWindow : Pointer to structure containing destination window |
|
8570 parameters like xOffset,yOffset,windWidth, |
|
8571 windHeight. (i/p) |
|
8572 Return Value : void |
|
8573 ****************************************************************************** |
|
8574 */ |
|
8575 |
|
8576 void sEmz_VDec_YUV422BEChr2toColor16MU_601_5_FR |
|
8577 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
8578 tWndParam* srcWindow, tWndParam* dstWindow) |
|
8579 { |
|
8580 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
8581 uint8 *lYuyvPtr; |
|
8582 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
8583 int32 lY1, lCr, lCb; |
|
8584 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
8585 int32 i, j, extraCol, extraRow; |
|
8586 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
8587 cropWidth,cropHeight,wndWidth,wndHeight; |
|
8588 |
|
8589 srcXOffset = srcWindow->xOffset; |
|
8590 srcYOffset = srcWindow->yOffset; |
|
8591 cropWidth = srcWindow->wndWidth; |
|
8592 cropHeight = srcWindow->wndHeight; |
|
8593 |
|
8594 dstXOffset = dstWindow->xOffset; |
|
8595 dstYOffset = dstWindow->yOffset; |
|
8596 wndWidth = dstWindow->wndWidth; |
|
8597 wndHeight = dstWindow->wndHeight; |
|
8598 |
|
8599 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
8600 { |
|
8601 lWidth = cropWidth; |
|
8602 } |
|
8603 else |
|
8604 { |
|
8605 lWidth = srcImage->width - srcXOffset; |
|
8606 } |
|
8607 |
|
8608 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
8609 { |
|
8610 lHeight = cropHeight; |
|
8611 } |
|
8612 else |
|
8613 { |
|
8614 lHeight = srcImage->height - srcYOffset; |
|
8615 } |
|
8616 |
|
8617 if (lWidth > (wndWidth - dstXOffset)) |
|
8618 { |
|
8619 lWidth = wndWidth - dstXOffset; |
|
8620 } |
|
8621 |
|
8622 if (lHeight > (wndHeight - dstYOffset)) |
|
8623 { |
|
8624 lHeight = wndHeight - dstYOffset; |
|
8625 } |
|
8626 |
|
8627 extraCol = lWidth & 0x01; |
|
8628 extraRow = lHeight & 0x01; |
|
8629 |
|
8630 lTempWidth = lWidth; |
|
8631 lWidth = (lWidth >> 1) << 1; |
|
8632 lHeight = (lHeight >> 1) << 1; |
|
8633 |
|
8634 lLumWidth = (srcImage->width >> 1) << 1; |
|
8635 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
8636 |
|
8637 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
8638 |
|
8639 for(i = 0; i < lHeight; i++) |
|
8640 { |
|
8641 for(j = 0; j < lWidth; j += 2) |
|
8642 { |
|
8643 lCb = lYuyvPtr[0]; |
|
8644 lCr = lYuyvPtr[2]; |
|
8645 |
|
8646 lCr -= 128; |
|
8647 lCb -= 128; |
|
8648 |
|
8649 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
8650 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
8651 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
8652 |
|
8653 /*First Pixel*/ |
|
8654 lY1 = lYuyvPtr[1]; |
|
8655 |
|
8656 /*B component*/ |
|
8657 lTemp = lY1 + lTemp3; |
|
8658 if (lTemp < 0) |
|
8659 lTemp = 0; |
|
8660 if (lTemp > 255) |
|
8661 lTemp = 255; |
|
8662 lTemp4 = (uint8) lTemp; |
|
8663 |
|
8664 /*G component*/ |
|
8665 lTemp = lY1 - lTemp2; |
|
8666 if (lTemp < 0) |
|
8667 lTemp = 0; |
|
8668 if (lTemp > 255) |
|
8669 lTemp = 255; |
|
8670 lTemp4 |= lTemp << 8; |
|
8671 |
|
8672 /*R component*/ |
|
8673 lTemp = lY1 + lTemp1; |
|
8674 if (lTemp < 0) |
|
8675 lTemp = 0; |
|
8676 if (lTemp > 255) |
|
8677 lTemp = 255; |
|
8678 lTemp4 |= lTemp << 16; |
|
8679 |
|
8680 lRGBFramePtr[0] = (uint32)lTemp4; |
|
8681 |
|
8682 /*Second Pixel*/ |
|
8683 lY1 = lYuyvPtr[3]; |
|
8684 |
|
8685 /*B component*/ |
|
8686 lTemp = lY1 + lTemp3; |
|
8687 if (lTemp < 0) |
|
8688 lTemp = 0; |
|
8689 if (lTemp > 255) |
|
8690 lTemp = 255; |
|
8691 lTemp4 = (uint8) lTemp; |
|
8692 |
|
8693 /*G component*/ |
|
8694 lTemp = lY1 - lTemp2; |
|
8695 if (lTemp < 0) |
|
8696 lTemp = 0; |
|
8697 if (lTemp > 255) |
|
8698 lTemp = 255; |
|
8699 lTemp4 |= lTemp << 8; |
|
8700 |
|
8701 /*R component*/ |
|
8702 lTemp = lY1 + lTemp1; |
|
8703 if (lTemp < 0) |
|
8704 lTemp = 0; |
|
8705 if (lTemp > 255) |
|
8706 lTemp = 255; |
|
8707 lTemp4 |= lTemp << 16; |
|
8708 |
|
8709 lRGBFramePtr[1] = (uint32)lTemp4; |
|
8710 |
|
8711 lYuyvPtr += 4; |
|
8712 lRGBFramePtr += 2; |
|
8713 } |
|
8714 if(extraCol) |
|
8715 { |
|
8716 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
8717 lRGBFramePtr++; |
|
8718 } |
|
8719 |
|
8720 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
8721 lRGBFramePtr += (wndWidth - lTempWidth); |
|
8722 } |
|
8723 |
|
8724 if(extraRow) |
|
8725 { |
|
8726 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
8727 for(j = 0; j < lWidth; j += 2) |
|
8728 { |
|
8729 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
8730 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
8731 } |
|
8732 if(extraCol) |
|
8733 { |
|
8734 *lRGBFramePtr = *lRGBFramePtr1; |
|
8735 } |
|
8736 } |
|
8737 return; |
|
8738 } |
|
8739 |
|
8740 /* |
|
8741 ****************************************************************************** |
|
8742 Name : sEmz_VDec_YUV422BEChr2toColor16MU_709_RR |
|
8743 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
8744 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
8745 uint8 *dstImage : Pointer to rgb data (o/p). |
|
8746 tWndParam *srcWindow : Pointer to structure containing source window |
|
8747 parameters like xOffset,yOffset,cropWidth, |
|
8748 cropHeight. (i/p) |
|
8749 tWndParam *dstWindow : Pointer to structure containing destination window |
|
8750 parameters like xOffset,yOffset,windWidth, |
|
8751 windHeight. (i/p) |
|
8752 Return Value : void |
|
8753 ****************************************************************************** |
|
8754 */ |
|
8755 |
|
8756 void sEmz_VDec_YUV422BEChr2toColor16MU_709_RR |
|
8757 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
8758 tWndParam* srcWindow, tWndParam* dstWindow) |
|
8759 { |
|
8760 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
8761 uint8 *lYuyvPtr; |
|
8762 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
8763 int32 lY1, lCr, lCb; |
|
8764 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
8765 int32 i, j, extraCol, extraRow; |
|
8766 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
8767 cropWidth,cropHeight,wndWidth,wndHeight; |
|
8768 |
|
8769 srcXOffset = srcWindow->xOffset; |
|
8770 srcYOffset = srcWindow->yOffset; |
|
8771 cropWidth = srcWindow->wndWidth; |
|
8772 cropHeight = srcWindow->wndHeight; |
|
8773 |
|
8774 dstXOffset = dstWindow->xOffset; |
|
8775 dstYOffset = dstWindow->yOffset; |
|
8776 wndWidth = dstWindow->wndWidth; |
|
8777 wndHeight = dstWindow->wndHeight; |
|
8778 |
|
8779 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
8780 { |
|
8781 lWidth = cropWidth; |
|
8782 } |
|
8783 else |
|
8784 { |
|
8785 lWidth = srcImage->width - srcXOffset; |
|
8786 } |
|
8787 |
|
8788 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
8789 { |
|
8790 lHeight = cropHeight; |
|
8791 } |
|
8792 else |
|
8793 { |
|
8794 lHeight = srcImage->height - srcYOffset; |
|
8795 } |
|
8796 |
|
8797 if (lWidth > (wndWidth - dstXOffset)) |
|
8798 { |
|
8799 lWidth = wndWidth - dstXOffset; |
|
8800 } |
|
8801 |
|
8802 if (lHeight > (wndHeight - dstYOffset)) |
|
8803 { |
|
8804 lHeight = wndHeight - dstYOffset; |
|
8805 } |
|
8806 |
|
8807 extraCol = lWidth & 0x01; |
|
8808 extraRow = lHeight & 0x01; |
|
8809 |
|
8810 lTempWidth = lWidth; |
|
8811 lWidth = (lWidth >> 1) << 1; |
|
8812 lHeight = (lHeight >> 1) << 1; |
|
8813 |
|
8814 lLumWidth = (srcImage->width >> 1) << 1; |
|
8815 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
8816 |
|
8817 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
8818 |
|
8819 for(i = 0; i < lHeight; i++) |
|
8820 { |
|
8821 for(j = 0; j < lWidth; j += 2) |
|
8822 { |
|
8823 lCb = lYuyvPtr[0]; |
|
8824 lCr = lYuyvPtr[2]; |
|
8825 |
|
8826 lCr -= 128; |
|
8827 lCb -= 128; |
|
8828 |
|
8829 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
8830 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
8831 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
8832 |
|
8833 /*First Pixel*/ |
|
8834 lY1 = lYuyvPtr[1]; |
|
8835 lY1 -= 16; |
|
8836 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
8837 |
|
8838 /*B component*/ |
|
8839 lTemp = lY1 + lTemp3; |
|
8840 if (lTemp < 0) |
|
8841 lTemp = 0; |
|
8842 if (lTemp > 255) |
|
8843 lTemp = 255; |
|
8844 lTemp4 = (uint8) lTemp; |
|
8845 |
|
8846 /*G component*/ |
|
8847 lTemp = lY1 - lTemp2; |
|
8848 if (lTemp < 0) |
|
8849 lTemp = 0; |
|
8850 if (lTemp > 255) |
|
8851 lTemp = 255; |
|
8852 lTemp4 |= lTemp << 8; |
|
8853 |
|
8854 /*R component*/ |
|
8855 lTemp = lY1 + lTemp1; |
|
8856 if (lTemp < 0) |
|
8857 lTemp = 0; |
|
8858 if (lTemp > 255) |
|
8859 lTemp = 255; |
|
8860 lTemp4 |= lTemp << 16; |
|
8861 |
|
8862 lRGBFramePtr[0] = (uint32)lTemp4; |
|
8863 |
|
8864 /*Second Pixel*/ |
|
8865 lY1 = lYuyvPtr[3]; |
|
8866 lY1 -= 16; |
|
8867 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
8868 |
|
8869 /*B component*/ |
|
8870 lTemp = lY1 + lTemp3; |
|
8871 if (lTemp < 0) |
|
8872 lTemp = 0; |
|
8873 if (lTemp > 255) |
|
8874 lTemp = 255; |
|
8875 lTemp4 = (uint8) lTemp; |
|
8876 |
|
8877 /*G component*/ |
|
8878 lTemp = lY1 - lTemp2; |
|
8879 if (lTemp < 0) |
|
8880 lTemp = 0; |
|
8881 if (lTemp > 255) |
|
8882 lTemp = 255; |
|
8883 lTemp4 |= lTemp << 8; |
|
8884 |
|
8885 /*R component*/ |
|
8886 lTemp = lY1 + lTemp1; |
|
8887 if (lTemp < 0) |
|
8888 lTemp = 0; |
|
8889 if (lTemp > 255) |
|
8890 lTemp = 255; |
|
8891 lTemp4 |= lTemp << 16; |
|
8892 |
|
8893 lRGBFramePtr[1] = (uint32)lTemp4; |
|
8894 |
|
8895 lYuyvPtr += 4; |
|
8896 lRGBFramePtr += 2; |
|
8897 } |
|
8898 if(extraCol) |
|
8899 { |
|
8900 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
8901 lRGBFramePtr++; |
|
8902 } |
|
8903 |
|
8904 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
8905 lRGBFramePtr += (wndWidth - lTempWidth); |
|
8906 } |
|
8907 |
|
8908 if(extraRow) |
|
8909 { |
|
8910 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
8911 for(j = 0; j < lWidth; j += 2) |
|
8912 { |
|
8913 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
8914 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
8915 } |
|
8916 if(extraCol) |
|
8917 { |
|
8918 *lRGBFramePtr = *lRGBFramePtr1; |
|
8919 } |
|
8920 } |
|
8921 return; |
|
8922 } |
|
8923 |
|
8924 /* |
|
8925 ****************************************************************************** |
|
8926 Name : sEmz_VDec_YUV422BEChr2toColor16MU_601_5_RR |
|
8927 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
8928 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
8929 uint8 *dstImage : Pointer to rgb data (o/p). |
|
8930 tWndParam *srcWindow : Pointer to structure containing source window |
|
8931 parameters like xOffset,yOffset,cropWidth, |
|
8932 cropHeight. (i/p) |
|
8933 tWndParam *dstWindow : Pointer to structure containing destination window |
|
8934 parameters like xOffset,yOffset,windWidth, |
|
8935 windHeight. (i/p) |
|
8936 Return Value : void |
|
8937 ****************************************************************************** |
|
8938 */ |
|
8939 |
|
8940 void sEmz_VDec_YUV422BEChr2toColor16MU_601_5_RR |
|
8941 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
8942 tWndParam* srcWindow, tWndParam* dstWindow) |
|
8943 { |
|
8944 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
8945 uint8 *lYuyvPtr; |
|
8946 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
8947 int32 lY1, lCr, lCb; |
|
8948 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
8949 int32 i, j, extraCol, extraRow; |
|
8950 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
8951 cropWidth,cropHeight,wndWidth,wndHeight; |
|
8952 |
|
8953 srcXOffset = srcWindow->xOffset; |
|
8954 srcYOffset = srcWindow->yOffset; |
|
8955 cropWidth = srcWindow->wndWidth; |
|
8956 cropHeight = srcWindow->wndHeight; |
|
8957 |
|
8958 dstXOffset = dstWindow->xOffset; |
|
8959 dstYOffset = dstWindow->yOffset; |
|
8960 wndWidth = dstWindow->wndWidth; |
|
8961 wndHeight = dstWindow->wndHeight; |
|
8962 |
|
8963 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
8964 { |
|
8965 lWidth = cropWidth; |
|
8966 } |
|
8967 else |
|
8968 { |
|
8969 lWidth = srcImage->width - srcXOffset; |
|
8970 } |
|
8971 |
|
8972 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
8973 { |
|
8974 lHeight = cropHeight; |
|
8975 } |
|
8976 else |
|
8977 { |
|
8978 lHeight = srcImage->height - srcYOffset; |
|
8979 } |
|
8980 |
|
8981 if (lWidth > (wndWidth - dstXOffset)) |
|
8982 { |
|
8983 lWidth = wndWidth - dstXOffset; |
|
8984 } |
|
8985 |
|
8986 if (lHeight > (wndHeight - dstYOffset)) |
|
8987 { |
|
8988 lHeight = wndHeight - dstYOffset; |
|
8989 } |
|
8990 |
|
8991 extraCol = lWidth & 0x01; |
|
8992 extraRow = lHeight & 0x01; |
|
8993 |
|
8994 lTempWidth = lWidth; |
|
8995 lWidth = (lWidth >> 1) << 1; |
|
8996 lHeight = (lHeight >> 1) << 1; |
|
8997 |
|
8998 lLumWidth = (srcImage->width >> 1) << 1; |
|
8999 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
9000 |
|
9001 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
9002 |
|
9003 for(i = 0; i < lHeight; i++) |
|
9004 { |
|
9005 for(j = 0; j < lWidth; j += 2) |
|
9006 { |
|
9007 lCb = lYuyvPtr[0]; |
|
9008 lCr = lYuyvPtr[2]; |
|
9009 |
|
9010 lCr -= 128; |
|
9011 lCb -= 128; |
|
9012 |
|
9013 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
9014 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
9015 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
9016 |
|
9017 /*First Pixel*/ |
|
9018 lY1 = lYuyvPtr[1]; |
|
9019 lY1 -= 16; |
|
9020 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
9021 |
|
9022 /*B component*/ |
|
9023 lTemp = lY1 + lTemp3; |
|
9024 if (lTemp < 0) |
|
9025 lTemp = 0; |
|
9026 if (lTemp > 255) |
|
9027 lTemp = 255; |
|
9028 lTemp4 = (uint8) lTemp; |
|
9029 |
|
9030 /*G component*/ |
|
9031 lTemp = lY1 - lTemp2; |
|
9032 if (lTemp < 0) |
|
9033 lTemp = 0; |
|
9034 if (lTemp > 255) |
|
9035 lTemp = 255; |
|
9036 lTemp4 |= lTemp << 8; |
|
9037 |
|
9038 /*R component*/ |
|
9039 lTemp = lY1 + lTemp1; |
|
9040 if (lTemp < 0) |
|
9041 lTemp = 0; |
|
9042 if (lTemp > 255) |
|
9043 lTemp = 255; |
|
9044 lTemp4 |= lTemp << 16; |
|
9045 |
|
9046 lRGBFramePtr[0] = (uint32)lTemp4; |
|
9047 |
|
9048 /*Second Pixel*/ |
|
9049 lY1 = lYuyvPtr[3]; |
|
9050 lY1 -= 16; |
|
9051 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
9052 |
|
9053 /*B component*/ |
|
9054 lTemp = lY1 + lTemp3; |
|
9055 if (lTemp < 0) |
|
9056 lTemp = 0; |
|
9057 if (lTemp > 255) |
|
9058 lTemp = 255; |
|
9059 lTemp4 = (uint8) lTemp; |
|
9060 |
|
9061 /*G component*/ |
|
9062 lTemp = lY1 - lTemp2; |
|
9063 if (lTemp < 0) |
|
9064 lTemp = 0; |
|
9065 if (lTemp > 255) |
|
9066 lTemp = 255; |
|
9067 lTemp4 |= lTemp << 8; |
|
9068 |
|
9069 /*R component*/ |
|
9070 lTemp = lY1 + lTemp1; |
|
9071 if (lTemp < 0) |
|
9072 lTemp = 0; |
|
9073 if (lTemp > 255) |
|
9074 lTemp = 255; |
|
9075 lTemp4 |= lTemp << 16; |
|
9076 |
|
9077 lRGBFramePtr[1] = (uint32)lTemp4; |
|
9078 |
|
9079 lYuyvPtr += 4; |
|
9080 lRGBFramePtr += 2; |
|
9081 } |
|
9082 if(extraCol) |
|
9083 { |
|
9084 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
9085 lRGBFramePtr++; |
|
9086 } |
|
9087 |
|
9088 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
9089 lRGBFramePtr += (wndWidth - lTempWidth); |
|
9090 } |
|
9091 |
|
9092 if(extraRow) |
|
9093 { |
|
9094 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
9095 for(j = 0; j < lWidth; j += 2) |
|
9096 { |
|
9097 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
9098 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
9099 } |
|
9100 if(extraCol) |
|
9101 { |
|
9102 *lRGBFramePtr = *lRGBFramePtr1; |
|
9103 } |
|
9104 } |
|
9105 return; |
|
9106 } |
|
9107 |
|
9108 /***** End of YUV422BE input ****/ |
|
9109 |
|
9110 |
|
9111 |
|
9112 /**** Start of YUV422LE input *****/ |
|
9113 /* |
|
9114 ****************************************************************************** |
|
9115 Name : sEmz_VDec_YUV422LEChr2toColor64k_Ordered_709_FR |
|
9116 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
9117 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
9118 uint8 *dstImage : Pointer to rgb data (o/p). |
|
9119 tWndParam *srcWindow : Pointer to structure containing source window |
|
9120 parameters like xOffset,yOffset,cropWidth, |
|
9121 cropHeight. (i/p) |
|
9122 tWndParam *dstWindow : Pointer to structure containing destination window |
|
9123 parameters like xOffset,yOffset,windWidth, |
|
9124 windHeight. (i/p) |
|
9125 Return Value : void |
|
9126 ****************************************************************************** |
|
9127 */ |
|
9128 |
|
9129 void sEmz_VDec_YUV422LEChr2toColor64k_Ordered_709_FR |
|
9130 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
9131 tWndParam* srcWindow, tWndParam* dstWindow) |
|
9132 { |
|
9133 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
9134 uint8 *lYuyvPtr; |
|
9135 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
9136 int32 lY1, lCr, lCb; |
|
9137 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
9138 int32 i, j, extraCol, extraRow; |
|
9139 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
9140 cropWidth,cropHeight,wndWidth,wndHeight; |
|
9141 |
|
9142 srcXOffset = srcWindow->xOffset; |
|
9143 srcYOffset = srcWindow->yOffset; |
|
9144 cropWidth = srcWindow->wndWidth; |
|
9145 cropHeight = srcWindow->wndHeight; |
|
9146 |
|
9147 dstXOffset = dstWindow->xOffset; |
|
9148 dstYOffset = dstWindow->yOffset; |
|
9149 wndWidth = dstWindow->wndWidth; |
|
9150 wndHeight = dstWindow->wndHeight; |
|
9151 |
|
9152 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
9153 { |
|
9154 lWidth = cropWidth; |
|
9155 } |
|
9156 else |
|
9157 { |
|
9158 lWidth = srcImage->width - srcXOffset; |
|
9159 } |
|
9160 |
|
9161 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
9162 { |
|
9163 lHeight = cropHeight; |
|
9164 } |
|
9165 else |
|
9166 { |
|
9167 lHeight = srcImage->height - srcYOffset; |
|
9168 } |
|
9169 |
|
9170 if (lWidth > (wndWidth - dstXOffset)) |
|
9171 { |
|
9172 lWidth = wndWidth - dstXOffset; |
|
9173 } |
|
9174 |
|
9175 if (lHeight > (wndHeight - dstYOffset)) |
|
9176 { |
|
9177 lHeight = wndHeight - dstYOffset; |
|
9178 } |
|
9179 |
|
9180 extraCol = lWidth & 0x01; |
|
9181 extraRow = lHeight & 0x01; |
|
9182 |
|
9183 lTempWidth = lWidth; |
|
9184 lWidth = (lWidth >> 1) << 1; |
|
9185 lHeight = (lHeight >> 1) << 1; |
|
9186 |
|
9187 lLumWidth = (srcImage->width >> 1) << 1; |
|
9188 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
9189 |
|
9190 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
9191 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
9192 |
|
9193 lLumWidth <<= 1; |
|
9194 |
|
9195 for(i = 0; i < lHeight; i += 2) |
|
9196 { |
|
9197 for(j = 0; j < lWidth; j += 2) |
|
9198 { |
|
9199 lCb = lYuyvPtr[3]; |
|
9200 lCr = lYuyvPtr[1]; |
|
9201 |
|
9202 lCr -= 128; |
|
9203 lCb -= 128; |
|
9204 |
|
9205 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
9206 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
9207 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
9208 |
|
9209 /*First Pixel*/ |
|
9210 lY1 = lYuyvPtr[2]; |
|
9211 |
|
9212 /*B component*/ |
|
9213 lTemp = lY1 + lTemp3; |
|
9214 if (lTemp < 0) |
|
9215 lTemp = 0; |
|
9216 if (lTemp > 255) |
|
9217 lTemp = 255; |
|
9218 lTemp4 = (lTemp >> 3); |
|
9219 |
|
9220 /*G component*/ |
|
9221 lTemp = lY1 - lTemp2 + 3; |
|
9222 if (lTemp < 0) |
|
9223 lTemp = 0; |
|
9224 if (lTemp > 255) |
|
9225 lTemp = 255; |
|
9226 lTemp4 |= (lTemp >> 2) << 5; |
|
9227 |
|
9228 /*R component*/ |
|
9229 lTemp = lY1 + lTemp1 + 2; |
|
9230 if (lTemp < 0) |
|
9231 lTemp = 0; |
|
9232 if (lTemp > 255) |
|
9233 lTemp = 255; |
|
9234 lTemp4 |= (lTemp >> 3) << 11; |
|
9235 |
|
9236 lRGBFramePtr[0] = (uint16)lTemp4; |
|
9237 |
|
9238 /*Second Pixel*/ |
|
9239 lY1 = lYuyvPtr[0]; |
|
9240 |
|
9241 /*B component*/ |
|
9242 lTemp = lY1 + lTemp3 + 4; |
|
9243 if (lTemp < 0) |
|
9244 lTemp = 0; |
|
9245 if (lTemp > 255) |
|
9246 lTemp = 255; |
|
9247 lTemp4 = (lTemp >> 3); |
|
9248 |
|
9249 /*G component*/ |
|
9250 lTemp = lY1 - lTemp2; |
|
9251 if (lTemp < 0) |
|
9252 lTemp = 0; |
|
9253 if (lTemp > 255) |
|
9254 lTemp = 255; |
|
9255 lTemp4 |= (lTemp >> 2) << 5; |
|
9256 |
|
9257 /*R component*/ |
|
9258 lTemp = lY1 + lTemp1 + 6; |
|
9259 if (lTemp < 0) |
|
9260 lTemp = 0; |
|
9261 if (lTemp > 255) |
|
9262 lTemp = 255; |
|
9263 lTemp4 |= (lTemp >> 3) << 11; |
|
9264 |
|
9265 lRGBFramePtr[1] = (uint16)lTemp4; |
|
9266 |
|
9267 |
|
9268 lCb = lYuyvPtr[lLumWidth + 3]; |
|
9269 lCr = lYuyvPtr[lLumWidth + 1]; |
|
9270 |
|
9271 lCr -= 128; |
|
9272 lCb -= 128; |
|
9273 |
|
9274 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
9275 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
9276 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
9277 |
|
9278 /*Third Pixel*/ |
|
9279 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
9280 |
|
9281 /*B component*/ |
|
9282 lTemp = lY1 + lTemp3 + 6; |
|
9283 if (lTemp < 0) |
|
9284 lTemp = 0; |
|
9285 if (lTemp > 255) |
|
9286 lTemp = 255; |
|
9287 lTemp4 = (lTemp >> 3); |
|
9288 |
|
9289 /*G component*/ |
|
9290 lTemp = lY1 - lTemp2 + 1; |
|
9291 if (lTemp < 0) |
|
9292 lTemp = 0; |
|
9293 if (lTemp > 255) |
|
9294 lTemp = 255; |
|
9295 lTemp4 |= (lTemp >> 2) << 5; |
|
9296 |
|
9297 /*R component*/ |
|
9298 lTemp = lY1 + lTemp1 + 4; |
|
9299 if (lTemp < 0) |
|
9300 lTemp = 0; |
|
9301 if (lTemp > 255) |
|
9302 lTemp = 255; |
|
9303 lTemp4 |= (lTemp >> 3) << 11; |
|
9304 |
|
9305 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
9306 |
|
9307 /*Fourth Pixel*/ |
|
9308 lY1 = lYuyvPtr[lLumWidth]; |
|
9309 |
|
9310 /*B component*/ |
|
9311 lTemp = lY1 + lTemp3 + 2; |
|
9312 if (lTemp < 0) |
|
9313 lTemp = 0; |
|
9314 if (lTemp > 255) |
|
9315 lTemp = 255; |
|
9316 lTemp4 = (lTemp >> 3); |
|
9317 |
|
9318 /*G component*/ |
|
9319 lTemp = lY1 - lTemp2 + 2; |
|
9320 if (lTemp < 0) |
|
9321 lTemp = 0; |
|
9322 if (lTemp > 255) |
|
9323 lTemp = 255; |
|
9324 lTemp4 |= (lTemp >> 2) << 5; |
|
9325 |
|
9326 /*R component*/ |
|
9327 lTemp = lY1 + lTemp1; |
|
9328 if (lTemp < 0) |
|
9329 lTemp = 0; |
|
9330 if (lTemp > 255) |
|
9331 lTemp = 255; |
|
9332 lTemp4 |= (lTemp >> 3) << 11; |
|
9333 |
|
9334 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
9335 |
|
9336 lYuyvPtr += 4; |
|
9337 lRGBFramePtr += 2; |
|
9338 lRGBFramePtr1 += 2; |
|
9339 } |
|
9340 if(extraCol) |
|
9341 { |
|
9342 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
9343 lRGBFramePtr++; |
|
9344 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
9345 lRGBFramePtr1++; |
|
9346 } |
|
9347 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
9348 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
9349 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
9350 } |
|
9351 |
|
9352 if(extraRow) |
|
9353 { |
|
9354 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
9355 for(j = 0; j < lWidth; j += 2) |
|
9356 { |
|
9357 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
9358 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
9359 } |
|
9360 if(extraCol) |
|
9361 { |
|
9362 *lRGBFramePtr = *lRGBFramePtr1; |
|
9363 } |
|
9364 } |
|
9365 return; |
|
9366 } |
|
9367 |
|
9368 /* |
|
9369 ****************************************************************************** |
|
9370 Name : sEmz_VDec_YUV422LEChr2toColor64k_Ordered_601_5_FR |
|
9371 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
9372 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
9373 uint8 *dstImage : Pointer to rgb data (o/p). |
|
9374 tWndParam *srcWindow : Pointer to structure containing source window |
|
9375 parameters like xOffset,yOffset,cropWidth, |
|
9376 cropHeight. (i/p) |
|
9377 tWndParam *dstWindow : Pointer to structure containing destination window |
|
9378 parameters like xOffset,yOffset,windWidth, |
|
9379 windHeight. (i/p) |
|
9380 Return Value : void |
|
9381 ****************************************************************************** |
|
9382 */ |
|
9383 |
|
9384 void sEmz_VDec_YUV422LEChr2toColor64k_Ordered_601_5_FR |
|
9385 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
9386 tWndParam* srcWindow, tWndParam* dstWindow) |
|
9387 { |
|
9388 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
9389 uint8 *lYuyvPtr; |
|
9390 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
9391 int32 lY1, lCr, lCb; |
|
9392 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
9393 int32 i, j, extraCol, extraRow; |
|
9394 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
9395 cropWidth,cropHeight,wndWidth,wndHeight; |
|
9396 |
|
9397 srcXOffset = srcWindow->xOffset; |
|
9398 srcYOffset = srcWindow->yOffset; |
|
9399 cropWidth = srcWindow->wndWidth; |
|
9400 cropHeight = srcWindow->wndHeight; |
|
9401 |
|
9402 dstXOffset = dstWindow->xOffset; |
|
9403 dstYOffset = dstWindow->yOffset; |
|
9404 wndWidth = dstWindow->wndWidth; |
|
9405 wndHeight = dstWindow->wndHeight; |
|
9406 |
|
9407 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
9408 { |
|
9409 lWidth = cropWidth; |
|
9410 } |
|
9411 else |
|
9412 { |
|
9413 lWidth = srcImage->width - srcXOffset; |
|
9414 } |
|
9415 |
|
9416 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
9417 { |
|
9418 lHeight = cropHeight; |
|
9419 } |
|
9420 else |
|
9421 { |
|
9422 lHeight = srcImage->height - srcYOffset; |
|
9423 } |
|
9424 |
|
9425 if (lWidth > (wndWidth - dstXOffset)) |
|
9426 { |
|
9427 lWidth = wndWidth - dstXOffset; |
|
9428 } |
|
9429 |
|
9430 if (lHeight > (wndHeight - dstYOffset)) |
|
9431 { |
|
9432 lHeight = wndHeight - dstYOffset; |
|
9433 } |
|
9434 |
|
9435 extraCol = lWidth & 0x01; |
|
9436 extraRow = lHeight & 0x01; |
|
9437 |
|
9438 lTempWidth = lWidth; |
|
9439 lWidth = (lWidth >> 1) << 1; |
|
9440 lHeight = (lHeight >> 1) << 1; |
|
9441 |
|
9442 lLumWidth = (srcImage->width >> 1) << 1; |
|
9443 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
9444 |
|
9445 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
9446 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
9447 |
|
9448 lLumWidth <<= 1; |
|
9449 |
|
9450 for(i = 0; i < lHeight; i += 2) |
|
9451 { |
|
9452 for(j = 0; j < lWidth; j += 2) |
|
9453 { |
|
9454 lCb = lYuyvPtr[3]; |
|
9455 lCr = lYuyvPtr[1]; |
|
9456 |
|
9457 lCr -= 128; |
|
9458 lCb -= 128; |
|
9459 |
|
9460 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
9461 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
9462 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
9463 |
|
9464 /*First Pixel*/ |
|
9465 lY1 = lYuyvPtr[2]; |
|
9466 |
|
9467 /*B component*/ |
|
9468 lTemp = lY1 + lTemp3; |
|
9469 if (lTemp < 0) |
|
9470 lTemp = 0; |
|
9471 if (lTemp > 255) |
|
9472 lTemp = 255; |
|
9473 lTemp4 = (lTemp >> 3); |
|
9474 |
|
9475 /*G component*/ |
|
9476 lTemp = lY1 - lTemp2 + 3; |
|
9477 if (lTemp < 0) |
|
9478 lTemp = 0; |
|
9479 if (lTemp > 255) |
|
9480 lTemp = 255; |
|
9481 lTemp4 |= (lTemp >> 2) << 5; |
|
9482 |
|
9483 /*R component*/ |
|
9484 lTemp = lY1 + lTemp1 + 2; |
|
9485 if (lTemp < 0) |
|
9486 lTemp = 0; |
|
9487 if (lTemp > 255) |
|
9488 lTemp = 255; |
|
9489 lTemp4 |= (lTemp >> 3) << 11; |
|
9490 |
|
9491 lRGBFramePtr[0] = (uint16)lTemp4; |
|
9492 |
|
9493 /*Second Pixel*/ |
|
9494 lY1 = lYuyvPtr[0]; |
|
9495 |
|
9496 /*B component*/ |
|
9497 lTemp = lY1 + lTemp3 + 4; |
|
9498 if (lTemp < 0) |
|
9499 lTemp = 0; |
|
9500 if (lTemp > 255) |
|
9501 lTemp = 255; |
|
9502 lTemp4 = (lTemp >> 3); |
|
9503 |
|
9504 /*G component*/ |
|
9505 lTemp = lY1 - lTemp2; |
|
9506 if (lTemp < 0) |
|
9507 lTemp = 0; |
|
9508 if (lTemp > 255) |
|
9509 lTemp = 255; |
|
9510 lTemp4 |= (lTemp >> 2) << 5; |
|
9511 |
|
9512 /*R component*/ |
|
9513 lTemp = lY1 + lTemp1 + 6; |
|
9514 if (lTemp < 0) |
|
9515 lTemp = 0; |
|
9516 if (lTemp > 255) |
|
9517 lTemp = 255; |
|
9518 lTemp4 |= (lTemp >> 3) << 11; |
|
9519 |
|
9520 lRGBFramePtr[1] = (uint16)lTemp4; |
|
9521 |
|
9522 |
|
9523 lCb = lYuyvPtr[lLumWidth + 3]; |
|
9524 lCr = lYuyvPtr[lLumWidth + 1]; |
|
9525 |
|
9526 lCr -= 128; |
|
9527 lCb -= 128; |
|
9528 |
|
9529 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
9530 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
9531 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
9532 |
|
9533 /*Third Pixel*/ |
|
9534 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
9535 |
|
9536 /*B component*/ |
|
9537 lTemp = lY1 + lTemp3 + 6; |
|
9538 if (lTemp < 0) |
|
9539 lTemp = 0; |
|
9540 if (lTemp > 255) |
|
9541 lTemp = 255; |
|
9542 lTemp4 = (lTemp >> 3); |
|
9543 |
|
9544 /*G component*/ |
|
9545 lTemp = lY1 - lTemp2 + 1; |
|
9546 if (lTemp < 0) |
|
9547 lTemp = 0; |
|
9548 if (lTemp > 255) |
|
9549 lTemp = 255; |
|
9550 lTemp4 |= (lTemp >> 2) << 5; |
|
9551 |
|
9552 /*R component*/ |
|
9553 lTemp = lY1 + lTemp1 + 4; |
|
9554 if (lTemp < 0) |
|
9555 lTemp = 0; |
|
9556 if (lTemp > 255) |
|
9557 lTemp = 255; |
|
9558 lTemp4 |= (lTemp >> 3) << 11; |
|
9559 |
|
9560 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
9561 |
|
9562 /*Fourth Pixel*/ |
|
9563 lY1 = lYuyvPtr[lLumWidth]; |
|
9564 |
|
9565 /*B component*/ |
|
9566 lTemp = lY1 + lTemp3 + 2; |
|
9567 if (lTemp < 0) |
|
9568 lTemp = 0; |
|
9569 if (lTemp > 255) |
|
9570 lTemp = 255; |
|
9571 lTemp4 = (lTemp >> 3); |
|
9572 |
|
9573 /*G component*/ |
|
9574 lTemp = lY1 - lTemp2 + 2; |
|
9575 if (lTemp < 0) |
|
9576 lTemp = 0; |
|
9577 if (lTemp > 255) |
|
9578 lTemp = 255; |
|
9579 lTemp4 |= (lTemp >> 2) << 5; |
|
9580 |
|
9581 /*R component*/ |
|
9582 lTemp = lY1 + lTemp1; |
|
9583 if (lTemp < 0) |
|
9584 lTemp = 0; |
|
9585 if (lTemp > 255) |
|
9586 lTemp = 255; |
|
9587 lTemp4 |= (lTemp >> 3) << 11; |
|
9588 |
|
9589 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
9590 |
|
9591 lYuyvPtr += 4; |
|
9592 lRGBFramePtr += 2; |
|
9593 lRGBFramePtr1 += 2; |
|
9594 } |
|
9595 if(extraCol) |
|
9596 { |
|
9597 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
9598 lRGBFramePtr++; |
|
9599 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
9600 lRGBFramePtr1++; |
|
9601 } |
|
9602 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
9603 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
9604 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
9605 } |
|
9606 |
|
9607 if(extraRow) |
|
9608 { |
|
9609 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
9610 for(j = 0; j < lWidth; j += 2) |
|
9611 { |
|
9612 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
9613 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
9614 } |
|
9615 if(extraCol) |
|
9616 { |
|
9617 *lRGBFramePtr = *lRGBFramePtr1; |
|
9618 } |
|
9619 } |
|
9620 return; |
|
9621 } |
|
9622 |
|
9623 /* |
|
9624 ****************************************************************************** |
|
9625 Name : sEmz_VDec_YUV422LEChr2toColor64k_Ordered_709_RR |
|
9626 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
9627 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
9628 uint8 *dstImage : Pointer to rgb data (o/p). |
|
9629 tWndParam *srcWindow : Pointer to structure containing source window |
|
9630 parameters like xOffset,yOffset,cropWidth, |
|
9631 cropHeight. (i/p) |
|
9632 tWndParam *dstWindow : Pointer to structure containing destination window |
|
9633 parameters like xOffset,yOffset,windWidth, |
|
9634 windHeight. (i/p) |
|
9635 Return Value : void |
|
9636 ****************************************************************************** |
|
9637 */ |
|
9638 |
|
9639 void sEmz_VDec_YUV422LEChr2toColor64k_Ordered_709_RR |
|
9640 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
9641 tWndParam* srcWindow, tWndParam* dstWindow) |
|
9642 { |
|
9643 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
9644 uint8 *lYuyvPtr; |
|
9645 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
9646 int32 lY1, lCr, lCb; |
|
9647 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
9648 int32 i, j, extraCol, extraRow; |
|
9649 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
9650 cropWidth,cropHeight,wndWidth,wndHeight; |
|
9651 |
|
9652 srcXOffset = srcWindow->xOffset; |
|
9653 srcYOffset = srcWindow->yOffset; |
|
9654 cropWidth = srcWindow->wndWidth; |
|
9655 cropHeight = srcWindow->wndHeight; |
|
9656 |
|
9657 dstXOffset = dstWindow->xOffset; |
|
9658 dstYOffset = dstWindow->yOffset; |
|
9659 wndWidth = dstWindow->wndWidth; |
|
9660 wndHeight = dstWindow->wndHeight; |
|
9661 |
|
9662 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
9663 { |
|
9664 lWidth = cropWidth; |
|
9665 } |
|
9666 else |
|
9667 { |
|
9668 lWidth = srcImage->width - srcXOffset; |
|
9669 } |
|
9670 |
|
9671 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
9672 { |
|
9673 lHeight = cropHeight; |
|
9674 } |
|
9675 else |
|
9676 { |
|
9677 lHeight = srcImage->height - srcYOffset; |
|
9678 } |
|
9679 |
|
9680 if (lWidth > (wndWidth - dstXOffset)) |
|
9681 { |
|
9682 lWidth = wndWidth - dstXOffset; |
|
9683 } |
|
9684 |
|
9685 if (lHeight > (wndHeight - dstYOffset)) |
|
9686 { |
|
9687 lHeight = wndHeight - dstYOffset; |
|
9688 } |
|
9689 |
|
9690 extraCol = lWidth & 0x01; |
|
9691 extraRow = lHeight & 0x01; |
|
9692 |
|
9693 lTempWidth = lWidth; |
|
9694 lWidth = (lWidth >> 1) << 1; |
|
9695 lHeight = (lHeight >> 1) << 1; |
|
9696 |
|
9697 lLumWidth = (srcImage->width >> 1) << 1; |
|
9698 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
9699 |
|
9700 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
9701 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
9702 |
|
9703 lLumWidth <<= 1; |
|
9704 |
|
9705 for(i = 0; i < lHeight; i += 2) |
|
9706 { |
|
9707 for(j = 0; j < lWidth; j += 2) |
|
9708 { |
|
9709 lCb = lYuyvPtr[3]; |
|
9710 lCr = lYuyvPtr[1]; |
|
9711 |
|
9712 lCr -= 128; |
|
9713 lCb -= 128; |
|
9714 |
|
9715 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
9716 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
9717 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
9718 |
|
9719 /*First Pixel*/ |
|
9720 lY1 = lYuyvPtr[2]; |
|
9721 lY1 -= 16; |
|
9722 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
9723 |
|
9724 /*B component*/ |
|
9725 lTemp = lY1 + lTemp3; |
|
9726 if (lTemp < 0) |
|
9727 lTemp = 0; |
|
9728 if (lTemp > 255) |
|
9729 lTemp = 255; |
|
9730 lTemp4 = (lTemp >> 3); |
|
9731 |
|
9732 /*G component*/ |
|
9733 lTemp = lY1 - lTemp2 + 3; |
|
9734 if (lTemp < 0) |
|
9735 lTemp = 0; |
|
9736 if (lTemp > 255) |
|
9737 lTemp = 255; |
|
9738 lTemp4 |= (lTemp >> 2) << 5; |
|
9739 |
|
9740 /*R component*/ |
|
9741 lTemp = lY1 + lTemp1 + 2; |
|
9742 if (lTemp < 0) |
|
9743 lTemp = 0; |
|
9744 if (lTemp > 255) |
|
9745 lTemp = 255; |
|
9746 lTemp4 |= (lTemp >> 3) << 11; |
|
9747 |
|
9748 lRGBFramePtr[0] = (uint16)lTemp4; |
|
9749 |
|
9750 /*Second Pixel*/ |
|
9751 lY1 = lYuyvPtr[0]; |
|
9752 lY1 -= 16; |
|
9753 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
9754 |
|
9755 /*B component*/ |
|
9756 lTemp = lY1 + lTemp3 + 4; |
|
9757 if (lTemp < 0) |
|
9758 lTemp = 0; |
|
9759 if (lTemp > 255) |
|
9760 lTemp = 255; |
|
9761 lTemp4 = (lTemp >> 3); |
|
9762 |
|
9763 /*G component*/ |
|
9764 lTemp = lY1 - lTemp2; |
|
9765 if (lTemp < 0) |
|
9766 lTemp = 0; |
|
9767 if (lTemp > 255) |
|
9768 lTemp = 255; |
|
9769 lTemp4 |= (lTemp >> 2) << 5; |
|
9770 |
|
9771 /*R component*/ |
|
9772 lTemp = lY1 + lTemp1 + 6; |
|
9773 if (lTemp < 0) |
|
9774 lTemp = 0; |
|
9775 if (lTemp > 255) |
|
9776 lTemp = 255; |
|
9777 lTemp4 |= (lTemp >> 3) << 11; |
|
9778 |
|
9779 lRGBFramePtr[1] = (uint16)lTemp4; |
|
9780 |
|
9781 |
|
9782 lCb = lYuyvPtr[lLumWidth + 3]; |
|
9783 lCr = lYuyvPtr[lLumWidth + 1]; |
|
9784 |
|
9785 lCr -= 128; |
|
9786 lCb -= 128; |
|
9787 |
|
9788 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
9789 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
9790 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
9791 |
|
9792 /*Third Pixel*/ |
|
9793 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
9794 lY1 -= 16; |
|
9795 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
9796 |
|
9797 /*B component*/ |
|
9798 lTemp = lY1 + lTemp3 + 6; |
|
9799 if (lTemp < 0) |
|
9800 lTemp = 0; |
|
9801 if (lTemp > 255) |
|
9802 lTemp = 255; |
|
9803 lTemp4 = (lTemp >> 3); |
|
9804 |
|
9805 /*G component*/ |
|
9806 lTemp = lY1 - lTemp2 + 1; |
|
9807 if (lTemp < 0) |
|
9808 lTemp = 0; |
|
9809 if (lTemp > 255) |
|
9810 lTemp = 255; |
|
9811 lTemp4 |= (lTemp >> 2) << 5; |
|
9812 |
|
9813 /*R component*/ |
|
9814 lTemp = lY1 + lTemp1 + 4; |
|
9815 if (lTemp < 0) |
|
9816 lTemp = 0; |
|
9817 if (lTemp > 255) |
|
9818 lTemp = 255; |
|
9819 lTemp4 |= (lTemp >> 3) << 11; |
|
9820 |
|
9821 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
9822 |
|
9823 /*Fourth Pixel*/ |
|
9824 lY1 = lYuyvPtr[lLumWidth]; |
|
9825 lY1 -= 16; |
|
9826 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
9827 |
|
9828 /*B component*/ |
|
9829 lTemp = lY1 + lTemp3 + 2; |
|
9830 if (lTemp < 0) |
|
9831 lTemp = 0; |
|
9832 if (lTemp > 255) |
|
9833 lTemp = 255; |
|
9834 lTemp4 = (lTemp >> 3); |
|
9835 |
|
9836 /*G component*/ |
|
9837 lTemp = lY1 - lTemp2 + 2; |
|
9838 if (lTemp < 0) |
|
9839 lTemp = 0; |
|
9840 if (lTemp > 255) |
|
9841 lTemp = 255; |
|
9842 lTemp4 |= (lTemp >> 2) << 5; |
|
9843 |
|
9844 /*R component*/ |
|
9845 lTemp = lY1 + lTemp1; |
|
9846 if (lTemp < 0) |
|
9847 lTemp = 0; |
|
9848 if (lTemp > 255) |
|
9849 lTemp = 255; |
|
9850 lTemp4 |= (lTemp >> 3) << 11; |
|
9851 |
|
9852 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
9853 |
|
9854 lYuyvPtr += 4; |
|
9855 lRGBFramePtr += 2; |
|
9856 lRGBFramePtr1 += 2; |
|
9857 } |
|
9858 if(extraCol) |
|
9859 { |
|
9860 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
9861 lRGBFramePtr++; |
|
9862 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
9863 lRGBFramePtr1++; |
|
9864 } |
|
9865 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
9866 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
9867 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
9868 } |
|
9869 |
|
9870 if(extraRow) |
|
9871 { |
|
9872 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
9873 for(j = 0; j < lWidth; j += 2) |
|
9874 { |
|
9875 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
9876 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
9877 } |
|
9878 if(extraCol) |
|
9879 { |
|
9880 *lRGBFramePtr = *lRGBFramePtr1; |
|
9881 } |
|
9882 } |
|
9883 return; |
|
9884 } |
|
9885 |
|
9886 /* |
|
9887 ****************************************************************************** |
|
9888 Name : sEmz_VDec_YUV422LEChr2toColor64k_Ordered_601_5_RR |
|
9889 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
9890 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
9891 uint8 *dstImage : Pointer to rgb data (o/p). |
|
9892 tWndParam *srcWindow : Pointer to structure containing source window |
|
9893 parameters like xOffset,yOffset,cropWidth, |
|
9894 cropHeight. (i/p) |
|
9895 tWndParam *dstWindow : Pointer to structure containing destination window |
|
9896 parameters like xOffset,yOffset,windWidth, |
|
9897 windHeight. (i/p) |
|
9898 Return Value : void |
|
9899 ****************************************************************************** |
|
9900 */ |
|
9901 |
|
9902 void sEmz_VDec_YUV422LEChr2toColor64k_Ordered_601_5_RR |
|
9903 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
9904 tWndParam* srcWindow, tWndParam* dstWindow) |
|
9905 { |
|
9906 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
9907 uint8 *lYuyvPtr; |
|
9908 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
9909 int32 lY1, lCr, lCb; |
|
9910 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
9911 int32 i, j, extraCol, extraRow; |
|
9912 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
9913 cropWidth,cropHeight,wndWidth,wndHeight; |
|
9914 |
|
9915 srcXOffset = srcWindow->xOffset; |
|
9916 srcYOffset = srcWindow->yOffset; |
|
9917 cropWidth = srcWindow->wndWidth; |
|
9918 cropHeight = srcWindow->wndHeight; |
|
9919 |
|
9920 dstXOffset = dstWindow->xOffset; |
|
9921 dstYOffset = dstWindow->yOffset; |
|
9922 wndWidth = dstWindow->wndWidth; |
|
9923 wndHeight = dstWindow->wndHeight; |
|
9924 |
|
9925 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
9926 { |
|
9927 lWidth = cropWidth; |
|
9928 } |
|
9929 else |
|
9930 { |
|
9931 lWidth = srcImage->width - srcXOffset; |
|
9932 } |
|
9933 |
|
9934 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
9935 { |
|
9936 lHeight = cropHeight; |
|
9937 } |
|
9938 else |
|
9939 { |
|
9940 lHeight = srcImage->height - srcYOffset; |
|
9941 } |
|
9942 |
|
9943 if (lWidth > (wndWidth - dstXOffset)) |
|
9944 { |
|
9945 lWidth = wndWidth - dstXOffset; |
|
9946 } |
|
9947 |
|
9948 if (lHeight > (wndHeight - dstYOffset)) |
|
9949 { |
|
9950 lHeight = wndHeight - dstYOffset; |
|
9951 } |
|
9952 |
|
9953 extraCol = lWidth & 0x01; |
|
9954 extraRow = lHeight & 0x01; |
|
9955 |
|
9956 lTempWidth = lWidth; |
|
9957 lWidth = (lWidth >> 1) << 1; |
|
9958 lHeight = (lHeight >> 1) << 1; |
|
9959 |
|
9960 lLumWidth = (srcImage->width >> 1) << 1; |
|
9961 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
9962 |
|
9963 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
9964 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
9965 |
|
9966 lLumWidth <<= 1; |
|
9967 |
|
9968 for(i = 0; i < lHeight; i += 2) |
|
9969 { |
|
9970 for(j = 0; j < lWidth; j += 2) |
|
9971 { |
|
9972 lCb = lYuyvPtr[3]; |
|
9973 lCr = lYuyvPtr[1]; |
|
9974 |
|
9975 lCr -= 128; |
|
9976 lCb -= 128; |
|
9977 |
|
9978 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
9979 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
9980 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
9981 |
|
9982 /*First Pixel*/ |
|
9983 lY1 = lYuyvPtr[2]; |
|
9984 lY1 -= 16; |
|
9985 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
9986 |
|
9987 /*B component*/ |
|
9988 lTemp = lY1 + lTemp3; |
|
9989 if (lTemp < 0) |
|
9990 lTemp = 0; |
|
9991 if (lTemp > 255) |
|
9992 lTemp = 255; |
|
9993 lTemp4 = (lTemp >> 3); |
|
9994 |
|
9995 /*G component*/ |
|
9996 lTemp = lY1 - lTemp2 + 3; |
|
9997 if (lTemp < 0) |
|
9998 lTemp = 0; |
|
9999 if (lTemp > 255) |
|
10000 lTemp = 255; |
|
10001 lTemp4 |= (lTemp >> 2) << 5; |
|
10002 |
|
10003 /*R component*/ |
|
10004 lTemp = lY1 + lTemp1 + 2; |
|
10005 if (lTemp < 0) |
|
10006 lTemp = 0; |
|
10007 if (lTemp > 255) |
|
10008 lTemp = 255; |
|
10009 lTemp4 |= (lTemp >> 3) << 11; |
|
10010 |
|
10011 lRGBFramePtr[0] = (uint16)lTemp4; |
|
10012 |
|
10013 /*Second Pixel*/ |
|
10014 lY1 = lYuyvPtr[0]; |
|
10015 lY1 -= 16; |
|
10016 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
10017 |
|
10018 /*B component*/ |
|
10019 lTemp = lY1 + lTemp3 + 4; |
|
10020 if (lTemp < 0) |
|
10021 lTemp = 0; |
|
10022 if (lTemp > 255) |
|
10023 lTemp = 255; |
|
10024 lTemp4 = (lTemp >> 3); |
|
10025 |
|
10026 /*G component*/ |
|
10027 lTemp = lY1 - lTemp2; |
|
10028 if (lTemp < 0) |
|
10029 lTemp = 0; |
|
10030 if (lTemp > 255) |
|
10031 lTemp = 255; |
|
10032 lTemp4 |= (lTemp >> 2) << 5; |
|
10033 |
|
10034 /*R component*/ |
|
10035 lTemp = lY1 + lTemp1 + 6; |
|
10036 if (lTemp < 0) |
|
10037 lTemp = 0; |
|
10038 if (lTemp > 255) |
|
10039 lTemp = 255; |
|
10040 lTemp4 |= (lTemp >> 3) << 11; |
|
10041 |
|
10042 lRGBFramePtr[1] = (uint16)lTemp4; |
|
10043 |
|
10044 |
|
10045 lCb = lYuyvPtr[lLumWidth + 3]; |
|
10046 lCr = lYuyvPtr[lLumWidth + 1]; |
|
10047 |
|
10048 lCr -= 128; |
|
10049 lCb -= 128; |
|
10050 |
|
10051 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
10052 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
10053 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
10054 |
|
10055 /*Third Pixel*/ |
|
10056 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
10057 lY1 -= 16; |
|
10058 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
10059 |
|
10060 /*B component*/ |
|
10061 lTemp = lY1 + lTemp3 + 6; |
|
10062 if (lTemp < 0) |
|
10063 lTemp = 0; |
|
10064 if (lTemp > 255) |
|
10065 lTemp = 255; |
|
10066 lTemp4 = (lTemp >> 3); |
|
10067 |
|
10068 /*G component*/ |
|
10069 lTemp = lY1 - lTemp2 + 1; |
|
10070 if (lTemp < 0) |
|
10071 lTemp = 0; |
|
10072 if (lTemp > 255) |
|
10073 lTemp = 255; |
|
10074 lTemp4 |= (lTemp >> 2) << 5; |
|
10075 |
|
10076 /*R component*/ |
|
10077 lTemp = lY1 + lTemp1 + 4; |
|
10078 if (lTemp < 0) |
|
10079 lTemp = 0; |
|
10080 if (lTemp > 255) |
|
10081 lTemp = 255; |
|
10082 lTemp4 |= (lTemp >> 3) << 11; |
|
10083 |
|
10084 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
10085 |
|
10086 /*Fourth Pixel*/ |
|
10087 lY1 = lYuyvPtr[lLumWidth]; |
|
10088 lY1 -= 16; |
|
10089 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
10090 |
|
10091 /*B component*/ |
|
10092 lTemp = lY1 + lTemp3 + 2; |
|
10093 if (lTemp < 0) |
|
10094 lTemp = 0; |
|
10095 if (lTemp > 255) |
|
10096 lTemp = 255; |
|
10097 lTemp4 = (lTemp >> 3); |
|
10098 |
|
10099 /*G component*/ |
|
10100 lTemp = lY1 - lTemp2 + 2; |
|
10101 if (lTemp < 0) |
|
10102 lTemp = 0; |
|
10103 if (lTemp > 255) |
|
10104 lTemp = 255; |
|
10105 lTemp4 |= (lTemp >> 2) << 5; |
|
10106 |
|
10107 /*R component*/ |
|
10108 lTemp = lY1 + lTemp1; |
|
10109 if (lTemp < 0) |
|
10110 lTemp = 0; |
|
10111 if (lTemp > 255) |
|
10112 lTemp = 255; |
|
10113 lTemp4 |= (lTemp >> 3) << 11; |
|
10114 |
|
10115 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
10116 |
|
10117 lYuyvPtr += 4; |
|
10118 lRGBFramePtr += 2; |
|
10119 lRGBFramePtr1 += 2; |
|
10120 } |
|
10121 if(extraCol) |
|
10122 { |
|
10123 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
10124 lRGBFramePtr++; |
|
10125 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
10126 lRGBFramePtr1++; |
|
10127 } |
|
10128 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
10129 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
10130 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
10131 } |
|
10132 |
|
10133 if(extraRow) |
|
10134 { |
|
10135 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
10136 for(j = 0; j < lWidth; j += 2) |
|
10137 { |
|
10138 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10139 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10140 } |
|
10141 if(extraCol) |
|
10142 { |
|
10143 *lRGBFramePtr = *lRGBFramePtr1; |
|
10144 } |
|
10145 } |
|
10146 return; |
|
10147 } |
|
10148 |
|
10149 /* |
|
10150 ****************************************************************************** |
|
10151 Name : sEmz_VDec_YUV422LEChr2toColor16M_709_FR |
|
10152 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB888 Interleaved format. |
|
10153 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
10154 uint8 *dstImage : Pointer to rgb data (o/p). |
|
10155 tWndParam *srcWindow : Pointer to structure containing source window |
|
10156 parameters like xOffset,yOffset,cropWidth, |
|
10157 cropHeight. (i/p) |
|
10158 tWndParam *dstWindow : Pointer to structure containing destination window |
|
10159 parameters like xOffset,yOffset,windWidth, |
|
10160 windHeight. (i/p) |
|
10161 Return Value : void |
|
10162 ****************************************************************************** |
|
10163 */ |
|
10164 |
|
10165 void sEmz_VDec_YUV422LEChr2toColor16M_709_FR |
|
10166 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
10167 tWndParam* srcWindow, tWndParam* dstWindow) |
|
10168 { |
|
10169 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
10170 uint8 *lYuyvPtr; |
|
10171 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
10172 int32 lY1, lCr, lCb; |
|
10173 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
10174 int32 i, j, extraCol, extraRow; |
|
10175 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
10176 cropWidth,cropHeight,wndWidth,wndHeight; |
|
10177 |
|
10178 srcXOffset = srcWindow->xOffset; |
|
10179 srcYOffset = srcWindow->yOffset; |
|
10180 cropWidth = srcWindow->wndWidth; |
|
10181 cropHeight = srcWindow->wndHeight; |
|
10182 |
|
10183 |
|
10184 dstXOffset = dstWindow->xOffset; |
|
10185 dstYOffset = dstWindow->yOffset; |
|
10186 wndWidth = dstWindow->wndWidth; |
|
10187 wndHeight = dstWindow->wndHeight; |
|
10188 |
|
10189 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
10190 { |
|
10191 lWidth = cropWidth; |
|
10192 } |
|
10193 else |
|
10194 { |
|
10195 lWidth = srcImage->width - srcXOffset; |
|
10196 } |
|
10197 |
|
10198 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
10199 { |
|
10200 lHeight = cropHeight; |
|
10201 } |
|
10202 else |
|
10203 { |
|
10204 lHeight = srcImage->height - srcYOffset; |
|
10205 } |
|
10206 |
|
10207 if (lWidth > (wndWidth - dstXOffset)) |
|
10208 { |
|
10209 lWidth = wndWidth - dstXOffset; |
|
10210 } |
|
10211 |
|
10212 if (lHeight > (wndHeight - dstYOffset)) |
|
10213 { |
|
10214 lHeight = wndHeight - dstYOffset; |
|
10215 } |
|
10216 |
|
10217 extraCol = lWidth & 0x01; |
|
10218 extraRow = lHeight & 0x01; |
|
10219 |
|
10220 lTempWidth = lWidth * 3; |
|
10221 lWidth = (lWidth >> 1) << 1; |
|
10222 lHeight = (lHeight >> 1) << 1; |
|
10223 |
|
10224 dstXOffset *= 3; |
|
10225 wndWidth *= 3; |
|
10226 |
|
10227 lLumWidth = (srcImage->width >> 1) << 1 ; |
|
10228 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
10229 |
|
10230 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
10231 |
|
10232 for(i = 0; i < lHeight; i++) |
|
10233 { |
|
10234 for(j = 0; j < lWidth; j += 2) |
|
10235 { |
|
10236 lCb = lYuyvPtr[3]; |
|
10237 lCr = lYuyvPtr[1]; |
|
10238 |
|
10239 lCb -= 128; |
|
10240 lCr -= 128; |
|
10241 |
|
10242 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
10243 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
10244 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
10245 |
|
10246 /*First Pixel*/ |
|
10247 lY1 = lYuyvPtr[2]; |
|
10248 |
|
10249 /*R component*/ |
|
10250 lTemp = (lY1 + lTemp1); |
|
10251 if (lTemp < 0) |
|
10252 lTemp = 0; |
|
10253 if (lTemp > 255) |
|
10254 lTemp = 255; |
|
10255 lRGBFramePtr[0] = (uint8) lTemp; |
|
10256 |
|
10257 /*G component*/ |
|
10258 lTemp = (lY1 - lTemp2); |
|
10259 if (lTemp < 0) |
|
10260 lTemp = 0; |
|
10261 if (lTemp > 255) |
|
10262 lTemp = 255; |
|
10263 lRGBFramePtr[1] = (uint8) lTemp; |
|
10264 |
|
10265 /*B component*/ |
|
10266 lTemp = (lY1 + lTemp3); |
|
10267 if (lTemp < 0) |
|
10268 lTemp = 0; |
|
10269 if (lTemp > 255) |
|
10270 lTemp = 255; |
|
10271 |
|
10272 lRGBFramePtr[2] = (uint8) lTemp; |
|
10273 |
|
10274 /*Second Pixel*/ |
|
10275 lY1 = lYuyvPtr[0]; |
|
10276 |
|
10277 /*R component*/ |
|
10278 lTemp = (lY1 + lTemp1); |
|
10279 if (lTemp < 0) |
|
10280 lTemp = 0; |
|
10281 if (lTemp > 255) |
|
10282 lTemp = 255; |
|
10283 lRGBFramePtr[3] = (uint8) lTemp; |
|
10284 |
|
10285 /*G component*/ |
|
10286 lTemp = (lY1 - lTemp2); |
|
10287 if (lTemp < 0) |
|
10288 lTemp = 0; |
|
10289 if (lTemp > 255) |
|
10290 lTemp = 255; |
|
10291 lRGBFramePtr[4] = (uint8) lTemp; |
|
10292 |
|
10293 /*B component*/ |
|
10294 lTemp = (lY1 + lTemp3); |
|
10295 if (lTemp < 0) |
|
10296 lTemp = 0; |
|
10297 if (lTemp > 255) |
|
10298 lTemp = 255; |
|
10299 lRGBFramePtr[5] = (uint8) lTemp; |
|
10300 |
|
10301 lYuyvPtr += 4; |
|
10302 lRGBFramePtr += 6; |
|
10303 } |
|
10304 if(extraCol) |
|
10305 { |
|
10306 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10307 lRGBFramePtr++; |
|
10308 |
|
10309 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10310 lRGBFramePtr++; |
|
10311 |
|
10312 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10313 lRGBFramePtr++; |
|
10314 } |
|
10315 |
|
10316 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
10317 lRGBFramePtr += (wndWidth - lTempWidth); |
|
10318 } |
|
10319 |
|
10320 if(extraRow) |
|
10321 { |
|
10322 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
10323 for(j = 0; j < lWidth * 3; j += 2) |
|
10324 { |
|
10325 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10326 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10327 } |
|
10328 if(extraCol) |
|
10329 { |
|
10330 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10331 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10332 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10333 } |
|
10334 } |
|
10335 return; |
|
10336 } |
|
10337 |
|
10338 /* |
|
10339 ****************************************************************************** |
|
10340 Name : sEmz_VDec_YUV422LEChr2toColor16M_601_5_FR |
|
10341 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB888 Interleaved format. |
|
10342 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
10343 uint8 *dstImage : Pointer to rgb data (o/p). |
|
10344 tWndParam *srcWindow : Pointer to structure containing source window |
|
10345 parameters like xOffset,yOffset,cropWidth, |
|
10346 cropHeight. (i/p) |
|
10347 tWndParam *dstWindow : Pointer to structure containing destination window |
|
10348 parameters like xOffset,yOffset,windWidth, |
|
10349 windHeight. (i/p) |
|
10350 Return Value : void |
|
10351 ****************************************************************************** |
|
10352 */ |
|
10353 |
|
10354 void sEmz_VDec_YUV422LEChr2toColor16M_601_5_FR |
|
10355 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
10356 tWndParam* srcWindow, tWndParam* dstWindow) |
|
10357 { |
|
10358 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
10359 uint8 *lYuyvPtr; |
|
10360 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
10361 int32 lY1, lCr, lCb; |
|
10362 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
10363 int32 i, j, extraCol, extraRow; |
|
10364 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
10365 cropWidth,cropHeight,wndWidth,wndHeight; |
|
10366 |
|
10367 srcXOffset = srcWindow->xOffset; |
|
10368 srcYOffset = srcWindow->yOffset; |
|
10369 cropWidth = srcWindow->wndWidth; |
|
10370 cropHeight = srcWindow->wndHeight; |
|
10371 |
|
10372 dstXOffset = dstWindow->xOffset; |
|
10373 dstYOffset = dstWindow->yOffset; |
|
10374 wndWidth = dstWindow->wndWidth; |
|
10375 wndHeight = dstWindow->wndHeight; |
|
10376 |
|
10377 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
10378 { |
|
10379 lWidth = cropWidth; |
|
10380 } |
|
10381 else |
|
10382 { |
|
10383 lWidth = srcImage->width - srcXOffset; |
|
10384 } |
|
10385 |
|
10386 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
10387 { |
|
10388 lHeight = cropHeight; |
|
10389 } |
|
10390 else |
|
10391 { |
|
10392 lHeight = srcImage->height - srcYOffset; |
|
10393 } |
|
10394 |
|
10395 if (lWidth > (wndWidth - dstXOffset)) |
|
10396 { |
|
10397 lWidth = wndWidth - dstXOffset; |
|
10398 } |
|
10399 |
|
10400 if (lHeight > (wndHeight - dstYOffset)) |
|
10401 { |
|
10402 lHeight = wndHeight - dstYOffset; |
|
10403 } |
|
10404 |
|
10405 extraCol = lWidth & 0x01; |
|
10406 extraRow = lHeight & 0x01; |
|
10407 |
|
10408 lTempWidth = lWidth * 3; |
|
10409 lWidth = (lWidth >> 1) << 1; |
|
10410 lHeight = (lHeight >> 1) << 1; |
|
10411 |
|
10412 dstXOffset *= 3; |
|
10413 wndWidth *= 3; |
|
10414 |
|
10415 lLumWidth = (srcImage->width >> 1) << 1; |
|
10416 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
10417 |
|
10418 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
10419 |
|
10420 for(i = 0; i < lHeight; i++) |
|
10421 { |
|
10422 for(j = 0; j < lWidth; j += 2) |
|
10423 { |
|
10424 lCb = lYuyvPtr[3]; |
|
10425 lCr = lYuyvPtr[1]; |
|
10426 |
|
10427 lCb -= 128; |
|
10428 lCr -= 128; |
|
10429 |
|
10430 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
10431 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
10432 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
10433 |
|
10434 /*First Pixel*/ |
|
10435 lY1 = lYuyvPtr[2]; |
|
10436 |
|
10437 /*R component*/ |
|
10438 lTemp = (lY1 + lTemp1); |
|
10439 if (lTemp < 0) |
|
10440 lTemp = 0; |
|
10441 if (lTemp > 255) |
|
10442 lTemp = 255; |
|
10443 lRGBFramePtr[0] = (uint8) lTemp; |
|
10444 |
|
10445 /*G component*/ |
|
10446 lTemp = (lY1 - lTemp2); |
|
10447 if (lTemp < 0) |
|
10448 lTemp = 0; |
|
10449 if (lTemp > 255) |
|
10450 lTemp = 255; |
|
10451 lRGBFramePtr[1] = (uint8) lTemp; |
|
10452 |
|
10453 /*B component*/ |
|
10454 lTemp = (lY1 + lTemp3); |
|
10455 if (lTemp < 0) |
|
10456 lTemp = 0; |
|
10457 if (lTemp > 255) |
|
10458 lTemp = 255; |
|
10459 |
|
10460 lRGBFramePtr[2] = (uint8) lTemp; |
|
10461 |
|
10462 /*Second Pixel*/ |
|
10463 lY1 = lYuyvPtr[0]; |
|
10464 |
|
10465 /*R component*/ |
|
10466 lTemp = (lY1 + lTemp1); |
|
10467 if (lTemp < 0) |
|
10468 lTemp = 0; |
|
10469 if (lTemp > 255) |
|
10470 lTemp = 255; |
|
10471 lRGBFramePtr[3] = (uint8) lTemp; |
|
10472 |
|
10473 /*G component*/ |
|
10474 lTemp = (lY1 - lTemp2); |
|
10475 if (lTemp < 0) |
|
10476 lTemp = 0; |
|
10477 if (lTemp > 255) |
|
10478 lTemp = 255; |
|
10479 lRGBFramePtr[4] = (uint8) lTemp; |
|
10480 |
|
10481 /*B component*/ |
|
10482 lTemp = (lY1 + lTemp3); |
|
10483 if (lTemp < 0) |
|
10484 lTemp = 0; |
|
10485 if (lTemp > 255) |
|
10486 lTemp = 255; |
|
10487 lRGBFramePtr[5] = (uint8) lTemp; |
|
10488 |
|
10489 lYuyvPtr += 4; |
|
10490 lRGBFramePtr += 6; |
|
10491 } |
|
10492 if(extraCol) |
|
10493 { |
|
10494 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10495 lRGBFramePtr++; |
|
10496 |
|
10497 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10498 lRGBFramePtr++; |
|
10499 |
|
10500 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10501 lRGBFramePtr++; |
|
10502 } |
|
10503 |
|
10504 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
10505 lRGBFramePtr += (wndWidth - lTempWidth); |
|
10506 } |
|
10507 |
|
10508 if(extraRow) |
|
10509 { |
|
10510 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
10511 for(j = 0; j < lWidth * 3; j += 2) |
|
10512 { |
|
10513 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10514 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10515 } |
|
10516 if(extraCol) |
|
10517 { |
|
10518 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10519 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10520 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10521 } |
|
10522 } |
|
10523 return; |
|
10524 } |
|
10525 |
|
10526 /* |
|
10527 ****************************************************************************** |
|
10528 Name : sEmz_VDec_YUV422LEChr2toColor16M_709_RR |
|
10529 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB888 Interleaved format. |
|
10530 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
10531 uint8 *dstImage : Pointer to rgb data (o/p). |
|
10532 tWndParam *srcWindow : Pointer to structure containing source window |
|
10533 parameters like xOffset,yOffset,cropWidth, |
|
10534 cropHeight. (i/p) |
|
10535 tWndParam *dstWindow : Pointer to structure containing destination window |
|
10536 parameters like xOffset,yOffset,windWidth, |
|
10537 windHeight. (i/p) |
|
10538 Return Value : void |
|
10539 ****************************************************************************** |
|
10540 */ |
|
10541 |
|
10542 void sEmz_VDec_YUV422LEChr2toColor16M_709_RR |
|
10543 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
10544 tWndParam* srcWindow, tWndParam* dstWindow) |
|
10545 { |
|
10546 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
10547 uint8 *lYuyvPtr; |
|
10548 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
10549 int32 lY1, lCr, lCb; |
|
10550 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
10551 int32 i, j, extraCol, extraRow; |
|
10552 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
10553 cropWidth,cropHeight,wndWidth,wndHeight; |
|
10554 |
|
10555 srcXOffset = srcWindow->xOffset; |
|
10556 srcYOffset = srcWindow->yOffset; |
|
10557 cropWidth = srcWindow->wndWidth; |
|
10558 cropHeight = srcWindow->wndHeight; |
|
10559 |
|
10560 dstXOffset = dstWindow->xOffset; |
|
10561 dstYOffset = dstWindow->yOffset; |
|
10562 wndWidth = dstWindow->wndWidth; |
|
10563 wndHeight = dstWindow->wndHeight; |
|
10564 |
|
10565 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
10566 { |
|
10567 lWidth = cropWidth; |
|
10568 } |
|
10569 else |
|
10570 { |
|
10571 lWidth = srcImage->width - srcXOffset; |
|
10572 } |
|
10573 |
|
10574 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
10575 { |
|
10576 lHeight = cropHeight; |
|
10577 } |
|
10578 else |
|
10579 { |
|
10580 lHeight = srcImage->height - srcYOffset; |
|
10581 } |
|
10582 |
|
10583 if (lWidth > (wndWidth - dstXOffset)) |
|
10584 { |
|
10585 lWidth = wndWidth - dstXOffset; |
|
10586 } |
|
10587 |
|
10588 if (lHeight > (wndHeight - dstYOffset)) |
|
10589 { |
|
10590 lHeight = wndHeight - dstYOffset; |
|
10591 } |
|
10592 |
|
10593 extraCol = lWidth & 0x01; |
|
10594 extraRow = lHeight & 0x01; |
|
10595 |
|
10596 lTempWidth = lWidth * 3; |
|
10597 lWidth = (lWidth >> 1) << 1; |
|
10598 lHeight = (lHeight >> 1) << 1; |
|
10599 |
|
10600 dstXOffset *= 3; |
|
10601 wndWidth *= 3; |
|
10602 |
|
10603 lLumWidth = (srcImage->width >> 1) << 1; |
|
10604 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
10605 |
|
10606 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
10607 |
|
10608 for(i = 0; i < lHeight; i++) |
|
10609 { |
|
10610 for(j = 0; j < lWidth; j += 2) |
|
10611 { |
|
10612 lCb = lYuyvPtr[3]; |
|
10613 lCr = lYuyvPtr[1]; |
|
10614 |
|
10615 lCb -= 128; |
|
10616 lCr -= 128; |
|
10617 |
|
10618 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
10619 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
10620 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
10621 |
|
10622 /*First Pixel*/ |
|
10623 lY1 = lYuyvPtr[2]; |
|
10624 lY1 -= 16; |
|
10625 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
10626 |
|
10627 /*R component*/ |
|
10628 lTemp = (lY1 + lTemp1); |
|
10629 if (lTemp < 0) |
|
10630 lTemp = 0; |
|
10631 if (lTemp > 255) |
|
10632 lTemp = 255; |
|
10633 lRGBFramePtr[0] = (uint8) lTemp; |
|
10634 |
|
10635 /*G component*/ |
|
10636 lTemp = (lY1 - lTemp2); |
|
10637 if (lTemp < 0) |
|
10638 lTemp = 0; |
|
10639 if (lTemp > 255) |
|
10640 lTemp = 255; |
|
10641 lRGBFramePtr[1] = (uint8) lTemp; |
|
10642 |
|
10643 /*B component*/ |
|
10644 lTemp = (lY1 + lTemp3); |
|
10645 if (lTemp < 0) |
|
10646 lTemp = 0; |
|
10647 if (lTemp > 255) |
|
10648 lTemp = 255; |
|
10649 |
|
10650 lRGBFramePtr[2] = (uint8) lTemp; |
|
10651 |
|
10652 /*Second Pixel*/ |
|
10653 lY1 = lYuyvPtr[0]; |
|
10654 lY1 -= 16; |
|
10655 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
10656 |
|
10657 /*R component*/ |
|
10658 lTemp = (lY1 + lTemp1); |
|
10659 if (lTemp < 0) |
|
10660 lTemp = 0; |
|
10661 if (lTemp > 255) |
|
10662 lTemp = 255; |
|
10663 lRGBFramePtr[3] = (uint8) lTemp; |
|
10664 |
|
10665 /*G component*/ |
|
10666 lTemp = (lY1 - lTemp2); |
|
10667 if (lTemp < 0) |
|
10668 lTemp = 0; |
|
10669 if (lTemp > 255) |
|
10670 lTemp = 255; |
|
10671 lRGBFramePtr[4] = (uint8) lTemp; |
|
10672 |
|
10673 /*B component*/ |
|
10674 lTemp = (lY1 + lTemp3); |
|
10675 if (lTemp < 0) |
|
10676 lTemp = 0; |
|
10677 if (lTemp > 255) |
|
10678 lTemp = 255; |
|
10679 lRGBFramePtr[5] = (uint8) lTemp; |
|
10680 |
|
10681 lYuyvPtr += 4; |
|
10682 lRGBFramePtr += 6; |
|
10683 } |
|
10684 if(extraCol) |
|
10685 { |
|
10686 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10687 lRGBFramePtr++; |
|
10688 |
|
10689 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10690 lRGBFramePtr++; |
|
10691 |
|
10692 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10693 lRGBFramePtr++; |
|
10694 } |
|
10695 |
|
10696 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
10697 lRGBFramePtr += (wndWidth - lTempWidth); |
|
10698 } |
|
10699 |
|
10700 if(extraRow) |
|
10701 { |
|
10702 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
10703 for(j = 0; j < lWidth * 3; j += 2) |
|
10704 { |
|
10705 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10706 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10707 } |
|
10708 if(extraCol) |
|
10709 { |
|
10710 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10711 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10712 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10713 } |
|
10714 } |
|
10715 return; |
|
10716 } |
|
10717 |
|
10718 /* |
|
10719 ****************************************************************************** |
|
10720 Name : sEmz_VDec_YUV422LEChr2toColor16M_601_5_RR |
|
10721 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB888 Interleaved format. |
|
10722 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
10723 uint8 *dstImage : Pointer to rgb data (o/p). |
|
10724 tWndParam *srcWindow : Pointer to structure containing source window |
|
10725 parameters like xOffset,yOffset,cropWidth, |
|
10726 cropHeight. (i/p) |
|
10727 tWndParam *dstWindow : Pointer to structure containing destination window |
|
10728 parameters like xOffset,yOffset,windWidth, |
|
10729 windHeight. (i/p) |
|
10730 Return Value : void |
|
10731 ****************************************************************************** |
|
10732 */ |
|
10733 |
|
10734 void sEmz_VDec_YUV422LEChr2toColor16M_601_5_RR |
|
10735 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
10736 tWndParam* srcWindow, tWndParam* dstWindow) |
|
10737 { |
|
10738 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
10739 uint8 *lYuyvPtr; |
|
10740 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
10741 int32 lY1, lCr, lCb; |
|
10742 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
10743 int32 i, j, extraCol, extraRow; |
|
10744 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
10745 cropWidth,cropHeight,wndWidth,wndHeight; |
|
10746 |
|
10747 srcXOffset = srcWindow->xOffset; |
|
10748 srcYOffset = srcWindow->yOffset; |
|
10749 cropWidth = srcWindow->wndWidth; |
|
10750 cropHeight = srcWindow->wndHeight; |
|
10751 |
|
10752 dstXOffset = dstWindow->xOffset; |
|
10753 dstYOffset = dstWindow->yOffset; |
|
10754 wndWidth = dstWindow->wndWidth; |
|
10755 wndHeight = dstWindow->wndHeight; |
|
10756 |
|
10757 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
10758 { |
|
10759 lWidth = cropWidth; |
|
10760 } |
|
10761 else |
|
10762 { |
|
10763 lWidth = srcImage->width - srcXOffset; |
|
10764 } |
|
10765 |
|
10766 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
10767 { |
|
10768 lHeight = cropHeight; |
|
10769 } |
|
10770 else |
|
10771 { |
|
10772 lHeight = srcImage->height - srcYOffset; |
|
10773 } |
|
10774 |
|
10775 if (lWidth > (wndWidth - dstXOffset)) |
|
10776 { |
|
10777 lWidth = wndWidth - dstXOffset; |
|
10778 } |
|
10779 |
|
10780 if (lHeight > (wndHeight - dstYOffset)) |
|
10781 { |
|
10782 lHeight = wndHeight - dstYOffset; |
|
10783 } |
|
10784 |
|
10785 extraCol = lWidth & 0x01; |
|
10786 extraRow = lHeight & 0x01; |
|
10787 |
|
10788 lTempWidth = lWidth * 3; |
|
10789 lWidth = (lWidth >> 1) << 1; |
|
10790 lHeight = (lHeight >> 1) << 1; |
|
10791 |
|
10792 dstXOffset *= 3; |
|
10793 wndWidth *= 3; |
|
10794 |
|
10795 lLumWidth = (srcImage->width >> 1) << 1; |
|
10796 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
10797 |
|
10798 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
10799 |
|
10800 for(i = 0; i < lHeight; i++) |
|
10801 { |
|
10802 for(j = 0; j < lWidth; j += 2) |
|
10803 { |
|
10804 lCb = lYuyvPtr[3]; |
|
10805 lCr = lYuyvPtr[1]; |
|
10806 |
|
10807 lCb -= 128; |
|
10808 lCr -= 128; |
|
10809 |
|
10810 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
10811 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
10812 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
10813 |
|
10814 /*First Pixel*/ |
|
10815 lY1 = lYuyvPtr[2]; |
|
10816 lY1 -= 16; |
|
10817 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
10818 |
|
10819 /*R component*/ |
|
10820 lTemp = (lY1 + lTemp1); |
|
10821 if (lTemp < 0) |
|
10822 lTemp = 0; |
|
10823 if (lTemp > 255) |
|
10824 lTemp = 255; |
|
10825 lRGBFramePtr[0] = (uint8) lTemp; |
|
10826 |
|
10827 /*G component*/ |
|
10828 lTemp = (lY1 - lTemp2); |
|
10829 if (lTemp < 0) |
|
10830 lTemp = 0; |
|
10831 if (lTemp > 255) |
|
10832 lTemp = 255; |
|
10833 lRGBFramePtr[1] = (uint8) lTemp; |
|
10834 |
|
10835 /*B component*/ |
|
10836 lTemp = (lY1 + lTemp3); |
|
10837 if (lTemp < 0) |
|
10838 lTemp = 0; |
|
10839 if (lTemp > 255) |
|
10840 lTemp = 255; |
|
10841 |
|
10842 lRGBFramePtr[2] = (uint8) lTemp; |
|
10843 |
|
10844 /*Second Pixel*/ |
|
10845 lY1 = lYuyvPtr[0]; |
|
10846 lY1 -= 16; |
|
10847 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
10848 |
|
10849 /*R component*/ |
|
10850 lTemp = (lY1 + lTemp1); |
|
10851 if (lTemp < 0) |
|
10852 lTemp = 0; |
|
10853 if (lTemp > 255) |
|
10854 lTemp = 255; |
|
10855 lRGBFramePtr[3] = (uint8) lTemp; |
|
10856 |
|
10857 /*G component*/ |
|
10858 lTemp = (lY1 - lTemp2); |
|
10859 if (lTemp < 0) |
|
10860 lTemp = 0; |
|
10861 if (lTemp > 255) |
|
10862 lTemp = 255; |
|
10863 lRGBFramePtr[4] = (uint8) lTemp; |
|
10864 |
|
10865 /*B component*/ |
|
10866 lTemp = (lY1 + lTemp3); |
|
10867 if (lTemp < 0) |
|
10868 lTemp = 0; |
|
10869 if (lTemp > 255) |
|
10870 lTemp = 255; |
|
10871 lRGBFramePtr[5] = (uint8) lTemp; |
|
10872 |
|
10873 lYuyvPtr += 4; |
|
10874 lRGBFramePtr += 6; |
|
10875 } |
|
10876 if(extraCol) |
|
10877 { |
|
10878 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10879 lRGBFramePtr++; |
|
10880 |
|
10881 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10882 lRGBFramePtr++; |
|
10883 |
|
10884 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
10885 lRGBFramePtr++; |
|
10886 } |
|
10887 |
|
10888 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
10889 lRGBFramePtr += (wndWidth - lTempWidth); |
|
10890 } |
|
10891 |
|
10892 if(extraRow) |
|
10893 { |
|
10894 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
10895 for(j = 0; j < lWidth * 3; j += 2) |
|
10896 { |
|
10897 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10898 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10899 } |
|
10900 if(extraCol) |
|
10901 { |
|
10902 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10903 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10904 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
10905 } |
|
10906 } |
|
10907 return; |
|
10908 } |
|
10909 |
|
10910 |
|
10911 /* |
|
10912 ****************************************************************************** |
|
10913 Name : sEmz_VDec_YUV422LEChr2toColor4k_Ordered_709_FR |
|
10914 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
10915 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
10916 uint8 *dstImage : Pointer to rgb data (o/p). |
|
10917 tWndParam *srcWindow : Pointer to structure containing source window |
|
10918 parameters like xOffset,yOffset,cropWidth, |
|
10919 cropHeight. (i/p) |
|
10920 tWndParam *dstWindow : Pointer to structure containing destination window |
|
10921 parameters like xOffset,yOffset,windWidth, |
|
10922 windHeight. (i/p) |
|
10923 Return Value : void |
|
10924 ****************************************************************************** |
|
10925 */ |
|
10926 |
|
10927 void sEmz_VDec_YUV422LEChr2toColor4k_Ordered_709_FR |
|
10928 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
10929 tWndParam* srcWindow, tWndParam* dstWindow) |
|
10930 { |
|
10931 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
10932 uint8 *lYuyvPtr; |
|
10933 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
10934 int32 lY1, lCr, lCb; |
|
10935 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
10936 int32 i, j, extraCol, extraRow; |
|
10937 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
10938 cropWidth,cropHeight,wndWidth,wndHeight; |
|
10939 |
|
10940 srcXOffset = srcWindow->xOffset; |
|
10941 srcYOffset = srcWindow->yOffset; |
|
10942 cropWidth = srcWindow->wndWidth; |
|
10943 cropHeight = srcWindow->wndHeight; |
|
10944 |
|
10945 dstXOffset = dstWindow->xOffset; |
|
10946 dstYOffset = dstWindow->yOffset; |
|
10947 wndWidth = dstWindow->wndWidth; |
|
10948 wndHeight = dstWindow->wndHeight; |
|
10949 |
|
10950 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
10951 { |
|
10952 lWidth = cropWidth; |
|
10953 } |
|
10954 else |
|
10955 { |
|
10956 lWidth = srcImage->width - srcXOffset; |
|
10957 } |
|
10958 |
|
10959 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
10960 { |
|
10961 lHeight = cropHeight; |
|
10962 } |
|
10963 else |
|
10964 { |
|
10965 lHeight = srcImage->height - srcYOffset; |
|
10966 } |
|
10967 |
|
10968 if (lWidth > (wndWidth - dstXOffset)) |
|
10969 { |
|
10970 lWidth = wndWidth - dstXOffset; |
|
10971 } |
|
10972 |
|
10973 if (lHeight > (wndHeight - dstYOffset)) |
|
10974 { |
|
10975 lHeight = wndHeight - dstYOffset; |
|
10976 } |
|
10977 |
|
10978 extraCol = lWidth & 0x01; |
|
10979 extraRow = lHeight & 0x01; |
|
10980 |
|
10981 lTempWidth = lWidth; |
|
10982 lWidth = (lWidth >> 1) << 1; |
|
10983 lHeight = (lHeight >> 1) << 1; |
|
10984 |
|
10985 lLumWidth = (srcImage->width >> 1) << 1; |
|
10986 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
10987 |
|
10988 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
10989 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
10990 |
|
10991 lLumWidth <<= 1; |
|
10992 |
|
10993 for(i = 0; i < lHeight; i += 2) |
|
10994 { |
|
10995 for(j = 0; j < lWidth; j += 2) |
|
10996 { |
|
10997 lCb = lYuyvPtr[3]; |
|
10998 lCr = lYuyvPtr[1]; |
|
10999 |
|
11000 lCr -= 128; |
|
11001 lCb -= 128; |
|
11002 |
|
11003 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
11004 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
11005 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
11006 |
|
11007 /*First Pixel*/ |
|
11008 lY1 = lYuyvPtr[2]; |
|
11009 |
|
11010 /*B component*/ |
|
11011 lTemp = lY1 + lTemp3; |
|
11012 if (lTemp < 0) |
|
11013 lTemp = 0; |
|
11014 if (lTemp > 255) |
|
11015 lTemp = 255; |
|
11016 lTemp4 = (lTemp >> 4); |
|
11017 |
|
11018 /*G component*/ |
|
11019 lTemp = lY1 - lTemp2 + 15; |
|
11020 if (lTemp < 0) |
|
11021 lTemp = 0; |
|
11022 if (lTemp > 255) |
|
11023 lTemp = 255; |
|
11024 lTemp4 |= (lTemp >> 4) << 4; |
|
11025 |
|
11026 /*R component*/ |
|
11027 lTemp = lY1 + lTemp1 + 5; |
|
11028 if (lTemp < 0) |
|
11029 lTemp = 0; |
|
11030 if (lTemp > 255) |
|
11031 lTemp = 255; |
|
11032 lTemp4 |= (lTemp >> 4) << 8; |
|
11033 |
|
11034 lRGBFramePtr[0] = (uint16)lTemp4; |
|
11035 |
|
11036 /*Second Pixel*/ |
|
11037 lY1 = lYuyvPtr[0]; |
|
11038 |
|
11039 /*B component*/ |
|
11040 lTemp = lY1 + lTemp3 + 10; |
|
11041 if (lTemp < 0) |
|
11042 lTemp = 0; |
|
11043 if (lTemp > 255) |
|
11044 lTemp = 255; |
|
11045 lTemp4 = (lTemp >> 4); |
|
11046 |
|
11047 /*G component*/ |
|
11048 lTemp = lY1 - lTemp2; |
|
11049 if (lTemp < 0) |
|
11050 lTemp = 0; |
|
11051 if (lTemp > 255) |
|
11052 lTemp = 255; |
|
11053 lTemp4 |= (lTemp >> 4) << 4; |
|
11054 |
|
11055 /*R component*/ |
|
11056 lTemp = lY1 + lTemp1 + 15; |
|
11057 if (lTemp < 0) |
|
11058 lTemp = 0; |
|
11059 if (lTemp > 255) |
|
11060 lTemp = 255; |
|
11061 lTemp4 |= (lTemp >> 4) << 8; |
|
11062 |
|
11063 lRGBFramePtr[1] = (uint16)lTemp4; |
|
11064 |
|
11065 |
|
11066 lCb = lYuyvPtr[lLumWidth + 3]; |
|
11067 lCr = lYuyvPtr[lLumWidth + 1]; |
|
11068 |
|
11069 lCr -= 128; |
|
11070 lCb -= 128; |
|
11071 |
|
11072 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
11073 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
11074 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
11075 |
|
11076 /*Third Pixel*/ |
|
11077 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
11078 |
|
11079 /*B component*/ |
|
11080 lTemp = lY1 + lTemp3 + 15; |
|
11081 if (lTemp < 0) |
|
11082 lTemp = 0; |
|
11083 if (lTemp > 255) |
|
11084 lTemp = 255; |
|
11085 lTemp4 = (lTemp >> 4); |
|
11086 |
|
11087 /*G component*/ |
|
11088 lTemp = lY1 - lTemp2 + 5; |
|
11089 if (lTemp < 0) |
|
11090 lTemp = 0; |
|
11091 if (lTemp > 255) |
|
11092 lTemp = 255; |
|
11093 lTemp4 |= (lTemp >> 4) << 4; |
|
11094 |
|
11095 /*R component*/ |
|
11096 lTemp = lY1 + lTemp1 + 10; |
|
11097 if (lTemp < 0) |
|
11098 lTemp = 0; |
|
11099 if (lTemp > 255) |
|
11100 lTemp = 255; |
|
11101 lTemp4 |= (lTemp >> 4) << 8; |
|
11102 |
|
11103 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
11104 |
|
11105 /*Fourth Pixel*/ |
|
11106 lY1 = lYuyvPtr[lLumWidth]; |
|
11107 |
|
11108 /*B component*/ |
|
11109 lTemp = lY1 + lTemp3 + 5; |
|
11110 if (lTemp < 0) |
|
11111 lTemp = 0; |
|
11112 if (lTemp > 255) |
|
11113 lTemp = 255; |
|
11114 lTemp4 = (lTemp >> 4); |
|
11115 |
|
11116 /*G component*/ |
|
11117 lTemp = lY1 - lTemp2 + 10; |
|
11118 if (lTemp < 0) |
|
11119 lTemp = 0; |
|
11120 if (lTemp > 255) |
|
11121 lTemp = 255; |
|
11122 lTemp4 |= (lTemp >> 4) << 4; |
|
11123 |
|
11124 /*R component*/ |
|
11125 lTemp = lY1 + lTemp1; |
|
11126 if (lTemp < 0) |
|
11127 lTemp = 0; |
|
11128 if (lTemp > 255) |
|
11129 lTemp = 255; |
|
11130 lTemp4 |= (lTemp >> 4) << 8; |
|
11131 |
|
11132 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
11133 |
|
11134 lYuyvPtr += 4; |
|
11135 lRGBFramePtr += 2; |
|
11136 lRGBFramePtr1 += 2; |
|
11137 } |
|
11138 if(extraCol) |
|
11139 { |
|
11140 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
11141 lRGBFramePtr++; |
|
11142 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
11143 lRGBFramePtr1++; |
|
11144 } |
|
11145 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
11146 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
11147 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
11148 } |
|
11149 |
|
11150 if(extraRow) |
|
11151 { |
|
11152 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
11153 for(j = 0; j < lWidth; j += 2) |
|
11154 { |
|
11155 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
11156 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
11157 } |
|
11158 if(extraCol) |
|
11159 { |
|
11160 *lRGBFramePtr = *lRGBFramePtr1; |
|
11161 } |
|
11162 } |
|
11163 return; |
|
11164 } |
|
11165 |
|
11166 /* |
|
11167 ****************************************************************************** |
|
11168 Name : sEmz_VDec_YUV422LEChr2toColor4k_Ordered_601_5_FR |
|
11169 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
11170 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
11171 uint8 *dstImage : Pointer to rgb data (o/p). |
|
11172 tWndParam *srcWindow : Pointer to structure containing source window |
|
11173 parameters like xOffset,yOffset,cropWidth, |
|
11174 cropHeight. (i/p) |
|
11175 tWndParam *dstWindow : Pointer to structure containing destination window |
|
11176 parameters like xOffset,yOffset,windWidth, |
|
11177 windHeight. (i/p) |
|
11178 Return Value : void |
|
11179 ****************************************************************************** |
|
11180 */ |
|
11181 |
|
11182 void sEmz_VDec_YUV422LEChr2toColor4k_Ordered_601_5_FR |
|
11183 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
11184 tWndParam* srcWindow, tWndParam* dstWindow) |
|
11185 { |
|
11186 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
11187 uint8 *lYuyvPtr; |
|
11188 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
11189 int32 lY1, lCr, lCb; |
|
11190 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
11191 int32 i, j, extraCol, extraRow; |
|
11192 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
11193 cropWidth,cropHeight,wndWidth,wndHeight; |
|
11194 |
|
11195 srcXOffset = srcWindow->xOffset; |
|
11196 srcYOffset = srcWindow->yOffset; |
|
11197 cropWidth = srcWindow->wndWidth; |
|
11198 cropHeight = srcWindow->wndHeight; |
|
11199 |
|
11200 dstXOffset = dstWindow->xOffset; |
|
11201 dstYOffset = dstWindow->yOffset; |
|
11202 wndWidth = dstWindow->wndWidth; |
|
11203 wndHeight = dstWindow->wndHeight; |
|
11204 |
|
11205 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
11206 { |
|
11207 lWidth = cropWidth; |
|
11208 } |
|
11209 else |
|
11210 { |
|
11211 lWidth = srcImage->width - srcXOffset; |
|
11212 } |
|
11213 |
|
11214 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
11215 { |
|
11216 lHeight = cropHeight; |
|
11217 } |
|
11218 else |
|
11219 { |
|
11220 lHeight = srcImage->height - srcYOffset; |
|
11221 } |
|
11222 |
|
11223 if (lWidth > (wndWidth - dstXOffset)) |
|
11224 { |
|
11225 lWidth = wndWidth - dstXOffset; |
|
11226 } |
|
11227 |
|
11228 if (lHeight > (wndHeight - dstYOffset)) |
|
11229 { |
|
11230 lHeight = wndHeight - dstYOffset; |
|
11231 } |
|
11232 |
|
11233 extraCol = lWidth & 0x01; |
|
11234 extraRow = lHeight & 0x01; |
|
11235 |
|
11236 lTempWidth = lWidth; |
|
11237 lWidth = (lWidth >> 1) << 1; |
|
11238 lHeight = (lHeight >> 1) << 1; |
|
11239 |
|
11240 lLumWidth = (srcImage->width >> 1) << 1; |
|
11241 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
11242 |
|
11243 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
11244 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
11245 |
|
11246 lLumWidth <<= 1; |
|
11247 |
|
11248 for(i = 0; i < lHeight; i += 2) |
|
11249 { |
|
11250 for(j = 0; j < lWidth; j += 2) |
|
11251 { |
|
11252 lCb = lYuyvPtr[3]; |
|
11253 lCr = lYuyvPtr[1]; |
|
11254 |
|
11255 lCr -= 128; |
|
11256 lCb -= 128; |
|
11257 |
|
11258 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
11259 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
11260 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
11261 |
|
11262 /*First Pixel*/ |
|
11263 lY1 = lYuyvPtr[2]; |
|
11264 |
|
11265 /*B component*/ |
|
11266 lTemp = lY1 + lTemp3; |
|
11267 if (lTemp < 0) |
|
11268 lTemp = 0; |
|
11269 if (lTemp > 255) |
|
11270 lTemp = 255; |
|
11271 lTemp4 = (lTemp >> 4); |
|
11272 |
|
11273 /*G component*/ |
|
11274 lTemp = lY1 - lTemp2 + 15; |
|
11275 if (lTemp < 0) |
|
11276 lTemp = 0; |
|
11277 if (lTemp > 255) |
|
11278 lTemp = 255; |
|
11279 lTemp4 |= (lTemp >> 4) << 4; |
|
11280 |
|
11281 /*R component*/ |
|
11282 lTemp = lY1 + lTemp1 + 5; |
|
11283 if (lTemp < 0) |
|
11284 lTemp = 0; |
|
11285 if (lTemp > 255) |
|
11286 lTemp = 255; |
|
11287 lTemp4 |= (lTemp >> 4) << 8; |
|
11288 |
|
11289 lRGBFramePtr[0] = (uint16)lTemp4; |
|
11290 |
|
11291 /*Second Pixel*/ |
|
11292 lY1 = lYuyvPtr[0]; |
|
11293 |
|
11294 /*B component*/ |
|
11295 lTemp = lY1 + lTemp3 + 10; |
|
11296 if (lTemp < 0) |
|
11297 lTemp = 0; |
|
11298 if (lTemp > 255) |
|
11299 lTemp = 255; |
|
11300 lTemp4 = (lTemp >> 4); |
|
11301 |
|
11302 /*G component*/ |
|
11303 lTemp = lY1 - lTemp2; |
|
11304 if (lTemp < 0) |
|
11305 lTemp = 0; |
|
11306 if (lTemp > 255) |
|
11307 lTemp = 255; |
|
11308 lTemp4 |= (lTemp >> 4) << 4; |
|
11309 |
|
11310 /*R component*/ |
|
11311 lTemp = lY1 + lTemp1 + 15; |
|
11312 if (lTemp < 0) |
|
11313 lTemp = 0; |
|
11314 if (lTemp > 255) |
|
11315 lTemp = 255; |
|
11316 lTemp4 |= (lTemp >> 4) << 8; |
|
11317 |
|
11318 lRGBFramePtr[1] = (uint16)lTemp4; |
|
11319 |
|
11320 |
|
11321 lCb = lYuyvPtr[lLumWidth + 3]; |
|
11322 lCr = lYuyvPtr[lLumWidth + 1]; |
|
11323 |
|
11324 lCr -= 128; |
|
11325 lCb -= 128; |
|
11326 |
|
11327 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
11328 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
11329 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
11330 |
|
11331 /*Third Pixel*/ |
|
11332 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
11333 |
|
11334 /*B component*/ |
|
11335 lTemp = lY1 + lTemp3 + 15; |
|
11336 if (lTemp < 0) |
|
11337 lTemp = 0; |
|
11338 if (lTemp > 255) |
|
11339 lTemp = 255; |
|
11340 lTemp4 = (lTemp >> 4); |
|
11341 |
|
11342 /*G component*/ |
|
11343 lTemp = lY1 - lTemp2 + 5; |
|
11344 if (lTemp < 0) |
|
11345 lTemp = 0; |
|
11346 if (lTemp > 255) |
|
11347 lTemp = 255; |
|
11348 lTemp4 |= (lTemp >> 4) << 4; |
|
11349 |
|
11350 /*R component*/ |
|
11351 lTemp = lY1 + lTemp1 + 10; |
|
11352 if (lTemp < 0) |
|
11353 lTemp = 0; |
|
11354 if (lTemp > 255) |
|
11355 lTemp = 255; |
|
11356 lTemp4 |= (lTemp >> 4) << 8; |
|
11357 |
|
11358 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
11359 |
|
11360 /*Fourth Pixel*/ |
|
11361 lY1 = lYuyvPtr[lLumWidth]; |
|
11362 |
|
11363 /*B component*/ |
|
11364 lTemp = lY1 + lTemp3 + 5; |
|
11365 if (lTemp < 0) |
|
11366 lTemp = 0; |
|
11367 if (lTemp > 255) |
|
11368 lTemp = 255; |
|
11369 lTemp4 = (lTemp >> 4); |
|
11370 |
|
11371 /*G component*/ |
|
11372 lTemp = lY1 - lTemp2 + 10; |
|
11373 if (lTemp < 0) |
|
11374 lTemp = 0; |
|
11375 if (lTemp > 255) |
|
11376 lTemp = 255; |
|
11377 lTemp4 |= (lTemp >> 4) << 4; |
|
11378 |
|
11379 /*R component*/ |
|
11380 lTemp = lY1 + lTemp1; |
|
11381 if (lTemp < 0) |
|
11382 lTemp = 0; |
|
11383 if (lTemp > 255) |
|
11384 lTemp = 255; |
|
11385 lTemp4 |= (lTemp >> 4) << 8; |
|
11386 |
|
11387 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
11388 |
|
11389 lYuyvPtr += 4; |
|
11390 lRGBFramePtr += 2; |
|
11391 lRGBFramePtr1 += 2; |
|
11392 } |
|
11393 if(extraCol) |
|
11394 { |
|
11395 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
11396 lRGBFramePtr++; |
|
11397 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
11398 lRGBFramePtr1++; |
|
11399 } |
|
11400 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
11401 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
11402 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
11403 } |
|
11404 |
|
11405 if(extraRow) |
|
11406 { |
|
11407 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
11408 for(j = 0; j < lWidth; j += 2) |
|
11409 { |
|
11410 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
11411 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
11412 } |
|
11413 if(extraCol) |
|
11414 { |
|
11415 *lRGBFramePtr = *lRGBFramePtr1; |
|
11416 } |
|
11417 } |
|
11418 return; |
|
11419 } |
|
11420 |
|
11421 /* |
|
11422 ****************************************************************************** |
|
11423 Name : sEmz_VDec_YUV422LEChr2toColor4k_Ordered_709_RR |
|
11424 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
11425 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
11426 uint8 *dstImage : Pointer to rgb data (o/p). |
|
11427 tWndParam *srcWindow : Pointer to structure containing source window |
|
11428 parameters like xOffset,yOffset,cropWidth, |
|
11429 cropHeight. (i/p) |
|
11430 tWndParam *dstWindow : Pointer to structure containing destination window |
|
11431 parameters like xOffset,yOffset,windWidth, |
|
11432 windHeight. (i/p) |
|
11433 Return Value : void |
|
11434 ****************************************************************************** |
|
11435 */ |
|
11436 |
|
11437 void sEmz_VDec_YUV422LEChr2toColor4k_Ordered_709_RR |
|
11438 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
11439 tWndParam* srcWindow, tWndParam* dstWindow) |
|
11440 { |
|
11441 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
11442 uint8 *lYuyvPtr; |
|
11443 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
11444 int32 lY1, lCr, lCb; |
|
11445 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
11446 int32 i, j, extraCol, extraRow; |
|
11447 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
11448 cropWidth,cropHeight,wndWidth,wndHeight; |
|
11449 |
|
11450 srcXOffset = srcWindow->xOffset; |
|
11451 srcYOffset = srcWindow->yOffset; |
|
11452 cropWidth = srcWindow->wndWidth; |
|
11453 cropHeight = srcWindow->wndHeight; |
|
11454 |
|
11455 dstXOffset = dstWindow->xOffset; |
|
11456 dstYOffset = dstWindow->yOffset; |
|
11457 wndWidth = dstWindow->wndWidth; |
|
11458 wndHeight = dstWindow->wndHeight; |
|
11459 |
|
11460 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
11461 { |
|
11462 lWidth = cropWidth; |
|
11463 } |
|
11464 else |
|
11465 { |
|
11466 lWidth = srcImage->width - srcXOffset; |
|
11467 } |
|
11468 |
|
11469 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
11470 { |
|
11471 lHeight = cropHeight; |
|
11472 } |
|
11473 else |
|
11474 { |
|
11475 lHeight = srcImage->height - srcYOffset; |
|
11476 } |
|
11477 |
|
11478 if (lWidth > (wndWidth - dstXOffset)) |
|
11479 { |
|
11480 lWidth = wndWidth - dstXOffset; |
|
11481 } |
|
11482 |
|
11483 if (lHeight > (wndHeight - dstYOffset)) |
|
11484 { |
|
11485 lHeight = wndHeight - dstYOffset; |
|
11486 } |
|
11487 |
|
11488 extraCol = lWidth & 0x01; |
|
11489 extraRow = lHeight & 0x01; |
|
11490 |
|
11491 lTempWidth = lWidth; |
|
11492 lWidth = (lWidth >> 1) << 1; |
|
11493 lHeight = (lHeight >> 1) << 1; |
|
11494 |
|
11495 lLumWidth = (srcImage->width >> 1) << 1; |
|
11496 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
11497 |
|
11498 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
11499 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
11500 |
|
11501 lLumWidth <<= 1; |
|
11502 |
|
11503 for(i = 0; i < lHeight; i += 2) |
|
11504 { |
|
11505 for(j = 0; j < lWidth; j += 2) |
|
11506 { |
|
11507 lCb = lYuyvPtr[3]; |
|
11508 lCr = lYuyvPtr[1]; |
|
11509 |
|
11510 lCr -= 128; |
|
11511 lCb -= 128; |
|
11512 |
|
11513 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
11514 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
11515 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
11516 |
|
11517 /*First Pixel*/ |
|
11518 lY1 = lYuyvPtr[2]; |
|
11519 lY1 -= 16; |
|
11520 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
11521 |
|
11522 /*B component*/ |
|
11523 lTemp = lY1 + lTemp3; |
|
11524 if (lTemp < 0) |
|
11525 lTemp = 0; |
|
11526 if (lTemp > 255) |
|
11527 lTemp = 255; |
|
11528 lTemp4 = (lTemp >> 4); |
|
11529 |
|
11530 /*G component*/ |
|
11531 lTemp = lY1 - lTemp2 + 15; |
|
11532 if (lTemp < 0) |
|
11533 lTemp = 0; |
|
11534 if (lTemp > 255) |
|
11535 lTemp = 255; |
|
11536 lTemp4 |= (lTemp >> 4) << 4; |
|
11537 |
|
11538 /*R component*/ |
|
11539 lTemp = lY1 + lTemp1 + 5; |
|
11540 if (lTemp < 0) |
|
11541 lTemp = 0; |
|
11542 if (lTemp > 255) |
|
11543 lTemp = 255; |
|
11544 lTemp4 |= (lTemp >> 4) << 8; |
|
11545 |
|
11546 lRGBFramePtr[0] = (uint16)lTemp4; |
|
11547 |
|
11548 /*Second Pixel*/ |
|
11549 lY1 = lYuyvPtr[0]; |
|
11550 lY1 -= 16; |
|
11551 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
11552 |
|
11553 /*B component*/ |
|
11554 lTemp = lY1 + lTemp3 + 10; |
|
11555 if (lTemp < 0) |
|
11556 lTemp = 0; |
|
11557 if (lTemp > 255) |
|
11558 lTemp = 255; |
|
11559 lTemp4 = (lTemp >> 4); |
|
11560 |
|
11561 /*G component*/ |
|
11562 lTemp = lY1 - lTemp2; |
|
11563 if (lTemp < 0) |
|
11564 lTemp = 0; |
|
11565 if (lTemp > 255) |
|
11566 lTemp = 255; |
|
11567 lTemp4 |= (lTemp >> 4) << 4; |
|
11568 |
|
11569 /*R component*/ |
|
11570 lTemp = lY1 + lTemp1 + 15; |
|
11571 if (lTemp < 0) |
|
11572 lTemp = 0; |
|
11573 if (lTemp > 255) |
|
11574 lTemp = 255; |
|
11575 lTemp4 |= (lTemp >> 4) << 8; |
|
11576 |
|
11577 lRGBFramePtr[1] = (uint16)lTemp4; |
|
11578 |
|
11579 |
|
11580 lCb = lYuyvPtr[lLumWidth + 3]; |
|
11581 lCr = lYuyvPtr[lLumWidth + 1]; |
|
11582 |
|
11583 lCr -= 128; |
|
11584 lCb -= 128; |
|
11585 |
|
11586 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
11587 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
11588 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
11589 |
|
11590 /*Third Pixel*/ |
|
11591 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
11592 lY1 -= 16; |
|
11593 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
11594 |
|
11595 /*B component*/ |
|
11596 lTemp = lY1 + lTemp3 + 15; |
|
11597 if (lTemp < 0) |
|
11598 lTemp = 0; |
|
11599 if (lTemp > 255) |
|
11600 lTemp = 255; |
|
11601 lTemp4 = (lTemp >> 4); |
|
11602 |
|
11603 /*G component*/ |
|
11604 lTemp = lY1 - lTemp2 + 5; |
|
11605 if (lTemp < 0) |
|
11606 lTemp = 0; |
|
11607 if (lTemp > 255) |
|
11608 lTemp = 255; |
|
11609 lTemp4 |= (lTemp >> 4) << 4; |
|
11610 |
|
11611 /*R component*/ |
|
11612 lTemp = lY1 + lTemp1 + 10; |
|
11613 if (lTemp < 0) |
|
11614 lTemp = 0; |
|
11615 if (lTemp > 255) |
|
11616 lTemp = 255; |
|
11617 lTemp4 |= (lTemp >> 4) << 8; |
|
11618 |
|
11619 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
11620 |
|
11621 /*Fourth Pixel*/ |
|
11622 lY1 = lYuyvPtr[lLumWidth]; |
|
11623 lY1 -= 16; |
|
11624 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
11625 |
|
11626 /*B component*/ |
|
11627 lTemp = lY1 + lTemp3 + 5; |
|
11628 if (lTemp < 0) |
|
11629 lTemp = 0; |
|
11630 if (lTemp > 255) |
|
11631 lTemp = 255; |
|
11632 lTemp4 = (lTemp >> 4); |
|
11633 |
|
11634 /*G component*/ |
|
11635 lTemp = lY1 - lTemp2 + 10; |
|
11636 if (lTemp < 0) |
|
11637 lTemp = 0; |
|
11638 if (lTemp > 255) |
|
11639 lTemp = 255; |
|
11640 lTemp4 |= (lTemp >> 4) << 4; |
|
11641 |
|
11642 /*R component*/ |
|
11643 lTemp = lY1 + lTemp1; |
|
11644 if (lTemp < 0) |
|
11645 lTemp = 0; |
|
11646 if (lTemp > 255) |
|
11647 lTemp = 255; |
|
11648 lTemp4 |= (lTemp >> 4) << 8; |
|
11649 |
|
11650 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
11651 |
|
11652 lYuyvPtr += 4; |
|
11653 lRGBFramePtr += 2; |
|
11654 lRGBFramePtr1 += 2; |
|
11655 } |
|
11656 if(extraCol) |
|
11657 { |
|
11658 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
11659 lRGBFramePtr++; |
|
11660 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
11661 lRGBFramePtr1++; |
|
11662 } |
|
11663 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
11664 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
11665 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
11666 } |
|
11667 |
|
11668 if(extraRow) |
|
11669 { |
|
11670 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
11671 for(j = 0; j < lWidth; j += 2) |
|
11672 { |
|
11673 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
11674 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
11675 } |
|
11676 if(extraCol) |
|
11677 { |
|
11678 *lRGBFramePtr = *lRGBFramePtr1; |
|
11679 } |
|
11680 } |
|
11681 return; |
|
11682 } |
|
11683 |
|
11684 /* |
|
11685 ****************************************************************************** |
|
11686 Name : sEmz_VDec_YUV422LEChr2toColor4k_Ordered_601_5_RR |
|
11687 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
11688 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
11689 uint8 *dstImage : Pointer to rgb data (o/p). |
|
11690 tWndParam *srcWindow : Pointer to structure containing source window |
|
11691 parameters like xOffset,yOffset,cropWidth, |
|
11692 cropHeight. (i/p) |
|
11693 tWndParam *dstWindow : Pointer to structure containing destination window |
|
11694 parameters like xOffset,yOffset,windWidth, |
|
11695 windHeight. (i/p) |
|
11696 Return Value : void |
|
11697 ****************************************************************************** |
|
11698 */ |
|
11699 |
|
11700 void sEmz_VDec_YUV422LEChr2toColor4k_Ordered_601_5_RR |
|
11701 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
11702 tWndParam* srcWindow, tWndParam* dstWindow) |
|
11703 { |
|
11704 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
11705 uint8 *lYuyvPtr; |
|
11706 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
11707 int32 lY1, lCr, lCb; |
|
11708 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
11709 int32 i, j, extraCol, extraRow; |
|
11710 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
11711 cropWidth,cropHeight,wndWidth,wndHeight; |
|
11712 |
|
11713 srcXOffset = srcWindow->xOffset; |
|
11714 srcYOffset = srcWindow->yOffset; |
|
11715 cropWidth = srcWindow->wndWidth; |
|
11716 cropHeight = srcWindow->wndHeight; |
|
11717 |
|
11718 dstXOffset = dstWindow->xOffset; |
|
11719 dstYOffset = dstWindow->yOffset; |
|
11720 wndWidth = dstWindow->wndWidth; |
|
11721 wndHeight = dstWindow->wndHeight; |
|
11722 |
|
11723 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
11724 { |
|
11725 lWidth = cropWidth; |
|
11726 } |
|
11727 else |
|
11728 { |
|
11729 lWidth = srcImage->width - srcXOffset; |
|
11730 } |
|
11731 |
|
11732 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
11733 { |
|
11734 lHeight = cropHeight; |
|
11735 } |
|
11736 else |
|
11737 { |
|
11738 lHeight = srcImage->height - srcYOffset; |
|
11739 } |
|
11740 |
|
11741 if (lWidth > (wndWidth - dstXOffset)) |
|
11742 { |
|
11743 lWidth = wndWidth - dstXOffset; |
|
11744 } |
|
11745 |
|
11746 if (lHeight > (wndHeight - dstYOffset)) |
|
11747 { |
|
11748 lHeight = wndHeight - dstYOffset; |
|
11749 } |
|
11750 |
|
11751 extraCol = lWidth & 0x01; |
|
11752 extraRow = lHeight & 0x01; |
|
11753 |
|
11754 lTempWidth = lWidth; |
|
11755 lWidth = (lWidth >> 1) << 1; |
|
11756 lHeight = (lHeight >> 1) << 1; |
|
11757 |
|
11758 lLumWidth = (srcImage->width >> 1) << 1; |
|
11759 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
11760 |
|
11761 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
11762 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
11763 |
|
11764 lLumWidth <<= 1; |
|
11765 |
|
11766 for(i = 0; i < lHeight; i += 2) |
|
11767 { |
|
11768 for(j = 0; j < lWidth; j += 2) |
|
11769 { |
|
11770 lCb = lYuyvPtr[3]; |
|
11771 lCr = lYuyvPtr[1]; |
|
11772 |
|
11773 lCr -= 128; |
|
11774 lCb -= 128; |
|
11775 |
|
11776 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
11777 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
11778 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
11779 |
|
11780 /*First Pixel*/ |
|
11781 lY1 = lYuyvPtr[2]; |
|
11782 lY1 -= 16; |
|
11783 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
11784 |
|
11785 /*B component*/ |
|
11786 lTemp = lY1 + lTemp3; |
|
11787 if (lTemp < 0) |
|
11788 lTemp = 0; |
|
11789 if (lTemp > 255) |
|
11790 lTemp = 255; |
|
11791 lTemp4 = (lTemp >> 4); |
|
11792 |
|
11793 /*G component*/ |
|
11794 lTemp = lY1 - lTemp2 + 15; |
|
11795 if (lTemp < 0) |
|
11796 lTemp = 0; |
|
11797 if (lTemp > 255) |
|
11798 lTemp = 255; |
|
11799 lTemp4 |= (lTemp >> 4) << 4; |
|
11800 |
|
11801 /*R component*/ |
|
11802 lTemp = lY1 + lTemp1 + 5; |
|
11803 if (lTemp < 0) |
|
11804 lTemp = 0; |
|
11805 if (lTemp > 255) |
|
11806 lTemp = 255; |
|
11807 lTemp4 |= (lTemp >> 4) << 8; |
|
11808 |
|
11809 lRGBFramePtr[0] = (uint16)lTemp4; |
|
11810 |
|
11811 /*Second Pixel*/ |
|
11812 lY1 = lYuyvPtr[0]; |
|
11813 lY1 -= 16; |
|
11814 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
11815 |
|
11816 /*B component*/ |
|
11817 lTemp = lY1 + lTemp3 + 10; |
|
11818 if (lTemp < 0) |
|
11819 lTemp = 0; |
|
11820 if (lTemp > 255) |
|
11821 lTemp = 255; |
|
11822 lTemp4 = (lTemp >> 4); |
|
11823 |
|
11824 /*G component*/ |
|
11825 lTemp = lY1 - lTemp2; |
|
11826 if (lTemp < 0) |
|
11827 lTemp = 0; |
|
11828 if (lTemp > 255) |
|
11829 lTemp = 255; |
|
11830 lTemp4 |= (lTemp >> 4) << 4; |
|
11831 |
|
11832 /*R component*/ |
|
11833 lTemp = lY1 + lTemp1 + 15; |
|
11834 if (lTemp < 0) |
|
11835 lTemp = 0; |
|
11836 if (lTemp > 255) |
|
11837 lTemp = 255; |
|
11838 lTemp4 |= (lTemp >> 4) << 8; |
|
11839 |
|
11840 lRGBFramePtr[1] = (uint16)lTemp4; |
|
11841 |
|
11842 |
|
11843 lCb = lYuyvPtr[lLumWidth + 3]; |
|
11844 lCr = lYuyvPtr[lLumWidth + 1]; |
|
11845 |
|
11846 lCr -= 128; |
|
11847 lCb -= 128; |
|
11848 |
|
11849 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
11850 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
11851 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
11852 |
|
11853 /*Third Pixel*/ |
|
11854 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
11855 lY1 -= 16; |
|
11856 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
11857 |
|
11858 /*B component*/ |
|
11859 lTemp = lY1 + lTemp3 + 15; |
|
11860 if (lTemp < 0) |
|
11861 lTemp = 0; |
|
11862 if (lTemp > 255) |
|
11863 lTemp = 255; |
|
11864 lTemp4 = (lTemp >> 4); |
|
11865 |
|
11866 /*G component*/ |
|
11867 lTemp = lY1 - lTemp2 + 5; |
|
11868 if (lTemp < 0) |
|
11869 lTemp = 0; |
|
11870 if (lTemp > 255) |
|
11871 lTemp = 255; |
|
11872 lTemp4 |= (lTemp >> 4) << 4; |
|
11873 |
|
11874 /*R component*/ |
|
11875 lTemp = lY1 + lTemp1 + 10; |
|
11876 if (lTemp < 0) |
|
11877 lTemp = 0; |
|
11878 if (lTemp > 255) |
|
11879 lTemp = 255; |
|
11880 lTemp4 |= (lTemp >> 4) << 8; |
|
11881 |
|
11882 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
11883 |
|
11884 /*Fourth Pixel*/ |
|
11885 lY1 = lYuyvPtr[lLumWidth]; |
|
11886 lY1 -= 16; |
|
11887 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
11888 |
|
11889 /*B component*/ |
|
11890 lTemp = lY1 + lTemp3 + 5; |
|
11891 if (lTemp < 0) |
|
11892 lTemp = 0; |
|
11893 if (lTemp > 255) |
|
11894 lTemp = 255; |
|
11895 lTemp4 = (lTemp >> 4); |
|
11896 |
|
11897 /*G component*/ |
|
11898 lTemp = lY1 - lTemp2 + 10; |
|
11899 if (lTemp < 0) |
|
11900 lTemp = 0; |
|
11901 if (lTemp > 255) |
|
11902 lTemp = 255; |
|
11903 lTemp4 |= (lTemp >> 4) << 4; |
|
11904 |
|
11905 /*R component*/ |
|
11906 lTemp = lY1 + lTemp1; |
|
11907 if (lTemp < 0) |
|
11908 lTemp = 0; |
|
11909 if (lTemp > 255) |
|
11910 lTemp = 255; |
|
11911 lTemp4 |= (lTemp >> 4) << 8; |
|
11912 |
|
11913 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
11914 |
|
11915 lYuyvPtr += 4; |
|
11916 lRGBFramePtr += 2; |
|
11917 lRGBFramePtr1 += 2; |
|
11918 } |
|
11919 if(extraCol) |
|
11920 { |
|
11921 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
11922 lRGBFramePtr++; |
|
11923 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
11924 lRGBFramePtr1++; |
|
11925 } |
|
11926 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
11927 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
11928 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
11929 } |
|
11930 |
|
11931 if(extraRow) |
|
11932 { |
|
11933 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
11934 for(j = 0; j < lWidth; j += 2) |
|
11935 { |
|
11936 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
11937 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
11938 } |
|
11939 if(extraCol) |
|
11940 { |
|
11941 *lRGBFramePtr = *lRGBFramePtr1; |
|
11942 } |
|
11943 } |
|
11944 return; |
|
11945 } |
|
11946 |
|
11947 /* |
|
11948 ****************************************************************************** |
|
11949 Name : sEmz_VDec_YUV422LEChr2toColor16MU_709_FR |
|
11950 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
11951 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
11952 uint8 *dstImage : Pointer to rgb data (o/p). |
|
11953 tWndParam *srcWindow : Pointer to structure containing source window |
|
11954 parameters like xOffset,yOffset,cropWidth, |
|
11955 cropHeight. (i/p) |
|
11956 tWndParam *dstWindow : Pointer to structure containing destination window |
|
11957 parameters like xOffset,yOffset,windWidth, |
|
11958 windHeight. (i/p) |
|
11959 Return Value : void |
|
11960 ****************************************************************************** |
|
11961 */ |
|
11962 |
|
11963 void sEmz_VDec_YUV422LEChr2toColor16MU_709_FR |
|
11964 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
11965 tWndParam* srcWindow, tWndParam* dstWindow) |
|
11966 { |
|
11967 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
11968 uint8 *lYuyvPtr; |
|
11969 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
11970 int32 lY1, lCr, lCb; |
|
11971 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
11972 int32 i, j, extraCol, extraRow; |
|
11973 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
11974 cropWidth,cropHeight,wndWidth,wndHeight; |
|
11975 |
|
11976 srcXOffset = srcWindow->xOffset; |
|
11977 srcYOffset = srcWindow->yOffset; |
|
11978 cropWidth = srcWindow->wndWidth; |
|
11979 cropHeight = srcWindow->wndHeight; |
|
11980 |
|
11981 dstXOffset = dstWindow->xOffset; |
|
11982 dstYOffset = dstWindow->yOffset; |
|
11983 wndWidth = dstWindow->wndWidth; |
|
11984 wndHeight = dstWindow->wndHeight; |
|
11985 |
|
11986 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
11987 { |
|
11988 lWidth = cropWidth; |
|
11989 } |
|
11990 else |
|
11991 { |
|
11992 lWidth = srcImage->width - srcXOffset; |
|
11993 } |
|
11994 |
|
11995 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
11996 { |
|
11997 lHeight = cropHeight; |
|
11998 } |
|
11999 else |
|
12000 { |
|
12001 lHeight = srcImage->height - srcYOffset; |
|
12002 } |
|
12003 |
|
12004 if (lWidth > (wndWidth - dstXOffset)) |
|
12005 { |
|
12006 lWidth = wndWidth - dstXOffset; |
|
12007 } |
|
12008 |
|
12009 if (lHeight > (wndHeight - dstYOffset)) |
|
12010 { |
|
12011 lHeight = wndHeight - dstYOffset; |
|
12012 } |
|
12013 |
|
12014 extraCol = lWidth & 0x01; |
|
12015 extraRow = lHeight & 0x01; |
|
12016 |
|
12017 lTempWidth = lWidth; |
|
12018 lWidth = (lWidth >> 1) << 1; |
|
12019 lHeight = (lHeight >> 1) << 1; |
|
12020 |
|
12021 lLumWidth = (srcImage->width >> 1) << 1; |
|
12022 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
12023 |
|
12024 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
12025 |
|
12026 for(i = 0; i < lHeight; i++) |
|
12027 { |
|
12028 for(j = 0; j < lWidth; j += 2) |
|
12029 { |
|
12030 lCb = lYuyvPtr[3]; |
|
12031 lCr = lYuyvPtr[1]; |
|
12032 |
|
12033 lCr -= 128; |
|
12034 lCb -= 128; |
|
12035 |
|
12036 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
12037 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
12038 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
12039 |
|
12040 /*First Pixel*/ |
|
12041 lY1 = lYuyvPtr[2]; |
|
12042 |
|
12043 /*B component*/ |
|
12044 lTemp = lY1 + lTemp3; |
|
12045 if (lTemp < 0) |
|
12046 lTemp = 0; |
|
12047 if (lTemp > 255) |
|
12048 lTemp = 255; |
|
12049 lTemp4 = (uint8) lTemp; |
|
12050 |
|
12051 /*G component*/ |
|
12052 lTemp = lY1 - lTemp2; |
|
12053 if (lTemp < 0) |
|
12054 lTemp = 0; |
|
12055 if (lTemp > 255) |
|
12056 lTemp = 255; |
|
12057 lTemp4 |= lTemp << 8; |
|
12058 |
|
12059 /*R component*/ |
|
12060 lTemp = lY1 + lTemp1; |
|
12061 if (lTemp < 0) |
|
12062 lTemp = 0; |
|
12063 if (lTemp > 255) |
|
12064 lTemp = 255; |
|
12065 lTemp4 |= lTemp << 16; |
|
12066 |
|
12067 lRGBFramePtr[0] = (uint32)lTemp4; |
|
12068 |
|
12069 /*Second Pixel*/ |
|
12070 lY1 = lYuyvPtr[0]; |
|
12071 |
|
12072 /*B component*/ |
|
12073 lTemp = lY1 + lTemp3; |
|
12074 if (lTemp < 0) |
|
12075 lTemp = 0; |
|
12076 if (lTemp > 255) |
|
12077 lTemp = 255; |
|
12078 lTemp4 = (uint8) lTemp; |
|
12079 |
|
12080 /*G component*/ |
|
12081 lTemp = lY1 - lTemp2; |
|
12082 if (lTemp < 0) |
|
12083 lTemp = 0; |
|
12084 if (lTemp > 255) |
|
12085 lTemp = 255; |
|
12086 lTemp4 |= lTemp << 8; |
|
12087 |
|
12088 /*R component*/ |
|
12089 lTemp = lY1 + lTemp1; |
|
12090 if (lTemp < 0) |
|
12091 lTemp = 0; |
|
12092 if (lTemp > 255) |
|
12093 lTemp = 255; |
|
12094 lTemp4 |= lTemp << 16; |
|
12095 |
|
12096 lRGBFramePtr[1] = (uint32)lTemp4; |
|
12097 |
|
12098 lYuyvPtr += 4; |
|
12099 lRGBFramePtr += 2; |
|
12100 } |
|
12101 if(extraCol) |
|
12102 { |
|
12103 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
12104 lRGBFramePtr++; |
|
12105 } |
|
12106 |
|
12107 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
12108 lRGBFramePtr += (wndWidth - lTempWidth); |
|
12109 } |
|
12110 |
|
12111 if(extraRow) |
|
12112 { |
|
12113 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
12114 for(j = 0; j < lWidth; j += 2) |
|
12115 { |
|
12116 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
12117 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
12118 } |
|
12119 if(extraCol) |
|
12120 { |
|
12121 *lRGBFramePtr = *lRGBFramePtr1; |
|
12122 } |
|
12123 } |
|
12124 return; |
|
12125 } |
|
12126 |
|
12127 /* |
|
12128 ****************************************************************************** |
|
12129 Name : sEmz_VDec_YUV422LEChr2toColor16MU_601_5_FR |
|
12130 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
12131 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
12132 uint8 *dstImage : Pointer to rgb data (o/p). |
|
12133 tWndParam *srcWindow : Pointer to structure containing source window |
|
12134 parameters like xOffset,yOffset,cropWidth, |
|
12135 cropHeight. (i/p) |
|
12136 tWndParam *dstWindow : Pointer to structure containing destination window |
|
12137 parameters like xOffset,yOffset,windWidth, |
|
12138 windHeight. (i/p) |
|
12139 Return Value : void |
|
12140 ****************************************************************************** |
|
12141 */ |
|
12142 |
|
12143 void sEmz_VDec_YUV422LEChr2toColor16MU_601_5_FR |
|
12144 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
12145 tWndParam* srcWindow, tWndParam* dstWindow) |
|
12146 { |
|
12147 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
12148 uint8 *lYuyvPtr; |
|
12149 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
12150 int32 lY1, lCr, lCb; |
|
12151 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
12152 int32 i, j, extraCol, extraRow; |
|
12153 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
12154 cropWidth,cropHeight,wndWidth,wndHeight; |
|
12155 |
|
12156 srcXOffset = srcWindow->xOffset; |
|
12157 srcYOffset = srcWindow->yOffset; |
|
12158 cropWidth = srcWindow->wndWidth; |
|
12159 cropHeight = srcWindow->wndHeight; |
|
12160 |
|
12161 dstXOffset = dstWindow->xOffset; |
|
12162 dstYOffset = dstWindow->yOffset; |
|
12163 wndWidth = dstWindow->wndWidth; |
|
12164 wndHeight = dstWindow->wndHeight; |
|
12165 |
|
12166 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
12167 { |
|
12168 lWidth = cropWidth; |
|
12169 } |
|
12170 else |
|
12171 { |
|
12172 lWidth = srcImage->width - srcXOffset; |
|
12173 } |
|
12174 |
|
12175 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
12176 { |
|
12177 lHeight = cropHeight; |
|
12178 } |
|
12179 else |
|
12180 { |
|
12181 lHeight = srcImage->height - srcYOffset; |
|
12182 } |
|
12183 |
|
12184 if (lWidth > (wndWidth - dstXOffset)) |
|
12185 { |
|
12186 lWidth = wndWidth - dstXOffset; |
|
12187 } |
|
12188 |
|
12189 if (lHeight > (wndHeight - dstYOffset)) |
|
12190 { |
|
12191 lHeight = wndHeight - dstYOffset; |
|
12192 } |
|
12193 |
|
12194 extraCol = lWidth & 0x01; |
|
12195 extraRow = lHeight & 0x01; |
|
12196 |
|
12197 lTempWidth = lWidth; |
|
12198 lWidth = (lWidth >> 1) << 1; |
|
12199 lHeight = (lHeight >> 1) << 1; |
|
12200 |
|
12201 lLumWidth = (srcImage->width >> 1) << 1; |
|
12202 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
12203 |
|
12204 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
12205 |
|
12206 for(i = 0; i < lHeight; i++) |
|
12207 { |
|
12208 for(j = 0; j < lWidth; j += 2) |
|
12209 { |
|
12210 lCb = lYuyvPtr[3]; |
|
12211 lCr = lYuyvPtr[1]; |
|
12212 |
|
12213 lCr -= 128; |
|
12214 lCb -= 128; |
|
12215 |
|
12216 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
12217 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
12218 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
12219 |
|
12220 /*First Pixel*/ |
|
12221 lY1 = lYuyvPtr[2]; |
|
12222 |
|
12223 /*B component*/ |
|
12224 lTemp = lY1 + lTemp3; |
|
12225 if (lTemp < 0) |
|
12226 lTemp = 0; |
|
12227 if (lTemp > 255) |
|
12228 lTemp = 255; |
|
12229 lTemp4 = (uint8) lTemp; |
|
12230 |
|
12231 /*G component*/ |
|
12232 lTemp = lY1 - lTemp2; |
|
12233 if (lTemp < 0) |
|
12234 lTemp = 0; |
|
12235 if (lTemp > 255) |
|
12236 lTemp = 255; |
|
12237 lTemp4 |= lTemp << 8; |
|
12238 |
|
12239 /*R component*/ |
|
12240 lTemp = lY1 + lTemp1; |
|
12241 if (lTemp < 0) |
|
12242 lTemp = 0; |
|
12243 if (lTemp > 255) |
|
12244 lTemp = 255; |
|
12245 lTemp4 |= lTemp << 16; |
|
12246 |
|
12247 lRGBFramePtr[0] = (uint32)lTemp4; |
|
12248 |
|
12249 /*Second Pixel*/ |
|
12250 lY1 = lYuyvPtr[0]; |
|
12251 |
|
12252 /*B component*/ |
|
12253 lTemp = lY1 + lTemp3; |
|
12254 if (lTemp < 0) |
|
12255 lTemp = 0; |
|
12256 if (lTemp > 255) |
|
12257 lTemp = 255; |
|
12258 lTemp4 = (uint8) lTemp; |
|
12259 |
|
12260 /*G component*/ |
|
12261 lTemp = lY1 - lTemp2; |
|
12262 if (lTemp < 0) |
|
12263 lTemp = 0; |
|
12264 if (lTemp > 255) |
|
12265 lTemp = 255; |
|
12266 lTemp4 |= lTemp << 8; |
|
12267 |
|
12268 /*R component*/ |
|
12269 lTemp = lY1 + lTemp1; |
|
12270 if (lTemp < 0) |
|
12271 lTemp = 0; |
|
12272 if (lTemp > 255) |
|
12273 lTemp = 255; |
|
12274 lTemp4 |= lTemp << 16; |
|
12275 |
|
12276 lRGBFramePtr[1] = (uint32)lTemp4; |
|
12277 |
|
12278 lYuyvPtr += 4; |
|
12279 lRGBFramePtr += 2; |
|
12280 } |
|
12281 if(extraCol) |
|
12282 { |
|
12283 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
12284 lRGBFramePtr++; |
|
12285 } |
|
12286 |
|
12287 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
12288 lRGBFramePtr += (wndWidth - lTempWidth); |
|
12289 } |
|
12290 |
|
12291 if(extraRow) |
|
12292 { |
|
12293 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
12294 for(j = 0; j < lWidth; j += 2) |
|
12295 { |
|
12296 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
12297 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
12298 } |
|
12299 if(extraCol) |
|
12300 { |
|
12301 *lRGBFramePtr = *lRGBFramePtr1; |
|
12302 } |
|
12303 } |
|
12304 return; |
|
12305 } |
|
12306 |
|
12307 /* |
|
12308 ****************************************************************************** |
|
12309 Name : sEmz_VDec_YUV422LEChr2toColor16MU_709_RR |
|
12310 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
12311 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
12312 uint8 *dstImage : Pointer to rgb data (o/p). |
|
12313 tWndParam *srcWindow : Pointer to structure containing source window |
|
12314 parameters like xOffset,yOffset,cropWidth, |
|
12315 cropHeight. (i/p) |
|
12316 tWndParam *dstWindow : Pointer to structure containing destination window |
|
12317 parameters like xOffset,yOffset,windWidth, |
|
12318 windHeight. (i/p) |
|
12319 Return Value : void |
|
12320 ****************************************************************************** |
|
12321 */ |
|
12322 |
|
12323 void sEmz_VDec_YUV422LEChr2toColor16MU_709_RR |
|
12324 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
12325 tWndParam* srcWindow, tWndParam* dstWindow) |
|
12326 { |
|
12327 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
12328 uint8 *lYuyvPtr; |
|
12329 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
12330 int32 lY1, lCr, lCb; |
|
12331 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
12332 int32 i, j, extraCol, extraRow; |
|
12333 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
12334 cropWidth,cropHeight,wndWidth,wndHeight; |
|
12335 |
|
12336 srcXOffset = srcWindow->xOffset; |
|
12337 srcYOffset = srcWindow->yOffset; |
|
12338 cropWidth = srcWindow->wndWidth; |
|
12339 cropHeight = srcWindow->wndHeight; |
|
12340 |
|
12341 dstXOffset = dstWindow->xOffset; |
|
12342 dstYOffset = dstWindow->yOffset; |
|
12343 wndWidth = dstWindow->wndWidth; |
|
12344 wndHeight = dstWindow->wndHeight; |
|
12345 |
|
12346 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
12347 { |
|
12348 lWidth = cropWidth; |
|
12349 } |
|
12350 else |
|
12351 { |
|
12352 lWidth = srcImage->width - srcXOffset; |
|
12353 } |
|
12354 |
|
12355 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
12356 { |
|
12357 lHeight = cropHeight; |
|
12358 } |
|
12359 else |
|
12360 { |
|
12361 lHeight = srcImage->height - srcYOffset; |
|
12362 } |
|
12363 |
|
12364 if (lWidth > (wndWidth - dstXOffset)) |
|
12365 { |
|
12366 lWidth = wndWidth - dstXOffset; |
|
12367 } |
|
12368 |
|
12369 if (lHeight > (wndHeight - dstYOffset)) |
|
12370 { |
|
12371 lHeight = wndHeight - dstYOffset; |
|
12372 } |
|
12373 |
|
12374 extraCol = lWidth & 0x01; |
|
12375 extraRow = lHeight & 0x01; |
|
12376 |
|
12377 lTempWidth = lWidth; |
|
12378 lWidth = (lWidth >> 1) << 1; |
|
12379 lHeight = (lHeight >> 1) << 1; |
|
12380 |
|
12381 lLumWidth = (srcImage->width >> 1) << 1; |
|
12382 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
12383 |
|
12384 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
12385 |
|
12386 for(i = 0; i < lHeight; i++) |
|
12387 { |
|
12388 for(j = 0; j < lWidth; j += 2) |
|
12389 { |
|
12390 lCb = lYuyvPtr[3]; |
|
12391 lCr = lYuyvPtr[1]; |
|
12392 |
|
12393 lCr -= 128; |
|
12394 lCb -= 128; |
|
12395 |
|
12396 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
12397 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
12398 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
12399 |
|
12400 /*First Pixel*/ |
|
12401 lY1 = lYuyvPtr[2]; |
|
12402 lY1 -= 16; |
|
12403 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
12404 |
|
12405 /*B component*/ |
|
12406 lTemp = lY1 + lTemp3; |
|
12407 if (lTemp < 0) |
|
12408 lTemp = 0; |
|
12409 if (lTemp > 255) |
|
12410 lTemp = 255; |
|
12411 lTemp4 = (uint8) lTemp; |
|
12412 |
|
12413 /*G component*/ |
|
12414 lTemp = lY1 - lTemp2; |
|
12415 if (lTemp < 0) |
|
12416 lTemp = 0; |
|
12417 if (lTemp > 255) |
|
12418 lTemp = 255; |
|
12419 lTemp4 |= lTemp << 8; |
|
12420 |
|
12421 /*R component*/ |
|
12422 lTemp = lY1 + lTemp1; |
|
12423 if (lTemp < 0) |
|
12424 lTemp = 0; |
|
12425 if (lTemp > 255) |
|
12426 lTemp = 255; |
|
12427 lTemp4 |= lTemp << 16; |
|
12428 |
|
12429 lRGBFramePtr[0] = (uint32)lTemp4; |
|
12430 |
|
12431 /*Second Pixel*/ |
|
12432 lY1 = lYuyvPtr[0]; |
|
12433 lY1 -= 16; |
|
12434 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
12435 |
|
12436 /*B component*/ |
|
12437 lTemp = lY1 + lTemp3; |
|
12438 if (lTemp < 0) |
|
12439 lTemp = 0; |
|
12440 if (lTemp > 255) |
|
12441 lTemp = 255; |
|
12442 lTemp4 = (uint8) lTemp; |
|
12443 |
|
12444 /*G component*/ |
|
12445 lTemp = lY1 - lTemp2; |
|
12446 if (lTemp < 0) |
|
12447 lTemp = 0; |
|
12448 if (lTemp > 255) |
|
12449 lTemp = 255; |
|
12450 lTemp4 |= lTemp << 8; |
|
12451 |
|
12452 /*R component*/ |
|
12453 lTemp = lY1 + lTemp1; |
|
12454 if (lTemp < 0) |
|
12455 lTemp = 0; |
|
12456 if (lTemp > 255) |
|
12457 lTemp = 255; |
|
12458 lTemp4 |= lTemp << 16; |
|
12459 |
|
12460 lRGBFramePtr[1] = (uint32)lTemp4; |
|
12461 |
|
12462 lYuyvPtr += 4; |
|
12463 lRGBFramePtr += 2; |
|
12464 } |
|
12465 if(extraCol) |
|
12466 { |
|
12467 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
12468 lRGBFramePtr++; |
|
12469 } |
|
12470 |
|
12471 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
12472 lRGBFramePtr += (wndWidth - lTempWidth); |
|
12473 } |
|
12474 |
|
12475 if(extraRow) |
|
12476 { |
|
12477 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
12478 for(j = 0; j < lWidth; j += 2) |
|
12479 { |
|
12480 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
12481 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
12482 } |
|
12483 if(extraCol) |
|
12484 { |
|
12485 *lRGBFramePtr = *lRGBFramePtr1; |
|
12486 } |
|
12487 } |
|
12488 return; |
|
12489 } |
|
12490 |
|
12491 /* |
|
12492 ****************************************************************************** |
|
12493 Name : sEmz_VDec_YUV422LEChr2toColor16MU_601_5_RR |
|
12494 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
12495 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
12496 uint8 *dstImage : Pointer to rgb data (o/p). |
|
12497 tWndParam *srcWindow : Pointer to structure containing source window |
|
12498 parameters like xOffset,yOffset,cropWidth, |
|
12499 cropHeight. (i/p) |
|
12500 tWndParam *dstWindow : Pointer to structure containing destination window |
|
12501 parameters like xOffset,yOffset,windWidth, |
|
12502 windHeight. (i/p) |
|
12503 Return Value : void |
|
12504 ****************************************************************************** |
|
12505 */ |
|
12506 |
|
12507 void sEmz_VDec_YUV422LEChr2toColor16MU_601_5_RR |
|
12508 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
12509 tWndParam* srcWindow, tWndParam* dstWindow) |
|
12510 { |
|
12511 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
12512 uint8 *lYuyvPtr; |
|
12513 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
12514 int32 lY1, lCr, lCb; |
|
12515 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
12516 int32 i, j, extraCol, extraRow; |
|
12517 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
12518 cropWidth,cropHeight,wndWidth,wndHeight; |
|
12519 |
|
12520 srcXOffset = srcWindow->xOffset; |
|
12521 srcYOffset = srcWindow->yOffset; |
|
12522 cropWidth = srcWindow->wndWidth; |
|
12523 cropHeight = srcWindow->wndHeight; |
|
12524 |
|
12525 dstXOffset = dstWindow->xOffset; |
|
12526 dstYOffset = dstWindow->yOffset; |
|
12527 wndWidth = dstWindow->wndWidth; |
|
12528 wndHeight = dstWindow->wndHeight; |
|
12529 |
|
12530 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
12531 { |
|
12532 lWidth = cropWidth; |
|
12533 } |
|
12534 else |
|
12535 { |
|
12536 lWidth = srcImage->width - srcXOffset; |
|
12537 } |
|
12538 |
|
12539 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
12540 { |
|
12541 lHeight = cropHeight; |
|
12542 } |
|
12543 else |
|
12544 { |
|
12545 lHeight = srcImage->height - srcYOffset; |
|
12546 } |
|
12547 |
|
12548 if (lWidth > (wndWidth - dstXOffset)) |
|
12549 { |
|
12550 lWidth = wndWidth - dstXOffset; |
|
12551 } |
|
12552 |
|
12553 if (lHeight > (wndHeight - dstYOffset)) |
|
12554 { |
|
12555 lHeight = wndHeight - dstYOffset; |
|
12556 } |
|
12557 |
|
12558 extraCol = lWidth & 0x01; |
|
12559 extraRow = lHeight & 0x01; |
|
12560 |
|
12561 lTempWidth = lWidth; |
|
12562 lWidth = (lWidth >> 1) << 1; |
|
12563 lHeight = (lHeight >> 1) << 1; |
|
12564 |
|
12565 lLumWidth = (srcImage->width >> 1) << 1; |
|
12566 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
12567 |
|
12568 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
12569 |
|
12570 for(i = 0; i < lHeight; i++) |
|
12571 { |
|
12572 for(j = 0; j < lWidth; j += 2) |
|
12573 { |
|
12574 lCb = lYuyvPtr[3]; |
|
12575 lCr = lYuyvPtr[1]; |
|
12576 |
|
12577 lCr -= 128; |
|
12578 lCb -= 128; |
|
12579 |
|
12580 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
12581 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
12582 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
12583 |
|
12584 /*First Pixel*/ |
|
12585 lY1 = lYuyvPtr[2]; |
|
12586 lY1 -= 16; |
|
12587 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
12588 |
|
12589 /*B component*/ |
|
12590 lTemp = lY1 + lTemp3; |
|
12591 if (lTemp < 0) |
|
12592 lTemp = 0; |
|
12593 if (lTemp > 255) |
|
12594 lTemp = 255; |
|
12595 lTemp4 = (uint8) lTemp; |
|
12596 |
|
12597 /*G component*/ |
|
12598 lTemp = lY1 - lTemp2; |
|
12599 if (lTemp < 0) |
|
12600 lTemp = 0; |
|
12601 if (lTemp > 255) |
|
12602 lTemp = 255; |
|
12603 lTemp4 |= lTemp << 8; |
|
12604 |
|
12605 /*R component*/ |
|
12606 lTemp = lY1 + lTemp1; |
|
12607 if (lTemp < 0) |
|
12608 lTemp = 0; |
|
12609 if (lTemp > 255) |
|
12610 lTemp = 255; |
|
12611 lTemp4 |= lTemp << 16; |
|
12612 |
|
12613 lRGBFramePtr[0] = (uint32)lTemp4; |
|
12614 |
|
12615 /*Second Pixel*/ |
|
12616 lY1 = lYuyvPtr[0]; |
|
12617 lY1 -= 16; |
|
12618 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
12619 |
|
12620 /*B component*/ |
|
12621 lTemp = lY1 + lTemp3; |
|
12622 if (lTemp < 0) |
|
12623 lTemp = 0; |
|
12624 if (lTemp > 255) |
|
12625 lTemp = 255; |
|
12626 lTemp4 = (uint8) lTemp; |
|
12627 |
|
12628 /*G component*/ |
|
12629 lTemp = lY1 - lTemp2; |
|
12630 if (lTemp < 0) |
|
12631 lTemp = 0; |
|
12632 if (lTemp > 255) |
|
12633 lTemp = 255; |
|
12634 lTemp4 |= lTemp << 8; |
|
12635 |
|
12636 /*R component*/ |
|
12637 lTemp = lY1 + lTemp1; |
|
12638 if (lTemp < 0) |
|
12639 lTemp = 0; |
|
12640 if (lTemp > 255) |
|
12641 lTemp = 255; |
|
12642 lTemp4 |= lTemp << 16; |
|
12643 |
|
12644 lRGBFramePtr[1] = (uint32)lTemp4; |
|
12645 |
|
12646 lYuyvPtr += 4; |
|
12647 lRGBFramePtr += 2; |
|
12648 } |
|
12649 if(extraCol) |
|
12650 { |
|
12651 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
12652 lRGBFramePtr++; |
|
12653 } |
|
12654 |
|
12655 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
12656 lRGBFramePtr += (wndWidth - lTempWidth); |
|
12657 } |
|
12658 |
|
12659 if(extraRow) |
|
12660 { |
|
12661 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
12662 for(j = 0; j < lWidth; j += 2) |
|
12663 { |
|
12664 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
12665 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
12666 } |
|
12667 if(extraCol) |
|
12668 { |
|
12669 *lRGBFramePtr = *lRGBFramePtr1; |
|
12670 } |
|
12671 } |
|
12672 return; |
|
12673 } |
|
12674 |
|
12675 /***** End of YUV422LE input ****/ |
|
12676 |
|
12677 |
|
12678 |
|
12679 |
|
12680 |
|
12681 |
|
12682 |
|
12683 |
|
12684 /* |
|
12685 ****************************************************************************** |
|
12686 Name : sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_709_FR |
|
12687 Description : Converts YUV420 Chroma2 Planar to RGB565 Interleaved format |
|
12688 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
12689 uint8 *dstImage : Pointer to rgb data (o/p). |
|
12690 tWndParam *srcWindow : Pointer to structure containing source window |
|
12691 parameters like xOffset,yOffset,cropWidth, |
|
12692 cropHeight. (i/p) |
|
12693 tWndParam *dstWindow : Pointer to structure containing destination window |
|
12694 parameters like xOffset,yOffset,windWidth, |
|
12695 windHeight. (i/p) |
|
12696 Return Value : void |
|
12697 ****************************************************************************** |
|
12698 */ |
|
12699 |
|
12700 void sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_709_FR |
|
12701 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
12702 tWndParam* srcWindow, tWndParam* dstWindow) |
|
12703 { |
|
12704 uint16 *dest1, *dest2; |
|
12705 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
12706 uint8 *lBuffer; |
|
12707 uint8 *src1, *src2; |
|
12708 uint8 *lPtr1, *lPtr2; |
|
12709 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
12710 int32 lY1, lCr, lCb; |
|
12711 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
12712 int32 diff1, diff2, diff3; |
|
12713 int32 i, j, k, extraRow, extraCol; |
|
12714 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
12715 cropWidth,cropHeight,wndWidth,wndHeight; |
|
12716 |
|
12717 srcXOffset = srcWindow->xOffset; |
|
12718 srcYOffset = srcWindow->yOffset; |
|
12719 cropWidth = srcWindow->wndWidth; |
|
12720 cropHeight = srcWindow->wndHeight; |
|
12721 |
|
12722 dstXOffset = dstWindow->xOffset; |
|
12723 dstYOffset = dstWindow->yOffset; |
|
12724 wndWidth = dstWindow->wndWidth; |
|
12725 wndHeight = dstWindow->wndHeight; |
|
12726 |
|
12727 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
12728 { |
|
12729 lWidth = cropWidth; |
|
12730 } |
|
12731 else |
|
12732 { |
|
12733 lWidth = srcImage->width - srcXOffset; |
|
12734 } |
|
12735 |
|
12736 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
12737 { |
|
12738 lHeight = cropHeight; |
|
12739 } |
|
12740 else |
|
12741 { |
|
12742 lHeight = srcImage->height - srcYOffset; |
|
12743 } |
|
12744 |
|
12745 if (lWidth > (wndWidth - dstXOffset)) |
|
12746 { |
|
12747 lWidth = wndWidth - dstXOffset; |
|
12748 } |
|
12749 |
|
12750 if (lHeight > (wndHeight - dstYOffset)) |
|
12751 { |
|
12752 lHeight = wndHeight - dstYOffset; |
|
12753 } |
|
12754 |
|
12755 extraCol = lWidth & 0x01; |
|
12756 extraRow = lHeight & 0x01; |
|
12757 |
|
12758 lTempWidth = lWidth; |
|
12759 lWidth = (lWidth >> 1) << 1; |
|
12760 lHeight = (lHeight >> 1) << 1; |
|
12761 |
|
12762 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
12763 |
|
12764 lSrcWidth = lWidth * 3; |
|
12765 |
|
12766 lLumWidth = (srcImage->width >> 1) << 1; |
|
12767 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
12768 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
12769 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
12770 |
|
12771 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
12772 dest2 = dest1 + wndWidth; |
|
12773 |
|
12774 for(i = 0; i < lHeight; i += 2) |
|
12775 { |
|
12776 lPtr1 = src1 = lBuffer; |
|
12777 lPtr2 = src2 = src1 + lSrcWidth; |
|
12778 |
|
12779 for(k = 0; k < lWidth; k += 2) |
|
12780 { |
|
12781 lCr = lCrPtr[k >> 1]; |
|
12782 lCb = lCbPtr[k >> 1]; |
|
12783 |
|
12784 lCr -= 128; |
|
12785 lCb -= 128; |
|
12786 |
|
12787 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
12788 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
12789 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
12790 |
|
12791 /*First Pixel*/ |
|
12792 lY1 = lLumPtr[k]; |
|
12793 |
|
12794 lTemp = lY1 + lTemp1; |
|
12795 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12796 |
|
12797 lTemp = lY1 - lTemp2; |
|
12798 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12799 |
|
12800 lTemp = lY1 + lTemp3; |
|
12801 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12802 |
|
12803 /*Second Pixel*/ |
|
12804 lY1 = lLumPtr[k + 1]; |
|
12805 |
|
12806 lTemp = lY1 + lTemp1; |
|
12807 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12808 |
|
12809 lTemp = lY1 - lTemp2; |
|
12810 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12811 |
|
12812 lTemp = lY1 + lTemp3; |
|
12813 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12814 |
|
12815 |
|
12816 /*Third Pixel*/ |
|
12817 lY1 = lLumPtr[k + lLumWidth]; |
|
12818 |
|
12819 lTemp = lY1 + lTemp1; |
|
12820 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12821 |
|
12822 lTemp = lY1 - lTemp2; |
|
12823 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12824 |
|
12825 lTemp = lY1 + lTemp3; |
|
12826 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12827 |
|
12828 /*Fourth Pixel*/ |
|
12829 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
12830 |
|
12831 lTemp = lY1 + lTemp1; |
|
12832 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12833 |
|
12834 lTemp = lY1 - lTemp2; |
|
12835 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12836 |
|
12837 lTemp = lY1 + lTemp3; |
|
12838 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12839 |
|
12840 |
|
12841 lCr = lCrPtr[(k + lLumWidth) >> 1]; |
|
12842 lCb = lCbPtr[(k + lLumWidth) >> 1]; |
|
12843 |
|
12844 lCr -= 128; |
|
12845 lCb -= 128; |
|
12846 |
|
12847 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
12848 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
12849 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
12850 |
|
12851 /*Fifth Pixel*/ |
|
12852 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
12853 |
|
12854 lTemp = lY1 + lTemp1; |
|
12855 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12856 |
|
12857 lTemp = lY1 - lTemp2; |
|
12858 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12859 |
|
12860 lTemp = lY1 + lTemp3; |
|
12861 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12862 |
|
12863 /*Sixth Pixel*/ |
|
12864 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
12865 |
|
12866 lTemp = lY1 + lTemp1; |
|
12867 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12868 |
|
12869 lTemp = lY1 - lTemp2; |
|
12870 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12871 |
|
12872 lTemp = lY1 + lTemp3; |
|
12873 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
12874 |
|
12875 src1 += 6; |
|
12876 src2 += 6; |
|
12877 } |
|
12878 |
|
12879 src1 = lPtr1; |
|
12880 src2 = lPtr2; |
|
12881 |
|
12882 for(j = 0; j < lWidth; j += 2) |
|
12883 { |
|
12884 /* First Pixel */ |
|
12885 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
12886 diff1 = *src1 & 0x7; |
|
12887 diff2 = *(src1 + 1) & 0x3; |
|
12888 diff3 = *(src1 + 2) & 0x7; |
|
12889 |
|
12890 // diffuse the error |
|
12891 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
12892 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
12893 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
12894 |
|
12895 /* Second Pixel */ |
|
12896 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
12897 diff1 = *(src1 + 3) & 0x7; |
|
12898 diff2 = *(src1 + 4) & 0x3; |
|
12899 diff3 = *(src1 + 5) & 0x7; |
|
12900 // diffuse the error |
|
12901 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
12902 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
12903 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
12904 |
|
12905 src1 += 6; |
|
12906 dest1 += 2; |
|
12907 |
|
12908 /* Third Pixel */ |
|
12909 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
12910 diff1 = *src2 & 0x7; |
|
12911 diff2 = *(src2 + 1) & 0x3; |
|
12912 diff3 = *(src2 + 2) & 0x7; |
|
12913 //diffuse the error |
|
12914 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
12915 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
12916 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
12917 |
|
12918 /* Fourth Pixel */ |
|
12919 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
12920 diff1 = *(src2 + 3) & 0x7; |
|
12921 diff2 = *(src2 + 4) & 0x3; |
|
12922 diff3 = *(src2 + 5) & 0x7; |
|
12923 //diffuse the error |
|
12924 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
12925 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
12926 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
12927 |
|
12928 src2 += 6; |
|
12929 dest2 += 2; |
|
12930 } |
|
12931 if(extraCol) |
|
12932 { |
|
12933 *dest1 = dest1[-1]; |
|
12934 dest1++; |
|
12935 *dest2 = dest2[-1]; |
|
12936 dest2++; |
|
12937 } |
|
12938 |
|
12939 lLumPtr += (lLumWidth << 1); |
|
12940 lCrPtr += (lLumWidth >> 1); |
|
12941 lCbPtr += (lLumWidth >> 1); |
|
12942 |
|
12943 dest1 += ((wndWidth << 1) - lTempWidth); |
|
12944 dest2 += ((wndWidth << 1) - lTempWidth); |
|
12945 } |
|
12946 |
|
12947 if(extraRow) |
|
12948 { |
|
12949 dest2 = dest1 - wndWidth; |
|
12950 for(j = 0; j < lWidth; j += 2) |
|
12951 { |
|
12952 *dest1++ = *dest2++; |
|
12953 *dest1++ = *dest2++; |
|
12954 } |
|
12955 if(extraCol) |
|
12956 { |
|
12957 *dest1 = *dest2; |
|
12958 } |
|
12959 } |
|
12960 |
|
12961 free(lBuffer); |
|
12962 return; |
|
12963 } |
|
12964 |
|
12965 |
|
12966 /* |
|
12967 ****************************************************************************** |
|
12968 Name : sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_601_5_FR |
|
12969 Description : Converts YUV420 Chroma2 Planar to RGB565 Interleaved format |
|
12970 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
12971 uint8 *dstImage : Pointer to rgb data (o/p). |
|
12972 tWndParam *srcWindow : Pointer to structure containing source window |
|
12973 parameters like xOffset,yOffset,cropWidth, |
|
12974 cropHeight. (i/p) |
|
12975 tWndParam *dstWindow : Pointer to structure containing destination window |
|
12976 parameters like xOffset,yOffset,windWidth, |
|
12977 windHeight. (i/p) |
|
12978 Return Value : void |
|
12979 ****************************************************************************** |
|
12980 */ |
|
12981 |
|
12982 void sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_601_5_FR |
|
12983 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
12984 tWndParam* srcWindow, tWndParam* dstWindow) |
|
12985 { |
|
12986 uint16 *dest1, *dest2; |
|
12987 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
12988 uint8 *lBuffer; |
|
12989 uint8 *src1, *src2; |
|
12990 uint8 *lPtr1, *lPtr2; |
|
12991 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
12992 int32 lY1, lCr, lCb; |
|
12993 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
12994 int32 diff1, diff2, diff3; |
|
12995 int32 i, j, k, extraRow, extraCol; |
|
12996 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
12997 cropWidth,cropHeight,wndWidth,wndHeight; |
|
12998 |
|
12999 srcXOffset = srcWindow->xOffset; |
|
13000 srcYOffset = srcWindow->yOffset; |
|
13001 cropWidth = srcWindow->wndWidth; |
|
13002 cropHeight = srcWindow->wndHeight; |
|
13003 |
|
13004 dstXOffset = dstWindow->xOffset; |
|
13005 dstYOffset = dstWindow->yOffset; |
|
13006 wndWidth = dstWindow->wndWidth; |
|
13007 wndHeight = dstWindow->wndHeight; |
|
13008 |
|
13009 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
13010 { |
|
13011 lWidth = cropWidth; |
|
13012 } |
|
13013 else |
|
13014 { |
|
13015 lWidth = srcImage->width - srcXOffset; |
|
13016 } |
|
13017 |
|
13018 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
13019 { |
|
13020 lHeight = cropHeight; |
|
13021 } |
|
13022 else |
|
13023 { |
|
13024 lHeight = srcImage->height - srcYOffset; |
|
13025 } |
|
13026 |
|
13027 if (lWidth > (wndWidth - dstXOffset)) |
|
13028 { |
|
13029 lWidth = wndWidth - dstXOffset; |
|
13030 } |
|
13031 |
|
13032 if (lHeight > (wndHeight - dstYOffset)) |
|
13033 { |
|
13034 lHeight = wndHeight - dstYOffset; |
|
13035 } |
|
13036 |
|
13037 extraCol = lWidth & 0x01; |
|
13038 extraRow = lHeight & 0x01; |
|
13039 |
|
13040 lTempWidth = lWidth; |
|
13041 lWidth = (lWidth >> 1) << 1; |
|
13042 lHeight = (lHeight >> 1) << 1; |
|
13043 |
|
13044 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
13045 |
|
13046 lSrcWidth = lWidth * 3; |
|
13047 |
|
13048 lLumWidth = (srcImage->width >> 1) << 1; |
|
13049 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
13050 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
13051 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
13052 |
|
13053 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
13054 dest2 = dest1 + wndWidth; |
|
13055 |
|
13056 for(i = 0; i < lHeight; i += 2) |
|
13057 { |
|
13058 lPtr1 = src1 = lBuffer; |
|
13059 lPtr2 = src2 = src1 + lSrcWidth; |
|
13060 |
|
13061 for(k = 0; k < lWidth; k += 2) |
|
13062 { |
|
13063 lCr = lCrPtr[k >> 1]; |
|
13064 lCb = lCbPtr[k >> 1]; |
|
13065 |
|
13066 lCr -= 128; |
|
13067 lCb -= 128; |
|
13068 |
|
13069 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
13070 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
13071 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
13072 |
|
13073 /*First Pixel*/ |
|
13074 lY1 = lLumPtr[k]; |
|
13075 |
|
13076 lTemp = lY1 + lTemp1; |
|
13077 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13078 |
|
13079 lTemp = lY1 - lTemp2; |
|
13080 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13081 |
|
13082 lTemp = lY1 + lTemp3; |
|
13083 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13084 |
|
13085 /*Second Pixel*/ |
|
13086 lY1 = lLumPtr[k + 1]; |
|
13087 |
|
13088 lTemp = lY1 + lTemp1; |
|
13089 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13090 |
|
13091 lTemp = lY1 - lTemp2; |
|
13092 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13093 |
|
13094 lTemp = lY1 + lTemp3; |
|
13095 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13096 |
|
13097 |
|
13098 /*Third Pixel*/ |
|
13099 lY1 = lLumPtr[k + lLumWidth]; |
|
13100 |
|
13101 lTemp = lY1 + lTemp1; |
|
13102 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13103 |
|
13104 lTemp = lY1 - lTemp2; |
|
13105 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13106 |
|
13107 lTemp = lY1 + lTemp3; |
|
13108 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13109 |
|
13110 /*Fourth Pixel*/ |
|
13111 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
13112 |
|
13113 lTemp = lY1 + lTemp1; |
|
13114 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13115 |
|
13116 lTemp = lY1 - lTemp2; |
|
13117 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13118 |
|
13119 lTemp = lY1 + lTemp3; |
|
13120 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13121 |
|
13122 |
|
13123 lCr = lCrPtr[(k + lLumWidth) >> 1]; |
|
13124 lCb = lCbPtr[(k + lLumWidth) >> 1]; |
|
13125 |
|
13126 lCr -= 128; |
|
13127 lCb -= 128; |
|
13128 |
|
13129 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
13130 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
13131 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
13132 |
|
13133 /*Fifth Pixel*/ |
|
13134 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
13135 |
|
13136 lTemp = lY1 + lTemp1; |
|
13137 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13138 |
|
13139 lTemp = lY1 - lTemp2; |
|
13140 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13141 |
|
13142 lTemp = lY1 + lTemp3; |
|
13143 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13144 |
|
13145 /*Sixth Pixel*/ |
|
13146 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
13147 |
|
13148 lTemp = lY1 + lTemp1; |
|
13149 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13150 |
|
13151 lTemp = lY1 - lTemp2; |
|
13152 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13153 |
|
13154 lTemp = lY1 + lTemp3; |
|
13155 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13156 |
|
13157 src1 += 6; |
|
13158 src2 += 6; |
|
13159 } |
|
13160 |
|
13161 src1 = lPtr1; |
|
13162 src2 = lPtr2; |
|
13163 |
|
13164 for(j = 0; j < lWidth; j += 2) |
|
13165 { |
|
13166 /* First Pixel */ |
|
13167 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
13168 diff1 = *src1 & 0x7; |
|
13169 diff2 = *(src1 + 1) & 0x3; |
|
13170 diff3 = *(src1 + 2) & 0x7; |
|
13171 |
|
13172 // diffuse the error |
|
13173 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
13174 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
13175 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
13176 |
|
13177 /* Second Pixel */ |
|
13178 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
13179 diff1 = *(src1 + 3) & 0x7; |
|
13180 diff2 = *(src1 + 4) & 0x3; |
|
13181 diff3 = *(src1 + 5) & 0x7; |
|
13182 // diffuse the error |
|
13183 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
13184 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
13185 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
13186 |
|
13187 src1 += 6; |
|
13188 dest1 += 2; |
|
13189 |
|
13190 /* Third Pixel */ |
|
13191 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
13192 diff1 = *src2 & 0x7; |
|
13193 diff2 = *(src2 + 1) & 0x3; |
|
13194 diff3 = *(src2 + 2) & 0x7; |
|
13195 //diffuse the error |
|
13196 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
13197 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
13198 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
13199 |
|
13200 /* Fourth Pixel */ |
|
13201 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
13202 diff1 = *(src2 + 3) & 0x7; |
|
13203 diff2 = *(src2 + 4) & 0x3; |
|
13204 diff3 = *(src2 + 5) & 0x7; |
|
13205 //diffuse the error |
|
13206 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
13207 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
13208 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
13209 |
|
13210 src2 += 6; |
|
13211 dest2 += 2; |
|
13212 } |
|
13213 if(extraCol) |
|
13214 { |
|
13215 *dest1 = dest1[-1]; |
|
13216 dest1++; |
|
13217 *dest2 = dest2[-1]; |
|
13218 dest2++; |
|
13219 } |
|
13220 |
|
13221 lLumPtr += (lLumWidth << 1); |
|
13222 lCrPtr += (lLumWidth >> 1); |
|
13223 lCbPtr += (lLumWidth >> 1); |
|
13224 |
|
13225 dest1 += ((wndWidth << 1) - lTempWidth); |
|
13226 dest2 += ((wndWidth << 1) - lTempWidth); |
|
13227 } |
|
13228 |
|
13229 if(extraRow) |
|
13230 { |
|
13231 dest2 = dest1 - wndWidth; |
|
13232 for(j = 0; j < lWidth; j += 2) |
|
13233 { |
|
13234 *dest1++ = *dest2++; |
|
13235 *dest1++ = *dest2++; |
|
13236 } |
|
13237 if(extraCol) |
|
13238 { |
|
13239 *dest1 = *dest2; |
|
13240 } |
|
13241 } |
|
13242 |
|
13243 free(lBuffer); |
|
13244 return; |
|
13245 } |
|
13246 |
|
13247 |
|
13248 /* |
|
13249 ****************************************************************************** |
|
13250 Name : sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_709_RR |
|
13251 Description : Converts YUV420 Chroma2 Planar to RGB565 Interleaved format |
|
13252 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
13253 uint8 *dstImage : Pointer to rgb data (o/p). |
|
13254 tWndParam *srcWindow : Pointer to structure containing source window |
|
13255 parameters like xOffset,yOffset,cropWidth, |
|
13256 cropHeight. (i/p) |
|
13257 tWndParam *dstWindow : Pointer to structure containing destination window |
|
13258 parameters like xOffset,yOffset,windWidth, |
|
13259 windHeight. (i/p) |
|
13260 Return Value : void |
|
13261 ****************************************************************************** |
|
13262 */ |
|
13263 |
|
13264 void sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_709_RR |
|
13265 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
13266 tWndParam* srcWindow, tWndParam* dstWindow) |
|
13267 { |
|
13268 uint16 *dest1, *dest2; |
|
13269 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
13270 uint8 *lBuffer; |
|
13271 uint8 *src1, *src2; |
|
13272 uint8 *lPtr1, *lPtr2; |
|
13273 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
13274 int32 lY1, lCr, lCb; |
|
13275 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
13276 int32 diff1, diff2, diff3; |
|
13277 int32 i, j, k, extraRow, extraCol; |
|
13278 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
13279 cropWidth,cropHeight,wndWidth,wndHeight; |
|
13280 |
|
13281 srcXOffset = srcWindow->xOffset; |
|
13282 srcYOffset = srcWindow->yOffset; |
|
13283 cropWidth = srcWindow->wndWidth; |
|
13284 cropHeight = srcWindow->wndHeight; |
|
13285 |
|
13286 dstXOffset = dstWindow->xOffset; |
|
13287 dstYOffset = dstWindow->yOffset; |
|
13288 wndWidth = dstWindow->wndWidth; |
|
13289 wndHeight = dstWindow->wndHeight; |
|
13290 |
|
13291 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
13292 { |
|
13293 lWidth = cropWidth; |
|
13294 } |
|
13295 else |
|
13296 { |
|
13297 lWidth = srcImage->width - srcXOffset; |
|
13298 } |
|
13299 |
|
13300 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
13301 { |
|
13302 lHeight = cropHeight; |
|
13303 } |
|
13304 else |
|
13305 { |
|
13306 lHeight = srcImage->height - srcYOffset; |
|
13307 } |
|
13308 |
|
13309 if (lWidth > (wndWidth - dstXOffset)) |
|
13310 { |
|
13311 lWidth = wndWidth - dstXOffset; |
|
13312 } |
|
13313 |
|
13314 if (lHeight > (wndHeight - dstYOffset)) |
|
13315 { |
|
13316 lHeight = wndHeight - dstYOffset; |
|
13317 } |
|
13318 |
|
13319 extraCol = lWidth & 0x01; |
|
13320 extraRow = lHeight & 0x01; |
|
13321 |
|
13322 lTempWidth = lWidth; |
|
13323 lWidth = (lWidth >> 1) << 1; |
|
13324 lHeight = (lHeight >> 1) << 1; |
|
13325 |
|
13326 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
13327 |
|
13328 lSrcWidth = lWidth * 3; |
|
13329 |
|
13330 lLumWidth = (srcImage->width >> 1) << 1; |
|
13331 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
13332 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
13333 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
13334 |
|
13335 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
13336 dest2 = dest1 + wndWidth; |
|
13337 |
|
13338 for(i = 0; i < lHeight; i += 2) |
|
13339 { |
|
13340 lPtr1 = src1 = lBuffer; |
|
13341 lPtr2 = src2 = src1 + lSrcWidth; |
|
13342 |
|
13343 for(k = 0; k < lWidth; k += 2) |
|
13344 { |
|
13345 lCr = lCrPtr[k >> 1]; |
|
13346 lCb = lCbPtr[k >> 1]; |
|
13347 |
|
13348 lCr -= 128; |
|
13349 lCb -= 128; |
|
13350 |
|
13351 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
13352 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
13353 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
13354 |
|
13355 /*First Pixel*/ |
|
13356 lY1 = lLumPtr[k]; |
|
13357 lY1 -= 16; |
|
13358 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
13359 |
|
13360 lTemp = lY1 + lTemp1; |
|
13361 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13362 |
|
13363 lTemp = lY1 - lTemp2; |
|
13364 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13365 |
|
13366 lTemp = lY1 + lTemp3; |
|
13367 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13368 |
|
13369 /*Second Pixel*/ |
|
13370 lY1 = lLumPtr[k + 1]; |
|
13371 lY1 -= 16; |
|
13372 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
13373 |
|
13374 lTemp = lY1 + lTemp1; |
|
13375 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13376 |
|
13377 lTemp = lY1 - lTemp2; |
|
13378 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13379 |
|
13380 lTemp = lY1 + lTemp3; |
|
13381 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13382 |
|
13383 |
|
13384 /*Third Pixel*/ |
|
13385 lY1 = lLumPtr[k + lLumWidth]; |
|
13386 lY1 -= 16; |
|
13387 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
13388 |
|
13389 lTemp = lY1 + lTemp1; |
|
13390 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13391 |
|
13392 lTemp = lY1 - lTemp2; |
|
13393 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13394 |
|
13395 lTemp = lY1 + lTemp3; |
|
13396 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13397 |
|
13398 /*Fourth Pixel*/ |
|
13399 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
13400 lY1 -= 16; |
|
13401 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
13402 |
|
13403 lTemp = lY1 + lTemp1; |
|
13404 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13405 |
|
13406 lTemp = lY1 - lTemp2; |
|
13407 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13408 |
|
13409 lTemp = lY1 + lTemp3; |
|
13410 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13411 |
|
13412 lCr = lCrPtr[(k + lLumWidth) >> 1]; |
|
13413 lCb = lCbPtr[(k + lLumWidth) >> 1]; |
|
13414 |
|
13415 lCr -= 128; |
|
13416 lCb -= 128; |
|
13417 |
|
13418 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
13419 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
13420 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
13421 |
|
13422 /*Fifth Pixel*/ |
|
13423 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
13424 |
|
13425 lTemp = lY1 + lTemp1; |
|
13426 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13427 |
|
13428 lTemp = lY1 - lTemp2; |
|
13429 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13430 |
|
13431 lTemp = lY1 + lTemp3; |
|
13432 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13433 |
|
13434 /*Sixth Pixel*/ |
|
13435 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
13436 |
|
13437 lTemp = lY1 + lTemp1; |
|
13438 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13439 |
|
13440 lTemp = lY1 - lTemp2; |
|
13441 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13442 |
|
13443 lTemp = lY1 + lTemp3; |
|
13444 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13445 |
|
13446 src1 += 6; |
|
13447 src2 += 6; |
|
13448 } |
|
13449 |
|
13450 src1 = lPtr1; |
|
13451 src2 = lPtr2; |
|
13452 |
|
13453 for(j = 0; j < lWidth; j += 2) |
|
13454 { |
|
13455 /* First Pixel */ |
|
13456 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
13457 diff1 = *src1 & 0x7; |
|
13458 diff2 = *(src1 + 1) & 0x3; |
|
13459 diff3 = *(src1 + 2) & 0x7; |
|
13460 |
|
13461 // diffuse the error |
|
13462 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
13463 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
13464 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
13465 |
|
13466 /* Second Pixel */ |
|
13467 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
13468 diff1 = *(src1 + 3) & 0x7; |
|
13469 diff2 = *(src1 + 4) & 0x3; |
|
13470 diff3 = *(src1 + 5) & 0x7; |
|
13471 // diffuse the error |
|
13472 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
13473 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
13474 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
13475 |
|
13476 src1 += 6; |
|
13477 dest1 += 2; |
|
13478 |
|
13479 /* Third Pixel */ |
|
13480 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
13481 diff1 = *src2 & 0x7; |
|
13482 diff2 = *(src2 + 1) & 0x3; |
|
13483 diff3 = *(src2 + 2) & 0x7; |
|
13484 //diffuse the error |
|
13485 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
13486 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
13487 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
13488 |
|
13489 /* Fourth Pixel */ |
|
13490 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
13491 diff1 = *(src2 + 3) & 0x7; |
|
13492 diff2 = *(src2 + 4) & 0x3; |
|
13493 diff3 = *(src2 + 5) & 0x7; |
|
13494 //diffuse the error |
|
13495 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
13496 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
13497 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
13498 |
|
13499 src2 += 6; |
|
13500 dest2 += 2; |
|
13501 } |
|
13502 if(extraCol) |
|
13503 { |
|
13504 *dest1 = dest1[-1]; |
|
13505 dest1++; |
|
13506 *dest2 = dest2[-1]; |
|
13507 dest2++; |
|
13508 } |
|
13509 |
|
13510 lLumPtr += (lLumWidth << 1); |
|
13511 lCrPtr += (lLumWidth >> 1); |
|
13512 lCbPtr += (lLumWidth >> 1); |
|
13513 |
|
13514 dest1 += ((wndWidth << 1) - lTempWidth); |
|
13515 dest2 += ((wndWidth << 1) - lTempWidth); |
|
13516 } |
|
13517 |
|
13518 if(extraRow) |
|
13519 { |
|
13520 dest2 = dest1 - wndWidth; |
|
13521 for(j = 0; j < lWidth; j += 2) |
|
13522 { |
|
13523 *dest1++ = *dest2++; |
|
13524 *dest1++ = *dest2++; |
|
13525 } |
|
13526 if(extraCol) |
|
13527 { |
|
13528 *dest1 = *dest2; |
|
13529 } |
|
13530 } |
|
13531 |
|
13532 free(lBuffer); |
|
13533 return; |
|
13534 } |
|
13535 |
|
13536 |
|
13537 /* |
|
13538 ****************************************************************************** |
|
13539 Name : sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_601_5_RR |
|
13540 Description : Converts YUV420 Chroma2 Planar to RGB565 Interleaved format |
|
13541 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
13542 uint8 *dstImage : Pointer to rgb data (o/p). |
|
13543 tWndParam *srcWindow : Pointer to structure containing source window |
|
13544 parameters like xOffset,yOffset,cropWidth, |
|
13545 cropHeight. (i/p) |
|
13546 tWndParam *dstWindow : Pointer to structure containing destination window |
|
13547 parameters like xOffset,yOffset,windWidth, |
|
13548 windHeight. (i/p) |
|
13549 Return Value : void |
|
13550 ****************************************************************************** |
|
13551 */ |
|
13552 |
|
13553 void sEmz_VDec_YUV420Chr2toColor64k_ErrDiff_601_5_RR |
|
13554 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
13555 tWndParam* srcWindow, tWndParam* dstWindow) |
|
13556 { |
|
13557 uint16 *dest1, *dest2; |
|
13558 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
13559 uint8 *lBuffer; |
|
13560 uint8 *src1, *src2; |
|
13561 uint8 *lPtr1, *lPtr2; |
|
13562 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
13563 int32 lY1, lCr, lCb; |
|
13564 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
13565 int32 diff1, diff2, diff3; |
|
13566 int32 i, j, k, extraRow, extraCol; |
|
13567 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
13568 cropWidth,cropHeight,wndWidth,wndHeight; |
|
13569 |
|
13570 srcXOffset = srcWindow->xOffset; |
|
13571 srcYOffset = srcWindow->yOffset; |
|
13572 cropWidth = srcWindow->wndWidth; |
|
13573 cropHeight = srcWindow->wndHeight; |
|
13574 |
|
13575 dstXOffset = dstWindow->xOffset; |
|
13576 dstYOffset = dstWindow->yOffset; |
|
13577 wndWidth = dstWindow->wndWidth; |
|
13578 wndHeight = dstWindow->wndHeight; |
|
13579 |
|
13580 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
13581 { |
|
13582 lWidth = cropWidth; |
|
13583 } |
|
13584 else |
|
13585 { |
|
13586 lWidth = srcImage->width - srcXOffset; |
|
13587 } |
|
13588 |
|
13589 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
13590 { |
|
13591 lHeight = cropHeight; |
|
13592 } |
|
13593 else |
|
13594 { |
|
13595 lHeight = srcImage->height - srcYOffset; |
|
13596 } |
|
13597 |
|
13598 if (lWidth > (wndWidth - dstXOffset)) |
|
13599 { |
|
13600 lWidth = wndWidth - dstXOffset; |
|
13601 } |
|
13602 |
|
13603 if (lHeight > (wndHeight - dstYOffset)) |
|
13604 { |
|
13605 lHeight = wndHeight - dstYOffset; |
|
13606 } |
|
13607 |
|
13608 extraCol = lWidth & 0x01; |
|
13609 extraRow = lHeight & 0x01; |
|
13610 |
|
13611 lTempWidth = lWidth; |
|
13612 lWidth = (lWidth >> 1) << 1; |
|
13613 lHeight = (lHeight >> 1) << 1; |
|
13614 |
|
13615 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
13616 |
|
13617 lSrcWidth = lWidth * 3; |
|
13618 |
|
13619 lLumWidth = (srcImage->width >> 1) << 1; |
|
13620 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
13621 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
13622 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
13623 |
|
13624 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
13625 dest2 = dest1 + wndWidth; |
|
13626 |
|
13627 for(i = 0; i < lHeight; i += 2) |
|
13628 { |
|
13629 lPtr1 = src1 = lBuffer; |
|
13630 lPtr2 = src2 = src1 + lSrcWidth; |
|
13631 |
|
13632 for(k = 0; k < lWidth; k += 2) |
|
13633 { |
|
13634 lCr = lCrPtr[k >> 1]; |
|
13635 lCb = lCbPtr[k >> 1]; |
|
13636 |
|
13637 lCr -= 128; |
|
13638 lCb -= 128; |
|
13639 |
|
13640 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
13641 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
13642 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
13643 |
|
13644 /*First Pixel*/ |
|
13645 lY1 = lLumPtr[k]; |
|
13646 lY1 -= 16; |
|
13647 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
13648 |
|
13649 lTemp = lY1 + lTemp1; |
|
13650 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13651 |
|
13652 lTemp = lY1 - lTemp2; |
|
13653 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13654 |
|
13655 lTemp = lY1 + lTemp3; |
|
13656 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13657 |
|
13658 /*Second Pixel*/ |
|
13659 lY1 = lLumPtr[k + 1]; |
|
13660 lY1 -= 16; |
|
13661 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
13662 |
|
13663 lTemp = lY1 + lTemp1; |
|
13664 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13665 |
|
13666 lTemp = lY1 - lTemp2; |
|
13667 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13668 |
|
13669 lTemp = lY1 + lTemp3; |
|
13670 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13671 |
|
13672 |
|
13673 /*Third Pixel*/ |
|
13674 lY1 = lLumPtr[k + lLumWidth]; |
|
13675 lY1 -= 16; |
|
13676 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
13677 |
|
13678 lTemp = lY1 + lTemp1; |
|
13679 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13680 |
|
13681 lTemp = lY1 - lTemp2; |
|
13682 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13683 |
|
13684 lTemp = lY1 + lTemp3; |
|
13685 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13686 |
|
13687 /*Fourth Pixel*/ |
|
13688 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
13689 lY1 -= 16; |
|
13690 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
13691 |
|
13692 lTemp = lY1 + lTemp1; |
|
13693 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13694 |
|
13695 lTemp = lY1 - lTemp2; |
|
13696 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13697 |
|
13698 lTemp = lY1 + lTemp3; |
|
13699 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13700 |
|
13701 lCr = lCrPtr[(k + lLumWidth) >> 1]; |
|
13702 lCb = lCbPtr[(k + lLumWidth) >> 1]; |
|
13703 |
|
13704 lCr -= 128; |
|
13705 lCb -= 128; |
|
13706 |
|
13707 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
13708 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
13709 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
13710 |
|
13711 /*Fifth Pixel*/ |
|
13712 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
13713 |
|
13714 lTemp = lY1 + lTemp1; |
|
13715 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13716 |
|
13717 lTemp = lY1 - lTemp2; |
|
13718 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13719 |
|
13720 lTemp = lY1 + lTemp3; |
|
13721 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13722 |
|
13723 /*Sixth Pixel*/ |
|
13724 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
13725 |
|
13726 lTemp = lY1 + lTemp1; |
|
13727 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13728 |
|
13729 lTemp = lY1 - lTemp2; |
|
13730 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13731 |
|
13732 lTemp = lY1 + lTemp3; |
|
13733 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
13734 |
|
13735 src1 += 6; |
|
13736 src2 += 6; |
|
13737 } |
|
13738 |
|
13739 src1 = lPtr1; |
|
13740 src2 = lPtr2; |
|
13741 |
|
13742 for(j = 0; j < lWidth; j += 2) |
|
13743 { |
|
13744 /* First Pixel */ |
|
13745 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
13746 diff1 = *src1 & 0x7; |
|
13747 diff2 = *(src1 + 1) & 0x3; |
|
13748 diff3 = *(src1 + 2) & 0x7; |
|
13749 |
|
13750 // diffuse the error |
|
13751 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
13752 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
13753 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
13754 |
|
13755 /* Second Pixel */ |
|
13756 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
13757 diff1 = *(src1 + 3) & 0x7; |
|
13758 diff2 = *(src1 + 4) & 0x3; |
|
13759 diff3 = *(src1 + 5) & 0x7; |
|
13760 // diffuse the error |
|
13761 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
13762 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
13763 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
13764 |
|
13765 src1 += 6; |
|
13766 dest1 += 2; |
|
13767 |
|
13768 /* Third Pixel */ |
|
13769 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
13770 diff1 = *src2 & 0x7; |
|
13771 diff2 = *(src2 + 1) & 0x3; |
|
13772 diff3 = *(src2 + 2) & 0x7; |
|
13773 //diffuse the error |
|
13774 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
13775 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
13776 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
13777 |
|
13778 /* Fourth Pixel */ |
|
13779 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
13780 diff1 = *(src2 + 3) & 0x7; |
|
13781 diff2 = *(src2 + 4) & 0x3; |
|
13782 diff3 = *(src2 + 5) & 0x7; |
|
13783 //diffuse the error |
|
13784 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
13785 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
13786 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
13787 |
|
13788 src2 += 6; |
|
13789 dest2 += 2; |
|
13790 } |
|
13791 if(extraCol) |
|
13792 { |
|
13793 *dest1 = dest1[-1]; |
|
13794 dest1++; |
|
13795 *dest2 = dest2[-1]; |
|
13796 dest2++; |
|
13797 } |
|
13798 |
|
13799 lLumPtr += (lLumWidth << 1); |
|
13800 lCrPtr += (lLumWidth >> 1); |
|
13801 lCbPtr += (lLumWidth >> 1); |
|
13802 |
|
13803 dest1 += ((wndWidth << 1) - lTempWidth); |
|
13804 dest2 += ((wndWidth << 1) - lTempWidth); |
|
13805 } |
|
13806 |
|
13807 if(extraRow) |
|
13808 { |
|
13809 dest2 = dest1 - wndWidth; |
|
13810 for(j = 0; j < lWidth; j += 2) |
|
13811 { |
|
13812 *dest1++ = *dest2++; |
|
13813 *dest1++ = *dest2++; |
|
13814 } |
|
13815 if(extraCol) |
|
13816 { |
|
13817 *dest1 = *dest2; |
|
13818 } |
|
13819 } |
|
13820 |
|
13821 free(lBuffer); |
|
13822 return; |
|
13823 } |
|
13824 |
|
13825 |
|
13826 /* |
|
13827 ****************************************************************************** |
|
13828 Name : sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_709_FR |
|
13829 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
13830 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
13831 uint8 *dstImage : Pointer to rgb data (o/p). |
|
13832 tWndParam *srcWindow : Pointer to structure containing source window |
|
13833 parameters like xOffset,yOffset,cropWidth, |
|
13834 cropHeight. (i/p) |
|
13835 tWndParam *dstWindow : Pointer to structure containing destination window |
|
13836 parameters like xOffset,yOffset,windWidth, |
|
13837 windHeight. (i/p) |
|
13838 Return Value : void |
|
13839 ****************************************************************************** |
|
13840 */ |
|
13841 |
|
13842 void sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_709_FR |
|
13843 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
13844 tWndParam* srcWindow, tWndParam* dstWindow) |
|
13845 { |
|
13846 uint16 *dest1, *dest2; |
|
13847 uint8 *lYuyvPtr; |
|
13848 uint8 *lBuffer; |
|
13849 uint8 *src1, *src2; |
|
13850 uint8 *lPtr1, *lPtr2; |
|
13851 int32 diff1, diff2, diff3; |
|
13852 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
13853 int32 lY1, lCr, lCb; |
|
13854 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
13855 int32 i, j, k, extraCol, extraRow; |
|
13856 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
13857 cropWidth,cropHeight,wndWidth,wndHeight; |
|
13858 |
|
13859 srcXOffset = srcWindow->xOffset; |
|
13860 srcYOffset = srcWindow->yOffset; |
|
13861 cropWidth = srcWindow->wndWidth; |
|
13862 cropHeight = srcWindow->wndHeight; |
|
13863 |
|
13864 dstXOffset = dstWindow->xOffset; |
|
13865 dstYOffset = dstWindow->yOffset; |
|
13866 wndWidth = dstWindow->wndWidth; |
|
13867 wndHeight = dstWindow->wndHeight; |
|
13868 |
|
13869 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
13870 { |
|
13871 lWidth = cropWidth; |
|
13872 } |
|
13873 else |
|
13874 { |
|
13875 lWidth = srcImage->width - srcXOffset; |
|
13876 } |
|
13877 |
|
13878 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
13879 { |
|
13880 lHeight = cropHeight; |
|
13881 } |
|
13882 else |
|
13883 { |
|
13884 lHeight = srcImage->height - srcYOffset; |
|
13885 } |
|
13886 |
|
13887 if (lWidth > (wndWidth - dstXOffset)) |
|
13888 { |
|
13889 lWidth = wndWidth - dstXOffset; |
|
13890 } |
|
13891 |
|
13892 if (lHeight > (wndHeight - dstYOffset)) |
|
13893 { |
|
13894 lHeight = wndHeight - dstYOffset; |
|
13895 } |
|
13896 |
|
13897 extraCol = lWidth & 0x01; |
|
13898 extraRow = lHeight & 0x01; |
|
13899 |
|
13900 lTempWidth = lWidth; |
|
13901 lWidth = (lWidth >> 1) << 1; |
|
13902 lHeight = (lHeight >> 1) << 1; |
|
13903 |
|
13904 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
13905 |
|
13906 lSrcWidth = lWidth * 3; |
|
13907 |
|
13908 lLumWidth = (srcImage->width >> 1) << 1; |
|
13909 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
13910 |
|
13911 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
13912 dest2 = dest1 + wndWidth; |
|
13913 |
|
13914 lLumWidth <<= 1; |
|
13915 |
|
13916 for(i = 0; i < lHeight; i += 2) |
|
13917 { |
|
13918 lPtr1 = src1 = lBuffer; |
|
13919 lPtr2 = src2 = src1 + lSrcWidth; |
|
13920 |
|
13921 for(k = 0; k < lWidth; k += 2) |
|
13922 { |
|
13923 lCb = lYuyvPtr[0]; |
|
13924 lCr = lYuyvPtr[2]; |
|
13925 |
|
13926 lCb -= 128; |
|
13927 lCr -= 128; |
|
13928 |
|
13929 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
13930 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
13931 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
13932 |
|
13933 /*First Pixel*/ |
|
13934 lY1 = lYuyvPtr[1]; |
|
13935 |
|
13936 lTemp = lY1 + lTemp1; |
|
13937 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13938 |
|
13939 lTemp = lY1 - lTemp2; |
|
13940 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13941 |
|
13942 lTemp = lY1 + lTemp3; |
|
13943 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13944 |
|
13945 /*Second Pixel*/ |
|
13946 lY1 = lYuyvPtr[3]; |
|
13947 |
|
13948 lTemp = lY1 + lTemp1; |
|
13949 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13950 |
|
13951 lTemp = lY1 - lTemp2; |
|
13952 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13953 |
|
13954 lTemp = lY1 + lTemp3; |
|
13955 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13956 |
|
13957 lCb = lYuyvPtr[lLumWidth]; |
|
13958 lCr = lYuyvPtr[lLumWidth + 2]; |
|
13959 |
|
13960 lCb -= 128; |
|
13961 lCr -= 128; |
|
13962 |
|
13963 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
13964 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
13965 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
13966 |
|
13967 /*Third Pixel*/ |
|
13968 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
13969 |
|
13970 lTemp = lY1 + lTemp1; |
|
13971 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13972 |
|
13973 lTemp = lY1 - lTemp2; |
|
13974 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13975 |
|
13976 lTemp = lY1 + lTemp3; |
|
13977 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13978 |
|
13979 /*Fourth Pixel*/ |
|
13980 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
13981 |
|
13982 lTemp = lY1 + lTemp1; |
|
13983 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13984 |
|
13985 lTemp = lY1 - lTemp2; |
|
13986 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13987 |
|
13988 lTemp = lY1 + lTemp3; |
|
13989 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
13990 |
|
13991 lCb = lYuyvPtr[(lLumWidth << 1)]; |
|
13992 lCr = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
13993 |
|
13994 lCb -= 128; |
|
13995 lCr -= 128; |
|
13996 |
|
13997 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
13998 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
13999 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
14000 |
|
14001 /*Fifth Pixel*/ |
|
14002 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
14003 |
|
14004 lTemp = lY1 + lTemp1; |
|
14005 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14006 |
|
14007 lTemp = lY1 - lTemp2; |
|
14008 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14009 |
|
14010 lTemp = lY1 + lTemp3; |
|
14011 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14012 |
|
14013 /*Sixth Pixel*/ |
|
14014 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
14015 |
|
14016 lTemp = lY1 + lTemp1; |
|
14017 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14018 |
|
14019 lTemp = lY1 - lTemp2; |
|
14020 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14021 |
|
14022 lTemp = lY1 + lTemp3; |
|
14023 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14024 |
|
14025 lYuyvPtr += 4; |
|
14026 src1 += 6; |
|
14027 src2 += 6; |
|
14028 } |
|
14029 |
|
14030 src1 = lPtr1; |
|
14031 src2 = lPtr2; |
|
14032 |
|
14033 for(j = 0; j < lWidth; j += 2) |
|
14034 { |
|
14035 /* First Pixel */ |
|
14036 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
14037 diff1 = *src1 & 0x7; |
|
14038 diff2 = *(src1 + 1) & 0x3; |
|
14039 diff3 = *(src1 + 2) & 0x7; |
|
14040 |
|
14041 // diffuse the error |
|
14042 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
14043 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
14044 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
14045 |
|
14046 /* Second Pixel */ |
|
14047 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
14048 diff1 = *(src1 + 3) & 0x7; |
|
14049 diff2 = *(src1 + 4) & 0x3; |
|
14050 diff3 = *(src1 + 5) & 0x7; |
|
14051 // diffuse the error |
|
14052 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
14053 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
14054 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
14055 |
|
14056 src1 += 6; |
|
14057 dest1 += 2; |
|
14058 |
|
14059 /* Third Pixel */ |
|
14060 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
14061 diff1 = *src2 & 0x7; |
|
14062 diff2 = *(src2 + 1) & 0x3; |
|
14063 diff3 = *(src2 + 2) & 0x7; |
|
14064 //diffuse the error |
|
14065 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
14066 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
14067 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
14068 |
|
14069 /* Fourth Pixel */ |
|
14070 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
14071 diff1 = *(src2 + 3) & 0x7; |
|
14072 diff2 = *(src2 + 4) & 0x3; |
|
14073 diff3 = *(src2 + 5) & 0x7; |
|
14074 //diffuse the error |
|
14075 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
14076 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
14077 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
14078 |
|
14079 src2 += 6; |
|
14080 dest2 += 2; |
|
14081 } |
|
14082 if(extraCol) |
|
14083 { |
|
14084 *dest1 = dest1[-1]; |
|
14085 dest1++; |
|
14086 *dest2 = dest2[-1]; |
|
14087 dest2++; |
|
14088 } |
|
14089 |
|
14090 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
14091 |
|
14092 dest1 += ((wndWidth << 1) - lTempWidth); |
|
14093 dest2 += ((wndWidth << 1) - lTempWidth); |
|
14094 } |
|
14095 |
|
14096 if(extraRow) |
|
14097 { |
|
14098 dest2 = dest1 - wndWidth; |
|
14099 for(j = 0; j < lWidth; j += 2) |
|
14100 { |
|
14101 *dest1++ = *dest2++; |
|
14102 *dest1++ = *dest2++; |
|
14103 } |
|
14104 if(extraCol) |
|
14105 { |
|
14106 *dest1 = *dest2; |
|
14107 } |
|
14108 } |
|
14109 |
|
14110 free(lBuffer); |
|
14111 return; |
|
14112 } |
|
14113 |
|
14114 /* |
|
14115 ****************************************************************************** |
|
14116 Name : sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_601_5_FR |
|
14117 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
14118 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
14119 uint8 *dstImage : Pointer to rgb data (o/p). |
|
14120 tWndParam *srcWindow : Pointer to structure containing source window |
|
14121 parameters like xOffset,yOffset,cropWidth, |
|
14122 cropHeight. (i/p) |
|
14123 tWndParam *dstWindow : Pointer to structure containing destination window |
|
14124 parameters like xOffset,yOffset,windWidth, |
|
14125 windHeight. (i/p) |
|
14126 Return Value : void |
|
14127 ****************************************************************************** |
|
14128 */ |
|
14129 |
|
14130 void sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_601_5_FR |
|
14131 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
14132 tWndParam* srcWindow, tWndParam* dstWindow) |
|
14133 { |
|
14134 uint16 *dest1, *dest2; |
|
14135 uint8 *lYuyvPtr; |
|
14136 uint8 *lBuffer; |
|
14137 uint8 *src1, *src2; |
|
14138 uint8 *lPtr1, *lPtr2; |
|
14139 int32 diff1, diff2, diff3; |
|
14140 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
14141 int32 lY1, lCr, lCb; |
|
14142 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
14143 int32 i, j, k, extraCol, extraRow; |
|
14144 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
14145 cropWidth,cropHeight,wndWidth,wndHeight; |
|
14146 |
|
14147 srcXOffset = srcWindow->xOffset; |
|
14148 srcYOffset = srcWindow->yOffset; |
|
14149 cropWidth = srcWindow->wndWidth; |
|
14150 cropHeight = srcWindow->wndHeight; |
|
14151 |
|
14152 dstXOffset = dstWindow->xOffset; |
|
14153 dstYOffset = dstWindow->yOffset; |
|
14154 wndWidth = dstWindow->wndWidth; |
|
14155 wndHeight = dstWindow->wndHeight; |
|
14156 |
|
14157 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
14158 { |
|
14159 lWidth = cropWidth; |
|
14160 } |
|
14161 else |
|
14162 { |
|
14163 lWidth = srcImage->width - srcXOffset; |
|
14164 } |
|
14165 |
|
14166 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
14167 { |
|
14168 lHeight = cropHeight; |
|
14169 } |
|
14170 else |
|
14171 { |
|
14172 lHeight = srcImage->height - srcYOffset; |
|
14173 } |
|
14174 |
|
14175 if (lWidth > (wndWidth - dstXOffset)) |
|
14176 { |
|
14177 lWidth = wndWidth - dstXOffset; |
|
14178 } |
|
14179 |
|
14180 if (lHeight > (wndHeight - dstYOffset)) |
|
14181 { |
|
14182 lHeight = wndHeight - dstYOffset; |
|
14183 } |
|
14184 |
|
14185 extraCol = lWidth & 0x01; |
|
14186 extraRow = lHeight & 0x01; |
|
14187 |
|
14188 lTempWidth = lWidth; |
|
14189 lWidth = (lWidth >> 1) << 1; |
|
14190 lHeight = (lHeight >> 1) << 1; |
|
14191 |
|
14192 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
14193 |
|
14194 lSrcWidth = lWidth * 3; |
|
14195 |
|
14196 lLumWidth = (srcImage->width >> 1) << 1; |
|
14197 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
14198 |
|
14199 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
14200 dest2 = dest1 + wndWidth; |
|
14201 |
|
14202 lLumWidth <<= 1; |
|
14203 |
|
14204 for(i = 0; i < lHeight; i += 2) |
|
14205 { |
|
14206 lPtr1 = src1 = lBuffer; |
|
14207 lPtr2 = src2 = src1 + lSrcWidth; |
|
14208 |
|
14209 for(k = 0; k < lWidth; k += 2) |
|
14210 { |
|
14211 lCb = lYuyvPtr[0]; |
|
14212 lCr = lYuyvPtr[2]; |
|
14213 |
|
14214 lCb -= 128; |
|
14215 lCr -= 128; |
|
14216 |
|
14217 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
14218 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
14219 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
14220 |
|
14221 /*First Pixel*/ |
|
14222 lY1 = lYuyvPtr[1]; |
|
14223 |
|
14224 lTemp = lY1 + lTemp1; |
|
14225 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14226 |
|
14227 lTemp = lY1 - lTemp2; |
|
14228 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14229 |
|
14230 lTemp = lY1 + lTemp3; |
|
14231 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14232 |
|
14233 /*Second Pixel*/ |
|
14234 lY1 = lYuyvPtr[3]; |
|
14235 |
|
14236 lTemp = lY1 + lTemp1; |
|
14237 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14238 |
|
14239 lTemp = lY1 - lTemp2; |
|
14240 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14241 |
|
14242 lTemp = lY1 + lTemp3; |
|
14243 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14244 |
|
14245 lCb = lYuyvPtr[lLumWidth]; |
|
14246 lCr = lYuyvPtr[lLumWidth + 2]; |
|
14247 |
|
14248 lCb -= 128; |
|
14249 lCr -= 128; |
|
14250 |
|
14251 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
14252 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
14253 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
14254 |
|
14255 /*Third Pixel*/ |
|
14256 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
14257 |
|
14258 lTemp = lY1 + lTemp1; |
|
14259 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14260 |
|
14261 lTemp = lY1 - lTemp2; |
|
14262 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14263 |
|
14264 lTemp = lY1 + lTemp3; |
|
14265 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14266 |
|
14267 /*Fourth Pixel*/ |
|
14268 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
14269 |
|
14270 lTemp = lY1 + lTemp1; |
|
14271 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14272 |
|
14273 lTemp = lY1 - lTemp2; |
|
14274 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14275 |
|
14276 lTemp = lY1 + lTemp3; |
|
14277 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14278 |
|
14279 lCb = lYuyvPtr[(lLumWidth << 1)]; |
|
14280 lCr = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
14281 |
|
14282 lCb -= 128; |
|
14283 lCr -= 128; |
|
14284 |
|
14285 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
14286 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
14287 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
14288 |
|
14289 /*Fifth Pixel*/ |
|
14290 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
14291 |
|
14292 lTemp = lY1 + lTemp1; |
|
14293 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14294 |
|
14295 lTemp = lY1 - lTemp2; |
|
14296 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14297 |
|
14298 lTemp = lY1 + lTemp3; |
|
14299 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14300 |
|
14301 /*Sixth Pixel*/ |
|
14302 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
14303 |
|
14304 lTemp = lY1 + lTemp1; |
|
14305 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14306 |
|
14307 lTemp = lY1 - lTemp2; |
|
14308 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14309 |
|
14310 lTemp = lY1 + lTemp3; |
|
14311 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
14312 |
|
14313 lYuyvPtr += 4; |
|
14314 src1 += 6; |
|
14315 src2 += 6; |
|
14316 } |
|
14317 |
|
14318 src1 = lPtr1; |
|
14319 src2 = lPtr2; |
|
14320 |
|
14321 for(j = 0; j < lWidth; j += 2) |
|
14322 { |
|
14323 /* First Pixel */ |
|
14324 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
14325 diff1 = *src1 & 0x7; |
|
14326 diff2 = *(src1 + 1) & 0x3; |
|
14327 diff3 = *(src1 + 2) & 0x7; |
|
14328 |
|
14329 // diffuse the error |
|
14330 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
14331 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
14332 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
14333 |
|
14334 /* Second Pixel */ |
|
14335 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
14336 diff1 = *(src1 + 3) & 0x7; |
|
14337 diff2 = *(src1 + 4) & 0x3; |
|
14338 diff3 = *(src1 + 5) & 0x7; |
|
14339 // diffuse the error |
|
14340 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
14341 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
14342 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
14343 |
|
14344 src1 += 6; |
|
14345 dest1 += 2; |
|
14346 |
|
14347 /* Third Pixel */ |
|
14348 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
14349 diff1 = *src2 & 0x7; |
|
14350 diff2 = *(src2 + 1) & 0x3; |
|
14351 diff3 = *(src2 + 2) & 0x7; |
|
14352 //diffuse the error |
|
14353 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
14354 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
14355 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
14356 |
|
14357 /* Fourth Pixel */ |
|
14358 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
14359 diff1 = *(src2 + 3) & 0x7; |
|
14360 diff2 = *(src2 + 4) & 0x3; |
|
14361 diff3 = *(src2 + 5) & 0x7; |
|
14362 //diffuse the error |
|
14363 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
14364 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
14365 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
14366 |
|
14367 src2 += 6; |
|
14368 dest2 += 2; |
|
14369 } |
|
14370 if(extraCol) |
|
14371 { |
|
14372 *dest1 = dest1[-1]; |
|
14373 dest1++; |
|
14374 *dest2 = dest2[-1]; |
|
14375 dest2++; |
|
14376 } |
|
14377 |
|
14378 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
14379 |
|
14380 dest1 += ((wndWidth << 1) - lTempWidth); |
|
14381 dest2 += ((wndWidth << 1) - lTempWidth); |
|
14382 } |
|
14383 |
|
14384 if(extraRow) |
|
14385 { |
|
14386 dest2 = dest1 - wndWidth; |
|
14387 for(j = 0; j < lWidth; j += 2) |
|
14388 { |
|
14389 *dest1++ = *dest2++; |
|
14390 *dest1++ = *dest2++; |
|
14391 } |
|
14392 if(extraCol) |
|
14393 { |
|
14394 *dest1 = *dest2; |
|
14395 } |
|
14396 } |
|
14397 |
|
14398 free(lBuffer); |
|
14399 return; |
|
14400 } |
|
14401 |
|
14402 /* |
|
14403 ****************************************************************************** |
|
14404 Name : sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_709_RR |
|
14405 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
14406 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
14407 uint8 *dstImage : Pointer to rgb data (o/p). |
|
14408 tWndParam *srcWindow : Pointer to structure containing source window |
|
14409 parameters like xOffset,yOffset,cropWidth, |
|
14410 cropHeight. (i/p) |
|
14411 tWndParam *dstWindow : Pointer to structure containing destination window |
|
14412 parameters like xOffset,yOffset,windWidth, |
|
14413 windHeight. (i/p) |
|
14414 Return Value : void |
|
14415 ****************************************************************************** |
|
14416 */ |
|
14417 |
|
14418 void sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_709_RR |
|
14419 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
14420 tWndParam* srcWindow, tWndParam* dstWindow) |
|
14421 { |
|
14422 uint16 *dest1, *dest2; |
|
14423 uint8 *lYuyvPtr; |
|
14424 uint8 *lBuffer; |
|
14425 uint8 *src1, *src2; |
|
14426 uint8 *lPtr1, *lPtr2; |
|
14427 int32 diff1, diff2, diff3; |
|
14428 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
14429 int32 lY1, lCr, lCb; |
|
14430 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
14431 int32 i, j, k, extraCol, extraRow; |
|
14432 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
14433 cropWidth,cropHeight,wndWidth,wndHeight; |
|
14434 |
|
14435 srcXOffset = srcWindow->xOffset; |
|
14436 srcYOffset = srcWindow->yOffset; |
|
14437 cropWidth = srcWindow->wndWidth; |
|
14438 cropHeight = srcWindow->wndHeight; |
|
14439 |
|
14440 dstXOffset = dstWindow->xOffset; |
|
14441 dstYOffset = dstWindow->yOffset; |
|
14442 wndWidth = dstWindow->wndWidth; |
|
14443 wndHeight = dstWindow->wndHeight; |
|
14444 |
|
14445 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
14446 { |
|
14447 lWidth = cropWidth; |
|
14448 } |
|
14449 else |
|
14450 { |
|
14451 lWidth = srcImage->width - srcXOffset; |
|
14452 } |
|
14453 |
|
14454 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
14455 { |
|
14456 lHeight = cropHeight; |
|
14457 } |
|
14458 else |
|
14459 { |
|
14460 lHeight = srcImage->height - srcYOffset; |
|
14461 } |
|
14462 |
|
14463 if (lWidth > (wndWidth - dstXOffset)) |
|
14464 { |
|
14465 lWidth = wndWidth - dstXOffset; |
|
14466 } |
|
14467 |
|
14468 if (lHeight > (wndHeight - dstYOffset)) |
|
14469 { |
|
14470 lHeight = wndHeight - dstYOffset; |
|
14471 } |
|
14472 |
|
14473 extraCol = lWidth & 0x01; |
|
14474 extraRow = lHeight & 0x01; |
|
14475 |
|
14476 lTempWidth = lWidth; |
|
14477 lWidth = (lWidth >> 1) << 1; |
|
14478 lHeight = (lHeight >> 1) << 1; |
|
14479 |
|
14480 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
14481 |
|
14482 lSrcWidth = lWidth * 3; |
|
14483 |
|
14484 lLumWidth = (srcImage->width >> 1) << 1; |
|
14485 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
14486 |
|
14487 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
14488 dest2 = dest1 + wndWidth; |
|
14489 |
|
14490 lLumWidth <<= 1; |
|
14491 |
|
14492 for(i = 0; i < lHeight; i += 2) |
|
14493 { |
|
14494 lPtr1 = src1 = lBuffer; |
|
14495 lPtr2 = src2 = src1 + lSrcWidth; |
|
14496 |
|
14497 for(k = 0; k < lWidth; k += 2) |
|
14498 { |
|
14499 lCb = lYuyvPtr[0]; |
|
14500 lCr = lYuyvPtr[2]; |
|
14501 |
|
14502 lCb -= 128; |
|
14503 lCr -= 128; |
|
14504 |
|
14505 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
14506 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
14507 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
14508 |
|
14509 /*First Pixel*/ |
|
14510 lY1 = lYuyvPtr[1]; |
|
14511 lY1 -= 16; |
|
14512 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14513 |
|
14514 lTemp = lY1 + lTemp1; |
|
14515 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14516 |
|
14517 lTemp = lY1 - lTemp2; |
|
14518 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14519 |
|
14520 lTemp = lY1 + lTemp3; |
|
14521 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14522 |
|
14523 /*Second Pixel*/ |
|
14524 lY1 = lYuyvPtr[3]; |
|
14525 lY1 -= 16; |
|
14526 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14527 |
|
14528 lTemp = lY1 + lTemp1; |
|
14529 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14530 |
|
14531 lTemp = lY1 - lTemp2; |
|
14532 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14533 |
|
14534 lTemp = lY1 + lTemp3; |
|
14535 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14536 |
|
14537 lCb = lYuyvPtr[lLumWidth]; |
|
14538 lCr = lYuyvPtr[lLumWidth + 2]; |
|
14539 |
|
14540 lCb -= 128; |
|
14541 lCr -= 128; |
|
14542 |
|
14543 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
14544 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
14545 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
14546 |
|
14547 /*Third Pixel*/ |
|
14548 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
14549 lY1 -= 16; |
|
14550 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14551 |
|
14552 lTemp = lY1 + lTemp1; |
|
14553 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14554 |
|
14555 lTemp = lY1 - lTemp2; |
|
14556 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14557 |
|
14558 lTemp = lY1 + lTemp3; |
|
14559 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14560 |
|
14561 /*Fourth Pixel*/ |
|
14562 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
14563 lY1 -= 16; |
|
14564 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14565 |
|
14566 lTemp = lY1 + lTemp1; |
|
14567 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14568 |
|
14569 lTemp = lY1 - lTemp2; |
|
14570 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14571 |
|
14572 lTemp = lY1 + lTemp3; |
|
14573 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14574 |
|
14575 lCb = lYuyvPtr[(lLumWidth << 1)]; |
|
14576 lCr = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
14577 |
|
14578 lCb -= 128; |
|
14579 lCr -= 128; |
|
14580 |
|
14581 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
14582 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
14583 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
14584 |
|
14585 /*Fifth Pixel*/ |
|
14586 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
14587 lY1 -= 16; |
|
14588 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14589 |
|
14590 lTemp = lY1 + lTemp1; |
|
14591 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14592 |
|
14593 lTemp = lY1 - lTemp2; |
|
14594 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14595 |
|
14596 lTemp = lY1 + lTemp3; |
|
14597 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14598 |
|
14599 /*Sixth Pixel*/ |
|
14600 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
14601 lY1 -= 16; |
|
14602 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14603 |
|
14604 lTemp = lY1 + lTemp1; |
|
14605 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14606 |
|
14607 lTemp = lY1 - lTemp2; |
|
14608 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14609 |
|
14610 lTemp = lY1 + lTemp3; |
|
14611 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14612 |
|
14613 lYuyvPtr += 4; |
|
14614 src1 += 6; |
|
14615 src2 += 6; |
|
14616 } |
|
14617 |
|
14618 src1 = lPtr1; |
|
14619 src2 = lPtr2; |
|
14620 |
|
14621 for(j = 0; j < lWidth; j += 2) |
|
14622 { |
|
14623 /* First Pixel */ |
|
14624 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
14625 diff1 = *src1 & 0x7; |
|
14626 diff2 = *(src1 + 1) & 0x3; |
|
14627 diff3 = *(src1 + 2) & 0x7; |
|
14628 |
|
14629 // diffuse the error |
|
14630 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
14631 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
14632 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
14633 |
|
14634 /* Second Pixel */ |
|
14635 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
14636 diff1 = *(src1 + 3) & 0x7; |
|
14637 diff2 = *(src1 + 4) & 0x3; |
|
14638 diff3 = *(src1 + 5) & 0x7; |
|
14639 // diffuse the error |
|
14640 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
14641 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
14642 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
14643 |
|
14644 src1 += 6; |
|
14645 dest1 += 2; |
|
14646 |
|
14647 /* Third Pixel */ |
|
14648 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
14649 diff1 = *src2 & 0x7; |
|
14650 diff2 = *(src2 + 1) & 0x3; |
|
14651 diff3 = *(src2 + 2) & 0x7; |
|
14652 //diffuse the error |
|
14653 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
14654 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
14655 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
14656 |
|
14657 /* Fourth Pixel */ |
|
14658 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
14659 diff1 = *(src2 + 3) & 0x7; |
|
14660 diff2 = *(src2 + 4) & 0x3; |
|
14661 diff3 = *(src2 + 5) & 0x7; |
|
14662 //diffuse the error |
|
14663 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
14664 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
14665 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
14666 |
|
14667 src2 += 6; |
|
14668 dest2 += 2; |
|
14669 } |
|
14670 if(extraCol) |
|
14671 { |
|
14672 *dest1 = dest1[-1]; |
|
14673 dest1++; |
|
14674 *dest2 = dest2[-1]; |
|
14675 dest2++; |
|
14676 } |
|
14677 |
|
14678 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
14679 |
|
14680 dest1 += ((wndWidth << 1) - lTempWidth); |
|
14681 dest2 += ((wndWidth << 1) - lTempWidth); |
|
14682 } |
|
14683 |
|
14684 if(extraRow) |
|
14685 { |
|
14686 dest2 = dest1 - wndWidth; |
|
14687 for(j = 0; j < lWidth; j += 2) |
|
14688 { |
|
14689 *dest1++ = *dest2++; |
|
14690 *dest1++ = *dest2++; |
|
14691 } |
|
14692 if(extraCol) |
|
14693 { |
|
14694 *dest1 = *dest2; |
|
14695 } |
|
14696 } |
|
14697 |
|
14698 free(lBuffer); |
|
14699 return; |
|
14700 } |
|
14701 |
|
14702 /* |
|
14703 ****************************************************************************** |
|
14704 Name : sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_601_5_RR |
|
14705 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
14706 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
14707 uint8 *dstImage : Pointer to rgb data (o/p). |
|
14708 tWndParam *srcWindow : Pointer to structure containing source window |
|
14709 parameters like xOffset,yOffset,cropWidth, |
|
14710 cropHeight. (i/p) |
|
14711 tWndParam *dstWindow : Pointer to structure containing destination window |
|
14712 parameters like xOffset,yOffset,windWidth, |
|
14713 windHeight. (i/p) |
|
14714 Return Value : void |
|
14715 ****************************************************************************** |
|
14716 */ |
|
14717 |
|
14718 void sEmz_VDec_YUV422BEChr2toColor64k_ErrDiff_601_5_RR |
|
14719 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
14720 tWndParam* srcWindow, tWndParam* dstWindow) |
|
14721 { |
|
14722 uint16 *dest1, *dest2; |
|
14723 uint8 *lYuyvPtr; |
|
14724 uint8 *lBuffer; |
|
14725 uint8 *src1, *src2; |
|
14726 uint8 *lPtr1, *lPtr2; |
|
14727 int32 diff1, diff2, diff3; |
|
14728 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
14729 int32 lY1, lCr, lCb; |
|
14730 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
14731 int32 i, j, k, extraCol, extraRow; |
|
14732 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
14733 cropWidth,cropHeight,wndWidth,wndHeight; |
|
14734 |
|
14735 srcXOffset = srcWindow->xOffset; |
|
14736 srcYOffset = srcWindow->yOffset; |
|
14737 cropWidth = srcWindow->wndWidth; |
|
14738 cropHeight = srcWindow->wndHeight; |
|
14739 |
|
14740 dstXOffset = dstWindow->xOffset; |
|
14741 dstYOffset = dstWindow->yOffset; |
|
14742 wndWidth = dstWindow->wndWidth; |
|
14743 wndHeight = dstWindow->wndHeight; |
|
14744 |
|
14745 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
14746 { |
|
14747 lWidth = cropWidth; |
|
14748 } |
|
14749 else |
|
14750 { |
|
14751 lWidth = srcImage->width - srcXOffset; |
|
14752 } |
|
14753 |
|
14754 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
14755 { |
|
14756 lHeight = cropHeight; |
|
14757 } |
|
14758 else |
|
14759 { |
|
14760 lHeight = srcImage->height - srcYOffset; |
|
14761 } |
|
14762 |
|
14763 if (lWidth > (wndWidth - dstXOffset)) |
|
14764 { |
|
14765 lWidth = wndWidth - dstXOffset; |
|
14766 } |
|
14767 |
|
14768 if (lHeight > (wndHeight - dstYOffset)) |
|
14769 { |
|
14770 lHeight = wndHeight - dstYOffset; |
|
14771 } |
|
14772 |
|
14773 extraCol = lWidth & 0x01; |
|
14774 extraRow = lHeight & 0x01; |
|
14775 |
|
14776 lTempWidth = lWidth; |
|
14777 lWidth = (lWidth >> 1) << 1; |
|
14778 lHeight = (lHeight >> 1) << 1; |
|
14779 |
|
14780 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
14781 |
|
14782 lSrcWidth = lWidth * 3; |
|
14783 |
|
14784 lLumWidth = (srcImage->width >> 1) << 1; |
|
14785 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
14786 |
|
14787 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
14788 dest2 = dest1 + wndWidth; |
|
14789 |
|
14790 lLumWidth <<= 1; |
|
14791 |
|
14792 for(i = 0; i < lHeight; i += 2) |
|
14793 { |
|
14794 lPtr1 = src1 = lBuffer; |
|
14795 lPtr2 = src2 = src1 + lSrcWidth; |
|
14796 |
|
14797 for(k = 0; k < lWidth; k += 2) |
|
14798 { |
|
14799 lCb = lYuyvPtr[0]; |
|
14800 lCr = lYuyvPtr[2]; |
|
14801 |
|
14802 lCb -= 128; |
|
14803 lCr -= 128; |
|
14804 |
|
14805 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
14806 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
14807 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
14808 |
|
14809 /*First Pixel*/ |
|
14810 lY1 = lYuyvPtr[1]; |
|
14811 lY1 -= 16; |
|
14812 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14813 |
|
14814 lTemp = lY1 + lTemp1; |
|
14815 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14816 |
|
14817 lTemp = lY1 - lTemp2; |
|
14818 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14819 |
|
14820 lTemp = lY1 + lTemp3; |
|
14821 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14822 |
|
14823 /*Second Pixel*/ |
|
14824 lY1 = lYuyvPtr[3]; |
|
14825 lY1 -= 16; |
|
14826 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14827 |
|
14828 lTemp = lY1 + lTemp1; |
|
14829 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14830 |
|
14831 lTemp = lY1 - lTemp2; |
|
14832 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14833 |
|
14834 lTemp = lY1 + lTemp3; |
|
14835 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14836 |
|
14837 lCb = lYuyvPtr[lLumWidth]; |
|
14838 lCr = lYuyvPtr[lLumWidth + 2]; |
|
14839 |
|
14840 lCb -= 128; |
|
14841 lCr -= 128; |
|
14842 |
|
14843 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
14844 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
14845 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
14846 |
|
14847 /*Third Pixel*/ |
|
14848 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
14849 lY1 -= 16; |
|
14850 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14851 |
|
14852 lTemp = lY1 + lTemp1; |
|
14853 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14854 |
|
14855 lTemp = lY1 - lTemp2; |
|
14856 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14857 |
|
14858 lTemp = lY1 + lTemp3; |
|
14859 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14860 |
|
14861 /*Fourth Pixel*/ |
|
14862 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
14863 lY1 -= 16; |
|
14864 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14865 |
|
14866 lTemp = lY1 + lTemp1; |
|
14867 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14868 |
|
14869 lTemp = lY1 - lTemp2; |
|
14870 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14871 |
|
14872 lTemp = lY1 + lTemp3; |
|
14873 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14874 |
|
14875 lCb = lYuyvPtr[(lLumWidth << 1)]; |
|
14876 lCr = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
14877 |
|
14878 lCb -= 128; |
|
14879 lCr -= 128; |
|
14880 |
|
14881 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
14882 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
14883 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
14884 |
|
14885 /*Fifth Pixel*/ |
|
14886 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
14887 lY1 -= 16; |
|
14888 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14889 |
|
14890 lTemp = lY1 + lTemp1; |
|
14891 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14892 |
|
14893 lTemp = lY1 - lTemp2; |
|
14894 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14895 |
|
14896 lTemp = lY1 + lTemp3; |
|
14897 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14898 |
|
14899 /*Sixth Pixel*/ |
|
14900 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
14901 lY1 -= 16; |
|
14902 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
14903 |
|
14904 lTemp = lY1 + lTemp1; |
|
14905 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14906 |
|
14907 lTemp = lY1 - lTemp2; |
|
14908 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14909 |
|
14910 lTemp = lY1 + lTemp3; |
|
14911 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
14912 |
|
14913 lYuyvPtr += 4; |
|
14914 src1 += 6; |
|
14915 src2 += 6; |
|
14916 } |
|
14917 |
|
14918 src1 = lPtr1; |
|
14919 src2 = lPtr2; |
|
14920 |
|
14921 for(j = 0; j < lWidth; j += 2) |
|
14922 { |
|
14923 /* First Pixel */ |
|
14924 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
14925 diff1 = *src1 & 0x7; |
|
14926 diff2 = *(src1 + 1) & 0x3; |
|
14927 diff3 = *(src1 + 2) & 0x7; |
|
14928 |
|
14929 // diffuse the error |
|
14930 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
14931 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
14932 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
14933 |
|
14934 /* Second Pixel */ |
|
14935 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
14936 diff1 = *(src1 + 3) & 0x7; |
|
14937 diff2 = *(src1 + 4) & 0x3; |
|
14938 diff3 = *(src1 + 5) & 0x7; |
|
14939 // diffuse the error |
|
14940 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
14941 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
14942 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
14943 |
|
14944 src1 += 6; |
|
14945 dest1 += 2; |
|
14946 |
|
14947 /* Third Pixel */ |
|
14948 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
14949 diff1 = *src2 & 0x7; |
|
14950 diff2 = *(src2 + 1) & 0x3; |
|
14951 diff3 = *(src2 + 2) & 0x7; |
|
14952 //diffuse the error |
|
14953 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
14954 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
14955 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
14956 |
|
14957 /* Fourth Pixel */ |
|
14958 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
14959 diff1 = *(src2 + 3) & 0x7; |
|
14960 diff2 = *(src2 + 4) & 0x3; |
|
14961 diff3 = *(src2 + 5) & 0x7; |
|
14962 //diffuse the error |
|
14963 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
14964 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
14965 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
14966 |
|
14967 src2 += 6; |
|
14968 dest2 += 2; |
|
14969 } |
|
14970 if(extraCol) |
|
14971 { |
|
14972 *dest1 = dest1[-1]; |
|
14973 dest1++; |
|
14974 *dest2 = dest2[-1]; |
|
14975 dest2++; |
|
14976 } |
|
14977 |
|
14978 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
14979 |
|
14980 dest1 += ((wndWidth << 1) - lTempWidth); |
|
14981 dest2 += ((wndWidth << 1) - lTempWidth); |
|
14982 } |
|
14983 |
|
14984 if(extraRow) |
|
14985 { |
|
14986 dest2 = dest1 - wndWidth; |
|
14987 for(j = 0; j < lWidth; j += 2) |
|
14988 { |
|
14989 *dest1++ = *dest2++; |
|
14990 *dest1++ = *dest2++; |
|
14991 } |
|
14992 if(extraCol) |
|
14993 { |
|
14994 *dest1 = *dest2; |
|
14995 } |
|
14996 } |
|
14997 |
|
14998 free(lBuffer); |
|
14999 return; |
|
15000 } |
|
15001 |
|
15002 /* |
|
15003 ****************************************************************************** |
|
15004 Name : sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_709_FR |
|
15005 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
15006 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
15007 uint8 *dstImage : Pointer to rgb data (o/p). |
|
15008 tWndParam *srcWindow : Pointer to structure containing source window |
|
15009 parameters like xOffset,yOffset,cropWidth, |
|
15010 cropHeight. (i/p) |
|
15011 tWndParam *dstWindow : Pointer to structure containing destination window |
|
15012 parameters like xOffset,yOffset,windWidth, |
|
15013 windHeight. (i/p) |
|
15014 Return Value : void |
|
15015 ****************************************************************************** |
|
15016 */ |
|
15017 |
|
15018 void sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_709_FR |
|
15019 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
15020 tWndParam* srcWindow, tWndParam* dstWindow) |
|
15021 { |
|
15022 uint16 *dest1, *dest2; |
|
15023 uint8 *lYuyvPtr; |
|
15024 uint8 *lBuffer; |
|
15025 uint8 *src1, *src2; |
|
15026 uint8 *lPtr1, *lPtr2; |
|
15027 int32 diff1, diff2, diff3; |
|
15028 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
15029 int32 lY1, lCr, lCb; |
|
15030 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
15031 int32 i, j, k, extraCol, extraRow; |
|
15032 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
15033 cropWidth,cropHeight,wndWidth,wndHeight; |
|
15034 |
|
15035 srcXOffset = srcWindow->xOffset; |
|
15036 srcYOffset = srcWindow->yOffset; |
|
15037 cropWidth = srcWindow->wndWidth; |
|
15038 cropHeight = srcWindow->wndHeight; |
|
15039 |
|
15040 dstXOffset = dstWindow->xOffset; |
|
15041 dstYOffset = dstWindow->yOffset; |
|
15042 wndWidth = dstWindow->wndWidth; |
|
15043 wndHeight = dstWindow->wndHeight; |
|
15044 |
|
15045 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
15046 { |
|
15047 lWidth = cropWidth; |
|
15048 } |
|
15049 else |
|
15050 { |
|
15051 lWidth = srcImage->width - srcXOffset; |
|
15052 } |
|
15053 |
|
15054 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
15055 { |
|
15056 lHeight = cropHeight; |
|
15057 } |
|
15058 else |
|
15059 { |
|
15060 lHeight = srcImage->height - srcYOffset; |
|
15061 } |
|
15062 |
|
15063 if (lWidth > (wndWidth - dstXOffset)) |
|
15064 { |
|
15065 lWidth = wndWidth - dstXOffset; |
|
15066 } |
|
15067 |
|
15068 if (lHeight > (wndHeight - dstYOffset)) |
|
15069 { |
|
15070 lHeight = wndHeight - dstYOffset; |
|
15071 } |
|
15072 |
|
15073 extraCol = lWidth & 0x01; |
|
15074 extraRow = lHeight & 0x01; |
|
15075 |
|
15076 lTempWidth = lWidth; |
|
15077 lWidth = (lWidth >> 1) << 1; |
|
15078 lHeight = (lHeight >> 1) << 1; |
|
15079 |
|
15080 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
15081 |
|
15082 lSrcWidth = lWidth * 3; |
|
15083 |
|
15084 lLumWidth = (srcImage->width >> 1) << 1; |
|
15085 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
15086 |
|
15087 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
15088 dest2 = dest1 + wndWidth; |
|
15089 |
|
15090 lLumWidth <<= 1; |
|
15091 |
|
15092 for(i = 0; i < lHeight; i += 2) |
|
15093 { |
|
15094 lPtr1 = src1 = lBuffer; |
|
15095 lPtr2 = src2 = src1 + lSrcWidth; |
|
15096 |
|
15097 for(k = 0; k < lWidth; k += 2) |
|
15098 { |
|
15099 lCb = lYuyvPtr[3]; |
|
15100 lCr = lYuyvPtr[1]; |
|
15101 |
|
15102 lCb -= 128; |
|
15103 lCr -= 128; |
|
15104 |
|
15105 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
15106 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
15107 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
15108 |
|
15109 /*First Pixel*/ |
|
15110 lY1 = lYuyvPtr[2]; |
|
15111 |
|
15112 lTemp = lY1 + lTemp1; |
|
15113 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15114 |
|
15115 lTemp = lY1 - lTemp2; |
|
15116 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15117 |
|
15118 lTemp = lY1 + lTemp3; |
|
15119 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15120 |
|
15121 /*Second Pixel*/ |
|
15122 lY1 = lYuyvPtr[0]; |
|
15123 |
|
15124 lTemp = lY1 + lTemp1; |
|
15125 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15126 |
|
15127 lTemp = lY1 - lTemp2; |
|
15128 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15129 |
|
15130 lTemp = lY1 + lTemp3; |
|
15131 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15132 |
|
15133 lCb = lYuyvPtr[lLumWidth + 3]; |
|
15134 lCr = lYuyvPtr[lLumWidth + 1]; |
|
15135 |
|
15136 lCb -= 128; |
|
15137 lCr -= 128; |
|
15138 |
|
15139 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
15140 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
15141 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
15142 |
|
15143 /*Third Pixel*/ |
|
15144 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
15145 |
|
15146 lTemp = lY1 + lTemp1; |
|
15147 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15148 |
|
15149 lTemp = lY1 - lTemp2; |
|
15150 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15151 |
|
15152 lTemp = lY1 + lTemp3; |
|
15153 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15154 |
|
15155 /*Fourth Pixel*/ |
|
15156 lY1 = lYuyvPtr[lLumWidth]; |
|
15157 |
|
15158 lTemp = lY1 + lTemp1; |
|
15159 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15160 |
|
15161 lTemp = lY1 - lTemp2; |
|
15162 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15163 |
|
15164 lTemp = lY1 + lTemp3; |
|
15165 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15166 |
|
15167 lCb = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
15168 lCr = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
15169 |
|
15170 lCb -= 128; |
|
15171 lCr -= 128; |
|
15172 |
|
15173 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
15174 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
15175 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
15176 |
|
15177 /*Fifth Pixel*/ |
|
15178 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
15179 |
|
15180 lTemp = lY1 + lTemp1; |
|
15181 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15182 |
|
15183 lTemp = lY1 - lTemp2; |
|
15184 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15185 |
|
15186 lTemp = lY1 + lTemp3; |
|
15187 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15188 |
|
15189 /*Sixth Pixel*/ |
|
15190 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
15191 |
|
15192 lTemp = lY1 + lTemp1; |
|
15193 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15194 |
|
15195 lTemp = lY1 - lTemp2; |
|
15196 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15197 |
|
15198 lTemp = lY1 + lTemp3; |
|
15199 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15200 |
|
15201 lYuyvPtr += 4; |
|
15202 src1 += 6; |
|
15203 src2 += 6; |
|
15204 } |
|
15205 |
|
15206 src1 = lPtr1; |
|
15207 src2 = lPtr2; |
|
15208 |
|
15209 for(j = 0; j < lWidth; j += 2) |
|
15210 { |
|
15211 /* First Pixel */ |
|
15212 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
15213 diff1 = *src1 & 0xf; |
|
15214 diff2 = *(src1 + 1) & 0xf; |
|
15215 diff3 = *(src1 + 2) & 0xf; |
|
15216 |
|
15217 // diffuse the error |
|
15218 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
15219 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
15220 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
15221 |
|
15222 /* Second Pixel */ |
|
15223 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
15224 diff1 = *(src1 + 3) & 0xf; |
|
15225 diff2 = *(src1 + 4) & 0xf; |
|
15226 diff3 = *(src1 + 5) & 0xf; |
|
15227 // diffuse the error |
|
15228 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
15229 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
15230 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
15231 |
|
15232 src1 += 6; |
|
15233 dest1 += 2; |
|
15234 |
|
15235 /* Third Pixel */ |
|
15236 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
15237 diff1 = *src2 & 0xf; |
|
15238 diff2 = *(src2 + 1) & 0xf; |
|
15239 diff3 = *(src2 + 2) & 0xf; |
|
15240 //diffuse the error |
|
15241 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
15242 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
15243 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
15244 |
|
15245 /* Fourth Pixel */ |
|
15246 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
15247 diff1 = *(src2 + 3) & 0xf; |
|
15248 diff2 = *(src2 + 4) & 0xf; |
|
15249 diff3 = *(src2 + 5) & 0xf; |
|
15250 //diffuse the error |
|
15251 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
15252 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
15253 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
15254 |
|
15255 src2 += 6; |
|
15256 dest2 += 2; |
|
15257 } |
|
15258 if(extraCol) |
|
15259 { |
|
15260 *dest1 = dest1[-1]; |
|
15261 dest1++; |
|
15262 *dest2 = dest2[-1]; |
|
15263 dest2++; |
|
15264 } |
|
15265 |
|
15266 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
15267 |
|
15268 dest1 += ((wndWidth << 1) - lTempWidth); |
|
15269 dest2 += ((wndWidth << 1) - lTempWidth); |
|
15270 } |
|
15271 |
|
15272 if(extraRow) |
|
15273 { |
|
15274 dest2 = dest1 - wndWidth; |
|
15275 for(j = 0; j < lWidth; j += 2) |
|
15276 { |
|
15277 *dest1++ = *dest2++; |
|
15278 *dest1++ = *dest2++; |
|
15279 } |
|
15280 if(extraCol) |
|
15281 { |
|
15282 *dest1 = *dest2; |
|
15283 } |
|
15284 } |
|
15285 |
|
15286 free(lBuffer); |
|
15287 return; |
|
15288 } |
|
15289 |
|
15290 /* |
|
15291 ****************************************************************************** |
|
15292 Name : sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_601_5_FR |
|
15293 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
15294 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
15295 uint8 *dstImage : Pointer to rgb data (o/p). |
|
15296 tWndParam *srcWindow : Pointer to structure containing source window |
|
15297 parameters like xOffset,yOffset,cropWidth, |
|
15298 cropHeight. (i/p) |
|
15299 tWndParam *dstWindow : Pointer to structure containing destination window |
|
15300 parameters like xOffset,yOffset,windWidth, |
|
15301 windHeight. (i/p) |
|
15302 Return Value : void |
|
15303 ****************************************************************************** |
|
15304 */ |
|
15305 |
|
15306 void sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_601_5_FR |
|
15307 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
15308 tWndParam* srcWindow, tWndParam* dstWindow) |
|
15309 { |
|
15310 uint16 *dest1, *dest2; |
|
15311 uint8 *lYuyvPtr; |
|
15312 uint8 *lBuffer; |
|
15313 uint8 *src1, *src2; |
|
15314 uint8 *lPtr1, *lPtr2; |
|
15315 int32 diff1, diff2, diff3; |
|
15316 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
15317 int32 lY1, lCr, lCb; |
|
15318 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
15319 int32 i, j, k, extraCol, extraRow; |
|
15320 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
15321 cropWidth,cropHeight,wndWidth,wndHeight; |
|
15322 |
|
15323 srcXOffset = srcWindow->xOffset; |
|
15324 srcYOffset = srcWindow->yOffset; |
|
15325 cropWidth = srcWindow->wndWidth; |
|
15326 cropHeight = srcWindow->wndHeight; |
|
15327 |
|
15328 dstXOffset = dstWindow->xOffset; |
|
15329 dstYOffset = dstWindow->yOffset; |
|
15330 wndWidth = dstWindow->wndWidth; |
|
15331 wndHeight = dstWindow->wndHeight; |
|
15332 |
|
15333 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
15334 { |
|
15335 lWidth = cropWidth; |
|
15336 } |
|
15337 else |
|
15338 { |
|
15339 lWidth = srcImage->width - srcXOffset; |
|
15340 } |
|
15341 |
|
15342 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
15343 { |
|
15344 lHeight = cropHeight; |
|
15345 } |
|
15346 else |
|
15347 { |
|
15348 lHeight = srcImage->height - srcYOffset; |
|
15349 } |
|
15350 |
|
15351 if (lWidth > (wndWidth - dstXOffset)) |
|
15352 { |
|
15353 lWidth = wndWidth - dstXOffset; |
|
15354 } |
|
15355 |
|
15356 if (lHeight > (wndHeight - dstYOffset)) |
|
15357 { |
|
15358 lHeight = wndHeight - dstYOffset; |
|
15359 } |
|
15360 |
|
15361 extraCol = lWidth & 0x01; |
|
15362 extraRow = lHeight & 0x01; |
|
15363 |
|
15364 lTempWidth = lWidth; |
|
15365 lWidth = (lWidth >> 1) << 1; |
|
15366 lHeight = (lHeight >> 1) << 1; |
|
15367 |
|
15368 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
15369 |
|
15370 lSrcWidth = lWidth * 3; |
|
15371 |
|
15372 lLumWidth = (srcImage->width >> 1) << 1; |
|
15373 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
15374 |
|
15375 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
15376 dest2 = dest1 + wndWidth; |
|
15377 |
|
15378 lLumWidth <<= 1; |
|
15379 |
|
15380 for(i = 0; i < lHeight; i += 2) |
|
15381 { |
|
15382 lPtr1 = src1 = lBuffer; |
|
15383 lPtr2 = src2 = src1 + lSrcWidth; |
|
15384 |
|
15385 for(k = 0; k < lWidth; k += 2) |
|
15386 { |
|
15387 lCb = lYuyvPtr[3]; |
|
15388 lCr = lYuyvPtr[1]; |
|
15389 |
|
15390 lCb -= 128; |
|
15391 lCr -= 128; |
|
15392 |
|
15393 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
15394 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
15395 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
15396 |
|
15397 /*First Pixel*/ |
|
15398 lY1 = lYuyvPtr[2]; |
|
15399 |
|
15400 lTemp = lY1 + lTemp1; |
|
15401 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15402 |
|
15403 lTemp = lY1 - lTemp2; |
|
15404 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15405 |
|
15406 lTemp = lY1 + lTemp3; |
|
15407 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15408 |
|
15409 /*Second Pixel*/ |
|
15410 lY1 = lYuyvPtr[0]; |
|
15411 |
|
15412 lTemp = lY1 + lTemp1; |
|
15413 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15414 |
|
15415 lTemp = lY1 - lTemp2; |
|
15416 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15417 |
|
15418 lTemp = lY1 + lTemp3; |
|
15419 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15420 |
|
15421 lCb = lYuyvPtr[lLumWidth + 3]; |
|
15422 lCr = lYuyvPtr[lLumWidth + 1]; |
|
15423 |
|
15424 lCb -= 128; |
|
15425 lCr -= 128; |
|
15426 |
|
15427 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
15428 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
15429 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
15430 |
|
15431 /*Third Pixel*/ |
|
15432 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
15433 |
|
15434 lTemp = lY1 + lTemp1; |
|
15435 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15436 |
|
15437 lTemp = lY1 - lTemp2; |
|
15438 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15439 |
|
15440 lTemp = lY1 + lTemp3; |
|
15441 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15442 |
|
15443 /*Fourth Pixel*/ |
|
15444 lY1 = lYuyvPtr[lLumWidth]; |
|
15445 |
|
15446 lTemp = lY1 + lTemp1; |
|
15447 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15448 |
|
15449 lTemp = lY1 - lTemp2; |
|
15450 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15451 |
|
15452 lTemp = lY1 + lTemp3; |
|
15453 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15454 |
|
15455 lCb = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
15456 lCr = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
15457 |
|
15458 lCb -= 128; |
|
15459 lCr -= 128; |
|
15460 |
|
15461 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
15462 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
15463 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
15464 |
|
15465 /*Fifth Pixel*/ |
|
15466 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
15467 |
|
15468 lTemp = lY1 + lTemp1; |
|
15469 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15470 |
|
15471 lTemp = lY1 - lTemp2; |
|
15472 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15473 |
|
15474 lTemp = lY1 + lTemp3; |
|
15475 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15476 |
|
15477 /*Sixth Pixel*/ |
|
15478 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
15479 |
|
15480 lTemp = lY1 + lTemp1; |
|
15481 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15482 |
|
15483 lTemp = lY1 - lTemp2; |
|
15484 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15485 |
|
15486 lTemp = lY1 + lTemp3; |
|
15487 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
15488 |
|
15489 lYuyvPtr += 4; |
|
15490 src1 += 6; |
|
15491 src2 += 6; |
|
15492 } |
|
15493 |
|
15494 src1 = lPtr1; |
|
15495 src2 = lPtr2; |
|
15496 |
|
15497 for(j = 0; j < lWidth; j += 2) |
|
15498 { |
|
15499 /* First Pixel */ |
|
15500 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
15501 diff1 = *src1 & 0xf; |
|
15502 diff2 = *(src1 + 1) & 0xf; |
|
15503 diff3 = *(src1 + 2) & 0xf; |
|
15504 |
|
15505 // diffuse the error |
|
15506 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
15507 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
15508 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
15509 |
|
15510 /* Second Pixel */ |
|
15511 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
15512 diff1 = *(src1 + 3) & 0xf; |
|
15513 diff2 = *(src1 + 4) & 0xf; |
|
15514 diff3 = *(src1 + 5) & 0xf; |
|
15515 // diffuse the error |
|
15516 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
15517 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
15518 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
15519 |
|
15520 src1 += 6; |
|
15521 dest1 += 2; |
|
15522 |
|
15523 /* Third Pixel */ |
|
15524 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
15525 diff1 = *src2 & 0xf; |
|
15526 diff2 = *(src2 + 1) & 0xf; |
|
15527 diff3 = *(src2 + 2) & 0xf; |
|
15528 //diffuse the error |
|
15529 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
15530 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
15531 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
15532 |
|
15533 /* Fourth Pixel */ |
|
15534 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
15535 diff1 = *(src2 + 3) & 0xf; |
|
15536 diff2 = *(src2 + 4) & 0xf; |
|
15537 diff3 = *(src2 + 5) & 0xf; |
|
15538 //diffuse the error |
|
15539 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
15540 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
15541 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
15542 |
|
15543 src2 += 6; |
|
15544 dest2 += 2; |
|
15545 } |
|
15546 if(extraCol) |
|
15547 { |
|
15548 *dest1 = dest1[-1]; |
|
15549 dest1++; |
|
15550 *dest2 = dest2[-1]; |
|
15551 dest2++; |
|
15552 } |
|
15553 |
|
15554 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
15555 |
|
15556 dest1 += ((wndWidth << 1) - lTempWidth); |
|
15557 dest2 += ((wndWidth << 1) - lTempWidth); |
|
15558 } |
|
15559 |
|
15560 if(extraRow) |
|
15561 { |
|
15562 dest2 = dest1 - wndWidth; |
|
15563 for(j = 0; j < lWidth; j += 2) |
|
15564 { |
|
15565 *dest1++ = *dest2++; |
|
15566 *dest1++ = *dest2++; |
|
15567 } |
|
15568 if(extraCol) |
|
15569 { |
|
15570 *dest1 = *dest2; |
|
15571 } |
|
15572 } |
|
15573 |
|
15574 free(lBuffer); |
|
15575 return; |
|
15576 } |
|
15577 |
|
15578 /* |
|
15579 ****************************************************************************** |
|
15580 Name : sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_709_RR |
|
15581 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
15582 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
15583 uint8 *dstImage : Pointer to rgb data (o/p). |
|
15584 tWndParam *srcWindow : Pointer to structure containing source window |
|
15585 parameters like xOffset,yOffset,cropWidth, |
|
15586 cropHeight. (i/p) |
|
15587 tWndParam *dstWindow : Pointer to structure containing destination window |
|
15588 parameters like xOffset,yOffset,windWidth, |
|
15589 windHeight. (i/p) |
|
15590 Return Value : void |
|
15591 ****************************************************************************** |
|
15592 */ |
|
15593 |
|
15594 void sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_709_RR |
|
15595 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
15596 tWndParam* srcWindow, tWndParam* dstWindow) |
|
15597 { |
|
15598 uint16 *dest1, *dest2; |
|
15599 uint8 *lYuyvPtr; |
|
15600 uint8 *lBuffer; |
|
15601 uint8 *src1, *src2; |
|
15602 uint8 *lPtr1, *lPtr2; |
|
15603 int32 diff1, diff2, diff3; |
|
15604 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
15605 int32 lY1, lCr, lCb; |
|
15606 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
15607 int32 i, j, k, extraCol, extraRow; |
|
15608 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
15609 cropWidth,cropHeight,wndWidth,wndHeight; |
|
15610 |
|
15611 srcXOffset = srcWindow->xOffset; |
|
15612 srcYOffset = srcWindow->yOffset; |
|
15613 cropWidth = srcWindow->wndWidth; |
|
15614 cropHeight = srcWindow->wndHeight; |
|
15615 |
|
15616 dstXOffset = dstWindow->xOffset; |
|
15617 dstYOffset = dstWindow->yOffset; |
|
15618 wndWidth = dstWindow->wndWidth; |
|
15619 wndHeight = dstWindow->wndHeight; |
|
15620 |
|
15621 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
15622 { |
|
15623 lWidth = cropWidth; |
|
15624 } |
|
15625 else |
|
15626 { |
|
15627 lWidth = srcImage->width - srcXOffset; |
|
15628 } |
|
15629 |
|
15630 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
15631 { |
|
15632 lHeight = cropHeight; |
|
15633 } |
|
15634 else |
|
15635 { |
|
15636 lHeight = srcImage->height - srcYOffset; |
|
15637 } |
|
15638 |
|
15639 if (lWidth > (wndWidth - dstXOffset)) |
|
15640 { |
|
15641 lWidth = wndWidth - dstXOffset; |
|
15642 } |
|
15643 |
|
15644 if (lHeight > (wndHeight - dstYOffset)) |
|
15645 { |
|
15646 lHeight = wndHeight - dstYOffset; |
|
15647 } |
|
15648 |
|
15649 extraCol = lWidth & 0x01; |
|
15650 extraRow = lHeight & 0x01; |
|
15651 |
|
15652 lTempWidth = lWidth; |
|
15653 lWidth = (lWidth >> 1) << 1; |
|
15654 lHeight = (lHeight >> 1) << 1; |
|
15655 |
|
15656 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
15657 |
|
15658 lSrcWidth = lWidth * 3; |
|
15659 |
|
15660 lLumWidth = (srcImage->width >> 1) << 1; |
|
15661 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
15662 |
|
15663 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
15664 dest2 = dest1 + wndWidth; |
|
15665 |
|
15666 lLumWidth <<= 1; |
|
15667 |
|
15668 for(i = 0; i < lHeight; i += 2) |
|
15669 { |
|
15670 lPtr1 = src1 = lBuffer; |
|
15671 lPtr2 = src2 = src1 + lSrcWidth; |
|
15672 |
|
15673 for(k = 0; k < lWidth; k += 2) |
|
15674 { |
|
15675 lCb = lYuyvPtr[3]; |
|
15676 lCr = lYuyvPtr[1]; |
|
15677 |
|
15678 lCb -= 128; |
|
15679 lCr -= 128; |
|
15680 |
|
15681 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
15682 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
15683 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
15684 |
|
15685 /*First Pixel*/ |
|
15686 lY1 = lYuyvPtr[2]; |
|
15687 lY1 -= 16; |
|
15688 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
15689 |
|
15690 lTemp = lY1 + lTemp1; |
|
15691 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15692 |
|
15693 lTemp = lY1 - lTemp2; |
|
15694 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15695 |
|
15696 lTemp = lY1 + lTemp3; |
|
15697 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15698 |
|
15699 /*Second Pixel*/ |
|
15700 lY1 = lYuyvPtr[0]; |
|
15701 lY1 -= 16; |
|
15702 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
15703 |
|
15704 lTemp = lY1 + lTemp1; |
|
15705 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15706 |
|
15707 lTemp = lY1 - lTemp2; |
|
15708 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15709 |
|
15710 lTemp = lY1 + lTemp3; |
|
15711 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15712 |
|
15713 lCb = lYuyvPtr[lLumWidth + 3]; |
|
15714 lCr = lYuyvPtr[lLumWidth + 1]; |
|
15715 |
|
15716 lCb -= 128; |
|
15717 lCr -= 128; |
|
15718 |
|
15719 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
15720 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
15721 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
15722 |
|
15723 /*Third Pixel*/ |
|
15724 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
15725 lY1 -= 16; |
|
15726 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
15727 |
|
15728 lTemp = lY1 + lTemp1; |
|
15729 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15730 |
|
15731 lTemp = lY1 - lTemp2; |
|
15732 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15733 |
|
15734 lTemp = lY1 + lTemp3; |
|
15735 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15736 |
|
15737 /*Fourth Pixel*/ |
|
15738 lY1 = lYuyvPtr[lLumWidth]; |
|
15739 lY1 -= 16; |
|
15740 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
15741 |
|
15742 lTemp = lY1 + lTemp1; |
|
15743 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15744 |
|
15745 lTemp = lY1 - lTemp2; |
|
15746 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15747 |
|
15748 lTemp = lY1 + lTemp3; |
|
15749 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15750 |
|
15751 lCb = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
15752 lCr = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
15753 |
|
15754 lCb -= 128; |
|
15755 lCr -= 128; |
|
15756 |
|
15757 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
15758 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
15759 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
15760 |
|
15761 /*Fifth Pixel*/ |
|
15762 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
15763 lY1 -= 16; |
|
15764 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
15765 |
|
15766 lTemp = lY1 + lTemp1; |
|
15767 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15768 |
|
15769 lTemp = lY1 - lTemp2; |
|
15770 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15771 |
|
15772 lTemp = lY1 + lTemp3; |
|
15773 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15774 |
|
15775 /*Sixth Pixel*/ |
|
15776 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
15777 lY1 -= 16; |
|
15778 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
15779 |
|
15780 lTemp = lY1 + lTemp1; |
|
15781 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15782 |
|
15783 lTemp = lY1 - lTemp2; |
|
15784 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15785 |
|
15786 lTemp = lY1 + lTemp3; |
|
15787 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15788 |
|
15789 lYuyvPtr += 4; |
|
15790 src1 += 6; |
|
15791 src2 += 6; |
|
15792 } |
|
15793 |
|
15794 src1 = lPtr1; |
|
15795 src2 = lPtr2; |
|
15796 |
|
15797 for(j = 0; j < lWidth; j += 2) |
|
15798 { |
|
15799 /* First Pixel */ |
|
15800 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
15801 diff1 = *src1 & 0xf; |
|
15802 diff2 = *(src1 + 1) & 0xf; |
|
15803 diff3 = *(src1 + 2) & 0xf; |
|
15804 |
|
15805 // diffuse the error |
|
15806 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
15807 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
15808 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
15809 |
|
15810 /* Second Pixel */ |
|
15811 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
15812 diff1 = *(src1 + 3) & 0xf; |
|
15813 diff2 = *(src1 + 4) & 0xf; |
|
15814 diff3 = *(src1 + 5) & 0xf; |
|
15815 // diffuse the error |
|
15816 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
15817 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
15818 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
15819 |
|
15820 src1 += 6; |
|
15821 dest1 += 2; |
|
15822 |
|
15823 /* Third Pixel */ |
|
15824 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
15825 diff1 = *src2 & 0xf; |
|
15826 diff2 = *(src2 + 1) & 0xf; |
|
15827 diff3 = *(src2 + 2) & 0xf; |
|
15828 //diffuse the error |
|
15829 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
15830 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
15831 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
15832 |
|
15833 /* Fourth Pixel */ |
|
15834 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
15835 diff1 = *(src2 + 3) & 0xf; |
|
15836 diff2 = *(src2 + 4) & 0xf; |
|
15837 diff3 = *(src2 + 5) & 0xf; |
|
15838 //diffuse the error |
|
15839 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
15840 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
15841 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
15842 |
|
15843 src2 += 6; |
|
15844 dest2 += 2; |
|
15845 } |
|
15846 if(extraCol) |
|
15847 { |
|
15848 *dest1 = dest1[-1]; |
|
15849 dest1++; |
|
15850 *dest2 = dest2[-1]; |
|
15851 dest2++; |
|
15852 } |
|
15853 |
|
15854 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
15855 |
|
15856 dest1 += ((wndWidth << 1) - lTempWidth); |
|
15857 dest2 += ((wndWidth << 1) - lTempWidth); |
|
15858 } |
|
15859 |
|
15860 if(extraRow) |
|
15861 { |
|
15862 dest2 = dest1 - wndWidth; |
|
15863 for(j = 0; j < lWidth; j += 2) |
|
15864 { |
|
15865 *dest1++ = *dest2++; |
|
15866 *dest1++ = *dest2++; |
|
15867 } |
|
15868 if(extraCol) |
|
15869 { |
|
15870 *dest1 = *dest2; |
|
15871 } |
|
15872 } |
|
15873 |
|
15874 free(lBuffer); |
|
15875 return; |
|
15876 } |
|
15877 |
|
15878 /* |
|
15879 ****************************************************************************** |
|
15880 Name : sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_601_5_RR |
|
15881 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
15882 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
15883 uint8 *dstImage : Pointer to rgb data (o/p). |
|
15884 tWndParam *srcWindow : Pointer to structure containing source window |
|
15885 parameters like xOffset,yOffset,cropWidth, |
|
15886 cropHeight. (i/p) |
|
15887 tWndParam *dstWindow : Pointer to structure containing destination window |
|
15888 parameters like xOffset,yOffset,windWidth, |
|
15889 windHeight. (i/p) |
|
15890 Return Value : void |
|
15891 ****************************************************************************** |
|
15892 */ |
|
15893 |
|
15894 void sEmz_VDec_YUV422LEChr2toColor4k_ErrDiff_601_5_RR |
|
15895 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
15896 tWndParam* srcWindow, tWndParam* dstWindow) |
|
15897 { |
|
15898 uint16 *dest1, *dest2; |
|
15899 uint8 *lYuyvPtr; |
|
15900 uint8 *lBuffer; |
|
15901 uint8 *src1, *src2; |
|
15902 uint8 *lPtr1, *lPtr2; |
|
15903 int32 diff1, diff2, diff3; |
|
15904 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
15905 int32 lY1, lCr, lCb; |
|
15906 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
15907 int32 i, j, k, extraCol, extraRow; |
|
15908 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
15909 cropWidth,cropHeight,wndWidth,wndHeight; |
|
15910 |
|
15911 srcXOffset = srcWindow->xOffset; |
|
15912 srcYOffset = srcWindow->yOffset; |
|
15913 cropWidth = srcWindow->wndWidth; |
|
15914 cropHeight = srcWindow->wndHeight; |
|
15915 |
|
15916 dstXOffset = dstWindow->xOffset; |
|
15917 dstYOffset = dstWindow->yOffset; |
|
15918 wndWidth = dstWindow->wndWidth; |
|
15919 wndHeight = dstWindow->wndHeight; |
|
15920 |
|
15921 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
15922 { |
|
15923 lWidth = cropWidth; |
|
15924 } |
|
15925 else |
|
15926 { |
|
15927 lWidth = srcImage->width - srcXOffset; |
|
15928 } |
|
15929 |
|
15930 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
15931 { |
|
15932 lHeight = cropHeight; |
|
15933 } |
|
15934 else |
|
15935 { |
|
15936 lHeight = srcImage->height - srcYOffset; |
|
15937 } |
|
15938 |
|
15939 if (lWidth > (wndWidth - dstXOffset)) |
|
15940 { |
|
15941 lWidth = wndWidth - dstXOffset; |
|
15942 } |
|
15943 |
|
15944 if (lHeight > (wndHeight - dstYOffset)) |
|
15945 { |
|
15946 lHeight = wndHeight - dstYOffset; |
|
15947 } |
|
15948 |
|
15949 extraCol = lWidth & 0x01; |
|
15950 extraRow = lHeight & 0x01; |
|
15951 |
|
15952 lTempWidth = lWidth; |
|
15953 lWidth = (lWidth >> 1) << 1; |
|
15954 lHeight = (lHeight >> 1) << 1; |
|
15955 |
|
15956 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
15957 |
|
15958 lSrcWidth = lWidth * 3; |
|
15959 |
|
15960 lLumWidth = (srcImage->width >> 1) << 1; |
|
15961 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
15962 |
|
15963 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
15964 dest2 = dest1 + wndWidth; |
|
15965 |
|
15966 lLumWidth <<= 1; |
|
15967 |
|
15968 for(i = 0; i < lHeight; i += 2) |
|
15969 { |
|
15970 lPtr1 = src1 = lBuffer; |
|
15971 lPtr2 = src2 = src1 + lSrcWidth; |
|
15972 |
|
15973 for(k = 0; k < lWidth; k += 2) |
|
15974 { |
|
15975 lCb = lYuyvPtr[3]; |
|
15976 lCr = lYuyvPtr[1]; |
|
15977 |
|
15978 lCb -= 128; |
|
15979 lCr -= 128; |
|
15980 |
|
15981 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
15982 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
15983 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
15984 |
|
15985 /*First Pixel*/ |
|
15986 lY1 = lYuyvPtr[2]; |
|
15987 lY1 -= 16; |
|
15988 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
15989 |
|
15990 lTemp = lY1 + lTemp1; |
|
15991 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15992 |
|
15993 lTemp = lY1 - lTemp2; |
|
15994 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15995 |
|
15996 lTemp = lY1 + lTemp3; |
|
15997 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
15998 |
|
15999 /*Second Pixel*/ |
|
16000 lY1 = lYuyvPtr[0]; |
|
16001 lY1 -= 16; |
|
16002 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
16003 |
|
16004 lTemp = lY1 + lTemp1; |
|
16005 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16006 |
|
16007 lTemp = lY1 - lTemp2; |
|
16008 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16009 |
|
16010 lTemp = lY1 + lTemp3; |
|
16011 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16012 |
|
16013 lCb = lYuyvPtr[lLumWidth + 3]; |
|
16014 lCr = lYuyvPtr[lLumWidth + 1]; |
|
16015 |
|
16016 lCb -= 128; |
|
16017 lCr -= 128; |
|
16018 |
|
16019 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
16020 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
16021 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
16022 |
|
16023 /*Third Pixel*/ |
|
16024 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
16025 lY1 -= 16; |
|
16026 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
16027 |
|
16028 lTemp = lY1 + lTemp1; |
|
16029 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16030 |
|
16031 lTemp = lY1 - lTemp2; |
|
16032 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16033 |
|
16034 lTemp = lY1 + lTemp3; |
|
16035 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16036 |
|
16037 /*Fourth Pixel*/ |
|
16038 lY1 = lYuyvPtr[lLumWidth]; |
|
16039 lY1 -= 16; |
|
16040 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
16041 |
|
16042 lTemp = lY1 + lTemp1; |
|
16043 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16044 |
|
16045 lTemp = lY1 - lTemp2; |
|
16046 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16047 |
|
16048 lTemp = lY1 + lTemp3; |
|
16049 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16050 |
|
16051 lCb = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
16052 lCr = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
16053 |
|
16054 lCb -= 128; |
|
16055 lCr -= 128; |
|
16056 |
|
16057 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
16058 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
16059 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
16060 |
|
16061 /*Fifth Pixel*/ |
|
16062 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
16063 lY1 -= 16; |
|
16064 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
16065 |
|
16066 lTemp = lY1 + lTemp1; |
|
16067 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16068 |
|
16069 lTemp = lY1 - lTemp2; |
|
16070 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16071 |
|
16072 lTemp = lY1 + lTemp3; |
|
16073 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16074 |
|
16075 /*Sixth Pixel*/ |
|
16076 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
16077 lY1 -= 16; |
|
16078 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
16079 |
|
16080 lTemp = lY1 + lTemp1; |
|
16081 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16082 |
|
16083 lTemp = lY1 - lTemp2; |
|
16084 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16085 |
|
16086 lTemp = lY1 + lTemp3; |
|
16087 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16088 |
|
16089 lYuyvPtr += 4; |
|
16090 src1 += 6; |
|
16091 src2 += 6; |
|
16092 } |
|
16093 |
|
16094 src1 = lPtr1; |
|
16095 src2 = lPtr2; |
|
16096 |
|
16097 for(j = 0; j < lWidth; j += 2) |
|
16098 { |
|
16099 /* First Pixel */ |
|
16100 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
16101 diff1 = *src1 & 0xf; |
|
16102 diff2 = *(src1 + 1) & 0xf; |
|
16103 diff3 = *(src1 + 2) & 0xf; |
|
16104 |
|
16105 // diffuse the error |
|
16106 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
16107 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
16108 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
16109 |
|
16110 /* Second Pixel */ |
|
16111 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
16112 diff1 = *(src1 + 3) & 0xf; |
|
16113 diff2 = *(src1 + 4) & 0xf; |
|
16114 diff3 = *(src1 + 5) & 0xf; |
|
16115 // diffuse the error |
|
16116 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
16117 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
16118 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
16119 |
|
16120 src1 += 6; |
|
16121 dest1 += 2; |
|
16122 |
|
16123 /* Third Pixel */ |
|
16124 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
16125 diff1 = *src2 & 0xf; |
|
16126 diff2 = *(src2 + 1) & 0xf; |
|
16127 diff3 = *(src2 + 2) & 0xf; |
|
16128 //diffuse the error |
|
16129 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
16130 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
16131 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
16132 |
|
16133 /* Fourth Pixel */ |
|
16134 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
16135 diff1 = *(src2 + 3) & 0xf; |
|
16136 diff2 = *(src2 + 4) & 0xf; |
|
16137 diff3 = *(src2 + 5) & 0xf; |
|
16138 //diffuse the error |
|
16139 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
16140 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
16141 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
16142 |
|
16143 src2 += 6; |
|
16144 dest2 += 2; |
|
16145 } |
|
16146 if(extraCol) |
|
16147 { |
|
16148 *dest1 = dest1[-1]; |
|
16149 dest1++; |
|
16150 *dest2 = dest2[-1]; |
|
16151 dest2++; |
|
16152 } |
|
16153 |
|
16154 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
16155 |
|
16156 dest1 += ((wndWidth << 1) - lTempWidth); |
|
16157 dest2 += ((wndWidth << 1) - lTempWidth); |
|
16158 } |
|
16159 |
|
16160 if(extraRow) |
|
16161 { |
|
16162 dest2 = dest1 - wndWidth; |
|
16163 for(j = 0; j < lWidth; j += 2) |
|
16164 { |
|
16165 *dest1++ = *dest2++; |
|
16166 *dest1++ = *dest2++; |
|
16167 } |
|
16168 if(extraCol) |
|
16169 { |
|
16170 *dest1 = *dest2; |
|
16171 } |
|
16172 } |
|
16173 |
|
16174 free(lBuffer); |
|
16175 return; |
|
16176 } |
|
16177 |
|
16178 |
|
16179 |
|
16180 |
|
16181 |
|
16182 |
|
16183 |
|
16184 |
|
16185 |
|
16186 |
|
16187 |
|
16188 |
|
16189 |
|
16190 |
|
16191 |
|
16192 |
|
16193 |
|
16194 |
|
16195 |
|
16196 |
|
16197 |
|
16198 |
|
16199 |
|
16200 |
|
16201 |
|
16202 |
|
16203 |
|
16204 |
|
16205 |
|
16206 |
|
16207 |
|
16208 |
|
16209 |
|
16210 |
|
16211 |
|
16212 |
|
16213 |
|
16214 |
|
16215 |
|
16216 |
|
16217 |
|
16218 |
|
16219 |
|
16220 |
|
16221 |
|
16222 |
|
16223 |
|
16224 |
|
16225 |
|
16226 |
|
16227 |
|
16228 /* |
|
16229 ****************************************************************************** |
|
16230 Name : sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_709_FR |
|
16231 Description : Converts YUV420 Chroma2 Planar to XRGB (4:4:4:4) Interleaved format |
|
16232 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
16233 uint8 *dstImage : Pointer to rgb data (o/p). |
|
16234 tWndParam *srcWindow : Pointer to structure containing source window |
|
16235 parameters like xOffset,yOffset,cropWidth, |
|
16236 cropHeight. (i/p) |
|
16237 tWndParam *dstWindow : Pointer to structure containing destination window |
|
16238 parameters like xOffset,yOffset,windWidth, |
|
16239 windHeight. (i/p) |
|
16240 Return Value : void |
|
16241 ****************************************************************************** |
|
16242 */ |
|
16243 |
|
16244 void sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_709_FR |
|
16245 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
16246 tWndParam* srcWindow, tWndParam* dstWindow) |
|
16247 { |
|
16248 uint16 *dest1, *dest2; |
|
16249 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
16250 uint8 *lBuffer; |
|
16251 uint8 *src1, *src2; |
|
16252 uint8 *lPtr1, *lPtr2; |
|
16253 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
16254 int32 lY1, lCr, lCb; |
|
16255 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
16256 int32 diff1, diff2, diff3; |
|
16257 int32 i, j, k, extraRow, extraCol; |
|
16258 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
16259 cropWidth,cropHeight,wndWidth,wndHeight; |
|
16260 |
|
16261 srcXOffset = srcWindow->xOffset; |
|
16262 srcYOffset = srcWindow->yOffset; |
|
16263 cropWidth = srcWindow->wndWidth; |
|
16264 cropHeight = srcWindow->wndHeight; |
|
16265 |
|
16266 dstXOffset = dstWindow->xOffset; |
|
16267 dstYOffset = dstWindow->yOffset; |
|
16268 wndWidth = dstWindow->wndWidth; |
|
16269 wndHeight = dstWindow->wndHeight; |
|
16270 |
|
16271 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
16272 { |
|
16273 lWidth = cropWidth; |
|
16274 } |
|
16275 else |
|
16276 { |
|
16277 lWidth = srcImage->width - srcXOffset; |
|
16278 } |
|
16279 |
|
16280 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
16281 { |
|
16282 lHeight = cropHeight; |
|
16283 } |
|
16284 else |
|
16285 { |
|
16286 lHeight = srcImage->height - srcYOffset; |
|
16287 } |
|
16288 |
|
16289 if (lWidth > (wndWidth - dstXOffset)) |
|
16290 { |
|
16291 lWidth = wndWidth - dstXOffset; |
|
16292 } |
|
16293 |
|
16294 if (lHeight > (wndHeight - dstYOffset)) |
|
16295 { |
|
16296 lHeight = wndHeight - dstYOffset; |
|
16297 } |
|
16298 |
|
16299 extraCol = lWidth & 0x01; |
|
16300 extraRow = lHeight & 0x01; |
|
16301 |
|
16302 lTempWidth = lWidth; |
|
16303 lWidth = (lWidth >> 1) << 1; |
|
16304 lHeight = (lHeight >> 1) << 1; |
|
16305 |
|
16306 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
16307 |
|
16308 lSrcWidth = lWidth * 3; |
|
16309 |
|
16310 lLumWidth = (srcImage->width >> 1) << 1; |
|
16311 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
16312 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
16313 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
16314 |
|
16315 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
16316 dest2 = dest1 + wndWidth; |
|
16317 |
|
16318 for(i = 0; i < lHeight; i += 2) |
|
16319 { |
|
16320 lPtr1 = src1 = lBuffer; |
|
16321 lPtr2 = src2 = src1 + lSrcWidth; |
|
16322 |
|
16323 for(k = 0; k < lWidth; k += 2) |
|
16324 { |
|
16325 lCr = lCrPtr[k >> 1]; |
|
16326 lCb = lCbPtr[k >> 1]; |
|
16327 |
|
16328 lCr -= 128; |
|
16329 lCb -= 128; |
|
16330 |
|
16331 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
16332 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
16333 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
16334 |
|
16335 /*First Pixel*/ |
|
16336 lY1 = lLumPtr[k]; |
|
16337 |
|
16338 lTemp = lY1 + lTemp1; |
|
16339 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16340 |
|
16341 lTemp = lY1 - lTemp2; |
|
16342 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16343 |
|
16344 lTemp = lY1 + lTemp3; |
|
16345 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16346 |
|
16347 /*Second Pixel*/ |
|
16348 lY1 = lLumPtr[k + 1]; |
|
16349 |
|
16350 lTemp = lY1 + lTemp1; |
|
16351 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16352 |
|
16353 lTemp = lY1 - lTemp2; |
|
16354 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16355 |
|
16356 lTemp = lY1 + lTemp3; |
|
16357 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16358 |
|
16359 |
|
16360 /*Third Pixel*/ |
|
16361 lY1 = lLumPtr[k + lLumWidth]; |
|
16362 |
|
16363 lTemp = lY1 + lTemp1; |
|
16364 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16365 |
|
16366 lTemp = lY1 - lTemp2; |
|
16367 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16368 |
|
16369 lTemp = lY1 + lTemp3; |
|
16370 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16371 |
|
16372 /*Fourth Pixel*/ |
|
16373 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
16374 |
|
16375 lTemp = lY1 + lTemp1; |
|
16376 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16377 |
|
16378 lTemp = lY1 - lTemp2; |
|
16379 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16380 |
|
16381 lTemp = lY1 + lTemp3; |
|
16382 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16383 |
|
16384 |
|
16385 lCr = lCrPtr[(k + lLumWidth) >> 1]; |
|
16386 lCb = lCbPtr[(k + lLumWidth) >> 1]; |
|
16387 |
|
16388 lCr -= 128; |
|
16389 lCb -= 128; |
|
16390 |
|
16391 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
16392 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
16393 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
16394 |
|
16395 /*Fifth Pixel*/ |
|
16396 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
16397 |
|
16398 lTemp = lY1 + lTemp1; |
|
16399 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16400 |
|
16401 lTemp = lY1 - lTemp2; |
|
16402 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16403 |
|
16404 lTemp = lY1 + lTemp3; |
|
16405 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16406 |
|
16407 /*Sixth Pixel*/ |
|
16408 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
16409 |
|
16410 lTemp = lY1 + lTemp1; |
|
16411 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16412 |
|
16413 lTemp = lY1 - lTemp2; |
|
16414 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16415 |
|
16416 lTemp = lY1 + lTemp3; |
|
16417 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16418 |
|
16419 src1 += 6; |
|
16420 src2 += 6; |
|
16421 } |
|
16422 |
|
16423 src1 = lPtr1; |
|
16424 src2 = lPtr2; |
|
16425 |
|
16426 for(j = 0; j < lWidth; j += 2) |
|
16427 { |
|
16428 /* First Pixel */ |
|
16429 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
16430 diff1 = *src1 & 0xf; |
|
16431 diff2 = *(src1 + 1) & 0xf; |
|
16432 diff3 = *(src1 + 2) & 0xf; |
|
16433 |
|
16434 // diffuse the error |
|
16435 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
16436 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
16437 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
16438 |
|
16439 /* Second Pixel */ |
|
16440 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
16441 diff1 = *(src1 + 3) & 0xf; |
|
16442 diff2 = *(src1 + 4) & 0xf; |
|
16443 diff3 = *(src1 + 5) & 0xf; |
|
16444 // diffuse the error |
|
16445 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
16446 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
16447 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
16448 |
|
16449 src1 += 6; |
|
16450 dest1 += 2; |
|
16451 |
|
16452 /* Third Pixel */ |
|
16453 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
16454 diff1 = *src2 & 0xf; |
|
16455 diff2 = *(src2 + 1) & 0xf; |
|
16456 diff3 = *(src2 + 2) & 0xf; |
|
16457 //diffuse the error |
|
16458 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
16459 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
16460 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
16461 |
|
16462 /* Fourth Pixel */ |
|
16463 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
16464 diff1 = *(src2 + 3) & 0xf; |
|
16465 diff2 = *(src2 + 4) & 0xf; |
|
16466 diff3 = *(src2 + 5) & 0xf; |
|
16467 //diffuse the error |
|
16468 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
16469 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
16470 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
16471 |
|
16472 src2 += 6; |
|
16473 dest2 += 2; |
|
16474 } |
|
16475 if(extraCol) |
|
16476 { |
|
16477 *dest1 = dest1[-1]; |
|
16478 dest1++; |
|
16479 *dest2 = dest2[-1]; |
|
16480 dest2++; |
|
16481 } |
|
16482 |
|
16483 lLumPtr += (lLumWidth << 1); |
|
16484 lCrPtr += (lLumWidth >> 1); |
|
16485 lCbPtr += (lLumWidth >> 1); |
|
16486 |
|
16487 dest1 += ((wndWidth << 1) - lTempWidth); |
|
16488 dest2 += ((wndWidth << 1) - lTempWidth); |
|
16489 } |
|
16490 |
|
16491 if(extraRow) |
|
16492 { |
|
16493 dest2 = dest1 - wndWidth; |
|
16494 for(j = 0; j < lWidth; j += 2) |
|
16495 { |
|
16496 *dest1++ = *dest2++; |
|
16497 *dest1++ = *dest2++; |
|
16498 } |
|
16499 if(extraCol) |
|
16500 { |
|
16501 *dest1 = *dest2; |
|
16502 } |
|
16503 } |
|
16504 |
|
16505 free(lBuffer); |
|
16506 return; |
|
16507 } |
|
16508 |
|
16509 |
|
16510 /* |
|
16511 ****************************************************************************** |
|
16512 Name : sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_601_5_FR |
|
16513 Description : Converts YUV420 Chroma2 Planar to XRGB (4:4:4:4) Interleaved format |
|
16514 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
16515 uint8 *dstImage : Pointer to rgb data (o/p). |
|
16516 tWndParam *srcWindow : Pointer to structure containing source window |
|
16517 parameters like xOffset,yOffset,cropWidth, |
|
16518 cropHeight. (i/p) |
|
16519 tWndParam *dstWindow : Pointer to structure containing destination window |
|
16520 parameters like xOffset,yOffset,windWidth, |
|
16521 windHeight. (i/p) |
|
16522 Return Value : void |
|
16523 ****************************************************************************** |
|
16524 */ |
|
16525 |
|
16526 void sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_601_5_FR |
|
16527 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
16528 tWndParam* srcWindow, tWndParam* dstWindow) |
|
16529 { |
|
16530 uint16 *dest1, *dest2; |
|
16531 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
16532 uint8 *lBuffer; |
|
16533 uint8 *src1, *src2; |
|
16534 uint8 *lPtr1, *lPtr2; |
|
16535 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
16536 int32 lY1, lCr, lCb; |
|
16537 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
16538 int32 diff1, diff2, diff3; |
|
16539 int32 i, j, k, extraRow, extraCol; |
|
16540 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
16541 cropWidth,cropHeight,wndWidth,wndHeight; |
|
16542 |
|
16543 srcXOffset = srcWindow->xOffset; |
|
16544 srcYOffset = srcWindow->yOffset; |
|
16545 cropWidth = srcWindow->wndWidth; |
|
16546 cropHeight = srcWindow->wndHeight; |
|
16547 |
|
16548 dstXOffset = dstWindow->xOffset; |
|
16549 dstYOffset = dstWindow->yOffset; |
|
16550 wndWidth = dstWindow->wndWidth; |
|
16551 wndHeight = dstWindow->wndHeight; |
|
16552 |
|
16553 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
16554 { |
|
16555 lWidth = cropWidth; |
|
16556 } |
|
16557 else |
|
16558 { |
|
16559 lWidth = srcImage->width - srcXOffset; |
|
16560 } |
|
16561 |
|
16562 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
16563 { |
|
16564 lHeight = cropHeight; |
|
16565 } |
|
16566 else |
|
16567 { |
|
16568 lHeight = srcImage->height - srcYOffset; |
|
16569 } |
|
16570 |
|
16571 if (lWidth > (wndWidth - dstXOffset)) |
|
16572 { |
|
16573 lWidth = wndWidth - dstXOffset; |
|
16574 } |
|
16575 |
|
16576 if (lHeight > (wndHeight - dstYOffset)) |
|
16577 { |
|
16578 lHeight = wndHeight - dstYOffset; |
|
16579 } |
|
16580 |
|
16581 extraCol = lWidth & 0x01; |
|
16582 extraRow = lHeight & 0x01; |
|
16583 |
|
16584 lTempWidth = lWidth; |
|
16585 lWidth = (lWidth >> 1) << 1; |
|
16586 lHeight = (lHeight >> 1) << 1; |
|
16587 |
|
16588 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
16589 |
|
16590 lSrcWidth = lWidth * 3; |
|
16591 |
|
16592 lLumWidth = (srcImage->width >> 1) << 1; |
|
16593 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
16594 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
16595 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
16596 |
|
16597 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
16598 dest2 = dest1 + wndWidth; |
|
16599 |
|
16600 for(i = 0; i < lHeight; i += 2) |
|
16601 { |
|
16602 lPtr1 = src1 = lBuffer; |
|
16603 lPtr2 = src2 = src1 + lSrcWidth; |
|
16604 |
|
16605 for(k = 0; k < lWidth; k += 2) |
|
16606 { |
|
16607 lCr = lCrPtr[k >> 1]; |
|
16608 lCb = lCbPtr[k >> 1]; |
|
16609 |
|
16610 lCr -= 128; |
|
16611 lCb -= 128; |
|
16612 |
|
16613 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
16614 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
16615 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
16616 |
|
16617 /*First Pixel*/ |
|
16618 lY1 = lLumPtr[k]; |
|
16619 |
|
16620 lTemp = lY1 + lTemp1; |
|
16621 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16622 |
|
16623 lTemp = lY1 - lTemp2; |
|
16624 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16625 |
|
16626 lTemp = lY1 + lTemp3; |
|
16627 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16628 |
|
16629 /*Second Pixel*/ |
|
16630 lY1 = lLumPtr[k + 1]; |
|
16631 |
|
16632 lTemp = lY1 + lTemp1; |
|
16633 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16634 |
|
16635 lTemp = lY1 - lTemp2; |
|
16636 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16637 |
|
16638 lTemp = lY1 + lTemp3; |
|
16639 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16640 |
|
16641 |
|
16642 /*Third Pixel*/ |
|
16643 lY1 = lLumPtr[k + lLumWidth]; |
|
16644 |
|
16645 lTemp = lY1 + lTemp1; |
|
16646 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16647 |
|
16648 lTemp = lY1 - lTemp2; |
|
16649 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16650 |
|
16651 lTemp = lY1 + lTemp3; |
|
16652 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16653 |
|
16654 /*Fourth Pixel*/ |
|
16655 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
16656 |
|
16657 lTemp = lY1 + lTemp1; |
|
16658 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16659 |
|
16660 lTemp = lY1 - lTemp2; |
|
16661 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16662 |
|
16663 lTemp = lY1 + lTemp3; |
|
16664 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16665 |
|
16666 |
|
16667 lCr = lCrPtr[(k + lLumWidth) >> 1]; |
|
16668 lCb = lCbPtr[(k + lLumWidth) >> 1]; |
|
16669 |
|
16670 lCr -= 128; |
|
16671 lCb -= 128; |
|
16672 |
|
16673 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
16674 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
16675 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
16676 |
|
16677 /*Fifth Pixel*/ |
|
16678 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
16679 |
|
16680 lTemp = lY1 + lTemp1; |
|
16681 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16682 |
|
16683 lTemp = lY1 - lTemp2; |
|
16684 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16685 |
|
16686 lTemp = lY1 + lTemp3; |
|
16687 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16688 |
|
16689 /*Sixth Pixel*/ |
|
16690 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
16691 |
|
16692 lTemp = lY1 + lTemp1; |
|
16693 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16694 |
|
16695 lTemp = lY1 - lTemp2; |
|
16696 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16697 |
|
16698 lTemp = lY1 + lTemp3; |
|
16699 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
16700 |
|
16701 src1 += 6; |
|
16702 src2 += 6; |
|
16703 } |
|
16704 |
|
16705 src1 = lPtr1; |
|
16706 src2 = lPtr2; |
|
16707 |
|
16708 for(j = 0; j < lWidth; j += 2) |
|
16709 { |
|
16710 /* First Pixel */ |
|
16711 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
16712 diff1 = *src1 & 0xf; |
|
16713 diff2 = *(src1 + 1) & 0xf; |
|
16714 diff3 = *(src1 + 2) & 0xf; |
|
16715 |
|
16716 // diffuse the error |
|
16717 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
16718 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
16719 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
16720 |
|
16721 /* Second Pixel */ |
|
16722 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
16723 diff1 = *(src1 + 3) & 0xf; |
|
16724 diff2 = *(src1 + 4) & 0xf; |
|
16725 diff3 = *(src1 + 5) & 0xf; |
|
16726 // diffuse the error |
|
16727 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
16728 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
16729 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
16730 |
|
16731 src1 += 6; |
|
16732 dest1 += 2; |
|
16733 |
|
16734 /* Third Pixel */ |
|
16735 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
16736 diff1 = *src2 & 0xf; |
|
16737 diff2 = *(src2 + 1) & 0xf; |
|
16738 diff3 = *(src2 + 2) & 0xf; |
|
16739 //diffuse the error |
|
16740 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
16741 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
16742 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
16743 |
|
16744 /* Fourth Pixel */ |
|
16745 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
16746 diff1 = *(src2 + 3) & 0xf; |
|
16747 diff2 = *(src2 + 4) & 0xf; |
|
16748 diff3 = *(src2 + 5) & 0xf; |
|
16749 //diffuse the error |
|
16750 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
16751 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
16752 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
16753 |
|
16754 src2 += 6; |
|
16755 dest2 += 2; |
|
16756 } |
|
16757 if(extraCol) |
|
16758 { |
|
16759 *dest1 = dest1[-1]; |
|
16760 dest1++; |
|
16761 *dest2 = dest2[-1]; |
|
16762 dest2++; |
|
16763 } |
|
16764 |
|
16765 lLumPtr += (lLumWidth << 1); |
|
16766 lCrPtr += (lLumWidth >> 1); |
|
16767 lCbPtr += (lLumWidth >> 1); |
|
16768 |
|
16769 dest1 += ((wndWidth << 1) - lTempWidth); |
|
16770 dest2 += ((wndWidth << 1) - lTempWidth); |
|
16771 } |
|
16772 |
|
16773 if(extraRow) |
|
16774 { |
|
16775 dest2 = dest1 - wndWidth; |
|
16776 for(j = 0; j < lWidth; j += 2) |
|
16777 { |
|
16778 *dest1++ = *dest2++; |
|
16779 *dest1++ = *dest2++; |
|
16780 } |
|
16781 if(extraCol) |
|
16782 { |
|
16783 *dest1 = *dest2; |
|
16784 } |
|
16785 } |
|
16786 |
|
16787 free(lBuffer); |
|
16788 return; |
|
16789 } |
|
16790 |
|
16791 |
|
16792 /* |
|
16793 ****************************************************************************** |
|
16794 Name : sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_709_RR |
|
16795 Description : Converts YUV420 Chroma2 Planar to XRGB (4:4:4:4) Interleaved format |
|
16796 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
16797 uint8 *dstImage : Pointer to rgb data (o/p). |
|
16798 tWndParam *srcWindow : Pointer to structure containing source window |
|
16799 parameters like xOffset,yOffset,cropWidth, |
|
16800 cropHeight. (i/p) |
|
16801 tWndParam *dstWindow : Pointer to structure containing destination window |
|
16802 parameters like xOffset,yOffset,windWidth, |
|
16803 windHeight. (i/p) |
|
16804 Return Value : void |
|
16805 ****************************************************************************** |
|
16806 */ |
|
16807 |
|
16808 void sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_709_RR |
|
16809 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
16810 tWndParam* srcWindow, tWndParam* dstWindow) |
|
16811 { |
|
16812 uint16 *dest1, *dest2; |
|
16813 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
16814 uint8 *lBuffer; |
|
16815 uint8 *src1, *src2; |
|
16816 uint8 *lPtr1, *lPtr2; |
|
16817 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
16818 int32 lY1, lCr, lCb; |
|
16819 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
16820 int32 diff1, diff2, diff3; |
|
16821 int32 i, j, k, extraRow, extraCol; |
|
16822 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
16823 cropWidth,cropHeight,wndWidth,wndHeight; |
|
16824 |
|
16825 srcXOffset = srcWindow->xOffset; |
|
16826 srcYOffset = srcWindow->yOffset; |
|
16827 cropWidth = srcWindow->wndWidth; |
|
16828 cropHeight = srcWindow->wndHeight; |
|
16829 |
|
16830 dstXOffset = dstWindow->xOffset; |
|
16831 dstYOffset = dstWindow->yOffset; |
|
16832 wndWidth = dstWindow->wndWidth; |
|
16833 wndHeight = dstWindow->wndHeight; |
|
16834 |
|
16835 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
16836 { |
|
16837 lWidth = cropWidth; |
|
16838 } |
|
16839 else |
|
16840 { |
|
16841 lWidth = srcImage->width - srcXOffset; |
|
16842 } |
|
16843 |
|
16844 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
16845 { |
|
16846 lHeight = cropHeight; |
|
16847 } |
|
16848 else |
|
16849 { |
|
16850 lHeight = srcImage->height - srcYOffset; |
|
16851 } |
|
16852 |
|
16853 if (lWidth > (wndWidth - dstXOffset)) |
|
16854 { |
|
16855 lWidth = wndWidth - dstXOffset; |
|
16856 } |
|
16857 |
|
16858 if (lHeight > (wndHeight - dstYOffset)) |
|
16859 { |
|
16860 lHeight = wndHeight - dstYOffset; |
|
16861 } |
|
16862 |
|
16863 extraCol = lWidth & 0x01; |
|
16864 extraRow = lHeight & 0x01; |
|
16865 |
|
16866 lTempWidth = lWidth; |
|
16867 lWidth = (lWidth >> 1) << 1; |
|
16868 lHeight = (lHeight >> 1) << 1; |
|
16869 |
|
16870 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
16871 |
|
16872 lSrcWidth = lWidth * 3; |
|
16873 |
|
16874 lLumWidth = (srcImage->width >> 1) << 1; |
|
16875 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
16876 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
16877 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
16878 |
|
16879 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
16880 dest2 = dest1 + wndWidth; |
|
16881 |
|
16882 for(i = 0; i < lHeight; i += 2) |
|
16883 { |
|
16884 lPtr1 = src1 = lBuffer; |
|
16885 lPtr2 = src2 = src1 + lSrcWidth; |
|
16886 |
|
16887 for(k = 0; k < lWidth; k += 2) |
|
16888 { |
|
16889 lCr = lCrPtr[k >> 1]; |
|
16890 lCb = lCbPtr[k >> 1]; |
|
16891 |
|
16892 lCr -= 128; |
|
16893 lCb -= 128; |
|
16894 |
|
16895 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
16896 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
16897 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
16898 |
|
16899 /*First Pixel*/ |
|
16900 lY1 = lLumPtr[k]; |
|
16901 lY1 -= 16; |
|
16902 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
16903 |
|
16904 lTemp = lY1 + lTemp1; |
|
16905 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16906 |
|
16907 lTemp = lY1 - lTemp2; |
|
16908 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16909 |
|
16910 lTemp = lY1 + lTemp3; |
|
16911 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16912 |
|
16913 /*Second Pixel*/ |
|
16914 lY1 = lLumPtr[k + 1]; |
|
16915 lY1 -= 16; |
|
16916 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
16917 |
|
16918 lTemp = lY1 + lTemp1; |
|
16919 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16920 |
|
16921 lTemp = lY1 - lTemp2; |
|
16922 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16923 |
|
16924 lTemp = lY1 + lTemp3; |
|
16925 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16926 |
|
16927 |
|
16928 /*Third Pixel*/ |
|
16929 lY1 = lLumPtr[k + lLumWidth]; |
|
16930 lY1 -= 16; |
|
16931 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
16932 |
|
16933 lTemp = lY1 + lTemp1; |
|
16934 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16935 |
|
16936 lTemp = lY1 - lTemp2; |
|
16937 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16938 |
|
16939 lTemp = lY1 + lTemp3; |
|
16940 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16941 |
|
16942 /*Fourth Pixel*/ |
|
16943 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
16944 lY1 -= 16; |
|
16945 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
16946 |
|
16947 lTemp = lY1 + lTemp1; |
|
16948 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16949 |
|
16950 lTemp = lY1 - lTemp2; |
|
16951 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16952 |
|
16953 lTemp = lY1 + lTemp3; |
|
16954 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16955 |
|
16956 |
|
16957 lCr = lCrPtr[(k + lLumWidth) >> 1]; |
|
16958 lCb = lCbPtr[(k + lLumWidth) >> 1]; |
|
16959 |
|
16960 lCr -= 128; |
|
16961 lCb -= 128; |
|
16962 |
|
16963 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
16964 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
16965 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
16966 |
|
16967 /*Fifth Pixel*/ |
|
16968 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
16969 |
|
16970 lTemp = lY1 + lTemp1; |
|
16971 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16972 |
|
16973 lTemp = lY1 - lTemp2; |
|
16974 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16975 |
|
16976 lTemp = lY1 + lTemp3; |
|
16977 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16978 |
|
16979 /*Sixth Pixel*/ |
|
16980 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
16981 |
|
16982 lTemp = lY1 + lTemp1; |
|
16983 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16984 |
|
16985 lTemp = lY1 - lTemp2; |
|
16986 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16987 |
|
16988 lTemp = lY1 + lTemp3; |
|
16989 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
16990 |
|
16991 src1 += 6; |
|
16992 src2 += 6; |
|
16993 } |
|
16994 |
|
16995 src1 = lPtr1; |
|
16996 src2 = lPtr2; |
|
16997 |
|
16998 for(j = 0; j < lWidth; j += 2) |
|
16999 { |
|
17000 /* First Pixel */ |
|
17001 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
17002 diff1 = *src1 & 0xf; |
|
17003 diff2 = *(src1 + 1) & 0xf; |
|
17004 diff3 = *(src1 + 2) & 0xf; |
|
17005 |
|
17006 // diffuse the error |
|
17007 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
17008 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
17009 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
17010 |
|
17011 /* Second Pixel */ |
|
17012 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
17013 diff1 = *(src1 + 3) & 0xf; |
|
17014 diff2 = *(src1 + 4) & 0xf; |
|
17015 diff3 = *(src1 + 5) & 0xf; |
|
17016 // diffuse the error |
|
17017 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
17018 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
17019 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
17020 |
|
17021 src1 += 6; |
|
17022 dest1 += 2; |
|
17023 |
|
17024 /* Third Pixel */ |
|
17025 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
17026 diff1 = *src2 & 0xf; |
|
17027 diff2 = *(src2 + 1) & 0xf; |
|
17028 diff3 = *(src2 + 2) & 0xf; |
|
17029 //diffuse the error |
|
17030 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
17031 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
17032 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
17033 |
|
17034 /* Fourth Pixel */ |
|
17035 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
17036 diff1 = *(src2 + 3) & 0xf; |
|
17037 diff2 = *(src2 + 4) & 0xf; |
|
17038 diff3 = *(src2 + 5) & 0xf; |
|
17039 //diffuse the error |
|
17040 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
17041 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
17042 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
17043 |
|
17044 src2 += 6; |
|
17045 dest2 += 2; |
|
17046 } |
|
17047 if(extraCol) |
|
17048 { |
|
17049 *dest1 = dest1[-1]; |
|
17050 dest1++; |
|
17051 *dest2 = dest2[-1]; |
|
17052 dest2++; |
|
17053 } |
|
17054 |
|
17055 lLumPtr += (lLumWidth << 1); |
|
17056 lCrPtr += (lLumWidth >> 1); |
|
17057 lCbPtr += (lLumWidth >> 1); |
|
17058 |
|
17059 dest1 += ((wndWidth << 1) - lTempWidth); |
|
17060 dest2 += ((wndWidth << 1) - lTempWidth); |
|
17061 } |
|
17062 |
|
17063 if(extraRow) |
|
17064 { |
|
17065 dest2 = dest1 - wndWidth; |
|
17066 for(j = 0; j < lWidth; j += 2) |
|
17067 { |
|
17068 *dest1++ = *dest2++; |
|
17069 *dest1++ = *dest2++; |
|
17070 } |
|
17071 if(extraCol) |
|
17072 { |
|
17073 *dest1 = *dest2; |
|
17074 } |
|
17075 } |
|
17076 |
|
17077 free(lBuffer); |
|
17078 return; |
|
17079 } |
|
17080 |
|
17081 |
|
17082 /* |
|
17083 ****************************************************************************** |
|
17084 Name : sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_601_5_RR |
|
17085 Description : Converts YUV420 Chroma2 Planar to XRGB (4:4:4:4) Interleaved format |
|
17086 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
17087 uint8 *dstImage : Pointer to rgb data (o/p). |
|
17088 tWndParam *srcWindow : Pointer to structure containing source window |
|
17089 parameters like xOffset,yOffset,cropWidth, |
|
17090 cropHeight. (i/p) |
|
17091 tWndParam *dstWindow : Pointer to structure containing destination window |
|
17092 parameters like xOffset,yOffset,windWidth, |
|
17093 windHeight. (i/p) |
|
17094 Return Value : void |
|
17095 ****************************************************************************** |
|
17096 */ |
|
17097 |
|
17098 void sEmz_VDec_YUV420Chr2toColor4k_ErrDiff_601_5_RR |
|
17099 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
17100 tWndParam* srcWindow, tWndParam* dstWindow) |
|
17101 { |
|
17102 uint16 *dest1, *dest2; |
|
17103 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
17104 uint8 *lBuffer; |
|
17105 uint8 *src1, *src2; |
|
17106 uint8 *lPtr1, *lPtr2; |
|
17107 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
17108 int32 lY1, lCr, lCb; |
|
17109 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
17110 int32 diff1, diff2, diff3; |
|
17111 int32 i, j, k, extraRow, extraCol; |
|
17112 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
17113 cropWidth,cropHeight,wndWidth,wndHeight; |
|
17114 |
|
17115 srcXOffset = srcWindow->xOffset; |
|
17116 srcYOffset = srcWindow->yOffset; |
|
17117 cropWidth = srcWindow->wndWidth; |
|
17118 cropHeight = srcWindow->wndHeight; |
|
17119 |
|
17120 dstXOffset = dstWindow->xOffset; |
|
17121 dstYOffset = dstWindow->yOffset; |
|
17122 wndWidth = dstWindow->wndWidth; |
|
17123 wndHeight = dstWindow->wndHeight; |
|
17124 |
|
17125 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
17126 { |
|
17127 lWidth = cropWidth; |
|
17128 } |
|
17129 else |
|
17130 { |
|
17131 lWidth = srcImage->width - srcXOffset; |
|
17132 } |
|
17133 |
|
17134 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
17135 { |
|
17136 lHeight = cropHeight; |
|
17137 } |
|
17138 else |
|
17139 { |
|
17140 lHeight = srcImage->height - srcYOffset; |
|
17141 } |
|
17142 |
|
17143 if (lWidth > (wndWidth - dstXOffset)) |
|
17144 { |
|
17145 lWidth = wndWidth - dstXOffset; |
|
17146 } |
|
17147 |
|
17148 if (lHeight > (wndHeight - dstYOffset)) |
|
17149 { |
|
17150 lHeight = wndHeight - dstYOffset; |
|
17151 } |
|
17152 |
|
17153 extraCol = lWidth & 0x01; |
|
17154 extraRow = lHeight & 0x01; |
|
17155 |
|
17156 lTempWidth = lWidth; |
|
17157 lWidth = (lWidth >> 1) << 1; |
|
17158 lHeight = (lHeight >> 1) << 1; |
|
17159 |
|
17160 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
17161 |
|
17162 lSrcWidth = lWidth * 3; |
|
17163 |
|
17164 lLumWidth = (srcImage->width >> 1) << 1; |
|
17165 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
17166 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
17167 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
17168 |
|
17169 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
17170 dest2 = dest1 + wndWidth; |
|
17171 |
|
17172 for(i = 0; i < lHeight; i += 2) |
|
17173 { |
|
17174 lPtr1 = src1 = lBuffer; |
|
17175 lPtr2 = src2 = src1 + lSrcWidth; |
|
17176 |
|
17177 for(k = 0; k < lWidth; k += 2) |
|
17178 { |
|
17179 lCr = lCrPtr[k >> 1]; |
|
17180 lCb = lCbPtr[k >> 1]; |
|
17181 |
|
17182 lCr -= 128; |
|
17183 lCb -= 128; |
|
17184 |
|
17185 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
17186 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
17187 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
17188 |
|
17189 /*First Pixel*/ |
|
17190 lY1 = lLumPtr[k]; |
|
17191 lY1 -= 16; |
|
17192 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
17193 |
|
17194 lTemp = lY1 + lTemp1; |
|
17195 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17196 |
|
17197 lTemp = lY1 - lTemp2; |
|
17198 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17199 |
|
17200 lTemp = lY1 + lTemp3; |
|
17201 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17202 |
|
17203 /*Second Pixel*/ |
|
17204 lY1 = lLumPtr[k + 1]; |
|
17205 lY1 -= 16; |
|
17206 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
17207 |
|
17208 lTemp = lY1 + lTemp1; |
|
17209 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17210 |
|
17211 lTemp = lY1 - lTemp2; |
|
17212 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17213 |
|
17214 lTemp = lY1 + lTemp3; |
|
17215 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17216 |
|
17217 |
|
17218 /*Third Pixel*/ |
|
17219 lY1 = lLumPtr[k + lLumWidth]; |
|
17220 lY1 -= 16; |
|
17221 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
17222 |
|
17223 lTemp = lY1 + lTemp1; |
|
17224 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17225 |
|
17226 lTemp = lY1 - lTemp2; |
|
17227 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17228 |
|
17229 lTemp = lY1 + lTemp3; |
|
17230 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17231 |
|
17232 /*Fourth Pixel*/ |
|
17233 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
17234 lY1 -= 16; |
|
17235 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
17236 |
|
17237 lTemp = lY1 + lTemp1; |
|
17238 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17239 |
|
17240 lTemp = lY1 - lTemp2; |
|
17241 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17242 |
|
17243 lTemp = lY1 + lTemp3; |
|
17244 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17245 |
|
17246 |
|
17247 lCr = lCrPtr[(k + lLumWidth) >> 1]; |
|
17248 lCb = lCbPtr[(k + lLumWidth) >> 1]; |
|
17249 |
|
17250 lCr -= 128; |
|
17251 lCb -= 128; |
|
17252 |
|
17253 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
17254 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
17255 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
17256 |
|
17257 /*Fifth Pixel*/ |
|
17258 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
17259 |
|
17260 lTemp = lY1 + lTemp1; |
|
17261 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17262 |
|
17263 lTemp = lY1 - lTemp2; |
|
17264 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17265 |
|
17266 lTemp = lY1 + lTemp3; |
|
17267 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17268 |
|
17269 /*Sixth Pixel*/ |
|
17270 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
17271 |
|
17272 lTemp = lY1 + lTemp1; |
|
17273 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17274 |
|
17275 lTemp = lY1 - lTemp2; |
|
17276 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17277 |
|
17278 lTemp = lY1 + lTemp3; |
|
17279 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
17280 |
|
17281 src1 += 6; |
|
17282 src2 += 6; |
|
17283 } |
|
17284 |
|
17285 src1 = lPtr1; |
|
17286 src2 = lPtr2; |
|
17287 |
|
17288 for(j = 0; j < lWidth; j += 2) |
|
17289 { |
|
17290 /* First Pixel */ |
|
17291 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
17292 diff1 = *src1 & 0xf; |
|
17293 diff2 = *(src1 + 1) & 0xf; |
|
17294 diff3 = *(src1 + 2) & 0xf; |
|
17295 |
|
17296 // diffuse the error |
|
17297 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
17298 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
17299 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
17300 |
|
17301 /* Second Pixel */ |
|
17302 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
17303 diff1 = *(src1 + 3) & 0xf; |
|
17304 diff2 = *(src1 + 4) & 0xf; |
|
17305 diff3 = *(src1 + 5) & 0xf; |
|
17306 // diffuse the error |
|
17307 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
17308 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
17309 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
17310 |
|
17311 src1 += 6; |
|
17312 dest1 += 2; |
|
17313 |
|
17314 /* Third Pixel */ |
|
17315 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
17316 diff1 = *src2 & 0xf; |
|
17317 diff2 = *(src2 + 1) & 0xf; |
|
17318 diff3 = *(src2 + 2) & 0xf; |
|
17319 //diffuse the error |
|
17320 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
17321 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
17322 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
17323 |
|
17324 /* Fourth Pixel */ |
|
17325 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
17326 diff1 = *(src2 + 3) & 0xf; |
|
17327 diff2 = *(src2 + 4) & 0xf; |
|
17328 diff3 = *(src2 + 5) & 0xf; |
|
17329 //diffuse the error |
|
17330 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
17331 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
17332 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
17333 |
|
17334 src2 += 6; |
|
17335 dest2 += 2; |
|
17336 } |
|
17337 if(extraCol) |
|
17338 { |
|
17339 *dest1 = dest1[-1]; |
|
17340 dest1++; |
|
17341 *dest2 = dest2[-1]; |
|
17342 dest2++; |
|
17343 } |
|
17344 |
|
17345 lLumPtr += (lLumWidth << 1); |
|
17346 lCrPtr += (lLumWidth >> 1); |
|
17347 lCbPtr += (lLumWidth >> 1); |
|
17348 |
|
17349 dest1 += ((wndWidth << 1) - lTempWidth); |
|
17350 dest2 += ((wndWidth << 1) - lTempWidth); |
|
17351 } |
|
17352 |
|
17353 if(extraRow) |
|
17354 { |
|
17355 dest2 = dest1 - wndWidth; |
|
17356 for(j = 0; j < lWidth; j += 2) |
|
17357 { |
|
17358 *dest1++ = *dest2++; |
|
17359 *dest1++ = *dest2++; |
|
17360 } |
|
17361 if(extraCol) |
|
17362 { |
|
17363 *dest1 = *dest2; |
|
17364 } |
|
17365 } |
|
17366 |
|
17367 free(lBuffer); |
|
17368 return; |
|
17369 } |
|
17370 |
|
17371 |
|
17372 /* |
|
17373 ****************************************************************************** |
|
17374 Name : sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_709_FR |
|
17375 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
17376 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
17377 uint8 *dstImage : Pointer to rgb data (o/p). |
|
17378 tWndParam *srcWindow : Pointer to structure containing source window |
|
17379 parameters like xOffset,yOffset,cropWidth, |
|
17380 cropHeight. (i/p) |
|
17381 tWndParam *dstWindow : Pointer to structure containing destination window |
|
17382 parameters like xOffset,yOffset,windWidth, |
|
17383 windHeight. (i/p) |
|
17384 Return Value : void |
|
17385 ****************************************************************************** |
|
17386 */ |
|
17387 |
|
17388 void sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_709_FR |
|
17389 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
17390 tWndParam* srcWindow, tWndParam* dstWindow) |
|
17391 { |
|
17392 uint16 *dest1, *dest2; |
|
17393 uint8 *lYuyvPtr; |
|
17394 uint8 *lBuffer; |
|
17395 uint8 *src1, *src2; |
|
17396 uint8 *lPtr1, *lPtr2; |
|
17397 int32 diff1, diff2, diff3; |
|
17398 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
17399 int32 lY1, lCr, lCb; |
|
17400 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
17401 int32 i, j, k, extraCol, extraRow; |
|
17402 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
17403 cropWidth,cropHeight,wndWidth,wndHeight; |
|
17404 |
|
17405 srcXOffset = srcWindow->xOffset; |
|
17406 srcYOffset = srcWindow->yOffset; |
|
17407 cropWidth = srcWindow->wndWidth; |
|
17408 cropHeight = srcWindow->wndHeight; |
|
17409 |
|
17410 dstXOffset = dstWindow->xOffset; |
|
17411 dstYOffset = dstWindow->yOffset; |
|
17412 wndWidth = dstWindow->wndWidth; |
|
17413 wndHeight = dstWindow->wndHeight; |
|
17414 |
|
17415 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
17416 { |
|
17417 lWidth = cropWidth; |
|
17418 } |
|
17419 else |
|
17420 { |
|
17421 lWidth = srcImage->width - srcXOffset; |
|
17422 } |
|
17423 |
|
17424 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
17425 { |
|
17426 lHeight = cropHeight; |
|
17427 } |
|
17428 else |
|
17429 { |
|
17430 lHeight = srcImage->height - srcYOffset; |
|
17431 } |
|
17432 |
|
17433 if (lWidth > (wndWidth - dstXOffset)) |
|
17434 { |
|
17435 lWidth = wndWidth - dstXOffset; |
|
17436 } |
|
17437 |
|
17438 if (lHeight > (wndHeight - dstYOffset)) |
|
17439 { |
|
17440 lHeight = wndHeight - dstYOffset; |
|
17441 } |
|
17442 |
|
17443 extraCol = lWidth & 0x01; |
|
17444 extraRow = lHeight & 0x01; |
|
17445 |
|
17446 lTempWidth = lWidth; |
|
17447 lWidth = (lWidth >> 1) << 1; |
|
17448 lHeight = (lHeight >> 1) << 1; |
|
17449 |
|
17450 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
17451 |
|
17452 lSrcWidth = lWidth * 3; |
|
17453 |
|
17454 lLumWidth = (srcImage->width >> 1) << 1; |
|
17455 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
17456 |
|
17457 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
17458 dest2 = dest1 + wndWidth; |
|
17459 |
|
17460 lLumWidth <<= 1; |
|
17461 |
|
17462 for(i = 0; i < lHeight; i += 2) |
|
17463 { |
|
17464 lPtr1 = src1 = lBuffer; |
|
17465 lPtr2 = src2 = src1 + lSrcWidth; |
|
17466 |
|
17467 for(k = 0; k < lWidth; k += 2) |
|
17468 { |
|
17469 lCb = lYuyvPtr[0]; |
|
17470 lCr = lYuyvPtr[2]; |
|
17471 |
|
17472 lCb -= 128; |
|
17473 lCr -= 128; |
|
17474 |
|
17475 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
17476 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
17477 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
17478 |
|
17479 /*First Pixel*/ |
|
17480 lY1 = lYuyvPtr[1]; |
|
17481 |
|
17482 lTemp = lY1 + lTemp1; |
|
17483 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17484 |
|
17485 lTemp = lY1 - lTemp2; |
|
17486 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17487 |
|
17488 lTemp = lY1 + lTemp3; |
|
17489 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17490 |
|
17491 /*Second Pixel*/ |
|
17492 lY1 = lYuyvPtr[3]; |
|
17493 |
|
17494 lTemp = lY1 + lTemp1; |
|
17495 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17496 |
|
17497 lTemp = lY1 - lTemp2; |
|
17498 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17499 |
|
17500 lTemp = lY1 + lTemp3; |
|
17501 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17502 |
|
17503 lCb = lYuyvPtr[lLumWidth]; |
|
17504 lCr = lYuyvPtr[lLumWidth + 2]; |
|
17505 |
|
17506 lCb -= 128; |
|
17507 lCr -= 128; |
|
17508 |
|
17509 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
17510 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
17511 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
17512 |
|
17513 /*Third Pixel*/ |
|
17514 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
17515 |
|
17516 lTemp = lY1 + lTemp1; |
|
17517 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17518 |
|
17519 lTemp = lY1 - lTemp2; |
|
17520 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17521 |
|
17522 lTemp = lY1 + lTemp3; |
|
17523 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17524 |
|
17525 /*Fourth Pixel*/ |
|
17526 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
17527 |
|
17528 lTemp = lY1 + lTemp1; |
|
17529 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17530 |
|
17531 lTemp = lY1 - lTemp2; |
|
17532 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17533 |
|
17534 lTemp = lY1 + lTemp3; |
|
17535 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17536 |
|
17537 lCb = lYuyvPtr[(lLumWidth << 1)]; |
|
17538 lCr = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
17539 |
|
17540 lCb -= 128; |
|
17541 lCr -= 128; |
|
17542 |
|
17543 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
17544 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
17545 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
17546 |
|
17547 /*Fifth Pixel*/ |
|
17548 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
17549 |
|
17550 lTemp = lY1 + lTemp1; |
|
17551 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17552 |
|
17553 lTemp = lY1 - lTemp2; |
|
17554 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17555 |
|
17556 lTemp = lY1 + lTemp3; |
|
17557 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17558 |
|
17559 /*Sixth Pixel*/ |
|
17560 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
17561 |
|
17562 lTemp = lY1 + lTemp1; |
|
17563 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17564 |
|
17565 lTemp = lY1 - lTemp2; |
|
17566 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17567 |
|
17568 lTemp = lY1 + lTemp3; |
|
17569 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17570 |
|
17571 lYuyvPtr += 4; |
|
17572 src1 += 6; |
|
17573 src2 += 6; |
|
17574 } |
|
17575 |
|
17576 src1 = lPtr1; |
|
17577 src2 = lPtr2; |
|
17578 |
|
17579 for(j = 0; j < lWidth; j += 2) |
|
17580 { |
|
17581 /* First Pixel */ |
|
17582 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
17583 diff1 = *src1 & 0xf; |
|
17584 diff2 = *(src1 + 1) & 0xf; |
|
17585 diff3 = *(src1 + 2) & 0xf; |
|
17586 |
|
17587 // diffuse the error |
|
17588 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
17589 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
17590 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
17591 |
|
17592 /* Second Pixel */ |
|
17593 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
17594 diff1 = *(src1 + 3) & 0xf; |
|
17595 diff2 = *(src1 + 4) & 0xf; |
|
17596 diff3 = *(src1 + 5) & 0xf; |
|
17597 // diffuse the error |
|
17598 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
17599 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
17600 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
17601 |
|
17602 src1 += 6; |
|
17603 dest1 += 2; |
|
17604 |
|
17605 /* Third Pixel */ |
|
17606 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
17607 diff1 = *src2 & 0xf; |
|
17608 diff2 = *(src2 + 1) & 0xf; |
|
17609 diff3 = *(src2 + 2) & 0xf; |
|
17610 //diffuse the error |
|
17611 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
17612 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
17613 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
17614 |
|
17615 /* Fourth Pixel */ |
|
17616 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
17617 diff1 = *(src2 + 3) & 0xf; |
|
17618 diff2 = *(src2 + 4) & 0xf; |
|
17619 diff3 = *(src2 + 5) & 0xf; |
|
17620 //diffuse the error |
|
17621 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
17622 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
17623 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
17624 |
|
17625 src2 += 6; |
|
17626 dest2 += 2; |
|
17627 } |
|
17628 if(extraCol) |
|
17629 { |
|
17630 *dest1 = dest1[-1]; |
|
17631 dest1++; |
|
17632 *dest2 = dest2[-1]; |
|
17633 dest2++; |
|
17634 } |
|
17635 |
|
17636 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
17637 |
|
17638 dest1 += ((wndWidth << 1) - lTempWidth); |
|
17639 dest2 += ((wndWidth << 1) - lTempWidth); |
|
17640 } |
|
17641 |
|
17642 if(extraRow) |
|
17643 { |
|
17644 dest2 = dest1 - wndWidth; |
|
17645 for(j = 0; j < lWidth; j += 2) |
|
17646 { |
|
17647 *dest1++ = *dest2++; |
|
17648 *dest1++ = *dest2++; |
|
17649 } |
|
17650 if(extraCol) |
|
17651 { |
|
17652 *dest1 = *dest2; |
|
17653 } |
|
17654 } |
|
17655 |
|
17656 free(lBuffer); |
|
17657 return; |
|
17658 } |
|
17659 |
|
17660 /* |
|
17661 ****************************************************************************** |
|
17662 Name : sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_601_5_FR |
|
17663 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
17664 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
17665 uint8 *dstImage : Pointer to rgb data (o/p). |
|
17666 tWndParam *srcWindow : Pointer to structure containing source window |
|
17667 parameters like xOffset,yOffset,cropWidth, |
|
17668 cropHeight. (i/p) |
|
17669 tWndParam *dstWindow : Pointer to structure containing destination window |
|
17670 parameters like xOffset,yOffset,windWidth, |
|
17671 windHeight. (i/p) |
|
17672 Return Value : void |
|
17673 ****************************************************************************** |
|
17674 */ |
|
17675 |
|
17676 void sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_601_5_FR |
|
17677 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
17678 tWndParam* srcWindow, tWndParam* dstWindow) |
|
17679 { |
|
17680 uint16 *dest1, *dest2; |
|
17681 uint8 *lYuyvPtr; |
|
17682 uint8 *lBuffer; |
|
17683 uint8 *src1, *src2; |
|
17684 uint8 *lPtr1, *lPtr2; |
|
17685 int32 diff1, diff2, diff3; |
|
17686 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
17687 int32 lY1, lCr, lCb; |
|
17688 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
17689 int32 i, j, k, extraCol, extraRow; |
|
17690 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
17691 cropWidth,cropHeight,wndWidth,wndHeight; |
|
17692 |
|
17693 srcXOffset = srcWindow->xOffset; |
|
17694 srcYOffset = srcWindow->yOffset; |
|
17695 cropWidth = srcWindow->wndWidth; |
|
17696 cropHeight = srcWindow->wndHeight; |
|
17697 |
|
17698 dstXOffset = dstWindow->xOffset; |
|
17699 dstYOffset = dstWindow->yOffset; |
|
17700 wndWidth = dstWindow->wndWidth; |
|
17701 wndHeight = dstWindow->wndHeight; |
|
17702 |
|
17703 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
17704 { |
|
17705 lWidth = cropWidth; |
|
17706 } |
|
17707 else |
|
17708 { |
|
17709 lWidth = srcImage->width - srcXOffset; |
|
17710 } |
|
17711 |
|
17712 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
17713 { |
|
17714 lHeight = cropHeight; |
|
17715 } |
|
17716 else |
|
17717 { |
|
17718 lHeight = srcImage->height - srcYOffset; |
|
17719 } |
|
17720 |
|
17721 if (lWidth > (wndWidth - dstXOffset)) |
|
17722 { |
|
17723 lWidth = wndWidth - dstXOffset; |
|
17724 } |
|
17725 |
|
17726 if (lHeight > (wndHeight - dstYOffset)) |
|
17727 { |
|
17728 lHeight = wndHeight - dstYOffset; |
|
17729 } |
|
17730 |
|
17731 extraCol = lWidth & 0x01; |
|
17732 extraRow = lHeight & 0x01; |
|
17733 |
|
17734 lTempWidth = lWidth; |
|
17735 lWidth = (lWidth >> 1) << 1; |
|
17736 lHeight = (lHeight >> 1) << 1; |
|
17737 |
|
17738 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
17739 |
|
17740 lSrcWidth = lWidth * 3; |
|
17741 |
|
17742 lLumWidth = (srcImage->width >> 1) << 1; |
|
17743 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
17744 |
|
17745 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
17746 dest2 = dest1 + wndWidth; |
|
17747 |
|
17748 lLumWidth <<= 1; |
|
17749 |
|
17750 for(i = 0; i < lHeight; i += 2) |
|
17751 { |
|
17752 lPtr1 = src1 = lBuffer; |
|
17753 lPtr2 = src2 = src1 + lSrcWidth; |
|
17754 |
|
17755 for(k = 0; k < lWidth; k += 2) |
|
17756 { |
|
17757 lCb = lYuyvPtr[0]; |
|
17758 lCr = lYuyvPtr[2]; |
|
17759 |
|
17760 lCb -= 128; |
|
17761 lCr -= 128; |
|
17762 |
|
17763 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
17764 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
17765 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
17766 |
|
17767 /*First Pixel*/ |
|
17768 lY1 = lYuyvPtr[1]; |
|
17769 |
|
17770 lTemp = lY1 + lTemp1; |
|
17771 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17772 |
|
17773 lTemp = lY1 - lTemp2; |
|
17774 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17775 |
|
17776 lTemp = lY1 + lTemp3; |
|
17777 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17778 |
|
17779 /*Second Pixel*/ |
|
17780 lY1 = lYuyvPtr[3]; |
|
17781 |
|
17782 lTemp = lY1 + lTemp1; |
|
17783 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17784 |
|
17785 lTemp = lY1 - lTemp2; |
|
17786 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17787 |
|
17788 lTemp = lY1 + lTemp3; |
|
17789 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17790 |
|
17791 lCb = lYuyvPtr[lLumWidth]; |
|
17792 lCr = lYuyvPtr[lLumWidth + 2]; |
|
17793 |
|
17794 lCb -= 128; |
|
17795 lCr -= 128; |
|
17796 |
|
17797 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
17798 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
17799 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
17800 |
|
17801 /*Third Pixel*/ |
|
17802 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
17803 |
|
17804 lTemp = lY1 + lTemp1; |
|
17805 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17806 |
|
17807 lTemp = lY1 - lTemp2; |
|
17808 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17809 |
|
17810 lTemp = lY1 + lTemp3; |
|
17811 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17812 |
|
17813 /*Fourth Pixel*/ |
|
17814 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
17815 |
|
17816 lTemp = lY1 + lTemp1; |
|
17817 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17818 |
|
17819 lTemp = lY1 - lTemp2; |
|
17820 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17821 |
|
17822 lTemp = lY1 + lTemp3; |
|
17823 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17824 |
|
17825 lCb = lYuyvPtr[(lLumWidth << 1)]; |
|
17826 lCr = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
17827 |
|
17828 lCb -= 128; |
|
17829 lCr -= 128; |
|
17830 |
|
17831 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
17832 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
17833 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
17834 |
|
17835 /*Fifth Pixel*/ |
|
17836 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
17837 |
|
17838 lTemp = lY1 + lTemp1; |
|
17839 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17840 |
|
17841 lTemp = lY1 - lTemp2; |
|
17842 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17843 |
|
17844 lTemp = lY1 + lTemp3; |
|
17845 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17846 |
|
17847 /*Sixth Pixel*/ |
|
17848 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
17849 |
|
17850 lTemp = lY1 + lTemp1; |
|
17851 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17852 |
|
17853 lTemp = lY1 - lTemp2; |
|
17854 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17855 |
|
17856 lTemp = lY1 + lTemp3; |
|
17857 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
17858 |
|
17859 lYuyvPtr += 4; |
|
17860 src1 += 6; |
|
17861 src2 += 6; |
|
17862 } |
|
17863 |
|
17864 src1 = lPtr1; |
|
17865 src2 = lPtr2; |
|
17866 |
|
17867 for(j = 0; j < lWidth; j += 2) |
|
17868 { |
|
17869 /* First Pixel */ |
|
17870 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
17871 diff1 = *src1 & 0xf; |
|
17872 diff2 = *(src1 + 1) & 0xf; |
|
17873 diff3 = *(src1 + 2) & 0xf; |
|
17874 |
|
17875 // diffuse the error |
|
17876 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
17877 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
17878 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
17879 |
|
17880 /* Second Pixel */ |
|
17881 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
17882 diff1 = *(src1 + 3) & 0xf; |
|
17883 diff2 = *(src1 + 4) & 0xf; |
|
17884 diff3 = *(src1 + 5) & 0xf; |
|
17885 // diffuse the error |
|
17886 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
17887 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
17888 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
17889 |
|
17890 src1 += 6; |
|
17891 dest1 += 2; |
|
17892 |
|
17893 /* Third Pixel */ |
|
17894 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
17895 diff1 = *src2 & 0xf; |
|
17896 diff2 = *(src2 + 1) & 0xf; |
|
17897 diff3 = *(src2 + 2) & 0xf; |
|
17898 //diffuse the error |
|
17899 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
17900 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
17901 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
17902 |
|
17903 /* Fourth Pixel */ |
|
17904 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
17905 diff1 = *(src2 + 3) & 0xf; |
|
17906 diff2 = *(src2 + 4) & 0xf; |
|
17907 diff3 = *(src2 + 5) & 0xf; |
|
17908 //diffuse the error |
|
17909 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
17910 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
17911 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
17912 |
|
17913 src2 += 6; |
|
17914 dest2 += 2; |
|
17915 } |
|
17916 if(extraCol) |
|
17917 { |
|
17918 *dest1 = dest1[-1]; |
|
17919 dest1++; |
|
17920 *dest2 = dest2[-1]; |
|
17921 dest2++; |
|
17922 } |
|
17923 |
|
17924 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
17925 |
|
17926 dest1 += ((wndWidth << 1) - lTempWidth); |
|
17927 dest2 += ((wndWidth << 1) - lTempWidth); |
|
17928 } |
|
17929 |
|
17930 if(extraRow) |
|
17931 { |
|
17932 dest2 = dest1 - wndWidth; |
|
17933 for(j = 0; j < lWidth; j += 2) |
|
17934 { |
|
17935 *dest1++ = *dest2++; |
|
17936 *dest1++ = *dest2++; |
|
17937 } |
|
17938 if(extraCol) |
|
17939 { |
|
17940 *dest1 = *dest2; |
|
17941 } |
|
17942 } |
|
17943 |
|
17944 free(lBuffer); |
|
17945 return; |
|
17946 } |
|
17947 |
|
17948 /* |
|
17949 ****************************************************************************** |
|
17950 Name : sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_709_RR |
|
17951 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
17952 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
17953 uint8 *dstImage : Pointer to rgb data (o/p). |
|
17954 tWndParam *srcWindow : Pointer to structure containing source window |
|
17955 parameters like xOffset,yOffset,cropWidth, |
|
17956 cropHeight. (i/p) |
|
17957 tWndParam *dstWindow : Pointer to structure containing destination window |
|
17958 parameters like xOffset,yOffset,windWidth, |
|
17959 windHeight. (i/p) |
|
17960 Return Value : void |
|
17961 ****************************************************************************** |
|
17962 */ |
|
17963 |
|
17964 void sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_709_RR |
|
17965 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
17966 tWndParam* srcWindow, tWndParam* dstWindow) |
|
17967 { |
|
17968 uint16 *dest1, *dest2; |
|
17969 uint8 *lYuyvPtr; |
|
17970 uint8 *lBuffer; |
|
17971 uint8 *src1, *src2; |
|
17972 uint8 *lPtr1, *lPtr2; |
|
17973 int32 diff1, diff2, diff3; |
|
17974 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
17975 int32 lY1, lCr, lCb; |
|
17976 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
17977 int32 i, j, k, extraCol, extraRow; |
|
17978 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
17979 cropWidth,cropHeight,wndWidth,wndHeight; |
|
17980 |
|
17981 srcXOffset = srcWindow->xOffset; |
|
17982 srcYOffset = srcWindow->yOffset; |
|
17983 cropWidth = srcWindow->wndWidth; |
|
17984 cropHeight = srcWindow->wndHeight; |
|
17985 |
|
17986 dstXOffset = dstWindow->xOffset; |
|
17987 dstYOffset = dstWindow->yOffset; |
|
17988 wndWidth = dstWindow->wndWidth; |
|
17989 wndHeight = dstWindow->wndHeight; |
|
17990 |
|
17991 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
17992 { |
|
17993 lWidth = cropWidth; |
|
17994 } |
|
17995 else |
|
17996 { |
|
17997 lWidth = srcImage->width - srcXOffset; |
|
17998 } |
|
17999 |
|
18000 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
18001 { |
|
18002 lHeight = cropHeight; |
|
18003 } |
|
18004 else |
|
18005 { |
|
18006 lHeight = srcImage->height - srcYOffset; |
|
18007 } |
|
18008 |
|
18009 if (lWidth > (wndWidth - dstXOffset)) |
|
18010 { |
|
18011 lWidth = wndWidth - dstXOffset; |
|
18012 } |
|
18013 |
|
18014 if (lHeight > (wndHeight - dstYOffset)) |
|
18015 { |
|
18016 lHeight = wndHeight - dstYOffset; |
|
18017 } |
|
18018 |
|
18019 extraCol = lWidth & 0x01; |
|
18020 extraRow = lHeight & 0x01; |
|
18021 |
|
18022 lTempWidth = lWidth; |
|
18023 lWidth = (lWidth >> 1) << 1; |
|
18024 lHeight = (lHeight >> 1) << 1; |
|
18025 |
|
18026 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
18027 |
|
18028 lSrcWidth = lWidth * 3; |
|
18029 |
|
18030 lLumWidth = (srcImage->width >> 1) << 1; |
|
18031 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
18032 |
|
18033 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
18034 dest2 = dest1 + wndWidth; |
|
18035 |
|
18036 lLumWidth <<= 1; |
|
18037 |
|
18038 for(i = 0; i < lHeight; i += 2) |
|
18039 { |
|
18040 lPtr1 = src1 = lBuffer; |
|
18041 lPtr2 = src2 = src1 + lSrcWidth; |
|
18042 |
|
18043 for(k = 0; k < lWidth; k += 2) |
|
18044 { |
|
18045 lCb = lYuyvPtr[0]; |
|
18046 lCr = lYuyvPtr[2]; |
|
18047 |
|
18048 lCb -= 128; |
|
18049 lCr -= 128; |
|
18050 |
|
18051 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
18052 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
18053 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
18054 |
|
18055 /*First Pixel*/ |
|
18056 lY1 = lYuyvPtr[1]; |
|
18057 lY1 -= 16; |
|
18058 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18059 |
|
18060 lTemp = lY1 + lTemp1; |
|
18061 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18062 |
|
18063 lTemp = lY1 - lTemp2; |
|
18064 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18065 |
|
18066 lTemp = lY1 + lTemp3; |
|
18067 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18068 |
|
18069 /*Second Pixel*/ |
|
18070 lY1 = lYuyvPtr[3]; |
|
18071 lY1 -= 16; |
|
18072 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18073 |
|
18074 lTemp = lY1 + lTemp1; |
|
18075 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18076 |
|
18077 lTemp = lY1 - lTemp2; |
|
18078 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18079 |
|
18080 lTemp = lY1 + lTemp3; |
|
18081 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18082 |
|
18083 lCb = lYuyvPtr[lLumWidth]; |
|
18084 lCr = lYuyvPtr[lLumWidth + 2]; |
|
18085 |
|
18086 lCb -= 128; |
|
18087 lCr -= 128; |
|
18088 |
|
18089 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
18090 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
18091 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
18092 |
|
18093 /*Third Pixel*/ |
|
18094 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
18095 lY1 -= 16; |
|
18096 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18097 |
|
18098 lTemp = lY1 + lTemp1; |
|
18099 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18100 |
|
18101 lTemp = lY1 - lTemp2; |
|
18102 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18103 |
|
18104 lTemp = lY1 + lTemp3; |
|
18105 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18106 |
|
18107 /*Fourth Pixel*/ |
|
18108 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
18109 lY1 -= 16; |
|
18110 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18111 |
|
18112 lTemp = lY1 + lTemp1; |
|
18113 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18114 |
|
18115 lTemp = lY1 - lTemp2; |
|
18116 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18117 |
|
18118 lTemp = lY1 + lTemp3; |
|
18119 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18120 |
|
18121 lCb = lYuyvPtr[(lLumWidth << 1)]; |
|
18122 lCr = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
18123 |
|
18124 lCb -= 128; |
|
18125 lCr -= 128; |
|
18126 |
|
18127 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
18128 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
18129 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
18130 |
|
18131 /*Fifth Pixel*/ |
|
18132 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
18133 lY1 -= 16; |
|
18134 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18135 |
|
18136 lTemp = lY1 + lTemp1; |
|
18137 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18138 |
|
18139 lTemp = lY1 - lTemp2; |
|
18140 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18141 |
|
18142 lTemp = lY1 + lTemp3; |
|
18143 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18144 |
|
18145 /*Sixth Pixel*/ |
|
18146 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
18147 lY1 -= 16; |
|
18148 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18149 |
|
18150 lTemp = lY1 + lTemp1; |
|
18151 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18152 |
|
18153 lTemp = lY1 - lTemp2; |
|
18154 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18155 |
|
18156 lTemp = lY1 + lTemp3; |
|
18157 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18158 |
|
18159 lYuyvPtr += 4; |
|
18160 src1 += 6; |
|
18161 src2 += 6; |
|
18162 } |
|
18163 |
|
18164 src1 = lPtr1; |
|
18165 src2 = lPtr2; |
|
18166 |
|
18167 for(j = 0; j < lWidth; j += 2) |
|
18168 { |
|
18169 /* First Pixel */ |
|
18170 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
18171 diff1 = *src1 & 0xf; |
|
18172 diff2 = *(src1 + 1) & 0xf; |
|
18173 diff3 = *(src1 + 2) & 0xf; |
|
18174 |
|
18175 // diffuse the error |
|
18176 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
18177 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
18178 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
18179 |
|
18180 /* Second Pixel */ |
|
18181 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
18182 diff1 = *(src1 + 3) & 0xf; |
|
18183 diff2 = *(src1 + 4) & 0xf; |
|
18184 diff3 = *(src1 + 5) & 0xf; |
|
18185 // diffuse the error |
|
18186 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
18187 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
18188 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
18189 |
|
18190 src1 += 6; |
|
18191 dest1 += 2; |
|
18192 |
|
18193 /* Third Pixel */ |
|
18194 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
18195 diff1 = *src2 & 0xf; |
|
18196 diff2 = *(src2 + 1) & 0xf; |
|
18197 diff3 = *(src2 + 2) & 0xf; |
|
18198 //diffuse the error |
|
18199 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
18200 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
18201 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
18202 |
|
18203 /* Fourth Pixel */ |
|
18204 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
18205 diff1 = *(src2 + 3) & 0xf; |
|
18206 diff2 = *(src2 + 4) & 0xf; |
|
18207 diff3 = *(src2 + 5) & 0xf; |
|
18208 //diffuse the error |
|
18209 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
18210 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
18211 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
18212 |
|
18213 src2 += 6; |
|
18214 dest2 += 2; |
|
18215 } |
|
18216 if(extraCol) |
|
18217 { |
|
18218 *dest1 = dest1[-1]; |
|
18219 dest1++; |
|
18220 *dest2 = dest2[-1]; |
|
18221 dest2++; |
|
18222 } |
|
18223 |
|
18224 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
18225 |
|
18226 dest1 += ((wndWidth << 1) - lTempWidth); |
|
18227 dest2 += ((wndWidth << 1) - lTempWidth); |
|
18228 } |
|
18229 |
|
18230 if(extraRow) |
|
18231 { |
|
18232 dest2 = dest1 - wndWidth; |
|
18233 for(j = 0; j < lWidth; j += 2) |
|
18234 { |
|
18235 *dest1++ = *dest2++; |
|
18236 *dest1++ = *dest2++; |
|
18237 } |
|
18238 if(extraCol) |
|
18239 { |
|
18240 *dest1 = *dest2; |
|
18241 } |
|
18242 } |
|
18243 |
|
18244 free(lBuffer); |
|
18245 return; |
|
18246 } |
|
18247 |
|
18248 /* |
|
18249 ****************************************************************************** |
|
18250 Name : sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_601_5_RR |
|
18251 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
18252 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
18253 uint8 *dstImage : Pointer to rgb data (o/p). |
|
18254 tWndParam *srcWindow : Pointer to structure containing source window |
|
18255 parameters like xOffset,yOffset,cropWidth, |
|
18256 cropHeight. (i/p) |
|
18257 tWndParam *dstWindow : Pointer to structure containing destination window |
|
18258 parameters like xOffset,yOffset,windWidth, |
|
18259 windHeight. (i/p) |
|
18260 Return Value : void |
|
18261 ****************************************************************************** |
|
18262 */ |
|
18263 |
|
18264 void sEmz_VDec_YUV422BEChr2toColor4k_ErrDiff_601_5_RR |
|
18265 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
18266 tWndParam* srcWindow, tWndParam* dstWindow) |
|
18267 { |
|
18268 uint16 *dest1, *dest2; |
|
18269 uint8 *lYuyvPtr; |
|
18270 uint8 *lBuffer; |
|
18271 uint8 *src1, *src2; |
|
18272 uint8 *lPtr1, *lPtr2; |
|
18273 int32 diff1, diff2, diff3; |
|
18274 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
18275 int32 lY1, lCr, lCb; |
|
18276 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
18277 int32 i, j, k, extraCol, extraRow; |
|
18278 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
18279 cropWidth,cropHeight,wndWidth,wndHeight; |
|
18280 |
|
18281 srcXOffset = srcWindow->xOffset; |
|
18282 srcYOffset = srcWindow->yOffset; |
|
18283 cropWidth = srcWindow->wndWidth; |
|
18284 cropHeight = srcWindow->wndHeight; |
|
18285 |
|
18286 dstXOffset = dstWindow->xOffset; |
|
18287 dstYOffset = dstWindow->yOffset; |
|
18288 wndWidth = dstWindow->wndWidth; |
|
18289 wndHeight = dstWindow->wndHeight; |
|
18290 |
|
18291 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
18292 { |
|
18293 lWidth = cropWidth; |
|
18294 } |
|
18295 else |
|
18296 { |
|
18297 lWidth = srcImage->width - srcXOffset; |
|
18298 } |
|
18299 |
|
18300 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
18301 { |
|
18302 lHeight = cropHeight; |
|
18303 } |
|
18304 else |
|
18305 { |
|
18306 lHeight = srcImage->height - srcYOffset; |
|
18307 } |
|
18308 |
|
18309 if (lWidth > (wndWidth - dstXOffset)) |
|
18310 { |
|
18311 lWidth = wndWidth - dstXOffset; |
|
18312 } |
|
18313 |
|
18314 if (lHeight > (wndHeight - dstYOffset)) |
|
18315 { |
|
18316 lHeight = wndHeight - dstYOffset; |
|
18317 } |
|
18318 |
|
18319 extraCol = lWidth & 0x01; |
|
18320 extraRow = lHeight & 0x01; |
|
18321 |
|
18322 lTempWidth = lWidth; |
|
18323 lWidth = (lWidth >> 1) << 1; |
|
18324 lHeight = (lHeight >> 1) << 1; |
|
18325 |
|
18326 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
18327 |
|
18328 lSrcWidth = lWidth * 3; |
|
18329 |
|
18330 lLumWidth = (srcImage->width >> 1) << 1; |
|
18331 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
18332 |
|
18333 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
18334 dest2 = dest1 + wndWidth; |
|
18335 |
|
18336 lLumWidth <<= 1; |
|
18337 |
|
18338 for(i = 0; i < lHeight; i += 2) |
|
18339 { |
|
18340 lPtr1 = src1 = lBuffer; |
|
18341 lPtr2 = src2 = src1 + lSrcWidth; |
|
18342 |
|
18343 for(k = 0; k < lWidth; k += 2) |
|
18344 { |
|
18345 lCb = lYuyvPtr[0]; |
|
18346 lCr = lYuyvPtr[2]; |
|
18347 |
|
18348 lCb -= 128; |
|
18349 lCr -= 128; |
|
18350 |
|
18351 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
18352 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
18353 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
18354 |
|
18355 /*First Pixel*/ |
|
18356 lY1 = lYuyvPtr[1]; |
|
18357 lY1 -= 16; |
|
18358 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18359 |
|
18360 lTemp = lY1 + lTemp1; |
|
18361 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18362 |
|
18363 lTemp = lY1 - lTemp2; |
|
18364 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18365 |
|
18366 lTemp = lY1 + lTemp3; |
|
18367 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18368 |
|
18369 /*Second Pixel*/ |
|
18370 lY1 = lYuyvPtr[3]; |
|
18371 lY1 -= 16; |
|
18372 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18373 |
|
18374 lTemp = lY1 + lTemp1; |
|
18375 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18376 |
|
18377 lTemp = lY1 - lTemp2; |
|
18378 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18379 |
|
18380 lTemp = lY1 + lTemp3; |
|
18381 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18382 |
|
18383 lCb = lYuyvPtr[lLumWidth]; |
|
18384 lCr = lYuyvPtr[lLumWidth + 2]; |
|
18385 |
|
18386 lCb -= 128; |
|
18387 lCr -= 128; |
|
18388 |
|
18389 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
18390 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
18391 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
18392 |
|
18393 /*Third Pixel*/ |
|
18394 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
18395 lY1 -= 16; |
|
18396 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18397 |
|
18398 lTemp = lY1 + lTemp1; |
|
18399 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18400 |
|
18401 lTemp = lY1 - lTemp2; |
|
18402 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18403 |
|
18404 lTemp = lY1 + lTemp3; |
|
18405 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18406 |
|
18407 /*Fourth Pixel*/ |
|
18408 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
18409 lY1 -= 16; |
|
18410 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18411 |
|
18412 lTemp = lY1 + lTemp1; |
|
18413 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18414 |
|
18415 lTemp = lY1 - lTemp2; |
|
18416 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18417 |
|
18418 lTemp = lY1 + lTemp3; |
|
18419 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18420 |
|
18421 lCb = lYuyvPtr[(lLumWidth << 1)]; |
|
18422 lCr = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
18423 |
|
18424 lCb -= 128; |
|
18425 lCr -= 128; |
|
18426 |
|
18427 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
18428 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
18429 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
18430 |
|
18431 /*Fifth Pixel*/ |
|
18432 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
18433 lY1 -= 16; |
|
18434 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18435 |
|
18436 lTemp = lY1 + lTemp1; |
|
18437 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18438 |
|
18439 lTemp = lY1 - lTemp2; |
|
18440 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18441 |
|
18442 lTemp = lY1 + lTemp3; |
|
18443 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18444 |
|
18445 /*Sixth Pixel*/ |
|
18446 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
18447 lY1 -= 16; |
|
18448 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
18449 |
|
18450 lTemp = lY1 + lTemp1; |
|
18451 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18452 |
|
18453 lTemp = lY1 - lTemp2; |
|
18454 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18455 |
|
18456 lTemp = lY1 + lTemp3; |
|
18457 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
18458 |
|
18459 lYuyvPtr += 4; |
|
18460 src1 += 6; |
|
18461 src2 += 6; |
|
18462 } |
|
18463 |
|
18464 src1 = lPtr1; |
|
18465 src2 = lPtr2; |
|
18466 |
|
18467 for(j = 0; j < lWidth; j += 2) |
|
18468 { |
|
18469 /* First Pixel */ |
|
18470 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
18471 diff1 = *src1 & 0xf; |
|
18472 diff2 = *(src1 + 1) & 0xf; |
|
18473 diff3 = *(src1 + 2) & 0xf; |
|
18474 |
|
18475 // diffuse the error |
|
18476 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
18477 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
18478 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
18479 |
|
18480 /* Second Pixel */ |
|
18481 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
18482 diff1 = *(src1 + 3) & 0xf; |
|
18483 diff2 = *(src1 + 4) & 0xf; |
|
18484 diff3 = *(src1 + 5) & 0xf; |
|
18485 // diffuse the error |
|
18486 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
18487 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
18488 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
18489 |
|
18490 src1 += 6; |
|
18491 dest1 += 2; |
|
18492 |
|
18493 /* Third Pixel */ |
|
18494 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
18495 diff1 = *src2 & 0xf; |
|
18496 diff2 = *(src2 + 1) & 0xf; |
|
18497 diff3 = *(src2 + 2) & 0xf; |
|
18498 //diffuse the error |
|
18499 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
18500 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
18501 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
18502 |
|
18503 /* Fourth Pixel */ |
|
18504 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
18505 diff1 = *(src2 + 3) & 0xf; |
|
18506 diff2 = *(src2 + 4) & 0xf; |
|
18507 diff3 = *(src2 + 5) & 0xf; |
|
18508 //diffuse the error |
|
18509 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
18510 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
18511 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
18512 |
|
18513 src2 += 6; |
|
18514 dest2 += 2; |
|
18515 } |
|
18516 if(extraCol) |
|
18517 { |
|
18518 *dest1 = dest1[-1]; |
|
18519 dest1++; |
|
18520 *dest2 = dest2[-1]; |
|
18521 dest2++; |
|
18522 } |
|
18523 |
|
18524 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
18525 |
|
18526 dest1 += ((wndWidth << 1) - lTempWidth); |
|
18527 dest2 += ((wndWidth << 1) - lTempWidth); |
|
18528 } |
|
18529 |
|
18530 if(extraRow) |
|
18531 { |
|
18532 dest2 = dest1 - wndWidth; |
|
18533 for(j = 0; j < lWidth; j += 2) |
|
18534 { |
|
18535 *dest1++ = *dest2++; |
|
18536 *dest1++ = *dest2++; |
|
18537 } |
|
18538 if(extraCol) |
|
18539 { |
|
18540 *dest1 = *dest2; |
|
18541 } |
|
18542 } |
|
18543 |
|
18544 free(lBuffer); |
|
18545 return; |
|
18546 } |
|
18547 |
|
18548 /* |
|
18549 ****************************************************************************** |
|
18550 Name : sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_709_FR |
|
18551 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
18552 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
18553 uint8 *dstImage : Pointer to rgb data (o/p). |
|
18554 tWndParam *srcWindow : Pointer to structure containing source window |
|
18555 parameters like xOffset,yOffset,cropWidth, |
|
18556 cropHeight. (i/p) |
|
18557 tWndParam *dstWindow : Pointer to structure containing destination window |
|
18558 parameters like xOffset,yOffset,windWidth, |
|
18559 windHeight. (i/p) |
|
18560 Return Value : void |
|
18561 ****************************************************************************** |
|
18562 */ |
|
18563 |
|
18564 void sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_709_FR |
|
18565 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
18566 tWndParam* srcWindow, tWndParam* dstWindow) |
|
18567 { |
|
18568 uint16 *dest1, *dest2; |
|
18569 uint8 *lYuyvPtr; |
|
18570 uint8 *lBuffer; |
|
18571 uint8 *src1, *src2; |
|
18572 uint8 *lPtr1, *lPtr2; |
|
18573 int32 diff1, diff2, diff3; |
|
18574 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
18575 int32 lY1, lCr, lCb; |
|
18576 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
18577 int32 i, j, k, extraCol, extraRow; |
|
18578 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
18579 cropWidth,cropHeight,wndWidth,wndHeight; |
|
18580 |
|
18581 srcXOffset = srcWindow->xOffset; |
|
18582 srcYOffset = srcWindow->yOffset; |
|
18583 cropWidth = srcWindow->wndWidth; |
|
18584 cropHeight = srcWindow->wndHeight; |
|
18585 |
|
18586 dstXOffset = dstWindow->xOffset; |
|
18587 dstYOffset = dstWindow->yOffset; |
|
18588 wndWidth = dstWindow->wndWidth; |
|
18589 wndHeight = dstWindow->wndHeight; |
|
18590 |
|
18591 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
18592 { |
|
18593 lWidth = cropWidth; |
|
18594 } |
|
18595 else |
|
18596 { |
|
18597 lWidth = srcImage->width - srcXOffset; |
|
18598 } |
|
18599 |
|
18600 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
18601 { |
|
18602 lHeight = cropHeight; |
|
18603 } |
|
18604 else |
|
18605 { |
|
18606 lHeight = srcImage->height - srcYOffset; |
|
18607 } |
|
18608 |
|
18609 if (lWidth > (wndWidth - dstXOffset)) |
|
18610 { |
|
18611 lWidth = wndWidth - dstXOffset; |
|
18612 } |
|
18613 |
|
18614 if (lHeight > (wndHeight - dstYOffset)) |
|
18615 { |
|
18616 lHeight = wndHeight - dstYOffset; |
|
18617 } |
|
18618 |
|
18619 extraCol = lWidth & 0x01; |
|
18620 extraRow = lHeight & 0x01; |
|
18621 |
|
18622 lTempWidth = lWidth; |
|
18623 lWidth = (lWidth >> 1) << 1; |
|
18624 lHeight = (lHeight >> 1) << 1; |
|
18625 |
|
18626 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
18627 |
|
18628 lSrcWidth = lWidth * 3; |
|
18629 |
|
18630 lLumWidth = (srcImage->width >> 1) << 1; |
|
18631 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
18632 |
|
18633 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
18634 dest2 = dest1 + wndWidth; |
|
18635 |
|
18636 lLumWidth <<= 1; |
|
18637 |
|
18638 for(i = 0; i < lHeight; i += 2) |
|
18639 { |
|
18640 lPtr1 = src1 = lBuffer; |
|
18641 lPtr2 = src2 = src1 + lSrcWidth; |
|
18642 |
|
18643 for(k = 0; k < lWidth; k += 2) |
|
18644 { |
|
18645 lCb = lYuyvPtr[3]; |
|
18646 lCr = lYuyvPtr[1]; |
|
18647 |
|
18648 lCb -= 128; |
|
18649 lCr -= 128; |
|
18650 |
|
18651 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
18652 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
18653 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
18654 |
|
18655 /*First Pixel*/ |
|
18656 lY1 = lYuyvPtr[2]; |
|
18657 |
|
18658 lTemp = lY1 + lTemp1; |
|
18659 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18660 |
|
18661 lTemp = lY1 - lTemp2; |
|
18662 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18663 |
|
18664 lTemp = lY1 + lTemp3; |
|
18665 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18666 |
|
18667 /*Second Pixel*/ |
|
18668 lY1 = lYuyvPtr[0]; |
|
18669 |
|
18670 lTemp = lY1 + lTemp1; |
|
18671 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18672 |
|
18673 lTemp = lY1 - lTemp2; |
|
18674 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18675 |
|
18676 lTemp = lY1 + lTemp3; |
|
18677 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18678 |
|
18679 lCb = lYuyvPtr[lLumWidth + 3]; |
|
18680 lCr = lYuyvPtr[lLumWidth + 1]; |
|
18681 |
|
18682 lCb -= 128; |
|
18683 lCr -= 128; |
|
18684 |
|
18685 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
18686 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
18687 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
18688 |
|
18689 /*Third Pixel*/ |
|
18690 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
18691 |
|
18692 lTemp = lY1 + lTemp1; |
|
18693 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18694 |
|
18695 lTemp = lY1 - lTemp2; |
|
18696 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18697 |
|
18698 lTemp = lY1 + lTemp3; |
|
18699 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18700 |
|
18701 /*Fourth Pixel*/ |
|
18702 lY1 = lYuyvPtr[lLumWidth]; |
|
18703 |
|
18704 lTemp = lY1 + lTemp1; |
|
18705 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18706 |
|
18707 lTemp = lY1 - lTemp2; |
|
18708 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18709 |
|
18710 lTemp = lY1 + lTemp3; |
|
18711 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18712 |
|
18713 lCb = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
18714 lCr = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
18715 |
|
18716 lCb -= 128; |
|
18717 lCr -= 128; |
|
18718 |
|
18719 lTemp1 = (25801 * lCr) >> COLOR_CONV_PRECISION; |
|
18720 lTemp2 = ((3072 * lCb) + (7670 * lCr)) >> COLOR_CONV_PRECISION; |
|
18721 lTemp3 = (30397 * lCb) >> COLOR_CONV_PRECISION; |
|
18722 |
|
18723 /*Fifth Pixel*/ |
|
18724 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
18725 |
|
18726 lTemp = lY1 + lTemp1; |
|
18727 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18728 |
|
18729 lTemp = lY1 - lTemp2; |
|
18730 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18731 |
|
18732 lTemp = lY1 + lTemp3; |
|
18733 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18734 |
|
18735 /*Sixth Pixel*/ |
|
18736 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
18737 |
|
18738 lTemp = lY1 + lTemp1; |
|
18739 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18740 |
|
18741 lTemp = lY1 - lTemp2; |
|
18742 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18743 |
|
18744 lTemp = lY1 + lTemp3; |
|
18745 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18746 |
|
18747 lYuyvPtr += 4; |
|
18748 src1 += 6; |
|
18749 src2 += 6; |
|
18750 } |
|
18751 |
|
18752 src1 = lPtr1; |
|
18753 src2 = lPtr2; |
|
18754 |
|
18755 for(j = 0; j < lWidth; j += 2) |
|
18756 { |
|
18757 /* First Pixel */ |
|
18758 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
18759 diff1 = *src1 & 0x7; |
|
18760 diff2 = *(src1 + 1) & 0x3; |
|
18761 diff3 = *(src1 + 2) & 0x7; |
|
18762 |
|
18763 // diffuse the error |
|
18764 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
18765 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
18766 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
18767 |
|
18768 /* Second Pixel */ |
|
18769 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
18770 diff1 = *(src1 + 3) & 0x7; |
|
18771 diff2 = *(src1 + 4) & 0x3; |
|
18772 diff3 = *(src1 + 5) & 0x7; |
|
18773 // diffuse the error |
|
18774 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
18775 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
18776 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
18777 |
|
18778 src1 += 6; |
|
18779 dest1 += 2; |
|
18780 |
|
18781 /* Third Pixel */ |
|
18782 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
18783 diff1 = *src2 & 0x7; |
|
18784 diff2 = *(src2 + 1) & 0x3; |
|
18785 diff3 = *(src2 + 2) & 0x7; |
|
18786 //diffuse the error |
|
18787 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
18788 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
18789 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
18790 |
|
18791 /* Fourth Pixel */ |
|
18792 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
18793 diff1 = *(src2 + 3) & 0x7; |
|
18794 diff2 = *(src2 + 4) & 0x3; |
|
18795 diff3 = *(src2 + 5) & 0x7; |
|
18796 //diffuse the error |
|
18797 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
18798 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
18799 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
18800 |
|
18801 src2 += 6; |
|
18802 dest2 += 2; |
|
18803 } |
|
18804 if(extraCol) |
|
18805 { |
|
18806 *dest1 = dest1[-1]; |
|
18807 dest1++; |
|
18808 *dest2 = dest2[-1]; |
|
18809 dest2++; |
|
18810 } |
|
18811 |
|
18812 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
18813 |
|
18814 dest1 += ((wndWidth << 1) - lTempWidth); |
|
18815 dest2 += ((wndWidth << 1) - lTempWidth); |
|
18816 } |
|
18817 |
|
18818 if(extraRow) |
|
18819 { |
|
18820 dest2 = dest1 - wndWidth; |
|
18821 for(j = 0; j < lWidth; j += 2) |
|
18822 { |
|
18823 *dest1++ = *dest2++; |
|
18824 *dest1++ = *dest2++; |
|
18825 } |
|
18826 if(extraCol) |
|
18827 { |
|
18828 *dest1 = *dest2; |
|
18829 } |
|
18830 } |
|
18831 |
|
18832 free(lBuffer); |
|
18833 return; |
|
18834 } |
|
18835 |
|
18836 /* |
|
18837 ****************************************************************************** |
|
18838 Name : sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_601_5_FR |
|
18839 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
18840 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
18841 uint8 *dstImage : Pointer to rgb data (o/p). |
|
18842 tWndParam *srcWindow : Pointer to structure containing source window |
|
18843 parameters like xOffset,yOffset,cropWidth, |
|
18844 cropHeight. (i/p) |
|
18845 tWndParam *dstWindow : Pointer to structure containing destination window |
|
18846 parameters like xOffset,yOffset,windWidth, |
|
18847 windHeight. (i/p) |
|
18848 Return Value : void |
|
18849 ****************************************************************************** |
|
18850 */ |
|
18851 |
|
18852 void sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_601_5_FR |
|
18853 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
18854 tWndParam* srcWindow, tWndParam* dstWindow) |
|
18855 { |
|
18856 uint16 *dest1, *dest2; |
|
18857 uint8 *lYuyvPtr; |
|
18858 uint8 *lBuffer; |
|
18859 uint8 *src1, *src2; |
|
18860 uint8 *lPtr1, *lPtr2; |
|
18861 int32 diff1, diff2, diff3; |
|
18862 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
18863 int32 lY1, lCr, lCb; |
|
18864 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
18865 int32 i, j, k, extraCol, extraRow; |
|
18866 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
18867 cropWidth,cropHeight,wndWidth,wndHeight; |
|
18868 |
|
18869 srcXOffset = srcWindow->xOffset; |
|
18870 srcYOffset = srcWindow->yOffset; |
|
18871 cropWidth = srcWindow->wndWidth; |
|
18872 cropHeight = srcWindow->wndHeight; |
|
18873 |
|
18874 dstXOffset = dstWindow->xOffset; |
|
18875 dstYOffset = dstWindow->yOffset; |
|
18876 wndWidth = dstWindow->wndWidth; |
|
18877 wndHeight = dstWindow->wndHeight; |
|
18878 |
|
18879 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
18880 { |
|
18881 lWidth = cropWidth; |
|
18882 } |
|
18883 else |
|
18884 { |
|
18885 lWidth = srcImage->width - srcXOffset; |
|
18886 } |
|
18887 |
|
18888 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
18889 { |
|
18890 lHeight = cropHeight; |
|
18891 } |
|
18892 else |
|
18893 { |
|
18894 lHeight = srcImage->height - srcYOffset; |
|
18895 } |
|
18896 |
|
18897 if (lWidth > (wndWidth - dstXOffset)) |
|
18898 { |
|
18899 lWidth = wndWidth - dstXOffset; |
|
18900 } |
|
18901 |
|
18902 if (lHeight > (wndHeight - dstYOffset)) |
|
18903 { |
|
18904 lHeight = wndHeight - dstYOffset; |
|
18905 } |
|
18906 |
|
18907 extraCol = lWidth & 0x01; |
|
18908 extraRow = lHeight & 0x01; |
|
18909 |
|
18910 lTempWidth = lWidth; |
|
18911 lWidth = (lWidth >> 1) << 1; |
|
18912 lHeight = (lHeight >> 1) << 1; |
|
18913 |
|
18914 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
18915 |
|
18916 lSrcWidth = lWidth * 3; |
|
18917 |
|
18918 lLumWidth = (srcImage->width >> 1) << 1; |
|
18919 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
18920 |
|
18921 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
18922 dest2 = dest1 + wndWidth; |
|
18923 |
|
18924 lLumWidth <<= 1; |
|
18925 |
|
18926 for(i = 0; i < lHeight; i += 2) |
|
18927 { |
|
18928 lPtr1 = src1 = lBuffer; |
|
18929 lPtr2 = src2 = src1 + lSrcWidth; |
|
18930 |
|
18931 for(k = 0; k < lWidth; k += 2) |
|
18932 { |
|
18933 lCb = lYuyvPtr[3]; |
|
18934 lCr = lYuyvPtr[1]; |
|
18935 |
|
18936 lCb -= 128; |
|
18937 lCr -= 128; |
|
18938 |
|
18939 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
18940 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
18941 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
18942 |
|
18943 /*First Pixel*/ |
|
18944 lY1 = lYuyvPtr[2]; |
|
18945 |
|
18946 lTemp = lY1 + lTemp1; |
|
18947 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18948 |
|
18949 lTemp = lY1 - lTemp2; |
|
18950 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18951 |
|
18952 lTemp = lY1 + lTemp3; |
|
18953 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18954 |
|
18955 /*Second Pixel*/ |
|
18956 lY1 = lYuyvPtr[0]; |
|
18957 |
|
18958 lTemp = lY1 + lTemp1; |
|
18959 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18960 |
|
18961 lTemp = lY1 - lTemp2; |
|
18962 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18963 |
|
18964 lTemp = lY1 + lTemp3; |
|
18965 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18966 |
|
18967 lCb = lYuyvPtr[lLumWidth + 3]; |
|
18968 lCr = lYuyvPtr[lLumWidth + 1]; |
|
18969 |
|
18970 lCb -= 128; |
|
18971 lCr -= 128; |
|
18972 |
|
18973 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
18974 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
18975 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
18976 |
|
18977 /*Third Pixel*/ |
|
18978 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
18979 |
|
18980 lTemp = lY1 + lTemp1; |
|
18981 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18982 |
|
18983 lTemp = lY1 - lTemp2; |
|
18984 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18985 |
|
18986 lTemp = lY1 + lTemp3; |
|
18987 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18988 |
|
18989 /*Fourth Pixel*/ |
|
18990 lY1 = lYuyvPtr[lLumWidth]; |
|
18991 |
|
18992 lTemp = lY1 + lTemp1; |
|
18993 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18994 |
|
18995 lTemp = lY1 - lTemp2; |
|
18996 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
18997 |
|
18998 lTemp = lY1 + lTemp3; |
|
18999 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
19000 |
|
19001 lCb = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
19002 lCr = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
19003 |
|
19004 lCb -= 128; |
|
19005 lCr -= 128; |
|
19006 |
|
19007 lTemp1 = (22973 * lCr) >> COLOR_CONV_PRECISION; |
|
19008 lTemp2 = ((5637 * lCb) + (11699 * lCr)) >> COLOR_CONV_PRECISION; |
|
19009 lTemp3 = (29032 * lCb) >> COLOR_CONV_PRECISION; |
|
19010 |
|
19011 /*Fifth Pixel*/ |
|
19012 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
19013 |
|
19014 lTemp = lY1 + lTemp1; |
|
19015 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
19016 |
|
19017 lTemp = lY1 - lTemp2; |
|
19018 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
19019 |
|
19020 lTemp = lY1 + lTemp3; |
|
19021 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
19022 |
|
19023 /*Sixth Pixel*/ |
|
19024 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
19025 |
|
19026 lTemp = lY1 + lTemp1; |
|
19027 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
19028 |
|
19029 lTemp = lY1 - lTemp2; |
|
19030 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
19031 |
|
19032 lTemp = lY1 + lTemp3; |
|
19033 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
19034 |
|
19035 lYuyvPtr += 4; |
|
19036 src1 += 6; |
|
19037 src2 += 6; |
|
19038 } |
|
19039 |
|
19040 src1 = lPtr1; |
|
19041 src2 = lPtr2; |
|
19042 |
|
19043 for(j = 0; j < lWidth; j += 2) |
|
19044 { |
|
19045 /* First Pixel */ |
|
19046 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
19047 diff1 = *src1 & 0x7; |
|
19048 diff2 = *(src1 + 1) & 0x3; |
|
19049 diff3 = *(src1 + 2) & 0x7; |
|
19050 |
|
19051 // diffuse the error |
|
19052 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
19053 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
19054 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
19055 |
|
19056 /* Second Pixel */ |
|
19057 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
19058 diff1 = *(src1 + 3) & 0x7; |
|
19059 diff2 = *(src1 + 4) & 0x3; |
|
19060 diff3 = *(src1 + 5) & 0x7; |
|
19061 // diffuse the error |
|
19062 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
19063 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
19064 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
19065 |
|
19066 src1 += 6; |
|
19067 dest1 += 2; |
|
19068 |
|
19069 /* Third Pixel */ |
|
19070 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
19071 diff1 = *src2 & 0x7; |
|
19072 diff2 = *(src2 + 1) & 0x3; |
|
19073 diff3 = *(src2 + 2) & 0x7; |
|
19074 //diffuse the error |
|
19075 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
19076 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
19077 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
19078 |
|
19079 /* Fourth Pixel */ |
|
19080 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
19081 diff1 = *(src2 + 3) & 0x7; |
|
19082 diff2 = *(src2 + 4) & 0x3; |
|
19083 diff3 = *(src2 + 5) & 0x7; |
|
19084 //diffuse the error |
|
19085 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
19086 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
19087 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
19088 |
|
19089 src2 += 6; |
|
19090 dest2 += 2; |
|
19091 } |
|
19092 if(extraCol) |
|
19093 { |
|
19094 *dest1 = dest1[-1]; |
|
19095 dest1++; |
|
19096 *dest2 = dest2[-1]; |
|
19097 dest2++; |
|
19098 } |
|
19099 |
|
19100 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
19101 |
|
19102 dest1 += ((wndWidth << 1) - lTempWidth); |
|
19103 dest2 += ((wndWidth << 1) - lTempWidth); |
|
19104 } |
|
19105 |
|
19106 if(extraRow) |
|
19107 { |
|
19108 dest2 = dest1 - wndWidth; |
|
19109 for(j = 0; j < lWidth; j += 2) |
|
19110 { |
|
19111 *dest1++ = *dest2++; |
|
19112 *dest1++ = *dest2++; |
|
19113 } |
|
19114 if(extraCol) |
|
19115 { |
|
19116 *dest1 = *dest2; |
|
19117 } |
|
19118 } |
|
19119 |
|
19120 free(lBuffer); |
|
19121 return; |
|
19122 } |
|
19123 |
|
19124 /* |
|
19125 ****************************************************************************** |
|
19126 Name : sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_709_RR |
|
19127 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
19128 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
19129 uint8 *dstImage : Pointer to rgb data (o/p). |
|
19130 tWndParam *srcWindow : Pointer to structure containing source window |
|
19131 parameters like xOffset,yOffset,cropWidth, |
|
19132 cropHeight. (i/p) |
|
19133 tWndParam *dstWindow : Pointer to structure containing destination window |
|
19134 parameters like xOffset,yOffset,windWidth, |
|
19135 windHeight. (i/p) |
|
19136 Return Value : void |
|
19137 ****************************************************************************** |
|
19138 */ |
|
19139 |
|
19140 void sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_709_RR |
|
19141 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
19142 tWndParam* srcWindow, tWndParam* dstWindow) |
|
19143 { |
|
19144 uint16 *dest1, *dest2; |
|
19145 uint8 *lYuyvPtr; |
|
19146 uint8 *lBuffer; |
|
19147 uint8 *src1, *src2; |
|
19148 uint8 *lPtr1, *lPtr2; |
|
19149 int32 diff1, diff2, diff3; |
|
19150 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
19151 int32 lY1, lCr, lCb; |
|
19152 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
19153 int32 i, j, k, extraCol, extraRow; |
|
19154 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
19155 cropWidth,cropHeight,wndWidth,wndHeight; |
|
19156 |
|
19157 srcXOffset = srcWindow->xOffset; |
|
19158 srcYOffset = srcWindow->yOffset; |
|
19159 cropWidth = srcWindow->wndWidth; |
|
19160 cropHeight = srcWindow->wndHeight; |
|
19161 |
|
19162 dstXOffset = dstWindow->xOffset; |
|
19163 dstYOffset = dstWindow->yOffset; |
|
19164 wndWidth = dstWindow->wndWidth; |
|
19165 wndHeight = dstWindow->wndHeight; |
|
19166 |
|
19167 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
19168 { |
|
19169 lWidth = cropWidth; |
|
19170 } |
|
19171 else |
|
19172 { |
|
19173 lWidth = srcImage->width - srcXOffset; |
|
19174 } |
|
19175 |
|
19176 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
19177 { |
|
19178 lHeight = cropHeight; |
|
19179 } |
|
19180 else |
|
19181 { |
|
19182 lHeight = srcImage->height - srcYOffset; |
|
19183 } |
|
19184 |
|
19185 if (lWidth > (wndWidth - dstXOffset)) |
|
19186 { |
|
19187 lWidth = wndWidth - dstXOffset; |
|
19188 } |
|
19189 |
|
19190 if (lHeight > (wndHeight - dstYOffset)) |
|
19191 { |
|
19192 lHeight = wndHeight - dstYOffset; |
|
19193 } |
|
19194 |
|
19195 extraCol = lWidth & 0x01; |
|
19196 extraRow = lHeight & 0x01; |
|
19197 |
|
19198 lTempWidth = lWidth; |
|
19199 lWidth = (lWidth >> 1) << 1; |
|
19200 lHeight = (lHeight >> 1) << 1; |
|
19201 |
|
19202 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
19203 |
|
19204 lSrcWidth = lWidth * 3; |
|
19205 |
|
19206 lLumWidth = (srcImage->width >> 1) << 1; |
|
19207 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
19208 |
|
19209 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
19210 dest2 = dest1 + wndWidth; |
|
19211 |
|
19212 lLumWidth <<= 1; |
|
19213 |
|
19214 for(i = 0; i < lHeight; i += 2) |
|
19215 { |
|
19216 lPtr1 = src1 = lBuffer; |
|
19217 lPtr2 = src2 = src1 + lSrcWidth; |
|
19218 |
|
19219 for(k = 0; k < lWidth; k += 2) |
|
19220 { |
|
19221 lCb = lYuyvPtr[3]; |
|
19222 lCr = lYuyvPtr[1]; |
|
19223 |
|
19224 lCb -= 128; |
|
19225 lCr -= 128; |
|
19226 |
|
19227 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
19228 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
19229 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
19230 |
|
19231 /*First Pixel*/ |
|
19232 lY1 = lYuyvPtr[2]; |
|
19233 lY1 -= 16; |
|
19234 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19235 |
|
19236 lTemp = lY1 + lTemp1; |
|
19237 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19238 |
|
19239 lTemp = lY1 - lTemp2; |
|
19240 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19241 |
|
19242 lTemp = lY1 + lTemp3; |
|
19243 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19244 |
|
19245 /*Second Pixel*/ |
|
19246 lY1 = lYuyvPtr[0]; |
|
19247 lY1 -= 16; |
|
19248 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19249 |
|
19250 lTemp = lY1 + lTemp1; |
|
19251 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19252 |
|
19253 lTemp = lY1 - lTemp2; |
|
19254 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19255 |
|
19256 lTemp = lY1 + lTemp3; |
|
19257 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19258 |
|
19259 lCb = lYuyvPtr[lLumWidth + 3]; |
|
19260 lCr = lYuyvPtr[lLumWidth + 1]; |
|
19261 |
|
19262 lCb -= 128; |
|
19263 lCr -= 128; |
|
19264 |
|
19265 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
19266 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
19267 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
19268 |
|
19269 /*Third Pixel*/ |
|
19270 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
19271 lY1 -= 16; |
|
19272 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19273 |
|
19274 lTemp = lY1 + lTemp1; |
|
19275 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19276 |
|
19277 lTemp = lY1 - lTemp2; |
|
19278 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19279 |
|
19280 lTemp = lY1 + lTemp3; |
|
19281 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19282 |
|
19283 /*Fourth Pixel*/ |
|
19284 lY1 = lYuyvPtr[lLumWidth]; |
|
19285 lY1 -= 16; |
|
19286 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19287 |
|
19288 lTemp = lY1 + lTemp1; |
|
19289 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19290 |
|
19291 lTemp = lY1 - lTemp2; |
|
19292 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19293 |
|
19294 lTemp = lY1 + lTemp3; |
|
19295 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19296 |
|
19297 lCb = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
19298 lCr = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
19299 |
|
19300 lCb -= 128; |
|
19301 lCr -= 128; |
|
19302 |
|
19303 lTemp1 = (29374 * lCr) >> COLOR_CONV_PRECISION; |
|
19304 lTemp2 = ((3494 * lCb) + (8731 * lCr)) >> COLOR_CONV_PRECISION; |
|
19305 lTemp3 = (34603 * lCb) >> COLOR_CONV_PRECISION; |
|
19306 |
|
19307 /*Fifth Pixel*/ |
|
19308 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
19309 lY1 -= 16; |
|
19310 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19311 |
|
19312 lTemp = lY1 + lTemp1; |
|
19313 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19314 |
|
19315 lTemp = lY1 - lTemp2; |
|
19316 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19317 |
|
19318 lTemp = lY1 + lTemp3; |
|
19319 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19320 |
|
19321 /*Sixth Pixel*/ |
|
19322 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
19323 lY1 -= 16; |
|
19324 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19325 |
|
19326 lTemp = lY1 + lTemp1; |
|
19327 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19328 |
|
19329 lTemp = lY1 - lTemp2; |
|
19330 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19331 |
|
19332 lTemp = lY1 + lTemp3; |
|
19333 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19334 |
|
19335 lYuyvPtr += 4; |
|
19336 src1 += 6; |
|
19337 src2 += 6; |
|
19338 } |
|
19339 |
|
19340 src1 = lPtr1; |
|
19341 src2 = lPtr2; |
|
19342 |
|
19343 for(j = 0; j < lWidth; j += 2) |
|
19344 { |
|
19345 /* First Pixel */ |
|
19346 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
19347 diff1 = *src1 & 0x7; |
|
19348 diff2 = *(src1 + 1) & 0x3; |
|
19349 diff3 = *(src1 + 2) & 0x7; |
|
19350 |
|
19351 // diffuse the error |
|
19352 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
19353 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
19354 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
19355 |
|
19356 /* Second Pixel */ |
|
19357 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
19358 diff1 = *(src1 + 3) & 0x7; |
|
19359 diff2 = *(src1 + 4) & 0x3; |
|
19360 diff3 = *(src1 + 5) & 0x7; |
|
19361 // diffuse the error |
|
19362 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
19363 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
19364 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
19365 |
|
19366 src1 += 6; |
|
19367 dest1 += 2; |
|
19368 |
|
19369 /* Third Pixel */ |
|
19370 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
19371 diff1 = *src2 & 0x7; |
|
19372 diff2 = *(src2 + 1) & 0x3; |
|
19373 diff3 = *(src2 + 2) & 0x7; |
|
19374 //diffuse the error |
|
19375 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
19376 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
19377 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
19378 |
|
19379 /* Fourth Pixel */ |
|
19380 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
19381 diff1 = *(src2 + 3) & 0x7; |
|
19382 diff2 = *(src2 + 4) & 0x3; |
|
19383 diff3 = *(src2 + 5) & 0x7; |
|
19384 //diffuse the error |
|
19385 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
19386 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
19387 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
19388 |
|
19389 src2 += 6; |
|
19390 dest2 += 2; |
|
19391 } |
|
19392 if(extraCol) |
|
19393 { |
|
19394 *dest1 = dest1[-1]; |
|
19395 dest1++; |
|
19396 *dest2 = dest2[-1]; |
|
19397 dest2++; |
|
19398 } |
|
19399 |
|
19400 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
19401 |
|
19402 dest1 += ((wndWidth << 1) - lTempWidth); |
|
19403 dest2 += ((wndWidth << 1) - lTempWidth); |
|
19404 } |
|
19405 |
|
19406 if(extraRow) |
|
19407 { |
|
19408 dest2 = dest1 - wndWidth; |
|
19409 for(j = 0; j < lWidth; j += 2) |
|
19410 { |
|
19411 *dest1++ = *dest2++; |
|
19412 *dest1++ = *dest2++; |
|
19413 } |
|
19414 if(extraCol) |
|
19415 { |
|
19416 *dest1 = *dest2; |
|
19417 } |
|
19418 } |
|
19419 |
|
19420 free(lBuffer); |
|
19421 return; |
|
19422 } |
|
19423 |
|
19424 /* |
|
19425 ****************************************************************************** |
|
19426 Name : sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_601_5_RR |
|
19427 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
19428 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
19429 uint8 *dstImage : Pointer to rgb data (o/p). |
|
19430 tWndParam *srcWindow : Pointer to structure containing source window |
|
19431 parameters like xOffset,yOffset,cropWidth, |
|
19432 cropHeight. (i/p) |
|
19433 tWndParam *dstWindow : Pointer to structure containing destination window |
|
19434 parameters like xOffset,yOffset,windWidth, |
|
19435 windHeight. (i/p) |
|
19436 Return Value : void |
|
19437 ****************************************************************************** |
|
19438 */ |
|
19439 |
|
19440 void sEmz_VDec_YUV422LEChr2toColor64k_ErrDiff_601_5_RR |
|
19441 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
19442 tWndParam* srcWindow, tWndParam* dstWindow) |
|
19443 { |
|
19444 uint16 *dest1, *dest2; |
|
19445 uint8 *lYuyvPtr; |
|
19446 uint8 *lBuffer; |
|
19447 uint8 *src1, *src2; |
|
19448 uint8 *lPtr1, *lPtr2; |
|
19449 int32 diff1, diff2, diff3; |
|
19450 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
19451 int32 lY1, lCr, lCb; |
|
19452 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
19453 int32 i, j, k, extraCol, extraRow; |
|
19454 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
19455 cropWidth,cropHeight,wndWidth,wndHeight; |
|
19456 |
|
19457 srcXOffset = srcWindow->xOffset; |
|
19458 srcYOffset = srcWindow->yOffset; |
|
19459 cropWidth = srcWindow->wndWidth; |
|
19460 cropHeight = srcWindow->wndHeight; |
|
19461 |
|
19462 dstXOffset = dstWindow->xOffset; |
|
19463 dstYOffset = dstWindow->yOffset; |
|
19464 wndWidth = dstWindow->wndWidth; |
|
19465 wndHeight = dstWindow->wndHeight; |
|
19466 |
|
19467 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
19468 { |
|
19469 lWidth = cropWidth; |
|
19470 } |
|
19471 else |
|
19472 { |
|
19473 lWidth = srcImage->width - srcXOffset; |
|
19474 } |
|
19475 |
|
19476 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
19477 { |
|
19478 lHeight = cropHeight; |
|
19479 } |
|
19480 else |
|
19481 { |
|
19482 lHeight = srcImage->height - srcYOffset; |
|
19483 } |
|
19484 |
|
19485 if (lWidth > (wndWidth - dstXOffset)) |
|
19486 { |
|
19487 lWidth = wndWidth - dstXOffset; |
|
19488 } |
|
19489 |
|
19490 if (lHeight > (wndHeight - dstYOffset)) |
|
19491 { |
|
19492 lHeight = wndHeight - dstYOffset; |
|
19493 } |
|
19494 |
|
19495 extraCol = lWidth & 0x01; |
|
19496 extraRow = lHeight & 0x01; |
|
19497 |
|
19498 lTempWidth = lWidth; |
|
19499 lWidth = (lWidth >> 1) << 1; |
|
19500 lHeight = (lHeight >> 1) << 1; |
|
19501 |
|
19502 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
19503 |
|
19504 lSrcWidth = lWidth * 3; |
|
19505 |
|
19506 lLumWidth = (srcImage->width >> 1) << 1; |
|
19507 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
19508 |
|
19509 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
19510 dest2 = dest1 + wndWidth; |
|
19511 |
|
19512 lLumWidth <<= 1; |
|
19513 |
|
19514 for(i = 0; i < lHeight; i += 2) |
|
19515 { |
|
19516 lPtr1 = src1 = lBuffer; |
|
19517 lPtr2 = src2 = src1 + lSrcWidth; |
|
19518 |
|
19519 for(k = 0; k < lWidth; k += 2) |
|
19520 { |
|
19521 lCb = lYuyvPtr[3]; |
|
19522 lCr = lYuyvPtr[1]; |
|
19523 |
|
19524 lCb -= 128; |
|
19525 lCr -= 128; |
|
19526 |
|
19527 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
19528 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
19529 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
19530 |
|
19531 /*First Pixel*/ |
|
19532 lY1 = lYuyvPtr[2]; |
|
19533 lY1 -= 16; |
|
19534 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19535 |
|
19536 lTemp = lY1 + lTemp1; |
|
19537 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19538 |
|
19539 lTemp = lY1 - lTemp2; |
|
19540 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19541 |
|
19542 lTemp = lY1 + lTemp3; |
|
19543 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19544 |
|
19545 /*Second Pixel*/ |
|
19546 lY1 = lYuyvPtr[0]; |
|
19547 lY1 -= 16; |
|
19548 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19549 |
|
19550 lTemp = lY1 + lTemp1; |
|
19551 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19552 |
|
19553 lTemp = lY1 - lTemp2; |
|
19554 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19555 |
|
19556 lTemp = lY1 + lTemp3; |
|
19557 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19558 |
|
19559 lCb = lYuyvPtr[lLumWidth + 3]; |
|
19560 lCr = lYuyvPtr[lLumWidth + 1]; |
|
19561 |
|
19562 lCb -= 128; |
|
19563 lCr -= 128; |
|
19564 |
|
19565 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
19566 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
19567 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
19568 |
|
19569 /*Third Pixel*/ |
|
19570 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
19571 lY1 -= 16; |
|
19572 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19573 |
|
19574 lTemp = lY1 + lTemp1; |
|
19575 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19576 |
|
19577 lTemp = lY1 - lTemp2; |
|
19578 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19579 |
|
19580 lTemp = lY1 + lTemp3; |
|
19581 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19582 |
|
19583 /*Fourth Pixel*/ |
|
19584 lY1 = lYuyvPtr[lLumWidth]; |
|
19585 lY1 -= 16; |
|
19586 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19587 |
|
19588 lTemp = lY1 + lTemp1; |
|
19589 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19590 |
|
19591 lTemp = lY1 - lTemp2; |
|
19592 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19593 |
|
19594 lTemp = lY1 + lTemp3; |
|
19595 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19596 |
|
19597 lCb = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
19598 lCr = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
19599 |
|
19600 lCb -= 128; |
|
19601 lCr -= 128; |
|
19602 |
|
19603 lTemp1 = (26748 * lCr) >> COLOR_CONV_PRECISION; |
|
19604 lTemp2 = ((6563 * lCb) + (13621 * lCr)) >> COLOR_CONV_PRECISION; |
|
19605 lTemp3 = (33802 * lCb) >> COLOR_CONV_PRECISION; |
|
19606 |
|
19607 /*Fifth Pixel*/ |
|
19608 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
19609 lY1 -= 16; |
|
19610 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19611 |
|
19612 lTemp = lY1 + lTemp1; |
|
19613 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19614 |
|
19615 lTemp = lY1 - lTemp2; |
|
19616 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19617 |
|
19618 lTemp = lY1 + lTemp3; |
|
19619 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19620 |
|
19621 /*Sixth Pixel*/ |
|
19622 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
19623 lY1 -= 16; |
|
19624 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
19625 |
|
19626 lTemp = lY1 + lTemp1; |
|
19627 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19628 |
|
19629 lTemp = lY1 - lTemp2; |
|
19630 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19631 |
|
19632 lTemp = lY1 + lTemp3; |
|
19633 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
19634 |
|
19635 lYuyvPtr += 4; |
|
19636 src1 += 6; |
|
19637 src2 += 6; |
|
19638 } |
|
19639 |
|
19640 src1 = lPtr1; |
|
19641 src2 = lPtr2; |
|
19642 |
|
19643 for(j = 0; j < lWidth; j += 2) |
|
19644 { |
|
19645 /* First Pixel */ |
|
19646 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
19647 diff1 = *src1 & 0x7; |
|
19648 diff2 = *(src1 + 1) & 0x3; |
|
19649 diff3 = *(src1 + 2) & 0x7; |
|
19650 |
|
19651 // diffuse the error |
|
19652 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
19653 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
19654 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
19655 |
|
19656 /* Second Pixel */ |
|
19657 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
19658 diff1 = *(src1 + 3) & 0x7; |
|
19659 diff2 = *(src1 + 4) & 0x3; |
|
19660 diff3 = *(src1 + 5) & 0x7; |
|
19661 // diffuse the error |
|
19662 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
19663 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
19664 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
19665 |
|
19666 src1 += 6; |
|
19667 dest1 += 2; |
|
19668 |
|
19669 /* Third Pixel */ |
|
19670 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
19671 diff1 = *src2 & 0x7; |
|
19672 diff2 = *(src2 + 1) & 0x3; |
|
19673 diff3 = *(src2 + 2) & 0x7; |
|
19674 //diffuse the error |
|
19675 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
19676 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
19677 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
19678 |
|
19679 /* Fourth Pixel */ |
|
19680 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
19681 diff1 = *(src2 + 3) & 0x7; |
|
19682 diff2 = *(src2 + 4) & 0x3; |
|
19683 diff3 = *(src2 + 5) & 0x7; |
|
19684 //diffuse the error |
|
19685 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
19686 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
19687 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
19688 |
|
19689 src2 += 6; |
|
19690 dest2 += 2; |
|
19691 } |
|
19692 if(extraCol) |
|
19693 { |
|
19694 *dest1 = dest1[-1]; |
|
19695 dest1++; |
|
19696 *dest2 = dest2[-1]; |
|
19697 dest2++; |
|
19698 } |
|
19699 |
|
19700 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
19701 |
|
19702 dest1 += ((wndWidth << 1) - lTempWidth); |
|
19703 dest2 += ((wndWidth << 1) - lTempWidth); |
|
19704 } |
|
19705 |
|
19706 if(extraRow) |
|
19707 { |
|
19708 dest2 = dest1 - wndWidth; |
|
19709 for(j = 0; j < lWidth; j += 2) |
|
19710 { |
|
19711 *dest1++ = *dest2++; |
|
19712 *dest1++ = *dest2++; |
|
19713 } |
|
19714 if(extraCol) |
|
19715 { |
|
19716 *dest1 = *dest2; |
|
19717 } |
|
19718 } |
|
19719 |
|
19720 free(lBuffer); |
|
19721 return; |
|
19722 } |
|
19723 |
|
19724 |
|
19725 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
19726 /**************** End of Chroma2 format *********************/ |
|
19727 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
19728 |
|
19729 |
|
19730 |
|
19731 |
|
19732 |
|
19733 |
|
19734 |
|
19735 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
19736 /**************** Start of Chroma1 format *******************/ |
|
19737 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
19738 |
|
19739 |
|
19740 /* |
|
19741 ****************************************************************************** |
|
19742 Name : sEmz_VDec_YUV420Chr1toColor64k_Ordered_709_FR |
|
19743 Description : Converts YUV420 Chroma1 Planar to RGB565 Interleaved format |
|
19744 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
19745 uint8 *dstImage : Pointer to rgb data (o/p). |
|
19746 tWndParam *srcWindow : Pointer to structure containing source window |
|
19747 parameters like xOffset,yOffset,cropWidth, |
|
19748 cropHeight. (i/p) |
|
19749 tWndParam *dstWindow : Pointer to structure containing destination window |
|
19750 parameters like xOffset,yOffset,windWidth, |
|
19751 windHeight. (i/p) |
|
19752 Return Value : void |
|
19753 ****************************************************************************** |
|
19754 */ |
|
19755 |
|
19756 void sEmz_VDec_YUV420Chr1toColor64k_Ordered_709_FR |
|
19757 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
19758 tWndParam* srcWindow, tWndParam* dstWindow) |
|
19759 { |
|
19760 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
19761 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
19762 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
19763 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
19764 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
19765 int32 i, j, extraRow, extraCol; |
|
19766 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
19767 cropWidth,cropHeight,wndWidth,wndHeight; |
|
19768 |
|
19769 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
19770 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
19771 |
|
19772 | {0,3,2} {4,0,6} | |
|
19773 | {6,1,4} {2,2,0} | */ |
|
19774 |
|
19775 srcXOffset = srcWindow->xOffset; |
|
19776 srcYOffset = srcWindow->yOffset; |
|
19777 cropWidth = srcWindow->wndWidth; |
|
19778 cropHeight = srcWindow->wndHeight; |
|
19779 |
|
19780 dstXOffset = dstWindow->xOffset; |
|
19781 dstYOffset = dstWindow->yOffset; |
|
19782 wndWidth = dstWindow->wndWidth; |
|
19783 wndHeight = dstWindow->wndHeight; |
|
19784 |
|
19785 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
19786 { |
|
19787 lWidth = cropWidth; |
|
19788 } |
|
19789 else |
|
19790 { |
|
19791 lWidth = srcImage->width - srcXOffset; |
|
19792 } |
|
19793 |
|
19794 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
19795 { |
|
19796 lHeight = cropHeight; |
|
19797 } |
|
19798 else |
|
19799 { |
|
19800 lHeight = srcImage->height - srcYOffset; |
|
19801 } |
|
19802 |
|
19803 if (lWidth > (wndWidth - dstXOffset)) |
|
19804 { |
|
19805 lWidth = wndWidth - dstXOffset; |
|
19806 } |
|
19807 |
|
19808 if (lHeight > (wndHeight - dstYOffset)) |
|
19809 { |
|
19810 lHeight = wndHeight - dstYOffset; |
|
19811 } |
|
19812 |
|
19813 extraCol = lWidth & 0x01; |
|
19814 extraRow = lHeight & 0x01; |
|
19815 |
|
19816 lTempWidth = lWidth; |
|
19817 lWidth = (lWidth >> 1) << 1; |
|
19818 lHeight = (lHeight >> 1) << 1; |
|
19819 |
|
19820 lLumWidth = (srcImage->width >> 1) << 1; |
|
19821 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
19822 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
19823 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
19824 |
|
19825 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
19826 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
19827 |
|
19828 for(i = 0; i < lHeight; i += 2) |
|
19829 { |
|
19830 for(j = 0; j < (lWidth - 2); j += 2) |
|
19831 { |
|
19832 lCr1 = lCrPtr[j >> 1]; |
|
19833 lCb1 = lCbPtr[j >> 1]; |
|
19834 |
|
19835 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
19836 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
19837 |
|
19838 lCr2 = (lCr1 + lCr2) >> 1; |
|
19839 lCb2 = (lCb1 + lCb2) >> 1; |
|
19840 |
|
19841 lCr1 -= 128; |
|
19842 lCb1 -= 128; |
|
19843 |
|
19844 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
19845 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
19846 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
19847 |
|
19848 /*First Pixel*/ |
|
19849 lY1 = lLumPtr[j]; |
|
19850 |
|
19851 /*B component*/ |
|
19852 lTemp = lY1 + lTemp3; |
|
19853 if (lTemp < 0) |
|
19854 lTemp = 0; |
|
19855 if (lTemp > 255) |
|
19856 lTemp = 255; |
|
19857 lTemp4 = (lTemp >> 3); |
|
19858 |
|
19859 /*G component*/ |
|
19860 lTemp = lY1 - lTemp2 + 3; |
|
19861 if (lTemp < 0) |
|
19862 lTemp = 0; |
|
19863 if (lTemp > 255) |
|
19864 lTemp = 255; |
|
19865 lTemp4 |= (lTemp >> 2) << 5; |
|
19866 |
|
19867 /*R component*/ |
|
19868 lTemp = lY1 + lTemp1 + 2; |
|
19869 if (lTemp < 0) |
|
19870 lTemp = 0; |
|
19871 if (lTemp > 255) |
|
19872 lTemp = 255; |
|
19873 lTemp4 |= (lTemp >> 3) << 11; |
|
19874 |
|
19875 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
19876 |
|
19877 /*Third Pixel*/ |
|
19878 lY1 = lLumPtr[j + lLumWidth]; |
|
19879 |
|
19880 /*B component*/ |
|
19881 lTemp = lY1 + lTemp3 + 6; |
|
19882 if (lTemp < 0) |
|
19883 lTemp = 0; |
|
19884 if (lTemp > 255) |
|
19885 lTemp = 255; |
|
19886 lTemp4 = (lTemp >> 3); |
|
19887 |
|
19888 /*G component*/ |
|
19889 lTemp = lY1 - lTemp2 + 1; |
|
19890 if (lTemp < 0) |
|
19891 lTemp = 0; |
|
19892 if (lTemp > 255) |
|
19893 lTemp = 255; |
|
19894 lTemp4 |= (lTemp >> 2) << 5; |
|
19895 |
|
19896 /*R component*/ |
|
19897 lTemp = lY1 + lTemp1 + 4; |
|
19898 if (lTemp < 0) |
|
19899 lTemp = 0; |
|
19900 if (lTemp > 255) |
|
19901 lTemp = 255; |
|
19902 lTemp4 |= (lTemp >> 3) << 11; |
|
19903 |
|
19904 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
19905 |
|
19906 |
|
19907 lCr2 -= 128; |
|
19908 lCb2 -= 128; |
|
19909 |
|
19910 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
19911 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
19912 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
19913 |
|
19914 /*Second Pixel*/ |
|
19915 lY1 = lLumPtr[j + 1]; |
|
19916 |
|
19917 /*B component*/ |
|
19918 lTemp = lY1 + lTemp3 + 4; |
|
19919 if (lTemp < 0) |
|
19920 lTemp = 0; |
|
19921 if (lTemp > 255) |
|
19922 lTemp = 255; |
|
19923 lTemp4 = (lTemp >> 3); |
|
19924 |
|
19925 /*G component*/ |
|
19926 lTemp = lY1 - lTemp2; |
|
19927 if (lTemp < 0) |
|
19928 lTemp = 0; |
|
19929 if (lTemp > 255) |
|
19930 lTemp = 255; |
|
19931 lTemp4 |= (lTemp >> 2) << 5; |
|
19932 |
|
19933 /*R component*/ |
|
19934 lTemp = lY1 + lTemp1 + 6; |
|
19935 if (lTemp < 0) |
|
19936 lTemp = 0; |
|
19937 if (lTemp > 255) |
|
19938 lTemp = 255; |
|
19939 lTemp4 |= (lTemp >> 3) << 11; |
|
19940 |
|
19941 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
19942 |
|
19943 |
|
19944 /*Fourth Pixel*/ |
|
19945 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
19946 |
|
19947 /*B component*/ |
|
19948 lTemp = lY1 + lTemp3 + 2; |
|
19949 if (lTemp < 0) |
|
19950 lTemp = 0; |
|
19951 if (lTemp > 255) |
|
19952 lTemp = 255; |
|
19953 lTemp4 = (lTemp >> 3); |
|
19954 |
|
19955 /*G component*/ |
|
19956 lTemp = lY1 - lTemp2 + 2; |
|
19957 if (lTemp < 0) |
|
19958 lTemp = 0; |
|
19959 if (lTemp > 255) |
|
19960 lTemp = 255; |
|
19961 lTemp4 |= (lTemp >> 2) << 5; |
|
19962 |
|
19963 /*R component*/ |
|
19964 lTemp = lY1 + lTemp1; |
|
19965 if (lTemp < 0) |
|
19966 lTemp = 0; |
|
19967 if (lTemp > 255) |
|
19968 lTemp = 255; |
|
19969 lTemp4 |= (lTemp >> 3) << 11; |
|
19970 |
|
19971 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
19972 |
|
19973 lRGBFramePtr += 2; |
|
19974 lRGBFramePtr1 += 2; |
|
19975 } |
|
19976 |
|
19977 lCr1 = lCrPtr[j >> 1]; |
|
19978 lCb1 = lCbPtr[j >> 1]; |
|
19979 |
|
19980 lCr1 -= 128; |
|
19981 lCb1 -= 128; |
|
19982 |
|
19983 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
19984 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
19985 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
19986 |
|
19987 /*First Pixel*/ |
|
19988 lY1 = lLumPtr[j]; |
|
19989 |
|
19990 /*B component*/ |
|
19991 lTemp = lY1 + lTemp3; |
|
19992 if (lTemp < 0) |
|
19993 lTemp = 0; |
|
19994 if (lTemp > 255) |
|
19995 lTemp = 255; |
|
19996 lTemp4 = (lTemp >> 3); |
|
19997 |
|
19998 /*G component*/ |
|
19999 lTemp = lY1 - lTemp2 + 3; |
|
20000 if (lTemp < 0) |
|
20001 lTemp = 0; |
|
20002 if (lTemp > 255) |
|
20003 lTemp = 255; |
|
20004 lTemp4 |= (lTemp >> 2) << 5; |
|
20005 |
|
20006 /*R component*/ |
|
20007 lTemp = lY1 + lTemp1 + 2; |
|
20008 if (lTemp < 0) |
|
20009 lTemp = 0; |
|
20010 if (lTemp > 255) |
|
20011 lTemp = 255; |
|
20012 lTemp4 |= (lTemp >> 3) << 11; |
|
20013 |
|
20014 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
20015 |
|
20016 /*Third Pixel*/ |
|
20017 lY1 = lLumPtr[j + lLumWidth]; |
|
20018 |
|
20019 /*B component*/ |
|
20020 lTemp = lY1 + lTemp3 + 6; |
|
20021 if (lTemp < 0) |
|
20022 lTemp = 0; |
|
20023 if (lTemp > 255) |
|
20024 lTemp = 255; |
|
20025 lTemp4 = (lTemp >> 3); |
|
20026 |
|
20027 /*G component*/ |
|
20028 lTemp = lY1 - lTemp2 + 1; |
|
20029 if (lTemp < 0) |
|
20030 lTemp = 0; |
|
20031 if (lTemp > 255) |
|
20032 lTemp = 255; |
|
20033 lTemp4 |= (lTemp >> 2) << 5; |
|
20034 |
|
20035 /*R component*/ |
|
20036 lTemp = lY1 + lTemp1 + 4; |
|
20037 if (lTemp < 0) |
|
20038 lTemp = 0; |
|
20039 if (lTemp > 255) |
|
20040 lTemp = 255; |
|
20041 lTemp4 |= (lTemp >> 3) << 11; |
|
20042 |
|
20043 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
20044 |
|
20045 |
|
20046 /*Second Pixel*/ |
|
20047 lY1 = lLumPtr[j + 1]; |
|
20048 |
|
20049 /*B component*/ |
|
20050 lTemp = lY1 + lTemp3 + 4; |
|
20051 if (lTemp < 0) |
|
20052 lTemp = 0; |
|
20053 if (lTemp > 255) |
|
20054 lTemp = 255; |
|
20055 lTemp4 = (lTemp >> 3); |
|
20056 |
|
20057 /*G component*/ |
|
20058 lTemp = lY1 - lTemp2; |
|
20059 if (lTemp < 0) |
|
20060 lTemp = 0; |
|
20061 if (lTemp > 255) |
|
20062 lTemp = 255; |
|
20063 lTemp4 |= (lTemp >> 2) << 5; |
|
20064 |
|
20065 /*R component*/ |
|
20066 lTemp = lY1 + lTemp1 + 6; |
|
20067 if (lTemp < 0) |
|
20068 lTemp = 0; |
|
20069 if (lTemp > 255) |
|
20070 lTemp = 255; |
|
20071 lTemp4 |= (lTemp >> 3) << 11; |
|
20072 |
|
20073 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
20074 |
|
20075 |
|
20076 /*Fourth Pixel*/ |
|
20077 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
20078 |
|
20079 /*B component*/ |
|
20080 lTemp = lY1 + lTemp3 + 2; |
|
20081 if (lTemp < 0) |
|
20082 lTemp = 0; |
|
20083 if (lTemp > 255) |
|
20084 lTemp = 255; |
|
20085 lTemp4 = (lTemp >> 3); |
|
20086 |
|
20087 /*G component*/ |
|
20088 lTemp = lY1 - lTemp2 + 2; |
|
20089 if (lTemp < 0) |
|
20090 lTemp = 0; |
|
20091 if (lTemp > 255) |
|
20092 lTemp = 255; |
|
20093 lTemp4 |= (lTemp >> 2) << 5; |
|
20094 |
|
20095 /*R component*/ |
|
20096 lTemp = lY1 + lTemp1; |
|
20097 if (lTemp < 0) |
|
20098 lTemp = 0; |
|
20099 if (lTemp > 255) |
|
20100 lTemp = 255; |
|
20101 lTemp4 |= (lTemp >> 3) << 11; |
|
20102 |
|
20103 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
20104 |
|
20105 lRGBFramePtr += 2; |
|
20106 lRGBFramePtr1 += 2; |
|
20107 |
|
20108 |
|
20109 if(extraCol) |
|
20110 { |
|
20111 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
20112 lRGBFramePtr++; |
|
20113 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
20114 lRGBFramePtr1++; |
|
20115 } |
|
20116 |
|
20117 lLumPtr += (lLumWidth << 1); |
|
20118 lCrPtr += (lLumWidth >> 1); |
|
20119 lCbPtr += (lLumWidth >> 1); |
|
20120 |
|
20121 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
20122 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
20123 } |
|
20124 |
|
20125 if(extraRow) |
|
20126 { |
|
20127 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
20128 for(j = 0; j < lWidth; j += 2) |
|
20129 { |
|
20130 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
20131 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
20132 } |
|
20133 if(extraCol) |
|
20134 { |
|
20135 *lRGBFramePtr = *lRGBFramePtr1; |
|
20136 } |
|
20137 } |
|
20138 return; |
|
20139 } |
|
20140 |
|
20141 /* |
|
20142 ****************************************************************************** |
|
20143 Name : sEmz_VDec_YUV420Chr1toColor64k_Ordered_601_5_FR |
|
20144 Description : Converts YUV420 Chroma1 Planar to RGB565 Interleaved format |
|
20145 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
20146 uint8 *dstImage : Pointer to rgb data (o/p). |
|
20147 tWndParam *srcWindow : Pointer to structure containing source window |
|
20148 parameters like xOffset,yOffset,cropWidth, |
|
20149 cropHeight. (i/p) |
|
20150 tWndParam *dstWindow : Pointer to structure containing destination window |
|
20151 parameters like xOffset,yOffset,windWidth, |
|
20152 windHeight. (i/p) |
|
20153 Return Value : void |
|
20154 ****************************************************************************** |
|
20155 */ |
|
20156 |
|
20157 void sEmz_VDec_YUV420Chr1toColor64k_Ordered_601_5_FR |
|
20158 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
20159 tWndParam* srcWindow, tWndParam* dstWindow) |
|
20160 { |
|
20161 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
20162 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
20163 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
20164 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
20165 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
20166 int32 i, j, extraRow, extraCol; |
|
20167 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
20168 cropWidth,cropHeight,wndWidth,wndHeight; |
|
20169 |
|
20170 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
20171 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
20172 |
|
20173 | {0,3,2} {4,0,6} | |
|
20174 | {6,1,4} {2,2,0} | */ |
|
20175 |
|
20176 srcXOffset = srcWindow->xOffset; |
|
20177 srcYOffset = srcWindow->yOffset; |
|
20178 cropWidth = srcWindow->wndWidth; |
|
20179 cropHeight = srcWindow->wndHeight; |
|
20180 |
|
20181 dstXOffset = dstWindow->xOffset; |
|
20182 dstYOffset = dstWindow->yOffset; |
|
20183 wndWidth = dstWindow->wndWidth; |
|
20184 wndHeight = dstWindow->wndHeight; |
|
20185 |
|
20186 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
20187 { |
|
20188 lWidth = cropWidth; |
|
20189 } |
|
20190 else |
|
20191 { |
|
20192 lWidth = srcImage->width - srcXOffset; |
|
20193 } |
|
20194 |
|
20195 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
20196 { |
|
20197 lHeight = cropHeight; |
|
20198 } |
|
20199 else |
|
20200 { |
|
20201 lHeight = srcImage->height - srcYOffset; |
|
20202 } |
|
20203 |
|
20204 if (lWidth > (wndWidth - dstXOffset)) |
|
20205 { |
|
20206 lWidth = wndWidth - dstXOffset; |
|
20207 } |
|
20208 |
|
20209 if (lHeight > (wndHeight - dstYOffset)) |
|
20210 { |
|
20211 lHeight = wndHeight - dstYOffset; |
|
20212 } |
|
20213 |
|
20214 extraCol = lWidth & 0x01; |
|
20215 extraRow = lHeight & 0x01; |
|
20216 |
|
20217 lTempWidth = lWidth; |
|
20218 lWidth = (lWidth >> 1) << 1; |
|
20219 lHeight = (lHeight >> 1) << 1; |
|
20220 |
|
20221 lLumWidth = (srcImage->width >> 1) << 1; |
|
20222 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
20223 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
20224 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
20225 |
|
20226 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
20227 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
20228 |
|
20229 for(i = 0; i < lHeight; i += 2) |
|
20230 { |
|
20231 for(j = 0; j < (lWidth - 2); j += 2) |
|
20232 { |
|
20233 lCr1 = lCrPtr[j >> 1]; |
|
20234 lCb1 = lCbPtr[j >> 1]; |
|
20235 |
|
20236 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
20237 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
20238 |
|
20239 lCr2 = (lCr1 + lCr2) >> 1; |
|
20240 lCb2 = (lCb1 + lCb2) >> 1; |
|
20241 |
|
20242 lCr1 -= 128; |
|
20243 lCb1 -= 128; |
|
20244 |
|
20245 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
20246 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
20247 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
20248 |
|
20249 /*First Pixel*/ |
|
20250 lY1 = lLumPtr[j]; |
|
20251 |
|
20252 /*B component*/ |
|
20253 lTemp = lY1 + lTemp3; |
|
20254 if (lTemp < 0) |
|
20255 lTemp = 0; |
|
20256 if (lTemp > 255) |
|
20257 lTemp = 255; |
|
20258 lTemp4 = (lTemp >> 3); |
|
20259 |
|
20260 /*G component*/ |
|
20261 lTemp = lY1 - lTemp2 + 3; |
|
20262 if (lTemp < 0) |
|
20263 lTemp = 0; |
|
20264 if (lTemp > 255) |
|
20265 lTemp = 255; |
|
20266 lTemp4 |= (lTemp >> 2) << 5; |
|
20267 |
|
20268 /*R component*/ |
|
20269 lTemp = lY1 + lTemp1 + 2; |
|
20270 if (lTemp < 0) |
|
20271 lTemp = 0; |
|
20272 if (lTemp > 255) |
|
20273 lTemp = 255; |
|
20274 lTemp4 |= (lTemp >> 3) << 11; |
|
20275 |
|
20276 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
20277 |
|
20278 /*Third Pixel*/ |
|
20279 lY1 = lLumPtr[j + lLumWidth]; |
|
20280 |
|
20281 /*B component*/ |
|
20282 lTemp = lY1 + lTemp3 + 6; |
|
20283 if (lTemp < 0) |
|
20284 lTemp = 0; |
|
20285 if (lTemp > 255) |
|
20286 lTemp = 255; |
|
20287 lTemp4 = (lTemp >> 3); |
|
20288 |
|
20289 /*G component*/ |
|
20290 lTemp = lY1 - lTemp2 + 1; |
|
20291 if (lTemp < 0) |
|
20292 lTemp = 0; |
|
20293 if (lTemp > 255) |
|
20294 lTemp = 255; |
|
20295 lTemp4 |= (lTemp >> 2) << 5; |
|
20296 |
|
20297 /*R component*/ |
|
20298 lTemp = lY1 + lTemp1 + 4; |
|
20299 if (lTemp < 0) |
|
20300 lTemp = 0; |
|
20301 if (lTemp > 255) |
|
20302 lTemp = 255; |
|
20303 lTemp4 |= (lTemp >> 3) << 11; |
|
20304 |
|
20305 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
20306 |
|
20307 |
|
20308 lCr2 -= 128; |
|
20309 lCb2 -= 128; |
|
20310 |
|
20311 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
20312 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
20313 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
20314 |
|
20315 /*Second Pixel*/ |
|
20316 lY1 = lLumPtr[j + 1]; |
|
20317 |
|
20318 /*B component*/ |
|
20319 lTemp = lY1 + lTemp3 + 4; |
|
20320 if (lTemp < 0) |
|
20321 lTemp = 0; |
|
20322 if (lTemp > 255) |
|
20323 lTemp = 255; |
|
20324 lTemp4 = (lTemp >> 3); |
|
20325 |
|
20326 /*G component*/ |
|
20327 lTemp = lY1 - lTemp2; |
|
20328 if (lTemp < 0) |
|
20329 lTemp = 0; |
|
20330 if (lTemp > 255) |
|
20331 lTemp = 255; |
|
20332 lTemp4 |= (lTemp >> 2) << 5; |
|
20333 |
|
20334 /*R component*/ |
|
20335 lTemp = lY1 + lTemp1 + 6; |
|
20336 if (lTemp < 0) |
|
20337 lTemp = 0; |
|
20338 if (lTemp > 255) |
|
20339 lTemp = 255; |
|
20340 lTemp4 |= (lTemp >> 3) << 11; |
|
20341 |
|
20342 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
20343 |
|
20344 |
|
20345 /*Fourth Pixel*/ |
|
20346 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
20347 |
|
20348 /*B component*/ |
|
20349 lTemp = lY1 + lTemp3 + 2; |
|
20350 if (lTemp < 0) |
|
20351 lTemp = 0; |
|
20352 if (lTemp > 255) |
|
20353 lTemp = 255; |
|
20354 lTemp4 = (lTemp >> 3); |
|
20355 |
|
20356 /*G component*/ |
|
20357 lTemp = lY1 - lTemp2 + 2; |
|
20358 if (lTemp < 0) |
|
20359 lTemp = 0; |
|
20360 if (lTemp > 255) |
|
20361 lTemp = 255; |
|
20362 lTemp4 |= (lTemp >> 2) << 5; |
|
20363 |
|
20364 /*R component*/ |
|
20365 lTemp = lY1 + lTemp1; |
|
20366 if (lTemp < 0) |
|
20367 lTemp = 0; |
|
20368 if (lTemp > 255) |
|
20369 lTemp = 255; |
|
20370 lTemp4 |= (lTemp >> 3) << 11; |
|
20371 |
|
20372 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
20373 |
|
20374 lRGBFramePtr += 2; |
|
20375 lRGBFramePtr1 += 2; |
|
20376 } |
|
20377 |
|
20378 lCr1 = lCrPtr[j >> 1]; |
|
20379 lCb1 = lCbPtr[j >> 1]; |
|
20380 |
|
20381 lCr1 -= 128; |
|
20382 lCb1 -= 128; |
|
20383 |
|
20384 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
20385 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
20386 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
20387 |
|
20388 /*First Pixel*/ |
|
20389 lY1 = lLumPtr[j]; |
|
20390 |
|
20391 /*B component*/ |
|
20392 lTemp = lY1 + lTemp3; |
|
20393 if (lTemp < 0) |
|
20394 lTemp = 0; |
|
20395 if (lTemp > 255) |
|
20396 lTemp = 255; |
|
20397 lTemp4 = (lTemp >> 3); |
|
20398 |
|
20399 /*G component*/ |
|
20400 lTemp = lY1 - lTemp2 + 3; |
|
20401 if (lTemp < 0) |
|
20402 lTemp = 0; |
|
20403 if (lTemp > 255) |
|
20404 lTemp = 255; |
|
20405 lTemp4 |= (lTemp >> 2) << 5; |
|
20406 |
|
20407 /*R component*/ |
|
20408 lTemp = lY1 + lTemp1 + 2; |
|
20409 if (lTemp < 0) |
|
20410 lTemp = 0; |
|
20411 if (lTemp > 255) |
|
20412 lTemp = 255; |
|
20413 lTemp4 |= (lTemp >> 3) << 11; |
|
20414 |
|
20415 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
20416 |
|
20417 /*Third Pixel*/ |
|
20418 lY1 = lLumPtr[j + lLumWidth]; |
|
20419 |
|
20420 /*B component*/ |
|
20421 lTemp = lY1 + lTemp3 + 6; |
|
20422 if (lTemp < 0) |
|
20423 lTemp = 0; |
|
20424 if (lTemp > 255) |
|
20425 lTemp = 255; |
|
20426 lTemp4 = (lTemp >> 3); |
|
20427 |
|
20428 /*G component*/ |
|
20429 lTemp = lY1 - lTemp2 + 1; |
|
20430 if (lTemp < 0) |
|
20431 lTemp = 0; |
|
20432 if (lTemp > 255) |
|
20433 lTemp = 255; |
|
20434 lTemp4 |= (lTemp >> 2) << 5; |
|
20435 |
|
20436 /*R component*/ |
|
20437 lTemp = lY1 + lTemp1 + 4; |
|
20438 if (lTemp < 0) |
|
20439 lTemp = 0; |
|
20440 if (lTemp > 255) |
|
20441 lTemp = 255; |
|
20442 lTemp4 |= (lTemp >> 3) << 11; |
|
20443 |
|
20444 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
20445 |
|
20446 |
|
20447 /*Second Pixel*/ |
|
20448 lY1 = lLumPtr[j + 1]; |
|
20449 |
|
20450 /*B component*/ |
|
20451 lTemp = lY1 + lTemp3 + 4; |
|
20452 if (lTemp < 0) |
|
20453 lTemp = 0; |
|
20454 if (lTemp > 255) |
|
20455 lTemp = 255; |
|
20456 lTemp4 = (lTemp >> 3); |
|
20457 |
|
20458 /*G component*/ |
|
20459 lTemp = lY1 - lTemp2; |
|
20460 if (lTemp < 0) |
|
20461 lTemp = 0; |
|
20462 if (lTemp > 255) |
|
20463 lTemp = 255; |
|
20464 lTemp4 |= (lTemp >> 2) << 5; |
|
20465 |
|
20466 /*R component*/ |
|
20467 lTemp = lY1 + lTemp1 + 6; |
|
20468 if (lTemp < 0) |
|
20469 lTemp = 0; |
|
20470 if (lTemp > 255) |
|
20471 lTemp = 255; |
|
20472 lTemp4 |= (lTemp >> 3) << 11; |
|
20473 |
|
20474 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
20475 |
|
20476 |
|
20477 /*Fourth Pixel*/ |
|
20478 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
20479 |
|
20480 /*B component*/ |
|
20481 lTemp = lY1 + lTemp3 + 2; |
|
20482 if (lTemp < 0) |
|
20483 lTemp = 0; |
|
20484 if (lTemp > 255) |
|
20485 lTemp = 255; |
|
20486 lTemp4 = (lTemp >> 3); |
|
20487 |
|
20488 /*G component*/ |
|
20489 lTemp = lY1 - lTemp2 + 2; |
|
20490 if (lTemp < 0) |
|
20491 lTemp = 0; |
|
20492 if (lTemp > 255) |
|
20493 lTemp = 255; |
|
20494 lTemp4 |= (lTemp >> 2) << 5; |
|
20495 |
|
20496 /*R component*/ |
|
20497 lTemp = lY1 + lTemp1; |
|
20498 if (lTemp < 0) |
|
20499 lTemp = 0; |
|
20500 if (lTemp > 255) |
|
20501 lTemp = 255; |
|
20502 lTemp4 |= (lTemp >> 3) << 11; |
|
20503 |
|
20504 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
20505 |
|
20506 lRGBFramePtr += 2; |
|
20507 lRGBFramePtr1 += 2; |
|
20508 |
|
20509 |
|
20510 if(extraCol) |
|
20511 { |
|
20512 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
20513 lRGBFramePtr++; |
|
20514 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
20515 lRGBFramePtr1++; |
|
20516 } |
|
20517 |
|
20518 lLumPtr += (lLumWidth << 1); |
|
20519 lCrPtr += (lLumWidth >> 1); |
|
20520 lCbPtr += (lLumWidth >> 1); |
|
20521 |
|
20522 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
20523 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
20524 } |
|
20525 |
|
20526 if(extraRow) |
|
20527 { |
|
20528 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
20529 for(j = 0; j < lWidth; j += 2) |
|
20530 { |
|
20531 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
20532 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
20533 } |
|
20534 if(extraCol) |
|
20535 { |
|
20536 *lRGBFramePtr = *lRGBFramePtr1; |
|
20537 } |
|
20538 } |
|
20539 return; |
|
20540 } |
|
20541 |
|
20542 /* |
|
20543 ****************************************************************************** |
|
20544 Name : sEmz_VDec_YUV420Chr1toColor64k_Ordered_709_RR |
|
20545 Description : Converts YUV420 Chroma1 Planar to RGB565 Interleaved format |
|
20546 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
20547 uint8 *dstImage : Pointer to rgb data (o/p). |
|
20548 tWndParam *srcWindow : Pointer to structure containing source window |
|
20549 parameters like xOffset,yOffset,cropWidth, |
|
20550 cropHeight. (i/p) |
|
20551 tWndParam *dstWindow : Pointer to structure containing destination window |
|
20552 parameters like xOffset,yOffset,windWidth, |
|
20553 windHeight. (i/p) |
|
20554 Return Value : void |
|
20555 ****************************************************************************** |
|
20556 */ |
|
20557 |
|
20558 void sEmz_VDec_YUV420Chr1toColor64k_Ordered_709_RR |
|
20559 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
20560 tWndParam* srcWindow, tWndParam* dstWindow) |
|
20561 { |
|
20562 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
20563 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
20564 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
20565 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
20566 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
20567 int32 i, j, extraRow, extraCol; |
|
20568 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
20569 cropWidth,cropHeight,wndWidth,wndHeight; |
|
20570 |
|
20571 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
20572 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
20573 |
|
20574 | {0,3,2} {4,0,6} | |
|
20575 | {6,1,4} {2,2,0} | */ |
|
20576 |
|
20577 srcXOffset = srcWindow->xOffset; |
|
20578 srcYOffset = srcWindow->yOffset; |
|
20579 cropWidth = srcWindow->wndWidth; |
|
20580 cropHeight = srcWindow->wndHeight; |
|
20581 |
|
20582 dstXOffset = dstWindow->xOffset; |
|
20583 dstYOffset = dstWindow->yOffset; |
|
20584 wndWidth = dstWindow->wndWidth; |
|
20585 wndHeight = dstWindow->wndHeight; |
|
20586 |
|
20587 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
20588 { |
|
20589 lWidth = cropWidth; |
|
20590 } |
|
20591 else |
|
20592 { |
|
20593 lWidth = srcImage->width - srcXOffset; |
|
20594 } |
|
20595 |
|
20596 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
20597 { |
|
20598 lHeight = cropHeight; |
|
20599 } |
|
20600 else |
|
20601 { |
|
20602 lHeight = srcImage->height - srcYOffset; |
|
20603 } |
|
20604 |
|
20605 if (lWidth > (wndWidth - dstXOffset)) |
|
20606 { |
|
20607 lWidth = wndWidth - dstXOffset; |
|
20608 } |
|
20609 |
|
20610 if (lHeight > (wndHeight - dstYOffset)) |
|
20611 { |
|
20612 lHeight = wndHeight - dstYOffset; |
|
20613 } |
|
20614 |
|
20615 extraCol = lWidth & 0x01; |
|
20616 extraRow = lHeight & 0x01; |
|
20617 |
|
20618 lTempWidth = lWidth; |
|
20619 lWidth = (lWidth >> 1) << 1; |
|
20620 lHeight = (lHeight >> 1) << 1; |
|
20621 |
|
20622 lLumWidth = (srcImage->width >> 1) << 1; |
|
20623 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
20624 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
20625 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
20626 |
|
20627 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
20628 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
20629 |
|
20630 for(i = 0; i < lHeight; i += 2) |
|
20631 { |
|
20632 for(j = 0; j < (lWidth - 2); j += 2) |
|
20633 { |
|
20634 lCr1 = lCrPtr[j >> 1]; |
|
20635 lCb1 = lCbPtr[j >> 1]; |
|
20636 |
|
20637 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
20638 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
20639 |
|
20640 lCr2 = (lCr1 + lCr2) >> 1; |
|
20641 lCb2 = (lCb1 + lCb2) >> 1; |
|
20642 |
|
20643 lCr1 -= 128; |
|
20644 lCb1 -= 128; |
|
20645 |
|
20646 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
20647 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
20648 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
20649 |
|
20650 /*First Pixel*/ |
|
20651 lY1 = lLumPtr[j]; |
|
20652 lY1 -= 16; |
|
20653 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
20654 |
|
20655 /*B component*/ |
|
20656 lTemp = lY1 + lTemp3; |
|
20657 if (lTemp < 0) |
|
20658 lTemp = 0; |
|
20659 if (lTemp > 255) |
|
20660 lTemp = 255; |
|
20661 lTemp4 = (lTemp >> 3); |
|
20662 |
|
20663 /*G component*/ |
|
20664 lTemp = lY1 - lTemp2 + 3; |
|
20665 if (lTemp < 0) |
|
20666 lTemp = 0; |
|
20667 if (lTemp > 255) |
|
20668 lTemp = 255; |
|
20669 lTemp4 |= (lTemp >> 2) << 5; |
|
20670 |
|
20671 /*R component*/ |
|
20672 lTemp = lY1 + lTemp1 + 2; |
|
20673 if (lTemp < 0) |
|
20674 lTemp = 0; |
|
20675 if (lTemp > 255) |
|
20676 lTemp = 255; |
|
20677 lTemp4 |= (lTemp >> 3) << 11; |
|
20678 |
|
20679 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
20680 |
|
20681 /*Third Pixel*/ |
|
20682 lY1 = lLumPtr[j + lLumWidth]; |
|
20683 lY1 -= 16; |
|
20684 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
20685 |
|
20686 /*B component*/ |
|
20687 lTemp = lY1 + lTemp3 + 6; |
|
20688 if (lTemp < 0) |
|
20689 lTemp = 0; |
|
20690 if (lTemp > 255) |
|
20691 lTemp = 255; |
|
20692 lTemp4 = (lTemp >> 3); |
|
20693 |
|
20694 /*G component*/ |
|
20695 lTemp = lY1 - lTemp2 + 1; |
|
20696 if (lTemp < 0) |
|
20697 lTemp = 0; |
|
20698 if (lTemp > 255) |
|
20699 lTemp = 255; |
|
20700 lTemp4 |= (lTemp >> 2) << 5; |
|
20701 |
|
20702 /*R component*/ |
|
20703 lTemp = lY1 + lTemp1 + 4; |
|
20704 if (lTemp < 0) |
|
20705 lTemp = 0; |
|
20706 if (lTemp > 255) |
|
20707 lTemp = 255; |
|
20708 lTemp4 |= (lTemp >> 3) << 11; |
|
20709 |
|
20710 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
20711 |
|
20712 |
|
20713 lCr2 -= 128; |
|
20714 lCb2 -= 128; |
|
20715 |
|
20716 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
20717 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
20718 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
20719 |
|
20720 /*Second Pixel*/ |
|
20721 lY1 = lLumPtr[j + 1]; |
|
20722 lY1 -= 16; |
|
20723 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
20724 |
|
20725 /*B component*/ |
|
20726 lTemp = lY1 + lTemp3 + 4; |
|
20727 if (lTemp < 0) |
|
20728 lTemp = 0; |
|
20729 if (lTemp > 255) |
|
20730 lTemp = 255; |
|
20731 lTemp4 = (lTemp >> 3); |
|
20732 |
|
20733 /*G component*/ |
|
20734 lTemp = lY1 - lTemp2; |
|
20735 if (lTemp < 0) |
|
20736 lTemp = 0; |
|
20737 if (lTemp > 255) |
|
20738 lTemp = 255; |
|
20739 lTemp4 |= (lTemp >> 2) << 5; |
|
20740 |
|
20741 /*R component*/ |
|
20742 lTemp = lY1 + lTemp1 + 6; |
|
20743 if (lTemp < 0) |
|
20744 lTemp = 0; |
|
20745 if (lTemp > 255) |
|
20746 lTemp = 255; |
|
20747 lTemp4 |= (lTemp >> 3) << 11; |
|
20748 |
|
20749 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
20750 |
|
20751 |
|
20752 /*Fourth Pixel*/ |
|
20753 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
20754 lY1 -= 16; |
|
20755 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
20756 |
|
20757 /*B component*/ |
|
20758 lTemp = lY1 + lTemp3 + 2; |
|
20759 if (lTemp < 0) |
|
20760 lTemp = 0; |
|
20761 if (lTemp > 255) |
|
20762 lTemp = 255; |
|
20763 lTemp4 = (lTemp >> 3); |
|
20764 |
|
20765 /*G component*/ |
|
20766 lTemp = lY1 - lTemp2 + 2; |
|
20767 if (lTemp < 0) |
|
20768 lTemp = 0; |
|
20769 if (lTemp > 255) |
|
20770 lTemp = 255; |
|
20771 lTemp4 |= (lTemp >> 2) << 5; |
|
20772 |
|
20773 /*R component*/ |
|
20774 lTemp = lY1 + lTemp1; |
|
20775 if (lTemp < 0) |
|
20776 lTemp = 0; |
|
20777 if (lTemp > 255) |
|
20778 lTemp = 255; |
|
20779 lTemp4 |= (lTemp >> 3) << 11; |
|
20780 |
|
20781 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
20782 |
|
20783 lRGBFramePtr += 2; |
|
20784 lRGBFramePtr1 += 2; |
|
20785 } |
|
20786 |
|
20787 lCr1 = lCrPtr[j >> 1]; |
|
20788 lCb1 = lCbPtr[j >> 1]; |
|
20789 |
|
20790 lCr1 -= 128; |
|
20791 lCb1 -= 128; |
|
20792 |
|
20793 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
20794 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
20795 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
20796 |
|
20797 /*First Pixel*/ |
|
20798 lY1 = lLumPtr[j]; |
|
20799 lY1 -= 16; |
|
20800 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
20801 |
|
20802 /*B component*/ |
|
20803 lTemp = lY1 + lTemp3; |
|
20804 if (lTemp < 0) |
|
20805 lTemp = 0; |
|
20806 if (lTemp > 255) |
|
20807 lTemp = 255; |
|
20808 lTemp4 = (lTemp >> 3); |
|
20809 |
|
20810 /*G component*/ |
|
20811 lTemp = lY1 - lTemp2 + 3; |
|
20812 if (lTemp < 0) |
|
20813 lTemp = 0; |
|
20814 if (lTemp > 255) |
|
20815 lTemp = 255; |
|
20816 lTemp4 |= (lTemp >> 2) << 5; |
|
20817 |
|
20818 /*R component*/ |
|
20819 lTemp = lY1 + lTemp1 + 2; |
|
20820 if (lTemp < 0) |
|
20821 lTemp = 0; |
|
20822 if (lTemp > 255) |
|
20823 lTemp = 255; |
|
20824 lTemp4 |= (lTemp >> 3) << 11; |
|
20825 |
|
20826 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
20827 |
|
20828 /*Third Pixel*/ |
|
20829 lY1 = lLumPtr[j + lLumWidth]; |
|
20830 lY1 -= 16; |
|
20831 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
20832 |
|
20833 /*B component*/ |
|
20834 lTemp = lY1 + lTemp3 + 6; |
|
20835 if (lTemp < 0) |
|
20836 lTemp = 0; |
|
20837 if (lTemp > 255) |
|
20838 lTemp = 255; |
|
20839 lTemp4 = (lTemp >> 3); |
|
20840 |
|
20841 /*G component*/ |
|
20842 lTemp = lY1 - lTemp2 + 1; |
|
20843 if (lTemp < 0) |
|
20844 lTemp = 0; |
|
20845 if (lTemp > 255) |
|
20846 lTemp = 255; |
|
20847 lTemp4 |= (lTemp >> 2) << 5; |
|
20848 |
|
20849 /*R component*/ |
|
20850 lTemp = lY1 + lTemp1 + 4; |
|
20851 if (lTemp < 0) |
|
20852 lTemp = 0; |
|
20853 if (lTemp > 255) |
|
20854 lTemp = 255; |
|
20855 lTemp4 |= (lTemp >> 3) << 11; |
|
20856 |
|
20857 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
20858 |
|
20859 |
|
20860 /*Second Pixel*/ |
|
20861 lY1 = lLumPtr[j + 1]; |
|
20862 lY1 -= 16; |
|
20863 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
20864 |
|
20865 /*B component*/ |
|
20866 lTemp = lY1 + lTemp3 + 4; |
|
20867 if (lTemp < 0) |
|
20868 lTemp = 0; |
|
20869 if (lTemp > 255) |
|
20870 lTemp = 255; |
|
20871 lTemp4 = (lTemp >> 3); |
|
20872 |
|
20873 /*G component*/ |
|
20874 lTemp = lY1 - lTemp2; |
|
20875 if (lTemp < 0) |
|
20876 lTemp = 0; |
|
20877 if (lTemp > 255) |
|
20878 lTemp = 255; |
|
20879 lTemp4 |= (lTemp >> 2) << 5; |
|
20880 |
|
20881 /*R component*/ |
|
20882 lTemp = lY1 + lTemp1 + 6; |
|
20883 if (lTemp < 0) |
|
20884 lTemp = 0; |
|
20885 if (lTemp > 255) |
|
20886 lTemp = 255; |
|
20887 lTemp4 |= (lTemp >> 3) << 11; |
|
20888 |
|
20889 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
20890 |
|
20891 |
|
20892 /*Fourth Pixel*/ |
|
20893 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
20894 lY1 -= 16; |
|
20895 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
20896 |
|
20897 /*B component*/ |
|
20898 lTemp = lY1 + lTemp3 + 2; |
|
20899 if (lTemp < 0) |
|
20900 lTemp = 0; |
|
20901 if (lTemp > 255) |
|
20902 lTemp = 255; |
|
20903 lTemp4 = (lTemp >> 3); |
|
20904 |
|
20905 /*G component*/ |
|
20906 lTemp = lY1 - lTemp2 + 2; |
|
20907 if (lTemp < 0) |
|
20908 lTemp = 0; |
|
20909 if (lTemp > 255) |
|
20910 lTemp = 255; |
|
20911 lTemp4 |= (lTemp >> 2) << 5; |
|
20912 |
|
20913 /*R component*/ |
|
20914 lTemp = lY1 + lTemp1; |
|
20915 if (lTemp < 0) |
|
20916 lTemp = 0; |
|
20917 if (lTemp > 255) |
|
20918 lTemp = 255; |
|
20919 lTemp4 |= (lTemp >> 3) << 11; |
|
20920 |
|
20921 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
20922 |
|
20923 lRGBFramePtr += 2; |
|
20924 lRGBFramePtr1 += 2; |
|
20925 |
|
20926 |
|
20927 if(extraCol) |
|
20928 { |
|
20929 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
20930 lRGBFramePtr++; |
|
20931 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
20932 lRGBFramePtr1++; |
|
20933 } |
|
20934 |
|
20935 lLumPtr += (lLumWidth << 1); |
|
20936 lCrPtr += (lLumWidth >> 1); |
|
20937 lCbPtr += (lLumWidth >> 1); |
|
20938 |
|
20939 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
20940 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
20941 } |
|
20942 |
|
20943 if(extraRow) |
|
20944 { |
|
20945 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
20946 for(j = 0; j < lWidth; j += 2) |
|
20947 { |
|
20948 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
20949 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
20950 } |
|
20951 if(extraCol) |
|
20952 { |
|
20953 *lRGBFramePtr = *lRGBFramePtr1; |
|
20954 } |
|
20955 } |
|
20956 return; |
|
20957 } |
|
20958 |
|
20959 /* |
|
20960 ****************************************************************************** |
|
20961 Name : sEmz_VDec_YUV420Chr1toColor64k_Ordered_601_5_RR |
|
20962 Description : Converts YUV420 Chroma1 Planar to RGB565 Interleaved format |
|
20963 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
20964 uint8 *dstImage : Pointer to rgb data (o/p). |
|
20965 tWndParam *srcWindow : Pointer to structure containing source window |
|
20966 parameters like xOffset,yOffset,cropWidth, |
|
20967 cropHeight. (i/p) |
|
20968 tWndParam *dstWindow : Pointer to structure containing destination window |
|
20969 parameters like xOffset,yOffset,windWidth, |
|
20970 windHeight. (i/p) |
|
20971 Return Value : void |
|
20972 ****************************************************************************** |
|
20973 */ |
|
20974 |
|
20975 void sEmz_VDec_YUV420Chr1toColor64k_Ordered_601_5_RR |
|
20976 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
20977 tWndParam* srcWindow, tWndParam* dstWindow) |
|
20978 { |
|
20979 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
20980 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
20981 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
20982 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
20983 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
20984 int32 i, j, extraRow, extraCol; |
|
20985 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
20986 cropWidth,cropHeight,wndWidth,wndHeight; |
|
20987 |
|
20988 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
20989 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
20990 |
|
20991 | {0,3,2} {4,0,6} | |
|
20992 | {6,1,4} {2,2,0} | */ |
|
20993 |
|
20994 srcXOffset = srcWindow->xOffset; |
|
20995 srcYOffset = srcWindow->yOffset; |
|
20996 cropWidth = srcWindow->wndWidth; |
|
20997 cropHeight = srcWindow->wndHeight; |
|
20998 |
|
20999 dstXOffset = dstWindow->xOffset; |
|
21000 dstYOffset = dstWindow->yOffset; |
|
21001 wndWidth = dstWindow->wndWidth; |
|
21002 wndHeight = dstWindow->wndHeight; |
|
21003 |
|
21004 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
21005 { |
|
21006 lWidth = cropWidth; |
|
21007 } |
|
21008 else |
|
21009 { |
|
21010 lWidth = srcImage->width - srcXOffset; |
|
21011 } |
|
21012 |
|
21013 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
21014 { |
|
21015 lHeight = cropHeight; |
|
21016 } |
|
21017 else |
|
21018 { |
|
21019 lHeight = srcImage->height - srcYOffset; |
|
21020 } |
|
21021 |
|
21022 if (lWidth > (wndWidth - dstXOffset)) |
|
21023 { |
|
21024 lWidth = wndWidth - dstXOffset; |
|
21025 } |
|
21026 |
|
21027 if (lHeight > (wndHeight - dstYOffset)) |
|
21028 { |
|
21029 lHeight = wndHeight - dstYOffset; |
|
21030 } |
|
21031 |
|
21032 extraCol = lWidth & 0x01; |
|
21033 extraRow = lHeight & 0x01; |
|
21034 |
|
21035 lTempWidth = lWidth; |
|
21036 lWidth = (lWidth >> 1) << 1; |
|
21037 lHeight = (lHeight >> 1) << 1; |
|
21038 |
|
21039 lLumWidth = (srcImage->width >> 1) << 1; |
|
21040 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
21041 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
21042 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
21043 |
|
21044 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
21045 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
21046 |
|
21047 for(i = 0; i < lHeight; i += 2) |
|
21048 { |
|
21049 for(j = 0; j < (lWidth - 2); j += 2) |
|
21050 { |
|
21051 lCr1 = lCrPtr[j >> 1]; |
|
21052 lCb1 = lCbPtr[j >> 1]; |
|
21053 |
|
21054 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
21055 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
21056 |
|
21057 lCr2 = (lCr1 + lCr2) >> 1; |
|
21058 lCb2 = (lCb1 + lCb2) >> 1; |
|
21059 |
|
21060 lCr1 -= 128; |
|
21061 lCb1 -= 128; |
|
21062 |
|
21063 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
21064 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
21065 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
21066 |
|
21067 /*First Pixel*/ |
|
21068 lY1 = lLumPtr[j]; |
|
21069 lY1 -= 16; |
|
21070 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
21071 |
|
21072 /*B component*/ |
|
21073 lTemp = lY1 + lTemp3; |
|
21074 if (lTemp < 0) |
|
21075 lTemp = 0; |
|
21076 if (lTemp > 255) |
|
21077 lTemp = 255; |
|
21078 lTemp4 = (lTemp >> 3); |
|
21079 |
|
21080 /*G component*/ |
|
21081 lTemp = lY1 - lTemp2 + 3; |
|
21082 if (lTemp < 0) |
|
21083 lTemp = 0; |
|
21084 if (lTemp > 255) |
|
21085 lTemp = 255; |
|
21086 lTemp4 |= (lTemp >> 2) << 5; |
|
21087 |
|
21088 /*R component*/ |
|
21089 lTemp = lY1 + lTemp1 + 2; |
|
21090 if (lTemp < 0) |
|
21091 lTemp = 0; |
|
21092 if (lTemp > 255) |
|
21093 lTemp = 255; |
|
21094 lTemp4 |= (lTemp >> 3) << 11; |
|
21095 |
|
21096 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
21097 |
|
21098 /*Third Pixel*/ |
|
21099 lY1 = lLumPtr[j + lLumWidth]; |
|
21100 lY1 -= 16; |
|
21101 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
21102 |
|
21103 /*B component*/ |
|
21104 lTemp = lY1 + lTemp3 + 6; |
|
21105 if (lTemp < 0) |
|
21106 lTemp = 0; |
|
21107 if (lTemp > 255) |
|
21108 lTemp = 255; |
|
21109 lTemp4 = (lTemp >> 3); |
|
21110 |
|
21111 /*G component*/ |
|
21112 lTemp = lY1 - lTemp2 + 1; |
|
21113 if (lTemp < 0) |
|
21114 lTemp = 0; |
|
21115 if (lTemp > 255) |
|
21116 lTemp = 255; |
|
21117 lTemp4 |= (lTemp >> 2) << 5; |
|
21118 |
|
21119 /*R component*/ |
|
21120 lTemp = lY1 + lTemp1 + 4; |
|
21121 if (lTemp < 0) |
|
21122 lTemp = 0; |
|
21123 if (lTemp > 255) |
|
21124 lTemp = 255; |
|
21125 lTemp4 |= (lTemp >> 3) << 11; |
|
21126 |
|
21127 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
21128 |
|
21129 |
|
21130 lCr2 -= 128; |
|
21131 lCb2 -= 128; |
|
21132 |
|
21133 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
21134 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
21135 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
21136 |
|
21137 /*Second Pixel*/ |
|
21138 lY1 = lLumPtr[j + 1]; |
|
21139 lY1 -= 16; |
|
21140 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
21141 |
|
21142 /*B component*/ |
|
21143 lTemp = lY1 + lTemp3 + 4; |
|
21144 if (lTemp < 0) |
|
21145 lTemp = 0; |
|
21146 if (lTemp > 255) |
|
21147 lTemp = 255; |
|
21148 lTemp4 = (lTemp >> 3); |
|
21149 |
|
21150 /*G component*/ |
|
21151 lTemp = lY1 - lTemp2; |
|
21152 if (lTemp < 0) |
|
21153 lTemp = 0; |
|
21154 if (lTemp > 255) |
|
21155 lTemp = 255; |
|
21156 lTemp4 |= (lTemp >> 2) << 5; |
|
21157 |
|
21158 /*R component*/ |
|
21159 lTemp = lY1 + lTemp1 + 6; |
|
21160 if (lTemp < 0) |
|
21161 lTemp = 0; |
|
21162 if (lTemp > 255) |
|
21163 lTemp = 255; |
|
21164 lTemp4 |= (lTemp >> 3) << 11; |
|
21165 |
|
21166 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
21167 |
|
21168 |
|
21169 /*Fourth Pixel*/ |
|
21170 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
21171 lY1 -= 16; |
|
21172 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
21173 |
|
21174 /*B component*/ |
|
21175 lTemp = lY1 + lTemp3 + 2; |
|
21176 if (lTemp < 0) |
|
21177 lTemp = 0; |
|
21178 if (lTemp > 255) |
|
21179 lTemp = 255; |
|
21180 lTemp4 = (lTemp >> 3); |
|
21181 |
|
21182 /*G component*/ |
|
21183 lTemp = lY1 - lTemp2 + 2; |
|
21184 if (lTemp < 0) |
|
21185 lTemp = 0; |
|
21186 if (lTemp > 255) |
|
21187 lTemp = 255; |
|
21188 lTemp4 |= (lTemp >> 2) << 5; |
|
21189 |
|
21190 /*R component*/ |
|
21191 lTemp = lY1 + lTemp1; |
|
21192 if (lTemp < 0) |
|
21193 lTemp = 0; |
|
21194 if (lTemp > 255) |
|
21195 lTemp = 255; |
|
21196 lTemp4 |= (lTemp >> 3) << 11; |
|
21197 |
|
21198 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
21199 |
|
21200 lRGBFramePtr += 2; |
|
21201 lRGBFramePtr1 += 2; |
|
21202 } |
|
21203 |
|
21204 lCr1 = lCrPtr[j >> 1]; |
|
21205 lCb1 = lCbPtr[j >> 1]; |
|
21206 |
|
21207 lCr1 -= 128; |
|
21208 lCb1 -= 128; |
|
21209 |
|
21210 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
21211 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
21212 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
21213 |
|
21214 /*First Pixel*/ |
|
21215 lY1 = lLumPtr[j]; |
|
21216 lY1 -= 16; |
|
21217 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
21218 |
|
21219 /*B component*/ |
|
21220 lTemp = lY1 + lTemp3; |
|
21221 if (lTemp < 0) |
|
21222 lTemp = 0; |
|
21223 if (lTemp > 255) |
|
21224 lTemp = 255; |
|
21225 lTemp4 = (lTemp >> 3); |
|
21226 |
|
21227 /*G component*/ |
|
21228 lTemp = lY1 - lTemp2 + 3; |
|
21229 if (lTemp < 0) |
|
21230 lTemp = 0; |
|
21231 if (lTemp > 255) |
|
21232 lTemp = 255; |
|
21233 lTemp4 |= (lTemp >> 2) << 5; |
|
21234 |
|
21235 /*R component*/ |
|
21236 lTemp = lY1 + lTemp1 + 2; |
|
21237 if (lTemp < 0) |
|
21238 lTemp = 0; |
|
21239 if (lTemp > 255) |
|
21240 lTemp = 255; |
|
21241 lTemp4 |= (lTemp >> 3) << 11; |
|
21242 |
|
21243 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
21244 |
|
21245 /*Third Pixel*/ |
|
21246 lY1 = lLumPtr[j + lLumWidth]; |
|
21247 lY1 -= 16; |
|
21248 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
21249 |
|
21250 /*B component*/ |
|
21251 lTemp = lY1 + lTemp3 + 6; |
|
21252 if (lTemp < 0) |
|
21253 lTemp = 0; |
|
21254 if (lTemp > 255) |
|
21255 lTemp = 255; |
|
21256 lTemp4 = (lTemp >> 3); |
|
21257 |
|
21258 /*G component*/ |
|
21259 lTemp = lY1 - lTemp2 + 1; |
|
21260 if (lTemp < 0) |
|
21261 lTemp = 0; |
|
21262 if (lTemp > 255) |
|
21263 lTemp = 255; |
|
21264 lTemp4 |= (lTemp >> 2) << 5; |
|
21265 |
|
21266 /*R component*/ |
|
21267 lTemp = lY1 + lTemp1 + 4; |
|
21268 if (lTemp < 0) |
|
21269 lTemp = 0; |
|
21270 if (lTemp > 255) |
|
21271 lTemp = 255; |
|
21272 lTemp4 |= (lTemp >> 3) << 11; |
|
21273 |
|
21274 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
21275 |
|
21276 |
|
21277 /*Second Pixel*/ |
|
21278 lY1 = lLumPtr[j + 1]; |
|
21279 lY1 -= 16; |
|
21280 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
21281 |
|
21282 /*B component*/ |
|
21283 lTemp = lY1 + lTemp3 + 4; |
|
21284 if (lTemp < 0) |
|
21285 lTemp = 0; |
|
21286 if (lTemp > 255) |
|
21287 lTemp = 255; |
|
21288 lTemp4 = (lTemp >> 3); |
|
21289 |
|
21290 /*G component*/ |
|
21291 lTemp = lY1 - lTemp2; |
|
21292 if (lTemp < 0) |
|
21293 lTemp = 0; |
|
21294 if (lTemp > 255) |
|
21295 lTemp = 255; |
|
21296 lTemp4 |= (lTemp >> 2) << 5; |
|
21297 |
|
21298 /*R component*/ |
|
21299 lTemp = lY1 + lTemp1 + 6; |
|
21300 if (lTemp < 0) |
|
21301 lTemp = 0; |
|
21302 if (lTemp > 255) |
|
21303 lTemp = 255; |
|
21304 lTemp4 |= (lTemp >> 3) << 11; |
|
21305 |
|
21306 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
21307 |
|
21308 |
|
21309 /*Fourth Pixel*/ |
|
21310 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
21311 lY1 -= 16; |
|
21312 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
21313 |
|
21314 /*B component*/ |
|
21315 lTemp = lY1 + lTemp3 + 2; |
|
21316 if (lTemp < 0) |
|
21317 lTemp = 0; |
|
21318 if (lTemp > 255) |
|
21319 lTemp = 255; |
|
21320 lTemp4 = (lTemp >> 3); |
|
21321 |
|
21322 /*G component*/ |
|
21323 lTemp = lY1 - lTemp2 + 2; |
|
21324 if (lTemp < 0) |
|
21325 lTemp = 0; |
|
21326 if (lTemp > 255) |
|
21327 lTemp = 255; |
|
21328 lTemp4 |= (lTemp >> 2) << 5; |
|
21329 |
|
21330 /*R component*/ |
|
21331 lTemp = lY1 + lTemp1; |
|
21332 if (lTemp < 0) |
|
21333 lTemp = 0; |
|
21334 if (lTemp > 255) |
|
21335 lTemp = 255; |
|
21336 lTemp4 |= (lTemp >> 3) << 11; |
|
21337 |
|
21338 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
21339 |
|
21340 lRGBFramePtr += 2; |
|
21341 lRGBFramePtr1 += 2; |
|
21342 |
|
21343 |
|
21344 if(extraCol) |
|
21345 { |
|
21346 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
21347 lRGBFramePtr++; |
|
21348 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
21349 lRGBFramePtr1++; |
|
21350 } |
|
21351 |
|
21352 lLumPtr += (lLumWidth << 1); |
|
21353 lCrPtr += (lLumWidth >> 1); |
|
21354 lCbPtr += (lLumWidth >> 1); |
|
21355 |
|
21356 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
21357 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
21358 } |
|
21359 |
|
21360 if(extraRow) |
|
21361 { |
|
21362 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
21363 for(j = 0; j < lWidth; j += 2) |
|
21364 { |
|
21365 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
21366 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
21367 } |
|
21368 if(extraCol) |
|
21369 { |
|
21370 *lRGBFramePtr = *lRGBFramePtr1; |
|
21371 } |
|
21372 } |
|
21373 return; |
|
21374 } |
|
21375 |
|
21376 |
|
21377 |
|
21378 /* |
|
21379 ****************************************************************************** |
|
21380 Name : sEmz_VDec_YUV420Chr1toColor16M_709_FR |
|
21381 Description : Converts YUV420 Chroma1 Planar to RGB888 Interleaved format |
|
21382 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
21383 uint8 *dstImage : Pointer to rgb data (o/p). |
|
21384 tWndParam *srcWindow : Pointer to structure containing source window |
|
21385 parameters like xOffset,yOffset,cropWidth, |
|
21386 cropHeight. (i/p) |
|
21387 tWndParam *dstWindow : Pointer to structure containing destination window |
|
21388 parameters like xOffset,yOffset,windWidth, |
|
21389 windHeight. (i/p) |
|
21390 Return Value : void |
|
21391 ****************************************************************************** |
|
21392 */ |
|
21393 |
|
21394 void sEmz_VDec_YUV420Chr1toColor16M_709_FR |
|
21395 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
21396 tWndParam* srcWindow, tWndParam* dstWindow) |
|
21397 { |
|
21398 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
21399 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
21400 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
21401 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
21402 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
21403 int32 i, j, extraRow, extraCol; |
|
21404 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
21405 cropWidth,cropHeight,wndWidth,wndHeight; |
|
21406 |
|
21407 srcXOffset = srcWindow->xOffset; |
|
21408 srcYOffset = srcWindow->yOffset; |
|
21409 cropWidth = srcWindow->wndWidth; |
|
21410 cropHeight = srcWindow->wndHeight; |
|
21411 |
|
21412 dstXOffset = dstWindow->xOffset; |
|
21413 dstYOffset = dstWindow->yOffset; |
|
21414 wndWidth = dstWindow->wndWidth; |
|
21415 wndHeight = dstWindow->wndHeight; |
|
21416 |
|
21417 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
21418 { |
|
21419 lWidth = cropWidth; |
|
21420 } |
|
21421 else |
|
21422 { |
|
21423 lWidth = srcImage->width - srcXOffset; |
|
21424 } |
|
21425 |
|
21426 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
21427 { |
|
21428 lHeight = cropHeight; |
|
21429 } |
|
21430 else |
|
21431 { |
|
21432 lHeight = srcImage->height - srcYOffset; |
|
21433 } |
|
21434 |
|
21435 if (lWidth > (wndWidth - dstXOffset)) |
|
21436 { |
|
21437 lWidth = wndWidth - dstXOffset; |
|
21438 } |
|
21439 |
|
21440 if (lHeight > (wndHeight - dstYOffset)) |
|
21441 { |
|
21442 lHeight = wndHeight - dstYOffset; |
|
21443 } |
|
21444 |
|
21445 extraCol = lWidth & 0x01; |
|
21446 extraRow = lHeight & 0x01; |
|
21447 |
|
21448 lTempWidth = lWidth * 3; |
|
21449 lWidth = (lWidth >> 1) << 1; |
|
21450 lHeight = (lHeight >> 1) << 1; |
|
21451 |
|
21452 dstXOffset *= 3; |
|
21453 wndWidth *= 3; |
|
21454 |
|
21455 lLumWidth = (srcImage->width >> 1) << 1; |
|
21456 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
21457 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
21458 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
21459 |
|
21460 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
21461 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
21462 |
|
21463 for(i = 0; i < lHeight; i += 2) |
|
21464 { |
|
21465 for(j = 0; j < (lWidth - 2); j += 2) |
|
21466 { |
|
21467 lCr1 = lCrPtr[j >> 1]; |
|
21468 lCb1 = lCbPtr[j >> 1]; |
|
21469 |
|
21470 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
21471 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
21472 |
|
21473 lCr2 = (lCr1 + lCr2) >> 1; |
|
21474 lCb2 = (lCb1 + lCb2) >> 1; |
|
21475 |
|
21476 lCr1 -= 128; |
|
21477 lCb1 -= 128; |
|
21478 |
|
21479 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
21480 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
21481 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
21482 |
|
21483 /*First Pixel*/ |
|
21484 lY1 = lLumPtr[j]; |
|
21485 |
|
21486 /*R component*/ |
|
21487 lTemp = lY1 + lTemp1; |
|
21488 if (lTemp < 0) |
|
21489 lTemp = 0; |
|
21490 if (lTemp > 255) |
|
21491 lTemp = 255; |
|
21492 |
|
21493 lRGBFramePtr[0] = (uint8) lTemp; |
|
21494 |
|
21495 /*G component*/ |
|
21496 lTemp = lY1 - lTemp2; |
|
21497 if (lTemp < 0) |
|
21498 lTemp = 0; |
|
21499 if (lTemp > 255) |
|
21500 lTemp = 255; |
|
21501 |
|
21502 lRGBFramePtr[1] = (uint8) lTemp; |
|
21503 |
|
21504 /*B component*/ |
|
21505 lTemp = lY1 + lTemp3; |
|
21506 if (lTemp < 0) |
|
21507 lTemp = 0; |
|
21508 if (lTemp > 255) |
|
21509 lTemp = 255; |
|
21510 |
|
21511 lRGBFramePtr[2] = (uint8) lTemp; |
|
21512 |
|
21513 /*Third Pixel*/ |
|
21514 lY1 = lLumPtr[j + lLumWidth]; |
|
21515 |
|
21516 /*R component*/ |
|
21517 lTemp = lY1 + lTemp1; |
|
21518 if (lTemp < 0) |
|
21519 lTemp = 0; |
|
21520 if (lTemp > 255) |
|
21521 lTemp = 255; |
|
21522 |
|
21523 lRGBFramePtr1[0] = (uint8) lTemp; |
|
21524 |
|
21525 /*G component*/ |
|
21526 lTemp = lY1 - lTemp2; |
|
21527 if (lTemp < 0) |
|
21528 lTemp = 0; |
|
21529 if (lTemp > 255) |
|
21530 lTemp = 255; |
|
21531 |
|
21532 lRGBFramePtr1[1] = (uint8) lTemp; |
|
21533 |
|
21534 /*B component*/ |
|
21535 lTemp = lY1 + lTemp3; |
|
21536 if (lTemp < 0) |
|
21537 lTemp = 0; |
|
21538 if (lTemp > 255) |
|
21539 lTemp = 255; |
|
21540 |
|
21541 lRGBFramePtr1[2] = (uint8) lTemp; |
|
21542 |
|
21543 |
|
21544 lCr2 -= 128; |
|
21545 lCb2 -= 128; |
|
21546 |
|
21547 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
21548 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
21549 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
21550 |
|
21551 /*Second Pixel*/ |
|
21552 lY1 = lLumPtr[j + 1]; |
|
21553 |
|
21554 /*R component*/ |
|
21555 lTemp = lY1 + lTemp1; |
|
21556 if (lTemp < 0) |
|
21557 lTemp = 0; |
|
21558 if (lTemp > 255) |
|
21559 lTemp = 255; |
|
21560 |
|
21561 lRGBFramePtr[3] = (uint8) lTemp; |
|
21562 |
|
21563 /*G component*/ |
|
21564 lTemp = lY1 - lTemp2; |
|
21565 if (lTemp < 0) |
|
21566 lTemp = 0; |
|
21567 if (lTemp > 255) |
|
21568 lTemp = 255; |
|
21569 |
|
21570 lRGBFramePtr[4] = (uint8) lTemp; |
|
21571 |
|
21572 /*B component*/ |
|
21573 lTemp = lY1 + lTemp3; |
|
21574 |
|
21575 if (lTemp < 0) |
|
21576 lTemp = 0; |
|
21577 if (lTemp > 255) |
|
21578 lTemp = 255; |
|
21579 |
|
21580 lRGBFramePtr[5] = (uint8) lTemp; |
|
21581 |
|
21582 |
|
21583 /*Fourth Pixel*/ |
|
21584 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
21585 |
|
21586 /*R component*/ |
|
21587 lTemp = lY1 + lTemp1; |
|
21588 if (lTemp < 0) |
|
21589 lTemp = 0; |
|
21590 if (lTemp > 255) |
|
21591 lTemp = 255; |
|
21592 |
|
21593 lRGBFramePtr1[3] = (uint8) lTemp; |
|
21594 |
|
21595 /*G component*/ |
|
21596 lTemp = lY1 - lTemp2; |
|
21597 if (lTemp < 0) |
|
21598 lTemp = 0; |
|
21599 if (lTemp > 255) |
|
21600 lTemp = 255; |
|
21601 |
|
21602 lRGBFramePtr1[4] = (uint8) lTemp; |
|
21603 |
|
21604 /*B component*/ |
|
21605 lTemp = lY1 + lTemp3; |
|
21606 |
|
21607 if (lTemp < 0) |
|
21608 lTemp = 0; |
|
21609 if (lTemp > 255) |
|
21610 lTemp = 255; |
|
21611 |
|
21612 lRGBFramePtr1[5] = (uint8) lTemp; |
|
21613 |
|
21614 lRGBFramePtr += 6; |
|
21615 lRGBFramePtr1 += 6; |
|
21616 } |
|
21617 |
|
21618 lCr1 = lCrPtr[j >> 1]; |
|
21619 lCb1 = lCbPtr[j >> 1]; |
|
21620 |
|
21621 lCr1 -= 128; |
|
21622 lCb1 -= 128; |
|
21623 |
|
21624 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
21625 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
21626 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
21627 |
|
21628 /*First Pixel*/ |
|
21629 lY1 = lLumPtr[j]; |
|
21630 |
|
21631 /*R component*/ |
|
21632 lTemp = lY1 + lTemp1; |
|
21633 if (lTemp < 0) |
|
21634 lTemp = 0; |
|
21635 if (lTemp > 255) |
|
21636 lTemp = 255; |
|
21637 |
|
21638 lRGBFramePtr[0] = (uint8) lTemp; |
|
21639 |
|
21640 /*G component*/ |
|
21641 lTemp = lY1 - lTemp2; |
|
21642 if (lTemp < 0) |
|
21643 lTemp = 0; |
|
21644 if (lTemp > 255) |
|
21645 lTemp = 255; |
|
21646 |
|
21647 lRGBFramePtr[1] = (uint8) lTemp; |
|
21648 |
|
21649 /*B component*/ |
|
21650 lTemp = lY1 + lTemp3; |
|
21651 if (lTemp < 0) |
|
21652 lTemp = 0; |
|
21653 if (lTemp > 255) |
|
21654 lTemp = 255; |
|
21655 |
|
21656 lRGBFramePtr[2] = (uint8) lTemp; |
|
21657 |
|
21658 /*Third Pixel*/ |
|
21659 lY1 = lLumPtr[j + lLumWidth]; |
|
21660 |
|
21661 /*R component*/ |
|
21662 lTemp = lY1 + lTemp1; |
|
21663 if (lTemp < 0) |
|
21664 lTemp = 0; |
|
21665 if (lTemp > 255) |
|
21666 lTemp = 255; |
|
21667 |
|
21668 lRGBFramePtr1[0] = (uint8) lTemp; |
|
21669 |
|
21670 /*G component*/ |
|
21671 lTemp = lY1 - lTemp2; |
|
21672 if (lTemp < 0) |
|
21673 lTemp = 0; |
|
21674 if (lTemp > 255) |
|
21675 lTemp = 255; |
|
21676 |
|
21677 lRGBFramePtr1[1] = (uint8) lTemp; |
|
21678 |
|
21679 /*B component*/ |
|
21680 lTemp = lY1 + lTemp3; |
|
21681 if (lTemp < 0) |
|
21682 lTemp = 0; |
|
21683 if (lTemp > 255) |
|
21684 lTemp = 255; |
|
21685 |
|
21686 lRGBFramePtr1[2] = (uint8) lTemp; |
|
21687 |
|
21688 |
|
21689 /*Second Pixel*/ |
|
21690 lY1 = lLumPtr[j + 1]; |
|
21691 |
|
21692 /*R component*/ |
|
21693 lTemp = lY1 + lTemp1; |
|
21694 if (lTemp < 0) |
|
21695 lTemp = 0; |
|
21696 if (lTemp > 255) |
|
21697 lTemp = 255; |
|
21698 |
|
21699 lRGBFramePtr[3] = (uint8) lTemp; |
|
21700 |
|
21701 /*G component*/ |
|
21702 lTemp = lY1 - lTemp2; |
|
21703 if (lTemp < 0) |
|
21704 lTemp = 0; |
|
21705 if (lTemp > 255) |
|
21706 lTemp = 255; |
|
21707 |
|
21708 lRGBFramePtr[4] = (uint8) lTemp; |
|
21709 |
|
21710 /*B component*/ |
|
21711 lTemp = lY1 + lTemp3; |
|
21712 |
|
21713 if (lTemp < 0) |
|
21714 lTemp = 0; |
|
21715 if (lTemp > 255) |
|
21716 lTemp = 255; |
|
21717 |
|
21718 lRGBFramePtr[5] = (uint8) lTemp; |
|
21719 |
|
21720 |
|
21721 /*Fourth Pixel*/ |
|
21722 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
21723 |
|
21724 /*R component*/ |
|
21725 lTemp = lY1 + lTemp1; |
|
21726 if (lTemp < 0) |
|
21727 lTemp = 0; |
|
21728 if (lTemp > 255) |
|
21729 lTemp = 255; |
|
21730 |
|
21731 lRGBFramePtr1[3] = (uint8) lTemp; |
|
21732 |
|
21733 /*G component*/ |
|
21734 lTemp = lY1 - lTemp2; |
|
21735 if (lTemp < 0) |
|
21736 lTemp = 0; |
|
21737 if (lTemp > 255) |
|
21738 lTemp = 255; |
|
21739 |
|
21740 lRGBFramePtr1[4] = (uint8) lTemp; |
|
21741 |
|
21742 /*B component*/ |
|
21743 lTemp = lY1 + lTemp3; |
|
21744 |
|
21745 if (lTemp < 0) |
|
21746 lTemp = 0; |
|
21747 if (lTemp > 255) |
|
21748 lTemp = 255; |
|
21749 |
|
21750 lRGBFramePtr1[5] = (uint8) lTemp; |
|
21751 |
|
21752 lRGBFramePtr += 6; |
|
21753 lRGBFramePtr1 += 6; |
|
21754 |
|
21755 |
|
21756 if(extraCol) |
|
21757 { |
|
21758 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
21759 lRGBFramePtr++; |
|
21760 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
21761 lRGBFramePtr++; |
|
21762 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
21763 lRGBFramePtr++; |
|
21764 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
21765 lRGBFramePtr1++; |
|
21766 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
21767 lRGBFramePtr1++; |
|
21768 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
21769 lRGBFramePtr1++; |
|
21770 } |
|
21771 |
|
21772 lLumPtr += (lLumWidth << 1); |
|
21773 lCrPtr += (lLumWidth >> 1); |
|
21774 lCbPtr += (lLumWidth >> 1); |
|
21775 |
|
21776 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
21777 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
21778 } |
|
21779 |
|
21780 if(extraRow) |
|
21781 { |
|
21782 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
21783 for(j = 0; j < lWidth * 3; j += 2) |
|
21784 { |
|
21785 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
21786 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
21787 } |
|
21788 if(extraCol) |
|
21789 { |
|
21790 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
21791 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
21792 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
21793 } |
|
21794 } |
|
21795 return; |
|
21796 } |
|
21797 |
|
21798 /* |
|
21799 ****************************************************************************** |
|
21800 Name : sEmz_VDec_YUV420Chr1toColor16M_601_5_FR |
|
21801 Description : Converts YUV420 Chroma1 Planar to RGB888 Interleaved format |
|
21802 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
21803 uint8 *dstImage : Pointer to rgb data (o/p). |
|
21804 tWndParam *srcWindow : Pointer to structure containing source window |
|
21805 parameters like xOffset,yOffset,cropWidth, |
|
21806 cropHeight. (i/p) |
|
21807 tWndParam *dstWindow : Pointer to structure containing destination window |
|
21808 parameters like xOffset,yOffset,windWidth, |
|
21809 windHeight. (i/p) |
|
21810 Return Value : void |
|
21811 ****************************************************************************** |
|
21812 */ |
|
21813 |
|
21814 void sEmz_VDec_YUV420Chr1toColor16M_601_5_FR |
|
21815 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
21816 tWndParam* srcWindow, tWndParam* dstWindow) |
|
21817 { |
|
21818 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
21819 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
21820 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
21821 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
21822 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
21823 int32 i, j, extraRow, extraCol; |
|
21824 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
21825 cropWidth,cropHeight,wndWidth,wndHeight; |
|
21826 |
|
21827 srcXOffset = srcWindow->xOffset; |
|
21828 srcYOffset = srcWindow->yOffset; |
|
21829 cropWidth = srcWindow->wndWidth; |
|
21830 cropHeight = srcWindow->wndHeight; |
|
21831 |
|
21832 dstXOffset = dstWindow->xOffset; |
|
21833 dstYOffset = dstWindow->yOffset; |
|
21834 wndWidth = dstWindow->wndWidth; |
|
21835 wndHeight = dstWindow->wndHeight; |
|
21836 |
|
21837 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
21838 { |
|
21839 lWidth = cropWidth; |
|
21840 } |
|
21841 else |
|
21842 { |
|
21843 lWidth = srcImage->width - srcXOffset; |
|
21844 } |
|
21845 |
|
21846 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
21847 { |
|
21848 lHeight = cropHeight; |
|
21849 } |
|
21850 else |
|
21851 { |
|
21852 lHeight = srcImage->height - srcYOffset; |
|
21853 } |
|
21854 |
|
21855 if (lWidth > (wndWidth - dstXOffset)) |
|
21856 { |
|
21857 lWidth = wndWidth - dstXOffset; |
|
21858 } |
|
21859 |
|
21860 if (lHeight > (wndHeight - dstYOffset)) |
|
21861 { |
|
21862 lHeight = wndHeight - dstYOffset; |
|
21863 } |
|
21864 |
|
21865 extraCol = lWidth & 0x01; |
|
21866 extraRow = lHeight & 0x01; |
|
21867 |
|
21868 lTempWidth = lWidth * 3; |
|
21869 lWidth = (lWidth >> 1) << 1; |
|
21870 lHeight = (lHeight >> 1) << 1; |
|
21871 |
|
21872 dstXOffset *= 3; |
|
21873 wndWidth *= 3; |
|
21874 |
|
21875 lLumWidth = (srcImage->width >> 1) << 1; |
|
21876 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
21877 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
21878 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
21879 |
|
21880 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
21881 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
21882 |
|
21883 for(i = 0; i < lHeight; i += 2) |
|
21884 { |
|
21885 for(j = 0; j < (lWidth - 2); j += 2) |
|
21886 { |
|
21887 lCr1 = lCrPtr[j >> 1]; |
|
21888 lCb1 = lCbPtr[j >> 1]; |
|
21889 |
|
21890 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
21891 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
21892 |
|
21893 lCr2 = (lCr1 + lCr2) >> 1; |
|
21894 lCb2 = (lCb1 + lCb2) >> 1; |
|
21895 |
|
21896 lCr1 -= 128; |
|
21897 lCb1 -= 128; |
|
21898 |
|
21899 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
21900 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
21901 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
21902 |
|
21903 /*First Pixel*/ |
|
21904 lY1 = lLumPtr[j]; |
|
21905 |
|
21906 /*R component*/ |
|
21907 lTemp = lY1 + lTemp1; |
|
21908 if (lTemp < 0) |
|
21909 lTemp = 0; |
|
21910 if (lTemp > 255) |
|
21911 lTemp = 255; |
|
21912 |
|
21913 lRGBFramePtr[0] = (uint8) lTemp; |
|
21914 |
|
21915 /*G component*/ |
|
21916 lTemp = lY1 - lTemp2; |
|
21917 if (lTemp < 0) |
|
21918 lTemp = 0; |
|
21919 if (lTemp > 255) |
|
21920 lTemp = 255; |
|
21921 |
|
21922 lRGBFramePtr[1] = (uint8) lTemp; |
|
21923 |
|
21924 /*B component*/ |
|
21925 lTemp = lY1 + lTemp3; |
|
21926 if (lTemp < 0) |
|
21927 lTemp = 0; |
|
21928 if (lTemp > 255) |
|
21929 lTemp = 255; |
|
21930 |
|
21931 lRGBFramePtr[2] = (uint8) lTemp; |
|
21932 |
|
21933 /*Third Pixel*/ |
|
21934 lY1 = lLumPtr[j + lLumWidth]; |
|
21935 |
|
21936 /*R component*/ |
|
21937 lTemp = lY1 + lTemp1; |
|
21938 if (lTemp < 0) |
|
21939 lTemp = 0; |
|
21940 if (lTemp > 255) |
|
21941 lTemp = 255; |
|
21942 |
|
21943 lRGBFramePtr1[0] = (uint8) lTemp; |
|
21944 |
|
21945 /*G component*/ |
|
21946 lTemp = lY1 - lTemp2; |
|
21947 if (lTemp < 0) |
|
21948 lTemp = 0; |
|
21949 if (lTemp > 255) |
|
21950 lTemp = 255; |
|
21951 |
|
21952 lRGBFramePtr1[1] = (uint8) lTemp; |
|
21953 |
|
21954 /*B component*/ |
|
21955 lTemp = lY1 + lTemp3; |
|
21956 if (lTemp < 0) |
|
21957 lTemp = 0; |
|
21958 if (lTemp > 255) |
|
21959 lTemp = 255; |
|
21960 |
|
21961 lRGBFramePtr1[2] = (uint8) lTemp; |
|
21962 |
|
21963 |
|
21964 lCr2 -= 128; |
|
21965 lCb2 -= 128; |
|
21966 |
|
21967 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
21968 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
21969 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
21970 |
|
21971 /*Second Pixel*/ |
|
21972 lY1 = lLumPtr[j + 1]; |
|
21973 |
|
21974 /*R component*/ |
|
21975 lTemp = lY1 + lTemp1; |
|
21976 if (lTemp < 0) |
|
21977 lTemp = 0; |
|
21978 if (lTemp > 255) |
|
21979 lTemp = 255; |
|
21980 |
|
21981 lRGBFramePtr[3] = (uint8) lTemp; |
|
21982 |
|
21983 /*G component*/ |
|
21984 lTemp = lY1 - lTemp2; |
|
21985 if (lTemp < 0) |
|
21986 lTemp = 0; |
|
21987 if (lTemp > 255) |
|
21988 lTemp = 255; |
|
21989 |
|
21990 lRGBFramePtr[4] = (uint8) lTemp; |
|
21991 |
|
21992 /*B component*/ |
|
21993 lTemp = lY1 + lTemp3; |
|
21994 |
|
21995 if (lTemp < 0) |
|
21996 lTemp = 0; |
|
21997 if (lTemp > 255) |
|
21998 lTemp = 255; |
|
21999 |
|
22000 lRGBFramePtr[5] = (uint8) lTemp; |
|
22001 |
|
22002 |
|
22003 /*Fourth Pixel*/ |
|
22004 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
22005 |
|
22006 /*R component*/ |
|
22007 lTemp = lY1 + lTemp1; |
|
22008 if (lTemp < 0) |
|
22009 lTemp = 0; |
|
22010 if (lTemp > 255) |
|
22011 lTemp = 255; |
|
22012 |
|
22013 lRGBFramePtr1[3] = (uint8) lTemp; |
|
22014 |
|
22015 /*G component*/ |
|
22016 lTemp = lY1 - lTemp2; |
|
22017 if (lTemp < 0) |
|
22018 lTemp = 0; |
|
22019 if (lTemp > 255) |
|
22020 lTemp = 255; |
|
22021 |
|
22022 lRGBFramePtr1[4] = (uint8) lTemp; |
|
22023 |
|
22024 /*B component*/ |
|
22025 lTemp = lY1 + lTemp3; |
|
22026 |
|
22027 if (lTemp < 0) |
|
22028 lTemp = 0; |
|
22029 if (lTemp > 255) |
|
22030 lTemp = 255; |
|
22031 |
|
22032 lRGBFramePtr1[5] = (uint8) lTemp; |
|
22033 |
|
22034 lRGBFramePtr += 6; |
|
22035 lRGBFramePtr1 += 6; |
|
22036 } |
|
22037 |
|
22038 lCr1 = lCrPtr[j >> 1]; |
|
22039 lCb1 = lCbPtr[j >> 1]; |
|
22040 |
|
22041 lCr1 -= 128; |
|
22042 lCb1 -= 128; |
|
22043 |
|
22044 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
22045 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
22046 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
22047 |
|
22048 /*First Pixel*/ |
|
22049 lY1 = lLumPtr[j]; |
|
22050 |
|
22051 /*R component*/ |
|
22052 lTemp = lY1 + lTemp1; |
|
22053 if (lTemp < 0) |
|
22054 lTemp = 0; |
|
22055 if (lTemp > 255) |
|
22056 lTemp = 255; |
|
22057 |
|
22058 lRGBFramePtr[0] = (uint8) lTemp; |
|
22059 |
|
22060 /*G component*/ |
|
22061 lTemp = lY1 - lTemp2; |
|
22062 if (lTemp < 0) |
|
22063 lTemp = 0; |
|
22064 if (lTemp > 255) |
|
22065 lTemp = 255; |
|
22066 |
|
22067 lRGBFramePtr[1] = (uint8) lTemp; |
|
22068 |
|
22069 /*B component*/ |
|
22070 lTemp = lY1 + lTemp3; |
|
22071 if (lTemp < 0) |
|
22072 lTemp = 0; |
|
22073 if (lTemp > 255) |
|
22074 lTemp = 255; |
|
22075 |
|
22076 lRGBFramePtr[2] = (uint8) lTemp; |
|
22077 |
|
22078 /*Third Pixel*/ |
|
22079 lY1 = lLumPtr[j + lLumWidth]; |
|
22080 |
|
22081 /*R component*/ |
|
22082 lTemp = lY1 + lTemp1; |
|
22083 if (lTemp < 0) |
|
22084 lTemp = 0; |
|
22085 if (lTemp > 255) |
|
22086 lTemp = 255; |
|
22087 |
|
22088 lRGBFramePtr1[0] = (uint8) lTemp; |
|
22089 |
|
22090 /*G component*/ |
|
22091 lTemp = lY1 - lTemp2; |
|
22092 if (lTemp < 0) |
|
22093 lTemp = 0; |
|
22094 if (lTemp > 255) |
|
22095 lTemp = 255; |
|
22096 |
|
22097 lRGBFramePtr1[1] = (uint8) lTemp; |
|
22098 |
|
22099 /*B component*/ |
|
22100 lTemp = lY1 + lTemp3; |
|
22101 if (lTemp < 0) |
|
22102 lTemp = 0; |
|
22103 if (lTemp > 255) |
|
22104 lTemp = 255; |
|
22105 |
|
22106 lRGBFramePtr1[2] = (uint8) lTemp; |
|
22107 |
|
22108 |
|
22109 /*Second Pixel*/ |
|
22110 lY1 = lLumPtr[j + 1]; |
|
22111 |
|
22112 /*R component*/ |
|
22113 lTemp = lY1 + lTemp1; |
|
22114 if (lTemp < 0) |
|
22115 lTemp = 0; |
|
22116 if (lTemp > 255) |
|
22117 lTemp = 255; |
|
22118 |
|
22119 lRGBFramePtr[3] = (uint8) lTemp; |
|
22120 |
|
22121 /*G component*/ |
|
22122 lTemp = lY1 - lTemp2; |
|
22123 if (lTemp < 0) |
|
22124 lTemp = 0; |
|
22125 if (lTemp > 255) |
|
22126 lTemp = 255; |
|
22127 |
|
22128 lRGBFramePtr[4] = (uint8) lTemp; |
|
22129 |
|
22130 /*B component*/ |
|
22131 lTemp = lY1 + lTemp3; |
|
22132 |
|
22133 if (lTemp < 0) |
|
22134 lTemp = 0; |
|
22135 if (lTemp > 255) |
|
22136 lTemp = 255; |
|
22137 |
|
22138 lRGBFramePtr[5] = (uint8) lTemp; |
|
22139 |
|
22140 |
|
22141 /*Fourth Pixel*/ |
|
22142 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
22143 |
|
22144 /*R component*/ |
|
22145 lTemp = lY1 + lTemp1; |
|
22146 if (lTemp < 0) |
|
22147 lTemp = 0; |
|
22148 if (lTemp > 255) |
|
22149 lTemp = 255; |
|
22150 |
|
22151 lRGBFramePtr1[3] = (uint8) lTemp; |
|
22152 |
|
22153 /*G component*/ |
|
22154 lTemp = lY1 - lTemp2; |
|
22155 if (lTemp < 0) |
|
22156 lTemp = 0; |
|
22157 if (lTemp > 255) |
|
22158 lTemp = 255; |
|
22159 |
|
22160 lRGBFramePtr1[4] = (uint8) lTemp; |
|
22161 |
|
22162 /*B component*/ |
|
22163 lTemp = lY1 + lTemp3; |
|
22164 |
|
22165 if (lTemp < 0) |
|
22166 lTemp = 0; |
|
22167 if (lTemp > 255) |
|
22168 lTemp = 255; |
|
22169 |
|
22170 lRGBFramePtr1[5] = (uint8) lTemp; |
|
22171 |
|
22172 lRGBFramePtr += 6; |
|
22173 lRGBFramePtr1 += 6; |
|
22174 |
|
22175 |
|
22176 if(extraCol) |
|
22177 { |
|
22178 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
22179 lRGBFramePtr++; |
|
22180 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
22181 lRGBFramePtr++; |
|
22182 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
22183 lRGBFramePtr++; |
|
22184 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
22185 lRGBFramePtr1++; |
|
22186 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
22187 lRGBFramePtr1++; |
|
22188 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
22189 lRGBFramePtr1++; |
|
22190 } |
|
22191 |
|
22192 lLumPtr += (lLumWidth << 1); |
|
22193 lCrPtr += (lLumWidth >> 1); |
|
22194 lCbPtr += (lLumWidth >> 1); |
|
22195 |
|
22196 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
22197 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
22198 } |
|
22199 |
|
22200 if(extraRow) |
|
22201 { |
|
22202 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
22203 for(j = 0; j < lWidth * 3; j += 2) |
|
22204 { |
|
22205 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
22206 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
22207 } |
|
22208 if(extraCol) |
|
22209 { |
|
22210 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
22211 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
22212 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
22213 } |
|
22214 } |
|
22215 return; |
|
22216 } |
|
22217 |
|
22218 /* |
|
22219 ****************************************************************************** |
|
22220 Name : sEmz_VDec_YUV420Chr1toColor16M_709_RR |
|
22221 Description : Converts YUV420 Chroma1 Planar to RGB888 Interleaved format |
|
22222 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
22223 uint8 *dstImage : Pointer to rgb data (o/p). |
|
22224 tWndParam *srcWindow : Pointer to structure containing source window |
|
22225 parameters like xOffset,yOffset,cropWidth, |
|
22226 cropHeight. (i/p) |
|
22227 tWndParam *dstWindow : Pointer to structure containing destination window |
|
22228 parameters like xOffset,yOffset,windWidth, |
|
22229 windHeight. (i/p) |
|
22230 Return Value : void |
|
22231 ****************************************************************************** |
|
22232 */ |
|
22233 |
|
22234 void sEmz_VDec_YUV420Chr1toColor16M_709_RR |
|
22235 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
22236 tWndParam* srcWindow, tWndParam* dstWindow) |
|
22237 { |
|
22238 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
22239 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
22240 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
22241 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
22242 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
22243 int32 i, j, extraRow, extraCol; |
|
22244 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
22245 cropWidth,cropHeight,wndWidth,wndHeight; |
|
22246 |
|
22247 srcXOffset = srcWindow->xOffset; |
|
22248 srcYOffset = srcWindow->yOffset; |
|
22249 cropWidth = srcWindow->wndWidth; |
|
22250 cropHeight = srcWindow->wndHeight; |
|
22251 |
|
22252 dstXOffset = dstWindow->xOffset; |
|
22253 dstYOffset = dstWindow->yOffset; |
|
22254 wndWidth = dstWindow->wndWidth; |
|
22255 wndHeight = dstWindow->wndHeight; |
|
22256 |
|
22257 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
22258 { |
|
22259 lWidth = cropWidth; |
|
22260 } |
|
22261 else |
|
22262 { |
|
22263 lWidth = srcImage->width - srcXOffset; |
|
22264 } |
|
22265 |
|
22266 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
22267 { |
|
22268 lHeight = cropHeight; |
|
22269 } |
|
22270 else |
|
22271 { |
|
22272 lHeight = srcImage->height - srcYOffset; |
|
22273 } |
|
22274 |
|
22275 if (lWidth > (wndWidth - dstXOffset)) |
|
22276 { |
|
22277 lWidth = wndWidth - dstXOffset; |
|
22278 } |
|
22279 |
|
22280 if (lHeight > (wndHeight - dstYOffset)) |
|
22281 { |
|
22282 lHeight = wndHeight - dstYOffset; |
|
22283 } |
|
22284 |
|
22285 extraCol = lWidth & 0x01; |
|
22286 extraRow = lHeight & 0x01; |
|
22287 |
|
22288 lTempWidth = lWidth * 3; |
|
22289 lWidth = (lWidth >> 1) << 1; |
|
22290 lHeight = (lHeight >> 1) << 1; |
|
22291 |
|
22292 dstXOffset *= 3; |
|
22293 wndWidth *= 3; |
|
22294 |
|
22295 lLumWidth = (srcImage->width >> 1) << 1; |
|
22296 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
22297 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
22298 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
22299 |
|
22300 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
22301 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
22302 |
|
22303 for(i = 0; i < lHeight; i += 2) |
|
22304 { |
|
22305 for(j = 0; j < (lWidth - 2); j += 2) |
|
22306 { |
|
22307 lCr1 = lCrPtr[j >> 1]; |
|
22308 lCb1 = lCbPtr[j >> 1]; |
|
22309 |
|
22310 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
22311 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
22312 |
|
22313 lCr2 = (lCr1 + lCr2) >> 1; |
|
22314 lCb2 = (lCb1 + lCb2) >> 1; |
|
22315 |
|
22316 lCr1 -= 128; |
|
22317 lCb1 -= 128; |
|
22318 |
|
22319 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
22320 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
22321 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
22322 |
|
22323 /*First Pixel*/ |
|
22324 lY1 = lLumPtr[j]; |
|
22325 lY1 -= 16; |
|
22326 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22327 |
|
22328 /*R component*/ |
|
22329 lTemp = lY1 + lTemp1; |
|
22330 if (lTemp < 0) |
|
22331 lTemp = 0; |
|
22332 if (lTemp > 255) |
|
22333 lTemp = 255; |
|
22334 |
|
22335 lRGBFramePtr[0] = (uint8) lTemp; |
|
22336 |
|
22337 /*G component*/ |
|
22338 lTemp = lY1 - lTemp2; |
|
22339 if (lTemp < 0) |
|
22340 lTemp = 0; |
|
22341 if (lTemp > 255) |
|
22342 lTemp = 255; |
|
22343 |
|
22344 lRGBFramePtr[1] = (uint8) lTemp; |
|
22345 |
|
22346 /*B component*/ |
|
22347 lTemp = lY1 + lTemp3; |
|
22348 if (lTemp < 0) |
|
22349 lTemp = 0; |
|
22350 if (lTemp > 255) |
|
22351 lTemp = 255; |
|
22352 |
|
22353 lRGBFramePtr[2] = (uint8) lTemp; |
|
22354 |
|
22355 /*Third Pixel*/ |
|
22356 lY1 = lLumPtr[j + lLumWidth]; |
|
22357 lY1 -= 16; |
|
22358 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22359 |
|
22360 /*R component*/ |
|
22361 lTemp = lY1 + lTemp1; |
|
22362 if (lTemp < 0) |
|
22363 lTemp = 0; |
|
22364 if (lTemp > 255) |
|
22365 lTemp = 255; |
|
22366 |
|
22367 lRGBFramePtr1[0] = (uint8) lTemp; |
|
22368 |
|
22369 /*G component*/ |
|
22370 lTemp = lY1 - lTemp2; |
|
22371 if (lTemp < 0) |
|
22372 lTemp = 0; |
|
22373 if (lTemp > 255) |
|
22374 lTemp = 255; |
|
22375 |
|
22376 lRGBFramePtr1[1] = (uint8) lTemp; |
|
22377 |
|
22378 /*B component*/ |
|
22379 lTemp = lY1 + lTemp3; |
|
22380 if (lTemp < 0) |
|
22381 lTemp = 0; |
|
22382 if (lTemp > 255) |
|
22383 lTemp = 255; |
|
22384 |
|
22385 lRGBFramePtr1[2] = (uint8) lTemp; |
|
22386 |
|
22387 |
|
22388 lCr2 -= 128; |
|
22389 lCb2 -= 128; |
|
22390 |
|
22391 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
22392 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
22393 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
22394 |
|
22395 /*Second Pixel*/ |
|
22396 lY1 = lLumPtr[j + 1]; |
|
22397 lY1 -= 16; |
|
22398 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22399 |
|
22400 /*R component*/ |
|
22401 lTemp = lY1 + lTemp1; |
|
22402 if (lTemp < 0) |
|
22403 lTemp = 0; |
|
22404 if (lTemp > 255) |
|
22405 lTemp = 255; |
|
22406 |
|
22407 lRGBFramePtr[3] = (uint8) lTemp; |
|
22408 |
|
22409 /*G component*/ |
|
22410 lTemp = lY1 - lTemp2; |
|
22411 if (lTemp < 0) |
|
22412 lTemp = 0; |
|
22413 if (lTemp > 255) |
|
22414 lTemp = 255; |
|
22415 |
|
22416 lRGBFramePtr[4] = (uint8) lTemp; |
|
22417 |
|
22418 /*B component*/ |
|
22419 lTemp = lY1 + lTemp3; |
|
22420 |
|
22421 if (lTemp < 0) |
|
22422 lTemp = 0; |
|
22423 if (lTemp > 255) |
|
22424 lTemp = 255; |
|
22425 |
|
22426 lRGBFramePtr[5] = (uint8) lTemp; |
|
22427 |
|
22428 |
|
22429 /*Fourth Pixel*/ |
|
22430 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
22431 lY1 -= 16; |
|
22432 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22433 |
|
22434 /*R component*/ |
|
22435 lTemp = lY1 + lTemp1; |
|
22436 if (lTemp < 0) |
|
22437 lTemp = 0; |
|
22438 if (lTemp > 255) |
|
22439 lTemp = 255; |
|
22440 |
|
22441 lRGBFramePtr1[3] = (uint8) lTemp; |
|
22442 |
|
22443 /*G component*/ |
|
22444 lTemp = lY1 - lTemp2; |
|
22445 if (lTemp < 0) |
|
22446 lTemp = 0; |
|
22447 if (lTemp > 255) |
|
22448 lTemp = 255; |
|
22449 |
|
22450 lRGBFramePtr1[4] = (uint8) lTemp; |
|
22451 |
|
22452 /*B component*/ |
|
22453 lTemp = lY1 + lTemp3; |
|
22454 |
|
22455 if (lTemp < 0) |
|
22456 lTemp = 0; |
|
22457 if (lTemp > 255) |
|
22458 lTemp = 255; |
|
22459 |
|
22460 lRGBFramePtr1[5] = (uint8) lTemp; |
|
22461 |
|
22462 lRGBFramePtr += 6; |
|
22463 lRGBFramePtr1 += 6; |
|
22464 } |
|
22465 |
|
22466 lCr1 = lCrPtr[j >> 1]; |
|
22467 lCb1 = lCbPtr[j >> 1]; |
|
22468 |
|
22469 lCr1 -= 128; |
|
22470 lCb1 -= 128; |
|
22471 |
|
22472 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
22473 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
22474 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
22475 |
|
22476 /*First Pixel*/ |
|
22477 lY1 = lLumPtr[j]; |
|
22478 lY1 -= 16; |
|
22479 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22480 |
|
22481 /*R component*/ |
|
22482 lTemp = lY1 + lTemp1; |
|
22483 if (lTemp < 0) |
|
22484 lTemp = 0; |
|
22485 if (lTemp > 255) |
|
22486 lTemp = 255; |
|
22487 |
|
22488 lRGBFramePtr[0] = (uint8) lTemp; |
|
22489 |
|
22490 /*G component*/ |
|
22491 lTemp = lY1 - lTemp2; |
|
22492 if (lTemp < 0) |
|
22493 lTemp = 0; |
|
22494 if (lTemp > 255) |
|
22495 lTemp = 255; |
|
22496 |
|
22497 lRGBFramePtr[1] = (uint8) lTemp; |
|
22498 |
|
22499 /*B component*/ |
|
22500 lTemp = lY1 + lTemp3; |
|
22501 if (lTemp < 0) |
|
22502 lTemp = 0; |
|
22503 if (lTemp > 255) |
|
22504 lTemp = 255; |
|
22505 |
|
22506 lRGBFramePtr[2] = (uint8) lTemp; |
|
22507 |
|
22508 /*Third Pixel*/ |
|
22509 lY1 = lLumPtr[j + lLumWidth]; |
|
22510 lY1 -= 16; |
|
22511 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22512 |
|
22513 /*R component*/ |
|
22514 lTemp = lY1 + lTemp1; |
|
22515 if (lTemp < 0) |
|
22516 lTemp = 0; |
|
22517 if (lTemp > 255) |
|
22518 lTemp = 255; |
|
22519 |
|
22520 lRGBFramePtr1[0] = (uint8) lTemp; |
|
22521 |
|
22522 /*G component*/ |
|
22523 lTemp = lY1 - lTemp2; |
|
22524 if (lTemp < 0) |
|
22525 lTemp = 0; |
|
22526 if (lTemp > 255) |
|
22527 lTemp = 255; |
|
22528 |
|
22529 lRGBFramePtr1[1] = (uint8) lTemp; |
|
22530 |
|
22531 /*B component*/ |
|
22532 lTemp = lY1 + lTemp3; |
|
22533 if (lTemp < 0) |
|
22534 lTemp = 0; |
|
22535 if (lTemp > 255) |
|
22536 lTemp = 255; |
|
22537 |
|
22538 lRGBFramePtr1[2] = (uint8) lTemp; |
|
22539 |
|
22540 |
|
22541 /*Second Pixel*/ |
|
22542 lY1 = lLumPtr[j + 1]; |
|
22543 lY1 -= 16; |
|
22544 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22545 |
|
22546 /*R component*/ |
|
22547 lTemp = lY1 + lTemp1; |
|
22548 if (lTemp < 0) |
|
22549 lTemp = 0; |
|
22550 if (lTemp > 255) |
|
22551 lTemp = 255; |
|
22552 |
|
22553 lRGBFramePtr[3] = (uint8) lTemp; |
|
22554 |
|
22555 /*G component*/ |
|
22556 lTemp = lY1 - lTemp2; |
|
22557 if (lTemp < 0) |
|
22558 lTemp = 0; |
|
22559 if (lTemp > 255) |
|
22560 lTemp = 255; |
|
22561 |
|
22562 lRGBFramePtr[4] = (uint8) lTemp; |
|
22563 |
|
22564 /*B component*/ |
|
22565 lTemp = lY1 + lTemp3; |
|
22566 |
|
22567 if (lTemp < 0) |
|
22568 lTemp = 0; |
|
22569 if (lTemp > 255) |
|
22570 lTemp = 255; |
|
22571 |
|
22572 lRGBFramePtr[5] = (uint8) lTemp; |
|
22573 |
|
22574 |
|
22575 /*Fourth Pixel*/ |
|
22576 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
22577 lY1 -= 16; |
|
22578 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22579 |
|
22580 /*R component*/ |
|
22581 lTemp = lY1 + lTemp1; |
|
22582 if (lTemp < 0) |
|
22583 lTemp = 0; |
|
22584 if (lTemp > 255) |
|
22585 lTemp = 255; |
|
22586 |
|
22587 lRGBFramePtr1[3] = (uint8) lTemp; |
|
22588 |
|
22589 /*G component*/ |
|
22590 lTemp = lY1 - lTemp2; |
|
22591 if (lTemp < 0) |
|
22592 lTemp = 0; |
|
22593 if (lTemp > 255) |
|
22594 lTemp = 255; |
|
22595 |
|
22596 lRGBFramePtr1[4] = (uint8) lTemp; |
|
22597 |
|
22598 /*B component*/ |
|
22599 lTemp = lY1 + lTemp3; |
|
22600 |
|
22601 if (lTemp < 0) |
|
22602 lTemp = 0; |
|
22603 if (lTemp > 255) |
|
22604 lTemp = 255; |
|
22605 |
|
22606 lRGBFramePtr1[5] = (uint8) lTemp; |
|
22607 |
|
22608 lRGBFramePtr += 6; |
|
22609 lRGBFramePtr1 += 6; |
|
22610 |
|
22611 |
|
22612 if(extraCol) |
|
22613 { |
|
22614 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
22615 lRGBFramePtr++; |
|
22616 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
22617 lRGBFramePtr++; |
|
22618 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
22619 lRGBFramePtr++; |
|
22620 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
22621 lRGBFramePtr1++; |
|
22622 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
22623 lRGBFramePtr1++; |
|
22624 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
22625 lRGBFramePtr1++; |
|
22626 } |
|
22627 |
|
22628 lLumPtr += (lLumWidth << 1); |
|
22629 lCrPtr += (lLumWidth >> 1); |
|
22630 lCbPtr += (lLumWidth >> 1); |
|
22631 |
|
22632 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
22633 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
22634 } |
|
22635 |
|
22636 if(extraRow) |
|
22637 { |
|
22638 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
22639 for(j = 0; j < lWidth * 3; j += 2) |
|
22640 { |
|
22641 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
22642 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
22643 } |
|
22644 if(extraCol) |
|
22645 { |
|
22646 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
22647 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
22648 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
22649 } |
|
22650 } |
|
22651 return; |
|
22652 } |
|
22653 |
|
22654 /* |
|
22655 ****************************************************************************** |
|
22656 Name : sEmz_VDec_YUV420Chr1toColor16M_601_5_RR |
|
22657 Description : Converts YUV420 Chroma1 Planar to RGB888 Interleaved format |
|
22658 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
22659 uint8 *dstImage : Pointer to rgb data (o/p). |
|
22660 tWndParam *srcWindow : Pointer to structure containing source window |
|
22661 parameters like xOffset,yOffset,cropWidth, |
|
22662 cropHeight. (i/p) |
|
22663 tWndParam *dstWindow : Pointer to structure containing destination window |
|
22664 parameters like xOffset,yOffset,windWidth, |
|
22665 windHeight. (i/p) |
|
22666 Return Value : void |
|
22667 ****************************************************************************** |
|
22668 */ |
|
22669 |
|
22670 void sEmz_VDec_YUV420Chr1toColor16M_601_5_RR |
|
22671 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
22672 tWndParam* srcWindow, tWndParam* dstWindow) |
|
22673 { |
|
22674 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
22675 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
22676 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
22677 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
22678 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
22679 int32 i, j, extraRow, extraCol; |
|
22680 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
22681 cropWidth,cropHeight,wndWidth,wndHeight; |
|
22682 |
|
22683 srcXOffset = srcWindow->xOffset; |
|
22684 srcYOffset = srcWindow->yOffset; |
|
22685 cropWidth = srcWindow->wndWidth; |
|
22686 cropHeight = srcWindow->wndHeight; |
|
22687 |
|
22688 dstXOffset = dstWindow->xOffset; |
|
22689 dstYOffset = dstWindow->yOffset; |
|
22690 wndWidth = dstWindow->wndWidth; |
|
22691 wndHeight = dstWindow->wndHeight; |
|
22692 |
|
22693 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
22694 { |
|
22695 lWidth = cropWidth; |
|
22696 } |
|
22697 else |
|
22698 { |
|
22699 lWidth = srcImage->width - srcXOffset; |
|
22700 } |
|
22701 |
|
22702 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
22703 { |
|
22704 lHeight = cropHeight; |
|
22705 } |
|
22706 else |
|
22707 { |
|
22708 lHeight = srcImage->height - srcYOffset; |
|
22709 } |
|
22710 |
|
22711 if (lWidth > (wndWidth - dstXOffset)) |
|
22712 { |
|
22713 lWidth = wndWidth - dstXOffset; |
|
22714 } |
|
22715 |
|
22716 if (lHeight > (wndHeight - dstYOffset)) |
|
22717 { |
|
22718 lHeight = wndHeight - dstYOffset; |
|
22719 } |
|
22720 |
|
22721 extraCol = lWidth & 0x01; |
|
22722 extraRow = lHeight & 0x01; |
|
22723 |
|
22724 lTempWidth = lWidth * 3; |
|
22725 lWidth = (lWidth >> 1) << 1; |
|
22726 lHeight = (lHeight >> 1) << 1; |
|
22727 |
|
22728 dstXOffset *= 3; |
|
22729 wndWidth *= 3; |
|
22730 |
|
22731 lLumWidth = (srcImage->width >> 1) << 1; |
|
22732 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
22733 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
22734 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
22735 |
|
22736 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
22737 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
22738 |
|
22739 for(i = 0; i < lHeight; i += 2) |
|
22740 { |
|
22741 for(j = 0; j < (lWidth - 2); j += 2) |
|
22742 { |
|
22743 lCr1 = lCrPtr[j >> 1]; |
|
22744 lCb1 = lCbPtr[j >> 1]; |
|
22745 |
|
22746 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
22747 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
22748 |
|
22749 lCr2 = (lCr1 + lCr2) >> 1; |
|
22750 lCb2 = (lCb1 + lCb2) >> 1; |
|
22751 |
|
22752 lCr1 -= 128; |
|
22753 lCb1 -= 128; |
|
22754 |
|
22755 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
22756 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
22757 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
22758 |
|
22759 /*First Pixel*/ |
|
22760 lY1 = lLumPtr[j]; |
|
22761 lY1 -= 16; |
|
22762 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22763 |
|
22764 /*R component*/ |
|
22765 lTemp = lY1 + lTemp1; |
|
22766 if (lTemp < 0) |
|
22767 lTemp = 0; |
|
22768 if (lTemp > 255) |
|
22769 lTemp = 255; |
|
22770 |
|
22771 lRGBFramePtr[0] = (uint8) lTemp; |
|
22772 |
|
22773 /*G component*/ |
|
22774 lTemp = lY1 - lTemp2; |
|
22775 if (lTemp < 0) |
|
22776 lTemp = 0; |
|
22777 if (lTemp > 255) |
|
22778 lTemp = 255; |
|
22779 |
|
22780 lRGBFramePtr[1] = (uint8) lTemp; |
|
22781 |
|
22782 /*B component*/ |
|
22783 lTemp = lY1 + lTemp3; |
|
22784 if (lTemp < 0) |
|
22785 lTemp = 0; |
|
22786 if (lTemp > 255) |
|
22787 lTemp = 255; |
|
22788 |
|
22789 lRGBFramePtr[2] = (uint8) lTemp; |
|
22790 |
|
22791 /*Third Pixel*/ |
|
22792 lY1 = lLumPtr[j + lLumWidth]; |
|
22793 lY1 -= 16; |
|
22794 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22795 |
|
22796 /*R component*/ |
|
22797 lTemp = lY1 + lTemp1; |
|
22798 if (lTemp < 0) |
|
22799 lTemp = 0; |
|
22800 if (lTemp > 255) |
|
22801 lTemp = 255; |
|
22802 |
|
22803 lRGBFramePtr1[0] = (uint8) lTemp; |
|
22804 |
|
22805 /*G component*/ |
|
22806 lTemp = lY1 - lTemp2; |
|
22807 if (lTemp < 0) |
|
22808 lTemp = 0; |
|
22809 if (lTemp > 255) |
|
22810 lTemp = 255; |
|
22811 |
|
22812 lRGBFramePtr1[1] = (uint8) lTemp; |
|
22813 |
|
22814 /*B component*/ |
|
22815 lTemp = lY1 + lTemp3; |
|
22816 if (lTemp < 0) |
|
22817 lTemp = 0; |
|
22818 if (lTemp > 255) |
|
22819 lTemp = 255; |
|
22820 |
|
22821 lRGBFramePtr1[2] = (uint8) lTemp; |
|
22822 |
|
22823 |
|
22824 lCr2 -= 128; |
|
22825 lCb2 -= 128; |
|
22826 |
|
22827 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
22828 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
22829 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
22830 |
|
22831 /*Second Pixel*/ |
|
22832 lY1 = lLumPtr[j + 1]; |
|
22833 lY1 -= 16; |
|
22834 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22835 |
|
22836 /*R component*/ |
|
22837 lTemp = lY1 + lTemp1; |
|
22838 if (lTemp < 0) |
|
22839 lTemp = 0; |
|
22840 if (lTemp > 255) |
|
22841 lTemp = 255; |
|
22842 |
|
22843 lRGBFramePtr[3] = (uint8) lTemp; |
|
22844 |
|
22845 /*G component*/ |
|
22846 lTemp = lY1 - lTemp2; |
|
22847 if (lTemp < 0) |
|
22848 lTemp = 0; |
|
22849 if (lTemp > 255) |
|
22850 lTemp = 255; |
|
22851 |
|
22852 lRGBFramePtr[4] = (uint8) lTemp; |
|
22853 |
|
22854 /*B component*/ |
|
22855 lTemp = lY1 + lTemp3; |
|
22856 |
|
22857 if (lTemp < 0) |
|
22858 lTemp = 0; |
|
22859 if (lTemp > 255) |
|
22860 lTemp = 255; |
|
22861 |
|
22862 lRGBFramePtr[5] = (uint8) lTemp; |
|
22863 |
|
22864 |
|
22865 /*Fourth Pixel*/ |
|
22866 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
22867 lY1 -= 16; |
|
22868 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22869 |
|
22870 /*R component*/ |
|
22871 lTemp = lY1 + lTemp1; |
|
22872 if (lTemp < 0) |
|
22873 lTemp = 0; |
|
22874 if (lTemp > 255) |
|
22875 lTemp = 255; |
|
22876 |
|
22877 lRGBFramePtr1[3] = (uint8) lTemp; |
|
22878 |
|
22879 /*G component*/ |
|
22880 lTemp = lY1 - lTemp2; |
|
22881 if (lTemp < 0) |
|
22882 lTemp = 0; |
|
22883 if (lTemp > 255) |
|
22884 lTemp = 255; |
|
22885 |
|
22886 lRGBFramePtr1[4] = (uint8) lTemp; |
|
22887 |
|
22888 /*B component*/ |
|
22889 lTemp = lY1 + lTemp3; |
|
22890 |
|
22891 if (lTemp < 0) |
|
22892 lTemp = 0; |
|
22893 if (lTemp > 255) |
|
22894 lTemp = 255; |
|
22895 |
|
22896 lRGBFramePtr1[5] = (uint8) lTemp; |
|
22897 |
|
22898 lRGBFramePtr += 6; |
|
22899 lRGBFramePtr1 += 6; |
|
22900 } |
|
22901 |
|
22902 lCr1 = lCrPtr[j >> 1]; |
|
22903 lCb1 = lCbPtr[j >> 1]; |
|
22904 |
|
22905 lCr1 -= 128; |
|
22906 lCb1 -= 128; |
|
22907 |
|
22908 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
22909 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
22910 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
22911 |
|
22912 /*First Pixel*/ |
|
22913 lY1 = lLumPtr[j]; |
|
22914 lY1 -= 16; |
|
22915 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22916 |
|
22917 /*R component*/ |
|
22918 lTemp = lY1 + lTemp1; |
|
22919 if (lTemp < 0) |
|
22920 lTemp = 0; |
|
22921 if (lTemp > 255) |
|
22922 lTemp = 255; |
|
22923 |
|
22924 lRGBFramePtr[0] = (uint8) lTemp; |
|
22925 |
|
22926 /*G component*/ |
|
22927 lTemp = lY1 - lTemp2; |
|
22928 if (lTemp < 0) |
|
22929 lTemp = 0; |
|
22930 if (lTemp > 255) |
|
22931 lTemp = 255; |
|
22932 |
|
22933 lRGBFramePtr[1] = (uint8) lTemp; |
|
22934 |
|
22935 /*B component*/ |
|
22936 lTemp = lY1 + lTemp3; |
|
22937 if (lTemp < 0) |
|
22938 lTemp = 0; |
|
22939 if (lTemp > 255) |
|
22940 lTemp = 255; |
|
22941 |
|
22942 lRGBFramePtr[2] = (uint8) lTemp; |
|
22943 |
|
22944 /*Third Pixel*/ |
|
22945 lY1 = lLumPtr[j + lLumWidth]; |
|
22946 lY1 -= 16; |
|
22947 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22948 |
|
22949 /*R component*/ |
|
22950 lTemp = lY1 + lTemp1; |
|
22951 if (lTemp < 0) |
|
22952 lTemp = 0; |
|
22953 if (lTemp > 255) |
|
22954 lTemp = 255; |
|
22955 |
|
22956 lRGBFramePtr1[0] = (uint8) lTemp; |
|
22957 |
|
22958 /*G component*/ |
|
22959 lTemp = lY1 - lTemp2; |
|
22960 if (lTemp < 0) |
|
22961 lTemp = 0; |
|
22962 if (lTemp > 255) |
|
22963 lTemp = 255; |
|
22964 |
|
22965 lRGBFramePtr1[1] = (uint8) lTemp; |
|
22966 |
|
22967 /*B component*/ |
|
22968 lTemp = lY1 + lTemp3; |
|
22969 if (lTemp < 0) |
|
22970 lTemp = 0; |
|
22971 if (lTemp > 255) |
|
22972 lTemp = 255; |
|
22973 |
|
22974 lRGBFramePtr1[2] = (uint8) lTemp; |
|
22975 |
|
22976 |
|
22977 /*Second Pixel*/ |
|
22978 lY1 = lLumPtr[j + 1]; |
|
22979 lY1 -= 16; |
|
22980 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
22981 |
|
22982 /*R component*/ |
|
22983 lTemp = lY1 + lTemp1; |
|
22984 if (lTemp < 0) |
|
22985 lTemp = 0; |
|
22986 if (lTemp > 255) |
|
22987 lTemp = 255; |
|
22988 |
|
22989 lRGBFramePtr[3] = (uint8) lTemp; |
|
22990 |
|
22991 /*G component*/ |
|
22992 lTemp = lY1 - lTemp2; |
|
22993 if (lTemp < 0) |
|
22994 lTemp = 0; |
|
22995 if (lTemp > 255) |
|
22996 lTemp = 255; |
|
22997 |
|
22998 lRGBFramePtr[4] = (uint8) lTemp; |
|
22999 |
|
23000 /*B component*/ |
|
23001 lTemp = lY1 + lTemp3; |
|
23002 |
|
23003 if (lTemp < 0) |
|
23004 lTemp = 0; |
|
23005 if (lTemp > 255) |
|
23006 lTemp = 255; |
|
23007 |
|
23008 lRGBFramePtr[5] = (uint8) lTemp; |
|
23009 |
|
23010 |
|
23011 /*Fourth Pixel*/ |
|
23012 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
23013 lY1 -= 16; |
|
23014 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
23015 |
|
23016 /*R component*/ |
|
23017 lTemp = lY1 + lTemp1; |
|
23018 if (lTemp < 0) |
|
23019 lTemp = 0; |
|
23020 if (lTemp > 255) |
|
23021 lTemp = 255; |
|
23022 |
|
23023 lRGBFramePtr1[3] = (uint8) lTemp; |
|
23024 |
|
23025 /*G component*/ |
|
23026 lTemp = lY1 - lTemp2; |
|
23027 if (lTemp < 0) |
|
23028 lTemp = 0; |
|
23029 if (lTemp > 255) |
|
23030 lTemp = 255; |
|
23031 |
|
23032 lRGBFramePtr1[4] = (uint8) lTemp; |
|
23033 |
|
23034 /*B component*/ |
|
23035 lTemp = lY1 + lTemp3; |
|
23036 |
|
23037 if (lTemp < 0) |
|
23038 lTemp = 0; |
|
23039 if (lTemp > 255) |
|
23040 lTemp = 255; |
|
23041 |
|
23042 lRGBFramePtr1[5] = (uint8) lTemp; |
|
23043 |
|
23044 lRGBFramePtr += 6; |
|
23045 lRGBFramePtr1 += 6; |
|
23046 |
|
23047 |
|
23048 if(extraCol) |
|
23049 { |
|
23050 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
23051 lRGBFramePtr++; |
|
23052 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
23053 lRGBFramePtr++; |
|
23054 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
23055 lRGBFramePtr++; |
|
23056 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
23057 lRGBFramePtr1++; |
|
23058 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
23059 lRGBFramePtr1++; |
|
23060 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
23061 lRGBFramePtr1++; |
|
23062 } |
|
23063 |
|
23064 lLumPtr += (lLumWidth << 1); |
|
23065 lCrPtr += (lLumWidth >> 1); |
|
23066 lCbPtr += (lLumWidth >> 1); |
|
23067 |
|
23068 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
23069 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
23070 } |
|
23071 |
|
23072 if(extraRow) |
|
23073 { |
|
23074 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
23075 for(j = 0; j < lWidth * 3; j += 2) |
|
23076 { |
|
23077 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
23078 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
23079 } |
|
23080 if(extraCol) |
|
23081 { |
|
23082 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
23083 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
23084 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
23085 } |
|
23086 } |
|
23087 return; |
|
23088 } |
|
23089 |
|
23090 |
|
23091 /* |
|
23092 ****************************************************************************** |
|
23093 Name : sEmz_VDec_YUV420Chr1toColor4k_Ordered_709_FR |
|
23094 Description : Converts YUV420 Chroma1 Planar to XRGB (4:4:4:4) Interleaved format |
|
23095 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
23096 uint8 *dstImage : Pointer to rgb data (o/p). |
|
23097 tWndParam *srcWindow : Pointer to structure containing source window |
|
23098 parameters like xOffset,yOffset,cropWidth, |
|
23099 cropHeight. (i/p) |
|
23100 tWndParam *dstWindow : Pointer to structure containing destination window |
|
23101 parameters like xOffset,yOffset,windWidth, |
|
23102 windHeight. (i/p) |
|
23103 Return Value : void |
|
23104 ****************************************************************************** |
|
23105 */ |
|
23106 |
|
23107 void sEmz_VDec_YUV420Chr1toColor4k_Ordered_709_FR |
|
23108 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
23109 tWndParam* srcWindow, tWndParam* dstWindow) |
|
23110 { |
|
23111 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
23112 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
23113 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
23114 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
23115 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
23116 int32 i, j, extraRow, extraCol; |
|
23117 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
23118 cropWidth,cropHeight,wndWidth,wndHeight; |
|
23119 |
|
23120 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
23121 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
23122 |
|
23123 | {0,15,5} {10,0,15} | |
|
23124 | {15,5,10} {5,10,0} | */ |
|
23125 |
|
23126 srcXOffset = srcWindow->xOffset; |
|
23127 srcYOffset = srcWindow->yOffset; |
|
23128 cropWidth = srcWindow->wndWidth; |
|
23129 cropHeight = srcWindow->wndHeight; |
|
23130 |
|
23131 dstXOffset = dstWindow->xOffset; |
|
23132 dstYOffset = dstWindow->yOffset; |
|
23133 wndWidth = dstWindow->wndWidth; |
|
23134 wndHeight = dstWindow->wndHeight; |
|
23135 |
|
23136 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
23137 { |
|
23138 lWidth = cropWidth; |
|
23139 } |
|
23140 else |
|
23141 { |
|
23142 lWidth = srcImage->width - srcXOffset; |
|
23143 } |
|
23144 |
|
23145 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
23146 { |
|
23147 lHeight = cropHeight; |
|
23148 } |
|
23149 else |
|
23150 { |
|
23151 lHeight = srcImage->height - srcYOffset; |
|
23152 } |
|
23153 |
|
23154 if (lWidth > (wndWidth - dstXOffset)) |
|
23155 { |
|
23156 lWidth = wndWidth - dstXOffset; |
|
23157 } |
|
23158 |
|
23159 if (lHeight > (wndHeight - dstYOffset)) |
|
23160 { |
|
23161 lHeight = wndHeight - dstYOffset; |
|
23162 } |
|
23163 |
|
23164 extraCol = lWidth & 0x01; |
|
23165 extraRow = lHeight & 0x01; |
|
23166 |
|
23167 lTempWidth = lWidth; |
|
23168 lWidth = (lWidth >> 1) << 1; |
|
23169 lHeight = (lHeight >> 1) << 1; |
|
23170 |
|
23171 lLumWidth = (srcImage->width >> 1) << 1; |
|
23172 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
23173 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
23174 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
23175 |
|
23176 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
23177 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
23178 |
|
23179 for(i = 0; i < lHeight; i += 2) |
|
23180 { |
|
23181 for(j = 0; j < (lWidth - 2); j += 2) |
|
23182 { |
|
23183 lCr1 = lCrPtr[j >> 1]; |
|
23184 lCb1 = lCbPtr[j >> 1]; |
|
23185 |
|
23186 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
23187 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
23188 |
|
23189 lCr2 = (lCr1 + lCr2) >> 1; |
|
23190 lCb2 = (lCb1 + lCb2) >> 1; |
|
23191 |
|
23192 lCr1 -= 128; |
|
23193 lCb1 -= 128; |
|
23194 |
|
23195 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
23196 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
23197 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
23198 |
|
23199 /*First Pixel*/ |
|
23200 lY1 = lLumPtr[j]; |
|
23201 |
|
23202 /*B component*/ |
|
23203 lTemp = lY1 + lTemp3; |
|
23204 if (lTemp < 0) |
|
23205 lTemp = 0; |
|
23206 if (lTemp > 255) |
|
23207 lTemp = 255; |
|
23208 lTemp4 = (lTemp >> 4); |
|
23209 |
|
23210 /*G component*/ |
|
23211 lTemp = lY1 - lTemp2 + 15; |
|
23212 if (lTemp < 0) |
|
23213 lTemp = 0; |
|
23214 if (lTemp > 255) |
|
23215 lTemp = 255; |
|
23216 lTemp4 |= (lTemp >> 4) << 4; |
|
23217 |
|
23218 /*R component*/ |
|
23219 lTemp = lY1 + lTemp1 + 5; |
|
23220 if (lTemp < 0) |
|
23221 lTemp = 0; |
|
23222 if (lTemp > 255) |
|
23223 lTemp = 255; |
|
23224 lTemp4 |= (lTemp >> 4) << 8; |
|
23225 |
|
23226 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
23227 |
|
23228 /*Third Pixel*/ |
|
23229 lY1 = lLumPtr[j + lLumWidth]; |
|
23230 |
|
23231 /*B component*/ |
|
23232 lTemp = lY1 + lTemp3 + 15; |
|
23233 if (lTemp < 0) |
|
23234 lTemp = 0; |
|
23235 if (lTemp > 255) |
|
23236 lTemp = 255; |
|
23237 lTemp4 = (lTemp >> 4); |
|
23238 |
|
23239 /*G component*/ |
|
23240 lTemp = lY1 - lTemp2 + 5; |
|
23241 if (lTemp < 0) |
|
23242 lTemp = 0; |
|
23243 if (lTemp > 255) |
|
23244 lTemp = 255; |
|
23245 lTemp4 |= (lTemp >> 4) << 4; |
|
23246 |
|
23247 /*R component*/ |
|
23248 lTemp = lY1 + lTemp1 + 10; |
|
23249 if (lTemp < 0) |
|
23250 lTemp = 0; |
|
23251 if (lTemp > 255) |
|
23252 lTemp = 255; |
|
23253 lTemp4 |= (lTemp >> 4) << 8; |
|
23254 |
|
23255 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
23256 |
|
23257 |
|
23258 lCr2 -= 128; |
|
23259 lCb2 -= 128; |
|
23260 |
|
23261 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
23262 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
23263 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
23264 |
|
23265 /*Second Pixel*/ |
|
23266 lY1 = lLumPtr[j + 1]; |
|
23267 |
|
23268 /*B component*/ |
|
23269 lTemp = lY1 + lTemp3 + 10; |
|
23270 if (lTemp < 0) |
|
23271 lTemp = 0; |
|
23272 if (lTemp > 255) |
|
23273 lTemp = 255; |
|
23274 lTemp4 = (lTemp >> 4); |
|
23275 |
|
23276 /*G component*/ |
|
23277 lTemp = lY1 - lTemp2; |
|
23278 if (lTemp < 0) |
|
23279 lTemp = 0; |
|
23280 if (lTemp > 255) |
|
23281 lTemp = 255; |
|
23282 lTemp4 |= (lTemp >> 4) << 4; |
|
23283 |
|
23284 /*R component*/ |
|
23285 lTemp = lY1 + lTemp1 + 15; |
|
23286 if (lTemp < 0) |
|
23287 lTemp = 0; |
|
23288 if (lTemp > 255) |
|
23289 lTemp = 255; |
|
23290 lTemp4 |= (lTemp >> 4) << 8; |
|
23291 |
|
23292 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
23293 |
|
23294 |
|
23295 /*Fourth Pixel*/ |
|
23296 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
23297 |
|
23298 /*B component*/ |
|
23299 lTemp = lY1 + lTemp3 + 5; |
|
23300 if (lTemp < 0) |
|
23301 lTemp = 0; |
|
23302 if (lTemp > 255) |
|
23303 lTemp = 255; |
|
23304 lTemp4 = (lTemp >> 4); |
|
23305 |
|
23306 /*G component*/ |
|
23307 lTemp = lY1 - lTemp2 + 10; |
|
23308 if (lTemp < 0) |
|
23309 lTemp = 0; |
|
23310 if (lTemp > 255) |
|
23311 lTemp = 255; |
|
23312 lTemp4 |= (lTemp >> 4) << 4; |
|
23313 |
|
23314 /*R component*/ |
|
23315 lTemp = lY1 + lTemp1; |
|
23316 if (lTemp < 0) |
|
23317 lTemp = 0; |
|
23318 if (lTemp > 255) |
|
23319 lTemp = 255; |
|
23320 lTemp4 |= (lTemp >> 4) << 8; |
|
23321 |
|
23322 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
23323 |
|
23324 lRGBFramePtr += 2; |
|
23325 lRGBFramePtr1 += 2; |
|
23326 } |
|
23327 |
|
23328 lCr1 = lCrPtr[j >> 1]; |
|
23329 lCb1 = lCbPtr[j >> 1]; |
|
23330 |
|
23331 lCr1 -= 128; |
|
23332 lCb1 -= 128; |
|
23333 |
|
23334 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
23335 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
23336 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
23337 |
|
23338 /*First Pixel*/ |
|
23339 lY1 = lLumPtr[j]; |
|
23340 |
|
23341 /*B component*/ |
|
23342 lTemp = lY1 + lTemp3; |
|
23343 if (lTemp < 0) |
|
23344 lTemp = 0; |
|
23345 if (lTemp > 255) |
|
23346 lTemp = 255; |
|
23347 lTemp4 = (lTemp >> 4); |
|
23348 |
|
23349 /*G component*/ |
|
23350 lTemp = lY1 - lTemp2 + 15; |
|
23351 if (lTemp < 0) |
|
23352 lTemp = 0; |
|
23353 if (lTemp > 255) |
|
23354 lTemp = 255; |
|
23355 lTemp4 |= (lTemp >> 4) << 4; |
|
23356 |
|
23357 /*R component*/ |
|
23358 lTemp = lY1 + lTemp1 + 5; |
|
23359 if (lTemp < 0) |
|
23360 lTemp = 0; |
|
23361 if (lTemp > 255) |
|
23362 lTemp = 255; |
|
23363 lTemp4 |= (lTemp >> 4) << 8; |
|
23364 |
|
23365 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
23366 |
|
23367 /*Third Pixel*/ |
|
23368 lY1 = lLumPtr[j + lLumWidth]; |
|
23369 |
|
23370 /*B component*/ |
|
23371 lTemp = lY1 + lTemp3 + 15; |
|
23372 if (lTemp < 0) |
|
23373 lTemp = 0; |
|
23374 if (lTemp > 255) |
|
23375 lTemp = 255; |
|
23376 lTemp4 = (lTemp >> 4); |
|
23377 |
|
23378 /*G component*/ |
|
23379 lTemp = lY1 - lTemp2 + 5; |
|
23380 if (lTemp < 0) |
|
23381 lTemp = 0; |
|
23382 if (lTemp > 255) |
|
23383 lTemp = 255; |
|
23384 lTemp4 |= (lTemp >> 4) << 4; |
|
23385 |
|
23386 /*R component*/ |
|
23387 lTemp = lY1 + lTemp1 + 10; |
|
23388 if (lTemp < 0) |
|
23389 lTemp = 0; |
|
23390 if (lTemp > 255) |
|
23391 lTemp = 255; |
|
23392 lTemp4 |= (lTemp >> 4) << 8; |
|
23393 |
|
23394 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
23395 |
|
23396 |
|
23397 /*Second Pixel*/ |
|
23398 lY1 = lLumPtr[j + 1]; |
|
23399 |
|
23400 /*B component*/ |
|
23401 lTemp = lY1 + lTemp3 + 10; |
|
23402 if (lTemp < 0) |
|
23403 lTemp = 0; |
|
23404 if (lTemp > 255) |
|
23405 lTemp = 255; |
|
23406 lTemp4 = (lTemp >> 4); |
|
23407 |
|
23408 /*G component*/ |
|
23409 lTemp = lY1 - lTemp2; |
|
23410 if (lTemp < 0) |
|
23411 lTemp = 0; |
|
23412 if (lTemp > 255) |
|
23413 lTemp = 255; |
|
23414 lTemp4 |= (lTemp >> 4) << 4; |
|
23415 |
|
23416 /*R component*/ |
|
23417 lTemp = lY1 + lTemp1 + 15; |
|
23418 if (lTemp < 0) |
|
23419 lTemp = 0; |
|
23420 if (lTemp > 255) |
|
23421 lTemp = 255; |
|
23422 lTemp4 |= (lTemp >> 4) << 8; |
|
23423 |
|
23424 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
23425 |
|
23426 |
|
23427 /*Fourth Pixel*/ |
|
23428 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
23429 |
|
23430 /*B component*/ |
|
23431 lTemp = lY1 + lTemp3 + 5; |
|
23432 if (lTemp < 0) |
|
23433 lTemp = 0; |
|
23434 if (lTemp > 255) |
|
23435 lTemp = 255; |
|
23436 lTemp4 = (lTemp >> 4); |
|
23437 |
|
23438 /*G component*/ |
|
23439 lTemp = lY1 - lTemp2 + 10; |
|
23440 if (lTemp < 0) |
|
23441 lTemp = 0; |
|
23442 if (lTemp > 255) |
|
23443 lTemp = 255; |
|
23444 lTemp4 |= (lTemp >> 4) << 4; |
|
23445 |
|
23446 /*R component*/ |
|
23447 lTemp = lY1 + lTemp1; |
|
23448 if (lTemp < 0) |
|
23449 lTemp = 0; |
|
23450 if (lTemp > 255) |
|
23451 lTemp = 255; |
|
23452 lTemp4 |= (lTemp >> 4) << 8; |
|
23453 |
|
23454 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
23455 |
|
23456 lRGBFramePtr += 2; |
|
23457 lRGBFramePtr1 += 2; |
|
23458 |
|
23459 |
|
23460 if(extraCol) |
|
23461 { |
|
23462 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
23463 lRGBFramePtr++; |
|
23464 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
23465 lRGBFramePtr1++; |
|
23466 } |
|
23467 |
|
23468 lLumPtr += (lLumWidth << 1); |
|
23469 lCrPtr += (lLumWidth >> 1); |
|
23470 lCbPtr += (lLumWidth >> 1); |
|
23471 |
|
23472 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
23473 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
23474 } |
|
23475 |
|
23476 if(extraRow) |
|
23477 { |
|
23478 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
23479 for(j = 0; j < lWidth; j += 2) |
|
23480 { |
|
23481 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
23482 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
23483 } |
|
23484 if(extraCol) |
|
23485 { |
|
23486 *lRGBFramePtr = *lRGBFramePtr1; |
|
23487 } |
|
23488 } |
|
23489 return; |
|
23490 } |
|
23491 |
|
23492 /* |
|
23493 ****************************************************************************** |
|
23494 Name : sEmz_VDec_YUV420Chr1toColor4k_Ordered_601_5_FR |
|
23495 Description : Converts YUV420 Chroma1 Planar to XRGB (4:4:4:4) Interleaved format |
|
23496 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
23497 uint8 *dstImage : Pointer to rgb data (o/p). |
|
23498 tWndParam *srcWindow : Pointer to structure containing source window |
|
23499 parameters like xOffset,yOffset,cropWidth, |
|
23500 cropHeight. (i/p) |
|
23501 tWndParam *dstWindow : Pointer to structure containing destination window |
|
23502 parameters like xOffset,yOffset,windWidth, |
|
23503 windHeight. (i/p) |
|
23504 Return Value : void |
|
23505 ****************************************************************************** |
|
23506 */ |
|
23507 |
|
23508 void sEmz_VDec_YUV420Chr1toColor4k_Ordered_601_5_FR |
|
23509 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
23510 tWndParam* srcWindow, tWndParam* dstWindow) |
|
23511 { |
|
23512 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
23513 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
23514 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
23515 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
23516 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
23517 int32 i, j, extraRow, extraCol; |
|
23518 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
23519 cropWidth,cropHeight,wndWidth,wndHeight; |
|
23520 |
|
23521 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
23522 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
23523 |
|
23524 | {0,15,5} {10,0,15} | |
|
23525 | {15,5,10} {5,10,0} | */ |
|
23526 |
|
23527 srcXOffset = srcWindow->xOffset; |
|
23528 srcYOffset = srcWindow->yOffset; |
|
23529 cropWidth = srcWindow->wndWidth; |
|
23530 cropHeight = srcWindow->wndHeight; |
|
23531 |
|
23532 dstXOffset = dstWindow->xOffset; |
|
23533 dstYOffset = dstWindow->yOffset; |
|
23534 wndWidth = dstWindow->wndWidth; |
|
23535 wndHeight = dstWindow->wndHeight; |
|
23536 |
|
23537 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
23538 { |
|
23539 lWidth = cropWidth; |
|
23540 } |
|
23541 else |
|
23542 { |
|
23543 lWidth = srcImage->width - srcXOffset; |
|
23544 } |
|
23545 |
|
23546 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
23547 { |
|
23548 lHeight = cropHeight; |
|
23549 } |
|
23550 else |
|
23551 { |
|
23552 lHeight = srcImage->height - srcYOffset; |
|
23553 } |
|
23554 |
|
23555 if (lWidth > (wndWidth - dstXOffset)) |
|
23556 { |
|
23557 lWidth = wndWidth - dstXOffset; |
|
23558 } |
|
23559 |
|
23560 if (lHeight > (wndHeight - dstYOffset)) |
|
23561 { |
|
23562 lHeight = wndHeight - dstYOffset; |
|
23563 } |
|
23564 |
|
23565 extraCol = lWidth & 0x01; |
|
23566 extraRow = lHeight & 0x01; |
|
23567 |
|
23568 lTempWidth = lWidth; |
|
23569 lWidth = (lWidth >> 1) << 1; |
|
23570 lHeight = (lHeight >> 1) << 1; |
|
23571 |
|
23572 lLumWidth = (srcImage->width >> 1) << 1; |
|
23573 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
23574 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
23575 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
23576 |
|
23577 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
23578 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
23579 |
|
23580 for(i = 0; i < lHeight; i += 2) |
|
23581 { |
|
23582 for(j = 0; j < (lWidth - 2); j += 2) |
|
23583 { |
|
23584 lCr1 = lCrPtr[j >> 1]; |
|
23585 lCb1 = lCbPtr[j >> 1]; |
|
23586 |
|
23587 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
23588 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
23589 |
|
23590 lCr2 = (lCr1 + lCr2) >> 1; |
|
23591 lCb2 = (lCb1 + lCb2) >> 1; |
|
23592 |
|
23593 lCr1 -= 128; |
|
23594 lCb1 -= 128; |
|
23595 |
|
23596 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
23597 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
23598 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
23599 |
|
23600 /*First Pixel*/ |
|
23601 lY1 = lLumPtr[j]; |
|
23602 |
|
23603 /*B component*/ |
|
23604 lTemp = lY1 + lTemp3; |
|
23605 if (lTemp < 0) |
|
23606 lTemp = 0; |
|
23607 if (lTemp > 255) |
|
23608 lTemp = 255; |
|
23609 lTemp4 = (lTemp >> 4); |
|
23610 |
|
23611 /*G component*/ |
|
23612 lTemp = lY1 - lTemp2 + 15; |
|
23613 if (lTemp < 0) |
|
23614 lTemp = 0; |
|
23615 if (lTemp > 255) |
|
23616 lTemp = 255; |
|
23617 lTemp4 |= (lTemp >> 4) << 4; |
|
23618 |
|
23619 /*R component*/ |
|
23620 lTemp = lY1 + lTemp1 + 5; |
|
23621 if (lTemp < 0) |
|
23622 lTemp = 0; |
|
23623 if (lTemp > 255) |
|
23624 lTemp = 255; |
|
23625 lTemp4 |= (lTemp >> 4) << 8; |
|
23626 |
|
23627 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
23628 |
|
23629 /*Third Pixel*/ |
|
23630 lY1 = lLumPtr[j + lLumWidth]; |
|
23631 |
|
23632 /*B component*/ |
|
23633 lTemp = lY1 + lTemp3 + 15; |
|
23634 if (lTemp < 0) |
|
23635 lTemp = 0; |
|
23636 if (lTemp > 255) |
|
23637 lTemp = 255; |
|
23638 lTemp4 = (lTemp >> 4); |
|
23639 |
|
23640 /*G component*/ |
|
23641 lTemp = lY1 - lTemp2 + 5; |
|
23642 if (lTemp < 0) |
|
23643 lTemp = 0; |
|
23644 if (lTemp > 255) |
|
23645 lTemp = 255; |
|
23646 lTemp4 |= (lTemp >> 4) << 4; |
|
23647 |
|
23648 /*R component*/ |
|
23649 lTemp = lY1 + lTemp1 + 10; |
|
23650 if (lTemp < 0) |
|
23651 lTemp = 0; |
|
23652 if (lTemp > 255) |
|
23653 lTemp = 255; |
|
23654 lTemp4 |= (lTemp >> 4) << 8; |
|
23655 |
|
23656 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
23657 |
|
23658 |
|
23659 lCr2 -= 128; |
|
23660 lCb2 -= 128; |
|
23661 |
|
23662 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
23663 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
23664 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
23665 |
|
23666 /*Second Pixel*/ |
|
23667 lY1 = lLumPtr[j + 1]; |
|
23668 |
|
23669 /*B component*/ |
|
23670 lTemp = lY1 + lTemp3 + 10; |
|
23671 if (lTemp < 0) |
|
23672 lTemp = 0; |
|
23673 if (lTemp > 255) |
|
23674 lTemp = 255; |
|
23675 lTemp4 = (lTemp >> 4); |
|
23676 |
|
23677 /*G component*/ |
|
23678 lTemp = lY1 - lTemp2; |
|
23679 if (lTemp < 0) |
|
23680 lTemp = 0; |
|
23681 if (lTemp > 255) |
|
23682 lTemp = 255; |
|
23683 lTemp4 |= (lTemp >> 4) << 4; |
|
23684 |
|
23685 /*R component*/ |
|
23686 lTemp = lY1 + lTemp1 + 15; |
|
23687 if (lTemp < 0) |
|
23688 lTemp = 0; |
|
23689 if (lTemp > 255) |
|
23690 lTemp = 255; |
|
23691 lTemp4 |= (lTemp >> 4) << 8; |
|
23692 |
|
23693 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
23694 |
|
23695 |
|
23696 /*Fourth Pixel*/ |
|
23697 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
23698 |
|
23699 /*B component*/ |
|
23700 lTemp = lY1 + lTemp3 + 5; |
|
23701 if (lTemp < 0) |
|
23702 lTemp = 0; |
|
23703 if (lTemp > 255) |
|
23704 lTemp = 255; |
|
23705 lTemp4 = (lTemp >> 4); |
|
23706 |
|
23707 /*G component*/ |
|
23708 lTemp = lY1 - lTemp2 + 10; |
|
23709 if (lTemp < 0) |
|
23710 lTemp = 0; |
|
23711 if (lTemp > 255) |
|
23712 lTemp = 255; |
|
23713 lTemp4 |= (lTemp >> 4) << 4; |
|
23714 |
|
23715 /*R component*/ |
|
23716 lTemp = lY1 + lTemp1; |
|
23717 if (lTemp < 0) |
|
23718 lTemp = 0; |
|
23719 if (lTemp > 255) |
|
23720 lTemp = 255; |
|
23721 lTemp4 |= (lTemp >> 4) << 8; |
|
23722 |
|
23723 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
23724 |
|
23725 lRGBFramePtr += 2; |
|
23726 lRGBFramePtr1 += 2; |
|
23727 } |
|
23728 |
|
23729 lCr1 = lCrPtr[j >> 1]; |
|
23730 lCb1 = lCbPtr[j >> 1]; |
|
23731 |
|
23732 lCr1 -= 128; |
|
23733 lCb1 -= 128; |
|
23734 |
|
23735 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
23736 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
23737 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
23738 |
|
23739 /*First Pixel*/ |
|
23740 lY1 = lLumPtr[j]; |
|
23741 |
|
23742 /*B component*/ |
|
23743 lTemp = lY1 + lTemp3; |
|
23744 if (lTemp < 0) |
|
23745 lTemp = 0; |
|
23746 if (lTemp > 255) |
|
23747 lTemp = 255; |
|
23748 lTemp4 = (lTemp >> 4); |
|
23749 |
|
23750 /*G component*/ |
|
23751 lTemp = lY1 - lTemp2 + 15; |
|
23752 if (lTemp < 0) |
|
23753 lTemp = 0; |
|
23754 if (lTemp > 255) |
|
23755 lTemp = 255; |
|
23756 lTemp4 |= (lTemp >> 4) << 4; |
|
23757 |
|
23758 /*R component*/ |
|
23759 lTemp = lY1 + lTemp1 + 5; |
|
23760 if (lTemp < 0) |
|
23761 lTemp = 0; |
|
23762 if (lTemp > 255) |
|
23763 lTemp = 255; |
|
23764 lTemp4 |= (lTemp >> 4) << 8; |
|
23765 |
|
23766 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
23767 |
|
23768 /*Third Pixel*/ |
|
23769 lY1 = lLumPtr[j + lLumWidth]; |
|
23770 |
|
23771 /*B component*/ |
|
23772 lTemp = lY1 + lTemp3 + 15; |
|
23773 if (lTemp < 0) |
|
23774 lTemp = 0; |
|
23775 if (lTemp > 255) |
|
23776 lTemp = 255; |
|
23777 lTemp4 = (lTemp >> 4); |
|
23778 |
|
23779 /*G component*/ |
|
23780 lTemp = lY1 - lTemp2 + 5; |
|
23781 if (lTemp < 0) |
|
23782 lTemp = 0; |
|
23783 if (lTemp > 255) |
|
23784 lTemp = 255; |
|
23785 lTemp4 |= (lTemp >> 4) << 4; |
|
23786 |
|
23787 /*R component*/ |
|
23788 lTemp = lY1 + lTemp1 + 10; |
|
23789 if (lTemp < 0) |
|
23790 lTemp = 0; |
|
23791 if (lTemp > 255) |
|
23792 lTemp = 255; |
|
23793 lTemp4 |= (lTemp >> 4) << 8; |
|
23794 |
|
23795 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
23796 |
|
23797 |
|
23798 /*Second Pixel*/ |
|
23799 lY1 = lLumPtr[j + 1]; |
|
23800 |
|
23801 /*B component*/ |
|
23802 lTemp = lY1 + lTemp3 + 10; |
|
23803 if (lTemp < 0) |
|
23804 lTemp = 0; |
|
23805 if (lTemp > 255) |
|
23806 lTemp = 255; |
|
23807 lTemp4 = (lTemp >> 4); |
|
23808 |
|
23809 /*G component*/ |
|
23810 lTemp = lY1 - lTemp2; |
|
23811 if (lTemp < 0) |
|
23812 lTemp = 0; |
|
23813 if (lTemp > 255) |
|
23814 lTemp = 255; |
|
23815 lTemp4 |= (lTemp >> 4) << 4; |
|
23816 |
|
23817 /*R component*/ |
|
23818 lTemp = lY1 + lTemp1 + 15; |
|
23819 if (lTemp < 0) |
|
23820 lTemp = 0; |
|
23821 if (lTemp > 255) |
|
23822 lTemp = 255; |
|
23823 lTemp4 |= (lTemp >> 4) << 8; |
|
23824 |
|
23825 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
23826 |
|
23827 |
|
23828 /*Fourth Pixel*/ |
|
23829 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
23830 |
|
23831 /*B component*/ |
|
23832 lTemp = lY1 + lTemp3 + 5; |
|
23833 if (lTemp < 0) |
|
23834 lTemp = 0; |
|
23835 if (lTemp > 255) |
|
23836 lTemp = 255; |
|
23837 lTemp4 = (lTemp >> 4); |
|
23838 |
|
23839 /*G component*/ |
|
23840 lTemp = lY1 - lTemp2 + 10; |
|
23841 if (lTemp < 0) |
|
23842 lTemp = 0; |
|
23843 if (lTemp > 255) |
|
23844 lTemp = 255; |
|
23845 lTemp4 |= (lTemp >> 4) << 4; |
|
23846 |
|
23847 /*R component*/ |
|
23848 lTemp = lY1 + lTemp1; |
|
23849 if (lTemp < 0) |
|
23850 lTemp = 0; |
|
23851 if (lTemp > 255) |
|
23852 lTemp = 255; |
|
23853 lTemp4 |= (lTemp >> 4) << 8; |
|
23854 |
|
23855 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
23856 |
|
23857 lRGBFramePtr += 2; |
|
23858 lRGBFramePtr1 += 2; |
|
23859 |
|
23860 |
|
23861 if(extraCol) |
|
23862 { |
|
23863 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
23864 lRGBFramePtr++; |
|
23865 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
23866 lRGBFramePtr1++; |
|
23867 } |
|
23868 |
|
23869 lLumPtr += (lLumWidth << 1); |
|
23870 lCrPtr += (lLumWidth >> 1); |
|
23871 lCbPtr += (lLumWidth >> 1); |
|
23872 |
|
23873 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
23874 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
23875 } |
|
23876 |
|
23877 if(extraRow) |
|
23878 { |
|
23879 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
23880 for(j = 0; j < lWidth; j += 2) |
|
23881 { |
|
23882 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
23883 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
23884 } |
|
23885 if(extraCol) |
|
23886 { |
|
23887 *lRGBFramePtr = *lRGBFramePtr1; |
|
23888 } |
|
23889 } |
|
23890 return; |
|
23891 } |
|
23892 |
|
23893 /* |
|
23894 ****************************************************************************** |
|
23895 Name : sEmz_VDec_YUV420Chr1toColor4k_Ordered_709_RR |
|
23896 Description : Converts YUV420 Chroma1 Planar to XRGB (4:4:4:4) Interleaved format |
|
23897 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
23898 uint8 *dstImage : Pointer to rgb data (o/p). |
|
23899 tWndParam *srcWindow : Pointer to structure containing source window |
|
23900 parameters like xOffset,yOffset,cropWidth, |
|
23901 cropHeight. (i/p) |
|
23902 tWndParam *dstWindow : Pointer to structure containing destination window |
|
23903 parameters like xOffset,yOffset,windWidth, |
|
23904 windHeight. (i/p) |
|
23905 Return Value : void |
|
23906 ****************************************************************************** |
|
23907 */ |
|
23908 |
|
23909 void sEmz_VDec_YUV420Chr1toColor4k_Ordered_709_RR |
|
23910 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
23911 tWndParam* srcWindow, tWndParam* dstWindow) |
|
23912 { |
|
23913 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
23914 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
23915 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
23916 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
23917 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
23918 int32 i, j, extraRow, extraCol; |
|
23919 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
23920 cropWidth,cropHeight,wndWidth,wndHeight; |
|
23921 |
|
23922 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
23923 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
23924 |
|
23925 | {0,15,5} {10,0,15} | |
|
23926 | {15,5,10} {5,10,0} | */ |
|
23927 |
|
23928 srcXOffset = srcWindow->xOffset; |
|
23929 srcYOffset = srcWindow->yOffset; |
|
23930 cropWidth = srcWindow->wndWidth; |
|
23931 cropHeight = srcWindow->wndHeight; |
|
23932 |
|
23933 dstXOffset = dstWindow->xOffset; |
|
23934 dstYOffset = dstWindow->yOffset; |
|
23935 wndWidth = dstWindow->wndWidth; |
|
23936 wndHeight = dstWindow->wndHeight; |
|
23937 |
|
23938 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
23939 { |
|
23940 lWidth = cropWidth; |
|
23941 } |
|
23942 else |
|
23943 { |
|
23944 lWidth = srcImage->width - srcXOffset; |
|
23945 } |
|
23946 |
|
23947 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
23948 { |
|
23949 lHeight = cropHeight; |
|
23950 } |
|
23951 else |
|
23952 { |
|
23953 lHeight = srcImage->height - srcYOffset; |
|
23954 } |
|
23955 |
|
23956 if (lWidth > (wndWidth - dstXOffset)) |
|
23957 { |
|
23958 lWidth = wndWidth - dstXOffset; |
|
23959 } |
|
23960 |
|
23961 if (lHeight > (wndHeight - dstYOffset)) |
|
23962 { |
|
23963 lHeight = wndHeight - dstYOffset; |
|
23964 } |
|
23965 |
|
23966 extraCol = lWidth & 0x01; |
|
23967 extraRow = lHeight & 0x01; |
|
23968 |
|
23969 lTempWidth = lWidth; |
|
23970 lWidth = (lWidth >> 1) << 1; |
|
23971 lHeight = (lHeight >> 1) << 1; |
|
23972 |
|
23973 lLumWidth = (srcImage->width >> 1) << 1; |
|
23974 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
23975 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
23976 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
23977 |
|
23978 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
23979 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
23980 |
|
23981 for(i = 0; i < lHeight; i += 2) |
|
23982 { |
|
23983 for(j = 0; j < (lWidth - 2); j += 2) |
|
23984 { |
|
23985 lCr1 = lCrPtr[j >> 1]; |
|
23986 lCb1 = lCbPtr[j >> 1]; |
|
23987 |
|
23988 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
23989 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
23990 |
|
23991 lCr2 = (lCr1 + lCr2) >> 1; |
|
23992 lCb2 = (lCb1 + lCb2) >> 1; |
|
23993 |
|
23994 lCr1 -= 128; |
|
23995 lCb1 -= 128; |
|
23996 |
|
23997 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
23998 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
23999 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
24000 |
|
24001 /*First Pixel*/ |
|
24002 lY1 = lLumPtr[j]; |
|
24003 lY1 -= 16; |
|
24004 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24005 |
|
24006 /*B component*/ |
|
24007 lTemp = lY1 + lTemp3; |
|
24008 if (lTemp < 0) |
|
24009 lTemp = 0; |
|
24010 if (lTemp > 255) |
|
24011 lTemp = 255; |
|
24012 lTemp4 = (lTemp >> 4); |
|
24013 |
|
24014 /*G component*/ |
|
24015 lTemp = lY1 - lTemp2 + 15; |
|
24016 if (lTemp < 0) |
|
24017 lTemp = 0; |
|
24018 if (lTemp > 255) |
|
24019 lTemp = 255; |
|
24020 lTemp4 |= (lTemp >> 4) << 4; |
|
24021 |
|
24022 /*R component*/ |
|
24023 lTemp = lY1 + lTemp1 + 5; |
|
24024 if (lTemp < 0) |
|
24025 lTemp = 0; |
|
24026 if (lTemp > 255) |
|
24027 lTemp = 255; |
|
24028 lTemp4 |= (lTemp >> 4) << 8; |
|
24029 |
|
24030 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
24031 |
|
24032 /*Third Pixel*/ |
|
24033 lY1 = lLumPtr[j + lLumWidth]; |
|
24034 lY1 -= 16; |
|
24035 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24036 |
|
24037 /*B component*/ |
|
24038 lTemp = lY1 + lTemp3 + 15; |
|
24039 if (lTemp < 0) |
|
24040 lTemp = 0; |
|
24041 if (lTemp > 255) |
|
24042 lTemp = 255; |
|
24043 lTemp4 = (lTemp >> 4); |
|
24044 |
|
24045 /*G component*/ |
|
24046 lTemp = lY1 - lTemp2 + 5; |
|
24047 if (lTemp < 0) |
|
24048 lTemp = 0; |
|
24049 if (lTemp > 255) |
|
24050 lTemp = 255; |
|
24051 lTemp4 |= (lTemp >> 4) << 4; |
|
24052 |
|
24053 /*R component*/ |
|
24054 lTemp = lY1 + lTemp1 + 10; |
|
24055 if (lTemp < 0) |
|
24056 lTemp = 0; |
|
24057 if (lTemp > 255) |
|
24058 lTemp = 255; |
|
24059 lTemp4 |= (lTemp >> 4) << 8; |
|
24060 |
|
24061 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
24062 |
|
24063 |
|
24064 lCr2 -= 128; |
|
24065 lCb2 -= 128; |
|
24066 |
|
24067 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
24068 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
24069 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
24070 |
|
24071 /*Second Pixel*/ |
|
24072 lY1 = lLumPtr[j + 1]; |
|
24073 lY1 -= 16; |
|
24074 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24075 |
|
24076 /*B component*/ |
|
24077 lTemp = lY1 + lTemp3 + 10; |
|
24078 if (lTemp < 0) |
|
24079 lTemp = 0; |
|
24080 if (lTemp > 255) |
|
24081 lTemp = 255; |
|
24082 lTemp4 = (lTemp >> 4); |
|
24083 |
|
24084 /*G component*/ |
|
24085 lTemp = lY1 - lTemp2; |
|
24086 if (lTemp < 0) |
|
24087 lTemp = 0; |
|
24088 if (lTemp > 255) |
|
24089 lTemp = 255; |
|
24090 lTemp4 |= (lTemp >> 4) << 4; |
|
24091 |
|
24092 /*R component*/ |
|
24093 lTemp = lY1 + lTemp1 + 15; |
|
24094 if (lTemp < 0) |
|
24095 lTemp = 0; |
|
24096 if (lTemp > 255) |
|
24097 lTemp = 255; |
|
24098 lTemp4 |= (lTemp >> 4) << 8; |
|
24099 |
|
24100 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
24101 |
|
24102 |
|
24103 /*Fourth Pixel*/ |
|
24104 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
24105 lY1 -= 16; |
|
24106 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24107 |
|
24108 /*B component*/ |
|
24109 lTemp = lY1 + lTemp3 + 5; |
|
24110 if (lTemp < 0) |
|
24111 lTemp = 0; |
|
24112 if (lTemp > 255) |
|
24113 lTemp = 255; |
|
24114 lTemp4 = (lTemp >> 4); |
|
24115 |
|
24116 /*G component*/ |
|
24117 lTemp = lY1 - lTemp2 + 10; |
|
24118 if (lTemp < 0) |
|
24119 lTemp = 0; |
|
24120 if (lTemp > 255) |
|
24121 lTemp = 255; |
|
24122 lTemp4 |= (lTemp >> 4) << 4; |
|
24123 |
|
24124 /*R component*/ |
|
24125 lTemp = lY1 + lTemp1; |
|
24126 if (lTemp < 0) |
|
24127 lTemp = 0; |
|
24128 if (lTemp > 255) |
|
24129 lTemp = 255; |
|
24130 lTemp4 |= (lTemp >> 4) << 8; |
|
24131 |
|
24132 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
24133 |
|
24134 lRGBFramePtr += 2; |
|
24135 lRGBFramePtr1 += 2; |
|
24136 } |
|
24137 |
|
24138 lCr1 = lCrPtr[j >> 1]; |
|
24139 lCb1 = lCbPtr[j >> 1]; |
|
24140 |
|
24141 lCr1 -= 128; |
|
24142 lCb1 -= 128; |
|
24143 |
|
24144 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
24145 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
24146 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
24147 |
|
24148 /*First Pixel*/ |
|
24149 lY1 = lLumPtr[j]; |
|
24150 lY1 -= 16; |
|
24151 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24152 |
|
24153 /*B component*/ |
|
24154 lTemp = lY1 + lTemp3; |
|
24155 if (lTemp < 0) |
|
24156 lTemp = 0; |
|
24157 if (lTemp > 255) |
|
24158 lTemp = 255; |
|
24159 lTemp4 = (lTemp >> 4); |
|
24160 |
|
24161 /*G component*/ |
|
24162 lTemp = lY1 - lTemp2 + 15; |
|
24163 if (lTemp < 0) |
|
24164 lTemp = 0; |
|
24165 if (lTemp > 255) |
|
24166 lTemp = 255; |
|
24167 lTemp4 |= (lTemp >> 4) << 4; |
|
24168 |
|
24169 /*R component*/ |
|
24170 lTemp = lY1 + lTemp1 + 5; |
|
24171 if (lTemp < 0) |
|
24172 lTemp = 0; |
|
24173 if (lTemp > 255) |
|
24174 lTemp = 255; |
|
24175 lTemp4 |= (lTemp >> 4) << 8; |
|
24176 |
|
24177 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
24178 |
|
24179 /*Third Pixel*/ |
|
24180 lY1 = lLumPtr[j + lLumWidth]; |
|
24181 lY1 -= 16; |
|
24182 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24183 |
|
24184 /*B component*/ |
|
24185 lTemp = lY1 + lTemp3 + 15; |
|
24186 if (lTemp < 0) |
|
24187 lTemp = 0; |
|
24188 if (lTemp > 255) |
|
24189 lTemp = 255; |
|
24190 lTemp4 = (lTemp >> 4); |
|
24191 |
|
24192 /*G component*/ |
|
24193 lTemp = lY1 - lTemp2 + 5; |
|
24194 if (lTemp < 0) |
|
24195 lTemp = 0; |
|
24196 if (lTemp > 255) |
|
24197 lTemp = 255; |
|
24198 lTemp4 |= (lTemp >> 4) << 4; |
|
24199 |
|
24200 /*R component*/ |
|
24201 lTemp = lY1 + lTemp1 + 10; |
|
24202 if (lTemp < 0) |
|
24203 lTemp = 0; |
|
24204 if (lTemp > 255) |
|
24205 lTemp = 255; |
|
24206 lTemp4 |= (lTemp >> 4) << 8; |
|
24207 |
|
24208 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
24209 |
|
24210 |
|
24211 /*Second Pixel*/ |
|
24212 lY1 = lLumPtr[j + 1]; |
|
24213 lY1 -= 16; |
|
24214 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24215 |
|
24216 /*B component*/ |
|
24217 lTemp = lY1 + lTemp3 + 10; |
|
24218 if (lTemp < 0) |
|
24219 lTemp = 0; |
|
24220 if (lTemp > 255) |
|
24221 lTemp = 255; |
|
24222 lTemp4 = (lTemp >> 4); |
|
24223 |
|
24224 /*G component*/ |
|
24225 lTemp = lY1 - lTemp2; |
|
24226 if (lTemp < 0) |
|
24227 lTemp = 0; |
|
24228 if (lTemp > 255) |
|
24229 lTemp = 255; |
|
24230 lTemp4 |= (lTemp >> 4) << 4; |
|
24231 |
|
24232 /*R component*/ |
|
24233 lTemp = lY1 + lTemp1 + 15; |
|
24234 if (lTemp < 0) |
|
24235 lTemp = 0; |
|
24236 if (lTemp > 255) |
|
24237 lTemp = 255; |
|
24238 lTemp4 |= (lTemp >> 4) << 8; |
|
24239 |
|
24240 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
24241 |
|
24242 |
|
24243 /*Fourth Pixel*/ |
|
24244 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
24245 lY1 -= 16; |
|
24246 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24247 |
|
24248 /*B component*/ |
|
24249 lTemp = lY1 + lTemp3 + 5; |
|
24250 if (lTemp < 0) |
|
24251 lTemp = 0; |
|
24252 if (lTemp > 255) |
|
24253 lTemp = 255; |
|
24254 lTemp4 = (lTemp >> 4); |
|
24255 |
|
24256 /*G component*/ |
|
24257 lTemp = lY1 - lTemp2 + 10; |
|
24258 if (lTemp < 0) |
|
24259 lTemp = 0; |
|
24260 if (lTemp > 255) |
|
24261 lTemp = 255; |
|
24262 lTemp4 |= (lTemp >> 4) << 4; |
|
24263 |
|
24264 /*R component*/ |
|
24265 lTemp = lY1 + lTemp1; |
|
24266 if (lTemp < 0) |
|
24267 lTemp = 0; |
|
24268 if (lTemp > 255) |
|
24269 lTemp = 255; |
|
24270 lTemp4 |= (lTemp >> 4) << 8; |
|
24271 |
|
24272 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
24273 |
|
24274 lRGBFramePtr += 2; |
|
24275 lRGBFramePtr1 += 2; |
|
24276 |
|
24277 |
|
24278 if(extraCol) |
|
24279 { |
|
24280 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
24281 lRGBFramePtr++; |
|
24282 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
24283 lRGBFramePtr1++; |
|
24284 } |
|
24285 |
|
24286 lLumPtr += (lLumWidth << 1); |
|
24287 lCrPtr += (lLumWidth >> 1); |
|
24288 lCbPtr += (lLumWidth >> 1); |
|
24289 |
|
24290 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
24291 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
24292 } |
|
24293 |
|
24294 if(extraRow) |
|
24295 { |
|
24296 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
24297 for(j = 0; j < lWidth; j += 2) |
|
24298 { |
|
24299 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
24300 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
24301 } |
|
24302 if(extraCol) |
|
24303 { |
|
24304 *lRGBFramePtr = *lRGBFramePtr1; |
|
24305 } |
|
24306 } |
|
24307 return; |
|
24308 } |
|
24309 |
|
24310 /* |
|
24311 ****************************************************************************** |
|
24312 Name : sEmz_VDec_YUV420Chr1toColor4k_Ordered_601_5_RR |
|
24313 Description : Converts YUV420 Chroma1 Planar to XRGB (4:4:4:4) Interleaved format |
|
24314 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
24315 uint8 *dstImage : Pointer to rgb data (o/p). |
|
24316 tWndParam *srcWindow : Pointer to structure containing source window |
|
24317 parameters like xOffset,yOffset,cropWidth, |
|
24318 cropHeight. (i/p) |
|
24319 tWndParam *dstWindow : Pointer to structure containing destination window |
|
24320 parameters like xOffset,yOffset,windWidth, |
|
24321 windHeight. (i/p) |
|
24322 Return Value : void |
|
24323 ****************************************************************************** |
|
24324 */ |
|
24325 |
|
24326 void sEmz_VDec_YUV420Chr1toColor4k_Ordered_601_5_RR |
|
24327 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
24328 tWndParam* srcWindow, tWndParam* dstWindow) |
|
24329 { |
|
24330 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
24331 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
24332 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
24333 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
24334 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
24335 int32 i, j, extraRow, extraCol; |
|
24336 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
24337 cropWidth,cropHeight,wndWidth,wndHeight; |
|
24338 |
|
24339 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
24340 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
24341 |
|
24342 | {0,15,5} {10,0,15} | |
|
24343 | {15,5,10} {5,10,0} | */ |
|
24344 |
|
24345 srcXOffset = srcWindow->xOffset; |
|
24346 srcYOffset = srcWindow->yOffset; |
|
24347 cropWidth = srcWindow->wndWidth; |
|
24348 cropHeight = srcWindow->wndHeight; |
|
24349 |
|
24350 dstXOffset = dstWindow->xOffset; |
|
24351 dstYOffset = dstWindow->yOffset; |
|
24352 wndWidth = dstWindow->wndWidth; |
|
24353 wndHeight = dstWindow->wndHeight; |
|
24354 |
|
24355 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
24356 { |
|
24357 lWidth = cropWidth; |
|
24358 } |
|
24359 else |
|
24360 { |
|
24361 lWidth = srcImage->width - srcXOffset; |
|
24362 } |
|
24363 |
|
24364 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
24365 { |
|
24366 lHeight = cropHeight; |
|
24367 } |
|
24368 else |
|
24369 { |
|
24370 lHeight = srcImage->height - srcYOffset; |
|
24371 } |
|
24372 |
|
24373 if (lWidth > (wndWidth - dstXOffset)) |
|
24374 { |
|
24375 lWidth = wndWidth - dstXOffset; |
|
24376 } |
|
24377 |
|
24378 if (lHeight > (wndHeight - dstYOffset)) |
|
24379 { |
|
24380 lHeight = wndHeight - dstYOffset; |
|
24381 } |
|
24382 |
|
24383 extraCol = lWidth & 0x01; |
|
24384 extraRow = lHeight & 0x01; |
|
24385 |
|
24386 lTempWidth = lWidth; |
|
24387 lWidth = (lWidth >> 1) << 1; |
|
24388 lHeight = (lHeight >> 1) << 1; |
|
24389 |
|
24390 lLumWidth = (srcImage->width >> 1) << 1; |
|
24391 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
24392 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
24393 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
24394 |
|
24395 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
24396 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
24397 |
|
24398 for(i = 0; i < lHeight; i += 2) |
|
24399 { |
|
24400 for(j = 0; j < (lWidth - 2); j += 2) |
|
24401 { |
|
24402 lCr1 = lCrPtr[j >> 1]; |
|
24403 lCb1 = lCbPtr[j >> 1]; |
|
24404 |
|
24405 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
24406 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
24407 |
|
24408 lCr2 = (lCr1 + lCr2) >> 1; |
|
24409 lCb2 = (lCb1 + lCb2) >> 1; |
|
24410 |
|
24411 lCr1 -= 128; |
|
24412 lCb1 -= 128; |
|
24413 |
|
24414 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
24415 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
24416 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
24417 |
|
24418 /*First Pixel*/ |
|
24419 lY1 = lLumPtr[j]; |
|
24420 lY1 -= 16; |
|
24421 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24422 |
|
24423 /*B component*/ |
|
24424 lTemp = lY1 + lTemp3; |
|
24425 if (lTemp < 0) |
|
24426 lTemp = 0; |
|
24427 if (lTemp > 255) |
|
24428 lTemp = 255; |
|
24429 lTemp4 = (lTemp >> 4); |
|
24430 |
|
24431 /*G component*/ |
|
24432 lTemp = lY1 - lTemp2 + 15; |
|
24433 if (lTemp < 0) |
|
24434 lTemp = 0; |
|
24435 if (lTemp > 255) |
|
24436 lTemp = 255; |
|
24437 lTemp4 |= (lTemp >> 4) << 4; |
|
24438 |
|
24439 /*R component*/ |
|
24440 lTemp = lY1 + lTemp1 + 5; |
|
24441 if (lTemp < 0) |
|
24442 lTemp = 0; |
|
24443 if (lTemp > 255) |
|
24444 lTemp = 255; |
|
24445 lTemp4 |= (lTemp >> 4) << 8; |
|
24446 |
|
24447 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
24448 |
|
24449 /*Third Pixel*/ |
|
24450 lY1 = lLumPtr[j + lLumWidth]; |
|
24451 lY1 -= 16; |
|
24452 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24453 |
|
24454 /*B component*/ |
|
24455 lTemp = lY1 + lTemp3 + 15; |
|
24456 if (lTemp < 0) |
|
24457 lTemp = 0; |
|
24458 if (lTemp > 255) |
|
24459 lTemp = 255; |
|
24460 lTemp4 = (lTemp >> 4); |
|
24461 |
|
24462 /*G component*/ |
|
24463 lTemp = lY1 - lTemp2 + 5; |
|
24464 if (lTemp < 0) |
|
24465 lTemp = 0; |
|
24466 if (lTemp > 255) |
|
24467 lTemp = 255; |
|
24468 lTemp4 |= (lTemp >> 4) << 4; |
|
24469 |
|
24470 /*R component*/ |
|
24471 lTemp = lY1 + lTemp1 + 10; |
|
24472 if (lTemp < 0) |
|
24473 lTemp = 0; |
|
24474 if (lTemp > 255) |
|
24475 lTemp = 255; |
|
24476 lTemp4 |= (lTemp >> 4) << 8; |
|
24477 |
|
24478 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
24479 |
|
24480 |
|
24481 lCr2 -= 128; |
|
24482 lCb2 -= 128; |
|
24483 |
|
24484 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
24485 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
24486 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
24487 |
|
24488 /*Second Pixel*/ |
|
24489 lY1 = lLumPtr[j + 1]; |
|
24490 lY1 -= 16; |
|
24491 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24492 |
|
24493 /*B component*/ |
|
24494 lTemp = lY1 + lTemp3 + 10; |
|
24495 if (lTemp < 0) |
|
24496 lTemp = 0; |
|
24497 if (lTemp > 255) |
|
24498 lTemp = 255; |
|
24499 lTemp4 = (lTemp >> 4); |
|
24500 |
|
24501 /*G component*/ |
|
24502 lTemp = lY1 - lTemp2; |
|
24503 if (lTemp < 0) |
|
24504 lTemp = 0; |
|
24505 if (lTemp > 255) |
|
24506 lTemp = 255; |
|
24507 lTemp4 |= (lTemp >> 4) << 4; |
|
24508 |
|
24509 /*R component*/ |
|
24510 lTemp = lY1 + lTemp1 + 15; |
|
24511 if (lTemp < 0) |
|
24512 lTemp = 0; |
|
24513 if (lTemp > 255) |
|
24514 lTemp = 255; |
|
24515 lTemp4 |= (lTemp >> 4) << 8; |
|
24516 |
|
24517 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
24518 |
|
24519 |
|
24520 /*Fourth Pixel*/ |
|
24521 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
24522 lY1 -= 16; |
|
24523 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24524 |
|
24525 /*B component*/ |
|
24526 lTemp = lY1 + lTemp3 + 5; |
|
24527 if (lTemp < 0) |
|
24528 lTemp = 0; |
|
24529 if (lTemp > 255) |
|
24530 lTemp = 255; |
|
24531 lTemp4 = (lTemp >> 4); |
|
24532 |
|
24533 /*G component*/ |
|
24534 lTemp = lY1 - lTemp2 + 10; |
|
24535 if (lTemp < 0) |
|
24536 lTemp = 0; |
|
24537 if (lTemp > 255) |
|
24538 lTemp = 255; |
|
24539 lTemp4 |= (lTemp >> 4) << 4; |
|
24540 |
|
24541 /*R component*/ |
|
24542 lTemp = lY1 + lTemp1; |
|
24543 if (lTemp < 0) |
|
24544 lTemp = 0; |
|
24545 if (lTemp > 255) |
|
24546 lTemp = 255; |
|
24547 lTemp4 |= (lTemp >> 4) << 8; |
|
24548 |
|
24549 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
24550 |
|
24551 lRGBFramePtr += 2; |
|
24552 lRGBFramePtr1 += 2; |
|
24553 } |
|
24554 |
|
24555 lCr1 = lCrPtr[j >> 1]; |
|
24556 lCb1 = lCbPtr[j >> 1]; |
|
24557 |
|
24558 lCr1 -= 128; |
|
24559 lCb1 -= 128; |
|
24560 |
|
24561 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
24562 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
24563 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
24564 |
|
24565 /*First Pixel*/ |
|
24566 lY1 = lLumPtr[j]; |
|
24567 lY1 -= 16; |
|
24568 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24569 |
|
24570 /*B component*/ |
|
24571 lTemp = lY1 + lTemp3; |
|
24572 if (lTemp < 0) |
|
24573 lTemp = 0; |
|
24574 if (lTemp > 255) |
|
24575 lTemp = 255; |
|
24576 lTemp4 = (lTemp >> 4); |
|
24577 |
|
24578 /*G component*/ |
|
24579 lTemp = lY1 - lTemp2 + 15; |
|
24580 if (lTemp < 0) |
|
24581 lTemp = 0; |
|
24582 if (lTemp > 255) |
|
24583 lTemp = 255; |
|
24584 lTemp4 |= (lTemp >> 4) << 4; |
|
24585 |
|
24586 /*R component*/ |
|
24587 lTemp = lY1 + lTemp1 + 5; |
|
24588 if (lTemp < 0) |
|
24589 lTemp = 0; |
|
24590 if (lTemp > 255) |
|
24591 lTemp = 255; |
|
24592 lTemp4 |= (lTemp >> 4) << 8; |
|
24593 |
|
24594 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
24595 |
|
24596 /*Third Pixel*/ |
|
24597 lY1 = lLumPtr[j + lLumWidth]; |
|
24598 lY1 -= 16; |
|
24599 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24600 |
|
24601 /*B component*/ |
|
24602 lTemp = lY1 + lTemp3 + 15; |
|
24603 if (lTemp < 0) |
|
24604 lTemp = 0; |
|
24605 if (lTemp > 255) |
|
24606 lTemp = 255; |
|
24607 lTemp4 = (lTemp >> 4); |
|
24608 |
|
24609 /*G component*/ |
|
24610 lTemp = lY1 - lTemp2 + 5; |
|
24611 if (lTemp < 0) |
|
24612 lTemp = 0; |
|
24613 if (lTemp > 255) |
|
24614 lTemp = 255; |
|
24615 lTemp4 |= (lTemp >> 4) << 4; |
|
24616 |
|
24617 /*R component*/ |
|
24618 lTemp = lY1 + lTemp1 + 10; |
|
24619 if (lTemp < 0) |
|
24620 lTemp = 0; |
|
24621 if (lTemp > 255) |
|
24622 lTemp = 255; |
|
24623 lTemp4 |= (lTemp >> 4) << 8; |
|
24624 |
|
24625 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
24626 |
|
24627 |
|
24628 /*Second Pixel*/ |
|
24629 lY1 = lLumPtr[j + 1]; |
|
24630 lY1 -= 16; |
|
24631 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24632 |
|
24633 /*B component*/ |
|
24634 lTemp = lY1 + lTemp3 + 10; |
|
24635 if (lTemp < 0) |
|
24636 lTemp = 0; |
|
24637 if (lTemp > 255) |
|
24638 lTemp = 255; |
|
24639 lTemp4 = (lTemp >> 4); |
|
24640 |
|
24641 /*G component*/ |
|
24642 lTemp = lY1 - lTemp2; |
|
24643 if (lTemp < 0) |
|
24644 lTemp = 0; |
|
24645 if (lTemp > 255) |
|
24646 lTemp = 255; |
|
24647 lTemp4 |= (lTemp >> 4) << 4; |
|
24648 |
|
24649 /*R component*/ |
|
24650 lTemp = lY1 + lTemp1 + 15; |
|
24651 if (lTemp < 0) |
|
24652 lTemp = 0; |
|
24653 if (lTemp > 255) |
|
24654 lTemp = 255; |
|
24655 lTemp4 |= (lTemp >> 4) << 8; |
|
24656 |
|
24657 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
24658 |
|
24659 |
|
24660 /*Fourth Pixel*/ |
|
24661 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
24662 lY1 -= 16; |
|
24663 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
24664 |
|
24665 /*B component*/ |
|
24666 lTemp = lY1 + lTemp3 + 5; |
|
24667 if (lTemp < 0) |
|
24668 lTemp = 0; |
|
24669 if (lTemp > 255) |
|
24670 lTemp = 255; |
|
24671 lTemp4 = (lTemp >> 4); |
|
24672 |
|
24673 /*G component*/ |
|
24674 lTemp = lY1 - lTemp2 + 10; |
|
24675 if (lTemp < 0) |
|
24676 lTemp = 0; |
|
24677 if (lTemp > 255) |
|
24678 lTemp = 255; |
|
24679 lTemp4 |= (lTemp >> 4) << 4; |
|
24680 |
|
24681 /*R component*/ |
|
24682 lTemp = lY1 + lTemp1; |
|
24683 if (lTemp < 0) |
|
24684 lTemp = 0; |
|
24685 if (lTemp > 255) |
|
24686 lTemp = 255; |
|
24687 lTemp4 |= (lTemp >> 4) << 8; |
|
24688 |
|
24689 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
24690 |
|
24691 lRGBFramePtr += 2; |
|
24692 lRGBFramePtr1 += 2; |
|
24693 |
|
24694 |
|
24695 if(extraCol) |
|
24696 { |
|
24697 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
24698 lRGBFramePtr++; |
|
24699 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
24700 lRGBFramePtr1++; |
|
24701 } |
|
24702 |
|
24703 lLumPtr += (lLumWidth << 1); |
|
24704 lCrPtr += (lLumWidth >> 1); |
|
24705 lCbPtr += (lLumWidth >> 1); |
|
24706 |
|
24707 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
24708 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
24709 } |
|
24710 |
|
24711 if(extraRow) |
|
24712 { |
|
24713 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
24714 for(j = 0; j < lWidth; j += 2) |
|
24715 { |
|
24716 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
24717 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
24718 } |
|
24719 if(extraCol) |
|
24720 { |
|
24721 *lRGBFramePtr = *lRGBFramePtr1; |
|
24722 } |
|
24723 } |
|
24724 return; |
|
24725 } |
|
24726 |
|
24727 |
|
24728 /* |
|
24729 ****************************************************************************** |
|
24730 Name : sEmz_VDec_YUV420Chr1toColor16MU_709_FR |
|
24731 Description : Converts YUV420 Chroma2 Planar to XRGB (8:8:8:8) Interleaved format |
|
24732 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
24733 uint8 *dstImage : Pointer to rgb data (o/p). |
|
24734 tWndParam *srcWindow : Pointer to structure containing source window |
|
24735 parameters like xOffset,yOffset,cropWidth, |
|
24736 cropHeight. (i/p) |
|
24737 tWndParam *dstWindow : Pointer to structure containing destination window |
|
24738 parameters like xOffset,yOffset,windWidth, |
|
24739 windHeight. (i/p) |
|
24740 Return Value : void |
|
24741 ****************************************************************************** |
|
24742 */ |
|
24743 |
|
24744 void sEmz_VDec_YUV420Chr1toColor16MU_709_FR |
|
24745 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
24746 tWndParam* srcWindow, tWndParam* dstWindow) |
|
24747 { |
|
24748 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
24749 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
24750 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
24751 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
24752 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
24753 int32 i, j, extraRow, extraCol; |
|
24754 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
24755 cropWidth,cropHeight,wndWidth,wndHeight; |
|
24756 |
|
24757 srcXOffset = srcWindow->xOffset; |
|
24758 srcYOffset = srcWindow->yOffset; |
|
24759 cropWidth = srcWindow->wndWidth; |
|
24760 cropHeight = srcWindow->wndHeight; |
|
24761 |
|
24762 dstXOffset = dstWindow->xOffset; |
|
24763 dstYOffset = dstWindow->yOffset; |
|
24764 wndWidth = dstWindow->wndWidth; |
|
24765 wndHeight = dstWindow->wndHeight; |
|
24766 |
|
24767 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
24768 { |
|
24769 lWidth = cropWidth; |
|
24770 } |
|
24771 else |
|
24772 { |
|
24773 lWidth = srcImage->width - srcXOffset; |
|
24774 } |
|
24775 |
|
24776 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
24777 { |
|
24778 lHeight = cropHeight; |
|
24779 } |
|
24780 else |
|
24781 { |
|
24782 lHeight = srcImage->height - srcYOffset; |
|
24783 } |
|
24784 |
|
24785 if (lWidth > (wndWidth - dstXOffset)) |
|
24786 { |
|
24787 lWidth = wndWidth - dstXOffset; |
|
24788 } |
|
24789 |
|
24790 if (lHeight > (wndHeight - dstYOffset)) |
|
24791 { |
|
24792 lHeight = wndHeight - dstYOffset; |
|
24793 } |
|
24794 |
|
24795 extraCol = lWidth & 0x01; |
|
24796 extraRow = lHeight & 0x01; |
|
24797 |
|
24798 lTempWidth = lWidth; |
|
24799 lWidth = (lWidth >> 1) << 1; |
|
24800 lHeight = (lHeight >> 1) << 1; |
|
24801 |
|
24802 lLumWidth = (srcImage->width >> 1) << 1; |
|
24803 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
24804 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
24805 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
24806 |
|
24807 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
24808 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
24809 |
|
24810 for(i = 0; i < lHeight; i += 2) |
|
24811 { |
|
24812 for(j = 0; j < (lWidth - 2); j += 2) |
|
24813 { |
|
24814 lCr1 = lCrPtr[j >> 1]; |
|
24815 lCb1 = lCbPtr[j >> 1]; |
|
24816 |
|
24817 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
24818 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
24819 |
|
24820 lCr2 = (lCr1 + lCr2) >> 1; |
|
24821 lCb2 = (lCb1 + lCb2) >> 1; |
|
24822 |
|
24823 lCr1 -= 128; |
|
24824 lCb1 -= 128; |
|
24825 |
|
24826 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
24827 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
24828 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
24829 |
|
24830 /*First Pixel*/ |
|
24831 lY1 = lLumPtr[j]; |
|
24832 |
|
24833 /*B component*/ |
|
24834 lTemp = lY1 + lTemp3; |
|
24835 if (lTemp < 0) |
|
24836 lTemp = 0; |
|
24837 if (lTemp > 255) |
|
24838 lTemp = 255; |
|
24839 lTemp4 = (uint8) lTemp; |
|
24840 |
|
24841 /*G component*/ |
|
24842 lTemp = lY1 - lTemp2; |
|
24843 if (lTemp < 0) |
|
24844 lTemp = 0; |
|
24845 if (lTemp > 255) |
|
24846 lTemp = 255; |
|
24847 lTemp4 |= lTemp << 8; |
|
24848 |
|
24849 /*R component*/ |
|
24850 lTemp = lY1 + lTemp1; |
|
24851 if (lTemp < 0) |
|
24852 lTemp = 0; |
|
24853 if (lTemp > 255) |
|
24854 lTemp = 255; |
|
24855 lTemp4 |= lTemp << 16; |
|
24856 |
|
24857 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
24858 |
|
24859 |
|
24860 /*Third Pixel*/ |
|
24861 lY1 = lLumPtr[j + lLumWidth]; |
|
24862 |
|
24863 /*B component*/ |
|
24864 lTemp = lY1 + lTemp3; |
|
24865 if (lTemp < 0) |
|
24866 lTemp = 0; |
|
24867 if (lTemp > 255) |
|
24868 lTemp = 255; |
|
24869 lTemp4 = (uint8) lTemp; |
|
24870 |
|
24871 /*G component*/ |
|
24872 lTemp = lY1 - lTemp2; |
|
24873 if (lTemp < 0) |
|
24874 lTemp = 0; |
|
24875 if (lTemp > 255) |
|
24876 lTemp = 255; |
|
24877 lTemp4 |= lTemp << 8; |
|
24878 |
|
24879 /*R component*/ |
|
24880 lTemp = lY1 + lTemp1; |
|
24881 if (lTemp < 0) |
|
24882 lTemp = 0; |
|
24883 if (lTemp > 255) |
|
24884 lTemp = 255; |
|
24885 lTemp4 |= lTemp << 16; |
|
24886 |
|
24887 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
24888 |
|
24889 |
|
24890 lCr2 -= 128; |
|
24891 lCb2 -= 128; |
|
24892 |
|
24893 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
24894 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
24895 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
24896 |
|
24897 /*Second Pixel*/ |
|
24898 lY1 = lLumPtr[j + 1]; |
|
24899 |
|
24900 /*B component*/ |
|
24901 lTemp = lY1 + lTemp3; |
|
24902 if (lTemp < 0) |
|
24903 lTemp = 0; |
|
24904 if (lTemp > 255) |
|
24905 lTemp = 255; |
|
24906 lTemp4 = (uint8) lTemp; |
|
24907 |
|
24908 /*G component*/ |
|
24909 lTemp = lY1 - lTemp2; |
|
24910 if (lTemp < 0) |
|
24911 lTemp = 0; |
|
24912 if (lTemp > 255) |
|
24913 lTemp = 255; |
|
24914 lTemp4 |= lTemp << 8; |
|
24915 |
|
24916 /*R component*/ |
|
24917 lTemp = lY1 + lTemp1; |
|
24918 if (lTemp < 0) |
|
24919 lTemp = 0; |
|
24920 if (lTemp > 255) |
|
24921 lTemp = 255; |
|
24922 lTemp4 |= lTemp << 16; |
|
24923 |
|
24924 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
24925 |
|
24926 /*Fourth Pixel*/ |
|
24927 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
24928 |
|
24929 /*B component*/ |
|
24930 lTemp = lY1 + lTemp3; |
|
24931 if (lTemp < 0) |
|
24932 lTemp = 0; |
|
24933 if (lTemp > 255) |
|
24934 lTemp = 255; |
|
24935 lTemp4 = (uint8) lTemp; |
|
24936 |
|
24937 /*G component*/ |
|
24938 lTemp = lY1 - lTemp2; |
|
24939 if (lTemp < 0) |
|
24940 lTemp = 0; |
|
24941 if (lTemp > 255) |
|
24942 lTemp = 255; |
|
24943 lTemp4 |= lTemp << 8; |
|
24944 |
|
24945 /*R component*/ |
|
24946 lTemp = lY1 + lTemp1; |
|
24947 if (lTemp < 0) |
|
24948 lTemp = 0; |
|
24949 if (lTemp > 255) |
|
24950 lTemp = 255; |
|
24951 lTemp4 |= lTemp << 16; |
|
24952 |
|
24953 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
24954 |
|
24955 lRGBFramePtr += 2; |
|
24956 lRGBFramePtr1 += 2; |
|
24957 } |
|
24958 |
|
24959 lCr1 = lCrPtr[j >> 1]; |
|
24960 lCb1 = lCbPtr[j >> 1]; |
|
24961 |
|
24962 lCr1 -= 128; |
|
24963 lCb1 -= 128; |
|
24964 |
|
24965 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
24966 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
24967 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
24968 |
|
24969 /*First Pixel*/ |
|
24970 lY1 = lLumPtr[j]; |
|
24971 |
|
24972 /*B component*/ |
|
24973 lTemp = lY1 + lTemp3; |
|
24974 if (lTemp < 0) |
|
24975 lTemp = 0; |
|
24976 if (lTemp > 255) |
|
24977 lTemp = 255; |
|
24978 lTemp4 = (uint8) lTemp; |
|
24979 |
|
24980 /*G component*/ |
|
24981 lTemp = lY1 - lTemp2; |
|
24982 if (lTemp < 0) |
|
24983 lTemp = 0; |
|
24984 if (lTemp > 255) |
|
24985 lTemp = 255; |
|
24986 lTemp4 |= lTemp << 8; |
|
24987 |
|
24988 /*R component*/ |
|
24989 lTemp = lY1 + lTemp1; |
|
24990 if (lTemp < 0) |
|
24991 lTemp = 0; |
|
24992 if (lTemp > 255) |
|
24993 lTemp = 255; |
|
24994 lTemp4 |= lTemp << 16; |
|
24995 |
|
24996 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
24997 |
|
24998 |
|
24999 /*Third Pixel*/ |
|
25000 lY1 = lLumPtr[j + lLumWidth]; |
|
25001 |
|
25002 /*B component*/ |
|
25003 lTemp = lY1 + lTemp3; |
|
25004 if (lTemp < 0) |
|
25005 lTemp = 0; |
|
25006 if (lTemp > 255) |
|
25007 lTemp = 255; |
|
25008 lTemp4 = (uint8) lTemp; |
|
25009 |
|
25010 /*G component*/ |
|
25011 lTemp = lY1 - lTemp2; |
|
25012 if (lTemp < 0) |
|
25013 lTemp = 0; |
|
25014 if (lTemp > 255) |
|
25015 lTemp = 255; |
|
25016 lTemp4 |= lTemp << 8; |
|
25017 |
|
25018 /*R component*/ |
|
25019 lTemp = lY1 + lTemp1; |
|
25020 if (lTemp < 0) |
|
25021 lTemp = 0; |
|
25022 if (lTemp > 255) |
|
25023 lTemp = 255; |
|
25024 lTemp4 |= lTemp << 16; |
|
25025 |
|
25026 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
25027 |
|
25028 /*Second Pixel*/ |
|
25029 lY1 = lLumPtr[j + 1]; |
|
25030 |
|
25031 /*B component*/ |
|
25032 lTemp = lY1 + lTemp3; |
|
25033 if (lTemp < 0) |
|
25034 lTemp = 0; |
|
25035 if (lTemp > 255) |
|
25036 lTemp = 255; |
|
25037 lTemp4 = (uint8) lTemp; |
|
25038 |
|
25039 /*G component*/ |
|
25040 lTemp = lY1 - lTemp2; |
|
25041 if (lTemp < 0) |
|
25042 lTemp = 0; |
|
25043 if (lTemp > 255) |
|
25044 lTemp = 255; |
|
25045 lTemp4 |= lTemp << 8; |
|
25046 |
|
25047 /*R component*/ |
|
25048 lTemp = lY1 + lTemp1; |
|
25049 if (lTemp < 0) |
|
25050 lTemp = 0; |
|
25051 if (lTemp > 255) |
|
25052 lTemp = 255; |
|
25053 lTemp4 |= lTemp << 16; |
|
25054 |
|
25055 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
25056 |
|
25057 /*Fourth Pixel*/ |
|
25058 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
25059 |
|
25060 /*B component*/ |
|
25061 lTemp = lY1 + lTemp3; |
|
25062 if (lTemp < 0) |
|
25063 lTemp = 0; |
|
25064 if (lTemp > 255) |
|
25065 lTemp = 255; |
|
25066 lTemp4 = (uint8) lTemp; |
|
25067 |
|
25068 /*G component*/ |
|
25069 lTemp = lY1 - lTemp2; |
|
25070 if (lTemp < 0) |
|
25071 lTemp = 0; |
|
25072 if (lTemp > 255) |
|
25073 lTemp = 255; |
|
25074 lTemp4 |= lTemp << 8; |
|
25075 |
|
25076 /*R component*/ |
|
25077 lTemp = lY1 + lTemp1; |
|
25078 if (lTemp < 0) |
|
25079 lTemp = 0; |
|
25080 if (lTemp > 255) |
|
25081 lTemp = 255; |
|
25082 lTemp4 |= lTemp << 16; |
|
25083 |
|
25084 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
25085 |
|
25086 lRGBFramePtr += 2; |
|
25087 lRGBFramePtr1 += 2; |
|
25088 |
|
25089 if(extraCol) |
|
25090 { |
|
25091 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
25092 lRGBFramePtr++; |
|
25093 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
25094 lRGBFramePtr1++; |
|
25095 } |
|
25096 |
|
25097 lLumPtr += (lLumWidth << 1); |
|
25098 lCrPtr += (lLumWidth >> 1); |
|
25099 lCbPtr += (lLumWidth >> 1); |
|
25100 |
|
25101 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
25102 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
25103 } |
|
25104 |
|
25105 if(extraRow) |
|
25106 { |
|
25107 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
25108 for(j = 0; j < lWidth; j += 2) |
|
25109 { |
|
25110 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
25111 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
25112 } |
|
25113 if(extraCol) |
|
25114 { |
|
25115 *lRGBFramePtr = *lRGBFramePtr1; |
|
25116 } |
|
25117 } |
|
25118 return; |
|
25119 } |
|
25120 |
|
25121 /* |
|
25122 ****************************************************************************** |
|
25123 Name : sEmz_VDec_YUV420Chr1toColor16MU_601_5_FR |
|
25124 Description : Converts YUV420 Chroma2 Planar to XRGB (8:8:8:8) Interleaved format |
|
25125 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
25126 uint8 *dstImage : Pointer to rgb data (o/p). |
|
25127 tWndParam *srcWindow : Pointer to structure containing source window |
|
25128 parameters like xOffset,yOffset,cropWidth, |
|
25129 cropHeight. (i/p) |
|
25130 tWndParam *dstWindow : Pointer to structure containing destination window |
|
25131 parameters like xOffset,yOffset,windWidth, |
|
25132 windHeight. (i/p) |
|
25133 Return Value : void |
|
25134 ****************************************************************************** |
|
25135 */ |
|
25136 |
|
25137 void sEmz_VDec_YUV420Chr1toColor16MU_601_5_FR |
|
25138 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
25139 tWndParam* srcWindow, tWndParam* dstWindow) |
|
25140 { |
|
25141 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
25142 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
25143 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
25144 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
25145 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
25146 int32 i, j, extraRow, extraCol; |
|
25147 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
25148 cropWidth,cropHeight,wndWidth,wndHeight; |
|
25149 |
|
25150 srcXOffset = srcWindow->xOffset; |
|
25151 srcYOffset = srcWindow->yOffset; |
|
25152 cropWidth = srcWindow->wndWidth; |
|
25153 cropHeight = srcWindow->wndHeight; |
|
25154 |
|
25155 dstXOffset = dstWindow->xOffset; |
|
25156 dstYOffset = dstWindow->yOffset; |
|
25157 wndWidth = dstWindow->wndWidth; |
|
25158 wndHeight = dstWindow->wndHeight; |
|
25159 |
|
25160 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
25161 { |
|
25162 lWidth = cropWidth; |
|
25163 } |
|
25164 else |
|
25165 { |
|
25166 lWidth = srcImage->width - srcXOffset; |
|
25167 } |
|
25168 |
|
25169 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
25170 { |
|
25171 lHeight = cropHeight; |
|
25172 } |
|
25173 else |
|
25174 { |
|
25175 lHeight = srcImage->height - srcYOffset; |
|
25176 } |
|
25177 |
|
25178 if (lWidth > (wndWidth - dstXOffset)) |
|
25179 { |
|
25180 lWidth = wndWidth - dstXOffset; |
|
25181 } |
|
25182 |
|
25183 if (lHeight > (wndHeight - dstYOffset)) |
|
25184 { |
|
25185 lHeight = wndHeight - dstYOffset; |
|
25186 } |
|
25187 |
|
25188 extraCol = lWidth & 0x01; |
|
25189 extraRow = lHeight & 0x01; |
|
25190 |
|
25191 lTempWidth = lWidth; |
|
25192 lWidth = (lWidth >> 1) << 1; |
|
25193 lHeight = (lHeight >> 1) << 1; |
|
25194 |
|
25195 lLumWidth = (srcImage->width >> 1) << 1; |
|
25196 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
25197 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
25198 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
25199 |
|
25200 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
25201 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
25202 |
|
25203 for(i = 0; i < lHeight; i += 2) |
|
25204 { |
|
25205 for(j = 0; j < (lWidth - 2); j += 2) |
|
25206 { |
|
25207 lCr1 = lCrPtr[j >> 1]; |
|
25208 lCb1 = lCbPtr[j >> 1]; |
|
25209 |
|
25210 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
25211 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
25212 |
|
25213 lCr2 = (lCr1 + lCr2) >> 1; |
|
25214 lCb2 = (lCb1 + lCb2) >> 1; |
|
25215 |
|
25216 lCr1 -= 128; |
|
25217 lCb1 -= 128; |
|
25218 |
|
25219 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
25220 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
25221 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
25222 |
|
25223 /*First Pixel*/ |
|
25224 lY1 = lLumPtr[j]; |
|
25225 |
|
25226 /*B component*/ |
|
25227 lTemp = lY1 + lTemp3; |
|
25228 if (lTemp < 0) |
|
25229 lTemp = 0; |
|
25230 if (lTemp > 255) |
|
25231 lTemp = 255; |
|
25232 lTemp4 = (uint8) lTemp; |
|
25233 |
|
25234 /*G component*/ |
|
25235 lTemp = lY1 - lTemp2; |
|
25236 if (lTemp < 0) |
|
25237 lTemp = 0; |
|
25238 if (lTemp > 255) |
|
25239 lTemp = 255; |
|
25240 lTemp4 |= lTemp << 8; |
|
25241 |
|
25242 /*R component*/ |
|
25243 lTemp = lY1 + lTemp1; |
|
25244 if (lTemp < 0) |
|
25245 lTemp = 0; |
|
25246 if (lTemp > 255) |
|
25247 lTemp = 255; |
|
25248 lTemp4 |= lTemp << 16; |
|
25249 |
|
25250 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
25251 |
|
25252 |
|
25253 /*Third Pixel*/ |
|
25254 lY1 = lLumPtr[j + lLumWidth]; |
|
25255 |
|
25256 /*B component*/ |
|
25257 lTemp = lY1 + lTemp3; |
|
25258 if (lTemp < 0) |
|
25259 lTemp = 0; |
|
25260 if (lTemp > 255) |
|
25261 lTemp = 255; |
|
25262 lTemp4 = (uint8) lTemp; |
|
25263 |
|
25264 /*G component*/ |
|
25265 lTemp = lY1 - lTemp2; |
|
25266 if (lTemp < 0) |
|
25267 lTemp = 0; |
|
25268 if (lTemp > 255) |
|
25269 lTemp = 255; |
|
25270 lTemp4 |= lTemp << 8; |
|
25271 |
|
25272 /*R component*/ |
|
25273 lTemp = lY1 + lTemp1; |
|
25274 if (lTemp < 0) |
|
25275 lTemp = 0; |
|
25276 if (lTemp > 255) |
|
25277 lTemp = 255; |
|
25278 lTemp4 |= lTemp << 16; |
|
25279 |
|
25280 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
25281 |
|
25282 |
|
25283 lCr2 -= 128; |
|
25284 lCb2 -= 128; |
|
25285 |
|
25286 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
25287 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
25288 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
25289 |
|
25290 /*Second Pixel*/ |
|
25291 lY1 = lLumPtr[j + 1]; |
|
25292 |
|
25293 /*B component*/ |
|
25294 lTemp = lY1 + lTemp3; |
|
25295 if (lTemp < 0) |
|
25296 lTemp = 0; |
|
25297 if (lTemp > 255) |
|
25298 lTemp = 255; |
|
25299 lTemp4 = (uint8) lTemp; |
|
25300 |
|
25301 /*G component*/ |
|
25302 lTemp = lY1 - lTemp2; |
|
25303 if (lTemp < 0) |
|
25304 lTemp = 0; |
|
25305 if (lTemp > 255) |
|
25306 lTemp = 255; |
|
25307 lTemp4 |= lTemp << 8; |
|
25308 |
|
25309 /*R component*/ |
|
25310 lTemp = lY1 + lTemp1; |
|
25311 if (lTemp < 0) |
|
25312 lTemp = 0; |
|
25313 if (lTemp > 255) |
|
25314 lTemp = 255; |
|
25315 lTemp4 |= lTemp << 16; |
|
25316 |
|
25317 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
25318 |
|
25319 /*Fourth Pixel*/ |
|
25320 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
25321 |
|
25322 /*B component*/ |
|
25323 lTemp = lY1 + lTemp3; |
|
25324 if (lTemp < 0) |
|
25325 lTemp = 0; |
|
25326 if (lTemp > 255) |
|
25327 lTemp = 255; |
|
25328 lTemp4 = (uint8) lTemp; |
|
25329 |
|
25330 /*G component*/ |
|
25331 lTemp = lY1 - lTemp2; |
|
25332 if (lTemp < 0) |
|
25333 lTemp = 0; |
|
25334 if (lTemp > 255) |
|
25335 lTemp = 255; |
|
25336 lTemp4 |= lTemp << 8; |
|
25337 |
|
25338 /*R component*/ |
|
25339 lTemp = lY1 + lTemp1; |
|
25340 if (lTemp < 0) |
|
25341 lTemp = 0; |
|
25342 if (lTemp > 255) |
|
25343 lTemp = 255; |
|
25344 lTemp4 |= lTemp << 16; |
|
25345 |
|
25346 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
25347 |
|
25348 lRGBFramePtr += 2; |
|
25349 lRGBFramePtr1 += 2; |
|
25350 } |
|
25351 |
|
25352 lCr1 = lCrPtr[j >> 1]; |
|
25353 lCb1 = lCbPtr[j >> 1]; |
|
25354 |
|
25355 lCr1 -= 128; |
|
25356 lCb1 -= 128; |
|
25357 |
|
25358 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
25359 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
25360 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
25361 |
|
25362 /*First Pixel*/ |
|
25363 lY1 = lLumPtr[j]; |
|
25364 |
|
25365 /*B component*/ |
|
25366 lTemp = lY1 + lTemp3; |
|
25367 if (lTemp < 0) |
|
25368 lTemp = 0; |
|
25369 if (lTemp > 255) |
|
25370 lTemp = 255; |
|
25371 lTemp4 = (uint8) lTemp; |
|
25372 |
|
25373 /*G component*/ |
|
25374 lTemp = lY1 - lTemp2; |
|
25375 if (lTemp < 0) |
|
25376 lTemp = 0; |
|
25377 if (lTemp > 255) |
|
25378 lTemp = 255; |
|
25379 lTemp4 |= lTemp << 8; |
|
25380 |
|
25381 /*R component*/ |
|
25382 lTemp = lY1 + lTemp1; |
|
25383 if (lTemp < 0) |
|
25384 lTemp = 0; |
|
25385 if (lTemp > 255) |
|
25386 lTemp = 255; |
|
25387 lTemp4 |= lTemp << 16; |
|
25388 |
|
25389 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
25390 |
|
25391 |
|
25392 /*Third Pixel*/ |
|
25393 lY1 = lLumPtr[j + lLumWidth]; |
|
25394 |
|
25395 /*B component*/ |
|
25396 lTemp = lY1 + lTemp3; |
|
25397 if (lTemp < 0) |
|
25398 lTemp = 0; |
|
25399 if (lTemp > 255) |
|
25400 lTemp = 255; |
|
25401 lTemp4 = (uint8) lTemp; |
|
25402 |
|
25403 /*G component*/ |
|
25404 lTemp = lY1 - lTemp2; |
|
25405 if (lTemp < 0) |
|
25406 lTemp = 0; |
|
25407 if (lTemp > 255) |
|
25408 lTemp = 255; |
|
25409 lTemp4 |= lTemp << 8; |
|
25410 |
|
25411 /*R component*/ |
|
25412 lTemp = lY1 + lTemp1; |
|
25413 if (lTemp < 0) |
|
25414 lTemp = 0; |
|
25415 if (lTemp > 255) |
|
25416 lTemp = 255; |
|
25417 lTemp4 |= lTemp << 16; |
|
25418 |
|
25419 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
25420 |
|
25421 /*Second Pixel*/ |
|
25422 lY1 = lLumPtr[j + 1]; |
|
25423 |
|
25424 /*B component*/ |
|
25425 lTemp = lY1 + lTemp3; |
|
25426 if (lTemp < 0) |
|
25427 lTemp = 0; |
|
25428 if (lTemp > 255) |
|
25429 lTemp = 255; |
|
25430 lTemp4 = (uint8) lTemp; |
|
25431 |
|
25432 /*G component*/ |
|
25433 lTemp = lY1 - lTemp2; |
|
25434 if (lTemp < 0) |
|
25435 lTemp = 0; |
|
25436 if (lTemp > 255) |
|
25437 lTemp = 255; |
|
25438 lTemp4 |= lTemp << 8; |
|
25439 |
|
25440 /*R component*/ |
|
25441 lTemp = lY1 + lTemp1; |
|
25442 if (lTemp < 0) |
|
25443 lTemp = 0; |
|
25444 if (lTemp > 255) |
|
25445 lTemp = 255; |
|
25446 lTemp4 |= lTemp << 16; |
|
25447 |
|
25448 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
25449 |
|
25450 /*Fourth Pixel*/ |
|
25451 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
25452 |
|
25453 /*B component*/ |
|
25454 lTemp = lY1 + lTemp3; |
|
25455 if (lTemp < 0) |
|
25456 lTemp = 0; |
|
25457 if (lTemp > 255) |
|
25458 lTemp = 255; |
|
25459 lTemp4 = (uint8) lTemp; |
|
25460 |
|
25461 /*G component*/ |
|
25462 lTemp = lY1 - lTemp2; |
|
25463 if (lTemp < 0) |
|
25464 lTemp = 0; |
|
25465 if (lTemp > 255) |
|
25466 lTemp = 255; |
|
25467 lTemp4 |= lTemp << 8; |
|
25468 |
|
25469 /*R component*/ |
|
25470 lTemp = lY1 + lTemp1; |
|
25471 if (lTemp < 0) |
|
25472 lTemp = 0; |
|
25473 if (lTemp > 255) |
|
25474 lTemp = 255; |
|
25475 lTemp4 |= lTemp << 16; |
|
25476 |
|
25477 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
25478 |
|
25479 lRGBFramePtr += 2; |
|
25480 lRGBFramePtr1 += 2; |
|
25481 |
|
25482 if(extraCol) |
|
25483 { |
|
25484 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
25485 lRGBFramePtr++; |
|
25486 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
25487 lRGBFramePtr1++; |
|
25488 } |
|
25489 |
|
25490 lLumPtr += (lLumWidth << 1); |
|
25491 lCrPtr += (lLumWidth >> 1); |
|
25492 lCbPtr += (lLumWidth >> 1); |
|
25493 |
|
25494 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
25495 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
25496 } |
|
25497 |
|
25498 if(extraRow) |
|
25499 { |
|
25500 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
25501 for(j = 0; j < lWidth; j += 2) |
|
25502 { |
|
25503 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
25504 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
25505 } |
|
25506 if(extraCol) |
|
25507 { |
|
25508 *lRGBFramePtr = *lRGBFramePtr1; |
|
25509 } |
|
25510 } |
|
25511 return; |
|
25512 } |
|
25513 |
|
25514 /* |
|
25515 ****************************************************************************** |
|
25516 Name : sEmz_VDec_YUV420Chr1toColor16MU_709_RR |
|
25517 Description : Converts YUV420 Chroma2 Planar to XRGB (8:8:8:8) Interleaved format |
|
25518 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
25519 uint8 *dstImage : Pointer to rgb data (o/p). |
|
25520 tWndParam *srcWindow : Pointer to structure containing source window |
|
25521 parameters like xOffset,yOffset,cropWidth, |
|
25522 cropHeight. (i/p) |
|
25523 tWndParam *dstWindow : Pointer to structure containing destination window |
|
25524 parameters like xOffset,yOffset,windWidth, |
|
25525 windHeight. (i/p) |
|
25526 Return Value : void |
|
25527 ****************************************************************************** |
|
25528 */ |
|
25529 |
|
25530 void sEmz_VDec_YUV420Chr1toColor16MU_709_RR |
|
25531 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
25532 tWndParam* srcWindow, tWndParam* dstWindow) |
|
25533 { |
|
25534 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
25535 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
25536 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
25537 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
25538 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
25539 int32 i, j, extraRow, extraCol; |
|
25540 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
25541 cropWidth,cropHeight,wndWidth,wndHeight; |
|
25542 |
|
25543 srcXOffset = srcWindow->xOffset; |
|
25544 srcYOffset = srcWindow->yOffset; |
|
25545 cropWidth = srcWindow->wndWidth; |
|
25546 cropHeight = srcWindow->wndHeight; |
|
25547 |
|
25548 dstXOffset = dstWindow->xOffset; |
|
25549 dstYOffset = dstWindow->yOffset; |
|
25550 wndWidth = dstWindow->wndWidth; |
|
25551 wndHeight = dstWindow->wndHeight; |
|
25552 |
|
25553 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
25554 { |
|
25555 lWidth = cropWidth; |
|
25556 } |
|
25557 else |
|
25558 { |
|
25559 lWidth = srcImage->width - srcXOffset; |
|
25560 } |
|
25561 |
|
25562 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
25563 { |
|
25564 lHeight = cropHeight; |
|
25565 } |
|
25566 else |
|
25567 { |
|
25568 lHeight = srcImage->height - srcYOffset; |
|
25569 } |
|
25570 |
|
25571 if (lWidth > (wndWidth - dstXOffset)) |
|
25572 { |
|
25573 lWidth = wndWidth - dstXOffset; |
|
25574 } |
|
25575 |
|
25576 if (lHeight > (wndHeight - dstYOffset)) |
|
25577 { |
|
25578 lHeight = wndHeight - dstYOffset; |
|
25579 } |
|
25580 |
|
25581 extraCol = lWidth & 0x01; |
|
25582 extraRow = lHeight & 0x01; |
|
25583 |
|
25584 lTempWidth = lWidth; |
|
25585 lWidth = (lWidth >> 1) << 1; |
|
25586 lHeight = (lHeight >> 1) << 1; |
|
25587 |
|
25588 lLumWidth = (srcImage->width >> 1) << 1; |
|
25589 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
25590 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
25591 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
25592 |
|
25593 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
25594 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
25595 |
|
25596 for(i = 0; i < lHeight; i += 2) |
|
25597 { |
|
25598 for(j = 0; j < (lWidth - 2); j += 2) |
|
25599 { |
|
25600 lCr1 = lCrPtr[j >> 1]; |
|
25601 lCb1 = lCbPtr[j >> 1]; |
|
25602 |
|
25603 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
25604 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
25605 |
|
25606 lCr2 = (lCr1 + lCr2) >> 1; |
|
25607 lCb2 = (lCb1 + lCb2) >> 1; |
|
25608 |
|
25609 lCr1 -= 128; |
|
25610 lCb1 -= 128; |
|
25611 |
|
25612 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
25613 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
25614 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
25615 |
|
25616 /*First Pixel*/ |
|
25617 lY1 = lLumPtr[j]; |
|
25618 lY1 -= 16; |
|
25619 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
25620 |
|
25621 /*B component*/ |
|
25622 lTemp = lY1 + lTemp3; |
|
25623 if (lTemp < 0) |
|
25624 lTemp = 0; |
|
25625 if (lTemp > 255) |
|
25626 lTemp = 255; |
|
25627 lTemp4 = (uint8) lTemp; |
|
25628 |
|
25629 /*G component*/ |
|
25630 lTemp = lY1 - lTemp2; |
|
25631 if (lTemp < 0) |
|
25632 lTemp = 0; |
|
25633 if (lTemp > 255) |
|
25634 lTemp = 255; |
|
25635 lTemp4 |= lTemp << 8; |
|
25636 |
|
25637 /*R component*/ |
|
25638 lTemp = lY1 + lTemp1; |
|
25639 if (lTemp < 0) |
|
25640 lTemp = 0; |
|
25641 if (lTemp > 255) |
|
25642 lTemp = 255; |
|
25643 lTemp4 |= lTemp << 16; |
|
25644 |
|
25645 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
25646 |
|
25647 |
|
25648 /*Third Pixel*/ |
|
25649 lY1 = lLumPtr[j + lLumWidth]; |
|
25650 lY1 -= 16; |
|
25651 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
25652 |
|
25653 /*B component*/ |
|
25654 lTemp = lY1 + lTemp3; |
|
25655 if (lTemp < 0) |
|
25656 lTemp = 0; |
|
25657 if (lTemp > 255) |
|
25658 lTemp = 255; |
|
25659 lTemp4 = (uint8) lTemp; |
|
25660 |
|
25661 /*G component*/ |
|
25662 lTemp = lY1 - lTemp2; |
|
25663 if (lTemp < 0) |
|
25664 lTemp = 0; |
|
25665 if (lTemp > 255) |
|
25666 lTemp = 255; |
|
25667 lTemp4 |= lTemp << 8; |
|
25668 |
|
25669 /*R component*/ |
|
25670 lTemp = lY1 + lTemp1; |
|
25671 if (lTemp < 0) |
|
25672 lTemp = 0; |
|
25673 if (lTemp > 255) |
|
25674 lTemp = 255; |
|
25675 lTemp4 |= lTemp << 16; |
|
25676 |
|
25677 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
25678 |
|
25679 |
|
25680 lCr2 -= 128; |
|
25681 lCb2 -= 128; |
|
25682 |
|
25683 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
25684 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
25685 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
25686 |
|
25687 /*Second Pixel*/ |
|
25688 lY1 = lLumPtr[j + 1]; |
|
25689 lY1 -= 16; |
|
25690 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
25691 |
|
25692 /*B component*/ |
|
25693 lTemp = lY1 + lTemp3; |
|
25694 if (lTemp < 0) |
|
25695 lTemp = 0; |
|
25696 if (lTemp > 255) |
|
25697 lTemp = 255; |
|
25698 lTemp4 = (uint8) lTemp; |
|
25699 |
|
25700 /*G component*/ |
|
25701 lTemp = lY1 - lTemp2; |
|
25702 if (lTemp < 0) |
|
25703 lTemp = 0; |
|
25704 if (lTemp > 255) |
|
25705 lTemp = 255; |
|
25706 lTemp4 |= lTemp << 8; |
|
25707 |
|
25708 /*R component*/ |
|
25709 lTemp = lY1 + lTemp1; |
|
25710 if (lTemp < 0) |
|
25711 lTemp = 0; |
|
25712 if (lTemp > 255) |
|
25713 lTemp = 255; |
|
25714 lTemp4 |= lTemp << 16; |
|
25715 |
|
25716 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
25717 |
|
25718 /*Fourth Pixel*/ |
|
25719 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
25720 lY1 -= 16; |
|
25721 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
25722 |
|
25723 /*B component*/ |
|
25724 lTemp = lY1 + lTemp3; |
|
25725 if (lTemp < 0) |
|
25726 lTemp = 0; |
|
25727 if (lTemp > 255) |
|
25728 lTemp = 255; |
|
25729 lTemp4 = (uint8) lTemp; |
|
25730 |
|
25731 /*G component*/ |
|
25732 lTemp = lY1 - lTemp2; |
|
25733 if (lTemp < 0) |
|
25734 lTemp = 0; |
|
25735 if (lTemp > 255) |
|
25736 lTemp = 255; |
|
25737 lTemp4 |= lTemp << 8; |
|
25738 |
|
25739 /*R component*/ |
|
25740 lTemp = lY1 + lTemp1; |
|
25741 if (lTemp < 0) |
|
25742 lTemp = 0; |
|
25743 if (lTemp > 255) |
|
25744 lTemp = 255; |
|
25745 lTemp4 |= lTemp << 16; |
|
25746 |
|
25747 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
25748 |
|
25749 lRGBFramePtr += 2; |
|
25750 lRGBFramePtr1 += 2; |
|
25751 } |
|
25752 |
|
25753 lCr1 = lCrPtr[j >> 1]; |
|
25754 lCb1 = lCbPtr[j >> 1]; |
|
25755 |
|
25756 lCr1 -= 128; |
|
25757 lCb1 -= 128; |
|
25758 |
|
25759 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
25760 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
25761 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
25762 |
|
25763 /*First Pixel*/ |
|
25764 lY1 = lLumPtr[j]; |
|
25765 lY1 -= 16; |
|
25766 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
25767 |
|
25768 /*B component*/ |
|
25769 lTemp = lY1 + lTemp3; |
|
25770 if (lTemp < 0) |
|
25771 lTemp = 0; |
|
25772 if (lTemp > 255) |
|
25773 lTemp = 255; |
|
25774 lTemp4 = (uint8) lTemp; |
|
25775 |
|
25776 /*G component*/ |
|
25777 lTemp = lY1 - lTemp2; |
|
25778 if (lTemp < 0) |
|
25779 lTemp = 0; |
|
25780 if (lTemp > 255) |
|
25781 lTemp = 255; |
|
25782 lTemp4 |= lTemp << 8; |
|
25783 |
|
25784 /*R component*/ |
|
25785 lTemp = lY1 + lTemp1; |
|
25786 if (lTemp < 0) |
|
25787 lTemp = 0; |
|
25788 if (lTemp > 255) |
|
25789 lTemp = 255; |
|
25790 lTemp4 |= lTemp << 16; |
|
25791 |
|
25792 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
25793 |
|
25794 |
|
25795 /*Third Pixel*/ |
|
25796 lY1 = lLumPtr[j + lLumWidth]; |
|
25797 lY1 -= 16; |
|
25798 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
25799 |
|
25800 /*B component*/ |
|
25801 lTemp = lY1 + lTemp3; |
|
25802 if (lTemp < 0) |
|
25803 lTemp = 0; |
|
25804 if (lTemp > 255) |
|
25805 lTemp = 255; |
|
25806 lTemp4 = (uint8) lTemp; |
|
25807 |
|
25808 /*G component*/ |
|
25809 lTemp = lY1 - lTemp2; |
|
25810 if (lTemp < 0) |
|
25811 lTemp = 0; |
|
25812 if (lTemp > 255) |
|
25813 lTemp = 255; |
|
25814 lTemp4 |= lTemp << 8; |
|
25815 |
|
25816 /*R component*/ |
|
25817 lTemp = lY1 + lTemp1; |
|
25818 if (lTemp < 0) |
|
25819 lTemp = 0; |
|
25820 if (lTemp > 255) |
|
25821 lTemp = 255; |
|
25822 lTemp4 |= lTemp << 16; |
|
25823 |
|
25824 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
25825 |
|
25826 /*Second Pixel*/ |
|
25827 lY1 = lLumPtr[j + 1]; |
|
25828 lY1 -= 16; |
|
25829 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
25830 |
|
25831 /*B component*/ |
|
25832 lTemp = lY1 + lTemp3; |
|
25833 if (lTemp < 0) |
|
25834 lTemp = 0; |
|
25835 if (lTemp > 255) |
|
25836 lTemp = 255; |
|
25837 lTemp4 = (uint8) lTemp; |
|
25838 |
|
25839 /*G component*/ |
|
25840 lTemp = lY1 - lTemp2; |
|
25841 if (lTemp < 0) |
|
25842 lTemp = 0; |
|
25843 if (lTemp > 255) |
|
25844 lTemp = 255; |
|
25845 lTemp4 |= lTemp << 8; |
|
25846 |
|
25847 /*R component*/ |
|
25848 lTemp = lY1 + lTemp1; |
|
25849 if (lTemp < 0) |
|
25850 lTemp = 0; |
|
25851 if (lTemp > 255) |
|
25852 lTemp = 255; |
|
25853 lTemp4 |= lTemp << 16; |
|
25854 |
|
25855 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
25856 |
|
25857 /*Fourth Pixel*/ |
|
25858 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
25859 lY1 -= 16; |
|
25860 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
25861 |
|
25862 /*B component*/ |
|
25863 lTemp = lY1 + lTemp3; |
|
25864 if (lTemp < 0) |
|
25865 lTemp = 0; |
|
25866 if (lTemp > 255) |
|
25867 lTemp = 255; |
|
25868 lTemp4 = (uint8) lTemp; |
|
25869 |
|
25870 /*G component*/ |
|
25871 lTemp = lY1 - lTemp2; |
|
25872 if (lTemp < 0) |
|
25873 lTemp = 0; |
|
25874 if (lTemp > 255) |
|
25875 lTemp = 255; |
|
25876 lTemp4 |= lTemp << 8; |
|
25877 |
|
25878 /*R component*/ |
|
25879 lTemp = lY1 + lTemp1; |
|
25880 if (lTemp < 0) |
|
25881 lTemp = 0; |
|
25882 if (lTemp > 255) |
|
25883 lTemp = 255; |
|
25884 lTemp4 |= lTemp << 16; |
|
25885 |
|
25886 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
25887 |
|
25888 lRGBFramePtr += 2; |
|
25889 lRGBFramePtr1 += 2; |
|
25890 |
|
25891 if(extraCol) |
|
25892 { |
|
25893 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
25894 lRGBFramePtr++; |
|
25895 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
25896 lRGBFramePtr1++; |
|
25897 } |
|
25898 |
|
25899 lLumPtr += (lLumWidth << 1); |
|
25900 lCrPtr += (lLumWidth >> 1); |
|
25901 lCbPtr += (lLumWidth >> 1); |
|
25902 |
|
25903 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
25904 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
25905 } |
|
25906 |
|
25907 if(extraRow) |
|
25908 { |
|
25909 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
25910 for(j = 0; j < lWidth; j += 2) |
|
25911 { |
|
25912 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
25913 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
25914 } |
|
25915 if(extraCol) |
|
25916 { |
|
25917 *lRGBFramePtr = *lRGBFramePtr1; |
|
25918 } |
|
25919 } |
|
25920 return; |
|
25921 } |
|
25922 |
|
25923 /* |
|
25924 ****************************************************************************** |
|
25925 Name : sEmz_VDec_YUV420Chr1toColor16MU_601_5_RR |
|
25926 Description : Converts YUV420 Chroma2 Planar to XRGB (8:8:8:8) Interleaved format |
|
25927 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
25928 uint8 *dstImage : Pointer to rgb data (o/p). |
|
25929 tWndParam *srcWindow : Pointer to structure containing source window |
|
25930 parameters like xOffset,yOffset,cropWidth, |
|
25931 cropHeight. (i/p) |
|
25932 tWndParam *dstWindow : Pointer to structure containing destination window |
|
25933 parameters like xOffset,yOffset,windWidth, |
|
25934 windHeight. (i/p) |
|
25935 Return Value : void |
|
25936 ****************************************************************************** |
|
25937 */ |
|
25938 |
|
25939 void sEmz_VDec_YUV420Chr1toColor16MU_601_5_RR |
|
25940 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
25941 tWndParam* srcWindow, tWndParam* dstWindow) |
|
25942 { |
|
25943 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
25944 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
25945 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
25946 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
25947 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
25948 int32 i, j, extraRow, extraCol; |
|
25949 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
25950 cropWidth,cropHeight,wndWidth,wndHeight; |
|
25951 |
|
25952 srcXOffset = srcWindow->xOffset; |
|
25953 srcYOffset = srcWindow->yOffset; |
|
25954 cropWidth = srcWindow->wndWidth; |
|
25955 cropHeight = srcWindow->wndHeight; |
|
25956 |
|
25957 dstXOffset = dstWindow->xOffset; |
|
25958 dstYOffset = dstWindow->yOffset; |
|
25959 wndWidth = dstWindow->wndWidth; |
|
25960 wndHeight = dstWindow->wndHeight; |
|
25961 |
|
25962 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
25963 { |
|
25964 lWidth = cropWidth; |
|
25965 } |
|
25966 else |
|
25967 { |
|
25968 lWidth = srcImage->width - srcXOffset; |
|
25969 } |
|
25970 |
|
25971 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
25972 { |
|
25973 lHeight = cropHeight; |
|
25974 } |
|
25975 else |
|
25976 { |
|
25977 lHeight = srcImage->height - srcYOffset; |
|
25978 } |
|
25979 |
|
25980 if (lWidth > (wndWidth - dstXOffset)) |
|
25981 { |
|
25982 lWidth = wndWidth - dstXOffset; |
|
25983 } |
|
25984 |
|
25985 if (lHeight > (wndHeight - dstYOffset)) |
|
25986 { |
|
25987 lHeight = wndHeight - dstYOffset; |
|
25988 } |
|
25989 |
|
25990 extraCol = lWidth & 0x01; |
|
25991 extraRow = lHeight & 0x01; |
|
25992 |
|
25993 lTempWidth = lWidth; |
|
25994 lWidth = (lWidth >> 1) << 1; |
|
25995 lHeight = (lHeight >> 1) << 1; |
|
25996 |
|
25997 lLumWidth = (srcImage->width >> 1) << 1; |
|
25998 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
25999 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
26000 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
26001 |
|
26002 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
26003 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
26004 |
|
26005 for(i = 0; i < lHeight; i += 2) |
|
26006 { |
|
26007 for(j = 0; j < (lWidth - 2); j += 2) |
|
26008 { |
|
26009 lCr1 = lCrPtr[j >> 1]; |
|
26010 lCb1 = lCbPtr[j >> 1]; |
|
26011 |
|
26012 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
26013 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
26014 |
|
26015 lCr2 = (lCr1 + lCr2) >> 1; |
|
26016 lCb2 = (lCb1 + lCb2) >> 1; |
|
26017 |
|
26018 lCr1 -= 128; |
|
26019 lCb1 -= 128; |
|
26020 |
|
26021 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
26022 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
26023 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
26024 |
|
26025 /*First Pixel*/ |
|
26026 lY1 = lLumPtr[j]; |
|
26027 lY1 -= 16; |
|
26028 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
26029 |
|
26030 /*B component*/ |
|
26031 lTemp = lY1 + lTemp3; |
|
26032 if (lTemp < 0) |
|
26033 lTemp = 0; |
|
26034 if (lTemp > 255) |
|
26035 lTemp = 255; |
|
26036 lTemp4 = (uint8) lTemp; |
|
26037 |
|
26038 /*G component*/ |
|
26039 lTemp = lY1 - lTemp2; |
|
26040 if (lTemp < 0) |
|
26041 lTemp = 0; |
|
26042 if (lTemp > 255) |
|
26043 lTemp = 255; |
|
26044 lTemp4 |= lTemp << 8; |
|
26045 |
|
26046 /*R component*/ |
|
26047 lTemp = lY1 + lTemp1; |
|
26048 if (lTemp < 0) |
|
26049 lTemp = 0; |
|
26050 if (lTemp > 255) |
|
26051 lTemp = 255; |
|
26052 lTemp4 |= lTemp << 16; |
|
26053 |
|
26054 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
26055 |
|
26056 |
|
26057 /*Third Pixel*/ |
|
26058 lY1 = lLumPtr[j + lLumWidth]; |
|
26059 lY1 -= 16; |
|
26060 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
26061 |
|
26062 /*B component*/ |
|
26063 lTemp = lY1 + lTemp3; |
|
26064 if (lTemp < 0) |
|
26065 lTemp = 0; |
|
26066 if (lTemp > 255) |
|
26067 lTemp = 255; |
|
26068 lTemp4 = (uint8) lTemp; |
|
26069 |
|
26070 /*G component*/ |
|
26071 lTemp = lY1 - lTemp2; |
|
26072 if (lTemp < 0) |
|
26073 lTemp = 0; |
|
26074 if (lTemp > 255) |
|
26075 lTemp = 255; |
|
26076 lTemp4 |= lTemp << 8; |
|
26077 |
|
26078 /*R component*/ |
|
26079 lTemp = lY1 + lTemp1; |
|
26080 if (lTemp < 0) |
|
26081 lTemp = 0; |
|
26082 if (lTemp > 255) |
|
26083 lTemp = 255; |
|
26084 lTemp4 |= lTemp << 16; |
|
26085 |
|
26086 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
26087 |
|
26088 |
|
26089 lCr2 -= 128; |
|
26090 lCb2 -= 128; |
|
26091 |
|
26092 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
26093 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
26094 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
26095 |
|
26096 /*Second Pixel*/ |
|
26097 lY1 = lLumPtr[j + 1]; |
|
26098 lY1 -= 16; |
|
26099 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
26100 |
|
26101 /*B component*/ |
|
26102 lTemp = lY1 + lTemp3; |
|
26103 if (lTemp < 0) |
|
26104 lTemp = 0; |
|
26105 if (lTemp > 255) |
|
26106 lTemp = 255; |
|
26107 lTemp4 = (uint8) lTemp; |
|
26108 |
|
26109 /*G component*/ |
|
26110 lTemp = lY1 - lTemp2; |
|
26111 if (lTemp < 0) |
|
26112 lTemp = 0; |
|
26113 if (lTemp > 255) |
|
26114 lTemp = 255; |
|
26115 lTemp4 |= lTemp << 8; |
|
26116 |
|
26117 /*R component*/ |
|
26118 lTemp = lY1 + lTemp1; |
|
26119 if (lTemp < 0) |
|
26120 lTemp = 0; |
|
26121 if (lTemp > 255) |
|
26122 lTemp = 255; |
|
26123 lTemp4 |= lTemp << 16; |
|
26124 |
|
26125 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
26126 |
|
26127 /*Fourth Pixel*/ |
|
26128 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
26129 lY1 -= 16; |
|
26130 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
26131 |
|
26132 /*B component*/ |
|
26133 lTemp = lY1 + lTemp3; |
|
26134 if (lTemp < 0) |
|
26135 lTemp = 0; |
|
26136 if (lTemp > 255) |
|
26137 lTemp = 255; |
|
26138 lTemp4 = (uint8) lTemp; |
|
26139 |
|
26140 /*G component*/ |
|
26141 lTemp = lY1 - lTemp2; |
|
26142 if (lTemp < 0) |
|
26143 lTemp = 0; |
|
26144 if (lTemp > 255) |
|
26145 lTemp = 255; |
|
26146 lTemp4 |= lTemp << 8; |
|
26147 |
|
26148 /*R component*/ |
|
26149 lTemp = lY1 + lTemp1; |
|
26150 if (lTemp < 0) |
|
26151 lTemp = 0; |
|
26152 if (lTemp > 255) |
|
26153 lTemp = 255; |
|
26154 lTemp4 |= lTemp << 16; |
|
26155 |
|
26156 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
26157 |
|
26158 lRGBFramePtr += 2; |
|
26159 lRGBFramePtr1 += 2; |
|
26160 } |
|
26161 |
|
26162 lCr1 = lCrPtr[j >> 1]; |
|
26163 lCb1 = lCbPtr[j >> 1]; |
|
26164 |
|
26165 lCr1 -= 128; |
|
26166 lCb1 -= 128; |
|
26167 |
|
26168 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
26169 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
26170 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
26171 |
|
26172 /*First Pixel*/ |
|
26173 lY1 = lLumPtr[j]; |
|
26174 lY1 -= 16; |
|
26175 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
26176 |
|
26177 /*B component*/ |
|
26178 lTemp = lY1 + lTemp3; |
|
26179 if (lTemp < 0) |
|
26180 lTemp = 0; |
|
26181 if (lTemp > 255) |
|
26182 lTemp = 255; |
|
26183 lTemp4 = (uint8) lTemp; |
|
26184 |
|
26185 /*G component*/ |
|
26186 lTemp = lY1 - lTemp2; |
|
26187 if (lTemp < 0) |
|
26188 lTemp = 0; |
|
26189 if (lTemp > 255) |
|
26190 lTemp = 255; |
|
26191 lTemp4 |= lTemp << 8; |
|
26192 |
|
26193 /*R component*/ |
|
26194 lTemp = lY1 + lTemp1; |
|
26195 if (lTemp < 0) |
|
26196 lTemp = 0; |
|
26197 if (lTemp > 255) |
|
26198 lTemp = 255; |
|
26199 lTemp4 |= lTemp << 16; |
|
26200 |
|
26201 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
26202 |
|
26203 |
|
26204 /*Third Pixel*/ |
|
26205 lY1 = lLumPtr[j + lLumWidth]; |
|
26206 lY1 -= 16; |
|
26207 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
26208 |
|
26209 /*B component*/ |
|
26210 lTemp = lY1 + lTemp3; |
|
26211 if (lTemp < 0) |
|
26212 lTemp = 0; |
|
26213 if (lTemp > 255) |
|
26214 lTemp = 255; |
|
26215 lTemp4 = (uint8) lTemp; |
|
26216 |
|
26217 /*G component*/ |
|
26218 lTemp = lY1 - lTemp2; |
|
26219 if (lTemp < 0) |
|
26220 lTemp = 0; |
|
26221 if (lTemp > 255) |
|
26222 lTemp = 255; |
|
26223 lTemp4 |= lTemp << 8; |
|
26224 |
|
26225 /*R component*/ |
|
26226 lTemp = lY1 + lTemp1; |
|
26227 if (lTemp < 0) |
|
26228 lTemp = 0; |
|
26229 if (lTemp > 255) |
|
26230 lTemp = 255; |
|
26231 lTemp4 |= lTemp << 16; |
|
26232 |
|
26233 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
26234 |
|
26235 /*Second Pixel*/ |
|
26236 lY1 = lLumPtr[j + 1]; |
|
26237 lY1 -= 16; |
|
26238 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
26239 |
|
26240 /*B component*/ |
|
26241 lTemp = lY1 + lTemp3; |
|
26242 if (lTemp < 0) |
|
26243 lTemp = 0; |
|
26244 if (lTemp > 255) |
|
26245 lTemp = 255; |
|
26246 lTemp4 = (uint8) lTemp; |
|
26247 |
|
26248 /*G component*/ |
|
26249 lTemp = lY1 - lTemp2; |
|
26250 if (lTemp < 0) |
|
26251 lTemp = 0; |
|
26252 if (lTemp > 255) |
|
26253 lTemp = 255; |
|
26254 lTemp4 |= lTemp << 8; |
|
26255 |
|
26256 /*R component*/ |
|
26257 lTemp = lY1 + lTemp1; |
|
26258 if (lTemp < 0) |
|
26259 lTemp = 0; |
|
26260 if (lTemp > 255) |
|
26261 lTemp = 255; |
|
26262 lTemp4 |= lTemp << 16; |
|
26263 |
|
26264 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
26265 |
|
26266 /*Fourth Pixel*/ |
|
26267 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
26268 lY1 -= 16; |
|
26269 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
26270 |
|
26271 /*B component*/ |
|
26272 lTemp = lY1 + lTemp3; |
|
26273 if (lTemp < 0) |
|
26274 lTemp = 0; |
|
26275 if (lTemp > 255) |
|
26276 lTemp = 255; |
|
26277 lTemp4 = (uint8) lTemp; |
|
26278 |
|
26279 /*G component*/ |
|
26280 lTemp = lY1 - lTemp2; |
|
26281 if (lTemp < 0) |
|
26282 lTemp = 0; |
|
26283 if (lTemp > 255) |
|
26284 lTemp = 255; |
|
26285 lTemp4 |= lTemp << 8; |
|
26286 |
|
26287 /*R component*/ |
|
26288 lTemp = lY1 + lTemp1; |
|
26289 if (lTemp < 0) |
|
26290 lTemp = 0; |
|
26291 if (lTemp > 255) |
|
26292 lTemp = 255; |
|
26293 lTemp4 |= lTemp << 16; |
|
26294 |
|
26295 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
26296 |
|
26297 lRGBFramePtr += 2; |
|
26298 lRGBFramePtr1 += 2; |
|
26299 |
|
26300 if(extraCol) |
|
26301 { |
|
26302 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
26303 lRGBFramePtr++; |
|
26304 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
26305 lRGBFramePtr1++; |
|
26306 } |
|
26307 |
|
26308 lLumPtr += (lLumWidth << 1); |
|
26309 lCrPtr += (lLumWidth >> 1); |
|
26310 lCbPtr += (lLumWidth >> 1); |
|
26311 |
|
26312 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
26313 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
26314 } |
|
26315 |
|
26316 if(extraRow) |
|
26317 { |
|
26318 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
26319 for(j = 0; j < lWidth; j += 2) |
|
26320 { |
|
26321 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
26322 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
26323 } |
|
26324 if(extraCol) |
|
26325 { |
|
26326 *lRGBFramePtr = *lRGBFramePtr1; |
|
26327 } |
|
26328 } |
|
26329 return; |
|
26330 } |
|
26331 |
|
26332 |
|
26333 |
|
26334 /************** End of YUV420 input *************/ |
|
26335 |
|
26336 /************** Start of YUV422BE input ********/ |
|
26337 |
|
26338 /* |
|
26339 ****************************************************************************** |
|
26340 Name : sEmz_VDec_YUV422BEChr1toColor64k_Ordered_709_FR |
|
26341 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to RGB565 Interleaved format. |
|
26342 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
26343 uint8 *dstImage : Pointer to rgb data (o/p). |
|
26344 tWndParam *srcWindow : Pointer to structure containing source window |
|
26345 parameters like xOffset,yOffset,cropWidth, |
|
26346 cropHeight. (i/p) |
|
26347 tWndParam *dstWindow : Pointer to structure containing destination window |
|
26348 parameters like xOffset,yOffset,windWidth, |
|
26349 windHeight. (i/p) |
|
26350 Return Value : void |
|
26351 ****************************************************************************** |
|
26352 */ |
|
26353 |
|
26354 void sEmz_VDec_YUV422BEChr1toColor64k_Ordered_709_FR |
|
26355 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
26356 tWndParam* srcWindow, tWndParam* dstWindow) |
|
26357 { |
|
26358 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
26359 uint8 *lYuyvPtr; |
|
26360 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
26361 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
26362 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
26363 int32 i, j, extraCol, extraRow; |
|
26364 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
26365 cropWidth,cropHeight,wndWidth,wndHeight; |
|
26366 |
|
26367 srcXOffset = srcWindow->xOffset; |
|
26368 srcYOffset = srcWindow->yOffset; |
|
26369 cropWidth = srcWindow->wndWidth; |
|
26370 cropHeight = srcWindow->wndHeight; |
|
26371 |
|
26372 dstXOffset = dstWindow->xOffset; |
|
26373 dstYOffset = dstWindow->yOffset; |
|
26374 wndWidth = dstWindow->wndWidth; |
|
26375 wndHeight = dstWindow->wndHeight; |
|
26376 |
|
26377 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
26378 { |
|
26379 lWidth = cropWidth; |
|
26380 } |
|
26381 else |
|
26382 { |
|
26383 lWidth = srcImage->width - srcXOffset; |
|
26384 } |
|
26385 |
|
26386 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
26387 { |
|
26388 lHeight = cropHeight; |
|
26389 } |
|
26390 else |
|
26391 { |
|
26392 lHeight = srcImage->height - srcYOffset; |
|
26393 } |
|
26394 |
|
26395 if (lWidth > (wndWidth - dstXOffset)) |
|
26396 { |
|
26397 lWidth = wndWidth - dstXOffset; |
|
26398 } |
|
26399 |
|
26400 if (lHeight > (wndHeight - dstYOffset)) |
|
26401 { |
|
26402 lHeight = wndHeight - dstYOffset; |
|
26403 } |
|
26404 |
|
26405 extraCol = lWidth & 0x01; |
|
26406 extraRow = lHeight & 0x01; |
|
26407 |
|
26408 lTempWidth = lWidth; |
|
26409 lWidth = (lWidth >> 1) << 1; |
|
26410 lHeight = (lHeight >> 1) << 1; |
|
26411 |
|
26412 lLumWidth = (srcImage->width >> 1) << 1; |
|
26413 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
26414 |
|
26415 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
26416 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
26417 |
|
26418 lLumWidth <<= 1; |
|
26419 |
|
26420 for(i = 0; i < lHeight; i += 2) |
|
26421 { |
|
26422 for(j = 0; j < (lWidth - 2); j += 2) |
|
26423 { |
|
26424 lCb1 = lYuyvPtr[0]; |
|
26425 lCr1 = lYuyvPtr[2]; |
|
26426 |
|
26427 lCb2 = lYuyvPtr[4]; |
|
26428 lCr2 = lYuyvPtr[6]; |
|
26429 |
|
26430 lCr2 = (lCr1 + lCr2) >> 1; |
|
26431 lCb2 = (lCb1 + lCb2) >> 1; |
|
26432 |
|
26433 /*First Pixel*/ |
|
26434 lCr1 -= 128; |
|
26435 lCb1 -= 128; |
|
26436 |
|
26437 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
26438 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
26439 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
26440 |
|
26441 lY1 = lYuyvPtr[1]; |
|
26442 |
|
26443 /*B component*/ |
|
26444 lTemp = lY1 + lTemp3; |
|
26445 if (lTemp < 0) |
|
26446 lTemp = 0; |
|
26447 if (lTemp > 255) |
|
26448 lTemp = 255; |
|
26449 lTemp4 = (lTemp >> 3); |
|
26450 |
|
26451 /*G component*/ |
|
26452 lTemp = lY1 - lTemp2 + 3; |
|
26453 if (lTemp < 0) |
|
26454 lTemp = 0; |
|
26455 if (lTemp > 255) |
|
26456 lTemp = 255; |
|
26457 lTemp4 |= (lTemp >> 2) << 5; |
|
26458 |
|
26459 /*R component*/ |
|
26460 lTemp = lY1 + lTemp1 + 2; |
|
26461 if (lTemp < 0) |
|
26462 lTemp = 0; |
|
26463 if (lTemp > 255) |
|
26464 lTemp = 255; |
|
26465 lTemp4 |= (lTemp >> 3) << 11; |
|
26466 |
|
26467 lRGBFramePtr[0] = (uint16)lTemp4; |
|
26468 |
|
26469 /*Second Pixel*/ |
|
26470 lCr2 -= 128; |
|
26471 lCb2 -= 128; |
|
26472 |
|
26473 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
26474 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
26475 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
26476 |
|
26477 lY1 = lYuyvPtr[3]; |
|
26478 |
|
26479 /*B component*/ |
|
26480 lTemp = lY1 + lTemp3 + 4; |
|
26481 if (lTemp < 0) |
|
26482 lTemp = 0; |
|
26483 if (lTemp > 255) |
|
26484 lTemp = 255; |
|
26485 lTemp4 = (lTemp >> 3); |
|
26486 |
|
26487 /*G component*/ |
|
26488 lTemp = lY1 - lTemp2; |
|
26489 if (lTemp < 0) |
|
26490 lTemp = 0; |
|
26491 if (lTemp > 255) |
|
26492 lTemp = 255; |
|
26493 lTemp4 |= (lTemp >> 2) << 5; |
|
26494 |
|
26495 /*R component*/ |
|
26496 lTemp = lY1 + lTemp1 + 6; |
|
26497 if (lTemp < 0) |
|
26498 lTemp = 0; |
|
26499 if (lTemp > 255) |
|
26500 lTemp = 255; |
|
26501 lTemp4 |= (lTemp >> 3) << 11; |
|
26502 |
|
26503 lRGBFramePtr[1] = (uint16)lTemp4; |
|
26504 |
|
26505 |
|
26506 lCb1 = lYuyvPtr[lLumWidth]; |
|
26507 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
26508 |
|
26509 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
26510 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
26511 |
|
26512 lCr2 = (lCr1 + lCr2) >> 1; |
|
26513 lCb2 = (lCb1 + lCb2) >> 1; |
|
26514 |
|
26515 /*Third Pixel*/ |
|
26516 lCr1 -= 128; |
|
26517 lCb1 -= 128; |
|
26518 |
|
26519 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
26520 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
26521 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
26522 |
|
26523 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
26524 |
|
26525 /*B component*/ |
|
26526 lTemp = lY1 + lTemp3 + 6; |
|
26527 if (lTemp < 0) |
|
26528 lTemp = 0; |
|
26529 if (lTemp > 255) |
|
26530 lTemp = 255; |
|
26531 lTemp4 = (lTemp >> 3); |
|
26532 |
|
26533 /*G component*/ |
|
26534 lTemp = lY1 - lTemp2 + 1; |
|
26535 if (lTemp < 0) |
|
26536 lTemp = 0; |
|
26537 if (lTemp > 255) |
|
26538 lTemp = 255; |
|
26539 lTemp4 |= (lTemp >> 2) << 5; |
|
26540 |
|
26541 /*R component*/ |
|
26542 lTemp = lY1 + lTemp1 + 4; |
|
26543 if (lTemp < 0) |
|
26544 lTemp = 0; |
|
26545 if (lTemp > 255) |
|
26546 lTemp = 255; |
|
26547 lTemp4 |= (lTemp >> 3) << 11; |
|
26548 |
|
26549 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
26550 |
|
26551 /*Fourth Pixel*/ |
|
26552 lCr2 -= 128; |
|
26553 lCb2 -= 128; |
|
26554 |
|
26555 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
26556 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
26557 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
26558 |
|
26559 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
26560 |
|
26561 /*B component*/ |
|
26562 lTemp = lY1 + lTemp3 + 2; |
|
26563 if (lTemp < 0) |
|
26564 lTemp = 0; |
|
26565 if (lTemp > 255) |
|
26566 lTemp = 255; |
|
26567 lTemp4 = (lTemp >> 3); |
|
26568 |
|
26569 /*G component*/ |
|
26570 lTemp = lY1 - lTemp2 + 2; |
|
26571 if (lTemp < 0) |
|
26572 lTemp = 0; |
|
26573 if (lTemp > 255) |
|
26574 lTemp = 255; |
|
26575 lTemp4 |= (lTemp >> 2) << 5; |
|
26576 |
|
26577 /*R component*/ |
|
26578 lTemp = lY1 + lTemp1; |
|
26579 if (lTemp < 0) |
|
26580 lTemp = 0; |
|
26581 if (lTemp > 255) |
|
26582 lTemp = 255; |
|
26583 lTemp4 |= (lTemp >> 3) << 11; |
|
26584 |
|
26585 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
26586 |
|
26587 lYuyvPtr += 4; |
|
26588 lRGBFramePtr += 2; |
|
26589 lRGBFramePtr1 += 2; |
|
26590 } |
|
26591 |
|
26592 |
|
26593 lCb1 = lYuyvPtr[0]; |
|
26594 lCr1 = lYuyvPtr[2]; |
|
26595 |
|
26596 lCr1 -= 128; |
|
26597 lCb1 -= 128; |
|
26598 |
|
26599 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
26600 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
26601 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
26602 |
|
26603 /*First Pixel*/ |
|
26604 lY1 = lYuyvPtr[1]; |
|
26605 |
|
26606 /*B component*/ |
|
26607 lTemp = lY1 + lTemp3; |
|
26608 if (lTemp < 0) |
|
26609 lTemp = 0; |
|
26610 if (lTemp > 255) |
|
26611 lTemp = 255; |
|
26612 lTemp4 = (lTemp >> 3); |
|
26613 |
|
26614 /*G component*/ |
|
26615 lTemp = lY1 - lTemp2 + 3; |
|
26616 if (lTemp < 0) |
|
26617 lTemp = 0; |
|
26618 if (lTemp > 255) |
|
26619 lTemp = 255; |
|
26620 lTemp4 |= (lTemp >> 2) << 5; |
|
26621 |
|
26622 /*R component*/ |
|
26623 lTemp = lY1 + lTemp1 + 2; |
|
26624 if (lTemp < 0) |
|
26625 lTemp = 0; |
|
26626 if (lTemp > 255) |
|
26627 lTemp = 255; |
|
26628 lTemp4 |= (lTemp >> 3) << 11; |
|
26629 |
|
26630 lRGBFramePtr[0] = (uint16)lTemp4; |
|
26631 |
|
26632 /*Second Pixel*/ |
|
26633 lY1 = lYuyvPtr[3]; |
|
26634 |
|
26635 /*B component*/ |
|
26636 lTemp = lY1 + lTemp3 + 4; |
|
26637 if (lTemp < 0) |
|
26638 lTemp = 0; |
|
26639 if (lTemp > 255) |
|
26640 lTemp = 255; |
|
26641 lTemp4 = (lTemp >> 3); |
|
26642 |
|
26643 /*G component*/ |
|
26644 lTemp = lY1 - lTemp2; |
|
26645 if (lTemp < 0) |
|
26646 lTemp = 0; |
|
26647 if (lTemp > 255) |
|
26648 lTemp = 255; |
|
26649 lTemp4 |= (lTemp >> 2) << 5; |
|
26650 |
|
26651 /*R component*/ |
|
26652 lTemp = lY1 + lTemp1 + 6; |
|
26653 if (lTemp < 0) |
|
26654 lTemp = 0; |
|
26655 if (lTemp > 255) |
|
26656 lTemp = 255; |
|
26657 lTemp4 |= (lTemp >> 3) << 11; |
|
26658 |
|
26659 lRGBFramePtr[1] = (uint16)lTemp4; |
|
26660 |
|
26661 |
|
26662 lCb1 = lYuyvPtr[lLumWidth]; |
|
26663 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
26664 |
|
26665 lCr1 -= 128; |
|
26666 lCb1 -= 128; |
|
26667 |
|
26668 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
26669 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
26670 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
26671 |
|
26672 /*Third Pixel*/ |
|
26673 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
26674 |
|
26675 /*B component*/ |
|
26676 lTemp = lY1 + lTemp3 + 6; |
|
26677 if (lTemp < 0) |
|
26678 lTemp = 0; |
|
26679 if (lTemp > 255) |
|
26680 lTemp = 255; |
|
26681 lTemp4 = (lTemp >> 3); |
|
26682 |
|
26683 /*G component*/ |
|
26684 lTemp = lY1 - lTemp2 + 1; |
|
26685 if (lTemp < 0) |
|
26686 lTemp = 0; |
|
26687 if (lTemp > 255) |
|
26688 lTemp = 255; |
|
26689 lTemp4 |= (lTemp >> 2) << 5; |
|
26690 |
|
26691 /*R component*/ |
|
26692 lTemp = lY1 + lTemp1 + 4; |
|
26693 if (lTemp < 0) |
|
26694 lTemp = 0; |
|
26695 if (lTemp > 255) |
|
26696 lTemp = 255; |
|
26697 lTemp4 |= (lTemp >> 3) << 11; |
|
26698 |
|
26699 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
26700 |
|
26701 /*Fourth Pixel*/ |
|
26702 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
26703 |
|
26704 /*B component*/ |
|
26705 lTemp = lY1 + lTemp3 + 2; |
|
26706 if (lTemp < 0) |
|
26707 lTemp = 0; |
|
26708 if (lTemp > 255) |
|
26709 lTemp = 255; |
|
26710 lTemp4 = (lTemp >> 3); |
|
26711 |
|
26712 /*G component*/ |
|
26713 lTemp = lY1 - lTemp2 + 2; |
|
26714 if (lTemp < 0) |
|
26715 lTemp = 0; |
|
26716 if (lTemp > 255) |
|
26717 lTemp = 255; |
|
26718 lTemp4 |= (lTemp >> 2) << 5; |
|
26719 |
|
26720 /*R component*/ |
|
26721 lTemp = lY1 + lTemp1; |
|
26722 if (lTemp < 0) |
|
26723 lTemp = 0; |
|
26724 if (lTemp > 255) |
|
26725 lTemp = 255; |
|
26726 lTemp4 |= (lTemp >> 3) << 11; |
|
26727 |
|
26728 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
26729 |
|
26730 lYuyvPtr += 4; |
|
26731 lRGBFramePtr += 2; |
|
26732 lRGBFramePtr1 += 2; |
|
26733 |
|
26734 |
|
26735 if(extraCol) |
|
26736 { |
|
26737 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
26738 lRGBFramePtr++; |
|
26739 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
26740 lRGBFramePtr1++; |
|
26741 } |
|
26742 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
26743 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
26744 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
26745 } |
|
26746 |
|
26747 if(extraRow) |
|
26748 { |
|
26749 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
26750 for(j = 0; j < lWidth; j += 2) |
|
26751 { |
|
26752 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
26753 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
26754 } |
|
26755 if(extraCol) |
|
26756 { |
|
26757 *lRGBFramePtr = *lRGBFramePtr1; |
|
26758 } |
|
26759 } |
|
26760 return; |
|
26761 } |
|
26762 |
|
26763 /* |
|
26764 ****************************************************************************** |
|
26765 Name : sEmz_VDec_YUV422BEChr1toColor64k_Ordered_601_5_FR |
|
26766 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to RGB565 Interleaved format. |
|
26767 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
26768 uint8 *dstImage : Pointer to rgb data (o/p). |
|
26769 tWndParam *srcWindow : Pointer to structure containing source window |
|
26770 parameters like xOffset,yOffset,cropWidth, |
|
26771 cropHeight. (i/p) |
|
26772 tWndParam *dstWindow : Pointer to structure containing destination window |
|
26773 parameters like xOffset,yOffset,windWidth, |
|
26774 windHeight. (i/p) |
|
26775 Return Value : void |
|
26776 ****************************************************************************** |
|
26777 */ |
|
26778 |
|
26779 void sEmz_VDec_YUV422BEChr1toColor64k_Ordered_601_5_FR |
|
26780 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
26781 tWndParam* srcWindow, tWndParam* dstWindow) |
|
26782 { |
|
26783 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
26784 uint8 *lYuyvPtr; |
|
26785 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
26786 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
26787 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
26788 int32 i, j, extraCol, extraRow; |
|
26789 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
26790 cropWidth,cropHeight,wndWidth,wndHeight; |
|
26791 |
|
26792 srcXOffset = srcWindow->xOffset; |
|
26793 srcYOffset = srcWindow->yOffset; |
|
26794 cropWidth = srcWindow->wndWidth; |
|
26795 cropHeight = srcWindow->wndHeight; |
|
26796 |
|
26797 dstXOffset = dstWindow->xOffset; |
|
26798 dstYOffset = dstWindow->yOffset; |
|
26799 wndWidth = dstWindow->wndWidth; |
|
26800 wndHeight = dstWindow->wndHeight; |
|
26801 |
|
26802 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
26803 { |
|
26804 lWidth = cropWidth; |
|
26805 } |
|
26806 else |
|
26807 { |
|
26808 lWidth = srcImage->width - srcXOffset; |
|
26809 } |
|
26810 |
|
26811 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
26812 { |
|
26813 lHeight = cropHeight; |
|
26814 } |
|
26815 else |
|
26816 { |
|
26817 lHeight = srcImage->height - srcYOffset; |
|
26818 } |
|
26819 |
|
26820 if (lWidth > (wndWidth - dstXOffset)) |
|
26821 { |
|
26822 lWidth = wndWidth - dstXOffset; |
|
26823 } |
|
26824 |
|
26825 if (lHeight > (wndHeight - dstYOffset)) |
|
26826 { |
|
26827 lHeight = wndHeight - dstYOffset; |
|
26828 } |
|
26829 |
|
26830 extraCol = lWidth & 0x01; |
|
26831 extraRow = lHeight & 0x01; |
|
26832 |
|
26833 lTempWidth = lWidth; |
|
26834 lWidth = (lWidth >> 1) << 1; |
|
26835 lHeight = (lHeight >> 1) << 1; |
|
26836 |
|
26837 lLumWidth = (srcImage->width >> 1) << 1; |
|
26838 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
26839 |
|
26840 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
26841 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
26842 |
|
26843 lLumWidth <<= 1; |
|
26844 |
|
26845 for(i = 0; i < lHeight; i += 2) |
|
26846 { |
|
26847 for(j = 0; j < (lWidth - 2); j += 2) |
|
26848 { |
|
26849 lCb1 = lYuyvPtr[0]; |
|
26850 lCr1 = lYuyvPtr[2]; |
|
26851 |
|
26852 lCb2 = lYuyvPtr[4]; |
|
26853 lCr2 = lYuyvPtr[6]; |
|
26854 |
|
26855 lCr2 = (lCr1 + lCr2) >> 1; |
|
26856 lCb2 = (lCb1 + lCb2) >> 1; |
|
26857 |
|
26858 /*First Pixel*/ |
|
26859 lCr1 -= 128; |
|
26860 lCb1 -= 128; |
|
26861 |
|
26862 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
26863 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
26864 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
26865 |
|
26866 lY1 = lYuyvPtr[1]; |
|
26867 |
|
26868 /*B component*/ |
|
26869 lTemp = lY1 + lTemp3; |
|
26870 if (lTemp < 0) |
|
26871 lTemp = 0; |
|
26872 if (lTemp > 255) |
|
26873 lTemp = 255; |
|
26874 lTemp4 = (lTemp >> 3); |
|
26875 |
|
26876 /*G component*/ |
|
26877 lTemp = lY1 - lTemp2 + 3; |
|
26878 if (lTemp < 0) |
|
26879 lTemp = 0; |
|
26880 if (lTemp > 255) |
|
26881 lTemp = 255; |
|
26882 lTemp4 |= (lTemp >> 2) << 5; |
|
26883 |
|
26884 /*R component*/ |
|
26885 lTemp = lY1 + lTemp1 + 2; |
|
26886 if (lTemp < 0) |
|
26887 lTemp = 0; |
|
26888 if (lTemp > 255) |
|
26889 lTemp = 255; |
|
26890 lTemp4 |= (lTemp >> 3) << 11; |
|
26891 |
|
26892 lRGBFramePtr[0] = (uint16)lTemp4; |
|
26893 |
|
26894 /*Second Pixel*/ |
|
26895 lCr2 -= 128; |
|
26896 lCb2 -= 128; |
|
26897 |
|
26898 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
26899 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
26900 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
26901 |
|
26902 lY1 = lYuyvPtr[3]; |
|
26903 |
|
26904 /*B component*/ |
|
26905 lTemp = lY1 + lTemp3 + 4; |
|
26906 if (lTemp < 0) |
|
26907 lTemp = 0; |
|
26908 if (lTemp > 255) |
|
26909 lTemp = 255; |
|
26910 lTemp4 = (lTemp >> 3); |
|
26911 |
|
26912 /*G component*/ |
|
26913 lTemp = lY1 - lTemp2; |
|
26914 if (lTemp < 0) |
|
26915 lTemp = 0; |
|
26916 if (lTemp > 255) |
|
26917 lTemp = 255; |
|
26918 lTemp4 |= (lTemp >> 2) << 5; |
|
26919 |
|
26920 /*R component*/ |
|
26921 lTemp = lY1 + lTemp1 + 6; |
|
26922 if (lTemp < 0) |
|
26923 lTemp = 0; |
|
26924 if (lTemp > 255) |
|
26925 lTemp = 255; |
|
26926 lTemp4 |= (lTemp >> 3) << 11; |
|
26927 |
|
26928 lRGBFramePtr[1] = (uint16)lTemp4; |
|
26929 |
|
26930 |
|
26931 lCb1 = lYuyvPtr[lLumWidth]; |
|
26932 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
26933 |
|
26934 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
26935 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
26936 |
|
26937 lCr2 = (lCr1 + lCr2) >> 1; |
|
26938 lCb2 = (lCb1 + lCb2) >> 1; |
|
26939 |
|
26940 /*Third Pixel*/ |
|
26941 lCr1 -= 128; |
|
26942 lCb1 -= 128; |
|
26943 |
|
26944 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
26945 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
26946 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
26947 |
|
26948 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
26949 |
|
26950 /*B component*/ |
|
26951 lTemp = lY1 + lTemp3 + 6; |
|
26952 if (lTemp < 0) |
|
26953 lTemp = 0; |
|
26954 if (lTemp > 255) |
|
26955 lTemp = 255; |
|
26956 lTemp4 = (lTemp >> 3); |
|
26957 |
|
26958 /*G component*/ |
|
26959 lTemp = lY1 - lTemp2 + 1; |
|
26960 if (lTemp < 0) |
|
26961 lTemp = 0; |
|
26962 if (lTemp > 255) |
|
26963 lTemp = 255; |
|
26964 lTemp4 |= (lTemp >> 2) << 5; |
|
26965 |
|
26966 /*R component*/ |
|
26967 lTemp = lY1 + lTemp1 + 4; |
|
26968 if (lTemp < 0) |
|
26969 lTemp = 0; |
|
26970 if (lTemp > 255) |
|
26971 lTemp = 255; |
|
26972 lTemp4 |= (lTemp >> 3) << 11; |
|
26973 |
|
26974 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
26975 |
|
26976 /*Fourth Pixel*/ |
|
26977 lCr2 -= 128; |
|
26978 lCb2 -= 128; |
|
26979 |
|
26980 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
26981 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
26982 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
26983 |
|
26984 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
26985 |
|
26986 /*B component*/ |
|
26987 lTemp = lY1 + lTemp3 + 2; |
|
26988 if (lTemp < 0) |
|
26989 lTemp = 0; |
|
26990 if (lTemp > 255) |
|
26991 lTemp = 255; |
|
26992 lTemp4 = (lTemp >> 3); |
|
26993 |
|
26994 /*G component*/ |
|
26995 lTemp = lY1 - lTemp2 + 2; |
|
26996 if (lTemp < 0) |
|
26997 lTemp = 0; |
|
26998 if (lTemp > 255) |
|
26999 lTemp = 255; |
|
27000 lTemp4 |= (lTemp >> 2) << 5; |
|
27001 |
|
27002 /*R component*/ |
|
27003 lTemp = lY1 + lTemp1; |
|
27004 if (lTemp < 0) |
|
27005 lTemp = 0; |
|
27006 if (lTemp > 255) |
|
27007 lTemp = 255; |
|
27008 lTemp4 |= (lTemp >> 3) << 11; |
|
27009 |
|
27010 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
27011 |
|
27012 lYuyvPtr += 4; |
|
27013 lRGBFramePtr += 2; |
|
27014 lRGBFramePtr1 += 2; |
|
27015 } |
|
27016 |
|
27017 |
|
27018 lCb1 = lYuyvPtr[0]; |
|
27019 lCr1 = lYuyvPtr[2]; |
|
27020 |
|
27021 lCr1 -= 128; |
|
27022 lCb1 -= 128; |
|
27023 |
|
27024 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
27025 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
27026 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
27027 |
|
27028 /*First Pixel*/ |
|
27029 lY1 = lYuyvPtr[1]; |
|
27030 |
|
27031 /*B component*/ |
|
27032 lTemp = lY1 + lTemp3; |
|
27033 if (lTemp < 0) |
|
27034 lTemp = 0; |
|
27035 if (lTemp > 255) |
|
27036 lTemp = 255; |
|
27037 lTemp4 = (lTemp >> 3); |
|
27038 |
|
27039 /*G component*/ |
|
27040 lTemp = lY1 - lTemp2 + 3; |
|
27041 if (lTemp < 0) |
|
27042 lTemp = 0; |
|
27043 if (lTemp > 255) |
|
27044 lTemp = 255; |
|
27045 lTemp4 |= (lTemp >> 2) << 5; |
|
27046 |
|
27047 /*R component*/ |
|
27048 lTemp = lY1 + lTemp1 + 2; |
|
27049 if (lTemp < 0) |
|
27050 lTemp = 0; |
|
27051 if (lTemp > 255) |
|
27052 lTemp = 255; |
|
27053 lTemp4 |= (lTemp >> 3) << 11; |
|
27054 |
|
27055 lRGBFramePtr[0] = (uint16)lTemp4; |
|
27056 |
|
27057 /*Second Pixel*/ |
|
27058 lY1 = lYuyvPtr[3]; |
|
27059 |
|
27060 /*B component*/ |
|
27061 lTemp = lY1 + lTemp3 + 4; |
|
27062 if (lTemp < 0) |
|
27063 lTemp = 0; |
|
27064 if (lTemp > 255) |
|
27065 lTemp = 255; |
|
27066 lTemp4 = (lTemp >> 3); |
|
27067 |
|
27068 /*G component*/ |
|
27069 lTemp = lY1 - lTemp2; |
|
27070 if (lTemp < 0) |
|
27071 lTemp = 0; |
|
27072 if (lTemp > 255) |
|
27073 lTemp = 255; |
|
27074 lTemp4 |= (lTemp >> 2) << 5; |
|
27075 |
|
27076 /*R component*/ |
|
27077 lTemp = lY1 + lTemp1 + 6; |
|
27078 if (lTemp < 0) |
|
27079 lTemp = 0; |
|
27080 if (lTemp > 255) |
|
27081 lTemp = 255; |
|
27082 lTemp4 |= (lTemp >> 3) << 11; |
|
27083 |
|
27084 lRGBFramePtr[1] = (uint16)lTemp4; |
|
27085 |
|
27086 |
|
27087 lCb1 = lYuyvPtr[lLumWidth]; |
|
27088 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
27089 |
|
27090 lCr1 -= 128; |
|
27091 lCb1 -= 128; |
|
27092 |
|
27093 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
27094 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
27095 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
27096 |
|
27097 /*Third Pixel*/ |
|
27098 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
27099 |
|
27100 /*B component*/ |
|
27101 lTemp = lY1 + lTemp3 + 6; |
|
27102 if (lTemp < 0) |
|
27103 lTemp = 0; |
|
27104 if (lTemp > 255) |
|
27105 lTemp = 255; |
|
27106 lTemp4 = (lTemp >> 3); |
|
27107 |
|
27108 /*G component*/ |
|
27109 lTemp = lY1 - lTemp2 + 1; |
|
27110 if (lTemp < 0) |
|
27111 lTemp = 0; |
|
27112 if (lTemp > 255) |
|
27113 lTemp = 255; |
|
27114 lTemp4 |= (lTemp >> 2) << 5; |
|
27115 |
|
27116 /*R component*/ |
|
27117 lTemp = lY1 + lTemp1 + 4; |
|
27118 if (lTemp < 0) |
|
27119 lTemp = 0; |
|
27120 if (lTemp > 255) |
|
27121 lTemp = 255; |
|
27122 lTemp4 |= (lTemp >> 3) << 11; |
|
27123 |
|
27124 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
27125 |
|
27126 /*Fourth Pixel*/ |
|
27127 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
27128 |
|
27129 /*B component*/ |
|
27130 lTemp = lY1 + lTemp3 + 2; |
|
27131 if (lTemp < 0) |
|
27132 lTemp = 0; |
|
27133 if (lTemp > 255) |
|
27134 lTemp = 255; |
|
27135 lTemp4 = (lTemp >> 3); |
|
27136 |
|
27137 /*G component*/ |
|
27138 lTemp = lY1 - lTemp2 + 2; |
|
27139 if (lTemp < 0) |
|
27140 lTemp = 0; |
|
27141 if (lTemp > 255) |
|
27142 lTemp = 255; |
|
27143 lTemp4 |= (lTemp >> 2) << 5; |
|
27144 |
|
27145 /*R component*/ |
|
27146 lTemp = lY1 + lTemp1; |
|
27147 if (lTemp < 0) |
|
27148 lTemp = 0; |
|
27149 if (lTemp > 255) |
|
27150 lTemp = 255; |
|
27151 lTemp4 |= (lTemp >> 3) << 11; |
|
27152 |
|
27153 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
27154 |
|
27155 lYuyvPtr += 4; |
|
27156 lRGBFramePtr += 2; |
|
27157 lRGBFramePtr1 += 2; |
|
27158 |
|
27159 |
|
27160 if(extraCol) |
|
27161 { |
|
27162 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
27163 lRGBFramePtr++; |
|
27164 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
27165 lRGBFramePtr1++; |
|
27166 } |
|
27167 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
27168 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
27169 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
27170 } |
|
27171 |
|
27172 if(extraRow) |
|
27173 { |
|
27174 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
27175 for(j = 0; j < lWidth; j += 2) |
|
27176 { |
|
27177 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
27178 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
27179 } |
|
27180 if(extraCol) |
|
27181 { |
|
27182 *lRGBFramePtr = *lRGBFramePtr1; |
|
27183 } |
|
27184 } |
|
27185 return; |
|
27186 } |
|
27187 |
|
27188 /* |
|
27189 ****************************************************************************** |
|
27190 Name : sEmz_VDec_YUV422BEChr1toColor64k_Ordered_709_RR |
|
27191 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to RGB565 Interleaved format. |
|
27192 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
27193 uint8 *dstImage : Pointer to rgb data (o/p). |
|
27194 tWndParam *srcWindow : Pointer to structure containing source window |
|
27195 parameters like xOffset,yOffset,cropWidth, |
|
27196 cropHeight. (i/p) |
|
27197 tWndParam *dstWindow : Pointer to structure containing destination window |
|
27198 parameters like xOffset,yOffset,windWidth, |
|
27199 windHeight. (i/p) |
|
27200 Return Value : void |
|
27201 ****************************************************************************** |
|
27202 */ |
|
27203 |
|
27204 void sEmz_VDec_YUV422BEChr1toColor64k_Ordered_709_RR |
|
27205 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
27206 tWndParam* srcWindow, tWndParam* dstWindow) |
|
27207 { |
|
27208 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
27209 uint8 *lYuyvPtr; |
|
27210 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
27211 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
27212 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
27213 int32 i, j, extraCol, extraRow; |
|
27214 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
27215 cropWidth,cropHeight,wndWidth,wndHeight; |
|
27216 |
|
27217 srcXOffset = srcWindow->xOffset; |
|
27218 srcYOffset = srcWindow->yOffset; |
|
27219 cropWidth = srcWindow->wndWidth; |
|
27220 cropHeight = srcWindow->wndHeight; |
|
27221 |
|
27222 dstXOffset = dstWindow->xOffset; |
|
27223 dstYOffset = dstWindow->yOffset; |
|
27224 wndWidth = dstWindow->wndWidth; |
|
27225 wndHeight = dstWindow->wndHeight; |
|
27226 |
|
27227 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
27228 { |
|
27229 lWidth = cropWidth; |
|
27230 } |
|
27231 else |
|
27232 { |
|
27233 lWidth = srcImage->width - srcXOffset; |
|
27234 } |
|
27235 |
|
27236 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
27237 { |
|
27238 lHeight = cropHeight; |
|
27239 } |
|
27240 else |
|
27241 { |
|
27242 lHeight = srcImage->height - srcYOffset; |
|
27243 } |
|
27244 |
|
27245 if (lWidth > (wndWidth - dstXOffset)) |
|
27246 { |
|
27247 lWidth = wndWidth - dstXOffset; |
|
27248 } |
|
27249 |
|
27250 if (lHeight > (wndHeight - dstYOffset)) |
|
27251 { |
|
27252 lHeight = wndHeight - dstYOffset; |
|
27253 } |
|
27254 |
|
27255 extraCol = lWidth & 0x01; |
|
27256 extraRow = lHeight & 0x01; |
|
27257 |
|
27258 lTempWidth = lWidth; |
|
27259 lWidth = (lWidth >> 1) << 1; |
|
27260 lHeight = (lHeight >> 1) << 1; |
|
27261 |
|
27262 lLumWidth = (srcImage->width >> 1) << 1; |
|
27263 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
27264 |
|
27265 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
27266 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
27267 |
|
27268 lLumWidth <<= 1; |
|
27269 |
|
27270 for(i = 0; i < lHeight; i += 2) |
|
27271 { |
|
27272 for(j = 0; j < (lWidth - 2); j += 2) |
|
27273 { |
|
27274 lCb1 = lYuyvPtr[0]; |
|
27275 lCr1 = lYuyvPtr[2]; |
|
27276 |
|
27277 lCb2 = lYuyvPtr[4]; |
|
27278 lCr2 = lYuyvPtr[6]; |
|
27279 |
|
27280 lCr2 = (lCr1 + lCr2) >> 1; |
|
27281 lCb2 = (lCb1 + lCb2) >> 1; |
|
27282 |
|
27283 /*First Pixel*/ |
|
27284 lCr1 -= 128; |
|
27285 lCb1 -= 128; |
|
27286 |
|
27287 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
27288 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
27289 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
27290 |
|
27291 lY1 = lYuyvPtr[1]; |
|
27292 lY1 -= 16; |
|
27293 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27294 |
|
27295 /*B component*/ |
|
27296 lTemp = lY1 + lTemp3; |
|
27297 if (lTemp < 0) |
|
27298 lTemp = 0; |
|
27299 if (lTemp > 255) |
|
27300 lTemp = 255; |
|
27301 lTemp4 = (lTemp >> 3); |
|
27302 |
|
27303 /*G component*/ |
|
27304 lTemp = lY1 - lTemp2 + 3; |
|
27305 if (lTemp < 0) |
|
27306 lTemp = 0; |
|
27307 if (lTemp > 255) |
|
27308 lTemp = 255; |
|
27309 lTemp4 |= (lTemp >> 2) << 5; |
|
27310 |
|
27311 /*R component*/ |
|
27312 lTemp = lY1 + lTemp1 + 2; |
|
27313 if (lTemp < 0) |
|
27314 lTemp = 0; |
|
27315 if (lTemp > 255) |
|
27316 lTemp = 255; |
|
27317 lTemp4 |= (lTemp >> 3) << 11; |
|
27318 |
|
27319 lRGBFramePtr[0] = (uint16)lTemp4; |
|
27320 |
|
27321 /*Second Pixel*/ |
|
27322 lCr2 -= 128; |
|
27323 lCb2 -= 128; |
|
27324 |
|
27325 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
27326 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
27327 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
27328 |
|
27329 lY1 = lYuyvPtr[3]; |
|
27330 lY1 -= 16; |
|
27331 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27332 |
|
27333 /*B component*/ |
|
27334 lTemp = lY1 + lTemp3 + 4; |
|
27335 if (lTemp < 0) |
|
27336 lTemp = 0; |
|
27337 if (lTemp > 255) |
|
27338 lTemp = 255; |
|
27339 lTemp4 = (lTemp >> 3); |
|
27340 |
|
27341 /*G component*/ |
|
27342 lTemp = lY1 - lTemp2; |
|
27343 if (lTemp < 0) |
|
27344 lTemp = 0; |
|
27345 if (lTemp > 255) |
|
27346 lTemp = 255; |
|
27347 lTemp4 |= (lTemp >> 2) << 5; |
|
27348 |
|
27349 /*R component*/ |
|
27350 lTemp = lY1 + lTemp1 + 6; |
|
27351 if (lTemp < 0) |
|
27352 lTemp = 0; |
|
27353 if (lTemp > 255) |
|
27354 lTemp = 255; |
|
27355 lTemp4 |= (lTemp >> 3) << 11; |
|
27356 |
|
27357 lRGBFramePtr[1] = (uint16)lTemp4; |
|
27358 |
|
27359 |
|
27360 lCb1 = lYuyvPtr[lLumWidth]; |
|
27361 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
27362 |
|
27363 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
27364 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
27365 |
|
27366 lCr2 = (lCr1 + lCr2) >> 1; |
|
27367 lCb2 = (lCb1 + lCb2) >> 1; |
|
27368 |
|
27369 /*Third Pixel*/ |
|
27370 lCr1 -= 128; |
|
27371 lCb1 -= 128; |
|
27372 |
|
27373 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
27374 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
27375 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
27376 |
|
27377 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
27378 lY1 -= 16; |
|
27379 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27380 |
|
27381 /*B component*/ |
|
27382 lTemp = lY1 + lTemp3 + 6; |
|
27383 if (lTemp < 0) |
|
27384 lTemp = 0; |
|
27385 if (lTemp > 255) |
|
27386 lTemp = 255; |
|
27387 lTemp4 = (lTemp >> 3); |
|
27388 |
|
27389 /*G component*/ |
|
27390 lTemp = lY1 - lTemp2 + 1; |
|
27391 if (lTemp < 0) |
|
27392 lTemp = 0; |
|
27393 if (lTemp > 255) |
|
27394 lTemp = 255; |
|
27395 lTemp4 |= (lTemp >> 2) << 5; |
|
27396 |
|
27397 /*R component*/ |
|
27398 lTemp = lY1 + lTemp1 + 4; |
|
27399 if (lTemp < 0) |
|
27400 lTemp = 0; |
|
27401 if (lTemp > 255) |
|
27402 lTemp = 255; |
|
27403 lTemp4 |= (lTemp >> 3) << 11; |
|
27404 |
|
27405 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
27406 |
|
27407 /*Fourth Pixel*/ |
|
27408 lCr2 -= 128; |
|
27409 lCb2 -= 128; |
|
27410 |
|
27411 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
27412 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
27413 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
27414 |
|
27415 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
27416 lY1 -= 16; |
|
27417 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27418 |
|
27419 /*B component*/ |
|
27420 lTemp = lY1 + lTemp3 + 2; |
|
27421 if (lTemp < 0) |
|
27422 lTemp = 0; |
|
27423 if (lTemp > 255) |
|
27424 lTemp = 255; |
|
27425 lTemp4 = (lTemp >> 3); |
|
27426 |
|
27427 /*G component*/ |
|
27428 lTemp = lY1 - lTemp2 + 2; |
|
27429 if (lTemp < 0) |
|
27430 lTemp = 0; |
|
27431 if (lTemp > 255) |
|
27432 lTemp = 255; |
|
27433 lTemp4 |= (lTemp >> 2) << 5; |
|
27434 |
|
27435 /*R component*/ |
|
27436 lTemp = lY1 + lTemp1; |
|
27437 if (lTemp < 0) |
|
27438 lTemp = 0; |
|
27439 if (lTemp > 255) |
|
27440 lTemp = 255; |
|
27441 lTemp4 |= (lTemp >> 3) << 11; |
|
27442 |
|
27443 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
27444 |
|
27445 lYuyvPtr += 4; |
|
27446 lRGBFramePtr += 2; |
|
27447 lRGBFramePtr1 += 2; |
|
27448 } |
|
27449 |
|
27450 |
|
27451 lCb1 = lYuyvPtr[0]; |
|
27452 lCr1 = lYuyvPtr[2]; |
|
27453 |
|
27454 lCr1 -= 128; |
|
27455 lCb1 -= 128; |
|
27456 |
|
27457 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
27458 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
27459 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
27460 |
|
27461 /*First Pixel*/ |
|
27462 lY1 = lYuyvPtr[1]; |
|
27463 lY1 -= 16; |
|
27464 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27465 |
|
27466 /*B component*/ |
|
27467 lTemp = lY1 + lTemp3; |
|
27468 if (lTemp < 0) |
|
27469 lTemp = 0; |
|
27470 if (lTemp > 255) |
|
27471 lTemp = 255; |
|
27472 lTemp4 = (lTemp >> 3); |
|
27473 |
|
27474 /*G component*/ |
|
27475 lTemp = lY1 - lTemp2 + 3; |
|
27476 if (lTemp < 0) |
|
27477 lTemp = 0; |
|
27478 if (lTemp > 255) |
|
27479 lTemp = 255; |
|
27480 lTemp4 |= (lTemp >> 2) << 5; |
|
27481 |
|
27482 /*R component*/ |
|
27483 lTemp = lY1 + lTemp1 + 2; |
|
27484 if (lTemp < 0) |
|
27485 lTemp = 0; |
|
27486 if (lTemp > 255) |
|
27487 lTemp = 255; |
|
27488 lTemp4 |= (lTemp >> 3) << 11; |
|
27489 |
|
27490 lRGBFramePtr[0] = (uint16)lTemp4; |
|
27491 |
|
27492 /*Second Pixel*/ |
|
27493 lY1 = lYuyvPtr[3]; |
|
27494 lY1 -= 16; |
|
27495 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27496 |
|
27497 /*B component*/ |
|
27498 lTemp = lY1 + lTemp3 + 4; |
|
27499 if (lTemp < 0) |
|
27500 lTemp = 0; |
|
27501 if (lTemp > 255) |
|
27502 lTemp = 255; |
|
27503 lTemp4 = (lTemp >> 3); |
|
27504 |
|
27505 /*G component*/ |
|
27506 lTemp = lY1 - lTemp2; |
|
27507 if (lTemp < 0) |
|
27508 lTemp = 0; |
|
27509 if (lTemp > 255) |
|
27510 lTemp = 255; |
|
27511 lTemp4 |= (lTemp >> 2) << 5; |
|
27512 |
|
27513 /*R component*/ |
|
27514 lTemp = lY1 + lTemp1 + 6; |
|
27515 if (lTemp < 0) |
|
27516 lTemp = 0; |
|
27517 if (lTemp > 255) |
|
27518 lTemp = 255; |
|
27519 lTemp4 |= (lTemp >> 3) << 11; |
|
27520 |
|
27521 lRGBFramePtr[1] = (uint16)lTemp4; |
|
27522 |
|
27523 |
|
27524 lCb1 = lYuyvPtr[lLumWidth]; |
|
27525 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
27526 |
|
27527 lCr1 -= 128; |
|
27528 lCb1 -= 128; |
|
27529 |
|
27530 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
27531 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
27532 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
27533 |
|
27534 /*Third Pixel*/ |
|
27535 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
27536 lY1 -= 16; |
|
27537 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27538 |
|
27539 /*B component*/ |
|
27540 lTemp = lY1 + lTemp3 + 6; |
|
27541 if (lTemp < 0) |
|
27542 lTemp = 0; |
|
27543 if (lTemp > 255) |
|
27544 lTemp = 255; |
|
27545 lTemp4 = (lTemp >> 3); |
|
27546 |
|
27547 /*G component*/ |
|
27548 lTemp = lY1 - lTemp2 + 1; |
|
27549 if (lTemp < 0) |
|
27550 lTemp = 0; |
|
27551 if (lTemp > 255) |
|
27552 lTemp = 255; |
|
27553 lTemp4 |= (lTemp >> 2) << 5; |
|
27554 |
|
27555 /*R component*/ |
|
27556 lTemp = lY1 + lTemp1 + 4; |
|
27557 if (lTemp < 0) |
|
27558 lTemp = 0; |
|
27559 if (lTemp > 255) |
|
27560 lTemp = 255; |
|
27561 lTemp4 |= (lTemp >> 3) << 11; |
|
27562 |
|
27563 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
27564 |
|
27565 /*Fourth Pixel*/ |
|
27566 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
27567 lY1 -= 16; |
|
27568 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27569 |
|
27570 /*B component*/ |
|
27571 lTemp = lY1 + lTemp3 + 2; |
|
27572 if (lTemp < 0) |
|
27573 lTemp = 0; |
|
27574 if (lTemp > 255) |
|
27575 lTemp = 255; |
|
27576 lTemp4 = (lTemp >> 3); |
|
27577 |
|
27578 /*G component*/ |
|
27579 lTemp = lY1 - lTemp2 + 2; |
|
27580 if (lTemp < 0) |
|
27581 lTemp = 0; |
|
27582 if (lTemp > 255) |
|
27583 lTemp = 255; |
|
27584 lTemp4 |= (lTemp >> 2) << 5; |
|
27585 |
|
27586 /*R component*/ |
|
27587 lTemp = lY1 + lTemp1; |
|
27588 if (lTemp < 0) |
|
27589 lTemp = 0; |
|
27590 if (lTemp > 255) |
|
27591 lTemp = 255; |
|
27592 lTemp4 |= (lTemp >> 3) << 11; |
|
27593 |
|
27594 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
27595 |
|
27596 lYuyvPtr += 4; |
|
27597 lRGBFramePtr += 2; |
|
27598 lRGBFramePtr1 += 2; |
|
27599 |
|
27600 |
|
27601 if(extraCol) |
|
27602 { |
|
27603 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
27604 lRGBFramePtr++; |
|
27605 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
27606 lRGBFramePtr1++; |
|
27607 } |
|
27608 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
27609 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
27610 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
27611 } |
|
27612 |
|
27613 if(extraRow) |
|
27614 { |
|
27615 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
27616 for(j = 0; j < lWidth; j += 2) |
|
27617 { |
|
27618 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
27619 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
27620 } |
|
27621 if(extraCol) |
|
27622 { |
|
27623 *lRGBFramePtr = *lRGBFramePtr1; |
|
27624 } |
|
27625 } |
|
27626 return; |
|
27627 } |
|
27628 |
|
27629 /* |
|
27630 ****************************************************************************** |
|
27631 Name : sEmz_VDec_YUV422BEChr1toColor64k_Ordered_601_5_RR |
|
27632 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to RGB565 Interleaved format. |
|
27633 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
27634 uint8 *dstImage : Pointer to rgb data (o/p). |
|
27635 tWndParam *srcWindow : Pointer to structure containing source window |
|
27636 parameters like xOffset,yOffset,cropWidth, |
|
27637 cropHeight. (i/p) |
|
27638 tWndParam *dstWindow : Pointer to structure containing destination window |
|
27639 parameters like xOffset,yOffset,windWidth, |
|
27640 windHeight. (i/p) |
|
27641 Return Value : void |
|
27642 ****************************************************************************** |
|
27643 */ |
|
27644 |
|
27645 void sEmz_VDec_YUV422BEChr1toColor64k_Ordered_601_5_RR |
|
27646 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
27647 tWndParam* srcWindow, tWndParam* dstWindow) |
|
27648 { |
|
27649 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
27650 uint8 *lYuyvPtr; |
|
27651 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
27652 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
27653 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
27654 int32 i, j, extraCol, extraRow; |
|
27655 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
27656 cropWidth,cropHeight,wndWidth,wndHeight; |
|
27657 |
|
27658 srcXOffset = srcWindow->xOffset; |
|
27659 srcYOffset = srcWindow->yOffset; |
|
27660 cropWidth = srcWindow->wndWidth; |
|
27661 cropHeight = srcWindow->wndHeight; |
|
27662 |
|
27663 dstXOffset = dstWindow->xOffset; |
|
27664 dstYOffset = dstWindow->yOffset; |
|
27665 wndWidth = dstWindow->wndWidth; |
|
27666 wndHeight = dstWindow->wndHeight; |
|
27667 |
|
27668 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
27669 { |
|
27670 lWidth = cropWidth; |
|
27671 } |
|
27672 else |
|
27673 { |
|
27674 lWidth = srcImage->width - srcXOffset; |
|
27675 } |
|
27676 |
|
27677 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
27678 { |
|
27679 lHeight = cropHeight; |
|
27680 } |
|
27681 else |
|
27682 { |
|
27683 lHeight = srcImage->height - srcYOffset; |
|
27684 } |
|
27685 |
|
27686 if (lWidth > (wndWidth - dstXOffset)) |
|
27687 { |
|
27688 lWidth = wndWidth - dstXOffset; |
|
27689 } |
|
27690 |
|
27691 if (lHeight > (wndHeight - dstYOffset)) |
|
27692 { |
|
27693 lHeight = wndHeight - dstYOffset; |
|
27694 } |
|
27695 |
|
27696 extraCol = lWidth & 0x01; |
|
27697 extraRow = lHeight & 0x01; |
|
27698 |
|
27699 lTempWidth = lWidth; |
|
27700 lWidth = (lWidth >> 1) << 1; |
|
27701 lHeight = (lHeight >> 1) << 1; |
|
27702 |
|
27703 lLumWidth = (srcImage->width >> 1) << 1; |
|
27704 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
27705 |
|
27706 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
27707 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
27708 |
|
27709 lLumWidth <<= 1; |
|
27710 |
|
27711 for(i = 0; i < lHeight; i += 2) |
|
27712 { |
|
27713 for(j = 0; j < (lWidth - 2); j += 2) |
|
27714 { |
|
27715 lCb1 = lYuyvPtr[0]; |
|
27716 lCr1 = lYuyvPtr[2]; |
|
27717 |
|
27718 lCb2 = lYuyvPtr[4]; |
|
27719 lCr2 = lYuyvPtr[6]; |
|
27720 |
|
27721 lCr2 = (lCr1 + lCr2) >> 1; |
|
27722 lCb2 = (lCb1 + lCb2) >> 1; |
|
27723 |
|
27724 /*First Pixel*/ |
|
27725 lCr1 -= 128; |
|
27726 lCb1 -= 128; |
|
27727 |
|
27728 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
27729 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
27730 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
27731 |
|
27732 lY1 = lYuyvPtr[1]; |
|
27733 lY1 -= 16; |
|
27734 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27735 |
|
27736 /*B component*/ |
|
27737 lTemp = lY1 + lTemp3; |
|
27738 if (lTemp < 0) |
|
27739 lTemp = 0; |
|
27740 if (lTemp > 255) |
|
27741 lTemp = 255; |
|
27742 lTemp4 = (lTemp >> 3); |
|
27743 |
|
27744 /*G component*/ |
|
27745 lTemp = lY1 - lTemp2 + 3; |
|
27746 if (lTemp < 0) |
|
27747 lTemp = 0; |
|
27748 if (lTemp > 255) |
|
27749 lTemp = 255; |
|
27750 lTemp4 |= (lTemp >> 2) << 5; |
|
27751 |
|
27752 /*R component*/ |
|
27753 lTemp = lY1 + lTemp1 + 2; |
|
27754 if (lTemp < 0) |
|
27755 lTemp = 0; |
|
27756 if (lTemp > 255) |
|
27757 lTemp = 255; |
|
27758 lTemp4 |= (lTemp >> 3) << 11; |
|
27759 |
|
27760 lRGBFramePtr[0] = (uint16)lTemp4; |
|
27761 |
|
27762 /*Second Pixel*/ |
|
27763 lCr2 -= 128; |
|
27764 lCb2 -= 128; |
|
27765 |
|
27766 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
27767 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
27768 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
27769 |
|
27770 lY1 = lYuyvPtr[3]; |
|
27771 lY1 -= 16; |
|
27772 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27773 |
|
27774 /*B component*/ |
|
27775 lTemp = lY1 + lTemp3 + 4; |
|
27776 if (lTemp < 0) |
|
27777 lTemp = 0; |
|
27778 if (lTemp > 255) |
|
27779 lTemp = 255; |
|
27780 lTemp4 = (lTemp >> 3); |
|
27781 |
|
27782 /*G component*/ |
|
27783 lTemp = lY1 - lTemp2; |
|
27784 if (lTemp < 0) |
|
27785 lTemp = 0; |
|
27786 if (lTemp > 255) |
|
27787 lTemp = 255; |
|
27788 lTemp4 |= (lTemp >> 2) << 5; |
|
27789 |
|
27790 /*R component*/ |
|
27791 lTemp = lY1 + lTemp1 + 6; |
|
27792 if (lTemp < 0) |
|
27793 lTemp = 0; |
|
27794 if (lTemp > 255) |
|
27795 lTemp = 255; |
|
27796 lTemp4 |= (lTemp >> 3) << 11; |
|
27797 |
|
27798 lRGBFramePtr[1] = (uint16)lTemp4; |
|
27799 |
|
27800 |
|
27801 lCb1 = lYuyvPtr[lLumWidth]; |
|
27802 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
27803 |
|
27804 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
27805 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
27806 |
|
27807 lCr2 = (lCr1 + lCr2) >> 1; |
|
27808 lCb2 = (lCb1 + lCb2) >> 1; |
|
27809 |
|
27810 /*Third Pixel*/ |
|
27811 lCr1 -= 128; |
|
27812 lCb1 -= 128; |
|
27813 |
|
27814 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
27815 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
27816 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
27817 |
|
27818 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
27819 lY1 -= 16; |
|
27820 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27821 |
|
27822 /*B component*/ |
|
27823 lTemp = lY1 + lTemp3 + 6; |
|
27824 if (lTemp < 0) |
|
27825 lTemp = 0; |
|
27826 if (lTemp > 255) |
|
27827 lTemp = 255; |
|
27828 lTemp4 = (lTemp >> 3); |
|
27829 |
|
27830 /*G component*/ |
|
27831 lTemp = lY1 - lTemp2 + 1; |
|
27832 if (lTemp < 0) |
|
27833 lTemp = 0; |
|
27834 if (lTemp > 255) |
|
27835 lTemp = 255; |
|
27836 lTemp4 |= (lTemp >> 2) << 5; |
|
27837 |
|
27838 /*R component*/ |
|
27839 lTemp = lY1 + lTemp1 + 4; |
|
27840 if (lTemp < 0) |
|
27841 lTemp = 0; |
|
27842 if (lTemp > 255) |
|
27843 lTemp = 255; |
|
27844 lTemp4 |= (lTemp >> 3) << 11; |
|
27845 |
|
27846 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
27847 |
|
27848 /*Fourth Pixel*/ |
|
27849 lCr2 -= 128; |
|
27850 lCb2 -= 128; |
|
27851 |
|
27852 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
27853 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
27854 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
27855 |
|
27856 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
27857 lY1 -= 16; |
|
27858 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27859 |
|
27860 /*B component*/ |
|
27861 lTemp = lY1 + lTemp3 + 2; |
|
27862 if (lTemp < 0) |
|
27863 lTemp = 0; |
|
27864 if (lTemp > 255) |
|
27865 lTemp = 255; |
|
27866 lTemp4 = (lTemp >> 3); |
|
27867 |
|
27868 /*G component*/ |
|
27869 lTemp = lY1 - lTemp2 + 2; |
|
27870 if (lTemp < 0) |
|
27871 lTemp = 0; |
|
27872 if (lTemp > 255) |
|
27873 lTemp = 255; |
|
27874 lTemp4 |= (lTemp >> 2) << 5; |
|
27875 |
|
27876 /*R component*/ |
|
27877 lTemp = lY1 + lTemp1; |
|
27878 if (lTemp < 0) |
|
27879 lTemp = 0; |
|
27880 if (lTemp > 255) |
|
27881 lTemp = 255; |
|
27882 lTemp4 |= (lTemp >> 3) << 11; |
|
27883 |
|
27884 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
27885 |
|
27886 lYuyvPtr += 4; |
|
27887 lRGBFramePtr += 2; |
|
27888 lRGBFramePtr1 += 2; |
|
27889 } |
|
27890 |
|
27891 |
|
27892 lCb1 = lYuyvPtr[0]; |
|
27893 lCr1 = lYuyvPtr[2]; |
|
27894 |
|
27895 lCr1 -= 128; |
|
27896 lCb1 -= 128; |
|
27897 |
|
27898 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
27899 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
27900 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
27901 |
|
27902 /*First Pixel*/ |
|
27903 lY1 = lYuyvPtr[1]; |
|
27904 lY1 -= 16; |
|
27905 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27906 |
|
27907 /*B component*/ |
|
27908 lTemp = lY1 + lTemp3; |
|
27909 if (lTemp < 0) |
|
27910 lTemp = 0; |
|
27911 if (lTemp > 255) |
|
27912 lTemp = 255; |
|
27913 lTemp4 = (lTemp >> 3); |
|
27914 |
|
27915 /*G component*/ |
|
27916 lTemp = lY1 - lTemp2 + 3; |
|
27917 if (lTemp < 0) |
|
27918 lTemp = 0; |
|
27919 if (lTemp > 255) |
|
27920 lTemp = 255; |
|
27921 lTemp4 |= (lTemp >> 2) << 5; |
|
27922 |
|
27923 /*R component*/ |
|
27924 lTemp = lY1 + lTemp1 + 2; |
|
27925 if (lTemp < 0) |
|
27926 lTemp = 0; |
|
27927 if (lTemp > 255) |
|
27928 lTemp = 255; |
|
27929 lTemp4 |= (lTemp >> 3) << 11; |
|
27930 |
|
27931 lRGBFramePtr[0] = (uint16)lTemp4; |
|
27932 |
|
27933 /*Second Pixel*/ |
|
27934 lY1 = lYuyvPtr[3]; |
|
27935 lY1 -= 16; |
|
27936 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27937 |
|
27938 /*B component*/ |
|
27939 lTemp = lY1 + lTemp3 + 4; |
|
27940 if (lTemp < 0) |
|
27941 lTemp = 0; |
|
27942 if (lTemp > 255) |
|
27943 lTemp = 255; |
|
27944 lTemp4 = (lTemp >> 3); |
|
27945 |
|
27946 /*G component*/ |
|
27947 lTemp = lY1 - lTemp2; |
|
27948 if (lTemp < 0) |
|
27949 lTemp = 0; |
|
27950 if (lTemp > 255) |
|
27951 lTemp = 255; |
|
27952 lTemp4 |= (lTemp >> 2) << 5; |
|
27953 |
|
27954 /*R component*/ |
|
27955 lTemp = lY1 + lTemp1 + 6; |
|
27956 if (lTemp < 0) |
|
27957 lTemp = 0; |
|
27958 if (lTemp > 255) |
|
27959 lTemp = 255; |
|
27960 lTemp4 |= (lTemp >> 3) << 11; |
|
27961 |
|
27962 lRGBFramePtr[1] = (uint16)lTemp4; |
|
27963 |
|
27964 |
|
27965 lCb1 = lYuyvPtr[lLumWidth]; |
|
27966 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
27967 |
|
27968 lCr1 -= 128; |
|
27969 lCb1 -= 128; |
|
27970 |
|
27971 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
27972 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
27973 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
27974 |
|
27975 /*Third Pixel*/ |
|
27976 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
27977 lY1 -= 16; |
|
27978 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
27979 |
|
27980 /*B component*/ |
|
27981 lTemp = lY1 + lTemp3 + 6; |
|
27982 if (lTemp < 0) |
|
27983 lTemp = 0; |
|
27984 if (lTemp > 255) |
|
27985 lTemp = 255; |
|
27986 lTemp4 = (lTemp >> 3); |
|
27987 |
|
27988 /*G component*/ |
|
27989 lTemp = lY1 - lTemp2 + 1; |
|
27990 if (lTemp < 0) |
|
27991 lTemp = 0; |
|
27992 if (lTemp > 255) |
|
27993 lTemp = 255; |
|
27994 lTemp4 |= (lTemp >> 2) << 5; |
|
27995 |
|
27996 /*R component*/ |
|
27997 lTemp = lY1 + lTemp1 + 4; |
|
27998 if (lTemp < 0) |
|
27999 lTemp = 0; |
|
28000 if (lTemp > 255) |
|
28001 lTemp = 255; |
|
28002 lTemp4 |= (lTemp >> 3) << 11; |
|
28003 |
|
28004 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
28005 |
|
28006 /*Fourth Pixel*/ |
|
28007 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
28008 lY1 -= 16; |
|
28009 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
28010 |
|
28011 /*B component*/ |
|
28012 lTemp = lY1 + lTemp3 + 2; |
|
28013 if (lTemp < 0) |
|
28014 lTemp = 0; |
|
28015 if (lTemp > 255) |
|
28016 lTemp = 255; |
|
28017 lTemp4 = (lTemp >> 3); |
|
28018 |
|
28019 /*G component*/ |
|
28020 lTemp = lY1 - lTemp2 + 2; |
|
28021 if (lTemp < 0) |
|
28022 lTemp = 0; |
|
28023 if (lTemp > 255) |
|
28024 lTemp = 255; |
|
28025 lTemp4 |= (lTemp >> 2) << 5; |
|
28026 |
|
28027 /*R component*/ |
|
28028 lTemp = lY1 + lTemp1; |
|
28029 if (lTemp < 0) |
|
28030 lTemp = 0; |
|
28031 if (lTemp > 255) |
|
28032 lTemp = 255; |
|
28033 lTemp4 |= (lTemp >> 3) << 11; |
|
28034 |
|
28035 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
28036 |
|
28037 lYuyvPtr += 4; |
|
28038 lRGBFramePtr += 2; |
|
28039 lRGBFramePtr1 += 2; |
|
28040 |
|
28041 |
|
28042 if(extraCol) |
|
28043 { |
|
28044 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
28045 lRGBFramePtr++; |
|
28046 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
28047 lRGBFramePtr1++; |
|
28048 } |
|
28049 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
28050 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
28051 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
28052 } |
|
28053 |
|
28054 if(extraRow) |
|
28055 { |
|
28056 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
28057 for(j = 0; j < lWidth; j += 2) |
|
28058 { |
|
28059 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28060 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28061 } |
|
28062 if(extraCol) |
|
28063 { |
|
28064 *lRGBFramePtr = *lRGBFramePtr1; |
|
28065 } |
|
28066 } |
|
28067 return; |
|
28068 } |
|
28069 |
|
28070 |
|
28071 /* |
|
28072 ****************************************************************************** |
|
28073 Name : sEmz_VDec_YUV422BEChr1toColor16M_709_FR |
|
28074 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to RGB888 Interleaved format. |
|
28075 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
28076 uint8 *dstImage : Pointer to rgb data (o/p). |
|
28077 tWndParam *srcWindow : Pointer to structure containing source window |
|
28078 parameters like xOffset,yOffset,cropWidth, |
|
28079 cropHeight. (i/p) |
|
28080 tWndParam *dstWindow : Pointer to structure containing destination window |
|
28081 parameters like xOffset,yOffset,windWidth, |
|
28082 windHeight. (i/p) |
|
28083 Return Value : void |
|
28084 ****************************************************************************** |
|
28085 */ |
|
28086 |
|
28087 void sEmz_VDec_YUV422BEChr1toColor16M_709_FR |
|
28088 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
28089 tWndParam* srcWindow, tWndParam* dstWindow) |
|
28090 { |
|
28091 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
28092 uint8 *lYuyvPtr; |
|
28093 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
28094 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
28095 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
28096 int32 i, j, extraCol, extraRow; |
|
28097 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
28098 cropWidth,cropHeight,wndWidth,wndHeight; |
|
28099 |
|
28100 srcXOffset = srcWindow->xOffset; |
|
28101 srcYOffset = srcWindow->yOffset; |
|
28102 cropWidth = srcWindow->wndWidth; |
|
28103 cropHeight = srcWindow->wndHeight; |
|
28104 |
|
28105 |
|
28106 dstXOffset = dstWindow->xOffset; |
|
28107 dstYOffset = dstWindow->yOffset; |
|
28108 wndWidth = dstWindow->wndWidth; |
|
28109 wndHeight = dstWindow->wndHeight; |
|
28110 |
|
28111 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
28112 { |
|
28113 lWidth = cropWidth; |
|
28114 } |
|
28115 else |
|
28116 { |
|
28117 lWidth = srcImage->width - srcXOffset; |
|
28118 } |
|
28119 |
|
28120 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
28121 { |
|
28122 lHeight = cropHeight; |
|
28123 } |
|
28124 else |
|
28125 { |
|
28126 lHeight = srcImage->height - srcYOffset; |
|
28127 } |
|
28128 |
|
28129 if (lWidth > (wndWidth - dstXOffset)) |
|
28130 { |
|
28131 lWidth = wndWidth - dstXOffset; |
|
28132 } |
|
28133 |
|
28134 if (lHeight > (wndHeight - dstYOffset)) |
|
28135 { |
|
28136 lHeight = wndHeight - dstYOffset; |
|
28137 } |
|
28138 |
|
28139 extraCol = lWidth & 0x01; |
|
28140 extraRow = lHeight & 0x01; |
|
28141 |
|
28142 lTempWidth = lWidth * 3; |
|
28143 lWidth = (lWidth >> 1) << 1; |
|
28144 lHeight = (lHeight >> 1) << 1; |
|
28145 |
|
28146 dstXOffset *= 3; |
|
28147 wndWidth *= 3; |
|
28148 |
|
28149 lLumWidth = (srcImage->width >> 1) << 1 ; |
|
28150 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
28151 |
|
28152 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
28153 |
|
28154 for(i = 0; i < lHeight; i++) |
|
28155 { |
|
28156 for(j = 0; j < (lWidth - 2); j += 2) |
|
28157 { |
|
28158 lCb1 = lYuyvPtr[0]; |
|
28159 lCr1 = lYuyvPtr[2]; |
|
28160 |
|
28161 lCb2 = lYuyvPtr[4]; |
|
28162 lCr2 = lYuyvPtr[6]; |
|
28163 |
|
28164 lCr2 = (lCr1 + lCr2) >> 1; |
|
28165 lCb2 = (lCb1 + lCb2) >> 1; |
|
28166 |
|
28167 lCb1 -= 128; |
|
28168 lCr1 -= 128; |
|
28169 |
|
28170 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
28171 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
28172 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
28173 |
|
28174 /*First Pixel*/ |
|
28175 lY1 = lYuyvPtr[1]; |
|
28176 |
|
28177 /*R component*/ |
|
28178 lTemp = (lY1 + lTemp1); |
|
28179 if (lTemp < 0) |
|
28180 lTemp = 0; |
|
28181 if (lTemp > 255) |
|
28182 lTemp = 255; |
|
28183 lRGBFramePtr[0] = (uint8) lTemp; |
|
28184 |
|
28185 /*G component*/ |
|
28186 lTemp = (lY1 - lTemp2); |
|
28187 if (lTemp < 0) |
|
28188 lTemp = 0; |
|
28189 if (lTemp > 255) |
|
28190 lTemp = 255; |
|
28191 lRGBFramePtr[1] = (uint8) lTemp; |
|
28192 |
|
28193 /*B component*/ |
|
28194 lTemp = (lY1 + lTemp3); |
|
28195 if (lTemp < 0) |
|
28196 lTemp = 0; |
|
28197 if (lTemp > 255) |
|
28198 lTemp = 255; |
|
28199 |
|
28200 lRGBFramePtr[2] = (uint8) lTemp; |
|
28201 |
|
28202 lCb2 -= 128; |
|
28203 lCr2 -= 128; |
|
28204 |
|
28205 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
28206 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
28207 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
28208 |
|
28209 /*Second Pixel*/ |
|
28210 lY1 = lYuyvPtr[3]; |
|
28211 |
|
28212 /*R component*/ |
|
28213 lTemp = (lY1 + lTemp1); |
|
28214 if (lTemp < 0) |
|
28215 lTemp = 0; |
|
28216 if (lTemp > 255) |
|
28217 lTemp = 255; |
|
28218 lRGBFramePtr[3] = (uint8) lTemp; |
|
28219 |
|
28220 /*G component*/ |
|
28221 lTemp = (lY1 - lTemp2); |
|
28222 if (lTemp < 0) |
|
28223 lTemp = 0; |
|
28224 if (lTemp > 255) |
|
28225 lTemp = 255; |
|
28226 lRGBFramePtr[4] = (uint8) lTemp; |
|
28227 |
|
28228 /*B component*/ |
|
28229 lTemp = (lY1 + lTemp3); |
|
28230 if (lTemp < 0) |
|
28231 lTemp = 0; |
|
28232 if (lTemp > 255) |
|
28233 lTemp = 255; |
|
28234 lRGBFramePtr[5] = (uint8) lTemp; |
|
28235 |
|
28236 lYuyvPtr += 4; |
|
28237 lRGBFramePtr += 6; |
|
28238 } |
|
28239 |
|
28240 lCb1 = lYuyvPtr[0]; |
|
28241 lCr1 = lYuyvPtr[2]; |
|
28242 |
|
28243 lCb1 -= 128; |
|
28244 lCr1 -= 128; |
|
28245 |
|
28246 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
28247 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
28248 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
28249 |
|
28250 /*First Pixel*/ |
|
28251 lY1 = lYuyvPtr[1]; |
|
28252 |
|
28253 /*R component*/ |
|
28254 lTemp = (lY1 + lTemp1); |
|
28255 if (lTemp < 0) |
|
28256 lTemp = 0; |
|
28257 if (lTemp > 255) |
|
28258 lTemp = 255; |
|
28259 lRGBFramePtr[0] = (uint8) lTemp; |
|
28260 |
|
28261 /*G component*/ |
|
28262 lTemp = (lY1 - lTemp2); |
|
28263 if (lTemp < 0) |
|
28264 lTemp = 0; |
|
28265 if (lTemp > 255) |
|
28266 lTemp = 255; |
|
28267 lRGBFramePtr[1] = (uint8) lTemp; |
|
28268 |
|
28269 /*B component*/ |
|
28270 lTemp = (lY1 + lTemp3); |
|
28271 if (lTemp < 0) |
|
28272 lTemp = 0; |
|
28273 if (lTemp > 255) |
|
28274 lTemp = 255; |
|
28275 |
|
28276 lRGBFramePtr[2] = (uint8) lTemp; |
|
28277 |
|
28278 /*Second Pixel*/ |
|
28279 lY1 = lYuyvPtr[3]; |
|
28280 |
|
28281 /*R component*/ |
|
28282 lTemp = (lY1 + lTemp1); |
|
28283 if (lTemp < 0) |
|
28284 lTemp = 0; |
|
28285 if (lTemp > 255) |
|
28286 lTemp = 255; |
|
28287 lRGBFramePtr[3] = (uint8) lTemp; |
|
28288 |
|
28289 /*G component*/ |
|
28290 lTemp = (lY1 - lTemp2); |
|
28291 if (lTemp < 0) |
|
28292 lTemp = 0; |
|
28293 if (lTemp > 255) |
|
28294 lTemp = 255; |
|
28295 lRGBFramePtr[4] = (uint8) lTemp; |
|
28296 |
|
28297 /*B component*/ |
|
28298 lTemp = (lY1 + lTemp3); |
|
28299 if (lTemp < 0) |
|
28300 lTemp = 0; |
|
28301 if (lTemp > 255) |
|
28302 lTemp = 255; |
|
28303 lRGBFramePtr[5] = (uint8) lTemp; |
|
28304 |
|
28305 lYuyvPtr += 4; |
|
28306 lRGBFramePtr += 6; |
|
28307 |
|
28308 if(extraCol) |
|
28309 { |
|
28310 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
28311 lRGBFramePtr++; |
|
28312 |
|
28313 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
28314 lRGBFramePtr++; |
|
28315 |
|
28316 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
28317 lRGBFramePtr++; |
|
28318 } |
|
28319 |
|
28320 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
28321 lRGBFramePtr += (wndWidth - lTempWidth); |
|
28322 } |
|
28323 |
|
28324 if(extraRow) |
|
28325 { |
|
28326 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
28327 for(j = 0; j < lWidth * 3; j += 2) |
|
28328 { |
|
28329 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28330 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28331 } |
|
28332 if(extraCol) |
|
28333 { |
|
28334 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28335 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28336 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28337 } |
|
28338 } |
|
28339 return; |
|
28340 } |
|
28341 |
|
28342 /* |
|
28343 ****************************************************************************** |
|
28344 Name : sEmz_VDec_YUV422BEChr1toColor16M_601_5_FR |
|
28345 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to RGB888 Interleaved format. |
|
28346 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
28347 uint8 *dstImage : Pointer to rgb data (o/p). |
|
28348 tWndParam *srcWindow : Pointer to structure containing source window |
|
28349 parameters like xOffset,yOffset,cropWidth, |
|
28350 cropHeight. (i/p) |
|
28351 tWndParam *dstWindow : Pointer to structure containing destination window |
|
28352 parameters like xOffset,yOffset,windWidth, |
|
28353 windHeight. (i/p) |
|
28354 Return Value : void |
|
28355 ****************************************************************************** |
|
28356 */ |
|
28357 |
|
28358 void sEmz_VDec_YUV422BEChr1toColor16M_601_5_FR |
|
28359 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
28360 tWndParam* srcWindow, tWndParam* dstWindow) |
|
28361 { |
|
28362 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
28363 uint8 *lYuyvPtr; |
|
28364 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
28365 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
28366 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
28367 int32 i, j, extraCol, extraRow; |
|
28368 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
28369 cropWidth,cropHeight,wndWidth,wndHeight; |
|
28370 |
|
28371 srcXOffset = srcWindow->xOffset; |
|
28372 srcYOffset = srcWindow->yOffset; |
|
28373 cropWidth = srcWindow->wndWidth; |
|
28374 cropHeight = srcWindow->wndHeight; |
|
28375 |
|
28376 |
|
28377 dstXOffset = dstWindow->xOffset; |
|
28378 dstYOffset = dstWindow->yOffset; |
|
28379 wndWidth = dstWindow->wndWidth; |
|
28380 wndHeight = dstWindow->wndHeight; |
|
28381 |
|
28382 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
28383 { |
|
28384 lWidth = cropWidth; |
|
28385 } |
|
28386 else |
|
28387 { |
|
28388 lWidth = srcImage->width - srcXOffset; |
|
28389 } |
|
28390 |
|
28391 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
28392 { |
|
28393 lHeight = cropHeight; |
|
28394 } |
|
28395 else |
|
28396 { |
|
28397 lHeight = srcImage->height - srcYOffset; |
|
28398 } |
|
28399 |
|
28400 if (lWidth > (wndWidth - dstXOffset)) |
|
28401 { |
|
28402 lWidth = wndWidth - dstXOffset; |
|
28403 } |
|
28404 |
|
28405 if (lHeight > (wndHeight - dstYOffset)) |
|
28406 { |
|
28407 lHeight = wndHeight - dstYOffset; |
|
28408 } |
|
28409 |
|
28410 extraCol = lWidth & 0x01; |
|
28411 extraRow = lHeight & 0x01; |
|
28412 |
|
28413 lTempWidth = lWidth * 3; |
|
28414 lWidth = (lWidth >> 1) << 1; |
|
28415 lHeight = (lHeight >> 1) << 1; |
|
28416 |
|
28417 dstXOffset *= 3; |
|
28418 wndWidth *= 3; |
|
28419 |
|
28420 lLumWidth = (srcImage->width >> 1) << 1 ; |
|
28421 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
28422 |
|
28423 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
28424 |
|
28425 for(i = 0; i < lHeight; i++) |
|
28426 { |
|
28427 for(j = 0; j < (lWidth - 2); j += 2) |
|
28428 { |
|
28429 lCb1 = lYuyvPtr[0]; |
|
28430 lCr1 = lYuyvPtr[2]; |
|
28431 |
|
28432 lCb2 = lYuyvPtr[4]; |
|
28433 lCr2 = lYuyvPtr[6]; |
|
28434 |
|
28435 lCr2 = (lCr1 + lCr2) >> 1; |
|
28436 lCb2 = (lCb1 + lCb2) >> 1; |
|
28437 |
|
28438 lCb1 -= 128; |
|
28439 lCr1 -= 128; |
|
28440 |
|
28441 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
28442 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
28443 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
28444 |
|
28445 /*First Pixel*/ |
|
28446 lY1 = lYuyvPtr[1]; |
|
28447 |
|
28448 /*R component*/ |
|
28449 lTemp = (lY1 + lTemp1); |
|
28450 if (lTemp < 0) |
|
28451 lTemp = 0; |
|
28452 if (lTemp > 255) |
|
28453 lTemp = 255; |
|
28454 lRGBFramePtr[0] = (uint8) lTemp; |
|
28455 |
|
28456 /*G component*/ |
|
28457 lTemp = (lY1 - lTemp2); |
|
28458 if (lTemp < 0) |
|
28459 lTemp = 0; |
|
28460 if (lTemp > 255) |
|
28461 lTemp = 255; |
|
28462 lRGBFramePtr[1] = (uint8) lTemp; |
|
28463 |
|
28464 /*B component*/ |
|
28465 lTemp = (lY1 + lTemp3); |
|
28466 if (lTemp < 0) |
|
28467 lTemp = 0; |
|
28468 if (lTemp > 255) |
|
28469 lTemp = 255; |
|
28470 |
|
28471 lRGBFramePtr[2] = (uint8) lTemp; |
|
28472 |
|
28473 lCb2 -= 128; |
|
28474 lCr2 -= 128; |
|
28475 |
|
28476 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
28477 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
28478 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
28479 |
|
28480 /*Second Pixel*/ |
|
28481 lY1 = lYuyvPtr[3]; |
|
28482 |
|
28483 /*R component*/ |
|
28484 lTemp = (lY1 + lTemp1); |
|
28485 if (lTemp < 0) |
|
28486 lTemp = 0; |
|
28487 if (lTemp > 255) |
|
28488 lTemp = 255; |
|
28489 lRGBFramePtr[3] = (uint8) lTemp; |
|
28490 |
|
28491 /*G component*/ |
|
28492 lTemp = (lY1 - lTemp2); |
|
28493 if (lTemp < 0) |
|
28494 lTemp = 0; |
|
28495 if (lTemp > 255) |
|
28496 lTemp = 255; |
|
28497 lRGBFramePtr[4] = (uint8) lTemp; |
|
28498 |
|
28499 /*B component*/ |
|
28500 lTemp = (lY1 + lTemp3); |
|
28501 if (lTemp < 0) |
|
28502 lTemp = 0; |
|
28503 if (lTemp > 255) |
|
28504 lTemp = 255; |
|
28505 lRGBFramePtr[5] = (uint8) lTemp; |
|
28506 |
|
28507 lYuyvPtr += 4; |
|
28508 lRGBFramePtr += 6; |
|
28509 } |
|
28510 |
|
28511 lCb1 = lYuyvPtr[0]; |
|
28512 lCr1 = lYuyvPtr[2]; |
|
28513 |
|
28514 lCb1 -= 128; |
|
28515 lCr1 -= 128; |
|
28516 |
|
28517 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
28518 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
28519 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
28520 |
|
28521 /*First Pixel*/ |
|
28522 lY1 = lYuyvPtr[1]; |
|
28523 |
|
28524 /*R component*/ |
|
28525 lTemp = (lY1 + lTemp1); |
|
28526 if (lTemp < 0) |
|
28527 lTemp = 0; |
|
28528 if (lTemp > 255) |
|
28529 lTemp = 255; |
|
28530 lRGBFramePtr[0] = (uint8) lTemp; |
|
28531 |
|
28532 /*G component*/ |
|
28533 lTemp = (lY1 - lTemp2); |
|
28534 if (lTemp < 0) |
|
28535 lTemp = 0; |
|
28536 if (lTemp > 255) |
|
28537 lTemp = 255; |
|
28538 lRGBFramePtr[1] = (uint8) lTemp; |
|
28539 |
|
28540 /*B component*/ |
|
28541 lTemp = (lY1 + lTemp3); |
|
28542 if (lTemp < 0) |
|
28543 lTemp = 0; |
|
28544 if (lTemp > 255) |
|
28545 lTemp = 255; |
|
28546 |
|
28547 lRGBFramePtr[2] = (uint8) lTemp; |
|
28548 |
|
28549 /*Second Pixel*/ |
|
28550 lY1 = lYuyvPtr[3]; |
|
28551 |
|
28552 /*R component*/ |
|
28553 lTemp = (lY1 + lTemp1); |
|
28554 if (lTemp < 0) |
|
28555 lTemp = 0; |
|
28556 if (lTemp > 255) |
|
28557 lTemp = 255; |
|
28558 lRGBFramePtr[3] = (uint8) lTemp; |
|
28559 |
|
28560 /*G component*/ |
|
28561 lTemp = (lY1 - lTemp2); |
|
28562 if (lTemp < 0) |
|
28563 lTemp = 0; |
|
28564 if (lTemp > 255) |
|
28565 lTemp = 255; |
|
28566 lRGBFramePtr[4] = (uint8) lTemp; |
|
28567 |
|
28568 /*B component*/ |
|
28569 lTemp = (lY1 + lTemp3); |
|
28570 if (lTemp < 0) |
|
28571 lTemp = 0; |
|
28572 if (lTemp > 255) |
|
28573 lTemp = 255; |
|
28574 lRGBFramePtr[5] = (uint8) lTemp; |
|
28575 |
|
28576 lYuyvPtr += 4; |
|
28577 lRGBFramePtr += 6; |
|
28578 |
|
28579 if(extraCol) |
|
28580 { |
|
28581 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
28582 lRGBFramePtr++; |
|
28583 |
|
28584 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
28585 lRGBFramePtr++; |
|
28586 |
|
28587 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
28588 lRGBFramePtr++; |
|
28589 } |
|
28590 |
|
28591 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
28592 lRGBFramePtr += (wndWidth - lTempWidth); |
|
28593 } |
|
28594 |
|
28595 if(extraRow) |
|
28596 { |
|
28597 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
28598 for(j = 0; j < lWidth * 3; j += 2) |
|
28599 { |
|
28600 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28601 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28602 } |
|
28603 if(extraCol) |
|
28604 { |
|
28605 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28606 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28607 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28608 } |
|
28609 } |
|
28610 return; |
|
28611 } |
|
28612 |
|
28613 /* |
|
28614 ****************************************************************************** |
|
28615 Name : sEmz_VDec_YUV422BEChr1toColor16M_709_RR |
|
28616 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to RGB888 Interleaved format. |
|
28617 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
28618 uint8 *dstImage : Pointer to rgb data (o/p). |
|
28619 tWndParam *srcWindow : Pointer to structure containing source window |
|
28620 parameters like xOffset,yOffset,cropWidth, |
|
28621 cropHeight. (i/p) |
|
28622 tWndParam *dstWindow : Pointer to structure containing destination window |
|
28623 parameters like xOffset,yOffset,windWidth, |
|
28624 windHeight. (i/p) |
|
28625 Return Value : void |
|
28626 ****************************************************************************** |
|
28627 */ |
|
28628 |
|
28629 void sEmz_VDec_YUV422BEChr1toColor16M_709_RR |
|
28630 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
28631 tWndParam* srcWindow, tWndParam* dstWindow) |
|
28632 { |
|
28633 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
28634 uint8 *lYuyvPtr; |
|
28635 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
28636 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
28637 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
28638 int32 i, j, extraCol, extraRow; |
|
28639 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
28640 cropWidth,cropHeight,wndWidth,wndHeight; |
|
28641 |
|
28642 srcXOffset = srcWindow->xOffset; |
|
28643 srcYOffset = srcWindow->yOffset; |
|
28644 cropWidth = srcWindow->wndWidth; |
|
28645 cropHeight = srcWindow->wndHeight; |
|
28646 |
|
28647 |
|
28648 dstXOffset = dstWindow->xOffset; |
|
28649 dstYOffset = dstWindow->yOffset; |
|
28650 wndWidth = dstWindow->wndWidth; |
|
28651 wndHeight = dstWindow->wndHeight; |
|
28652 |
|
28653 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
28654 { |
|
28655 lWidth = cropWidth; |
|
28656 } |
|
28657 else |
|
28658 { |
|
28659 lWidth = srcImage->width - srcXOffset; |
|
28660 } |
|
28661 |
|
28662 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
28663 { |
|
28664 lHeight = cropHeight; |
|
28665 } |
|
28666 else |
|
28667 { |
|
28668 lHeight = srcImage->height - srcYOffset; |
|
28669 } |
|
28670 |
|
28671 if (lWidth > (wndWidth - dstXOffset)) |
|
28672 { |
|
28673 lWidth = wndWidth - dstXOffset; |
|
28674 } |
|
28675 |
|
28676 if (lHeight > (wndHeight - dstYOffset)) |
|
28677 { |
|
28678 lHeight = wndHeight - dstYOffset; |
|
28679 } |
|
28680 |
|
28681 extraCol = lWidth & 0x01; |
|
28682 extraRow = lHeight & 0x01; |
|
28683 |
|
28684 lTempWidth = lWidth * 3; |
|
28685 lWidth = (lWidth >> 1) << 1; |
|
28686 lHeight = (lHeight >> 1) << 1; |
|
28687 |
|
28688 dstXOffset *= 3; |
|
28689 wndWidth *= 3; |
|
28690 |
|
28691 lLumWidth = (srcImage->width >> 1) << 1 ; |
|
28692 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
28693 |
|
28694 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
28695 |
|
28696 for(i = 0; i < lHeight; i++) |
|
28697 { |
|
28698 for(j = 0; j < (lWidth - 2); j += 2) |
|
28699 { |
|
28700 lCb1 = lYuyvPtr[0]; |
|
28701 lCr1 = lYuyvPtr[2]; |
|
28702 |
|
28703 lCb2 = lYuyvPtr[4]; |
|
28704 lCr2 = lYuyvPtr[6]; |
|
28705 |
|
28706 lCr2 = (lCr1 + lCr2) >> 1; |
|
28707 lCb2 = (lCb1 + lCb2) >> 1; |
|
28708 |
|
28709 lCb1 -= 128; |
|
28710 lCr1 -= 128; |
|
28711 |
|
28712 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
28713 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
28714 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
28715 |
|
28716 /*First Pixel*/ |
|
28717 lY1 = lYuyvPtr[1]; |
|
28718 lY1 -= 16; |
|
28719 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
28720 |
|
28721 /*R component*/ |
|
28722 lTemp = (lY1 + lTemp1); |
|
28723 if (lTemp < 0) |
|
28724 lTemp = 0; |
|
28725 if (lTemp > 255) |
|
28726 lTemp = 255; |
|
28727 lRGBFramePtr[0] = (uint8) lTemp; |
|
28728 |
|
28729 /*G component*/ |
|
28730 lTemp = (lY1 - lTemp2); |
|
28731 if (lTemp < 0) |
|
28732 lTemp = 0; |
|
28733 if (lTemp > 255) |
|
28734 lTemp = 255; |
|
28735 lRGBFramePtr[1] = (uint8) lTemp; |
|
28736 |
|
28737 /*B component*/ |
|
28738 lTemp = (lY1 + lTemp3); |
|
28739 if (lTemp < 0) |
|
28740 lTemp = 0; |
|
28741 if (lTemp > 255) |
|
28742 lTemp = 255; |
|
28743 |
|
28744 lRGBFramePtr[2] = (uint8) lTemp; |
|
28745 |
|
28746 lCb2 -= 128; |
|
28747 lCr2 -= 128; |
|
28748 |
|
28749 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
28750 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
28751 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
28752 |
|
28753 /*Second Pixel*/ |
|
28754 lY1 = lYuyvPtr[3]; |
|
28755 lY1 -= 16; |
|
28756 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
28757 |
|
28758 /*R component*/ |
|
28759 lTemp = (lY1 + lTemp1); |
|
28760 if (lTemp < 0) |
|
28761 lTemp = 0; |
|
28762 if (lTemp > 255) |
|
28763 lTemp = 255; |
|
28764 lRGBFramePtr[3] = (uint8) lTemp; |
|
28765 |
|
28766 /*G component*/ |
|
28767 lTemp = (lY1 - lTemp2); |
|
28768 if (lTemp < 0) |
|
28769 lTemp = 0; |
|
28770 if (lTemp > 255) |
|
28771 lTemp = 255; |
|
28772 lRGBFramePtr[4] = (uint8) lTemp; |
|
28773 |
|
28774 /*B component*/ |
|
28775 lTemp = (lY1 + lTemp3); |
|
28776 if (lTemp < 0) |
|
28777 lTemp = 0; |
|
28778 if (lTemp > 255) |
|
28779 lTemp = 255; |
|
28780 lRGBFramePtr[5] = (uint8) lTemp; |
|
28781 |
|
28782 lYuyvPtr += 4; |
|
28783 lRGBFramePtr += 6; |
|
28784 } |
|
28785 |
|
28786 lCb1 = lYuyvPtr[0]; |
|
28787 lCr1 = lYuyvPtr[2]; |
|
28788 |
|
28789 lCb1 -= 128; |
|
28790 lCr1 -= 128; |
|
28791 |
|
28792 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
28793 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
28794 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
28795 |
|
28796 /*First Pixel*/ |
|
28797 lY1 = lYuyvPtr[1]; |
|
28798 lY1 -= 16; |
|
28799 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
28800 |
|
28801 /*R component*/ |
|
28802 lTemp = (lY1 + lTemp1); |
|
28803 if (lTemp < 0) |
|
28804 lTemp = 0; |
|
28805 if (lTemp > 255) |
|
28806 lTemp = 255; |
|
28807 lRGBFramePtr[0] = (uint8) lTemp; |
|
28808 |
|
28809 /*G component*/ |
|
28810 lTemp = (lY1 - lTemp2); |
|
28811 if (lTemp < 0) |
|
28812 lTemp = 0; |
|
28813 if (lTemp > 255) |
|
28814 lTemp = 255; |
|
28815 lRGBFramePtr[1] = (uint8) lTemp; |
|
28816 |
|
28817 /*B component*/ |
|
28818 lTemp = (lY1 + lTemp3); |
|
28819 if (lTemp < 0) |
|
28820 lTemp = 0; |
|
28821 if (lTemp > 255) |
|
28822 lTemp = 255; |
|
28823 |
|
28824 lRGBFramePtr[2] = (uint8) lTemp; |
|
28825 |
|
28826 /*Second Pixel*/ |
|
28827 lY1 = lYuyvPtr[3]; |
|
28828 lY1 -= 16; |
|
28829 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
28830 |
|
28831 /*R component*/ |
|
28832 lTemp = (lY1 + lTemp1); |
|
28833 if (lTemp < 0) |
|
28834 lTemp = 0; |
|
28835 if (lTemp > 255) |
|
28836 lTemp = 255; |
|
28837 lRGBFramePtr[3] = (uint8) lTemp; |
|
28838 |
|
28839 /*G component*/ |
|
28840 lTemp = (lY1 - lTemp2); |
|
28841 if (lTemp < 0) |
|
28842 lTemp = 0; |
|
28843 if (lTemp > 255) |
|
28844 lTemp = 255; |
|
28845 lRGBFramePtr[4] = (uint8) lTemp; |
|
28846 |
|
28847 /*B component*/ |
|
28848 lTemp = (lY1 + lTemp3); |
|
28849 if (lTemp < 0) |
|
28850 lTemp = 0; |
|
28851 if (lTemp > 255) |
|
28852 lTemp = 255; |
|
28853 lRGBFramePtr[5] = (uint8) lTemp; |
|
28854 |
|
28855 lYuyvPtr += 4; |
|
28856 lRGBFramePtr += 6; |
|
28857 |
|
28858 if(extraCol) |
|
28859 { |
|
28860 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
28861 lRGBFramePtr++; |
|
28862 |
|
28863 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
28864 lRGBFramePtr++; |
|
28865 |
|
28866 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
28867 lRGBFramePtr++; |
|
28868 } |
|
28869 |
|
28870 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
28871 lRGBFramePtr += (wndWidth - lTempWidth); |
|
28872 } |
|
28873 |
|
28874 if(extraRow) |
|
28875 { |
|
28876 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
28877 for(j = 0; j < lWidth * 3; j += 2) |
|
28878 { |
|
28879 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28880 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28881 } |
|
28882 if(extraCol) |
|
28883 { |
|
28884 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28885 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28886 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
28887 } |
|
28888 } |
|
28889 return; |
|
28890 } |
|
28891 |
|
28892 /* |
|
28893 ****************************************************************************** |
|
28894 Name : sEmz_VDec_YUV422BEChr1toColor16M_601_5_RR |
|
28895 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to RGB888 Interleaved format. |
|
28896 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
28897 uint8 *dstImage : Pointer to rgb data (o/p). |
|
28898 tWndParam *srcWindow : Pointer to structure containing source window |
|
28899 parameters like xOffset,yOffset,cropWidth, |
|
28900 cropHeight. (i/p) |
|
28901 tWndParam *dstWindow : Pointer to structure containing destination window |
|
28902 parameters like xOffset,yOffset,windWidth, |
|
28903 windHeight. (i/p) |
|
28904 Return Value : void |
|
28905 ****************************************************************************** |
|
28906 */ |
|
28907 |
|
28908 void sEmz_VDec_YUV422BEChr1toColor16M_601_5_RR |
|
28909 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
28910 tWndParam* srcWindow, tWndParam* dstWindow) |
|
28911 { |
|
28912 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
28913 uint8 *lYuyvPtr; |
|
28914 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
28915 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
28916 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
28917 int32 i, j, extraCol, extraRow; |
|
28918 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
28919 cropWidth,cropHeight,wndWidth,wndHeight; |
|
28920 |
|
28921 srcXOffset = srcWindow->xOffset; |
|
28922 srcYOffset = srcWindow->yOffset; |
|
28923 cropWidth = srcWindow->wndWidth; |
|
28924 cropHeight = srcWindow->wndHeight; |
|
28925 |
|
28926 |
|
28927 dstXOffset = dstWindow->xOffset; |
|
28928 dstYOffset = dstWindow->yOffset; |
|
28929 wndWidth = dstWindow->wndWidth; |
|
28930 wndHeight = dstWindow->wndHeight; |
|
28931 |
|
28932 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
28933 { |
|
28934 lWidth = cropWidth; |
|
28935 } |
|
28936 else |
|
28937 { |
|
28938 lWidth = srcImage->width - srcXOffset; |
|
28939 } |
|
28940 |
|
28941 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
28942 { |
|
28943 lHeight = cropHeight; |
|
28944 } |
|
28945 else |
|
28946 { |
|
28947 lHeight = srcImage->height - srcYOffset; |
|
28948 } |
|
28949 |
|
28950 if (lWidth > (wndWidth - dstXOffset)) |
|
28951 { |
|
28952 lWidth = wndWidth - dstXOffset; |
|
28953 } |
|
28954 |
|
28955 if (lHeight > (wndHeight - dstYOffset)) |
|
28956 { |
|
28957 lHeight = wndHeight - dstYOffset; |
|
28958 } |
|
28959 |
|
28960 extraCol = lWidth & 0x01; |
|
28961 extraRow = lHeight & 0x01; |
|
28962 |
|
28963 lTempWidth = lWidth * 3; |
|
28964 lWidth = (lWidth >> 1) << 1; |
|
28965 lHeight = (lHeight >> 1) << 1; |
|
28966 |
|
28967 dstXOffset *= 3; |
|
28968 wndWidth *= 3; |
|
28969 |
|
28970 lLumWidth = (srcImage->width >> 1) << 1 ; |
|
28971 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
28972 |
|
28973 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
28974 |
|
28975 for(i = 0; i < lHeight; i++) |
|
28976 { |
|
28977 for(j = 0; j < (lWidth - 2); j += 2) |
|
28978 { |
|
28979 lCb1 = lYuyvPtr[0]; |
|
28980 lCr1 = lYuyvPtr[2]; |
|
28981 |
|
28982 lCb2 = lYuyvPtr[4]; |
|
28983 lCr2 = lYuyvPtr[6]; |
|
28984 |
|
28985 lCr2 = (lCr1 + lCr2) >> 1; |
|
28986 lCb2 = (lCb1 + lCb2) >> 1; |
|
28987 |
|
28988 lCb1 -= 128; |
|
28989 lCr1 -= 128; |
|
28990 |
|
28991 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
28992 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
28993 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
28994 |
|
28995 /*First Pixel*/ |
|
28996 lY1 = lYuyvPtr[1]; |
|
28997 lY1 -= 16; |
|
28998 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
28999 |
|
29000 /*R component*/ |
|
29001 lTemp = (lY1 + lTemp1); |
|
29002 if (lTemp < 0) |
|
29003 lTemp = 0; |
|
29004 if (lTemp > 255) |
|
29005 lTemp = 255; |
|
29006 lRGBFramePtr[0] = (uint8) lTemp; |
|
29007 |
|
29008 /*G component*/ |
|
29009 lTemp = (lY1 - lTemp2); |
|
29010 if (lTemp < 0) |
|
29011 lTemp = 0; |
|
29012 if (lTemp > 255) |
|
29013 lTemp = 255; |
|
29014 lRGBFramePtr[1] = (uint8) lTemp; |
|
29015 |
|
29016 /*B component*/ |
|
29017 lTemp = (lY1 + lTemp3); |
|
29018 if (lTemp < 0) |
|
29019 lTemp = 0; |
|
29020 if (lTemp > 255) |
|
29021 lTemp = 255; |
|
29022 |
|
29023 lRGBFramePtr[2] = (uint8) lTemp; |
|
29024 |
|
29025 lCb2 -= 128; |
|
29026 lCr2 -= 128; |
|
29027 |
|
29028 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
29029 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
29030 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
29031 |
|
29032 /*Second Pixel*/ |
|
29033 lY1 = lYuyvPtr[3]; |
|
29034 lY1 -= 16; |
|
29035 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
29036 |
|
29037 /*R component*/ |
|
29038 lTemp = (lY1 + lTemp1); |
|
29039 if (lTemp < 0) |
|
29040 lTemp = 0; |
|
29041 if (lTemp > 255) |
|
29042 lTemp = 255; |
|
29043 lRGBFramePtr[3] = (uint8) lTemp; |
|
29044 |
|
29045 /*G component*/ |
|
29046 lTemp = (lY1 - lTemp2); |
|
29047 if (lTemp < 0) |
|
29048 lTemp = 0; |
|
29049 if (lTemp > 255) |
|
29050 lTemp = 255; |
|
29051 lRGBFramePtr[4] = (uint8) lTemp; |
|
29052 |
|
29053 /*B component*/ |
|
29054 lTemp = (lY1 + lTemp3); |
|
29055 if (lTemp < 0) |
|
29056 lTemp = 0; |
|
29057 if (lTemp > 255) |
|
29058 lTemp = 255; |
|
29059 lRGBFramePtr[5] = (uint8) lTemp; |
|
29060 |
|
29061 lYuyvPtr += 4; |
|
29062 lRGBFramePtr += 6; |
|
29063 } |
|
29064 |
|
29065 lCb1 = lYuyvPtr[0]; |
|
29066 lCr1 = lYuyvPtr[2]; |
|
29067 |
|
29068 lCb1 -= 128; |
|
29069 lCr1 -= 128; |
|
29070 |
|
29071 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
29072 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
29073 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
29074 |
|
29075 /*First Pixel*/ |
|
29076 lY1 = lYuyvPtr[1]; |
|
29077 lY1 -= 16; |
|
29078 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
29079 |
|
29080 /*R component*/ |
|
29081 lTemp = (lY1 + lTemp1); |
|
29082 if (lTemp < 0) |
|
29083 lTemp = 0; |
|
29084 if (lTemp > 255) |
|
29085 lTemp = 255; |
|
29086 lRGBFramePtr[0] = (uint8) lTemp; |
|
29087 |
|
29088 /*G component*/ |
|
29089 lTemp = (lY1 - lTemp2); |
|
29090 if (lTemp < 0) |
|
29091 lTemp = 0; |
|
29092 if (lTemp > 255) |
|
29093 lTemp = 255; |
|
29094 lRGBFramePtr[1] = (uint8) lTemp; |
|
29095 |
|
29096 /*B component*/ |
|
29097 lTemp = (lY1 + lTemp3); |
|
29098 if (lTemp < 0) |
|
29099 lTemp = 0; |
|
29100 if (lTemp > 255) |
|
29101 lTemp = 255; |
|
29102 |
|
29103 lRGBFramePtr[2] = (uint8) lTemp; |
|
29104 |
|
29105 /*Second Pixel*/ |
|
29106 lY1 = lYuyvPtr[3]; |
|
29107 lY1 -= 16; |
|
29108 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
29109 |
|
29110 /*R component*/ |
|
29111 lTemp = (lY1 + lTemp1); |
|
29112 if (lTemp < 0) |
|
29113 lTemp = 0; |
|
29114 if (lTemp > 255) |
|
29115 lTemp = 255; |
|
29116 lRGBFramePtr[3] = (uint8) lTemp; |
|
29117 |
|
29118 /*G component*/ |
|
29119 lTemp = (lY1 - lTemp2); |
|
29120 if (lTemp < 0) |
|
29121 lTemp = 0; |
|
29122 if (lTemp > 255) |
|
29123 lTemp = 255; |
|
29124 lRGBFramePtr[4] = (uint8) lTemp; |
|
29125 |
|
29126 /*B component*/ |
|
29127 lTemp = (lY1 + lTemp3); |
|
29128 if (lTemp < 0) |
|
29129 lTemp = 0; |
|
29130 if (lTemp > 255) |
|
29131 lTemp = 255; |
|
29132 lRGBFramePtr[5] = (uint8) lTemp; |
|
29133 |
|
29134 lYuyvPtr += 4; |
|
29135 lRGBFramePtr += 6; |
|
29136 |
|
29137 if(extraCol) |
|
29138 { |
|
29139 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
29140 lRGBFramePtr++; |
|
29141 |
|
29142 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
29143 lRGBFramePtr++; |
|
29144 |
|
29145 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
29146 lRGBFramePtr++; |
|
29147 } |
|
29148 |
|
29149 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
29150 lRGBFramePtr += (wndWidth - lTempWidth); |
|
29151 } |
|
29152 |
|
29153 if(extraRow) |
|
29154 { |
|
29155 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
29156 for(j = 0; j < lWidth * 3; j += 2) |
|
29157 { |
|
29158 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
29159 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
29160 } |
|
29161 if(extraCol) |
|
29162 { |
|
29163 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
29164 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
29165 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
29166 } |
|
29167 } |
|
29168 return; |
|
29169 } |
|
29170 |
|
29171 |
|
29172 /* |
|
29173 ****************************************************************************** |
|
29174 Name : sEmz_VDec_YUV422BEChr1toColor4k_Ordered_709_FR |
|
29175 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
29176 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
29177 uint8 *dstImage : Pointer to rgb data (o/p). |
|
29178 tWndParam *srcWindow : Pointer to structure containing source window |
|
29179 parameters like xOffset,yOffset,cropWidth, |
|
29180 cropHeight. (i/p) |
|
29181 tWndParam *dstWindow : Pointer to structure containing destination window |
|
29182 parameters like xOffset,yOffset,windWidth, |
|
29183 windHeight. (i/p) |
|
29184 Return Value : void |
|
29185 ****************************************************************************** |
|
29186 */ |
|
29187 |
|
29188 void sEmz_VDec_YUV422BEChr1toColor4k_Ordered_709_FR |
|
29189 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
29190 tWndParam* srcWindow, tWndParam* dstWindow) |
|
29191 { |
|
29192 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
29193 uint8 *lYuyvPtr; |
|
29194 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
29195 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
29196 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
29197 int32 i, j, extraCol, extraRow; |
|
29198 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
29199 cropWidth,cropHeight,wndWidth,wndHeight; |
|
29200 |
|
29201 srcXOffset = srcWindow->xOffset; |
|
29202 srcYOffset = srcWindow->yOffset; |
|
29203 cropWidth = srcWindow->wndWidth; |
|
29204 cropHeight = srcWindow->wndHeight; |
|
29205 |
|
29206 dstXOffset = dstWindow->xOffset; |
|
29207 dstYOffset = dstWindow->yOffset; |
|
29208 wndWidth = dstWindow->wndWidth; |
|
29209 wndHeight = dstWindow->wndHeight; |
|
29210 |
|
29211 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
29212 { |
|
29213 lWidth = cropWidth; |
|
29214 } |
|
29215 else |
|
29216 { |
|
29217 lWidth = srcImage->width - srcXOffset; |
|
29218 } |
|
29219 |
|
29220 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
29221 { |
|
29222 lHeight = cropHeight; |
|
29223 } |
|
29224 else |
|
29225 { |
|
29226 lHeight = srcImage->height - srcYOffset; |
|
29227 } |
|
29228 |
|
29229 if (lWidth > (wndWidth - dstXOffset)) |
|
29230 { |
|
29231 lWidth = wndWidth - dstXOffset; |
|
29232 } |
|
29233 |
|
29234 if (lHeight > (wndHeight - dstYOffset)) |
|
29235 { |
|
29236 lHeight = wndHeight - dstYOffset; |
|
29237 } |
|
29238 |
|
29239 extraCol = lWidth & 0x01; |
|
29240 extraRow = lHeight & 0x01; |
|
29241 |
|
29242 lTempWidth = lWidth; |
|
29243 lWidth = (lWidth >> 1) << 1; |
|
29244 lHeight = (lHeight >> 1) << 1; |
|
29245 |
|
29246 lLumWidth = (srcImage->width >> 1) << 1; |
|
29247 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
29248 |
|
29249 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
29250 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
29251 |
|
29252 lLumWidth <<= 1; |
|
29253 |
|
29254 for(i = 0; i < lHeight; i += 2) |
|
29255 { |
|
29256 for(j = 0; j < (lWidth - 2); j += 2) |
|
29257 { |
|
29258 lCb1 = lYuyvPtr[0]; |
|
29259 lCr1 = lYuyvPtr[2]; |
|
29260 |
|
29261 lCb2 = lYuyvPtr[4]; |
|
29262 lCr2 = lYuyvPtr[6]; |
|
29263 |
|
29264 lCr2 = (lCr1 + lCr2) >> 1; |
|
29265 lCb2 = (lCb1 + lCb2) >> 1; |
|
29266 |
|
29267 /*First Pixel*/ |
|
29268 lCr1 -= 128; |
|
29269 lCb1 -= 128; |
|
29270 |
|
29271 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
29272 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
29273 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
29274 |
|
29275 lY1 = lYuyvPtr[1]; |
|
29276 |
|
29277 /*B component*/ |
|
29278 lTemp = lY1 + lTemp3; |
|
29279 if (lTemp < 0) |
|
29280 lTemp = 0; |
|
29281 if (lTemp > 255) |
|
29282 lTemp = 255; |
|
29283 lTemp4 = (lTemp >> 4); |
|
29284 |
|
29285 /*G component*/ |
|
29286 lTemp = lY1 - lTemp2 + 15; |
|
29287 if (lTemp < 0) |
|
29288 lTemp = 0; |
|
29289 if (lTemp > 255) |
|
29290 lTemp = 255; |
|
29291 lTemp4 |= (lTemp >> 4) << 4; |
|
29292 |
|
29293 /*R component*/ |
|
29294 lTemp = lY1 + lTemp1 + 5; |
|
29295 if (lTemp < 0) |
|
29296 lTemp = 0; |
|
29297 if (lTemp > 255) |
|
29298 lTemp = 255; |
|
29299 lTemp4 |= (lTemp >> 4) << 8; |
|
29300 |
|
29301 lRGBFramePtr[0] = (uint16)lTemp4; |
|
29302 |
|
29303 /*Second Pixel*/ |
|
29304 lCr2 -= 128; |
|
29305 lCb2 -= 128; |
|
29306 |
|
29307 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
29308 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
29309 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
29310 |
|
29311 lY1 = lYuyvPtr[3]; |
|
29312 |
|
29313 /*B component*/ |
|
29314 lTemp = lY1 + lTemp3 + 10; |
|
29315 if (lTemp < 0) |
|
29316 lTemp = 0; |
|
29317 if (lTemp > 255) |
|
29318 lTemp = 255; |
|
29319 lTemp4 = (lTemp >> 4); |
|
29320 |
|
29321 /*G component*/ |
|
29322 lTemp = lY1 - lTemp2; |
|
29323 if (lTemp < 0) |
|
29324 lTemp = 0; |
|
29325 if (lTemp > 255) |
|
29326 lTemp = 255; |
|
29327 lTemp4 |= (lTemp >> 4) << 4; |
|
29328 |
|
29329 /*R component*/ |
|
29330 lTemp = lY1 + lTemp1 + 15; |
|
29331 if (lTemp < 0) |
|
29332 lTemp = 0; |
|
29333 if (lTemp > 255) |
|
29334 lTemp = 255; |
|
29335 lTemp4 |= (lTemp >> 4) << 8; |
|
29336 |
|
29337 lRGBFramePtr[1] = (uint16)lTemp4; |
|
29338 |
|
29339 |
|
29340 lCb1 = lYuyvPtr[lLumWidth]; |
|
29341 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
29342 |
|
29343 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
29344 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
29345 |
|
29346 lCr2 = (lCr1 + lCr2) >> 1; |
|
29347 lCb2 = (lCb1 + lCb2) >> 1; |
|
29348 |
|
29349 /*Third Pixel*/ |
|
29350 lCr1 -= 128; |
|
29351 lCb1 -= 128; |
|
29352 |
|
29353 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
29354 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
29355 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
29356 |
|
29357 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
29358 |
|
29359 /*B component*/ |
|
29360 lTemp = lY1 + lTemp3 + 15; |
|
29361 if (lTemp < 0) |
|
29362 lTemp = 0; |
|
29363 if (lTemp > 255) |
|
29364 lTemp = 255; |
|
29365 lTemp4 = (lTemp >> 4); |
|
29366 |
|
29367 /*G component*/ |
|
29368 lTemp = lY1 - lTemp2 + 5; |
|
29369 if (lTemp < 0) |
|
29370 lTemp = 0; |
|
29371 if (lTemp > 255) |
|
29372 lTemp = 255; |
|
29373 lTemp4 |= (lTemp >> 4) << 4; |
|
29374 |
|
29375 /*R component*/ |
|
29376 lTemp = lY1 + lTemp1 + 10; |
|
29377 if (lTemp < 0) |
|
29378 lTemp = 0; |
|
29379 if (lTemp > 255) |
|
29380 lTemp = 255; |
|
29381 lTemp4 |= (lTemp >> 4) << 8; |
|
29382 |
|
29383 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
29384 |
|
29385 /*Fourth Pixel*/ |
|
29386 lCr2 -= 128; |
|
29387 lCb2 -= 128; |
|
29388 |
|
29389 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
29390 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
29391 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
29392 |
|
29393 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
29394 |
|
29395 /*B component*/ |
|
29396 lTemp = lY1 + lTemp3 + 5; |
|
29397 if (lTemp < 0) |
|
29398 lTemp = 0; |
|
29399 if (lTemp > 255) |
|
29400 lTemp = 255; |
|
29401 lTemp4 = (lTemp >> 4); |
|
29402 |
|
29403 /*G component*/ |
|
29404 lTemp = lY1 - lTemp2 + 10; |
|
29405 if (lTemp < 0) |
|
29406 lTemp = 0; |
|
29407 if (lTemp > 255) |
|
29408 lTemp = 255; |
|
29409 lTemp4 |= (lTemp >> 4) << 4; |
|
29410 |
|
29411 /*R component*/ |
|
29412 lTemp = lY1 + lTemp1; |
|
29413 if (lTemp < 0) |
|
29414 lTemp = 0; |
|
29415 if (lTemp > 255) |
|
29416 lTemp = 255; |
|
29417 lTemp4 |= (lTemp >> 4) << 8; |
|
29418 |
|
29419 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
29420 |
|
29421 lYuyvPtr += 4; |
|
29422 lRGBFramePtr += 2; |
|
29423 lRGBFramePtr1 += 2; |
|
29424 } |
|
29425 |
|
29426 |
|
29427 lCb1 = lYuyvPtr[0]; |
|
29428 lCr1 = lYuyvPtr[2]; |
|
29429 |
|
29430 lCr1 -= 128; |
|
29431 lCb1 -= 128; |
|
29432 |
|
29433 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
29434 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
29435 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
29436 |
|
29437 /*First Pixel*/ |
|
29438 lY1 = lYuyvPtr[1]; |
|
29439 |
|
29440 /*B component*/ |
|
29441 lTemp = lY1 + lTemp3; |
|
29442 if (lTemp < 0) |
|
29443 lTemp = 0; |
|
29444 if (lTemp > 255) |
|
29445 lTemp = 255; |
|
29446 lTemp4 = (lTemp >> 4); |
|
29447 |
|
29448 /*G component*/ |
|
29449 lTemp = lY1 - lTemp2 + 15; |
|
29450 if (lTemp < 0) |
|
29451 lTemp = 0; |
|
29452 if (lTemp > 255) |
|
29453 lTemp = 255; |
|
29454 lTemp4 |= (lTemp >> 4) << 4; |
|
29455 |
|
29456 /*R component*/ |
|
29457 lTemp = lY1 + lTemp1 + 5; |
|
29458 if (lTemp < 0) |
|
29459 lTemp = 0; |
|
29460 if (lTemp > 255) |
|
29461 lTemp = 255; |
|
29462 lTemp4 |= (lTemp >> 4) << 8; |
|
29463 |
|
29464 lRGBFramePtr[0] = (uint16)lTemp4; |
|
29465 |
|
29466 /*Second Pixel*/ |
|
29467 lY1 = lYuyvPtr[3]; |
|
29468 |
|
29469 /*B component*/ |
|
29470 lTemp = lY1 + lTemp3 + 10; |
|
29471 if (lTemp < 0) |
|
29472 lTemp = 0; |
|
29473 if (lTemp > 255) |
|
29474 lTemp = 255; |
|
29475 lTemp4 = (lTemp >> 4); |
|
29476 |
|
29477 /*G component*/ |
|
29478 lTemp = lY1 - lTemp2; |
|
29479 if (lTemp < 0) |
|
29480 lTemp = 0; |
|
29481 if (lTemp > 255) |
|
29482 lTemp = 255; |
|
29483 lTemp4 |= (lTemp >> 4) << 4; |
|
29484 |
|
29485 /*R component*/ |
|
29486 lTemp = lY1 + lTemp1 + 15; |
|
29487 if (lTemp < 0) |
|
29488 lTemp = 0; |
|
29489 if (lTemp > 255) |
|
29490 lTemp = 255; |
|
29491 lTemp4 |= (lTemp >> 4) << 8; |
|
29492 |
|
29493 lRGBFramePtr[1] = (uint16)lTemp4; |
|
29494 |
|
29495 |
|
29496 lCb1 = lYuyvPtr[lLumWidth]; |
|
29497 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
29498 |
|
29499 lCr1 -= 128; |
|
29500 lCb1 -= 128; |
|
29501 |
|
29502 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
29503 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
29504 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
29505 |
|
29506 /*Third Pixel*/ |
|
29507 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
29508 |
|
29509 /*B component*/ |
|
29510 lTemp = lY1 + lTemp3 + 15; |
|
29511 if (lTemp < 0) |
|
29512 lTemp = 0; |
|
29513 if (lTemp > 255) |
|
29514 lTemp = 255; |
|
29515 lTemp4 = (lTemp >> 4); |
|
29516 |
|
29517 /*G component*/ |
|
29518 lTemp = lY1 - lTemp2 + 5; |
|
29519 if (lTemp < 0) |
|
29520 lTemp = 0; |
|
29521 if (lTemp > 255) |
|
29522 lTemp = 255; |
|
29523 lTemp4 |= (lTemp >> 4) << 4; |
|
29524 |
|
29525 /*R component*/ |
|
29526 lTemp = lY1 + lTemp1 + 10; |
|
29527 if (lTemp < 0) |
|
29528 lTemp = 0; |
|
29529 if (lTemp > 255) |
|
29530 lTemp = 255; |
|
29531 lTemp4 |= (lTemp >> 4) << 8; |
|
29532 |
|
29533 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
29534 |
|
29535 /*Fourth Pixel*/ |
|
29536 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
29537 |
|
29538 /*B component*/ |
|
29539 lTemp = lY1 + lTemp3 + 5; |
|
29540 if (lTemp < 0) |
|
29541 lTemp = 0; |
|
29542 if (lTemp > 255) |
|
29543 lTemp = 255; |
|
29544 lTemp4 = (lTemp >> 4); |
|
29545 |
|
29546 /*G component*/ |
|
29547 lTemp = lY1 - lTemp2 + 10; |
|
29548 if (lTemp < 0) |
|
29549 lTemp = 0; |
|
29550 if (lTemp > 255) |
|
29551 lTemp = 255; |
|
29552 lTemp4 |= (lTemp >> 4) << 4; |
|
29553 |
|
29554 /*R component*/ |
|
29555 lTemp = lY1 + lTemp1; |
|
29556 if (lTemp < 0) |
|
29557 lTemp = 0; |
|
29558 if (lTemp > 255) |
|
29559 lTemp = 255; |
|
29560 lTemp4 |= (lTemp >> 4) << 8; |
|
29561 |
|
29562 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
29563 |
|
29564 lYuyvPtr += 4; |
|
29565 lRGBFramePtr += 2; |
|
29566 lRGBFramePtr1 += 2; |
|
29567 |
|
29568 |
|
29569 if(extraCol) |
|
29570 { |
|
29571 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
29572 lRGBFramePtr++; |
|
29573 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
29574 lRGBFramePtr1++; |
|
29575 } |
|
29576 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
29577 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
29578 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
29579 } |
|
29580 |
|
29581 if(extraRow) |
|
29582 { |
|
29583 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
29584 for(j = 0; j < lWidth; j += 2) |
|
29585 { |
|
29586 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
29587 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
29588 } |
|
29589 if(extraCol) |
|
29590 { |
|
29591 *lRGBFramePtr = *lRGBFramePtr1; |
|
29592 } |
|
29593 } |
|
29594 return; |
|
29595 } |
|
29596 |
|
29597 /* |
|
29598 ****************************************************************************** |
|
29599 Name : sEmz_VDec_YUV422BEChr1toColor4k_Ordered_601_5_FR |
|
29600 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
29601 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
29602 uint8 *dstImage : Pointer to rgb data (o/p). |
|
29603 tWndParam *srcWindow : Pointer to structure containing source window |
|
29604 parameters like xOffset,yOffset,cropWidth, |
|
29605 cropHeight. (i/p) |
|
29606 tWndParam *dstWindow : Pointer to structure containing destination window |
|
29607 parameters like xOffset,yOffset,windWidth, |
|
29608 windHeight. (i/p) |
|
29609 Return Value : void |
|
29610 ****************************************************************************** |
|
29611 */ |
|
29612 |
|
29613 void sEmz_VDec_YUV422BEChr1toColor4k_Ordered_601_5_FR |
|
29614 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
29615 tWndParam* srcWindow, tWndParam* dstWindow) |
|
29616 { |
|
29617 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
29618 uint8 *lYuyvPtr; |
|
29619 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
29620 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
29621 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
29622 int32 i, j, extraCol, extraRow; |
|
29623 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
29624 cropWidth,cropHeight,wndWidth,wndHeight; |
|
29625 |
|
29626 srcXOffset = srcWindow->xOffset; |
|
29627 srcYOffset = srcWindow->yOffset; |
|
29628 cropWidth = srcWindow->wndWidth; |
|
29629 cropHeight = srcWindow->wndHeight; |
|
29630 |
|
29631 dstXOffset = dstWindow->xOffset; |
|
29632 dstYOffset = dstWindow->yOffset; |
|
29633 wndWidth = dstWindow->wndWidth; |
|
29634 wndHeight = dstWindow->wndHeight; |
|
29635 |
|
29636 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
29637 { |
|
29638 lWidth = cropWidth; |
|
29639 } |
|
29640 else |
|
29641 { |
|
29642 lWidth = srcImage->width - srcXOffset; |
|
29643 } |
|
29644 |
|
29645 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
29646 { |
|
29647 lHeight = cropHeight; |
|
29648 } |
|
29649 else |
|
29650 { |
|
29651 lHeight = srcImage->height - srcYOffset; |
|
29652 } |
|
29653 |
|
29654 if (lWidth > (wndWidth - dstXOffset)) |
|
29655 { |
|
29656 lWidth = wndWidth - dstXOffset; |
|
29657 } |
|
29658 |
|
29659 if (lHeight > (wndHeight - dstYOffset)) |
|
29660 { |
|
29661 lHeight = wndHeight - dstYOffset; |
|
29662 } |
|
29663 |
|
29664 extraCol = lWidth & 0x01; |
|
29665 extraRow = lHeight & 0x01; |
|
29666 |
|
29667 lTempWidth = lWidth; |
|
29668 lWidth = (lWidth >> 1) << 1; |
|
29669 lHeight = (lHeight >> 1) << 1; |
|
29670 |
|
29671 lLumWidth = (srcImage->width >> 1) << 1; |
|
29672 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
29673 |
|
29674 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
29675 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
29676 |
|
29677 lLumWidth <<= 1; |
|
29678 |
|
29679 for(i = 0; i < lHeight; i += 2) |
|
29680 { |
|
29681 for(j = 0; j < (lWidth - 2); j += 2) |
|
29682 { |
|
29683 lCb1 = lYuyvPtr[0]; |
|
29684 lCr1 = lYuyvPtr[2]; |
|
29685 |
|
29686 lCb2 = lYuyvPtr[4]; |
|
29687 lCr2 = lYuyvPtr[6]; |
|
29688 |
|
29689 lCr2 = (lCr1 + lCr2) >> 1; |
|
29690 lCb2 = (lCb1 + lCb2) >> 1; |
|
29691 |
|
29692 /*First Pixel*/ |
|
29693 lCr1 -= 128; |
|
29694 lCb1 -= 128; |
|
29695 |
|
29696 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
29697 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
29698 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
29699 |
|
29700 lY1 = lYuyvPtr[1]; |
|
29701 |
|
29702 /*B component*/ |
|
29703 lTemp = lY1 + lTemp3; |
|
29704 if (lTemp < 0) |
|
29705 lTemp = 0; |
|
29706 if (lTemp > 255) |
|
29707 lTemp = 255; |
|
29708 lTemp4 = (lTemp >> 4); |
|
29709 |
|
29710 /*G component*/ |
|
29711 lTemp = lY1 - lTemp2 + 15; |
|
29712 if (lTemp < 0) |
|
29713 lTemp = 0; |
|
29714 if (lTemp > 255) |
|
29715 lTemp = 255; |
|
29716 lTemp4 |= (lTemp >> 4) << 4; |
|
29717 |
|
29718 /*R component*/ |
|
29719 lTemp = lY1 + lTemp1 + 5; |
|
29720 if (lTemp < 0) |
|
29721 lTemp = 0; |
|
29722 if (lTemp > 255) |
|
29723 lTemp = 255; |
|
29724 lTemp4 |= (lTemp >> 4) << 8; |
|
29725 |
|
29726 lRGBFramePtr[0] = (uint16)lTemp4; |
|
29727 |
|
29728 /*Second Pixel*/ |
|
29729 lCr2 -= 128; |
|
29730 lCb2 -= 128; |
|
29731 |
|
29732 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
29733 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
29734 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
29735 |
|
29736 lY1 = lYuyvPtr[3]; |
|
29737 |
|
29738 /*B component*/ |
|
29739 lTemp = lY1 + lTemp3 + 10; |
|
29740 if (lTemp < 0) |
|
29741 lTemp = 0; |
|
29742 if (lTemp > 255) |
|
29743 lTemp = 255; |
|
29744 lTemp4 = (lTemp >> 4); |
|
29745 |
|
29746 /*G component*/ |
|
29747 lTemp = lY1 - lTemp2; |
|
29748 if (lTemp < 0) |
|
29749 lTemp = 0; |
|
29750 if (lTemp > 255) |
|
29751 lTemp = 255; |
|
29752 lTemp4 |= (lTemp >> 4) << 4; |
|
29753 |
|
29754 /*R component*/ |
|
29755 lTemp = lY1 + lTemp1 + 15; |
|
29756 if (lTemp < 0) |
|
29757 lTemp = 0; |
|
29758 if (lTemp > 255) |
|
29759 lTemp = 255; |
|
29760 lTemp4 |= (lTemp >> 4) << 8; |
|
29761 |
|
29762 lRGBFramePtr[1] = (uint16)lTemp4; |
|
29763 |
|
29764 |
|
29765 lCb1 = lYuyvPtr[lLumWidth]; |
|
29766 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
29767 |
|
29768 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
29769 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
29770 |
|
29771 lCr2 = (lCr1 + lCr2) >> 1; |
|
29772 lCb2 = (lCb1 + lCb2) >> 1; |
|
29773 |
|
29774 /*Third Pixel*/ |
|
29775 lCr1 -= 128; |
|
29776 lCb1 -= 128; |
|
29777 |
|
29778 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
29779 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
29780 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
29781 |
|
29782 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
29783 |
|
29784 /*B component*/ |
|
29785 lTemp = lY1 + lTemp3 + 15; |
|
29786 if (lTemp < 0) |
|
29787 lTemp = 0; |
|
29788 if (lTemp > 255) |
|
29789 lTemp = 255; |
|
29790 lTemp4 = (lTemp >> 4); |
|
29791 |
|
29792 /*G component*/ |
|
29793 lTemp = lY1 - lTemp2 + 5; |
|
29794 if (lTemp < 0) |
|
29795 lTemp = 0; |
|
29796 if (lTemp > 255) |
|
29797 lTemp = 255; |
|
29798 lTemp4 |= (lTemp >> 4) << 4; |
|
29799 |
|
29800 /*R component*/ |
|
29801 lTemp = lY1 + lTemp1 + 10; |
|
29802 if (lTemp < 0) |
|
29803 lTemp = 0; |
|
29804 if (lTemp > 255) |
|
29805 lTemp = 255; |
|
29806 lTemp4 |= (lTemp >> 4) << 8; |
|
29807 |
|
29808 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
29809 |
|
29810 /*Fourth Pixel*/ |
|
29811 lCr2 -= 128; |
|
29812 lCb2 -= 128; |
|
29813 |
|
29814 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
29815 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
29816 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
29817 |
|
29818 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
29819 |
|
29820 /*B component*/ |
|
29821 lTemp = lY1 + lTemp3 + 5; |
|
29822 if (lTemp < 0) |
|
29823 lTemp = 0; |
|
29824 if (lTemp > 255) |
|
29825 lTemp = 255; |
|
29826 lTemp4 = (lTemp >> 4); |
|
29827 |
|
29828 /*G component*/ |
|
29829 lTemp = lY1 - lTemp2 + 10; |
|
29830 if (lTemp < 0) |
|
29831 lTemp = 0; |
|
29832 if (lTemp > 255) |
|
29833 lTemp = 255; |
|
29834 lTemp4 |= (lTemp >> 4) << 4; |
|
29835 |
|
29836 /*R component*/ |
|
29837 lTemp = lY1 + lTemp1; |
|
29838 if (lTemp < 0) |
|
29839 lTemp = 0; |
|
29840 if (lTemp > 255) |
|
29841 lTemp = 255; |
|
29842 lTemp4 |= (lTemp >> 4) << 8; |
|
29843 |
|
29844 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
29845 |
|
29846 lYuyvPtr += 4; |
|
29847 lRGBFramePtr += 2; |
|
29848 lRGBFramePtr1 += 2; |
|
29849 } |
|
29850 |
|
29851 |
|
29852 lCb1 = lYuyvPtr[0]; |
|
29853 lCr1 = lYuyvPtr[2]; |
|
29854 |
|
29855 lCr1 -= 128; |
|
29856 lCb1 -= 128; |
|
29857 |
|
29858 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
29859 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
29860 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
29861 |
|
29862 /*First Pixel*/ |
|
29863 lY1 = lYuyvPtr[1]; |
|
29864 |
|
29865 /*B component*/ |
|
29866 lTemp = lY1 + lTemp3; |
|
29867 if (lTemp < 0) |
|
29868 lTemp = 0; |
|
29869 if (lTemp > 255) |
|
29870 lTemp = 255; |
|
29871 lTemp4 = (lTemp >> 4); |
|
29872 |
|
29873 /*G component*/ |
|
29874 lTemp = lY1 - lTemp2 + 15; |
|
29875 if (lTemp < 0) |
|
29876 lTemp = 0; |
|
29877 if (lTemp > 255) |
|
29878 lTemp = 255; |
|
29879 lTemp4 |= (lTemp >> 4) << 4; |
|
29880 |
|
29881 /*R component*/ |
|
29882 lTemp = lY1 + lTemp1 + 5; |
|
29883 if (lTemp < 0) |
|
29884 lTemp = 0; |
|
29885 if (lTemp > 255) |
|
29886 lTemp = 255; |
|
29887 lTemp4 |= (lTemp >> 4) << 8; |
|
29888 |
|
29889 lRGBFramePtr[0] = (uint16)lTemp4; |
|
29890 |
|
29891 /*Second Pixel*/ |
|
29892 lY1 = lYuyvPtr[3]; |
|
29893 |
|
29894 /*B component*/ |
|
29895 lTemp = lY1 + lTemp3 + 10; |
|
29896 if (lTemp < 0) |
|
29897 lTemp = 0; |
|
29898 if (lTemp > 255) |
|
29899 lTemp = 255; |
|
29900 lTemp4 = (lTemp >> 4); |
|
29901 |
|
29902 /*G component*/ |
|
29903 lTemp = lY1 - lTemp2; |
|
29904 if (lTemp < 0) |
|
29905 lTemp = 0; |
|
29906 if (lTemp > 255) |
|
29907 lTemp = 255; |
|
29908 lTemp4 |= (lTemp >> 4) << 4; |
|
29909 |
|
29910 /*R component*/ |
|
29911 lTemp = lY1 + lTemp1 + 15; |
|
29912 if (lTemp < 0) |
|
29913 lTemp = 0; |
|
29914 if (lTemp > 255) |
|
29915 lTemp = 255; |
|
29916 lTemp4 |= (lTemp >> 4) << 8; |
|
29917 |
|
29918 lRGBFramePtr[1] = (uint16)lTemp4; |
|
29919 |
|
29920 |
|
29921 lCb1 = lYuyvPtr[lLumWidth]; |
|
29922 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
29923 |
|
29924 lCr1 -= 128; |
|
29925 lCb1 -= 128; |
|
29926 |
|
29927 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
29928 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
29929 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
29930 |
|
29931 /*Third Pixel*/ |
|
29932 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
29933 |
|
29934 /*B component*/ |
|
29935 lTemp = lY1 + lTemp3 + 15; |
|
29936 if (lTemp < 0) |
|
29937 lTemp = 0; |
|
29938 if (lTemp > 255) |
|
29939 lTemp = 255; |
|
29940 lTemp4 = (lTemp >> 4); |
|
29941 |
|
29942 /*G component*/ |
|
29943 lTemp = lY1 - lTemp2 + 5; |
|
29944 if (lTemp < 0) |
|
29945 lTemp = 0; |
|
29946 if (lTemp > 255) |
|
29947 lTemp = 255; |
|
29948 lTemp4 |= (lTemp >> 4) << 4; |
|
29949 |
|
29950 /*R component*/ |
|
29951 lTemp = lY1 + lTemp1 + 10; |
|
29952 if (lTemp < 0) |
|
29953 lTemp = 0; |
|
29954 if (lTemp > 255) |
|
29955 lTemp = 255; |
|
29956 lTemp4 |= (lTemp >> 4) << 8; |
|
29957 |
|
29958 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
29959 |
|
29960 /*Fourth Pixel*/ |
|
29961 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
29962 |
|
29963 /*B component*/ |
|
29964 lTemp = lY1 + lTemp3 + 5; |
|
29965 if (lTemp < 0) |
|
29966 lTemp = 0; |
|
29967 if (lTemp > 255) |
|
29968 lTemp = 255; |
|
29969 lTemp4 = (lTemp >> 4); |
|
29970 |
|
29971 /*G component*/ |
|
29972 lTemp = lY1 - lTemp2 + 10; |
|
29973 if (lTemp < 0) |
|
29974 lTemp = 0; |
|
29975 if (lTemp > 255) |
|
29976 lTemp = 255; |
|
29977 lTemp4 |= (lTemp >> 4) << 4; |
|
29978 |
|
29979 /*R component*/ |
|
29980 lTemp = lY1 + lTemp1; |
|
29981 if (lTemp < 0) |
|
29982 lTemp = 0; |
|
29983 if (lTemp > 255) |
|
29984 lTemp = 255; |
|
29985 lTemp4 |= (lTemp >> 4) << 8; |
|
29986 |
|
29987 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
29988 |
|
29989 lYuyvPtr += 4; |
|
29990 lRGBFramePtr += 2; |
|
29991 lRGBFramePtr1 += 2; |
|
29992 |
|
29993 |
|
29994 if(extraCol) |
|
29995 { |
|
29996 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
29997 lRGBFramePtr++; |
|
29998 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
29999 lRGBFramePtr1++; |
|
30000 } |
|
30001 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
30002 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
30003 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
30004 } |
|
30005 |
|
30006 if(extraRow) |
|
30007 { |
|
30008 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
30009 for(j = 0; j < lWidth; j += 2) |
|
30010 { |
|
30011 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
30012 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
30013 } |
|
30014 if(extraCol) |
|
30015 { |
|
30016 *lRGBFramePtr = *lRGBFramePtr1; |
|
30017 } |
|
30018 } |
|
30019 return; |
|
30020 } |
|
30021 |
|
30022 /* |
|
30023 ****************************************************************************** |
|
30024 Name : sEmz_VDec_YUV422BEChr1toColor4k_Ordered_709_RR |
|
30025 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
30026 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
30027 uint8 *dstImage : Pointer to rgb data (o/p). |
|
30028 tWndParam *srcWindow : Pointer to structure containing source window |
|
30029 parameters like xOffset,yOffset,cropWidth, |
|
30030 cropHeight. (i/p) |
|
30031 tWndParam *dstWindow : Pointer to structure containing destination window |
|
30032 parameters like xOffset,yOffset,windWidth, |
|
30033 windHeight. (i/p) |
|
30034 Return Value : void |
|
30035 ****************************************************************************** |
|
30036 */ |
|
30037 |
|
30038 void sEmz_VDec_YUV422BEChr1toColor4k_Ordered_709_RR |
|
30039 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
30040 tWndParam* srcWindow, tWndParam* dstWindow) |
|
30041 { |
|
30042 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
30043 uint8 *lYuyvPtr; |
|
30044 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
30045 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
30046 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
30047 int32 i, j, extraCol, extraRow; |
|
30048 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
30049 cropWidth,cropHeight,wndWidth,wndHeight; |
|
30050 |
|
30051 srcXOffset = srcWindow->xOffset; |
|
30052 srcYOffset = srcWindow->yOffset; |
|
30053 cropWidth = srcWindow->wndWidth; |
|
30054 cropHeight = srcWindow->wndHeight; |
|
30055 |
|
30056 dstXOffset = dstWindow->xOffset; |
|
30057 dstYOffset = dstWindow->yOffset; |
|
30058 wndWidth = dstWindow->wndWidth; |
|
30059 wndHeight = dstWindow->wndHeight; |
|
30060 |
|
30061 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
30062 { |
|
30063 lWidth = cropWidth; |
|
30064 } |
|
30065 else |
|
30066 { |
|
30067 lWidth = srcImage->width - srcXOffset; |
|
30068 } |
|
30069 |
|
30070 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
30071 { |
|
30072 lHeight = cropHeight; |
|
30073 } |
|
30074 else |
|
30075 { |
|
30076 lHeight = srcImage->height - srcYOffset; |
|
30077 } |
|
30078 |
|
30079 if (lWidth > (wndWidth - dstXOffset)) |
|
30080 { |
|
30081 lWidth = wndWidth - dstXOffset; |
|
30082 } |
|
30083 |
|
30084 if (lHeight > (wndHeight - dstYOffset)) |
|
30085 { |
|
30086 lHeight = wndHeight - dstYOffset; |
|
30087 } |
|
30088 |
|
30089 extraCol = lWidth & 0x01; |
|
30090 extraRow = lHeight & 0x01; |
|
30091 |
|
30092 lTempWidth = lWidth; |
|
30093 lWidth = (lWidth >> 1) << 1; |
|
30094 lHeight = (lHeight >> 1) << 1; |
|
30095 |
|
30096 lLumWidth = (srcImage->width >> 1) << 1; |
|
30097 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
30098 |
|
30099 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
30100 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
30101 |
|
30102 lLumWidth <<= 1; |
|
30103 |
|
30104 for(i = 0; i < lHeight; i += 2) |
|
30105 { |
|
30106 for(j = 0; j < (lWidth - 2); j += 2) |
|
30107 { |
|
30108 lCb1 = lYuyvPtr[0]; |
|
30109 lCr1 = lYuyvPtr[2]; |
|
30110 |
|
30111 lCb2 = lYuyvPtr[4]; |
|
30112 lCr2 = lYuyvPtr[6]; |
|
30113 |
|
30114 lCr2 = (lCr1 + lCr2) >> 1; |
|
30115 lCb2 = (lCb1 + lCb2) >> 1; |
|
30116 |
|
30117 /*First Pixel*/ |
|
30118 lCr1 -= 128; |
|
30119 lCb1 -= 128; |
|
30120 |
|
30121 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
30122 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
30123 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
30124 |
|
30125 lY1 = lYuyvPtr[1]; |
|
30126 lY1 -= 16; |
|
30127 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30128 |
|
30129 /*B component*/ |
|
30130 lTemp = lY1 + lTemp3; |
|
30131 if (lTemp < 0) |
|
30132 lTemp = 0; |
|
30133 if (lTemp > 255) |
|
30134 lTemp = 255; |
|
30135 lTemp4 = (lTemp >> 4); |
|
30136 |
|
30137 /*G component*/ |
|
30138 lTemp = lY1 - lTemp2 + 15; |
|
30139 if (lTemp < 0) |
|
30140 lTemp = 0; |
|
30141 if (lTemp > 255) |
|
30142 lTemp = 255; |
|
30143 lTemp4 |= (lTemp >> 4) << 4; |
|
30144 |
|
30145 /*R component*/ |
|
30146 lTemp = lY1 + lTemp1 + 5; |
|
30147 if (lTemp < 0) |
|
30148 lTemp = 0; |
|
30149 if (lTemp > 255) |
|
30150 lTemp = 255; |
|
30151 lTemp4 |= (lTemp >> 4) << 8; |
|
30152 |
|
30153 lRGBFramePtr[0] = (uint16)lTemp4; |
|
30154 |
|
30155 /*Second Pixel*/ |
|
30156 lCr2 -= 128; |
|
30157 lCb2 -= 128; |
|
30158 |
|
30159 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
30160 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
30161 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
30162 |
|
30163 lY1 = lYuyvPtr[3]; |
|
30164 lY1 -= 16; |
|
30165 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30166 |
|
30167 /*B component*/ |
|
30168 lTemp = lY1 + lTemp3 + 10; |
|
30169 if (lTemp < 0) |
|
30170 lTemp = 0; |
|
30171 if (lTemp > 255) |
|
30172 lTemp = 255; |
|
30173 lTemp4 = (lTemp >> 4); |
|
30174 |
|
30175 /*G component*/ |
|
30176 lTemp = lY1 - lTemp2; |
|
30177 if (lTemp < 0) |
|
30178 lTemp = 0; |
|
30179 if (lTemp > 255) |
|
30180 lTemp = 255; |
|
30181 lTemp4 |= (lTemp >> 4) << 4; |
|
30182 |
|
30183 /*R component*/ |
|
30184 lTemp = lY1 + lTemp1 + 15; |
|
30185 if (lTemp < 0) |
|
30186 lTemp = 0; |
|
30187 if (lTemp > 255) |
|
30188 lTemp = 255; |
|
30189 lTemp4 |= (lTemp >> 4) << 8; |
|
30190 |
|
30191 lRGBFramePtr[1] = (uint16)lTemp4; |
|
30192 |
|
30193 |
|
30194 lCb1 = lYuyvPtr[lLumWidth]; |
|
30195 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
30196 |
|
30197 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
30198 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
30199 |
|
30200 lCr2 = (lCr1 + lCr2) >> 1; |
|
30201 lCb2 = (lCb1 + lCb2) >> 1; |
|
30202 |
|
30203 /*Third Pixel*/ |
|
30204 lCr1 -= 128; |
|
30205 lCb1 -= 128; |
|
30206 |
|
30207 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
30208 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
30209 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
30210 |
|
30211 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
30212 lY1 -= 16; |
|
30213 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30214 |
|
30215 /*B component*/ |
|
30216 lTemp = lY1 + lTemp3 + 15; |
|
30217 if (lTemp < 0) |
|
30218 lTemp = 0; |
|
30219 if (lTemp > 255) |
|
30220 lTemp = 255; |
|
30221 lTemp4 = (lTemp >> 4); |
|
30222 |
|
30223 /*G component*/ |
|
30224 lTemp = lY1 - lTemp2 + 5; |
|
30225 if (lTemp < 0) |
|
30226 lTemp = 0; |
|
30227 if (lTemp > 255) |
|
30228 lTemp = 255; |
|
30229 lTemp4 |= (lTemp >> 4) << 4; |
|
30230 |
|
30231 /*R component*/ |
|
30232 lTemp = lY1 + lTemp1 + 10; |
|
30233 if (lTemp < 0) |
|
30234 lTemp = 0; |
|
30235 if (lTemp > 255) |
|
30236 lTemp = 255; |
|
30237 lTemp4 |= (lTemp >> 4) << 8; |
|
30238 |
|
30239 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
30240 |
|
30241 /*Fourth Pixel*/ |
|
30242 lCr2 -= 128; |
|
30243 lCb2 -= 128; |
|
30244 |
|
30245 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
30246 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
30247 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
30248 |
|
30249 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
30250 lY1 -= 16; |
|
30251 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30252 |
|
30253 /*B component*/ |
|
30254 lTemp = lY1 + lTemp3 + 5; |
|
30255 if (lTemp < 0) |
|
30256 lTemp = 0; |
|
30257 if (lTemp > 255) |
|
30258 lTemp = 255; |
|
30259 lTemp4 = (lTemp >> 4); |
|
30260 |
|
30261 /*G component*/ |
|
30262 lTemp = lY1 - lTemp2 + 10; |
|
30263 if (lTemp < 0) |
|
30264 lTemp = 0; |
|
30265 if (lTemp > 255) |
|
30266 lTemp = 255; |
|
30267 lTemp4 |= (lTemp >> 4) << 4; |
|
30268 |
|
30269 /*R component*/ |
|
30270 lTemp = lY1 + lTemp1; |
|
30271 if (lTemp < 0) |
|
30272 lTemp = 0; |
|
30273 if (lTemp > 255) |
|
30274 lTemp = 255; |
|
30275 lTemp4 |= (lTemp >> 4) << 8; |
|
30276 |
|
30277 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
30278 |
|
30279 lYuyvPtr += 4; |
|
30280 lRGBFramePtr += 2; |
|
30281 lRGBFramePtr1 += 2; |
|
30282 } |
|
30283 |
|
30284 |
|
30285 lCb1 = lYuyvPtr[0]; |
|
30286 lCr1 = lYuyvPtr[2]; |
|
30287 |
|
30288 lCr1 -= 128; |
|
30289 lCb1 -= 128; |
|
30290 |
|
30291 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
30292 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
30293 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
30294 |
|
30295 /*First Pixel*/ |
|
30296 lY1 = lYuyvPtr[1]; |
|
30297 lY1 -= 16; |
|
30298 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30299 |
|
30300 /*B component*/ |
|
30301 lTemp = lY1 + lTemp3; |
|
30302 if (lTemp < 0) |
|
30303 lTemp = 0; |
|
30304 if (lTemp > 255) |
|
30305 lTemp = 255; |
|
30306 lTemp4 = (lTemp >> 4); |
|
30307 |
|
30308 /*G component*/ |
|
30309 lTemp = lY1 - lTemp2 + 15; |
|
30310 if (lTemp < 0) |
|
30311 lTemp = 0; |
|
30312 if (lTemp > 255) |
|
30313 lTemp = 255; |
|
30314 lTemp4 |= (lTemp >> 4) << 4; |
|
30315 |
|
30316 /*R component*/ |
|
30317 lTemp = lY1 + lTemp1 + 5; |
|
30318 if (lTemp < 0) |
|
30319 lTemp = 0; |
|
30320 if (lTemp > 255) |
|
30321 lTemp = 255; |
|
30322 lTemp4 |= (lTemp >> 4) << 8; |
|
30323 |
|
30324 lRGBFramePtr[0] = (uint16)lTemp4; |
|
30325 |
|
30326 /*Second Pixel*/ |
|
30327 lY1 = lYuyvPtr[3]; |
|
30328 lY1 -= 16; |
|
30329 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30330 |
|
30331 /*B component*/ |
|
30332 lTemp = lY1 + lTemp3 + 10; |
|
30333 if (lTemp < 0) |
|
30334 lTemp = 0; |
|
30335 if (lTemp > 255) |
|
30336 lTemp = 255; |
|
30337 lTemp4 = (lTemp >> 4); |
|
30338 |
|
30339 /*G component*/ |
|
30340 lTemp = lY1 - lTemp2; |
|
30341 if (lTemp < 0) |
|
30342 lTemp = 0; |
|
30343 if (lTemp > 255) |
|
30344 lTemp = 255; |
|
30345 lTemp4 |= (lTemp >> 4) << 4; |
|
30346 |
|
30347 /*R component*/ |
|
30348 lTemp = lY1 + lTemp1 + 15; |
|
30349 if (lTemp < 0) |
|
30350 lTemp = 0; |
|
30351 if (lTemp > 255) |
|
30352 lTemp = 255; |
|
30353 lTemp4 |= (lTemp >> 4) << 8; |
|
30354 |
|
30355 lRGBFramePtr[1] = (uint16)lTemp4; |
|
30356 |
|
30357 |
|
30358 lCb1 = lYuyvPtr[lLumWidth]; |
|
30359 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
30360 |
|
30361 lCr1 -= 128; |
|
30362 lCb1 -= 128; |
|
30363 |
|
30364 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
30365 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
30366 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
30367 |
|
30368 /*Third Pixel*/ |
|
30369 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
30370 lY1 -= 16; |
|
30371 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30372 |
|
30373 /*B component*/ |
|
30374 lTemp = lY1 + lTemp3 + 15; |
|
30375 if (lTemp < 0) |
|
30376 lTemp = 0; |
|
30377 if (lTemp > 255) |
|
30378 lTemp = 255; |
|
30379 lTemp4 = (lTemp >> 4); |
|
30380 |
|
30381 /*G component*/ |
|
30382 lTemp = lY1 - lTemp2 + 5; |
|
30383 if (lTemp < 0) |
|
30384 lTemp = 0; |
|
30385 if (lTemp > 255) |
|
30386 lTemp = 255; |
|
30387 lTemp4 |= (lTemp >> 4) << 4; |
|
30388 |
|
30389 /*R component*/ |
|
30390 lTemp = lY1 + lTemp1 + 10; |
|
30391 if (lTemp < 0) |
|
30392 lTemp = 0; |
|
30393 if (lTemp > 255) |
|
30394 lTemp = 255; |
|
30395 lTemp4 |= (lTemp >> 4) << 8; |
|
30396 |
|
30397 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
30398 |
|
30399 /*Fourth Pixel*/ |
|
30400 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
30401 lY1 -= 16; |
|
30402 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30403 |
|
30404 /*B component*/ |
|
30405 lTemp = lY1 + lTemp3 + 5; |
|
30406 if (lTemp < 0) |
|
30407 lTemp = 0; |
|
30408 if (lTemp > 255) |
|
30409 lTemp = 255; |
|
30410 lTemp4 = (lTemp >> 4); |
|
30411 |
|
30412 /*G component*/ |
|
30413 lTemp = lY1 - lTemp2 + 10; |
|
30414 if (lTemp < 0) |
|
30415 lTemp = 0; |
|
30416 if (lTemp > 255) |
|
30417 lTemp = 255; |
|
30418 lTemp4 |= (lTemp >> 4) << 4; |
|
30419 |
|
30420 /*R component*/ |
|
30421 lTemp = lY1 + lTemp1; |
|
30422 if (lTemp < 0) |
|
30423 lTemp = 0; |
|
30424 if (lTemp > 255) |
|
30425 lTemp = 255; |
|
30426 lTemp4 |= (lTemp >> 4) << 8; |
|
30427 |
|
30428 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
30429 |
|
30430 lYuyvPtr += 4; |
|
30431 lRGBFramePtr += 2; |
|
30432 lRGBFramePtr1 += 2; |
|
30433 |
|
30434 |
|
30435 if(extraCol) |
|
30436 { |
|
30437 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
30438 lRGBFramePtr++; |
|
30439 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
30440 lRGBFramePtr1++; |
|
30441 } |
|
30442 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
30443 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
30444 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
30445 } |
|
30446 |
|
30447 if(extraRow) |
|
30448 { |
|
30449 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
30450 for(j = 0; j < lWidth; j += 2) |
|
30451 { |
|
30452 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
30453 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
30454 } |
|
30455 if(extraCol) |
|
30456 { |
|
30457 *lRGBFramePtr = *lRGBFramePtr1; |
|
30458 } |
|
30459 } |
|
30460 return; |
|
30461 } |
|
30462 |
|
30463 /* |
|
30464 ****************************************************************************** |
|
30465 Name : sEmz_VDec_YUV422BEChr1toColor4k_Ordered_601_5_RR |
|
30466 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
30467 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
30468 uint8 *dstImage : Pointer to rgb data (o/p). |
|
30469 tWndParam *srcWindow : Pointer to structure containing source window |
|
30470 parameters like xOffset,yOffset,cropWidth, |
|
30471 cropHeight. (i/p) |
|
30472 tWndParam *dstWindow : Pointer to structure containing destination window |
|
30473 parameters like xOffset,yOffset,windWidth, |
|
30474 windHeight. (i/p) |
|
30475 Return Value : void |
|
30476 ****************************************************************************** |
|
30477 */ |
|
30478 |
|
30479 void sEmz_VDec_YUV422BEChr1toColor4k_Ordered_601_5_RR |
|
30480 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
30481 tWndParam* srcWindow, tWndParam* dstWindow) |
|
30482 { |
|
30483 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
30484 uint8 *lYuyvPtr; |
|
30485 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
30486 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
30487 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
30488 int32 i, j, extraCol, extraRow; |
|
30489 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
30490 cropWidth,cropHeight,wndWidth,wndHeight; |
|
30491 |
|
30492 srcXOffset = srcWindow->xOffset; |
|
30493 srcYOffset = srcWindow->yOffset; |
|
30494 cropWidth = srcWindow->wndWidth; |
|
30495 cropHeight = srcWindow->wndHeight; |
|
30496 |
|
30497 dstXOffset = dstWindow->xOffset; |
|
30498 dstYOffset = dstWindow->yOffset; |
|
30499 wndWidth = dstWindow->wndWidth; |
|
30500 wndHeight = dstWindow->wndHeight; |
|
30501 |
|
30502 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
30503 { |
|
30504 lWidth = cropWidth; |
|
30505 } |
|
30506 else |
|
30507 { |
|
30508 lWidth = srcImage->width - srcXOffset; |
|
30509 } |
|
30510 |
|
30511 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
30512 { |
|
30513 lHeight = cropHeight; |
|
30514 } |
|
30515 else |
|
30516 { |
|
30517 lHeight = srcImage->height - srcYOffset; |
|
30518 } |
|
30519 |
|
30520 if (lWidth > (wndWidth - dstXOffset)) |
|
30521 { |
|
30522 lWidth = wndWidth - dstXOffset; |
|
30523 } |
|
30524 |
|
30525 if (lHeight > (wndHeight - dstYOffset)) |
|
30526 { |
|
30527 lHeight = wndHeight - dstYOffset; |
|
30528 } |
|
30529 |
|
30530 extraCol = lWidth & 0x01; |
|
30531 extraRow = lHeight & 0x01; |
|
30532 |
|
30533 lTempWidth = lWidth; |
|
30534 lWidth = (lWidth >> 1) << 1; |
|
30535 lHeight = (lHeight >> 1) << 1; |
|
30536 |
|
30537 lLumWidth = (srcImage->width >> 1) << 1; |
|
30538 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
30539 |
|
30540 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
30541 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
30542 |
|
30543 lLumWidth <<= 1; |
|
30544 |
|
30545 for(i = 0; i < lHeight; i += 2) |
|
30546 { |
|
30547 for(j = 0; j < (lWidth - 2); j += 2) |
|
30548 { |
|
30549 lCb1 = lYuyvPtr[0]; |
|
30550 lCr1 = lYuyvPtr[2]; |
|
30551 |
|
30552 lCb2 = lYuyvPtr[4]; |
|
30553 lCr2 = lYuyvPtr[6]; |
|
30554 |
|
30555 lCr2 = (lCr1 + lCr2) >> 1; |
|
30556 lCb2 = (lCb1 + lCb2) >> 1; |
|
30557 |
|
30558 /*First Pixel*/ |
|
30559 lCr1 -= 128; |
|
30560 lCb1 -= 128; |
|
30561 |
|
30562 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
30563 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
30564 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
30565 |
|
30566 lY1 = lYuyvPtr[1]; |
|
30567 lY1 -= 16; |
|
30568 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30569 |
|
30570 /*B component*/ |
|
30571 lTemp = lY1 + lTemp3; |
|
30572 if (lTemp < 0) |
|
30573 lTemp = 0; |
|
30574 if (lTemp > 255) |
|
30575 lTemp = 255; |
|
30576 lTemp4 = (lTemp >> 4); |
|
30577 |
|
30578 /*G component*/ |
|
30579 lTemp = lY1 - lTemp2 + 15; |
|
30580 if (lTemp < 0) |
|
30581 lTemp = 0; |
|
30582 if (lTemp > 255) |
|
30583 lTemp = 255; |
|
30584 lTemp4 |= (lTemp >> 4) << 4; |
|
30585 |
|
30586 /*R component*/ |
|
30587 lTemp = lY1 + lTemp1 + 5; |
|
30588 if (lTemp < 0) |
|
30589 lTemp = 0; |
|
30590 if (lTemp > 255) |
|
30591 lTemp = 255; |
|
30592 lTemp4 |= (lTemp >> 4) << 8; |
|
30593 |
|
30594 lRGBFramePtr[0] = (uint16)lTemp4; |
|
30595 |
|
30596 /*Second Pixel*/ |
|
30597 lCr2 -= 128; |
|
30598 lCb2 -= 128; |
|
30599 |
|
30600 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
30601 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
30602 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
30603 |
|
30604 lY1 = lYuyvPtr[3]; |
|
30605 lY1 -= 16; |
|
30606 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30607 |
|
30608 /*B component*/ |
|
30609 lTemp = lY1 + lTemp3 + 10; |
|
30610 if (lTemp < 0) |
|
30611 lTemp = 0; |
|
30612 if (lTemp > 255) |
|
30613 lTemp = 255; |
|
30614 lTemp4 = (lTemp >> 4); |
|
30615 |
|
30616 /*G component*/ |
|
30617 lTemp = lY1 - lTemp2; |
|
30618 if (lTemp < 0) |
|
30619 lTemp = 0; |
|
30620 if (lTemp > 255) |
|
30621 lTemp = 255; |
|
30622 lTemp4 |= (lTemp >> 4) << 4; |
|
30623 |
|
30624 /*R component*/ |
|
30625 lTemp = lY1 + lTemp1 + 15; |
|
30626 if (lTemp < 0) |
|
30627 lTemp = 0; |
|
30628 if (lTemp > 255) |
|
30629 lTemp = 255; |
|
30630 lTemp4 |= (lTemp >> 4) << 8; |
|
30631 |
|
30632 lRGBFramePtr[1] = (uint16)lTemp4; |
|
30633 |
|
30634 |
|
30635 lCb1 = lYuyvPtr[lLumWidth]; |
|
30636 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
30637 |
|
30638 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
30639 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
30640 |
|
30641 lCr2 = (lCr1 + lCr2) >> 1; |
|
30642 lCb2 = (lCb1 + lCb2) >> 1; |
|
30643 |
|
30644 /*Third Pixel*/ |
|
30645 lCr1 -= 128; |
|
30646 lCb1 -= 128; |
|
30647 |
|
30648 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
30649 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
30650 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
30651 |
|
30652 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
30653 lY1 -= 16; |
|
30654 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30655 |
|
30656 /*B component*/ |
|
30657 lTemp = lY1 + lTemp3 + 15; |
|
30658 if (lTemp < 0) |
|
30659 lTemp = 0; |
|
30660 if (lTemp > 255) |
|
30661 lTemp = 255; |
|
30662 lTemp4 = (lTemp >> 4); |
|
30663 |
|
30664 /*G component*/ |
|
30665 lTemp = lY1 - lTemp2 + 5; |
|
30666 if (lTemp < 0) |
|
30667 lTemp = 0; |
|
30668 if (lTemp > 255) |
|
30669 lTemp = 255; |
|
30670 lTemp4 |= (lTemp >> 4) << 4; |
|
30671 |
|
30672 /*R component*/ |
|
30673 lTemp = lY1 + lTemp1 + 10; |
|
30674 if (lTemp < 0) |
|
30675 lTemp = 0; |
|
30676 if (lTemp > 255) |
|
30677 lTemp = 255; |
|
30678 lTemp4 |= (lTemp >> 4) << 8; |
|
30679 |
|
30680 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
30681 |
|
30682 /*Fourth Pixel*/ |
|
30683 lCr2 -= 128; |
|
30684 lCb2 -= 128; |
|
30685 |
|
30686 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
30687 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
30688 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
30689 |
|
30690 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
30691 lY1 -= 16; |
|
30692 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30693 |
|
30694 /*B component*/ |
|
30695 lTemp = lY1 + lTemp3 + 5; |
|
30696 if (lTemp < 0) |
|
30697 lTemp = 0; |
|
30698 if (lTemp > 255) |
|
30699 lTemp = 255; |
|
30700 lTemp4 = (lTemp >> 4); |
|
30701 |
|
30702 /*G component*/ |
|
30703 lTemp = lY1 - lTemp2 + 10; |
|
30704 if (lTemp < 0) |
|
30705 lTemp = 0; |
|
30706 if (lTemp > 255) |
|
30707 lTemp = 255; |
|
30708 lTemp4 |= (lTemp >> 4) << 4; |
|
30709 |
|
30710 /*R component*/ |
|
30711 lTemp = lY1 + lTemp1; |
|
30712 if (lTemp < 0) |
|
30713 lTemp = 0; |
|
30714 if (lTemp > 255) |
|
30715 lTemp = 255; |
|
30716 lTemp4 |= (lTemp >> 4) << 8; |
|
30717 |
|
30718 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
30719 |
|
30720 lYuyvPtr += 4; |
|
30721 lRGBFramePtr += 2; |
|
30722 lRGBFramePtr1 += 2; |
|
30723 } |
|
30724 |
|
30725 |
|
30726 lCb1 = lYuyvPtr[0]; |
|
30727 lCr1 = lYuyvPtr[2]; |
|
30728 |
|
30729 lCr1 -= 128; |
|
30730 lCb1 -= 128; |
|
30731 |
|
30732 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
30733 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
30734 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
30735 |
|
30736 /*First Pixel*/ |
|
30737 lY1 = lYuyvPtr[1]; |
|
30738 lY1 -= 16; |
|
30739 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30740 |
|
30741 /*B component*/ |
|
30742 lTemp = lY1 + lTemp3; |
|
30743 if (lTemp < 0) |
|
30744 lTemp = 0; |
|
30745 if (lTemp > 255) |
|
30746 lTemp = 255; |
|
30747 lTemp4 = (lTemp >> 4); |
|
30748 |
|
30749 /*G component*/ |
|
30750 lTemp = lY1 - lTemp2 + 15; |
|
30751 if (lTemp < 0) |
|
30752 lTemp = 0; |
|
30753 if (lTemp > 255) |
|
30754 lTemp = 255; |
|
30755 lTemp4 |= (lTemp >> 4) << 4; |
|
30756 |
|
30757 /*R component*/ |
|
30758 lTemp = lY1 + lTemp1 + 5; |
|
30759 if (lTemp < 0) |
|
30760 lTemp = 0; |
|
30761 if (lTemp > 255) |
|
30762 lTemp = 255; |
|
30763 lTemp4 |= (lTemp >> 4) << 8; |
|
30764 |
|
30765 lRGBFramePtr[0] = (uint16)lTemp4; |
|
30766 |
|
30767 /*Second Pixel*/ |
|
30768 lY1 = lYuyvPtr[3]; |
|
30769 lY1 -= 16; |
|
30770 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30771 |
|
30772 /*B component*/ |
|
30773 lTemp = lY1 + lTemp3 + 10; |
|
30774 if (lTemp < 0) |
|
30775 lTemp = 0; |
|
30776 if (lTemp > 255) |
|
30777 lTemp = 255; |
|
30778 lTemp4 = (lTemp >> 4); |
|
30779 |
|
30780 /*G component*/ |
|
30781 lTemp = lY1 - lTemp2; |
|
30782 if (lTemp < 0) |
|
30783 lTemp = 0; |
|
30784 if (lTemp > 255) |
|
30785 lTemp = 255; |
|
30786 lTemp4 |= (lTemp >> 4) << 4; |
|
30787 |
|
30788 /*R component*/ |
|
30789 lTemp = lY1 + lTemp1 + 15; |
|
30790 if (lTemp < 0) |
|
30791 lTemp = 0; |
|
30792 if (lTemp > 255) |
|
30793 lTemp = 255; |
|
30794 lTemp4 |= (lTemp >> 4) << 8; |
|
30795 |
|
30796 lRGBFramePtr[1] = (uint16)lTemp4; |
|
30797 |
|
30798 |
|
30799 lCb1 = lYuyvPtr[lLumWidth]; |
|
30800 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
30801 |
|
30802 lCr1 -= 128; |
|
30803 lCb1 -= 128; |
|
30804 |
|
30805 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
30806 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
30807 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
30808 |
|
30809 /*Third Pixel*/ |
|
30810 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
30811 lY1 -= 16; |
|
30812 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30813 |
|
30814 /*B component*/ |
|
30815 lTemp = lY1 + lTemp3 + 15; |
|
30816 if (lTemp < 0) |
|
30817 lTemp = 0; |
|
30818 if (lTemp > 255) |
|
30819 lTemp = 255; |
|
30820 lTemp4 = (lTemp >> 4); |
|
30821 |
|
30822 /*G component*/ |
|
30823 lTemp = lY1 - lTemp2 + 5; |
|
30824 if (lTemp < 0) |
|
30825 lTemp = 0; |
|
30826 if (lTemp > 255) |
|
30827 lTemp = 255; |
|
30828 lTemp4 |= (lTemp >> 4) << 4; |
|
30829 |
|
30830 /*R component*/ |
|
30831 lTemp = lY1 + lTemp1 + 10; |
|
30832 if (lTemp < 0) |
|
30833 lTemp = 0; |
|
30834 if (lTemp > 255) |
|
30835 lTemp = 255; |
|
30836 lTemp4 |= (lTemp >> 4) << 8; |
|
30837 |
|
30838 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
30839 |
|
30840 /*Fourth Pixel*/ |
|
30841 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
30842 lY1 -= 16; |
|
30843 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
30844 |
|
30845 /*B component*/ |
|
30846 lTemp = lY1 + lTemp3 + 5; |
|
30847 if (lTemp < 0) |
|
30848 lTemp = 0; |
|
30849 if (lTemp > 255) |
|
30850 lTemp = 255; |
|
30851 lTemp4 = (lTemp >> 4); |
|
30852 |
|
30853 /*G component*/ |
|
30854 lTemp = lY1 - lTemp2 + 10; |
|
30855 if (lTemp < 0) |
|
30856 lTemp = 0; |
|
30857 if (lTemp > 255) |
|
30858 lTemp = 255; |
|
30859 lTemp4 |= (lTemp >> 4) << 4; |
|
30860 |
|
30861 /*R component*/ |
|
30862 lTemp = lY1 + lTemp1; |
|
30863 if (lTemp < 0) |
|
30864 lTemp = 0; |
|
30865 if (lTemp > 255) |
|
30866 lTemp = 255; |
|
30867 lTemp4 |= (lTemp >> 4) << 8; |
|
30868 |
|
30869 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
30870 |
|
30871 lYuyvPtr += 4; |
|
30872 lRGBFramePtr += 2; |
|
30873 lRGBFramePtr1 += 2; |
|
30874 |
|
30875 |
|
30876 if(extraCol) |
|
30877 { |
|
30878 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
30879 lRGBFramePtr++; |
|
30880 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
30881 lRGBFramePtr1++; |
|
30882 } |
|
30883 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
30884 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
30885 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
30886 } |
|
30887 |
|
30888 if(extraRow) |
|
30889 { |
|
30890 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
30891 for(j = 0; j < lWidth; j += 2) |
|
30892 { |
|
30893 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
30894 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
30895 } |
|
30896 if(extraCol) |
|
30897 { |
|
30898 *lRGBFramePtr = *lRGBFramePtr1; |
|
30899 } |
|
30900 } |
|
30901 return; |
|
30902 } |
|
30903 |
|
30904 |
|
30905 /* |
|
30906 ****************************************************************************** |
|
30907 Name : sEmz_VDec_YUV422BEChr1toColor16MU_709_FR |
|
30908 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
30909 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
30910 uint8 *dstImage : Pointer to rgb data (o/p). |
|
30911 tWndParam *srcWindow : Pointer to structure containing source window |
|
30912 parameters like xOffset,yOffset,cropWidth, |
|
30913 cropHeight. (i/p) |
|
30914 tWndParam *dstWindow : Pointer to structure containing destination window |
|
30915 parameters like xOffset,yOffset,windWidth, |
|
30916 windHeight. (i/p) |
|
30917 Return Value : void |
|
30918 ****************************************************************************** |
|
30919 */ |
|
30920 |
|
30921 void sEmz_VDec_YUV422BEChr1toColor16MU_709_FR |
|
30922 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
30923 tWndParam* srcWindow, tWndParam* dstWindow) |
|
30924 { |
|
30925 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
30926 uint8 *lYuyvPtr; |
|
30927 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
30928 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
30929 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
30930 int32 i, j, extraCol, extraRow; |
|
30931 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
30932 cropWidth,cropHeight,wndWidth,wndHeight; |
|
30933 |
|
30934 srcXOffset = srcWindow->xOffset; |
|
30935 srcYOffset = srcWindow->yOffset; |
|
30936 cropWidth = srcWindow->wndWidth; |
|
30937 cropHeight = srcWindow->wndHeight; |
|
30938 |
|
30939 dstXOffset = dstWindow->xOffset; |
|
30940 dstYOffset = dstWindow->yOffset; |
|
30941 wndWidth = dstWindow->wndWidth; |
|
30942 wndHeight = dstWindow->wndHeight; |
|
30943 |
|
30944 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
30945 { |
|
30946 lWidth = cropWidth; |
|
30947 } |
|
30948 else |
|
30949 { |
|
30950 lWidth = srcImage->width - srcXOffset; |
|
30951 } |
|
30952 |
|
30953 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
30954 { |
|
30955 lHeight = cropHeight; |
|
30956 } |
|
30957 else |
|
30958 { |
|
30959 lHeight = srcImage->height - srcYOffset; |
|
30960 } |
|
30961 |
|
30962 if (lWidth > (wndWidth - dstXOffset)) |
|
30963 { |
|
30964 lWidth = wndWidth - dstXOffset; |
|
30965 } |
|
30966 |
|
30967 if (lHeight > (wndHeight - dstYOffset)) |
|
30968 { |
|
30969 lHeight = wndHeight - dstYOffset; |
|
30970 } |
|
30971 |
|
30972 extraCol = lWidth & 0x01; |
|
30973 extraRow = lHeight & 0x01; |
|
30974 |
|
30975 lTempWidth = lWidth; |
|
30976 lWidth = (lWidth >> 1) << 1; |
|
30977 lHeight = (lHeight >> 1) << 1; |
|
30978 |
|
30979 lLumWidth = (srcImage->width >> 1) << 1; |
|
30980 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
30981 |
|
30982 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
30983 |
|
30984 for(i = 0; i < lHeight; i++) |
|
30985 { |
|
30986 for(j = 0; j < (lWidth - 2); j += 2) |
|
30987 { |
|
30988 lCb1 = lYuyvPtr[0]; |
|
30989 lCr1 = lYuyvPtr[2]; |
|
30990 |
|
30991 lCb2 = lYuyvPtr[4]; |
|
30992 lCr2 = lYuyvPtr[6]; |
|
30993 |
|
30994 lCr2 = (lCr1 + lCr2) >> 1; |
|
30995 lCb2 = (lCb1 + lCb2) >> 1; |
|
30996 |
|
30997 lCr1 -= 128; |
|
30998 lCb1 -= 128; |
|
30999 |
|
31000 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
31001 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
31002 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
31003 |
|
31004 /*First Pixel*/ |
|
31005 lY1 = lYuyvPtr[1]; |
|
31006 |
|
31007 /*B component*/ |
|
31008 lTemp = lY1 + lTemp3; |
|
31009 if (lTemp < 0) |
|
31010 lTemp = 0; |
|
31011 if (lTemp > 255) |
|
31012 lTemp = 255; |
|
31013 lTemp4 = (uint8) lTemp; |
|
31014 |
|
31015 /*G component*/ |
|
31016 lTemp = lY1 - lTemp2; |
|
31017 if (lTemp < 0) |
|
31018 lTemp = 0; |
|
31019 if (lTemp > 255) |
|
31020 lTemp = 255; |
|
31021 lTemp4 |= lTemp << 8; |
|
31022 |
|
31023 /*R component*/ |
|
31024 lTemp = lY1 + lTemp1; |
|
31025 if (lTemp < 0) |
|
31026 lTemp = 0; |
|
31027 if (lTemp > 255) |
|
31028 lTemp = 255; |
|
31029 lTemp4 |= lTemp << 16; |
|
31030 |
|
31031 lRGBFramePtr[0] = (uint32)lTemp4; |
|
31032 |
|
31033 lCr2 -= 128; |
|
31034 lCb2 -= 128; |
|
31035 |
|
31036 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
31037 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
31038 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
31039 |
|
31040 /*Second Pixel*/ |
|
31041 lY1 = lYuyvPtr[3]; |
|
31042 |
|
31043 /*B component*/ |
|
31044 lTemp = lY1 + lTemp3; |
|
31045 if (lTemp < 0) |
|
31046 lTemp = 0; |
|
31047 if (lTemp > 255) |
|
31048 lTemp = 255; |
|
31049 lTemp4 = (uint8) lTemp; |
|
31050 |
|
31051 /*G component*/ |
|
31052 lTemp = lY1 - lTemp2; |
|
31053 if (lTemp < 0) |
|
31054 lTemp = 0; |
|
31055 if (lTemp > 255) |
|
31056 lTemp = 255; |
|
31057 lTemp4 |= lTemp << 8; |
|
31058 |
|
31059 /*R component*/ |
|
31060 lTemp = lY1 + lTemp1; |
|
31061 if (lTemp < 0) |
|
31062 lTemp = 0; |
|
31063 if (lTemp > 255) |
|
31064 lTemp = 255; |
|
31065 lTemp4 |= lTemp << 16; |
|
31066 |
|
31067 lRGBFramePtr[1] = (uint32)lTemp4; |
|
31068 |
|
31069 lYuyvPtr += 4; |
|
31070 lRGBFramePtr += 2; |
|
31071 } |
|
31072 |
|
31073 lCb1 = lYuyvPtr[0]; |
|
31074 lCr1 = lYuyvPtr[2]; |
|
31075 |
|
31076 lCr1 -= 128; |
|
31077 lCb1 -= 128; |
|
31078 |
|
31079 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
31080 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
31081 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
31082 |
|
31083 /*First Pixel*/ |
|
31084 lY1 = lYuyvPtr[1]; |
|
31085 |
|
31086 /*B component*/ |
|
31087 lTemp = lY1 + lTemp3; |
|
31088 if (lTemp < 0) |
|
31089 lTemp = 0; |
|
31090 if (lTemp > 255) |
|
31091 lTemp = 255; |
|
31092 lTemp4 = (uint8) lTemp; |
|
31093 |
|
31094 /*G component*/ |
|
31095 lTemp = lY1 - lTemp2; |
|
31096 if (lTemp < 0) |
|
31097 lTemp = 0; |
|
31098 if (lTemp > 255) |
|
31099 lTemp = 255; |
|
31100 lTemp4 |= lTemp << 8; |
|
31101 |
|
31102 /*R component*/ |
|
31103 lTemp = lY1 + lTemp1; |
|
31104 if (lTemp < 0) |
|
31105 lTemp = 0; |
|
31106 if (lTemp > 255) |
|
31107 lTemp = 255; |
|
31108 lTemp4 |= lTemp << 16; |
|
31109 |
|
31110 lRGBFramePtr[0] = (uint32)lTemp4; |
|
31111 |
|
31112 /*Second Pixel*/ |
|
31113 lY1 = lYuyvPtr[3]; |
|
31114 |
|
31115 /*B component*/ |
|
31116 lTemp = lY1 + lTemp3; |
|
31117 if (lTemp < 0) |
|
31118 lTemp = 0; |
|
31119 if (lTemp > 255) |
|
31120 lTemp = 255; |
|
31121 lTemp4 = (uint8) lTemp; |
|
31122 |
|
31123 /*G component*/ |
|
31124 lTemp = lY1 - lTemp2; |
|
31125 if (lTemp < 0) |
|
31126 lTemp = 0; |
|
31127 if (lTemp > 255) |
|
31128 lTemp = 255; |
|
31129 lTemp4 |= lTemp << 8; |
|
31130 |
|
31131 /*R component*/ |
|
31132 lTemp = lY1 + lTemp1; |
|
31133 if (lTemp < 0) |
|
31134 lTemp = 0; |
|
31135 if (lTemp > 255) |
|
31136 lTemp = 255; |
|
31137 lTemp4 |= lTemp << 16; |
|
31138 |
|
31139 lRGBFramePtr[1] = (uint32)lTemp4; |
|
31140 |
|
31141 lYuyvPtr += 4; |
|
31142 lRGBFramePtr += 2; |
|
31143 |
|
31144 if(extraCol) |
|
31145 { |
|
31146 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
31147 lRGBFramePtr++; |
|
31148 } |
|
31149 |
|
31150 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
31151 lRGBFramePtr += (wndWidth - lTempWidth); |
|
31152 } |
|
31153 |
|
31154 if(extraRow) |
|
31155 { |
|
31156 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
31157 for(j = 0; j < lWidth; j += 2) |
|
31158 { |
|
31159 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
31160 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
31161 } |
|
31162 if(extraCol) |
|
31163 { |
|
31164 *lRGBFramePtr = *lRGBFramePtr1; |
|
31165 } |
|
31166 } |
|
31167 return; |
|
31168 } |
|
31169 |
|
31170 /* |
|
31171 ****************************************************************************** |
|
31172 Name : sEmz_VDec_YUV422BEChr1toColor16MU_601_5_FR |
|
31173 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
31174 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
31175 uint8 *dstImage : Pointer to rgb data (o/p). |
|
31176 tWndParam *srcWindow : Pointer to structure containing source window |
|
31177 parameters like xOffset,yOffset,cropWidth, |
|
31178 cropHeight. (i/p) |
|
31179 tWndParam *dstWindow : Pointer to structure containing destination window |
|
31180 parameters like xOffset,yOffset,windWidth, |
|
31181 windHeight. (i/p) |
|
31182 Return Value : void |
|
31183 ****************************************************************************** |
|
31184 */ |
|
31185 |
|
31186 void sEmz_VDec_YUV422BEChr1toColor16MU_601_5_FR |
|
31187 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
31188 tWndParam* srcWindow, tWndParam* dstWindow) |
|
31189 { |
|
31190 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
31191 uint8 *lYuyvPtr; |
|
31192 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
31193 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
31194 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
31195 int32 i, j, extraCol, extraRow; |
|
31196 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
31197 cropWidth,cropHeight,wndWidth,wndHeight; |
|
31198 |
|
31199 srcXOffset = srcWindow->xOffset; |
|
31200 srcYOffset = srcWindow->yOffset; |
|
31201 cropWidth = srcWindow->wndWidth; |
|
31202 cropHeight = srcWindow->wndHeight; |
|
31203 |
|
31204 dstXOffset = dstWindow->xOffset; |
|
31205 dstYOffset = dstWindow->yOffset; |
|
31206 wndWidth = dstWindow->wndWidth; |
|
31207 wndHeight = dstWindow->wndHeight; |
|
31208 |
|
31209 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
31210 { |
|
31211 lWidth = cropWidth; |
|
31212 } |
|
31213 else |
|
31214 { |
|
31215 lWidth = srcImage->width - srcXOffset; |
|
31216 } |
|
31217 |
|
31218 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
31219 { |
|
31220 lHeight = cropHeight; |
|
31221 } |
|
31222 else |
|
31223 { |
|
31224 lHeight = srcImage->height - srcYOffset; |
|
31225 } |
|
31226 |
|
31227 if (lWidth > (wndWidth - dstXOffset)) |
|
31228 { |
|
31229 lWidth = wndWidth - dstXOffset; |
|
31230 } |
|
31231 |
|
31232 if (lHeight > (wndHeight - dstYOffset)) |
|
31233 { |
|
31234 lHeight = wndHeight - dstYOffset; |
|
31235 } |
|
31236 |
|
31237 extraCol = lWidth & 0x01; |
|
31238 extraRow = lHeight & 0x01; |
|
31239 |
|
31240 lTempWidth = lWidth; |
|
31241 lWidth = (lWidth >> 1) << 1; |
|
31242 lHeight = (lHeight >> 1) << 1; |
|
31243 |
|
31244 lLumWidth = (srcImage->width >> 1) << 1; |
|
31245 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
31246 |
|
31247 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
31248 |
|
31249 for(i = 0; i < lHeight; i++) |
|
31250 { |
|
31251 for(j = 0; j < (lWidth - 2); j += 2) |
|
31252 { |
|
31253 lCb1 = lYuyvPtr[0]; |
|
31254 lCr1 = lYuyvPtr[2]; |
|
31255 |
|
31256 lCb2 = lYuyvPtr[4]; |
|
31257 lCr2 = lYuyvPtr[6]; |
|
31258 |
|
31259 lCr2 = (lCr1 + lCr2) >> 1; |
|
31260 lCb2 = (lCb1 + lCb2) >> 1; |
|
31261 |
|
31262 lCr1 -= 128; |
|
31263 lCb1 -= 128; |
|
31264 |
|
31265 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
31266 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
31267 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
31268 |
|
31269 /*First Pixel*/ |
|
31270 lY1 = lYuyvPtr[1]; |
|
31271 |
|
31272 /*B component*/ |
|
31273 lTemp = lY1 + lTemp3; |
|
31274 if (lTemp < 0) |
|
31275 lTemp = 0; |
|
31276 if (lTemp > 255) |
|
31277 lTemp = 255; |
|
31278 lTemp4 = (uint8) lTemp; |
|
31279 |
|
31280 /*G component*/ |
|
31281 lTemp = lY1 - lTemp2; |
|
31282 if (lTemp < 0) |
|
31283 lTemp = 0; |
|
31284 if (lTemp > 255) |
|
31285 lTemp = 255; |
|
31286 lTemp4 |= lTemp << 8; |
|
31287 |
|
31288 /*R component*/ |
|
31289 lTemp = lY1 + lTemp1; |
|
31290 if (lTemp < 0) |
|
31291 lTemp = 0; |
|
31292 if (lTemp > 255) |
|
31293 lTemp = 255; |
|
31294 lTemp4 |= lTemp << 16; |
|
31295 |
|
31296 lRGBFramePtr[0] = (uint32)lTemp4; |
|
31297 |
|
31298 lCr2 -= 128; |
|
31299 lCb2 -= 128; |
|
31300 |
|
31301 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
31302 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
31303 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
31304 |
|
31305 /*Second Pixel*/ |
|
31306 lY1 = lYuyvPtr[3]; |
|
31307 |
|
31308 /*B component*/ |
|
31309 lTemp = lY1 + lTemp3; |
|
31310 if (lTemp < 0) |
|
31311 lTemp = 0; |
|
31312 if (lTemp > 255) |
|
31313 lTemp = 255; |
|
31314 lTemp4 = (uint8) lTemp; |
|
31315 |
|
31316 /*G component*/ |
|
31317 lTemp = lY1 - lTemp2; |
|
31318 if (lTemp < 0) |
|
31319 lTemp = 0; |
|
31320 if (lTemp > 255) |
|
31321 lTemp = 255; |
|
31322 lTemp4 |= lTemp << 8; |
|
31323 |
|
31324 /*R component*/ |
|
31325 lTemp = lY1 + lTemp1; |
|
31326 if (lTemp < 0) |
|
31327 lTemp = 0; |
|
31328 if (lTemp > 255) |
|
31329 lTemp = 255; |
|
31330 lTemp4 |= lTemp << 16; |
|
31331 |
|
31332 lRGBFramePtr[1] = (uint32)lTemp4; |
|
31333 |
|
31334 lYuyvPtr += 4; |
|
31335 lRGBFramePtr += 2; |
|
31336 } |
|
31337 |
|
31338 lCb1 = lYuyvPtr[0]; |
|
31339 lCr1 = lYuyvPtr[2]; |
|
31340 |
|
31341 lCr1 -= 128; |
|
31342 lCb1 -= 128; |
|
31343 |
|
31344 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
31345 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
31346 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
31347 |
|
31348 /*First Pixel*/ |
|
31349 lY1 = lYuyvPtr[1]; |
|
31350 |
|
31351 /*B component*/ |
|
31352 lTemp = lY1 + lTemp3; |
|
31353 if (lTemp < 0) |
|
31354 lTemp = 0; |
|
31355 if (lTemp > 255) |
|
31356 lTemp = 255; |
|
31357 lTemp4 = (uint8) lTemp; |
|
31358 |
|
31359 /*G component*/ |
|
31360 lTemp = lY1 - lTemp2; |
|
31361 if (lTemp < 0) |
|
31362 lTemp = 0; |
|
31363 if (lTemp > 255) |
|
31364 lTemp = 255; |
|
31365 lTemp4 |= lTemp << 8; |
|
31366 |
|
31367 /*R component*/ |
|
31368 lTemp = lY1 + lTemp1; |
|
31369 if (lTemp < 0) |
|
31370 lTemp = 0; |
|
31371 if (lTemp > 255) |
|
31372 lTemp = 255; |
|
31373 lTemp4 |= lTemp << 16; |
|
31374 |
|
31375 lRGBFramePtr[0] = (uint32)lTemp4; |
|
31376 |
|
31377 /*Second Pixel*/ |
|
31378 lY1 = lYuyvPtr[3]; |
|
31379 |
|
31380 /*B component*/ |
|
31381 lTemp = lY1 + lTemp3; |
|
31382 if (lTemp < 0) |
|
31383 lTemp = 0; |
|
31384 if (lTemp > 255) |
|
31385 lTemp = 255; |
|
31386 lTemp4 = (uint8) lTemp; |
|
31387 |
|
31388 /*G component*/ |
|
31389 lTemp = lY1 - lTemp2; |
|
31390 if (lTemp < 0) |
|
31391 lTemp = 0; |
|
31392 if (lTemp > 255) |
|
31393 lTemp = 255; |
|
31394 lTemp4 |= lTemp << 8; |
|
31395 |
|
31396 /*R component*/ |
|
31397 lTemp = lY1 + lTemp1; |
|
31398 if (lTemp < 0) |
|
31399 lTemp = 0; |
|
31400 if (lTemp > 255) |
|
31401 lTemp = 255; |
|
31402 lTemp4 |= lTemp << 16; |
|
31403 |
|
31404 lRGBFramePtr[1] = (uint32)lTemp4; |
|
31405 |
|
31406 lYuyvPtr += 4; |
|
31407 lRGBFramePtr += 2; |
|
31408 |
|
31409 if(extraCol) |
|
31410 { |
|
31411 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
31412 lRGBFramePtr++; |
|
31413 } |
|
31414 |
|
31415 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
31416 lRGBFramePtr += (wndWidth - lTempWidth); |
|
31417 } |
|
31418 |
|
31419 if(extraRow) |
|
31420 { |
|
31421 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
31422 for(j = 0; j < lWidth; j += 2) |
|
31423 { |
|
31424 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
31425 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
31426 } |
|
31427 if(extraCol) |
|
31428 { |
|
31429 *lRGBFramePtr = *lRGBFramePtr1; |
|
31430 } |
|
31431 } |
|
31432 return; |
|
31433 } |
|
31434 |
|
31435 /* |
|
31436 ****************************************************************************** |
|
31437 Name : sEmz_VDec_YUV422BEChr1toColor16MU_709_RR |
|
31438 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
31439 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
31440 uint8 *dstImage : Pointer to rgb data (o/p). |
|
31441 tWndParam *srcWindow : Pointer to structure containing source window |
|
31442 parameters like xOffset,yOffset,cropWidth, |
|
31443 cropHeight. (i/p) |
|
31444 tWndParam *dstWindow : Pointer to structure containing destination window |
|
31445 parameters like xOffset,yOffset,windWidth, |
|
31446 windHeight. (i/p) |
|
31447 Return Value : void |
|
31448 ****************************************************************************** |
|
31449 */ |
|
31450 |
|
31451 void sEmz_VDec_YUV422BEChr1toColor16MU_709_RR |
|
31452 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
31453 tWndParam* srcWindow, tWndParam* dstWindow) |
|
31454 { |
|
31455 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
31456 uint8 *lYuyvPtr; |
|
31457 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
31458 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
31459 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
31460 int32 i, j, extraCol, extraRow; |
|
31461 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
31462 cropWidth,cropHeight,wndWidth,wndHeight; |
|
31463 |
|
31464 srcXOffset = srcWindow->xOffset; |
|
31465 srcYOffset = srcWindow->yOffset; |
|
31466 cropWidth = srcWindow->wndWidth; |
|
31467 cropHeight = srcWindow->wndHeight; |
|
31468 |
|
31469 dstXOffset = dstWindow->xOffset; |
|
31470 dstYOffset = dstWindow->yOffset; |
|
31471 wndWidth = dstWindow->wndWidth; |
|
31472 wndHeight = dstWindow->wndHeight; |
|
31473 |
|
31474 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
31475 { |
|
31476 lWidth = cropWidth; |
|
31477 } |
|
31478 else |
|
31479 { |
|
31480 lWidth = srcImage->width - srcXOffset; |
|
31481 } |
|
31482 |
|
31483 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
31484 { |
|
31485 lHeight = cropHeight; |
|
31486 } |
|
31487 else |
|
31488 { |
|
31489 lHeight = srcImage->height - srcYOffset; |
|
31490 } |
|
31491 |
|
31492 if (lWidth > (wndWidth - dstXOffset)) |
|
31493 { |
|
31494 lWidth = wndWidth - dstXOffset; |
|
31495 } |
|
31496 |
|
31497 if (lHeight > (wndHeight - dstYOffset)) |
|
31498 { |
|
31499 lHeight = wndHeight - dstYOffset; |
|
31500 } |
|
31501 |
|
31502 extraCol = lWidth & 0x01; |
|
31503 extraRow = lHeight & 0x01; |
|
31504 |
|
31505 lTempWidth = lWidth; |
|
31506 lWidth = (lWidth >> 1) << 1; |
|
31507 lHeight = (lHeight >> 1) << 1; |
|
31508 |
|
31509 lLumWidth = (srcImage->width >> 1) << 1; |
|
31510 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
31511 |
|
31512 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
31513 |
|
31514 for(i = 0; i < lHeight; i++) |
|
31515 { |
|
31516 for(j = 0; j < (lWidth - 2); j += 2) |
|
31517 { |
|
31518 lCb1 = lYuyvPtr[0]; |
|
31519 lCr1 = lYuyvPtr[2]; |
|
31520 |
|
31521 lCb2 = lYuyvPtr[4]; |
|
31522 lCr2 = lYuyvPtr[6]; |
|
31523 |
|
31524 lCr2 = (lCr1 + lCr2) >> 1; |
|
31525 lCb2 = (lCb1 + lCb2) >> 1; |
|
31526 |
|
31527 lCr1 -= 128; |
|
31528 lCb1 -= 128; |
|
31529 |
|
31530 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
31531 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
31532 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
31533 |
|
31534 /*First Pixel*/ |
|
31535 lY1 = lYuyvPtr[1]; |
|
31536 lY1 -= 16; |
|
31537 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
31538 |
|
31539 /*B component*/ |
|
31540 lTemp = lY1 + lTemp3; |
|
31541 if (lTemp < 0) |
|
31542 lTemp = 0; |
|
31543 if (lTemp > 255) |
|
31544 lTemp = 255; |
|
31545 lTemp4 = (uint8) lTemp; |
|
31546 |
|
31547 /*G component*/ |
|
31548 lTemp = lY1 - lTemp2; |
|
31549 if (lTemp < 0) |
|
31550 lTemp = 0; |
|
31551 if (lTemp > 255) |
|
31552 lTemp = 255; |
|
31553 lTemp4 |= lTemp << 8; |
|
31554 |
|
31555 /*R component*/ |
|
31556 lTemp = lY1 + lTemp1; |
|
31557 if (lTemp < 0) |
|
31558 lTemp = 0; |
|
31559 if (lTemp > 255) |
|
31560 lTemp = 255; |
|
31561 lTemp4 |= lTemp << 16; |
|
31562 |
|
31563 lRGBFramePtr[0] = (uint32)lTemp4; |
|
31564 |
|
31565 lCr2 -= 128; |
|
31566 lCb2 -= 128; |
|
31567 |
|
31568 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
31569 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
31570 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
31571 |
|
31572 /*Second Pixel*/ |
|
31573 lY1 = lYuyvPtr[3]; |
|
31574 lY1 -= 16; |
|
31575 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
31576 |
|
31577 /*B component*/ |
|
31578 lTemp = lY1 + lTemp3; |
|
31579 if (lTemp < 0) |
|
31580 lTemp = 0; |
|
31581 if (lTemp > 255) |
|
31582 lTemp = 255; |
|
31583 lTemp4 = (uint8) lTemp; |
|
31584 |
|
31585 /*G component*/ |
|
31586 lTemp = lY1 - lTemp2; |
|
31587 if (lTemp < 0) |
|
31588 lTemp = 0; |
|
31589 if (lTemp > 255) |
|
31590 lTemp = 255; |
|
31591 lTemp4 |= lTemp << 8; |
|
31592 |
|
31593 /*R component*/ |
|
31594 lTemp = lY1 + lTemp1; |
|
31595 if (lTemp < 0) |
|
31596 lTemp = 0; |
|
31597 if (lTemp > 255) |
|
31598 lTemp = 255; |
|
31599 lTemp4 |= lTemp << 16; |
|
31600 |
|
31601 lRGBFramePtr[1] = (uint32)lTemp4; |
|
31602 |
|
31603 lYuyvPtr += 4; |
|
31604 lRGBFramePtr += 2; |
|
31605 } |
|
31606 |
|
31607 lCb1 = lYuyvPtr[0]; |
|
31608 lCr1 = lYuyvPtr[2]; |
|
31609 |
|
31610 lCr1 -= 128; |
|
31611 lCb1 -= 128; |
|
31612 |
|
31613 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
31614 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
31615 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
31616 |
|
31617 /*First Pixel*/ |
|
31618 lY1 = lYuyvPtr[1]; |
|
31619 lY1 -= 16; |
|
31620 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
31621 |
|
31622 /*B component*/ |
|
31623 lTemp = lY1 + lTemp3; |
|
31624 if (lTemp < 0) |
|
31625 lTemp = 0; |
|
31626 if (lTemp > 255) |
|
31627 lTemp = 255; |
|
31628 lTemp4 = (uint8) lTemp; |
|
31629 |
|
31630 /*G component*/ |
|
31631 lTemp = lY1 - lTemp2; |
|
31632 if (lTemp < 0) |
|
31633 lTemp = 0; |
|
31634 if (lTemp > 255) |
|
31635 lTemp = 255; |
|
31636 lTemp4 |= lTemp << 8; |
|
31637 |
|
31638 /*R component*/ |
|
31639 lTemp = lY1 + lTemp1; |
|
31640 if (lTemp < 0) |
|
31641 lTemp = 0; |
|
31642 if (lTemp > 255) |
|
31643 lTemp = 255; |
|
31644 lTemp4 |= lTemp << 16; |
|
31645 |
|
31646 lRGBFramePtr[0] = (uint32)lTemp4; |
|
31647 |
|
31648 /*Second Pixel*/ |
|
31649 lY1 = lYuyvPtr[3]; |
|
31650 lY1 -= 16; |
|
31651 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
31652 |
|
31653 /*B component*/ |
|
31654 lTemp = lY1 + lTemp3; |
|
31655 if (lTemp < 0) |
|
31656 lTemp = 0; |
|
31657 if (lTemp > 255) |
|
31658 lTemp = 255; |
|
31659 lTemp4 = (uint8) lTemp; |
|
31660 |
|
31661 /*G component*/ |
|
31662 lTemp = lY1 - lTemp2; |
|
31663 if (lTemp < 0) |
|
31664 lTemp = 0; |
|
31665 if (lTemp > 255) |
|
31666 lTemp = 255; |
|
31667 lTemp4 |= lTemp << 8; |
|
31668 |
|
31669 /*R component*/ |
|
31670 lTemp = lY1 + lTemp1; |
|
31671 if (lTemp < 0) |
|
31672 lTemp = 0; |
|
31673 if (lTemp > 255) |
|
31674 lTemp = 255; |
|
31675 lTemp4 |= lTemp << 16; |
|
31676 |
|
31677 lRGBFramePtr[1] = (uint32)lTemp4; |
|
31678 |
|
31679 lYuyvPtr += 4; |
|
31680 lRGBFramePtr += 2; |
|
31681 |
|
31682 if(extraCol) |
|
31683 { |
|
31684 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
31685 lRGBFramePtr++; |
|
31686 } |
|
31687 |
|
31688 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
31689 lRGBFramePtr += (wndWidth - lTempWidth); |
|
31690 } |
|
31691 |
|
31692 if(extraRow) |
|
31693 { |
|
31694 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
31695 for(j = 0; j < lWidth; j += 2) |
|
31696 { |
|
31697 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
31698 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
31699 } |
|
31700 if(extraCol) |
|
31701 { |
|
31702 *lRGBFramePtr = *lRGBFramePtr1; |
|
31703 } |
|
31704 } |
|
31705 return; |
|
31706 } |
|
31707 |
|
31708 /* |
|
31709 ****************************************************************************** |
|
31710 Name : sEmz_VDec_YUV422BEChr1toColor16MU_601_5_RR |
|
31711 Description : Converts YUV422 BE (UYVY) Chroma1 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
31712 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
31713 uint8 *dstImage : Pointer to rgb data (o/p). |
|
31714 tWndParam *srcWindow : Pointer to structure containing source window |
|
31715 parameters like xOffset,yOffset,cropWidth, |
|
31716 cropHeight. (i/p) |
|
31717 tWndParam *dstWindow : Pointer to structure containing destination window |
|
31718 parameters like xOffset,yOffset,windWidth, |
|
31719 windHeight. (i/p) |
|
31720 Return Value : void |
|
31721 ****************************************************************************** |
|
31722 */ |
|
31723 |
|
31724 void sEmz_VDec_YUV422BEChr1toColor16MU_601_5_RR |
|
31725 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
31726 tWndParam* srcWindow, tWndParam* dstWindow) |
|
31727 { |
|
31728 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
31729 uint8 *lYuyvPtr; |
|
31730 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
31731 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
31732 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
31733 int32 i, j, extraCol, extraRow; |
|
31734 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
31735 cropWidth,cropHeight,wndWidth,wndHeight; |
|
31736 |
|
31737 srcXOffset = srcWindow->xOffset; |
|
31738 srcYOffset = srcWindow->yOffset; |
|
31739 cropWidth = srcWindow->wndWidth; |
|
31740 cropHeight = srcWindow->wndHeight; |
|
31741 |
|
31742 dstXOffset = dstWindow->xOffset; |
|
31743 dstYOffset = dstWindow->yOffset; |
|
31744 wndWidth = dstWindow->wndWidth; |
|
31745 wndHeight = dstWindow->wndHeight; |
|
31746 |
|
31747 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
31748 { |
|
31749 lWidth = cropWidth; |
|
31750 } |
|
31751 else |
|
31752 { |
|
31753 lWidth = srcImage->width - srcXOffset; |
|
31754 } |
|
31755 |
|
31756 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
31757 { |
|
31758 lHeight = cropHeight; |
|
31759 } |
|
31760 else |
|
31761 { |
|
31762 lHeight = srcImage->height - srcYOffset; |
|
31763 } |
|
31764 |
|
31765 if (lWidth > (wndWidth - dstXOffset)) |
|
31766 { |
|
31767 lWidth = wndWidth - dstXOffset; |
|
31768 } |
|
31769 |
|
31770 if (lHeight > (wndHeight - dstYOffset)) |
|
31771 { |
|
31772 lHeight = wndHeight - dstYOffset; |
|
31773 } |
|
31774 |
|
31775 extraCol = lWidth & 0x01; |
|
31776 extraRow = lHeight & 0x01; |
|
31777 |
|
31778 lTempWidth = lWidth; |
|
31779 lWidth = (lWidth >> 1) << 1; |
|
31780 lHeight = (lHeight >> 1) << 1; |
|
31781 |
|
31782 lLumWidth = (srcImage->width >> 1) << 1; |
|
31783 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
31784 |
|
31785 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
31786 |
|
31787 for(i = 0; i < lHeight; i++) |
|
31788 { |
|
31789 for(j = 0; j < (lWidth - 2); j += 2) |
|
31790 { |
|
31791 lCb1 = lYuyvPtr[0]; |
|
31792 lCr1 = lYuyvPtr[2]; |
|
31793 |
|
31794 lCb2 = lYuyvPtr[4]; |
|
31795 lCr2 = lYuyvPtr[6]; |
|
31796 |
|
31797 lCr2 = (lCr1 + lCr2) >> 1; |
|
31798 lCb2 = (lCb1 + lCb2) >> 1; |
|
31799 |
|
31800 lCr1 -= 128; |
|
31801 lCb1 -= 128; |
|
31802 |
|
31803 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
31804 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
31805 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
31806 |
|
31807 /*First Pixel*/ |
|
31808 lY1 = lYuyvPtr[1]; |
|
31809 lY1 -= 16; |
|
31810 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
31811 |
|
31812 /*B component*/ |
|
31813 lTemp = lY1 + lTemp3; |
|
31814 if (lTemp < 0) |
|
31815 lTemp = 0; |
|
31816 if (lTemp > 255) |
|
31817 lTemp = 255; |
|
31818 lTemp4 = (uint8) lTemp; |
|
31819 |
|
31820 /*G component*/ |
|
31821 lTemp = lY1 - lTemp2; |
|
31822 if (lTemp < 0) |
|
31823 lTemp = 0; |
|
31824 if (lTemp > 255) |
|
31825 lTemp = 255; |
|
31826 lTemp4 |= lTemp << 8; |
|
31827 |
|
31828 /*R component*/ |
|
31829 lTemp = lY1 + lTemp1; |
|
31830 if (lTemp < 0) |
|
31831 lTemp = 0; |
|
31832 if (lTemp > 255) |
|
31833 lTemp = 255; |
|
31834 lTemp4 |= lTemp << 16; |
|
31835 |
|
31836 lRGBFramePtr[0] = (uint32)lTemp4; |
|
31837 |
|
31838 lCr2 -= 128; |
|
31839 lCb2 -= 128; |
|
31840 |
|
31841 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
31842 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
31843 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
31844 |
|
31845 /*Second Pixel*/ |
|
31846 lY1 = lYuyvPtr[3]; |
|
31847 lY1 -= 16; |
|
31848 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
31849 |
|
31850 /*B component*/ |
|
31851 lTemp = lY1 + lTemp3; |
|
31852 if (lTemp < 0) |
|
31853 lTemp = 0; |
|
31854 if (lTemp > 255) |
|
31855 lTemp = 255; |
|
31856 lTemp4 = (uint8) lTemp; |
|
31857 |
|
31858 /*G component*/ |
|
31859 lTemp = lY1 - lTemp2; |
|
31860 if (lTemp < 0) |
|
31861 lTemp = 0; |
|
31862 if (lTemp > 255) |
|
31863 lTemp = 255; |
|
31864 lTemp4 |= lTemp << 8; |
|
31865 |
|
31866 /*R component*/ |
|
31867 lTemp = lY1 + lTemp1; |
|
31868 if (lTemp < 0) |
|
31869 lTemp = 0; |
|
31870 if (lTemp > 255) |
|
31871 lTemp = 255; |
|
31872 lTemp4 |= lTemp << 16; |
|
31873 |
|
31874 lRGBFramePtr[1] = (uint32)lTemp4; |
|
31875 |
|
31876 lYuyvPtr += 4; |
|
31877 lRGBFramePtr += 2; |
|
31878 } |
|
31879 |
|
31880 lCb1 = lYuyvPtr[0]; |
|
31881 lCr1 = lYuyvPtr[2]; |
|
31882 |
|
31883 lCr1 -= 128; |
|
31884 lCb1 -= 128; |
|
31885 |
|
31886 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
31887 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
31888 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
31889 |
|
31890 /*First Pixel*/ |
|
31891 lY1 = lYuyvPtr[1]; |
|
31892 lY1 -= 16; |
|
31893 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
31894 |
|
31895 /*B component*/ |
|
31896 lTemp = lY1 + lTemp3; |
|
31897 if (lTemp < 0) |
|
31898 lTemp = 0; |
|
31899 if (lTemp > 255) |
|
31900 lTemp = 255; |
|
31901 lTemp4 = (uint8) lTemp; |
|
31902 |
|
31903 /*G component*/ |
|
31904 lTemp = lY1 - lTemp2; |
|
31905 if (lTemp < 0) |
|
31906 lTemp = 0; |
|
31907 if (lTemp > 255) |
|
31908 lTemp = 255; |
|
31909 lTemp4 |= lTemp << 8; |
|
31910 |
|
31911 /*R component*/ |
|
31912 lTemp = lY1 + lTemp1; |
|
31913 if (lTemp < 0) |
|
31914 lTemp = 0; |
|
31915 if (lTemp > 255) |
|
31916 lTemp = 255; |
|
31917 lTemp4 |= lTemp << 16; |
|
31918 |
|
31919 lRGBFramePtr[0] = (uint32)lTemp4; |
|
31920 |
|
31921 /*Second Pixel*/ |
|
31922 lY1 = lYuyvPtr[3]; |
|
31923 lY1 -= 16; |
|
31924 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
31925 |
|
31926 /*B component*/ |
|
31927 lTemp = lY1 + lTemp3; |
|
31928 if (lTemp < 0) |
|
31929 lTemp = 0; |
|
31930 if (lTemp > 255) |
|
31931 lTemp = 255; |
|
31932 lTemp4 = (uint8) lTemp; |
|
31933 |
|
31934 /*G component*/ |
|
31935 lTemp = lY1 - lTemp2; |
|
31936 if (lTemp < 0) |
|
31937 lTemp = 0; |
|
31938 if (lTemp > 255) |
|
31939 lTemp = 255; |
|
31940 lTemp4 |= lTemp << 8; |
|
31941 |
|
31942 /*R component*/ |
|
31943 lTemp = lY1 + lTemp1; |
|
31944 if (lTemp < 0) |
|
31945 lTemp = 0; |
|
31946 if (lTemp > 255) |
|
31947 lTemp = 255; |
|
31948 lTemp4 |= lTemp << 16; |
|
31949 |
|
31950 lRGBFramePtr[1] = (uint32)lTemp4; |
|
31951 |
|
31952 lYuyvPtr += 4; |
|
31953 lRGBFramePtr += 2; |
|
31954 |
|
31955 if(extraCol) |
|
31956 { |
|
31957 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
31958 lRGBFramePtr++; |
|
31959 } |
|
31960 |
|
31961 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
31962 lRGBFramePtr += (wndWidth - lTempWidth); |
|
31963 } |
|
31964 |
|
31965 if(extraRow) |
|
31966 { |
|
31967 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
31968 for(j = 0; j < lWidth; j += 2) |
|
31969 { |
|
31970 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
31971 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
31972 } |
|
31973 if(extraCol) |
|
31974 { |
|
31975 *lRGBFramePtr = *lRGBFramePtr1; |
|
31976 } |
|
31977 } |
|
31978 return; |
|
31979 } |
|
31980 |
|
31981 /************** End of YUV422BE input *******************/ |
|
31982 |
|
31983 |
|
31984 |
|
31985 |
|
31986 |
|
31987 /************** Start of YUV422LE input ********/ |
|
31988 |
|
31989 /* |
|
31990 ****************************************************************************** |
|
31991 Name : sEmz_VDec_YUV422LEChr1toColor64k_Ordered_709_FR |
|
31992 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to RGB565 Interleaved format. |
|
31993 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
31994 uint8 *dstImage : Pointer to rgb data (o/p). |
|
31995 tWndParam *srcWindow : Pointer to structure containing source window |
|
31996 parameters like xOffset,yOffset,cropWidth, |
|
31997 cropHeight. (i/p) |
|
31998 tWndParam *dstWindow : Pointer to structure containing destination window |
|
31999 parameters like xOffset,yOffset,windWidth, |
|
32000 windHeight. (i/p) |
|
32001 Return Value : void |
|
32002 ****************************************************************************** |
|
32003 */ |
|
32004 |
|
32005 void sEmz_VDec_YUV422LEChr1toColor64k_Ordered_709_FR |
|
32006 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
32007 tWndParam* srcWindow, tWndParam* dstWindow) |
|
32008 { |
|
32009 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
32010 uint8 *lYuyvPtr; |
|
32011 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
32012 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
32013 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
32014 int32 i, j, extraCol, extraRow; |
|
32015 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
32016 cropWidth,cropHeight,wndWidth,wndHeight; |
|
32017 |
|
32018 srcXOffset = srcWindow->xOffset; |
|
32019 srcYOffset = srcWindow->yOffset; |
|
32020 cropWidth = srcWindow->wndWidth; |
|
32021 cropHeight = srcWindow->wndHeight; |
|
32022 |
|
32023 dstXOffset = dstWindow->xOffset; |
|
32024 dstYOffset = dstWindow->yOffset; |
|
32025 wndWidth = dstWindow->wndWidth; |
|
32026 wndHeight = dstWindow->wndHeight; |
|
32027 |
|
32028 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
32029 { |
|
32030 lWidth = cropWidth; |
|
32031 } |
|
32032 else |
|
32033 { |
|
32034 lWidth = srcImage->width - srcXOffset; |
|
32035 } |
|
32036 |
|
32037 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
32038 { |
|
32039 lHeight = cropHeight; |
|
32040 } |
|
32041 else |
|
32042 { |
|
32043 lHeight = srcImage->height - srcYOffset; |
|
32044 } |
|
32045 |
|
32046 if (lWidth > (wndWidth - dstXOffset)) |
|
32047 { |
|
32048 lWidth = wndWidth - dstXOffset; |
|
32049 } |
|
32050 |
|
32051 if (lHeight > (wndHeight - dstYOffset)) |
|
32052 { |
|
32053 lHeight = wndHeight - dstYOffset; |
|
32054 } |
|
32055 |
|
32056 extraCol = lWidth & 0x01; |
|
32057 extraRow = lHeight & 0x01; |
|
32058 |
|
32059 lTempWidth = lWidth; |
|
32060 lWidth = (lWidth >> 1) << 1; |
|
32061 lHeight = (lHeight >> 1) << 1; |
|
32062 |
|
32063 lLumWidth = (srcImage->width >> 1) << 1; |
|
32064 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
32065 |
|
32066 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
32067 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
32068 |
|
32069 lLumWidth <<= 1; |
|
32070 |
|
32071 for(i = 0; i < lHeight; i += 2) |
|
32072 { |
|
32073 for(j = 0; j < (lWidth - 2); j += 2) |
|
32074 { |
|
32075 lCb1 = lYuyvPtr[3]; |
|
32076 lCr1 = lYuyvPtr[1]; |
|
32077 |
|
32078 lCb2 = lYuyvPtr[7]; |
|
32079 lCr2 = lYuyvPtr[5]; |
|
32080 |
|
32081 lCr2 = (lCr1 + lCr2) >> 1; |
|
32082 lCb2 = (lCb1 + lCb2) >> 1; |
|
32083 |
|
32084 /*First Pixel*/ |
|
32085 lCr1 -= 128; |
|
32086 lCb1 -= 128; |
|
32087 |
|
32088 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
32089 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
32090 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
32091 |
|
32092 lY1 = lYuyvPtr[2]; |
|
32093 |
|
32094 /*B component*/ |
|
32095 lTemp = lY1 + lTemp3; |
|
32096 if (lTemp < 0) |
|
32097 lTemp = 0; |
|
32098 if (lTemp > 255) |
|
32099 lTemp = 255; |
|
32100 lTemp4 = (lTemp >> 3); |
|
32101 |
|
32102 /*G component*/ |
|
32103 lTemp = lY1 - lTemp2 + 3; |
|
32104 if (lTemp < 0) |
|
32105 lTemp = 0; |
|
32106 if (lTemp > 255) |
|
32107 lTemp = 255; |
|
32108 lTemp4 |= (lTemp >> 2) << 5; |
|
32109 |
|
32110 /*R component*/ |
|
32111 lTemp = lY1 + lTemp1 + 2; |
|
32112 if (lTemp < 0) |
|
32113 lTemp = 0; |
|
32114 if (lTemp > 255) |
|
32115 lTemp = 255; |
|
32116 lTemp4 |= (lTemp >> 3) << 11; |
|
32117 |
|
32118 lRGBFramePtr[0] = (uint16)lTemp4; |
|
32119 |
|
32120 /*Second Pixel*/ |
|
32121 lCr2 -= 128; |
|
32122 lCb2 -= 128; |
|
32123 |
|
32124 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
32125 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
32126 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
32127 |
|
32128 lY1 = lYuyvPtr[0]; |
|
32129 |
|
32130 /*B component*/ |
|
32131 lTemp = lY1 + lTemp3 + 4; |
|
32132 if (lTemp < 0) |
|
32133 lTemp = 0; |
|
32134 if (lTemp > 255) |
|
32135 lTemp = 255; |
|
32136 lTemp4 = (lTemp >> 3); |
|
32137 |
|
32138 /*G component*/ |
|
32139 lTemp = lY1 - lTemp2; |
|
32140 if (lTemp < 0) |
|
32141 lTemp = 0; |
|
32142 if (lTemp > 255) |
|
32143 lTemp = 255; |
|
32144 lTemp4 |= (lTemp >> 2) << 5; |
|
32145 |
|
32146 /*R component*/ |
|
32147 lTemp = lY1 + lTemp1 + 6; |
|
32148 if (lTemp < 0) |
|
32149 lTemp = 0; |
|
32150 if (lTemp > 255) |
|
32151 lTemp = 255; |
|
32152 lTemp4 |= (lTemp >> 3) << 11; |
|
32153 |
|
32154 lRGBFramePtr[1] = (uint16)lTemp4; |
|
32155 |
|
32156 |
|
32157 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
32158 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
32159 |
|
32160 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
32161 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
32162 |
|
32163 lCr2 = (lCr1 + lCr2) >> 1; |
|
32164 lCb2 = (lCb1 + lCb2) >> 1; |
|
32165 |
|
32166 /*Third Pixel*/ |
|
32167 lCr1 -= 128; |
|
32168 lCb1 -= 128; |
|
32169 |
|
32170 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
32171 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
32172 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
32173 |
|
32174 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
32175 |
|
32176 /*B component*/ |
|
32177 lTemp = lY1 + lTemp3 + 6; |
|
32178 if (lTemp < 0) |
|
32179 lTemp = 0; |
|
32180 if (lTemp > 255) |
|
32181 lTemp = 255; |
|
32182 lTemp4 = (lTemp >> 3); |
|
32183 |
|
32184 /*G component*/ |
|
32185 lTemp = lY1 - lTemp2 + 1; |
|
32186 if (lTemp < 0) |
|
32187 lTemp = 0; |
|
32188 if (lTemp > 255) |
|
32189 lTemp = 255; |
|
32190 lTemp4 |= (lTemp >> 2) << 5; |
|
32191 |
|
32192 /*R component*/ |
|
32193 lTemp = lY1 + lTemp1 + 4; |
|
32194 if (lTemp < 0) |
|
32195 lTemp = 0; |
|
32196 if (lTemp > 255) |
|
32197 lTemp = 255; |
|
32198 lTemp4 |= (lTemp >> 3) << 11; |
|
32199 |
|
32200 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
32201 |
|
32202 /*Fourth Pixel*/ |
|
32203 lCr2 -= 128; |
|
32204 lCb2 -= 128; |
|
32205 |
|
32206 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
32207 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
32208 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
32209 |
|
32210 lY1 = lYuyvPtr[lLumWidth]; |
|
32211 |
|
32212 /*B component*/ |
|
32213 lTemp = lY1 + lTemp3 + 2; |
|
32214 if (lTemp < 0) |
|
32215 lTemp = 0; |
|
32216 if (lTemp > 255) |
|
32217 lTemp = 255; |
|
32218 lTemp4 = (lTemp >> 3); |
|
32219 |
|
32220 /*G component*/ |
|
32221 lTemp = lY1 - lTemp2 + 2; |
|
32222 if (lTemp < 0) |
|
32223 lTemp = 0; |
|
32224 if (lTemp > 255) |
|
32225 lTemp = 255; |
|
32226 lTemp4 |= (lTemp >> 2) << 5; |
|
32227 |
|
32228 /*R component*/ |
|
32229 lTemp = lY1 + lTemp1; |
|
32230 if (lTemp < 0) |
|
32231 lTemp = 0; |
|
32232 if (lTemp > 255) |
|
32233 lTemp = 255; |
|
32234 lTemp4 |= (lTemp >> 3) << 11; |
|
32235 |
|
32236 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
32237 |
|
32238 lYuyvPtr += 4; |
|
32239 lRGBFramePtr += 2; |
|
32240 lRGBFramePtr1 += 2; |
|
32241 } |
|
32242 |
|
32243 |
|
32244 lCb1 = lYuyvPtr[3]; |
|
32245 lCr1 = lYuyvPtr[1]; |
|
32246 |
|
32247 lCr1 -= 128; |
|
32248 lCb1 -= 128; |
|
32249 |
|
32250 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
32251 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
32252 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
32253 |
|
32254 /*First Pixel*/ |
|
32255 lY1 = lYuyvPtr[2]; |
|
32256 |
|
32257 /*B component*/ |
|
32258 lTemp = lY1 + lTemp3; |
|
32259 if (lTemp < 0) |
|
32260 lTemp = 0; |
|
32261 if (lTemp > 255) |
|
32262 lTemp = 255; |
|
32263 lTemp4 = (lTemp >> 3); |
|
32264 |
|
32265 /*G component*/ |
|
32266 lTemp = lY1 - lTemp2 + 3; |
|
32267 if (lTemp < 0) |
|
32268 lTemp = 0; |
|
32269 if (lTemp > 255) |
|
32270 lTemp = 255; |
|
32271 lTemp4 |= (lTemp >> 2) << 5; |
|
32272 |
|
32273 /*R component*/ |
|
32274 lTemp = lY1 + lTemp1 + 2; |
|
32275 if (lTemp < 0) |
|
32276 lTemp = 0; |
|
32277 if (lTemp > 255) |
|
32278 lTemp = 255; |
|
32279 lTemp4 |= (lTemp >> 3) << 11; |
|
32280 |
|
32281 lRGBFramePtr[0] = (uint16)lTemp4; |
|
32282 |
|
32283 /*Second Pixel*/ |
|
32284 lY1 = lYuyvPtr[0]; |
|
32285 |
|
32286 /*B component*/ |
|
32287 lTemp = lY1 + lTemp3 + 4; |
|
32288 if (lTemp < 0) |
|
32289 lTemp = 0; |
|
32290 if (lTemp > 255) |
|
32291 lTemp = 255; |
|
32292 lTemp4 = (lTemp >> 3); |
|
32293 |
|
32294 /*G component*/ |
|
32295 lTemp = lY1 - lTemp2; |
|
32296 if (lTemp < 0) |
|
32297 lTemp = 0; |
|
32298 if (lTemp > 255) |
|
32299 lTemp = 255; |
|
32300 lTemp4 |= (lTemp >> 2) << 5; |
|
32301 |
|
32302 /*R component*/ |
|
32303 lTemp = lY1 + lTemp1 + 6; |
|
32304 if (lTemp < 0) |
|
32305 lTemp = 0; |
|
32306 if (lTemp > 255) |
|
32307 lTemp = 255; |
|
32308 lTemp4 |= (lTemp >> 3) << 11; |
|
32309 |
|
32310 lRGBFramePtr[1] = (uint16)lTemp4; |
|
32311 |
|
32312 |
|
32313 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
32314 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
32315 |
|
32316 lCr1 -= 128; |
|
32317 lCb1 -= 128; |
|
32318 |
|
32319 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
32320 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
32321 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
32322 |
|
32323 /*Third Pixel*/ |
|
32324 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
32325 |
|
32326 /*B component*/ |
|
32327 lTemp = lY1 + lTemp3 + 6; |
|
32328 if (lTemp < 0) |
|
32329 lTemp = 0; |
|
32330 if (lTemp > 255) |
|
32331 lTemp = 255; |
|
32332 lTemp4 = (lTemp >> 3); |
|
32333 |
|
32334 /*G component*/ |
|
32335 lTemp = lY1 - lTemp2 + 1; |
|
32336 if (lTemp < 0) |
|
32337 lTemp = 0; |
|
32338 if (lTemp > 255) |
|
32339 lTemp = 255; |
|
32340 lTemp4 |= (lTemp >> 2) << 5; |
|
32341 |
|
32342 /*R component*/ |
|
32343 lTemp = lY1 + lTemp1 + 4; |
|
32344 if (lTemp < 0) |
|
32345 lTemp = 0; |
|
32346 if (lTemp > 255) |
|
32347 lTemp = 255; |
|
32348 lTemp4 |= (lTemp >> 3) << 11; |
|
32349 |
|
32350 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
32351 |
|
32352 /*Fourth Pixel*/ |
|
32353 lY1 = lYuyvPtr[lLumWidth]; |
|
32354 |
|
32355 /*B component*/ |
|
32356 lTemp = lY1 + lTemp3 + 2; |
|
32357 if (lTemp < 0) |
|
32358 lTemp = 0; |
|
32359 if (lTemp > 255) |
|
32360 lTemp = 255; |
|
32361 lTemp4 = (lTemp >> 3); |
|
32362 |
|
32363 /*G component*/ |
|
32364 lTemp = lY1 - lTemp2 + 2; |
|
32365 if (lTemp < 0) |
|
32366 lTemp = 0; |
|
32367 if (lTemp > 255) |
|
32368 lTemp = 255; |
|
32369 lTemp4 |= (lTemp >> 2) << 5; |
|
32370 |
|
32371 /*R component*/ |
|
32372 lTemp = lY1 + lTemp1; |
|
32373 if (lTemp < 0) |
|
32374 lTemp = 0; |
|
32375 if (lTemp > 255) |
|
32376 lTemp = 255; |
|
32377 lTemp4 |= (lTemp >> 3) << 11; |
|
32378 |
|
32379 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
32380 |
|
32381 lYuyvPtr += 4; |
|
32382 lRGBFramePtr += 2; |
|
32383 lRGBFramePtr1 += 2; |
|
32384 |
|
32385 |
|
32386 if(extraCol) |
|
32387 { |
|
32388 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
32389 lRGBFramePtr++; |
|
32390 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
32391 lRGBFramePtr1++; |
|
32392 } |
|
32393 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
32394 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
32395 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
32396 } |
|
32397 |
|
32398 if(extraRow) |
|
32399 { |
|
32400 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
32401 for(j = 0; j < lWidth; j += 2) |
|
32402 { |
|
32403 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
32404 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
32405 } |
|
32406 if(extraCol) |
|
32407 { |
|
32408 *lRGBFramePtr = *lRGBFramePtr1; |
|
32409 } |
|
32410 } |
|
32411 return; |
|
32412 } |
|
32413 |
|
32414 /* |
|
32415 ****************************************************************************** |
|
32416 Name : sEmz_VDec_YUV422LEChr1toColor64k_Ordered_601_5_FR |
|
32417 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to RGB565 Interleaved format. |
|
32418 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
32419 uint8 *dstImage : Pointer to rgb data (o/p). |
|
32420 tWndParam *srcWindow : Pointer to structure containing source window |
|
32421 parameters like xOffset,yOffset,cropWidth, |
|
32422 cropHeight. (i/p) |
|
32423 tWndParam *dstWindow : Pointer to structure containing destination window |
|
32424 parameters like xOffset,yOffset,windWidth, |
|
32425 windHeight. (i/p) |
|
32426 Return Value : void |
|
32427 ****************************************************************************** |
|
32428 */ |
|
32429 |
|
32430 void sEmz_VDec_YUV422LEChr1toColor64k_Ordered_601_5_FR |
|
32431 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
32432 tWndParam* srcWindow, tWndParam* dstWindow) |
|
32433 { |
|
32434 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
32435 uint8 *lYuyvPtr; |
|
32436 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
32437 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
32438 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
32439 int32 i, j, extraCol, extraRow; |
|
32440 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
32441 cropWidth,cropHeight,wndWidth,wndHeight; |
|
32442 |
|
32443 srcXOffset = srcWindow->xOffset; |
|
32444 srcYOffset = srcWindow->yOffset; |
|
32445 cropWidth = srcWindow->wndWidth; |
|
32446 cropHeight = srcWindow->wndHeight; |
|
32447 |
|
32448 dstXOffset = dstWindow->xOffset; |
|
32449 dstYOffset = dstWindow->yOffset; |
|
32450 wndWidth = dstWindow->wndWidth; |
|
32451 wndHeight = dstWindow->wndHeight; |
|
32452 |
|
32453 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
32454 { |
|
32455 lWidth = cropWidth; |
|
32456 } |
|
32457 else |
|
32458 { |
|
32459 lWidth = srcImage->width - srcXOffset; |
|
32460 } |
|
32461 |
|
32462 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
32463 { |
|
32464 lHeight = cropHeight; |
|
32465 } |
|
32466 else |
|
32467 { |
|
32468 lHeight = srcImage->height - srcYOffset; |
|
32469 } |
|
32470 |
|
32471 if (lWidth > (wndWidth - dstXOffset)) |
|
32472 { |
|
32473 lWidth = wndWidth - dstXOffset; |
|
32474 } |
|
32475 |
|
32476 if (lHeight > (wndHeight - dstYOffset)) |
|
32477 { |
|
32478 lHeight = wndHeight - dstYOffset; |
|
32479 } |
|
32480 |
|
32481 extraCol = lWidth & 0x01; |
|
32482 extraRow = lHeight & 0x01; |
|
32483 |
|
32484 lTempWidth = lWidth; |
|
32485 lWidth = (lWidth >> 1) << 1; |
|
32486 lHeight = (lHeight >> 1) << 1; |
|
32487 |
|
32488 lLumWidth = (srcImage->width >> 1) << 1; |
|
32489 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
32490 |
|
32491 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
32492 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
32493 |
|
32494 lLumWidth <<= 1; |
|
32495 |
|
32496 for(i = 0; i < lHeight; i += 2) |
|
32497 { |
|
32498 for(j = 0; j < (lWidth - 2); j += 2) |
|
32499 { |
|
32500 lCb1 = lYuyvPtr[3]; |
|
32501 lCr1 = lYuyvPtr[1]; |
|
32502 |
|
32503 lCb2 = lYuyvPtr[7]; |
|
32504 lCr2 = lYuyvPtr[5]; |
|
32505 |
|
32506 lCr2 = (lCr1 + lCr2) >> 1; |
|
32507 lCb2 = (lCb1 + lCb2) >> 1; |
|
32508 |
|
32509 /*First Pixel*/ |
|
32510 lCr1 -= 128; |
|
32511 lCb1 -= 128; |
|
32512 |
|
32513 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
32514 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
32515 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
32516 |
|
32517 lY1 = lYuyvPtr[2]; |
|
32518 |
|
32519 /*B component*/ |
|
32520 lTemp = lY1 + lTemp3; |
|
32521 if (lTemp < 0) |
|
32522 lTemp = 0; |
|
32523 if (lTemp > 255) |
|
32524 lTemp = 255; |
|
32525 lTemp4 = (lTemp >> 3); |
|
32526 |
|
32527 /*G component*/ |
|
32528 lTemp = lY1 - lTemp2 + 3; |
|
32529 if (lTemp < 0) |
|
32530 lTemp = 0; |
|
32531 if (lTemp > 255) |
|
32532 lTemp = 255; |
|
32533 lTemp4 |= (lTemp >> 2) << 5; |
|
32534 |
|
32535 /*R component*/ |
|
32536 lTemp = lY1 + lTemp1 + 2; |
|
32537 if (lTemp < 0) |
|
32538 lTemp = 0; |
|
32539 if (lTemp > 255) |
|
32540 lTemp = 255; |
|
32541 lTemp4 |= (lTemp >> 3) << 11; |
|
32542 |
|
32543 lRGBFramePtr[0] = (uint16)lTemp4; |
|
32544 |
|
32545 /*Second Pixel*/ |
|
32546 lCr2 -= 128; |
|
32547 lCb2 -= 128; |
|
32548 |
|
32549 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
32550 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
32551 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
32552 |
|
32553 lY1 = lYuyvPtr[0]; |
|
32554 |
|
32555 /*B component*/ |
|
32556 lTemp = lY1 + lTemp3 + 4; |
|
32557 if (lTemp < 0) |
|
32558 lTemp = 0; |
|
32559 if (lTemp > 255) |
|
32560 lTemp = 255; |
|
32561 lTemp4 = (lTemp >> 3); |
|
32562 |
|
32563 /*G component*/ |
|
32564 lTemp = lY1 - lTemp2; |
|
32565 if (lTemp < 0) |
|
32566 lTemp = 0; |
|
32567 if (lTemp > 255) |
|
32568 lTemp = 255; |
|
32569 lTemp4 |= (lTemp >> 2) << 5; |
|
32570 |
|
32571 /*R component*/ |
|
32572 lTemp = lY1 + lTemp1 + 6; |
|
32573 if (lTemp < 0) |
|
32574 lTemp = 0; |
|
32575 if (lTemp > 255) |
|
32576 lTemp = 255; |
|
32577 lTemp4 |= (lTemp >> 3) << 11; |
|
32578 |
|
32579 lRGBFramePtr[1] = (uint16)lTemp4; |
|
32580 |
|
32581 |
|
32582 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
32583 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
32584 |
|
32585 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
32586 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
32587 |
|
32588 lCr2 = (lCr1 + lCr2) >> 1; |
|
32589 lCb2 = (lCb1 + lCb2) >> 1; |
|
32590 |
|
32591 /*Third Pixel*/ |
|
32592 lCr1 -= 128; |
|
32593 lCb1 -= 128; |
|
32594 |
|
32595 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
32596 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
32597 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
32598 |
|
32599 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
32600 |
|
32601 /*B component*/ |
|
32602 lTemp = lY1 + lTemp3 + 6; |
|
32603 if (lTemp < 0) |
|
32604 lTemp = 0; |
|
32605 if (lTemp > 255) |
|
32606 lTemp = 255; |
|
32607 lTemp4 = (lTemp >> 3); |
|
32608 |
|
32609 /*G component*/ |
|
32610 lTemp = lY1 - lTemp2 + 1; |
|
32611 if (lTemp < 0) |
|
32612 lTemp = 0; |
|
32613 if (lTemp > 255) |
|
32614 lTemp = 255; |
|
32615 lTemp4 |= (lTemp >> 2) << 5; |
|
32616 |
|
32617 /*R component*/ |
|
32618 lTemp = lY1 + lTemp1 + 4; |
|
32619 if (lTemp < 0) |
|
32620 lTemp = 0; |
|
32621 if (lTemp > 255) |
|
32622 lTemp = 255; |
|
32623 lTemp4 |= (lTemp >> 3) << 11; |
|
32624 |
|
32625 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
32626 |
|
32627 /*Fourth Pixel*/ |
|
32628 lCr2 -= 128; |
|
32629 lCb2 -= 128; |
|
32630 |
|
32631 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
32632 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
32633 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
32634 |
|
32635 lY1 = lYuyvPtr[lLumWidth]; |
|
32636 |
|
32637 /*B component*/ |
|
32638 lTemp = lY1 + lTemp3 + 2; |
|
32639 if (lTemp < 0) |
|
32640 lTemp = 0; |
|
32641 if (lTemp > 255) |
|
32642 lTemp = 255; |
|
32643 lTemp4 = (lTemp >> 3); |
|
32644 |
|
32645 /*G component*/ |
|
32646 lTemp = lY1 - lTemp2 + 2; |
|
32647 if (lTemp < 0) |
|
32648 lTemp = 0; |
|
32649 if (lTemp > 255) |
|
32650 lTemp = 255; |
|
32651 lTemp4 |= (lTemp >> 2) << 5; |
|
32652 |
|
32653 /*R component*/ |
|
32654 lTemp = lY1 + lTemp1; |
|
32655 if (lTemp < 0) |
|
32656 lTemp = 0; |
|
32657 if (lTemp > 255) |
|
32658 lTemp = 255; |
|
32659 lTemp4 |= (lTemp >> 3) << 11; |
|
32660 |
|
32661 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
32662 |
|
32663 lYuyvPtr += 4; |
|
32664 lRGBFramePtr += 2; |
|
32665 lRGBFramePtr1 += 2; |
|
32666 } |
|
32667 |
|
32668 |
|
32669 lCb1 = lYuyvPtr[3]; |
|
32670 lCr1 = lYuyvPtr[1]; |
|
32671 |
|
32672 lCr1 -= 128; |
|
32673 lCb1 -= 128; |
|
32674 |
|
32675 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
32676 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
32677 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
32678 |
|
32679 /*First Pixel*/ |
|
32680 lY1 = lYuyvPtr[2]; |
|
32681 |
|
32682 /*B component*/ |
|
32683 lTemp = lY1 + lTemp3; |
|
32684 if (lTemp < 0) |
|
32685 lTemp = 0; |
|
32686 if (lTemp > 255) |
|
32687 lTemp = 255; |
|
32688 lTemp4 = (lTemp >> 3); |
|
32689 |
|
32690 /*G component*/ |
|
32691 lTemp = lY1 - lTemp2 + 3; |
|
32692 if (lTemp < 0) |
|
32693 lTemp = 0; |
|
32694 if (lTemp > 255) |
|
32695 lTemp = 255; |
|
32696 lTemp4 |= (lTemp >> 2) << 5; |
|
32697 |
|
32698 /*R component*/ |
|
32699 lTemp = lY1 + lTemp1 + 2; |
|
32700 if (lTemp < 0) |
|
32701 lTemp = 0; |
|
32702 if (lTemp > 255) |
|
32703 lTemp = 255; |
|
32704 lTemp4 |= (lTemp >> 3) << 11; |
|
32705 |
|
32706 lRGBFramePtr[0] = (uint16)lTemp4; |
|
32707 |
|
32708 /*Second Pixel*/ |
|
32709 lY1 = lYuyvPtr[0]; |
|
32710 |
|
32711 /*B component*/ |
|
32712 lTemp = lY1 + lTemp3 + 4; |
|
32713 if (lTemp < 0) |
|
32714 lTemp = 0; |
|
32715 if (lTemp > 255) |
|
32716 lTemp = 255; |
|
32717 lTemp4 = (lTemp >> 3); |
|
32718 |
|
32719 /*G component*/ |
|
32720 lTemp = lY1 - lTemp2; |
|
32721 if (lTemp < 0) |
|
32722 lTemp = 0; |
|
32723 if (lTemp > 255) |
|
32724 lTemp = 255; |
|
32725 lTemp4 |= (lTemp >> 2) << 5; |
|
32726 |
|
32727 /*R component*/ |
|
32728 lTemp = lY1 + lTemp1 + 6; |
|
32729 if (lTemp < 0) |
|
32730 lTemp = 0; |
|
32731 if (lTemp > 255) |
|
32732 lTemp = 255; |
|
32733 lTemp4 |= (lTemp >> 3) << 11; |
|
32734 |
|
32735 lRGBFramePtr[1] = (uint16)lTemp4; |
|
32736 |
|
32737 |
|
32738 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
32739 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
32740 |
|
32741 lCr1 -= 128; |
|
32742 lCb1 -= 128; |
|
32743 |
|
32744 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
32745 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
32746 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
32747 |
|
32748 /*Third Pixel*/ |
|
32749 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
32750 |
|
32751 /*B component*/ |
|
32752 lTemp = lY1 + lTemp3 + 6; |
|
32753 if (lTemp < 0) |
|
32754 lTemp = 0; |
|
32755 if (lTemp > 255) |
|
32756 lTemp = 255; |
|
32757 lTemp4 = (lTemp >> 3); |
|
32758 |
|
32759 /*G component*/ |
|
32760 lTemp = lY1 - lTemp2 + 1; |
|
32761 if (lTemp < 0) |
|
32762 lTemp = 0; |
|
32763 if (lTemp > 255) |
|
32764 lTemp = 255; |
|
32765 lTemp4 |= (lTemp >> 2) << 5; |
|
32766 |
|
32767 /*R component*/ |
|
32768 lTemp = lY1 + lTemp1 + 4; |
|
32769 if (lTemp < 0) |
|
32770 lTemp = 0; |
|
32771 if (lTemp > 255) |
|
32772 lTemp = 255; |
|
32773 lTemp4 |= (lTemp >> 3) << 11; |
|
32774 |
|
32775 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
32776 |
|
32777 /*Fourth Pixel*/ |
|
32778 lY1 = lYuyvPtr[lLumWidth]; |
|
32779 |
|
32780 /*B component*/ |
|
32781 lTemp = lY1 + lTemp3 + 2; |
|
32782 if (lTemp < 0) |
|
32783 lTemp = 0; |
|
32784 if (lTemp > 255) |
|
32785 lTemp = 255; |
|
32786 lTemp4 = (lTemp >> 3); |
|
32787 |
|
32788 /*G component*/ |
|
32789 lTemp = lY1 - lTemp2 + 2; |
|
32790 if (lTemp < 0) |
|
32791 lTemp = 0; |
|
32792 if (lTemp > 255) |
|
32793 lTemp = 255; |
|
32794 lTemp4 |= (lTemp >> 2) << 5; |
|
32795 |
|
32796 /*R component*/ |
|
32797 lTemp = lY1 + lTemp1; |
|
32798 if (lTemp < 0) |
|
32799 lTemp = 0; |
|
32800 if (lTemp > 255) |
|
32801 lTemp = 255; |
|
32802 lTemp4 |= (lTemp >> 3) << 11; |
|
32803 |
|
32804 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
32805 |
|
32806 lYuyvPtr += 4; |
|
32807 lRGBFramePtr += 2; |
|
32808 lRGBFramePtr1 += 2; |
|
32809 |
|
32810 |
|
32811 if(extraCol) |
|
32812 { |
|
32813 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
32814 lRGBFramePtr++; |
|
32815 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
32816 lRGBFramePtr1++; |
|
32817 } |
|
32818 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
32819 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
32820 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
32821 } |
|
32822 |
|
32823 if(extraRow) |
|
32824 { |
|
32825 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
32826 for(j = 0; j < lWidth; j += 2) |
|
32827 { |
|
32828 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
32829 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
32830 } |
|
32831 if(extraCol) |
|
32832 { |
|
32833 *lRGBFramePtr = *lRGBFramePtr1; |
|
32834 } |
|
32835 } |
|
32836 return; |
|
32837 } |
|
32838 |
|
32839 /* |
|
32840 ****************************************************************************** |
|
32841 Name : sEmz_VDec_YUV422LEChr1toColor64k_Ordered_709_RR |
|
32842 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to RGB565 Interleaved format. |
|
32843 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
32844 uint8 *dstImage : Pointer to rgb data (o/p). |
|
32845 tWndParam *srcWindow : Pointer to structure containing source window |
|
32846 parameters like xOffset,yOffset,cropWidth, |
|
32847 cropHeight. (i/p) |
|
32848 tWndParam *dstWindow : Pointer to structure containing destination window |
|
32849 parameters like xOffset,yOffset,windWidth, |
|
32850 windHeight. (i/p) |
|
32851 Return Value : void |
|
32852 ****************************************************************************** |
|
32853 */ |
|
32854 |
|
32855 void sEmz_VDec_YUV422LEChr1toColor64k_Ordered_709_RR |
|
32856 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
32857 tWndParam* srcWindow, tWndParam* dstWindow) |
|
32858 { |
|
32859 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
32860 uint8 *lYuyvPtr; |
|
32861 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
32862 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
32863 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
32864 int32 i, j, extraCol, extraRow; |
|
32865 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
32866 cropWidth,cropHeight,wndWidth,wndHeight; |
|
32867 |
|
32868 srcXOffset = srcWindow->xOffset; |
|
32869 srcYOffset = srcWindow->yOffset; |
|
32870 cropWidth = srcWindow->wndWidth; |
|
32871 cropHeight = srcWindow->wndHeight; |
|
32872 |
|
32873 dstXOffset = dstWindow->xOffset; |
|
32874 dstYOffset = dstWindow->yOffset; |
|
32875 wndWidth = dstWindow->wndWidth; |
|
32876 wndHeight = dstWindow->wndHeight; |
|
32877 |
|
32878 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
32879 { |
|
32880 lWidth = cropWidth; |
|
32881 } |
|
32882 else |
|
32883 { |
|
32884 lWidth = srcImage->width - srcXOffset; |
|
32885 } |
|
32886 |
|
32887 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
32888 { |
|
32889 lHeight = cropHeight; |
|
32890 } |
|
32891 else |
|
32892 { |
|
32893 lHeight = srcImage->height - srcYOffset; |
|
32894 } |
|
32895 |
|
32896 if (lWidth > (wndWidth - dstXOffset)) |
|
32897 { |
|
32898 lWidth = wndWidth - dstXOffset; |
|
32899 } |
|
32900 |
|
32901 if (lHeight > (wndHeight - dstYOffset)) |
|
32902 { |
|
32903 lHeight = wndHeight - dstYOffset; |
|
32904 } |
|
32905 |
|
32906 extraCol = lWidth & 0x01; |
|
32907 extraRow = lHeight & 0x01; |
|
32908 |
|
32909 lTempWidth = lWidth; |
|
32910 lWidth = (lWidth >> 1) << 1; |
|
32911 lHeight = (lHeight >> 1) << 1; |
|
32912 |
|
32913 lLumWidth = (srcImage->width >> 1) << 1; |
|
32914 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
32915 |
|
32916 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
32917 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
32918 |
|
32919 lLumWidth <<= 1; |
|
32920 |
|
32921 for(i = 0; i < lHeight; i += 2) |
|
32922 { |
|
32923 for(j = 0; j < (lWidth - 2); j += 2) |
|
32924 { |
|
32925 lCb1 = lYuyvPtr[3]; |
|
32926 lCr1 = lYuyvPtr[1]; |
|
32927 |
|
32928 lCb2 = lYuyvPtr[7]; |
|
32929 lCr2 = lYuyvPtr[5]; |
|
32930 |
|
32931 lCr2 = (lCr1 + lCr2) >> 1; |
|
32932 lCb2 = (lCb1 + lCb2) >> 1; |
|
32933 |
|
32934 /*First Pixel*/ |
|
32935 lCr1 -= 128; |
|
32936 lCb1 -= 128; |
|
32937 |
|
32938 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
32939 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
32940 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
32941 |
|
32942 lY1 = lYuyvPtr[2]; |
|
32943 lY1 -= 16; |
|
32944 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
32945 |
|
32946 /*B component*/ |
|
32947 lTemp = lY1 + lTemp3; |
|
32948 if (lTemp < 0) |
|
32949 lTemp = 0; |
|
32950 if (lTemp > 255) |
|
32951 lTemp = 255; |
|
32952 lTemp4 = (lTemp >> 3); |
|
32953 |
|
32954 /*G component*/ |
|
32955 lTemp = lY1 - lTemp2 + 3; |
|
32956 if (lTemp < 0) |
|
32957 lTemp = 0; |
|
32958 if (lTemp > 255) |
|
32959 lTemp = 255; |
|
32960 lTemp4 |= (lTemp >> 2) << 5; |
|
32961 |
|
32962 /*R component*/ |
|
32963 lTemp = lY1 + lTemp1 + 2; |
|
32964 if (lTemp < 0) |
|
32965 lTemp = 0; |
|
32966 if (lTemp > 255) |
|
32967 lTemp = 255; |
|
32968 lTemp4 |= (lTemp >> 3) << 11; |
|
32969 |
|
32970 lRGBFramePtr[0] = (uint16)lTemp4; |
|
32971 |
|
32972 /*Second Pixel*/ |
|
32973 lCr2 -= 128; |
|
32974 lCb2 -= 128; |
|
32975 |
|
32976 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
32977 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
32978 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
32979 |
|
32980 lY1 = lYuyvPtr[0]; |
|
32981 lY1 -= 16; |
|
32982 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
32983 |
|
32984 /*B component*/ |
|
32985 lTemp = lY1 + lTemp3 + 4; |
|
32986 if (lTemp < 0) |
|
32987 lTemp = 0; |
|
32988 if (lTemp > 255) |
|
32989 lTemp = 255; |
|
32990 lTemp4 = (lTemp >> 3); |
|
32991 |
|
32992 /*G component*/ |
|
32993 lTemp = lY1 - lTemp2; |
|
32994 if (lTemp < 0) |
|
32995 lTemp = 0; |
|
32996 if (lTemp > 255) |
|
32997 lTemp = 255; |
|
32998 lTemp4 |= (lTemp >> 2) << 5; |
|
32999 |
|
33000 /*R component*/ |
|
33001 lTemp = lY1 + lTemp1 + 6; |
|
33002 if (lTemp < 0) |
|
33003 lTemp = 0; |
|
33004 if (lTemp > 255) |
|
33005 lTemp = 255; |
|
33006 lTemp4 |= (lTemp >> 3) << 11; |
|
33007 |
|
33008 lRGBFramePtr[1] = (uint16)lTemp4; |
|
33009 |
|
33010 |
|
33011 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
33012 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
33013 |
|
33014 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
33015 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
33016 |
|
33017 lCr2 = (lCr1 + lCr2) >> 1; |
|
33018 lCb2 = (lCb1 + lCb2) >> 1; |
|
33019 |
|
33020 /*Third Pixel*/ |
|
33021 lCr1 -= 128; |
|
33022 lCb1 -= 128; |
|
33023 |
|
33024 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
33025 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
33026 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
33027 |
|
33028 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
33029 lY1 -= 16; |
|
33030 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33031 |
|
33032 /*B component*/ |
|
33033 lTemp = lY1 + lTemp3 + 6; |
|
33034 if (lTemp < 0) |
|
33035 lTemp = 0; |
|
33036 if (lTemp > 255) |
|
33037 lTemp = 255; |
|
33038 lTemp4 = (lTemp >> 3); |
|
33039 |
|
33040 /*G component*/ |
|
33041 lTemp = lY1 - lTemp2 + 1; |
|
33042 if (lTemp < 0) |
|
33043 lTemp = 0; |
|
33044 if (lTemp > 255) |
|
33045 lTemp = 255; |
|
33046 lTemp4 |= (lTemp >> 2) << 5; |
|
33047 |
|
33048 /*R component*/ |
|
33049 lTemp = lY1 + lTemp1 + 4; |
|
33050 if (lTemp < 0) |
|
33051 lTemp = 0; |
|
33052 if (lTemp > 255) |
|
33053 lTemp = 255; |
|
33054 lTemp4 |= (lTemp >> 3) << 11; |
|
33055 |
|
33056 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
33057 |
|
33058 /*Fourth Pixel*/ |
|
33059 lCr2 -= 128; |
|
33060 lCb2 -= 128; |
|
33061 |
|
33062 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
33063 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
33064 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
33065 |
|
33066 lY1 = lYuyvPtr[lLumWidth]; |
|
33067 lY1 -= 16; |
|
33068 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33069 |
|
33070 /*B component*/ |
|
33071 lTemp = lY1 + lTemp3 + 2; |
|
33072 if (lTemp < 0) |
|
33073 lTemp = 0; |
|
33074 if (lTemp > 255) |
|
33075 lTemp = 255; |
|
33076 lTemp4 = (lTemp >> 3); |
|
33077 |
|
33078 /*G component*/ |
|
33079 lTemp = lY1 - lTemp2 + 2; |
|
33080 if (lTemp < 0) |
|
33081 lTemp = 0; |
|
33082 if (lTemp > 255) |
|
33083 lTemp = 255; |
|
33084 lTemp4 |= (lTemp >> 2) << 5; |
|
33085 |
|
33086 /*R component*/ |
|
33087 lTemp = lY1 + lTemp1; |
|
33088 if (lTemp < 0) |
|
33089 lTemp = 0; |
|
33090 if (lTemp > 255) |
|
33091 lTemp = 255; |
|
33092 lTemp4 |= (lTemp >> 3) << 11; |
|
33093 |
|
33094 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
33095 |
|
33096 lYuyvPtr += 4; |
|
33097 lRGBFramePtr += 2; |
|
33098 lRGBFramePtr1 += 2; |
|
33099 } |
|
33100 |
|
33101 |
|
33102 lCb1 = lYuyvPtr[3]; |
|
33103 lCr1 = lYuyvPtr[1]; |
|
33104 |
|
33105 lCr1 -= 128; |
|
33106 lCb1 -= 128; |
|
33107 |
|
33108 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
33109 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
33110 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
33111 |
|
33112 /*First Pixel*/ |
|
33113 lY1 = lYuyvPtr[2]; |
|
33114 lY1 -= 16; |
|
33115 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33116 |
|
33117 /*B component*/ |
|
33118 lTemp = lY1 + lTemp3; |
|
33119 if (lTemp < 0) |
|
33120 lTemp = 0; |
|
33121 if (lTemp > 255) |
|
33122 lTemp = 255; |
|
33123 lTemp4 = (lTemp >> 3); |
|
33124 |
|
33125 /*G component*/ |
|
33126 lTemp = lY1 - lTemp2 + 3; |
|
33127 if (lTemp < 0) |
|
33128 lTemp = 0; |
|
33129 if (lTemp > 255) |
|
33130 lTemp = 255; |
|
33131 lTemp4 |= (lTemp >> 2) << 5; |
|
33132 |
|
33133 /*R component*/ |
|
33134 lTemp = lY1 + lTemp1 + 2; |
|
33135 if (lTemp < 0) |
|
33136 lTemp = 0; |
|
33137 if (lTemp > 255) |
|
33138 lTemp = 255; |
|
33139 lTemp4 |= (lTemp >> 3) << 11; |
|
33140 |
|
33141 lRGBFramePtr[0] = (uint16)lTemp4; |
|
33142 |
|
33143 /*Second Pixel*/ |
|
33144 lY1 = lYuyvPtr[0]; |
|
33145 lY1 -= 16; |
|
33146 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33147 |
|
33148 /*B component*/ |
|
33149 lTemp = lY1 + lTemp3 + 4; |
|
33150 if (lTemp < 0) |
|
33151 lTemp = 0; |
|
33152 if (lTemp > 255) |
|
33153 lTemp = 255; |
|
33154 lTemp4 = (lTemp >> 3); |
|
33155 |
|
33156 /*G component*/ |
|
33157 lTemp = lY1 - lTemp2; |
|
33158 if (lTemp < 0) |
|
33159 lTemp = 0; |
|
33160 if (lTemp > 255) |
|
33161 lTemp = 255; |
|
33162 lTemp4 |= (lTemp >> 2) << 5; |
|
33163 |
|
33164 /*R component*/ |
|
33165 lTemp = lY1 + lTemp1 + 6; |
|
33166 if (lTemp < 0) |
|
33167 lTemp = 0; |
|
33168 if (lTemp > 255) |
|
33169 lTemp = 255; |
|
33170 lTemp4 |= (lTemp >> 3) << 11; |
|
33171 |
|
33172 lRGBFramePtr[1] = (uint16)lTemp4; |
|
33173 |
|
33174 |
|
33175 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
33176 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
33177 |
|
33178 lCr1 -= 128; |
|
33179 lCb1 -= 128; |
|
33180 |
|
33181 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
33182 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
33183 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
33184 |
|
33185 /*Third Pixel*/ |
|
33186 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
33187 lY1 -= 16; |
|
33188 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33189 |
|
33190 /*B component*/ |
|
33191 lTemp = lY1 + lTemp3 + 6; |
|
33192 if (lTemp < 0) |
|
33193 lTemp = 0; |
|
33194 if (lTemp > 255) |
|
33195 lTemp = 255; |
|
33196 lTemp4 = (lTemp >> 3); |
|
33197 |
|
33198 /*G component*/ |
|
33199 lTemp = lY1 - lTemp2 + 1; |
|
33200 if (lTemp < 0) |
|
33201 lTemp = 0; |
|
33202 if (lTemp > 255) |
|
33203 lTemp = 255; |
|
33204 lTemp4 |= (lTemp >> 2) << 5; |
|
33205 |
|
33206 /*R component*/ |
|
33207 lTemp = lY1 + lTemp1 + 4; |
|
33208 if (lTemp < 0) |
|
33209 lTemp = 0; |
|
33210 if (lTemp > 255) |
|
33211 lTemp = 255; |
|
33212 lTemp4 |= (lTemp >> 3) << 11; |
|
33213 |
|
33214 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
33215 |
|
33216 /*Fourth Pixel*/ |
|
33217 lY1 = lYuyvPtr[lLumWidth]; |
|
33218 lY1 -= 16; |
|
33219 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33220 |
|
33221 /*B component*/ |
|
33222 lTemp = lY1 + lTemp3 + 2; |
|
33223 if (lTemp < 0) |
|
33224 lTemp = 0; |
|
33225 if (lTemp > 255) |
|
33226 lTemp = 255; |
|
33227 lTemp4 = (lTemp >> 3); |
|
33228 |
|
33229 /*G component*/ |
|
33230 lTemp = lY1 - lTemp2 + 2; |
|
33231 if (lTemp < 0) |
|
33232 lTemp = 0; |
|
33233 if (lTemp > 255) |
|
33234 lTemp = 255; |
|
33235 lTemp4 |= (lTemp >> 2) << 5; |
|
33236 |
|
33237 /*R component*/ |
|
33238 lTemp = lY1 + lTemp1; |
|
33239 if (lTemp < 0) |
|
33240 lTemp = 0; |
|
33241 if (lTemp > 255) |
|
33242 lTemp = 255; |
|
33243 lTemp4 |= (lTemp >> 3) << 11; |
|
33244 |
|
33245 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
33246 |
|
33247 lYuyvPtr += 4; |
|
33248 lRGBFramePtr += 2; |
|
33249 lRGBFramePtr1 += 2; |
|
33250 |
|
33251 |
|
33252 if(extraCol) |
|
33253 { |
|
33254 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
33255 lRGBFramePtr++; |
|
33256 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
33257 lRGBFramePtr1++; |
|
33258 } |
|
33259 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
33260 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
33261 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
33262 } |
|
33263 |
|
33264 if(extraRow) |
|
33265 { |
|
33266 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
33267 for(j = 0; j < lWidth; j += 2) |
|
33268 { |
|
33269 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
33270 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
33271 } |
|
33272 if(extraCol) |
|
33273 { |
|
33274 *lRGBFramePtr = *lRGBFramePtr1; |
|
33275 } |
|
33276 } |
|
33277 return; |
|
33278 } |
|
33279 |
|
33280 /* |
|
33281 ****************************************************************************** |
|
33282 Name : sEmz_VDec_YUV422LEChr1toColor64k_Ordered_601_5_RR |
|
33283 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to RGB565 Interleaved format. |
|
33284 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
33285 uint8 *dstImage : Pointer to rgb data (o/p). |
|
33286 tWndParam *srcWindow : Pointer to structure containing source window |
|
33287 parameters like xOffset,yOffset,cropWidth, |
|
33288 cropHeight. (i/p) |
|
33289 tWndParam *dstWindow : Pointer to structure containing destination window |
|
33290 parameters like xOffset,yOffset,windWidth, |
|
33291 windHeight. (i/p) |
|
33292 Return Value : void |
|
33293 ****************************************************************************** |
|
33294 */ |
|
33295 |
|
33296 void sEmz_VDec_YUV422LEChr1toColor64k_Ordered_601_5_RR |
|
33297 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
33298 tWndParam* srcWindow, tWndParam* dstWindow) |
|
33299 { |
|
33300 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
33301 uint8 *lYuyvPtr; |
|
33302 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
33303 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
33304 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
33305 int32 i, j, extraCol, extraRow; |
|
33306 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
33307 cropWidth,cropHeight,wndWidth,wndHeight; |
|
33308 |
|
33309 srcXOffset = srcWindow->xOffset; |
|
33310 srcYOffset = srcWindow->yOffset; |
|
33311 cropWidth = srcWindow->wndWidth; |
|
33312 cropHeight = srcWindow->wndHeight; |
|
33313 |
|
33314 dstXOffset = dstWindow->xOffset; |
|
33315 dstYOffset = dstWindow->yOffset; |
|
33316 wndWidth = dstWindow->wndWidth; |
|
33317 wndHeight = dstWindow->wndHeight; |
|
33318 |
|
33319 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
33320 { |
|
33321 lWidth = cropWidth; |
|
33322 } |
|
33323 else |
|
33324 { |
|
33325 lWidth = srcImage->width - srcXOffset; |
|
33326 } |
|
33327 |
|
33328 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
33329 { |
|
33330 lHeight = cropHeight; |
|
33331 } |
|
33332 else |
|
33333 { |
|
33334 lHeight = srcImage->height - srcYOffset; |
|
33335 } |
|
33336 |
|
33337 if (lWidth > (wndWidth - dstXOffset)) |
|
33338 { |
|
33339 lWidth = wndWidth - dstXOffset; |
|
33340 } |
|
33341 |
|
33342 if (lHeight > (wndHeight - dstYOffset)) |
|
33343 { |
|
33344 lHeight = wndHeight - dstYOffset; |
|
33345 } |
|
33346 |
|
33347 extraCol = lWidth & 0x01; |
|
33348 extraRow = lHeight & 0x01; |
|
33349 |
|
33350 lTempWidth = lWidth; |
|
33351 lWidth = (lWidth >> 1) << 1; |
|
33352 lHeight = (lHeight >> 1) << 1; |
|
33353 |
|
33354 lLumWidth = (srcImage->width >> 1) << 1; |
|
33355 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
33356 |
|
33357 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
33358 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
33359 |
|
33360 lLumWidth <<= 1; |
|
33361 |
|
33362 for(i = 0; i < lHeight; i += 2) |
|
33363 { |
|
33364 for(j = 0; j < (lWidth - 2); j += 2) |
|
33365 { |
|
33366 lCb1 = lYuyvPtr[3]; |
|
33367 lCr1 = lYuyvPtr[1]; |
|
33368 |
|
33369 lCb2 = lYuyvPtr[7]; |
|
33370 lCr2 = lYuyvPtr[5]; |
|
33371 |
|
33372 lCr2 = (lCr1 + lCr2) >> 1; |
|
33373 lCb2 = (lCb1 + lCb2) >> 1; |
|
33374 |
|
33375 /*First Pixel*/ |
|
33376 lCr1 -= 128; |
|
33377 lCb1 -= 128; |
|
33378 |
|
33379 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
33380 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
33381 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
33382 |
|
33383 lY1 = lYuyvPtr[2]; |
|
33384 lY1 -= 16; |
|
33385 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33386 |
|
33387 /*B component*/ |
|
33388 lTemp = lY1 + lTemp3; |
|
33389 if (lTemp < 0) |
|
33390 lTemp = 0; |
|
33391 if (lTemp > 255) |
|
33392 lTemp = 255; |
|
33393 lTemp4 = (lTemp >> 3); |
|
33394 |
|
33395 /*G component*/ |
|
33396 lTemp = lY1 - lTemp2 + 3; |
|
33397 if (lTemp < 0) |
|
33398 lTemp = 0; |
|
33399 if (lTemp > 255) |
|
33400 lTemp = 255; |
|
33401 lTemp4 |= (lTemp >> 2) << 5; |
|
33402 |
|
33403 /*R component*/ |
|
33404 lTemp = lY1 + lTemp1 + 2; |
|
33405 if (lTemp < 0) |
|
33406 lTemp = 0; |
|
33407 if (lTemp > 255) |
|
33408 lTemp = 255; |
|
33409 lTemp4 |= (lTemp >> 3) << 11; |
|
33410 |
|
33411 lRGBFramePtr[0] = (uint16)lTemp4; |
|
33412 |
|
33413 /*Second Pixel*/ |
|
33414 lCr2 -= 128; |
|
33415 lCb2 -= 128; |
|
33416 |
|
33417 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
33418 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
33419 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
33420 |
|
33421 lY1 = lYuyvPtr[0]; |
|
33422 lY1 -= 16; |
|
33423 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33424 |
|
33425 /*B component*/ |
|
33426 lTemp = lY1 + lTemp3 + 4; |
|
33427 if (lTemp < 0) |
|
33428 lTemp = 0; |
|
33429 if (lTemp > 255) |
|
33430 lTemp = 255; |
|
33431 lTemp4 = (lTemp >> 3); |
|
33432 |
|
33433 /*G component*/ |
|
33434 lTemp = lY1 - lTemp2; |
|
33435 if (lTemp < 0) |
|
33436 lTemp = 0; |
|
33437 if (lTemp > 255) |
|
33438 lTemp = 255; |
|
33439 lTemp4 |= (lTemp >> 2) << 5; |
|
33440 |
|
33441 /*R component*/ |
|
33442 lTemp = lY1 + lTemp1 + 6; |
|
33443 if (lTemp < 0) |
|
33444 lTemp = 0; |
|
33445 if (lTemp > 255) |
|
33446 lTemp = 255; |
|
33447 lTemp4 |= (lTemp >> 3) << 11; |
|
33448 |
|
33449 lRGBFramePtr[1] = (uint16)lTemp4; |
|
33450 |
|
33451 |
|
33452 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
33453 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
33454 |
|
33455 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
33456 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
33457 |
|
33458 lCr2 = (lCr1 + lCr2) >> 1; |
|
33459 lCb2 = (lCb1 + lCb2) >> 1; |
|
33460 |
|
33461 /*Third Pixel*/ |
|
33462 lCr1 -= 128; |
|
33463 lCb1 -= 128; |
|
33464 |
|
33465 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
33466 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
33467 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
33468 |
|
33469 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
33470 lY1 -= 16; |
|
33471 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33472 |
|
33473 /*B component*/ |
|
33474 lTemp = lY1 + lTemp3 + 6; |
|
33475 if (lTemp < 0) |
|
33476 lTemp = 0; |
|
33477 if (lTemp > 255) |
|
33478 lTemp = 255; |
|
33479 lTemp4 = (lTemp >> 3); |
|
33480 |
|
33481 /*G component*/ |
|
33482 lTemp = lY1 - lTemp2 + 1; |
|
33483 if (lTemp < 0) |
|
33484 lTemp = 0; |
|
33485 if (lTemp > 255) |
|
33486 lTemp = 255; |
|
33487 lTemp4 |= (lTemp >> 2) << 5; |
|
33488 |
|
33489 /*R component*/ |
|
33490 lTemp = lY1 + lTemp1 + 4; |
|
33491 if (lTemp < 0) |
|
33492 lTemp = 0; |
|
33493 if (lTemp > 255) |
|
33494 lTemp = 255; |
|
33495 lTemp4 |= (lTemp >> 3) << 11; |
|
33496 |
|
33497 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
33498 |
|
33499 /*Fourth Pixel*/ |
|
33500 lCr2 -= 128; |
|
33501 lCb2 -= 128; |
|
33502 |
|
33503 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
33504 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
33505 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
33506 |
|
33507 lY1 = lYuyvPtr[lLumWidth]; |
|
33508 lY1 -= 16; |
|
33509 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33510 |
|
33511 /*B component*/ |
|
33512 lTemp = lY1 + lTemp3 + 2; |
|
33513 if (lTemp < 0) |
|
33514 lTemp = 0; |
|
33515 if (lTemp > 255) |
|
33516 lTemp = 255; |
|
33517 lTemp4 = (lTemp >> 3); |
|
33518 |
|
33519 /*G component*/ |
|
33520 lTemp = lY1 - lTemp2 + 2; |
|
33521 if (lTemp < 0) |
|
33522 lTemp = 0; |
|
33523 if (lTemp > 255) |
|
33524 lTemp = 255; |
|
33525 lTemp4 |= (lTemp >> 2) << 5; |
|
33526 |
|
33527 /*R component*/ |
|
33528 lTemp = lY1 + lTemp1; |
|
33529 if (lTemp < 0) |
|
33530 lTemp = 0; |
|
33531 if (lTemp > 255) |
|
33532 lTemp = 255; |
|
33533 lTemp4 |= (lTemp >> 3) << 11; |
|
33534 |
|
33535 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
33536 |
|
33537 lYuyvPtr += 4; |
|
33538 lRGBFramePtr += 2; |
|
33539 lRGBFramePtr1 += 2; |
|
33540 } |
|
33541 |
|
33542 |
|
33543 lCb1 = lYuyvPtr[3]; |
|
33544 lCr1 = lYuyvPtr[1]; |
|
33545 |
|
33546 lCr1 -= 128; |
|
33547 lCb1 -= 128; |
|
33548 |
|
33549 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
33550 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
33551 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
33552 |
|
33553 /*First Pixel*/ |
|
33554 lY1 = lYuyvPtr[2]; |
|
33555 lY1 -= 16; |
|
33556 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33557 |
|
33558 /*B component*/ |
|
33559 lTemp = lY1 + lTemp3; |
|
33560 if (lTemp < 0) |
|
33561 lTemp = 0; |
|
33562 if (lTemp > 255) |
|
33563 lTemp = 255; |
|
33564 lTemp4 = (lTemp >> 3); |
|
33565 |
|
33566 /*G component*/ |
|
33567 lTemp = lY1 - lTemp2 + 3; |
|
33568 if (lTemp < 0) |
|
33569 lTemp = 0; |
|
33570 if (lTemp > 255) |
|
33571 lTemp = 255; |
|
33572 lTemp4 |= (lTemp >> 2) << 5; |
|
33573 |
|
33574 /*R component*/ |
|
33575 lTemp = lY1 + lTemp1 + 2; |
|
33576 if (lTemp < 0) |
|
33577 lTemp = 0; |
|
33578 if (lTemp > 255) |
|
33579 lTemp = 255; |
|
33580 lTemp4 |= (lTemp >> 3) << 11; |
|
33581 |
|
33582 lRGBFramePtr[0] = (uint16)lTemp4; |
|
33583 |
|
33584 /*Second Pixel*/ |
|
33585 lY1 = lYuyvPtr[0]; |
|
33586 lY1 -= 16; |
|
33587 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33588 |
|
33589 /*B component*/ |
|
33590 lTemp = lY1 + lTemp3 + 4; |
|
33591 if (lTemp < 0) |
|
33592 lTemp = 0; |
|
33593 if (lTemp > 255) |
|
33594 lTemp = 255; |
|
33595 lTemp4 = (lTemp >> 3); |
|
33596 |
|
33597 /*G component*/ |
|
33598 lTemp = lY1 - lTemp2; |
|
33599 if (lTemp < 0) |
|
33600 lTemp = 0; |
|
33601 if (lTemp > 255) |
|
33602 lTemp = 255; |
|
33603 lTemp4 |= (lTemp >> 2) << 5; |
|
33604 |
|
33605 /*R component*/ |
|
33606 lTemp = lY1 + lTemp1 + 6; |
|
33607 if (lTemp < 0) |
|
33608 lTemp = 0; |
|
33609 if (lTemp > 255) |
|
33610 lTemp = 255; |
|
33611 lTemp4 |= (lTemp >> 3) << 11; |
|
33612 |
|
33613 lRGBFramePtr[1] = (uint16)lTemp4; |
|
33614 |
|
33615 |
|
33616 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
33617 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
33618 |
|
33619 lCr1 -= 128; |
|
33620 lCb1 -= 128; |
|
33621 |
|
33622 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
33623 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
33624 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
33625 |
|
33626 /*Third Pixel*/ |
|
33627 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
33628 lY1 -= 16; |
|
33629 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33630 |
|
33631 /*B component*/ |
|
33632 lTemp = lY1 + lTemp3 + 6; |
|
33633 if (lTemp < 0) |
|
33634 lTemp = 0; |
|
33635 if (lTemp > 255) |
|
33636 lTemp = 255; |
|
33637 lTemp4 = (lTemp >> 3); |
|
33638 |
|
33639 /*G component*/ |
|
33640 lTemp = lY1 - lTemp2 + 1; |
|
33641 if (lTemp < 0) |
|
33642 lTemp = 0; |
|
33643 if (lTemp > 255) |
|
33644 lTemp = 255; |
|
33645 lTemp4 |= (lTemp >> 2) << 5; |
|
33646 |
|
33647 /*R component*/ |
|
33648 lTemp = lY1 + lTemp1 + 4; |
|
33649 if (lTemp < 0) |
|
33650 lTemp = 0; |
|
33651 if (lTemp > 255) |
|
33652 lTemp = 255; |
|
33653 lTemp4 |= (lTemp >> 3) << 11; |
|
33654 |
|
33655 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
33656 |
|
33657 /*Fourth Pixel*/ |
|
33658 lY1 = lYuyvPtr[lLumWidth]; |
|
33659 lY1 -= 16; |
|
33660 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
33661 |
|
33662 /*B component*/ |
|
33663 lTemp = lY1 + lTemp3 + 2; |
|
33664 if (lTemp < 0) |
|
33665 lTemp = 0; |
|
33666 if (lTemp > 255) |
|
33667 lTemp = 255; |
|
33668 lTemp4 = (lTemp >> 3); |
|
33669 |
|
33670 /*G component*/ |
|
33671 lTemp = lY1 - lTemp2 + 2; |
|
33672 if (lTemp < 0) |
|
33673 lTemp = 0; |
|
33674 if (lTemp > 255) |
|
33675 lTemp = 255; |
|
33676 lTemp4 |= (lTemp >> 2) << 5; |
|
33677 |
|
33678 /*R component*/ |
|
33679 lTemp = lY1 + lTemp1; |
|
33680 if (lTemp < 0) |
|
33681 lTemp = 0; |
|
33682 if (lTemp > 255) |
|
33683 lTemp = 255; |
|
33684 lTemp4 |= (lTemp >> 3) << 11; |
|
33685 |
|
33686 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
33687 |
|
33688 lYuyvPtr += 4; |
|
33689 lRGBFramePtr += 2; |
|
33690 lRGBFramePtr1 += 2; |
|
33691 |
|
33692 |
|
33693 if(extraCol) |
|
33694 { |
|
33695 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
33696 lRGBFramePtr++; |
|
33697 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
33698 lRGBFramePtr1++; |
|
33699 } |
|
33700 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
33701 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
33702 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
33703 } |
|
33704 |
|
33705 if(extraRow) |
|
33706 { |
|
33707 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
33708 for(j = 0; j < lWidth; j += 2) |
|
33709 { |
|
33710 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
33711 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
33712 } |
|
33713 if(extraCol) |
|
33714 { |
|
33715 *lRGBFramePtr = *lRGBFramePtr1; |
|
33716 } |
|
33717 } |
|
33718 return; |
|
33719 } |
|
33720 |
|
33721 |
|
33722 /* |
|
33723 ****************************************************************************** |
|
33724 Name : sEmz_VDec_YUV422LEChr1toColor16M_709_FR |
|
33725 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to RGB888 Interleaved format. |
|
33726 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
33727 uint8 *dstImage : Pointer to rgb data (o/p). |
|
33728 tWndParam *srcWindow : Pointer to structure containing source window |
|
33729 parameters like xOffset,yOffset,cropWidth, |
|
33730 cropHeight. (i/p) |
|
33731 tWndParam *dstWindow : Pointer to structure containing destination window |
|
33732 parameters like xOffset,yOffset,windWidth, |
|
33733 windHeight. (i/p) |
|
33734 Return Value : void |
|
33735 ****************************************************************************** |
|
33736 */ |
|
33737 |
|
33738 void sEmz_VDec_YUV422LEChr1toColor16M_709_FR |
|
33739 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
33740 tWndParam* srcWindow, tWndParam* dstWindow) |
|
33741 { |
|
33742 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
33743 uint8 *lYuyvPtr; |
|
33744 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
33745 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
33746 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
33747 int32 i, j, extraCol, extraRow; |
|
33748 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
33749 cropWidth,cropHeight,wndWidth,wndHeight; |
|
33750 |
|
33751 srcXOffset = srcWindow->xOffset; |
|
33752 srcYOffset = srcWindow->yOffset; |
|
33753 cropWidth = srcWindow->wndWidth; |
|
33754 cropHeight = srcWindow->wndHeight; |
|
33755 |
|
33756 |
|
33757 dstXOffset = dstWindow->xOffset; |
|
33758 dstYOffset = dstWindow->yOffset; |
|
33759 wndWidth = dstWindow->wndWidth; |
|
33760 wndHeight = dstWindow->wndHeight; |
|
33761 |
|
33762 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
33763 { |
|
33764 lWidth = cropWidth; |
|
33765 } |
|
33766 else |
|
33767 { |
|
33768 lWidth = srcImage->width - srcXOffset; |
|
33769 } |
|
33770 |
|
33771 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
33772 { |
|
33773 lHeight = cropHeight; |
|
33774 } |
|
33775 else |
|
33776 { |
|
33777 lHeight = srcImage->height - srcYOffset; |
|
33778 } |
|
33779 |
|
33780 if (lWidth > (wndWidth - dstXOffset)) |
|
33781 { |
|
33782 lWidth = wndWidth - dstXOffset; |
|
33783 } |
|
33784 |
|
33785 if (lHeight > (wndHeight - dstYOffset)) |
|
33786 { |
|
33787 lHeight = wndHeight - dstYOffset; |
|
33788 } |
|
33789 |
|
33790 extraCol = lWidth & 0x01; |
|
33791 extraRow = lHeight & 0x01; |
|
33792 |
|
33793 lTempWidth = lWidth * 3; |
|
33794 lWidth = (lWidth >> 1) << 1; |
|
33795 lHeight = (lHeight >> 1) << 1; |
|
33796 |
|
33797 dstXOffset *= 3; |
|
33798 wndWidth *= 3; |
|
33799 |
|
33800 lLumWidth = (srcImage->width >> 1) << 1 ; |
|
33801 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
33802 |
|
33803 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
33804 |
|
33805 for(i = 0; i < lHeight; i++) |
|
33806 { |
|
33807 for(j = 0; j < (lWidth - 2); j += 2) |
|
33808 { |
|
33809 lCb1 = lYuyvPtr[3]; |
|
33810 lCr1 = lYuyvPtr[1]; |
|
33811 |
|
33812 lCb2 = lYuyvPtr[7]; |
|
33813 lCr2 = lYuyvPtr[5]; |
|
33814 |
|
33815 lCr2 = (lCr1 + lCr2) >> 1; |
|
33816 lCb2 = (lCb1 + lCb2) >> 1; |
|
33817 |
|
33818 lCb1 -= 128; |
|
33819 lCr1 -= 128; |
|
33820 |
|
33821 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
33822 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
33823 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
33824 |
|
33825 /*First Pixel*/ |
|
33826 lY1 = lYuyvPtr[2]; |
|
33827 |
|
33828 /*R component*/ |
|
33829 lTemp = (lY1 + lTemp1); |
|
33830 if (lTemp < 0) |
|
33831 lTemp = 0; |
|
33832 if (lTemp > 255) |
|
33833 lTemp = 255; |
|
33834 lRGBFramePtr[0] = (uint8) lTemp; |
|
33835 |
|
33836 /*G component*/ |
|
33837 lTemp = (lY1 - lTemp2); |
|
33838 if (lTemp < 0) |
|
33839 lTemp = 0; |
|
33840 if (lTemp > 255) |
|
33841 lTemp = 255; |
|
33842 lRGBFramePtr[1] = (uint8) lTemp; |
|
33843 |
|
33844 /*B component*/ |
|
33845 lTemp = (lY1 + lTemp3); |
|
33846 if (lTemp < 0) |
|
33847 lTemp = 0; |
|
33848 if (lTemp > 255) |
|
33849 lTemp = 255; |
|
33850 |
|
33851 lRGBFramePtr[2] = (uint8) lTemp; |
|
33852 |
|
33853 lCb2 -= 128; |
|
33854 lCr2 -= 128; |
|
33855 |
|
33856 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
33857 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
33858 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
33859 |
|
33860 /*Second Pixel*/ |
|
33861 lY1 = lYuyvPtr[0]; |
|
33862 |
|
33863 /*R component*/ |
|
33864 lTemp = (lY1 + lTemp1); |
|
33865 if (lTemp < 0) |
|
33866 lTemp = 0; |
|
33867 if (lTemp > 255) |
|
33868 lTemp = 255; |
|
33869 lRGBFramePtr[3] = (uint8) lTemp; |
|
33870 |
|
33871 /*G component*/ |
|
33872 lTemp = (lY1 - lTemp2); |
|
33873 if (lTemp < 0) |
|
33874 lTemp = 0; |
|
33875 if (lTemp > 255) |
|
33876 lTemp = 255; |
|
33877 lRGBFramePtr[4] = (uint8) lTemp; |
|
33878 |
|
33879 /*B component*/ |
|
33880 lTemp = (lY1 + lTemp3); |
|
33881 if (lTemp < 0) |
|
33882 lTemp = 0; |
|
33883 if (lTemp > 255) |
|
33884 lTemp = 255; |
|
33885 lRGBFramePtr[5] = (uint8) lTemp; |
|
33886 |
|
33887 lYuyvPtr += 4; |
|
33888 lRGBFramePtr += 6; |
|
33889 } |
|
33890 |
|
33891 lCb1 = lYuyvPtr[3]; |
|
33892 lCr1 = lYuyvPtr[1]; |
|
33893 |
|
33894 lCb1 -= 128; |
|
33895 lCr1 -= 128; |
|
33896 |
|
33897 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
33898 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
33899 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
33900 |
|
33901 /*First Pixel*/ |
|
33902 lY1 = lYuyvPtr[2]; |
|
33903 |
|
33904 /*R component*/ |
|
33905 lTemp = (lY1 + lTemp1); |
|
33906 if (lTemp < 0) |
|
33907 lTemp = 0; |
|
33908 if (lTemp > 255) |
|
33909 lTemp = 255; |
|
33910 lRGBFramePtr[0] = (uint8) lTemp; |
|
33911 |
|
33912 /*G component*/ |
|
33913 lTemp = (lY1 - lTemp2); |
|
33914 if (lTemp < 0) |
|
33915 lTemp = 0; |
|
33916 if (lTemp > 255) |
|
33917 lTemp = 255; |
|
33918 lRGBFramePtr[1] = (uint8) lTemp; |
|
33919 |
|
33920 /*B component*/ |
|
33921 lTemp = (lY1 + lTemp3); |
|
33922 if (lTemp < 0) |
|
33923 lTemp = 0; |
|
33924 if (lTemp > 255) |
|
33925 lTemp = 255; |
|
33926 |
|
33927 lRGBFramePtr[2] = (uint8) lTemp; |
|
33928 |
|
33929 /*Second Pixel*/ |
|
33930 lY1 = lYuyvPtr[0]; |
|
33931 |
|
33932 /*R component*/ |
|
33933 lTemp = (lY1 + lTemp1); |
|
33934 if (lTemp < 0) |
|
33935 lTemp = 0; |
|
33936 if (lTemp > 255) |
|
33937 lTemp = 255; |
|
33938 lRGBFramePtr[3] = (uint8) lTemp; |
|
33939 |
|
33940 /*G component*/ |
|
33941 lTemp = (lY1 - lTemp2); |
|
33942 if (lTemp < 0) |
|
33943 lTemp = 0; |
|
33944 if (lTemp > 255) |
|
33945 lTemp = 255; |
|
33946 lRGBFramePtr[4] = (uint8) lTemp; |
|
33947 |
|
33948 /*B component*/ |
|
33949 lTemp = (lY1 + lTemp3); |
|
33950 if (lTemp < 0) |
|
33951 lTemp = 0; |
|
33952 if (lTemp > 255) |
|
33953 lTemp = 255; |
|
33954 lRGBFramePtr[5] = (uint8) lTemp; |
|
33955 |
|
33956 lYuyvPtr += 4; |
|
33957 lRGBFramePtr += 6; |
|
33958 |
|
33959 if(extraCol) |
|
33960 { |
|
33961 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
33962 lRGBFramePtr++; |
|
33963 |
|
33964 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
33965 lRGBFramePtr++; |
|
33966 |
|
33967 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
33968 lRGBFramePtr++; |
|
33969 } |
|
33970 |
|
33971 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
33972 lRGBFramePtr += (wndWidth - lTempWidth); |
|
33973 } |
|
33974 |
|
33975 if(extraRow) |
|
33976 { |
|
33977 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
33978 for(j = 0; j < lWidth * 3; j += 2) |
|
33979 { |
|
33980 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
33981 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
33982 } |
|
33983 if(extraCol) |
|
33984 { |
|
33985 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
33986 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
33987 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
33988 } |
|
33989 } |
|
33990 return; |
|
33991 } |
|
33992 |
|
33993 /* |
|
33994 ****************************************************************************** |
|
33995 Name : sEmz_VDec_YUV422LEChr1toColor16M_601_5_FR |
|
33996 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to RGB888 Interleaved format. |
|
33997 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
33998 uint8 *dstImage : Pointer to rgb data (o/p). |
|
33999 tWndParam *srcWindow : Pointer to structure containing source window |
|
34000 parameters like xOffset,yOffset,cropWidth, |
|
34001 cropHeight. (i/p) |
|
34002 tWndParam *dstWindow : Pointer to structure containing destination window |
|
34003 parameters like xOffset,yOffset,windWidth, |
|
34004 windHeight. (i/p) |
|
34005 Return Value : void |
|
34006 ****************************************************************************** |
|
34007 */ |
|
34008 |
|
34009 void sEmz_VDec_YUV422LEChr1toColor16M_601_5_FR |
|
34010 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
34011 tWndParam* srcWindow, tWndParam* dstWindow) |
|
34012 { |
|
34013 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
34014 uint8 *lYuyvPtr; |
|
34015 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
34016 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
34017 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
34018 int32 i, j, extraCol, extraRow; |
|
34019 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
34020 cropWidth,cropHeight,wndWidth,wndHeight; |
|
34021 |
|
34022 srcXOffset = srcWindow->xOffset; |
|
34023 srcYOffset = srcWindow->yOffset; |
|
34024 cropWidth = srcWindow->wndWidth; |
|
34025 cropHeight = srcWindow->wndHeight; |
|
34026 |
|
34027 |
|
34028 dstXOffset = dstWindow->xOffset; |
|
34029 dstYOffset = dstWindow->yOffset; |
|
34030 wndWidth = dstWindow->wndWidth; |
|
34031 wndHeight = dstWindow->wndHeight; |
|
34032 |
|
34033 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
34034 { |
|
34035 lWidth = cropWidth; |
|
34036 } |
|
34037 else |
|
34038 { |
|
34039 lWidth = srcImage->width - srcXOffset; |
|
34040 } |
|
34041 |
|
34042 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
34043 { |
|
34044 lHeight = cropHeight; |
|
34045 } |
|
34046 else |
|
34047 { |
|
34048 lHeight = srcImage->height - srcYOffset; |
|
34049 } |
|
34050 |
|
34051 if (lWidth > (wndWidth - dstXOffset)) |
|
34052 { |
|
34053 lWidth = wndWidth - dstXOffset; |
|
34054 } |
|
34055 |
|
34056 if (lHeight > (wndHeight - dstYOffset)) |
|
34057 { |
|
34058 lHeight = wndHeight - dstYOffset; |
|
34059 } |
|
34060 |
|
34061 extraCol = lWidth & 0x01; |
|
34062 extraRow = lHeight & 0x01; |
|
34063 |
|
34064 lTempWidth = lWidth * 3; |
|
34065 lWidth = (lWidth >> 1) << 1; |
|
34066 lHeight = (lHeight >> 1) << 1; |
|
34067 |
|
34068 dstXOffset *= 3; |
|
34069 wndWidth *= 3; |
|
34070 |
|
34071 lLumWidth = (srcImage->width >> 1) << 1 ; |
|
34072 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
34073 |
|
34074 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
34075 |
|
34076 for(i = 0; i < lHeight; i++) |
|
34077 { |
|
34078 for(j = 0; j < (lWidth - 2); j += 2) |
|
34079 { |
|
34080 lCb1 = lYuyvPtr[3]; |
|
34081 lCr1 = lYuyvPtr[1]; |
|
34082 |
|
34083 lCb2 = lYuyvPtr[7]; |
|
34084 lCr2 = lYuyvPtr[5]; |
|
34085 |
|
34086 lCr2 = (lCr1 + lCr2) >> 1; |
|
34087 lCb2 = (lCb1 + lCb2) >> 1; |
|
34088 |
|
34089 lCb1 -= 128; |
|
34090 lCr1 -= 128; |
|
34091 |
|
34092 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
34093 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
34094 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
34095 |
|
34096 /*First Pixel*/ |
|
34097 lY1 = lYuyvPtr[2]; |
|
34098 |
|
34099 /*R component*/ |
|
34100 lTemp = (lY1 + lTemp1); |
|
34101 if (lTemp < 0) |
|
34102 lTemp = 0; |
|
34103 if (lTemp > 255) |
|
34104 lTemp = 255; |
|
34105 lRGBFramePtr[0] = (uint8) lTemp; |
|
34106 |
|
34107 /*G component*/ |
|
34108 lTemp = (lY1 - lTemp2); |
|
34109 if (lTemp < 0) |
|
34110 lTemp = 0; |
|
34111 if (lTemp > 255) |
|
34112 lTemp = 255; |
|
34113 lRGBFramePtr[1] = (uint8) lTemp; |
|
34114 |
|
34115 /*B component*/ |
|
34116 lTemp = (lY1 + lTemp3); |
|
34117 if (lTemp < 0) |
|
34118 lTemp = 0; |
|
34119 if (lTemp > 255) |
|
34120 lTemp = 255; |
|
34121 |
|
34122 lRGBFramePtr[2] = (uint8) lTemp; |
|
34123 |
|
34124 lCb2 -= 128; |
|
34125 lCr2 -= 128; |
|
34126 |
|
34127 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
34128 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
34129 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
34130 |
|
34131 /*Second Pixel*/ |
|
34132 lY1 = lYuyvPtr[0]; |
|
34133 |
|
34134 /*R component*/ |
|
34135 lTemp = (lY1 + lTemp1); |
|
34136 if (lTemp < 0) |
|
34137 lTemp = 0; |
|
34138 if (lTemp > 255) |
|
34139 lTemp = 255; |
|
34140 lRGBFramePtr[3] = (uint8) lTemp; |
|
34141 |
|
34142 /*G component*/ |
|
34143 lTemp = (lY1 - lTemp2); |
|
34144 if (lTemp < 0) |
|
34145 lTemp = 0; |
|
34146 if (lTemp > 255) |
|
34147 lTemp = 255; |
|
34148 lRGBFramePtr[4] = (uint8) lTemp; |
|
34149 |
|
34150 /*B component*/ |
|
34151 lTemp = (lY1 + lTemp3); |
|
34152 if (lTemp < 0) |
|
34153 lTemp = 0; |
|
34154 if (lTemp > 255) |
|
34155 lTemp = 255; |
|
34156 lRGBFramePtr[5] = (uint8) lTemp; |
|
34157 |
|
34158 lYuyvPtr += 4; |
|
34159 lRGBFramePtr += 6; |
|
34160 } |
|
34161 |
|
34162 lCb1 = lYuyvPtr[3]; |
|
34163 lCr1 = lYuyvPtr[1]; |
|
34164 |
|
34165 lCb1 -= 128; |
|
34166 lCr1 -= 128; |
|
34167 |
|
34168 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
34169 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
34170 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
34171 |
|
34172 /*First Pixel*/ |
|
34173 lY1 = lYuyvPtr[2]; |
|
34174 |
|
34175 /*R component*/ |
|
34176 lTemp = (lY1 + lTemp1); |
|
34177 if (lTemp < 0) |
|
34178 lTemp = 0; |
|
34179 if (lTemp > 255) |
|
34180 lTemp = 255; |
|
34181 lRGBFramePtr[0] = (uint8) lTemp; |
|
34182 |
|
34183 /*G component*/ |
|
34184 lTemp = (lY1 - lTemp2); |
|
34185 if (lTemp < 0) |
|
34186 lTemp = 0; |
|
34187 if (lTemp > 255) |
|
34188 lTemp = 255; |
|
34189 lRGBFramePtr[1] = (uint8) lTemp; |
|
34190 |
|
34191 /*B component*/ |
|
34192 lTemp = (lY1 + lTemp3); |
|
34193 if (lTemp < 0) |
|
34194 lTemp = 0; |
|
34195 if (lTemp > 255) |
|
34196 lTemp = 255; |
|
34197 |
|
34198 lRGBFramePtr[2] = (uint8) lTemp; |
|
34199 |
|
34200 /*Second Pixel*/ |
|
34201 lY1 = lYuyvPtr[0]; |
|
34202 |
|
34203 /*R component*/ |
|
34204 lTemp = (lY1 + lTemp1); |
|
34205 if (lTemp < 0) |
|
34206 lTemp = 0; |
|
34207 if (lTemp > 255) |
|
34208 lTemp = 255; |
|
34209 lRGBFramePtr[3] = (uint8) lTemp; |
|
34210 |
|
34211 /*G component*/ |
|
34212 lTemp = (lY1 - lTemp2); |
|
34213 if (lTemp < 0) |
|
34214 lTemp = 0; |
|
34215 if (lTemp > 255) |
|
34216 lTemp = 255; |
|
34217 lRGBFramePtr[4] = (uint8) lTemp; |
|
34218 |
|
34219 /*B component*/ |
|
34220 lTemp = (lY1 + lTemp3); |
|
34221 if (lTemp < 0) |
|
34222 lTemp = 0; |
|
34223 if (lTemp > 255) |
|
34224 lTemp = 255; |
|
34225 lRGBFramePtr[5] = (uint8) lTemp; |
|
34226 |
|
34227 lYuyvPtr += 4; |
|
34228 lRGBFramePtr += 6; |
|
34229 |
|
34230 if(extraCol) |
|
34231 { |
|
34232 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
34233 lRGBFramePtr++; |
|
34234 |
|
34235 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
34236 lRGBFramePtr++; |
|
34237 |
|
34238 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
34239 lRGBFramePtr++; |
|
34240 } |
|
34241 |
|
34242 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
34243 lRGBFramePtr += (wndWidth - lTempWidth); |
|
34244 } |
|
34245 |
|
34246 if(extraRow) |
|
34247 { |
|
34248 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
34249 for(j = 0; j < lWidth * 3; j += 2) |
|
34250 { |
|
34251 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34252 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34253 } |
|
34254 if(extraCol) |
|
34255 { |
|
34256 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34257 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34258 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34259 } |
|
34260 } |
|
34261 return; |
|
34262 } |
|
34263 |
|
34264 /* |
|
34265 ****************************************************************************** |
|
34266 Name : sEmz_VDec_YUV422LEChr1toColor16M_709_RR |
|
34267 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to RGB888 Interleaved format. |
|
34268 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
34269 uint8 *dstImage : Pointer to rgb data (o/p). |
|
34270 tWndParam *srcWindow : Pointer to structure containing source window |
|
34271 parameters like xOffset,yOffset,cropWidth, |
|
34272 cropHeight. (i/p) |
|
34273 tWndParam *dstWindow : Pointer to structure containing destination window |
|
34274 parameters like xOffset,yOffset,windWidth, |
|
34275 windHeight. (i/p) |
|
34276 Return Value : void |
|
34277 ****************************************************************************** |
|
34278 */ |
|
34279 |
|
34280 void sEmz_VDec_YUV422LEChr1toColor16M_709_RR |
|
34281 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
34282 tWndParam* srcWindow, tWndParam* dstWindow) |
|
34283 { |
|
34284 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
34285 uint8 *lYuyvPtr; |
|
34286 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
34287 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
34288 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
34289 int32 i, j, extraCol, extraRow; |
|
34290 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
34291 cropWidth,cropHeight,wndWidth,wndHeight; |
|
34292 |
|
34293 srcXOffset = srcWindow->xOffset; |
|
34294 srcYOffset = srcWindow->yOffset; |
|
34295 cropWidth = srcWindow->wndWidth; |
|
34296 cropHeight = srcWindow->wndHeight; |
|
34297 |
|
34298 |
|
34299 dstXOffset = dstWindow->xOffset; |
|
34300 dstYOffset = dstWindow->yOffset; |
|
34301 wndWidth = dstWindow->wndWidth; |
|
34302 wndHeight = dstWindow->wndHeight; |
|
34303 |
|
34304 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
34305 { |
|
34306 lWidth = cropWidth; |
|
34307 } |
|
34308 else |
|
34309 { |
|
34310 lWidth = srcImage->width - srcXOffset; |
|
34311 } |
|
34312 |
|
34313 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
34314 { |
|
34315 lHeight = cropHeight; |
|
34316 } |
|
34317 else |
|
34318 { |
|
34319 lHeight = srcImage->height - srcYOffset; |
|
34320 } |
|
34321 |
|
34322 if (lWidth > (wndWidth - dstXOffset)) |
|
34323 { |
|
34324 lWidth = wndWidth - dstXOffset; |
|
34325 } |
|
34326 |
|
34327 if (lHeight > (wndHeight - dstYOffset)) |
|
34328 { |
|
34329 lHeight = wndHeight - dstYOffset; |
|
34330 } |
|
34331 |
|
34332 extraCol = lWidth & 0x01; |
|
34333 extraRow = lHeight & 0x01; |
|
34334 |
|
34335 lTempWidth = lWidth * 3; |
|
34336 lWidth = (lWidth >> 1) << 1; |
|
34337 lHeight = (lHeight >> 1) << 1; |
|
34338 |
|
34339 dstXOffset *= 3; |
|
34340 wndWidth *= 3; |
|
34341 |
|
34342 lLumWidth = (srcImage->width >> 1) << 1 ; |
|
34343 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
34344 |
|
34345 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
34346 |
|
34347 for(i = 0; i < lHeight; i++) |
|
34348 { |
|
34349 for(j = 0; j < (lWidth - 2); j += 2) |
|
34350 { |
|
34351 lCb1 = lYuyvPtr[3]; |
|
34352 lCr1 = lYuyvPtr[1]; |
|
34353 |
|
34354 lCb2 = lYuyvPtr[7]; |
|
34355 lCr2 = lYuyvPtr[5]; |
|
34356 |
|
34357 lCr2 = (lCr1 + lCr2) >> 1; |
|
34358 lCb2 = (lCb1 + lCb2) >> 1; |
|
34359 |
|
34360 lCb1 -= 128; |
|
34361 lCr1 -= 128; |
|
34362 |
|
34363 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
34364 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
34365 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
34366 |
|
34367 /*First Pixel*/ |
|
34368 lY1 = lYuyvPtr[2]; |
|
34369 lY1 -= 16; |
|
34370 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
34371 |
|
34372 /*R component*/ |
|
34373 lTemp = (lY1 + lTemp1); |
|
34374 if (lTemp < 0) |
|
34375 lTemp = 0; |
|
34376 if (lTemp > 255) |
|
34377 lTemp = 255; |
|
34378 lRGBFramePtr[0] = (uint8) lTemp; |
|
34379 |
|
34380 /*G component*/ |
|
34381 lTemp = (lY1 - lTemp2); |
|
34382 if (lTemp < 0) |
|
34383 lTemp = 0; |
|
34384 if (lTemp > 255) |
|
34385 lTemp = 255; |
|
34386 lRGBFramePtr[1] = (uint8) lTemp; |
|
34387 |
|
34388 /*B component*/ |
|
34389 lTemp = (lY1 + lTemp3); |
|
34390 if (lTemp < 0) |
|
34391 lTemp = 0; |
|
34392 if (lTemp > 255) |
|
34393 lTemp = 255; |
|
34394 |
|
34395 lRGBFramePtr[2] = (uint8) lTemp; |
|
34396 |
|
34397 lCb2 -= 128; |
|
34398 lCr2 -= 128; |
|
34399 |
|
34400 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
34401 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
34402 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
34403 |
|
34404 /*Second Pixel*/ |
|
34405 lY1 = lYuyvPtr[0]; |
|
34406 lY1 -= 16; |
|
34407 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
34408 |
|
34409 /*R component*/ |
|
34410 lTemp = (lY1 + lTemp1); |
|
34411 if (lTemp < 0) |
|
34412 lTemp = 0; |
|
34413 if (lTemp > 255) |
|
34414 lTemp = 255; |
|
34415 lRGBFramePtr[3] = (uint8) lTemp; |
|
34416 |
|
34417 /*G component*/ |
|
34418 lTemp = (lY1 - lTemp2); |
|
34419 if (lTemp < 0) |
|
34420 lTemp = 0; |
|
34421 if (lTemp > 255) |
|
34422 lTemp = 255; |
|
34423 lRGBFramePtr[4] = (uint8) lTemp; |
|
34424 |
|
34425 /*B component*/ |
|
34426 lTemp = (lY1 + lTemp3); |
|
34427 if (lTemp < 0) |
|
34428 lTemp = 0; |
|
34429 if (lTemp > 255) |
|
34430 lTemp = 255; |
|
34431 lRGBFramePtr[5] = (uint8) lTemp; |
|
34432 |
|
34433 lYuyvPtr += 4; |
|
34434 lRGBFramePtr += 6; |
|
34435 } |
|
34436 |
|
34437 lCb1 = lYuyvPtr[3]; |
|
34438 lCr1 = lYuyvPtr[1]; |
|
34439 |
|
34440 lCb1 -= 128; |
|
34441 lCr1 -= 128; |
|
34442 |
|
34443 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
34444 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
34445 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
34446 |
|
34447 /*First Pixel*/ |
|
34448 lY1 = lYuyvPtr[2]; |
|
34449 lY1 -= 16; |
|
34450 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
34451 |
|
34452 /*R component*/ |
|
34453 lTemp = (lY1 + lTemp1); |
|
34454 if (lTemp < 0) |
|
34455 lTemp = 0; |
|
34456 if (lTemp > 255) |
|
34457 lTemp = 255; |
|
34458 lRGBFramePtr[0] = (uint8) lTemp; |
|
34459 |
|
34460 /*G component*/ |
|
34461 lTemp = (lY1 - lTemp2); |
|
34462 if (lTemp < 0) |
|
34463 lTemp = 0; |
|
34464 if (lTemp > 255) |
|
34465 lTemp = 255; |
|
34466 lRGBFramePtr[1] = (uint8) lTemp; |
|
34467 |
|
34468 /*B component*/ |
|
34469 lTemp = (lY1 + lTemp3); |
|
34470 if (lTemp < 0) |
|
34471 lTemp = 0; |
|
34472 if (lTemp > 255) |
|
34473 lTemp = 255; |
|
34474 |
|
34475 lRGBFramePtr[2] = (uint8) lTemp; |
|
34476 |
|
34477 /*Second Pixel*/ |
|
34478 lY1 = lYuyvPtr[0]; |
|
34479 lY1 -= 16; |
|
34480 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
34481 |
|
34482 /*R component*/ |
|
34483 lTemp = (lY1 + lTemp1); |
|
34484 if (lTemp < 0) |
|
34485 lTemp = 0; |
|
34486 if (lTemp > 255) |
|
34487 lTemp = 255; |
|
34488 lRGBFramePtr[3] = (uint8) lTemp; |
|
34489 |
|
34490 /*G component*/ |
|
34491 lTemp = (lY1 - lTemp2); |
|
34492 if (lTemp < 0) |
|
34493 lTemp = 0; |
|
34494 if (lTemp > 255) |
|
34495 lTemp = 255; |
|
34496 lRGBFramePtr[4] = (uint8) lTemp; |
|
34497 |
|
34498 /*B component*/ |
|
34499 lTemp = (lY1 + lTemp3); |
|
34500 if (lTemp < 0) |
|
34501 lTemp = 0; |
|
34502 if (lTemp > 255) |
|
34503 lTemp = 255; |
|
34504 lRGBFramePtr[5] = (uint8) lTemp; |
|
34505 |
|
34506 lYuyvPtr += 4; |
|
34507 lRGBFramePtr += 6; |
|
34508 |
|
34509 if(extraCol) |
|
34510 { |
|
34511 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
34512 lRGBFramePtr++; |
|
34513 |
|
34514 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
34515 lRGBFramePtr++; |
|
34516 |
|
34517 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
34518 lRGBFramePtr++; |
|
34519 } |
|
34520 |
|
34521 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
34522 lRGBFramePtr += (wndWidth - lTempWidth); |
|
34523 } |
|
34524 |
|
34525 if(extraRow) |
|
34526 { |
|
34527 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
34528 for(j = 0; j < lWidth * 3; j += 2) |
|
34529 { |
|
34530 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34531 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34532 } |
|
34533 if(extraCol) |
|
34534 { |
|
34535 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34536 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34537 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34538 } |
|
34539 } |
|
34540 return; |
|
34541 } |
|
34542 |
|
34543 /* |
|
34544 ****************************************************************************** |
|
34545 Name : sEmz_VDec_YUV422LEChr1toColor16M_601_5_RR |
|
34546 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to RGB888 Interleaved format. |
|
34547 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
34548 uint8 *dstImage : Pointer to rgb data (o/p). |
|
34549 tWndParam *srcWindow : Pointer to structure containing source window |
|
34550 parameters like xOffset,yOffset,cropWidth, |
|
34551 cropHeight. (i/p) |
|
34552 tWndParam *dstWindow : Pointer to structure containing destination window |
|
34553 parameters like xOffset,yOffset,windWidth, |
|
34554 windHeight. (i/p) |
|
34555 Return Value : void |
|
34556 ****************************************************************************** |
|
34557 */ |
|
34558 |
|
34559 void sEmz_VDec_YUV422LEChr1toColor16M_601_5_RR |
|
34560 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
34561 tWndParam* srcWindow, tWndParam* dstWindow) |
|
34562 { |
|
34563 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
34564 uint8 *lYuyvPtr; |
|
34565 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
34566 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
34567 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
34568 int32 i, j, extraCol, extraRow; |
|
34569 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
34570 cropWidth,cropHeight,wndWidth,wndHeight; |
|
34571 |
|
34572 srcXOffset = srcWindow->xOffset; |
|
34573 srcYOffset = srcWindow->yOffset; |
|
34574 cropWidth = srcWindow->wndWidth; |
|
34575 cropHeight = srcWindow->wndHeight; |
|
34576 |
|
34577 |
|
34578 dstXOffset = dstWindow->xOffset; |
|
34579 dstYOffset = dstWindow->yOffset; |
|
34580 wndWidth = dstWindow->wndWidth; |
|
34581 wndHeight = dstWindow->wndHeight; |
|
34582 |
|
34583 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
34584 { |
|
34585 lWidth = cropWidth; |
|
34586 } |
|
34587 else |
|
34588 { |
|
34589 lWidth = srcImage->width - srcXOffset; |
|
34590 } |
|
34591 |
|
34592 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
34593 { |
|
34594 lHeight = cropHeight; |
|
34595 } |
|
34596 else |
|
34597 { |
|
34598 lHeight = srcImage->height - srcYOffset; |
|
34599 } |
|
34600 |
|
34601 if (lWidth > (wndWidth - dstXOffset)) |
|
34602 { |
|
34603 lWidth = wndWidth - dstXOffset; |
|
34604 } |
|
34605 |
|
34606 if (lHeight > (wndHeight - dstYOffset)) |
|
34607 { |
|
34608 lHeight = wndHeight - dstYOffset; |
|
34609 } |
|
34610 |
|
34611 extraCol = lWidth & 0x01; |
|
34612 extraRow = lHeight & 0x01; |
|
34613 |
|
34614 lTempWidth = lWidth * 3; |
|
34615 lWidth = (lWidth >> 1) << 1; |
|
34616 lHeight = (lHeight >> 1) << 1; |
|
34617 |
|
34618 dstXOffset *= 3; |
|
34619 wndWidth *= 3; |
|
34620 |
|
34621 lLumWidth = (srcImage->width >> 1) << 1 ; |
|
34622 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
34623 |
|
34624 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
34625 |
|
34626 for(i = 0; i < lHeight; i++) |
|
34627 { |
|
34628 for(j = 0; j < (lWidth - 2); j += 2) |
|
34629 { |
|
34630 lCb1 = lYuyvPtr[3]; |
|
34631 lCr1 = lYuyvPtr[1]; |
|
34632 |
|
34633 lCb2 = lYuyvPtr[7]; |
|
34634 lCr2 = lYuyvPtr[5]; |
|
34635 |
|
34636 lCr2 = (lCr1 + lCr2) >> 1; |
|
34637 lCb2 = (lCb1 + lCb2) >> 1; |
|
34638 |
|
34639 lCb1 -= 128; |
|
34640 lCr1 -= 128; |
|
34641 |
|
34642 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
34643 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
34644 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
34645 |
|
34646 /*First Pixel*/ |
|
34647 lY1 = lYuyvPtr[2]; |
|
34648 lY1 -= 16; |
|
34649 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
34650 |
|
34651 /*R component*/ |
|
34652 lTemp = (lY1 + lTemp1); |
|
34653 if (lTemp < 0) |
|
34654 lTemp = 0; |
|
34655 if (lTemp > 255) |
|
34656 lTemp = 255; |
|
34657 lRGBFramePtr[0] = (uint8) lTemp; |
|
34658 |
|
34659 /*G component*/ |
|
34660 lTemp = (lY1 - lTemp2); |
|
34661 if (lTemp < 0) |
|
34662 lTemp = 0; |
|
34663 if (lTemp > 255) |
|
34664 lTemp = 255; |
|
34665 lRGBFramePtr[1] = (uint8) lTemp; |
|
34666 |
|
34667 /*B component*/ |
|
34668 lTemp = (lY1 + lTemp3); |
|
34669 if (lTemp < 0) |
|
34670 lTemp = 0; |
|
34671 if (lTemp > 255) |
|
34672 lTemp = 255; |
|
34673 |
|
34674 lRGBFramePtr[2] = (uint8) lTemp; |
|
34675 |
|
34676 lCb2 -= 128; |
|
34677 lCr2 -= 128; |
|
34678 |
|
34679 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
34680 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
34681 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
34682 |
|
34683 /*Second Pixel*/ |
|
34684 lY1 = lYuyvPtr[0]; |
|
34685 lY1 -= 16; |
|
34686 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
34687 |
|
34688 /*R component*/ |
|
34689 lTemp = (lY1 + lTemp1); |
|
34690 if (lTemp < 0) |
|
34691 lTemp = 0; |
|
34692 if (lTemp > 255) |
|
34693 lTemp = 255; |
|
34694 lRGBFramePtr[3] = (uint8) lTemp; |
|
34695 |
|
34696 /*G component*/ |
|
34697 lTemp = (lY1 - lTemp2); |
|
34698 if (lTemp < 0) |
|
34699 lTemp = 0; |
|
34700 if (lTemp > 255) |
|
34701 lTemp = 255; |
|
34702 lRGBFramePtr[4] = (uint8) lTemp; |
|
34703 |
|
34704 /*B component*/ |
|
34705 lTemp = (lY1 + lTemp3); |
|
34706 if (lTemp < 0) |
|
34707 lTemp = 0; |
|
34708 if (lTemp > 255) |
|
34709 lTemp = 255; |
|
34710 lRGBFramePtr[5] = (uint8) lTemp; |
|
34711 |
|
34712 lYuyvPtr += 4; |
|
34713 lRGBFramePtr += 6; |
|
34714 } |
|
34715 |
|
34716 lCb1 = lYuyvPtr[3]; |
|
34717 lCr1 = lYuyvPtr[1]; |
|
34718 |
|
34719 lCb1 -= 128; |
|
34720 lCr1 -= 128; |
|
34721 |
|
34722 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
34723 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
34724 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
34725 |
|
34726 /*First Pixel*/ |
|
34727 lY1 = lYuyvPtr[2]; |
|
34728 lY1 -= 16; |
|
34729 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
34730 |
|
34731 /*R component*/ |
|
34732 lTemp = (lY1 + lTemp1); |
|
34733 if (lTemp < 0) |
|
34734 lTemp = 0; |
|
34735 if (lTemp > 255) |
|
34736 lTemp = 255; |
|
34737 lRGBFramePtr[0] = (uint8) lTemp; |
|
34738 |
|
34739 /*G component*/ |
|
34740 lTemp = (lY1 - lTemp2); |
|
34741 if (lTemp < 0) |
|
34742 lTemp = 0; |
|
34743 if (lTemp > 255) |
|
34744 lTemp = 255; |
|
34745 lRGBFramePtr[1] = (uint8) lTemp; |
|
34746 |
|
34747 /*B component*/ |
|
34748 lTemp = (lY1 + lTemp3); |
|
34749 if (lTemp < 0) |
|
34750 lTemp = 0; |
|
34751 if (lTemp > 255) |
|
34752 lTemp = 255; |
|
34753 |
|
34754 lRGBFramePtr[2] = (uint8) lTemp; |
|
34755 |
|
34756 /*Second Pixel*/ |
|
34757 lY1 = lYuyvPtr[0]; |
|
34758 lY1 -= 16; |
|
34759 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
34760 |
|
34761 /*R component*/ |
|
34762 lTemp = (lY1 + lTemp1); |
|
34763 if (lTemp < 0) |
|
34764 lTemp = 0; |
|
34765 if (lTemp > 255) |
|
34766 lTemp = 255; |
|
34767 lRGBFramePtr[3] = (uint8) lTemp; |
|
34768 |
|
34769 /*G component*/ |
|
34770 lTemp = (lY1 - lTemp2); |
|
34771 if (lTemp < 0) |
|
34772 lTemp = 0; |
|
34773 if (lTemp > 255) |
|
34774 lTemp = 255; |
|
34775 lRGBFramePtr[4] = (uint8) lTemp; |
|
34776 |
|
34777 /*B component*/ |
|
34778 lTemp = (lY1 + lTemp3); |
|
34779 if (lTemp < 0) |
|
34780 lTemp = 0; |
|
34781 if (lTemp > 255) |
|
34782 lTemp = 255; |
|
34783 lRGBFramePtr[5] = (uint8) lTemp; |
|
34784 |
|
34785 lYuyvPtr += 4; |
|
34786 lRGBFramePtr += 6; |
|
34787 |
|
34788 if(extraCol) |
|
34789 { |
|
34790 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
34791 lRGBFramePtr++; |
|
34792 |
|
34793 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
34794 lRGBFramePtr++; |
|
34795 |
|
34796 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
34797 lRGBFramePtr++; |
|
34798 } |
|
34799 |
|
34800 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
34801 lRGBFramePtr += (wndWidth - lTempWidth); |
|
34802 } |
|
34803 |
|
34804 if(extraRow) |
|
34805 { |
|
34806 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
34807 for(j = 0; j < lWidth * 3; j += 2) |
|
34808 { |
|
34809 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34810 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34811 } |
|
34812 if(extraCol) |
|
34813 { |
|
34814 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34815 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34816 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
34817 } |
|
34818 } |
|
34819 return; |
|
34820 } |
|
34821 |
|
34822 |
|
34823 /* |
|
34824 ****************************************************************************** |
|
34825 Name : sEmz_VDec_YUV422LEChr1toColor4k_Ordered_709_FR |
|
34826 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
34827 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
34828 uint8 *dstImage : Pointer to rgb data (o/p). |
|
34829 tWndParam *srcWindow : Pointer to structure containing source window |
|
34830 parameters like xOffset,yOffset,cropWidth, |
|
34831 cropHeight. (i/p) |
|
34832 tWndParam *dstWindow : Pointer to structure containing destination window |
|
34833 parameters like xOffset,yOffset,windWidth, |
|
34834 windHeight. (i/p) |
|
34835 Return Value : void |
|
34836 ****************************************************************************** |
|
34837 */ |
|
34838 |
|
34839 void sEmz_VDec_YUV422LEChr1toColor4k_Ordered_709_FR |
|
34840 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
34841 tWndParam* srcWindow, tWndParam* dstWindow) |
|
34842 { |
|
34843 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
34844 uint8 *lYuyvPtr; |
|
34845 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
34846 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
34847 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
34848 int32 i, j, extraCol, extraRow; |
|
34849 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
34850 cropWidth,cropHeight,wndWidth,wndHeight; |
|
34851 |
|
34852 srcXOffset = srcWindow->xOffset; |
|
34853 srcYOffset = srcWindow->yOffset; |
|
34854 cropWidth = srcWindow->wndWidth; |
|
34855 cropHeight = srcWindow->wndHeight; |
|
34856 |
|
34857 dstXOffset = dstWindow->xOffset; |
|
34858 dstYOffset = dstWindow->yOffset; |
|
34859 wndWidth = dstWindow->wndWidth; |
|
34860 wndHeight = dstWindow->wndHeight; |
|
34861 |
|
34862 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
34863 { |
|
34864 lWidth = cropWidth; |
|
34865 } |
|
34866 else |
|
34867 { |
|
34868 lWidth = srcImage->width - srcXOffset; |
|
34869 } |
|
34870 |
|
34871 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
34872 { |
|
34873 lHeight = cropHeight; |
|
34874 } |
|
34875 else |
|
34876 { |
|
34877 lHeight = srcImage->height - srcYOffset; |
|
34878 } |
|
34879 |
|
34880 if (lWidth > (wndWidth - dstXOffset)) |
|
34881 { |
|
34882 lWidth = wndWidth - dstXOffset; |
|
34883 } |
|
34884 |
|
34885 if (lHeight > (wndHeight - dstYOffset)) |
|
34886 { |
|
34887 lHeight = wndHeight - dstYOffset; |
|
34888 } |
|
34889 |
|
34890 extraCol = lWidth & 0x01; |
|
34891 extraRow = lHeight & 0x01; |
|
34892 |
|
34893 lTempWidth = lWidth; |
|
34894 lWidth = (lWidth >> 1) << 1; |
|
34895 lHeight = (lHeight >> 1) << 1; |
|
34896 |
|
34897 lLumWidth = (srcImage->width >> 1) << 1; |
|
34898 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
34899 |
|
34900 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
34901 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
34902 |
|
34903 lLumWidth <<= 1; |
|
34904 |
|
34905 for(i = 0; i < lHeight; i += 2) |
|
34906 { |
|
34907 for(j = 0; j < (lWidth - 2); j += 2) |
|
34908 { |
|
34909 lCb1 = lYuyvPtr[3]; |
|
34910 lCr1 = lYuyvPtr[1]; |
|
34911 |
|
34912 lCb2 = lYuyvPtr[7]; |
|
34913 lCr2 = lYuyvPtr[5]; |
|
34914 |
|
34915 lCr2 = (lCr1 + lCr2) >> 1; |
|
34916 lCb2 = (lCb1 + lCb2) >> 1; |
|
34917 |
|
34918 /*First Pixel*/ |
|
34919 lCr1 -= 128; |
|
34920 lCb1 -= 128; |
|
34921 |
|
34922 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
34923 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
34924 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
34925 |
|
34926 lY1 = lYuyvPtr[2]; |
|
34927 |
|
34928 /*B component*/ |
|
34929 lTemp = lY1 + lTemp3; |
|
34930 if (lTemp < 0) |
|
34931 lTemp = 0; |
|
34932 if (lTemp > 255) |
|
34933 lTemp = 255; |
|
34934 lTemp4 = (lTemp >> 4); |
|
34935 |
|
34936 /*G component*/ |
|
34937 lTemp = lY1 - lTemp2 + 15; |
|
34938 if (lTemp < 0) |
|
34939 lTemp = 0; |
|
34940 if (lTemp > 255) |
|
34941 lTemp = 255; |
|
34942 lTemp4 |= (lTemp >> 4) << 4; |
|
34943 |
|
34944 /*R component*/ |
|
34945 lTemp = lY1 + lTemp1 + 5; |
|
34946 if (lTemp < 0) |
|
34947 lTemp = 0; |
|
34948 if (lTemp > 255) |
|
34949 lTemp = 255; |
|
34950 lTemp4 |= (lTemp >> 4) << 8; |
|
34951 |
|
34952 lRGBFramePtr[0] = (uint16)lTemp4; |
|
34953 |
|
34954 /*Second Pixel*/ |
|
34955 lCr2 -= 128; |
|
34956 lCb2 -= 128; |
|
34957 |
|
34958 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
34959 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
34960 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
34961 |
|
34962 lY1 = lYuyvPtr[0]; |
|
34963 |
|
34964 /*B component*/ |
|
34965 lTemp = lY1 + lTemp3 + 10; |
|
34966 if (lTemp < 0) |
|
34967 lTemp = 0; |
|
34968 if (lTemp > 255) |
|
34969 lTemp = 255; |
|
34970 lTemp4 = (lTemp >> 4); |
|
34971 |
|
34972 /*G component*/ |
|
34973 lTemp = lY1 - lTemp2; |
|
34974 if (lTemp < 0) |
|
34975 lTemp = 0; |
|
34976 if (lTemp > 255) |
|
34977 lTemp = 255; |
|
34978 lTemp4 |= (lTemp >> 4) << 4; |
|
34979 |
|
34980 /*R component*/ |
|
34981 lTemp = lY1 + lTemp1 + 15; |
|
34982 if (lTemp < 0) |
|
34983 lTemp = 0; |
|
34984 if (lTemp > 255) |
|
34985 lTemp = 255; |
|
34986 lTemp4 |= (lTemp >> 4) << 8; |
|
34987 |
|
34988 lRGBFramePtr[1] = (uint16)lTemp4; |
|
34989 |
|
34990 |
|
34991 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
34992 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
34993 |
|
34994 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
34995 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
34996 |
|
34997 lCr2 = (lCr1 + lCr2) >> 1; |
|
34998 lCb2 = (lCb1 + lCb2) >> 1; |
|
34999 |
|
35000 /*Third Pixel*/ |
|
35001 lCr1 -= 128; |
|
35002 lCb1 -= 128; |
|
35003 |
|
35004 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
35005 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
35006 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
35007 |
|
35008 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
35009 |
|
35010 /*B component*/ |
|
35011 lTemp = lY1 + lTemp3 + 15; |
|
35012 if (lTemp < 0) |
|
35013 lTemp = 0; |
|
35014 if (lTemp > 255) |
|
35015 lTemp = 255; |
|
35016 lTemp4 = (lTemp >> 4); |
|
35017 |
|
35018 /*G component*/ |
|
35019 lTemp = lY1 - lTemp2 + 5; |
|
35020 if (lTemp < 0) |
|
35021 lTemp = 0; |
|
35022 if (lTemp > 255) |
|
35023 lTemp = 255; |
|
35024 lTemp4 |= (lTemp >> 4) << 4; |
|
35025 |
|
35026 /*R component*/ |
|
35027 lTemp = lY1 + lTemp1 + 10; |
|
35028 if (lTemp < 0) |
|
35029 lTemp = 0; |
|
35030 if (lTemp > 255) |
|
35031 lTemp = 255; |
|
35032 lTemp4 |= (lTemp >> 4) << 8; |
|
35033 |
|
35034 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
35035 |
|
35036 /*Fourth Pixel*/ |
|
35037 lCr2 -= 128; |
|
35038 lCb2 -= 128; |
|
35039 |
|
35040 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
35041 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
35042 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
35043 |
|
35044 lY1 = lYuyvPtr[lLumWidth]; |
|
35045 |
|
35046 /*B component*/ |
|
35047 lTemp = lY1 + lTemp3 + 5; |
|
35048 if (lTemp < 0) |
|
35049 lTemp = 0; |
|
35050 if (lTemp > 255) |
|
35051 lTemp = 255; |
|
35052 lTemp4 = (lTemp >> 4); |
|
35053 |
|
35054 /*G component*/ |
|
35055 lTemp = lY1 - lTemp2 + 10; |
|
35056 if (lTemp < 0) |
|
35057 lTemp = 0; |
|
35058 if (lTemp > 255) |
|
35059 lTemp = 255; |
|
35060 lTemp4 |= (lTemp >> 4) << 4; |
|
35061 |
|
35062 /*R component*/ |
|
35063 lTemp = lY1 + lTemp1; |
|
35064 if (lTemp < 0) |
|
35065 lTemp = 0; |
|
35066 if (lTemp > 255) |
|
35067 lTemp = 255; |
|
35068 lTemp4 |= (lTemp >> 4) << 8; |
|
35069 |
|
35070 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
35071 |
|
35072 lYuyvPtr += 4; |
|
35073 lRGBFramePtr += 2; |
|
35074 lRGBFramePtr1 += 2; |
|
35075 } |
|
35076 |
|
35077 |
|
35078 lCb1 = lYuyvPtr[3]; |
|
35079 lCr1 = lYuyvPtr[1]; |
|
35080 |
|
35081 lCr1 -= 128; |
|
35082 lCb1 -= 128; |
|
35083 |
|
35084 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
35085 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
35086 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
35087 |
|
35088 /*First Pixel*/ |
|
35089 lY1 = lYuyvPtr[2]; |
|
35090 |
|
35091 /*B component*/ |
|
35092 lTemp = lY1 + lTemp3; |
|
35093 if (lTemp < 0) |
|
35094 lTemp = 0; |
|
35095 if (lTemp > 255) |
|
35096 lTemp = 255; |
|
35097 lTemp4 = (lTemp >> 4); |
|
35098 |
|
35099 /*G component*/ |
|
35100 lTemp = lY1 - lTemp2 + 15; |
|
35101 if (lTemp < 0) |
|
35102 lTemp = 0; |
|
35103 if (lTemp > 255) |
|
35104 lTemp = 255; |
|
35105 lTemp4 |= (lTemp >> 4) << 4; |
|
35106 |
|
35107 /*R component*/ |
|
35108 lTemp = lY1 + lTemp1 + 5; |
|
35109 if (lTemp < 0) |
|
35110 lTemp = 0; |
|
35111 if (lTemp > 255) |
|
35112 lTemp = 255; |
|
35113 lTemp4 |= (lTemp >> 4) << 8; |
|
35114 |
|
35115 lRGBFramePtr[0] = (uint16)lTemp4; |
|
35116 |
|
35117 /*Second Pixel*/ |
|
35118 lY1 = lYuyvPtr[0]; |
|
35119 |
|
35120 /*B component*/ |
|
35121 lTemp = lY1 + lTemp3 + 10; |
|
35122 if (lTemp < 0) |
|
35123 lTemp = 0; |
|
35124 if (lTemp > 255) |
|
35125 lTemp = 255; |
|
35126 lTemp4 = (lTemp >> 4); |
|
35127 |
|
35128 /*G component*/ |
|
35129 lTemp = lY1 - lTemp2; |
|
35130 if (lTemp < 0) |
|
35131 lTemp = 0; |
|
35132 if (lTemp > 255) |
|
35133 lTemp = 255; |
|
35134 lTemp4 |= (lTemp >> 4) << 4; |
|
35135 |
|
35136 /*R component*/ |
|
35137 lTemp = lY1 + lTemp1 + 15; |
|
35138 if (lTemp < 0) |
|
35139 lTemp = 0; |
|
35140 if (lTemp > 255) |
|
35141 lTemp = 255; |
|
35142 lTemp4 |= (lTemp >> 4) << 8; |
|
35143 |
|
35144 lRGBFramePtr[1] = (uint16)lTemp4; |
|
35145 |
|
35146 |
|
35147 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
35148 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
35149 |
|
35150 lCr1 -= 128; |
|
35151 lCb1 -= 128; |
|
35152 |
|
35153 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
35154 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
35155 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
35156 |
|
35157 /*Third Pixel*/ |
|
35158 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
35159 |
|
35160 /*B component*/ |
|
35161 lTemp = lY1 + lTemp3 + 15; |
|
35162 if (lTemp < 0) |
|
35163 lTemp = 0; |
|
35164 if (lTemp > 255) |
|
35165 lTemp = 255; |
|
35166 lTemp4 = (lTemp >> 4); |
|
35167 |
|
35168 /*G component*/ |
|
35169 lTemp = lY1 - lTemp2 + 5; |
|
35170 if (lTemp < 0) |
|
35171 lTemp = 0; |
|
35172 if (lTemp > 255) |
|
35173 lTemp = 255; |
|
35174 lTemp4 |= (lTemp >> 4) << 4; |
|
35175 |
|
35176 /*R component*/ |
|
35177 lTemp = lY1 + lTemp1 + 10; |
|
35178 if (lTemp < 0) |
|
35179 lTemp = 0; |
|
35180 if (lTemp > 255) |
|
35181 lTemp = 255; |
|
35182 lTemp4 |= (lTemp >> 4) << 8; |
|
35183 |
|
35184 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
35185 |
|
35186 /*Fourth Pixel*/ |
|
35187 lY1 = lYuyvPtr[lLumWidth]; |
|
35188 |
|
35189 /*B component*/ |
|
35190 lTemp = lY1 + lTemp3 + 5; |
|
35191 if (lTemp < 0) |
|
35192 lTemp = 0; |
|
35193 if (lTemp > 255) |
|
35194 lTemp = 255; |
|
35195 lTemp4 = (lTemp >> 4); |
|
35196 |
|
35197 /*G component*/ |
|
35198 lTemp = lY1 - lTemp2 + 10; |
|
35199 if (lTemp < 0) |
|
35200 lTemp = 0; |
|
35201 if (lTemp > 255) |
|
35202 lTemp = 255; |
|
35203 lTemp4 |= (lTemp >> 4) << 4; |
|
35204 |
|
35205 /*R component*/ |
|
35206 lTemp = lY1 + lTemp1; |
|
35207 if (lTemp < 0) |
|
35208 lTemp = 0; |
|
35209 if (lTemp > 255) |
|
35210 lTemp = 255; |
|
35211 lTemp4 |= (lTemp >> 4) << 8; |
|
35212 |
|
35213 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
35214 |
|
35215 lYuyvPtr += 4; |
|
35216 lRGBFramePtr += 2; |
|
35217 lRGBFramePtr1 += 2; |
|
35218 |
|
35219 |
|
35220 if(extraCol) |
|
35221 { |
|
35222 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
35223 lRGBFramePtr++; |
|
35224 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
35225 lRGBFramePtr1++; |
|
35226 } |
|
35227 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
35228 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
35229 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
35230 } |
|
35231 |
|
35232 if(extraRow) |
|
35233 { |
|
35234 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
35235 for(j = 0; j < lWidth; j += 2) |
|
35236 { |
|
35237 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
35238 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
35239 } |
|
35240 if(extraCol) |
|
35241 { |
|
35242 *lRGBFramePtr = *lRGBFramePtr1; |
|
35243 } |
|
35244 } |
|
35245 return; |
|
35246 } |
|
35247 |
|
35248 /* |
|
35249 ****************************************************************************** |
|
35250 Name : sEmz_VDec_YUV422LEChr1toColor4k_Ordered_601_5_FR |
|
35251 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
35252 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
35253 uint8 *dstImage : Pointer to rgb data (o/p). |
|
35254 tWndParam *srcWindow : Pointer to structure containing source window |
|
35255 parameters like xOffset,yOffset,cropWidth, |
|
35256 cropHeight. (i/p) |
|
35257 tWndParam *dstWindow : Pointer to structure containing destination window |
|
35258 parameters like xOffset,yOffset,windWidth, |
|
35259 windHeight. (i/p) |
|
35260 Return Value : void |
|
35261 ****************************************************************************** |
|
35262 */ |
|
35263 |
|
35264 void sEmz_VDec_YUV422LEChr1toColor4k_Ordered_601_5_FR |
|
35265 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
35266 tWndParam* srcWindow, tWndParam* dstWindow) |
|
35267 { |
|
35268 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
35269 uint8 *lYuyvPtr; |
|
35270 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
35271 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
35272 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
35273 int32 i, j, extraCol, extraRow; |
|
35274 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
35275 cropWidth,cropHeight,wndWidth,wndHeight; |
|
35276 |
|
35277 srcXOffset = srcWindow->xOffset; |
|
35278 srcYOffset = srcWindow->yOffset; |
|
35279 cropWidth = srcWindow->wndWidth; |
|
35280 cropHeight = srcWindow->wndHeight; |
|
35281 |
|
35282 dstXOffset = dstWindow->xOffset; |
|
35283 dstYOffset = dstWindow->yOffset; |
|
35284 wndWidth = dstWindow->wndWidth; |
|
35285 wndHeight = dstWindow->wndHeight; |
|
35286 |
|
35287 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
35288 { |
|
35289 lWidth = cropWidth; |
|
35290 } |
|
35291 else |
|
35292 { |
|
35293 lWidth = srcImage->width - srcXOffset; |
|
35294 } |
|
35295 |
|
35296 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
35297 { |
|
35298 lHeight = cropHeight; |
|
35299 } |
|
35300 else |
|
35301 { |
|
35302 lHeight = srcImage->height - srcYOffset; |
|
35303 } |
|
35304 |
|
35305 if (lWidth > (wndWidth - dstXOffset)) |
|
35306 { |
|
35307 lWidth = wndWidth - dstXOffset; |
|
35308 } |
|
35309 |
|
35310 if (lHeight > (wndHeight - dstYOffset)) |
|
35311 { |
|
35312 lHeight = wndHeight - dstYOffset; |
|
35313 } |
|
35314 |
|
35315 extraCol = lWidth & 0x01; |
|
35316 extraRow = lHeight & 0x01; |
|
35317 |
|
35318 lTempWidth = lWidth; |
|
35319 lWidth = (lWidth >> 1) << 1; |
|
35320 lHeight = (lHeight >> 1) << 1; |
|
35321 |
|
35322 lLumWidth = (srcImage->width >> 1) << 1; |
|
35323 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
35324 |
|
35325 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
35326 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
35327 |
|
35328 lLumWidth <<= 1; |
|
35329 |
|
35330 for(i = 0; i < lHeight; i += 2) |
|
35331 { |
|
35332 for(j = 0; j < (lWidth - 2); j += 2) |
|
35333 { |
|
35334 lCb1 = lYuyvPtr[3]; |
|
35335 lCr1 = lYuyvPtr[1]; |
|
35336 |
|
35337 lCb2 = lYuyvPtr[7]; |
|
35338 lCr2 = lYuyvPtr[5]; |
|
35339 |
|
35340 lCr2 = (lCr1 + lCr2) >> 1; |
|
35341 lCb2 = (lCb1 + lCb2) >> 1; |
|
35342 |
|
35343 /*First Pixel*/ |
|
35344 lCr1 -= 128; |
|
35345 lCb1 -= 128; |
|
35346 |
|
35347 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
35348 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
35349 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
35350 |
|
35351 lY1 = lYuyvPtr[2]; |
|
35352 |
|
35353 /*B component*/ |
|
35354 lTemp = lY1 + lTemp3; |
|
35355 if (lTemp < 0) |
|
35356 lTemp = 0; |
|
35357 if (lTemp > 255) |
|
35358 lTemp = 255; |
|
35359 lTemp4 = (lTemp >> 4); |
|
35360 |
|
35361 /*G component*/ |
|
35362 lTemp = lY1 - lTemp2 + 15; |
|
35363 if (lTemp < 0) |
|
35364 lTemp = 0; |
|
35365 if (lTemp > 255) |
|
35366 lTemp = 255; |
|
35367 lTemp4 |= (lTemp >> 4) << 4; |
|
35368 |
|
35369 /*R component*/ |
|
35370 lTemp = lY1 + lTemp1 + 5; |
|
35371 if (lTemp < 0) |
|
35372 lTemp = 0; |
|
35373 if (lTemp > 255) |
|
35374 lTemp = 255; |
|
35375 lTemp4 |= (lTemp >> 4) << 8; |
|
35376 |
|
35377 lRGBFramePtr[0] = (uint16)lTemp4; |
|
35378 |
|
35379 /*Second Pixel*/ |
|
35380 lCr2 -= 128; |
|
35381 lCb2 -= 128; |
|
35382 |
|
35383 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
35384 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
35385 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
35386 |
|
35387 lY1 = lYuyvPtr[0]; |
|
35388 |
|
35389 /*B component*/ |
|
35390 lTemp = lY1 + lTemp3 + 10; |
|
35391 if (lTemp < 0) |
|
35392 lTemp = 0; |
|
35393 if (lTemp > 255) |
|
35394 lTemp = 255; |
|
35395 lTemp4 = (lTemp >> 4); |
|
35396 |
|
35397 /*G component*/ |
|
35398 lTemp = lY1 - lTemp2; |
|
35399 if (lTemp < 0) |
|
35400 lTemp = 0; |
|
35401 if (lTemp > 255) |
|
35402 lTemp = 255; |
|
35403 lTemp4 |= (lTemp >> 4) << 4; |
|
35404 |
|
35405 /*R component*/ |
|
35406 lTemp = lY1 + lTemp1 + 15; |
|
35407 if (lTemp < 0) |
|
35408 lTemp = 0; |
|
35409 if (lTemp > 255) |
|
35410 lTemp = 255; |
|
35411 lTemp4 |= (lTemp >> 4) << 8; |
|
35412 |
|
35413 lRGBFramePtr[1] = (uint16)lTemp4; |
|
35414 |
|
35415 |
|
35416 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
35417 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
35418 |
|
35419 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
35420 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
35421 |
|
35422 lCr2 = (lCr1 + lCr2) >> 1; |
|
35423 lCb2 = (lCb1 + lCb2) >> 1; |
|
35424 |
|
35425 /*Third Pixel*/ |
|
35426 lCr1 -= 128; |
|
35427 lCb1 -= 128; |
|
35428 |
|
35429 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
35430 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
35431 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
35432 |
|
35433 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
35434 |
|
35435 /*B component*/ |
|
35436 lTemp = lY1 + lTemp3 + 15; |
|
35437 if (lTemp < 0) |
|
35438 lTemp = 0; |
|
35439 if (lTemp > 255) |
|
35440 lTemp = 255; |
|
35441 lTemp4 = (lTemp >> 4); |
|
35442 |
|
35443 /*G component*/ |
|
35444 lTemp = lY1 - lTemp2 + 5; |
|
35445 if (lTemp < 0) |
|
35446 lTemp = 0; |
|
35447 if (lTemp > 255) |
|
35448 lTemp = 255; |
|
35449 lTemp4 |= (lTemp >> 4) << 4; |
|
35450 |
|
35451 /*R component*/ |
|
35452 lTemp = lY1 + lTemp1 + 10; |
|
35453 if (lTemp < 0) |
|
35454 lTemp = 0; |
|
35455 if (lTemp > 255) |
|
35456 lTemp = 255; |
|
35457 lTemp4 |= (lTemp >> 4) << 8; |
|
35458 |
|
35459 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
35460 |
|
35461 /*Fourth Pixel*/ |
|
35462 lCr2 -= 128; |
|
35463 lCb2 -= 128; |
|
35464 |
|
35465 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
35466 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
35467 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
35468 |
|
35469 lY1 = lYuyvPtr[lLumWidth]; |
|
35470 |
|
35471 /*B component*/ |
|
35472 lTemp = lY1 + lTemp3 + 5; |
|
35473 if (lTemp < 0) |
|
35474 lTemp = 0; |
|
35475 if (lTemp > 255) |
|
35476 lTemp = 255; |
|
35477 lTemp4 = (lTemp >> 4); |
|
35478 |
|
35479 /*G component*/ |
|
35480 lTemp = lY1 - lTemp2 + 10; |
|
35481 if (lTemp < 0) |
|
35482 lTemp = 0; |
|
35483 if (lTemp > 255) |
|
35484 lTemp = 255; |
|
35485 lTemp4 |= (lTemp >> 4) << 4; |
|
35486 |
|
35487 /*R component*/ |
|
35488 lTemp = lY1 + lTemp1; |
|
35489 if (lTemp < 0) |
|
35490 lTemp = 0; |
|
35491 if (lTemp > 255) |
|
35492 lTemp = 255; |
|
35493 lTemp4 |= (lTemp >> 4) << 8; |
|
35494 |
|
35495 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
35496 |
|
35497 lYuyvPtr += 4; |
|
35498 lRGBFramePtr += 2; |
|
35499 lRGBFramePtr1 += 2; |
|
35500 } |
|
35501 |
|
35502 |
|
35503 lCb1 = lYuyvPtr[3]; |
|
35504 lCr1 = lYuyvPtr[1]; |
|
35505 |
|
35506 lCr1 -= 128; |
|
35507 lCb1 -= 128; |
|
35508 |
|
35509 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
35510 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
35511 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
35512 |
|
35513 /*First Pixel*/ |
|
35514 lY1 = lYuyvPtr[2]; |
|
35515 |
|
35516 /*B component*/ |
|
35517 lTemp = lY1 + lTemp3; |
|
35518 if (lTemp < 0) |
|
35519 lTemp = 0; |
|
35520 if (lTemp > 255) |
|
35521 lTemp = 255; |
|
35522 lTemp4 = (lTemp >> 4); |
|
35523 |
|
35524 /*G component*/ |
|
35525 lTemp = lY1 - lTemp2 + 15; |
|
35526 if (lTemp < 0) |
|
35527 lTemp = 0; |
|
35528 if (lTemp > 255) |
|
35529 lTemp = 255; |
|
35530 lTemp4 |= (lTemp >> 4) << 4; |
|
35531 |
|
35532 /*R component*/ |
|
35533 lTemp = lY1 + lTemp1 + 5; |
|
35534 if (lTemp < 0) |
|
35535 lTemp = 0; |
|
35536 if (lTemp > 255) |
|
35537 lTemp = 255; |
|
35538 lTemp4 |= (lTemp >> 4) << 8; |
|
35539 |
|
35540 lRGBFramePtr[0] = (uint16)lTemp4; |
|
35541 |
|
35542 /*Second Pixel*/ |
|
35543 lY1 = lYuyvPtr[0]; |
|
35544 |
|
35545 /*B component*/ |
|
35546 lTemp = lY1 + lTemp3 + 10; |
|
35547 if (lTemp < 0) |
|
35548 lTemp = 0; |
|
35549 if (lTemp > 255) |
|
35550 lTemp = 255; |
|
35551 lTemp4 = (lTemp >> 4); |
|
35552 |
|
35553 /*G component*/ |
|
35554 lTemp = lY1 - lTemp2; |
|
35555 if (lTemp < 0) |
|
35556 lTemp = 0; |
|
35557 if (lTemp > 255) |
|
35558 lTemp = 255; |
|
35559 lTemp4 |= (lTemp >> 4) << 4; |
|
35560 |
|
35561 /*R component*/ |
|
35562 lTemp = lY1 + lTemp1 + 15; |
|
35563 if (lTemp < 0) |
|
35564 lTemp = 0; |
|
35565 if (lTemp > 255) |
|
35566 lTemp = 255; |
|
35567 lTemp4 |= (lTemp >> 4) << 8; |
|
35568 |
|
35569 lRGBFramePtr[1] = (uint16)lTemp4; |
|
35570 |
|
35571 |
|
35572 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
35573 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
35574 |
|
35575 lCr1 -= 128; |
|
35576 lCb1 -= 128; |
|
35577 |
|
35578 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
35579 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
35580 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
35581 |
|
35582 /*Third Pixel*/ |
|
35583 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
35584 |
|
35585 /*B component*/ |
|
35586 lTemp = lY1 + lTemp3 + 15; |
|
35587 if (lTemp < 0) |
|
35588 lTemp = 0; |
|
35589 if (lTemp > 255) |
|
35590 lTemp = 255; |
|
35591 lTemp4 = (lTemp >> 4); |
|
35592 |
|
35593 /*G component*/ |
|
35594 lTemp = lY1 - lTemp2 + 5; |
|
35595 if (lTemp < 0) |
|
35596 lTemp = 0; |
|
35597 if (lTemp > 255) |
|
35598 lTemp = 255; |
|
35599 lTemp4 |= (lTemp >> 4) << 4; |
|
35600 |
|
35601 /*R component*/ |
|
35602 lTemp = lY1 + lTemp1 + 10; |
|
35603 if (lTemp < 0) |
|
35604 lTemp = 0; |
|
35605 if (lTemp > 255) |
|
35606 lTemp = 255; |
|
35607 lTemp4 |= (lTemp >> 4) << 8; |
|
35608 |
|
35609 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
35610 |
|
35611 /*Fourth Pixel*/ |
|
35612 lY1 = lYuyvPtr[lLumWidth]; |
|
35613 |
|
35614 /*B component*/ |
|
35615 lTemp = lY1 + lTemp3 + 5; |
|
35616 if (lTemp < 0) |
|
35617 lTemp = 0; |
|
35618 if (lTemp > 255) |
|
35619 lTemp = 255; |
|
35620 lTemp4 = (lTemp >> 4); |
|
35621 |
|
35622 /*G component*/ |
|
35623 lTemp = lY1 - lTemp2 + 10; |
|
35624 if (lTemp < 0) |
|
35625 lTemp = 0; |
|
35626 if (lTemp > 255) |
|
35627 lTemp = 255; |
|
35628 lTemp4 |= (lTemp >> 4) << 4; |
|
35629 |
|
35630 /*R component*/ |
|
35631 lTemp = lY1 + lTemp1; |
|
35632 if (lTemp < 0) |
|
35633 lTemp = 0; |
|
35634 if (lTemp > 255) |
|
35635 lTemp = 255; |
|
35636 lTemp4 |= (lTemp >> 4) << 8; |
|
35637 |
|
35638 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
35639 |
|
35640 lYuyvPtr += 4; |
|
35641 lRGBFramePtr += 2; |
|
35642 lRGBFramePtr1 += 2; |
|
35643 |
|
35644 |
|
35645 if(extraCol) |
|
35646 { |
|
35647 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
35648 lRGBFramePtr++; |
|
35649 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
35650 lRGBFramePtr1++; |
|
35651 } |
|
35652 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
35653 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
35654 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
35655 } |
|
35656 |
|
35657 if(extraRow) |
|
35658 { |
|
35659 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
35660 for(j = 0; j < lWidth; j += 2) |
|
35661 { |
|
35662 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
35663 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
35664 } |
|
35665 if(extraCol) |
|
35666 { |
|
35667 *lRGBFramePtr = *lRGBFramePtr1; |
|
35668 } |
|
35669 } |
|
35670 return; |
|
35671 } |
|
35672 |
|
35673 /* |
|
35674 ****************************************************************************** |
|
35675 Name : sEmz_VDec_YUV422LEChr1toColor4k_Ordered_709_RR |
|
35676 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
35677 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
35678 uint8 *dstImage : Pointer to rgb data (o/p). |
|
35679 tWndParam *srcWindow : Pointer to structure containing source window |
|
35680 parameters like xOffset,yOffset,cropWidth, |
|
35681 cropHeight. (i/p) |
|
35682 tWndParam *dstWindow : Pointer to structure containing destination window |
|
35683 parameters like xOffset,yOffset,windWidth, |
|
35684 windHeight. (i/p) |
|
35685 Return Value : void |
|
35686 ****************************************************************************** |
|
35687 */ |
|
35688 |
|
35689 void sEmz_VDec_YUV422LEChr1toColor4k_Ordered_709_RR |
|
35690 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
35691 tWndParam* srcWindow, tWndParam* dstWindow) |
|
35692 { |
|
35693 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
35694 uint8 *lYuyvPtr; |
|
35695 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
35696 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
35697 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
35698 int32 i, j, extraCol, extraRow; |
|
35699 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
35700 cropWidth,cropHeight,wndWidth,wndHeight; |
|
35701 |
|
35702 srcXOffset = srcWindow->xOffset; |
|
35703 srcYOffset = srcWindow->yOffset; |
|
35704 cropWidth = srcWindow->wndWidth; |
|
35705 cropHeight = srcWindow->wndHeight; |
|
35706 |
|
35707 dstXOffset = dstWindow->xOffset; |
|
35708 dstYOffset = dstWindow->yOffset; |
|
35709 wndWidth = dstWindow->wndWidth; |
|
35710 wndHeight = dstWindow->wndHeight; |
|
35711 |
|
35712 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
35713 { |
|
35714 lWidth = cropWidth; |
|
35715 } |
|
35716 else |
|
35717 { |
|
35718 lWidth = srcImage->width - srcXOffset; |
|
35719 } |
|
35720 |
|
35721 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
35722 { |
|
35723 lHeight = cropHeight; |
|
35724 } |
|
35725 else |
|
35726 { |
|
35727 lHeight = srcImage->height - srcYOffset; |
|
35728 } |
|
35729 |
|
35730 if (lWidth > (wndWidth - dstXOffset)) |
|
35731 { |
|
35732 lWidth = wndWidth - dstXOffset; |
|
35733 } |
|
35734 |
|
35735 if (lHeight > (wndHeight - dstYOffset)) |
|
35736 { |
|
35737 lHeight = wndHeight - dstYOffset; |
|
35738 } |
|
35739 |
|
35740 extraCol = lWidth & 0x01; |
|
35741 extraRow = lHeight & 0x01; |
|
35742 |
|
35743 lTempWidth = lWidth; |
|
35744 lWidth = (lWidth >> 1) << 1; |
|
35745 lHeight = (lHeight >> 1) << 1; |
|
35746 |
|
35747 lLumWidth = (srcImage->width >> 1) << 1; |
|
35748 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
35749 |
|
35750 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
35751 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
35752 |
|
35753 lLumWidth <<= 1; |
|
35754 |
|
35755 for(i = 0; i < lHeight; i += 2) |
|
35756 { |
|
35757 for(j = 0; j < (lWidth - 2); j += 2) |
|
35758 { |
|
35759 lCb1 = lYuyvPtr[3]; |
|
35760 lCr1 = lYuyvPtr[1]; |
|
35761 |
|
35762 lCb2 = lYuyvPtr[7]; |
|
35763 lCr2 = lYuyvPtr[5]; |
|
35764 |
|
35765 lCr2 = (lCr1 + lCr2) >> 1; |
|
35766 lCb2 = (lCb1 + lCb2) >> 1; |
|
35767 |
|
35768 /*First Pixel*/ |
|
35769 lCr1 -= 128; |
|
35770 lCb1 -= 128; |
|
35771 |
|
35772 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
35773 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
35774 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
35775 |
|
35776 lY1 = lYuyvPtr[2]; |
|
35777 lY1 -= 16; |
|
35778 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
35779 |
|
35780 /*B component*/ |
|
35781 lTemp = lY1 + lTemp3; |
|
35782 if (lTemp < 0) |
|
35783 lTemp = 0; |
|
35784 if (lTemp > 255) |
|
35785 lTemp = 255; |
|
35786 lTemp4 = (lTemp >> 4); |
|
35787 |
|
35788 /*G component*/ |
|
35789 lTemp = lY1 - lTemp2 + 15; |
|
35790 if (lTemp < 0) |
|
35791 lTemp = 0; |
|
35792 if (lTemp > 255) |
|
35793 lTemp = 255; |
|
35794 lTemp4 |= (lTemp >> 4) << 4; |
|
35795 |
|
35796 /*R component*/ |
|
35797 lTemp = lY1 + lTemp1 + 5; |
|
35798 if (lTemp < 0) |
|
35799 lTemp = 0; |
|
35800 if (lTemp > 255) |
|
35801 lTemp = 255; |
|
35802 lTemp4 |= (lTemp >> 4) << 8; |
|
35803 |
|
35804 lRGBFramePtr[0] = (uint16)lTemp4; |
|
35805 |
|
35806 /*Second Pixel*/ |
|
35807 lCr2 -= 128; |
|
35808 lCb2 -= 128; |
|
35809 |
|
35810 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
35811 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
35812 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
35813 |
|
35814 lY1 = lYuyvPtr[0]; |
|
35815 lY1 -= 16; |
|
35816 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
35817 |
|
35818 /*B component*/ |
|
35819 lTemp = lY1 + lTemp3 + 10; |
|
35820 if (lTemp < 0) |
|
35821 lTemp = 0; |
|
35822 if (lTemp > 255) |
|
35823 lTemp = 255; |
|
35824 lTemp4 = (lTemp >> 4); |
|
35825 |
|
35826 /*G component*/ |
|
35827 lTemp = lY1 - lTemp2; |
|
35828 if (lTemp < 0) |
|
35829 lTemp = 0; |
|
35830 if (lTemp > 255) |
|
35831 lTemp = 255; |
|
35832 lTemp4 |= (lTemp >> 4) << 4; |
|
35833 |
|
35834 /*R component*/ |
|
35835 lTemp = lY1 + lTemp1 + 15; |
|
35836 if (lTemp < 0) |
|
35837 lTemp = 0; |
|
35838 if (lTemp > 255) |
|
35839 lTemp = 255; |
|
35840 lTemp4 |= (lTemp >> 4) << 8; |
|
35841 |
|
35842 lRGBFramePtr[1] = (uint16)lTemp4; |
|
35843 |
|
35844 |
|
35845 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
35846 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
35847 |
|
35848 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
35849 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
35850 |
|
35851 lCr2 = (lCr1 + lCr2) >> 1; |
|
35852 lCb2 = (lCb1 + lCb2) >> 1; |
|
35853 |
|
35854 /*Third Pixel*/ |
|
35855 lCr1 -= 128; |
|
35856 lCb1 -= 128; |
|
35857 |
|
35858 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
35859 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
35860 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
35861 |
|
35862 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
35863 lY1 -= 16; |
|
35864 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
35865 |
|
35866 /*B component*/ |
|
35867 lTemp = lY1 + lTemp3 + 15; |
|
35868 if (lTemp < 0) |
|
35869 lTemp = 0; |
|
35870 if (lTemp > 255) |
|
35871 lTemp = 255; |
|
35872 lTemp4 = (lTemp >> 4); |
|
35873 |
|
35874 /*G component*/ |
|
35875 lTemp = lY1 - lTemp2 + 5; |
|
35876 if (lTemp < 0) |
|
35877 lTemp = 0; |
|
35878 if (lTemp > 255) |
|
35879 lTemp = 255; |
|
35880 lTemp4 |= (lTemp >> 4) << 4; |
|
35881 |
|
35882 /*R component*/ |
|
35883 lTemp = lY1 + lTemp1 + 10; |
|
35884 if (lTemp < 0) |
|
35885 lTemp = 0; |
|
35886 if (lTemp > 255) |
|
35887 lTemp = 255; |
|
35888 lTemp4 |= (lTemp >> 4) << 8; |
|
35889 |
|
35890 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
35891 |
|
35892 /*Fourth Pixel*/ |
|
35893 lCr2 -= 128; |
|
35894 lCb2 -= 128; |
|
35895 |
|
35896 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
35897 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
35898 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
35899 |
|
35900 lY1 = lYuyvPtr[lLumWidth]; |
|
35901 lY1 -= 16; |
|
35902 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
35903 |
|
35904 /*B component*/ |
|
35905 lTemp = lY1 + lTemp3 + 5; |
|
35906 if (lTemp < 0) |
|
35907 lTemp = 0; |
|
35908 if (lTemp > 255) |
|
35909 lTemp = 255; |
|
35910 lTemp4 = (lTemp >> 4); |
|
35911 |
|
35912 /*G component*/ |
|
35913 lTemp = lY1 - lTemp2 + 10; |
|
35914 if (lTemp < 0) |
|
35915 lTemp = 0; |
|
35916 if (lTemp > 255) |
|
35917 lTemp = 255; |
|
35918 lTemp4 |= (lTemp >> 4) << 4; |
|
35919 |
|
35920 /*R component*/ |
|
35921 lTemp = lY1 + lTemp1; |
|
35922 if (lTemp < 0) |
|
35923 lTemp = 0; |
|
35924 if (lTemp > 255) |
|
35925 lTemp = 255; |
|
35926 lTemp4 |= (lTemp >> 4) << 8; |
|
35927 |
|
35928 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
35929 |
|
35930 lYuyvPtr += 4; |
|
35931 lRGBFramePtr += 2; |
|
35932 lRGBFramePtr1 += 2; |
|
35933 } |
|
35934 |
|
35935 |
|
35936 lCb1 = lYuyvPtr[3]; |
|
35937 lCr1 = lYuyvPtr[1]; |
|
35938 |
|
35939 lCr1 -= 128; |
|
35940 lCb1 -= 128; |
|
35941 |
|
35942 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
35943 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
35944 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
35945 |
|
35946 /*First Pixel*/ |
|
35947 lY1 = lYuyvPtr[2]; |
|
35948 lY1 -= 16; |
|
35949 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
35950 |
|
35951 /*B component*/ |
|
35952 lTemp = lY1 + lTemp3; |
|
35953 if (lTemp < 0) |
|
35954 lTemp = 0; |
|
35955 if (lTemp > 255) |
|
35956 lTemp = 255; |
|
35957 lTemp4 = (lTemp >> 4); |
|
35958 |
|
35959 /*G component*/ |
|
35960 lTemp = lY1 - lTemp2 + 15; |
|
35961 if (lTemp < 0) |
|
35962 lTemp = 0; |
|
35963 if (lTemp > 255) |
|
35964 lTemp = 255; |
|
35965 lTemp4 |= (lTemp >> 4) << 4; |
|
35966 |
|
35967 /*R component*/ |
|
35968 lTemp = lY1 + lTemp1 + 5; |
|
35969 if (lTemp < 0) |
|
35970 lTemp = 0; |
|
35971 if (lTemp > 255) |
|
35972 lTemp = 255; |
|
35973 lTemp4 |= (lTemp >> 4) << 8; |
|
35974 |
|
35975 lRGBFramePtr[0] = (uint16)lTemp4; |
|
35976 |
|
35977 /*Second Pixel*/ |
|
35978 lY1 = lYuyvPtr[0]; |
|
35979 lY1 -= 16; |
|
35980 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
35981 |
|
35982 /*B component*/ |
|
35983 lTemp = lY1 + lTemp3 + 10; |
|
35984 if (lTemp < 0) |
|
35985 lTemp = 0; |
|
35986 if (lTemp > 255) |
|
35987 lTemp = 255; |
|
35988 lTemp4 = (lTemp >> 4); |
|
35989 |
|
35990 /*G component*/ |
|
35991 lTemp = lY1 - lTemp2; |
|
35992 if (lTemp < 0) |
|
35993 lTemp = 0; |
|
35994 if (lTemp > 255) |
|
35995 lTemp = 255; |
|
35996 lTemp4 |= (lTemp >> 4) << 4; |
|
35997 |
|
35998 /*R component*/ |
|
35999 lTemp = lY1 + lTemp1 + 15; |
|
36000 if (lTemp < 0) |
|
36001 lTemp = 0; |
|
36002 if (lTemp > 255) |
|
36003 lTemp = 255; |
|
36004 lTemp4 |= (lTemp >> 4) << 8; |
|
36005 |
|
36006 lRGBFramePtr[1] = (uint16)lTemp4; |
|
36007 |
|
36008 |
|
36009 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
36010 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
36011 |
|
36012 lCr1 -= 128; |
|
36013 lCb1 -= 128; |
|
36014 |
|
36015 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
36016 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
36017 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
36018 |
|
36019 /*Third Pixel*/ |
|
36020 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
36021 lY1 -= 16; |
|
36022 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
36023 |
|
36024 /*B component*/ |
|
36025 lTemp = lY1 + lTemp3 + 15; |
|
36026 if (lTemp < 0) |
|
36027 lTemp = 0; |
|
36028 if (lTemp > 255) |
|
36029 lTemp = 255; |
|
36030 lTemp4 = (lTemp >> 4); |
|
36031 |
|
36032 /*G component*/ |
|
36033 lTemp = lY1 - lTemp2 + 5; |
|
36034 if (lTemp < 0) |
|
36035 lTemp = 0; |
|
36036 if (lTemp > 255) |
|
36037 lTemp = 255; |
|
36038 lTemp4 |= (lTemp >> 4) << 4; |
|
36039 |
|
36040 /*R component*/ |
|
36041 lTemp = lY1 + lTemp1 + 10; |
|
36042 if (lTemp < 0) |
|
36043 lTemp = 0; |
|
36044 if (lTemp > 255) |
|
36045 lTemp = 255; |
|
36046 lTemp4 |= (lTemp >> 4) << 8; |
|
36047 |
|
36048 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
36049 |
|
36050 /*Fourth Pixel*/ |
|
36051 lY1 = lYuyvPtr[lLumWidth]; |
|
36052 lY1 -= 16; |
|
36053 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
36054 |
|
36055 /*B component*/ |
|
36056 lTemp = lY1 + lTemp3 + 5; |
|
36057 if (lTemp < 0) |
|
36058 lTemp = 0; |
|
36059 if (lTemp > 255) |
|
36060 lTemp = 255; |
|
36061 lTemp4 = (lTemp >> 4); |
|
36062 |
|
36063 /*G component*/ |
|
36064 lTemp = lY1 - lTemp2 + 10; |
|
36065 if (lTemp < 0) |
|
36066 lTemp = 0; |
|
36067 if (lTemp > 255) |
|
36068 lTemp = 255; |
|
36069 lTemp4 |= (lTemp >> 4) << 4; |
|
36070 |
|
36071 /*R component*/ |
|
36072 lTemp = lY1 + lTemp1; |
|
36073 if (lTemp < 0) |
|
36074 lTemp = 0; |
|
36075 if (lTemp > 255) |
|
36076 lTemp = 255; |
|
36077 lTemp4 |= (lTemp >> 4) << 8; |
|
36078 |
|
36079 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
36080 |
|
36081 lYuyvPtr += 4; |
|
36082 lRGBFramePtr += 2; |
|
36083 lRGBFramePtr1 += 2; |
|
36084 |
|
36085 |
|
36086 if(extraCol) |
|
36087 { |
|
36088 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
36089 lRGBFramePtr++; |
|
36090 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
36091 lRGBFramePtr1++; |
|
36092 } |
|
36093 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
36094 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
36095 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
36096 } |
|
36097 |
|
36098 if(extraRow) |
|
36099 { |
|
36100 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
36101 for(j = 0; j < lWidth; j += 2) |
|
36102 { |
|
36103 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
36104 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
36105 } |
|
36106 if(extraCol) |
|
36107 { |
|
36108 *lRGBFramePtr = *lRGBFramePtr1; |
|
36109 } |
|
36110 } |
|
36111 return; |
|
36112 } |
|
36113 |
|
36114 /* |
|
36115 ****************************************************************************** |
|
36116 Name : sEmz_VDec_YUV422LEChr1toColor4k_Ordered_601_5_RR |
|
36117 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
36118 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
36119 uint8 *dstImage : Pointer to rgb data (o/p). |
|
36120 tWndParam *srcWindow : Pointer to structure containing source window |
|
36121 parameters like xOffset,yOffset,cropWidth, |
|
36122 cropHeight. (i/p) |
|
36123 tWndParam *dstWindow : Pointer to structure containing destination window |
|
36124 parameters like xOffset,yOffset,windWidth, |
|
36125 windHeight. (i/p) |
|
36126 Return Value : void |
|
36127 ****************************************************************************** |
|
36128 */ |
|
36129 |
|
36130 void sEmz_VDec_YUV422LEChr1toColor4k_Ordered_601_5_RR |
|
36131 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
36132 tWndParam* srcWindow, tWndParam* dstWindow) |
|
36133 { |
|
36134 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
36135 uint8 *lYuyvPtr; |
|
36136 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
36137 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
36138 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
36139 int32 i, j, extraCol, extraRow; |
|
36140 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
36141 cropWidth,cropHeight,wndWidth,wndHeight; |
|
36142 |
|
36143 srcXOffset = srcWindow->xOffset; |
|
36144 srcYOffset = srcWindow->yOffset; |
|
36145 cropWidth = srcWindow->wndWidth; |
|
36146 cropHeight = srcWindow->wndHeight; |
|
36147 |
|
36148 dstXOffset = dstWindow->xOffset; |
|
36149 dstYOffset = dstWindow->yOffset; |
|
36150 wndWidth = dstWindow->wndWidth; |
|
36151 wndHeight = dstWindow->wndHeight; |
|
36152 |
|
36153 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
36154 { |
|
36155 lWidth = cropWidth; |
|
36156 } |
|
36157 else |
|
36158 { |
|
36159 lWidth = srcImage->width - srcXOffset; |
|
36160 } |
|
36161 |
|
36162 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
36163 { |
|
36164 lHeight = cropHeight; |
|
36165 } |
|
36166 else |
|
36167 { |
|
36168 lHeight = srcImage->height - srcYOffset; |
|
36169 } |
|
36170 |
|
36171 if (lWidth > (wndWidth - dstXOffset)) |
|
36172 { |
|
36173 lWidth = wndWidth - dstXOffset; |
|
36174 } |
|
36175 |
|
36176 if (lHeight > (wndHeight - dstYOffset)) |
|
36177 { |
|
36178 lHeight = wndHeight - dstYOffset; |
|
36179 } |
|
36180 |
|
36181 extraCol = lWidth & 0x01; |
|
36182 extraRow = lHeight & 0x01; |
|
36183 |
|
36184 lTempWidth = lWidth; |
|
36185 lWidth = (lWidth >> 1) << 1; |
|
36186 lHeight = (lHeight >> 1) << 1; |
|
36187 |
|
36188 lLumWidth = (srcImage->width >> 1) << 1; |
|
36189 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
36190 |
|
36191 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
36192 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
36193 |
|
36194 lLumWidth <<= 1; |
|
36195 |
|
36196 for(i = 0; i < lHeight; i += 2) |
|
36197 { |
|
36198 for(j = 0; j < (lWidth - 2); j += 2) |
|
36199 { |
|
36200 lCb1 = lYuyvPtr[3]; |
|
36201 lCr1 = lYuyvPtr[1]; |
|
36202 |
|
36203 lCb2 = lYuyvPtr[7]; |
|
36204 lCr2 = lYuyvPtr[5]; |
|
36205 |
|
36206 lCr2 = (lCr1 + lCr2) >> 1; |
|
36207 lCb2 = (lCb1 + lCb2) >> 1; |
|
36208 |
|
36209 /*First Pixel*/ |
|
36210 lCr1 -= 128; |
|
36211 lCb1 -= 128; |
|
36212 |
|
36213 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
36214 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
36215 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
36216 |
|
36217 lY1 = lYuyvPtr[2]; |
|
36218 lY1 -= 16; |
|
36219 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
36220 |
|
36221 /*B component*/ |
|
36222 lTemp = lY1 + lTemp3; |
|
36223 if (lTemp < 0) |
|
36224 lTemp = 0; |
|
36225 if (lTemp > 255) |
|
36226 lTemp = 255; |
|
36227 lTemp4 = (lTemp >> 4); |
|
36228 |
|
36229 /*G component*/ |
|
36230 lTemp = lY1 - lTemp2 + 15; |
|
36231 if (lTemp < 0) |
|
36232 lTemp = 0; |
|
36233 if (lTemp > 255) |
|
36234 lTemp = 255; |
|
36235 lTemp4 |= (lTemp >> 4) << 4; |
|
36236 |
|
36237 /*R component*/ |
|
36238 lTemp = lY1 + lTemp1 + 5; |
|
36239 if (lTemp < 0) |
|
36240 lTemp = 0; |
|
36241 if (lTemp > 255) |
|
36242 lTemp = 255; |
|
36243 lTemp4 |= (lTemp >> 4) << 8; |
|
36244 |
|
36245 lRGBFramePtr[0] = (uint16)lTemp4; |
|
36246 |
|
36247 /*Second Pixel*/ |
|
36248 lCr2 -= 128; |
|
36249 lCb2 -= 128; |
|
36250 |
|
36251 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
36252 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
36253 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
36254 |
|
36255 lY1 = lYuyvPtr[0]; |
|
36256 lY1 -= 16; |
|
36257 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
36258 |
|
36259 /*B component*/ |
|
36260 lTemp = lY1 + lTemp3 + 10; |
|
36261 if (lTemp < 0) |
|
36262 lTemp = 0; |
|
36263 if (lTemp > 255) |
|
36264 lTemp = 255; |
|
36265 lTemp4 = (lTemp >> 4); |
|
36266 |
|
36267 /*G component*/ |
|
36268 lTemp = lY1 - lTemp2; |
|
36269 if (lTemp < 0) |
|
36270 lTemp = 0; |
|
36271 if (lTemp > 255) |
|
36272 lTemp = 255; |
|
36273 lTemp4 |= (lTemp >> 4) << 4; |
|
36274 |
|
36275 /*R component*/ |
|
36276 lTemp = lY1 + lTemp1 + 15; |
|
36277 if (lTemp < 0) |
|
36278 lTemp = 0; |
|
36279 if (lTemp > 255) |
|
36280 lTemp = 255; |
|
36281 lTemp4 |= (lTemp >> 4) << 8; |
|
36282 |
|
36283 lRGBFramePtr[1] = (uint16)lTemp4; |
|
36284 |
|
36285 |
|
36286 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
36287 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
36288 |
|
36289 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
36290 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
36291 |
|
36292 lCr2 = (lCr1 + lCr2) >> 1; |
|
36293 lCb2 = (lCb1 + lCb2) >> 1; |
|
36294 |
|
36295 /*Third Pixel*/ |
|
36296 lCr1 -= 128; |
|
36297 lCb1 -= 128; |
|
36298 |
|
36299 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
36300 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
36301 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
36302 |
|
36303 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
36304 lY1 -= 16; |
|
36305 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
36306 |
|
36307 /*B component*/ |
|
36308 lTemp = lY1 + lTemp3 + 15; |
|
36309 if (lTemp < 0) |
|
36310 lTemp = 0; |
|
36311 if (lTemp > 255) |
|
36312 lTemp = 255; |
|
36313 lTemp4 = (lTemp >> 4); |
|
36314 |
|
36315 /*G component*/ |
|
36316 lTemp = lY1 - lTemp2 + 5; |
|
36317 if (lTemp < 0) |
|
36318 lTemp = 0; |
|
36319 if (lTemp > 255) |
|
36320 lTemp = 255; |
|
36321 lTemp4 |= (lTemp >> 4) << 4; |
|
36322 |
|
36323 /*R component*/ |
|
36324 lTemp = lY1 + lTemp1 + 10; |
|
36325 if (lTemp < 0) |
|
36326 lTemp = 0; |
|
36327 if (lTemp > 255) |
|
36328 lTemp = 255; |
|
36329 lTemp4 |= (lTemp >> 4) << 8; |
|
36330 |
|
36331 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
36332 |
|
36333 /*Fourth Pixel*/ |
|
36334 lCr2 -= 128; |
|
36335 lCb2 -= 128; |
|
36336 |
|
36337 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
36338 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
36339 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
36340 |
|
36341 lY1 = lYuyvPtr[lLumWidth]; |
|
36342 lY1 -= 16; |
|
36343 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
36344 |
|
36345 /*B component*/ |
|
36346 lTemp = lY1 + lTemp3 + 5; |
|
36347 if (lTemp < 0) |
|
36348 lTemp = 0; |
|
36349 if (lTemp > 255) |
|
36350 lTemp = 255; |
|
36351 lTemp4 = (lTemp >> 4); |
|
36352 |
|
36353 /*G component*/ |
|
36354 lTemp = lY1 - lTemp2 + 10; |
|
36355 if (lTemp < 0) |
|
36356 lTemp = 0; |
|
36357 if (lTemp > 255) |
|
36358 lTemp = 255; |
|
36359 lTemp4 |= (lTemp >> 4) << 4; |
|
36360 |
|
36361 /*R component*/ |
|
36362 lTemp = lY1 + lTemp1; |
|
36363 if (lTemp < 0) |
|
36364 lTemp = 0; |
|
36365 if (lTemp > 255) |
|
36366 lTemp = 255; |
|
36367 lTemp4 |= (lTemp >> 4) << 8; |
|
36368 |
|
36369 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
36370 |
|
36371 lYuyvPtr += 4; |
|
36372 lRGBFramePtr += 2; |
|
36373 lRGBFramePtr1 += 2; |
|
36374 } |
|
36375 |
|
36376 |
|
36377 lCb1 = lYuyvPtr[3]; |
|
36378 lCr1 = lYuyvPtr[1]; |
|
36379 |
|
36380 lCr1 -= 128; |
|
36381 lCb1 -= 128; |
|
36382 |
|
36383 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
36384 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
36385 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
36386 |
|
36387 /*First Pixel*/ |
|
36388 lY1 = lYuyvPtr[2]; |
|
36389 lY1 -= 16; |
|
36390 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
36391 |
|
36392 /*B component*/ |
|
36393 lTemp = lY1 + lTemp3; |
|
36394 if (lTemp < 0) |
|
36395 lTemp = 0; |
|
36396 if (lTemp > 255) |
|
36397 lTemp = 255; |
|
36398 lTemp4 = (lTemp >> 4); |
|
36399 |
|
36400 /*G component*/ |
|
36401 lTemp = lY1 - lTemp2 + 15; |
|
36402 if (lTemp < 0) |
|
36403 lTemp = 0; |
|
36404 if (lTemp > 255) |
|
36405 lTemp = 255; |
|
36406 lTemp4 |= (lTemp >> 4) << 4; |
|
36407 |
|
36408 /*R component*/ |
|
36409 lTemp = lY1 + lTemp1 + 5; |
|
36410 if (lTemp < 0) |
|
36411 lTemp = 0; |
|
36412 if (lTemp > 255) |
|
36413 lTemp = 255; |
|
36414 lTemp4 |= (lTemp >> 4) << 8; |
|
36415 |
|
36416 lRGBFramePtr[0] = (uint16)lTemp4; |
|
36417 |
|
36418 /*Second Pixel*/ |
|
36419 lY1 = lYuyvPtr[0]; |
|
36420 lY1 -= 16; |
|
36421 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
36422 |
|
36423 /*B component*/ |
|
36424 lTemp = lY1 + lTemp3 + 10; |
|
36425 if (lTemp < 0) |
|
36426 lTemp = 0; |
|
36427 if (lTemp > 255) |
|
36428 lTemp = 255; |
|
36429 lTemp4 = (lTemp >> 4); |
|
36430 |
|
36431 /*G component*/ |
|
36432 lTemp = lY1 - lTemp2; |
|
36433 if (lTemp < 0) |
|
36434 lTemp = 0; |
|
36435 if (lTemp > 255) |
|
36436 lTemp = 255; |
|
36437 lTemp4 |= (lTemp >> 4) << 4; |
|
36438 |
|
36439 /*R component*/ |
|
36440 lTemp = lY1 + lTemp1 + 15; |
|
36441 if (lTemp < 0) |
|
36442 lTemp = 0; |
|
36443 if (lTemp > 255) |
|
36444 lTemp = 255; |
|
36445 lTemp4 |= (lTemp >> 4) << 8; |
|
36446 |
|
36447 lRGBFramePtr[1] = (uint16)lTemp4; |
|
36448 |
|
36449 |
|
36450 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
36451 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
36452 |
|
36453 lCr1 -= 128; |
|
36454 lCb1 -= 128; |
|
36455 |
|
36456 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
36457 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
36458 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
36459 |
|
36460 /*Third Pixel*/ |
|
36461 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
36462 lY1 -= 16; |
|
36463 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
36464 |
|
36465 /*B component*/ |
|
36466 lTemp = lY1 + lTemp3 + 15; |
|
36467 if (lTemp < 0) |
|
36468 lTemp = 0; |
|
36469 if (lTemp > 255) |
|
36470 lTemp = 255; |
|
36471 lTemp4 = (lTemp >> 4); |
|
36472 |
|
36473 /*G component*/ |
|
36474 lTemp = lY1 - lTemp2 + 5; |
|
36475 if (lTemp < 0) |
|
36476 lTemp = 0; |
|
36477 if (lTemp > 255) |
|
36478 lTemp = 255; |
|
36479 lTemp4 |= (lTemp >> 4) << 4; |
|
36480 |
|
36481 /*R component*/ |
|
36482 lTemp = lY1 + lTemp1 + 10; |
|
36483 if (lTemp < 0) |
|
36484 lTemp = 0; |
|
36485 if (lTemp > 255) |
|
36486 lTemp = 255; |
|
36487 lTemp4 |= (lTemp >> 4) << 8; |
|
36488 |
|
36489 lRGBFramePtr1[0] = (uint16)lTemp4; |
|
36490 |
|
36491 /*Fourth Pixel*/ |
|
36492 lY1 = lYuyvPtr[lLumWidth]; |
|
36493 lY1 -= 16; |
|
36494 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
36495 |
|
36496 /*B component*/ |
|
36497 lTemp = lY1 + lTemp3 + 5; |
|
36498 if (lTemp < 0) |
|
36499 lTemp = 0; |
|
36500 if (lTemp > 255) |
|
36501 lTemp = 255; |
|
36502 lTemp4 = (lTemp >> 4); |
|
36503 |
|
36504 /*G component*/ |
|
36505 lTemp = lY1 - lTemp2 + 10; |
|
36506 if (lTemp < 0) |
|
36507 lTemp = 0; |
|
36508 if (lTemp > 255) |
|
36509 lTemp = 255; |
|
36510 lTemp4 |= (lTemp >> 4) << 4; |
|
36511 |
|
36512 /*R component*/ |
|
36513 lTemp = lY1 + lTemp1; |
|
36514 if (lTemp < 0) |
|
36515 lTemp = 0; |
|
36516 if (lTemp > 255) |
|
36517 lTemp = 255; |
|
36518 lTemp4 |= (lTemp >> 4) << 8; |
|
36519 |
|
36520 lRGBFramePtr1[1] = (uint16)lTemp4; |
|
36521 |
|
36522 lYuyvPtr += 4; |
|
36523 lRGBFramePtr += 2; |
|
36524 lRGBFramePtr1 += 2; |
|
36525 |
|
36526 |
|
36527 if(extraCol) |
|
36528 { |
|
36529 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
36530 lRGBFramePtr++; |
|
36531 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
36532 lRGBFramePtr1++; |
|
36533 } |
|
36534 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
36535 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
36536 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
36537 } |
|
36538 |
|
36539 if(extraRow) |
|
36540 { |
|
36541 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
36542 for(j = 0; j < lWidth; j += 2) |
|
36543 { |
|
36544 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
36545 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
36546 } |
|
36547 if(extraCol) |
|
36548 { |
|
36549 *lRGBFramePtr = *lRGBFramePtr1; |
|
36550 } |
|
36551 } |
|
36552 return; |
|
36553 } |
|
36554 |
|
36555 |
|
36556 /* |
|
36557 ****************************************************************************** |
|
36558 Name : sEmz_VDec_YUV422LEChr1toColor16MU_709_FR |
|
36559 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
36560 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
36561 uint8 *dstImage : Pointer to rgb data (o/p). |
|
36562 tWndParam *srcWindow : Pointer to structure containing source window |
|
36563 parameters like xOffset,yOffset,cropWidth, |
|
36564 cropHeight. (i/p) |
|
36565 tWndParam *dstWindow : Pointer to structure containing destination window |
|
36566 parameters like xOffset,yOffset,windWidth, |
|
36567 windHeight. (i/p) |
|
36568 Return Value : void |
|
36569 ****************************************************************************** |
|
36570 */ |
|
36571 |
|
36572 void sEmz_VDec_YUV422LEChr1toColor16MU_709_FR |
|
36573 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
36574 tWndParam* srcWindow, tWndParam* dstWindow) |
|
36575 { |
|
36576 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
36577 uint8 *lYuyvPtr; |
|
36578 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
36579 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
36580 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
36581 int32 i, j, extraCol, extraRow; |
|
36582 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
36583 cropWidth,cropHeight,wndWidth,wndHeight; |
|
36584 |
|
36585 srcXOffset = srcWindow->xOffset; |
|
36586 srcYOffset = srcWindow->yOffset; |
|
36587 cropWidth = srcWindow->wndWidth; |
|
36588 cropHeight = srcWindow->wndHeight; |
|
36589 |
|
36590 dstXOffset = dstWindow->xOffset; |
|
36591 dstYOffset = dstWindow->yOffset; |
|
36592 wndWidth = dstWindow->wndWidth; |
|
36593 wndHeight = dstWindow->wndHeight; |
|
36594 |
|
36595 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
36596 { |
|
36597 lWidth = cropWidth; |
|
36598 } |
|
36599 else |
|
36600 { |
|
36601 lWidth = srcImage->width - srcXOffset; |
|
36602 } |
|
36603 |
|
36604 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
36605 { |
|
36606 lHeight = cropHeight; |
|
36607 } |
|
36608 else |
|
36609 { |
|
36610 lHeight = srcImage->height - srcYOffset; |
|
36611 } |
|
36612 |
|
36613 if (lWidth > (wndWidth - dstXOffset)) |
|
36614 { |
|
36615 lWidth = wndWidth - dstXOffset; |
|
36616 } |
|
36617 |
|
36618 if (lHeight > (wndHeight - dstYOffset)) |
|
36619 { |
|
36620 lHeight = wndHeight - dstYOffset; |
|
36621 } |
|
36622 |
|
36623 extraCol = lWidth & 0x01; |
|
36624 extraRow = lHeight & 0x01; |
|
36625 |
|
36626 lTempWidth = lWidth; |
|
36627 lWidth = (lWidth >> 1) << 1; |
|
36628 lHeight = (lHeight >> 1) << 1; |
|
36629 |
|
36630 lLumWidth = (srcImage->width >> 1) << 1; |
|
36631 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
36632 |
|
36633 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
36634 |
|
36635 for(i = 0; i < lHeight; i++) |
|
36636 { |
|
36637 for(j = 0; j < (lWidth - 2); j += 2) |
|
36638 { |
|
36639 lCb1 = lYuyvPtr[3]; |
|
36640 lCr1 = lYuyvPtr[1]; |
|
36641 |
|
36642 lCb2 = lYuyvPtr[7]; |
|
36643 lCr2 = lYuyvPtr[5]; |
|
36644 |
|
36645 lCr2 = (lCr1 + lCr2) >> 1; |
|
36646 lCb2 = (lCb1 + lCb2) >> 1; |
|
36647 |
|
36648 lCr1 -= 128; |
|
36649 lCb1 -= 128; |
|
36650 |
|
36651 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
36652 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
36653 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
36654 |
|
36655 /*First Pixel*/ |
|
36656 lY1 = lYuyvPtr[2]; |
|
36657 |
|
36658 /*B component*/ |
|
36659 lTemp = lY1 + lTemp3; |
|
36660 if (lTemp < 0) |
|
36661 lTemp = 0; |
|
36662 if (lTemp > 255) |
|
36663 lTemp = 255; |
|
36664 lTemp4 = (uint8) lTemp; |
|
36665 |
|
36666 /*G component*/ |
|
36667 lTemp = lY1 - lTemp2; |
|
36668 if (lTemp < 0) |
|
36669 lTemp = 0; |
|
36670 if (lTemp > 255) |
|
36671 lTemp = 255; |
|
36672 lTemp4 |= lTemp << 8; |
|
36673 |
|
36674 /*R component*/ |
|
36675 lTemp = lY1 + lTemp1; |
|
36676 if (lTemp < 0) |
|
36677 lTemp = 0; |
|
36678 if (lTemp > 255) |
|
36679 lTemp = 255; |
|
36680 lTemp4 |= lTemp << 16; |
|
36681 |
|
36682 lRGBFramePtr[0] = (uint32)lTemp4; |
|
36683 |
|
36684 lCr2 -= 128; |
|
36685 lCb2 -= 128; |
|
36686 |
|
36687 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
36688 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
36689 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
36690 |
|
36691 /*Second Pixel*/ |
|
36692 lY1 = lYuyvPtr[0]; |
|
36693 |
|
36694 /*B component*/ |
|
36695 lTemp = lY1 + lTemp3; |
|
36696 if (lTemp < 0) |
|
36697 lTemp = 0; |
|
36698 if (lTemp > 255) |
|
36699 lTemp = 255; |
|
36700 lTemp4 = (uint8) lTemp; |
|
36701 |
|
36702 /*G component*/ |
|
36703 lTemp = lY1 - lTemp2; |
|
36704 if (lTemp < 0) |
|
36705 lTemp = 0; |
|
36706 if (lTemp > 255) |
|
36707 lTemp = 255; |
|
36708 lTemp4 |= lTemp << 8; |
|
36709 |
|
36710 /*R component*/ |
|
36711 lTemp = lY1 + lTemp1; |
|
36712 if (lTemp < 0) |
|
36713 lTemp = 0; |
|
36714 if (lTemp > 255) |
|
36715 lTemp = 255; |
|
36716 lTemp4 |= lTemp << 16; |
|
36717 |
|
36718 lRGBFramePtr[1] = (uint32)lTemp4; |
|
36719 |
|
36720 lYuyvPtr += 4; |
|
36721 lRGBFramePtr += 2; |
|
36722 } |
|
36723 |
|
36724 lCb1 = lYuyvPtr[3]; |
|
36725 lCr1 = lYuyvPtr[1]; |
|
36726 |
|
36727 lCr1 -= 128; |
|
36728 lCb1 -= 128; |
|
36729 |
|
36730 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
36731 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
36732 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
36733 |
|
36734 /*First Pixel*/ |
|
36735 lY1 = lYuyvPtr[2]; |
|
36736 |
|
36737 /*B component*/ |
|
36738 lTemp = lY1 + lTemp3; |
|
36739 if (lTemp < 0) |
|
36740 lTemp = 0; |
|
36741 if (lTemp > 255) |
|
36742 lTemp = 255; |
|
36743 lTemp4 = (uint8) lTemp; |
|
36744 |
|
36745 /*G component*/ |
|
36746 lTemp = lY1 - lTemp2; |
|
36747 if (lTemp < 0) |
|
36748 lTemp = 0; |
|
36749 if (lTemp > 255) |
|
36750 lTemp = 255; |
|
36751 lTemp4 |= lTemp << 8; |
|
36752 |
|
36753 /*R component*/ |
|
36754 lTemp = lY1 + lTemp1; |
|
36755 if (lTemp < 0) |
|
36756 lTemp = 0; |
|
36757 if (lTemp > 255) |
|
36758 lTemp = 255; |
|
36759 lTemp4 |= lTemp << 16; |
|
36760 |
|
36761 lRGBFramePtr[0] = (uint32)lTemp4; |
|
36762 |
|
36763 /*Second Pixel*/ |
|
36764 lY1 = lYuyvPtr[0]; |
|
36765 |
|
36766 /*B component*/ |
|
36767 lTemp = lY1 + lTemp3; |
|
36768 if (lTemp < 0) |
|
36769 lTemp = 0; |
|
36770 if (lTemp > 255) |
|
36771 lTemp = 255; |
|
36772 lTemp4 = (uint8) lTemp; |
|
36773 |
|
36774 /*G component*/ |
|
36775 lTemp = lY1 - lTemp2; |
|
36776 if (lTemp < 0) |
|
36777 lTemp = 0; |
|
36778 if (lTemp > 255) |
|
36779 lTemp = 255; |
|
36780 lTemp4 |= lTemp << 8; |
|
36781 |
|
36782 /*R component*/ |
|
36783 lTemp = lY1 + lTemp1; |
|
36784 if (lTemp < 0) |
|
36785 lTemp = 0; |
|
36786 if (lTemp > 255) |
|
36787 lTemp = 255; |
|
36788 lTemp4 |= lTemp << 16; |
|
36789 |
|
36790 lRGBFramePtr[1] = (uint32)lTemp4; |
|
36791 |
|
36792 lYuyvPtr += 4; |
|
36793 lRGBFramePtr += 2; |
|
36794 |
|
36795 if(extraCol) |
|
36796 { |
|
36797 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
36798 lRGBFramePtr++; |
|
36799 } |
|
36800 |
|
36801 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
36802 lRGBFramePtr += (wndWidth - lTempWidth); |
|
36803 } |
|
36804 |
|
36805 if(extraRow) |
|
36806 { |
|
36807 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
36808 for(j = 0; j < lWidth; j += 2) |
|
36809 { |
|
36810 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
36811 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
36812 } |
|
36813 if(extraCol) |
|
36814 { |
|
36815 *lRGBFramePtr = *lRGBFramePtr1; |
|
36816 } |
|
36817 } |
|
36818 return; |
|
36819 } |
|
36820 |
|
36821 /* |
|
36822 ****************************************************************************** |
|
36823 Name : sEmz_VDec_YUV422LEChr1toColor16MU_601_5_FR |
|
36824 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
36825 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
36826 uint8 *dstImage : Pointer to rgb data (o/p). |
|
36827 tWndParam *srcWindow : Pointer to structure containing source window |
|
36828 parameters like xOffset,yOffset,cropWidth, |
|
36829 cropHeight. (i/p) |
|
36830 tWndParam *dstWindow : Pointer to structure containing destination window |
|
36831 parameters like xOffset,yOffset,windWidth, |
|
36832 windHeight. (i/p) |
|
36833 Return Value : void |
|
36834 ****************************************************************************** |
|
36835 */ |
|
36836 |
|
36837 void sEmz_VDec_YUV422LEChr1toColor16MU_601_5_FR |
|
36838 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
36839 tWndParam* srcWindow, tWndParam* dstWindow) |
|
36840 { |
|
36841 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
36842 uint8 *lYuyvPtr; |
|
36843 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
36844 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
36845 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
36846 int32 i, j, extraCol, extraRow; |
|
36847 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
36848 cropWidth,cropHeight,wndWidth,wndHeight; |
|
36849 |
|
36850 srcXOffset = srcWindow->xOffset; |
|
36851 srcYOffset = srcWindow->yOffset; |
|
36852 cropWidth = srcWindow->wndWidth; |
|
36853 cropHeight = srcWindow->wndHeight; |
|
36854 |
|
36855 dstXOffset = dstWindow->xOffset; |
|
36856 dstYOffset = dstWindow->yOffset; |
|
36857 wndWidth = dstWindow->wndWidth; |
|
36858 wndHeight = dstWindow->wndHeight; |
|
36859 |
|
36860 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
36861 { |
|
36862 lWidth = cropWidth; |
|
36863 } |
|
36864 else |
|
36865 { |
|
36866 lWidth = srcImage->width - srcXOffset; |
|
36867 } |
|
36868 |
|
36869 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
36870 { |
|
36871 lHeight = cropHeight; |
|
36872 } |
|
36873 else |
|
36874 { |
|
36875 lHeight = srcImage->height - srcYOffset; |
|
36876 } |
|
36877 |
|
36878 if (lWidth > (wndWidth - dstXOffset)) |
|
36879 { |
|
36880 lWidth = wndWidth - dstXOffset; |
|
36881 } |
|
36882 |
|
36883 if (lHeight > (wndHeight - dstYOffset)) |
|
36884 { |
|
36885 lHeight = wndHeight - dstYOffset; |
|
36886 } |
|
36887 |
|
36888 extraCol = lWidth & 0x01; |
|
36889 extraRow = lHeight & 0x01; |
|
36890 |
|
36891 lTempWidth = lWidth; |
|
36892 lWidth = (lWidth >> 1) << 1; |
|
36893 lHeight = (lHeight >> 1) << 1; |
|
36894 |
|
36895 lLumWidth = (srcImage->width >> 1) << 1; |
|
36896 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
36897 |
|
36898 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
36899 |
|
36900 for(i = 0; i < lHeight; i++) |
|
36901 { |
|
36902 for(j = 0; j < (lWidth - 2); j += 2) |
|
36903 { |
|
36904 lCb1 = lYuyvPtr[3]; |
|
36905 lCr1 = lYuyvPtr[1]; |
|
36906 |
|
36907 lCb2 = lYuyvPtr[7]; |
|
36908 lCr2 = lYuyvPtr[5]; |
|
36909 |
|
36910 lCr2 = (lCr1 + lCr2) >> 1; |
|
36911 lCb2 = (lCb1 + lCb2) >> 1; |
|
36912 |
|
36913 lCr1 -= 128; |
|
36914 lCb1 -= 128; |
|
36915 |
|
36916 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
36917 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
36918 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
36919 |
|
36920 /*First Pixel*/ |
|
36921 lY1 = lYuyvPtr[2]; |
|
36922 |
|
36923 /*B component*/ |
|
36924 lTemp = lY1 + lTemp3; |
|
36925 if (lTemp < 0) |
|
36926 lTemp = 0; |
|
36927 if (lTemp > 255) |
|
36928 lTemp = 255; |
|
36929 lTemp4 = (uint8) lTemp; |
|
36930 |
|
36931 /*G component*/ |
|
36932 lTemp = lY1 - lTemp2; |
|
36933 if (lTemp < 0) |
|
36934 lTemp = 0; |
|
36935 if (lTemp > 255) |
|
36936 lTemp = 255; |
|
36937 lTemp4 |= lTemp << 8; |
|
36938 |
|
36939 /*R component*/ |
|
36940 lTemp = lY1 + lTemp1; |
|
36941 if (lTemp < 0) |
|
36942 lTemp = 0; |
|
36943 if (lTemp > 255) |
|
36944 lTemp = 255; |
|
36945 lTemp4 |= lTemp << 16; |
|
36946 |
|
36947 lRGBFramePtr[0] = (uint32)lTemp4; |
|
36948 |
|
36949 lCr2 -= 128; |
|
36950 lCb2 -= 128; |
|
36951 |
|
36952 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
36953 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
36954 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
36955 |
|
36956 /*Second Pixel*/ |
|
36957 lY1 = lYuyvPtr[0]; |
|
36958 |
|
36959 /*B component*/ |
|
36960 lTemp = lY1 + lTemp3; |
|
36961 if (lTemp < 0) |
|
36962 lTemp = 0; |
|
36963 if (lTemp > 255) |
|
36964 lTemp = 255; |
|
36965 lTemp4 = (uint8) lTemp; |
|
36966 |
|
36967 /*G component*/ |
|
36968 lTemp = lY1 - lTemp2; |
|
36969 if (lTemp < 0) |
|
36970 lTemp = 0; |
|
36971 if (lTemp > 255) |
|
36972 lTemp = 255; |
|
36973 lTemp4 |= lTemp << 8; |
|
36974 |
|
36975 /*R component*/ |
|
36976 lTemp = lY1 + lTemp1; |
|
36977 if (lTemp < 0) |
|
36978 lTemp = 0; |
|
36979 if (lTemp > 255) |
|
36980 lTemp = 255; |
|
36981 lTemp4 |= lTemp << 16; |
|
36982 |
|
36983 lRGBFramePtr[1] = (uint32)lTemp4; |
|
36984 |
|
36985 lYuyvPtr += 4; |
|
36986 lRGBFramePtr += 2; |
|
36987 } |
|
36988 |
|
36989 lCb1 = lYuyvPtr[3]; |
|
36990 lCr1 = lYuyvPtr[1]; |
|
36991 |
|
36992 lCr1 -= 128; |
|
36993 lCb1 -= 128; |
|
36994 |
|
36995 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
36996 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
36997 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
36998 |
|
36999 /*First Pixel*/ |
|
37000 lY1 = lYuyvPtr[2]; |
|
37001 |
|
37002 /*B component*/ |
|
37003 lTemp = lY1 + lTemp3; |
|
37004 if (lTemp < 0) |
|
37005 lTemp = 0; |
|
37006 if (lTemp > 255) |
|
37007 lTemp = 255; |
|
37008 lTemp4 = (uint8) lTemp; |
|
37009 |
|
37010 /*G component*/ |
|
37011 lTemp = lY1 - lTemp2; |
|
37012 if (lTemp < 0) |
|
37013 lTemp = 0; |
|
37014 if (lTemp > 255) |
|
37015 lTemp = 255; |
|
37016 lTemp4 |= lTemp << 8; |
|
37017 |
|
37018 /*R component*/ |
|
37019 lTemp = lY1 + lTemp1; |
|
37020 if (lTemp < 0) |
|
37021 lTemp = 0; |
|
37022 if (lTemp > 255) |
|
37023 lTemp = 255; |
|
37024 lTemp4 |= lTemp << 16; |
|
37025 |
|
37026 lRGBFramePtr[0] = (uint32)lTemp4; |
|
37027 |
|
37028 /*Second Pixel*/ |
|
37029 lY1 = lYuyvPtr[0]; |
|
37030 |
|
37031 /*B component*/ |
|
37032 lTemp = lY1 + lTemp3; |
|
37033 if (lTemp < 0) |
|
37034 lTemp = 0; |
|
37035 if (lTemp > 255) |
|
37036 lTemp = 255; |
|
37037 lTemp4 = (uint8) lTemp; |
|
37038 |
|
37039 /*G component*/ |
|
37040 lTemp = lY1 - lTemp2; |
|
37041 if (lTemp < 0) |
|
37042 lTemp = 0; |
|
37043 if (lTemp > 255) |
|
37044 lTemp = 255; |
|
37045 lTemp4 |= lTemp << 8; |
|
37046 |
|
37047 /*R component*/ |
|
37048 lTemp = lY1 + lTemp1; |
|
37049 if (lTemp < 0) |
|
37050 lTemp = 0; |
|
37051 if (lTemp > 255) |
|
37052 lTemp = 255; |
|
37053 lTemp4 |= lTemp << 16; |
|
37054 |
|
37055 lRGBFramePtr[1] = (uint32)lTemp4; |
|
37056 |
|
37057 lYuyvPtr += 4; |
|
37058 lRGBFramePtr += 2; |
|
37059 |
|
37060 if(extraCol) |
|
37061 { |
|
37062 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
37063 lRGBFramePtr++; |
|
37064 } |
|
37065 |
|
37066 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
37067 lRGBFramePtr += (wndWidth - lTempWidth); |
|
37068 } |
|
37069 |
|
37070 if(extraRow) |
|
37071 { |
|
37072 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
37073 for(j = 0; j < lWidth; j += 2) |
|
37074 { |
|
37075 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
37076 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
37077 } |
|
37078 if(extraCol) |
|
37079 { |
|
37080 *lRGBFramePtr = *lRGBFramePtr1; |
|
37081 } |
|
37082 } |
|
37083 return; |
|
37084 } |
|
37085 |
|
37086 /* |
|
37087 ****************************************************************************** |
|
37088 Name : sEmz_VDec_YUV422LEChr1toColor16MU_709_RR |
|
37089 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
37090 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
37091 uint8 *dstImage : Pointer to rgb data (o/p). |
|
37092 tWndParam *srcWindow : Pointer to structure containing source window |
|
37093 parameters like xOffset,yOffset,cropWidth, |
|
37094 cropHeight. (i/p) |
|
37095 tWndParam *dstWindow : Pointer to structure containing destination window |
|
37096 parameters like xOffset,yOffset,windWidth, |
|
37097 windHeight. (i/p) |
|
37098 Return Value : void |
|
37099 ****************************************************************************** |
|
37100 */ |
|
37101 |
|
37102 void sEmz_VDec_YUV422LEChr1toColor16MU_709_RR |
|
37103 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
37104 tWndParam* srcWindow, tWndParam* dstWindow) |
|
37105 { |
|
37106 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
37107 uint8 *lYuyvPtr; |
|
37108 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
37109 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
37110 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
37111 int32 i, j, extraCol, extraRow; |
|
37112 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
37113 cropWidth,cropHeight,wndWidth,wndHeight; |
|
37114 |
|
37115 srcXOffset = srcWindow->xOffset; |
|
37116 srcYOffset = srcWindow->yOffset; |
|
37117 cropWidth = srcWindow->wndWidth; |
|
37118 cropHeight = srcWindow->wndHeight; |
|
37119 |
|
37120 dstXOffset = dstWindow->xOffset; |
|
37121 dstYOffset = dstWindow->yOffset; |
|
37122 wndWidth = dstWindow->wndWidth; |
|
37123 wndHeight = dstWindow->wndHeight; |
|
37124 |
|
37125 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
37126 { |
|
37127 lWidth = cropWidth; |
|
37128 } |
|
37129 else |
|
37130 { |
|
37131 lWidth = srcImage->width - srcXOffset; |
|
37132 } |
|
37133 |
|
37134 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
37135 { |
|
37136 lHeight = cropHeight; |
|
37137 } |
|
37138 else |
|
37139 { |
|
37140 lHeight = srcImage->height - srcYOffset; |
|
37141 } |
|
37142 |
|
37143 if (lWidth > (wndWidth - dstXOffset)) |
|
37144 { |
|
37145 lWidth = wndWidth - dstXOffset; |
|
37146 } |
|
37147 |
|
37148 if (lHeight > (wndHeight - dstYOffset)) |
|
37149 { |
|
37150 lHeight = wndHeight - dstYOffset; |
|
37151 } |
|
37152 |
|
37153 extraCol = lWidth & 0x01; |
|
37154 extraRow = lHeight & 0x01; |
|
37155 |
|
37156 lTempWidth = lWidth; |
|
37157 lWidth = (lWidth >> 1) << 1; |
|
37158 lHeight = (lHeight >> 1) << 1; |
|
37159 |
|
37160 lLumWidth = (srcImage->width >> 1) << 1; |
|
37161 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
37162 |
|
37163 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
37164 |
|
37165 for(i = 0; i < lHeight; i++) |
|
37166 { |
|
37167 for(j = 0; j < (lWidth - 2); j += 2) |
|
37168 { |
|
37169 lCb1 = lYuyvPtr[3]; |
|
37170 lCr1 = lYuyvPtr[1]; |
|
37171 |
|
37172 lCb2 = lYuyvPtr[7]; |
|
37173 lCr2 = lYuyvPtr[5]; |
|
37174 |
|
37175 lCr2 = (lCr1 + lCr2) >> 1; |
|
37176 lCb2 = (lCb1 + lCb2) >> 1; |
|
37177 |
|
37178 lCr1 -= 128; |
|
37179 lCb1 -= 128; |
|
37180 |
|
37181 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
37182 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
37183 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
37184 |
|
37185 /*First Pixel*/ |
|
37186 lY1 = lYuyvPtr[2]; |
|
37187 lY1 -= 16; |
|
37188 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
37189 |
|
37190 /*B component*/ |
|
37191 lTemp = lY1 + lTemp3; |
|
37192 if (lTemp < 0) |
|
37193 lTemp = 0; |
|
37194 if (lTemp > 255) |
|
37195 lTemp = 255; |
|
37196 lTemp4 = (uint8) lTemp; |
|
37197 |
|
37198 /*G component*/ |
|
37199 lTemp = lY1 - lTemp2; |
|
37200 if (lTemp < 0) |
|
37201 lTemp = 0; |
|
37202 if (lTemp > 255) |
|
37203 lTemp = 255; |
|
37204 lTemp4 |= lTemp << 8; |
|
37205 |
|
37206 /*R component*/ |
|
37207 lTemp = lY1 + lTemp1; |
|
37208 if (lTemp < 0) |
|
37209 lTemp = 0; |
|
37210 if (lTemp > 255) |
|
37211 lTemp = 255; |
|
37212 lTemp4 |= lTemp << 16; |
|
37213 |
|
37214 lRGBFramePtr[0] = (uint32)lTemp4; |
|
37215 |
|
37216 lCr2 -= 128; |
|
37217 lCb2 -= 128; |
|
37218 |
|
37219 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
37220 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
37221 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
37222 |
|
37223 /*Second Pixel*/ |
|
37224 lY1 = lYuyvPtr[0]; |
|
37225 lY1 -= 16; |
|
37226 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
37227 |
|
37228 /*B component*/ |
|
37229 lTemp = lY1 + lTemp3; |
|
37230 if (lTemp < 0) |
|
37231 lTemp = 0; |
|
37232 if (lTemp > 255) |
|
37233 lTemp = 255; |
|
37234 lTemp4 = (uint8) lTemp; |
|
37235 |
|
37236 /*G component*/ |
|
37237 lTemp = lY1 - lTemp2; |
|
37238 if (lTemp < 0) |
|
37239 lTemp = 0; |
|
37240 if (lTemp > 255) |
|
37241 lTemp = 255; |
|
37242 lTemp4 |= lTemp << 8; |
|
37243 |
|
37244 /*R component*/ |
|
37245 lTemp = lY1 + lTemp1; |
|
37246 if (lTemp < 0) |
|
37247 lTemp = 0; |
|
37248 if (lTemp > 255) |
|
37249 lTemp = 255; |
|
37250 lTemp4 |= lTemp << 16; |
|
37251 |
|
37252 lRGBFramePtr[1] = (uint32)lTemp4; |
|
37253 |
|
37254 lYuyvPtr += 4; |
|
37255 lRGBFramePtr += 2; |
|
37256 } |
|
37257 |
|
37258 lCb1 = lYuyvPtr[3]; |
|
37259 lCr1 = lYuyvPtr[1]; |
|
37260 |
|
37261 lCr1 -= 128; |
|
37262 lCb1 -= 128; |
|
37263 |
|
37264 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
37265 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
37266 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
37267 |
|
37268 /*First Pixel*/ |
|
37269 lY1 = lYuyvPtr[2]; |
|
37270 lY1 -= 16; |
|
37271 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
37272 |
|
37273 /*B component*/ |
|
37274 lTemp = lY1 + lTemp3; |
|
37275 if (lTemp < 0) |
|
37276 lTemp = 0; |
|
37277 if (lTemp > 255) |
|
37278 lTemp = 255; |
|
37279 lTemp4 = (uint8) lTemp; |
|
37280 |
|
37281 /*G component*/ |
|
37282 lTemp = lY1 - lTemp2; |
|
37283 if (lTemp < 0) |
|
37284 lTemp = 0; |
|
37285 if (lTemp > 255) |
|
37286 lTemp = 255; |
|
37287 lTemp4 |= lTemp << 8; |
|
37288 |
|
37289 /*R component*/ |
|
37290 lTemp = lY1 + lTemp1; |
|
37291 if (lTemp < 0) |
|
37292 lTemp = 0; |
|
37293 if (lTemp > 255) |
|
37294 lTemp = 255; |
|
37295 lTemp4 |= lTemp << 16; |
|
37296 |
|
37297 lRGBFramePtr[0] = (uint32)lTemp4; |
|
37298 |
|
37299 /*Second Pixel*/ |
|
37300 lY1 = lYuyvPtr[0]; |
|
37301 lY1 -= 16; |
|
37302 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
37303 |
|
37304 /*B component*/ |
|
37305 lTemp = lY1 + lTemp3; |
|
37306 if (lTemp < 0) |
|
37307 lTemp = 0; |
|
37308 if (lTemp > 255) |
|
37309 lTemp = 255; |
|
37310 lTemp4 = (uint8) lTemp; |
|
37311 |
|
37312 /*G component*/ |
|
37313 lTemp = lY1 - lTemp2; |
|
37314 if (lTemp < 0) |
|
37315 lTemp = 0; |
|
37316 if (lTemp > 255) |
|
37317 lTemp = 255; |
|
37318 lTemp4 |= lTemp << 8; |
|
37319 |
|
37320 /*R component*/ |
|
37321 lTemp = lY1 + lTemp1; |
|
37322 if (lTemp < 0) |
|
37323 lTemp = 0; |
|
37324 if (lTemp > 255) |
|
37325 lTemp = 255; |
|
37326 lTemp4 |= lTemp << 16; |
|
37327 |
|
37328 lRGBFramePtr[1] = (uint32)lTemp4; |
|
37329 |
|
37330 lYuyvPtr += 4; |
|
37331 lRGBFramePtr += 2; |
|
37332 |
|
37333 if(extraCol) |
|
37334 { |
|
37335 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
37336 lRGBFramePtr++; |
|
37337 } |
|
37338 |
|
37339 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
37340 lRGBFramePtr += (wndWidth - lTempWidth); |
|
37341 } |
|
37342 |
|
37343 if(extraRow) |
|
37344 { |
|
37345 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
37346 for(j = 0; j < lWidth; j += 2) |
|
37347 { |
|
37348 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
37349 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
37350 } |
|
37351 if(extraCol) |
|
37352 { |
|
37353 *lRGBFramePtr = *lRGBFramePtr1; |
|
37354 } |
|
37355 } |
|
37356 return; |
|
37357 } |
|
37358 |
|
37359 /* |
|
37360 ****************************************************************************** |
|
37361 Name : sEmz_VDec_YUV422LEChr1toColor16MU_601_5_RR |
|
37362 Description : Converts YUV422 LE (YVYU) Chroma1 Interleaved to XRGB (8:8:8:8) Interleaved format. |
|
37363 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
37364 uint8 *dstImage : Pointer to rgb data (o/p). |
|
37365 tWndParam *srcWindow : Pointer to structure containing source window |
|
37366 parameters like xOffset,yOffset,cropWidth, |
|
37367 cropHeight. (i/p) |
|
37368 tWndParam *dstWindow : Pointer to structure containing destination window |
|
37369 parameters like xOffset,yOffset,windWidth, |
|
37370 windHeight. (i/p) |
|
37371 Return Value : void |
|
37372 ****************************************************************************** |
|
37373 */ |
|
37374 |
|
37375 void sEmz_VDec_YUV422LEChr1toColor16MU_601_5_RR |
|
37376 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
37377 tWndParam* srcWindow, tWndParam* dstWindow) |
|
37378 { |
|
37379 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
37380 uint8 *lYuyvPtr; |
|
37381 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
37382 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
37383 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
37384 int32 i, j, extraCol, extraRow; |
|
37385 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
37386 cropWidth,cropHeight,wndWidth,wndHeight; |
|
37387 |
|
37388 srcXOffset = srcWindow->xOffset; |
|
37389 srcYOffset = srcWindow->yOffset; |
|
37390 cropWidth = srcWindow->wndWidth; |
|
37391 cropHeight = srcWindow->wndHeight; |
|
37392 |
|
37393 dstXOffset = dstWindow->xOffset; |
|
37394 dstYOffset = dstWindow->yOffset; |
|
37395 wndWidth = dstWindow->wndWidth; |
|
37396 wndHeight = dstWindow->wndHeight; |
|
37397 |
|
37398 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
37399 { |
|
37400 lWidth = cropWidth; |
|
37401 } |
|
37402 else |
|
37403 { |
|
37404 lWidth = srcImage->width - srcXOffset; |
|
37405 } |
|
37406 |
|
37407 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
37408 { |
|
37409 lHeight = cropHeight; |
|
37410 } |
|
37411 else |
|
37412 { |
|
37413 lHeight = srcImage->height - srcYOffset; |
|
37414 } |
|
37415 |
|
37416 if (lWidth > (wndWidth - dstXOffset)) |
|
37417 { |
|
37418 lWidth = wndWidth - dstXOffset; |
|
37419 } |
|
37420 |
|
37421 if (lHeight > (wndHeight - dstYOffset)) |
|
37422 { |
|
37423 lHeight = wndHeight - dstYOffset; |
|
37424 } |
|
37425 |
|
37426 extraCol = lWidth & 0x01; |
|
37427 extraRow = lHeight & 0x01; |
|
37428 |
|
37429 lTempWidth = lWidth; |
|
37430 lWidth = (lWidth >> 1) << 1; |
|
37431 lHeight = (lHeight >> 1) << 1; |
|
37432 |
|
37433 lLumWidth = (srcImage->width >> 1) << 1; |
|
37434 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
37435 |
|
37436 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
37437 |
|
37438 for(i = 0; i < lHeight; i++) |
|
37439 { |
|
37440 for(j = 0; j < (lWidth - 2); j += 2) |
|
37441 { |
|
37442 lCb1 = lYuyvPtr[3]; |
|
37443 lCr1 = lYuyvPtr[1]; |
|
37444 |
|
37445 lCb2 = lYuyvPtr[7]; |
|
37446 lCr2 = lYuyvPtr[5]; |
|
37447 |
|
37448 lCr2 = (lCr1 + lCr2) >> 1; |
|
37449 lCb2 = (lCb1 + lCb2) >> 1; |
|
37450 |
|
37451 lCr1 -= 128; |
|
37452 lCb1 -= 128; |
|
37453 |
|
37454 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
37455 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
37456 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
37457 |
|
37458 /*First Pixel*/ |
|
37459 lY1 = lYuyvPtr[2]; |
|
37460 lY1 -= 16; |
|
37461 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
37462 |
|
37463 /*B component*/ |
|
37464 lTemp = lY1 + lTemp3; |
|
37465 if (lTemp < 0) |
|
37466 lTemp = 0; |
|
37467 if (lTemp > 255) |
|
37468 lTemp = 255; |
|
37469 lTemp4 = (uint8) lTemp; |
|
37470 |
|
37471 /*G component*/ |
|
37472 lTemp = lY1 - lTemp2; |
|
37473 if (lTemp < 0) |
|
37474 lTemp = 0; |
|
37475 if (lTemp > 255) |
|
37476 lTemp = 255; |
|
37477 lTemp4 |= lTemp << 8; |
|
37478 |
|
37479 /*R component*/ |
|
37480 lTemp = lY1 + lTemp1; |
|
37481 if (lTemp < 0) |
|
37482 lTemp = 0; |
|
37483 if (lTemp > 255) |
|
37484 lTemp = 255; |
|
37485 lTemp4 |= lTemp << 16; |
|
37486 |
|
37487 lRGBFramePtr[0] = (uint32)lTemp4; |
|
37488 |
|
37489 lCr2 -= 128; |
|
37490 lCb2 -= 128; |
|
37491 |
|
37492 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
37493 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
37494 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
37495 |
|
37496 /*Second Pixel*/ |
|
37497 lY1 = lYuyvPtr[0]; |
|
37498 lY1 -= 16; |
|
37499 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
37500 |
|
37501 /*B component*/ |
|
37502 lTemp = lY1 + lTemp3; |
|
37503 if (lTemp < 0) |
|
37504 lTemp = 0; |
|
37505 if (lTemp > 255) |
|
37506 lTemp = 255; |
|
37507 lTemp4 = (uint8) lTemp; |
|
37508 |
|
37509 /*G component*/ |
|
37510 lTemp = lY1 - lTemp2; |
|
37511 if (lTemp < 0) |
|
37512 lTemp = 0; |
|
37513 if (lTemp > 255) |
|
37514 lTemp = 255; |
|
37515 lTemp4 |= lTemp << 8; |
|
37516 |
|
37517 /*R component*/ |
|
37518 lTemp = lY1 + lTemp1; |
|
37519 if (lTemp < 0) |
|
37520 lTemp = 0; |
|
37521 if (lTemp > 255) |
|
37522 lTemp = 255; |
|
37523 lTemp4 |= lTemp << 16; |
|
37524 |
|
37525 lRGBFramePtr[1] = (uint32)lTemp4; |
|
37526 |
|
37527 lYuyvPtr += 4; |
|
37528 lRGBFramePtr += 2; |
|
37529 } |
|
37530 |
|
37531 lCb1 = lYuyvPtr[3]; |
|
37532 lCr1 = lYuyvPtr[1]; |
|
37533 |
|
37534 lCr1 -= 128; |
|
37535 lCb1 -= 128; |
|
37536 |
|
37537 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
37538 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
37539 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
37540 |
|
37541 /*First Pixel*/ |
|
37542 lY1 = lYuyvPtr[2]; |
|
37543 lY1 -= 16; |
|
37544 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
37545 |
|
37546 /*B component*/ |
|
37547 lTemp = lY1 + lTemp3; |
|
37548 if (lTemp < 0) |
|
37549 lTemp = 0; |
|
37550 if (lTemp > 255) |
|
37551 lTemp = 255; |
|
37552 lTemp4 = (uint8) lTemp; |
|
37553 |
|
37554 /*G component*/ |
|
37555 lTemp = lY1 - lTemp2; |
|
37556 if (lTemp < 0) |
|
37557 lTemp = 0; |
|
37558 if (lTemp > 255) |
|
37559 lTemp = 255; |
|
37560 lTemp4 |= lTemp << 8; |
|
37561 |
|
37562 /*R component*/ |
|
37563 lTemp = lY1 + lTemp1; |
|
37564 if (lTemp < 0) |
|
37565 lTemp = 0; |
|
37566 if (lTemp > 255) |
|
37567 lTemp = 255; |
|
37568 lTemp4 |= lTemp << 16; |
|
37569 |
|
37570 lRGBFramePtr[0] = (uint32)lTemp4; |
|
37571 |
|
37572 /*Second Pixel*/ |
|
37573 lY1 = lYuyvPtr[0]; |
|
37574 lY1 -= 16; |
|
37575 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
37576 |
|
37577 /*B component*/ |
|
37578 lTemp = lY1 + lTemp3; |
|
37579 if (lTemp < 0) |
|
37580 lTemp = 0; |
|
37581 if (lTemp > 255) |
|
37582 lTemp = 255; |
|
37583 lTemp4 = (uint8) lTemp; |
|
37584 |
|
37585 /*G component*/ |
|
37586 lTemp = lY1 - lTemp2; |
|
37587 if (lTemp < 0) |
|
37588 lTemp = 0; |
|
37589 if (lTemp > 255) |
|
37590 lTemp = 255; |
|
37591 lTemp4 |= lTemp << 8; |
|
37592 |
|
37593 /*R component*/ |
|
37594 lTemp = lY1 + lTemp1; |
|
37595 if (lTemp < 0) |
|
37596 lTemp = 0; |
|
37597 if (lTemp > 255) |
|
37598 lTemp = 255; |
|
37599 lTemp4 |= lTemp << 16; |
|
37600 |
|
37601 lRGBFramePtr[1] = (uint32)lTemp4; |
|
37602 |
|
37603 lYuyvPtr += 4; |
|
37604 lRGBFramePtr += 2; |
|
37605 |
|
37606 if(extraCol) |
|
37607 { |
|
37608 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
37609 lRGBFramePtr++; |
|
37610 } |
|
37611 |
|
37612 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
37613 lRGBFramePtr += (wndWidth - lTempWidth); |
|
37614 } |
|
37615 |
|
37616 if(extraRow) |
|
37617 { |
|
37618 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
37619 for(j = 0; j < lWidth; j += 2) |
|
37620 { |
|
37621 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
37622 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
37623 } |
|
37624 if(extraCol) |
|
37625 { |
|
37626 *lRGBFramePtr = *lRGBFramePtr1; |
|
37627 } |
|
37628 } |
|
37629 return; |
|
37630 } |
|
37631 |
|
37632 /************** End of YUV422LE input *******************/ |
|
37633 |
|
37634 |
|
37635 /* |
|
37636 ****************************************************************************** |
|
37637 Name : sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_709_FR |
|
37638 Description : Converts YUV420 Chroma1 Planar to RGB565 Interleaved format |
|
37639 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
37640 uint8 *dstImage : Pointer to rgb data (o/p). |
|
37641 tWndParam *srcWindow : Pointer to structure containing source window |
|
37642 parameters like xOffset,yOffset,cropWidth, |
|
37643 cropHeight. (i/p) |
|
37644 tWndParam *dstWindow : Pointer to structure containing destination window |
|
37645 parameters like xOffset,yOffset,windWidth, |
|
37646 windHeight. (i/p) |
|
37647 Return Value : void |
|
37648 ****************************************************************************** |
|
37649 */ |
|
37650 |
|
37651 void sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_709_FR |
|
37652 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
37653 tWndParam* srcWindow, tWndParam* dstWindow) |
|
37654 { |
|
37655 uint16 *dest1, *dest2; |
|
37656 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
37657 uint8 *lBuffer; |
|
37658 uint8 *src1, *src2; |
|
37659 uint8 *lPtr1, *lPtr2; |
|
37660 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
37661 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
37662 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
37663 int32 diff1, diff2, diff3; |
|
37664 int32 i, j, k, extraRow, extraCol; |
|
37665 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
37666 cropWidth,cropHeight,wndWidth,wndHeight; |
|
37667 |
|
37668 srcXOffset = srcWindow->xOffset; |
|
37669 srcYOffset = srcWindow->yOffset; |
|
37670 cropWidth = srcWindow->wndWidth; |
|
37671 cropHeight = srcWindow->wndHeight; |
|
37672 |
|
37673 dstXOffset = dstWindow->xOffset; |
|
37674 dstYOffset = dstWindow->yOffset; |
|
37675 wndWidth = dstWindow->wndWidth; |
|
37676 wndHeight = dstWindow->wndHeight; |
|
37677 |
|
37678 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
37679 { |
|
37680 lWidth = cropWidth; |
|
37681 } |
|
37682 else |
|
37683 { |
|
37684 lWidth = srcImage->width - srcXOffset; |
|
37685 } |
|
37686 |
|
37687 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
37688 { |
|
37689 lHeight = cropHeight; |
|
37690 } |
|
37691 else |
|
37692 { |
|
37693 lHeight = srcImage->height - srcYOffset; |
|
37694 } |
|
37695 |
|
37696 if (lWidth > (wndWidth - dstXOffset)) |
|
37697 { |
|
37698 lWidth = wndWidth - dstXOffset; |
|
37699 } |
|
37700 |
|
37701 if (lHeight > (wndHeight - dstYOffset)) |
|
37702 { |
|
37703 lHeight = wndHeight - dstYOffset; |
|
37704 } |
|
37705 |
|
37706 extraCol = lWidth & 0x01; |
|
37707 extraRow = lHeight & 0x01; |
|
37708 |
|
37709 lTempWidth = lWidth; |
|
37710 lWidth = (lWidth >> 1) << 1; |
|
37711 lHeight = (lHeight >> 1) << 1; |
|
37712 |
|
37713 lBuffer = (uint8*) malloc(lWidth * 3 * 4); |
|
37714 |
|
37715 lSrcWidth = lWidth * 3; |
|
37716 |
|
37717 lLumWidth = (srcImage->width >> 1) << 1; |
|
37718 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
37719 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
37720 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
37721 |
|
37722 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
37723 dest2 = dest1 + wndWidth; |
|
37724 |
|
37725 for(i = 0; i < lHeight; i += 2) |
|
37726 { |
|
37727 lPtr1 = src1 = lBuffer; |
|
37728 lPtr2 = src2 = src1 + lSrcWidth; |
|
37729 |
|
37730 for(k = 0; k < (lWidth - 2); k += 2) |
|
37731 { |
|
37732 lCr1 = lCrPtr[k >> 1]; |
|
37733 lCb1 = lCbPtr[k >> 1]; |
|
37734 |
|
37735 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
37736 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
37737 |
|
37738 lCr2 = (lCr1 + lCr2) >> 1; |
|
37739 lCb2 = (lCb1 + lCb2) >> 1; |
|
37740 |
|
37741 lCr1 -= 128; |
|
37742 lCb1 -= 128; |
|
37743 |
|
37744 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
37745 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
37746 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
37747 |
|
37748 /*First Pixel*/ |
|
37749 lY1 = lLumPtr[k]; |
|
37750 |
|
37751 lTemp = lY1 + lTemp1; |
|
37752 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37753 |
|
37754 lTemp = lY1 - lTemp2; |
|
37755 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37756 |
|
37757 lTemp = lY1 + lTemp3; |
|
37758 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37759 |
|
37760 /*Third Pixel*/ |
|
37761 lY1 = lLumPtr[k + lLumWidth]; |
|
37762 |
|
37763 lTemp = lY1 + lTemp1; |
|
37764 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37765 |
|
37766 lTemp = lY1 - lTemp2; |
|
37767 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37768 |
|
37769 lTemp = lY1 + lTemp3; |
|
37770 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37771 |
|
37772 |
|
37773 lCr2 -= 128; |
|
37774 lCb2 -= 128; |
|
37775 |
|
37776 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
37777 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
37778 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
37779 |
|
37780 /*Second Pixel*/ |
|
37781 lY1 = lLumPtr[k + 1]; |
|
37782 |
|
37783 lTemp = lY1 + lTemp1; |
|
37784 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37785 |
|
37786 lTemp = lY1 - lTemp2; |
|
37787 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37788 |
|
37789 lTemp = lY1 + lTemp3; |
|
37790 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37791 |
|
37792 |
|
37793 /*Fourth Pixel*/ |
|
37794 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
37795 |
|
37796 lTemp = lY1 + lTemp1; |
|
37797 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37798 |
|
37799 lTemp = lY1 - lTemp2; |
|
37800 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37801 |
|
37802 lTemp = lY1 + lTemp3; |
|
37803 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37804 |
|
37805 |
|
37806 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
37807 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
37808 |
|
37809 lCr2 = lCrPtr[(k + lLumWidth) >> 1 + 1]; |
|
37810 lCb2 = lCbPtr[(k + lLumWidth) >> 1 + 1]; |
|
37811 |
|
37812 lCr2 = (lCr1 + lCr2) >> 1; |
|
37813 lCb2 = (lCb1 + lCb2) >> 1; |
|
37814 |
|
37815 lCr1 -= 128; |
|
37816 lCb1 -= 128; |
|
37817 |
|
37818 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
37819 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
37820 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
37821 |
|
37822 |
|
37823 /*Fifth Pixel*/ |
|
37824 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
37825 |
|
37826 lTemp = lY1 + lTemp1; |
|
37827 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37828 |
|
37829 lTemp = lY1 - lTemp2; |
|
37830 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37831 |
|
37832 lTemp = lY1 + lTemp3; |
|
37833 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37834 |
|
37835 /*Seventh Pixel*/ |
|
37836 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
37837 |
|
37838 lTemp = lY1 + lTemp1; |
|
37839 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37840 |
|
37841 lTemp = lY1 - lTemp2; |
|
37842 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37843 |
|
37844 lTemp = lY1 + lTemp3; |
|
37845 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37846 |
|
37847 |
|
37848 lCr2 -= 128; |
|
37849 lCb2 -= 128; |
|
37850 |
|
37851 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
37852 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
37853 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
37854 |
|
37855 /*Sixth Pixel*/ |
|
37856 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
37857 |
|
37858 lTemp = lY1 + lTemp1; |
|
37859 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37860 |
|
37861 lTemp = lY1 - lTemp2; |
|
37862 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37863 |
|
37864 lTemp = lY1 + lTemp3; |
|
37865 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37866 |
|
37867 /*Eighth Pixel*/ |
|
37868 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
37869 |
|
37870 lTemp = lY1 + lTemp1; |
|
37871 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37872 |
|
37873 lTemp = lY1 - lTemp2; |
|
37874 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37875 |
|
37876 lTemp = lY1 + lTemp3; |
|
37877 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37878 |
|
37879 src1 += 6; |
|
37880 src2 += 6; |
|
37881 } |
|
37882 |
|
37883 |
|
37884 lCr1 = lCrPtr[k >> 1]; |
|
37885 lCb1 = lCbPtr[k >> 1]; |
|
37886 |
|
37887 lCr1 -= 128; |
|
37888 lCb1 -= 128; |
|
37889 |
|
37890 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
37891 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
37892 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
37893 |
|
37894 /*First Pixel*/ |
|
37895 lY1 = lLumPtr[k]; |
|
37896 |
|
37897 lTemp = lY1 + lTemp1; |
|
37898 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37899 |
|
37900 lTemp = lY1 - lTemp2; |
|
37901 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37902 |
|
37903 lTemp = lY1 + lTemp3; |
|
37904 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37905 |
|
37906 /*Third Pixel*/ |
|
37907 lY1 = lLumPtr[k + lLumWidth]; |
|
37908 |
|
37909 lTemp = lY1 + lTemp1; |
|
37910 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37911 |
|
37912 lTemp = lY1 - lTemp2; |
|
37913 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37914 |
|
37915 lTemp = lY1 + lTemp3; |
|
37916 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37917 |
|
37918 /*Second Pixel*/ |
|
37919 lY1 = lLumPtr[k + 1]; |
|
37920 |
|
37921 lTemp = lY1 + lTemp1; |
|
37922 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37923 |
|
37924 lTemp = lY1 - lTemp2; |
|
37925 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37926 |
|
37927 lTemp = lY1 + lTemp3; |
|
37928 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37929 |
|
37930 |
|
37931 /*Fourth Pixel*/ |
|
37932 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
37933 |
|
37934 lTemp = lY1 + lTemp1; |
|
37935 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37936 |
|
37937 lTemp = lY1 - lTemp2; |
|
37938 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37939 |
|
37940 lTemp = lY1 + lTemp3; |
|
37941 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37942 |
|
37943 |
|
37944 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
37945 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
37946 |
|
37947 lCr1 -= 128; |
|
37948 lCb1 -= 128; |
|
37949 |
|
37950 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
37951 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
37952 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
37953 |
|
37954 |
|
37955 /*Fifth Pixel*/ |
|
37956 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
37957 |
|
37958 lTemp = lY1 + lTemp1; |
|
37959 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37960 |
|
37961 lTemp = lY1 - lTemp2; |
|
37962 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37963 |
|
37964 lTemp = lY1 + lTemp3; |
|
37965 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37966 |
|
37967 /*Seventh Pixel*/ |
|
37968 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
37969 |
|
37970 lTemp = lY1 + lTemp1; |
|
37971 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37972 |
|
37973 lTemp = lY1 - lTemp2; |
|
37974 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37975 |
|
37976 lTemp = lY1 + lTemp3; |
|
37977 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37978 |
|
37979 /*Sixth Pixel*/ |
|
37980 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
37981 |
|
37982 lTemp = lY1 + lTemp1; |
|
37983 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37984 |
|
37985 lTemp = lY1 - lTemp2; |
|
37986 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37987 |
|
37988 lTemp = lY1 + lTemp3; |
|
37989 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37990 |
|
37991 /*Eighth Pixel*/ |
|
37992 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
37993 |
|
37994 lTemp = lY1 + lTemp1; |
|
37995 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37996 |
|
37997 lTemp = lY1 - lTemp2; |
|
37998 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
37999 |
|
38000 lTemp = lY1 + lTemp3; |
|
38001 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38002 |
|
38003 src1 += 6; |
|
38004 src2 += 6; |
|
38005 |
|
38006 |
|
38007 src1 = lPtr1; |
|
38008 src2 = lPtr2; |
|
38009 |
|
38010 for(j = 0; j < lWidth; j += 2) |
|
38011 { |
|
38012 /* First Pixel */ |
|
38013 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
38014 diff1 = *src1 & 0x7; |
|
38015 diff2 = *(src1 + 1) & 0x3; |
|
38016 diff3 = *(src1 + 2) & 0x7; |
|
38017 |
|
38018 // diffuse the error |
|
38019 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
38020 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
38021 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
38022 |
|
38023 /* Second Pixel */ |
|
38024 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
38025 diff1 = *(src1 + 3) & 0x7; |
|
38026 diff2 = *(src1 + 4) & 0x3; |
|
38027 diff3 = *(src1 + 5) & 0x7; |
|
38028 // diffuse the error |
|
38029 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
38030 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
38031 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
38032 |
|
38033 src1 += 6; |
|
38034 dest1 += 2; |
|
38035 |
|
38036 /* Third Pixel */ |
|
38037 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
38038 diff1 = *src2 & 0x7; |
|
38039 diff2 = *(src2 + 1) & 0x3; |
|
38040 diff3 = *(src2 + 2) & 0x7; |
|
38041 //diffuse the error |
|
38042 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
38043 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
38044 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
38045 |
|
38046 /* Fourth Pixel */ |
|
38047 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
38048 diff1 = *(src2 + 3) & 0x7; |
|
38049 diff2 = *(src2 + 4) & 0x3; |
|
38050 diff3 = *(src2 + 5) & 0x7; |
|
38051 //diffuse the error |
|
38052 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
38053 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
38054 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
38055 |
|
38056 src2 += 6; |
|
38057 dest2 += 2; |
|
38058 } |
|
38059 if(extraCol) |
|
38060 { |
|
38061 *dest1 = dest1[-1]; |
|
38062 dest1++; |
|
38063 *dest2 = dest2[-1]; |
|
38064 dest2++; |
|
38065 } |
|
38066 |
|
38067 lLumPtr += (lLumWidth << 1); |
|
38068 lCrPtr += (lLumWidth >> 1); |
|
38069 lCbPtr += (lLumWidth >> 1); |
|
38070 |
|
38071 dest1 += ((wndWidth << 1) - lTempWidth); |
|
38072 dest2 += ((wndWidth << 1) - lTempWidth); |
|
38073 } |
|
38074 |
|
38075 if(extraRow) |
|
38076 { |
|
38077 dest2 = dest1 - wndWidth; |
|
38078 for(j = 0; j < lWidth; j += 2) |
|
38079 { |
|
38080 *dest1++ = *dest2++; |
|
38081 *dest1++ = *dest2++; |
|
38082 } |
|
38083 if(extraCol) |
|
38084 { |
|
38085 *dest1 = *dest2; |
|
38086 } |
|
38087 } |
|
38088 |
|
38089 free(lBuffer); |
|
38090 return; |
|
38091 } |
|
38092 |
|
38093 /* |
|
38094 ****************************************************************************** |
|
38095 Name : sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_601_5_FR |
|
38096 Description : Converts YUV420 Chroma1 Planar to RGB565 Interleaved format |
|
38097 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
38098 uint8 *dstImage : Pointer to rgb data (o/p). |
|
38099 tWndParam *srcWindow : Pointer to structure containing source window |
|
38100 parameters like xOffset,yOffset,cropWidth, |
|
38101 cropHeight. (i/p) |
|
38102 tWndParam *dstWindow : Pointer to structure containing destination window |
|
38103 parameters like xOffset,yOffset,windWidth, |
|
38104 windHeight. (i/p) |
|
38105 Return Value : void |
|
38106 ****************************************************************************** |
|
38107 */ |
|
38108 |
|
38109 void sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_601_5_FR |
|
38110 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
38111 tWndParam* srcWindow, tWndParam* dstWindow) |
|
38112 { |
|
38113 uint16 *dest1, *dest2; |
|
38114 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
38115 uint8 *lBuffer; |
|
38116 uint8 *src1, *src2; |
|
38117 uint8 *lPtr1, *lPtr2; |
|
38118 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
38119 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
38120 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
38121 int32 diff1, diff2, diff3; |
|
38122 int32 i, j, k, extraRow, extraCol; |
|
38123 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
38124 cropWidth,cropHeight,wndWidth,wndHeight; |
|
38125 |
|
38126 srcXOffset = srcWindow->xOffset; |
|
38127 srcYOffset = srcWindow->yOffset; |
|
38128 cropWidth = srcWindow->wndWidth; |
|
38129 cropHeight = srcWindow->wndHeight; |
|
38130 |
|
38131 dstXOffset = dstWindow->xOffset; |
|
38132 dstYOffset = dstWindow->yOffset; |
|
38133 wndWidth = dstWindow->wndWidth; |
|
38134 wndHeight = dstWindow->wndHeight; |
|
38135 |
|
38136 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
38137 { |
|
38138 lWidth = cropWidth; |
|
38139 } |
|
38140 else |
|
38141 { |
|
38142 lWidth = srcImage->width - srcXOffset; |
|
38143 } |
|
38144 |
|
38145 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
38146 { |
|
38147 lHeight = cropHeight; |
|
38148 } |
|
38149 else |
|
38150 { |
|
38151 lHeight = srcImage->height - srcYOffset; |
|
38152 } |
|
38153 |
|
38154 if (lWidth > (wndWidth - dstXOffset)) |
|
38155 { |
|
38156 lWidth = wndWidth - dstXOffset; |
|
38157 } |
|
38158 |
|
38159 if (lHeight > (wndHeight - dstYOffset)) |
|
38160 { |
|
38161 lHeight = wndHeight - dstYOffset; |
|
38162 } |
|
38163 |
|
38164 extraCol = lWidth & 0x01; |
|
38165 extraRow = lHeight & 0x01; |
|
38166 |
|
38167 lTempWidth = lWidth; |
|
38168 lWidth = (lWidth >> 1) << 1; |
|
38169 lHeight = (lHeight >> 1) << 1; |
|
38170 |
|
38171 lBuffer = (uint8*) malloc(lWidth * 3 * 4); |
|
38172 |
|
38173 lSrcWidth = lWidth * 3; |
|
38174 |
|
38175 lLumWidth = (srcImage->width >> 1) << 1; |
|
38176 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
38177 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
38178 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
38179 |
|
38180 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
38181 dest2 = dest1 + wndWidth; |
|
38182 |
|
38183 for(i = 0; i < lHeight; i += 2) |
|
38184 { |
|
38185 lPtr1 = src1 = lBuffer; |
|
38186 lPtr2 = src2 = src1 + lSrcWidth; |
|
38187 |
|
38188 for(k = 0; k < (lWidth - 2); k += 2) |
|
38189 { |
|
38190 lCr1 = lCrPtr[k >> 1]; |
|
38191 lCb1 = lCbPtr[k >> 1]; |
|
38192 |
|
38193 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
38194 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
38195 |
|
38196 lCr2 = (lCr1 + lCr2) >> 1; |
|
38197 lCb2 = (lCb1 + lCb2) >> 1; |
|
38198 |
|
38199 lCr1 -= 128; |
|
38200 lCb1 -= 128; |
|
38201 |
|
38202 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
38203 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
38204 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
38205 |
|
38206 /*First Pixel*/ |
|
38207 lY1 = lLumPtr[k]; |
|
38208 |
|
38209 lTemp = lY1 + lTemp1; |
|
38210 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38211 |
|
38212 lTemp = lY1 - lTemp2; |
|
38213 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38214 |
|
38215 lTemp = lY1 + lTemp3; |
|
38216 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38217 |
|
38218 /*Third Pixel*/ |
|
38219 lY1 = lLumPtr[k + lLumWidth]; |
|
38220 |
|
38221 lTemp = lY1 + lTemp1; |
|
38222 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38223 |
|
38224 lTemp = lY1 - lTemp2; |
|
38225 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38226 |
|
38227 lTemp = lY1 + lTemp3; |
|
38228 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38229 |
|
38230 |
|
38231 lCr2 -= 128; |
|
38232 lCb2 -= 128; |
|
38233 |
|
38234 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
38235 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
38236 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
38237 |
|
38238 /*Second Pixel*/ |
|
38239 lY1 = lLumPtr[k + 1]; |
|
38240 |
|
38241 lTemp = lY1 + lTemp1; |
|
38242 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38243 |
|
38244 lTemp = lY1 - lTemp2; |
|
38245 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38246 |
|
38247 lTemp = lY1 + lTemp3; |
|
38248 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38249 |
|
38250 |
|
38251 /*Fourth Pixel*/ |
|
38252 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
38253 |
|
38254 lTemp = lY1 + lTemp1; |
|
38255 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38256 |
|
38257 lTemp = lY1 - lTemp2; |
|
38258 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38259 |
|
38260 lTemp = lY1 + lTemp3; |
|
38261 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38262 |
|
38263 |
|
38264 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
38265 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
38266 |
|
38267 lCr2 = lCrPtr[(k + lLumWidth) >> 1 + 1]; |
|
38268 lCb2 = lCbPtr[(k + lLumWidth) >> 1 + 1]; |
|
38269 |
|
38270 lCr2 = (lCr1 + lCr2) >> 1; |
|
38271 lCb2 = (lCb1 + lCb2) >> 1; |
|
38272 |
|
38273 lCr1 -= 128; |
|
38274 lCb1 -= 128; |
|
38275 |
|
38276 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
38277 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
38278 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
38279 |
|
38280 |
|
38281 /*Fifth Pixel*/ |
|
38282 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
38283 |
|
38284 lTemp = lY1 + lTemp1; |
|
38285 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38286 |
|
38287 lTemp = lY1 - lTemp2; |
|
38288 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38289 |
|
38290 lTemp = lY1 + lTemp3; |
|
38291 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38292 |
|
38293 /*Seventh Pixel*/ |
|
38294 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
38295 |
|
38296 lTemp = lY1 + lTemp1; |
|
38297 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38298 |
|
38299 lTemp = lY1 - lTemp2; |
|
38300 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38301 |
|
38302 lTemp = lY1 + lTemp3; |
|
38303 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38304 |
|
38305 |
|
38306 lCr2 -= 128; |
|
38307 lCb2 -= 128; |
|
38308 |
|
38309 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
38310 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
38311 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
38312 |
|
38313 /*Sixth Pixel*/ |
|
38314 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
38315 |
|
38316 lTemp = lY1 + lTemp1; |
|
38317 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38318 |
|
38319 lTemp = lY1 - lTemp2; |
|
38320 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38321 |
|
38322 lTemp = lY1 + lTemp3; |
|
38323 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38324 |
|
38325 /*Eighth Pixel*/ |
|
38326 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
38327 |
|
38328 lTemp = lY1 + lTemp1; |
|
38329 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38330 |
|
38331 lTemp = lY1 - lTemp2; |
|
38332 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38333 |
|
38334 lTemp = lY1 + lTemp3; |
|
38335 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38336 |
|
38337 src1 += 6; |
|
38338 src2 += 6; |
|
38339 } |
|
38340 |
|
38341 |
|
38342 lCr1 = lCrPtr[k >> 1]; |
|
38343 lCb1 = lCbPtr[k >> 1]; |
|
38344 |
|
38345 lCr1 -= 128; |
|
38346 lCb1 -= 128; |
|
38347 |
|
38348 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
38349 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
38350 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
38351 |
|
38352 /*First Pixel*/ |
|
38353 lY1 = lLumPtr[k]; |
|
38354 |
|
38355 lTemp = lY1 + lTemp1; |
|
38356 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38357 |
|
38358 lTemp = lY1 - lTemp2; |
|
38359 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38360 |
|
38361 lTemp = lY1 + lTemp3; |
|
38362 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38363 |
|
38364 /*Third Pixel*/ |
|
38365 lY1 = lLumPtr[k + lLumWidth]; |
|
38366 |
|
38367 lTemp = lY1 + lTemp1; |
|
38368 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38369 |
|
38370 lTemp = lY1 - lTemp2; |
|
38371 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38372 |
|
38373 lTemp = lY1 + lTemp3; |
|
38374 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38375 |
|
38376 /*Second Pixel*/ |
|
38377 lY1 = lLumPtr[k + 1]; |
|
38378 |
|
38379 lTemp = lY1 + lTemp1; |
|
38380 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38381 |
|
38382 lTemp = lY1 - lTemp2; |
|
38383 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38384 |
|
38385 lTemp = lY1 + lTemp3; |
|
38386 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38387 |
|
38388 |
|
38389 /*Fourth Pixel*/ |
|
38390 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
38391 |
|
38392 lTemp = lY1 + lTemp1; |
|
38393 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38394 |
|
38395 lTemp = lY1 - lTemp2; |
|
38396 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38397 |
|
38398 lTemp = lY1 + lTemp3; |
|
38399 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38400 |
|
38401 |
|
38402 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
38403 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
38404 |
|
38405 lCr1 -= 128; |
|
38406 lCb1 -= 128; |
|
38407 |
|
38408 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
38409 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
38410 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
38411 |
|
38412 |
|
38413 /*Fifth Pixel*/ |
|
38414 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
38415 |
|
38416 lTemp = lY1 + lTemp1; |
|
38417 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38418 |
|
38419 lTemp = lY1 - lTemp2; |
|
38420 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38421 |
|
38422 lTemp = lY1 + lTemp3; |
|
38423 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38424 |
|
38425 /*Seventh Pixel*/ |
|
38426 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
38427 |
|
38428 lTemp = lY1 + lTemp1; |
|
38429 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38430 |
|
38431 lTemp = lY1 - lTemp2; |
|
38432 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38433 |
|
38434 lTemp = lY1 + lTemp3; |
|
38435 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38436 |
|
38437 /*Sixth Pixel*/ |
|
38438 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
38439 |
|
38440 lTemp = lY1 + lTemp1; |
|
38441 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38442 |
|
38443 lTemp = lY1 - lTemp2; |
|
38444 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38445 |
|
38446 lTemp = lY1 + lTemp3; |
|
38447 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38448 |
|
38449 /*Eighth Pixel*/ |
|
38450 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
38451 |
|
38452 lTemp = lY1 + lTemp1; |
|
38453 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38454 |
|
38455 lTemp = lY1 - lTemp2; |
|
38456 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38457 |
|
38458 lTemp = lY1 + lTemp3; |
|
38459 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
38460 |
|
38461 src1 += 6; |
|
38462 src2 += 6; |
|
38463 |
|
38464 |
|
38465 src1 = lPtr1; |
|
38466 src2 = lPtr2; |
|
38467 |
|
38468 for(j = 0; j < lWidth; j += 2) |
|
38469 { |
|
38470 /* First Pixel */ |
|
38471 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
38472 diff1 = *src1 & 0x7; |
|
38473 diff2 = *(src1 + 1) & 0x3; |
|
38474 diff3 = *(src1 + 2) & 0x7; |
|
38475 |
|
38476 // diffuse the error |
|
38477 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
38478 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
38479 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
38480 |
|
38481 /* Second Pixel */ |
|
38482 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
38483 diff1 = *(src1 + 3) & 0x7; |
|
38484 diff2 = *(src1 + 4) & 0x3; |
|
38485 diff3 = *(src1 + 5) & 0x7; |
|
38486 // diffuse the error |
|
38487 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
38488 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
38489 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
38490 |
|
38491 src1 += 6; |
|
38492 dest1 += 2; |
|
38493 |
|
38494 /* Third Pixel */ |
|
38495 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
38496 diff1 = *src2 & 0x7; |
|
38497 diff2 = *(src2 + 1) & 0x3; |
|
38498 diff3 = *(src2 + 2) & 0x7; |
|
38499 //diffuse the error |
|
38500 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
38501 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
38502 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
38503 |
|
38504 /* Fourth Pixel */ |
|
38505 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
38506 diff1 = *(src2 + 3) & 0x7; |
|
38507 diff2 = *(src2 + 4) & 0x3; |
|
38508 diff3 = *(src2 + 5) & 0x7; |
|
38509 //diffuse the error |
|
38510 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
38511 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
38512 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
38513 |
|
38514 src2 += 6; |
|
38515 dest2 += 2; |
|
38516 } |
|
38517 if(extraCol) |
|
38518 { |
|
38519 *dest1 = dest1[-1]; |
|
38520 dest1++; |
|
38521 *dest2 = dest2[-1]; |
|
38522 dest2++; |
|
38523 } |
|
38524 |
|
38525 lLumPtr += (lLumWidth << 1); |
|
38526 lCrPtr += (lLumWidth >> 1); |
|
38527 lCbPtr += (lLumWidth >> 1); |
|
38528 |
|
38529 dest1 += ((wndWidth << 1) - lTempWidth); |
|
38530 dest2 += ((wndWidth << 1) - lTempWidth); |
|
38531 } |
|
38532 |
|
38533 if(extraRow) |
|
38534 { |
|
38535 dest2 = dest1 - wndWidth; |
|
38536 for(j = 0; j < lWidth; j += 2) |
|
38537 { |
|
38538 *dest1++ = *dest2++; |
|
38539 *dest1++ = *dest2++; |
|
38540 } |
|
38541 if(extraCol) |
|
38542 { |
|
38543 *dest1 = *dest2; |
|
38544 } |
|
38545 } |
|
38546 |
|
38547 free(lBuffer); |
|
38548 return; |
|
38549 } |
|
38550 |
|
38551 /* |
|
38552 ****************************************************************************** |
|
38553 Name : sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_709_RR |
|
38554 Description : Converts YUV420 Chroma1 Planar to RGB565 Interleaved format |
|
38555 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
38556 uint8 *dstImage : Pointer to rgb data (o/p). |
|
38557 tWndParam *srcWindow : Pointer to structure containing source window |
|
38558 parameters like xOffset,yOffset,cropWidth, |
|
38559 cropHeight. (i/p) |
|
38560 tWndParam *dstWindow : Pointer to structure containing destination window |
|
38561 parameters like xOffset,yOffset,windWidth, |
|
38562 windHeight. (i/p) |
|
38563 Return Value : void |
|
38564 ****************************************************************************** |
|
38565 */ |
|
38566 |
|
38567 void sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_709_RR |
|
38568 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
38569 tWndParam* srcWindow, tWndParam* dstWindow) |
|
38570 { |
|
38571 uint16 *dest1, *dest2; |
|
38572 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
38573 uint8 *lBuffer; |
|
38574 uint8 *src1, *src2; |
|
38575 uint8 *lPtr1, *lPtr2; |
|
38576 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
38577 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
38578 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
38579 int32 diff1, diff2, diff3; |
|
38580 int32 i, j, k, extraRow, extraCol; |
|
38581 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
38582 cropWidth,cropHeight,wndWidth,wndHeight; |
|
38583 |
|
38584 srcXOffset = srcWindow->xOffset; |
|
38585 srcYOffset = srcWindow->yOffset; |
|
38586 cropWidth = srcWindow->wndWidth; |
|
38587 cropHeight = srcWindow->wndHeight; |
|
38588 |
|
38589 dstXOffset = dstWindow->xOffset; |
|
38590 dstYOffset = dstWindow->yOffset; |
|
38591 wndWidth = dstWindow->wndWidth; |
|
38592 wndHeight = dstWindow->wndHeight; |
|
38593 |
|
38594 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
38595 { |
|
38596 lWidth = cropWidth; |
|
38597 } |
|
38598 else |
|
38599 { |
|
38600 lWidth = srcImage->width - srcXOffset; |
|
38601 } |
|
38602 |
|
38603 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
38604 { |
|
38605 lHeight = cropHeight; |
|
38606 } |
|
38607 else |
|
38608 { |
|
38609 lHeight = srcImage->height - srcYOffset; |
|
38610 } |
|
38611 |
|
38612 if (lWidth > (wndWidth - dstXOffset)) |
|
38613 { |
|
38614 lWidth = wndWidth - dstXOffset; |
|
38615 } |
|
38616 |
|
38617 if (lHeight > (wndHeight - dstYOffset)) |
|
38618 { |
|
38619 lHeight = wndHeight - dstYOffset; |
|
38620 } |
|
38621 |
|
38622 extraCol = lWidth & 0x01; |
|
38623 extraRow = lHeight & 0x01; |
|
38624 |
|
38625 lTempWidth = lWidth; |
|
38626 lWidth = (lWidth >> 1) << 1; |
|
38627 lHeight = (lHeight >> 1) << 1; |
|
38628 |
|
38629 lBuffer = (uint8*) malloc(lWidth * 3 * 4); |
|
38630 |
|
38631 lSrcWidth = lWidth * 3; |
|
38632 |
|
38633 lLumWidth = (srcImage->width >> 1) << 1; |
|
38634 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
38635 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
38636 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
38637 |
|
38638 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
38639 dest2 = dest1 + wndWidth; |
|
38640 |
|
38641 for(i = 0; i < lHeight; i += 2) |
|
38642 { |
|
38643 lPtr1 = src1 = lBuffer; |
|
38644 lPtr2 = src2 = src1 + lSrcWidth; |
|
38645 |
|
38646 for(k = 0; k < (lWidth - 2); k += 2) |
|
38647 { |
|
38648 lCr1 = lCrPtr[k >> 1]; |
|
38649 lCb1 = lCbPtr[k >> 1]; |
|
38650 |
|
38651 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
38652 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
38653 |
|
38654 lCr2 = (lCr1 + lCr2) >> 1; |
|
38655 lCb2 = (lCb1 + lCb2) >> 1; |
|
38656 |
|
38657 lCr1 -= 128; |
|
38658 lCb1 -= 128; |
|
38659 |
|
38660 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
38661 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
38662 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
38663 |
|
38664 /*First Pixel*/ |
|
38665 lY1 = lLumPtr[k]; |
|
38666 lY1 -= 16; |
|
38667 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38668 |
|
38669 lTemp = lY1 + lTemp1; |
|
38670 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38671 |
|
38672 lTemp = lY1 - lTemp2; |
|
38673 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38674 |
|
38675 lTemp = lY1 + lTemp3; |
|
38676 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38677 |
|
38678 /*Third Pixel*/ |
|
38679 lY1 = lLumPtr[k + lLumWidth]; |
|
38680 lY1 -= 16; |
|
38681 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38682 |
|
38683 lTemp = lY1 + lTemp1; |
|
38684 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38685 |
|
38686 lTemp = lY1 - lTemp2; |
|
38687 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38688 |
|
38689 lTemp = lY1 + lTemp3; |
|
38690 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38691 |
|
38692 |
|
38693 lCr2 -= 128; |
|
38694 lCb2 -= 128; |
|
38695 |
|
38696 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
38697 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
38698 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
38699 |
|
38700 /*Second Pixel*/ |
|
38701 lY1 = lLumPtr[k + 1]; |
|
38702 lY1 -= 16; |
|
38703 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38704 |
|
38705 lTemp = lY1 + lTemp1; |
|
38706 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38707 |
|
38708 lTemp = lY1 - lTemp2; |
|
38709 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38710 |
|
38711 lTemp = lY1 + lTemp3; |
|
38712 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38713 |
|
38714 |
|
38715 /*Fourth Pixel*/ |
|
38716 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
38717 lY1 -= 16; |
|
38718 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38719 |
|
38720 lTemp = lY1 + lTemp1; |
|
38721 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38722 |
|
38723 lTemp = lY1 - lTemp2; |
|
38724 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38725 |
|
38726 lTemp = lY1 + lTemp3; |
|
38727 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38728 |
|
38729 |
|
38730 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
38731 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
38732 |
|
38733 lCr2 = lCrPtr[(k + lLumWidth) >> 1 + 1]; |
|
38734 lCb2 = lCbPtr[(k + lLumWidth) >> 1 + 1]; |
|
38735 |
|
38736 lCr2 = (lCr1 + lCr2) >> 1; |
|
38737 lCb2 = (lCb1 + lCb2) >> 1; |
|
38738 |
|
38739 lCr1 -= 128; |
|
38740 lCb1 -= 128; |
|
38741 |
|
38742 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
38743 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
38744 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
38745 |
|
38746 |
|
38747 /*Fifth Pixel*/ |
|
38748 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
38749 lY1 -= 16; |
|
38750 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38751 |
|
38752 lTemp = lY1 + lTemp1; |
|
38753 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38754 |
|
38755 lTemp = lY1 - lTemp2; |
|
38756 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38757 |
|
38758 lTemp = lY1 + lTemp3; |
|
38759 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38760 |
|
38761 /*Seventh Pixel*/ |
|
38762 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
38763 lY1 -= 16; |
|
38764 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38765 |
|
38766 lTemp = lY1 + lTemp1; |
|
38767 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38768 |
|
38769 lTemp = lY1 - lTemp2; |
|
38770 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38771 |
|
38772 lTemp = lY1 + lTemp3; |
|
38773 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38774 |
|
38775 |
|
38776 lCr2 -= 128; |
|
38777 lCb2 -= 128; |
|
38778 |
|
38779 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
38780 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
38781 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
38782 |
|
38783 /*Sixth Pixel*/ |
|
38784 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
38785 lY1 -= 16; |
|
38786 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38787 |
|
38788 lTemp = lY1 + lTemp1; |
|
38789 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38790 |
|
38791 lTemp = lY1 - lTemp2; |
|
38792 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38793 |
|
38794 lTemp = lY1 + lTemp3; |
|
38795 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38796 |
|
38797 /*Eighth Pixel*/ |
|
38798 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
38799 lY1 -= 16; |
|
38800 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38801 |
|
38802 lTemp = lY1 + lTemp1; |
|
38803 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38804 |
|
38805 lTemp = lY1 - lTemp2; |
|
38806 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38807 |
|
38808 lTemp = lY1 + lTemp3; |
|
38809 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38810 |
|
38811 src1 += 6; |
|
38812 src2 += 6; |
|
38813 } |
|
38814 |
|
38815 |
|
38816 lCr1 = lCrPtr[k >> 1]; |
|
38817 lCb1 = lCbPtr[k >> 1]; |
|
38818 |
|
38819 lCr1 -= 128; |
|
38820 lCb1 -= 128; |
|
38821 |
|
38822 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
38823 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
38824 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
38825 |
|
38826 /*First Pixel*/ |
|
38827 lY1 = lLumPtr[k]; |
|
38828 lY1 -= 16; |
|
38829 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38830 |
|
38831 lTemp = lY1 + lTemp1; |
|
38832 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38833 |
|
38834 lTemp = lY1 - lTemp2; |
|
38835 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38836 |
|
38837 lTemp = lY1 + lTemp3; |
|
38838 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38839 |
|
38840 /*Third Pixel*/ |
|
38841 lY1 = lLumPtr[k + lLumWidth]; |
|
38842 lY1 -= 16; |
|
38843 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38844 |
|
38845 lTemp = lY1 + lTemp1; |
|
38846 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38847 |
|
38848 lTemp = lY1 - lTemp2; |
|
38849 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38850 |
|
38851 lTemp = lY1 + lTemp3; |
|
38852 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38853 |
|
38854 /*Second Pixel*/ |
|
38855 lY1 = lLumPtr[k + 1]; |
|
38856 lY1 -= 16; |
|
38857 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38858 |
|
38859 lTemp = lY1 + lTemp1; |
|
38860 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38861 |
|
38862 lTemp = lY1 - lTemp2; |
|
38863 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38864 |
|
38865 lTemp = lY1 + lTemp3; |
|
38866 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38867 |
|
38868 |
|
38869 /*Fourth Pixel*/ |
|
38870 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
38871 lY1 -= 16; |
|
38872 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38873 |
|
38874 lTemp = lY1 + lTemp1; |
|
38875 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38876 |
|
38877 lTemp = lY1 - lTemp2; |
|
38878 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38879 |
|
38880 lTemp = lY1 + lTemp3; |
|
38881 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38882 |
|
38883 |
|
38884 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
38885 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
38886 |
|
38887 lCr1 -= 128; |
|
38888 lCb1 -= 128; |
|
38889 |
|
38890 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
38891 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
38892 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
38893 |
|
38894 |
|
38895 /*Fifth Pixel*/ |
|
38896 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
38897 lY1 -= 16; |
|
38898 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38899 |
|
38900 lTemp = lY1 + lTemp1; |
|
38901 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38902 |
|
38903 lTemp = lY1 - lTemp2; |
|
38904 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38905 |
|
38906 lTemp = lY1 + lTemp3; |
|
38907 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38908 |
|
38909 /*Seventh Pixel*/ |
|
38910 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
38911 lY1 -= 16; |
|
38912 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38913 |
|
38914 lTemp = lY1 + lTemp1; |
|
38915 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38916 |
|
38917 lTemp = lY1 - lTemp2; |
|
38918 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38919 |
|
38920 lTemp = lY1 + lTemp3; |
|
38921 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38922 |
|
38923 /*Sixth Pixel*/ |
|
38924 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
38925 lY1 -= 16; |
|
38926 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38927 |
|
38928 lTemp = lY1 + lTemp1; |
|
38929 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38930 |
|
38931 lTemp = lY1 - lTemp2; |
|
38932 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38933 |
|
38934 lTemp = lY1 + lTemp3; |
|
38935 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38936 |
|
38937 /*Eighth Pixel*/ |
|
38938 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
38939 lY1 -= 16; |
|
38940 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
38941 |
|
38942 lTemp = lY1 + lTemp1; |
|
38943 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38944 |
|
38945 lTemp = lY1 - lTemp2; |
|
38946 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38947 |
|
38948 lTemp = lY1 + lTemp3; |
|
38949 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
38950 |
|
38951 src1 += 6; |
|
38952 src2 += 6; |
|
38953 |
|
38954 |
|
38955 src1 = lPtr1; |
|
38956 src2 = lPtr2; |
|
38957 |
|
38958 for(j = 0; j < lWidth; j += 2) |
|
38959 { |
|
38960 /* First Pixel */ |
|
38961 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
38962 diff1 = *src1 & 0x7; |
|
38963 diff2 = *(src1 + 1) & 0x3; |
|
38964 diff3 = *(src1 + 2) & 0x7; |
|
38965 |
|
38966 // diffuse the error |
|
38967 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
38968 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
38969 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
38970 |
|
38971 /* Second Pixel */ |
|
38972 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
38973 diff1 = *(src1 + 3) & 0x7; |
|
38974 diff2 = *(src1 + 4) & 0x3; |
|
38975 diff3 = *(src1 + 5) & 0x7; |
|
38976 // diffuse the error |
|
38977 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
38978 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
38979 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
38980 |
|
38981 src1 += 6; |
|
38982 dest1 += 2; |
|
38983 |
|
38984 /* Third Pixel */ |
|
38985 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
38986 diff1 = *src2 & 0x7; |
|
38987 diff2 = *(src2 + 1) & 0x3; |
|
38988 diff3 = *(src2 + 2) & 0x7; |
|
38989 //diffuse the error |
|
38990 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
38991 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
38992 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
38993 |
|
38994 /* Fourth Pixel */ |
|
38995 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
38996 diff1 = *(src2 + 3) & 0x7; |
|
38997 diff2 = *(src2 + 4) & 0x3; |
|
38998 diff3 = *(src2 + 5) & 0x7; |
|
38999 //diffuse the error |
|
39000 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
39001 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
39002 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
39003 |
|
39004 src2 += 6; |
|
39005 dest2 += 2; |
|
39006 } |
|
39007 if(extraCol) |
|
39008 { |
|
39009 *dest1 = dest1[-1]; |
|
39010 dest1++; |
|
39011 *dest2 = dest2[-1]; |
|
39012 dest2++; |
|
39013 } |
|
39014 |
|
39015 lLumPtr += (lLumWidth << 1); |
|
39016 lCrPtr += (lLumWidth >> 1); |
|
39017 lCbPtr += (lLumWidth >> 1); |
|
39018 |
|
39019 dest1 += ((wndWidth << 1) - lTempWidth); |
|
39020 dest2 += ((wndWidth << 1) - lTempWidth); |
|
39021 } |
|
39022 |
|
39023 if(extraRow) |
|
39024 { |
|
39025 dest2 = dest1 - wndWidth; |
|
39026 for(j = 0; j < lWidth; j += 2) |
|
39027 { |
|
39028 *dest1++ = *dest2++; |
|
39029 *dest1++ = *dest2++; |
|
39030 } |
|
39031 if(extraCol) |
|
39032 { |
|
39033 *dest1 = *dest2; |
|
39034 } |
|
39035 } |
|
39036 |
|
39037 free(lBuffer); |
|
39038 return; |
|
39039 } |
|
39040 |
|
39041 /* |
|
39042 ****************************************************************************** |
|
39043 Name : sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_601_5_RR |
|
39044 Description : Converts YUV420 Chroma1 Planar to RGB565 Interleaved format |
|
39045 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
39046 uint8 *dstImage : Pointer to rgb data (o/p). |
|
39047 tWndParam *srcWindow : Pointer to structure containing source window |
|
39048 parameters like xOffset,yOffset,cropWidth, |
|
39049 cropHeight. (i/p) |
|
39050 tWndParam *dstWindow : Pointer to structure containing destination window |
|
39051 parameters like xOffset,yOffset,windWidth, |
|
39052 windHeight. (i/p) |
|
39053 Return Value : void |
|
39054 ****************************************************************************** |
|
39055 */ |
|
39056 |
|
39057 void sEmz_VDec_YUV420Chr1toColor64k_ErrDiff_601_5_RR |
|
39058 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
39059 tWndParam* srcWindow, tWndParam* dstWindow) |
|
39060 { |
|
39061 uint16 *dest1, *dest2; |
|
39062 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
39063 uint8 *lBuffer; |
|
39064 uint8 *src1, *src2; |
|
39065 uint8 *lPtr1, *lPtr2; |
|
39066 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
39067 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
39068 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
39069 int32 diff1, diff2, diff3; |
|
39070 int32 i, j, k, extraRow, extraCol; |
|
39071 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
39072 cropWidth,cropHeight,wndWidth,wndHeight; |
|
39073 |
|
39074 srcXOffset = srcWindow->xOffset; |
|
39075 srcYOffset = srcWindow->yOffset; |
|
39076 cropWidth = srcWindow->wndWidth; |
|
39077 cropHeight = srcWindow->wndHeight; |
|
39078 |
|
39079 dstXOffset = dstWindow->xOffset; |
|
39080 dstYOffset = dstWindow->yOffset; |
|
39081 wndWidth = dstWindow->wndWidth; |
|
39082 wndHeight = dstWindow->wndHeight; |
|
39083 |
|
39084 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
39085 { |
|
39086 lWidth = cropWidth; |
|
39087 } |
|
39088 else |
|
39089 { |
|
39090 lWidth = srcImage->width - srcXOffset; |
|
39091 } |
|
39092 |
|
39093 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
39094 { |
|
39095 lHeight = cropHeight; |
|
39096 } |
|
39097 else |
|
39098 { |
|
39099 lHeight = srcImage->height - srcYOffset; |
|
39100 } |
|
39101 |
|
39102 if (lWidth > (wndWidth - dstXOffset)) |
|
39103 { |
|
39104 lWidth = wndWidth - dstXOffset; |
|
39105 } |
|
39106 |
|
39107 if (lHeight > (wndHeight - dstYOffset)) |
|
39108 { |
|
39109 lHeight = wndHeight - dstYOffset; |
|
39110 } |
|
39111 |
|
39112 extraCol = lWidth & 0x01; |
|
39113 extraRow = lHeight & 0x01; |
|
39114 |
|
39115 lTempWidth = lWidth; |
|
39116 lWidth = (lWidth >> 1) << 1; |
|
39117 lHeight = (lHeight >> 1) << 1; |
|
39118 |
|
39119 lBuffer = (uint8*) malloc(lWidth * 3 * 4); |
|
39120 |
|
39121 lSrcWidth = lWidth * 3; |
|
39122 |
|
39123 lLumWidth = (srcImage->width >> 1) << 1; |
|
39124 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
39125 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
39126 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
39127 |
|
39128 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
39129 dest2 = dest1 + wndWidth; |
|
39130 |
|
39131 for(i = 0; i < lHeight; i += 2) |
|
39132 { |
|
39133 lPtr1 = src1 = lBuffer; |
|
39134 lPtr2 = src2 = src1 + lSrcWidth; |
|
39135 |
|
39136 for(k = 0; k < (lWidth - 2); k += 2) |
|
39137 { |
|
39138 lCr1 = lCrPtr[k >> 1]; |
|
39139 lCb1 = lCbPtr[k >> 1]; |
|
39140 |
|
39141 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
39142 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
39143 |
|
39144 lCr2 = (lCr1 + lCr2) >> 1; |
|
39145 lCb2 = (lCb1 + lCb2) >> 1; |
|
39146 |
|
39147 lCr1 -= 128; |
|
39148 lCb1 -= 128; |
|
39149 |
|
39150 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
39151 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
39152 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
39153 |
|
39154 /*First Pixel*/ |
|
39155 lY1 = lLumPtr[k]; |
|
39156 lY1 -= 16; |
|
39157 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39158 |
|
39159 lTemp = lY1 + lTemp1; |
|
39160 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39161 |
|
39162 lTemp = lY1 - lTemp2; |
|
39163 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39164 |
|
39165 lTemp = lY1 + lTemp3; |
|
39166 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39167 |
|
39168 /*Third Pixel*/ |
|
39169 lY1 = lLumPtr[k + lLumWidth]; |
|
39170 lY1 -= 16; |
|
39171 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39172 |
|
39173 lTemp = lY1 + lTemp1; |
|
39174 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39175 |
|
39176 lTemp = lY1 - lTemp2; |
|
39177 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39178 |
|
39179 lTemp = lY1 + lTemp3; |
|
39180 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39181 |
|
39182 |
|
39183 lCr2 -= 128; |
|
39184 lCb2 -= 128; |
|
39185 |
|
39186 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
39187 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
39188 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
39189 |
|
39190 /*Second Pixel*/ |
|
39191 lY1 = lLumPtr[k + 1]; |
|
39192 lY1 -= 16; |
|
39193 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39194 |
|
39195 lTemp = lY1 + lTemp1; |
|
39196 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39197 |
|
39198 lTemp = lY1 - lTemp2; |
|
39199 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39200 |
|
39201 lTemp = lY1 + lTemp3; |
|
39202 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39203 |
|
39204 |
|
39205 /*Fourth Pixel*/ |
|
39206 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
39207 lY1 -= 16; |
|
39208 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39209 |
|
39210 lTemp = lY1 + lTemp1; |
|
39211 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39212 |
|
39213 lTemp = lY1 - lTemp2; |
|
39214 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39215 |
|
39216 lTemp = lY1 + lTemp3; |
|
39217 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39218 |
|
39219 |
|
39220 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
39221 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
39222 |
|
39223 lCr2 = lCrPtr[(k + lLumWidth) >> 1 + 1]; |
|
39224 lCb2 = lCbPtr[(k + lLumWidth) >> 1 + 1]; |
|
39225 |
|
39226 lCr2 = (lCr1 + lCr2) >> 1; |
|
39227 lCb2 = (lCb1 + lCb2) >> 1; |
|
39228 |
|
39229 lCr1 -= 128; |
|
39230 lCb1 -= 128; |
|
39231 |
|
39232 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
39233 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
39234 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
39235 |
|
39236 |
|
39237 /*Fifth Pixel*/ |
|
39238 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
39239 lY1 -= 16; |
|
39240 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39241 |
|
39242 lTemp = lY1 + lTemp1; |
|
39243 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39244 |
|
39245 lTemp = lY1 - lTemp2; |
|
39246 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39247 |
|
39248 lTemp = lY1 + lTemp3; |
|
39249 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39250 |
|
39251 /*Seventh Pixel*/ |
|
39252 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
39253 lY1 -= 16; |
|
39254 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39255 |
|
39256 lTemp = lY1 + lTemp1; |
|
39257 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39258 |
|
39259 lTemp = lY1 - lTemp2; |
|
39260 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39261 |
|
39262 lTemp = lY1 + lTemp3; |
|
39263 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39264 |
|
39265 |
|
39266 lCr2 -= 128; |
|
39267 lCb2 -= 128; |
|
39268 |
|
39269 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
39270 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
39271 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
39272 |
|
39273 /*Sixth Pixel*/ |
|
39274 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
39275 lY1 -= 16; |
|
39276 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39277 |
|
39278 lTemp = lY1 + lTemp1; |
|
39279 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39280 |
|
39281 lTemp = lY1 - lTemp2; |
|
39282 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39283 |
|
39284 lTemp = lY1 + lTemp3; |
|
39285 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39286 |
|
39287 /*Eighth Pixel*/ |
|
39288 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
39289 lY1 -= 16; |
|
39290 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39291 |
|
39292 lTemp = lY1 + lTemp1; |
|
39293 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39294 |
|
39295 lTemp = lY1 - lTemp2; |
|
39296 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39297 |
|
39298 lTemp = lY1 + lTemp3; |
|
39299 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39300 |
|
39301 src1 += 6; |
|
39302 src2 += 6; |
|
39303 } |
|
39304 |
|
39305 |
|
39306 lCr1 = lCrPtr[k >> 1]; |
|
39307 lCb1 = lCbPtr[k >> 1]; |
|
39308 |
|
39309 lCr1 -= 128; |
|
39310 lCb1 -= 128; |
|
39311 |
|
39312 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
39313 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
39314 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
39315 |
|
39316 /*First Pixel*/ |
|
39317 lY1 = lLumPtr[k]; |
|
39318 lY1 -= 16; |
|
39319 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39320 |
|
39321 lTemp = lY1 + lTemp1; |
|
39322 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39323 |
|
39324 lTemp = lY1 - lTemp2; |
|
39325 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39326 |
|
39327 lTemp = lY1 + lTemp3; |
|
39328 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39329 |
|
39330 /*Third Pixel*/ |
|
39331 lY1 = lLumPtr[k + lLumWidth]; |
|
39332 lY1 -= 16; |
|
39333 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39334 |
|
39335 lTemp = lY1 + lTemp1; |
|
39336 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39337 |
|
39338 lTemp = lY1 - lTemp2; |
|
39339 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39340 |
|
39341 lTemp = lY1 + lTemp3; |
|
39342 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39343 |
|
39344 /*Second Pixel*/ |
|
39345 lY1 = lLumPtr[k + 1]; |
|
39346 lY1 -= 16; |
|
39347 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39348 |
|
39349 lTemp = lY1 + lTemp1; |
|
39350 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39351 |
|
39352 lTemp = lY1 - lTemp2; |
|
39353 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39354 |
|
39355 lTemp = lY1 + lTemp3; |
|
39356 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39357 |
|
39358 |
|
39359 /*Fourth Pixel*/ |
|
39360 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
39361 lY1 -= 16; |
|
39362 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39363 |
|
39364 lTemp = lY1 + lTemp1; |
|
39365 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39366 |
|
39367 lTemp = lY1 - lTemp2; |
|
39368 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39369 |
|
39370 lTemp = lY1 + lTemp3; |
|
39371 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39372 |
|
39373 |
|
39374 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
39375 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
39376 |
|
39377 lCr1 -= 128; |
|
39378 lCb1 -= 128; |
|
39379 |
|
39380 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
39381 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
39382 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
39383 |
|
39384 |
|
39385 /*Fifth Pixel*/ |
|
39386 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
39387 lY1 -= 16; |
|
39388 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39389 |
|
39390 lTemp = lY1 + lTemp1; |
|
39391 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39392 |
|
39393 lTemp = lY1 - lTemp2; |
|
39394 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39395 |
|
39396 lTemp = lY1 + lTemp3; |
|
39397 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39398 |
|
39399 /*Seventh Pixel*/ |
|
39400 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
39401 lY1 -= 16; |
|
39402 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39403 |
|
39404 lTemp = lY1 + lTemp1; |
|
39405 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39406 |
|
39407 lTemp = lY1 - lTemp2; |
|
39408 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39409 |
|
39410 lTemp = lY1 + lTemp3; |
|
39411 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39412 |
|
39413 /*Sixth Pixel*/ |
|
39414 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
39415 lY1 -= 16; |
|
39416 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39417 |
|
39418 lTemp = lY1 + lTemp1; |
|
39419 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39420 |
|
39421 lTemp = lY1 - lTemp2; |
|
39422 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39423 |
|
39424 lTemp = lY1 + lTemp3; |
|
39425 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39426 |
|
39427 /*Eighth Pixel*/ |
|
39428 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
39429 lY1 -= 16; |
|
39430 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
39431 |
|
39432 lTemp = lY1 + lTemp1; |
|
39433 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39434 |
|
39435 lTemp = lY1 - lTemp2; |
|
39436 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39437 |
|
39438 lTemp = lY1 + lTemp3; |
|
39439 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
39440 |
|
39441 src1 += 6; |
|
39442 src2 += 6; |
|
39443 |
|
39444 |
|
39445 src1 = lPtr1; |
|
39446 src2 = lPtr2; |
|
39447 |
|
39448 for(j = 0; j < lWidth; j += 2) |
|
39449 { |
|
39450 /* First Pixel */ |
|
39451 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
39452 diff1 = *src1 & 0x7; |
|
39453 diff2 = *(src1 + 1) & 0x3; |
|
39454 diff3 = *(src1 + 2) & 0x7; |
|
39455 |
|
39456 // diffuse the error |
|
39457 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
39458 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
39459 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
39460 |
|
39461 /* Second Pixel */ |
|
39462 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
39463 diff1 = *(src1 + 3) & 0x7; |
|
39464 diff2 = *(src1 + 4) & 0x3; |
|
39465 diff3 = *(src1 + 5) & 0x7; |
|
39466 // diffuse the error |
|
39467 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
39468 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
39469 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
39470 |
|
39471 src1 += 6; |
|
39472 dest1 += 2; |
|
39473 |
|
39474 /* Third Pixel */ |
|
39475 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
39476 diff1 = *src2 & 0x7; |
|
39477 diff2 = *(src2 + 1) & 0x3; |
|
39478 diff3 = *(src2 + 2) & 0x7; |
|
39479 //diffuse the error |
|
39480 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
39481 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
39482 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
39483 |
|
39484 /* Fourth Pixel */ |
|
39485 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
39486 diff1 = *(src2 + 3) & 0x7; |
|
39487 diff2 = *(src2 + 4) & 0x3; |
|
39488 diff3 = *(src2 + 5) & 0x7; |
|
39489 //diffuse the error |
|
39490 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
39491 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
39492 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
39493 |
|
39494 src2 += 6; |
|
39495 dest2 += 2; |
|
39496 } |
|
39497 if(extraCol) |
|
39498 { |
|
39499 *dest1 = dest1[-1]; |
|
39500 dest1++; |
|
39501 *dest2 = dest2[-1]; |
|
39502 dest2++; |
|
39503 } |
|
39504 |
|
39505 lLumPtr += (lLumWidth << 1); |
|
39506 lCrPtr += (lLumWidth >> 1); |
|
39507 lCbPtr += (lLumWidth >> 1); |
|
39508 |
|
39509 dest1 += ((wndWidth << 1) - lTempWidth); |
|
39510 dest2 += ((wndWidth << 1) - lTempWidth); |
|
39511 } |
|
39512 |
|
39513 if(extraRow) |
|
39514 { |
|
39515 dest2 = dest1 - wndWidth; |
|
39516 for(j = 0; j < lWidth; j += 2) |
|
39517 { |
|
39518 *dest1++ = *dest2++; |
|
39519 *dest1++ = *dest2++; |
|
39520 } |
|
39521 if(extraCol) |
|
39522 { |
|
39523 *dest1 = *dest2; |
|
39524 } |
|
39525 } |
|
39526 |
|
39527 free(lBuffer); |
|
39528 return; |
|
39529 } |
|
39530 |
|
39531 |
|
39532 /* |
|
39533 ****************************************************************************** |
|
39534 Name : sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_709_FR |
|
39535 Description : Converts YUV420 Chroma1 Planar to XRGB (4:4:4:4) Interleaved format |
|
39536 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
39537 uint8 *dstImage : Pointer to rgb data (o/p). |
|
39538 tWndParam *srcWindow : Pointer to structure containing source window |
|
39539 parameters like xOffset,yOffset,cropWidth, |
|
39540 cropHeight. (i/p) |
|
39541 tWndParam *dstWindow : Pointer to structure containing destination window |
|
39542 parameters like xOffset,yOffset,windWidth, |
|
39543 windHeight. (i/p) |
|
39544 Return Value : void |
|
39545 ****************************************************************************** |
|
39546 */ |
|
39547 |
|
39548 void sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_709_FR |
|
39549 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
39550 tWndParam* srcWindow, tWndParam* dstWindow) |
|
39551 { |
|
39552 uint16 *dest1, *dest2; |
|
39553 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
39554 uint8 *lBuffer; |
|
39555 uint8 *src1, *src2; |
|
39556 uint8 *lPtr1, *lPtr2; |
|
39557 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
39558 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
39559 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
39560 int32 diff1, diff2, diff3; |
|
39561 int32 i, j, k, extraRow, extraCol; |
|
39562 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
39563 cropWidth,cropHeight,wndWidth,wndHeight; |
|
39564 |
|
39565 srcXOffset = srcWindow->xOffset; |
|
39566 srcYOffset = srcWindow->yOffset; |
|
39567 cropWidth = srcWindow->wndWidth; |
|
39568 cropHeight = srcWindow->wndHeight; |
|
39569 |
|
39570 dstXOffset = dstWindow->xOffset; |
|
39571 dstYOffset = dstWindow->yOffset; |
|
39572 wndWidth = dstWindow->wndWidth; |
|
39573 wndHeight = dstWindow->wndHeight; |
|
39574 |
|
39575 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
39576 { |
|
39577 lWidth = cropWidth; |
|
39578 } |
|
39579 else |
|
39580 { |
|
39581 lWidth = srcImage->width - srcXOffset; |
|
39582 } |
|
39583 |
|
39584 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
39585 { |
|
39586 lHeight = cropHeight; |
|
39587 } |
|
39588 else |
|
39589 { |
|
39590 lHeight = srcImage->height - srcYOffset; |
|
39591 } |
|
39592 |
|
39593 if (lWidth > (wndWidth - dstXOffset)) |
|
39594 { |
|
39595 lWidth = wndWidth - dstXOffset; |
|
39596 } |
|
39597 |
|
39598 if (lHeight > (wndHeight - dstYOffset)) |
|
39599 { |
|
39600 lHeight = wndHeight - dstYOffset; |
|
39601 } |
|
39602 |
|
39603 extraCol = lWidth & 0x01; |
|
39604 extraRow = lHeight & 0x01; |
|
39605 |
|
39606 lTempWidth = lWidth; |
|
39607 lWidth = (lWidth >> 1) << 1; |
|
39608 lHeight = (lHeight >> 1) << 1; |
|
39609 |
|
39610 lBuffer = (uint8*) malloc(lWidth * 3 * 4); |
|
39611 |
|
39612 lSrcWidth = lWidth * 3; |
|
39613 |
|
39614 lLumWidth = (srcImage->width >> 1) << 1; |
|
39615 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
39616 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
39617 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
39618 |
|
39619 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
39620 dest2 = dest1 + wndWidth; |
|
39621 |
|
39622 for(i = 0; i < lHeight; i += 2) |
|
39623 { |
|
39624 lPtr1 = src1 = lBuffer; |
|
39625 lPtr2 = src2 = src1 + lSrcWidth; |
|
39626 |
|
39627 for(k = 0; k < (lWidth - 2); k += 2) |
|
39628 { |
|
39629 lCr1 = lCrPtr[k >> 1]; |
|
39630 lCb1 = lCbPtr[k >> 1]; |
|
39631 |
|
39632 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
39633 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
39634 |
|
39635 lCr2 = (lCr1 + lCr2) >> 1; |
|
39636 lCb2 = (lCb1 + lCb2) >> 1; |
|
39637 |
|
39638 lCr1 -= 128; |
|
39639 lCb1 -= 128; |
|
39640 |
|
39641 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
39642 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
39643 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
39644 |
|
39645 /*First Pixel*/ |
|
39646 lY1 = lLumPtr[k]; |
|
39647 |
|
39648 lTemp = lY1 + lTemp1; |
|
39649 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39650 |
|
39651 lTemp = lY1 - lTemp2; |
|
39652 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39653 |
|
39654 lTemp = lY1 + lTemp3; |
|
39655 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39656 |
|
39657 /*Third Pixel*/ |
|
39658 lY1 = lLumPtr[k + lLumWidth]; |
|
39659 |
|
39660 lTemp = lY1 + lTemp1; |
|
39661 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39662 |
|
39663 lTemp = lY1 - lTemp2; |
|
39664 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39665 |
|
39666 lTemp = lY1 + lTemp3; |
|
39667 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39668 |
|
39669 |
|
39670 lCr2 -= 128; |
|
39671 lCb2 -= 128; |
|
39672 |
|
39673 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
39674 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
39675 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
39676 |
|
39677 /*Second Pixel*/ |
|
39678 lY1 = lLumPtr[k + 1]; |
|
39679 |
|
39680 lTemp = lY1 + lTemp1; |
|
39681 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39682 |
|
39683 lTemp = lY1 - lTemp2; |
|
39684 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39685 |
|
39686 lTemp = lY1 + lTemp3; |
|
39687 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39688 |
|
39689 |
|
39690 /*Fourth Pixel*/ |
|
39691 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
39692 |
|
39693 lTemp = lY1 + lTemp1; |
|
39694 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39695 |
|
39696 lTemp = lY1 - lTemp2; |
|
39697 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39698 |
|
39699 lTemp = lY1 + lTemp3; |
|
39700 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39701 |
|
39702 |
|
39703 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
39704 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
39705 |
|
39706 lCr2 = lCrPtr[(k + lLumWidth) >> 1 + 1]; |
|
39707 lCb2 = lCbPtr[(k + lLumWidth) >> 1 + 1]; |
|
39708 |
|
39709 lCr2 = (lCr1 + lCr2) >> 1; |
|
39710 lCb2 = (lCb1 + lCb2) >> 1; |
|
39711 |
|
39712 lCr1 -= 128; |
|
39713 lCb1 -= 128; |
|
39714 |
|
39715 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
39716 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
39717 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
39718 |
|
39719 |
|
39720 /*Fifth Pixel*/ |
|
39721 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
39722 |
|
39723 lTemp = lY1 + lTemp1; |
|
39724 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39725 |
|
39726 lTemp = lY1 - lTemp2; |
|
39727 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39728 |
|
39729 lTemp = lY1 + lTemp3; |
|
39730 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39731 |
|
39732 /*Seventh Pixel*/ |
|
39733 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
39734 |
|
39735 lTemp = lY1 + lTemp1; |
|
39736 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39737 |
|
39738 lTemp = lY1 - lTemp2; |
|
39739 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39740 |
|
39741 lTemp = lY1 + lTemp3; |
|
39742 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39743 |
|
39744 |
|
39745 lCr2 -= 128; |
|
39746 lCb2 -= 128; |
|
39747 |
|
39748 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
39749 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
39750 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
39751 |
|
39752 /*Sixth Pixel*/ |
|
39753 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
39754 |
|
39755 lTemp = lY1 + lTemp1; |
|
39756 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39757 |
|
39758 lTemp = lY1 - lTemp2; |
|
39759 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39760 |
|
39761 lTemp = lY1 + lTemp3; |
|
39762 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39763 |
|
39764 /*Eighth Pixel*/ |
|
39765 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
39766 |
|
39767 lTemp = lY1 + lTemp1; |
|
39768 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39769 |
|
39770 lTemp = lY1 - lTemp2; |
|
39771 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39772 |
|
39773 lTemp = lY1 + lTemp3; |
|
39774 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39775 |
|
39776 src1 += 6; |
|
39777 src2 += 6; |
|
39778 } |
|
39779 |
|
39780 |
|
39781 lCr1 = lCrPtr[k >> 1]; |
|
39782 lCb1 = lCbPtr[k >> 1]; |
|
39783 |
|
39784 lCr1 -= 128; |
|
39785 lCb1 -= 128; |
|
39786 |
|
39787 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
39788 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
39789 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
39790 |
|
39791 /*First Pixel*/ |
|
39792 lY1 = lLumPtr[k]; |
|
39793 |
|
39794 lTemp = lY1 + lTemp1; |
|
39795 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39796 |
|
39797 lTemp = lY1 - lTemp2; |
|
39798 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39799 |
|
39800 lTemp = lY1 + lTemp3; |
|
39801 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39802 |
|
39803 /*Third Pixel*/ |
|
39804 lY1 = lLumPtr[k + lLumWidth]; |
|
39805 |
|
39806 lTemp = lY1 + lTemp1; |
|
39807 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39808 |
|
39809 lTemp = lY1 - lTemp2; |
|
39810 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39811 |
|
39812 lTemp = lY1 + lTemp3; |
|
39813 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39814 |
|
39815 /*Second Pixel*/ |
|
39816 lY1 = lLumPtr[k + 1]; |
|
39817 |
|
39818 lTemp = lY1 + lTemp1; |
|
39819 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39820 |
|
39821 lTemp = lY1 - lTemp2; |
|
39822 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39823 |
|
39824 lTemp = lY1 + lTemp3; |
|
39825 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39826 |
|
39827 |
|
39828 /*Fourth Pixel*/ |
|
39829 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
39830 |
|
39831 lTemp = lY1 + lTemp1; |
|
39832 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39833 |
|
39834 lTemp = lY1 - lTemp2; |
|
39835 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39836 |
|
39837 lTemp = lY1 + lTemp3; |
|
39838 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39839 |
|
39840 |
|
39841 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
39842 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
39843 |
|
39844 lCr1 -= 128; |
|
39845 lCb1 -= 128; |
|
39846 |
|
39847 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
39848 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
39849 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
39850 |
|
39851 |
|
39852 /*Fifth Pixel*/ |
|
39853 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
39854 |
|
39855 lTemp = lY1 + lTemp1; |
|
39856 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39857 |
|
39858 lTemp = lY1 - lTemp2; |
|
39859 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39860 |
|
39861 lTemp = lY1 + lTemp3; |
|
39862 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39863 |
|
39864 /*Seventh Pixel*/ |
|
39865 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
39866 |
|
39867 lTemp = lY1 + lTemp1; |
|
39868 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39869 |
|
39870 lTemp = lY1 - lTemp2; |
|
39871 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39872 |
|
39873 lTemp = lY1 + lTemp3; |
|
39874 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39875 |
|
39876 /*Sixth Pixel*/ |
|
39877 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
39878 |
|
39879 lTemp = lY1 + lTemp1; |
|
39880 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39881 |
|
39882 lTemp = lY1 - lTemp2; |
|
39883 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39884 |
|
39885 lTemp = lY1 + lTemp3; |
|
39886 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39887 |
|
39888 /*Eighth Pixel*/ |
|
39889 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
39890 |
|
39891 lTemp = lY1 + lTemp1; |
|
39892 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39893 |
|
39894 lTemp = lY1 - lTemp2; |
|
39895 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39896 |
|
39897 lTemp = lY1 + lTemp3; |
|
39898 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
39899 |
|
39900 src1 += 6; |
|
39901 src2 += 6; |
|
39902 |
|
39903 |
|
39904 src1 = lPtr1; |
|
39905 src2 = lPtr2; |
|
39906 |
|
39907 for(j = 0; j < lWidth; j += 2) |
|
39908 { |
|
39909 /* First Pixel */ |
|
39910 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
39911 diff1 = *src1 & 0xf; |
|
39912 diff2 = *(src1 + 1) & 0xf; |
|
39913 diff3 = *(src1 + 2) & 0xf; |
|
39914 |
|
39915 // diffuse the error |
|
39916 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
39917 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
39918 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
39919 |
|
39920 /* Second Pixel */ |
|
39921 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
39922 diff1 = *(src1 + 3) & 0xf; |
|
39923 diff2 = *(src1 + 4) & 0xf; |
|
39924 diff3 = *(src1 + 5) & 0xf; |
|
39925 // diffuse the error |
|
39926 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
39927 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
39928 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
39929 |
|
39930 src1 += 6; |
|
39931 dest1 += 2; |
|
39932 |
|
39933 /* Third Pixel */ |
|
39934 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
39935 diff1 = *src2 & 0xf; |
|
39936 diff2 = *(src2 + 1) & 0xf; |
|
39937 diff3 = *(src2 + 2) & 0xf; |
|
39938 //diffuse the error |
|
39939 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
39940 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
39941 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
39942 |
|
39943 /* Fourth Pixel */ |
|
39944 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
39945 diff1 = *(src2 + 3) & 0xf; |
|
39946 diff2 = *(src2 + 4) & 0xf; |
|
39947 diff3 = *(src2 + 5) & 0xf; |
|
39948 //diffuse the error |
|
39949 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
39950 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
39951 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
39952 |
|
39953 src2 += 6; |
|
39954 dest2 += 2; |
|
39955 } |
|
39956 if(extraCol) |
|
39957 { |
|
39958 *dest1 = dest1[-1]; |
|
39959 dest1++; |
|
39960 *dest2 = dest2[-1]; |
|
39961 dest2++; |
|
39962 } |
|
39963 |
|
39964 lLumPtr += (lLumWidth << 1); |
|
39965 lCrPtr += (lLumWidth >> 1); |
|
39966 lCbPtr += (lLumWidth >> 1); |
|
39967 |
|
39968 dest1 += ((wndWidth << 1) - lTempWidth); |
|
39969 dest2 += ((wndWidth << 1) - lTempWidth); |
|
39970 } |
|
39971 |
|
39972 if(extraRow) |
|
39973 { |
|
39974 dest2 = dest1 - wndWidth; |
|
39975 for(j = 0; j < lWidth; j += 2) |
|
39976 { |
|
39977 *dest1++ = *dest2++; |
|
39978 *dest1++ = *dest2++; |
|
39979 } |
|
39980 if(extraCol) |
|
39981 { |
|
39982 *dest1 = *dest2; |
|
39983 } |
|
39984 } |
|
39985 |
|
39986 free(lBuffer); |
|
39987 return; |
|
39988 } |
|
39989 |
|
39990 /* |
|
39991 ****************************************************************************** |
|
39992 Name : sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_601_5_FR |
|
39993 Description : Converts YUV420 Chroma1 Planar to XRGB (4:4:4:4) Interleaved format |
|
39994 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
39995 uint8 *dstImage : Pointer to rgb data (o/p). |
|
39996 tWndParam *srcWindow : Pointer to structure containing source window |
|
39997 parameters like xOffset,yOffset,cropWidth, |
|
39998 cropHeight. (i/p) |
|
39999 tWndParam *dstWindow : Pointer to structure containing destination window |
|
40000 parameters like xOffset,yOffset,windWidth, |
|
40001 windHeight. (i/p) |
|
40002 Return Value : void |
|
40003 ****************************************************************************** |
|
40004 */ |
|
40005 |
|
40006 void sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_601_5_FR |
|
40007 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
40008 tWndParam* srcWindow, tWndParam* dstWindow) |
|
40009 { |
|
40010 uint16 *dest1, *dest2; |
|
40011 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
40012 uint8 *lBuffer; |
|
40013 uint8 *src1, *src2; |
|
40014 uint8 *lPtr1, *lPtr2; |
|
40015 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
40016 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
40017 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
40018 int32 diff1, diff2, diff3; |
|
40019 int32 i, j, k, extraRow, extraCol; |
|
40020 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
40021 cropWidth,cropHeight,wndWidth,wndHeight; |
|
40022 |
|
40023 srcXOffset = srcWindow->xOffset; |
|
40024 srcYOffset = srcWindow->yOffset; |
|
40025 cropWidth = srcWindow->wndWidth; |
|
40026 cropHeight = srcWindow->wndHeight; |
|
40027 |
|
40028 dstXOffset = dstWindow->xOffset; |
|
40029 dstYOffset = dstWindow->yOffset; |
|
40030 wndWidth = dstWindow->wndWidth; |
|
40031 wndHeight = dstWindow->wndHeight; |
|
40032 |
|
40033 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
40034 { |
|
40035 lWidth = cropWidth; |
|
40036 } |
|
40037 else |
|
40038 { |
|
40039 lWidth = srcImage->width - srcXOffset; |
|
40040 } |
|
40041 |
|
40042 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
40043 { |
|
40044 lHeight = cropHeight; |
|
40045 } |
|
40046 else |
|
40047 { |
|
40048 lHeight = srcImage->height - srcYOffset; |
|
40049 } |
|
40050 |
|
40051 if (lWidth > (wndWidth - dstXOffset)) |
|
40052 { |
|
40053 lWidth = wndWidth - dstXOffset; |
|
40054 } |
|
40055 |
|
40056 if (lHeight > (wndHeight - dstYOffset)) |
|
40057 { |
|
40058 lHeight = wndHeight - dstYOffset; |
|
40059 } |
|
40060 |
|
40061 extraCol = lWidth & 0x01; |
|
40062 extraRow = lHeight & 0x01; |
|
40063 |
|
40064 lTempWidth = lWidth; |
|
40065 lWidth = (lWidth >> 1) << 1; |
|
40066 lHeight = (lHeight >> 1) << 1; |
|
40067 |
|
40068 lBuffer = (uint8*) malloc(lWidth * 3 * 4); |
|
40069 |
|
40070 lSrcWidth = lWidth * 3; |
|
40071 |
|
40072 lLumWidth = (srcImage->width >> 1) << 1; |
|
40073 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
40074 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
40075 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
40076 |
|
40077 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
40078 dest2 = dest1 + wndWidth; |
|
40079 |
|
40080 for(i = 0; i < lHeight; i += 2) |
|
40081 { |
|
40082 lPtr1 = src1 = lBuffer; |
|
40083 lPtr2 = src2 = src1 + lSrcWidth; |
|
40084 |
|
40085 for(k = 0; k < (lWidth - 2); k += 2) |
|
40086 { |
|
40087 lCr1 = lCrPtr[k >> 1]; |
|
40088 lCb1 = lCbPtr[k >> 1]; |
|
40089 |
|
40090 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
40091 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
40092 |
|
40093 lCr2 = (lCr1 + lCr2) >> 1; |
|
40094 lCb2 = (lCb1 + lCb2) >> 1; |
|
40095 |
|
40096 lCr1 -= 128; |
|
40097 lCb1 -= 128; |
|
40098 |
|
40099 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
40100 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
40101 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
40102 |
|
40103 /*First Pixel*/ |
|
40104 lY1 = lLumPtr[k]; |
|
40105 |
|
40106 lTemp = lY1 + lTemp1; |
|
40107 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40108 |
|
40109 lTemp = lY1 - lTemp2; |
|
40110 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40111 |
|
40112 lTemp = lY1 + lTemp3; |
|
40113 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40114 |
|
40115 /*Third Pixel*/ |
|
40116 lY1 = lLumPtr[k + lLumWidth]; |
|
40117 |
|
40118 lTemp = lY1 + lTemp1; |
|
40119 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40120 |
|
40121 lTemp = lY1 - lTemp2; |
|
40122 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40123 |
|
40124 lTemp = lY1 + lTemp3; |
|
40125 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40126 |
|
40127 |
|
40128 lCr2 -= 128; |
|
40129 lCb2 -= 128; |
|
40130 |
|
40131 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
40132 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
40133 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
40134 |
|
40135 /*Second Pixel*/ |
|
40136 lY1 = lLumPtr[k + 1]; |
|
40137 |
|
40138 lTemp = lY1 + lTemp1; |
|
40139 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40140 |
|
40141 lTemp = lY1 - lTemp2; |
|
40142 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40143 |
|
40144 lTemp = lY1 + lTemp3; |
|
40145 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40146 |
|
40147 |
|
40148 /*Fourth Pixel*/ |
|
40149 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
40150 |
|
40151 lTemp = lY1 + lTemp1; |
|
40152 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40153 |
|
40154 lTemp = lY1 - lTemp2; |
|
40155 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40156 |
|
40157 lTemp = lY1 + lTemp3; |
|
40158 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40159 |
|
40160 |
|
40161 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
40162 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
40163 |
|
40164 lCr2 = lCrPtr[(k + lLumWidth) >> 1 + 1]; |
|
40165 lCb2 = lCbPtr[(k + lLumWidth) >> 1 + 1]; |
|
40166 |
|
40167 lCr2 = (lCr1 + lCr2) >> 1; |
|
40168 lCb2 = (lCb1 + lCb2) >> 1; |
|
40169 |
|
40170 lCr1 -= 128; |
|
40171 lCb1 -= 128; |
|
40172 |
|
40173 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
40174 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
40175 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
40176 |
|
40177 |
|
40178 /*Fifth Pixel*/ |
|
40179 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
40180 |
|
40181 lTemp = lY1 + lTemp1; |
|
40182 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40183 |
|
40184 lTemp = lY1 - lTemp2; |
|
40185 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40186 |
|
40187 lTemp = lY1 + lTemp3; |
|
40188 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40189 |
|
40190 /*Seventh Pixel*/ |
|
40191 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
40192 |
|
40193 lTemp = lY1 + lTemp1; |
|
40194 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40195 |
|
40196 lTemp = lY1 - lTemp2; |
|
40197 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40198 |
|
40199 lTemp = lY1 + lTemp3; |
|
40200 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40201 |
|
40202 |
|
40203 lCr2 -= 128; |
|
40204 lCb2 -= 128; |
|
40205 |
|
40206 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
40207 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
40208 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
40209 |
|
40210 /*Sixth Pixel*/ |
|
40211 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
40212 |
|
40213 lTemp = lY1 + lTemp1; |
|
40214 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40215 |
|
40216 lTemp = lY1 - lTemp2; |
|
40217 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40218 |
|
40219 lTemp = lY1 + lTemp3; |
|
40220 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40221 |
|
40222 /*Eighth Pixel*/ |
|
40223 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
40224 |
|
40225 lTemp = lY1 + lTemp1; |
|
40226 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40227 |
|
40228 lTemp = lY1 - lTemp2; |
|
40229 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40230 |
|
40231 lTemp = lY1 + lTemp3; |
|
40232 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40233 |
|
40234 src1 += 6; |
|
40235 src2 += 6; |
|
40236 } |
|
40237 |
|
40238 |
|
40239 lCr1 = lCrPtr[k >> 1]; |
|
40240 lCb1 = lCbPtr[k >> 1]; |
|
40241 |
|
40242 lCr1 -= 128; |
|
40243 lCb1 -= 128; |
|
40244 |
|
40245 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
40246 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
40247 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
40248 |
|
40249 /*First Pixel*/ |
|
40250 lY1 = lLumPtr[k]; |
|
40251 |
|
40252 lTemp = lY1 + lTemp1; |
|
40253 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40254 |
|
40255 lTemp = lY1 - lTemp2; |
|
40256 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40257 |
|
40258 lTemp = lY1 + lTemp3; |
|
40259 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40260 |
|
40261 /*Third Pixel*/ |
|
40262 lY1 = lLumPtr[k + lLumWidth]; |
|
40263 |
|
40264 lTemp = lY1 + lTemp1; |
|
40265 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40266 |
|
40267 lTemp = lY1 - lTemp2; |
|
40268 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40269 |
|
40270 lTemp = lY1 + lTemp3; |
|
40271 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40272 |
|
40273 /*Second Pixel*/ |
|
40274 lY1 = lLumPtr[k + 1]; |
|
40275 |
|
40276 lTemp = lY1 + lTemp1; |
|
40277 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40278 |
|
40279 lTemp = lY1 - lTemp2; |
|
40280 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40281 |
|
40282 lTemp = lY1 + lTemp3; |
|
40283 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40284 |
|
40285 |
|
40286 /*Fourth Pixel*/ |
|
40287 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
40288 |
|
40289 lTemp = lY1 + lTemp1; |
|
40290 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40291 |
|
40292 lTemp = lY1 - lTemp2; |
|
40293 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40294 |
|
40295 lTemp = lY1 + lTemp3; |
|
40296 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40297 |
|
40298 |
|
40299 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
40300 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
40301 |
|
40302 lCr1 -= 128; |
|
40303 lCb1 -= 128; |
|
40304 |
|
40305 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
40306 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
40307 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
40308 |
|
40309 |
|
40310 /*Fifth Pixel*/ |
|
40311 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
40312 |
|
40313 lTemp = lY1 + lTemp1; |
|
40314 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40315 |
|
40316 lTemp = lY1 - lTemp2; |
|
40317 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40318 |
|
40319 lTemp = lY1 + lTemp3; |
|
40320 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40321 |
|
40322 /*Seventh Pixel*/ |
|
40323 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
40324 |
|
40325 lTemp = lY1 + lTemp1; |
|
40326 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40327 |
|
40328 lTemp = lY1 - lTemp2; |
|
40329 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40330 |
|
40331 lTemp = lY1 + lTemp3; |
|
40332 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40333 |
|
40334 /*Sixth Pixel*/ |
|
40335 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
40336 |
|
40337 lTemp = lY1 + lTemp1; |
|
40338 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40339 |
|
40340 lTemp = lY1 - lTemp2; |
|
40341 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40342 |
|
40343 lTemp = lY1 + lTemp3; |
|
40344 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40345 |
|
40346 /*Eighth Pixel*/ |
|
40347 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
40348 |
|
40349 lTemp = lY1 + lTemp1; |
|
40350 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40351 |
|
40352 lTemp = lY1 - lTemp2; |
|
40353 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40354 |
|
40355 lTemp = lY1 + lTemp3; |
|
40356 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
40357 |
|
40358 src1 += 6; |
|
40359 src2 += 6; |
|
40360 |
|
40361 |
|
40362 src1 = lPtr1; |
|
40363 src2 = lPtr2; |
|
40364 |
|
40365 for(j = 0; j < lWidth; j += 2) |
|
40366 { |
|
40367 /* First Pixel */ |
|
40368 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
40369 diff1 = *src1 & 0xf; |
|
40370 diff2 = *(src1 + 1) & 0xf; |
|
40371 diff3 = *(src1 + 2) & 0xf; |
|
40372 |
|
40373 // diffuse the error |
|
40374 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
40375 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
40376 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
40377 |
|
40378 /* Second Pixel */ |
|
40379 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
40380 diff1 = *(src1 + 3) & 0xf; |
|
40381 diff2 = *(src1 + 4) & 0xf; |
|
40382 diff3 = *(src1 + 5) & 0xf; |
|
40383 // diffuse the error |
|
40384 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
40385 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
40386 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
40387 |
|
40388 src1 += 6; |
|
40389 dest1 += 2; |
|
40390 |
|
40391 /* Third Pixel */ |
|
40392 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
40393 diff1 = *src2 & 0xf; |
|
40394 diff2 = *(src2 + 1) & 0xf; |
|
40395 diff3 = *(src2 + 2) & 0xf; |
|
40396 //diffuse the error |
|
40397 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
40398 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
40399 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
40400 |
|
40401 /* Fourth Pixel */ |
|
40402 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
40403 diff1 = *(src2 + 3) & 0xf; |
|
40404 diff2 = *(src2 + 4) & 0xf; |
|
40405 diff3 = *(src2 + 5) & 0xf; |
|
40406 //diffuse the error |
|
40407 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
40408 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
40409 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
40410 |
|
40411 src2 += 6; |
|
40412 dest2 += 2; |
|
40413 } |
|
40414 if(extraCol) |
|
40415 { |
|
40416 *dest1 = dest1[-1]; |
|
40417 dest1++; |
|
40418 *dest2 = dest2[-1]; |
|
40419 dest2++; |
|
40420 } |
|
40421 |
|
40422 lLumPtr += (lLumWidth << 1); |
|
40423 lCrPtr += (lLumWidth >> 1); |
|
40424 lCbPtr += (lLumWidth >> 1); |
|
40425 |
|
40426 dest1 += ((wndWidth << 1) - lTempWidth); |
|
40427 dest2 += ((wndWidth << 1) - lTempWidth); |
|
40428 } |
|
40429 |
|
40430 if(extraRow) |
|
40431 { |
|
40432 dest2 = dest1 - wndWidth; |
|
40433 for(j = 0; j < lWidth; j += 2) |
|
40434 { |
|
40435 *dest1++ = *dest2++; |
|
40436 *dest1++ = *dest2++; |
|
40437 } |
|
40438 if(extraCol) |
|
40439 { |
|
40440 *dest1 = *dest2; |
|
40441 } |
|
40442 } |
|
40443 |
|
40444 free(lBuffer); |
|
40445 return; |
|
40446 } |
|
40447 |
|
40448 /* |
|
40449 ****************************************************************************** |
|
40450 Name : sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_709_RR |
|
40451 Description : Converts YUV420 Chroma1 Planar to XRGB (4:4:4:4) Interleaved format |
|
40452 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
40453 uint8 *dstImage : Pointer to rgb data (o/p). |
|
40454 tWndParam *srcWindow : Pointer to structure containing source window |
|
40455 parameters like xOffset,yOffset,cropWidth, |
|
40456 cropHeight. (i/p) |
|
40457 tWndParam *dstWindow : Pointer to structure containing destination window |
|
40458 parameters like xOffset,yOffset,windWidth, |
|
40459 windHeight. (i/p) |
|
40460 Return Value : void |
|
40461 ****************************************************************************** |
|
40462 */ |
|
40463 |
|
40464 void sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_709_RR |
|
40465 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
40466 tWndParam* srcWindow, tWndParam* dstWindow) |
|
40467 { |
|
40468 uint16 *dest1, *dest2; |
|
40469 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
40470 uint8 *lBuffer; |
|
40471 uint8 *src1, *src2; |
|
40472 uint8 *lPtr1, *lPtr2; |
|
40473 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
40474 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
40475 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
40476 int32 diff1, diff2, diff3; |
|
40477 int32 i, j, k, extraRow, extraCol; |
|
40478 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
40479 cropWidth,cropHeight,wndWidth,wndHeight; |
|
40480 |
|
40481 srcXOffset = srcWindow->xOffset; |
|
40482 srcYOffset = srcWindow->yOffset; |
|
40483 cropWidth = srcWindow->wndWidth; |
|
40484 cropHeight = srcWindow->wndHeight; |
|
40485 |
|
40486 dstXOffset = dstWindow->xOffset; |
|
40487 dstYOffset = dstWindow->yOffset; |
|
40488 wndWidth = dstWindow->wndWidth; |
|
40489 wndHeight = dstWindow->wndHeight; |
|
40490 |
|
40491 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
40492 { |
|
40493 lWidth = cropWidth; |
|
40494 } |
|
40495 else |
|
40496 { |
|
40497 lWidth = srcImage->width - srcXOffset; |
|
40498 } |
|
40499 |
|
40500 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
40501 { |
|
40502 lHeight = cropHeight; |
|
40503 } |
|
40504 else |
|
40505 { |
|
40506 lHeight = srcImage->height - srcYOffset; |
|
40507 } |
|
40508 |
|
40509 if (lWidth > (wndWidth - dstXOffset)) |
|
40510 { |
|
40511 lWidth = wndWidth - dstXOffset; |
|
40512 } |
|
40513 |
|
40514 if (lHeight > (wndHeight - dstYOffset)) |
|
40515 { |
|
40516 lHeight = wndHeight - dstYOffset; |
|
40517 } |
|
40518 |
|
40519 extraCol = lWidth & 0x01; |
|
40520 extraRow = lHeight & 0x01; |
|
40521 |
|
40522 lTempWidth = lWidth; |
|
40523 lWidth = (lWidth >> 1) << 1; |
|
40524 lHeight = (lHeight >> 1) << 1; |
|
40525 |
|
40526 lBuffer = (uint8*) malloc(lWidth * 3 * 4); |
|
40527 |
|
40528 lSrcWidth = lWidth * 3; |
|
40529 |
|
40530 lLumWidth = (srcImage->width >> 1) << 1; |
|
40531 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
40532 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
40533 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
40534 |
|
40535 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
40536 dest2 = dest1 + wndWidth; |
|
40537 |
|
40538 for(i = 0; i < lHeight; i += 2) |
|
40539 { |
|
40540 lPtr1 = src1 = lBuffer; |
|
40541 lPtr2 = src2 = src1 + lSrcWidth; |
|
40542 |
|
40543 for(k = 0; k < (lWidth - 2); k += 2) |
|
40544 { |
|
40545 lCr1 = lCrPtr[k >> 1]; |
|
40546 lCb1 = lCbPtr[k >> 1]; |
|
40547 |
|
40548 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
40549 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
40550 |
|
40551 lCr2 = (lCr1 + lCr2) >> 1; |
|
40552 lCb2 = (lCb1 + lCb2) >> 1; |
|
40553 |
|
40554 lCr1 -= 128; |
|
40555 lCb1 -= 128; |
|
40556 |
|
40557 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
40558 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
40559 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
40560 |
|
40561 /*First Pixel*/ |
|
40562 lY1 = lLumPtr[k]; |
|
40563 lY1 -= 16; |
|
40564 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40565 |
|
40566 lTemp = lY1 + lTemp1; |
|
40567 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40568 |
|
40569 lTemp = lY1 - lTemp2; |
|
40570 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40571 |
|
40572 lTemp = lY1 + lTemp3; |
|
40573 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40574 |
|
40575 /*Third Pixel*/ |
|
40576 lY1 = lLumPtr[k + lLumWidth]; |
|
40577 lY1 -= 16; |
|
40578 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40579 |
|
40580 lTemp = lY1 + lTemp1; |
|
40581 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40582 |
|
40583 lTemp = lY1 - lTemp2; |
|
40584 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40585 |
|
40586 lTemp = lY1 + lTemp3; |
|
40587 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40588 |
|
40589 |
|
40590 lCr2 -= 128; |
|
40591 lCb2 -= 128; |
|
40592 |
|
40593 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
40594 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
40595 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
40596 |
|
40597 /*Second Pixel*/ |
|
40598 lY1 = lLumPtr[k + 1]; |
|
40599 lY1 -= 16; |
|
40600 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40601 |
|
40602 lTemp = lY1 + lTemp1; |
|
40603 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40604 |
|
40605 lTemp = lY1 - lTemp2; |
|
40606 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40607 |
|
40608 lTemp = lY1 + lTemp3; |
|
40609 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40610 |
|
40611 |
|
40612 /*Fourth Pixel*/ |
|
40613 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
40614 lY1 -= 16; |
|
40615 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40616 |
|
40617 lTemp = lY1 + lTemp1; |
|
40618 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40619 |
|
40620 lTemp = lY1 - lTemp2; |
|
40621 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40622 |
|
40623 lTemp = lY1 + lTemp3; |
|
40624 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40625 |
|
40626 |
|
40627 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
40628 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
40629 |
|
40630 lCr2 = lCrPtr[(k + lLumWidth) >> 1 + 1]; |
|
40631 lCb2 = lCbPtr[(k + lLumWidth) >> 1 + 1]; |
|
40632 |
|
40633 lCr2 = (lCr1 + lCr2) >> 1; |
|
40634 lCb2 = (lCb1 + lCb2) >> 1; |
|
40635 |
|
40636 lCr1 -= 128; |
|
40637 lCb1 -= 128; |
|
40638 |
|
40639 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
40640 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
40641 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
40642 |
|
40643 |
|
40644 /*Fifth Pixel*/ |
|
40645 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
40646 lY1 -= 16; |
|
40647 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40648 |
|
40649 lTemp = lY1 + lTemp1; |
|
40650 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40651 |
|
40652 lTemp = lY1 - lTemp2; |
|
40653 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40654 |
|
40655 lTemp = lY1 + lTemp3; |
|
40656 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40657 |
|
40658 /*Seventh Pixel*/ |
|
40659 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
40660 lY1 -= 16; |
|
40661 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40662 |
|
40663 lTemp = lY1 + lTemp1; |
|
40664 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40665 |
|
40666 lTemp = lY1 - lTemp2; |
|
40667 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40668 |
|
40669 lTemp = lY1 + lTemp3; |
|
40670 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40671 |
|
40672 |
|
40673 lCr2 -= 128; |
|
40674 lCb2 -= 128; |
|
40675 |
|
40676 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
40677 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
40678 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
40679 |
|
40680 /*Sixth Pixel*/ |
|
40681 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
40682 lY1 -= 16; |
|
40683 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40684 |
|
40685 lTemp = lY1 + lTemp1; |
|
40686 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40687 |
|
40688 lTemp = lY1 - lTemp2; |
|
40689 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40690 |
|
40691 lTemp = lY1 + lTemp3; |
|
40692 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40693 |
|
40694 /*Eighth Pixel*/ |
|
40695 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
40696 lY1 -= 16; |
|
40697 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40698 |
|
40699 lTemp = lY1 + lTemp1; |
|
40700 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40701 |
|
40702 lTemp = lY1 - lTemp2; |
|
40703 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40704 |
|
40705 lTemp = lY1 + lTemp3; |
|
40706 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40707 |
|
40708 src1 += 6; |
|
40709 src2 += 6; |
|
40710 } |
|
40711 |
|
40712 |
|
40713 lCr1 = lCrPtr[k >> 1]; |
|
40714 lCb1 = lCbPtr[k >> 1]; |
|
40715 |
|
40716 lCr1 -= 128; |
|
40717 lCb1 -= 128; |
|
40718 |
|
40719 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
40720 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
40721 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
40722 |
|
40723 /*First Pixel*/ |
|
40724 lY1 = lLumPtr[k]; |
|
40725 lY1 -= 16; |
|
40726 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40727 |
|
40728 lTemp = lY1 + lTemp1; |
|
40729 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40730 |
|
40731 lTemp = lY1 - lTemp2; |
|
40732 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40733 |
|
40734 lTemp = lY1 + lTemp3; |
|
40735 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40736 |
|
40737 /*Third Pixel*/ |
|
40738 lY1 = lLumPtr[k + lLumWidth]; |
|
40739 lY1 -= 16; |
|
40740 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40741 |
|
40742 lTemp = lY1 + lTemp1; |
|
40743 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40744 |
|
40745 lTemp = lY1 - lTemp2; |
|
40746 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40747 |
|
40748 lTemp = lY1 + lTemp3; |
|
40749 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40750 |
|
40751 /*Second Pixel*/ |
|
40752 lY1 = lLumPtr[k + 1]; |
|
40753 lY1 -= 16; |
|
40754 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40755 |
|
40756 lTemp = lY1 + lTemp1; |
|
40757 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40758 |
|
40759 lTemp = lY1 - lTemp2; |
|
40760 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40761 |
|
40762 lTemp = lY1 + lTemp3; |
|
40763 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40764 |
|
40765 |
|
40766 /*Fourth Pixel*/ |
|
40767 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
40768 lY1 -= 16; |
|
40769 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40770 |
|
40771 lTemp = lY1 + lTemp1; |
|
40772 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40773 |
|
40774 lTemp = lY1 - lTemp2; |
|
40775 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40776 |
|
40777 lTemp = lY1 + lTemp3; |
|
40778 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40779 |
|
40780 |
|
40781 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
40782 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
40783 |
|
40784 lCr1 -= 128; |
|
40785 lCb1 -= 128; |
|
40786 |
|
40787 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
40788 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
40789 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
40790 |
|
40791 |
|
40792 /*Fifth Pixel*/ |
|
40793 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
40794 lY1 -= 16; |
|
40795 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40796 |
|
40797 lTemp = lY1 + lTemp1; |
|
40798 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40799 |
|
40800 lTemp = lY1 - lTemp2; |
|
40801 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40802 |
|
40803 lTemp = lY1 + lTemp3; |
|
40804 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40805 |
|
40806 /*Seventh Pixel*/ |
|
40807 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
40808 lY1 -= 16; |
|
40809 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40810 |
|
40811 lTemp = lY1 + lTemp1; |
|
40812 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40813 |
|
40814 lTemp = lY1 - lTemp2; |
|
40815 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40816 |
|
40817 lTemp = lY1 + lTemp3; |
|
40818 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40819 |
|
40820 /*Sixth Pixel*/ |
|
40821 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
40822 lY1 -= 16; |
|
40823 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40824 |
|
40825 lTemp = lY1 + lTemp1; |
|
40826 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40827 |
|
40828 lTemp = lY1 - lTemp2; |
|
40829 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40830 |
|
40831 lTemp = lY1 + lTemp3; |
|
40832 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40833 |
|
40834 /*Eighth Pixel*/ |
|
40835 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
40836 lY1 -= 16; |
|
40837 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
40838 |
|
40839 lTemp = lY1 + lTemp1; |
|
40840 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40841 |
|
40842 lTemp = lY1 - lTemp2; |
|
40843 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40844 |
|
40845 lTemp = lY1 + lTemp3; |
|
40846 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
40847 |
|
40848 src1 += 6; |
|
40849 src2 += 6; |
|
40850 |
|
40851 |
|
40852 src1 = lPtr1; |
|
40853 src2 = lPtr2; |
|
40854 |
|
40855 for(j = 0; j < lWidth; j += 2) |
|
40856 { |
|
40857 /* First Pixel */ |
|
40858 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
40859 diff1 = *src1 & 0xf; |
|
40860 diff2 = *(src1 + 1) & 0xf; |
|
40861 diff3 = *(src1 + 2) & 0xf; |
|
40862 |
|
40863 // diffuse the error |
|
40864 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
40865 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
40866 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
40867 |
|
40868 /* Second Pixel */ |
|
40869 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
40870 diff1 = *(src1 + 3) & 0xf; |
|
40871 diff2 = *(src1 + 4) & 0xf; |
|
40872 diff3 = *(src1 + 5) & 0xf; |
|
40873 // diffuse the error |
|
40874 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
40875 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
40876 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
40877 |
|
40878 src1 += 6; |
|
40879 dest1 += 2; |
|
40880 |
|
40881 /* Third Pixel */ |
|
40882 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
40883 diff1 = *src2 & 0xf; |
|
40884 diff2 = *(src2 + 1) & 0xf; |
|
40885 diff3 = *(src2 + 2) & 0xf; |
|
40886 //diffuse the error |
|
40887 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
40888 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
40889 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
40890 |
|
40891 /* Fourth Pixel */ |
|
40892 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
40893 diff1 = *(src2 + 3) & 0xf; |
|
40894 diff2 = *(src2 + 4) & 0xf; |
|
40895 diff3 = *(src2 + 5) & 0xf; |
|
40896 //diffuse the error |
|
40897 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
40898 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
40899 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
40900 |
|
40901 src2 += 6; |
|
40902 dest2 += 2; |
|
40903 } |
|
40904 if(extraCol) |
|
40905 { |
|
40906 *dest1 = dest1[-1]; |
|
40907 dest1++; |
|
40908 *dest2 = dest2[-1]; |
|
40909 dest2++; |
|
40910 } |
|
40911 |
|
40912 lLumPtr += (lLumWidth << 1); |
|
40913 lCrPtr += (lLumWidth >> 1); |
|
40914 lCbPtr += (lLumWidth >> 1); |
|
40915 |
|
40916 dest1 += ((wndWidth << 1) - lTempWidth); |
|
40917 dest2 += ((wndWidth << 1) - lTempWidth); |
|
40918 } |
|
40919 |
|
40920 if(extraRow) |
|
40921 { |
|
40922 dest2 = dest1 - wndWidth; |
|
40923 for(j = 0; j < lWidth; j += 2) |
|
40924 { |
|
40925 *dest1++ = *dest2++; |
|
40926 *dest1++ = *dest2++; |
|
40927 } |
|
40928 if(extraCol) |
|
40929 { |
|
40930 *dest1 = *dest2; |
|
40931 } |
|
40932 } |
|
40933 |
|
40934 free(lBuffer); |
|
40935 return; |
|
40936 } |
|
40937 |
|
40938 /* |
|
40939 ****************************************************************************** |
|
40940 Name : sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_601_5_RR |
|
40941 Description : Converts YUV420 Chroma1 Planar to XRGB (4:4:4:4) Interleaved format |
|
40942 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
40943 uint8 *dstImage : Pointer to rgb data (o/p). |
|
40944 tWndParam *srcWindow : Pointer to structure containing source window |
|
40945 parameters like xOffset,yOffset,cropWidth, |
|
40946 cropHeight. (i/p) |
|
40947 tWndParam *dstWindow : Pointer to structure containing destination window |
|
40948 parameters like xOffset,yOffset,windWidth, |
|
40949 windHeight. (i/p) |
|
40950 Return Value : void |
|
40951 ****************************************************************************** |
|
40952 */ |
|
40953 |
|
40954 void sEmz_VDec_YUV420Chr1toColor4k_ErrDiff_601_5_RR |
|
40955 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
40956 tWndParam* srcWindow, tWndParam* dstWindow) |
|
40957 { |
|
40958 uint16 *dest1, *dest2; |
|
40959 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
40960 uint8 *lBuffer; |
|
40961 uint8 *src1, *src2; |
|
40962 uint8 *lPtr1, *lPtr2; |
|
40963 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
40964 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
40965 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
40966 int32 diff1, diff2, diff3; |
|
40967 int32 i, j, k, extraRow, extraCol; |
|
40968 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
40969 cropWidth,cropHeight,wndWidth,wndHeight; |
|
40970 |
|
40971 srcXOffset = srcWindow->xOffset; |
|
40972 srcYOffset = srcWindow->yOffset; |
|
40973 cropWidth = srcWindow->wndWidth; |
|
40974 cropHeight = srcWindow->wndHeight; |
|
40975 |
|
40976 dstXOffset = dstWindow->xOffset; |
|
40977 dstYOffset = dstWindow->yOffset; |
|
40978 wndWidth = dstWindow->wndWidth; |
|
40979 wndHeight = dstWindow->wndHeight; |
|
40980 |
|
40981 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
40982 { |
|
40983 lWidth = cropWidth; |
|
40984 } |
|
40985 else |
|
40986 { |
|
40987 lWidth = srcImage->width - srcXOffset; |
|
40988 } |
|
40989 |
|
40990 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
40991 { |
|
40992 lHeight = cropHeight; |
|
40993 } |
|
40994 else |
|
40995 { |
|
40996 lHeight = srcImage->height - srcYOffset; |
|
40997 } |
|
40998 |
|
40999 if (lWidth > (wndWidth - dstXOffset)) |
|
41000 { |
|
41001 lWidth = wndWidth - dstXOffset; |
|
41002 } |
|
41003 |
|
41004 if (lHeight > (wndHeight - dstYOffset)) |
|
41005 { |
|
41006 lHeight = wndHeight - dstYOffset; |
|
41007 } |
|
41008 |
|
41009 extraCol = lWidth & 0x01; |
|
41010 extraRow = lHeight & 0x01; |
|
41011 |
|
41012 lTempWidth = lWidth; |
|
41013 lWidth = (lWidth >> 1) << 1; |
|
41014 lHeight = (lHeight >> 1) << 1; |
|
41015 |
|
41016 lBuffer = (uint8*) malloc(lWidth * 3 * 4); |
|
41017 |
|
41018 lSrcWidth = lWidth * 3; |
|
41019 |
|
41020 lLumWidth = (srcImage->width >> 1) << 1; |
|
41021 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
41022 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
41023 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
41024 |
|
41025 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
41026 dest2 = dest1 + wndWidth; |
|
41027 |
|
41028 for(i = 0; i < lHeight; i += 2) |
|
41029 { |
|
41030 lPtr1 = src1 = lBuffer; |
|
41031 lPtr2 = src2 = src1 + lSrcWidth; |
|
41032 |
|
41033 for(k = 0; k < (lWidth - 2); k += 2) |
|
41034 { |
|
41035 lCr1 = lCrPtr[k >> 1]; |
|
41036 lCb1 = lCbPtr[k >> 1]; |
|
41037 |
|
41038 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
41039 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
41040 |
|
41041 lCr2 = (lCr1 + lCr2) >> 1; |
|
41042 lCb2 = (lCb1 + lCb2) >> 1; |
|
41043 |
|
41044 lCr1 -= 128; |
|
41045 lCb1 -= 128; |
|
41046 |
|
41047 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
41048 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
41049 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
41050 |
|
41051 /*First Pixel*/ |
|
41052 lY1 = lLumPtr[k]; |
|
41053 lY1 -= 16; |
|
41054 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41055 |
|
41056 lTemp = lY1 + lTemp1; |
|
41057 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41058 |
|
41059 lTemp = lY1 - lTemp2; |
|
41060 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41061 |
|
41062 lTemp = lY1 + lTemp3; |
|
41063 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41064 |
|
41065 /*Third Pixel*/ |
|
41066 lY1 = lLumPtr[k + lLumWidth]; |
|
41067 lY1 -= 16; |
|
41068 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41069 |
|
41070 lTemp = lY1 + lTemp1; |
|
41071 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41072 |
|
41073 lTemp = lY1 - lTemp2; |
|
41074 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41075 |
|
41076 lTemp = lY1 + lTemp3; |
|
41077 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41078 |
|
41079 |
|
41080 lCr2 -= 128; |
|
41081 lCb2 -= 128; |
|
41082 |
|
41083 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
41084 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
41085 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
41086 |
|
41087 /*Second Pixel*/ |
|
41088 lY1 = lLumPtr[k + 1]; |
|
41089 lY1 -= 16; |
|
41090 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41091 |
|
41092 lTemp = lY1 + lTemp1; |
|
41093 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41094 |
|
41095 lTemp = lY1 - lTemp2; |
|
41096 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41097 |
|
41098 lTemp = lY1 + lTemp3; |
|
41099 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41100 |
|
41101 |
|
41102 /*Fourth Pixel*/ |
|
41103 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
41104 lY1 -= 16; |
|
41105 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41106 |
|
41107 lTemp = lY1 + lTemp1; |
|
41108 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41109 |
|
41110 lTemp = lY1 - lTemp2; |
|
41111 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41112 |
|
41113 lTemp = lY1 + lTemp3; |
|
41114 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41115 |
|
41116 |
|
41117 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
41118 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
41119 |
|
41120 lCr2 = lCrPtr[(k + lLumWidth) >> 1 + 1]; |
|
41121 lCb2 = lCbPtr[(k + lLumWidth) >> 1 + 1]; |
|
41122 |
|
41123 lCr2 = (lCr1 + lCr2) >> 1; |
|
41124 lCb2 = (lCb1 + lCb2) >> 1; |
|
41125 |
|
41126 lCr1 -= 128; |
|
41127 lCb1 -= 128; |
|
41128 |
|
41129 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
41130 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
41131 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
41132 |
|
41133 |
|
41134 /*Fifth Pixel*/ |
|
41135 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
41136 lY1 -= 16; |
|
41137 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41138 |
|
41139 lTemp = lY1 + lTemp1; |
|
41140 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41141 |
|
41142 lTemp = lY1 - lTemp2; |
|
41143 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41144 |
|
41145 lTemp = lY1 + lTemp3; |
|
41146 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41147 |
|
41148 /*Seventh Pixel*/ |
|
41149 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
41150 lY1 -= 16; |
|
41151 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41152 |
|
41153 lTemp = lY1 + lTemp1; |
|
41154 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41155 |
|
41156 lTemp = lY1 - lTemp2; |
|
41157 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41158 |
|
41159 lTemp = lY1 + lTemp3; |
|
41160 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41161 |
|
41162 |
|
41163 lCr2 -= 128; |
|
41164 lCb2 -= 128; |
|
41165 |
|
41166 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
41167 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
41168 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
41169 |
|
41170 /*Sixth Pixel*/ |
|
41171 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
41172 lY1 -= 16; |
|
41173 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41174 |
|
41175 lTemp = lY1 + lTemp1; |
|
41176 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41177 |
|
41178 lTemp = lY1 - lTemp2; |
|
41179 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41180 |
|
41181 lTemp = lY1 + lTemp3; |
|
41182 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41183 |
|
41184 /*Eighth Pixel*/ |
|
41185 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
41186 lY1 -= 16; |
|
41187 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41188 |
|
41189 lTemp = lY1 + lTemp1; |
|
41190 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41191 |
|
41192 lTemp = lY1 - lTemp2; |
|
41193 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41194 |
|
41195 lTemp = lY1 + lTemp3; |
|
41196 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41197 |
|
41198 src1 += 6; |
|
41199 src2 += 6; |
|
41200 } |
|
41201 |
|
41202 |
|
41203 lCr1 = lCrPtr[k >> 1]; |
|
41204 lCb1 = lCbPtr[k >> 1]; |
|
41205 |
|
41206 lCr1 -= 128; |
|
41207 lCb1 -= 128; |
|
41208 |
|
41209 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
41210 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
41211 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
41212 |
|
41213 /*First Pixel*/ |
|
41214 lY1 = lLumPtr[k]; |
|
41215 lY1 -= 16; |
|
41216 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41217 |
|
41218 lTemp = lY1 + lTemp1; |
|
41219 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41220 |
|
41221 lTemp = lY1 - lTemp2; |
|
41222 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41223 |
|
41224 lTemp = lY1 + lTemp3; |
|
41225 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41226 |
|
41227 /*Third Pixel*/ |
|
41228 lY1 = lLumPtr[k + lLumWidth]; |
|
41229 lY1 -= 16; |
|
41230 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41231 |
|
41232 lTemp = lY1 + lTemp1; |
|
41233 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41234 |
|
41235 lTemp = lY1 - lTemp2; |
|
41236 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41237 |
|
41238 lTemp = lY1 + lTemp3; |
|
41239 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41240 |
|
41241 /*Second Pixel*/ |
|
41242 lY1 = lLumPtr[k + 1]; |
|
41243 lY1 -= 16; |
|
41244 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41245 |
|
41246 lTemp = lY1 + lTemp1; |
|
41247 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41248 |
|
41249 lTemp = lY1 - lTemp2; |
|
41250 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41251 |
|
41252 lTemp = lY1 + lTemp3; |
|
41253 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41254 |
|
41255 |
|
41256 /*Fourth Pixel*/ |
|
41257 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
41258 lY1 -= 16; |
|
41259 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41260 |
|
41261 lTemp = lY1 + lTemp1; |
|
41262 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41263 |
|
41264 lTemp = lY1 - lTemp2; |
|
41265 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41266 |
|
41267 lTemp = lY1 + lTemp3; |
|
41268 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41269 |
|
41270 |
|
41271 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
41272 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
41273 |
|
41274 lCr1 -= 128; |
|
41275 lCb1 -= 128; |
|
41276 |
|
41277 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
41278 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
41279 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
41280 |
|
41281 |
|
41282 /*Fifth Pixel*/ |
|
41283 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
41284 lY1 -= 16; |
|
41285 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41286 |
|
41287 lTemp = lY1 + lTemp1; |
|
41288 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41289 |
|
41290 lTemp = lY1 - lTemp2; |
|
41291 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41292 |
|
41293 lTemp = lY1 + lTemp3; |
|
41294 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41295 |
|
41296 /*Seventh Pixel*/ |
|
41297 lY1 = lLumPtr[k + (lLumWidth << 2)]; |
|
41298 lY1 -= 16; |
|
41299 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41300 |
|
41301 lTemp = lY1 + lTemp1; |
|
41302 *(src2 + (lSrcWidth << 1)) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41303 |
|
41304 lTemp = lY1 - lTemp2; |
|
41305 *(src2 + (lSrcWidth << 1) + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41306 |
|
41307 lTemp = lY1 + lTemp3; |
|
41308 *(src2 + (lSrcWidth << 1) + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41309 |
|
41310 /*Sixth Pixel*/ |
|
41311 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
41312 lY1 -= 16; |
|
41313 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41314 |
|
41315 lTemp = lY1 + lTemp1; |
|
41316 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41317 |
|
41318 lTemp = lY1 - lTemp2; |
|
41319 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41320 |
|
41321 lTemp = lY1 + lTemp3; |
|
41322 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41323 |
|
41324 /*Eighth Pixel*/ |
|
41325 lY1 = lLumPtr[k + (lLumWidth << 2) + 1]; |
|
41326 lY1 -= 16; |
|
41327 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
41328 |
|
41329 lTemp = lY1 + lTemp1; |
|
41330 *(src2 + (lSrcWidth << 1) + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41331 |
|
41332 lTemp = lY1 - lTemp2; |
|
41333 *(src2 + (lSrcWidth << 1) + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41334 |
|
41335 lTemp = lY1 + lTemp3; |
|
41336 *(src2 + (lSrcWidth << 1) + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
41337 |
|
41338 src1 += 6; |
|
41339 src2 += 6; |
|
41340 |
|
41341 |
|
41342 src1 = lPtr1; |
|
41343 src2 = lPtr2; |
|
41344 |
|
41345 for(j = 0; j < lWidth; j += 2) |
|
41346 { |
|
41347 /* First Pixel */ |
|
41348 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
41349 diff1 = *src1 & 0xf; |
|
41350 diff2 = *(src1 + 1) & 0xf; |
|
41351 diff3 = *(src1 + 2) & 0xf; |
|
41352 |
|
41353 // diffuse the error |
|
41354 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
41355 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
41356 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
41357 |
|
41358 /* Second Pixel */ |
|
41359 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
41360 diff1 = *(src1 + 3) & 0xf; |
|
41361 diff2 = *(src1 + 4) & 0xf; |
|
41362 diff3 = *(src1 + 5) & 0xf; |
|
41363 // diffuse the error |
|
41364 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
41365 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
41366 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
41367 |
|
41368 src1 += 6; |
|
41369 dest1 += 2; |
|
41370 |
|
41371 /* Third Pixel */ |
|
41372 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
41373 diff1 = *src2 & 0xf; |
|
41374 diff2 = *(src2 + 1) & 0xf; |
|
41375 diff3 = *(src2 + 2) & 0xf; |
|
41376 //diffuse the error |
|
41377 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
41378 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
41379 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
41380 |
|
41381 /* Fourth Pixel */ |
|
41382 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
41383 diff1 = *(src2 + 3) & 0xf; |
|
41384 diff2 = *(src2 + 4) & 0xf; |
|
41385 diff3 = *(src2 + 5) & 0xf; |
|
41386 //diffuse the error |
|
41387 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
41388 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
41389 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
41390 |
|
41391 src2 += 6; |
|
41392 dest2 += 2; |
|
41393 } |
|
41394 if(extraCol) |
|
41395 { |
|
41396 *dest1 = dest1[-1]; |
|
41397 dest1++; |
|
41398 *dest2 = dest2[-1]; |
|
41399 dest2++; |
|
41400 } |
|
41401 |
|
41402 lLumPtr += (lLumWidth << 1); |
|
41403 lCrPtr += (lLumWidth >> 1); |
|
41404 lCbPtr += (lLumWidth >> 1); |
|
41405 |
|
41406 dest1 += ((wndWidth << 1) - lTempWidth); |
|
41407 dest2 += ((wndWidth << 1) - lTempWidth); |
|
41408 } |
|
41409 |
|
41410 if(extraRow) |
|
41411 { |
|
41412 dest2 = dest1 - wndWidth; |
|
41413 for(j = 0; j < lWidth; j += 2) |
|
41414 { |
|
41415 *dest1++ = *dest2++; |
|
41416 *dest1++ = *dest2++; |
|
41417 } |
|
41418 if(extraCol) |
|
41419 { |
|
41420 *dest1 = *dest2; |
|
41421 } |
|
41422 } |
|
41423 |
|
41424 free(lBuffer); |
|
41425 return; |
|
41426 } |
|
41427 |
|
41428 |
|
41429 /* |
|
41430 ****************************************************************************** |
|
41431 Name : sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_709_FR |
|
41432 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
41433 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
41434 uint8 *dstImage : Pointer to rgb data (o/p). |
|
41435 tWndParam *srcWindow : Pointer to structure containing source window |
|
41436 parameters like xOffset,yOffset,cropWidth, |
|
41437 cropHeight. (i/p) |
|
41438 tWndParam *dstWindow : Pointer to structure containing destination window |
|
41439 parameters like xOffset,yOffset,windWidth, |
|
41440 windHeight. (i/p) |
|
41441 Return Value : void |
|
41442 ****************************************************************************** |
|
41443 */ |
|
41444 |
|
41445 void sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_709_FR |
|
41446 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
41447 tWndParam* srcWindow, tWndParam* dstWindow) |
|
41448 { |
|
41449 uint16 *dest1, *dest2; |
|
41450 uint8 *lYuyvPtr; |
|
41451 uint8 *lBuffer; |
|
41452 uint8 *src1, *src2; |
|
41453 uint8 *lPtr1, *lPtr2; |
|
41454 int32 diff1, diff2, diff3; |
|
41455 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
41456 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
41457 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
41458 int32 i, j, k, extraCol, extraRow; |
|
41459 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
41460 cropWidth,cropHeight,wndWidth,wndHeight; |
|
41461 |
|
41462 srcXOffset = srcWindow->xOffset; |
|
41463 srcYOffset = srcWindow->yOffset; |
|
41464 cropWidth = srcWindow->wndWidth; |
|
41465 cropHeight = srcWindow->wndHeight; |
|
41466 |
|
41467 dstXOffset = dstWindow->xOffset; |
|
41468 dstYOffset = dstWindow->yOffset; |
|
41469 wndWidth = dstWindow->wndWidth; |
|
41470 wndHeight = dstWindow->wndHeight; |
|
41471 |
|
41472 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
41473 { |
|
41474 lWidth = cropWidth; |
|
41475 } |
|
41476 else |
|
41477 { |
|
41478 lWidth = srcImage->width - srcXOffset; |
|
41479 } |
|
41480 |
|
41481 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
41482 { |
|
41483 lHeight = cropHeight; |
|
41484 } |
|
41485 else |
|
41486 { |
|
41487 lHeight = srcImage->height - srcYOffset; |
|
41488 } |
|
41489 |
|
41490 if (lWidth > (wndWidth - dstXOffset)) |
|
41491 { |
|
41492 lWidth = wndWidth - dstXOffset; |
|
41493 } |
|
41494 |
|
41495 if (lHeight > (wndHeight - dstYOffset)) |
|
41496 { |
|
41497 lHeight = wndHeight - dstYOffset; |
|
41498 } |
|
41499 |
|
41500 extraCol = lWidth & 0x01; |
|
41501 extraRow = lHeight & 0x01; |
|
41502 |
|
41503 lTempWidth = lWidth; |
|
41504 lWidth = (lWidth >> 1) << 1; |
|
41505 lHeight = (lHeight >> 1) << 1; |
|
41506 |
|
41507 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
41508 |
|
41509 lSrcWidth = lWidth * 3; |
|
41510 |
|
41511 lLumWidth = (srcImage->width >> 1) << 1; |
|
41512 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
41513 |
|
41514 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
41515 dest2 = dest1 + wndWidth; |
|
41516 |
|
41517 lLumWidth <<= 1; |
|
41518 |
|
41519 for(i = 0; i < lHeight; i += 2) |
|
41520 { |
|
41521 lPtr1 = src1 = lBuffer; |
|
41522 lPtr2 = src2 = src1 + lSrcWidth; |
|
41523 |
|
41524 for(k = 0; k < (lWidth - 2); k += 2) |
|
41525 { |
|
41526 lCb1 = lYuyvPtr[0]; |
|
41527 lCr1 = lYuyvPtr[2]; |
|
41528 |
|
41529 lCb2 = lYuyvPtr[4]; |
|
41530 lCr2 = lYuyvPtr[6]; |
|
41531 |
|
41532 lCr2 = (lCr1 + lCr2) >> 1; |
|
41533 lCb2 = (lCb1 + lCb2) >> 1; |
|
41534 |
|
41535 /*First Pixel*/ |
|
41536 lCb1 -= 128; |
|
41537 lCr1 -= 128; |
|
41538 |
|
41539 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
41540 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
41541 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
41542 |
|
41543 lY1 = lYuyvPtr[1]; |
|
41544 |
|
41545 lTemp = lY1 + lTemp1; |
|
41546 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41547 |
|
41548 lTemp = lY1 - lTemp2; |
|
41549 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41550 |
|
41551 lTemp = lY1 + lTemp3; |
|
41552 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41553 |
|
41554 /*Second Pixel*/ |
|
41555 lCb2 -= 128; |
|
41556 lCr2 -= 128; |
|
41557 |
|
41558 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
41559 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
41560 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
41561 |
|
41562 lY1 = lYuyvPtr[3]; |
|
41563 |
|
41564 lTemp = lY1 + lTemp1; |
|
41565 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41566 |
|
41567 lTemp = lY1 - lTemp2; |
|
41568 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41569 |
|
41570 lTemp = lY1 + lTemp3; |
|
41571 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41572 |
|
41573 |
|
41574 lCb1 = lYuyvPtr[lLumWidth]; |
|
41575 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
41576 |
|
41577 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
41578 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
41579 |
|
41580 lCr2 = (lCr1 + lCr2) >> 1; |
|
41581 lCb2 = (lCb1 + lCb2) >> 1; |
|
41582 |
|
41583 |
|
41584 /*Third Pixel*/ |
|
41585 lCb1 -= 128; |
|
41586 lCr1 -= 128; |
|
41587 |
|
41588 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
41589 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
41590 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
41591 |
|
41592 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
41593 |
|
41594 lTemp = lY1 + lTemp1; |
|
41595 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41596 |
|
41597 lTemp = lY1 - lTemp2; |
|
41598 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41599 |
|
41600 lTemp = lY1 + lTemp3; |
|
41601 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41602 |
|
41603 /*Fourth Pixel*/ |
|
41604 lCb2 -= 128; |
|
41605 lCr2 -= 128; |
|
41606 |
|
41607 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
41608 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
41609 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
41610 |
|
41611 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
41612 |
|
41613 lTemp = lY1 + lTemp1; |
|
41614 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41615 |
|
41616 lTemp = lY1 - lTemp2; |
|
41617 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41618 |
|
41619 lTemp = lY1 + lTemp3; |
|
41620 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41621 |
|
41622 |
|
41623 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
41624 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
41625 |
|
41626 lCb2 = lYuyvPtr[(lLumWidth << 1) + 4]; |
|
41627 lCr2 = lYuyvPtr[(lLumWidth << 1) + 6]; |
|
41628 |
|
41629 lCr2 = (lCr1 + lCr2) >> 1; |
|
41630 lCb2 = (lCb1 + lCb2) >> 1; |
|
41631 |
|
41632 /*Fifth Pixel*/ |
|
41633 lCb1 -= 128; |
|
41634 lCr1 -= 128; |
|
41635 |
|
41636 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
41637 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
41638 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
41639 |
|
41640 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
41641 |
|
41642 lTemp = lY1 + lTemp1; |
|
41643 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41644 |
|
41645 lTemp = lY1 - lTemp2; |
|
41646 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41647 |
|
41648 lTemp = lY1 + lTemp3; |
|
41649 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41650 |
|
41651 /*Sixth Pixel*/ |
|
41652 lCb2 -= 128; |
|
41653 lCr2 -= 128; |
|
41654 |
|
41655 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
41656 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
41657 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
41658 |
|
41659 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
41660 |
|
41661 lTemp = lY1 + lTemp1; |
|
41662 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41663 |
|
41664 lTemp = lY1 - lTemp2; |
|
41665 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41666 |
|
41667 lTemp = lY1 + lTemp3; |
|
41668 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41669 |
|
41670 lYuyvPtr += 4; |
|
41671 src1 += 6; |
|
41672 src2 += 6; |
|
41673 } |
|
41674 |
|
41675 lCb1 = lYuyvPtr[0]; |
|
41676 lCr1 = lYuyvPtr[2]; |
|
41677 |
|
41678 lCb1 -= 128; |
|
41679 lCr1 -= 128; |
|
41680 |
|
41681 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
41682 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
41683 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
41684 |
|
41685 /*First Pixel*/ |
|
41686 lY1 = lYuyvPtr[1]; |
|
41687 |
|
41688 lTemp = lY1 + lTemp1; |
|
41689 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41690 |
|
41691 lTemp = lY1 - lTemp2; |
|
41692 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41693 |
|
41694 lTemp = lY1 + lTemp3; |
|
41695 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41696 |
|
41697 /*Second Pixel*/ |
|
41698 lY1 = lYuyvPtr[3]; |
|
41699 |
|
41700 lTemp = lY1 + lTemp1; |
|
41701 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41702 |
|
41703 lTemp = lY1 - lTemp2; |
|
41704 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41705 |
|
41706 lTemp = lY1 + lTemp3; |
|
41707 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41708 |
|
41709 |
|
41710 lCb1 = lYuyvPtr[lLumWidth]; |
|
41711 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
41712 |
|
41713 lCb1 -= 128; |
|
41714 lCr1 -= 128; |
|
41715 |
|
41716 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
41717 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
41718 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
41719 |
|
41720 /*Third Pixel*/ |
|
41721 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
41722 |
|
41723 lTemp = lY1 + lTemp1; |
|
41724 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41725 |
|
41726 lTemp = lY1 - lTemp2; |
|
41727 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41728 |
|
41729 lTemp = lY1 + lTemp3; |
|
41730 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41731 |
|
41732 /*Fourth Pixel*/ |
|
41733 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
41734 |
|
41735 lTemp = lY1 + lTemp1; |
|
41736 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41737 |
|
41738 lTemp = lY1 - lTemp2; |
|
41739 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41740 |
|
41741 lTemp = lY1 + lTemp3; |
|
41742 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41743 |
|
41744 |
|
41745 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
41746 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
41747 |
|
41748 lCb1 -= 128; |
|
41749 lCr1 -= 128; |
|
41750 |
|
41751 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
41752 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
41753 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
41754 |
|
41755 /*Fifth Pixel*/ |
|
41756 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
41757 |
|
41758 lTemp = lY1 + lTemp1; |
|
41759 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41760 |
|
41761 lTemp = lY1 - lTemp2; |
|
41762 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41763 |
|
41764 lTemp = lY1 + lTemp3; |
|
41765 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41766 |
|
41767 /*Sixth Pixel*/ |
|
41768 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
41769 |
|
41770 lTemp = lY1 + lTemp1; |
|
41771 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41772 |
|
41773 lTemp = lY1 - lTemp2; |
|
41774 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41775 |
|
41776 lTemp = lY1 + lTemp3; |
|
41777 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41778 |
|
41779 lYuyvPtr += 4; |
|
41780 src1 += 6; |
|
41781 src2 += 6; |
|
41782 |
|
41783 |
|
41784 src1 = lPtr1; |
|
41785 src2 = lPtr2; |
|
41786 |
|
41787 for(j = 0; j < lWidth; j += 2) |
|
41788 { |
|
41789 /* First Pixel */ |
|
41790 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
41791 diff1 = *src1 & 0x7; |
|
41792 diff2 = *(src1 + 1) & 0x3; |
|
41793 diff3 = *(src1 + 2) & 0x7; |
|
41794 |
|
41795 // diffuse the error |
|
41796 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
41797 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
41798 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
41799 |
|
41800 /* Second Pixel */ |
|
41801 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
41802 diff1 = *(src1 + 3) & 0x7; |
|
41803 diff2 = *(src1 + 4) & 0x3; |
|
41804 diff3 = *(src1 + 5) & 0x7; |
|
41805 // diffuse the error |
|
41806 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
41807 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
41808 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
41809 |
|
41810 src1 += 6; |
|
41811 dest1 += 2; |
|
41812 |
|
41813 /* Third Pixel */ |
|
41814 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
41815 diff1 = *src2 & 0x7; |
|
41816 diff2 = *(src2 + 1) & 0x3; |
|
41817 diff3 = *(src2 + 2) & 0x7; |
|
41818 //diffuse the error |
|
41819 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
41820 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
41821 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
41822 |
|
41823 /* Fourth Pixel */ |
|
41824 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
41825 diff1 = *(src2 + 3) & 0x7; |
|
41826 diff2 = *(src2 + 4) & 0x3; |
|
41827 diff3 = *(src2 + 5) & 0x7; |
|
41828 //diffuse the error |
|
41829 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
41830 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
41831 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
41832 |
|
41833 src2 += 6; |
|
41834 dest2 += 2; |
|
41835 } |
|
41836 if(extraCol) |
|
41837 { |
|
41838 *dest1 = dest1[-1]; |
|
41839 dest1++; |
|
41840 *dest2 = dest2[-1]; |
|
41841 dest2++; |
|
41842 } |
|
41843 |
|
41844 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
41845 |
|
41846 dest1 += ((wndWidth << 1) - lTempWidth); |
|
41847 dest2 += ((wndWidth << 1) - lTempWidth); |
|
41848 } |
|
41849 |
|
41850 if(extraRow) |
|
41851 { |
|
41852 dest2 = dest1 - wndWidth; |
|
41853 for(j = 0; j < lWidth; j += 2) |
|
41854 { |
|
41855 *dest1++ = *dest2++; |
|
41856 *dest1++ = *dest2++; |
|
41857 } |
|
41858 if(extraCol) |
|
41859 { |
|
41860 *dest1 = *dest2; |
|
41861 } |
|
41862 } |
|
41863 |
|
41864 free(lBuffer); |
|
41865 return; |
|
41866 } |
|
41867 |
|
41868 /* |
|
41869 ****************************************************************************** |
|
41870 Name : sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_601_5_FR |
|
41871 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
41872 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
41873 uint8 *dstImage : Pointer to rgb data (o/p). |
|
41874 tWndParam *srcWindow : Pointer to structure containing source window |
|
41875 parameters like xOffset,yOffset,cropWidth, |
|
41876 cropHeight. (i/p) |
|
41877 tWndParam *dstWindow : Pointer to structure containing destination window |
|
41878 parameters like xOffset,yOffset,windWidth, |
|
41879 windHeight. (i/p) |
|
41880 Return Value : void |
|
41881 ****************************************************************************** |
|
41882 */ |
|
41883 |
|
41884 void sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_601_5_FR |
|
41885 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
41886 tWndParam* srcWindow, tWndParam* dstWindow) |
|
41887 { |
|
41888 uint16 *dest1, *dest2; |
|
41889 uint8 *lYuyvPtr; |
|
41890 uint8 *lBuffer; |
|
41891 uint8 *src1, *src2; |
|
41892 uint8 *lPtr1, *lPtr2; |
|
41893 int32 diff1, diff2, diff3; |
|
41894 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
41895 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
41896 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
41897 int32 i, j, k, extraCol, extraRow; |
|
41898 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
41899 cropWidth,cropHeight,wndWidth,wndHeight; |
|
41900 |
|
41901 srcXOffset = srcWindow->xOffset; |
|
41902 srcYOffset = srcWindow->yOffset; |
|
41903 cropWidth = srcWindow->wndWidth; |
|
41904 cropHeight = srcWindow->wndHeight; |
|
41905 |
|
41906 dstXOffset = dstWindow->xOffset; |
|
41907 dstYOffset = dstWindow->yOffset; |
|
41908 wndWidth = dstWindow->wndWidth; |
|
41909 wndHeight = dstWindow->wndHeight; |
|
41910 |
|
41911 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
41912 { |
|
41913 lWidth = cropWidth; |
|
41914 } |
|
41915 else |
|
41916 { |
|
41917 lWidth = srcImage->width - srcXOffset; |
|
41918 } |
|
41919 |
|
41920 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
41921 { |
|
41922 lHeight = cropHeight; |
|
41923 } |
|
41924 else |
|
41925 { |
|
41926 lHeight = srcImage->height - srcYOffset; |
|
41927 } |
|
41928 |
|
41929 if (lWidth > (wndWidth - dstXOffset)) |
|
41930 { |
|
41931 lWidth = wndWidth - dstXOffset; |
|
41932 } |
|
41933 |
|
41934 if (lHeight > (wndHeight - dstYOffset)) |
|
41935 { |
|
41936 lHeight = wndHeight - dstYOffset; |
|
41937 } |
|
41938 |
|
41939 extraCol = lWidth & 0x01; |
|
41940 extraRow = lHeight & 0x01; |
|
41941 |
|
41942 lTempWidth = lWidth; |
|
41943 lWidth = (lWidth >> 1) << 1; |
|
41944 lHeight = (lHeight >> 1) << 1; |
|
41945 |
|
41946 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
41947 |
|
41948 lSrcWidth = lWidth * 3; |
|
41949 |
|
41950 lLumWidth = (srcImage->width >> 1) << 1; |
|
41951 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
41952 |
|
41953 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
41954 dest2 = dest1 + wndWidth; |
|
41955 |
|
41956 lLumWidth <<= 1; |
|
41957 |
|
41958 for(i = 0; i < lHeight; i += 2) |
|
41959 { |
|
41960 lPtr1 = src1 = lBuffer; |
|
41961 lPtr2 = src2 = src1 + lSrcWidth; |
|
41962 |
|
41963 for(k = 0; k < (lWidth - 2); k += 2) |
|
41964 { |
|
41965 lCb1 = lYuyvPtr[0]; |
|
41966 lCr1 = lYuyvPtr[2]; |
|
41967 |
|
41968 lCb2 = lYuyvPtr[4]; |
|
41969 lCr2 = lYuyvPtr[6]; |
|
41970 |
|
41971 lCr2 = (lCr1 + lCr2) >> 1; |
|
41972 lCb2 = (lCb1 + lCb2) >> 1; |
|
41973 |
|
41974 /*First Pixel*/ |
|
41975 lCb1 -= 128; |
|
41976 lCr1 -= 128; |
|
41977 |
|
41978 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
41979 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
41980 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
41981 |
|
41982 lY1 = lYuyvPtr[1]; |
|
41983 |
|
41984 lTemp = lY1 + lTemp1; |
|
41985 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41986 |
|
41987 lTemp = lY1 - lTemp2; |
|
41988 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41989 |
|
41990 lTemp = lY1 + lTemp3; |
|
41991 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
41992 |
|
41993 /*Second Pixel*/ |
|
41994 lCb2 -= 128; |
|
41995 lCr2 -= 128; |
|
41996 |
|
41997 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
41998 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
41999 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
42000 |
|
42001 lY1 = lYuyvPtr[3]; |
|
42002 |
|
42003 lTemp = lY1 + lTemp1; |
|
42004 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42005 |
|
42006 lTemp = lY1 - lTemp2; |
|
42007 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42008 |
|
42009 lTemp = lY1 + lTemp3; |
|
42010 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42011 |
|
42012 |
|
42013 lCb1 = lYuyvPtr[lLumWidth]; |
|
42014 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
42015 |
|
42016 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
42017 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
42018 |
|
42019 lCr2 = (lCr1 + lCr2) >> 1; |
|
42020 lCb2 = (lCb1 + lCb2) >> 1; |
|
42021 |
|
42022 |
|
42023 /*Third Pixel*/ |
|
42024 lCb1 -= 128; |
|
42025 lCr1 -= 128; |
|
42026 |
|
42027 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
42028 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42029 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
42030 |
|
42031 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
42032 |
|
42033 lTemp = lY1 + lTemp1; |
|
42034 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42035 |
|
42036 lTemp = lY1 - lTemp2; |
|
42037 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42038 |
|
42039 lTemp = lY1 + lTemp3; |
|
42040 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42041 |
|
42042 /*Fourth Pixel*/ |
|
42043 lCb2 -= 128; |
|
42044 lCr2 -= 128; |
|
42045 |
|
42046 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
42047 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
42048 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
42049 |
|
42050 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
42051 |
|
42052 lTemp = lY1 + lTemp1; |
|
42053 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42054 |
|
42055 lTemp = lY1 - lTemp2; |
|
42056 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42057 |
|
42058 lTemp = lY1 + lTemp3; |
|
42059 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42060 |
|
42061 |
|
42062 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
42063 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
42064 |
|
42065 lCb2 = lYuyvPtr[(lLumWidth << 1) + 4]; |
|
42066 lCr2 = lYuyvPtr[(lLumWidth << 1) + 6]; |
|
42067 |
|
42068 lCr2 = (lCr1 + lCr2) >> 1; |
|
42069 lCb2 = (lCb1 + lCb2) >> 1; |
|
42070 |
|
42071 /*Fifth Pixel*/ |
|
42072 lCb1 -= 128; |
|
42073 lCr1 -= 128; |
|
42074 |
|
42075 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
42076 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42077 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
42078 |
|
42079 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
42080 |
|
42081 lTemp = lY1 + lTemp1; |
|
42082 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42083 |
|
42084 lTemp = lY1 - lTemp2; |
|
42085 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42086 |
|
42087 lTemp = lY1 + lTemp3; |
|
42088 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42089 |
|
42090 /*Sixth Pixel*/ |
|
42091 lCb2 -= 128; |
|
42092 lCr2 -= 128; |
|
42093 |
|
42094 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
42095 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
42096 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
42097 |
|
42098 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
42099 |
|
42100 lTemp = lY1 + lTemp1; |
|
42101 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42102 |
|
42103 lTemp = lY1 - lTemp2; |
|
42104 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42105 |
|
42106 lTemp = lY1 + lTemp3; |
|
42107 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42108 |
|
42109 lYuyvPtr += 4; |
|
42110 src1 += 6; |
|
42111 src2 += 6; |
|
42112 } |
|
42113 |
|
42114 lCb1 = lYuyvPtr[0]; |
|
42115 lCr1 = lYuyvPtr[2]; |
|
42116 |
|
42117 lCb1 -= 128; |
|
42118 lCr1 -= 128; |
|
42119 |
|
42120 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
42121 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42122 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
42123 |
|
42124 /*First Pixel*/ |
|
42125 lY1 = lYuyvPtr[1]; |
|
42126 |
|
42127 lTemp = lY1 + lTemp1; |
|
42128 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42129 |
|
42130 lTemp = lY1 - lTemp2; |
|
42131 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42132 |
|
42133 lTemp = lY1 + lTemp3; |
|
42134 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42135 |
|
42136 /*Second Pixel*/ |
|
42137 lY1 = lYuyvPtr[3]; |
|
42138 |
|
42139 lTemp = lY1 + lTemp1; |
|
42140 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42141 |
|
42142 lTemp = lY1 - lTemp2; |
|
42143 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42144 |
|
42145 lTemp = lY1 + lTemp3; |
|
42146 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42147 |
|
42148 |
|
42149 lCb1 = lYuyvPtr[lLumWidth]; |
|
42150 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
42151 |
|
42152 lCb1 -= 128; |
|
42153 lCr1 -= 128; |
|
42154 |
|
42155 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
42156 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42157 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
42158 |
|
42159 /*Third Pixel*/ |
|
42160 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
42161 |
|
42162 lTemp = lY1 + lTemp1; |
|
42163 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42164 |
|
42165 lTemp = lY1 - lTemp2; |
|
42166 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42167 |
|
42168 lTemp = lY1 + lTemp3; |
|
42169 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42170 |
|
42171 /*Fourth Pixel*/ |
|
42172 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
42173 |
|
42174 lTemp = lY1 + lTemp1; |
|
42175 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42176 |
|
42177 lTemp = lY1 - lTemp2; |
|
42178 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42179 |
|
42180 lTemp = lY1 + lTemp3; |
|
42181 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42182 |
|
42183 |
|
42184 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
42185 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
42186 |
|
42187 lCb1 -= 128; |
|
42188 lCr1 -= 128; |
|
42189 |
|
42190 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
42191 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42192 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
42193 |
|
42194 /*Fifth Pixel*/ |
|
42195 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
42196 |
|
42197 lTemp = lY1 + lTemp1; |
|
42198 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42199 |
|
42200 lTemp = lY1 - lTemp2; |
|
42201 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42202 |
|
42203 lTemp = lY1 + lTemp3; |
|
42204 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42205 |
|
42206 /*Sixth Pixel*/ |
|
42207 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
42208 |
|
42209 lTemp = lY1 + lTemp1; |
|
42210 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42211 |
|
42212 lTemp = lY1 - lTemp2; |
|
42213 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42214 |
|
42215 lTemp = lY1 + lTemp3; |
|
42216 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
42217 |
|
42218 lYuyvPtr += 4; |
|
42219 src1 += 6; |
|
42220 src2 += 6; |
|
42221 |
|
42222 |
|
42223 src1 = lPtr1; |
|
42224 src2 = lPtr2; |
|
42225 |
|
42226 for(j = 0; j < lWidth; j += 2) |
|
42227 { |
|
42228 /* First Pixel */ |
|
42229 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
42230 diff1 = *src1 & 0x7; |
|
42231 diff2 = *(src1 + 1) & 0x3; |
|
42232 diff3 = *(src1 + 2) & 0x7; |
|
42233 |
|
42234 // diffuse the error |
|
42235 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
42236 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
42237 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
42238 |
|
42239 /* Second Pixel */ |
|
42240 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
42241 diff1 = *(src1 + 3) & 0x7; |
|
42242 diff2 = *(src1 + 4) & 0x3; |
|
42243 diff3 = *(src1 + 5) & 0x7; |
|
42244 // diffuse the error |
|
42245 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
42246 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
42247 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
42248 |
|
42249 src1 += 6; |
|
42250 dest1 += 2; |
|
42251 |
|
42252 /* Third Pixel */ |
|
42253 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
42254 diff1 = *src2 & 0x7; |
|
42255 diff2 = *(src2 + 1) & 0x3; |
|
42256 diff3 = *(src2 + 2) & 0x7; |
|
42257 //diffuse the error |
|
42258 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
42259 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
42260 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
42261 |
|
42262 /* Fourth Pixel */ |
|
42263 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
42264 diff1 = *(src2 + 3) & 0x7; |
|
42265 diff2 = *(src2 + 4) & 0x3; |
|
42266 diff3 = *(src2 + 5) & 0x7; |
|
42267 //diffuse the error |
|
42268 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
42269 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
42270 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
42271 |
|
42272 src2 += 6; |
|
42273 dest2 += 2; |
|
42274 } |
|
42275 if(extraCol) |
|
42276 { |
|
42277 *dest1 = dest1[-1]; |
|
42278 dest1++; |
|
42279 *dest2 = dest2[-1]; |
|
42280 dest2++; |
|
42281 } |
|
42282 |
|
42283 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
42284 |
|
42285 dest1 += ((wndWidth << 1) - lTempWidth); |
|
42286 dest2 += ((wndWidth << 1) - lTempWidth); |
|
42287 } |
|
42288 |
|
42289 if(extraRow) |
|
42290 { |
|
42291 dest2 = dest1 - wndWidth; |
|
42292 for(j = 0; j < lWidth; j += 2) |
|
42293 { |
|
42294 *dest1++ = *dest2++; |
|
42295 *dest1++ = *dest2++; |
|
42296 } |
|
42297 if(extraCol) |
|
42298 { |
|
42299 *dest1 = *dest2; |
|
42300 } |
|
42301 } |
|
42302 |
|
42303 free(lBuffer); |
|
42304 return; |
|
42305 } |
|
42306 |
|
42307 /* |
|
42308 ****************************************************************************** |
|
42309 Name : sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_709_RR |
|
42310 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
42311 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
42312 uint8 *dstImage : Pointer to rgb data (o/p). |
|
42313 tWndParam *srcWindow : Pointer to structure containing source window |
|
42314 parameters like xOffset,yOffset,cropWidth, |
|
42315 cropHeight. (i/p) |
|
42316 tWndParam *dstWindow : Pointer to structure containing destination window |
|
42317 parameters like xOffset,yOffset,windWidth, |
|
42318 windHeight. (i/p) |
|
42319 Return Value : void |
|
42320 ****************************************************************************** |
|
42321 */ |
|
42322 |
|
42323 void sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_709_RR |
|
42324 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
42325 tWndParam* srcWindow, tWndParam* dstWindow) |
|
42326 { |
|
42327 uint16 *dest1, *dest2; |
|
42328 uint8 *lYuyvPtr; |
|
42329 uint8 *lBuffer; |
|
42330 uint8 *src1, *src2; |
|
42331 uint8 *lPtr1, *lPtr2; |
|
42332 int32 diff1, diff2, diff3; |
|
42333 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
42334 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
42335 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
42336 int32 i, j, k, extraCol, extraRow; |
|
42337 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
42338 cropWidth,cropHeight,wndWidth,wndHeight; |
|
42339 |
|
42340 srcXOffset = srcWindow->xOffset; |
|
42341 srcYOffset = srcWindow->yOffset; |
|
42342 cropWidth = srcWindow->wndWidth; |
|
42343 cropHeight = srcWindow->wndHeight; |
|
42344 |
|
42345 dstXOffset = dstWindow->xOffset; |
|
42346 dstYOffset = dstWindow->yOffset; |
|
42347 wndWidth = dstWindow->wndWidth; |
|
42348 wndHeight = dstWindow->wndHeight; |
|
42349 |
|
42350 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
42351 { |
|
42352 lWidth = cropWidth; |
|
42353 } |
|
42354 else |
|
42355 { |
|
42356 lWidth = srcImage->width - srcXOffset; |
|
42357 } |
|
42358 |
|
42359 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
42360 { |
|
42361 lHeight = cropHeight; |
|
42362 } |
|
42363 else |
|
42364 { |
|
42365 lHeight = srcImage->height - srcYOffset; |
|
42366 } |
|
42367 |
|
42368 if (lWidth > (wndWidth - dstXOffset)) |
|
42369 { |
|
42370 lWidth = wndWidth - dstXOffset; |
|
42371 } |
|
42372 |
|
42373 if (lHeight > (wndHeight - dstYOffset)) |
|
42374 { |
|
42375 lHeight = wndHeight - dstYOffset; |
|
42376 } |
|
42377 |
|
42378 extraCol = lWidth & 0x01; |
|
42379 extraRow = lHeight & 0x01; |
|
42380 |
|
42381 lTempWidth = lWidth; |
|
42382 lWidth = (lWidth >> 1) << 1; |
|
42383 lHeight = (lHeight >> 1) << 1; |
|
42384 |
|
42385 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
42386 |
|
42387 lSrcWidth = lWidth * 3; |
|
42388 |
|
42389 lLumWidth = (srcImage->width >> 1) << 1; |
|
42390 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
42391 |
|
42392 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
42393 dest2 = dest1 + wndWidth; |
|
42394 |
|
42395 lLumWidth <<= 1; |
|
42396 |
|
42397 for(i = 0; i < lHeight; i += 2) |
|
42398 { |
|
42399 lPtr1 = src1 = lBuffer; |
|
42400 lPtr2 = src2 = src1 + lSrcWidth; |
|
42401 |
|
42402 for(k = 0; k < (lWidth - 2); k += 2) |
|
42403 { |
|
42404 lCb1 = lYuyvPtr[0]; |
|
42405 lCr1 = lYuyvPtr[2]; |
|
42406 |
|
42407 lCb2 = lYuyvPtr[4]; |
|
42408 lCr2 = lYuyvPtr[6]; |
|
42409 |
|
42410 lCr2 = (lCr1 + lCr2) >> 1; |
|
42411 lCb2 = (lCb1 + lCb2) >> 1; |
|
42412 |
|
42413 /*First Pixel*/ |
|
42414 lCb1 -= 128; |
|
42415 lCr1 -= 128; |
|
42416 |
|
42417 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
42418 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42419 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
42420 |
|
42421 lY1 = lYuyvPtr[1]; |
|
42422 lY1 -= 16; |
|
42423 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42424 |
|
42425 lTemp = lY1 + lTemp1; |
|
42426 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42427 |
|
42428 lTemp = lY1 - lTemp2; |
|
42429 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42430 |
|
42431 lTemp = lY1 + lTemp3; |
|
42432 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42433 |
|
42434 /*Second Pixel*/ |
|
42435 lCb2 -= 128; |
|
42436 lCr2 -= 128; |
|
42437 |
|
42438 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
42439 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
42440 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
42441 |
|
42442 lY1 = lYuyvPtr[3]; |
|
42443 lY1 -= 16; |
|
42444 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42445 |
|
42446 lTemp = lY1 + lTemp1; |
|
42447 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42448 |
|
42449 lTemp = lY1 - lTemp2; |
|
42450 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42451 |
|
42452 lTemp = lY1 + lTemp3; |
|
42453 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42454 |
|
42455 |
|
42456 lCb1 = lYuyvPtr[lLumWidth]; |
|
42457 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
42458 |
|
42459 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
42460 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
42461 |
|
42462 lCr2 = (lCr1 + lCr2) >> 1; |
|
42463 lCb2 = (lCb1 + lCb2) >> 1; |
|
42464 |
|
42465 |
|
42466 /*Third Pixel*/ |
|
42467 lCb1 -= 128; |
|
42468 lCr1 -= 128; |
|
42469 |
|
42470 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
42471 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42472 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
42473 |
|
42474 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
42475 lY1 -= 16; |
|
42476 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42477 |
|
42478 lTemp = lY1 + lTemp1; |
|
42479 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42480 |
|
42481 lTemp = lY1 - lTemp2; |
|
42482 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42483 |
|
42484 lTemp = lY1 + lTemp3; |
|
42485 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42486 |
|
42487 /*Fourth Pixel*/ |
|
42488 lCb2 -= 128; |
|
42489 lCr2 -= 128; |
|
42490 |
|
42491 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
42492 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
42493 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
42494 |
|
42495 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
42496 lY1 -= 16; |
|
42497 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42498 |
|
42499 lTemp = lY1 + lTemp1; |
|
42500 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42501 |
|
42502 lTemp = lY1 - lTemp2; |
|
42503 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42504 |
|
42505 lTemp = lY1 + lTemp3; |
|
42506 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42507 |
|
42508 |
|
42509 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
42510 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
42511 |
|
42512 lCb2 = lYuyvPtr[(lLumWidth << 1) + 4]; |
|
42513 lCr2 = lYuyvPtr[(lLumWidth << 1) + 6]; |
|
42514 |
|
42515 lCr2 = (lCr1 + lCr2) >> 1; |
|
42516 lCb2 = (lCb1 + lCb2) >> 1; |
|
42517 |
|
42518 /*Fifth Pixel*/ |
|
42519 lCb1 -= 128; |
|
42520 lCr1 -= 128; |
|
42521 |
|
42522 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
42523 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42524 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
42525 |
|
42526 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
42527 lY1 -= 16; |
|
42528 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42529 |
|
42530 lTemp = lY1 + lTemp1; |
|
42531 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42532 |
|
42533 lTemp = lY1 - lTemp2; |
|
42534 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42535 |
|
42536 lTemp = lY1 + lTemp3; |
|
42537 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42538 |
|
42539 /*Sixth Pixel*/ |
|
42540 lCb2 -= 128; |
|
42541 lCr2 -= 128; |
|
42542 |
|
42543 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
42544 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
42545 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
42546 |
|
42547 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
42548 lY1 -= 16; |
|
42549 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42550 |
|
42551 lTemp = lY1 + lTemp1; |
|
42552 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42553 |
|
42554 lTemp = lY1 - lTemp2; |
|
42555 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42556 |
|
42557 lTemp = lY1 + lTemp3; |
|
42558 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42559 |
|
42560 lYuyvPtr += 4; |
|
42561 src1 += 6; |
|
42562 src2 += 6; |
|
42563 } |
|
42564 |
|
42565 lCb1 = lYuyvPtr[0]; |
|
42566 lCr1 = lYuyvPtr[2]; |
|
42567 |
|
42568 lCb1 -= 128; |
|
42569 lCr1 -= 128; |
|
42570 |
|
42571 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
42572 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42573 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
42574 |
|
42575 /*First Pixel*/ |
|
42576 lY1 = lYuyvPtr[1]; |
|
42577 lY1 -= 16; |
|
42578 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42579 |
|
42580 lTemp = lY1 + lTemp1; |
|
42581 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42582 |
|
42583 lTemp = lY1 - lTemp2; |
|
42584 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42585 |
|
42586 lTemp = lY1 + lTemp3; |
|
42587 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42588 |
|
42589 /*Second Pixel*/ |
|
42590 lY1 = lYuyvPtr[3]; |
|
42591 lY1 -= 16; |
|
42592 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42593 |
|
42594 lTemp = lY1 + lTemp1; |
|
42595 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42596 |
|
42597 lTemp = lY1 - lTemp2; |
|
42598 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42599 |
|
42600 lTemp = lY1 + lTemp3; |
|
42601 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42602 |
|
42603 |
|
42604 lCb1 = lYuyvPtr[lLumWidth]; |
|
42605 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
42606 |
|
42607 lCb1 -= 128; |
|
42608 lCr1 -= 128; |
|
42609 |
|
42610 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
42611 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42612 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
42613 |
|
42614 /*Third Pixel*/ |
|
42615 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
42616 lY1 -= 16; |
|
42617 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42618 |
|
42619 lTemp = lY1 + lTemp1; |
|
42620 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42621 |
|
42622 lTemp = lY1 - lTemp2; |
|
42623 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42624 |
|
42625 lTemp = lY1 + lTemp3; |
|
42626 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42627 |
|
42628 /*Fourth Pixel*/ |
|
42629 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
42630 lY1 -= 16; |
|
42631 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42632 |
|
42633 lTemp = lY1 + lTemp1; |
|
42634 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42635 |
|
42636 lTemp = lY1 - lTemp2; |
|
42637 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42638 |
|
42639 lTemp = lY1 + lTemp3; |
|
42640 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42641 |
|
42642 |
|
42643 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
42644 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
42645 |
|
42646 lCb1 -= 128; |
|
42647 lCr1 -= 128; |
|
42648 |
|
42649 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
42650 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42651 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
42652 |
|
42653 /*Fifth Pixel*/ |
|
42654 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
42655 lY1 -= 16; |
|
42656 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42657 |
|
42658 lTemp = lY1 + lTemp1; |
|
42659 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42660 |
|
42661 lTemp = lY1 - lTemp2; |
|
42662 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42663 |
|
42664 lTemp = lY1 + lTemp3; |
|
42665 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42666 |
|
42667 /*Sixth Pixel*/ |
|
42668 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
42669 lY1 -= 16; |
|
42670 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42671 |
|
42672 lTemp = lY1 + lTemp1; |
|
42673 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42674 |
|
42675 lTemp = lY1 - lTemp2; |
|
42676 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42677 |
|
42678 lTemp = lY1 + lTemp3; |
|
42679 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42680 |
|
42681 lYuyvPtr += 4; |
|
42682 src1 += 6; |
|
42683 src2 += 6; |
|
42684 |
|
42685 |
|
42686 src1 = lPtr1; |
|
42687 src2 = lPtr2; |
|
42688 |
|
42689 for(j = 0; j < lWidth; j += 2) |
|
42690 { |
|
42691 /* First Pixel */ |
|
42692 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
42693 diff1 = *src1 & 0x7; |
|
42694 diff2 = *(src1 + 1) & 0x3; |
|
42695 diff3 = *(src1 + 2) & 0x7; |
|
42696 |
|
42697 // diffuse the error |
|
42698 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
42699 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
42700 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
42701 |
|
42702 /* Second Pixel */ |
|
42703 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
42704 diff1 = *(src1 + 3) & 0x7; |
|
42705 diff2 = *(src1 + 4) & 0x3; |
|
42706 diff3 = *(src1 + 5) & 0x7; |
|
42707 // diffuse the error |
|
42708 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
42709 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
42710 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
42711 |
|
42712 src1 += 6; |
|
42713 dest1 += 2; |
|
42714 |
|
42715 /* Third Pixel */ |
|
42716 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
42717 diff1 = *src2 & 0x7; |
|
42718 diff2 = *(src2 + 1) & 0x3; |
|
42719 diff3 = *(src2 + 2) & 0x7; |
|
42720 //diffuse the error |
|
42721 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
42722 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
42723 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
42724 |
|
42725 /* Fourth Pixel */ |
|
42726 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
42727 diff1 = *(src2 + 3) & 0x7; |
|
42728 diff2 = *(src2 + 4) & 0x3; |
|
42729 diff3 = *(src2 + 5) & 0x7; |
|
42730 //diffuse the error |
|
42731 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
42732 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
42733 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
42734 |
|
42735 src2 += 6; |
|
42736 dest2 += 2; |
|
42737 } |
|
42738 if(extraCol) |
|
42739 { |
|
42740 *dest1 = dest1[-1]; |
|
42741 dest1++; |
|
42742 *dest2 = dest2[-1]; |
|
42743 dest2++; |
|
42744 } |
|
42745 |
|
42746 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
42747 |
|
42748 dest1 += ((wndWidth << 1) - lTempWidth); |
|
42749 dest2 += ((wndWidth << 1) - lTempWidth); |
|
42750 } |
|
42751 |
|
42752 if(extraRow) |
|
42753 { |
|
42754 dest2 = dest1 - wndWidth; |
|
42755 for(j = 0; j < lWidth; j += 2) |
|
42756 { |
|
42757 *dest1++ = *dest2++; |
|
42758 *dest1++ = *dest2++; |
|
42759 } |
|
42760 if(extraCol) |
|
42761 { |
|
42762 *dest1 = *dest2; |
|
42763 } |
|
42764 } |
|
42765 |
|
42766 free(lBuffer); |
|
42767 return; |
|
42768 } |
|
42769 |
|
42770 /* |
|
42771 ****************************************************************************** |
|
42772 Name : sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_601_5_RR |
|
42773 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to RGB565 Interleaved format. |
|
42774 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
42775 uint8 *dstImage : Pointer to rgb data (o/p). |
|
42776 tWndParam *srcWindow : Pointer to structure containing source window |
|
42777 parameters like xOffset,yOffset,cropWidth, |
|
42778 cropHeight. (i/p) |
|
42779 tWndParam *dstWindow : Pointer to structure containing destination window |
|
42780 parameters like xOffset,yOffset,windWidth, |
|
42781 windHeight. (i/p) |
|
42782 Return Value : void |
|
42783 ****************************************************************************** |
|
42784 */ |
|
42785 |
|
42786 void sEmz_VDec_YUV422BEChr1toColor64k_ErrDiff_601_5_RR |
|
42787 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
42788 tWndParam* srcWindow, tWndParam* dstWindow) |
|
42789 { |
|
42790 uint16 *dest1, *dest2; |
|
42791 uint8 *lYuyvPtr; |
|
42792 uint8 *lBuffer; |
|
42793 uint8 *src1, *src2; |
|
42794 uint8 *lPtr1, *lPtr2; |
|
42795 int32 diff1, diff2, diff3; |
|
42796 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
42797 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
42798 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
42799 int32 i, j, k, extraCol, extraRow; |
|
42800 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
42801 cropWidth,cropHeight,wndWidth,wndHeight; |
|
42802 |
|
42803 srcXOffset = srcWindow->xOffset; |
|
42804 srcYOffset = srcWindow->yOffset; |
|
42805 cropWidth = srcWindow->wndWidth; |
|
42806 cropHeight = srcWindow->wndHeight; |
|
42807 |
|
42808 dstXOffset = dstWindow->xOffset; |
|
42809 dstYOffset = dstWindow->yOffset; |
|
42810 wndWidth = dstWindow->wndWidth; |
|
42811 wndHeight = dstWindow->wndHeight; |
|
42812 |
|
42813 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
42814 { |
|
42815 lWidth = cropWidth; |
|
42816 } |
|
42817 else |
|
42818 { |
|
42819 lWidth = srcImage->width - srcXOffset; |
|
42820 } |
|
42821 |
|
42822 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
42823 { |
|
42824 lHeight = cropHeight; |
|
42825 } |
|
42826 else |
|
42827 { |
|
42828 lHeight = srcImage->height - srcYOffset; |
|
42829 } |
|
42830 |
|
42831 if (lWidth > (wndWidth - dstXOffset)) |
|
42832 { |
|
42833 lWidth = wndWidth - dstXOffset; |
|
42834 } |
|
42835 |
|
42836 if (lHeight > (wndHeight - dstYOffset)) |
|
42837 { |
|
42838 lHeight = wndHeight - dstYOffset; |
|
42839 } |
|
42840 |
|
42841 extraCol = lWidth & 0x01; |
|
42842 extraRow = lHeight & 0x01; |
|
42843 |
|
42844 lTempWidth = lWidth; |
|
42845 lWidth = (lWidth >> 1) << 1; |
|
42846 lHeight = (lHeight >> 1) << 1; |
|
42847 |
|
42848 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
42849 |
|
42850 lSrcWidth = lWidth * 3; |
|
42851 |
|
42852 lLumWidth = (srcImage->width >> 1) << 1; |
|
42853 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
42854 |
|
42855 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
42856 dest2 = dest1 + wndWidth; |
|
42857 |
|
42858 lLumWidth <<= 1; |
|
42859 |
|
42860 for(i = 0; i < lHeight; i += 2) |
|
42861 { |
|
42862 lPtr1 = src1 = lBuffer; |
|
42863 lPtr2 = src2 = src1 + lSrcWidth; |
|
42864 |
|
42865 for(k = 0; k < (lWidth - 2); k += 2) |
|
42866 { |
|
42867 lCb1 = lYuyvPtr[0]; |
|
42868 lCr1 = lYuyvPtr[2]; |
|
42869 |
|
42870 lCb2 = lYuyvPtr[4]; |
|
42871 lCr2 = lYuyvPtr[6]; |
|
42872 |
|
42873 lCr2 = (lCr1 + lCr2) >> 1; |
|
42874 lCb2 = (lCb1 + lCb2) >> 1; |
|
42875 |
|
42876 /*First Pixel*/ |
|
42877 lCb1 -= 128; |
|
42878 lCr1 -= 128; |
|
42879 |
|
42880 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
42881 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42882 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
42883 |
|
42884 lY1 = lYuyvPtr[1]; |
|
42885 lY1 -= 16; |
|
42886 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42887 |
|
42888 lTemp = lY1 + lTemp1; |
|
42889 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42890 |
|
42891 lTemp = lY1 - lTemp2; |
|
42892 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42893 |
|
42894 lTemp = lY1 + lTemp3; |
|
42895 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42896 |
|
42897 /*Second Pixel*/ |
|
42898 lCb2 -= 128; |
|
42899 lCr2 -= 128; |
|
42900 |
|
42901 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
42902 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
42903 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
42904 |
|
42905 lY1 = lYuyvPtr[3]; |
|
42906 lY1 -= 16; |
|
42907 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42908 |
|
42909 lTemp = lY1 + lTemp1; |
|
42910 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42911 |
|
42912 lTemp = lY1 - lTemp2; |
|
42913 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42914 |
|
42915 lTemp = lY1 + lTemp3; |
|
42916 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42917 |
|
42918 |
|
42919 lCb1 = lYuyvPtr[lLumWidth]; |
|
42920 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
42921 |
|
42922 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
42923 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
42924 |
|
42925 lCr2 = (lCr1 + lCr2) >> 1; |
|
42926 lCb2 = (lCb1 + lCb2) >> 1; |
|
42927 |
|
42928 |
|
42929 /*Third Pixel*/ |
|
42930 lCb1 -= 128; |
|
42931 lCr1 -= 128; |
|
42932 |
|
42933 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
42934 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42935 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
42936 |
|
42937 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
42938 lY1 -= 16; |
|
42939 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42940 |
|
42941 lTemp = lY1 + lTemp1; |
|
42942 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42943 |
|
42944 lTemp = lY1 - lTemp2; |
|
42945 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42946 |
|
42947 lTemp = lY1 + lTemp3; |
|
42948 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42949 |
|
42950 /*Fourth Pixel*/ |
|
42951 lCb2 -= 128; |
|
42952 lCr2 -= 128; |
|
42953 |
|
42954 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
42955 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
42956 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
42957 |
|
42958 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
42959 lY1 -= 16; |
|
42960 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42961 |
|
42962 lTemp = lY1 + lTemp1; |
|
42963 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42964 |
|
42965 lTemp = lY1 - lTemp2; |
|
42966 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42967 |
|
42968 lTemp = lY1 + lTemp3; |
|
42969 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42970 |
|
42971 |
|
42972 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
42973 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
42974 |
|
42975 lCb2 = lYuyvPtr[(lLumWidth << 1) + 4]; |
|
42976 lCr2 = lYuyvPtr[(lLumWidth << 1) + 6]; |
|
42977 |
|
42978 lCr2 = (lCr1 + lCr2) >> 1; |
|
42979 lCb2 = (lCb1 + lCb2) >> 1; |
|
42980 |
|
42981 /*Fifth Pixel*/ |
|
42982 lCb1 -= 128; |
|
42983 lCr1 -= 128; |
|
42984 |
|
42985 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
42986 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
42987 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
42988 |
|
42989 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
42990 lY1 -= 16; |
|
42991 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
42992 |
|
42993 lTemp = lY1 + lTemp1; |
|
42994 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42995 |
|
42996 lTemp = lY1 - lTemp2; |
|
42997 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
42998 |
|
42999 lTemp = lY1 + lTemp3; |
|
43000 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43001 |
|
43002 /*Sixth Pixel*/ |
|
43003 lCb2 -= 128; |
|
43004 lCr2 -= 128; |
|
43005 |
|
43006 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
43007 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
43008 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
43009 |
|
43010 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
43011 lY1 -= 16; |
|
43012 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
43013 |
|
43014 lTemp = lY1 + lTemp1; |
|
43015 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43016 |
|
43017 lTemp = lY1 - lTemp2; |
|
43018 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43019 |
|
43020 lTemp = lY1 + lTemp3; |
|
43021 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43022 |
|
43023 lYuyvPtr += 4; |
|
43024 src1 += 6; |
|
43025 src2 += 6; |
|
43026 } |
|
43027 |
|
43028 lCb1 = lYuyvPtr[0]; |
|
43029 lCr1 = lYuyvPtr[2]; |
|
43030 |
|
43031 lCb1 -= 128; |
|
43032 lCr1 -= 128; |
|
43033 |
|
43034 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
43035 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43036 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
43037 |
|
43038 /*First Pixel*/ |
|
43039 lY1 = lYuyvPtr[1]; |
|
43040 lY1 -= 16; |
|
43041 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
43042 |
|
43043 lTemp = lY1 + lTemp1; |
|
43044 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43045 |
|
43046 lTemp = lY1 - lTemp2; |
|
43047 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43048 |
|
43049 lTemp = lY1 + lTemp3; |
|
43050 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43051 |
|
43052 /*Second Pixel*/ |
|
43053 lY1 = lYuyvPtr[3]; |
|
43054 lY1 -= 16; |
|
43055 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
43056 |
|
43057 lTemp = lY1 + lTemp1; |
|
43058 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43059 |
|
43060 lTemp = lY1 - lTemp2; |
|
43061 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43062 |
|
43063 lTemp = lY1 + lTemp3; |
|
43064 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43065 |
|
43066 |
|
43067 lCb1 = lYuyvPtr[lLumWidth]; |
|
43068 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
43069 |
|
43070 lCb1 -= 128; |
|
43071 lCr1 -= 128; |
|
43072 |
|
43073 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
43074 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43075 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
43076 |
|
43077 /*Third Pixel*/ |
|
43078 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
43079 lY1 -= 16; |
|
43080 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
43081 |
|
43082 lTemp = lY1 + lTemp1; |
|
43083 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43084 |
|
43085 lTemp = lY1 - lTemp2; |
|
43086 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43087 |
|
43088 lTemp = lY1 + lTemp3; |
|
43089 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43090 |
|
43091 /*Fourth Pixel*/ |
|
43092 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
43093 lY1 -= 16; |
|
43094 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
43095 |
|
43096 lTemp = lY1 + lTemp1; |
|
43097 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43098 |
|
43099 lTemp = lY1 - lTemp2; |
|
43100 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43101 |
|
43102 lTemp = lY1 + lTemp3; |
|
43103 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43104 |
|
43105 |
|
43106 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
43107 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
43108 |
|
43109 lCb1 -= 128; |
|
43110 lCr1 -= 128; |
|
43111 |
|
43112 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
43113 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43114 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
43115 |
|
43116 /*Fifth Pixel*/ |
|
43117 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
43118 lY1 -= 16; |
|
43119 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
43120 |
|
43121 lTemp = lY1 + lTemp1; |
|
43122 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43123 |
|
43124 lTemp = lY1 - lTemp2; |
|
43125 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43126 |
|
43127 lTemp = lY1 + lTemp3; |
|
43128 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43129 |
|
43130 /*Sixth Pixel*/ |
|
43131 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
43132 lY1 -= 16; |
|
43133 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
43134 |
|
43135 lTemp = lY1 + lTemp1; |
|
43136 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43137 |
|
43138 lTemp = lY1 - lTemp2; |
|
43139 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43140 |
|
43141 lTemp = lY1 + lTemp3; |
|
43142 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
43143 |
|
43144 lYuyvPtr += 4; |
|
43145 src1 += 6; |
|
43146 src2 += 6; |
|
43147 |
|
43148 |
|
43149 src1 = lPtr1; |
|
43150 src2 = lPtr2; |
|
43151 |
|
43152 for(j = 0; j < lWidth; j += 2) |
|
43153 { |
|
43154 /* First Pixel */ |
|
43155 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
43156 diff1 = *src1 & 0x7; |
|
43157 diff2 = *(src1 + 1) & 0x3; |
|
43158 diff3 = *(src1 + 2) & 0x7; |
|
43159 |
|
43160 // diffuse the error |
|
43161 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
43162 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
43163 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
43164 |
|
43165 /* Second Pixel */ |
|
43166 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
43167 diff1 = *(src1 + 3) & 0x7; |
|
43168 diff2 = *(src1 + 4) & 0x3; |
|
43169 diff3 = *(src1 + 5) & 0x7; |
|
43170 // diffuse the error |
|
43171 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
43172 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
43173 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
43174 |
|
43175 src1 += 6; |
|
43176 dest1 += 2; |
|
43177 |
|
43178 /* Third Pixel */ |
|
43179 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
43180 diff1 = *src2 & 0x7; |
|
43181 diff2 = *(src2 + 1) & 0x3; |
|
43182 diff3 = *(src2 + 2) & 0x7; |
|
43183 //diffuse the error |
|
43184 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
43185 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
43186 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
43187 |
|
43188 /* Fourth Pixel */ |
|
43189 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
43190 diff1 = *(src2 + 3) & 0x7; |
|
43191 diff2 = *(src2 + 4) & 0x3; |
|
43192 diff3 = *(src2 + 5) & 0x7; |
|
43193 //diffuse the error |
|
43194 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
43195 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
43196 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
43197 |
|
43198 src2 += 6; |
|
43199 dest2 += 2; |
|
43200 } |
|
43201 if(extraCol) |
|
43202 { |
|
43203 *dest1 = dest1[-1]; |
|
43204 dest1++; |
|
43205 *dest2 = dest2[-1]; |
|
43206 dest2++; |
|
43207 } |
|
43208 |
|
43209 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
43210 |
|
43211 dest1 += ((wndWidth << 1) - lTempWidth); |
|
43212 dest2 += ((wndWidth << 1) - lTempWidth); |
|
43213 } |
|
43214 |
|
43215 if(extraRow) |
|
43216 { |
|
43217 dest2 = dest1 - wndWidth; |
|
43218 for(j = 0; j < lWidth; j += 2) |
|
43219 { |
|
43220 *dest1++ = *dest2++; |
|
43221 *dest1++ = *dest2++; |
|
43222 } |
|
43223 if(extraCol) |
|
43224 { |
|
43225 *dest1 = *dest2; |
|
43226 } |
|
43227 } |
|
43228 |
|
43229 free(lBuffer); |
|
43230 return; |
|
43231 } |
|
43232 |
|
43233 |
|
43234 /* |
|
43235 ****************************************************************************** |
|
43236 Name : sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_709_FR |
|
43237 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
43238 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
43239 uint8 *dstImage : Pointer to rgb data (o/p). |
|
43240 tWndParam *srcWindow : Pointer to structure containing source window |
|
43241 parameters like xOffset,yOffset,cropWidth, |
|
43242 cropHeight. (i/p) |
|
43243 tWndParam *dstWindow : Pointer to structure containing destination window |
|
43244 parameters like xOffset,yOffset,windWidth, |
|
43245 windHeight. (i/p) |
|
43246 Return Value : void |
|
43247 ****************************************************************************** |
|
43248 */ |
|
43249 |
|
43250 void sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_709_FR |
|
43251 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
43252 tWndParam* srcWindow, tWndParam* dstWindow) |
|
43253 { |
|
43254 uint16 *dest1, *dest2; |
|
43255 uint8 *lYuyvPtr; |
|
43256 uint8 *lBuffer; |
|
43257 uint8 *src1, *src2; |
|
43258 uint8 *lPtr1, *lPtr2; |
|
43259 int32 diff1, diff2, diff3; |
|
43260 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
43261 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
43262 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
43263 int32 i, j, k, extraCol, extraRow; |
|
43264 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
43265 cropWidth,cropHeight,wndWidth,wndHeight; |
|
43266 |
|
43267 srcXOffset = srcWindow->xOffset; |
|
43268 srcYOffset = srcWindow->yOffset; |
|
43269 cropWidth = srcWindow->wndWidth; |
|
43270 cropHeight = srcWindow->wndHeight; |
|
43271 |
|
43272 dstXOffset = dstWindow->xOffset; |
|
43273 dstYOffset = dstWindow->yOffset; |
|
43274 wndWidth = dstWindow->wndWidth; |
|
43275 wndHeight = dstWindow->wndHeight; |
|
43276 |
|
43277 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
43278 { |
|
43279 lWidth = cropWidth; |
|
43280 } |
|
43281 else |
|
43282 { |
|
43283 lWidth = srcImage->width - srcXOffset; |
|
43284 } |
|
43285 |
|
43286 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
43287 { |
|
43288 lHeight = cropHeight; |
|
43289 } |
|
43290 else |
|
43291 { |
|
43292 lHeight = srcImage->height - srcYOffset; |
|
43293 } |
|
43294 |
|
43295 if (lWidth > (wndWidth - dstXOffset)) |
|
43296 { |
|
43297 lWidth = wndWidth - dstXOffset; |
|
43298 } |
|
43299 |
|
43300 if (lHeight > (wndHeight - dstYOffset)) |
|
43301 { |
|
43302 lHeight = wndHeight - dstYOffset; |
|
43303 } |
|
43304 |
|
43305 extraCol = lWidth & 0x01; |
|
43306 extraRow = lHeight & 0x01; |
|
43307 |
|
43308 lTempWidth = lWidth; |
|
43309 lWidth = (lWidth >> 1) << 1; |
|
43310 lHeight = (lHeight >> 1) << 1; |
|
43311 |
|
43312 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
43313 |
|
43314 lSrcWidth = lWidth * 3; |
|
43315 |
|
43316 lLumWidth = (srcImage->width >> 1) << 1; |
|
43317 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
43318 |
|
43319 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
43320 dest2 = dest1 + wndWidth; |
|
43321 |
|
43322 lLumWidth <<= 1; |
|
43323 |
|
43324 for(i = 0; i < lHeight; i += 2) |
|
43325 { |
|
43326 lPtr1 = src1 = lBuffer; |
|
43327 lPtr2 = src2 = src1 + lSrcWidth; |
|
43328 |
|
43329 for(k = 0; k < (lWidth - 2); k += 2) |
|
43330 { |
|
43331 lCb1 = lYuyvPtr[0]; |
|
43332 lCr1 = lYuyvPtr[2]; |
|
43333 |
|
43334 lCb2 = lYuyvPtr[4]; |
|
43335 lCr2 = lYuyvPtr[6]; |
|
43336 |
|
43337 lCr2 = (lCr1 + lCr2) >> 1; |
|
43338 lCb2 = (lCb1 + lCb2) >> 1; |
|
43339 |
|
43340 /*First Pixel*/ |
|
43341 lCb1 -= 128; |
|
43342 lCr1 -= 128; |
|
43343 |
|
43344 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
43345 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43346 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
43347 |
|
43348 lY1 = lYuyvPtr[1]; |
|
43349 |
|
43350 lTemp = lY1 + lTemp1; |
|
43351 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43352 |
|
43353 lTemp = lY1 - lTemp2; |
|
43354 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43355 |
|
43356 lTemp = lY1 + lTemp3; |
|
43357 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43358 |
|
43359 /*Second Pixel*/ |
|
43360 lCb2 -= 128; |
|
43361 lCr2 -= 128; |
|
43362 |
|
43363 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
43364 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
43365 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
43366 |
|
43367 lY1 = lYuyvPtr[3]; |
|
43368 |
|
43369 lTemp = lY1 + lTemp1; |
|
43370 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43371 |
|
43372 lTemp = lY1 - lTemp2; |
|
43373 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43374 |
|
43375 lTemp = lY1 + lTemp3; |
|
43376 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43377 |
|
43378 |
|
43379 lCb1 = lYuyvPtr[lLumWidth]; |
|
43380 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
43381 |
|
43382 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
43383 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
43384 |
|
43385 lCr2 = (lCr1 + lCr2) >> 1; |
|
43386 lCb2 = (lCb1 + lCb2) >> 1; |
|
43387 |
|
43388 |
|
43389 /*Third Pixel*/ |
|
43390 lCb1 -= 128; |
|
43391 lCr1 -= 128; |
|
43392 |
|
43393 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
43394 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43395 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
43396 |
|
43397 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
43398 |
|
43399 lTemp = lY1 + lTemp1; |
|
43400 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43401 |
|
43402 lTemp = lY1 - lTemp2; |
|
43403 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43404 |
|
43405 lTemp = lY1 + lTemp3; |
|
43406 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43407 |
|
43408 /*Fourth Pixel*/ |
|
43409 lCb2 -= 128; |
|
43410 lCr2 -= 128; |
|
43411 |
|
43412 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
43413 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
43414 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
43415 |
|
43416 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
43417 |
|
43418 lTemp = lY1 + lTemp1; |
|
43419 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43420 |
|
43421 lTemp = lY1 - lTemp2; |
|
43422 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43423 |
|
43424 lTemp = lY1 + lTemp3; |
|
43425 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43426 |
|
43427 |
|
43428 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
43429 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
43430 |
|
43431 lCb2 = lYuyvPtr[(lLumWidth << 1) + 4]; |
|
43432 lCr2 = lYuyvPtr[(lLumWidth << 1) + 6]; |
|
43433 |
|
43434 lCr2 = (lCr1 + lCr2) >> 1; |
|
43435 lCb2 = (lCb1 + lCb2) >> 1; |
|
43436 |
|
43437 /*Fifth Pixel*/ |
|
43438 lCb1 -= 128; |
|
43439 lCr1 -= 128; |
|
43440 |
|
43441 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
43442 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43443 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
43444 |
|
43445 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
43446 |
|
43447 lTemp = lY1 + lTemp1; |
|
43448 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43449 |
|
43450 lTemp = lY1 - lTemp2; |
|
43451 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43452 |
|
43453 lTemp = lY1 + lTemp3; |
|
43454 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43455 |
|
43456 /*Sixth Pixel*/ |
|
43457 lCb2 -= 128; |
|
43458 lCr2 -= 128; |
|
43459 |
|
43460 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
43461 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
43462 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
43463 |
|
43464 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
43465 |
|
43466 lTemp = lY1 + lTemp1; |
|
43467 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43468 |
|
43469 lTemp = lY1 - lTemp2; |
|
43470 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43471 |
|
43472 lTemp = lY1 + lTemp3; |
|
43473 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43474 |
|
43475 lYuyvPtr += 4; |
|
43476 src1 += 6; |
|
43477 src2 += 6; |
|
43478 } |
|
43479 |
|
43480 lCb1 = lYuyvPtr[0]; |
|
43481 lCr1 = lYuyvPtr[2]; |
|
43482 |
|
43483 lCb1 -= 128; |
|
43484 lCr1 -= 128; |
|
43485 |
|
43486 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
43487 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43488 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
43489 |
|
43490 /*First Pixel*/ |
|
43491 lY1 = lYuyvPtr[1]; |
|
43492 |
|
43493 lTemp = lY1 + lTemp1; |
|
43494 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43495 |
|
43496 lTemp = lY1 - lTemp2; |
|
43497 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43498 |
|
43499 lTemp = lY1 + lTemp3; |
|
43500 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43501 |
|
43502 /*Second Pixel*/ |
|
43503 lY1 = lYuyvPtr[3]; |
|
43504 |
|
43505 lTemp = lY1 + lTemp1; |
|
43506 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43507 |
|
43508 lTemp = lY1 - lTemp2; |
|
43509 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43510 |
|
43511 lTemp = lY1 + lTemp3; |
|
43512 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43513 |
|
43514 |
|
43515 lCb1 = lYuyvPtr[lLumWidth]; |
|
43516 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
43517 |
|
43518 lCb1 -= 128; |
|
43519 lCr1 -= 128; |
|
43520 |
|
43521 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
43522 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43523 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
43524 |
|
43525 /*Third Pixel*/ |
|
43526 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
43527 |
|
43528 lTemp = lY1 + lTemp1; |
|
43529 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43530 |
|
43531 lTemp = lY1 - lTemp2; |
|
43532 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43533 |
|
43534 lTemp = lY1 + lTemp3; |
|
43535 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43536 |
|
43537 /*Fourth Pixel*/ |
|
43538 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
43539 |
|
43540 lTemp = lY1 + lTemp1; |
|
43541 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43542 |
|
43543 lTemp = lY1 - lTemp2; |
|
43544 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43545 |
|
43546 lTemp = lY1 + lTemp3; |
|
43547 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43548 |
|
43549 |
|
43550 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
43551 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
43552 |
|
43553 lCb1 -= 128; |
|
43554 lCr1 -= 128; |
|
43555 |
|
43556 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
43557 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43558 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
43559 |
|
43560 /*Fifth Pixel*/ |
|
43561 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
43562 |
|
43563 lTemp = lY1 + lTemp1; |
|
43564 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43565 |
|
43566 lTemp = lY1 - lTemp2; |
|
43567 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43568 |
|
43569 lTemp = lY1 + lTemp3; |
|
43570 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43571 |
|
43572 /*Sixth Pixel*/ |
|
43573 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
43574 |
|
43575 lTemp = lY1 + lTemp1; |
|
43576 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43577 |
|
43578 lTemp = lY1 - lTemp2; |
|
43579 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43580 |
|
43581 lTemp = lY1 + lTemp3; |
|
43582 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43583 |
|
43584 lYuyvPtr += 4; |
|
43585 src1 += 6; |
|
43586 src2 += 6; |
|
43587 |
|
43588 |
|
43589 src1 = lPtr1; |
|
43590 src2 = lPtr2; |
|
43591 |
|
43592 for(j = 0; j < lWidth; j += 2) |
|
43593 { |
|
43594 /* First Pixel */ |
|
43595 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
43596 diff1 = *src1 & 0xf; |
|
43597 diff2 = *(src1 + 1) & 0xf; |
|
43598 diff3 = *(src1 + 2) & 0xf; |
|
43599 |
|
43600 // diffuse the error |
|
43601 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
43602 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
43603 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
43604 |
|
43605 /* Second Pixel */ |
|
43606 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
43607 diff1 = *(src1 + 3) & 0xf; |
|
43608 diff2 = *(src1 + 4) & 0xf; |
|
43609 diff3 = *(src1 + 5) & 0xf; |
|
43610 // diffuse the error |
|
43611 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
43612 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
43613 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
43614 |
|
43615 src1 += 6; |
|
43616 dest1 += 2; |
|
43617 |
|
43618 /* Third Pixel */ |
|
43619 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
43620 diff1 = *src2 & 0xf; |
|
43621 diff2 = *(src2 + 1) & 0xf; |
|
43622 diff3 = *(src2 + 2) & 0xf; |
|
43623 //diffuse the error |
|
43624 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
43625 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
43626 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
43627 |
|
43628 /* Fourth Pixel */ |
|
43629 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
43630 diff1 = *(src2 + 3) & 0xf; |
|
43631 diff2 = *(src2 + 4) & 0xf; |
|
43632 diff3 = *(src2 + 5) & 0xf; |
|
43633 //diffuse the error |
|
43634 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
43635 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
43636 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
43637 |
|
43638 src2 += 6; |
|
43639 dest2 += 2; |
|
43640 } |
|
43641 if(extraCol) |
|
43642 { |
|
43643 *dest1 = dest1[-1]; |
|
43644 dest1++; |
|
43645 *dest2 = dest2[-1]; |
|
43646 dest2++; |
|
43647 } |
|
43648 |
|
43649 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
43650 |
|
43651 dest1 += ((wndWidth << 1) - lTempWidth); |
|
43652 dest2 += ((wndWidth << 1) - lTempWidth); |
|
43653 } |
|
43654 |
|
43655 if(extraRow) |
|
43656 { |
|
43657 dest2 = dest1 - wndWidth; |
|
43658 for(j = 0; j < lWidth; j += 2) |
|
43659 { |
|
43660 *dest1++ = *dest2++; |
|
43661 *dest1++ = *dest2++; |
|
43662 } |
|
43663 if(extraCol) |
|
43664 { |
|
43665 *dest1 = *dest2; |
|
43666 } |
|
43667 } |
|
43668 |
|
43669 free(lBuffer); |
|
43670 return; |
|
43671 } |
|
43672 |
|
43673 /* |
|
43674 ****************************************************************************** |
|
43675 Name : sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_601_5_FR |
|
43676 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
43677 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
43678 uint8 *dstImage : Pointer to rgb data (o/p). |
|
43679 tWndParam *srcWindow : Pointer to structure containing source window |
|
43680 parameters like xOffset,yOffset,cropWidth, |
|
43681 cropHeight. (i/p) |
|
43682 tWndParam *dstWindow : Pointer to structure containing destination window |
|
43683 parameters like xOffset,yOffset,windWidth, |
|
43684 windHeight. (i/p) |
|
43685 Return Value : void |
|
43686 ****************************************************************************** |
|
43687 */ |
|
43688 |
|
43689 void sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_601_5_FR |
|
43690 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
43691 tWndParam* srcWindow, tWndParam* dstWindow) |
|
43692 { |
|
43693 uint16 *dest1, *dest2; |
|
43694 uint8 *lYuyvPtr; |
|
43695 uint8 *lBuffer; |
|
43696 uint8 *src1, *src2; |
|
43697 uint8 *lPtr1, *lPtr2; |
|
43698 int32 diff1, diff2, diff3; |
|
43699 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
43700 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
43701 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
43702 int32 i, j, k, extraCol, extraRow; |
|
43703 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
43704 cropWidth,cropHeight,wndWidth,wndHeight; |
|
43705 |
|
43706 srcXOffset = srcWindow->xOffset; |
|
43707 srcYOffset = srcWindow->yOffset; |
|
43708 cropWidth = srcWindow->wndWidth; |
|
43709 cropHeight = srcWindow->wndHeight; |
|
43710 |
|
43711 dstXOffset = dstWindow->xOffset; |
|
43712 dstYOffset = dstWindow->yOffset; |
|
43713 wndWidth = dstWindow->wndWidth; |
|
43714 wndHeight = dstWindow->wndHeight; |
|
43715 |
|
43716 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
43717 { |
|
43718 lWidth = cropWidth; |
|
43719 } |
|
43720 else |
|
43721 { |
|
43722 lWidth = srcImage->width - srcXOffset; |
|
43723 } |
|
43724 |
|
43725 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
43726 { |
|
43727 lHeight = cropHeight; |
|
43728 } |
|
43729 else |
|
43730 { |
|
43731 lHeight = srcImage->height - srcYOffset; |
|
43732 } |
|
43733 |
|
43734 if (lWidth > (wndWidth - dstXOffset)) |
|
43735 { |
|
43736 lWidth = wndWidth - dstXOffset; |
|
43737 } |
|
43738 |
|
43739 if (lHeight > (wndHeight - dstYOffset)) |
|
43740 { |
|
43741 lHeight = wndHeight - dstYOffset; |
|
43742 } |
|
43743 |
|
43744 extraCol = lWidth & 0x01; |
|
43745 extraRow = lHeight & 0x01; |
|
43746 |
|
43747 lTempWidth = lWidth; |
|
43748 lWidth = (lWidth >> 1) << 1; |
|
43749 lHeight = (lHeight >> 1) << 1; |
|
43750 |
|
43751 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
43752 |
|
43753 lSrcWidth = lWidth * 3; |
|
43754 |
|
43755 lLumWidth = (srcImage->width >> 1) << 1; |
|
43756 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
43757 |
|
43758 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
43759 dest2 = dest1 + wndWidth; |
|
43760 |
|
43761 lLumWidth <<= 1; |
|
43762 |
|
43763 for(i = 0; i < lHeight; i += 2) |
|
43764 { |
|
43765 lPtr1 = src1 = lBuffer; |
|
43766 lPtr2 = src2 = src1 + lSrcWidth; |
|
43767 |
|
43768 for(k = 0; k < (lWidth - 2); k += 2) |
|
43769 { |
|
43770 lCb1 = lYuyvPtr[0]; |
|
43771 lCr1 = lYuyvPtr[2]; |
|
43772 |
|
43773 lCb2 = lYuyvPtr[4]; |
|
43774 lCr2 = lYuyvPtr[6]; |
|
43775 |
|
43776 lCr2 = (lCr1 + lCr2) >> 1; |
|
43777 lCb2 = (lCb1 + lCb2) >> 1; |
|
43778 |
|
43779 /*First Pixel*/ |
|
43780 lCb1 -= 128; |
|
43781 lCr1 -= 128; |
|
43782 |
|
43783 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
43784 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43785 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
43786 |
|
43787 lY1 = lYuyvPtr[1]; |
|
43788 |
|
43789 lTemp = lY1 + lTemp1; |
|
43790 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43791 |
|
43792 lTemp = lY1 - lTemp2; |
|
43793 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43794 |
|
43795 lTemp = lY1 + lTemp3; |
|
43796 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43797 |
|
43798 /*Second Pixel*/ |
|
43799 lCb2 -= 128; |
|
43800 lCr2 -= 128; |
|
43801 |
|
43802 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
43803 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
43804 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
43805 |
|
43806 lY1 = lYuyvPtr[3]; |
|
43807 |
|
43808 lTemp = lY1 + lTemp1; |
|
43809 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43810 |
|
43811 lTemp = lY1 - lTemp2; |
|
43812 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43813 |
|
43814 lTemp = lY1 + lTemp3; |
|
43815 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43816 |
|
43817 |
|
43818 lCb1 = lYuyvPtr[lLumWidth]; |
|
43819 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
43820 |
|
43821 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
43822 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
43823 |
|
43824 lCr2 = (lCr1 + lCr2) >> 1; |
|
43825 lCb2 = (lCb1 + lCb2) >> 1; |
|
43826 |
|
43827 |
|
43828 /*Third Pixel*/ |
|
43829 lCb1 -= 128; |
|
43830 lCr1 -= 128; |
|
43831 |
|
43832 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
43833 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43834 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
43835 |
|
43836 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
43837 |
|
43838 lTemp = lY1 + lTemp1; |
|
43839 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43840 |
|
43841 lTemp = lY1 - lTemp2; |
|
43842 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43843 |
|
43844 lTemp = lY1 + lTemp3; |
|
43845 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43846 |
|
43847 /*Fourth Pixel*/ |
|
43848 lCb2 -= 128; |
|
43849 lCr2 -= 128; |
|
43850 |
|
43851 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
43852 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
43853 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
43854 |
|
43855 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
43856 |
|
43857 lTemp = lY1 + lTemp1; |
|
43858 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43859 |
|
43860 lTemp = lY1 - lTemp2; |
|
43861 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43862 |
|
43863 lTemp = lY1 + lTemp3; |
|
43864 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43865 |
|
43866 |
|
43867 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
43868 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
43869 |
|
43870 lCb2 = lYuyvPtr[(lLumWidth << 1) + 4]; |
|
43871 lCr2 = lYuyvPtr[(lLumWidth << 1) + 6]; |
|
43872 |
|
43873 lCr2 = (lCr1 + lCr2) >> 1; |
|
43874 lCb2 = (lCb1 + lCb2) >> 1; |
|
43875 |
|
43876 /*Fifth Pixel*/ |
|
43877 lCb1 -= 128; |
|
43878 lCr1 -= 128; |
|
43879 |
|
43880 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
43881 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43882 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
43883 |
|
43884 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
43885 |
|
43886 lTemp = lY1 + lTemp1; |
|
43887 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43888 |
|
43889 lTemp = lY1 - lTemp2; |
|
43890 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43891 |
|
43892 lTemp = lY1 + lTemp3; |
|
43893 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43894 |
|
43895 /*Sixth Pixel*/ |
|
43896 lCb2 -= 128; |
|
43897 lCr2 -= 128; |
|
43898 |
|
43899 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
43900 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
43901 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
43902 |
|
43903 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
43904 |
|
43905 lTemp = lY1 + lTemp1; |
|
43906 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43907 |
|
43908 lTemp = lY1 - lTemp2; |
|
43909 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43910 |
|
43911 lTemp = lY1 + lTemp3; |
|
43912 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43913 |
|
43914 lYuyvPtr += 4; |
|
43915 src1 += 6; |
|
43916 src2 += 6; |
|
43917 } |
|
43918 |
|
43919 lCb1 = lYuyvPtr[0]; |
|
43920 lCr1 = lYuyvPtr[2]; |
|
43921 |
|
43922 lCb1 -= 128; |
|
43923 lCr1 -= 128; |
|
43924 |
|
43925 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
43926 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43927 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
43928 |
|
43929 /*First Pixel*/ |
|
43930 lY1 = lYuyvPtr[1]; |
|
43931 |
|
43932 lTemp = lY1 + lTemp1; |
|
43933 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43934 |
|
43935 lTemp = lY1 - lTemp2; |
|
43936 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43937 |
|
43938 lTemp = lY1 + lTemp3; |
|
43939 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43940 |
|
43941 /*Second Pixel*/ |
|
43942 lY1 = lYuyvPtr[3]; |
|
43943 |
|
43944 lTemp = lY1 + lTemp1; |
|
43945 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43946 |
|
43947 lTemp = lY1 - lTemp2; |
|
43948 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43949 |
|
43950 lTemp = lY1 + lTemp3; |
|
43951 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43952 |
|
43953 |
|
43954 lCb1 = lYuyvPtr[lLumWidth]; |
|
43955 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
43956 |
|
43957 lCb1 -= 128; |
|
43958 lCr1 -= 128; |
|
43959 |
|
43960 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
43961 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43962 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
43963 |
|
43964 /*Third Pixel*/ |
|
43965 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
43966 |
|
43967 lTemp = lY1 + lTemp1; |
|
43968 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43969 |
|
43970 lTemp = lY1 - lTemp2; |
|
43971 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43972 |
|
43973 lTemp = lY1 + lTemp3; |
|
43974 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43975 |
|
43976 /*Fourth Pixel*/ |
|
43977 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
43978 |
|
43979 lTemp = lY1 + lTemp1; |
|
43980 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43981 |
|
43982 lTemp = lY1 - lTemp2; |
|
43983 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43984 |
|
43985 lTemp = lY1 + lTemp3; |
|
43986 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
43987 |
|
43988 |
|
43989 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
43990 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
43991 |
|
43992 lCb1 -= 128; |
|
43993 lCr1 -= 128; |
|
43994 |
|
43995 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
43996 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
43997 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
43998 |
|
43999 /*Fifth Pixel*/ |
|
44000 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
44001 |
|
44002 lTemp = lY1 + lTemp1; |
|
44003 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
44004 |
|
44005 lTemp = lY1 - lTemp2; |
|
44006 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
44007 |
|
44008 lTemp = lY1 + lTemp3; |
|
44009 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
44010 |
|
44011 /*Sixth Pixel*/ |
|
44012 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
44013 |
|
44014 lTemp = lY1 + lTemp1; |
|
44015 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
44016 |
|
44017 lTemp = lY1 - lTemp2; |
|
44018 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
44019 |
|
44020 lTemp = lY1 + lTemp3; |
|
44021 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
44022 |
|
44023 lYuyvPtr += 4; |
|
44024 src1 += 6; |
|
44025 src2 += 6; |
|
44026 |
|
44027 |
|
44028 src1 = lPtr1; |
|
44029 src2 = lPtr2; |
|
44030 |
|
44031 for(j = 0; j < lWidth; j += 2) |
|
44032 { |
|
44033 /* First Pixel */ |
|
44034 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
44035 diff1 = *src1 & 0xf; |
|
44036 diff2 = *(src1 + 1) & 0xf; |
|
44037 diff3 = *(src1 + 2) & 0xf; |
|
44038 |
|
44039 // diffuse the error |
|
44040 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
44041 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
44042 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
44043 |
|
44044 /* Second Pixel */ |
|
44045 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
44046 diff1 = *(src1 + 3) & 0xf; |
|
44047 diff2 = *(src1 + 4) & 0xf; |
|
44048 diff3 = *(src1 + 5) & 0xf; |
|
44049 // diffuse the error |
|
44050 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
44051 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
44052 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
44053 |
|
44054 src1 += 6; |
|
44055 dest1 += 2; |
|
44056 |
|
44057 /* Third Pixel */ |
|
44058 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
44059 diff1 = *src2 & 0xf; |
|
44060 diff2 = *(src2 + 1) & 0xf; |
|
44061 diff3 = *(src2 + 2) & 0xf; |
|
44062 //diffuse the error |
|
44063 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
44064 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
44065 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
44066 |
|
44067 /* Fourth Pixel */ |
|
44068 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
44069 diff1 = *(src2 + 3) & 0xf; |
|
44070 diff2 = *(src2 + 4) & 0xf; |
|
44071 diff3 = *(src2 + 5) & 0xf; |
|
44072 //diffuse the error |
|
44073 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
44074 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
44075 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
44076 |
|
44077 src2 += 6; |
|
44078 dest2 += 2; |
|
44079 } |
|
44080 if(extraCol) |
|
44081 { |
|
44082 *dest1 = dest1[-1]; |
|
44083 dest1++; |
|
44084 *dest2 = dest2[-1]; |
|
44085 dest2++; |
|
44086 } |
|
44087 |
|
44088 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
44089 |
|
44090 dest1 += ((wndWidth << 1) - lTempWidth); |
|
44091 dest2 += ((wndWidth << 1) - lTempWidth); |
|
44092 } |
|
44093 |
|
44094 if(extraRow) |
|
44095 { |
|
44096 dest2 = dest1 - wndWidth; |
|
44097 for(j = 0; j < lWidth; j += 2) |
|
44098 { |
|
44099 *dest1++ = *dest2++; |
|
44100 *dest1++ = *dest2++; |
|
44101 } |
|
44102 if(extraCol) |
|
44103 { |
|
44104 *dest1 = *dest2; |
|
44105 } |
|
44106 } |
|
44107 |
|
44108 free(lBuffer); |
|
44109 return; |
|
44110 } |
|
44111 |
|
44112 /* |
|
44113 ****************************************************************************** |
|
44114 Name : sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_709_RR |
|
44115 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
44116 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
44117 uint8 *dstImage : Pointer to rgb data (o/p). |
|
44118 tWndParam *srcWindow : Pointer to structure containing source window |
|
44119 parameters like xOffset,yOffset,cropWidth, |
|
44120 cropHeight. (i/p) |
|
44121 tWndParam *dstWindow : Pointer to structure containing destination window |
|
44122 parameters like xOffset,yOffset,windWidth, |
|
44123 windHeight. (i/p) |
|
44124 Return Value : void |
|
44125 ****************************************************************************** |
|
44126 */ |
|
44127 |
|
44128 void sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_709_RR |
|
44129 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
44130 tWndParam* srcWindow, tWndParam* dstWindow) |
|
44131 { |
|
44132 uint16 *dest1, *dest2; |
|
44133 uint8 *lYuyvPtr; |
|
44134 uint8 *lBuffer; |
|
44135 uint8 *src1, *src2; |
|
44136 uint8 *lPtr1, *lPtr2; |
|
44137 int32 diff1, diff2, diff3; |
|
44138 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
44139 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
44140 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
44141 int32 i, j, k, extraCol, extraRow; |
|
44142 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
44143 cropWidth,cropHeight,wndWidth,wndHeight; |
|
44144 |
|
44145 srcXOffset = srcWindow->xOffset; |
|
44146 srcYOffset = srcWindow->yOffset; |
|
44147 cropWidth = srcWindow->wndWidth; |
|
44148 cropHeight = srcWindow->wndHeight; |
|
44149 |
|
44150 dstXOffset = dstWindow->xOffset; |
|
44151 dstYOffset = dstWindow->yOffset; |
|
44152 wndWidth = dstWindow->wndWidth; |
|
44153 wndHeight = dstWindow->wndHeight; |
|
44154 |
|
44155 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
44156 { |
|
44157 lWidth = cropWidth; |
|
44158 } |
|
44159 else |
|
44160 { |
|
44161 lWidth = srcImage->width - srcXOffset; |
|
44162 } |
|
44163 |
|
44164 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
44165 { |
|
44166 lHeight = cropHeight; |
|
44167 } |
|
44168 else |
|
44169 { |
|
44170 lHeight = srcImage->height - srcYOffset; |
|
44171 } |
|
44172 |
|
44173 if (lWidth > (wndWidth - dstXOffset)) |
|
44174 { |
|
44175 lWidth = wndWidth - dstXOffset; |
|
44176 } |
|
44177 |
|
44178 if (lHeight > (wndHeight - dstYOffset)) |
|
44179 { |
|
44180 lHeight = wndHeight - dstYOffset; |
|
44181 } |
|
44182 |
|
44183 extraCol = lWidth & 0x01; |
|
44184 extraRow = lHeight & 0x01; |
|
44185 |
|
44186 lTempWidth = lWidth; |
|
44187 lWidth = (lWidth >> 1) << 1; |
|
44188 lHeight = (lHeight >> 1) << 1; |
|
44189 |
|
44190 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
44191 |
|
44192 lSrcWidth = lWidth * 3; |
|
44193 |
|
44194 lLumWidth = (srcImage->width >> 1) << 1; |
|
44195 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
44196 |
|
44197 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
44198 dest2 = dest1 + wndWidth; |
|
44199 |
|
44200 lLumWidth <<= 1; |
|
44201 |
|
44202 for(i = 0; i < lHeight; i += 2) |
|
44203 { |
|
44204 lPtr1 = src1 = lBuffer; |
|
44205 lPtr2 = src2 = src1 + lSrcWidth; |
|
44206 |
|
44207 for(k = 0; k < (lWidth - 2); k += 2) |
|
44208 { |
|
44209 lCb1 = lYuyvPtr[0]; |
|
44210 lCr1 = lYuyvPtr[2]; |
|
44211 |
|
44212 lCb2 = lYuyvPtr[4]; |
|
44213 lCr2 = lYuyvPtr[6]; |
|
44214 |
|
44215 lCr2 = (lCr1 + lCr2) >> 1; |
|
44216 lCb2 = (lCb1 + lCb2) >> 1; |
|
44217 |
|
44218 /*First Pixel*/ |
|
44219 lCb1 -= 128; |
|
44220 lCr1 -= 128; |
|
44221 |
|
44222 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
44223 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44224 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
44225 |
|
44226 lY1 = lYuyvPtr[1]; |
|
44227 lY1 -= 16; |
|
44228 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44229 |
|
44230 lTemp = lY1 + lTemp1; |
|
44231 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44232 |
|
44233 lTemp = lY1 - lTemp2; |
|
44234 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44235 |
|
44236 lTemp = lY1 + lTemp3; |
|
44237 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44238 |
|
44239 /*Second Pixel*/ |
|
44240 lCb2 -= 128; |
|
44241 lCr2 -= 128; |
|
44242 |
|
44243 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
44244 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
44245 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
44246 |
|
44247 lY1 = lYuyvPtr[3]; |
|
44248 lY1 -= 16; |
|
44249 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44250 |
|
44251 lTemp = lY1 + lTemp1; |
|
44252 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44253 |
|
44254 lTemp = lY1 - lTemp2; |
|
44255 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44256 |
|
44257 lTemp = lY1 + lTemp3; |
|
44258 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44259 |
|
44260 |
|
44261 lCb1 = lYuyvPtr[lLumWidth]; |
|
44262 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
44263 |
|
44264 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
44265 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
44266 |
|
44267 lCr2 = (lCr1 + lCr2) >> 1; |
|
44268 lCb2 = (lCb1 + lCb2) >> 1; |
|
44269 |
|
44270 |
|
44271 /*Third Pixel*/ |
|
44272 lCb1 -= 128; |
|
44273 lCr1 -= 128; |
|
44274 |
|
44275 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
44276 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44277 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
44278 |
|
44279 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
44280 lY1 -= 16; |
|
44281 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44282 |
|
44283 lTemp = lY1 + lTemp1; |
|
44284 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44285 |
|
44286 lTemp = lY1 - lTemp2; |
|
44287 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44288 |
|
44289 lTemp = lY1 + lTemp3; |
|
44290 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44291 |
|
44292 /*Fourth Pixel*/ |
|
44293 lCb2 -= 128; |
|
44294 lCr2 -= 128; |
|
44295 |
|
44296 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
44297 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
44298 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
44299 |
|
44300 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
44301 lY1 -= 16; |
|
44302 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44303 |
|
44304 lTemp = lY1 + lTemp1; |
|
44305 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44306 |
|
44307 lTemp = lY1 - lTemp2; |
|
44308 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44309 |
|
44310 lTemp = lY1 + lTemp3; |
|
44311 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44312 |
|
44313 |
|
44314 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
44315 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
44316 |
|
44317 lCb2 = lYuyvPtr[(lLumWidth << 1) + 4]; |
|
44318 lCr2 = lYuyvPtr[(lLumWidth << 1) + 6]; |
|
44319 |
|
44320 lCr2 = (lCr1 + lCr2) >> 1; |
|
44321 lCb2 = (lCb1 + lCb2) >> 1; |
|
44322 |
|
44323 /*Fifth Pixel*/ |
|
44324 lCb1 -= 128; |
|
44325 lCr1 -= 128; |
|
44326 |
|
44327 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
44328 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44329 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
44330 |
|
44331 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
44332 lY1 -= 16; |
|
44333 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44334 |
|
44335 lTemp = lY1 + lTemp1; |
|
44336 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44337 |
|
44338 lTemp = lY1 - lTemp2; |
|
44339 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44340 |
|
44341 lTemp = lY1 + lTemp3; |
|
44342 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44343 |
|
44344 /*Sixth Pixel*/ |
|
44345 lCb2 -= 128; |
|
44346 lCr2 -= 128; |
|
44347 |
|
44348 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
44349 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
44350 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
44351 |
|
44352 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
44353 lY1 -= 16; |
|
44354 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44355 |
|
44356 lTemp = lY1 + lTemp1; |
|
44357 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44358 |
|
44359 lTemp = lY1 - lTemp2; |
|
44360 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44361 |
|
44362 lTemp = lY1 + lTemp3; |
|
44363 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44364 |
|
44365 lYuyvPtr += 4; |
|
44366 src1 += 6; |
|
44367 src2 += 6; |
|
44368 } |
|
44369 |
|
44370 lCb1 = lYuyvPtr[0]; |
|
44371 lCr1 = lYuyvPtr[2]; |
|
44372 |
|
44373 lCb1 -= 128; |
|
44374 lCr1 -= 128; |
|
44375 |
|
44376 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
44377 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44378 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
44379 |
|
44380 /*First Pixel*/ |
|
44381 lY1 = lYuyvPtr[1]; |
|
44382 lY1 -= 16; |
|
44383 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44384 |
|
44385 lTemp = lY1 + lTemp1; |
|
44386 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44387 |
|
44388 lTemp = lY1 - lTemp2; |
|
44389 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44390 |
|
44391 lTemp = lY1 + lTemp3; |
|
44392 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44393 |
|
44394 /*Second Pixel*/ |
|
44395 lY1 = lYuyvPtr[3]; |
|
44396 lY1 -= 16; |
|
44397 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44398 |
|
44399 lTemp = lY1 + lTemp1; |
|
44400 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44401 |
|
44402 lTemp = lY1 - lTemp2; |
|
44403 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44404 |
|
44405 lTemp = lY1 + lTemp3; |
|
44406 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44407 |
|
44408 |
|
44409 lCb1 = lYuyvPtr[lLumWidth]; |
|
44410 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
44411 |
|
44412 lCb1 -= 128; |
|
44413 lCr1 -= 128; |
|
44414 |
|
44415 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
44416 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44417 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
44418 |
|
44419 /*Third Pixel*/ |
|
44420 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
44421 lY1 -= 16; |
|
44422 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44423 |
|
44424 lTemp = lY1 + lTemp1; |
|
44425 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44426 |
|
44427 lTemp = lY1 - lTemp2; |
|
44428 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44429 |
|
44430 lTemp = lY1 + lTemp3; |
|
44431 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44432 |
|
44433 /*Fourth Pixel*/ |
|
44434 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
44435 lY1 -= 16; |
|
44436 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44437 |
|
44438 lTemp = lY1 + lTemp1; |
|
44439 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44440 |
|
44441 lTemp = lY1 - lTemp2; |
|
44442 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44443 |
|
44444 lTemp = lY1 + lTemp3; |
|
44445 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44446 |
|
44447 |
|
44448 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
44449 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
44450 |
|
44451 lCb1 -= 128; |
|
44452 lCr1 -= 128; |
|
44453 |
|
44454 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
44455 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44456 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
44457 |
|
44458 /*Fifth Pixel*/ |
|
44459 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
44460 lY1 -= 16; |
|
44461 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44462 |
|
44463 lTemp = lY1 + lTemp1; |
|
44464 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44465 |
|
44466 lTemp = lY1 - lTemp2; |
|
44467 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44468 |
|
44469 lTemp = lY1 + lTemp3; |
|
44470 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44471 |
|
44472 /*Sixth Pixel*/ |
|
44473 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
44474 lY1 -= 16; |
|
44475 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44476 |
|
44477 lTemp = lY1 + lTemp1; |
|
44478 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44479 |
|
44480 lTemp = lY1 - lTemp2; |
|
44481 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44482 |
|
44483 lTemp = lY1 + lTemp3; |
|
44484 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44485 |
|
44486 lYuyvPtr += 4; |
|
44487 src1 += 6; |
|
44488 src2 += 6; |
|
44489 |
|
44490 |
|
44491 src1 = lPtr1; |
|
44492 src2 = lPtr2; |
|
44493 |
|
44494 for(j = 0; j < lWidth; j += 2) |
|
44495 { |
|
44496 /* First Pixel */ |
|
44497 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
44498 diff1 = *src1 & 0xf; |
|
44499 diff2 = *(src1 + 1) & 0xf; |
|
44500 diff3 = *(src1 + 2) & 0xf; |
|
44501 |
|
44502 // diffuse the error |
|
44503 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
44504 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
44505 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
44506 |
|
44507 /* Second Pixel */ |
|
44508 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
44509 diff1 = *(src1 + 3) & 0xf; |
|
44510 diff2 = *(src1 + 4) & 0xf; |
|
44511 diff3 = *(src1 + 5) & 0xf; |
|
44512 // diffuse the error |
|
44513 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
44514 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
44515 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
44516 |
|
44517 src1 += 6; |
|
44518 dest1 += 2; |
|
44519 |
|
44520 /* Third Pixel */ |
|
44521 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
44522 diff1 = *src2 & 0xf; |
|
44523 diff2 = *(src2 + 1) & 0xf; |
|
44524 diff3 = *(src2 + 2) & 0xf; |
|
44525 //diffuse the error |
|
44526 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
44527 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
44528 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
44529 |
|
44530 /* Fourth Pixel */ |
|
44531 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
44532 diff1 = *(src2 + 3) & 0xf; |
|
44533 diff2 = *(src2 + 4) & 0xf; |
|
44534 diff3 = *(src2 + 5) & 0xf; |
|
44535 //diffuse the error |
|
44536 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
44537 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
44538 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
44539 |
|
44540 src2 += 6; |
|
44541 dest2 += 2; |
|
44542 } |
|
44543 if(extraCol) |
|
44544 { |
|
44545 *dest1 = dest1[-1]; |
|
44546 dest1++; |
|
44547 *dest2 = dest2[-1]; |
|
44548 dest2++; |
|
44549 } |
|
44550 |
|
44551 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
44552 |
|
44553 dest1 += ((wndWidth << 1) - lTempWidth); |
|
44554 dest2 += ((wndWidth << 1) - lTempWidth); |
|
44555 } |
|
44556 |
|
44557 if(extraRow) |
|
44558 { |
|
44559 dest2 = dest1 - wndWidth; |
|
44560 for(j = 0; j < lWidth; j += 2) |
|
44561 { |
|
44562 *dest1++ = *dest2++; |
|
44563 *dest1++ = *dest2++; |
|
44564 } |
|
44565 if(extraCol) |
|
44566 { |
|
44567 *dest1 = *dest2; |
|
44568 } |
|
44569 } |
|
44570 |
|
44571 free(lBuffer); |
|
44572 return; |
|
44573 } |
|
44574 |
|
44575 /* |
|
44576 ****************************************************************************** |
|
44577 Name : sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_601_5_RR |
|
44578 Description : Converts YUV422 BE (UYVY) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
44579 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
44580 uint8 *dstImage : Pointer to rgb data (o/p). |
|
44581 tWndParam *srcWindow : Pointer to structure containing source window |
|
44582 parameters like xOffset,yOffset,cropWidth, |
|
44583 cropHeight. (i/p) |
|
44584 tWndParam *dstWindow : Pointer to structure containing destination window |
|
44585 parameters like xOffset,yOffset,windWidth, |
|
44586 windHeight. (i/p) |
|
44587 Return Value : void |
|
44588 ****************************************************************************** |
|
44589 */ |
|
44590 |
|
44591 void sEmz_VDec_YUV422BEChr1toColor4k_ErrDiff_601_5_RR |
|
44592 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
44593 tWndParam* srcWindow, tWndParam* dstWindow) |
|
44594 { |
|
44595 uint16 *dest1, *dest2; |
|
44596 uint8 *lYuyvPtr; |
|
44597 uint8 *lBuffer; |
|
44598 uint8 *src1, *src2; |
|
44599 uint8 *lPtr1, *lPtr2; |
|
44600 int32 diff1, diff2, diff3; |
|
44601 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
44602 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
44603 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
44604 int32 i, j, k, extraCol, extraRow; |
|
44605 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
44606 cropWidth,cropHeight,wndWidth,wndHeight; |
|
44607 |
|
44608 srcXOffset = srcWindow->xOffset; |
|
44609 srcYOffset = srcWindow->yOffset; |
|
44610 cropWidth = srcWindow->wndWidth; |
|
44611 cropHeight = srcWindow->wndHeight; |
|
44612 |
|
44613 dstXOffset = dstWindow->xOffset; |
|
44614 dstYOffset = dstWindow->yOffset; |
|
44615 wndWidth = dstWindow->wndWidth; |
|
44616 wndHeight = dstWindow->wndHeight; |
|
44617 |
|
44618 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
44619 { |
|
44620 lWidth = cropWidth; |
|
44621 } |
|
44622 else |
|
44623 { |
|
44624 lWidth = srcImage->width - srcXOffset; |
|
44625 } |
|
44626 |
|
44627 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
44628 { |
|
44629 lHeight = cropHeight; |
|
44630 } |
|
44631 else |
|
44632 { |
|
44633 lHeight = srcImage->height - srcYOffset; |
|
44634 } |
|
44635 |
|
44636 if (lWidth > (wndWidth - dstXOffset)) |
|
44637 { |
|
44638 lWidth = wndWidth - dstXOffset; |
|
44639 } |
|
44640 |
|
44641 if (lHeight > (wndHeight - dstYOffset)) |
|
44642 { |
|
44643 lHeight = wndHeight - dstYOffset; |
|
44644 } |
|
44645 |
|
44646 extraCol = lWidth & 0x01; |
|
44647 extraRow = lHeight & 0x01; |
|
44648 |
|
44649 lTempWidth = lWidth; |
|
44650 lWidth = (lWidth >> 1) << 1; |
|
44651 lHeight = (lHeight >> 1) << 1; |
|
44652 |
|
44653 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
44654 |
|
44655 lSrcWidth = lWidth * 3; |
|
44656 |
|
44657 lLumWidth = (srcImage->width >> 1) << 1; |
|
44658 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
44659 |
|
44660 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
44661 dest2 = dest1 + wndWidth; |
|
44662 |
|
44663 lLumWidth <<= 1; |
|
44664 |
|
44665 for(i = 0; i < lHeight; i += 2) |
|
44666 { |
|
44667 lPtr1 = src1 = lBuffer; |
|
44668 lPtr2 = src2 = src1 + lSrcWidth; |
|
44669 |
|
44670 for(k = 0; k < (lWidth - 2); k += 2) |
|
44671 { |
|
44672 lCb1 = lYuyvPtr[0]; |
|
44673 lCr1 = lYuyvPtr[2]; |
|
44674 |
|
44675 lCb2 = lYuyvPtr[4]; |
|
44676 lCr2 = lYuyvPtr[6]; |
|
44677 |
|
44678 lCr2 = (lCr1 + lCr2) >> 1; |
|
44679 lCb2 = (lCb1 + lCb2) >> 1; |
|
44680 |
|
44681 /*First Pixel*/ |
|
44682 lCb1 -= 128; |
|
44683 lCr1 -= 128; |
|
44684 |
|
44685 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
44686 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44687 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
44688 |
|
44689 lY1 = lYuyvPtr[1]; |
|
44690 lY1 -= 16; |
|
44691 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44692 |
|
44693 lTemp = lY1 + lTemp1; |
|
44694 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44695 |
|
44696 lTemp = lY1 - lTemp2; |
|
44697 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44698 |
|
44699 lTemp = lY1 + lTemp3; |
|
44700 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44701 |
|
44702 /*Second Pixel*/ |
|
44703 lCb2 -= 128; |
|
44704 lCr2 -= 128; |
|
44705 |
|
44706 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
44707 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
44708 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
44709 |
|
44710 lY1 = lYuyvPtr[3]; |
|
44711 lY1 -= 16; |
|
44712 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44713 |
|
44714 lTemp = lY1 + lTemp1; |
|
44715 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44716 |
|
44717 lTemp = lY1 - lTemp2; |
|
44718 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44719 |
|
44720 lTemp = lY1 + lTemp3; |
|
44721 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44722 |
|
44723 |
|
44724 lCb1 = lYuyvPtr[lLumWidth]; |
|
44725 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
44726 |
|
44727 lCb2 = lYuyvPtr[lLumWidth + 4]; |
|
44728 lCr2 = lYuyvPtr[lLumWidth + 6]; |
|
44729 |
|
44730 lCr2 = (lCr1 + lCr2) >> 1; |
|
44731 lCb2 = (lCb1 + lCb2) >> 1; |
|
44732 |
|
44733 |
|
44734 /*Third Pixel*/ |
|
44735 lCb1 -= 128; |
|
44736 lCr1 -= 128; |
|
44737 |
|
44738 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
44739 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44740 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
44741 |
|
44742 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
44743 lY1 -= 16; |
|
44744 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44745 |
|
44746 lTemp = lY1 + lTemp1; |
|
44747 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44748 |
|
44749 lTemp = lY1 - lTemp2; |
|
44750 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44751 |
|
44752 lTemp = lY1 + lTemp3; |
|
44753 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44754 |
|
44755 /*Fourth Pixel*/ |
|
44756 lCb2 -= 128; |
|
44757 lCr2 -= 128; |
|
44758 |
|
44759 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
44760 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
44761 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
44762 |
|
44763 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
44764 lY1 -= 16; |
|
44765 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44766 |
|
44767 lTemp = lY1 + lTemp1; |
|
44768 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44769 |
|
44770 lTemp = lY1 - lTemp2; |
|
44771 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44772 |
|
44773 lTemp = lY1 + lTemp3; |
|
44774 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44775 |
|
44776 |
|
44777 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
44778 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
44779 |
|
44780 lCb2 = lYuyvPtr[(lLumWidth << 1) + 4]; |
|
44781 lCr2 = lYuyvPtr[(lLumWidth << 1) + 6]; |
|
44782 |
|
44783 lCr2 = (lCr1 + lCr2) >> 1; |
|
44784 lCb2 = (lCb1 + lCb2) >> 1; |
|
44785 |
|
44786 /*Fifth Pixel*/ |
|
44787 lCb1 -= 128; |
|
44788 lCr1 -= 128; |
|
44789 |
|
44790 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
44791 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44792 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
44793 |
|
44794 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
44795 lY1 -= 16; |
|
44796 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44797 |
|
44798 lTemp = lY1 + lTemp1; |
|
44799 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44800 |
|
44801 lTemp = lY1 - lTemp2; |
|
44802 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44803 |
|
44804 lTemp = lY1 + lTemp3; |
|
44805 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44806 |
|
44807 /*Sixth Pixel*/ |
|
44808 lCb2 -= 128; |
|
44809 lCr2 -= 128; |
|
44810 |
|
44811 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
44812 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
44813 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
44814 |
|
44815 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
44816 lY1 -= 16; |
|
44817 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44818 |
|
44819 lTemp = lY1 + lTemp1; |
|
44820 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44821 |
|
44822 lTemp = lY1 - lTemp2; |
|
44823 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44824 |
|
44825 lTemp = lY1 + lTemp3; |
|
44826 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44827 |
|
44828 lYuyvPtr += 4; |
|
44829 src1 += 6; |
|
44830 src2 += 6; |
|
44831 } |
|
44832 |
|
44833 lCb1 = lYuyvPtr[0]; |
|
44834 lCr1 = lYuyvPtr[2]; |
|
44835 |
|
44836 lCb1 -= 128; |
|
44837 lCr1 -= 128; |
|
44838 |
|
44839 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
44840 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44841 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
44842 |
|
44843 /*First Pixel*/ |
|
44844 lY1 = lYuyvPtr[1]; |
|
44845 lY1 -= 16; |
|
44846 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44847 |
|
44848 lTemp = lY1 + lTemp1; |
|
44849 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44850 |
|
44851 lTemp = lY1 - lTemp2; |
|
44852 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44853 |
|
44854 lTemp = lY1 + lTemp3; |
|
44855 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44856 |
|
44857 /*Second Pixel*/ |
|
44858 lY1 = lYuyvPtr[3]; |
|
44859 lY1 -= 16; |
|
44860 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44861 |
|
44862 lTemp = lY1 + lTemp1; |
|
44863 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44864 |
|
44865 lTemp = lY1 - lTemp2; |
|
44866 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44867 |
|
44868 lTemp = lY1 + lTemp3; |
|
44869 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44870 |
|
44871 |
|
44872 lCb1 = lYuyvPtr[lLumWidth]; |
|
44873 lCr1 = lYuyvPtr[lLumWidth + 2]; |
|
44874 |
|
44875 lCb1 -= 128; |
|
44876 lCr1 -= 128; |
|
44877 |
|
44878 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
44879 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44880 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
44881 |
|
44882 /*Third Pixel*/ |
|
44883 lY1 = lYuyvPtr[lLumWidth + 1]; |
|
44884 lY1 -= 16; |
|
44885 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44886 |
|
44887 lTemp = lY1 + lTemp1; |
|
44888 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44889 |
|
44890 lTemp = lY1 - lTemp2; |
|
44891 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44892 |
|
44893 lTemp = lY1 + lTemp3; |
|
44894 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44895 |
|
44896 /*Fourth Pixel*/ |
|
44897 lY1 = lYuyvPtr[lLumWidth + 3]; |
|
44898 lY1 -= 16; |
|
44899 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44900 |
|
44901 lTemp = lY1 + lTemp1; |
|
44902 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44903 |
|
44904 lTemp = lY1 - lTemp2; |
|
44905 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44906 |
|
44907 lTemp = lY1 + lTemp3; |
|
44908 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44909 |
|
44910 |
|
44911 lCb1 = lYuyvPtr[lLumWidth << 1]; |
|
44912 lCr1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
44913 |
|
44914 lCb1 -= 128; |
|
44915 lCr1 -= 128; |
|
44916 |
|
44917 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
44918 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
44919 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
44920 |
|
44921 /*Fifth Pixel*/ |
|
44922 lY1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
44923 lY1 -= 16; |
|
44924 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44925 |
|
44926 lTemp = lY1 + lTemp1; |
|
44927 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44928 |
|
44929 lTemp = lY1 - lTemp2; |
|
44930 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44931 |
|
44932 lTemp = lY1 + lTemp3; |
|
44933 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44934 |
|
44935 /*Sixth Pixel*/ |
|
44936 lY1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
44937 lY1 -= 16; |
|
44938 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
44939 |
|
44940 lTemp = lY1 + lTemp1; |
|
44941 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44942 |
|
44943 lTemp = lY1 - lTemp2; |
|
44944 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44945 |
|
44946 lTemp = lY1 + lTemp3; |
|
44947 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
44948 |
|
44949 lYuyvPtr += 4; |
|
44950 src1 += 6; |
|
44951 src2 += 6; |
|
44952 |
|
44953 |
|
44954 src1 = lPtr1; |
|
44955 src2 = lPtr2; |
|
44956 |
|
44957 for(j = 0; j < lWidth; j += 2) |
|
44958 { |
|
44959 /* First Pixel */ |
|
44960 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
44961 diff1 = *src1 & 0xf; |
|
44962 diff2 = *(src1 + 1) & 0xf; |
|
44963 diff3 = *(src1 + 2) & 0xf; |
|
44964 |
|
44965 // diffuse the error |
|
44966 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
44967 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
44968 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
44969 |
|
44970 /* Second Pixel */ |
|
44971 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
44972 diff1 = *(src1 + 3) & 0xf; |
|
44973 diff2 = *(src1 + 4) & 0xf; |
|
44974 diff3 = *(src1 + 5) & 0xf; |
|
44975 // diffuse the error |
|
44976 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
44977 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
44978 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
44979 |
|
44980 src1 += 6; |
|
44981 dest1 += 2; |
|
44982 |
|
44983 /* Third Pixel */ |
|
44984 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
44985 diff1 = *src2 & 0xf; |
|
44986 diff2 = *(src2 + 1) & 0xf; |
|
44987 diff3 = *(src2 + 2) & 0xf; |
|
44988 //diffuse the error |
|
44989 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
44990 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
44991 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
44992 |
|
44993 /* Fourth Pixel */ |
|
44994 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
44995 diff1 = *(src2 + 3) & 0xf; |
|
44996 diff2 = *(src2 + 4) & 0xf; |
|
44997 diff3 = *(src2 + 5) & 0xf; |
|
44998 //diffuse the error |
|
44999 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
45000 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
45001 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
45002 |
|
45003 src2 += 6; |
|
45004 dest2 += 2; |
|
45005 } |
|
45006 if(extraCol) |
|
45007 { |
|
45008 *dest1 = dest1[-1]; |
|
45009 dest1++; |
|
45010 *dest2 = dest2[-1]; |
|
45011 dest2++; |
|
45012 } |
|
45013 |
|
45014 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
45015 |
|
45016 dest1 += ((wndWidth << 1) - lTempWidth); |
|
45017 dest2 += ((wndWidth << 1) - lTempWidth); |
|
45018 } |
|
45019 |
|
45020 if(extraRow) |
|
45021 { |
|
45022 dest2 = dest1 - wndWidth; |
|
45023 for(j = 0; j < lWidth; j += 2) |
|
45024 { |
|
45025 *dest1++ = *dest2++; |
|
45026 *dest1++ = *dest2++; |
|
45027 } |
|
45028 if(extraCol) |
|
45029 { |
|
45030 *dest1 = *dest2; |
|
45031 } |
|
45032 } |
|
45033 |
|
45034 free(lBuffer); |
|
45035 return; |
|
45036 } |
|
45037 |
|
45038 |
|
45039 |
|
45040 /* |
|
45041 ****************************************************************************** |
|
45042 Name : sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_709_FR |
|
45043 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
45044 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
45045 uint8 *dstImage : Pointer to rgb data (o/p). |
|
45046 tWndParam *srcWindow : Pointer to structure containing source window |
|
45047 parameters like xOffset,yOffset,cropWidth, |
|
45048 cropHeight. (i/p) |
|
45049 tWndParam *dstWindow : Pointer to structure containing destination window |
|
45050 parameters like xOffset,yOffset,windWidth, |
|
45051 windHeight. (i/p) |
|
45052 Return Value : void |
|
45053 ****************************************************************************** |
|
45054 */ |
|
45055 |
|
45056 void sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_709_FR |
|
45057 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
45058 tWndParam* srcWindow, tWndParam* dstWindow) |
|
45059 { |
|
45060 uint16 *dest1, *dest2; |
|
45061 uint8 *lYuyvPtr; |
|
45062 uint8 *lBuffer; |
|
45063 uint8 *src1, *src2; |
|
45064 uint8 *lPtr1, *lPtr2; |
|
45065 int32 diff1, diff2, diff3; |
|
45066 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
45067 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
45068 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
45069 int32 i, j, k, extraCol, extraRow; |
|
45070 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
45071 cropWidth,cropHeight,wndWidth,wndHeight; |
|
45072 |
|
45073 srcXOffset = srcWindow->xOffset; |
|
45074 srcYOffset = srcWindow->yOffset; |
|
45075 cropWidth = srcWindow->wndWidth; |
|
45076 cropHeight = srcWindow->wndHeight; |
|
45077 |
|
45078 dstXOffset = dstWindow->xOffset; |
|
45079 dstYOffset = dstWindow->yOffset; |
|
45080 wndWidth = dstWindow->wndWidth; |
|
45081 wndHeight = dstWindow->wndHeight; |
|
45082 |
|
45083 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
45084 { |
|
45085 lWidth = cropWidth; |
|
45086 } |
|
45087 else |
|
45088 { |
|
45089 lWidth = srcImage->width - srcXOffset; |
|
45090 } |
|
45091 |
|
45092 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
45093 { |
|
45094 lHeight = cropHeight; |
|
45095 } |
|
45096 else |
|
45097 { |
|
45098 lHeight = srcImage->height - srcYOffset; |
|
45099 } |
|
45100 |
|
45101 if (lWidth > (wndWidth - dstXOffset)) |
|
45102 { |
|
45103 lWidth = wndWidth - dstXOffset; |
|
45104 } |
|
45105 |
|
45106 if (lHeight > (wndHeight - dstYOffset)) |
|
45107 { |
|
45108 lHeight = wndHeight - dstYOffset; |
|
45109 } |
|
45110 |
|
45111 extraCol = lWidth & 0x01; |
|
45112 extraRow = lHeight & 0x01; |
|
45113 |
|
45114 lTempWidth = lWidth; |
|
45115 lWidth = (lWidth >> 1) << 1; |
|
45116 lHeight = (lHeight >> 1) << 1; |
|
45117 |
|
45118 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
45119 |
|
45120 lSrcWidth = lWidth * 3; |
|
45121 |
|
45122 lLumWidth = (srcImage->width >> 1) << 1; |
|
45123 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
45124 |
|
45125 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
45126 dest2 = dest1 + wndWidth; |
|
45127 |
|
45128 lLumWidth <<= 1; |
|
45129 |
|
45130 for(i = 0; i < lHeight; i += 2) |
|
45131 { |
|
45132 lPtr1 = src1 = lBuffer; |
|
45133 lPtr2 = src2 = src1 + lSrcWidth; |
|
45134 |
|
45135 for(k = 0; k < (lWidth - 2); k += 2) |
|
45136 { |
|
45137 lCb1 = lYuyvPtr[3]; |
|
45138 lCr1 = lYuyvPtr[1]; |
|
45139 |
|
45140 lCb2 = lYuyvPtr[7]; |
|
45141 lCr2 = lYuyvPtr[5]; |
|
45142 |
|
45143 lCr2 = (lCr1 + lCr2) >> 1; |
|
45144 lCb2 = (lCb1 + lCb2) >> 1; |
|
45145 |
|
45146 /*First Pixel*/ |
|
45147 lCb1 -= 128; |
|
45148 lCr1 -= 128; |
|
45149 |
|
45150 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
45151 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45152 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
45153 |
|
45154 lY1 = lYuyvPtr[2]; |
|
45155 |
|
45156 lTemp = lY1 + lTemp1; |
|
45157 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45158 |
|
45159 lTemp = lY1 - lTemp2; |
|
45160 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45161 |
|
45162 lTemp = lY1 + lTemp3; |
|
45163 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45164 |
|
45165 /*Second Pixel*/ |
|
45166 lCb2 -= 128; |
|
45167 lCr2 -= 128; |
|
45168 |
|
45169 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
45170 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
45171 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
45172 |
|
45173 lY1 = lYuyvPtr[0]; |
|
45174 |
|
45175 lTemp = lY1 + lTemp1; |
|
45176 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45177 |
|
45178 lTemp = lY1 - lTemp2; |
|
45179 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45180 |
|
45181 lTemp = lY1 + lTemp3; |
|
45182 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45183 |
|
45184 |
|
45185 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
45186 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
45187 |
|
45188 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
45189 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
45190 |
|
45191 lCr2 = (lCr1 + lCr2) >> 1; |
|
45192 lCb2 = (lCb1 + lCb2) >> 1; |
|
45193 |
|
45194 |
|
45195 /*Third Pixel*/ |
|
45196 lCb1 -= 128; |
|
45197 lCr1 -= 128; |
|
45198 |
|
45199 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
45200 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45201 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
45202 |
|
45203 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
45204 |
|
45205 lTemp = lY1 + lTemp1; |
|
45206 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45207 |
|
45208 lTemp = lY1 - lTemp2; |
|
45209 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45210 |
|
45211 lTemp = lY1 + lTemp3; |
|
45212 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45213 |
|
45214 /*Fourth Pixel*/ |
|
45215 lCb2 -= 128; |
|
45216 lCr2 -= 128; |
|
45217 |
|
45218 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
45219 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
45220 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
45221 |
|
45222 lY1 = lYuyvPtr[lLumWidth]; |
|
45223 |
|
45224 lTemp = lY1 + lTemp1; |
|
45225 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45226 |
|
45227 lTemp = lY1 - lTemp2; |
|
45228 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45229 |
|
45230 lTemp = lY1 + lTemp3; |
|
45231 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45232 |
|
45233 |
|
45234 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
45235 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
45236 |
|
45237 lCb2 = lYuyvPtr[(lLumWidth << 1) + 7]; |
|
45238 lCr2 = lYuyvPtr[(lLumWidth << 1) + 5]; |
|
45239 |
|
45240 lCr2 = (lCr1 + lCr2) >> 1; |
|
45241 lCb2 = (lCb1 + lCb2) >> 1; |
|
45242 |
|
45243 /*Fifth Pixel*/ |
|
45244 lCb1 -= 128; |
|
45245 lCr1 -= 128; |
|
45246 |
|
45247 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
45248 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45249 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
45250 |
|
45251 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
45252 |
|
45253 lTemp = lY1 + lTemp1; |
|
45254 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45255 |
|
45256 lTemp = lY1 - lTemp2; |
|
45257 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45258 |
|
45259 lTemp = lY1 + lTemp3; |
|
45260 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45261 |
|
45262 /*Sixth Pixel*/ |
|
45263 lCb2 -= 128; |
|
45264 lCr2 -= 128; |
|
45265 |
|
45266 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
45267 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
45268 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
45269 |
|
45270 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
45271 |
|
45272 lTemp = lY1 + lTemp1; |
|
45273 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45274 |
|
45275 lTemp = lY1 - lTemp2; |
|
45276 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45277 |
|
45278 lTemp = lY1 + lTemp3; |
|
45279 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45280 |
|
45281 lYuyvPtr += 4; |
|
45282 src1 += 6; |
|
45283 src2 += 6; |
|
45284 } |
|
45285 |
|
45286 lCb1 = lYuyvPtr[3]; |
|
45287 lCr1 = lYuyvPtr[1]; |
|
45288 |
|
45289 lCb1 -= 128; |
|
45290 lCr1 -= 128; |
|
45291 |
|
45292 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
45293 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45294 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
45295 |
|
45296 /*First Pixel*/ |
|
45297 lY1 = lYuyvPtr[2]; |
|
45298 |
|
45299 lTemp = lY1 + lTemp1; |
|
45300 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45301 |
|
45302 lTemp = lY1 - lTemp2; |
|
45303 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45304 |
|
45305 lTemp = lY1 + lTemp3; |
|
45306 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45307 |
|
45308 /*Second Pixel*/ |
|
45309 lY1 = lYuyvPtr[0]; |
|
45310 |
|
45311 lTemp = lY1 + lTemp1; |
|
45312 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45313 |
|
45314 lTemp = lY1 - lTemp2; |
|
45315 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45316 |
|
45317 lTemp = lY1 + lTemp3; |
|
45318 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45319 |
|
45320 |
|
45321 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
45322 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
45323 |
|
45324 lCb1 -= 128; |
|
45325 lCr1 -= 128; |
|
45326 |
|
45327 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
45328 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45329 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
45330 |
|
45331 /*Third Pixel*/ |
|
45332 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
45333 |
|
45334 lTemp = lY1 + lTemp1; |
|
45335 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45336 |
|
45337 lTemp = lY1 - lTemp2; |
|
45338 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45339 |
|
45340 lTemp = lY1 + lTemp3; |
|
45341 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45342 |
|
45343 /*Fourth Pixel*/ |
|
45344 lY1 = lYuyvPtr[lLumWidth]; |
|
45345 |
|
45346 lTemp = lY1 + lTemp1; |
|
45347 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45348 |
|
45349 lTemp = lY1 - lTemp2; |
|
45350 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45351 |
|
45352 lTemp = lY1 + lTemp3; |
|
45353 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45354 |
|
45355 |
|
45356 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
45357 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
45358 |
|
45359 lCb1 -= 128; |
|
45360 lCr1 -= 128; |
|
45361 |
|
45362 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
45363 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45364 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
45365 |
|
45366 /*Fifth Pixel*/ |
|
45367 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
45368 |
|
45369 lTemp = lY1 + lTemp1; |
|
45370 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45371 |
|
45372 lTemp = lY1 - lTemp2; |
|
45373 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45374 |
|
45375 lTemp = lY1 + lTemp3; |
|
45376 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45377 |
|
45378 /*Sixth Pixel*/ |
|
45379 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
45380 |
|
45381 lTemp = lY1 + lTemp1; |
|
45382 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45383 |
|
45384 lTemp = lY1 - lTemp2; |
|
45385 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45386 |
|
45387 lTemp = lY1 + lTemp3; |
|
45388 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45389 |
|
45390 lYuyvPtr += 4; |
|
45391 src1 += 6; |
|
45392 src2 += 6; |
|
45393 |
|
45394 |
|
45395 src1 = lPtr1; |
|
45396 src2 = lPtr2; |
|
45397 |
|
45398 for(j = 0; j < lWidth; j += 2) |
|
45399 { |
|
45400 /* First Pixel */ |
|
45401 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
45402 diff1 = *src1 & 0x7; |
|
45403 diff2 = *(src1 + 1) & 0x3; |
|
45404 diff3 = *(src1 + 2) & 0x7; |
|
45405 |
|
45406 // diffuse the error |
|
45407 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
45408 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
45409 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
45410 |
|
45411 /* Second Pixel */ |
|
45412 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
45413 diff1 = *(src1 + 3) & 0x7; |
|
45414 diff2 = *(src1 + 4) & 0x3; |
|
45415 diff3 = *(src1 + 5) & 0x7; |
|
45416 // diffuse the error |
|
45417 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
45418 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
45419 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
45420 |
|
45421 src1 += 6; |
|
45422 dest1 += 2; |
|
45423 |
|
45424 /* Third Pixel */ |
|
45425 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
45426 diff1 = *src2 & 0x7; |
|
45427 diff2 = *(src2 + 1) & 0x3; |
|
45428 diff3 = *(src2 + 2) & 0x7; |
|
45429 //diffuse the error |
|
45430 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
45431 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
45432 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
45433 |
|
45434 /* Fourth Pixel */ |
|
45435 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
45436 diff1 = *(src2 + 3) & 0x7; |
|
45437 diff2 = *(src2 + 4) & 0x3; |
|
45438 diff3 = *(src2 + 5) & 0x7; |
|
45439 //diffuse the error |
|
45440 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
45441 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
45442 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
45443 |
|
45444 src2 += 6; |
|
45445 dest2 += 2; |
|
45446 } |
|
45447 if(extraCol) |
|
45448 { |
|
45449 *dest1 = dest1[-1]; |
|
45450 dest1++; |
|
45451 *dest2 = dest2[-1]; |
|
45452 dest2++; |
|
45453 } |
|
45454 |
|
45455 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
45456 |
|
45457 dest1 += ((wndWidth << 1) - lTempWidth); |
|
45458 dest2 += ((wndWidth << 1) - lTempWidth); |
|
45459 } |
|
45460 |
|
45461 if(extraRow) |
|
45462 { |
|
45463 dest2 = dest1 - wndWidth; |
|
45464 for(j = 0; j < lWidth; j += 2) |
|
45465 { |
|
45466 *dest1++ = *dest2++; |
|
45467 *dest1++ = *dest2++; |
|
45468 } |
|
45469 if(extraCol) |
|
45470 { |
|
45471 *dest1 = *dest2; |
|
45472 } |
|
45473 } |
|
45474 |
|
45475 free(lBuffer); |
|
45476 return; |
|
45477 } |
|
45478 |
|
45479 /* |
|
45480 ****************************************************************************** |
|
45481 Name : sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_601_5_FR |
|
45482 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
45483 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
45484 uint8 *dstImage : Pointer to rgb data (o/p). |
|
45485 tWndParam *srcWindow : Pointer to structure containing source window |
|
45486 parameters like xOffset,yOffset,cropWidth, |
|
45487 cropHeight. (i/p) |
|
45488 tWndParam *dstWindow : Pointer to structure containing destination window |
|
45489 parameters like xOffset,yOffset,windWidth, |
|
45490 windHeight. (i/p) |
|
45491 Return Value : void |
|
45492 ****************************************************************************** |
|
45493 */ |
|
45494 |
|
45495 void sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_601_5_FR |
|
45496 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
45497 tWndParam* srcWindow, tWndParam* dstWindow) |
|
45498 { |
|
45499 uint16 *dest1, *dest2; |
|
45500 uint8 *lYuyvPtr; |
|
45501 uint8 *lBuffer; |
|
45502 uint8 *src1, *src2; |
|
45503 uint8 *lPtr1, *lPtr2; |
|
45504 int32 diff1, diff2, diff3; |
|
45505 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
45506 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
45507 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
45508 int32 i, j, k, extraCol, extraRow; |
|
45509 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
45510 cropWidth,cropHeight,wndWidth,wndHeight; |
|
45511 |
|
45512 srcXOffset = srcWindow->xOffset; |
|
45513 srcYOffset = srcWindow->yOffset; |
|
45514 cropWidth = srcWindow->wndWidth; |
|
45515 cropHeight = srcWindow->wndHeight; |
|
45516 |
|
45517 dstXOffset = dstWindow->xOffset; |
|
45518 dstYOffset = dstWindow->yOffset; |
|
45519 wndWidth = dstWindow->wndWidth; |
|
45520 wndHeight = dstWindow->wndHeight; |
|
45521 |
|
45522 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
45523 { |
|
45524 lWidth = cropWidth; |
|
45525 } |
|
45526 else |
|
45527 { |
|
45528 lWidth = srcImage->width - srcXOffset; |
|
45529 } |
|
45530 |
|
45531 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
45532 { |
|
45533 lHeight = cropHeight; |
|
45534 } |
|
45535 else |
|
45536 { |
|
45537 lHeight = srcImage->height - srcYOffset; |
|
45538 } |
|
45539 |
|
45540 if (lWidth > (wndWidth - dstXOffset)) |
|
45541 { |
|
45542 lWidth = wndWidth - dstXOffset; |
|
45543 } |
|
45544 |
|
45545 if (lHeight > (wndHeight - dstYOffset)) |
|
45546 { |
|
45547 lHeight = wndHeight - dstYOffset; |
|
45548 } |
|
45549 |
|
45550 extraCol = lWidth & 0x01; |
|
45551 extraRow = lHeight & 0x01; |
|
45552 |
|
45553 lTempWidth = lWidth; |
|
45554 lWidth = (lWidth >> 1) << 1; |
|
45555 lHeight = (lHeight >> 1) << 1; |
|
45556 |
|
45557 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
45558 |
|
45559 lSrcWidth = lWidth * 3; |
|
45560 |
|
45561 lLumWidth = (srcImage->width >> 1) << 1; |
|
45562 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
45563 |
|
45564 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
45565 dest2 = dest1 + wndWidth; |
|
45566 |
|
45567 lLumWidth <<= 1; |
|
45568 |
|
45569 for(i = 0; i < lHeight; i += 2) |
|
45570 { |
|
45571 lPtr1 = src1 = lBuffer; |
|
45572 lPtr2 = src2 = src1 + lSrcWidth; |
|
45573 |
|
45574 for(k = 0; k < (lWidth - 2); k += 2) |
|
45575 { |
|
45576 lCb1 = lYuyvPtr[3]; |
|
45577 lCr1 = lYuyvPtr[1]; |
|
45578 |
|
45579 lCb2 = lYuyvPtr[7]; |
|
45580 lCr2 = lYuyvPtr[5]; |
|
45581 |
|
45582 lCr2 = (lCr1 + lCr2) >> 1; |
|
45583 lCb2 = (lCb1 + lCb2) >> 1; |
|
45584 |
|
45585 /*First Pixel*/ |
|
45586 lCb1 -= 128; |
|
45587 lCr1 -= 128; |
|
45588 |
|
45589 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
45590 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45591 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
45592 |
|
45593 lY1 = lYuyvPtr[2]; |
|
45594 |
|
45595 lTemp = lY1 + lTemp1; |
|
45596 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45597 |
|
45598 lTemp = lY1 - lTemp2; |
|
45599 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45600 |
|
45601 lTemp = lY1 + lTemp3; |
|
45602 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45603 |
|
45604 /*Second Pixel*/ |
|
45605 lCb2 -= 128; |
|
45606 lCr2 -= 128; |
|
45607 |
|
45608 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
45609 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
45610 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
45611 |
|
45612 lY1 = lYuyvPtr[0]; |
|
45613 |
|
45614 lTemp = lY1 + lTemp1; |
|
45615 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45616 |
|
45617 lTemp = lY1 - lTemp2; |
|
45618 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45619 |
|
45620 lTemp = lY1 + lTemp3; |
|
45621 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45622 |
|
45623 |
|
45624 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
45625 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
45626 |
|
45627 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
45628 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
45629 |
|
45630 lCr2 = (lCr1 + lCr2) >> 1; |
|
45631 lCb2 = (lCb1 + lCb2) >> 1; |
|
45632 |
|
45633 |
|
45634 /*Third Pixel*/ |
|
45635 lCb1 -= 128; |
|
45636 lCr1 -= 128; |
|
45637 |
|
45638 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
45639 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45640 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
45641 |
|
45642 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
45643 |
|
45644 lTemp = lY1 + lTemp1; |
|
45645 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45646 |
|
45647 lTemp = lY1 - lTemp2; |
|
45648 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45649 |
|
45650 lTemp = lY1 + lTemp3; |
|
45651 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45652 |
|
45653 /*Fourth Pixel*/ |
|
45654 lCb2 -= 128; |
|
45655 lCr2 -= 128; |
|
45656 |
|
45657 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
45658 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
45659 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
45660 |
|
45661 lY1 = lYuyvPtr[lLumWidth]; |
|
45662 |
|
45663 lTemp = lY1 + lTemp1; |
|
45664 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45665 |
|
45666 lTemp = lY1 - lTemp2; |
|
45667 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45668 |
|
45669 lTemp = lY1 + lTemp3; |
|
45670 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45671 |
|
45672 |
|
45673 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
45674 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
45675 |
|
45676 lCb2 = lYuyvPtr[(lLumWidth << 1) + 7]; |
|
45677 lCr2 = lYuyvPtr[(lLumWidth << 1) + 5]; |
|
45678 |
|
45679 lCr2 = (lCr1 + lCr2) >> 1; |
|
45680 lCb2 = (lCb1 + lCb2) >> 1; |
|
45681 |
|
45682 /*Fifth Pixel*/ |
|
45683 lCb1 -= 128; |
|
45684 lCr1 -= 128; |
|
45685 |
|
45686 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
45687 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45688 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
45689 |
|
45690 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
45691 |
|
45692 lTemp = lY1 + lTemp1; |
|
45693 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45694 |
|
45695 lTemp = lY1 - lTemp2; |
|
45696 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45697 |
|
45698 lTemp = lY1 + lTemp3; |
|
45699 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45700 |
|
45701 /*Sixth Pixel*/ |
|
45702 lCb2 -= 128; |
|
45703 lCr2 -= 128; |
|
45704 |
|
45705 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
45706 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
45707 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
45708 |
|
45709 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
45710 |
|
45711 lTemp = lY1 + lTemp1; |
|
45712 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45713 |
|
45714 lTemp = lY1 - lTemp2; |
|
45715 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45716 |
|
45717 lTemp = lY1 + lTemp3; |
|
45718 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45719 |
|
45720 lYuyvPtr += 4; |
|
45721 src1 += 6; |
|
45722 src2 += 6; |
|
45723 } |
|
45724 |
|
45725 lCb1 = lYuyvPtr[3]; |
|
45726 lCr1 = lYuyvPtr[1]; |
|
45727 |
|
45728 lCb1 -= 128; |
|
45729 lCr1 -= 128; |
|
45730 |
|
45731 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
45732 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45733 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
45734 |
|
45735 /*First Pixel*/ |
|
45736 lY1 = lYuyvPtr[2]; |
|
45737 |
|
45738 lTemp = lY1 + lTemp1; |
|
45739 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45740 |
|
45741 lTemp = lY1 - lTemp2; |
|
45742 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45743 |
|
45744 lTemp = lY1 + lTemp3; |
|
45745 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45746 |
|
45747 /*Second Pixel*/ |
|
45748 lY1 = lYuyvPtr[0]; |
|
45749 |
|
45750 lTemp = lY1 + lTemp1; |
|
45751 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45752 |
|
45753 lTemp = lY1 - lTemp2; |
|
45754 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45755 |
|
45756 lTemp = lY1 + lTemp3; |
|
45757 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45758 |
|
45759 |
|
45760 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
45761 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
45762 |
|
45763 lCb1 -= 128; |
|
45764 lCr1 -= 128; |
|
45765 |
|
45766 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
45767 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45768 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
45769 |
|
45770 /*Third Pixel*/ |
|
45771 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
45772 |
|
45773 lTemp = lY1 + lTemp1; |
|
45774 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45775 |
|
45776 lTemp = lY1 - lTemp2; |
|
45777 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45778 |
|
45779 lTemp = lY1 + lTemp3; |
|
45780 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45781 |
|
45782 /*Fourth Pixel*/ |
|
45783 lY1 = lYuyvPtr[lLumWidth]; |
|
45784 |
|
45785 lTemp = lY1 + lTemp1; |
|
45786 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45787 |
|
45788 lTemp = lY1 - lTemp2; |
|
45789 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45790 |
|
45791 lTemp = lY1 + lTemp3; |
|
45792 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45793 |
|
45794 |
|
45795 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
45796 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
45797 |
|
45798 lCb1 -= 128; |
|
45799 lCr1 -= 128; |
|
45800 |
|
45801 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
45802 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
45803 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
45804 |
|
45805 /*Fifth Pixel*/ |
|
45806 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
45807 |
|
45808 lTemp = lY1 + lTemp1; |
|
45809 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45810 |
|
45811 lTemp = lY1 - lTemp2; |
|
45812 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45813 |
|
45814 lTemp = lY1 + lTemp3; |
|
45815 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45816 |
|
45817 /*Sixth Pixel*/ |
|
45818 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
45819 |
|
45820 lTemp = lY1 + lTemp1; |
|
45821 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45822 |
|
45823 lTemp = lY1 - lTemp2; |
|
45824 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45825 |
|
45826 lTemp = lY1 + lTemp3; |
|
45827 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
45828 |
|
45829 lYuyvPtr += 4; |
|
45830 src1 += 6; |
|
45831 src2 += 6; |
|
45832 |
|
45833 |
|
45834 src1 = lPtr1; |
|
45835 src2 = lPtr2; |
|
45836 |
|
45837 for(j = 0; j < lWidth; j += 2) |
|
45838 { |
|
45839 /* First Pixel */ |
|
45840 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
45841 diff1 = *src1 & 0x7; |
|
45842 diff2 = *(src1 + 1) & 0x3; |
|
45843 diff3 = *(src1 + 2) & 0x7; |
|
45844 |
|
45845 // diffuse the error |
|
45846 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
45847 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
45848 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
45849 |
|
45850 /* Second Pixel */ |
|
45851 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
45852 diff1 = *(src1 + 3) & 0x7; |
|
45853 diff2 = *(src1 + 4) & 0x3; |
|
45854 diff3 = *(src1 + 5) & 0x7; |
|
45855 // diffuse the error |
|
45856 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
45857 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
45858 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
45859 |
|
45860 src1 += 6; |
|
45861 dest1 += 2; |
|
45862 |
|
45863 /* Third Pixel */ |
|
45864 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
45865 diff1 = *src2 & 0x7; |
|
45866 diff2 = *(src2 + 1) & 0x3; |
|
45867 diff3 = *(src2 + 2) & 0x7; |
|
45868 //diffuse the error |
|
45869 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
45870 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
45871 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
45872 |
|
45873 /* Fourth Pixel */ |
|
45874 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
45875 diff1 = *(src2 + 3) & 0x7; |
|
45876 diff2 = *(src2 + 4) & 0x3; |
|
45877 diff3 = *(src2 + 5) & 0x7; |
|
45878 //diffuse the error |
|
45879 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
45880 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
45881 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
45882 |
|
45883 src2 += 6; |
|
45884 dest2 += 2; |
|
45885 } |
|
45886 if(extraCol) |
|
45887 { |
|
45888 *dest1 = dest1[-1]; |
|
45889 dest1++; |
|
45890 *dest2 = dest2[-1]; |
|
45891 dest2++; |
|
45892 } |
|
45893 |
|
45894 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
45895 |
|
45896 dest1 += ((wndWidth << 1) - lTempWidth); |
|
45897 dest2 += ((wndWidth << 1) - lTempWidth); |
|
45898 } |
|
45899 |
|
45900 if(extraRow) |
|
45901 { |
|
45902 dest2 = dest1 - wndWidth; |
|
45903 for(j = 0; j < lWidth; j += 2) |
|
45904 { |
|
45905 *dest1++ = *dest2++; |
|
45906 *dest1++ = *dest2++; |
|
45907 } |
|
45908 if(extraCol) |
|
45909 { |
|
45910 *dest1 = *dest2; |
|
45911 } |
|
45912 } |
|
45913 |
|
45914 free(lBuffer); |
|
45915 return; |
|
45916 } |
|
45917 |
|
45918 /* |
|
45919 ****************************************************************************** |
|
45920 Name : sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_709_RR |
|
45921 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
45922 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
45923 uint8 *dstImage : Pointer to rgb data (o/p). |
|
45924 tWndParam *srcWindow : Pointer to structure containing source window |
|
45925 parameters like xOffset,yOffset,cropWidth, |
|
45926 cropHeight. (i/p) |
|
45927 tWndParam *dstWindow : Pointer to structure containing destination window |
|
45928 parameters like xOffset,yOffset,windWidth, |
|
45929 windHeight. (i/p) |
|
45930 Return Value : void |
|
45931 ****************************************************************************** |
|
45932 */ |
|
45933 |
|
45934 void sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_709_RR |
|
45935 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
45936 tWndParam* srcWindow, tWndParam* dstWindow) |
|
45937 { |
|
45938 uint16 *dest1, *dest2; |
|
45939 uint8 *lYuyvPtr; |
|
45940 uint8 *lBuffer; |
|
45941 uint8 *src1, *src2; |
|
45942 uint8 *lPtr1, *lPtr2; |
|
45943 int32 diff1, diff2, diff3; |
|
45944 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
45945 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
45946 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
45947 int32 i, j, k, extraCol, extraRow; |
|
45948 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
45949 cropWidth,cropHeight,wndWidth,wndHeight; |
|
45950 |
|
45951 srcXOffset = srcWindow->xOffset; |
|
45952 srcYOffset = srcWindow->yOffset; |
|
45953 cropWidth = srcWindow->wndWidth; |
|
45954 cropHeight = srcWindow->wndHeight; |
|
45955 |
|
45956 dstXOffset = dstWindow->xOffset; |
|
45957 dstYOffset = dstWindow->yOffset; |
|
45958 wndWidth = dstWindow->wndWidth; |
|
45959 wndHeight = dstWindow->wndHeight; |
|
45960 |
|
45961 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
45962 { |
|
45963 lWidth = cropWidth; |
|
45964 } |
|
45965 else |
|
45966 { |
|
45967 lWidth = srcImage->width - srcXOffset; |
|
45968 } |
|
45969 |
|
45970 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
45971 { |
|
45972 lHeight = cropHeight; |
|
45973 } |
|
45974 else |
|
45975 { |
|
45976 lHeight = srcImage->height - srcYOffset; |
|
45977 } |
|
45978 |
|
45979 if (lWidth > (wndWidth - dstXOffset)) |
|
45980 { |
|
45981 lWidth = wndWidth - dstXOffset; |
|
45982 } |
|
45983 |
|
45984 if (lHeight > (wndHeight - dstYOffset)) |
|
45985 { |
|
45986 lHeight = wndHeight - dstYOffset; |
|
45987 } |
|
45988 |
|
45989 extraCol = lWidth & 0x01; |
|
45990 extraRow = lHeight & 0x01; |
|
45991 |
|
45992 lTempWidth = lWidth; |
|
45993 lWidth = (lWidth >> 1) << 1; |
|
45994 lHeight = (lHeight >> 1) << 1; |
|
45995 |
|
45996 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
45997 |
|
45998 lSrcWidth = lWidth * 3; |
|
45999 |
|
46000 lLumWidth = (srcImage->width >> 1) << 1; |
|
46001 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
46002 |
|
46003 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
46004 dest2 = dest1 + wndWidth; |
|
46005 |
|
46006 lLumWidth <<= 1; |
|
46007 |
|
46008 for(i = 0; i < lHeight; i += 2) |
|
46009 { |
|
46010 lPtr1 = src1 = lBuffer; |
|
46011 lPtr2 = src2 = src1 + lSrcWidth; |
|
46012 |
|
46013 for(k = 0; k < (lWidth - 2); k += 2) |
|
46014 { |
|
46015 lCb1 = lYuyvPtr[3]; |
|
46016 lCr1 = lYuyvPtr[1]; |
|
46017 |
|
46018 lCb2 = lYuyvPtr[7]; |
|
46019 lCr2 = lYuyvPtr[5]; |
|
46020 |
|
46021 lCr2 = (lCr1 + lCr2) >> 1; |
|
46022 lCb2 = (lCb1 + lCb2) >> 1; |
|
46023 |
|
46024 /*First Pixel*/ |
|
46025 lCb1 -= 128; |
|
46026 lCr1 -= 128; |
|
46027 |
|
46028 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
46029 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46030 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
46031 |
|
46032 lY1 = lYuyvPtr[2]; |
|
46033 lY1 -= 16; |
|
46034 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46035 |
|
46036 lTemp = lY1 + lTemp1; |
|
46037 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46038 |
|
46039 lTemp = lY1 - lTemp2; |
|
46040 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46041 |
|
46042 lTemp = lY1 + lTemp3; |
|
46043 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46044 |
|
46045 /*Second Pixel*/ |
|
46046 lCb2 -= 128; |
|
46047 lCr2 -= 128; |
|
46048 |
|
46049 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
46050 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
46051 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
46052 |
|
46053 lY1 = lYuyvPtr[0]; |
|
46054 lY1 -= 16; |
|
46055 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46056 |
|
46057 lTemp = lY1 + lTemp1; |
|
46058 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46059 |
|
46060 lTemp = lY1 - lTemp2; |
|
46061 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46062 |
|
46063 lTemp = lY1 + lTemp3; |
|
46064 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46065 |
|
46066 |
|
46067 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
46068 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
46069 |
|
46070 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
46071 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
46072 |
|
46073 lCr2 = (lCr1 + lCr2) >> 1; |
|
46074 lCb2 = (lCb1 + lCb2) >> 1; |
|
46075 |
|
46076 |
|
46077 /*Third Pixel*/ |
|
46078 lCb1 -= 128; |
|
46079 lCr1 -= 128; |
|
46080 |
|
46081 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
46082 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46083 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
46084 |
|
46085 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
46086 lY1 -= 16; |
|
46087 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46088 |
|
46089 lTemp = lY1 + lTemp1; |
|
46090 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46091 |
|
46092 lTemp = lY1 - lTemp2; |
|
46093 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46094 |
|
46095 lTemp = lY1 + lTemp3; |
|
46096 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46097 |
|
46098 /*Fourth Pixel*/ |
|
46099 lCb2 -= 128; |
|
46100 lCr2 -= 128; |
|
46101 |
|
46102 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
46103 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
46104 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
46105 |
|
46106 lY1 = lYuyvPtr[lLumWidth]; |
|
46107 lY1 -= 16; |
|
46108 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46109 |
|
46110 lTemp = lY1 + lTemp1; |
|
46111 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46112 |
|
46113 lTemp = lY1 - lTemp2; |
|
46114 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46115 |
|
46116 lTemp = lY1 + lTemp3; |
|
46117 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46118 |
|
46119 |
|
46120 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
46121 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
46122 |
|
46123 lCb2 = lYuyvPtr[(lLumWidth << 1) + 7]; |
|
46124 lCr2 = lYuyvPtr[(lLumWidth << 1) + 5]; |
|
46125 |
|
46126 lCr2 = (lCr1 + lCr2) >> 1; |
|
46127 lCb2 = (lCb1 + lCb2) >> 1; |
|
46128 |
|
46129 /*Fifth Pixel*/ |
|
46130 lCb1 -= 128; |
|
46131 lCr1 -= 128; |
|
46132 |
|
46133 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
46134 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46135 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
46136 |
|
46137 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
46138 lY1 -= 16; |
|
46139 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46140 |
|
46141 lTemp = lY1 + lTemp1; |
|
46142 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46143 |
|
46144 lTemp = lY1 - lTemp2; |
|
46145 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46146 |
|
46147 lTemp = lY1 + lTemp3; |
|
46148 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46149 |
|
46150 /*Sixth Pixel*/ |
|
46151 lCb2 -= 128; |
|
46152 lCr2 -= 128; |
|
46153 |
|
46154 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
46155 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
46156 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
46157 |
|
46158 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
46159 lY1 -= 16; |
|
46160 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46161 |
|
46162 lTemp = lY1 + lTemp1; |
|
46163 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46164 |
|
46165 lTemp = lY1 - lTemp2; |
|
46166 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46167 |
|
46168 lTemp = lY1 + lTemp3; |
|
46169 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46170 |
|
46171 lYuyvPtr += 4; |
|
46172 src1 += 6; |
|
46173 src2 += 6; |
|
46174 } |
|
46175 |
|
46176 lCb1 = lYuyvPtr[3]; |
|
46177 lCr1 = lYuyvPtr[1]; |
|
46178 |
|
46179 lCb1 -= 128; |
|
46180 lCr1 -= 128; |
|
46181 |
|
46182 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
46183 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46184 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
46185 |
|
46186 /*First Pixel*/ |
|
46187 lY1 = lYuyvPtr[2]; |
|
46188 lY1 -= 16; |
|
46189 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46190 |
|
46191 lTemp = lY1 + lTemp1; |
|
46192 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46193 |
|
46194 lTemp = lY1 - lTemp2; |
|
46195 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46196 |
|
46197 lTemp = lY1 + lTemp3; |
|
46198 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46199 |
|
46200 /*Second Pixel*/ |
|
46201 lY1 = lYuyvPtr[0]; |
|
46202 lY1 -= 16; |
|
46203 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46204 |
|
46205 lTemp = lY1 + lTemp1; |
|
46206 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46207 |
|
46208 lTemp = lY1 - lTemp2; |
|
46209 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46210 |
|
46211 lTemp = lY1 + lTemp3; |
|
46212 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46213 |
|
46214 |
|
46215 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
46216 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
46217 |
|
46218 lCb1 -= 128; |
|
46219 lCr1 -= 128; |
|
46220 |
|
46221 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
46222 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46223 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
46224 |
|
46225 /*Third Pixel*/ |
|
46226 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
46227 lY1 -= 16; |
|
46228 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46229 |
|
46230 lTemp = lY1 + lTemp1; |
|
46231 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46232 |
|
46233 lTemp = lY1 - lTemp2; |
|
46234 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46235 |
|
46236 lTemp = lY1 + lTemp3; |
|
46237 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46238 |
|
46239 /*Fourth Pixel*/ |
|
46240 lY1 = lYuyvPtr[lLumWidth]; |
|
46241 lY1 -= 16; |
|
46242 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46243 |
|
46244 lTemp = lY1 + lTemp1; |
|
46245 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46246 |
|
46247 lTemp = lY1 - lTemp2; |
|
46248 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46249 |
|
46250 lTemp = lY1 + lTemp3; |
|
46251 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46252 |
|
46253 |
|
46254 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
46255 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
46256 |
|
46257 lCb1 -= 128; |
|
46258 lCr1 -= 128; |
|
46259 |
|
46260 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
46261 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46262 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
46263 |
|
46264 /*Fifth Pixel*/ |
|
46265 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
46266 lY1 -= 16; |
|
46267 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46268 |
|
46269 lTemp = lY1 + lTemp1; |
|
46270 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46271 |
|
46272 lTemp = lY1 - lTemp2; |
|
46273 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46274 |
|
46275 lTemp = lY1 + lTemp3; |
|
46276 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46277 |
|
46278 /*Sixth Pixel*/ |
|
46279 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
46280 lY1 -= 16; |
|
46281 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46282 |
|
46283 lTemp = lY1 + lTemp1; |
|
46284 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46285 |
|
46286 lTemp = lY1 - lTemp2; |
|
46287 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46288 |
|
46289 lTemp = lY1 + lTemp3; |
|
46290 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46291 |
|
46292 lYuyvPtr += 4; |
|
46293 src1 += 6; |
|
46294 src2 += 6; |
|
46295 |
|
46296 |
|
46297 src1 = lPtr1; |
|
46298 src2 = lPtr2; |
|
46299 |
|
46300 for(j = 0; j < lWidth; j += 2) |
|
46301 { |
|
46302 /* First Pixel */ |
|
46303 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
46304 diff1 = *src1 & 0x7; |
|
46305 diff2 = *(src1 + 1) & 0x3; |
|
46306 diff3 = *(src1 + 2) & 0x7; |
|
46307 |
|
46308 // diffuse the error |
|
46309 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
46310 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
46311 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
46312 |
|
46313 /* Second Pixel */ |
|
46314 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
46315 diff1 = *(src1 + 3) & 0x7; |
|
46316 diff2 = *(src1 + 4) & 0x3; |
|
46317 diff3 = *(src1 + 5) & 0x7; |
|
46318 // diffuse the error |
|
46319 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
46320 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
46321 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
46322 |
|
46323 src1 += 6; |
|
46324 dest1 += 2; |
|
46325 |
|
46326 /* Third Pixel */ |
|
46327 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
46328 diff1 = *src2 & 0x7; |
|
46329 diff2 = *(src2 + 1) & 0x3; |
|
46330 diff3 = *(src2 + 2) & 0x7; |
|
46331 //diffuse the error |
|
46332 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
46333 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
46334 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
46335 |
|
46336 /* Fourth Pixel */ |
|
46337 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
46338 diff1 = *(src2 + 3) & 0x7; |
|
46339 diff2 = *(src2 + 4) & 0x3; |
|
46340 diff3 = *(src2 + 5) & 0x7; |
|
46341 //diffuse the error |
|
46342 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
46343 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
46344 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
46345 |
|
46346 src2 += 6; |
|
46347 dest2 += 2; |
|
46348 } |
|
46349 if(extraCol) |
|
46350 { |
|
46351 *dest1 = dest1[-1]; |
|
46352 dest1++; |
|
46353 *dest2 = dest2[-1]; |
|
46354 dest2++; |
|
46355 } |
|
46356 |
|
46357 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
46358 |
|
46359 dest1 += ((wndWidth << 1) - lTempWidth); |
|
46360 dest2 += ((wndWidth << 1) - lTempWidth); |
|
46361 } |
|
46362 |
|
46363 if(extraRow) |
|
46364 { |
|
46365 dest2 = dest1 - wndWidth; |
|
46366 for(j = 0; j < lWidth; j += 2) |
|
46367 { |
|
46368 *dest1++ = *dest2++; |
|
46369 *dest1++ = *dest2++; |
|
46370 } |
|
46371 if(extraCol) |
|
46372 { |
|
46373 *dest1 = *dest2; |
|
46374 } |
|
46375 } |
|
46376 |
|
46377 free(lBuffer); |
|
46378 return; |
|
46379 } |
|
46380 |
|
46381 /* |
|
46382 ****************************************************************************** |
|
46383 Name : sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_601_5_RR |
|
46384 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to RGB565 Interleaved format. |
|
46385 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
46386 uint8 *dstImage : Pointer to rgb data (o/p). |
|
46387 tWndParam *srcWindow : Pointer to structure containing source window |
|
46388 parameters like xOffset,yOffset,cropWidth, |
|
46389 cropHeight. (i/p) |
|
46390 tWndParam *dstWindow : Pointer to structure containing destination window |
|
46391 parameters like xOffset,yOffset,windWidth, |
|
46392 windHeight. (i/p) |
|
46393 Return Value : void |
|
46394 ****************************************************************************** |
|
46395 */ |
|
46396 |
|
46397 void sEmz_VDec_YUV422LEChr1toColor64k_ErrDiff_601_5_RR |
|
46398 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
46399 tWndParam* srcWindow, tWndParam* dstWindow) |
|
46400 { |
|
46401 uint16 *dest1, *dest2; |
|
46402 uint8 *lYuyvPtr; |
|
46403 uint8 *lBuffer; |
|
46404 uint8 *src1, *src2; |
|
46405 uint8 *lPtr1, *lPtr2; |
|
46406 int32 diff1, diff2, diff3; |
|
46407 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
46408 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
46409 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
46410 int32 i, j, k, extraCol, extraRow; |
|
46411 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
46412 cropWidth,cropHeight,wndWidth,wndHeight; |
|
46413 |
|
46414 srcXOffset = srcWindow->xOffset; |
|
46415 srcYOffset = srcWindow->yOffset; |
|
46416 cropWidth = srcWindow->wndWidth; |
|
46417 cropHeight = srcWindow->wndHeight; |
|
46418 |
|
46419 dstXOffset = dstWindow->xOffset; |
|
46420 dstYOffset = dstWindow->yOffset; |
|
46421 wndWidth = dstWindow->wndWidth; |
|
46422 wndHeight = dstWindow->wndHeight; |
|
46423 |
|
46424 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
46425 { |
|
46426 lWidth = cropWidth; |
|
46427 } |
|
46428 else |
|
46429 { |
|
46430 lWidth = srcImage->width - srcXOffset; |
|
46431 } |
|
46432 |
|
46433 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
46434 { |
|
46435 lHeight = cropHeight; |
|
46436 } |
|
46437 else |
|
46438 { |
|
46439 lHeight = srcImage->height - srcYOffset; |
|
46440 } |
|
46441 |
|
46442 if (lWidth > (wndWidth - dstXOffset)) |
|
46443 { |
|
46444 lWidth = wndWidth - dstXOffset; |
|
46445 } |
|
46446 |
|
46447 if (lHeight > (wndHeight - dstYOffset)) |
|
46448 { |
|
46449 lHeight = wndHeight - dstYOffset; |
|
46450 } |
|
46451 |
|
46452 extraCol = lWidth & 0x01; |
|
46453 extraRow = lHeight & 0x01; |
|
46454 |
|
46455 lTempWidth = lWidth; |
|
46456 lWidth = (lWidth >> 1) << 1; |
|
46457 lHeight = (lHeight >> 1) << 1; |
|
46458 |
|
46459 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
46460 |
|
46461 lSrcWidth = lWidth * 3; |
|
46462 |
|
46463 lLumWidth = (srcImage->width >> 1) << 1; |
|
46464 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
46465 |
|
46466 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
46467 dest2 = dest1 + wndWidth; |
|
46468 |
|
46469 lLumWidth <<= 1; |
|
46470 |
|
46471 for(i = 0; i < lHeight; i += 2) |
|
46472 { |
|
46473 lPtr1 = src1 = lBuffer; |
|
46474 lPtr2 = src2 = src1 + lSrcWidth; |
|
46475 |
|
46476 for(k = 0; k < (lWidth - 2); k += 2) |
|
46477 { |
|
46478 lCb1 = lYuyvPtr[3]; |
|
46479 lCr1 = lYuyvPtr[1]; |
|
46480 |
|
46481 lCb2 = lYuyvPtr[7]; |
|
46482 lCr2 = lYuyvPtr[5]; |
|
46483 |
|
46484 lCr2 = (lCr1 + lCr2) >> 1; |
|
46485 lCb2 = (lCb1 + lCb2) >> 1; |
|
46486 |
|
46487 /*First Pixel*/ |
|
46488 lCb1 -= 128; |
|
46489 lCr1 -= 128; |
|
46490 |
|
46491 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
46492 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46493 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
46494 |
|
46495 lY1 = lYuyvPtr[2]; |
|
46496 lY1 -= 16; |
|
46497 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46498 |
|
46499 lTemp = lY1 + lTemp1; |
|
46500 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46501 |
|
46502 lTemp = lY1 - lTemp2; |
|
46503 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46504 |
|
46505 lTemp = lY1 + lTemp3; |
|
46506 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46507 |
|
46508 /*Second Pixel*/ |
|
46509 lCb2 -= 128; |
|
46510 lCr2 -= 128; |
|
46511 |
|
46512 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
46513 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
46514 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
46515 |
|
46516 lY1 = lYuyvPtr[0]; |
|
46517 lY1 -= 16; |
|
46518 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46519 |
|
46520 lTemp = lY1 + lTemp1; |
|
46521 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46522 |
|
46523 lTemp = lY1 - lTemp2; |
|
46524 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46525 |
|
46526 lTemp = lY1 + lTemp3; |
|
46527 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46528 |
|
46529 |
|
46530 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
46531 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
46532 |
|
46533 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
46534 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
46535 |
|
46536 lCr2 = (lCr1 + lCr2) >> 1; |
|
46537 lCb2 = (lCb1 + lCb2) >> 1; |
|
46538 |
|
46539 |
|
46540 /*Third Pixel*/ |
|
46541 lCb1 -= 128; |
|
46542 lCr1 -= 128; |
|
46543 |
|
46544 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
46545 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46546 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
46547 |
|
46548 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
46549 lY1 -= 16; |
|
46550 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46551 |
|
46552 lTemp = lY1 + lTemp1; |
|
46553 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46554 |
|
46555 lTemp = lY1 - lTemp2; |
|
46556 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46557 |
|
46558 lTemp = lY1 + lTemp3; |
|
46559 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46560 |
|
46561 /*Fourth Pixel*/ |
|
46562 lCb2 -= 128; |
|
46563 lCr2 -= 128; |
|
46564 |
|
46565 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
46566 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
46567 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
46568 |
|
46569 lY1 = lYuyvPtr[lLumWidth]; |
|
46570 lY1 -= 16; |
|
46571 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46572 |
|
46573 lTemp = lY1 + lTemp1; |
|
46574 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46575 |
|
46576 lTemp = lY1 - lTemp2; |
|
46577 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46578 |
|
46579 lTemp = lY1 + lTemp3; |
|
46580 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46581 |
|
46582 |
|
46583 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
46584 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
46585 |
|
46586 lCb2 = lYuyvPtr[(lLumWidth << 1) + 7]; |
|
46587 lCr2 = lYuyvPtr[(lLumWidth << 1) + 5]; |
|
46588 |
|
46589 lCr2 = (lCr1 + lCr2) >> 1; |
|
46590 lCb2 = (lCb1 + lCb2) >> 1; |
|
46591 |
|
46592 /*Fifth Pixel*/ |
|
46593 lCb1 -= 128; |
|
46594 lCr1 -= 128; |
|
46595 |
|
46596 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
46597 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46598 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
46599 |
|
46600 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
46601 lY1 -= 16; |
|
46602 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46603 |
|
46604 lTemp = lY1 + lTemp1; |
|
46605 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46606 |
|
46607 lTemp = lY1 - lTemp2; |
|
46608 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46609 |
|
46610 lTemp = lY1 + lTemp3; |
|
46611 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46612 |
|
46613 /*Sixth Pixel*/ |
|
46614 lCb2 -= 128; |
|
46615 lCr2 -= 128; |
|
46616 |
|
46617 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
46618 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
46619 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
46620 |
|
46621 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
46622 lY1 -= 16; |
|
46623 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46624 |
|
46625 lTemp = lY1 + lTemp1; |
|
46626 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46627 |
|
46628 lTemp = lY1 - lTemp2; |
|
46629 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46630 |
|
46631 lTemp = lY1 + lTemp3; |
|
46632 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46633 |
|
46634 lYuyvPtr += 4; |
|
46635 src1 += 6; |
|
46636 src2 += 6; |
|
46637 } |
|
46638 |
|
46639 lCb1 = lYuyvPtr[3]; |
|
46640 lCr1 = lYuyvPtr[1]; |
|
46641 |
|
46642 lCb1 -= 128; |
|
46643 lCr1 -= 128; |
|
46644 |
|
46645 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
46646 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46647 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
46648 |
|
46649 /*First Pixel*/ |
|
46650 lY1 = lYuyvPtr[2]; |
|
46651 lY1 -= 16; |
|
46652 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46653 |
|
46654 lTemp = lY1 + lTemp1; |
|
46655 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46656 |
|
46657 lTemp = lY1 - lTemp2; |
|
46658 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46659 |
|
46660 lTemp = lY1 + lTemp3; |
|
46661 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46662 |
|
46663 /*Second Pixel*/ |
|
46664 lY1 = lYuyvPtr[0]; |
|
46665 lY1 -= 16; |
|
46666 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46667 |
|
46668 lTemp = lY1 + lTemp1; |
|
46669 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46670 |
|
46671 lTemp = lY1 - lTemp2; |
|
46672 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46673 |
|
46674 lTemp = lY1 + lTemp3; |
|
46675 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46676 |
|
46677 |
|
46678 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
46679 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
46680 |
|
46681 lCb1 -= 128; |
|
46682 lCr1 -= 128; |
|
46683 |
|
46684 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
46685 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46686 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
46687 |
|
46688 /*Third Pixel*/ |
|
46689 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
46690 lY1 -= 16; |
|
46691 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46692 |
|
46693 lTemp = lY1 + lTemp1; |
|
46694 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46695 |
|
46696 lTemp = lY1 - lTemp2; |
|
46697 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46698 |
|
46699 lTemp = lY1 + lTemp3; |
|
46700 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46701 |
|
46702 /*Fourth Pixel*/ |
|
46703 lY1 = lYuyvPtr[lLumWidth]; |
|
46704 lY1 -= 16; |
|
46705 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46706 |
|
46707 lTemp = lY1 + lTemp1; |
|
46708 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46709 |
|
46710 lTemp = lY1 - lTemp2; |
|
46711 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46712 |
|
46713 lTemp = lY1 + lTemp3; |
|
46714 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46715 |
|
46716 |
|
46717 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
46718 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
46719 |
|
46720 lCb1 -= 128; |
|
46721 lCr1 -= 128; |
|
46722 |
|
46723 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
46724 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46725 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
46726 |
|
46727 /*Fifth Pixel*/ |
|
46728 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
46729 lY1 -= 16; |
|
46730 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46731 |
|
46732 lTemp = lY1 + lTemp1; |
|
46733 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46734 |
|
46735 lTemp = lY1 - lTemp2; |
|
46736 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46737 |
|
46738 lTemp = lY1 + lTemp3; |
|
46739 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46740 |
|
46741 /*Sixth Pixel*/ |
|
46742 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
46743 lY1 -= 16; |
|
46744 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
46745 |
|
46746 lTemp = lY1 + lTemp1; |
|
46747 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46748 |
|
46749 lTemp = lY1 - lTemp2; |
|
46750 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46751 |
|
46752 lTemp = lY1 + lTemp3; |
|
46753 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
46754 |
|
46755 lYuyvPtr += 4; |
|
46756 src1 += 6; |
|
46757 src2 += 6; |
|
46758 |
|
46759 |
|
46760 src1 = lPtr1; |
|
46761 src2 = lPtr2; |
|
46762 |
|
46763 for(j = 0; j < lWidth; j += 2) |
|
46764 { |
|
46765 /* First Pixel */ |
|
46766 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
46767 diff1 = *src1 & 0x7; |
|
46768 diff2 = *(src1 + 1) & 0x3; |
|
46769 diff3 = *(src1 + 2) & 0x7; |
|
46770 |
|
46771 // diffuse the error |
|
46772 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
46773 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
46774 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
46775 |
|
46776 /* Second Pixel */ |
|
46777 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
46778 diff1 = *(src1 + 3) & 0x7; |
|
46779 diff2 = *(src1 + 4) & 0x3; |
|
46780 diff3 = *(src1 + 5) & 0x7; |
|
46781 // diffuse the error |
|
46782 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
46783 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
46784 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
46785 |
|
46786 src1 += 6; |
|
46787 dest1 += 2; |
|
46788 |
|
46789 /* Third Pixel */ |
|
46790 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
46791 diff1 = *src2 & 0x7; |
|
46792 diff2 = *(src2 + 1) & 0x3; |
|
46793 diff3 = *(src2 + 2) & 0x7; |
|
46794 //diffuse the error |
|
46795 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
46796 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
46797 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
46798 |
|
46799 /* Fourth Pixel */ |
|
46800 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
46801 diff1 = *(src2 + 3) & 0x7; |
|
46802 diff2 = *(src2 + 4) & 0x3; |
|
46803 diff3 = *(src2 + 5) & 0x7; |
|
46804 //diffuse the error |
|
46805 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
46806 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
46807 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
46808 |
|
46809 src2 += 6; |
|
46810 dest2 += 2; |
|
46811 } |
|
46812 if(extraCol) |
|
46813 { |
|
46814 *dest1 = dest1[-1]; |
|
46815 dest1++; |
|
46816 *dest2 = dest2[-1]; |
|
46817 dest2++; |
|
46818 } |
|
46819 |
|
46820 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
46821 |
|
46822 dest1 += ((wndWidth << 1) - lTempWidth); |
|
46823 dest2 += ((wndWidth << 1) - lTempWidth); |
|
46824 } |
|
46825 |
|
46826 if(extraRow) |
|
46827 { |
|
46828 dest2 = dest1 - wndWidth; |
|
46829 for(j = 0; j < lWidth; j += 2) |
|
46830 { |
|
46831 *dest1++ = *dest2++; |
|
46832 *dest1++ = *dest2++; |
|
46833 } |
|
46834 if(extraCol) |
|
46835 { |
|
46836 *dest1 = *dest2; |
|
46837 } |
|
46838 } |
|
46839 |
|
46840 free(lBuffer); |
|
46841 return; |
|
46842 } |
|
46843 |
|
46844 |
|
46845 |
|
46846 |
|
46847 |
|
46848 |
|
46849 |
|
46850 |
|
46851 |
|
46852 |
|
46853 |
|
46854 |
|
46855 |
|
46856 |
|
46857 |
|
46858 |
|
46859 |
|
46860 |
|
46861 |
|
46862 /* |
|
46863 ****************************************************************************** |
|
46864 Name : sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_709_FR |
|
46865 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
46866 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
46867 uint8 *dstImage : Pointer to rgb data (o/p). |
|
46868 tWndParam *srcWindow : Pointer to structure containing source window |
|
46869 parameters like xOffset,yOffset,cropWidth, |
|
46870 cropHeight. (i/p) |
|
46871 tWndParam *dstWindow : Pointer to structure containing destination window |
|
46872 parameters like xOffset,yOffset,windWidth, |
|
46873 windHeight. (i/p) |
|
46874 Return Value : void |
|
46875 ****************************************************************************** |
|
46876 */ |
|
46877 |
|
46878 void sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_709_FR |
|
46879 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
46880 tWndParam* srcWindow, tWndParam* dstWindow) |
|
46881 { |
|
46882 uint16 *dest1, *dest2; |
|
46883 uint8 *lYuyvPtr; |
|
46884 uint8 *lBuffer; |
|
46885 uint8 *src1, *src2; |
|
46886 uint8 *lPtr1, *lPtr2; |
|
46887 int32 diff1, diff2, diff3; |
|
46888 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
46889 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
46890 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
46891 int32 i, j, k, extraCol, extraRow; |
|
46892 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
46893 cropWidth,cropHeight,wndWidth,wndHeight; |
|
46894 |
|
46895 srcXOffset = srcWindow->xOffset; |
|
46896 srcYOffset = srcWindow->yOffset; |
|
46897 cropWidth = srcWindow->wndWidth; |
|
46898 cropHeight = srcWindow->wndHeight; |
|
46899 |
|
46900 dstXOffset = dstWindow->xOffset; |
|
46901 dstYOffset = dstWindow->yOffset; |
|
46902 wndWidth = dstWindow->wndWidth; |
|
46903 wndHeight = dstWindow->wndHeight; |
|
46904 |
|
46905 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
46906 { |
|
46907 lWidth = cropWidth; |
|
46908 } |
|
46909 else |
|
46910 { |
|
46911 lWidth = srcImage->width - srcXOffset; |
|
46912 } |
|
46913 |
|
46914 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
46915 { |
|
46916 lHeight = cropHeight; |
|
46917 } |
|
46918 else |
|
46919 { |
|
46920 lHeight = srcImage->height - srcYOffset; |
|
46921 } |
|
46922 |
|
46923 if (lWidth > (wndWidth - dstXOffset)) |
|
46924 { |
|
46925 lWidth = wndWidth - dstXOffset; |
|
46926 } |
|
46927 |
|
46928 if (lHeight > (wndHeight - dstYOffset)) |
|
46929 { |
|
46930 lHeight = wndHeight - dstYOffset; |
|
46931 } |
|
46932 |
|
46933 extraCol = lWidth & 0x01; |
|
46934 extraRow = lHeight & 0x01; |
|
46935 |
|
46936 lTempWidth = lWidth; |
|
46937 lWidth = (lWidth >> 1) << 1; |
|
46938 lHeight = (lHeight >> 1) << 1; |
|
46939 |
|
46940 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
46941 |
|
46942 lSrcWidth = lWidth * 3; |
|
46943 |
|
46944 lLumWidth = (srcImage->width >> 1) << 1; |
|
46945 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
46946 |
|
46947 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
46948 dest2 = dest1 + wndWidth; |
|
46949 |
|
46950 lLumWidth <<= 1; |
|
46951 |
|
46952 for(i = 0; i < lHeight; i += 2) |
|
46953 { |
|
46954 lPtr1 = src1 = lBuffer; |
|
46955 lPtr2 = src2 = src1 + lSrcWidth; |
|
46956 |
|
46957 for(k = 0; k < (lWidth - 2); k += 2) |
|
46958 { |
|
46959 lCb1 = lYuyvPtr[3]; |
|
46960 lCr1 = lYuyvPtr[1]; |
|
46961 |
|
46962 lCb2 = lYuyvPtr[7]; |
|
46963 lCr2 = lYuyvPtr[5]; |
|
46964 |
|
46965 lCr2 = (lCr1 + lCr2) >> 1; |
|
46966 lCb2 = (lCb1 + lCb2) >> 1; |
|
46967 |
|
46968 /*First Pixel*/ |
|
46969 lCb1 -= 128; |
|
46970 lCr1 -= 128; |
|
46971 |
|
46972 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
46973 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
46974 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
46975 |
|
46976 lY1 = lYuyvPtr[2]; |
|
46977 |
|
46978 lTemp = lY1 + lTemp1; |
|
46979 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
46980 |
|
46981 lTemp = lY1 - lTemp2; |
|
46982 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
46983 |
|
46984 lTemp = lY1 + lTemp3; |
|
46985 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
46986 |
|
46987 /*Second Pixel*/ |
|
46988 lCb2 -= 128; |
|
46989 lCr2 -= 128; |
|
46990 |
|
46991 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
46992 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
46993 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
46994 |
|
46995 lY1 = lYuyvPtr[0]; |
|
46996 |
|
46997 lTemp = lY1 + lTemp1; |
|
46998 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
46999 |
|
47000 lTemp = lY1 - lTemp2; |
|
47001 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47002 |
|
47003 lTemp = lY1 + lTemp3; |
|
47004 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47005 |
|
47006 |
|
47007 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
47008 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
47009 |
|
47010 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
47011 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
47012 |
|
47013 lCr2 = (lCr1 + lCr2) >> 1; |
|
47014 lCb2 = (lCb1 + lCb2) >> 1; |
|
47015 |
|
47016 |
|
47017 /*Third Pixel*/ |
|
47018 lCb1 -= 128; |
|
47019 lCr1 -= 128; |
|
47020 |
|
47021 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
47022 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47023 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
47024 |
|
47025 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
47026 |
|
47027 lTemp = lY1 + lTemp1; |
|
47028 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47029 |
|
47030 lTemp = lY1 - lTemp2; |
|
47031 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47032 |
|
47033 lTemp = lY1 + lTemp3; |
|
47034 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47035 |
|
47036 /*Fourth Pixel*/ |
|
47037 lCb2 -= 128; |
|
47038 lCr2 -= 128; |
|
47039 |
|
47040 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
47041 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
47042 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
47043 |
|
47044 lY1 = lYuyvPtr[lLumWidth]; |
|
47045 |
|
47046 lTemp = lY1 + lTemp1; |
|
47047 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47048 |
|
47049 lTemp = lY1 - lTemp2; |
|
47050 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47051 |
|
47052 lTemp = lY1 + lTemp3; |
|
47053 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47054 |
|
47055 |
|
47056 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
47057 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
47058 |
|
47059 lCb2 = lYuyvPtr[(lLumWidth << 1) + 7]; |
|
47060 lCr2 = lYuyvPtr[(lLumWidth << 1) + 5]; |
|
47061 |
|
47062 lCr2 = (lCr1 + lCr2) >> 1; |
|
47063 lCb2 = (lCb1 + lCb2) >> 1; |
|
47064 |
|
47065 /*Fifth Pixel*/ |
|
47066 lCb1 -= 128; |
|
47067 lCr1 -= 128; |
|
47068 |
|
47069 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
47070 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47071 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
47072 |
|
47073 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
47074 |
|
47075 lTemp = lY1 + lTemp1; |
|
47076 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47077 |
|
47078 lTemp = lY1 - lTemp2; |
|
47079 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47080 |
|
47081 lTemp = lY1 + lTemp3; |
|
47082 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47083 |
|
47084 /*Sixth Pixel*/ |
|
47085 lCb2 -= 128; |
|
47086 lCr2 -= 128; |
|
47087 |
|
47088 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
47089 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
47090 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
47091 |
|
47092 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
47093 |
|
47094 lTemp = lY1 + lTemp1; |
|
47095 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47096 |
|
47097 lTemp = lY1 - lTemp2; |
|
47098 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47099 |
|
47100 lTemp = lY1 + lTemp3; |
|
47101 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47102 |
|
47103 lYuyvPtr += 4; |
|
47104 src1 += 6; |
|
47105 src2 += 6; |
|
47106 } |
|
47107 |
|
47108 lCb1 = lYuyvPtr[3]; |
|
47109 lCr1 = lYuyvPtr[1]; |
|
47110 |
|
47111 lCb1 -= 128; |
|
47112 lCr1 -= 128; |
|
47113 |
|
47114 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
47115 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47116 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
47117 |
|
47118 /*First Pixel*/ |
|
47119 lY1 = lYuyvPtr[2]; |
|
47120 |
|
47121 lTemp = lY1 + lTemp1; |
|
47122 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47123 |
|
47124 lTemp = lY1 - lTemp2; |
|
47125 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47126 |
|
47127 lTemp = lY1 + lTemp3; |
|
47128 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47129 |
|
47130 /*Second Pixel*/ |
|
47131 lY1 = lYuyvPtr[0]; |
|
47132 |
|
47133 lTemp = lY1 + lTemp1; |
|
47134 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47135 |
|
47136 lTemp = lY1 - lTemp2; |
|
47137 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47138 |
|
47139 lTemp = lY1 + lTemp3; |
|
47140 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47141 |
|
47142 |
|
47143 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
47144 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
47145 |
|
47146 lCb1 -= 128; |
|
47147 lCr1 -= 128; |
|
47148 |
|
47149 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
47150 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47151 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
47152 |
|
47153 /*Third Pixel*/ |
|
47154 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
47155 |
|
47156 lTemp = lY1 + lTemp1; |
|
47157 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47158 |
|
47159 lTemp = lY1 - lTemp2; |
|
47160 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47161 |
|
47162 lTemp = lY1 + lTemp3; |
|
47163 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47164 |
|
47165 /*Fourth Pixel*/ |
|
47166 lY1 = lYuyvPtr[lLumWidth]; |
|
47167 |
|
47168 lTemp = lY1 + lTemp1; |
|
47169 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47170 |
|
47171 lTemp = lY1 - lTemp2; |
|
47172 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47173 |
|
47174 lTemp = lY1 + lTemp3; |
|
47175 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47176 |
|
47177 |
|
47178 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
47179 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
47180 |
|
47181 lCb1 -= 128; |
|
47182 lCr1 -= 128; |
|
47183 |
|
47184 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
47185 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47186 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
47187 |
|
47188 /*Fifth Pixel*/ |
|
47189 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
47190 |
|
47191 lTemp = lY1 + lTemp1; |
|
47192 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47193 |
|
47194 lTemp = lY1 - lTemp2; |
|
47195 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47196 |
|
47197 lTemp = lY1 + lTemp3; |
|
47198 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47199 |
|
47200 /*Sixth Pixel*/ |
|
47201 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
47202 |
|
47203 lTemp = lY1 + lTemp1; |
|
47204 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47205 |
|
47206 lTemp = lY1 - lTemp2; |
|
47207 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47208 |
|
47209 lTemp = lY1 + lTemp3; |
|
47210 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47211 |
|
47212 lYuyvPtr += 4; |
|
47213 src1 += 6; |
|
47214 src2 += 6; |
|
47215 |
|
47216 |
|
47217 src1 = lPtr1; |
|
47218 src2 = lPtr2; |
|
47219 |
|
47220 for(j = 0; j < lWidth; j += 2) |
|
47221 { |
|
47222 /* First Pixel */ |
|
47223 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
47224 diff1 = *src1 & 0xf; |
|
47225 diff2 = *(src1 + 1) & 0xf; |
|
47226 diff3 = *(src1 + 2) & 0xf; |
|
47227 |
|
47228 // diffuse the error |
|
47229 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
47230 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
47231 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
47232 |
|
47233 /* Second Pixel */ |
|
47234 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
47235 diff1 = *(src1 + 3) & 0xf; |
|
47236 diff2 = *(src1 + 4) & 0xf; |
|
47237 diff3 = *(src1 + 5) & 0xf; |
|
47238 // diffuse the error |
|
47239 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
47240 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
47241 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
47242 |
|
47243 src1 += 6; |
|
47244 dest1 += 2; |
|
47245 |
|
47246 /* Third Pixel */ |
|
47247 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
47248 diff1 = *src2 & 0xf; |
|
47249 diff2 = *(src2 + 1) & 0xf; |
|
47250 diff3 = *(src2 + 2) & 0xf; |
|
47251 //diffuse the error |
|
47252 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
47253 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
47254 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
47255 |
|
47256 /* Fourth Pixel */ |
|
47257 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
47258 diff1 = *(src2 + 3) & 0xf; |
|
47259 diff2 = *(src2 + 4) & 0xf; |
|
47260 diff3 = *(src2 + 5) & 0xf; |
|
47261 //diffuse the error |
|
47262 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
47263 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
47264 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
47265 |
|
47266 src2 += 6; |
|
47267 dest2 += 2; |
|
47268 } |
|
47269 if(extraCol) |
|
47270 { |
|
47271 *dest1 = dest1[-1]; |
|
47272 dest1++; |
|
47273 *dest2 = dest2[-1]; |
|
47274 dest2++; |
|
47275 } |
|
47276 |
|
47277 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
47278 |
|
47279 dest1 += ((wndWidth << 1) - lTempWidth); |
|
47280 dest2 += ((wndWidth << 1) - lTempWidth); |
|
47281 } |
|
47282 |
|
47283 if(extraRow) |
|
47284 { |
|
47285 dest2 = dest1 - wndWidth; |
|
47286 for(j = 0; j < lWidth; j += 2) |
|
47287 { |
|
47288 *dest1++ = *dest2++; |
|
47289 *dest1++ = *dest2++; |
|
47290 } |
|
47291 if(extraCol) |
|
47292 { |
|
47293 *dest1 = *dest2; |
|
47294 } |
|
47295 } |
|
47296 |
|
47297 free(lBuffer); |
|
47298 return; |
|
47299 } |
|
47300 |
|
47301 /* |
|
47302 ****************************************************************************** |
|
47303 Name : sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_601_5_FR |
|
47304 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
47305 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
47306 uint8 *dstImage : Pointer to rgb data (o/p). |
|
47307 tWndParam *srcWindow : Pointer to structure containing source window |
|
47308 parameters like xOffset,yOffset,cropWidth, |
|
47309 cropHeight. (i/p) |
|
47310 tWndParam *dstWindow : Pointer to structure containing destination window |
|
47311 parameters like xOffset,yOffset,windWidth, |
|
47312 windHeight. (i/p) |
|
47313 Return Value : void |
|
47314 ****************************************************************************** |
|
47315 */ |
|
47316 |
|
47317 void sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_601_5_FR |
|
47318 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
47319 tWndParam* srcWindow, tWndParam* dstWindow) |
|
47320 { |
|
47321 uint16 *dest1, *dest2; |
|
47322 uint8 *lYuyvPtr; |
|
47323 uint8 *lBuffer; |
|
47324 uint8 *src1, *src2; |
|
47325 uint8 *lPtr1, *lPtr2; |
|
47326 int32 diff1, diff2, diff3; |
|
47327 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
47328 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
47329 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
47330 int32 i, j, k, extraCol, extraRow; |
|
47331 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
47332 cropWidth,cropHeight,wndWidth,wndHeight; |
|
47333 |
|
47334 srcXOffset = srcWindow->xOffset; |
|
47335 srcYOffset = srcWindow->yOffset; |
|
47336 cropWidth = srcWindow->wndWidth; |
|
47337 cropHeight = srcWindow->wndHeight; |
|
47338 |
|
47339 dstXOffset = dstWindow->xOffset; |
|
47340 dstYOffset = dstWindow->yOffset; |
|
47341 wndWidth = dstWindow->wndWidth; |
|
47342 wndHeight = dstWindow->wndHeight; |
|
47343 |
|
47344 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
47345 { |
|
47346 lWidth = cropWidth; |
|
47347 } |
|
47348 else |
|
47349 { |
|
47350 lWidth = srcImage->width - srcXOffset; |
|
47351 } |
|
47352 |
|
47353 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
47354 { |
|
47355 lHeight = cropHeight; |
|
47356 } |
|
47357 else |
|
47358 { |
|
47359 lHeight = srcImage->height - srcYOffset; |
|
47360 } |
|
47361 |
|
47362 if (lWidth > (wndWidth - dstXOffset)) |
|
47363 { |
|
47364 lWidth = wndWidth - dstXOffset; |
|
47365 } |
|
47366 |
|
47367 if (lHeight > (wndHeight - dstYOffset)) |
|
47368 { |
|
47369 lHeight = wndHeight - dstYOffset; |
|
47370 } |
|
47371 |
|
47372 extraCol = lWidth & 0x01; |
|
47373 extraRow = lHeight & 0x01; |
|
47374 |
|
47375 lTempWidth = lWidth; |
|
47376 lWidth = (lWidth >> 1) << 1; |
|
47377 lHeight = (lHeight >> 1) << 1; |
|
47378 |
|
47379 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
47380 |
|
47381 lSrcWidth = lWidth * 3; |
|
47382 |
|
47383 lLumWidth = (srcImage->width >> 1) << 1; |
|
47384 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
47385 |
|
47386 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
47387 dest2 = dest1 + wndWidth; |
|
47388 |
|
47389 lLumWidth <<= 1; |
|
47390 |
|
47391 for(i = 0; i < lHeight; i += 2) |
|
47392 { |
|
47393 lPtr1 = src1 = lBuffer; |
|
47394 lPtr2 = src2 = src1 + lSrcWidth; |
|
47395 |
|
47396 for(k = 0; k < (lWidth - 2); k += 2) |
|
47397 { |
|
47398 lCb1 = lYuyvPtr[3]; |
|
47399 lCr1 = lYuyvPtr[1]; |
|
47400 |
|
47401 lCb2 = lYuyvPtr[7]; |
|
47402 lCr2 = lYuyvPtr[5]; |
|
47403 |
|
47404 lCr2 = (lCr1 + lCr2) >> 1; |
|
47405 lCb2 = (lCb1 + lCb2) >> 1; |
|
47406 |
|
47407 /*First Pixel*/ |
|
47408 lCb1 -= 128; |
|
47409 lCr1 -= 128; |
|
47410 |
|
47411 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
47412 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47413 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
47414 |
|
47415 lY1 = lYuyvPtr[2]; |
|
47416 |
|
47417 lTemp = lY1 + lTemp1; |
|
47418 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47419 |
|
47420 lTemp = lY1 - lTemp2; |
|
47421 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47422 |
|
47423 lTemp = lY1 + lTemp3; |
|
47424 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47425 |
|
47426 /*Second Pixel*/ |
|
47427 lCb2 -= 128; |
|
47428 lCr2 -= 128; |
|
47429 |
|
47430 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
47431 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
47432 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
47433 |
|
47434 lY1 = lYuyvPtr[0]; |
|
47435 |
|
47436 lTemp = lY1 + lTemp1; |
|
47437 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47438 |
|
47439 lTemp = lY1 - lTemp2; |
|
47440 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47441 |
|
47442 lTemp = lY1 + lTemp3; |
|
47443 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47444 |
|
47445 |
|
47446 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
47447 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
47448 |
|
47449 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
47450 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
47451 |
|
47452 lCr2 = (lCr1 + lCr2) >> 1; |
|
47453 lCb2 = (lCb1 + lCb2) >> 1; |
|
47454 |
|
47455 |
|
47456 /*Third Pixel*/ |
|
47457 lCb1 -= 128; |
|
47458 lCr1 -= 128; |
|
47459 |
|
47460 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
47461 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47462 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
47463 |
|
47464 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
47465 |
|
47466 lTemp = lY1 + lTemp1; |
|
47467 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47468 |
|
47469 lTemp = lY1 - lTemp2; |
|
47470 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47471 |
|
47472 lTemp = lY1 + lTemp3; |
|
47473 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47474 |
|
47475 /*Fourth Pixel*/ |
|
47476 lCb2 -= 128; |
|
47477 lCr2 -= 128; |
|
47478 |
|
47479 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
47480 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
47481 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
47482 |
|
47483 lY1 = lYuyvPtr[lLumWidth]; |
|
47484 |
|
47485 lTemp = lY1 + lTemp1; |
|
47486 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47487 |
|
47488 lTemp = lY1 - lTemp2; |
|
47489 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47490 |
|
47491 lTemp = lY1 + lTemp3; |
|
47492 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47493 |
|
47494 |
|
47495 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
47496 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
47497 |
|
47498 lCb2 = lYuyvPtr[(lLumWidth << 1) + 7]; |
|
47499 lCr2 = lYuyvPtr[(lLumWidth << 1) + 5]; |
|
47500 |
|
47501 lCr2 = (lCr1 + lCr2) >> 1; |
|
47502 lCb2 = (lCb1 + lCb2) >> 1; |
|
47503 |
|
47504 /*Fifth Pixel*/ |
|
47505 lCb1 -= 128; |
|
47506 lCr1 -= 128; |
|
47507 |
|
47508 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
47509 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47510 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
47511 |
|
47512 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
47513 |
|
47514 lTemp = lY1 + lTemp1; |
|
47515 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47516 |
|
47517 lTemp = lY1 - lTemp2; |
|
47518 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47519 |
|
47520 lTemp = lY1 + lTemp3; |
|
47521 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47522 |
|
47523 /*Sixth Pixel*/ |
|
47524 lCb2 -= 128; |
|
47525 lCr2 -= 128; |
|
47526 |
|
47527 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
47528 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
47529 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
47530 |
|
47531 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
47532 |
|
47533 lTemp = lY1 + lTemp1; |
|
47534 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47535 |
|
47536 lTemp = lY1 - lTemp2; |
|
47537 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47538 |
|
47539 lTemp = lY1 + lTemp3; |
|
47540 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47541 |
|
47542 lYuyvPtr += 4; |
|
47543 src1 += 6; |
|
47544 src2 += 6; |
|
47545 } |
|
47546 |
|
47547 lCb1 = lYuyvPtr[3]; |
|
47548 lCr1 = lYuyvPtr[1]; |
|
47549 |
|
47550 lCb1 -= 128; |
|
47551 lCr1 -= 128; |
|
47552 |
|
47553 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
47554 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47555 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
47556 |
|
47557 /*First Pixel*/ |
|
47558 lY1 = lYuyvPtr[2]; |
|
47559 |
|
47560 lTemp = lY1 + lTemp1; |
|
47561 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47562 |
|
47563 lTemp = lY1 - lTemp2; |
|
47564 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47565 |
|
47566 lTemp = lY1 + lTemp3; |
|
47567 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47568 |
|
47569 /*Second Pixel*/ |
|
47570 lY1 = lYuyvPtr[0]; |
|
47571 |
|
47572 lTemp = lY1 + lTemp1; |
|
47573 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47574 |
|
47575 lTemp = lY1 - lTemp2; |
|
47576 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47577 |
|
47578 lTemp = lY1 + lTemp3; |
|
47579 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47580 |
|
47581 |
|
47582 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
47583 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
47584 |
|
47585 lCb1 -= 128; |
|
47586 lCr1 -= 128; |
|
47587 |
|
47588 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
47589 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47590 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
47591 |
|
47592 /*Third Pixel*/ |
|
47593 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
47594 |
|
47595 lTemp = lY1 + lTemp1; |
|
47596 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47597 |
|
47598 lTemp = lY1 - lTemp2; |
|
47599 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47600 |
|
47601 lTemp = lY1 + lTemp3; |
|
47602 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47603 |
|
47604 /*Fourth Pixel*/ |
|
47605 lY1 = lYuyvPtr[lLumWidth]; |
|
47606 |
|
47607 lTemp = lY1 + lTemp1; |
|
47608 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47609 |
|
47610 lTemp = lY1 - lTemp2; |
|
47611 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47612 |
|
47613 lTemp = lY1 + lTemp3; |
|
47614 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47615 |
|
47616 |
|
47617 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
47618 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
47619 |
|
47620 lCb1 -= 128; |
|
47621 lCr1 -= 128; |
|
47622 |
|
47623 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
47624 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47625 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
47626 |
|
47627 /*Fifth Pixel*/ |
|
47628 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
47629 |
|
47630 lTemp = lY1 + lTemp1; |
|
47631 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47632 |
|
47633 lTemp = lY1 - lTemp2; |
|
47634 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47635 |
|
47636 lTemp = lY1 + lTemp3; |
|
47637 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47638 |
|
47639 /*Sixth Pixel*/ |
|
47640 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
47641 |
|
47642 lTemp = lY1 + lTemp1; |
|
47643 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47644 |
|
47645 lTemp = lY1 - lTemp2; |
|
47646 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47647 |
|
47648 lTemp = lY1 + lTemp3; |
|
47649 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
47650 |
|
47651 lYuyvPtr += 4; |
|
47652 src1 += 6; |
|
47653 src2 += 6; |
|
47654 |
|
47655 |
|
47656 src1 = lPtr1; |
|
47657 src2 = lPtr2; |
|
47658 |
|
47659 for(j = 0; j < lWidth; j += 2) |
|
47660 { |
|
47661 /* First Pixel */ |
|
47662 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
47663 diff1 = *src1 & 0xf; |
|
47664 diff2 = *(src1 + 1) & 0xf; |
|
47665 diff3 = *(src1 + 2) & 0xf; |
|
47666 |
|
47667 // diffuse the error |
|
47668 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
47669 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
47670 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
47671 |
|
47672 /* Second Pixel */ |
|
47673 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
47674 diff1 = *(src1 + 3) & 0xf; |
|
47675 diff2 = *(src1 + 4) & 0xf; |
|
47676 diff3 = *(src1 + 5) & 0xf; |
|
47677 // diffuse the error |
|
47678 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
47679 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
47680 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
47681 |
|
47682 src1 += 6; |
|
47683 dest1 += 2; |
|
47684 |
|
47685 /* Third Pixel */ |
|
47686 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
47687 diff1 = *src2 & 0xf; |
|
47688 diff2 = *(src2 + 1) & 0xf; |
|
47689 diff3 = *(src2 + 2) & 0xf; |
|
47690 //diffuse the error |
|
47691 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
47692 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
47693 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
47694 |
|
47695 /* Fourth Pixel */ |
|
47696 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
47697 diff1 = *(src2 + 3) & 0xf; |
|
47698 diff2 = *(src2 + 4) & 0xf; |
|
47699 diff3 = *(src2 + 5) & 0xf; |
|
47700 //diffuse the error |
|
47701 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
47702 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
47703 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
47704 |
|
47705 src2 += 6; |
|
47706 dest2 += 2; |
|
47707 } |
|
47708 if(extraCol) |
|
47709 { |
|
47710 *dest1 = dest1[-1]; |
|
47711 dest1++; |
|
47712 *dest2 = dest2[-1]; |
|
47713 dest2++; |
|
47714 } |
|
47715 |
|
47716 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
47717 |
|
47718 dest1 += ((wndWidth << 1) - lTempWidth); |
|
47719 dest2 += ((wndWidth << 1) - lTempWidth); |
|
47720 } |
|
47721 |
|
47722 if(extraRow) |
|
47723 { |
|
47724 dest2 = dest1 - wndWidth; |
|
47725 for(j = 0; j < lWidth; j += 2) |
|
47726 { |
|
47727 *dest1++ = *dest2++; |
|
47728 *dest1++ = *dest2++; |
|
47729 } |
|
47730 if(extraCol) |
|
47731 { |
|
47732 *dest1 = *dest2; |
|
47733 } |
|
47734 } |
|
47735 |
|
47736 free(lBuffer); |
|
47737 return; |
|
47738 } |
|
47739 |
|
47740 /* |
|
47741 ****************************************************************************** |
|
47742 Name : sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_709_RR |
|
47743 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
47744 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
47745 uint8 *dstImage : Pointer to rgb data (o/p). |
|
47746 tWndParam *srcWindow : Pointer to structure containing source window |
|
47747 parameters like xOffset,yOffset,cropWidth, |
|
47748 cropHeight. (i/p) |
|
47749 tWndParam *dstWindow : Pointer to structure containing destination window |
|
47750 parameters like xOffset,yOffset,windWidth, |
|
47751 windHeight. (i/p) |
|
47752 Return Value : void |
|
47753 ****************************************************************************** |
|
47754 */ |
|
47755 |
|
47756 void sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_709_RR |
|
47757 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
47758 tWndParam* srcWindow, tWndParam* dstWindow) |
|
47759 { |
|
47760 uint16 *dest1, *dest2; |
|
47761 uint8 *lYuyvPtr; |
|
47762 uint8 *lBuffer; |
|
47763 uint8 *src1, *src2; |
|
47764 uint8 *lPtr1, *lPtr2; |
|
47765 int32 diff1, diff2, diff3; |
|
47766 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
47767 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
47768 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
47769 int32 i, j, k, extraCol, extraRow; |
|
47770 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
47771 cropWidth,cropHeight,wndWidth,wndHeight; |
|
47772 |
|
47773 srcXOffset = srcWindow->xOffset; |
|
47774 srcYOffset = srcWindow->yOffset; |
|
47775 cropWidth = srcWindow->wndWidth; |
|
47776 cropHeight = srcWindow->wndHeight; |
|
47777 |
|
47778 dstXOffset = dstWindow->xOffset; |
|
47779 dstYOffset = dstWindow->yOffset; |
|
47780 wndWidth = dstWindow->wndWidth; |
|
47781 wndHeight = dstWindow->wndHeight; |
|
47782 |
|
47783 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
47784 { |
|
47785 lWidth = cropWidth; |
|
47786 } |
|
47787 else |
|
47788 { |
|
47789 lWidth = srcImage->width - srcXOffset; |
|
47790 } |
|
47791 |
|
47792 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
47793 { |
|
47794 lHeight = cropHeight; |
|
47795 } |
|
47796 else |
|
47797 { |
|
47798 lHeight = srcImage->height - srcYOffset; |
|
47799 } |
|
47800 |
|
47801 if (lWidth > (wndWidth - dstXOffset)) |
|
47802 { |
|
47803 lWidth = wndWidth - dstXOffset; |
|
47804 } |
|
47805 |
|
47806 if (lHeight > (wndHeight - dstYOffset)) |
|
47807 { |
|
47808 lHeight = wndHeight - dstYOffset; |
|
47809 } |
|
47810 |
|
47811 extraCol = lWidth & 0x01; |
|
47812 extraRow = lHeight & 0x01; |
|
47813 |
|
47814 lTempWidth = lWidth; |
|
47815 lWidth = (lWidth >> 1) << 1; |
|
47816 lHeight = (lHeight >> 1) << 1; |
|
47817 |
|
47818 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
47819 |
|
47820 lSrcWidth = lWidth * 3; |
|
47821 |
|
47822 lLumWidth = (srcImage->width >> 1) << 1; |
|
47823 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
47824 |
|
47825 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
47826 dest2 = dest1 + wndWidth; |
|
47827 |
|
47828 lLumWidth <<= 1; |
|
47829 |
|
47830 for(i = 0; i < lHeight; i += 2) |
|
47831 { |
|
47832 lPtr1 = src1 = lBuffer; |
|
47833 lPtr2 = src2 = src1 + lSrcWidth; |
|
47834 |
|
47835 for(k = 0; k < (lWidth - 2); k += 2) |
|
47836 { |
|
47837 lCb1 = lYuyvPtr[3]; |
|
47838 lCr1 = lYuyvPtr[1]; |
|
47839 |
|
47840 lCb2 = lYuyvPtr[7]; |
|
47841 lCr2 = lYuyvPtr[5]; |
|
47842 |
|
47843 lCr2 = (lCr1 + lCr2) >> 1; |
|
47844 lCb2 = (lCb1 + lCb2) >> 1; |
|
47845 |
|
47846 /*First Pixel*/ |
|
47847 lCb1 -= 128; |
|
47848 lCr1 -= 128; |
|
47849 |
|
47850 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
47851 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47852 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
47853 |
|
47854 lY1 = lYuyvPtr[2]; |
|
47855 lY1 -= 16; |
|
47856 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
47857 |
|
47858 lTemp = lY1 + lTemp1; |
|
47859 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47860 |
|
47861 lTemp = lY1 - lTemp2; |
|
47862 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47863 |
|
47864 lTemp = lY1 + lTemp3; |
|
47865 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47866 |
|
47867 /*Second Pixel*/ |
|
47868 lCb2 -= 128; |
|
47869 lCr2 -= 128; |
|
47870 |
|
47871 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
47872 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
47873 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
47874 |
|
47875 lY1 = lYuyvPtr[0]; |
|
47876 lY1 -= 16; |
|
47877 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
47878 |
|
47879 lTemp = lY1 + lTemp1; |
|
47880 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47881 |
|
47882 lTemp = lY1 - lTemp2; |
|
47883 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47884 |
|
47885 lTemp = lY1 + lTemp3; |
|
47886 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47887 |
|
47888 |
|
47889 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
47890 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
47891 |
|
47892 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
47893 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
47894 |
|
47895 lCr2 = (lCr1 + lCr2) >> 1; |
|
47896 lCb2 = (lCb1 + lCb2) >> 1; |
|
47897 |
|
47898 |
|
47899 /*Third Pixel*/ |
|
47900 lCb1 -= 128; |
|
47901 lCr1 -= 128; |
|
47902 |
|
47903 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
47904 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47905 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
47906 |
|
47907 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
47908 lY1 -= 16; |
|
47909 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
47910 |
|
47911 lTemp = lY1 + lTemp1; |
|
47912 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47913 |
|
47914 lTemp = lY1 - lTemp2; |
|
47915 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47916 |
|
47917 lTemp = lY1 + lTemp3; |
|
47918 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47919 |
|
47920 /*Fourth Pixel*/ |
|
47921 lCb2 -= 128; |
|
47922 lCr2 -= 128; |
|
47923 |
|
47924 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
47925 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
47926 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
47927 |
|
47928 lY1 = lYuyvPtr[lLumWidth]; |
|
47929 lY1 -= 16; |
|
47930 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
47931 |
|
47932 lTemp = lY1 + lTemp1; |
|
47933 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47934 |
|
47935 lTemp = lY1 - lTemp2; |
|
47936 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47937 |
|
47938 lTemp = lY1 + lTemp3; |
|
47939 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47940 |
|
47941 |
|
47942 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
47943 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
47944 |
|
47945 lCb2 = lYuyvPtr[(lLumWidth << 1) + 7]; |
|
47946 lCr2 = lYuyvPtr[(lLumWidth << 1) + 5]; |
|
47947 |
|
47948 lCr2 = (lCr1 + lCr2) >> 1; |
|
47949 lCb2 = (lCb1 + lCb2) >> 1; |
|
47950 |
|
47951 /*Fifth Pixel*/ |
|
47952 lCb1 -= 128; |
|
47953 lCr1 -= 128; |
|
47954 |
|
47955 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
47956 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
47957 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
47958 |
|
47959 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
47960 lY1 -= 16; |
|
47961 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
47962 |
|
47963 lTemp = lY1 + lTemp1; |
|
47964 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47965 |
|
47966 lTemp = lY1 - lTemp2; |
|
47967 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47968 |
|
47969 lTemp = lY1 + lTemp3; |
|
47970 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47971 |
|
47972 /*Sixth Pixel*/ |
|
47973 lCb2 -= 128; |
|
47974 lCr2 -= 128; |
|
47975 |
|
47976 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
47977 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
47978 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
47979 |
|
47980 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
47981 lY1 -= 16; |
|
47982 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
47983 |
|
47984 lTemp = lY1 + lTemp1; |
|
47985 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47986 |
|
47987 lTemp = lY1 - lTemp2; |
|
47988 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47989 |
|
47990 lTemp = lY1 + lTemp3; |
|
47991 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
47992 |
|
47993 lYuyvPtr += 4; |
|
47994 src1 += 6; |
|
47995 src2 += 6; |
|
47996 } |
|
47997 |
|
47998 lCb1 = lYuyvPtr[3]; |
|
47999 lCr1 = lYuyvPtr[1]; |
|
48000 |
|
48001 lCb1 -= 128; |
|
48002 lCr1 -= 128; |
|
48003 |
|
48004 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
48005 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
48006 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
48007 |
|
48008 /*First Pixel*/ |
|
48009 lY1 = lYuyvPtr[2]; |
|
48010 lY1 -= 16; |
|
48011 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48012 |
|
48013 lTemp = lY1 + lTemp1; |
|
48014 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48015 |
|
48016 lTemp = lY1 - lTemp2; |
|
48017 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48018 |
|
48019 lTemp = lY1 + lTemp3; |
|
48020 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48021 |
|
48022 /*Second Pixel*/ |
|
48023 lY1 = lYuyvPtr[0]; |
|
48024 lY1 -= 16; |
|
48025 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48026 |
|
48027 lTemp = lY1 + lTemp1; |
|
48028 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48029 |
|
48030 lTemp = lY1 - lTemp2; |
|
48031 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48032 |
|
48033 lTemp = lY1 + lTemp3; |
|
48034 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48035 |
|
48036 |
|
48037 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
48038 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
48039 |
|
48040 lCb1 -= 128; |
|
48041 lCr1 -= 128; |
|
48042 |
|
48043 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
48044 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
48045 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
48046 |
|
48047 /*Third Pixel*/ |
|
48048 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
48049 lY1 -= 16; |
|
48050 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48051 |
|
48052 lTemp = lY1 + lTemp1; |
|
48053 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48054 |
|
48055 lTemp = lY1 - lTemp2; |
|
48056 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48057 |
|
48058 lTemp = lY1 + lTemp3; |
|
48059 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48060 |
|
48061 /*Fourth Pixel*/ |
|
48062 lY1 = lYuyvPtr[lLumWidth]; |
|
48063 lY1 -= 16; |
|
48064 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48065 |
|
48066 lTemp = lY1 + lTemp1; |
|
48067 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48068 |
|
48069 lTemp = lY1 - lTemp2; |
|
48070 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48071 |
|
48072 lTemp = lY1 + lTemp3; |
|
48073 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48074 |
|
48075 |
|
48076 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
48077 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
48078 |
|
48079 lCb1 -= 128; |
|
48080 lCr1 -= 128; |
|
48081 |
|
48082 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
48083 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
48084 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
48085 |
|
48086 /*Fifth Pixel*/ |
|
48087 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
48088 lY1 -= 16; |
|
48089 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48090 |
|
48091 lTemp = lY1 + lTemp1; |
|
48092 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48093 |
|
48094 lTemp = lY1 - lTemp2; |
|
48095 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48096 |
|
48097 lTemp = lY1 + lTemp3; |
|
48098 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48099 |
|
48100 /*Sixth Pixel*/ |
|
48101 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
48102 lY1 -= 16; |
|
48103 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48104 |
|
48105 lTemp = lY1 + lTemp1; |
|
48106 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48107 |
|
48108 lTemp = lY1 - lTemp2; |
|
48109 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48110 |
|
48111 lTemp = lY1 + lTemp3; |
|
48112 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48113 |
|
48114 lYuyvPtr += 4; |
|
48115 src1 += 6; |
|
48116 src2 += 6; |
|
48117 |
|
48118 |
|
48119 src1 = lPtr1; |
|
48120 src2 = lPtr2; |
|
48121 |
|
48122 for(j = 0; j < lWidth; j += 2) |
|
48123 { |
|
48124 /* First Pixel */ |
|
48125 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
48126 diff1 = *src1 & 0xf; |
|
48127 diff2 = *(src1 + 1) & 0xf; |
|
48128 diff3 = *(src1 + 2) & 0xf; |
|
48129 |
|
48130 // diffuse the error |
|
48131 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
48132 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
48133 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
48134 |
|
48135 /* Second Pixel */ |
|
48136 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
48137 diff1 = *(src1 + 3) & 0xf; |
|
48138 diff2 = *(src1 + 4) & 0xf; |
|
48139 diff3 = *(src1 + 5) & 0xf; |
|
48140 // diffuse the error |
|
48141 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
48142 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
48143 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
48144 |
|
48145 src1 += 6; |
|
48146 dest1 += 2; |
|
48147 |
|
48148 /* Third Pixel */ |
|
48149 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
48150 diff1 = *src2 & 0xf; |
|
48151 diff2 = *(src2 + 1) & 0xf; |
|
48152 diff3 = *(src2 + 2) & 0xf; |
|
48153 //diffuse the error |
|
48154 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
48155 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
48156 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
48157 |
|
48158 /* Fourth Pixel */ |
|
48159 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
48160 diff1 = *(src2 + 3) & 0xf; |
|
48161 diff2 = *(src2 + 4) & 0xf; |
|
48162 diff3 = *(src2 + 5) & 0xf; |
|
48163 //diffuse the error |
|
48164 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
48165 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
48166 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
48167 |
|
48168 src2 += 6; |
|
48169 dest2 += 2; |
|
48170 } |
|
48171 if(extraCol) |
|
48172 { |
|
48173 *dest1 = dest1[-1]; |
|
48174 dest1++; |
|
48175 *dest2 = dest2[-1]; |
|
48176 dest2++; |
|
48177 } |
|
48178 |
|
48179 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
48180 |
|
48181 dest1 += ((wndWidth << 1) - lTempWidth); |
|
48182 dest2 += ((wndWidth << 1) - lTempWidth); |
|
48183 } |
|
48184 |
|
48185 if(extraRow) |
|
48186 { |
|
48187 dest2 = dest1 - wndWidth; |
|
48188 for(j = 0; j < lWidth; j += 2) |
|
48189 { |
|
48190 *dest1++ = *dest2++; |
|
48191 *dest1++ = *dest2++; |
|
48192 } |
|
48193 if(extraCol) |
|
48194 { |
|
48195 *dest1 = *dest2; |
|
48196 } |
|
48197 } |
|
48198 |
|
48199 free(lBuffer); |
|
48200 return; |
|
48201 } |
|
48202 |
|
48203 /* |
|
48204 ****************************************************************************** |
|
48205 Name : sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_601_5_RR |
|
48206 Description : Converts YUV422 LE (YVYU) Chroma2 Interleaved to XRGB (4:4:4:4) Interleaved format. |
|
48207 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
48208 uint8 *dstImage : Pointer to rgb data (o/p). |
|
48209 tWndParam *srcWindow : Pointer to structure containing source window |
|
48210 parameters like xOffset,yOffset,cropWidth, |
|
48211 cropHeight. (i/p) |
|
48212 tWndParam *dstWindow : Pointer to structure containing destination window |
|
48213 parameters like xOffset,yOffset,windWidth, |
|
48214 windHeight. (i/p) |
|
48215 Return Value : void |
|
48216 ****************************************************************************** |
|
48217 */ |
|
48218 |
|
48219 void sEmz_VDec_YUV422LEChr1toColor4k_ErrDiff_601_5_RR |
|
48220 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
48221 tWndParam* srcWindow, tWndParam* dstWindow) |
|
48222 { |
|
48223 uint16 *dest1, *dest2; |
|
48224 uint8 *lYuyvPtr; |
|
48225 uint8 *lBuffer; |
|
48226 uint8 *src1, *src2; |
|
48227 uint8 *lPtr1, *lPtr2; |
|
48228 int32 diff1, diff2, diff3; |
|
48229 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
48230 int32 lY1, lCr1, lCb1, lCr2, lCb2; |
|
48231 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
48232 int32 i, j, k, extraCol, extraRow; |
|
48233 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
48234 cropWidth,cropHeight,wndWidth,wndHeight; |
|
48235 |
|
48236 srcXOffset = srcWindow->xOffset; |
|
48237 srcYOffset = srcWindow->yOffset; |
|
48238 cropWidth = srcWindow->wndWidth; |
|
48239 cropHeight = srcWindow->wndHeight; |
|
48240 |
|
48241 dstXOffset = dstWindow->xOffset; |
|
48242 dstYOffset = dstWindow->yOffset; |
|
48243 wndWidth = dstWindow->wndWidth; |
|
48244 wndHeight = dstWindow->wndHeight; |
|
48245 |
|
48246 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
48247 { |
|
48248 lWidth = cropWidth; |
|
48249 } |
|
48250 else |
|
48251 { |
|
48252 lWidth = srcImage->width - srcXOffset; |
|
48253 } |
|
48254 |
|
48255 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
48256 { |
|
48257 lHeight = cropHeight; |
|
48258 } |
|
48259 else |
|
48260 { |
|
48261 lHeight = srcImage->height - srcYOffset; |
|
48262 } |
|
48263 |
|
48264 if (lWidth > (wndWidth - dstXOffset)) |
|
48265 { |
|
48266 lWidth = wndWidth - dstXOffset; |
|
48267 } |
|
48268 |
|
48269 if (lHeight > (wndHeight - dstYOffset)) |
|
48270 { |
|
48271 lHeight = wndHeight - dstYOffset; |
|
48272 } |
|
48273 |
|
48274 extraCol = lWidth & 0x01; |
|
48275 extraRow = lHeight & 0x01; |
|
48276 |
|
48277 lTempWidth = lWidth; |
|
48278 lWidth = (lWidth >> 1) << 1; |
|
48279 lHeight = (lHeight >> 1) << 1; |
|
48280 |
|
48281 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
48282 |
|
48283 lSrcWidth = lWidth * 3; |
|
48284 |
|
48285 lLumWidth = (srcImage->width >> 1) << 1; |
|
48286 lYuyvPtr = srcImage->lum + (srcYOffset * (lLumWidth << 1)) + (srcXOffset << 1); |
|
48287 |
|
48288 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
48289 dest2 = dest1 + wndWidth; |
|
48290 |
|
48291 lLumWidth <<= 1; |
|
48292 |
|
48293 for(i = 0; i < lHeight; i += 2) |
|
48294 { |
|
48295 lPtr1 = src1 = lBuffer; |
|
48296 lPtr2 = src2 = src1 + lSrcWidth; |
|
48297 |
|
48298 for(k = 0; k < (lWidth - 2); k += 2) |
|
48299 { |
|
48300 lCb1 = lYuyvPtr[3]; |
|
48301 lCr1 = lYuyvPtr[1]; |
|
48302 |
|
48303 lCb2 = lYuyvPtr[7]; |
|
48304 lCr2 = lYuyvPtr[5]; |
|
48305 |
|
48306 lCr2 = (lCr1 + lCr2) >> 1; |
|
48307 lCb2 = (lCb1 + lCb2) >> 1; |
|
48308 |
|
48309 /*First Pixel*/ |
|
48310 lCb1 -= 128; |
|
48311 lCr1 -= 128; |
|
48312 |
|
48313 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
48314 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
48315 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
48316 |
|
48317 lY1 = lYuyvPtr[2]; |
|
48318 lY1 -= 16; |
|
48319 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48320 |
|
48321 lTemp = lY1 + lTemp1; |
|
48322 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48323 |
|
48324 lTemp = lY1 - lTemp2; |
|
48325 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48326 |
|
48327 lTemp = lY1 + lTemp3; |
|
48328 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48329 |
|
48330 /*Second Pixel*/ |
|
48331 lCb2 -= 128; |
|
48332 lCr2 -= 128; |
|
48333 |
|
48334 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
48335 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
48336 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
48337 |
|
48338 lY1 = lYuyvPtr[0]; |
|
48339 lY1 -= 16; |
|
48340 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48341 |
|
48342 lTemp = lY1 + lTemp1; |
|
48343 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48344 |
|
48345 lTemp = lY1 - lTemp2; |
|
48346 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48347 |
|
48348 lTemp = lY1 + lTemp3; |
|
48349 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48350 |
|
48351 |
|
48352 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
48353 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
48354 |
|
48355 lCb2 = lYuyvPtr[lLumWidth + 7]; |
|
48356 lCr2 = lYuyvPtr[lLumWidth + 5]; |
|
48357 |
|
48358 lCr2 = (lCr1 + lCr2) >> 1; |
|
48359 lCb2 = (lCb1 + lCb2) >> 1; |
|
48360 |
|
48361 |
|
48362 /*Third Pixel*/ |
|
48363 lCb1 -= 128; |
|
48364 lCr1 -= 128; |
|
48365 |
|
48366 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
48367 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
48368 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
48369 |
|
48370 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
48371 lY1 -= 16; |
|
48372 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48373 |
|
48374 lTemp = lY1 + lTemp1; |
|
48375 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48376 |
|
48377 lTemp = lY1 - lTemp2; |
|
48378 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48379 |
|
48380 lTemp = lY1 + lTemp3; |
|
48381 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48382 |
|
48383 /*Fourth Pixel*/ |
|
48384 lCb2 -= 128; |
|
48385 lCr2 -= 128; |
|
48386 |
|
48387 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
48388 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
48389 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
48390 |
|
48391 lY1 = lYuyvPtr[lLumWidth]; |
|
48392 lY1 -= 16; |
|
48393 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48394 |
|
48395 lTemp = lY1 + lTemp1; |
|
48396 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48397 |
|
48398 lTemp = lY1 - lTemp2; |
|
48399 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48400 |
|
48401 lTemp = lY1 + lTemp3; |
|
48402 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48403 |
|
48404 |
|
48405 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
48406 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
48407 |
|
48408 lCb2 = lYuyvPtr[(lLumWidth << 1) + 7]; |
|
48409 lCr2 = lYuyvPtr[(lLumWidth << 1) + 5]; |
|
48410 |
|
48411 lCr2 = (lCr1 + lCr2) >> 1; |
|
48412 lCb2 = (lCb1 + lCb2) >> 1; |
|
48413 |
|
48414 /*Fifth Pixel*/ |
|
48415 lCb1 -= 128; |
|
48416 lCr1 -= 128; |
|
48417 |
|
48418 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
48419 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
48420 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
48421 |
|
48422 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
48423 lY1 -= 16; |
|
48424 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48425 |
|
48426 lTemp = lY1 + lTemp1; |
|
48427 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48428 |
|
48429 lTemp = lY1 - lTemp2; |
|
48430 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48431 |
|
48432 lTemp = lY1 + lTemp3; |
|
48433 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48434 |
|
48435 /*Sixth Pixel*/ |
|
48436 lCb2 -= 128; |
|
48437 lCr2 -= 128; |
|
48438 |
|
48439 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
48440 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
48441 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
48442 |
|
48443 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
48444 lY1 -= 16; |
|
48445 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48446 |
|
48447 lTemp = lY1 + lTemp1; |
|
48448 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48449 |
|
48450 lTemp = lY1 - lTemp2; |
|
48451 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48452 |
|
48453 lTemp = lY1 + lTemp3; |
|
48454 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48455 |
|
48456 lYuyvPtr += 4; |
|
48457 src1 += 6; |
|
48458 src2 += 6; |
|
48459 } |
|
48460 |
|
48461 lCb1 = lYuyvPtr[3]; |
|
48462 lCr1 = lYuyvPtr[1]; |
|
48463 |
|
48464 lCb1 -= 128; |
|
48465 lCr1 -= 128; |
|
48466 |
|
48467 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
48468 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
48469 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
48470 |
|
48471 /*First Pixel*/ |
|
48472 lY1 = lYuyvPtr[2]; |
|
48473 lY1 -= 16; |
|
48474 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48475 |
|
48476 lTemp = lY1 + lTemp1; |
|
48477 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48478 |
|
48479 lTemp = lY1 - lTemp2; |
|
48480 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48481 |
|
48482 lTemp = lY1 + lTemp3; |
|
48483 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48484 |
|
48485 /*Second Pixel*/ |
|
48486 lY1 = lYuyvPtr[0]; |
|
48487 lY1 -= 16; |
|
48488 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48489 |
|
48490 lTemp = lY1 + lTemp1; |
|
48491 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48492 |
|
48493 lTemp = lY1 - lTemp2; |
|
48494 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48495 |
|
48496 lTemp = lY1 + lTemp3; |
|
48497 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48498 |
|
48499 |
|
48500 lCb1 = lYuyvPtr[lLumWidth + 3]; |
|
48501 lCr1 = lYuyvPtr[lLumWidth + 1]; |
|
48502 |
|
48503 lCb1 -= 128; |
|
48504 lCr1 -= 128; |
|
48505 |
|
48506 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
48507 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
48508 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
48509 |
|
48510 /*Third Pixel*/ |
|
48511 lY1 = lYuyvPtr[lLumWidth + 2]; |
|
48512 lY1 -= 16; |
|
48513 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48514 |
|
48515 lTemp = lY1 + lTemp1; |
|
48516 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48517 |
|
48518 lTemp = lY1 - lTemp2; |
|
48519 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48520 |
|
48521 lTemp = lY1 + lTemp3; |
|
48522 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48523 |
|
48524 /*Fourth Pixel*/ |
|
48525 lY1 = lYuyvPtr[lLumWidth]; |
|
48526 lY1 -= 16; |
|
48527 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48528 |
|
48529 lTemp = lY1 + lTemp1; |
|
48530 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48531 |
|
48532 lTemp = lY1 - lTemp2; |
|
48533 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48534 |
|
48535 lTemp = lY1 + lTemp3; |
|
48536 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48537 |
|
48538 |
|
48539 lCb1 = lYuyvPtr[(lLumWidth << 1) + 3]; |
|
48540 lCr1 = lYuyvPtr[(lLumWidth << 1) + 1]; |
|
48541 |
|
48542 lCb1 -= 128; |
|
48543 lCr1 -= 128; |
|
48544 |
|
48545 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
48546 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
48547 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
48548 |
|
48549 /*Fifth Pixel*/ |
|
48550 lY1 = lYuyvPtr[(lLumWidth << 1) + 2]; |
|
48551 lY1 -= 16; |
|
48552 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48553 |
|
48554 lTemp = lY1 + lTemp1; |
|
48555 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48556 |
|
48557 lTemp = lY1 - lTemp2; |
|
48558 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48559 |
|
48560 lTemp = lY1 + lTemp3; |
|
48561 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48562 |
|
48563 /*Sixth Pixel*/ |
|
48564 lY1 = lYuyvPtr[(lLumWidth << 1)]; |
|
48565 lY1 -= 16; |
|
48566 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
48567 |
|
48568 lTemp = lY1 + lTemp1; |
|
48569 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48570 |
|
48571 lTemp = lY1 - lTemp2; |
|
48572 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48573 |
|
48574 lTemp = lY1 + lTemp3; |
|
48575 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
48576 |
|
48577 lYuyvPtr += 4; |
|
48578 src1 += 6; |
|
48579 src2 += 6; |
|
48580 |
|
48581 |
|
48582 src1 = lPtr1; |
|
48583 src2 = lPtr2; |
|
48584 |
|
48585 for(j = 0; j < lWidth; j += 2) |
|
48586 { |
|
48587 /* First Pixel */ |
|
48588 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
48589 diff1 = *src1 & 0xf; |
|
48590 diff2 = *(src1 + 1) & 0xf; |
|
48591 diff3 = *(src1 + 2) & 0xf; |
|
48592 |
|
48593 // diffuse the error |
|
48594 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
48595 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
48596 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
48597 |
|
48598 /* Second Pixel */ |
|
48599 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
48600 diff1 = *(src1 + 3) & 0xf; |
|
48601 diff2 = *(src1 + 4) & 0xf; |
|
48602 diff3 = *(src1 + 5) & 0xf; |
|
48603 // diffuse the error |
|
48604 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
48605 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
48606 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
48607 |
|
48608 src1 += 6; |
|
48609 dest1 += 2; |
|
48610 |
|
48611 /* Third Pixel */ |
|
48612 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
48613 diff1 = *src2 & 0xf; |
|
48614 diff2 = *(src2 + 1) & 0xf; |
|
48615 diff3 = *(src2 + 2) & 0xf; |
|
48616 //diffuse the error |
|
48617 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
48618 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
48619 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
48620 |
|
48621 /* Fourth Pixel */ |
|
48622 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
48623 diff1 = *(src2 + 3) & 0xf; |
|
48624 diff2 = *(src2 + 4) & 0xf; |
|
48625 diff3 = *(src2 + 5) & 0xf; |
|
48626 //diffuse the error |
|
48627 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
48628 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
48629 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
48630 |
|
48631 src2 += 6; |
|
48632 dest2 += 2; |
|
48633 } |
|
48634 if(extraCol) |
|
48635 { |
|
48636 *dest1 = dest1[-1]; |
|
48637 dest1++; |
|
48638 *dest2 = dest2[-1]; |
|
48639 dest2++; |
|
48640 } |
|
48641 |
|
48642 lYuyvPtr += ((lLumWidth - lWidth) << 1); |
|
48643 |
|
48644 dest1 += ((wndWidth << 1) - lTempWidth); |
|
48645 dest2 += ((wndWidth << 1) - lTempWidth); |
|
48646 } |
|
48647 |
|
48648 if(extraRow) |
|
48649 { |
|
48650 dest2 = dest1 - wndWidth; |
|
48651 for(j = 0; j < lWidth; j += 2) |
|
48652 { |
|
48653 *dest1++ = *dest2++; |
|
48654 *dest1++ = *dest2++; |
|
48655 } |
|
48656 if(extraCol) |
|
48657 { |
|
48658 *dest1 = *dest2; |
|
48659 } |
|
48660 } |
|
48661 |
|
48662 free(lBuffer); |
|
48663 return; |
|
48664 } |
|
48665 |
|
48666 |
|
48667 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
48668 /**************** End of Chroma1 format *********************/ |
|
48669 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
48670 |
|
48671 |
|
48672 |
|
48673 |
|
48674 |
|
48675 |
|
48676 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
48677 /**************** Start of Chroma3 format *******************/ |
|
48678 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
48679 |
|
48680 |
|
48681 /* |
|
48682 ****************************************************************************** |
|
48683 Name : sEmz_VDec_YUV420Chr3toColor64k_Ordered_709_FR |
|
48684 Description : Converts YUV420 Chroma3 Planar to RGB565 Interleaved format |
|
48685 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
48686 uint8 *dstImage : Pointer to rgb data (o/p). |
|
48687 tWndParam *srcWindow : Pointer to structure containing source window |
|
48688 parameters like xOffset,yOffset,cropWidth, |
|
48689 cropHeight. (i/p) |
|
48690 tWndParam *dstWindow : Pointer to structure containing destination window |
|
48691 parameters like xOffset,yOffset,windWidth, |
|
48692 windHeight. (i/p) |
|
48693 Return Value : void |
|
48694 ****************************************************************************** |
|
48695 */ |
|
48696 |
|
48697 void sEmz_VDec_YUV420Chr3toColor64k_Ordered_709_FR |
|
48698 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
48699 tWndParam* srcWindow, tWndParam* dstWindow) |
|
48700 { |
|
48701 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
48702 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
48703 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
48704 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
48705 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
48706 int32 i, j, extraRow, extraCol; |
|
48707 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
48708 cropWidth,cropHeight,wndWidth,wndHeight; |
|
48709 |
|
48710 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
48711 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
48712 |
|
48713 | {0,3,2} {4,0,6} | |
|
48714 | {6,1,4} {2,2,0} | */ |
|
48715 |
|
48716 srcXOffset = srcWindow->xOffset; |
|
48717 srcYOffset = srcWindow->yOffset; |
|
48718 cropWidth = srcWindow->wndWidth; |
|
48719 cropHeight = srcWindow->wndHeight; |
|
48720 |
|
48721 dstXOffset = dstWindow->xOffset; |
|
48722 dstYOffset = dstWindow->yOffset; |
|
48723 wndWidth = dstWindow->wndWidth; |
|
48724 wndHeight = dstWindow->wndHeight; |
|
48725 |
|
48726 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
48727 { |
|
48728 lWidth = cropWidth; |
|
48729 } |
|
48730 else |
|
48731 { |
|
48732 lWidth = srcImage->width - srcXOffset; |
|
48733 } |
|
48734 |
|
48735 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
48736 { |
|
48737 lHeight = cropHeight; |
|
48738 } |
|
48739 else |
|
48740 { |
|
48741 lHeight = srcImage->height - srcYOffset; |
|
48742 } |
|
48743 |
|
48744 if (lWidth > (wndWidth - dstXOffset)) |
|
48745 { |
|
48746 lWidth = wndWidth - dstXOffset; |
|
48747 } |
|
48748 |
|
48749 if (lHeight > (wndHeight - dstYOffset)) |
|
48750 { |
|
48751 lHeight = wndHeight - dstYOffset; |
|
48752 } |
|
48753 |
|
48754 extraCol = lWidth & 0x01; |
|
48755 extraRow = lHeight & 0x01; |
|
48756 |
|
48757 lTempWidth = lWidth; |
|
48758 lWidth = (lWidth >> 1) << 1; |
|
48759 lHeight = (lHeight >> 1) << 1; |
|
48760 |
|
48761 lLumWidth = (srcImage->width >> 1) << 1; |
|
48762 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
48763 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
48764 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
48765 |
|
48766 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
48767 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
48768 |
|
48769 for(i = 0; i < (lHeight - 2); i += 2) |
|
48770 { |
|
48771 for(j = 0; j < (lWidth - 2); j += 2) |
|
48772 { |
|
48773 lCr1 = lCrPtr[j >> 1]; |
|
48774 lCb1 = lCbPtr[j >> 1]; |
|
48775 |
|
48776 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
48777 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
48778 |
|
48779 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
48780 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
48781 |
|
48782 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
48783 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
48784 |
|
48785 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
48786 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
48787 |
|
48788 lCr2 = (lCr1 + lCr2) >> 1; |
|
48789 lCb2 = (lCb1 + lCb2) >> 1; |
|
48790 |
|
48791 lCr3 = (lCr1 + lCr3) >> 1; |
|
48792 lCb3 = (lCb1 + lCb3) >> 1; |
|
48793 |
|
48794 /*First Pixel*/ |
|
48795 lCr1 -= 128; |
|
48796 lCb1 -= 128; |
|
48797 |
|
48798 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
48799 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
48800 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
48801 |
|
48802 lY1 = lLumPtr[j]; |
|
48803 |
|
48804 /*B component*/ |
|
48805 lTemp = lY1 + lTemp3; |
|
48806 if (lTemp < 0) |
|
48807 lTemp = 0; |
|
48808 if (lTemp > 255) |
|
48809 lTemp = 255; |
|
48810 lTemp4 = (lTemp >> 3); |
|
48811 |
|
48812 /*G component*/ |
|
48813 lTemp = lY1 - lTemp2 + 3; |
|
48814 if (lTemp < 0) |
|
48815 lTemp = 0; |
|
48816 if (lTemp > 255) |
|
48817 lTemp = 255; |
|
48818 lTemp4 |= (lTemp >> 2) << 5; |
|
48819 |
|
48820 /*R component*/ |
|
48821 lTemp = lY1 + lTemp1 + 2; |
|
48822 if (lTemp < 0) |
|
48823 lTemp = 0; |
|
48824 if (lTemp > 255) |
|
48825 lTemp = 255; |
|
48826 lTemp4 |= (lTemp >> 3) << 11; |
|
48827 |
|
48828 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
48829 |
|
48830 /*Second Pixel*/ |
|
48831 lCr2 -= 128; |
|
48832 lCb2 -= 128; |
|
48833 |
|
48834 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
48835 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
48836 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
48837 |
|
48838 lY1 = lLumPtr[j + 1]; |
|
48839 |
|
48840 /*B component*/ |
|
48841 lTemp = lY1 + lTemp3 + 4; |
|
48842 if (lTemp < 0) |
|
48843 lTemp = 0; |
|
48844 if (lTemp > 255) |
|
48845 lTemp = 255; |
|
48846 lTemp4 = (lTemp >> 3); |
|
48847 |
|
48848 /*G component*/ |
|
48849 lTemp = lY1 - lTemp2; |
|
48850 if (lTemp < 0) |
|
48851 lTemp = 0; |
|
48852 if (lTemp > 255) |
|
48853 lTemp = 255; |
|
48854 lTemp4 |= (lTemp >> 2) << 5; |
|
48855 |
|
48856 /*R component*/ |
|
48857 lTemp = lY1 + lTemp1 + 6; |
|
48858 if (lTemp < 0) |
|
48859 lTemp = 0; |
|
48860 if (lTemp > 255) |
|
48861 lTemp = 255; |
|
48862 lTemp4 |= (lTemp >> 3) << 11; |
|
48863 |
|
48864 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
48865 |
|
48866 |
|
48867 /*Third Pixel*/ |
|
48868 lCr3 -= 128; |
|
48869 lCb3 -= 128; |
|
48870 |
|
48871 lTemp1 = (25801 * lCr3) >> COLOR_CONV_PRECISION; |
|
48872 lTemp2 = ((3072 * lCb3) + (7670 * lCr3)) >> COLOR_CONV_PRECISION; |
|
48873 lTemp3 = (30397 * lCb3) >> COLOR_CONV_PRECISION; |
|
48874 |
|
48875 lY1 = lLumPtr[j + lLumWidth]; |
|
48876 |
|
48877 /*B component*/ |
|
48878 lTemp = lY1 + lTemp3 + 6; |
|
48879 if (lTemp < 0) |
|
48880 lTemp = 0; |
|
48881 if (lTemp > 255) |
|
48882 lTemp = 255; |
|
48883 lTemp4 = (lTemp >> 3); |
|
48884 |
|
48885 /*G component*/ |
|
48886 lTemp = lY1 - lTemp2 + 1; |
|
48887 if (lTemp < 0) |
|
48888 lTemp = 0; |
|
48889 if (lTemp > 255) |
|
48890 lTemp = 255; |
|
48891 lTemp4 |= (lTemp >> 2) << 5; |
|
48892 |
|
48893 /*R component*/ |
|
48894 lTemp = lY1 + lTemp1 + 4; |
|
48895 if (lTemp < 0) |
|
48896 lTemp = 0; |
|
48897 if (lTemp > 255) |
|
48898 lTemp = 255; |
|
48899 lTemp4 |= (lTemp >> 3) << 11; |
|
48900 |
|
48901 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
48902 |
|
48903 /*Fourth Pixel*/ |
|
48904 lCr4 -= 128; |
|
48905 lCb4 -= 128; |
|
48906 |
|
48907 lTemp1 = (25801 * lCr4) >> COLOR_CONV_PRECISION; |
|
48908 lTemp2 = ((3072 * lCb4) + (7670 * lCr4)) >> COLOR_CONV_PRECISION; |
|
48909 lTemp3 = (30397 * lCb4) >> COLOR_CONV_PRECISION; |
|
48910 |
|
48911 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
48912 |
|
48913 /*B component*/ |
|
48914 lTemp = lY1 + lTemp3 + 2; |
|
48915 if (lTemp < 0) |
|
48916 lTemp = 0; |
|
48917 if (lTemp > 255) |
|
48918 lTemp = 255; |
|
48919 lTemp4 = (lTemp >> 3); |
|
48920 |
|
48921 /*G component*/ |
|
48922 lTemp = lY1 - lTemp2 + 2; |
|
48923 if (lTemp < 0) |
|
48924 lTemp = 0; |
|
48925 if (lTemp > 255) |
|
48926 lTemp = 255; |
|
48927 lTemp4 |= (lTemp >> 2) << 5; |
|
48928 |
|
48929 /*R component*/ |
|
48930 lTemp = lY1 + lTemp1; |
|
48931 if (lTemp < 0) |
|
48932 lTemp = 0; |
|
48933 if (lTemp > 255) |
|
48934 lTemp = 255; |
|
48935 lTemp4 |= (lTemp >> 3) << 11; |
|
48936 |
|
48937 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
48938 |
|
48939 lRGBFramePtr += 2; |
|
48940 lRGBFramePtr1 += 2; |
|
48941 } |
|
48942 |
|
48943 |
|
48944 lCr1 = lCrPtr[j >> 1]; |
|
48945 lCb1 = lCbPtr[j >> 1]; |
|
48946 |
|
48947 lCr1 -= 128; |
|
48948 lCb1 -= 128; |
|
48949 |
|
48950 /*First Pixel*/ |
|
48951 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
48952 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
48953 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
48954 |
|
48955 lY1 = lLumPtr[j]; |
|
48956 |
|
48957 /*B component*/ |
|
48958 lTemp = lY1 + lTemp3; |
|
48959 if (lTemp < 0) |
|
48960 lTemp = 0; |
|
48961 if (lTemp > 255) |
|
48962 lTemp = 255; |
|
48963 lTemp4 = (lTemp >> 3); |
|
48964 |
|
48965 /*G component*/ |
|
48966 lTemp = lY1 - lTemp2 + 3; |
|
48967 if (lTemp < 0) |
|
48968 lTemp = 0; |
|
48969 if (lTemp > 255) |
|
48970 lTemp = 255; |
|
48971 lTemp4 |= (lTemp >> 2) << 5; |
|
48972 |
|
48973 /*R component*/ |
|
48974 lTemp = lY1 + lTemp1 + 2; |
|
48975 if (lTemp < 0) |
|
48976 lTemp = 0; |
|
48977 if (lTemp > 255) |
|
48978 lTemp = 255; |
|
48979 lTemp4 |= (lTemp >> 3) << 11; |
|
48980 |
|
48981 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
48982 |
|
48983 /*Second Pixel*/ |
|
48984 lY1 = lLumPtr[j + 1]; |
|
48985 |
|
48986 /*B component*/ |
|
48987 lTemp = lY1 + lTemp3 + 4; |
|
48988 if (lTemp < 0) |
|
48989 lTemp = 0; |
|
48990 if (lTemp > 255) |
|
48991 lTemp = 255; |
|
48992 lTemp4 = (lTemp >> 3); |
|
48993 |
|
48994 /*G component*/ |
|
48995 lTemp = lY1 - lTemp2; |
|
48996 if (lTemp < 0) |
|
48997 lTemp = 0; |
|
48998 if (lTemp > 255) |
|
48999 lTemp = 255; |
|
49000 lTemp4 |= (lTemp >> 2) << 5; |
|
49001 |
|
49002 /*R component*/ |
|
49003 lTemp = lY1 + lTemp1 + 6; |
|
49004 if (lTemp < 0) |
|
49005 lTemp = 0; |
|
49006 if (lTemp > 255) |
|
49007 lTemp = 255; |
|
49008 lTemp4 |= (lTemp >> 3) << 11; |
|
49009 |
|
49010 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
49011 |
|
49012 |
|
49013 /*Third Pixel*/ |
|
49014 lY1 = lLumPtr[j + lLumWidth]; |
|
49015 |
|
49016 /*B component*/ |
|
49017 lTemp = lY1 + lTemp3 + 6; |
|
49018 if (lTemp < 0) |
|
49019 lTemp = 0; |
|
49020 if (lTemp > 255) |
|
49021 lTemp = 255; |
|
49022 lTemp4 = (lTemp >> 3); |
|
49023 |
|
49024 /*G component*/ |
|
49025 lTemp = lY1 - lTemp2 + 1; |
|
49026 if (lTemp < 0) |
|
49027 lTemp = 0; |
|
49028 if (lTemp > 255) |
|
49029 lTemp = 255; |
|
49030 lTemp4 |= (lTemp >> 2) << 5; |
|
49031 |
|
49032 /*R component*/ |
|
49033 lTemp = lY1 + lTemp1 + 4; |
|
49034 if (lTemp < 0) |
|
49035 lTemp = 0; |
|
49036 if (lTemp > 255) |
|
49037 lTemp = 255; |
|
49038 lTemp4 |= (lTemp >> 3) << 11; |
|
49039 |
|
49040 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
49041 |
|
49042 /*Fourth Pixel*/ |
|
49043 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
49044 |
|
49045 /*B component*/ |
|
49046 lTemp = lY1 + lTemp3 + 2; |
|
49047 if (lTemp < 0) |
|
49048 lTemp = 0; |
|
49049 if (lTemp > 255) |
|
49050 lTemp = 255; |
|
49051 lTemp4 = (lTemp >> 3); |
|
49052 |
|
49053 /*G component*/ |
|
49054 lTemp = lY1 - lTemp2 + 2; |
|
49055 if (lTemp < 0) |
|
49056 lTemp = 0; |
|
49057 if (lTemp > 255) |
|
49058 lTemp = 255; |
|
49059 lTemp4 |= (lTemp >> 2) << 5; |
|
49060 |
|
49061 /*R component*/ |
|
49062 lTemp = lY1 + lTemp1; |
|
49063 if (lTemp < 0) |
|
49064 lTemp = 0; |
|
49065 if (lTemp > 255) |
|
49066 lTemp = 255; |
|
49067 lTemp4 |= (lTemp >> 3) << 11; |
|
49068 |
|
49069 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
49070 |
|
49071 lRGBFramePtr += 2; |
|
49072 lRGBFramePtr1 += 2; |
|
49073 |
|
49074 if(extraCol) |
|
49075 { |
|
49076 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
49077 lRGBFramePtr++; |
|
49078 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
49079 lRGBFramePtr1++; |
|
49080 } |
|
49081 |
|
49082 lLumPtr += (lLumWidth << 1); |
|
49083 lCrPtr += (lLumWidth >> 1); |
|
49084 lCbPtr += (lLumWidth >> 1); |
|
49085 |
|
49086 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
49087 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
49088 } |
|
49089 |
|
49090 |
|
49091 for(j = 0; j < lWidth; j += 2) |
|
49092 { |
|
49093 lCr1 = lCrPtr[j >> 1]; |
|
49094 lCb1 = lCbPtr[j >> 1]; |
|
49095 |
|
49096 lCr1 -= 128; |
|
49097 lCb1 -= 128; |
|
49098 |
|
49099 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
49100 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
49101 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
49102 |
|
49103 /*First Pixel*/ |
|
49104 lY1 = lLumPtr[j]; |
|
49105 |
|
49106 /*B component*/ |
|
49107 lTemp = lY1 + lTemp3; |
|
49108 if (lTemp < 0) |
|
49109 lTemp = 0; |
|
49110 if (lTemp > 255) |
|
49111 lTemp = 255; |
|
49112 lTemp4 = (lTemp >> 3); |
|
49113 |
|
49114 /*G component*/ |
|
49115 lTemp = lY1 - lTemp2 + 3; |
|
49116 if (lTemp < 0) |
|
49117 lTemp = 0; |
|
49118 if (lTemp > 255) |
|
49119 lTemp = 255; |
|
49120 lTemp4 |= (lTemp >> 2) << 5; |
|
49121 |
|
49122 /*R component*/ |
|
49123 lTemp = lY1 + lTemp1 + 2; |
|
49124 if (lTemp < 0) |
|
49125 lTemp = 0; |
|
49126 if (lTemp > 255) |
|
49127 lTemp = 255; |
|
49128 lTemp4 |= (lTemp >> 3) << 11; |
|
49129 |
|
49130 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
49131 |
|
49132 /*Second Pixel*/ |
|
49133 lY1 = lLumPtr[j + 1]; |
|
49134 |
|
49135 /*B component*/ |
|
49136 lTemp = lY1 + lTemp3 + 4; |
|
49137 if (lTemp < 0) |
|
49138 lTemp = 0; |
|
49139 if (lTemp > 255) |
|
49140 lTemp = 255; |
|
49141 lTemp4 = (lTemp >> 3); |
|
49142 |
|
49143 /*G component*/ |
|
49144 lTemp = lY1 - lTemp2; |
|
49145 if (lTemp < 0) |
|
49146 lTemp = 0; |
|
49147 if (lTemp > 255) |
|
49148 lTemp = 255; |
|
49149 lTemp4 |= (lTemp >> 2) << 5; |
|
49150 |
|
49151 /*R component*/ |
|
49152 lTemp = lY1 + lTemp1 + 6; |
|
49153 if (lTemp < 0) |
|
49154 lTemp = 0; |
|
49155 if (lTemp > 255) |
|
49156 lTemp = 255; |
|
49157 lTemp4 |= (lTemp >> 3) << 11; |
|
49158 |
|
49159 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
49160 |
|
49161 |
|
49162 /*Third Pixel*/ |
|
49163 lY1 = lLumPtr[j + lLumWidth]; |
|
49164 |
|
49165 /*B component*/ |
|
49166 lTemp = lY1 + lTemp3 + 6; |
|
49167 if (lTemp < 0) |
|
49168 lTemp = 0; |
|
49169 if (lTemp > 255) |
|
49170 lTemp = 255; |
|
49171 lTemp4 = (lTemp >> 3); |
|
49172 |
|
49173 /*G component*/ |
|
49174 lTemp = lY1 - lTemp2 + 1; |
|
49175 if (lTemp < 0) |
|
49176 lTemp = 0; |
|
49177 if (lTemp > 255) |
|
49178 lTemp = 255; |
|
49179 lTemp4 |= (lTemp >> 2) << 5; |
|
49180 |
|
49181 /*R component*/ |
|
49182 lTemp = lY1 + lTemp1 + 4; |
|
49183 if (lTemp < 0) |
|
49184 lTemp = 0; |
|
49185 if (lTemp > 255) |
|
49186 lTemp = 255; |
|
49187 lTemp4 |= (lTemp >> 3) << 11; |
|
49188 |
|
49189 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
49190 |
|
49191 /*Fourth Pixel*/ |
|
49192 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
49193 |
|
49194 /*B component*/ |
|
49195 lTemp = lY1 + lTemp3 + 2; |
|
49196 if (lTemp < 0) |
|
49197 lTemp = 0; |
|
49198 if (lTemp > 255) |
|
49199 lTemp = 255; |
|
49200 lTemp4 = (lTemp >> 3); |
|
49201 |
|
49202 /*G component*/ |
|
49203 lTemp = lY1 - lTemp2 + 2; |
|
49204 if (lTemp < 0) |
|
49205 lTemp = 0; |
|
49206 if (lTemp > 255) |
|
49207 lTemp = 255; |
|
49208 lTemp4 |= (lTemp >> 2) << 5; |
|
49209 |
|
49210 /*R component*/ |
|
49211 lTemp = lY1 + lTemp1; |
|
49212 if (lTemp < 0) |
|
49213 lTemp = 0; |
|
49214 if (lTemp > 255) |
|
49215 lTemp = 255; |
|
49216 lTemp4 |= (lTemp >> 3) << 11; |
|
49217 |
|
49218 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
49219 |
|
49220 lRGBFramePtr += 2; |
|
49221 lRGBFramePtr1 += 2; |
|
49222 } |
|
49223 |
|
49224 if(extraCol) |
|
49225 { |
|
49226 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
49227 lRGBFramePtr++; |
|
49228 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
49229 lRGBFramePtr1++; |
|
49230 } |
|
49231 |
|
49232 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
49233 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
49234 |
|
49235 if(extraRow) |
|
49236 { |
|
49237 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
49238 for(j = 0; j < lWidth; j += 2) |
|
49239 { |
|
49240 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
49241 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
49242 } |
|
49243 if(extraCol) |
|
49244 { |
|
49245 *lRGBFramePtr = *lRGBFramePtr1; |
|
49246 } |
|
49247 } |
|
49248 return; |
|
49249 } |
|
49250 |
|
49251 /* |
|
49252 ****************************************************************************** |
|
49253 Name : sEmz_VDec_YUV420Chr3toColor64k_Ordered_601_5_FR |
|
49254 Description : Converts YUV420 Chroma3 Planar to RGB565 Interleaved format |
|
49255 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
49256 uint8 *dstImage : Pointer to rgb data (o/p). |
|
49257 tWndParam *srcWindow : Pointer to structure containing source window |
|
49258 parameters like xOffset,yOffset,cropWidth, |
|
49259 cropHeight. (i/p) |
|
49260 tWndParam *dstWindow : Pointer to structure containing destination window |
|
49261 parameters like xOffset,yOffset,windWidth, |
|
49262 windHeight. (i/p) |
|
49263 Return Value : void |
|
49264 ****************************************************************************** |
|
49265 */ |
|
49266 |
|
49267 void sEmz_VDec_YUV420Chr3toColor64k_Ordered_601_5_FR |
|
49268 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
49269 tWndParam* srcWindow, tWndParam* dstWindow) |
|
49270 { |
|
49271 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
49272 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
49273 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
49274 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
49275 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
49276 int32 i, j, extraRow, extraCol; |
|
49277 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
49278 cropWidth,cropHeight,wndWidth,wndHeight; |
|
49279 |
|
49280 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
49281 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
49282 |
|
49283 | {0,3,2} {4,0,6} | |
|
49284 | {6,1,4} {2,2,0} | */ |
|
49285 |
|
49286 srcXOffset = srcWindow->xOffset; |
|
49287 srcYOffset = srcWindow->yOffset; |
|
49288 cropWidth = srcWindow->wndWidth; |
|
49289 cropHeight = srcWindow->wndHeight; |
|
49290 |
|
49291 dstXOffset = dstWindow->xOffset; |
|
49292 dstYOffset = dstWindow->yOffset; |
|
49293 wndWidth = dstWindow->wndWidth; |
|
49294 wndHeight = dstWindow->wndHeight; |
|
49295 |
|
49296 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
49297 { |
|
49298 lWidth = cropWidth; |
|
49299 } |
|
49300 else |
|
49301 { |
|
49302 lWidth = srcImage->width - srcXOffset; |
|
49303 } |
|
49304 |
|
49305 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
49306 { |
|
49307 lHeight = cropHeight; |
|
49308 } |
|
49309 else |
|
49310 { |
|
49311 lHeight = srcImage->height - srcYOffset; |
|
49312 } |
|
49313 |
|
49314 if (lWidth > (wndWidth - dstXOffset)) |
|
49315 { |
|
49316 lWidth = wndWidth - dstXOffset; |
|
49317 } |
|
49318 |
|
49319 if (lHeight > (wndHeight - dstYOffset)) |
|
49320 { |
|
49321 lHeight = wndHeight - dstYOffset; |
|
49322 } |
|
49323 |
|
49324 extraCol = lWidth & 0x01; |
|
49325 extraRow = lHeight & 0x01; |
|
49326 |
|
49327 lTempWidth = lWidth; |
|
49328 lWidth = (lWidth >> 1) << 1; |
|
49329 lHeight = (lHeight >> 1) << 1; |
|
49330 |
|
49331 lLumWidth = (srcImage->width >> 1) << 1; |
|
49332 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
49333 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
49334 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
49335 |
|
49336 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
49337 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
49338 |
|
49339 for(i = 0; i < (lHeight - 2); i += 2) |
|
49340 { |
|
49341 for(j = 0; j < (lWidth - 2); j += 2) |
|
49342 { |
|
49343 lCr1 = lCrPtr[j >> 1]; |
|
49344 lCb1 = lCbPtr[j >> 1]; |
|
49345 |
|
49346 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
49347 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
49348 |
|
49349 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
49350 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
49351 |
|
49352 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
49353 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
49354 |
|
49355 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
49356 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
49357 |
|
49358 lCr2 = (lCr1 + lCr2) >> 1; |
|
49359 lCb2 = (lCb1 + lCb2) >> 1; |
|
49360 |
|
49361 lCr3 = (lCr1 + lCr3) >> 1; |
|
49362 lCb3 = (lCb1 + lCb3) >> 1; |
|
49363 |
|
49364 /*First Pixel*/ |
|
49365 lCr1 -= 128; |
|
49366 lCb1 -= 128; |
|
49367 |
|
49368 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
49369 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
49370 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
49371 |
|
49372 lY1 = lLumPtr[j]; |
|
49373 |
|
49374 /*B component*/ |
|
49375 lTemp = lY1 + lTemp3; |
|
49376 if (lTemp < 0) |
|
49377 lTemp = 0; |
|
49378 if (lTemp > 255) |
|
49379 lTemp = 255; |
|
49380 lTemp4 = (lTemp >> 3); |
|
49381 |
|
49382 /*G component*/ |
|
49383 lTemp = lY1 - lTemp2 + 3; |
|
49384 if (lTemp < 0) |
|
49385 lTemp = 0; |
|
49386 if (lTemp > 255) |
|
49387 lTemp = 255; |
|
49388 lTemp4 |= (lTemp >> 2) << 5; |
|
49389 |
|
49390 /*R component*/ |
|
49391 lTemp = lY1 + lTemp1 + 2; |
|
49392 if (lTemp < 0) |
|
49393 lTemp = 0; |
|
49394 if (lTemp > 255) |
|
49395 lTemp = 255; |
|
49396 lTemp4 |= (lTemp >> 3) << 11; |
|
49397 |
|
49398 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
49399 |
|
49400 /*Second Pixel*/ |
|
49401 lCr2 -= 128; |
|
49402 lCb2 -= 128; |
|
49403 |
|
49404 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
49405 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
49406 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
49407 |
|
49408 lY1 = lLumPtr[j + 1]; |
|
49409 |
|
49410 /*B component*/ |
|
49411 lTemp = lY1 + lTemp3 + 4; |
|
49412 if (lTemp < 0) |
|
49413 lTemp = 0; |
|
49414 if (lTemp > 255) |
|
49415 lTemp = 255; |
|
49416 lTemp4 = (lTemp >> 3); |
|
49417 |
|
49418 /*G component*/ |
|
49419 lTemp = lY1 - lTemp2; |
|
49420 if (lTemp < 0) |
|
49421 lTemp = 0; |
|
49422 if (lTemp > 255) |
|
49423 lTemp = 255; |
|
49424 lTemp4 |= (lTemp >> 2) << 5; |
|
49425 |
|
49426 /*R component*/ |
|
49427 lTemp = lY1 + lTemp1 + 6; |
|
49428 if (lTemp < 0) |
|
49429 lTemp = 0; |
|
49430 if (lTemp > 255) |
|
49431 lTemp = 255; |
|
49432 lTemp4 |= (lTemp >> 3) << 11; |
|
49433 |
|
49434 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
49435 |
|
49436 |
|
49437 /*Third Pixel*/ |
|
49438 lCr3 -= 128; |
|
49439 lCb3 -= 128; |
|
49440 |
|
49441 lTemp1 = (22973 * lCr3) >> COLOR_CONV_PRECISION; |
|
49442 lTemp2 = ((5637 * lCb3) + (11699 * lCr3)) >> COLOR_CONV_PRECISION; |
|
49443 lTemp3 = (29032 * lCb3) >> COLOR_CONV_PRECISION; |
|
49444 |
|
49445 lY1 = lLumPtr[j + lLumWidth]; |
|
49446 |
|
49447 /*B component*/ |
|
49448 lTemp = lY1 + lTemp3 + 6; |
|
49449 if (lTemp < 0) |
|
49450 lTemp = 0; |
|
49451 if (lTemp > 255) |
|
49452 lTemp = 255; |
|
49453 lTemp4 = (lTemp >> 3); |
|
49454 |
|
49455 /*G component*/ |
|
49456 lTemp = lY1 - lTemp2 + 1; |
|
49457 if (lTemp < 0) |
|
49458 lTemp = 0; |
|
49459 if (lTemp > 255) |
|
49460 lTemp = 255; |
|
49461 lTemp4 |= (lTemp >> 2) << 5; |
|
49462 |
|
49463 /*R component*/ |
|
49464 lTemp = lY1 + lTemp1 + 4; |
|
49465 if (lTemp < 0) |
|
49466 lTemp = 0; |
|
49467 if (lTemp > 255) |
|
49468 lTemp = 255; |
|
49469 lTemp4 |= (lTemp >> 3) << 11; |
|
49470 |
|
49471 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
49472 |
|
49473 /*Fourth Pixel*/ |
|
49474 lCr4 -= 128; |
|
49475 lCb4 -= 128; |
|
49476 |
|
49477 lTemp1 = (22973 * lCr4) >> COLOR_CONV_PRECISION; |
|
49478 lTemp2 = ((5637 * lCb4) + (11699 * lCr4)) >> COLOR_CONV_PRECISION; |
|
49479 lTemp3 = (29032 * lCb4) >> COLOR_CONV_PRECISION; |
|
49480 |
|
49481 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
49482 |
|
49483 /*B component*/ |
|
49484 lTemp = lY1 + lTemp3 + 2; |
|
49485 if (lTemp < 0) |
|
49486 lTemp = 0; |
|
49487 if (lTemp > 255) |
|
49488 lTemp = 255; |
|
49489 lTemp4 = (lTemp >> 3); |
|
49490 |
|
49491 /*G component*/ |
|
49492 lTemp = lY1 - lTemp2 + 2; |
|
49493 if (lTemp < 0) |
|
49494 lTemp = 0; |
|
49495 if (lTemp > 255) |
|
49496 lTemp = 255; |
|
49497 lTemp4 |= (lTemp >> 2) << 5; |
|
49498 |
|
49499 /*R component*/ |
|
49500 lTemp = lY1 + lTemp1; |
|
49501 if (lTemp < 0) |
|
49502 lTemp = 0; |
|
49503 if (lTemp > 255) |
|
49504 lTemp = 255; |
|
49505 lTemp4 |= (lTemp >> 3) << 11; |
|
49506 |
|
49507 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
49508 |
|
49509 lRGBFramePtr += 2; |
|
49510 lRGBFramePtr1 += 2; |
|
49511 } |
|
49512 |
|
49513 |
|
49514 lCr1 = lCrPtr[j >> 1]; |
|
49515 lCb1 = lCbPtr[j >> 1]; |
|
49516 |
|
49517 lCr1 -= 128; |
|
49518 lCb1 -= 128; |
|
49519 |
|
49520 /*First Pixel*/ |
|
49521 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
49522 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
49523 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
49524 |
|
49525 lY1 = lLumPtr[j]; |
|
49526 |
|
49527 /*B component*/ |
|
49528 lTemp = lY1 + lTemp3; |
|
49529 if (lTemp < 0) |
|
49530 lTemp = 0; |
|
49531 if (lTemp > 255) |
|
49532 lTemp = 255; |
|
49533 lTemp4 = (lTemp >> 3); |
|
49534 |
|
49535 /*G component*/ |
|
49536 lTemp = lY1 - lTemp2 + 3; |
|
49537 if (lTemp < 0) |
|
49538 lTemp = 0; |
|
49539 if (lTemp > 255) |
|
49540 lTemp = 255; |
|
49541 lTemp4 |= (lTemp >> 2) << 5; |
|
49542 |
|
49543 /*R component*/ |
|
49544 lTemp = lY1 + lTemp1 + 2; |
|
49545 if (lTemp < 0) |
|
49546 lTemp = 0; |
|
49547 if (lTemp > 255) |
|
49548 lTemp = 255; |
|
49549 lTemp4 |= (lTemp >> 3) << 11; |
|
49550 |
|
49551 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
49552 |
|
49553 /*Second Pixel*/ |
|
49554 lY1 = lLumPtr[j + 1]; |
|
49555 |
|
49556 /*B component*/ |
|
49557 lTemp = lY1 + lTemp3 + 4; |
|
49558 if (lTemp < 0) |
|
49559 lTemp = 0; |
|
49560 if (lTemp > 255) |
|
49561 lTemp = 255; |
|
49562 lTemp4 = (lTemp >> 3); |
|
49563 |
|
49564 /*G component*/ |
|
49565 lTemp = lY1 - lTemp2; |
|
49566 if (lTemp < 0) |
|
49567 lTemp = 0; |
|
49568 if (lTemp > 255) |
|
49569 lTemp = 255; |
|
49570 lTemp4 |= (lTemp >> 2) << 5; |
|
49571 |
|
49572 /*R component*/ |
|
49573 lTemp = lY1 + lTemp1 + 6; |
|
49574 if (lTemp < 0) |
|
49575 lTemp = 0; |
|
49576 if (lTemp > 255) |
|
49577 lTemp = 255; |
|
49578 lTemp4 |= (lTemp >> 3) << 11; |
|
49579 |
|
49580 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
49581 |
|
49582 |
|
49583 /*Third Pixel*/ |
|
49584 lY1 = lLumPtr[j + lLumWidth]; |
|
49585 |
|
49586 /*B component*/ |
|
49587 lTemp = lY1 + lTemp3 + 6; |
|
49588 if (lTemp < 0) |
|
49589 lTemp = 0; |
|
49590 if (lTemp > 255) |
|
49591 lTemp = 255; |
|
49592 lTemp4 = (lTemp >> 3); |
|
49593 |
|
49594 /*G component*/ |
|
49595 lTemp = lY1 - lTemp2 + 1; |
|
49596 if (lTemp < 0) |
|
49597 lTemp = 0; |
|
49598 if (lTemp > 255) |
|
49599 lTemp = 255; |
|
49600 lTemp4 |= (lTemp >> 2) << 5; |
|
49601 |
|
49602 /*R component*/ |
|
49603 lTemp = lY1 + lTemp1 + 4; |
|
49604 if (lTemp < 0) |
|
49605 lTemp = 0; |
|
49606 if (lTemp > 255) |
|
49607 lTemp = 255; |
|
49608 lTemp4 |= (lTemp >> 3) << 11; |
|
49609 |
|
49610 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
49611 |
|
49612 /*Fourth Pixel*/ |
|
49613 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
49614 |
|
49615 /*B component*/ |
|
49616 lTemp = lY1 + lTemp3 + 2; |
|
49617 if (lTemp < 0) |
|
49618 lTemp = 0; |
|
49619 if (lTemp > 255) |
|
49620 lTemp = 255; |
|
49621 lTemp4 = (lTemp >> 3); |
|
49622 |
|
49623 /*G component*/ |
|
49624 lTemp = lY1 - lTemp2 + 2; |
|
49625 if (lTemp < 0) |
|
49626 lTemp = 0; |
|
49627 if (lTemp > 255) |
|
49628 lTemp = 255; |
|
49629 lTemp4 |= (lTemp >> 2) << 5; |
|
49630 |
|
49631 /*R component*/ |
|
49632 lTemp = lY1 + lTemp1; |
|
49633 if (lTemp < 0) |
|
49634 lTemp = 0; |
|
49635 if (lTemp > 255) |
|
49636 lTemp = 255; |
|
49637 lTemp4 |= (lTemp >> 3) << 11; |
|
49638 |
|
49639 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
49640 |
|
49641 lRGBFramePtr += 2; |
|
49642 lRGBFramePtr1 += 2; |
|
49643 |
|
49644 if(extraCol) |
|
49645 { |
|
49646 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
49647 lRGBFramePtr++; |
|
49648 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
49649 lRGBFramePtr1++; |
|
49650 } |
|
49651 |
|
49652 lLumPtr += (lLumWidth << 1); |
|
49653 lCrPtr += (lLumWidth >> 1); |
|
49654 lCbPtr += (lLumWidth >> 1); |
|
49655 |
|
49656 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
49657 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
49658 } |
|
49659 |
|
49660 |
|
49661 for(j = 0; j < lWidth; j += 2) |
|
49662 { |
|
49663 lCr1 = lCrPtr[j >> 1]; |
|
49664 lCb1 = lCbPtr[j >> 1]; |
|
49665 |
|
49666 lCr1 -= 128; |
|
49667 lCb1 -= 128; |
|
49668 |
|
49669 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
49670 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
49671 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
49672 |
|
49673 /*First Pixel*/ |
|
49674 lY1 = lLumPtr[j]; |
|
49675 |
|
49676 /*B component*/ |
|
49677 lTemp = lY1 + lTemp3; |
|
49678 if (lTemp < 0) |
|
49679 lTemp = 0; |
|
49680 if (lTemp > 255) |
|
49681 lTemp = 255; |
|
49682 lTemp4 = (lTemp >> 3); |
|
49683 |
|
49684 /*G component*/ |
|
49685 lTemp = lY1 - lTemp2 + 3; |
|
49686 if (lTemp < 0) |
|
49687 lTemp = 0; |
|
49688 if (lTemp > 255) |
|
49689 lTemp = 255; |
|
49690 lTemp4 |= (lTemp >> 2) << 5; |
|
49691 |
|
49692 /*R component*/ |
|
49693 lTemp = lY1 + lTemp1 + 2; |
|
49694 if (lTemp < 0) |
|
49695 lTemp = 0; |
|
49696 if (lTemp > 255) |
|
49697 lTemp = 255; |
|
49698 lTemp4 |= (lTemp >> 3) << 11; |
|
49699 |
|
49700 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
49701 |
|
49702 /*Second Pixel*/ |
|
49703 lY1 = lLumPtr[j + 1]; |
|
49704 |
|
49705 /*B component*/ |
|
49706 lTemp = lY1 + lTemp3 + 4; |
|
49707 if (lTemp < 0) |
|
49708 lTemp = 0; |
|
49709 if (lTemp > 255) |
|
49710 lTemp = 255; |
|
49711 lTemp4 = (lTemp >> 3); |
|
49712 |
|
49713 /*G component*/ |
|
49714 lTemp = lY1 - lTemp2; |
|
49715 if (lTemp < 0) |
|
49716 lTemp = 0; |
|
49717 if (lTemp > 255) |
|
49718 lTemp = 255; |
|
49719 lTemp4 |= (lTemp >> 2) << 5; |
|
49720 |
|
49721 /*R component*/ |
|
49722 lTemp = lY1 + lTemp1 + 6; |
|
49723 if (lTemp < 0) |
|
49724 lTemp = 0; |
|
49725 if (lTemp > 255) |
|
49726 lTemp = 255; |
|
49727 lTemp4 |= (lTemp >> 3) << 11; |
|
49728 |
|
49729 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
49730 |
|
49731 |
|
49732 /*Third Pixel*/ |
|
49733 lY1 = lLumPtr[j + lLumWidth]; |
|
49734 |
|
49735 /*B component*/ |
|
49736 lTemp = lY1 + lTemp3 + 6; |
|
49737 if (lTemp < 0) |
|
49738 lTemp = 0; |
|
49739 if (lTemp > 255) |
|
49740 lTemp = 255; |
|
49741 lTemp4 = (lTemp >> 3); |
|
49742 |
|
49743 /*G component*/ |
|
49744 lTemp = lY1 - lTemp2 + 1; |
|
49745 if (lTemp < 0) |
|
49746 lTemp = 0; |
|
49747 if (lTemp > 255) |
|
49748 lTemp = 255; |
|
49749 lTemp4 |= (lTemp >> 2) << 5; |
|
49750 |
|
49751 /*R component*/ |
|
49752 lTemp = lY1 + lTemp1 + 4; |
|
49753 if (lTemp < 0) |
|
49754 lTemp = 0; |
|
49755 if (lTemp > 255) |
|
49756 lTemp = 255; |
|
49757 lTemp4 |= (lTemp >> 3) << 11; |
|
49758 |
|
49759 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
49760 |
|
49761 /*Fourth Pixel*/ |
|
49762 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
49763 |
|
49764 /*B component*/ |
|
49765 lTemp = lY1 + lTemp3 + 2; |
|
49766 if (lTemp < 0) |
|
49767 lTemp = 0; |
|
49768 if (lTemp > 255) |
|
49769 lTemp = 255; |
|
49770 lTemp4 = (lTemp >> 3); |
|
49771 |
|
49772 /*G component*/ |
|
49773 lTemp = lY1 - lTemp2 + 2; |
|
49774 if (lTemp < 0) |
|
49775 lTemp = 0; |
|
49776 if (lTemp > 255) |
|
49777 lTemp = 255; |
|
49778 lTemp4 |= (lTemp >> 2) << 5; |
|
49779 |
|
49780 /*R component*/ |
|
49781 lTemp = lY1 + lTemp1; |
|
49782 if (lTemp < 0) |
|
49783 lTemp = 0; |
|
49784 if (lTemp > 255) |
|
49785 lTemp = 255; |
|
49786 lTemp4 |= (lTemp >> 3) << 11; |
|
49787 |
|
49788 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
49789 |
|
49790 lRGBFramePtr += 2; |
|
49791 lRGBFramePtr1 += 2; |
|
49792 } |
|
49793 |
|
49794 if(extraCol) |
|
49795 { |
|
49796 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
49797 lRGBFramePtr++; |
|
49798 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
49799 lRGBFramePtr1++; |
|
49800 } |
|
49801 |
|
49802 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
49803 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
49804 |
|
49805 if(extraRow) |
|
49806 { |
|
49807 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
49808 for(j = 0; j < lWidth; j += 2) |
|
49809 { |
|
49810 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
49811 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
49812 } |
|
49813 if(extraCol) |
|
49814 { |
|
49815 *lRGBFramePtr = *lRGBFramePtr1; |
|
49816 } |
|
49817 } |
|
49818 return; |
|
49819 } |
|
49820 |
|
49821 /* |
|
49822 ****************************************************************************** |
|
49823 Name : sEmz_VDec_YUV420Chr3toColor64k_Ordered_709_RR |
|
49824 Description : Converts YUV420 Chroma3 Planar to RGB565 Interleaved format |
|
49825 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
49826 uint8 *dstImage : Pointer to rgb data (o/p). |
|
49827 tWndParam *srcWindow : Pointer to structure containing source window |
|
49828 parameters like xOffset,yOffset,cropWidth, |
|
49829 cropHeight. (i/p) |
|
49830 tWndParam *dstWindow : Pointer to structure containing destination window |
|
49831 parameters like xOffset,yOffset,windWidth, |
|
49832 windHeight. (i/p) |
|
49833 Return Value : void |
|
49834 ****************************************************************************** |
|
49835 */ |
|
49836 |
|
49837 void sEmz_VDec_YUV420Chr3toColor64k_Ordered_709_RR |
|
49838 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
49839 tWndParam* srcWindow, tWndParam* dstWindow) |
|
49840 { |
|
49841 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
49842 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
49843 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
49844 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
49845 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
49846 int32 i, j, extraRow, extraCol; |
|
49847 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
49848 cropWidth,cropHeight,wndWidth,wndHeight; |
|
49849 |
|
49850 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
49851 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
49852 |
|
49853 | {0,3,2} {4,0,6} | |
|
49854 | {6,1,4} {2,2,0} | */ |
|
49855 |
|
49856 srcXOffset = srcWindow->xOffset; |
|
49857 srcYOffset = srcWindow->yOffset; |
|
49858 cropWidth = srcWindow->wndWidth; |
|
49859 cropHeight = srcWindow->wndHeight; |
|
49860 |
|
49861 dstXOffset = dstWindow->xOffset; |
|
49862 dstYOffset = dstWindow->yOffset; |
|
49863 wndWidth = dstWindow->wndWidth; |
|
49864 wndHeight = dstWindow->wndHeight; |
|
49865 |
|
49866 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
49867 { |
|
49868 lWidth = cropWidth; |
|
49869 } |
|
49870 else |
|
49871 { |
|
49872 lWidth = srcImage->width - srcXOffset; |
|
49873 } |
|
49874 |
|
49875 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
49876 { |
|
49877 lHeight = cropHeight; |
|
49878 } |
|
49879 else |
|
49880 { |
|
49881 lHeight = srcImage->height - srcYOffset; |
|
49882 } |
|
49883 |
|
49884 if (lWidth > (wndWidth - dstXOffset)) |
|
49885 { |
|
49886 lWidth = wndWidth - dstXOffset; |
|
49887 } |
|
49888 |
|
49889 if (lHeight > (wndHeight - dstYOffset)) |
|
49890 { |
|
49891 lHeight = wndHeight - dstYOffset; |
|
49892 } |
|
49893 |
|
49894 extraCol = lWidth & 0x01; |
|
49895 extraRow = lHeight & 0x01; |
|
49896 |
|
49897 lTempWidth = lWidth; |
|
49898 lWidth = (lWidth >> 1) << 1; |
|
49899 lHeight = (lHeight >> 1) << 1; |
|
49900 |
|
49901 lLumWidth = (srcImage->width >> 1) << 1; |
|
49902 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
49903 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
49904 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
49905 |
|
49906 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
49907 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
49908 |
|
49909 for(i = 0; i < (lHeight - 2); i += 2) |
|
49910 { |
|
49911 for(j = 0; j < (lWidth - 2); j += 2) |
|
49912 { |
|
49913 lCr1 = lCrPtr[j >> 1]; |
|
49914 lCb1 = lCbPtr[j >> 1]; |
|
49915 |
|
49916 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
49917 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
49918 |
|
49919 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
49920 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
49921 |
|
49922 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
49923 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
49924 |
|
49925 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
49926 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
49927 |
|
49928 lCr2 = (lCr1 + lCr2) >> 1; |
|
49929 lCb2 = (lCb1 + lCb2) >> 1; |
|
49930 |
|
49931 lCr3 = (lCr1 + lCr3) >> 1; |
|
49932 lCb3 = (lCb1 + lCb3) >> 1; |
|
49933 |
|
49934 /*First Pixel*/ |
|
49935 lCr1 -= 128; |
|
49936 lCb1 -= 128; |
|
49937 |
|
49938 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
49939 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
49940 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
49941 |
|
49942 lY1 = lLumPtr[j]; |
|
49943 lY1 -= 16; |
|
49944 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
49945 |
|
49946 /*B component*/ |
|
49947 lTemp = lY1 + lTemp3; |
|
49948 if (lTemp < 0) |
|
49949 lTemp = 0; |
|
49950 if (lTemp > 255) |
|
49951 lTemp = 255; |
|
49952 lTemp4 = (lTemp >> 3); |
|
49953 |
|
49954 /*G component*/ |
|
49955 lTemp = lY1 - lTemp2 + 3; |
|
49956 if (lTemp < 0) |
|
49957 lTemp = 0; |
|
49958 if (lTemp > 255) |
|
49959 lTemp = 255; |
|
49960 lTemp4 |= (lTemp >> 2) << 5; |
|
49961 |
|
49962 /*R component*/ |
|
49963 lTemp = lY1 + lTemp1 + 2; |
|
49964 if (lTemp < 0) |
|
49965 lTemp = 0; |
|
49966 if (lTemp > 255) |
|
49967 lTemp = 255; |
|
49968 lTemp4 |= (lTemp >> 3) << 11; |
|
49969 |
|
49970 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
49971 |
|
49972 /*Second Pixel*/ |
|
49973 lCr2 -= 128; |
|
49974 lCb2 -= 128; |
|
49975 |
|
49976 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
49977 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
49978 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
49979 |
|
49980 lY1 = lLumPtr[j + 1]; |
|
49981 lY1 -= 16; |
|
49982 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
49983 |
|
49984 /*B component*/ |
|
49985 lTemp = lY1 + lTemp3 + 4; |
|
49986 if (lTemp < 0) |
|
49987 lTemp = 0; |
|
49988 if (lTemp > 255) |
|
49989 lTemp = 255; |
|
49990 lTemp4 = (lTemp >> 3); |
|
49991 |
|
49992 /*G component*/ |
|
49993 lTemp = lY1 - lTemp2; |
|
49994 if (lTemp < 0) |
|
49995 lTemp = 0; |
|
49996 if (lTemp > 255) |
|
49997 lTemp = 255; |
|
49998 lTemp4 |= (lTemp >> 2) << 5; |
|
49999 |
|
50000 /*R component*/ |
|
50001 lTemp = lY1 + lTemp1 + 6; |
|
50002 if (lTemp < 0) |
|
50003 lTemp = 0; |
|
50004 if (lTemp > 255) |
|
50005 lTemp = 255; |
|
50006 lTemp4 |= (lTemp >> 3) << 11; |
|
50007 |
|
50008 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
50009 |
|
50010 |
|
50011 /*Third Pixel*/ |
|
50012 lCr3 -= 128; |
|
50013 lCb3 -= 128; |
|
50014 |
|
50015 lTemp1 = (29374 * lCr3) >> COLOR_CONV_PRECISION; |
|
50016 lTemp2 = ((3494 * lCb3) + (8731 * lCr3)) >> COLOR_CONV_PRECISION; |
|
50017 lTemp3 = (34603 * lCb3) >> COLOR_CONV_PRECISION; |
|
50018 |
|
50019 lY1 = lLumPtr[j + lLumWidth]; |
|
50020 lY1 -= 16; |
|
50021 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50022 |
|
50023 /*B component*/ |
|
50024 lTemp = lY1 + lTemp3 + 6; |
|
50025 if (lTemp < 0) |
|
50026 lTemp = 0; |
|
50027 if (lTemp > 255) |
|
50028 lTemp = 255; |
|
50029 lTemp4 = (lTemp >> 3); |
|
50030 |
|
50031 /*G component*/ |
|
50032 lTemp = lY1 - lTemp2 + 1; |
|
50033 if (lTemp < 0) |
|
50034 lTemp = 0; |
|
50035 if (lTemp > 255) |
|
50036 lTemp = 255; |
|
50037 lTemp4 |= (lTemp >> 2) << 5; |
|
50038 |
|
50039 /*R component*/ |
|
50040 lTemp = lY1 + lTemp1 + 4; |
|
50041 if (lTemp < 0) |
|
50042 lTemp = 0; |
|
50043 if (lTemp > 255) |
|
50044 lTemp = 255; |
|
50045 lTemp4 |= (lTemp >> 3) << 11; |
|
50046 |
|
50047 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
50048 |
|
50049 /*Fourth Pixel*/ |
|
50050 lCr4 -= 128; |
|
50051 lCb4 -= 128; |
|
50052 |
|
50053 lTemp1 = (29374 * lCr4) >> COLOR_CONV_PRECISION; |
|
50054 lTemp2 = ((3494 * lCb4) + (8731 * lCr4)) >> COLOR_CONV_PRECISION; |
|
50055 lTemp3 = (34603 * lCb4) >> COLOR_CONV_PRECISION; |
|
50056 |
|
50057 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
50058 lY1 -= 16; |
|
50059 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50060 |
|
50061 /*B component*/ |
|
50062 lTemp = lY1 + lTemp3 + 2; |
|
50063 if (lTemp < 0) |
|
50064 lTemp = 0; |
|
50065 if (lTemp > 255) |
|
50066 lTemp = 255; |
|
50067 lTemp4 = (lTemp >> 3); |
|
50068 |
|
50069 /*G component*/ |
|
50070 lTemp = lY1 - lTemp2 + 2; |
|
50071 if (lTemp < 0) |
|
50072 lTemp = 0; |
|
50073 if (lTemp > 255) |
|
50074 lTemp = 255; |
|
50075 lTemp4 |= (lTemp >> 2) << 5; |
|
50076 |
|
50077 /*R component*/ |
|
50078 lTemp = lY1 + lTemp1; |
|
50079 if (lTemp < 0) |
|
50080 lTemp = 0; |
|
50081 if (lTemp > 255) |
|
50082 lTemp = 255; |
|
50083 lTemp4 |= (lTemp >> 3) << 11; |
|
50084 |
|
50085 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
50086 |
|
50087 lRGBFramePtr += 2; |
|
50088 lRGBFramePtr1 += 2; |
|
50089 } |
|
50090 |
|
50091 |
|
50092 lCr1 = lCrPtr[j >> 1]; |
|
50093 lCb1 = lCbPtr[j >> 1]; |
|
50094 |
|
50095 lCr1 -= 128; |
|
50096 lCb1 -= 128; |
|
50097 |
|
50098 /*First Pixel*/ |
|
50099 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
50100 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
50101 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
50102 |
|
50103 lY1 = lLumPtr[j]; |
|
50104 lY1 -= 16; |
|
50105 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50106 |
|
50107 /*B component*/ |
|
50108 lTemp = lY1 + lTemp3; |
|
50109 if (lTemp < 0) |
|
50110 lTemp = 0; |
|
50111 if (lTemp > 255) |
|
50112 lTemp = 255; |
|
50113 lTemp4 = (lTemp >> 3); |
|
50114 |
|
50115 /*G component*/ |
|
50116 lTemp = lY1 - lTemp2 + 3; |
|
50117 if (lTemp < 0) |
|
50118 lTemp = 0; |
|
50119 if (lTemp > 255) |
|
50120 lTemp = 255; |
|
50121 lTemp4 |= (lTemp >> 2) << 5; |
|
50122 |
|
50123 /*R component*/ |
|
50124 lTemp = lY1 + lTemp1 + 2; |
|
50125 if (lTemp < 0) |
|
50126 lTemp = 0; |
|
50127 if (lTemp > 255) |
|
50128 lTemp = 255; |
|
50129 lTemp4 |= (lTemp >> 3) << 11; |
|
50130 |
|
50131 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
50132 |
|
50133 /*Second Pixel*/ |
|
50134 lY1 = lLumPtr[j + 1]; |
|
50135 lY1 -= 16; |
|
50136 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50137 |
|
50138 /*B component*/ |
|
50139 lTemp = lY1 + lTemp3 + 4; |
|
50140 if (lTemp < 0) |
|
50141 lTemp = 0; |
|
50142 if (lTemp > 255) |
|
50143 lTemp = 255; |
|
50144 lTemp4 = (lTemp >> 3); |
|
50145 |
|
50146 /*G component*/ |
|
50147 lTemp = lY1 - lTemp2; |
|
50148 if (lTemp < 0) |
|
50149 lTemp = 0; |
|
50150 if (lTemp > 255) |
|
50151 lTemp = 255; |
|
50152 lTemp4 |= (lTemp >> 2) << 5; |
|
50153 |
|
50154 /*R component*/ |
|
50155 lTemp = lY1 + lTemp1 + 6; |
|
50156 if (lTemp < 0) |
|
50157 lTemp = 0; |
|
50158 if (lTemp > 255) |
|
50159 lTemp = 255; |
|
50160 lTemp4 |= (lTemp >> 3) << 11; |
|
50161 |
|
50162 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
50163 |
|
50164 |
|
50165 /*Third Pixel*/ |
|
50166 lY1 = lLumPtr[j + lLumWidth]; |
|
50167 lY1 -= 16; |
|
50168 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50169 |
|
50170 /*B component*/ |
|
50171 lTemp = lY1 + lTemp3 + 6; |
|
50172 if (lTemp < 0) |
|
50173 lTemp = 0; |
|
50174 if (lTemp > 255) |
|
50175 lTemp = 255; |
|
50176 lTemp4 = (lTemp >> 3); |
|
50177 |
|
50178 /*G component*/ |
|
50179 lTemp = lY1 - lTemp2 + 1; |
|
50180 if (lTemp < 0) |
|
50181 lTemp = 0; |
|
50182 if (lTemp > 255) |
|
50183 lTemp = 255; |
|
50184 lTemp4 |= (lTemp >> 2) << 5; |
|
50185 |
|
50186 /*R component*/ |
|
50187 lTemp = lY1 + lTemp1 + 4; |
|
50188 if (lTemp < 0) |
|
50189 lTemp = 0; |
|
50190 if (lTemp > 255) |
|
50191 lTemp = 255; |
|
50192 lTemp4 |= (lTemp >> 3) << 11; |
|
50193 |
|
50194 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
50195 |
|
50196 /*Fourth Pixel*/ |
|
50197 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
50198 lY1 -= 16; |
|
50199 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50200 |
|
50201 /*B component*/ |
|
50202 lTemp = lY1 + lTemp3 + 2; |
|
50203 if (lTemp < 0) |
|
50204 lTemp = 0; |
|
50205 if (lTemp > 255) |
|
50206 lTemp = 255; |
|
50207 lTemp4 = (lTemp >> 3); |
|
50208 |
|
50209 /*G component*/ |
|
50210 lTemp = lY1 - lTemp2 + 2; |
|
50211 if (lTemp < 0) |
|
50212 lTemp = 0; |
|
50213 if (lTemp > 255) |
|
50214 lTemp = 255; |
|
50215 lTemp4 |= (lTemp >> 2) << 5; |
|
50216 |
|
50217 /*R component*/ |
|
50218 lTemp = lY1 + lTemp1; |
|
50219 if (lTemp < 0) |
|
50220 lTemp = 0; |
|
50221 if (lTemp > 255) |
|
50222 lTemp = 255; |
|
50223 lTemp4 |= (lTemp >> 3) << 11; |
|
50224 |
|
50225 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
50226 |
|
50227 lRGBFramePtr += 2; |
|
50228 lRGBFramePtr1 += 2; |
|
50229 |
|
50230 if(extraCol) |
|
50231 { |
|
50232 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
50233 lRGBFramePtr++; |
|
50234 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
50235 lRGBFramePtr1++; |
|
50236 } |
|
50237 |
|
50238 lLumPtr += (lLumWidth << 1); |
|
50239 lCrPtr += (lLumWidth >> 1); |
|
50240 lCbPtr += (lLumWidth >> 1); |
|
50241 |
|
50242 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
50243 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
50244 } |
|
50245 |
|
50246 |
|
50247 for(j = 0; j < lWidth; j += 2) |
|
50248 { |
|
50249 lCr1 = lCrPtr[j >> 1]; |
|
50250 lCb1 = lCbPtr[j >> 1]; |
|
50251 |
|
50252 lCr1 -= 128; |
|
50253 lCb1 -= 128; |
|
50254 |
|
50255 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
50256 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
50257 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
50258 |
|
50259 /*First Pixel*/ |
|
50260 lY1 = lLumPtr[j]; |
|
50261 lY1 -= 16; |
|
50262 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50263 |
|
50264 /*B component*/ |
|
50265 lTemp = lY1 + lTemp3; |
|
50266 if (lTemp < 0) |
|
50267 lTemp = 0; |
|
50268 if (lTemp > 255) |
|
50269 lTemp = 255; |
|
50270 lTemp4 = (lTemp >> 3); |
|
50271 |
|
50272 /*G component*/ |
|
50273 lTemp = lY1 - lTemp2 + 3; |
|
50274 if (lTemp < 0) |
|
50275 lTemp = 0; |
|
50276 if (lTemp > 255) |
|
50277 lTemp = 255; |
|
50278 lTemp4 |= (lTemp >> 2) << 5; |
|
50279 |
|
50280 /*R component*/ |
|
50281 lTemp = lY1 + lTemp1 + 2; |
|
50282 if (lTemp < 0) |
|
50283 lTemp = 0; |
|
50284 if (lTemp > 255) |
|
50285 lTemp = 255; |
|
50286 lTemp4 |= (lTemp >> 3) << 11; |
|
50287 |
|
50288 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
50289 |
|
50290 /*Second Pixel*/ |
|
50291 lY1 = lLumPtr[j + 1]; |
|
50292 lY1 -= 16; |
|
50293 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50294 |
|
50295 /*B component*/ |
|
50296 lTemp = lY1 + lTemp3 + 4; |
|
50297 if (lTemp < 0) |
|
50298 lTemp = 0; |
|
50299 if (lTemp > 255) |
|
50300 lTemp = 255; |
|
50301 lTemp4 = (lTemp >> 3); |
|
50302 |
|
50303 /*G component*/ |
|
50304 lTemp = lY1 - lTemp2; |
|
50305 if (lTemp < 0) |
|
50306 lTemp = 0; |
|
50307 if (lTemp > 255) |
|
50308 lTemp = 255; |
|
50309 lTemp4 |= (lTemp >> 2) << 5; |
|
50310 |
|
50311 /*R component*/ |
|
50312 lTemp = lY1 + lTemp1 + 6; |
|
50313 if (lTemp < 0) |
|
50314 lTemp = 0; |
|
50315 if (lTemp > 255) |
|
50316 lTemp = 255; |
|
50317 lTemp4 |= (lTemp >> 3) << 11; |
|
50318 |
|
50319 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
50320 |
|
50321 |
|
50322 /*Third Pixel*/ |
|
50323 lY1 = lLumPtr[j + lLumWidth]; |
|
50324 lY1 -= 16; |
|
50325 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50326 |
|
50327 /*B component*/ |
|
50328 lTemp = lY1 + lTemp3 + 6; |
|
50329 if (lTemp < 0) |
|
50330 lTemp = 0; |
|
50331 if (lTemp > 255) |
|
50332 lTemp = 255; |
|
50333 lTemp4 = (lTemp >> 3); |
|
50334 |
|
50335 /*G component*/ |
|
50336 lTemp = lY1 - lTemp2 + 1; |
|
50337 if (lTemp < 0) |
|
50338 lTemp = 0; |
|
50339 if (lTemp > 255) |
|
50340 lTemp = 255; |
|
50341 lTemp4 |= (lTemp >> 2) << 5; |
|
50342 |
|
50343 /*R component*/ |
|
50344 lTemp = lY1 + lTemp1 + 4; |
|
50345 if (lTemp < 0) |
|
50346 lTemp = 0; |
|
50347 if (lTemp > 255) |
|
50348 lTemp = 255; |
|
50349 lTemp4 |= (lTemp >> 3) << 11; |
|
50350 |
|
50351 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
50352 |
|
50353 /*Fourth Pixel*/ |
|
50354 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
50355 lY1 -= 16; |
|
50356 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50357 |
|
50358 /*B component*/ |
|
50359 lTemp = lY1 + lTemp3 + 2; |
|
50360 if (lTemp < 0) |
|
50361 lTemp = 0; |
|
50362 if (lTemp > 255) |
|
50363 lTemp = 255; |
|
50364 lTemp4 = (lTemp >> 3); |
|
50365 |
|
50366 /*G component*/ |
|
50367 lTemp = lY1 - lTemp2 + 2; |
|
50368 if (lTemp < 0) |
|
50369 lTemp = 0; |
|
50370 if (lTemp > 255) |
|
50371 lTemp = 255; |
|
50372 lTemp4 |= (lTemp >> 2) << 5; |
|
50373 |
|
50374 /*R component*/ |
|
50375 lTemp = lY1 + lTemp1; |
|
50376 if (lTemp < 0) |
|
50377 lTemp = 0; |
|
50378 if (lTemp > 255) |
|
50379 lTemp = 255; |
|
50380 lTemp4 |= (lTemp >> 3) << 11; |
|
50381 |
|
50382 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
50383 |
|
50384 lRGBFramePtr += 2; |
|
50385 lRGBFramePtr1 += 2; |
|
50386 } |
|
50387 |
|
50388 if(extraCol) |
|
50389 { |
|
50390 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
50391 lRGBFramePtr++; |
|
50392 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
50393 lRGBFramePtr1++; |
|
50394 } |
|
50395 |
|
50396 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
50397 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
50398 |
|
50399 if(extraRow) |
|
50400 { |
|
50401 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
50402 for(j = 0; j < lWidth; j += 2) |
|
50403 { |
|
50404 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
50405 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
50406 } |
|
50407 if(extraCol) |
|
50408 { |
|
50409 *lRGBFramePtr = *lRGBFramePtr1; |
|
50410 } |
|
50411 } |
|
50412 return; |
|
50413 } |
|
50414 |
|
50415 /* |
|
50416 ****************************************************************************** |
|
50417 Name : sEmz_VDec_YUV420Chr3toColor64k_Ordered_601_5_RR |
|
50418 Description : Converts YUV420 Chroma3 Planar to RGB565 Interleaved format |
|
50419 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
50420 uint8 *dstImage : Pointer to rgb data (o/p). |
|
50421 tWndParam *srcWindow : Pointer to structure containing source window |
|
50422 parameters like xOffset,yOffset,cropWidth, |
|
50423 cropHeight. (i/p) |
|
50424 tWndParam *dstWindow : Pointer to structure containing destination window |
|
50425 parameters like xOffset,yOffset,windWidth, |
|
50426 windHeight. (i/p) |
|
50427 Return Value : void |
|
50428 ****************************************************************************** |
|
50429 */ |
|
50430 |
|
50431 void sEmz_VDec_YUV420Chr3toColor64k_Ordered_601_5_RR |
|
50432 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
50433 tWndParam* srcWindow, tWndParam* dstWindow) |
|
50434 { |
|
50435 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
50436 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
50437 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
50438 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
50439 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
50440 int32 i, j, extraRow, extraCol; |
|
50441 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
50442 cropWidth,cropHeight,wndWidth,wndHeight; |
|
50443 |
|
50444 /* This function performs YUV to RGB conversion with dithering for 16-bit |
|
50445 {5,6,5} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
50446 |
|
50447 | {0,3,2} {4,0,6} | |
|
50448 | {6,1,4} {2,2,0} | */ |
|
50449 |
|
50450 srcXOffset = srcWindow->xOffset; |
|
50451 srcYOffset = srcWindow->yOffset; |
|
50452 cropWidth = srcWindow->wndWidth; |
|
50453 cropHeight = srcWindow->wndHeight; |
|
50454 |
|
50455 dstXOffset = dstWindow->xOffset; |
|
50456 dstYOffset = dstWindow->yOffset; |
|
50457 wndWidth = dstWindow->wndWidth; |
|
50458 wndHeight = dstWindow->wndHeight; |
|
50459 |
|
50460 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
50461 { |
|
50462 lWidth = cropWidth; |
|
50463 } |
|
50464 else |
|
50465 { |
|
50466 lWidth = srcImage->width - srcXOffset; |
|
50467 } |
|
50468 |
|
50469 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
50470 { |
|
50471 lHeight = cropHeight; |
|
50472 } |
|
50473 else |
|
50474 { |
|
50475 lHeight = srcImage->height - srcYOffset; |
|
50476 } |
|
50477 |
|
50478 if (lWidth > (wndWidth - dstXOffset)) |
|
50479 { |
|
50480 lWidth = wndWidth - dstXOffset; |
|
50481 } |
|
50482 |
|
50483 if (lHeight > (wndHeight - dstYOffset)) |
|
50484 { |
|
50485 lHeight = wndHeight - dstYOffset; |
|
50486 } |
|
50487 |
|
50488 extraCol = lWidth & 0x01; |
|
50489 extraRow = lHeight & 0x01; |
|
50490 |
|
50491 lTempWidth = lWidth; |
|
50492 lWidth = (lWidth >> 1) << 1; |
|
50493 lHeight = (lHeight >> 1) << 1; |
|
50494 |
|
50495 lLumWidth = (srcImage->width >> 1) << 1; |
|
50496 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
50497 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
50498 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
50499 |
|
50500 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
50501 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
50502 |
|
50503 for(i = 0; i < (lHeight - 2); i += 2) |
|
50504 { |
|
50505 for(j = 0; j < (lWidth - 2); j += 2) |
|
50506 { |
|
50507 lCr1 = lCrPtr[j >> 1]; |
|
50508 lCb1 = lCbPtr[j >> 1]; |
|
50509 |
|
50510 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
50511 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
50512 |
|
50513 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
50514 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
50515 |
|
50516 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
50517 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
50518 |
|
50519 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
50520 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
50521 |
|
50522 lCr2 = (lCr1 + lCr2) >> 1; |
|
50523 lCb2 = (lCb1 + lCb2) >> 1; |
|
50524 |
|
50525 lCr3 = (lCr1 + lCr3) >> 1; |
|
50526 lCb3 = (lCb1 + lCb3) >> 1; |
|
50527 |
|
50528 /*First Pixel*/ |
|
50529 lCr1 -= 128; |
|
50530 lCb1 -= 128; |
|
50531 |
|
50532 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
50533 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
50534 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
50535 |
|
50536 lY1 = lLumPtr[j]; |
|
50537 lY1 -= 16; |
|
50538 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50539 |
|
50540 /*B component*/ |
|
50541 lTemp = lY1 + lTemp3; |
|
50542 if (lTemp < 0) |
|
50543 lTemp = 0; |
|
50544 if (lTemp > 255) |
|
50545 lTemp = 255; |
|
50546 lTemp4 = (lTemp >> 3); |
|
50547 |
|
50548 /*G component*/ |
|
50549 lTemp = lY1 - lTemp2 + 3; |
|
50550 if (lTemp < 0) |
|
50551 lTemp = 0; |
|
50552 if (lTemp > 255) |
|
50553 lTemp = 255; |
|
50554 lTemp4 |= (lTemp >> 2) << 5; |
|
50555 |
|
50556 /*R component*/ |
|
50557 lTemp = lY1 + lTemp1 + 2; |
|
50558 if (lTemp < 0) |
|
50559 lTemp = 0; |
|
50560 if (lTemp > 255) |
|
50561 lTemp = 255; |
|
50562 lTemp4 |= (lTemp >> 3) << 11; |
|
50563 |
|
50564 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
50565 |
|
50566 /*Second Pixel*/ |
|
50567 lCr2 -= 128; |
|
50568 lCb2 -= 128; |
|
50569 |
|
50570 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
50571 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
50572 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
50573 |
|
50574 lY1 = lLumPtr[j + 1]; |
|
50575 lY1 -= 16; |
|
50576 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50577 |
|
50578 /*B component*/ |
|
50579 lTemp = lY1 + lTemp3 + 4; |
|
50580 if (lTemp < 0) |
|
50581 lTemp = 0; |
|
50582 if (lTemp > 255) |
|
50583 lTemp = 255; |
|
50584 lTemp4 = (lTemp >> 3); |
|
50585 |
|
50586 /*G component*/ |
|
50587 lTemp = lY1 - lTemp2; |
|
50588 if (lTemp < 0) |
|
50589 lTemp = 0; |
|
50590 if (lTemp > 255) |
|
50591 lTemp = 255; |
|
50592 lTemp4 |= (lTemp >> 2) << 5; |
|
50593 |
|
50594 /*R component*/ |
|
50595 lTemp = lY1 + lTemp1 + 6; |
|
50596 if (lTemp < 0) |
|
50597 lTemp = 0; |
|
50598 if (lTemp > 255) |
|
50599 lTemp = 255; |
|
50600 lTemp4 |= (lTemp >> 3) << 11; |
|
50601 |
|
50602 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
50603 |
|
50604 |
|
50605 /*Third Pixel*/ |
|
50606 lCr3 -= 128; |
|
50607 lCb3 -= 128; |
|
50608 |
|
50609 lTemp1 = (26748 * lCr3) >> COLOR_CONV_PRECISION; |
|
50610 lTemp2 = ((6563 * lCb3) + (13621 * lCr3)) >> COLOR_CONV_PRECISION; |
|
50611 lTemp3 = (33802 * lCb3) >> COLOR_CONV_PRECISION; |
|
50612 |
|
50613 lY1 = lLumPtr[j + lLumWidth]; |
|
50614 lY1 -= 16; |
|
50615 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50616 |
|
50617 /*B component*/ |
|
50618 lTemp = lY1 + lTemp3 + 6; |
|
50619 if (lTemp < 0) |
|
50620 lTemp = 0; |
|
50621 if (lTemp > 255) |
|
50622 lTemp = 255; |
|
50623 lTemp4 = (lTemp >> 3); |
|
50624 |
|
50625 /*G component*/ |
|
50626 lTemp = lY1 - lTemp2 + 1; |
|
50627 if (lTemp < 0) |
|
50628 lTemp = 0; |
|
50629 if (lTemp > 255) |
|
50630 lTemp = 255; |
|
50631 lTemp4 |= (lTemp >> 2) << 5; |
|
50632 |
|
50633 /*R component*/ |
|
50634 lTemp = lY1 + lTemp1 + 4; |
|
50635 if (lTemp < 0) |
|
50636 lTemp = 0; |
|
50637 if (lTemp > 255) |
|
50638 lTemp = 255; |
|
50639 lTemp4 |= (lTemp >> 3) << 11; |
|
50640 |
|
50641 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
50642 |
|
50643 /*Fourth Pixel*/ |
|
50644 lCr4 -= 128; |
|
50645 lCb4 -= 128; |
|
50646 |
|
50647 lTemp1 = (26748 * lCr4) >> COLOR_CONV_PRECISION; |
|
50648 lTemp2 = ((6563 * lCb4) + (13621 * lCr4)) >> COLOR_CONV_PRECISION; |
|
50649 lTemp3 = (33802 * lCb4) >> COLOR_CONV_PRECISION; |
|
50650 |
|
50651 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
50652 lY1 -= 16; |
|
50653 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50654 |
|
50655 /*B component*/ |
|
50656 lTemp = lY1 + lTemp3 + 2; |
|
50657 if (lTemp < 0) |
|
50658 lTemp = 0; |
|
50659 if (lTemp > 255) |
|
50660 lTemp = 255; |
|
50661 lTemp4 = (lTemp >> 3); |
|
50662 |
|
50663 /*G component*/ |
|
50664 lTemp = lY1 - lTemp2 + 2; |
|
50665 if (lTemp < 0) |
|
50666 lTemp = 0; |
|
50667 if (lTemp > 255) |
|
50668 lTemp = 255; |
|
50669 lTemp4 |= (lTemp >> 2) << 5; |
|
50670 |
|
50671 /*R component*/ |
|
50672 lTemp = lY1 + lTemp1; |
|
50673 if (lTemp < 0) |
|
50674 lTemp = 0; |
|
50675 if (lTemp > 255) |
|
50676 lTemp = 255; |
|
50677 lTemp4 |= (lTemp >> 3) << 11; |
|
50678 |
|
50679 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
50680 |
|
50681 lRGBFramePtr += 2; |
|
50682 lRGBFramePtr1 += 2; |
|
50683 } |
|
50684 |
|
50685 |
|
50686 lCr1 = lCrPtr[j >> 1]; |
|
50687 lCb1 = lCbPtr[j >> 1]; |
|
50688 |
|
50689 lCr1 -= 128; |
|
50690 lCb1 -= 128; |
|
50691 |
|
50692 /*First Pixel*/ |
|
50693 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
50694 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
50695 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
50696 |
|
50697 lY1 = lLumPtr[j]; |
|
50698 lY1 -= 16; |
|
50699 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50700 |
|
50701 /*B component*/ |
|
50702 lTemp = lY1 + lTemp3; |
|
50703 if (lTemp < 0) |
|
50704 lTemp = 0; |
|
50705 if (lTemp > 255) |
|
50706 lTemp = 255; |
|
50707 lTemp4 = (lTemp >> 3); |
|
50708 |
|
50709 /*G component*/ |
|
50710 lTemp = lY1 - lTemp2 + 3; |
|
50711 if (lTemp < 0) |
|
50712 lTemp = 0; |
|
50713 if (lTemp > 255) |
|
50714 lTemp = 255; |
|
50715 lTemp4 |= (lTemp >> 2) << 5; |
|
50716 |
|
50717 /*R component*/ |
|
50718 lTemp = lY1 + lTemp1 + 2; |
|
50719 if (lTemp < 0) |
|
50720 lTemp = 0; |
|
50721 if (lTemp > 255) |
|
50722 lTemp = 255; |
|
50723 lTemp4 |= (lTemp >> 3) << 11; |
|
50724 |
|
50725 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
50726 |
|
50727 /*Second Pixel*/ |
|
50728 lY1 = lLumPtr[j + 1]; |
|
50729 lY1 -= 16; |
|
50730 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50731 |
|
50732 /*B component*/ |
|
50733 lTemp = lY1 + lTemp3 + 4; |
|
50734 if (lTemp < 0) |
|
50735 lTemp = 0; |
|
50736 if (lTemp > 255) |
|
50737 lTemp = 255; |
|
50738 lTemp4 = (lTemp >> 3); |
|
50739 |
|
50740 /*G component*/ |
|
50741 lTemp = lY1 - lTemp2; |
|
50742 if (lTemp < 0) |
|
50743 lTemp = 0; |
|
50744 if (lTemp > 255) |
|
50745 lTemp = 255; |
|
50746 lTemp4 |= (lTemp >> 2) << 5; |
|
50747 |
|
50748 /*R component*/ |
|
50749 lTemp = lY1 + lTemp1 + 6; |
|
50750 if (lTemp < 0) |
|
50751 lTemp = 0; |
|
50752 if (lTemp > 255) |
|
50753 lTemp = 255; |
|
50754 lTemp4 |= (lTemp >> 3) << 11; |
|
50755 |
|
50756 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
50757 |
|
50758 |
|
50759 /*Third Pixel*/ |
|
50760 lY1 = lLumPtr[j + lLumWidth]; |
|
50761 lY1 -= 16; |
|
50762 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50763 |
|
50764 /*B component*/ |
|
50765 lTemp = lY1 + lTemp3 + 6; |
|
50766 if (lTemp < 0) |
|
50767 lTemp = 0; |
|
50768 if (lTemp > 255) |
|
50769 lTemp = 255; |
|
50770 lTemp4 = (lTemp >> 3); |
|
50771 |
|
50772 /*G component*/ |
|
50773 lTemp = lY1 - lTemp2 + 1; |
|
50774 if (lTemp < 0) |
|
50775 lTemp = 0; |
|
50776 if (lTemp > 255) |
|
50777 lTemp = 255; |
|
50778 lTemp4 |= (lTemp >> 2) << 5; |
|
50779 |
|
50780 /*R component*/ |
|
50781 lTemp = lY1 + lTemp1 + 4; |
|
50782 if (lTemp < 0) |
|
50783 lTemp = 0; |
|
50784 if (lTemp > 255) |
|
50785 lTemp = 255; |
|
50786 lTemp4 |= (lTemp >> 3) << 11; |
|
50787 |
|
50788 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
50789 |
|
50790 /*Fourth Pixel*/ |
|
50791 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
50792 lY1 -= 16; |
|
50793 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50794 |
|
50795 /*B component*/ |
|
50796 lTemp = lY1 + lTemp3 + 2; |
|
50797 if (lTemp < 0) |
|
50798 lTemp = 0; |
|
50799 if (lTemp > 255) |
|
50800 lTemp = 255; |
|
50801 lTemp4 = (lTemp >> 3); |
|
50802 |
|
50803 /*G component*/ |
|
50804 lTemp = lY1 - lTemp2 + 2; |
|
50805 if (lTemp < 0) |
|
50806 lTemp = 0; |
|
50807 if (lTemp > 255) |
|
50808 lTemp = 255; |
|
50809 lTemp4 |= (lTemp >> 2) << 5; |
|
50810 |
|
50811 /*R component*/ |
|
50812 lTemp = lY1 + lTemp1; |
|
50813 if (lTemp < 0) |
|
50814 lTemp = 0; |
|
50815 if (lTemp > 255) |
|
50816 lTemp = 255; |
|
50817 lTemp4 |= (lTemp >> 3) << 11; |
|
50818 |
|
50819 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
50820 |
|
50821 lRGBFramePtr += 2; |
|
50822 lRGBFramePtr1 += 2; |
|
50823 |
|
50824 if(extraCol) |
|
50825 { |
|
50826 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
50827 lRGBFramePtr++; |
|
50828 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
50829 lRGBFramePtr1++; |
|
50830 } |
|
50831 |
|
50832 lLumPtr += (lLumWidth << 1); |
|
50833 lCrPtr += (lLumWidth >> 1); |
|
50834 lCbPtr += (lLumWidth >> 1); |
|
50835 |
|
50836 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
50837 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
50838 } |
|
50839 |
|
50840 |
|
50841 for(j = 0; j < lWidth; j += 2) |
|
50842 { |
|
50843 lCr1 = lCrPtr[j >> 1]; |
|
50844 lCb1 = lCbPtr[j >> 1]; |
|
50845 |
|
50846 lCr1 -= 128; |
|
50847 lCb1 -= 128; |
|
50848 |
|
50849 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
50850 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
50851 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
50852 |
|
50853 /*First Pixel*/ |
|
50854 lY1 = lLumPtr[j]; |
|
50855 lY1 -= 16; |
|
50856 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50857 |
|
50858 /*B component*/ |
|
50859 lTemp = lY1 + lTemp3; |
|
50860 if (lTemp < 0) |
|
50861 lTemp = 0; |
|
50862 if (lTemp > 255) |
|
50863 lTemp = 255; |
|
50864 lTemp4 = (lTemp >> 3); |
|
50865 |
|
50866 /*G component*/ |
|
50867 lTemp = lY1 - lTemp2 + 3; |
|
50868 if (lTemp < 0) |
|
50869 lTemp = 0; |
|
50870 if (lTemp > 255) |
|
50871 lTemp = 255; |
|
50872 lTemp4 |= (lTemp >> 2) << 5; |
|
50873 |
|
50874 /*R component*/ |
|
50875 lTemp = lY1 + lTemp1 + 2; |
|
50876 if (lTemp < 0) |
|
50877 lTemp = 0; |
|
50878 if (lTemp > 255) |
|
50879 lTemp = 255; |
|
50880 lTemp4 |= (lTemp >> 3) << 11; |
|
50881 |
|
50882 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
50883 |
|
50884 /*Second Pixel*/ |
|
50885 lY1 = lLumPtr[j + 1]; |
|
50886 lY1 -= 16; |
|
50887 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50888 |
|
50889 /*B component*/ |
|
50890 lTemp = lY1 + lTemp3 + 4; |
|
50891 if (lTemp < 0) |
|
50892 lTemp = 0; |
|
50893 if (lTemp > 255) |
|
50894 lTemp = 255; |
|
50895 lTemp4 = (lTemp >> 3); |
|
50896 |
|
50897 /*G component*/ |
|
50898 lTemp = lY1 - lTemp2; |
|
50899 if (lTemp < 0) |
|
50900 lTemp = 0; |
|
50901 if (lTemp > 255) |
|
50902 lTemp = 255; |
|
50903 lTemp4 |= (lTemp >> 2) << 5; |
|
50904 |
|
50905 /*R component*/ |
|
50906 lTemp = lY1 + lTemp1 + 6; |
|
50907 if (lTemp < 0) |
|
50908 lTemp = 0; |
|
50909 if (lTemp > 255) |
|
50910 lTemp = 255; |
|
50911 lTemp4 |= (lTemp >> 3) << 11; |
|
50912 |
|
50913 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
50914 |
|
50915 |
|
50916 /*Third Pixel*/ |
|
50917 lY1 = lLumPtr[j + lLumWidth]; |
|
50918 lY1 -= 16; |
|
50919 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50920 |
|
50921 /*B component*/ |
|
50922 lTemp = lY1 + lTemp3 + 6; |
|
50923 if (lTemp < 0) |
|
50924 lTemp = 0; |
|
50925 if (lTemp > 255) |
|
50926 lTemp = 255; |
|
50927 lTemp4 = (lTemp >> 3); |
|
50928 |
|
50929 /*G component*/ |
|
50930 lTemp = lY1 - lTemp2 + 1; |
|
50931 if (lTemp < 0) |
|
50932 lTemp = 0; |
|
50933 if (lTemp > 255) |
|
50934 lTemp = 255; |
|
50935 lTemp4 |= (lTemp >> 2) << 5; |
|
50936 |
|
50937 /*R component*/ |
|
50938 lTemp = lY1 + lTemp1 + 4; |
|
50939 if (lTemp < 0) |
|
50940 lTemp = 0; |
|
50941 if (lTemp > 255) |
|
50942 lTemp = 255; |
|
50943 lTemp4 |= (lTemp >> 3) << 11; |
|
50944 |
|
50945 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
50946 |
|
50947 /*Fourth Pixel*/ |
|
50948 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
50949 lY1 -= 16; |
|
50950 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
50951 |
|
50952 /*B component*/ |
|
50953 lTemp = lY1 + lTemp3 + 2; |
|
50954 if (lTemp < 0) |
|
50955 lTemp = 0; |
|
50956 if (lTemp > 255) |
|
50957 lTemp = 255; |
|
50958 lTemp4 = (lTemp >> 3); |
|
50959 |
|
50960 /*G component*/ |
|
50961 lTemp = lY1 - lTemp2 + 2; |
|
50962 if (lTemp < 0) |
|
50963 lTemp = 0; |
|
50964 if (lTemp > 255) |
|
50965 lTemp = 255; |
|
50966 lTemp4 |= (lTemp >> 2) << 5; |
|
50967 |
|
50968 /*R component*/ |
|
50969 lTemp = lY1 + lTemp1; |
|
50970 if (lTemp < 0) |
|
50971 lTemp = 0; |
|
50972 if (lTemp > 255) |
|
50973 lTemp = 255; |
|
50974 lTemp4 |= (lTemp >> 3) << 11; |
|
50975 |
|
50976 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
50977 |
|
50978 lRGBFramePtr += 2; |
|
50979 lRGBFramePtr1 += 2; |
|
50980 } |
|
50981 |
|
50982 if(extraCol) |
|
50983 { |
|
50984 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
50985 lRGBFramePtr++; |
|
50986 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
50987 lRGBFramePtr1++; |
|
50988 } |
|
50989 |
|
50990 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
50991 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
50992 |
|
50993 if(extraRow) |
|
50994 { |
|
50995 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
50996 for(j = 0; j < lWidth; j += 2) |
|
50997 { |
|
50998 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
50999 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
51000 } |
|
51001 if(extraCol) |
|
51002 { |
|
51003 *lRGBFramePtr = *lRGBFramePtr1; |
|
51004 } |
|
51005 } |
|
51006 return; |
|
51007 } |
|
51008 |
|
51009 |
|
51010 /* |
|
51011 ****************************************************************************** |
|
51012 Name : sEmz_VDec_YUV420Chr3toColor4k_Ordered_709_FR |
|
51013 Description : Converts YUV420 Chroma3 Planar to XRGB (4:4:4:4) Interleaved format |
|
51014 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
51015 uint8 *dstImage : Pointer to rgb data (o/p). |
|
51016 tWndParam *srcWindow : Pointer to structure containing source window |
|
51017 parameters like xOffset,yOffset,cropWidth, |
|
51018 cropHeight. (i/p) |
|
51019 tWndParam *dstWindow : Pointer to structure containing destination window |
|
51020 parameters like xOffset,yOffset,windWidth, |
|
51021 windHeight. (i/p) |
|
51022 Return Value : void |
|
51023 ****************************************************************************** |
|
51024 */ |
|
51025 |
|
51026 void sEmz_VDec_YUV420Chr3toColor4k_Ordered_709_FR |
|
51027 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
51028 tWndParam* srcWindow, tWndParam* dstWindow) |
|
51029 { |
|
51030 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
51031 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
51032 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
51033 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
51034 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
51035 int32 i, j, extraRow, extraCol; |
|
51036 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
51037 cropWidth,cropHeight,wndWidth,wndHeight; |
|
51038 |
|
51039 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
51040 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
51041 |
|
51042 | {0,15,5} {10,0,15} | |
|
51043 | {15,5,10} {5,10,0} | */ |
|
51044 |
|
51045 srcXOffset = srcWindow->xOffset; |
|
51046 srcYOffset = srcWindow->yOffset; |
|
51047 cropWidth = srcWindow->wndWidth; |
|
51048 cropHeight = srcWindow->wndHeight; |
|
51049 |
|
51050 dstXOffset = dstWindow->xOffset; |
|
51051 dstYOffset = dstWindow->yOffset; |
|
51052 wndWidth = dstWindow->wndWidth; |
|
51053 wndHeight = dstWindow->wndHeight; |
|
51054 |
|
51055 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
51056 { |
|
51057 lWidth = cropWidth; |
|
51058 } |
|
51059 else |
|
51060 { |
|
51061 lWidth = srcImage->width - srcXOffset; |
|
51062 } |
|
51063 |
|
51064 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
51065 { |
|
51066 lHeight = cropHeight; |
|
51067 } |
|
51068 else |
|
51069 { |
|
51070 lHeight = srcImage->height - srcYOffset; |
|
51071 } |
|
51072 |
|
51073 if (lWidth > (wndWidth - dstXOffset)) |
|
51074 { |
|
51075 lWidth = wndWidth - dstXOffset; |
|
51076 } |
|
51077 |
|
51078 if (lHeight > (wndHeight - dstYOffset)) |
|
51079 { |
|
51080 lHeight = wndHeight - dstYOffset; |
|
51081 } |
|
51082 |
|
51083 extraCol = lWidth & 0x01; |
|
51084 extraRow = lHeight & 0x01; |
|
51085 |
|
51086 lTempWidth = lWidth; |
|
51087 lWidth = (lWidth >> 1) << 1; |
|
51088 lHeight = (lHeight >> 1) << 1; |
|
51089 |
|
51090 lLumWidth = (srcImage->width >> 1) << 1; |
|
51091 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
51092 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
51093 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
51094 |
|
51095 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
51096 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
51097 |
|
51098 for(i = 0; i < (lHeight - 2); i += 2) |
|
51099 { |
|
51100 for(j = 0; j < (lWidth - 2); j += 2) |
|
51101 { |
|
51102 lCr1 = lCrPtr[j >> 1]; |
|
51103 lCb1 = lCbPtr[j >> 1]; |
|
51104 |
|
51105 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
51106 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
51107 |
|
51108 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
51109 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
51110 |
|
51111 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
51112 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
51113 |
|
51114 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
51115 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
51116 |
|
51117 lCr2 = (lCr1 + lCr2) >> 1; |
|
51118 lCb2 = (lCb1 + lCb2) >> 1; |
|
51119 |
|
51120 lCr3 = (lCr1 + lCr3) >> 1; |
|
51121 lCb3 = (lCb1 + lCb3) >> 1; |
|
51122 |
|
51123 /*First Pixel*/ |
|
51124 lCr1 -= 128; |
|
51125 lCb1 -= 128; |
|
51126 |
|
51127 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
51128 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
51129 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
51130 |
|
51131 lY1 = lLumPtr[j]; |
|
51132 |
|
51133 /*B component*/ |
|
51134 lTemp = lY1 + lTemp3; |
|
51135 if (lTemp < 0) |
|
51136 lTemp = 0; |
|
51137 if (lTemp > 255) |
|
51138 lTemp = 255; |
|
51139 lTemp4 = (lTemp >> 4); |
|
51140 |
|
51141 /*G component*/ |
|
51142 lTemp = lY1 - lTemp2 + 15; |
|
51143 if (lTemp < 0) |
|
51144 lTemp = 0; |
|
51145 if (lTemp > 255) |
|
51146 lTemp = 255; |
|
51147 lTemp4 |= (lTemp >> 4) << 4; |
|
51148 |
|
51149 /*R component*/ |
|
51150 lTemp = lY1 + lTemp1 + 5; |
|
51151 if (lTemp < 0) |
|
51152 lTemp = 0; |
|
51153 if (lTemp > 255) |
|
51154 lTemp = 255; |
|
51155 lTemp4 |= (lTemp >> 4) << 8; |
|
51156 |
|
51157 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
51158 |
|
51159 /*Second Pixel*/ |
|
51160 lCr2 -= 128; |
|
51161 lCb2 -= 128; |
|
51162 |
|
51163 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
51164 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
51165 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
51166 |
|
51167 lY1 = lLumPtr[j + 1]; |
|
51168 |
|
51169 /*B component*/ |
|
51170 lTemp = lY1 + lTemp3 + 10; |
|
51171 if (lTemp < 0) |
|
51172 lTemp = 0; |
|
51173 if (lTemp > 255) |
|
51174 lTemp = 255; |
|
51175 lTemp4 = (lTemp >> 4); |
|
51176 |
|
51177 /*G component*/ |
|
51178 lTemp = lY1 - lTemp2; |
|
51179 if (lTemp < 0) |
|
51180 lTemp = 0; |
|
51181 if (lTemp > 255) |
|
51182 lTemp = 255; |
|
51183 lTemp4 |= (lTemp >> 4) << 4; |
|
51184 |
|
51185 /*R component*/ |
|
51186 lTemp = lY1 + lTemp1 + 15; |
|
51187 if (lTemp < 0) |
|
51188 lTemp = 0; |
|
51189 if (lTemp > 255) |
|
51190 lTemp = 255; |
|
51191 lTemp4 |= (lTemp >> 4) << 8; |
|
51192 |
|
51193 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
51194 |
|
51195 |
|
51196 /*Third Pixel*/ |
|
51197 lCr3 -= 128; |
|
51198 lCb3 -= 128; |
|
51199 |
|
51200 lTemp1 = (25801 * lCr3) >> COLOR_CONV_PRECISION; |
|
51201 lTemp2 = ((3072 * lCb3) + (7670 * lCr3)) >> COLOR_CONV_PRECISION; |
|
51202 lTemp3 = (30397 * lCb3) >> COLOR_CONV_PRECISION; |
|
51203 |
|
51204 lY1 = lLumPtr[j + lLumWidth]; |
|
51205 |
|
51206 /*B component*/ |
|
51207 lTemp = lY1 + lTemp3 + 15; |
|
51208 if (lTemp < 0) |
|
51209 lTemp = 0; |
|
51210 if (lTemp > 255) |
|
51211 lTemp = 255; |
|
51212 lTemp4 = (lTemp >> 4); |
|
51213 |
|
51214 /*G component*/ |
|
51215 lTemp = lY1 - lTemp2 + 5; |
|
51216 if (lTemp < 0) |
|
51217 lTemp = 0; |
|
51218 if (lTemp > 255) |
|
51219 lTemp = 255; |
|
51220 lTemp4 |= (lTemp >> 4) << 4; |
|
51221 |
|
51222 /*R component*/ |
|
51223 lTemp = lY1 + lTemp1 + 10; |
|
51224 if (lTemp < 0) |
|
51225 lTemp = 0; |
|
51226 if (lTemp > 255) |
|
51227 lTemp = 255; |
|
51228 lTemp4 |= (lTemp >> 4) << 8; |
|
51229 |
|
51230 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
51231 |
|
51232 /*Fourth Pixel*/ |
|
51233 lCr4 -= 128; |
|
51234 lCb4 -= 128; |
|
51235 |
|
51236 lTemp1 = (25801 * lCr4) >> COLOR_CONV_PRECISION; |
|
51237 lTemp2 = ((3072 * lCb4) + (7670 * lCr4)) >> COLOR_CONV_PRECISION; |
|
51238 lTemp3 = (30397 * lCb4) >> COLOR_CONV_PRECISION; |
|
51239 |
|
51240 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
51241 |
|
51242 /*B component*/ |
|
51243 lTemp = lY1 + lTemp3 + 5; |
|
51244 if (lTemp < 0) |
|
51245 lTemp = 0; |
|
51246 if (lTemp > 255) |
|
51247 lTemp = 255; |
|
51248 lTemp4 = (lTemp >> 4); |
|
51249 |
|
51250 /*G component*/ |
|
51251 lTemp = lY1 - lTemp2 + 10; |
|
51252 if (lTemp < 0) |
|
51253 lTemp = 0; |
|
51254 if (lTemp > 255) |
|
51255 lTemp = 255; |
|
51256 lTemp4 |= (lTemp >> 4) << 4; |
|
51257 |
|
51258 /*R component*/ |
|
51259 lTemp = lY1 + lTemp1; |
|
51260 if (lTemp < 0) |
|
51261 lTemp = 0; |
|
51262 if (lTemp > 255) |
|
51263 lTemp = 255; |
|
51264 lTemp4 |= (lTemp >> 4) << 8; |
|
51265 |
|
51266 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
51267 |
|
51268 lRGBFramePtr += 2; |
|
51269 lRGBFramePtr1 += 2; |
|
51270 } |
|
51271 |
|
51272 |
|
51273 lCr1 = lCrPtr[j >> 1]; |
|
51274 lCb1 = lCbPtr[j >> 1]; |
|
51275 |
|
51276 lCr1 -= 128; |
|
51277 lCb1 -= 128; |
|
51278 |
|
51279 /*First Pixel*/ |
|
51280 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
51281 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
51282 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
51283 |
|
51284 lY1 = lLumPtr[j]; |
|
51285 |
|
51286 /*B component*/ |
|
51287 lTemp = lY1 + lTemp3; |
|
51288 if (lTemp < 0) |
|
51289 lTemp = 0; |
|
51290 if (lTemp > 255) |
|
51291 lTemp = 255; |
|
51292 lTemp4 = (lTemp >> 4); |
|
51293 |
|
51294 /*G component*/ |
|
51295 lTemp = lY1 - lTemp2 + 15; |
|
51296 if (lTemp < 0) |
|
51297 lTemp = 0; |
|
51298 if (lTemp > 255) |
|
51299 lTemp = 255; |
|
51300 lTemp4 |= (lTemp >> 4) << 4; |
|
51301 |
|
51302 /*R component*/ |
|
51303 lTemp = lY1 + lTemp1 + 5; |
|
51304 if (lTemp < 0) |
|
51305 lTemp = 0; |
|
51306 if (lTemp > 255) |
|
51307 lTemp = 255; |
|
51308 lTemp4 |= (lTemp >> 4) << 8; |
|
51309 |
|
51310 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
51311 |
|
51312 /*Second Pixel*/ |
|
51313 lY1 = lLumPtr[j + 1]; |
|
51314 |
|
51315 /*B component*/ |
|
51316 lTemp = lY1 + lTemp3 + 10; |
|
51317 if (lTemp < 0) |
|
51318 lTemp = 0; |
|
51319 if (lTemp > 255) |
|
51320 lTemp = 255; |
|
51321 lTemp4 = (lTemp >> 4); |
|
51322 |
|
51323 /*G component*/ |
|
51324 lTemp = lY1 - lTemp2; |
|
51325 if (lTemp < 0) |
|
51326 lTemp = 0; |
|
51327 if (lTemp > 255) |
|
51328 lTemp = 255; |
|
51329 lTemp4 |= (lTemp >> 4) << 4; |
|
51330 |
|
51331 /*R component*/ |
|
51332 lTemp = lY1 + lTemp1 + 15; |
|
51333 if (lTemp < 0) |
|
51334 lTemp = 0; |
|
51335 if (lTemp > 255) |
|
51336 lTemp = 255; |
|
51337 lTemp4 |= (lTemp >> 4) << 8; |
|
51338 |
|
51339 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
51340 |
|
51341 |
|
51342 /*Third Pixel*/ |
|
51343 lY1 = lLumPtr[j + lLumWidth]; |
|
51344 |
|
51345 /*B component*/ |
|
51346 lTemp = lY1 + lTemp3 + 15; |
|
51347 if (lTemp < 0) |
|
51348 lTemp = 0; |
|
51349 if (lTemp > 255) |
|
51350 lTemp = 255; |
|
51351 lTemp4 = (lTemp >> 4); |
|
51352 |
|
51353 /*G component*/ |
|
51354 lTemp = lY1 - lTemp2 + 5; |
|
51355 if (lTemp < 0) |
|
51356 lTemp = 0; |
|
51357 if (lTemp > 255) |
|
51358 lTemp = 255; |
|
51359 lTemp4 |= (lTemp >> 4) << 4; |
|
51360 |
|
51361 /*R component*/ |
|
51362 lTemp = lY1 + lTemp1 + 10; |
|
51363 if (lTemp < 0) |
|
51364 lTemp = 0; |
|
51365 if (lTemp > 255) |
|
51366 lTemp = 255; |
|
51367 lTemp4 |= (lTemp >> 4) << 8; |
|
51368 |
|
51369 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
51370 |
|
51371 /*Fourth Pixel*/ |
|
51372 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
51373 |
|
51374 /*B component*/ |
|
51375 lTemp = lY1 + lTemp3 + 5; |
|
51376 if (lTemp < 0) |
|
51377 lTemp = 0; |
|
51378 if (lTemp > 255) |
|
51379 lTemp = 255; |
|
51380 lTemp4 = (lTemp >> 4); |
|
51381 |
|
51382 /*G component*/ |
|
51383 lTemp = lY1 - lTemp2 + 10; |
|
51384 if (lTemp < 0) |
|
51385 lTemp = 0; |
|
51386 if (lTemp > 255) |
|
51387 lTemp = 255; |
|
51388 lTemp4 |= (lTemp >> 4) << 4; |
|
51389 |
|
51390 /*R component*/ |
|
51391 lTemp = lY1 + lTemp1; |
|
51392 if (lTemp < 0) |
|
51393 lTemp = 0; |
|
51394 if (lTemp > 255) |
|
51395 lTemp = 255; |
|
51396 lTemp4 |= (lTemp >> 4) << 8; |
|
51397 |
|
51398 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
51399 |
|
51400 lRGBFramePtr += 2; |
|
51401 lRGBFramePtr1 += 2; |
|
51402 |
|
51403 if(extraCol) |
|
51404 { |
|
51405 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
51406 lRGBFramePtr++; |
|
51407 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
51408 lRGBFramePtr1++; |
|
51409 } |
|
51410 |
|
51411 lLumPtr += (lLumWidth << 1); |
|
51412 lCrPtr += (lLumWidth >> 1); |
|
51413 lCbPtr += (lLumWidth >> 1); |
|
51414 |
|
51415 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
51416 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
51417 } |
|
51418 |
|
51419 |
|
51420 for(j = 0; j < lWidth; j += 2) |
|
51421 { |
|
51422 lCr1 = lCrPtr[j >> 1]; |
|
51423 lCb1 = lCbPtr[j >> 1]; |
|
51424 |
|
51425 lCr1 -= 128; |
|
51426 lCb1 -= 128; |
|
51427 |
|
51428 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
51429 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
51430 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
51431 |
|
51432 /*First Pixel*/ |
|
51433 lY1 = lLumPtr[j]; |
|
51434 |
|
51435 /*B component*/ |
|
51436 lTemp = lY1 + lTemp3; |
|
51437 if (lTemp < 0) |
|
51438 lTemp = 0; |
|
51439 if (lTemp > 255) |
|
51440 lTemp = 255; |
|
51441 lTemp4 = (lTemp >> 4); |
|
51442 |
|
51443 /*G component*/ |
|
51444 lTemp = lY1 - lTemp2 + 15; |
|
51445 if (lTemp < 0) |
|
51446 lTemp = 0; |
|
51447 if (lTemp > 255) |
|
51448 lTemp = 255; |
|
51449 lTemp4 |= (lTemp >> 4) << 4; |
|
51450 |
|
51451 /*R component*/ |
|
51452 lTemp = lY1 + lTemp1 + 5; |
|
51453 if (lTemp < 0) |
|
51454 lTemp = 0; |
|
51455 if (lTemp > 255) |
|
51456 lTemp = 255; |
|
51457 lTemp4 |= (lTemp >> 4) << 8; |
|
51458 |
|
51459 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
51460 |
|
51461 /*Second Pixel*/ |
|
51462 lY1 = lLumPtr[j + 1]; |
|
51463 |
|
51464 /*B component*/ |
|
51465 lTemp = lY1 + lTemp3 + 10; |
|
51466 if (lTemp < 0) |
|
51467 lTemp = 0; |
|
51468 if (lTemp > 255) |
|
51469 lTemp = 255; |
|
51470 lTemp4 = (lTemp >> 4); |
|
51471 |
|
51472 /*G component*/ |
|
51473 lTemp = lY1 - lTemp2; |
|
51474 if (lTemp < 0) |
|
51475 lTemp = 0; |
|
51476 if (lTemp > 255) |
|
51477 lTemp = 255; |
|
51478 lTemp4 |= (lTemp >> 4) << 4; |
|
51479 |
|
51480 /*R component*/ |
|
51481 lTemp = lY1 + lTemp1 + 15; |
|
51482 if (lTemp < 0) |
|
51483 lTemp = 0; |
|
51484 if (lTemp > 255) |
|
51485 lTemp = 255; |
|
51486 lTemp4 |= (lTemp >> 4) << 8; |
|
51487 |
|
51488 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
51489 |
|
51490 |
|
51491 /*Third Pixel*/ |
|
51492 lY1 = lLumPtr[j + lLumWidth]; |
|
51493 |
|
51494 /*B component*/ |
|
51495 lTemp = lY1 + lTemp3 + 15; |
|
51496 if (lTemp < 0) |
|
51497 lTemp = 0; |
|
51498 if (lTemp > 255) |
|
51499 lTemp = 255; |
|
51500 lTemp4 = (lTemp >> 4); |
|
51501 |
|
51502 /*G component*/ |
|
51503 lTemp = lY1 - lTemp2 + 5; |
|
51504 if (lTemp < 0) |
|
51505 lTemp = 0; |
|
51506 if (lTemp > 255) |
|
51507 lTemp = 255; |
|
51508 lTemp4 |= (lTemp >> 4) << 4; |
|
51509 |
|
51510 /*R component*/ |
|
51511 lTemp = lY1 + lTemp1 + 10; |
|
51512 if (lTemp < 0) |
|
51513 lTemp = 0; |
|
51514 if (lTemp > 255) |
|
51515 lTemp = 255; |
|
51516 lTemp4 |= (lTemp >> 4) << 8; |
|
51517 |
|
51518 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
51519 |
|
51520 /*Fourth Pixel*/ |
|
51521 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
51522 |
|
51523 /*B component*/ |
|
51524 lTemp = lY1 + lTemp3 + 5; |
|
51525 if (lTemp < 0) |
|
51526 lTemp = 0; |
|
51527 if (lTemp > 255) |
|
51528 lTemp = 255; |
|
51529 lTemp4 = (lTemp >> 4); |
|
51530 |
|
51531 /*G component*/ |
|
51532 lTemp = lY1 - lTemp2 + 10; |
|
51533 if (lTemp < 0) |
|
51534 lTemp = 0; |
|
51535 if (lTemp > 255) |
|
51536 lTemp = 255; |
|
51537 lTemp4 |= (lTemp >> 4) << 4; |
|
51538 |
|
51539 /*R component*/ |
|
51540 lTemp = lY1 + lTemp1; |
|
51541 if (lTemp < 0) |
|
51542 lTemp = 0; |
|
51543 if (lTemp > 255) |
|
51544 lTemp = 255; |
|
51545 lTemp4 |= (lTemp >> 4) << 8; |
|
51546 |
|
51547 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
51548 |
|
51549 lRGBFramePtr += 2; |
|
51550 lRGBFramePtr1 += 2; |
|
51551 } |
|
51552 |
|
51553 if(extraCol) |
|
51554 { |
|
51555 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
51556 lRGBFramePtr++; |
|
51557 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
51558 lRGBFramePtr1++; |
|
51559 } |
|
51560 |
|
51561 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
51562 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
51563 |
|
51564 if(extraRow) |
|
51565 { |
|
51566 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
51567 for(j = 0; j < lWidth; j += 2) |
|
51568 { |
|
51569 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
51570 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
51571 } |
|
51572 if(extraCol) |
|
51573 { |
|
51574 *lRGBFramePtr = *lRGBFramePtr1; |
|
51575 } |
|
51576 } |
|
51577 return; |
|
51578 } |
|
51579 |
|
51580 /* |
|
51581 ****************************************************************************** |
|
51582 Name : sEmz_VDec_YUV420Chr3toColor4k_Ordered_601_5_FR |
|
51583 Description : Converts YUV420 Chroma3 Planar to XRGB (4:4:4:4) Interleaved format |
|
51584 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
51585 uint8 *dstImage : Pointer to rgb data (o/p). |
|
51586 tWndParam *srcWindow : Pointer to structure containing source window |
|
51587 parameters like xOffset,yOffset,cropWidth, |
|
51588 cropHeight. (i/p) |
|
51589 tWndParam *dstWindow : Pointer to structure containing destination window |
|
51590 parameters like xOffset,yOffset,windWidth, |
|
51591 windHeight. (i/p) |
|
51592 Return Value : void |
|
51593 ****************************************************************************** |
|
51594 */ |
|
51595 |
|
51596 void sEmz_VDec_YUV420Chr3toColor4k_Ordered_601_5_FR |
|
51597 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
51598 tWndParam* srcWindow, tWndParam* dstWindow) |
|
51599 { |
|
51600 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
51601 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
51602 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
51603 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
51604 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
51605 int32 i, j, extraRow, extraCol; |
|
51606 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
51607 cropWidth,cropHeight,wndWidth,wndHeight; |
|
51608 |
|
51609 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
51610 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
51611 |
|
51612 | {0,15,5} {10,0,15} | |
|
51613 | {15,5,10} {5,10,0} | */ |
|
51614 |
|
51615 srcXOffset = srcWindow->xOffset; |
|
51616 srcYOffset = srcWindow->yOffset; |
|
51617 cropWidth = srcWindow->wndWidth; |
|
51618 cropHeight = srcWindow->wndHeight; |
|
51619 |
|
51620 dstXOffset = dstWindow->xOffset; |
|
51621 dstYOffset = dstWindow->yOffset; |
|
51622 wndWidth = dstWindow->wndWidth; |
|
51623 wndHeight = dstWindow->wndHeight; |
|
51624 |
|
51625 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
51626 { |
|
51627 lWidth = cropWidth; |
|
51628 } |
|
51629 else |
|
51630 { |
|
51631 lWidth = srcImage->width - srcXOffset; |
|
51632 } |
|
51633 |
|
51634 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
51635 { |
|
51636 lHeight = cropHeight; |
|
51637 } |
|
51638 else |
|
51639 { |
|
51640 lHeight = srcImage->height - srcYOffset; |
|
51641 } |
|
51642 |
|
51643 if (lWidth > (wndWidth - dstXOffset)) |
|
51644 { |
|
51645 lWidth = wndWidth - dstXOffset; |
|
51646 } |
|
51647 |
|
51648 if (lHeight > (wndHeight - dstYOffset)) |
|
51649 { |
|
51650 lHeight = wndHeight - dstYOffset; |
|
51651 } |
|
51652 |
|
51653 extraCol = lWidth & 0x01; |
|
51654 extraRow = lHeight & 0x01; |
|
51655 |
|
51656 lTempWidth = lWidth; |
|
51657 lWidth = (lWidth >> 1) << 1; |
|
51658 lHeight = (lHeight >> 1) << 1; |
|
51659 |
|
51660 lLumWidth = (srcImage->width >> 1) << 1; |
|
51661 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
51662 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
51663 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
51664 |
|
51665 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
51666 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
51667 |
|
51668 for(i = 0; i < (lHeight - 2); i += 2) |
|
51669 { |
|
51670 for(j = 0; j < (lWidth - 2); j += 2) |
|
51671 { |
|
51672 lCr1 = lCrPtr[j >> 1]; |
|
51673 lCb1 = lCbPtr[j >> 1]; |
|
51674 |
|
51675 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
51676 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
51677 |
|
51678 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
51679 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
51680 |
|
51681 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
51682 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
51683 |
|
51684 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
51685 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
51686 |
|
51687 lCr2 = (lCr1 + lCr2) >> 1; |
|
51688 lCb2 = (lCb1 + lCb2) >> 1; |
|
51689 |
|
51690 lCr3 = (lCr1 + lCr3) >> 1; |
|
51691 lCb3 = (lCb1 + lCb3) >> 1; |
|
51692 |
|
51693 /*First Pixel*/ |
|
51694 lCr1 -= 128; |
|
51695 lCb1 -= 128; |
|
51696 |
|
51697 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
51698 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
51699 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
51700 |
|
51701 lY1 = lLumPtr[j]; |
|
51702 |
|
51703 /*B component*/ |
|
51704 lTemp = lY1 + lTemp3; |
|
51705 if (lTemp < 0) |
|
51706 lTemp = 0; |
|
51707 if (lTemp > 255) |
|
51708 lTemp = 255; |
|
51709 lTemp4 = (lTemp >> 4); |
|
51710 |
|
51711 /*G component*/ |
|
51712 lTemp = lY1 - lTemp2 + 15; |
|
51713 if (lTemp < 0) |
|
51714 lTemp = 0; |
|
51715 if (lTemp > 255) |
|
51716 lTemp = 255; |
|
51717 lTemp4 |= (lTemp >> 4) << 4; |
|
51718 |
|
51719 /*R component*/ |
|
51720 lTemp = lY1 + lTemp1 + 5; |
|
51721 if (lTemp < 0) |
|
51722 lTemp = 0; |
|
51723 if (lTemp > 255) |
|
51724 lTemp = 255; |
|
51725 lTemp4 |= (lTemp >> 4) << 8; |
|
51726 |
|
51727 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
51728 |
|
51729 /*Second Pixel*/ |
|
51730 lCr2 -= 128; |
|
51731 lCb2 -= 128; |
|
51732 |
|
51733 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
51734 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
51735 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
51736 |
|
51737 lY1 = lLumPtr[j + 1]; |
|
51738 |
|
51739 /*B component*/ |
|
51740 lTemp = lY1 + lTemp3 + 10; |
|
51741 if (lTemp < 0) |
|
51742 lTemp = 0; |
|
51743 if (lTemp > 255) |
|
51744 lTemp = 255; |
|
51745 lTemp4 = (lTemp >> 4); |
|
51746 |
|
51747 /*G component*/ |
|
51748 lTemp = lY1 - lTemp2; |
|
51749 if (lTemp < 0) |
|
51750 lTemp = 0; |
|
51751 if (lTemp > 255) |
|
51752 lTemp = 255; |
|
51753 lTemp4 |= (lTemp >> 4) << 4; |
|
51754 |
|
51755 /*R component*/ |
|
51756 lTemp = lY1 + lTemp1 + 15; |
|
51757 if (lTemp < 0) |
|
51758 lTemp = 0; |
|
51759 if (lTemp > 255) |
|
51760 lTemp = 255; |
|
51761 lTemp4 |= (lTemp >> 4) << 8; |
|
51762 |
|
51763 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
51764 |
|
51765 |
|
51766 /*Third Pixel*/ |
|
51767 lCr3 -= 128; |
|
51768 lCb3 -= 128; |
|
51769 |
|
51770 lTemp1 = (22973 * lCr3) >> COLOR_CONV_PRECISION; |
|
51771 lTemp2 = ((5637 * lCb3) + (11699 * lCr3)) >> COLOR_CONV_PRECISION; |
|
51772 lTemp3 = (29032 * lCb3) >> COLOR_CONV_PRECISION; |
|
51773 |
|
51774 lY1 = lLumPtr[j + lLumWidth]; |
|
51775 |
|
51776 /*B component*/ |
|
51777 lTemp = lY1 + lTemp3 + 15; |
|
51778 if (lTemp < 0) |
|
51779 lTemp = 0; |
|
51780 if (lTemp > 255) |
|
51781 lTemp = 255; |
|
51782 lTemp4 = (lTemp >> 4); |
|
51783 |
|
51784 /*G component*/ |
|
51785 lTemp = lY1 - lTemp2 + 5; |
|
51786 if (lTemp < 0) |
|
51787 lTemp = 0; |
|
51788 if (lTemp > 255) |
|
51789 lTemp = 255; |
|
51790 lTemp4 |= (lTemp >> 4) << 4; |
|
51791 |
|
51792 /*R component*/ |
|
51793 lTemp = lY1 + lTemp1 + 10; |
|
51794 if (lTemp < 0) |
|
51795 lTemp = 0; |
|
51796 if (lTemp > 255) |
|
51797 lTemp = 255; |
|
51798 lTemp4 |= (lTemp >> 4) << 8; |
|
51799 |
|
51800 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
51801 |
|
51802 /*Fourth Pixel*/ |
|
51803 lCr4 -= 128; |
|
51804 lCb4 -= 128; |
|
51805 |
|
51806 lTemp1 = (22973 * lCr4) >> COLOR_CONV_PRECISION; |
|
51807 lTemp2 = ((5637 * lCb4) + (11699 * lCr4)) >> COLOR_CONV_PRECISION; |
|
51808 lTemp3 = (29032 * lCb4) >> COLOR_CONV_PRECISION; |
|
51809 |
|
51810 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
51811 |
|
51812 /*B component*/ |
|
51813 lTemp = lY1 + lTemp3 + 5; |
|
51814 if (lTemp < 0) |
|
51815 lTemp = 0; |
|
51816 if (lTemp > 255) |
|
51817 lTemp = 255; |
|
51818 lTemp4 = (lTemp >> 4); |
|
51819 |
|
51820 /*G component*/ |
|
51821 lTemp = lY1 - lTemp2 + 10; |
|
51822 if (lTemp < 0) |
|
51823 lTemp = 0; |
|
51824 if (lTemp > 255) |
|
51825 lTemp = 255; |
|
51826 lTemp4 |= (lTemp >> 4) << 4; |
|
51827 |
|
51828 /*R component*/ |
|
51829 lTemp = lY1 + lTemp1; |
|
51830 if (lTemp < 0) |
|
51831 lTemp = 0; |
|
51832 if (lTemp > 255) |
|
51833 lTemp = 255; |
|
51834 lTemp4 |= (lTemp >> 4) << 8; |
|
51835 |
|
51836 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
51837 |
|
51838 lRGBFramePtr += 2; |
|
51839 lRGBFramePtr1 += 2; |
|
51840 } |
|
51841 |
|
51842 |
|
51843 lCr1 = lCrPtr[j >> 1]; |
|
51844 lCb1 = lCbPtr[j >> 1]; |
|
51845 |
|
51846 lCr1 -= 128; |
|
51847 lCb1 -= 128; |
|
51848 |
|
51849 /*First Pixel*/ |
|
51850 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
51851 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
51852 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
51853 |
|
51854 lY1 = lLumPtr[j]; |
|
51855 |
|
51856 /*B component*/ |
|
51857 lTemp = lY1 + lTemp3; |
|
51858 if (lTemp < 0) |
|
51859 lTemp = 0; |
|
51860 if (lTemp > 255) |
|
51861 lTemp = 255; |
|
51862 lTemp4 = (lTemp >> 4); |
|
51863 |
|
51864 /*G component*/ |
|
51865 lTemp = lY1 - lTemp2 + 15; |
|
51866 if (lTemp < 0) |
|
51867 lTemp = 0; |
|
51868 if (lTemp > 255) |
|
51869 lTemp = 255; |
|
51870 lTemp4 |= (lTemp >> 4) << 4; |
|
51871 |
|
51872 /*R component*/ |
|
51873 lTemp = lY1 + lTemp1 + 5; |
|
51874 if (lTemp < 0) |
|
51875 lTemp = 0; |
|
51876 if (lTemp > 255) |
|
51877 lTemp = 255; |
|
51878 lTemp4 |= (lTemp >> 4) << 8; |
|
51879 |
|
51880 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
51881 |
|
51882 /*Second Pixel*/ |
|
51883 lY1 = lLumPtr[j + 1]; |
|
51884 |
|
51885 /*B component*/ |
|
51886 lTemp = lY1 + lTemp3 + 10; |
|
51887 if (lTemp < 0) |
|
51888 lTemp = 0; |
|
51889 if (lTemp > 255) |
|
51890 lTemp = 255; |
|
51891 lTemp4 = (lTemp >> 4); |
|
51892 |
|
51893 /*G component*/ |
|
51894 lTemp = lY1 - lTemp2; |
|
51895 if (lTemp < 0) |
|
51896 lTemp = 0; |
|
51897 if (lTemp > 255) |
|
51898 lTemp = 255; |
|
51899 lTemp4 |= (lTemp >> 4) << 4; |
|
51900 |
|
51901 /*R component*/ |
|
51902 lTemp = lY1 + lTemp1 + 15; |
|
51903 if (lTemp < 0) |
|
51904 lTemp = 0; |
|
51905 if (lTemp > 255) |
|
51906 lTemp = 255; |
|
51907 lTemp4 |= (lTemp >> 4) << 8; |
|
51908 |
|
51909 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
51910 |
|
51911 |
|
51912 /*Third Pixel*/ |
|
51913 lY1 = lLumPtr[j + lLumWidth]; |
|
51914 |
|
51915 /*B component*/ |
|
51916 lTemp = lY1 + lTemp3 + 15; |
|
51917 if (lTemp < 0) |
|
51918 lTemp = 0; |
|
51919 if (lTemp > 255) |
|
51920 lTemp = 255; |
|
51921 lTemp4 = (lTemp >> 4); |
|
51922 |
|
51923 /*G component*/ |
|
51924 lTemp = lY1 - lTemp2 + 5; |
|
51925 if (lTemp < 0) |
|
51926 lTemp = 0; |
|
51927 if (lTemp > 255) |
|
51928 lTemp = 255; |
|
51929 lTemp4 |= (lTemp >> 4) << 4; |
|
51930 |
|
51931 /*R component*/ |
|
51932 lTemp = lY1 + lTemp1 + 10; |
|
51933 if (lTemp < 0) |
|
51934 lTemp = 0; |
|
51935 if (lTemp > 255) |
|
51936 lTemp = 255; |
|
51937 lTemp4 |= (lTemp >> 4) << 8; |
|
51938 |
|
51939 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
51940 |
|
51941 /*Fourth Pixel*/ |
|
51942 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
51943 |
|
51944 /*B component*/ |
|
51945 lTemp = lY1 + lTemp3 + 5; |
|
51946 if (lTemp < 0) |
|
51947 lTemp = 0; |
|
51948 if (lTemp > 255) |
|
51949 lTemp = 255; |
|
51950 lTemp4 = (lTemp >> 4); |
|
51951 |
|
51952 /*G component*/ |
|
51953 lTemp = lY1 - lTemp2 + 10; |
|
51954 if (lTemp < 0) |
|
51955 lTemp = 0; |
|
51956 if (lTemp > 255) |
|
51957 lTemp = 255; |
|
51958 lTemp4 |= (lTemp >> 4) << 4; |
|
51959 |
|
51960 /*R component*/ |
|
51961 lTemp = lY1 + lTemp1; |
|
51962 if (lTemp < 0) |
|
51963 lTemp = 0; |
|
51964 if (lTemp > 255) |
|
51965 lTemp = 255; |
|
51966 lTemp4 |= (lTemp >> 4) << 8; |
|
51967 |
|
51968 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
51969 |
|
51970 lRGBFramePtr += 2; |
|
51971 lRGBFramePtr1 += 2; |
|
51972 |
|
51973 if(extraCol) |
|
51974 { |
|
51975 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
51976 lRGBFramePtr++; |
|
51977 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
51978 lRGBFramePtr1++; |
|
51979 } |
|
51980 |
|
51981 lLumPtr += (lLumWidth << 1); |
|
51982 lCrPtr += (lLumWidth >> 1); |
|
51983 lCbPtr += (lLumWidth >> 1); |
|
51984 |
|
51985 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
51986 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
51987 } |
|
51988 |
|
51989 |
|
51990 for(j = 0; j < lWidth; j += 2) |
|
51991 { |
|
51992 lCr1 = lCrPtr[j >> 1]; |
|
51993 lCb1 = lCbPtr[j >> 1]; |
|
51994 |
|
51995 lCr1 -= 128; |
|
51996 lCb1 -= 128; |
|
51997 |
|
51998 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
51999 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
52000 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
52001 |
|
52002 /*First Pixel*/ |
|
52003 lY1 = lLumPtr[j]; |
|
52004 |
|
52005 /*B component*/ |
|
52006 lTemp = lY1 + lTemp3; |
|
52007 if (lTemp < 0) |
|
52008 lTemp = 0; |
|
52009 if (lTemp > 255) |
|
52010 lTemp = 255; |
|
52011 lTemp4 = (lTemp >> 4); |
|
52012 |
|
52013 /*G component*/ |
|
52014 lTemp = lY1 - lTemp2 + 15; |
|
52015 if (lTemp < 0) |
|
52016 lTemp = 0; |
|
52017 if (lTemp > 255) |
|
52018 lTemp = 255; |
|
52019 lTemp4 |= (lTemp >> 4) << 4; |
|
52020 |
|
52021 /*R component*/ |
|
52022 lTemp = lY1 + lTemp1 + 5; |
|
52023 if (lTemp < 0) |
|
52024 lTemp = 0; |
|
52025 if (lTemp > 255) |
|
52026 lTemp = 255; |
|
52027 lTemp4 |= (lTemp >> 4) << 8; |
|
52028 |
|
52029 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
52030 |
|
52031 /*Second Pixel*/ |
|
52032 lY1 = lLumPtr[j + 1]; |
|
52033 |
|
52034 /*B component*/ |
|
52035 lTemp = lY1 + lTemp3 + 10; |
|
52036 if (lTemp < 0) |
|
52037 lTemp = 0; |
|
52038 if (lTemp > 255) |
|
52039 lTemp = 255; |
|
52040 lTemp4 = (lTemp >> 4); |
|
52041 |
|
52042 /*G component*/ |
|
52043 lTemp = lY1 - lTemp2; |
|
52044 if (lTemp < 0) |
|
52045 lTemp = 0; |
|
52046 if (lTemp > 255) |
|
52047 lTemp = 255; |
|
52048 lTemp4 |= (lTemp >> 4) << 4; |
|
52049 |
|
52050 /*R component*/ |
|
52051 lTemp = lY1 + lTemp1 + 15; |
|
52052 if (lTemp < 0) |
|
52053 lTemp = 0; |
|
52054 if (lTemp > 255) |
|
52055 lTemp = 255; |
|
52056 lTemp4 |= (lTemp >> 4) << 8; |
|
52057 |
|
52058 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
52059 |
|
52060 |
|
52061 /*Third Pixel*/ |
|
52062 lY1 = lLumPtr[j + lLumWidth]; |
|
52063 |
|
52064 /*B component*/ |
|
52065 lTemp = lY1 + lTemp3 + 15; |
|
52066 if (lTemp < 0) |
|
52067 lTemp = 0; |
|
52068 if (lTemp > 255) |
|
52069 lTemp = 255; |
|
52070 lTemp4 = (lTemp >> 4); |
|
52071 |
|
52072 /*G component*/ |
|
52073 lTemp = lY1 - lTemp2 + 5; |
|
52074 if (lTemp < 0) |
|
52075 lTemp = 0; |
|
52076 if (lTemp > 255) |
|
52077 lTemp = 255; |
|
52078 lTemp4 |= (lTemp >> 4) << 4; |
|
52079 |
|
52080 /*R component*/ |
|
52081 lTemp = lY1 + lTemp1 + 10; |
|
52082 if (lTemp < 0) |
|
52083 lTemp = 0; |
|
52084 if (lTemp > 255) |
|
52085 lTemp = 255; |
|
52086 lTemp4 |= (lTemp >> 4) << 8; |
|
52087 |
|
52088 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
52089 |
|
52090 /*Fourth Pixel*/ |
|
52091 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
52092 |
|
52093 /*B component*/ |
|
52094 lTemp = lY1 + lTemp3 + 5; |
|
52095 if (lTemp < 0) |
|
52096 lTemp = 0; |
|
52097 if (lTemp > 255) |
|
52098 lTemp = 255; |
|
52099 lTemp4 = (lTemp >> 4); |
|
52100 |
|
52101 /*G component*/ |
|
52102 lTemp = lY1 - lTemp2 + 10; |
|
52103 if (lTemp < 0) |
|
52104 lTemp = 0; |
|
52105 if (lTemp > 255) |
|
52106 lTemp = 255; |
|
52107 lTemp4 |= (lTemp >> 4) << 4; |
|
52108 |
|
52109 /*R component*/ |
|
52110 lTemp = lY1 + lTemp1; |
|
52111 if (lTemp < 0) |
|
52112 lTemp = 0; |
|
52113 if (lTemp > 255) |
|
52114 lTemp = 255; |
|
52115 lTemp4 |= (lTemp >> 4) << 8; |
|
52116 |
|
52117 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
52118 |
|
52119 lRGBFramePtr += 2; |
|
52120 lRGBFramePtr1 += 2; |
|
52121 } |
|
52122 |
|
52123 if(extraCol) |
|
52124 { |
|
52125 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
52126 lRGBFramePtr++; |
|
52127 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
52128 lRGBFramePtr1++; |
|
52129 } |
|
52130 |
|
52131 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
52132 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
52133 |
|
52134 if(extraRow) |
|
52135 { |
|
52136 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
52137 for(j = 0; j < lWidth; j += 2) |
|
52138 { |
|
52139 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
52140 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
52141 } |
|
52142 if(extraCol) |
|
52143 { |
|
52144 *lRGBFramePtr = *lRGBFramePtr1; |
|
52145 } |
|
52146 } |
|
52147 return; |
|
52148 } |
|
52149 |
|
52150 /* |
|
52151 ****************************************************************************** |
|
52152 Name : sEmz_VDec_YUV420Chr3toColor4k_Ordered_709_RR |
|
52153 Description : Converts YUV420 Chroma3 Planar to XRGB (4:4:4:4) Interleaved format |
|
52154 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
52155 uint8 *dstImage : Pointer to rgb data (o/p). |
|
52156 tWndParam *srcWindow : Pointer to structure containing source window |
|
52157 parameters like xOffset,yOffset,cropWidth, |
|
52158 cropHeight. (i/p) |
|
52159 tWndParam *dstWindow : Pointer to structure containing destination window |
|
52160 parameters like xOffset,yOffset,windWidth, |
|
52161 windHeight. (i/p) |
|
52162 Return Value : void |
|
52163 ****************************************************************************** |
|
52164 */ |
|
52165 |
|
52166 void sEmz_VDec_YUV420Chr3toColor4k_Ordered_709_RR |
|
52167 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
52168 tWndParam* srcWindow, tWndParam* dstWindow) |
|
52169 { |
|
52170 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
52171 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
52172 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
52173 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
52174 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
52175 int32 i, j, extraRow, extraCol; |
|
52176 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
52177 cropWidth,cropHeight,wndWidth,wndHeight; |
|
52178 |
|
52179 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
52180 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
52181 |
|
52182 | {0,15,5} {10,0,15} | |
|
52183 | {15,5,10} {5,10,0} | */ |
|
52184 |
|
52185 srcXOffset = srcWindow->xOffset; |
|
52186 srcYOffset = srcWindow->yOffset; |
|
52187 cropWidth = srcWindow->wndWidth; |
|
52188 cropHeight = srcWindow->wndHeight; |
|
52189 |
|
52190 dstXOffset = dstWindow->xOffset; |
|
52191 dstYOffset = dstWindow->yOffset; |
|
52192 wndWidth = dstWindow->wndWidth; |
|
52193 wndHeight = dstWindow->wndHeight; |
|
52194 |
|
52195 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
52196 { |
|
52197 lWidth = cropWidth; |
|
52198 } |
|
52199 else |
|
52200 { |
|
52201 lWidth = srcImage->width - srcXOffset; |
|
52202 } |
|
52203 |
|
52204 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
52205 { |
|
52206 lHeight = cropHeight; |
|
52207 } |
|
52208 else |
|
52209 { |
|
52210 lHeight = srcImage->height - srcYOffset; |
|
52211 } |
|
52212 |
|
52213 if (lWidth > (wndWidth - dstXOffset)) |
|
52214 { |
|
52215 lWidth = wndWidth - dstXOffset; |
|
52216 } |
|
52217 |
|
52218 if (lHeight > (wndHeight - dstYOffset)) |
|
52219 { |
|
52220 lHeight = wndHeight - dstYOffset; |
|
52221 } |
|
52222 |
|
52223 extraCol = lWidth & 0x01; |
|
52224 extraRow = lHeight & 0x01; |
|
52225 |
|
52226 lTempWidth = lWidth; |
|
52227 lWidth = (lWidth >> 1) << 1; |
|
52228 lHeight = (lHeight >> 1) << 1; |
|
52229 |
|
52230 lLumWidth = (srcImage->width >> 1) << 1; |
|
52231 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
52232 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
52233 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
52234 |
|
52235 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
52236 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
52237 |
|
52238 for(i = 0; i < (lHeight - 2); i += 2) |
|
52239 { |
|
52240 for(j = 0; j < (lWidth - 2); j += 2) |
|
52241 { |
|
52242 lCr1 = lCrPtr[j >> 1]; |
|
52243 lCb1 = lCbPtr[j >> 1]; |
|
52244 |
|
52245 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
52246 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
52247 |
|
52248 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
52249 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
52250 |
|
52251 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
52252 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
52253 |
|
52254 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
52255 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
52256 |
|
52257 lCr2 = (lCr1 + lCr2) >> 1; |
|
52258 lCb2 = (lCb1 + lCb2) >> 1; |
|
52259 |
|
52260 lCr3 = (lCr1 + lCr3) >> 1; |
|
52261 lCb3 = (lCb1 + lCb3) >> 1; |
|
52262 |
|
52263 /*First Pixel*/ |
|
52264 lCr1 -= 128; |
|
52265 lCb1 -= 128; |
|
52266 |
|
52267 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
52268 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
52269 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
52270 |
|
52271 lY1 = lLumPtr[j]; |
|
52272 lY1 -= 16; |
|
52273 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52274 |
|
52275 /*B component*/ |
|
52276 lTemp = lY1 + lTemp3; |
|
52277 if (lTemp < 0) |
|
52278 lTemp = 0; |
|
52279 if (lTemp > 255) |
|
52280 lTemp = 255; |
|
52281 lTemp4 = (lTemp >> 4); |
|
52282 |
|
52283 /*G component*/ |
|
52284 lTemp = lY1 - lTemp2 + 15; |
|
52285 if (lTemp < 0) |
|
52286 lTemp = 0; |
|
52287 if (lTemp > 255) |
|
52288 lTemp = 255; |
|
52289 lTemp4 |= (lTemp >> 4) << 4; |
|
52290 |
|
52291 /*R component*/ |
|
52292 lTemp = lY1 + lTemp1 + 5; |
|
52293 if (lTemp < 0) |
|
52294 lTemp = 0; |
|
52295 if (lTemp > 255) |
|
52296 lTemp = 255; |
|
52297 lTemp4 |= (lTemp >> 4) << 8; |
|
52298 |
|
52299 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
52300 |
|
52301 /*Second Pixel*/ |
|
52302 lCr2 -= 128; |
|
52303 lCb2 -= 128; |
|
52304 |
|
52305 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
52306 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
52307 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
52308 |
|
52309 lY1 = lLumPtr[j + 1]; |
|
52310 lY1 -= 16; |
|
52311 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52312 |
|
52313 /*B component*/ |
|
52314 lTemp = lY1 + lTemp3 + 10; |
|
52315 if (lTemp < 0) |
|
52316 lTemp = 0; |
|
52317 if (lTemp > 255) |
|
52318 lTemp = 255; |
|
52319 lTemp4 = (lTemp >> 4); |
|
52320 |
|
52321 /*G component*/ |
|
52322 lTemp = lY1 - lTemp2; |
|
52323 if (lTemp < 0) |
|
52324 lTemp = 0; |
|
52325 if (lTemp > 255) |
|
52326 lTemp = 255; |
|
52327 lTemp4 |= (lTemp >> 4) << 4; |
|
52328 |
|
52329 /*R component*/ |
|
52330 lTemp = lY1 + lTemp1 + 15; |
|
52331 if (lTemp < 0) |
|
52332 lTemp = 0; |
|
52333 if (lTemp > 255) |
|
52334 lTemp = 255; |
|
52335 lTemp4 |= (lTemp >> 4) << 8; |
|
52336 |
|
52337 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
52338 |
|
52339 |
|
52340 /*Third Pixel*/ |
|
52341 lCr3 -= 128; |
|
52342 lCb3 -= 128; |
|
52343 |
|
52344 lTemp1 = (29374 * lCr3) >> COLOR_CONV_PRECISION; |
|
52345 lTemp2 = ((3494 * lCb3) + (8731 * lCr3)) >> COLOR_CONV_PRECISION; |
|
52346 lTemp3 = (34603 * lCb3) >> COLOR_CONV_PRECISION; |
|
52347 |
|
52348 lY1 = lLumPtr[j + lLumWidth]; |
|
52349 lY1 -= 16; |
|
52350 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52351 |
|
52352 /*B component*/ |
|
52353 lTemp = lY1 + lTemp3 + 15; |
|
52354 if (lTemp < 0) |
|
52355 lTemp = 0; |
|
52356 if (lTemp > 255) |
|
52357 lTemp = 255; |
|
52358 lTemp4 = (lTemp >> 4); |
|
52359 |
|
52360 /*G component*/ |
|
52361 lTemp = lY1 - lTemp2 + 5; |
|
52362 if (lTemp < 0) |
|
52363 lTemp = 0; |
|
52364 if (lTemp > 255) |
|
52365 lTemp = 255; |
|
52366 lTemp4 |= (lTemp >> 4) << 4; |
|
52367 |
|
52368 /*R component*/ |
|
52369 lTemp = lY1 + lTemp1 + 10; |
|
52370 if (lTemp < 0) |
|
52371 lTemp = 0; |
|
52372 if (lTemp > 255) |
|
52373 lTemp = 255; |
|
52374 lTemp4 |= (lTemp >> 4) << 8; |
|
52375 |
|
52376 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
52377 |
|
52378 /*Fourth Pixel*/ |
|
52379 lCr4 -= 128; |
|
52380 lCb4 -= 128; |
|
52381 |
|
52382 lTemp1 = (29374 * lCr4) >> COLOR_CONV_PRECISION; |
|
52383 lTemp2 = ((3494 * lCb4) + (8731 * lCr4)) >> COLOR_CONV_PRECISION; |
|
52384 lTemp3 = (34603 * lCb4) >> COLOR_CONV_PRECISION; |
|
52385 |
|
52386 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
52387 lY1 -= 16; |
|
52388 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52389 |
|
52390 /*B component*/ |
|
52391 lTemp = lY1 + lTemp3 + 5; |
|
52392 if (lTemp < 0) |
|
52393 lTemp = 0; |
|
52394 if (lTemp > 255) |
|
52395 lTemp = 255; |
|
52396 lTemp4 = (lTemp >> 4); |
|
52397 |
|
52398 /*G component*/ |
|
52399 lTemp = lY1 - lTemp2 + 10; |
|
52400 if (lTemp < 0) |
|
52401 lTemp = 0; |
|
52402 if (lTemp > 255) |
|
52403 lTemp = 255; |
|
52404 lTemp4 |= (lTemp >> 4) << 4; |
|
52405 |
|
52406 /*R component*/ |
|
52407 lTemp = lY1 + lTemp1; |
|
52408 if (lTemp < 0) |
|
52409 lTemp = 0; |
|
52410 if (lTemp > 255) |
|
52411 lTemp = 255; |
|
52412 lTemp4 |= (lTemp >> 4) << 8; |
|
52413 |
|
52414 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
52415 |
|
52416 lRGBFramePtr += 2; |
|
52417 lRGBFramePtr1 += 2; |
|
52418 } |
|
52419 |
|
52420 |
|
52421 lCr1 = lCrPtr[j >> 1]; |
|
52422 lCb1 = lCbPtr[j >> 1]; |
|
52423 |
|
52424 lCr1 -= 128; |
|
52425 lCb1 -= 128; |
|
52426 |
|
52427 /*First Pixel*/ |
|
52428 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
52429 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
52430 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
52431 |
|
52432 lY1 = lLumPtr[j]; |
|
52433 lY1 -= 16; |
|
52434 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52435 |
|
52436 /*B component*/ |
|
52437 lTemp = lY1 + lTemp3; |
|
52438 if (lTemp < 0) |
|
52439 lTemp = 0; |
|
52440 if (lTemp > 255) |
|
52441 lTemp = 255; |
|
52442 lTemp4 = (lTemp >> 4); |
|
52443 |
|
52444 /*G component*/ |
|
52445 lTemp = lY1 - lTemp2 + 15; |
|
52446 if (lTemp < 0) |
|
52447 lTemp = 0; |
|
52448 if (lTemp > 255) |
|
52449 lTemp = 255; |
|
52450 lTemp4 |= (lTemp >> 4) << 4; |
|
52451 |
|
52452 /*R component*/ |
|
52453 lTemp = lY1 + lTemp1 + 5; |
|
52454 if (lTemp < 0) |
|
52455 lTemp = 0; |
|
52456 if (lTemp > 255) |
|
52457 lTemp = 255; |
|
52458 lTemp4 |= (lTemp >> 4) << 8; |
|
52459 |
|
52460 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
52461 |
|
52462 /*Second Pixel*/ |
|
52463 lY1 = lLumPtr[j + 1]; |
|
52464 lY1 -= 16; |
|
52465 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52466 |
|
52467 /*B component*/ |
|
52468 lTemp = lY1 + lTemp3 + 10; |
|
52469 if (lTemp < 0) |
|
52470 lTemp = 0; |
|
52471 if (lTemp > 255) |
|
52472 lTemp = 255; |
|
52473 lTemp4 = (lTemp >> 4); |
|
52474 |
|
52475 /*G component*/ |
|
52476 lTemp = lY1 - lTemp2; |
|
52477 if (lTemp < 0) |
|
52478 lTemp = 0; |
|
52479 if (lTemp > 255) |
|
52480 lTemp = 255; |
|
52481 lTemp4 |= (lTemp >> 4) << 4; |
|
52482 |
|
52483 /*R component*/ |
|
52484 lTemp = lY1 + lTemp1 + 15; |
|
52485 if (lTemp < 0) |
|
52486 lTemp = 0; |
|
52487 if (lTemp > 255) |
|
52488 lTemp = 255; |
|
52489 lTemp4 |= (lTemp >> 4) << 8; |
|
52490 |
|
52491 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
52492 |
|
52493 |
|
52494 /*Third Pixel*/ |
|
52495 lY1 = lLumPtr[j + lLumWidth]; |
|
52496 lY1 -= 16; |
|
52497 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52498 |
|
52499 /*B component*/ |
|
52500 lTemp = lY1 + lTemp3 + 15; |
|
52501 if (lTemp < 0) |
|
52502 lTemp = 0; |
|
52503 if (lTemp > 255) |
|
52504 lTemp = 255; |
|
52505 lTemp4 = (lTemp >> 4); |
|
52506 |
|
52507 /*G component*/ |
|
52508 lTemp = lY1 - lTemp2 + 5; |
|
52509 if (lTemp < 0) |
|
52510 lTemp = 0; |
|
52511 if (lTemp > 255) |
|
52512 lTemp = 255; |
|
52513 lTemp4 |= (lTemp >> 4) << 4; |
|
52514 |
|
52515 /*R component*/ |
|
52516 lTemp = lY1 + lTemp1 + 10; |
|
52517 if (lTemp < 0) |
|
52518 lTemp = 0; |
|
52519 if (lTemp > 255) |
|
52520 lTemp = 255; |
|
52521 lTemp4 |= (lTemp >> 4) << 8; |
|
52522 |
|
52523 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
52524 |
|
52525 /*Fourth Pixel*/ |
|
52526 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
52527 lY1 -= 16; |
|
52528 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52529 |
|
52530 /*B component*/ |
|
52531 lTemp = lY1 + lTemp3 + 5; |
|
52532 if (lTemp < 0) |
|
52533 lTemp = 0; |
|
52534 if (lTemp > 255) |
|
52535 lTemp = 255; |
|
52536 lTemp4 = (lTemp >> 4); |
|
52537 |
|
52538 /*G component*/ |
|
52539 lTemp = lY1 - lTemp2 + 10; |
|
52540 if (lTemp < 0) |
|
52541 lTemp = 0; |
|
52542 if (lTemp > 255) |
|
52543 lTemp = 255; |
|
52544 lTemp4 |= (lTemp >> 4) << 4; |
|
52545 |
|
52546 /*R component*/ |
|
52547 lTemp = lY1 + lTemp1; |
|
52548 if (lTemp < 0) |
|
52549 lTemp = 0; |
|
52550 if (lTemp > 255) |
|
52551 lTemp = 255; |
|
52552 lTemp4 |= (lTemp >> 4) << 8; |
|
52553 |
|
52554 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
52555 |
|
52556 lRGBFramePtr += 2; |
|
52557 lRGBFramePtr1 += 2; |
|
52558 |
|
52559 if(extraCol) |
|
52560 { |
|
52561 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
52562 lRGBFramePtr++; |
|
52563 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
52564 lRGBFramePtr1++; |
|
52565 } |
|
52566 |
|
52567 lLumPtr += (lLumWidth << 1); |
|
52568 lCrPtr += (lLumWidth >> 1); |
|
52569 lCbPtr += (lLumWidth >> 1); |
|
52570 |
|
52571 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
52572 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
52573 } |
|
52574 |
|
52575 |
|
52576 for(j = 0; j < lWidth; j += 2) |
|
52577 { |
|
52578 lCr1 = lCrPtr[j >> 1]; |
|
52579 lCb1 = lCbPtr[j >> 1]; |
|
52580 |
|
52581 lCr1 -= 128; |
|
52582 lCb1 -= 128; |
|
52583 |
|
52584 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
52585 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
52586 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
52587 |
|
52588 /*First Pixel*/ |
|
52589 lY1 = lLumPtr[j]; |
|
52590 lY1 -= 16; |
|
52591 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52592 |
|
52593 /*B component*/ |
|
52594 lTemp = lY1 + lTemp3; |
|
52595 if (lTemp < 0) |
|
52596 lTemp = 0; |
|
52597 if (lTemp > 255) |
|
52598 lTemp = 255; |
|
52599 lTemp4 = (lTemp >> 4); |
|
52600 |
|
52601 /*G component*/ |
|
52602 lTemp = lY1 - lTemp2 + 15; |
|
52603 if (lTemp < 0) |
|
52604 lTemp = 0; |
|
52605 if (lTemp > 255) |
|
52606 lTemp = 255; |
|
52607 lTemp4 |= (lTemp >> 4) << 4; |
|
52608 |
|
52609 /*R component*/ |
|
52610 lTemp = lY1 + lTemp1 + 5; |
|
52611 if (lTemp < 0) |
|
52612 lTemp = 0; |
|
52613 if (lTemp > 255) |
|
52614 lTemp = 255; |
|
52615 lTemp4 |= (lTemp >> 4) << 8; |
|
52616 |
|
52617 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
52618 |
|
52619 /*Second Pixel*/ |
|
52620 lY1 = lLumPtr[j + 1]; |
|
52621 lY1 -= 16; |
|
52622 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52623 |
|
52624 /*B component*/ |
|
52625 lTemp = lY1 + lTemp3 + 10; |
|
52626 if (lTemp < 0) |
|
52627 lTemp = 0; |
|
52628 if (lTemp > 255) |
|
52629 lTemp = 255; |
|
52630 lTemp4 = (lTemp >> 4); |
|
52631 |
|
52632 /*G component*/ |
|
52633 lTemp = lY1 - lTemp2; |
|
52634 if (lTemp < 0) |
|
52635 lTemp = 0; |
|
52636 if (lTemp > 255) |
|
52637 lTemp = 255; |
|
52638 lTemp4 |= (lTemp >> 4) << 4; |
|
52639 |
|
52640 /*R component*/ |
|
52641 lTemp = lY1 + lTemp1 + 15; |
|
52642 if (lTemp < 0) |
|
52643 lTemp = 0; |
|
52644 if (lTemp > 255) |
|
52645 lTemp = 255; |
|
52646 lTemp4 |= (lTemp >> 4) << 8; |
|
52647 |
|
52648 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
52649 |
|
52650 |
|
52651 /*Third Pixel*/ |
|
52652 lY1 = lLumPtr[j + lLumWidth]; |
|
52653 lY1 -= 16; |
|
52654 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52655 |
|
52656 /*B component*/ |
|
52657 lTemp = lY1 + lTemp3 + 15; |
|
52658 if (lTemp < 0) |
|
52659 lTemp = 0; |
|
52660 if (lTemp > 255) |
|
52661 lTemp = 255; |
|
52662 lTemp4 = (lTemp >> 4); |
|
52663 |
|
52664 /*G component*/ |
|
52665 lTemp = lY1 - lTemp2 + 5; |
|
52666 if (lTemp < 0) |
|
52667 lTemp = 0; |
|
52668 if (lTemp > 255) |
|
52669 lTemp = 255; |
|
52670 lTemp4 |= (lTemp >> 4) << 4; |
|
52671 |
|
52672 /*R component*/ |
|
52673 lTemp = lY1 + lTemp1 + 10; |
|
52674 if (lTemp < 0) |
|
52675 lTemp = 0; |
|
52676 if (lTemp > 255) |
|
52677 lTemp = 255; |
|
52678 lTemp4 |= (lTemp >> 4) << 8; |
|
52679 |
|
52680 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
52681 |
|
52682 /*Fourth Pixel*/ |
|
52683 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
52684 lY1 -= 16; |
|
52685 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52686 |
|
52687 /*B component*/ |
|
52688 lTemp = lY1 + lTemp3 + 5; |
|
52689 if (lTemp < 0) |
|
52690 lTemp = 0; |
|
52691 if (lTemp > 255) |
|
52692 lTemp = 255; |
|
52693 lTemp4 = (lTemp >> 4); |
|
52694 |
|
52695 /*G component*/ |
|
52696 lTemp = lY1 - lTemp2 + 10; |
|
52697 if (lTemp < 0) |
|
52698 lTemp = 0; |
|
52699 if (lTemp > 255) |
|
52700 lTemp = 255; |
|
52701 lTemp4 |= (lTemp >> 4) << 4; |
|
52702 |
|
52703 /*R component*/ |
|
52704 lTemp = lY1 + lTemp1; |
|
52705 if (lTemp < 0) |
|
52706 lTemp = 0; |
|
52707 if (lTemp > 255) |
|
52708 lTemp = 255; |
|
52709 lTemp4 |= (lTemp >> 4) << 8; |
|
52710 |
|
52711 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
52712 |
|
52713 lRGBFramePtr += 2; |
|
52714 lRGBFramePtr1 += 2; |
|
52715 } |
|
52716 |
|
52717 if(extraCol) |
|
52718 { |
|
52719 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
52720 lRGBFramePtr++; |
|
52721 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
52722 lRGBFramePtr1++; |
|
52723 } |
|
52724 |
|
52725 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
52726 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
52727 |
|
52728 if(extraRow) |
|
52729 { |
|
52730 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
52731 for(j = 0; j < lWidth; j += 2) |
|
52732 { |
|
52733 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
52734 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
52735 } |
|
52736 if(extraCol) |
|
52737 { |
|
52738 *lRGBFramePtr = *lRGBFramePtr1; |
|
52739 } |
|
52740 } |
|
52741 return; |
|
52742 } |
|
52743 |
|
52744 /* |
|
52745 ****************************************************************************** |
|
52746 Name : sEmz_VDec_YUV420Chr3toColor4k_Ordered_601_5_RR |
|
52747 Description : Converts YUV420 Chroma3 Planar to XRGB (4:4:4:4) Interleaved format |
|
52748 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
52749 uint8 *dstImage : Pointer to rgb data (o/p). |
|
52750 tWndParam *srcWindow : Pointer to structure containing source window |
|
52751 parameters like xOffset,yOffset,cropWidth, |
|
52752 cropHeight. (i/p) |
|
52753 tWndParam *dstWindow : Pointer to structure containing destination window |
|
52754 parameters like xOffset,yOffset,windWidth, |
|
52755 windHeight. (i/p) |
|
52756 Return Value : void |
|
52757 ****************************************************************************** |
|
52758 */ |
|
52759 |
|
52760 void sEmz_VDec_YUV420Chr3toColor4k_Ordered_601_5_RR |
|
52761 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
52762 tWndParam* srcWindow, tWndParam* dstWindow) |
|
52763 { |
|
52764 uint16 *lRGBFramePtr, *lRGBFramePtr1; |
|
52765 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
52766 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
52767 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
52768 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
52769 int32 i, j, extraRow, extraCol; |
|
52770 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
52771 cropWidth,cropHeight,wndWidth,wndHeight; |
|
52772 |
|
52773 /* This function performs YUV to RGB conversion with dithering for 12-bit |
|
52774 {4,4,4} RGB. The 2x2 dither pattern used for {R,G,B} colors is as follows: |
|
52775 |
|
52776 | {0,15,5} {10,0,15} | |
|
52777 | {15,5,10} {5,10,0} | */ |
|
52778 |
|
52779 srcXOffset = srcWindow->xOffset; |
|
52780 srcYOffset = srcWindow->yOffset; |
|
52781 cropWidth = srcWindow->wndWidth; |
|
52782 cropHeight = srcWindow->wndHeight; |
|
52783 |
|
52784 dstXOffset = dstWindow->xOffset; |
|
52785 dstYOffset = dstWindow->yOffset; |
|
52786 wndWidth = dstWindow->wndWidth; |
|
52787 wndHeight = dstWindow->wndHeight; |
|
52788 |
|
52789 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
52790 { |
|
52791 lWidth = cropWidth; |
|
52792 } |
|
52793 else |
|
52794 { |
|
52795 lWidth = srcImage->width - srcXOffset; |
|
52796 } |
|
52797 |
|
52798 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
52799 { |
|
52800 lHeight = cropHeight; |
|
52801 } |
|
52802 else |
|
52803 { |
|
52804 lHeight = srcImage->height - srcYOffset; |
|
52805 } |
|
52806 |
|
52807 if (lWidth > (wndWidth - dstXOffset)) |
|
52808 { |
|
52809 lWidth = wndWidth - dstXOffset; |
|
52810 } |
|
52811 |
|
52812 if (lHeight > (wndHeight - dstYOffset)) |
|
52813 { |
|
52814 lHeight = wndHeight - dstYOffset; |
|
52815 } |
|
52816 |
|
52817 extraCol = lWidth & 0x01; |
|
52818 extraRow = lHeight & 0x01; |
|
52819 |
|
52820 lTempWidth = lWidth; |
|
52821 lWidth = (lWidth >> 1) << 1; |
|
52822 lHeight = (lHeight >> 1) << 1; |
|
52823 |
|
52824 lLumWidth = (srcImage->width >> 1) << 1; |
|
52825 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
52826 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
52827 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
52828 |
|
52829 lRGBFramePtr = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
52830 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
52831 |
|
52832 for(i = 0; i < (lHeight - 2); i += 2) |
|
52833 { |
|
52834 for(j = 0; j < (lWidth - 2); j += 2) |
|
52835 { |
|
52836 lCr1 = lCrPtr[j >> 1]; |
|
52837 lCb1 = lCbPtr[j >> 1]; |
|
52838 |
|
52839 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
52840 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
52841 |
|
52842 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
52843 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
52844 |
|
52845 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
52846 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
52847 |
|
52848 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
52849 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
52850 |
|
52851 lCr2 = (lCr1 + lCr2) >> 1; |
|
52852 lCb2 = (lCb1 + lCb2) >> 1; |
|
52853 |
|
52854 lCr3 = (lCr1 + lCr3) >> 1; |
|
52855 lCb3 = (lCb1 + lCb3) >> 1; |
|
52856 |
|
52857 /*First Pixel*/ |
|
52858 lCr1 -= 128; |
|
52859 lCb1 -= 128; |
|
52860 |
|
52861 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
52862 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
52863 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
52864 |
|
52865 lY1 = lLumPtr[j]; |
|
52866 lY1 -= 16; |
|
52867 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52868 |
|
52869 /*B component*/ |
|
52870 lTemp = lY1 + lTemp3; |
|
52871 if (lTemp < 0) |
|
52872 lTemp = 0; |
|
52873 if (lTemp > 255) |
|
52874 lTemp = 255; |
|
52875 lTemp4 = (lTemp >> 4); |
|
52876 |
|
52877 /*G component*/ |
|
52878 lTemp = lY1 - lTemp2 + 15; |
|
52879 if (lTemp < 0) |
|
52880 lTemp = 0; |
|
52881 if (lTemp > 255) |
|
52882 lTemp = 255; |
|
52883 lTemp4 |= (lTemp >> 4) << 4; |
|
52884 |
|
52885 /*R component*/ |
|
52886 lTemp = lY1 + lTemp1 + 5; |
|
52887 if (lTemp < 0) |
|
52888 lTemp = 0; |
|
52889 if (lTemp > 255) |
|
52890 lTemp = 255; |
|
52891 lTemp4 |= (lTemp >> 4) << 8; |
|
52892 |
|
52893 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
52894 |
|
52895 /*Second Pixel*/ |
|
52896 lCr2 -= 128; |
|
52897 lCb2 -= 128; |
|
52898 |
|
52899 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
52900 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
52901 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
52902 |
|
52903 lY1 = lLumPtr[j + 1]; |
|
52904 lY1 -= 16; |
|
52905 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52906 |
|
52907 /*B component*/ |
|
52908 lTemp = lY1 + lTemp3 + 10; |
|
52909 if (lTemp < 0) |
|
52910 lTemp = 0; |
|
52911 if (lTemp > 255) |
|
52912 lTemp = 255; |
|
52913 lTemp4 = (lTemp >> 4); |
|
52914 |
|
52915 /*G component*/ |
|
52916 lTemp = lY1 - lTemp2; |
|
52917 if (lTemp < 0) |
|
52918 lTemp = 0; |
|
52919 if (lTemp > 255) |
|
52920 lTemp = 255; |
|
52921 lTemp4 |= (lTemp >> 4) << 4; |
|
52922 |
|
52923 /*R component*/ |
|
52924 lTemp = lY1 + lTemp1 + 15; |
|
52925 if (lTemp < 0) |
|
52926 lTemp = 0; |
|
52927 if (lTemp > 255) |
|
52928 lTemp = 255; |
|
52929 lTemp4 |= (lTemp >> 4) << 8; |
|
52930 |
|
52931 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
52932 |
|
52933 |
|
52934 /*Third Pixel*/ |
|
52935 lCr3 -= 128; |
|
52936 lCb3 -= 128; |
|
52937 |
|
52938 lTemp1 = (26748 * lCr3) >> COLOR_CONV_PRECISION; |
|
52939 lTemp2 = ((6563 * lCb3) + (13621 * lCr3)) >> COLOR_CONV_PRECISION; |
|
52940 lTemp3 = (33802 * lCb3) >> COLOR_CONV_PRECISION; |
|
52941 |
|
52942 lY1 = lLumPtr[j + lLumWidth]; |
|
52943 lY1 -= 16; |
|
52944 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52945 |
|
52946 /*B component*/ |
|
52947 lTemp = lY1 + lTemp3 + 15; |
|
52948 if (lTemp < 0) |
|
52949 lTemp = 0; |
|
52950 if (lTemp > 255) |
|
52951 lTemp = 255; |
|
52952 lTemp4 = (lTemp >> 4); |
|
52953 |
|
52954 /*G component*/ |
|
52955 lTemp = lY1 - lTemp2 + 5; |
|
52956 if (lTemp < 0) |
|
52957 lTemp = 0; |
|
52958 if (lTemp > 255) |
|
52959 lTemp = 255; |
|
52960 lTemp4 |= (lTemp >> 4) << 4; |
|
52961 |
|
52962 /*R component*/ |
|
52963 lTemp = lY1 + lTemp1 + 10; |
|
52964 if (lTemp < 0) |
|
52965 lTemp = 0; |
|
52966 if (lTemp > 255) |
|
52967 lTemp = 255; |
|
52968 lTemp4 |= (lTemp >> 4) << 8; |
|
52969 |
|
52970 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
52971 |
|
52972 /*Fourth Pixel*/ |
|
52973 lCr4 -= 128; |
|
52974 lCb4 -= 128; |
|
52975 |
|
52976 lTemp1 = (26748 * lCr4) >> COLOR_CONV_PRECISION; |
|
52977 lTemp2 = ((6563 * lCb4) + (13621 * lCr4)) >> COLOR_CONV_PRECISION; |
|
52978 lTemp3 = (33802 * lCb4) >> COLOR_CONV_PRECISION; |
|
52979 |
|
52980 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
52981 lY1 -= 16; |
|
52982 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
52983 |
|
52984 /*B component*/ |
|
52985 lTemp = lY1 + lTemp3 + 5; |
|
52986 if (lTemp < 0) |
|
52987 lTemp = 0; |
|
52988 if (lTemp > 255) |
|
52989 lTemp = 255; |
|
52990 lTemp4 = (lTemp >> 4); |
|
52991 |
|
52992 /*G component*/ |
|
52993 lTemp = lY1 - lTemp2 + 10; |
|
52994 if (lTemp < 0) |
|
52995 lTemp = 0; |
|
52996 if (lTemp > 255) |
|
52997 lTemp = 255; |
|
52998 lTemp4 |= (lTemp >> 4) << 4; |
|
52999 |
|
53000 /*R component*/ |
|
53001 lTemp = lY1 + lTemp1; |
|
53002 if (lTemp < 0) |
|
53003 lTemp = 0; |
|
53004 if (lTemp > 255) |
|
53005 lTemp = 255; |
|
53006 lTemp4 |= (lTemp >> 4) << 8; |
|
53007 |
|
53008 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
53009 |
|
53010 lRGBFramePtr += 2; |
|
53011 lRGBFramePtr1 += 2; |
|
53012 } |
|
53013 |
|
53014 |
|
53015 lCr1 = lCrPtr[j >> 1]; |
|
53016 lCb1 = lCbPtr[j >> 1]; |
|
53017 |
|
53018 lCr1 -= 128; |
|
53019 lCb1 -= 128; |
|
53020 |
|
53021 /*First Pixel*/ |
|
53022 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
53023 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
53024 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
53025 |
|
53026 lY1 = lLumPtr[j]; |
|
53027 lY1 -= 16; |
|
53028 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
53029 |
|
53030 /*B component*/ |
|
53031 lTemp = lY1 + lTemp3; |
|
53032 if (lTemp < 0) |
|
53033 lTemp = 0; |
|
53034 if (lTemp > 255) |
|
53035 lTemp = 255; |
|
53036 lTemp4 = (lTemp >> 4); |
|
53037 |
|
53038 /*G component*/ |
|
53039 lTemp = lY1 - lTemp2 + 15; |
|
53040 if (lTemp < 0) |
|
53041 lTemp = 0; |
|
53042 if (lTemp > 255) |
|
53043 lTemp = 255; |
|
53044 lTemp4 |= (lTemp >> 4) << 4; |
|
53045 |
|
53046 /*R component*/ |
|
53047 lTemp = lY1 + lTemp1 + 5; |
|
53048 if (lTemp < 0) |
|
53049 lTemp = 0; |
|
53050 if (lTemp > 255) |
|
53051 lTemp = 255; |
|
53052 lTemp4 |= (lTemp >> 4) << 8; |
|
53053 |
|
53054 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
53055 |
|
53056 /*Second Pixel*/ |
|
53057 lY1 = lLumPtr[j + 1]; |
|
53058 lY1 -= 16; |
|
53059 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
53060 |
|
53061 /*B component*/ |
|
53062 lTemp = lY1 + lTemp3 + 10; |
|
53063 if (lTemp < 0) |
|
53064 lTemp = 0; |
|
53065 if (lTemp > 255) |
|
53066 lTemp = 255; |
|
53067 lTemp4 = (lTemp >> 4); |
|
53068 |
|
53069 /*G component*/ |
|
53070 lTemp = lY1 - lTemp2; |
|
53071 if (lTemp < 0) |
|
53072 lTemp = 0; |
|
53073 if (lTemp > 255) |
|
53074 lTemp = 255; |
|
53075 lTemp4 |= (lTemp >> 4) << 4; |
|
53076 |
|
53077 /*R component*/ |
|
53078 lTemp = lY1 + lTemp1 + 15; |
|
53079 if (lTemp < 0) |
|
53080 lTemp = 0; |
|
53081 if (lTemp > 255) |
|
53082 lTemp = 255; |
|
53083 lTemp4 |= (lTemp >> 4) << 8; |
|
53084 |
|
53085 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
53086 |
|
53087 |
|
53088 /*Third Pixel*/ |
|
53089 lY1 = lLumPtr[j + lLumWidth]; |
|
53090 lY1 -= 16; |
|
53091 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
53092 |
|
53093 /*B component*/ |
|
53094 lTemp = lY1 + lTemp3 + 15; |
|
53095 if (lTemp < 0) |
|
53096 lTemp = 0; |
|
53097 if (lTemp > 255) |
|
53098 lTemp = 255; |
|
53099 lTemp4 = (lTemp >> 4); |
|
53100 |
|
53101 /*G component*/ |
|
53102 lTemp = lY1 - lTemp2 + 5; |
|
53103 if (lTemp < 0) |
|
53104 lTemp = 0; |
|
53105 if (lTemp > 255) |
|
53106 lTemp = 255; |
|
53107 lTemp4 |= (lTemp >> 4) << 4; |
|
53108 |
|
53109 /*R component*/ |
|
53110 lTemp = lY1 + lTemp1 + 10; |
|
53111 if (lTemp < 0) |
|
53112 lTemp = 0; |
|
53113 if (lTemp > 255) |
|
53114 lTemp = 255; |
|
53115 lTemp4 |= (lTemp >> 4) << 8; |
|
53116 |
|
53117 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
53118 |
|
53119 /*Fourth Pixel*/ |
|
53120 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
53121 lY1 -= 16; |
|
53122 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
53123 |
|
53124 /*B component*/ |
|
53125 lTemp = lY1 + lTemp3 + 5; |
|
53126 if (lTemp < 0) |
|
53127 lTemp = 0; |
|
53128 if (lTemp > 255) |
|
53129 lTemp = 255; |
|
53130 lTemp4 = (lTemp >> 4); |
|
53131 |
|
53132 /*G component*/ |
|
53133 lTemp = lY1 - lTemp2 + 10; |
|
53134 if (lTemp < 0) |
|
53135 lTemp = 0; |
|
53136 if (lTemp > 255) |
|
53137 lTemp = 255; |
|
53138 lTemp4 |= (lTemp >> 4) << 4; |
|
53139 |
|
53140 /*R component*/ |
|
53141 lTemp = lY1 + lTemp1; |
|
53142 if (lTemp < 0) |
|
53143 lTemp = 0; |
|
53144 if (lTemp > 255) |
|
53145 lTemp = 255; |
|
53146 lTemp4 |= (lTemp >> 4) << 8; |
|
53147 |
|
53148 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
53149 |
|
53150 lRGBFramePtr += 2; |
|
53151 lRGBFramePtr1 += 2; |
|
53152 |
|
53153 if(extraCol) |
|
53154 { |
|
53155 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
53156 lRGBFramePtr++; |
|
53157 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
53158 lRGBFramePtr1++; |
|
53159 } |
|
53160 |
|
53161 lLumPtr += (lLumWidth << 1); |
|
53162 lCrPtr += (lLumWidth >> 1); |
|
53163 lCbPtr += (lLumWidth >> 1); |
|
53164 |
|
53165 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
53166 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
53167 } |
|
53168 |
|
53169 |
|
53170 for(j = 0; j < lWidth; j += 2) |
|
53171 { |
|
53172 lCr1 = lCrPtr[j >> 1]; |
|
53173 lCb1 = lCbPtr[j >> 1]; |
|
53174 |
|
53175 lCr1 -= 128; |
|
53176 lCb1 -= 128; |
|
53177 |
|
53178 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
53179 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
53180 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
53181 |
|
53182 /*First Pixel*/ |
|
53183 lY1 = lLumPtr[j]; |
|
53184 lY1 -= 16; |
|
53185 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
53186 |
|
53187 /*B component*/ |
|
53188 lTemp = lY1 + lTemp3; |
|
53189 if (lTemp < 0) |
|
53190 lTemp = 0; |
|
53191 if (lTemp > 255) |
|
53192 lTemp = 255; |
|
53193 lTemp4 = (lTemp >> 4); |
|
53194 |
|
53195 /*G component*/ |
|
53196 lTemp = lY1 - lTemp2 + 15; |
|
53197 if (lTemp < 0) |
|
53198 lTemp = 0; |
|
53199 if (lTemp > 255) |
|
53200 lTemp = 255; |
|
53201 lTemp4 |= (lTemp >> 4) << 4; |
|
53202 |
|
53203 /*R component*/ |
|
53204 lTemp = lY1 + lTemp1 + 5; |
|
53205 if (lTemp < 0) |
|
53206 lTemp = 0; |
|
53207 if (lTemp > 255) |
|
53208 lTemp = 255; |
|
53209 lTemp4 |= (lTemp >> 4) << 8; |
|
53210 |
|
53211 lRGBFramePtr[0] = (uint16)(lTemp4); |
|
53212 |
|
53213 /*Second Pixel*/ |
|
53214 lY1 = lLumPtr[j + 1]; |
|
53215 lY1 -= 16; |
|
53216 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
53217 |
|
53218 /*B component*/ |
|
53219 lTemp = lY1 + lTemp3 + 10; |
|
53220 if (lTemp < 0) |
|
53221 lTemp = 0; |
|
53222 if (lTemp > 255) |
|
53223 lTemp = 255; |
|
53224 lTemp4 = (lTemp >> 4); |
|
53225 |
|
53226 /*G component*/ |
|
53227 lTemp = lY1 - lTemp2; |
|
53228 if (lTemp < 0) |
|
53229 lTemp = 0; |
|
53230 if (lTemp > 255) |
|
53231 lTemp = 255; |
|
53232 lTemp4 |= (lTemp >> 4) << 4; |
|
53233 |
|
53234 /*R component*/ |
|
53235 lTemp = lY1 + lTemp1 + 15; |
|
53236 if (lTemp < 0) |
|
53237 lTemp = 0; |
|
53238 if (lTemp > 255) |
|
53239 lTemp = 255; |
|
53240 lTemp4 |= (lTemp >> 4) << 8; |
|
53241 |
|
53242 lRGBFramePtr[1] = (uint16)(lTemp4); |
|
53243 |
|
53244 |
|
53245 /*Third Pixel*/ |
|
53246 lY1 = lLumPtr[j + lLumWidth]; |
|
53247 lY1 -= 16; |
|
53248 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
53249 |
|
53250 /*B component*/ |
|
53251 lTemp = lY1 + lTemp3 + 15; |
|
53252 if (lTemp < 0) |
|
53253 lTemp = 0; |
|
53254 if (lTemp > 255) |
|
53255 lTemp = 255; |
|
53256 lTemp4 = (lTemp >> 4); |
|
53257 |
|
53258 /*G component*/ |
|
53259 lTemp = lY1 - lTemp2 + 5; |
|
53260 if (lTemp < 0) |
|
53261 lTemp = 0; |
|
53262 if (lTemp > 255) |
|
53263 lTemp = 255; |
|
53264 lTemp4 |= (lTemp >> 4) << 4; |
|
53265 |
|
53266 /*R component*/ |
|
53267 lTemp = lY1 + lTemp1 + 10; |
|
53268 if (lTemp < 0) |
|
53269 lTemp = 0; |
|
53270 if (lTemp > 255) |
|
53271 lTemp = 255; |
|
53272 lTemp4 |= (lTemp >> 4) << 8; |
|
53273 |
|
53274 lRGBFramePtr1[0] = (uint16)(lTemp4); |
|
53275 |
|
53276 /*Fourth Pixel*/ |
|
53277 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
53278 lY1 -= 16; |
|
53279 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
53280 |
|
53281 /*B component*/ |
|
53282 lTemp = lY1 + lTemp3 + 5; |
|
53283 if (lTemp < 0) |
|
53284 lTemp = 0; |
|
53285 if (lTemp > 255) |
|
53286 lTemp = 255; |
|
53287 lTemp4 = (lTemp >> 4); |
|
53288 |
|
53289 /*G component*/ |
|
53290 lTemp = lY1 - lTemp2 + 10; |
|
53291 if (lTemp < 0) |
|
53292 lTemp = 0; |
|
53293 if (lTemp > 255) |
|
53294 lTemp = 255; |
|
53295 lTemp4 |= (lTemp >> 4) << 4; |
|
53296 |
|
53297 /*R component*/ |
|
53298 lTemp = lY1 + lTemp1; |
|
53299 if (lTemp < 0) |
|
53300 lTemp = 0; |
|
53301 if (lTemp > 255) |
|
53302 lTemp = 255; |
|
53303 lTemp4 |= (lTemp >> 4) << 8; |
|
53304 |
|
53305 lRGBFramePtr1[1] = (uint16)(lTemp4); |
|
53306 |
|
53307 lRGBFramePtr += 2; |
|
53308 lRGBFramePtr1 += 2; |
|
53309 } |
|
53310 |
|
53311 if(extraCol) |
|
53312 { |
|
53313 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
53314 lRGBFramePtr++; |
|
53315 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
53316 lRGBFramePtr1++; |
|
53317 } |
|
53318 |
|
53319 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
53320 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
53321 |
|
53322 if(extraRow) |
|
53323 { |
|
53324 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
53325 for(j = 0; j < lWidth; j += 2) |
|
53326 { |
|
53327 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
53328 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
53329 } |
|
53330 if(extraCol) |
|
53331 { |
|
53332 *lRGBFramePtr = *lRGBFramePtr1; |
|
53333 } |
|
53334 } |
|
53335 return; |
|
53336 } |
|
53337 |
|
53338 |
|
53339 /* |
|
53340 ****************************************************************************** |
|
53341 Name : sEmz_VDec_YUV420Chr3toColor16M_709_FR |
|
53342 Description : Converts YUV420 Chroma3 Planar to RGB888 Interleaved format |
|
53343 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
53344 uint8 *dstImage : Pointer to rgb data (o/p). |
|
53345 tWndParam *srcWindow : Pointer to structure containing source window |
|
53346 parameters like xOffset,yOffset,cropWidth, |
|
53347 cropHeight. (i/p) |
|
53348 tWndParam *dstWindow : Pointer to structure containing destination window |
|
53349 parameters like xOffset,yOffset,windWidth, |
|
53350 windHeight. (i/p) |
|
53351 Return Value : void |
|
53352 ****************************************************************************** |
|
53353 */ |
|
53354 |
|
53355 void sEmz_VDec_YUV420Chr3toColor16M_709_FR |
|
53356 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
53357 tWndParam* srcWindow, tWndParam* dstWindow) |
|
53358 { |
|
53359 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
53360 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
53361 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
53362 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
53363 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
53364 int32 i, j, extraRow, extraCol; |
|
53365 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
53366 cropWidth,cropHeight,wndWidth,wndHeight; |
|
53367 |
|
53368 srcXOffset = srcWindow->xOffset; |
|
53369 srcYOffset = srcWindow->yOffset; |
|
53370 cropWidth = srcWindow->wndWidth; |
|
53371 cropHeight = srcWindow->wndHeight; |
|
53372 |
|
53373 dstXOffset = dstWindow->xOffset; |
|
53374 dstYOffset = dstWindow->yOffset; |
|
53375 wndWidth = dstWindow->wndWidth; |
|
53376 wndHeight = dstWindow->wndHeight; |
|
53377 |
|
53378 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
53379 { |
|
53380 lWidth = cropWidth; |
|
53381 } |
|
53382 else |
|
53383 { |
|
53384 lWidth = srcImage->width - srcXOffset; |
|
53385 } |
|
53386 |
|
53387 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
53388 { |
|
53389 lHeight = cropHeight; |
|
53390 } |
|
53391 else |
|
53392 { |
|
53393 lHeight = srcImage->height - srcYOffset; |
|
53394 } |
|
53395 |
|
53396 if (lWidth > (wndWidth - dstXOffset)) |
|
53397 { |
|
53398 lWidth = wndWidth - dstXOffset; |
|
53399 } |
|
53400 |
|
53401 if (lHeight > (wndHeight - dstYOffset)) |
|
53402 { |
|
53403 lHeight = wndHeight - dstYOffset; |
|
53404 } |
|
53405 |
|
53406 extraCol = lWidth & 0x01; |
|
53407 extraRow = lHeight & 0x01; |
|
53408 |
|
53409 lTempWidth = lWidth * 3; |
|
53410 lWidth = (lWidth >> 1) << 1; |
|
53411 lHeight = (lHeight >> 1) << 1; |
|
53412 |
|
53413 dstXOffset *= 3; |
|
53414 wndWidth *= 3; |
|
53415 |
|
53416 lLumWidth = (srcImage->width >> 1) << 1; |
|
53417 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
53418 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
53419 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
53420 |
|
53421 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
53422 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
53423 |
|
53424 for(i = 0; i < (lHeight - 2); i += 2) |
|
53425 { |
|
53426 for(j = 0; j < (lWidth - 2); j += 2) |
|
53427 { |
|
53428 lCr1 = lCrPtr[j >> 1]; |
|
53429 lCb1 = lCbPtr[j >> 1]; |
|
53430 |
|
53431 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
53432 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
53433 |
|
53434 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
53435 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
53436 |
|
53437 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
53438 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
53439 |
|
53440 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
53441 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
53442 |
|
53443 lCr2 = (lCr1 + lCr2) >> 1; |
|
53444 lCb2 = (lCb1 + lCb2) >> 1; |
|
53445 |
|
53446 lCr3 = (lCr1 + lCr3) >> 1; |
|
53447 lCb3 = (lCb1 + lCb3) >> 1; |
|
53448 |
|
53449 /*First Pixel*/ |
|
53450 lCr1 -= 128; |
|
53451 lCb1 -= 128; |
|
53452 |
|
53453 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
53454 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
53455 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
53456 |
|
53457 lY1 = lLumPtr[j]; |
|
53458 |
|
53459 /*R component*/ |
|
53460 lTemp = lY1 + lTemp1; |
|
53461 if (lTemp < 0) |
|
53462 lTemp = 0; |
|
53463 if (lTemp > 255) |
|
53464 lTemp = 255; |
|
53465 |
|
53466 lRGBFramePtr[0] = (uint8) lTemp; |
|
53467 |
|
53468 /*G component*/ |
|
53469 lTemp = lY1 - lTemp2; |
|
53470 if (lTemp < 0) |
|
53471 lTemp = 0; |
|
53472 if (lTemp > 255) |
|
53473 lTemp = 255; |
|
53474 |
|
53475 lRGBFramePtr[1] = (uint8) lTemp; |
|
53476 |
|
53477 /*B component*/ |
|
53478 lTemp = lY1 + lTemp3; |
|
53479 if (lTemp < 0) |
|
53480 lTemp = 0; |
|
53481 if (lTemp > 255) |
|
53482 lTemp = 255; |
|
53483 |
|
53484 lRGBFramePtr[2] = (uint8) lTemp; |
|
53485 |
|
53486 /*Second Pixel*/ |
|
53487 lCr2 -= 128; |
|
53488 lCb2 -= 128; |
|
53489 |
|
53490 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
53491 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
53492 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
53493 |
|
53494 lY1 = lLumPtr[j + 1]; |
|
53495 |
|
53496 /*R component*/ |
|
53497 lTemp = lY1 + lTemp1; |
|
53498 if (lTemp < 0) |
|
53499 lTemp = 0; |
|
53500 if (lTemp > 255) |
|
53501 lTemp = 255; |
|
53502 |
|
53503 lRGBFramePtr[3] = (uint8) lTemp; |
|
53504 |
|
53505 /*G component*/ |
|
53506 lTemp = lY1 - lTemp2; |
|
53507 if (lTemp < 0) |
|
53508 lTemp = 0; |
|
53509 if (lTemp > 255) |
|
53510 lTemp = 255; |
|
53511 |
|
53512 lRGBFramePtr[4] = (uint8) lTemp; |
|
53513 |
|
53514 |
|
53515 /*B component*/ |
|
53516 lTemp = lY1 + lTemp3; |
|
53517 |
|
53518 if (lTemp < 0) |
|
53519 lTemp = 0; |
|
53520 if (lTemp > 255) |
|
53521 lTemp = 255; |
|
53522 |
|
53523 lRGBFramePtr[5] = (uint8) lTemp; |
|
53524 |
|
53525 |
|
53526 /*Third Pixel*/ |
|
53527 lCr3 -= 128; |
|
53528 lCb3 -= 128; |
|
53529 |
|
53530 lTemp1 = (25801 * lCr3) >> COLOR_CONV_PRECISION; |
|
53531 lTemp2 = ((3072 * lCb3) + (7670 * lCr3)) >> COLOR_CONV_PRECISION; |
|
53532 lTemp3 = (30397 * lCb3) >> COLOR_CONV_PRECISION; |
|
53533 |
|
53534 lY1 = lLumPtr[j + lLumWidth]; |
|
53535 |
|
53536 /*R component*/ |
|
53537 lTemp = lY1 + lTemp1; |
|
53538 if (lTemp < 0) |
|
53539 lTemp = 0; |
|
53540 if (lTemp > 255) |
|
53541 lTemp = 255; |
|
53542 lRGBFramePtr1[0] = (uint8) lTemp; |
|
53543 |
|
53544 /*G component*/ |
|
53545 lTemp = lY1 - lTemp2; |
|
53546 if (lTemp < 0) |
|
53547 lTemp = 0; |
|
53548 if (lTemp > 255) |
|
53549 lTemp = 255; |
|
53550 |
|
53551 lRGBFramePtr1[1] = (uint8) lTemp; |
|
53552 |
|
53553 /*B component*/ |
|
53554 lTemp = lY1 + lTemp3; |
|
53555 if (lTemp < 0) |
|
53556 lTemp = 0; |
|
53557 if (lTemp > 255) |
|
53558 lTemp = 255; |
|
53559 |
|
53560 lRGBFramePtr1[2] = (uint8) lTemp; |
|
53561 |
|
53562 /*Fourth Pixel*/ |
|
53563 lCr4 -= 128; |
|
53564 lCb4 -= 128; |
|
53565 |
|
53566 lTemp1 = (25801 * lCr4) >> COLOR_CONV_PRECISION; |
|
53567 lTemp2 = ((3072 * lCb4) + (7670 * lCr4)) >> COLOR_CONV_PRECISION; |
|
53568 lTemp3 = (30397 * lCb4) >> COLOR_CONV_PRECISION; |
|
53569 |
|
53570 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
53571 |
|
53572 /*R component*/ |
|
53573 lTemp = lY1 + lTemp1; |
|
53574 if (lTemp < 0) |
|
53575 lTemp = 0; |
|
53576 if (lTemp > 255) |
|
53577 lTemp = 255; |
|
53578 lRGBFramePtr1[3] = (uint8) lTemp; |
|
53579 |
|
53580 /*G component*/ |
|
53581 lTemp = lY1 - lTemp2; |
|
53582 if (lTemp < 0) |
|
53583 lTemp = 0; |
|
53584 if (lTemp > 255) |
|
53585 lTemp = 255; |
|
53586 lRGBFramePtr1[4] = (uint8) lTemp; |
|
53587 |
|
53588 /*B component*/ |
|
53589 lTemp = lY1 + lTemp3; |
|
53590 if (lTemp < 0) |
|
53591 lTemp = 0; |
|
53592 if (lTemp > 255) |
|
53593 lTemp = 255; |
|
53594 |
|
53595 lRGBFramePtr1[5] = (uint8) lTemp; |
|
53596 |
|
53597 lRGBFramePtr += 6; |
|
53598 lRGBFramePtr1 += 6; |
|
53599 } |
|
53600 |
|
53601 |
|
53602 lCr1 = lCrPtr[j >> 1]; |
|
53603 lCb1 = lCbPtr[j >> 1]; |
|
53604 |
|
53605 lCr1 -= 128; |
|
53606 lCb1 -= 128; |
|
53607 |
|
53608 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
53609 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
53610 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
53611 |
|
53612 /*First Pixel*/ |
|
53613 lY1 = lLumPtr[j]; |
|
53614 |
|
53615 /*R component*/ |
|
53616 lTemp = lY1 + lTemp1; |
|
53617 if (lTemp < 0) |
|
53618 lTemp = 0; |
|
53619 if (lTemp > 255) |
|
53620 lTemp = 255; |
|
53621 |
|
53622 lRGBFramePtr[0] = (uint8) lTemp; |
|
53623 |
|
53624 /*G component*/ |
|
53625 lTemp = lY1 - lTemp2; |
|
53626 if (lTemp < 0) |
|
53627 lTemp = 0; |
|
53628 if (lTemp > 255) |
|
53629 lTemp = 255; |
|
53630 |
|
53631 lRGBFramePtr[1] = (uint8) lTemp; |
|
53632 |
|
53633 /*B component*/ |
|
53634 lTemp = lY1 + lTemp3; |
|
53635 if (lTemp < 0) |
|
53636 lTemp = 0; |
|
53637 if (lTemp > 255) |
|
53638 lTemp = 255; |
|
53639 |
|
53640 lRGBFramePtr[2] = (uint8) lTemp; |
|
53641 |
|
53642 /*Second Pixel*/ |
|
53643 lY1 = lLumPtr[j + 1]; |
|
53644 |
|
53645 /*R component*/ |
|
53646 lTemp = lY1 + lTemp1; |
|
53647 if (lTemp < 0) |
|
53648 lTemp = 0; |
|
53649 if (lTemp > 255) |
|
53650 lTemp = 255; |
|
53651 |
|
53652 lRGBFramePtr[3] = (uint8) lTemp; |
|
53653 |
|
53654 /*G component*/ |
|
53655 lTemp = lY1 - lTemp2; |
|
53656 if (lTemp < 0) |
|
53657 lTemp = 0; |
|
53658 if (lTemp > 255) |
|
53659 lTemp = 255; |
|
53660 |
|
53661 lRGBFramePtr[4] = (uint8) lTemp; |
|
53662 |
|
53663 |
|
53664 /*B component*/ |
|
53665 lTemp = lY1 + lTemp3; |
|
53666 |
|
53667 if (lTemp < 0) |
|
53668 lTemp = 0; |
|
53669 if (lTemp > 255) |
|
53670 lTemp = 255; |
|
53671 |
|
53672 lRGBFramePtr[5] = (uint8) lTemp; |
|
53673 |
|
53674 |
|
53675 /*Third Pixel*/ |
|
53676 lY1 = lLumPtr[j + lLumWidth]; |
|
53677 |
|
53678 /*R component*/ |
|
53679 lTemp = lY1 + lTemp1; |
|
53680 if (lTemp < 0) |
|
53681 lTemp = 0; |
|
53682 if (lTemp > 255) |
|
53683 lTemp = 255; |
|
53684 lRGBFramePtr1[0] = (uint8) lTemp; |
|
53685 |
|
53686 /*G component*/ |
|
53687 lTemp = lY1 - lTemp2; |
|
53688 if (lTemp < 0) |
|
53689 lTemp = 0; |
|
53690 if (lTemp > 255) |
|
53691 lTemp = 255; |
|
53692 |
|
53693 lRGBFramePtr1[1] = (uint8) lTemp; |
|
53694 |
|
53695 /*B component*/ |
|
53696 lTemp = lY1 + lTemp3; |
|
53697 if (lTemp < 0) |
|
53698 lTemp = 0; |
|
53699 if (lTemp > 255) |
|
53700 lTemp = 255; |
|
53701 |
|
53702 lRGBFramePtr1[2] = (uint8) lTemp; |
|
53703 |
|
53704 /*Fourth Pixel*/ |
|
53705 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
53706 |
|
53707 /*R component*/ |
|
53708 lTemp = lY1 + lTemp1; |
|
53709 if (lTemp < 0) |
|
53710 lTemp = 0; |
|
53711 if (lTemp > 255) |
|
53712 lTemp = 255; |
|
53713 lRGBFramePtr1[3] = (uint8) lTemp; |
|
53714 |
|
53715 /*G component*/ |
|
53716 lTemp = lY1 - lTemp2; |
|
53717 if (lTemp < 0) |
|
53718 lTemp = 0; |
|
53719 if (lTemp > 255) |
|
53720 lTemp = 255; |
|
53721 lRGBFramePtr1[4] = (uint8) lTemp; |
|
53722 |
|
53723 /*B component*/ |
|
53724 lTemp = lY1 + lTemp3; |
|
53725 if (lTemp < 0) |
|
53726 lTemp = 0; |
|
53727 if (lTemp > 255) |
|
53728 lTemp = 255; |
|
53729 |
|
53730 lRGBFramePtr1[5] = (uint8) lTemp; |
|
53731 |
|
53732 lRGBFramePtr += 6; |
|
53733 lRGBFramePtr1 += 6; |
|
53734 |
|
53735 if(extraCol) |
|
53736 { |
|
53737 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
53738 lRGBFramePtr++; |
|
53739 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
53740 lRGBFramePtr++; |
|
53741 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
53742 lRGBFramePtr++; |
|
53743 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
53744 lRGBFramePtr1++; |
|
53745 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
53746 lRGBFramePtr1++; |
|
53747 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
53748 lRGBFramePtr1++; |
|
53749 |
|
53750 } |
|
53751 |
|
53752 lLumPtr += (lLumWidth << 1); |
|
53753 lCrPtr += (lLumWidth >> 1); |
|
53754 lCbPtr += (lLumWidth >> 1); |
|
53755 |
|
53756 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
53757 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
53758 } |
|
53759 |
|
53760 |
|
53761 for(j = 0; j < lWidth; j += 2) |
|
53762 { |
|
53763 lCr1 = lCrPtr[j >> 1]; |
|
53764 lCb1 = lCbPtr[j >> 1]; |
|
53765 |
|
53766 lCr1 -= 128; |
|
53767 lCb1 -= 128; |
|
53768 |
|
53769 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
53770 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
53771 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
53772 |
|
53773 /*First Pixel*/ |
|
53774 lY1 = lLumPtr[j]; |
|
53775 |
|
53776 /*R component*/ |
|
53777 lTemp = lY1 + lTemp1; |
|
53778 if (lTemp < 0) |
|
53779 lTemp = 0; |
|
53780 if (lTemp > 255) |
|
53781 lTemp = 255; |
|
53782 |
|
53783 lRGBFramePtr[0] = (uint8) lTemp; |
|
53784 |
|
53785 /*G component*/ |
|
53786 lTemp = lY1 - lTemp2; |
|
53787 if (lTemp < 0) |
|
53788 lTemp = 0; |
|
53789 if (lTemp > 255) |
|
53790 lTemp = 255; |
|
53791 |
|
53792 lRGBFramePtr[1] = (uint8) lTemp; |
|
53793 |
|
53794 /*B component*/ |
|
53795 lTemp = lY1 + lTemp3; |
|
53796 if (lTemp < 0) |
|
53797 lTemp = 0; |
|
53798 if (lTemp > 255) |
|
53799 lTemp = 255; |
|
53800 |
|
53801 lRGBFramePtr[2] = (uint8) lTemp; |
|
53802 |
|
53803 /*Second Pixel*/ |
|
53804 lY1 = lLumPtr[j + 1]; |
|
53805 |
|
53806 /*R component*/ |
|
53807 lTemp = lY1 + lTemp1; |
|
53808 if (lTemp < 0) |
|
53809 lTemp = 0; |
|
53810 if (lTemp > 255) |
|
53811 lTemp = 255; |
|
53812 |
|
53813 lRGBFramePtr[3] = (uint8) lTemp; |
|
53814 |
|
53815 /*G component*/ |
|
53816 lTemp = lY1 - lTemp2; |
|
53817 if (lTemp < 0) |
|
53818 lTemp = 0; |
|
53819 if (lTemp > 255) |
|
53820 lTemp = 255; |
|
53821 |
|
53822 lRGBFramePtr[4] = (uint8) lTemp; |
|
53823 |
|
53824 |
|
53825 /*B component*/ |
|
53826 lTemp = lY1 + lTemp3; |
|
53827 |
|
53828 if (lTemp < 0) |
|
53829 lTemp = 0; |
|
53830 if (lTemp > 255) |
|
53831 lTemp = 255; |
|
53832 |
|
53833 lRGBFramePtr[5] = (uint8) lTemp; |
|
53834 |
|
53835 |
|
53836 /*Third Pixel*/ |
|
53837 lY1 = lLumPtr[j + lLumWidth]; |
|
53838 |
|
53839 /*R component*/ |
|
53840 lTemp = lY1 + lTemp1; |
|
53841 if (lTemp < 0) |
|
53842 lTemp = 0; |
|
53843 if (lTemp > 255) |
|
53844 lTemp = 255; |
|
53845 lRGBFramePtr1[0] = (uint8) lTemp; |
|
53846 |
|
53847 /*G component*/ |
|
53848 lTemp = lY1 - lTemp2; |
|
53849 if (lTemp < 0) |
|
53850 lTemp = 0; |
|
53851 if (lTemp > 255) |
|
53852 lTemp = 255; |
|
53853 |
|
53854 lRGBFramePtr1[1] = (uint8) lTemp; |
|
53855 |
|
53856 /*B component*/ |
|
53857 lTemp = lY1 + lTemp3; |
|
53858 if (lTemp < 0) |
|
53859 lTemp = 0; |
|
53860 if (lTemp > 255) |
|
53861 lTemp = 255; |
|
53862 |
|
53863 lRGBFramePtr1[2] = (uint8) lTemp; |
|
53864 |
|
53865 /*Fourth Pixel*/ |
|
53866 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
53867 |
|
53868 /*R component*/ |
|
53869 lTemp = lY1 + lTemp1; |
|
53870 if (lTemp < 0) |
|
53871 lTemp = 0; |
|
53872 if (lTemp > 255) |
|
53873 lTemp = 255; |
|
53874 lRGBFramePtr1[3] = (uint8) lTemp; |
|
53875 |
|
53876 /*G component*/ |
|
53877 lTemp = lY1 - lTemp2; |
|
53878 if (lTemp < 0) |
|
53879 lTemp = 0; |
|
53880 if (lTemp > 255) |
|
53881 lTemp = 255; |
|
53882 lRGBFramePtr1[4] = (uint8) lTemp; |
|
53883 |
|
53884 /*B component*/ |
|
53885 lTemp = lY1 + lTemp3; |
|
53886 if (lTemp < 0) |
|
53887 lTemp = 0; |
|
53888 if (lTemp > 255) |
|
53889 lTemp = 255; |
|
53890 |
|
53891 lRGBFramePtr1[5] = (uint8) lTemp; |
|
53892 |
|
53893 lRGBFramePtr += 6; |
|
53894 lRGBFramePtr1 += 6; |
|
53895 } |
|
53896 |
|
53897 if(extraCol) |
|
53898 { |
|
53899 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
53900 lRGBFramePtr++; |
|
53901 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
53902 lRGBFramePtr++; |
|
53903 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
53904 lRGBFramePtr++; |
|
53905 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
53906 lRGBFramePtr1++; |
|
53907 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
53908 lRGBFramePtr1++; |
|
53909 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
53910 lRGBFramePtr1++; |
|
53911 |
|
53912 } |
|
53913 |
|
53914 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
53915 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
53916 |
|
53917 |
|
53918 if(extraRow) |
|
53919 { |
|
53920 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
53921 for(j = 0; j < lWidth * 3; j += 2) |
|
53922 { |
|
53923 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
53924 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
53925 } |
|
53926 if(extraCol) |
|
53927 { |
|
53928 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
53929 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
53930 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
53931 } |
|
53932 } |
|
53933 return; |
|
53934 } |
|
53935 |
|
53936 /* |
|
53937 ****************************************************************************** |
|
53938 Name : sEmz_VDec_YUV420Chr3toColor16M_601_5_FR |
|
53939 Description : Converts YUV420 Chroma3 Planar to RGB888 Interleaved format |
|
53940 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
53941 uint8 *dstImage : Pointer to rgb data (o/p). |
|
53942 tWndParam *srcWindow : Pointer to structure containing source window |
|
53943 parameters like xOffset,yOffset,cropWidth, |
|
53944 cropHeight. (i/p) |
|
53945 tWndParam *dstWindow : Pointer to structure containing destination window |
|
53946 parameters like xOffset,yOffset,windWidth, |
|
53947 windHeight. (i/p) |
|
53948 Return Value : void |
|
53949 ****************************************************************************** |
|
53950 */ |
|
53951 |
|
53952 void sEmz_VDec_YUV420Chr3toColor16M_601_5_FR |
|
53953 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
53954 tWndParam* srcWindow, tWndParam* dstWindow) |
|
53955 { |
|
53956 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
53957 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
53958 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
53959 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
53960 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
53961 int32 i, j, extraRow, extraCol; |
|
53962 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
53963 cropWidth,cropHeight,wndWidth,wndHeight; |
|
53964 |
|
53965 srcXOffset = srcWindow->xOffset; |
|
53966 srcYOffset = srcWindow->yOffset; |
|
53967 cropWidth = srcWindow->wndWidth; |
|
53968 cropHeight = srcWindow->wndHeight; |
|
53969 |
|
53970 dstXOffset = dstWindow->xOffset; |
|
53971 dstYOffset = dstWindow->yOffset; |
|
53972 wndWidth = dstWindow->wndWidth; |
|
53973 wndHeight = dstWindow->wndHeight; |
|
53974 |
|
53975 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
53976 { |
|
53977 lWidth = cropWidth; |
|
53978 } |
|
53979 else |
|
53980 { |
|
53981 lWidth = srcImage->width - srcXOffset; |
|
53982 } |
|
53983 |
|
53984 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
53985 { |
|
53986 lHeight = cropHeight; |
|
53987 } |
|
53988 else |
|
53989 { |
|
53990 lHeight = srcImage->height - srcYOffset; |
|
53991 } |
|
53992 |
|
53993 if (lWidth > (wndWidth - dstXOffset)) |
|
53994 { |
|
53995 lWidth = wndWidth - dstXOffset; |
|
53996 } |
|
53997 |
|
53998 if (lHeight > (wndHeight - dstYOffset)) |
|
53999 { |
|
54000 lHeight = wndHeight - dstYOffset; |
|
54001 } |
|
54002 |
|
54003 extraCol = lWidth & 0x01; |
|
54004 extraRow = lHeight & 0x01; |
|
54005 |
|
54006 lTempWidth = lWidth * 3; |
|
54007 lWidth = (lWidth >> 1) << 1; |
|
54008 lHeight = (lHeight >> 1) << 1; |
|
54009 |
|
54010 dstXOffset *= 3; |
|
54011 wndWidth *= 3; |
|
54012 |
|
54013 lLumWidth = (srcImage->width >> 1) << 1; |
|
54014 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
54015 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
54016 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
54017 |
|
54018 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
54019 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
54020 |
|
54021 for(i = 0; i < (lHeight - 2); i += 2) |
|
54022 { |
|
54023 for(j = 0; j < (lWidth - 2); j += 2) |
|
54024 { |
|
54025 lCr1 = lCrPtr[j >> 1]; |
|
54026 lCb1 = lCbPtr[j >> 1]; |
|
54027 |
|
54028 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
54029 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
54030 |
|
54031 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
54032 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
54033 |
|
54034 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
54035 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
54036 |
|
54037 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
54038 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
54039 |
|
54040 lCr2 = (lCr1 + lCr2) >> 1; |
|
54041 lCb2 = (lCb1 + lCb2) >> 1; |
|
54042 |
|
54043 lCr3 = (lCr1 + lCr3) >> 1; |
|
54044 lCb3 = (lCb1 + lCb3) >> 1; |
|
54045 |
|
54046 /*First Pixel*/ |
|
54047 lCr1 -= 128; |
|
54048 lCb1 -= 128; |
|
54049 |
|
54050 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
54051 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
54052 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
54053 |
|
54054 lY1 = lLumPtr[j]; |
|
54055 |
|
54056 /*R component*/ |
|
54057 lTemp = lY1 + lTemp1; |
|
54058 if (lTemp < 0) |
|
54059 lTemp = 0; |
|
54060 if (lTemp > 255) |
|
54061 lTemp = 255; |
|
54062 |
|
54063 lRGBFramePtr[0] = (uint8) lTemp; |
|
54064 |
|
54065 /*G component*/ |
|
54066 lTemp = lY1 - lTemp2; |
|
54067 if (lTemp < 0) |
|
54068 lTemp = 0; |
|
54069 if (lTemp > 255) |
|
54070 lTemp = 255; |
|
54071 |
|
54072 lRGBFramePtr[1] = (uint8) lTemp; |
|
54073 |
|
54074 /*B component*/ |
|
54075 lTemp = lY1 + lTemp3; |
|
54076 if (lTemp < 0) |
|
54077 lTemp = 0; |
|
54078 if (lTemp > 255) |
|
54079 lTemp = 255; |
|
54080 |
|
54081 lRGBFramePtr[2] = (uint8) lTemp; |
|
54082 |
|
54083 /*Second Pixel*/ |
|
54084 lCr2 -= 128; |
|
54085 lCb2 -= 128; |
|
54086 |
|
54087 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
54088 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
54089 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
54090 |
|
54091 lY1 = lLumPtr[j + 1]; |
|
54092 |
|
54093 /*R component*/ |
|
54094 lTemp = lY1 + lTemp1; |
|
54095 if (lTemp < 0) |
|
54096 lTemp = 0; |
|
54097 if (lTemp > 255) |
|
54098 lTemp = 255; |
|
54099 |
|
54100 lRGBFramePtr[3] = (uint8) lTemp; |
|
54101 |
|
54102 /*G component*/ |
|
54103 lTemp = lY1 - lTemp2; |
|
54104 if (lTemp < 0) |
|
54105 lTemp = 0; |
|
54106 if (lTemp > 255) |
|
54107 lTemp = 255; |
|
54108 |
|
54109 lRGBFramePtr[4] = (uint8) lTemp; |
|
54110 |
|
54111 |
|
54112 /*B component*/ |
|
54113 lTemp = lY1 + lTemp3; |
|
54114 |
|
54115 if (lTemp < 0) |
|
54116 lTemp = 0; |
|
54117 if (lTemp > 255) |
|
54118 lTemp = 255; |
|
54119 |
|
54120 lRGBFramePtr[5] = (uint8) lTemp; |
|
54121 |
|
54122 |
|
54123 /*Third Pixel*/ |
|
54124 lCr3 -= 128; |
|
54125 lCb3 -= 128; |
|
54126 |
|
54127 lTemp1 = (22973 * lCr3) >> COLOR_CONV_PRECISION; |
|
54128 lTemp2 = ((5637 * lCb3) + (11699 * lCr3)) >> COLOR_CONV_PRECISION; |
|
54129 lTemp3 = (29032 * lCb3) >> COLOR_CONV_PRECISION; |
|
54130 |
|
54131 lY1 = lLumPtr[j + lLumWidth]; |
|
54132 |
|
54133 /*R component*/ |
|
54134 lTemp = lY1 + lTemp1; |
|
54135 if (lTemp < 0) |
|
54136 lTemp = 0; |
|
54137 if (lTemp > 255) |
|
54138 lTemp = 255; |
|
54139 lRGBFramePtr1[0] = (uint8) lTemp; |
|
54140 |
|
54141 /*G component*/ |
|
54142 lTemp = lY1 - lTemp2; |
|
54143 if (lTemp < 0) |
|
54144 lTemp = 0; |
|
54145 if (lTemp > 255) |
|
54146 lTemp = 255; |
|
54147 |
|
54148 lRGBFramePtr1[1] = (uint8) lTemp; |
|
54149 |
|
54150 /*B component*/ |
|
54151 lTemp = lY1 + lTemp3; |
|
54152 if (lTemp < 0) |
|
54153 lTemp = 0; |
|
54154 if (lTemp > 255) |
|
54155 lTemp = 255; |
|
54156 |
|
54157 lRGBFramePtr1[2] = (uint8) lTemp; |
|
54158 |
|
54159 /*Fourth Pixel*/ |
|
54160 lCr4 -= 128; |
|
54161 lCb4 -= 128; |
|
54162 |
|
54163 lTemp1 = (22973 * lCr4) >> COLOR_CONV_PRECISION; |
|
54164 lTemp2 = ((5637 * lCb4) + (11699 * lCr4)) >> COLOR_CONV_PRECISION; |
|
54165 lTemp3 = (29032 * lCb4) >> COLOR_CONV_PRECISION; |
|
54166 |
|
54167 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
54168 |
|
54169 /*R component*/ |
|
54170 lTemp = lY1 + lTemp1; |
|
54171 if (lTemp < 0) |
|
54172 lTemp = 0; |
|
54173 if (lTemp > 255) |
|
54174 lTemp = 255; |
|
54175 lRGBFramePtr1[3] = (uint8) lTemp; |
|
54176 |
|
54177 /*G component*/ |
|
54178 lTemp = lY1 - lTemp2; |
|
54179 if (lTemp < 0) |
|
54180 lTemp = 0; |
|
54181 if (lTemp > 255) |
|
54182 lTemp = 255; |
|
54183 lRGBFramePtr1[4] = (uint8) lTemp; |
|
54184 |
|
54185 /*B component*/ |
|
54186 lTemp = lY1 + lTemp3; |
|
54187 if (lTemp < 0) |
|
54188 lTemp = 0; |
|
54189 if (lTemp > 255) |
|
54190 lTemp = 255; |
|
54191 |
|
54192 lRGBFramePtr1[5] = (uint8) lTemp; |
|
54193 |
|
54194 lRGBFramePtr += 6; |
|
54195 lRGBFramePtr1 += 6; |
|
54196 } |
|
54197 |
|
54198 |
|
54199 lCr1 = lCrPtr[j >> 1]; |
|
54200 lCb1 = lCbPtr[j >> 1]; |
|
54201 |
|
54202 lCr1 -= 128; |
|
54203 lCb1 -= 128; |
|
54204 |
|
54205 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
54206 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
54207 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
54208 |
|
54209 /*First Pixel*/ |
|
54210 lY1 = lLumPtr[j]; |
|
54211 |
|
54212 /*R component*/ |
|
54213 lTemp = lY1 + lTemp1; |
|
54214 if (lTemp < 0) |
|
54215 lTemp = 0; |
|
54216 if (lTemp > 255) |
|
54217 lTemp = 255; |
|
54218 |
|
54219 lRGBFramePtr[0] = (uint8) lTemp; |
|
54220 |
|
54221 /*G component*/ |
|
54222 lTemp = lY1 - lTemp2; |
|
54223 if (lTemp < 0) |
|
54224 lTemp = 0; |
|
54225 if (lTemp > 255) |
|
54226 lTemp = 255; |
|
54227 |
|
54228 lRGBFramePtr[1] = (uint8) lTemp; |
|
54229 |
|
54230 /*B component*/ |
|
54231 lTemp = lY1 + lTemp3; |
|
54232 if (lTemp < 0) |
|
54233 lTemp = 0; |
|
54234 if (lTemp > 255) |
|
54235 lTemp = 255; |
|
54236 |
|
54237 lRGBFramePtr[2] = (uint8) lTemp; |
|
54238 |
|
54239 /*Second Pixel*/ |
|
54240 lY1 = lLumPtr[j + 1]; |
|
54241 |
|
54242 /*R component*/ |
|
54243 lTemp = lY1 + lTemp1; |
|
54244 if (lTemp < 0) |
|
54245 lTemp = 0; |
|
54246 if (lTemp > 255) |
|
54247 lTemp = 255; |
|
54248 |
|
54249 lRGBFramePtr[3] = (uint8) lTemp; |
|
54250 |
|
54251 /*G component*/ |
|
54252 lTemp = lY1 - lTemp2; |
|
54253 if (lTemp < 0) |
|
54254 lTemp = 0; |
|
54255 if (lTemp > 255) |
|
54256 lTemp = 255; |
|
54257 |
|
54258 lRGBFramePtr[4] = (uint8) lTemp; |
|
54259 |
|
54260 |
|
54261 /*B component*/ |
|
54262 lTemp = lY1 + lTemp3; |
|
54263 |
|
54264 if (lTemp < 0) |
|
54265 lTemp = 0; |
|
54266 if (lTemp > 255) |
|
54267 lTemp = 255; |
|
54268 |
|
54269 lRGBFramePtr[5] = (uint8) lTemp; |
|
54270 |
|
54271 |
|
54272 /*Third Pixel*/ |
|
54273 lY1 = lLumPtr[j + lLumWidth]; |
|
54274 |
|
54275 /*R component*/ |
|
54276 lTemp = lY1 + lTemp1; |
|
54277 if (lTemp < 0) |
|
54278 lTemp = 0; |
|
54279 if (lTemp > 255) |
|
54280 lTemp = 255; |
|
54281 lRGBFramePtr1[0] = (uint8) lTemp; |
|
54282 |
|
54283 /*G component*/ |
|
54284 lTemp = lY1 - lTemp2; |
|
54285 if (lTemp < 0) |
|
54286 lTemp = 0; |
|
54287 if (lTemp > 255) |
|
54288 lTemp = 255; |
|
54289 |
|
54290 lRGBFramePtr1[1] = (uint8) lTemp; |
|
54291 |
|
54292 /*B component*/ |
|
54293 lTemp = lY1 + lTemp3; |
|
54294 if (lTemp < 0) |
|
54295 lTemp = 0; |
|
54296 if (lTemp > 255) |
|
54297 lTemp = 255; |
|
54298 |
|
54299 lRGBFramePtr1[2] = (uint8) lTemp; |
|
54300 |
|
54301 /*Fourth Pixel*/ |
|
54302 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
54303 |
|
54304 /*R component*/ |
|
54305 lTemp = lY1 + lTemp1; |
|
54306 if (lTemp < 0) |
|
54307 lTemp = 0; |
|
54308 if (lTemp > 255) |
|
54309 lTemp = 255; |
|
54310 lRGBFramePtr1[3] = (uint8) lTemp; |
|
54311 |
|
54312 /*G component*/ |
|
54313 lTemp = lY1 - lTemp2; |
|
54314 if (lTemp < 0) |
|
54315 lTemp = 0; |
|
54316 if (lTemp > 255) |
|
54317 lTemp = 255; |
|
54318 lRGBFramePtr1[4] = (uint8) lTemp; |
|
54319 |
|
54320 /*B component*/ |
|
54321 lTemp = lY1 + lTemp3; |
|
54322 if (lTemp < 0) |
|
54323 lTemp = 0; |
|
54324 if (lTemp > 255) |
|
54325 lTemp = 255; |
|
54326 |
|
54327 lRGBFramePtr1[5] = (uint8) lTemp; |
|
54328 |
|
54329 lRGBFramePtr += 6; |
|
54330 lRGBFramePtr1 += 6; |
|
54331 |
|
54332 if(extraCol) |
|
54333 { |
|
54334 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
54335 lRGBFramePtr++; |
|
54336 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
54337 lRGBFramePtr++; |
|
54338 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
54339 lRGBFramePtr++; |
|
54340 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
54341 lRGBFramePtr1++; |
|
54342 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
54343 lRGBFramePtr1++; |
|
54344 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
54345 lRGBFramePtr1++; |
|
54346 |
|
54347 } |
|
54348 |
|
54349 lLumPtr += (lLumWidth << 1); |
|
54350 lCrPtr += (lLumWidth >> 1); |
|
54351 lCbPtr += (lLumWidth >> 1); |
|
54352 |
|
54353 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
54354 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
54355 } |
|
54356 |
|
54357 |
|
54358 for(j = 0; j < lWidth; j += 2) |
|
54359 { |
|
54360 lCr1 = lCrPtr[j >> 1]; |
|
54361 lCb1 = lCbPtr[j >> 1]; |
|
54362 |
|
54363 lCr1 -= 128; |
|
54364 lCb1 -= 128; |
|
54365 |
|
54366 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
54367 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
54368 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
54369 |
|
54370 /*First Pixel*/ |
|
54371 lY1 = lLumPtr[j]; |
|
54372 |
|
54373 /*R component*/ |
|
54374 lTemp = lY1 + lTemp1; |
|
54375 if (lTemp < 0) |
|
54376 lTemp = 0; |
|
54377 if (lTemp > 255) |
|
54378 lTemp = 255; |
|
54379 |
|
54380 lRGBFramePtr[0] = (uint8) lTemp; |
|
54381 |
|
54382 /*G component*/ |
|
54383 lTemp = lY1 - lTemp2; |
|
54384 if (lTemp < 0) |
|
54385 lTemp = 0; |
|
54386 if (lTemp > 255) |
|
54387 lTemp = 255; |
|
54388 |
|
54389 lRGBFramePtr[1] = (uint8) lTemp; |
|
54390 |
|
54391 /*B component*/ |
|
54392 lTemp = lY1 + lTemp3; |
|
54393 if (lTemp < 0) |
|
54394 lTemp = 0; |
|
54395 if (lTemp > 255) |
|
54396 lTemp = 255; |
|
54397 |
|
54398 lRGBFramePtr[2] = (uint8) lTemp; |
|
54399 |
|
54400 /*Second Pixel*/ |
|
54401 lY1 = lLumPtr[j + 1]; |
|
54402 |
|
54403 /*R component*/ |
|
54404 lTemp = lY1 + lTemp1; |
|
54405 if (lTemp < 0) |
|
54406 lTemp = 0; |
|
54407 if (lTemp > 255) |
|
54408 lTemp = 255; |
|
54409 |
|
54410 lRGBFramePtr[3] = (uint8) lTemp; |
|
54411 |
|
54412 /*G component*/ |
|
54413 lTemp = lY1 - lTemp2; |
|
54414 if (lTemp < 0) |
|
54415 lTemp = 0; |
|
54416 if (lTemp > 255) |
|
54417 lTemp = 255; |
|
54418 |
|
54419 lRGBFramePtr[4] = (uint8) lTemp; |
|
54420 |
|
54421 |
|
54422 /*B component*/ |
|
54423 lTemp = lY1 + lTemp3; |
|
54424 |
|
54425 if (lTemp < 0) |
|
54426 lTemp = 0; |
|
54427 if (lTemp > 255) |
|
54428 lTemp = 255; |
|
54429 |
|
54430 lRGBFramePtr[5] = (uint8) lTemp; |
|
54431 |
|
54432 |
|
54433 /*Third Pixel*/ |
|
54434 lY1 = lLumPtr[j + lLumWidth]; |
|
54435 |
|
54436 /*R component*/ |
|
54437 lTemp = lY1 + lTemp1; |
|
54438 if (lTemp < 0) |
|
54439 lTemp = 0; |
|
54440 if (lTemp > 255) |
|
54441 lTemp = 255; |
|
54442 lRGBFramePtr1[0] = (uint8) lTemp; |
|
54443 |
|
54444 /*G component*/ |
|
54445 lTemp = lY1 - lTemp2; |
|
54446 if (lTemp < 0) |
|
54447 lTemp = 0; |
|
54448 if (lTemp > 255) |
|
54449 lTemp = 255; |
|
54450 |
|
54451 lRGBFramePtr1[1] = (uint8) lTemp; |
|
54452 |
|
54453 /*B component*/ |
|
54454 lTemp = lY1 + lTemp3; |
|
54455 if (lTemp < 0) |
|
54456 lTemp = 0; |
|
54457 if (lTemp > 255) |
|
54458 lTemp = 255; |
|
54459 |
|
54460 lRGBFramePtr1[2] = (uint8) lTemp; |
|
54461 |
|
54462 /*Fourth Pixel*/ |
|
54463 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
54464 |
|
54465 /*R component*/ |
|
54466 lTemp = lY1 + lTemp1; |
|
54467 if (lTemp < 0) |
|
54468 lTemp = 0; |
|
54469 if (lTemp > 255) |
|
54470 lTemp = 255; |
|
54471 lRGBFramePtr1[3] = (uint8) lTemp; |
|
54472 |
|
54473 /*G component*/ |
|
54474 lTemp = lY1 - lTemp2; |
|
54475 if (lTemp < 0) |
|
54476 lTemp = 0; |
|
54477 if (lTemp > 255) |
|
54478 lTemp = 255; |
|
54479 lRGBFramePtr1[4] = (uint8) lTemp; |
|
54480 |
|
54481 /*B component*/ |
|
54482 lTemp = lY1 + lTemp3; |
|
54483 if (lTemp < 0) |
|
54484 lTemp = 0; |
|
54485 if (lTemp > 255) |
|
54486 lTemp = 255; |
|
54487 |
|
54488 lRGBFramePtr1[5] = (uint8) lTemp; |
|
54489 |
|
54490 lRGBFramePtr += 6; |
|
54491 lRGBFramePtr1 += 6; |
|
54492 } |
|
54493 |
|
54494 if(extraCol) |
|
54495 { |
|
54496 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
54497 lRGBFramePtr++; |
|
54498 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
54499 lRGBFramePtr++; |
|
54500 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
54501 lRGBFramePtr++; |
|
54502 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
54503 lRGBFramePtr1++; |
|
54504 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
54505 lRGBFramePtr1++; |
|
54506 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
54507 lRGBFramePtr1++; |
|
54508 |
|
54509 } |
|
54510 |
|
54511 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
54512 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
54513 |
|
54514 |
|
54515 if(extraRow) |
|
54516 { |
|
54517 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
54518 for(j = 0; j < lWidth * 3; j += 2) |
|
54519 { |
|
54520 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
54521 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
54522 } |
|
54523 if(extraCol) |
|
54524 { |
|
54525 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
54526 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
54527 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
54528 } |
|
54529 } |
|
54530 return; |
|
54531 } |
|
54532 |
|
54533 /* |
|
54534 ****************************************************************************** |
|
54535 Name : sEmz_VDec_YUV420Chr3toColor16M_709_RR |
|
54536 Description : Converts YUV420 Chroma3 Planar to RGB888 Interleaved format |
|
54537 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
54538 uint8 *dstImage : Pointer to rgb data (o/p). |
|
54539 tWndParam *srcWindow : Pointer to structure containing source window |
|
54540 parameters like xOffset,yOffset,cropWidth, |
|
54541 cropHeight. (i/p) |
|
54542 tWndParam *dstWindow : Pointer to structure containing destination window |
|
54543 parameters like xOffset,yOffset,windWidth, |
|
54544 windHeight. (i/p) |
|
54545 Return Value : void |
|
54546 ****************************************************************************** |
|
54547 */ |
|
54548 |
|
54549 void sEmz_VDec_YUV420Chr3toColor16M_709_RR |
|
54550 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
54551 tWndParam* srcWindow, tWndParam* dstWindow) |
|
54552 { |
|
54553 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
54554 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
54555 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
54556 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
54557 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
54558 int32 i, j, extraRow, extraCol; |
|
54559 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
54560 cropWidth,cropHeight,wndWidth,wndHeight; |
|
54561 |
|
54562 srcXOffset = srcWindow->xOffset; |
|
54563 srcYOffset = srcWindow->yOffset; |
|
54564 cropWidth = srcWindow->wndWidth; |
|
54565 cropHeight = srcWindow->wndHeight; |
|
54566 |
|
54567 dstXOffset = dstWindow->xOffset; |
|
54568 dstYOffset = dstWindow->yOffset; |
|
54569 wndWidth = dstWindow->wndWidth; |
|
54570 wndHeight = dstWindow->wndHeight; |
|
54571 |
|
54572 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
54573 { |
|
54574 lWidth = cropWidth; |
|
54575 } |
|
54576 else |
|
54577 { |
|
54578 lWidth = srcImage->width - srcXOffset; |
|
54579 } |
|
54580 |
|
54581 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
54582 { |
|
54583 lHeight = cropHeight; |
|
54584 } |
|
54585 else |
|
54586 { |
|
54587 lHeight = srcImage->height - srcYOffset; |
|
54588 } |
|
54589 |
|
54590 if (lWidth > (wndWidth - dstXOffset)) |
|
54591 { |
|
54592 lWidth = wndWidth - dstXOffset; |
|
54593 } |
|
54594 |
|
54595 if (lHeight > (wndHeight - dstYOffset)) |
|
54596 { |
|
54597 lHeight = wndHeight - dstYOffset; |
|
54598 } |
|
54599 |
|
54600 extraCol = lWidth & 0x01; |
|
54601 extraRow = lHeight & 0x01; |
|
54602 |
|
54603 lTempWidth = lWidth * 3; |
|
54604 lWidth = (lWidth >> 1) << 1; |
|
54605 lHeight = (lHeight >> 1) << 1; |
|
54606 |
|
54607 dstXOffset *= 3; |
|
54608 wndWidth *= 3; |
|
54609 |
|
54610 lLumWidth = (srcImage->width >> 1) << 1; |
|
54611 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
54612 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
54613 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
54614 |
|
54615 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
54616 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
54617 |
|
54618 for(i = 0; i < (lHeight - 2); i += 2) |
|
54619 { |
|
54620 for(j = 0; j < (lWidth - 2); j += 2) |
|
54621 { |
|
54622 lCr1 = lCrPtr[j >> 1]; |
|
54623 lCb1 = lCbPtr[j >> 1]; |
|
54624 |
|
54625 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
54626 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
54627 |
|
54628 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
54629 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
54630 |
|
54631 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
54632 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
54633 |
|
54634 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
54635 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
54636 |
|
54637 lCr2 = (lCr1 + lCr2) >> 1; |
|
54638 lCb2 = (lCb1 + lCb2) >> 1; |
|
54639 |
|
54640 lCr3 = (lCr1 + lCr3) >> 1; |
|
54641 lCb3 = (lCb1 + lCb3) >> 1; |
|
54642 |
|
54643 /*First Pixel*/ |
|
54644 lCr1 -= 128; |
|
54645 lCb1 -= 128; |
|
54646 |
|
54647 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
54648 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
54649 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
54650 |
|
54651 lY1 = lLumPtr[j]; |
|
54652 lY1 -= 16; |
|
54653 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
54654 |
|
54655 /*R component*/ |
|
54656 lTemp = lY1 + lTemp1; |
|
54657 if (lTemp < 0) |
|
54658 lTemp = 0; |
|
54659 if (lTemp > 255) |
|
54660 lTemp = 255; |
|
54661 |
|
54662 lRGBFramePtr[0] = (uint8) lTemp; |
|
54663 |
|
54664 /*G component*/ |
|
54665 lTemp = lY1 - lTemp2; |
|
54666 if (lTemp < 0) |
|
54667 lTemp = 0; |
|
54668 if (lTemp > 255) |
|
54669 lTemp = 255; |
|
54670 |
|
54671 lRGBFramePtr[1] = (uint8) lTemp; |
|
54672 |
|
54673 /*B component*/ |
|
54674 lTemp = lY1 + lTemp3; |
|
54675 if (lTemp < 0) |
|
54676 lTemp = 0; |
|
54677 if (lTemp > 255) |
|
54678 lTemp = 255; |
|
54679 |
|
54680 lRGBFramePtr[2] = (uint8) lTemp; |
|
54681 |
|
54682 /*Second Pixel*/ |
|
54683 lCr2 -= 128; |
|
54684 lCb2 -= 128; |
|
54685 |
|
54686 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
54687 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
54688 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
54689 |
|
54690 lY1 = lLumPtr[j + 1]; |
|
54691 lY1 -= 16; |
|
54692 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
54693 |
|
54694 /*R component*/ |
|
54695 lTemp = lY1 + lTemp1; |
|
54696 if (lTemp < 0) |
|
54697 lTemp = 0; |
|
54698 if (lTemp > 255) |
|
54699 lTemp = 255; |
|
54700 |
|
54701 lRGBFramePtr[3] = (uint8) lTemp; |
|
54702 |
|
54703 /*G component*/ |
|
54704 lTemp = lY1 - lTemp2; |
|
54705 if (lTemp < 0) |
|
54706 lTemp = 0; |
|
54707 if (lTemp > 255) |
|
54708 lTemp = 255; |
|
54709 |
|
54710 lRGBFramePtr[4] = (uint8) lTemp; |
|
54711 |
|
54712 |
|
54713 /*B component*/ |
|
54714 lTemp = lY1 + lTemp3; |
|
54715 |
|
54716 if (lTemp < 0) |
|
54717 lTemp = 0; |
|
54718 if (lTemp > 255) |
|
54719 lTemp = 255; |
|
54720 |
|
54721 lRGBFramePtr[5] = (uint8) lTemp; |
|
54722 |
|
54723 |
|
54724 /*Third Pixel*/ |
|
54725 lCr3 -= 128; |
|
54726 lCb3 -= 128; |
|
54727 |
|
54728 lTemp1 = (29374 * lCr3) >> COLOR_CONV_PRECISION; |
|
54729 lTemp2 = ((3494 * lCb3) + (8731 * lCr3)) >> COLOR_CONV_PRECISION; |
|
54730 lTemp3 = (34603 * lCb3) >> COLOR_CONV_PRECISION; |
|
54731 |
|
54732 lY1 = lLumPtr[j + lLumWidth]; |
|
54733 lY1 -= 16; |
|
54734 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
54735 |
|
54736 /*R component*/ |
|
54737 lTemp = lY1 + lTemp1; |
|
54738 if (lTemp < 0) |
|
54739 lTemp = 0; |
|
54740 if (lTemp > 255) |
|
54741 lTemp = 255; |
|
54742 lRGBFramePtr1[0] = (uint8) lTemp; |
|
54743 |
|
54744 /*G component*/ |
|
54745 lTemp = lY1 - lTemp2; |
|
54746 if (lTemp < 0) |
|
54747 lTemp = 0; |
|
54748 if (lTemp > 255) |
|
54749 lTemp = 255; |
|
54750 |
|
54751 lRGBFramePtr1[1] = (uint8) lTemp; |
|
54752 |
|
54753 /*B component*/ |
|
54754 lTemp = lY1 + lTemp3; |
|
54755 if (lTemp < 0) |
|
54756 lTemp = 0; |
|
54757 if (lTemp > 255) |
|
54758 lTemp = 255; |
|
54759 |
|
54760 lRGBFramePtr1[2] = (uint8) lTemp; |
|
54761 |
|
54762 /*Fourth Pixel*/ |
|
54763 lCr4 -= 128; |
|
54764 lCb4 -= 128; |
|
54765 |
|
54766 lTemp1 = (29374 * lCr4) >> COLOR_CONV_PRECISION; |
|
54767 lTemp2 = ((3494 * lCb4) + (8731 * lCr4)) >> COLOR_CONV_PRECISION; |
|
54768 lTemp3 = (34603 * lCb4) >> COLOR_CONV_PRECISION; |
|
54769 |
|
54770 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
54771 lY1 -= 16; |
|
54772 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
54773 |
|
54774 /*R component*/ |
|
54775 lTemp = lY1 + lTemp1; |
|
54776 if (lTemp < 0) |
|
54777 lTemp = 0; |
|
54778 if (lTemp > 255) |
|
54779 lTemp = 255; |
|
54780 lRGBFramePtr1[3] = (uint8) lTemp; |
|
54781 |
|
54782 /*G component*/ |
|
54783 lTemp = lY1 - lTemp2; |
|
54784 if (lTemp < 0) |
|
54785 lTemp = 0; |
|
54786 if (lTemp > 255) |
|
54787 lTemp = 255; |
|
54788 lRGBFramePtr1[4] = (uint8) lTemp; |
|
54789 |
|
54790 /*B component*/ |
|
54791 lTemp = lY1 + lTemp3; |
|
54792 if (lTemp < 0) |
|
54793 lTemp = 0; |
|
54794 if (lTemp > 255) |
|
54795 lTemp = 255; |
|
54796 |
|
54797 lRGBFramePtr1[5] = (uint8) lTemp; |
|
54798 |
|
54799 lRGBFramePtr += 6; |
|
54800 lRGBFramePtr1 += 6; |
|
54801 } |
|
54802 |
|
54803 |
|
54804 lCr1 = lCrPtr[j >> 1]; |
|
54805 lCb1 = lCbPtr[j >> 1]; |
|
54806 |
|
54807 lCr1 -= 128; |
|
54808 lCb1 -= 128; |
|
54809 |
|
54810 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
54811 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
54812 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
54813 |
|
54814 /*First Pixel*/ |
|
54815 lY1 = lLumPtr[j]; |
|
54816 lY1 -= 16; |
|
54817 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
54818 |
|
54819 /*R component*/ |
|
54820 lTemp = lY1 + lTemp1; |
|
54821 if (lTemp < 0) |
|
54822 lTemp = 0; |
|
54823 if (lTemp > 255) |
|
54824 lTemp = 255; |
|
54825 |
|
54826 lRGBFramePtr[0] = (uint8) lTemp; |
|
54827 |
|
54828 /*G component*/ |
|
54829 lTemp = lY1 - lTemp2; |
|
54830 if (lTemp < 0) |
|
54831 lTemp = 0; |
|
54832 if (lTemp > 255) |
|
54833 lTemp = 255; |
|
54834 |
|
54835 lRGBFramePtr[1] = (uint8) lTemp; |
|
54836 |
|
54837 /*B component*/ |
|
54838 lTemp = lY1 + lTemp3; |
|
54839 if (lTemp < 0) |
|
54840 lTemp = 0; |
|
54841 if (lTemp > 255) |
|
54842 lTemp = 255; |
|
54843 |
|
54844 lRGBFramePtr[2] = (uint8) lTemp; |
|
54845 |
|
54846 /*Second Pixel*/ |
|
54847 lY1 = lLumPtr[j + 1]; |
|
54848 lY1 -= 16; |
|
54849 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
54850 |
|
54851 /*R component*/ |
|
54852 lTemp = lY1 + lTemp1; |
|
54853 if (lTemp < 0) |
|
54854 lTemp = 0; |
|
54855 if (lTemp > 255) |
|
54856 lTemp = 255; |
|
54857 |
|
54858 lRGBFramePtr[3] = (uint8) lTemp; |
|
54859 |
|
54860 /*G component*/ |
|
54861 lTemp = lY1 - lTemp2; |
|
54862 if (lTemp < 0) |
|
54863 lTemp = 0; |
|
54864 if (lTemp > 255) |
|
54865 lTemp = 255; |
|
54866 |
|
54867 lRGBFramePtr[4] = (uint8) lTemp; |
|
54868 |
|
54869 |
|
54870 /*B component*/ |
|
54871 lTemp = lY1 + lTemp3; |
|
54872 |
|
54873 if (lTemp < 0) |
|
54874 lTemp = 0; |
|
54875 if (lTemp > 255) |
|
54876 lTemp = 255; |
|
54877 |
|
54878 lRGBFramePtr[5] = (uint8) lTemp; |
|
54879 |
|
54880 |
|
54881 /*Third Pixel*/ |
|
54882 lY1 = lLumPtr[j + lLumWidth]; |
|
54883 lY1 -= 16; |
|
54884 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
54885 |
|
54886 /*R component*/ |
|
54887 lTemp = lY1 + lTemp1; |
|
54888 if (lTemp < 0) |
|
54889 lTemp = 0; |
|
54890 if (lTemp > 255) |
|
54891 lTemp = 255; |
|
54892 lRGBFramePtr1[0] = (uint8) lTemp; |
|
54893 |
|
54894 /*G component*/ |
|
54895 lTemp = lY1 - lTemp2; |
|
54896 if (lTemp < 0) |
|
54897 lTemp = 0; |
|
54898 if (lTemp > 255) |
|
54899 lTemp = 255; |
|
54900 |
|
54901 lRGBFramePtr1[1] = (uint8) lTemp; |
|
54902 |
|
54903 /*B component*/ |
|
54904 lTemp = lY1 + lTemp3; |
|
54905 if (lTemp < 0) |
|
54906 lTemp = 0; |
|
54907 if (lTemp > 255) |
|
54908 lTemp = 255; |
|
54909 |
|
54910 lRGBFramePtr1[2] = (uint8) lTemp; |
|
54911 |
|
54912 /*Fourth Pixel*/ |
|
54913 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
54914 lY1 -= 16; |
|
54915 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
54916 |
|
54917 /*R component*/ |
|
54918 lTemp = lY1 + lTemp1; |
|
54919 if (lTemp < 0) |
|
54920 lTemp = 0; |
|
54921 if (lTemp > 255) |
|
54922 lTemp = 255; |
|
54923 lRGBFramePtr1[3] = (uint8) lTemp; |
|
54924 |
|
54925 /*G component*/ |
|
54926 lTemp = lY1 - lTemp2; |
|
54927 if (lTemp < 0) |
|
54928 lTemp = 0; |
|
54929 if (lTemp > 255) |
|
54930 lTemp = 255; |
|
54931 lRGBFramePtr1[4] = (uint8) lTemp; |
|
54932 |
|
54933 /*B component*/ |
|
54934 lTemp = lY1 + lTemp3; |
|
54935 if (lTemp < 0) |
|
54936 lTemp = 0; |
|
54937 if (lTemp > 255) |
|
54938 lTemp = 255; |
|
54939 |
|
54940 lRGBFramePtr1[5] = (uint8) lTemp; |
|
54941 |
|
54942 lRGBFramePtr += 6; |
|
54943 lRGBFramePtr1 += 6; |
|
54944 |
|
54945 if(extraCol) |
|
54946 { |
|
54947 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
54948 lRGBFramePtr++; |
|
54949 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
54950 lRGBFramePtr++; |
|
54951 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
54952 lRGBFramePtr++; |
|
54953 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
54954 lRGBFramePtr1++; |
|
54955 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
54956 lRGBFramePtr1++; |
|
54957 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
54958 lRGBFramePtr1++; |
|
54959 |
|
54960 } |
|
54961 |
|
54962 lLumPtr += (lLumWidth << 1); |
|
54963 lCrPtr += (lLumWidth >> 1); |
|
54964 lCbPtr += (lLumWidth >> 1); |
|
54965 |
|
54966 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
54967 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
54968 } |
|
54969 |
|
54970 |
|
54971 for(j = 0; j < lWidth; j += 2) |
|
54972 { |
|
54973 lCr1 = lCrPtr[j >> 1]; |
|
54974 lCb1 = lCbPtr[j >> 1]; |
|
54975 |
|
54976 lCr1 -= 128; |
|
54977 lCb1 -= 128; |
|
54978 |
|
54979 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
54980 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
54981 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
54982 |
|
54983 /*First Pixel*/ |
|
54984 lY1 = lLumPtr[j]; |
|
54985 lY1 -= 16; |
|
54986 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
54987 |
|
54988 /*R component*/ |
|
54989 lTemp = lY1 + lTemp1; |
|
54990 if (lTemp < 0) |
|
54991 lTemp = 0; |
|
54992 if (lTemp > 255) |
|
54993 lTemp = 255; |
|
54994 |
|
54995 lRGBFramePtr[0] = (uint8) lTemp; |
|
54996 |
|
54997 /*G component*/ |
|
54998 lTemp = lY1 - lTemp2; |
|
54999 if (lTemp < 0) |
|
55000 lTemp = 0; |
|
55001 if (lTemp > 255) |
|
55002 lTemp = 255; |
|
55003 |
|
55004 lRGBFramePtr[1] = (uint8) lTemp; |
|
55005 |
|
55006 /*B component*/ |
|
55007 lTemp = lY1 + lTemp3; |
|
55008 if (lTemp < 0) |
|
55009 lTemp = 0; |
|
55010 if (lTemp > 255) |
|
55011 lTemp = 255; |
|
55012 |
|
55013 lRGBFramePtr[2] = (uint8) lTemp; |
|
55014 |
|
55015 /*Second Pixel*/ |
|
55016 lY1 = lLumPtr[j + 1]; |
|
55017 lY1 -= 16; |
|
55018 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55019 |
|
55020 /*R component*/ |
|
55021 lTemp = lY1 + lTemp1; |
|
55022 if (lTemp < 0) |
|
55023 lTemp = 0; |
|
55024 if (lTemp > 255) |
|
55025 lTemp = 255; |
|
55026 |
|
55027 lRGBFramePtr[3] = (uint8) lTemp; |
|
55028 |
|
55029 /*G component*/ |
|
55030 lTemp = lY1 - lTemp2; |
|
55031 if (lTemp < 0) |
|
55032 lTemp = 0; |
|
55033 if (lTemp > 255) |
|
55034 lTemp = 255; |
|
55035 |
|
55036 lRGBFramePtr[4] = (uint8) lTemp; |
|
55037 |
|
55038 |
|
55039 /*B component*/ |
|
55040 lTemp = lY1 + lTemp3; |
|
55041 |
|
55042 if (lTemp < 0) |
|
55043 lTemp = 0; |
|
55044 if (lTemp > 255) |
|
55045 lTemp = 255; |
|
55046 |
|
55047 lRGBFramePtr[5] = (uint8) lTemp; |
|
55048 |
|
55049 |
|
55050 /*Third Pixel*/ |
|
55051 lY1 = lLumPtr[j + lLumWidth]; |
|
55052 lY1 -= 16; |
|
55053 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55054 |
|
55055 /*R component*/ |
|
55056 lTemp = lY1 + lTemp1; |
|
55057 if (lTemp < 0) |
|
55058 lTemp = 0; |
|
55059 if (lTemp > 255) |
|
55060 lTemp = 255; |
|
55061 lRGBFramePtr1[0] = (uint8) lTemp; |
|
55062 |
|
55063 /*G component*/ |
|
55064 lTemp = lY1 - lTemp2; |
|
55065 if (lTemp < 0) |
|
55066 lTemp = 0; |
|
55067 if (lTemp > 255) |
|
55068 lTemp = 255; |
|
55069 |
|
55070 lRGBFramePtr1[1] = (uint8) lTemp; |
|
55071 |
|
55072 /*B component*/ |
|
55073 lTemp = lY1 + lTemp3; |
|
55074 if (lTemp < 0) |
|
55075 lTemp = 0; |
|
55076 if (lTemp > 255) |
|
55077 lTemp = 255; |
|
55078 |
|
55079 lRGBFramePtr1[2] = (uint8) lTemp; |
|
55080 |
|
55081 /*Fourth Pixel*/ |
|
55082 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
55083 lY1 -= 16; |
|
55084 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55085 |
|
55086 /*R component*/ |
|
55087 lTemp = lY1 + lTemp1; |
|
55088 if (lTemp < 0) |
|
55089 lTemp = 0; |
|
55090 if (lTemp > 255) |
|
55091 lTemp = 255; |
|
55092 lRGBFramePtr1[3] = (uint8) lTemp; |
|
55093 |
|
55094 /*G component*/ |
|
55095 lTemp = lY1 - lTemp2; |
|
55096 if (lTemp < 0) |
|
55097 lTemp = 0; |
|
55098 if (lTemp > 255) |
|
55099 lTemp = 255; |
|
55100 lRGBFramePtr1[4] = (uint8) lTemp; |
|
55101 |
|
55102 /*B component*/ |
|
55103 lTemp = lY1 + lTemp3; |
|
55104 if (lTemp < 0) |
|
55105 lTemp = 0; |
|
55106 if (lTemp > 255) |
|
55107 lTemp = 255; |
|
55108 |
|
55109 lRGBFramePtr1[5] = (uint8) lTemp; |
|
55110 |
|
55111 lRGBFramePtr += 6; |
|
55112 lRGBFramePtr1 += 6; |
|
55113 } |
|
55114 |
|
55115 if(extraCol) |
|
55116 { |
|
55117 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
55118 lRGBFramePtr++; |
|
55119 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
55120 lRGBFramePtr++; |
|
55121 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
55122 lRGBFramePtr++; |
|
55123 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
55124 lRGBFramePtr1++; |
|
55125 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
55126 lRGBFramePtr1++; |
|
55127 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
55128 lRGBFramePtr1++; |
|
55129 |
|
55130 } |
|
55131 |
|
55132 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
55133 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
55134 |
|
55135 |
|
55136 if(extraRow) |
|
55137 { |
|
55138 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
55139 for(j = 0; j < lWidth * 3; j += 2) |
|
55140 { |
|
55141 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
55142 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
55143 } |
|
55144 if(extraCol) |
|
55145 { |
|
55146 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
55147 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
55148 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
55149 } |
|
55150 } |
|
55151 return; |
|
55152 } |
|
55153 |
|
55154 /* |
|
55155 ****************************************************************************** |
|
55156 Name : sEmz_VDec_YUV420Chr3toColor16M_601_5_RR |
|
55157 Description : Converts YUV420 Chroma3 Planar to RGB888 Interleaved format |
|
55158 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
55159 uint8 *dstImage : Pointer to rgb data (o/p). |
|
55160 tWndParam *srcWindow : Pointer to structure containing source window |
|
55161 parameters like xOffset,yOffset,cropWidth, |
|
55162 cropHeight. (i/p) |
|
55163 tWndParam *dstWindow : Pointer to structure containing destination window |
|
55164 parameters like xOffset,yOffset,windWidth, |
|
55165 windHeight. (i/p) |
|
55166 Return Value : void |
|
55167 ****************************************************************************** |
|
55168 */ |
|
55169 |
|
55170 void sEmz_VDec_YUV420Chr3toColor16M_601_5_RR |
|
55171 (tBaseVideoFrame *srcImage, uint8* dstImage, |
|
55172 tWndParam* srcWindow, tWndParam* dstWindow) |
|
55173 { |
|
55174 uint8 *lRGBFramePtr, *lRGBFramePtr1; |
|
55175 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
55176 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
55177 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
55178 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
55179 int32 i, j, extraRow, extraCol; |
|
55180 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
55181 cropWidth,cropHeight,wndWidth,wndHeight; |
|
55182 |
|
55183 srcXOffset = srcWindow->xOffset; |
|
55184 srcYOffset = srcWindow->yOffset; |
|
55185 cropWidth = srcWindow->wndWidth; |
|
55186 cropHeight = srcWindow->wndHeight; |
|
55187 |
|
55188 dstXOffset = dstWindow->xOffset; |
|
55189 dstYOffset = dstWindow->yOffset; |
|
55190 wndWidth = dstWindow->wndWidth; |
|
55191 wndHeight = dstWindow->wndHeight; |
|
55192 |
|
55193 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
55194 { |
|
55195 lWidth = cropWidth; |
|
55196 } |
|
55197 else |
|
55198 { |
|
55199 lWidth = srcImage->width - srcXOffset; |
|
55200 } |
|
55201 |
|
55202 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
55203 { |
|
55204 lHeight = cropHeight; |
|
55205 } |
|
55206 else |
|
55207 { |
|
55208 lHeight = srcImage->height - srcYOffset; |
|
55209 } |
|
55210 |
|
55211 if (lWidth > (wndWidth - dstXOffset)) |
|
55212 { |
|
55213 lWidth = wndWidth - dstXOffset; |
|
55214 } |
|
55215 |
|
55216 if (lHeight > (wndHeight - dstYOffset)) |
|
55217 { |
|
55218 lHeight = wndHeight - dstYOffset; |
|
55219 } |
|
55220 |
|
55221 extraCol = lWidth & 0x01; |
|
55222 extraRow = lHeight & 0x01; |
|
55223 |
|
55224 lTempWidth = lWidth * 3; |
|
55225 lWidth = (lWidth >> 1) << 1; |
|
55226 lHeight = (lHeight >> 1) << 1; |
|
55227 |
|
55228 dstXOffset *= 3; |
|
55229 wndWidth *= 3; |
|
55230 |
|
55231 lLumWidth = (srcImage->width >> 1) << 1; |
|
55232 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
55233 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
55234 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
55235 |
|
55236 lRGBFramePtr = dstImage + (dstYOffset * wndWidth) + dstXOffset; |
|
55237 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
55238 |
|
55239 for(i = 0; i < (lHeight - 2); i += 2) |
|
55240 { |
|
55241 for(j = 0; j < (lWidth - 2); j += 2) |
|
55242 { |
|
55243 lCr1 = lCrPtr[j >> 1]; |
|
55244 lCb1 = lCbPtr[j >> 1]; |
|
55245 |
|
55246 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
55247 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
55248 |
|
55249 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
55250 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
55251 |
|
55252 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
55253 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
55254 |
|
55255 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
55256 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
55257 |
|
55258 lCr2 = (lCr1 + lCr2) >> 1; |
|
55259 lCb2 = (lCb1 + lCb2) >> 1; |
|
55260 |
|
55261 lCr3 = (lCr1 + lCr3) >> 1; |
|
55262 lCb3 = (lCb1 + lCb3) >> 1; |
|
55263 |
|
55264 /*First Pixel*/ |
|
55265 lCr1 -= 128; |
|
55266 lCb1 -= 128; |
|
55267 |
|
55268 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
55269 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
55270 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
55271 |
|
55272 lY1 = lLumPtr[j]; |
|
55273 lY1 -= 16; |
|
55274 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55275 |
|
55276 /*R component*/ |
|
55277 lTemp = lY1 + lTemp1; |
|
55278 if (lTemp < 0) |
|
55279 lTemp = 0; |
|
55280 if (lTemp > 255) |
|
55281 lTemp = 255; |
|
55282 |
|
55283 lRGBFramePtr[0] = (uint8) lTemp; |
|
55284 |
|
55285 /*G component*/ |
|
55286 lTemp = lY1 - lTemp2; |
|
55287 if (lTemp < 0) |
|
55288 lTemp = 0; |
|
55289 if (lTemp > 255) |
|
55290 lTemp = 255; |
|
55291 |
|
55292 lRGBFramePtr[1] = (uint8) lTemp; |
|
55293 |
|
55294 /*B component*/ |
|
55295 lTemp = lY1 + lTemp3; |
|
55296 if (lTemp < 0) |
|
55297 lTemp = 0; |
|
55298 if (lTemp > 255) |
|
55299 lTemp = 255; |
|
55300 |
|
55301 lRGBFramePtr[2] = (uint8) lTemp; |
|
55302 |
|
55303 /*Second Pixel*/ |
|
55304 lCr2 -= 128; |
|
55305 lCb2 -= 128; |
|
55306 |
|
55307 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
55308 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
55309 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
55310 |
|
55311 lY1 = lLumPtr[j + 1]; |
|
55312 lY1 -= 16; |
|
55313 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55314 |
|
55315 /*R component*/ |
|
55316 lTemp = lY1 + lTemp1; |
|
55317 if (lTemp < 0) |
|
55318 lTemp = 0; |
|
55319 if (lTemp > 255) |
|
55320 lTemp = 255; |
|
55321 |
|
55322 lRGBFramePtr[3] = (uint8) lTemp; |
|
55323 |
|
55324 /*G component*/ |
|
55325 lTemp = lY1 - lTemp2; |
|
55326 if (lTemp < 0) |
|
55327 lTemp = 0; |
|
55328 if (lTemp > 255) |
|
55329 lTemp = 255; |
|
55330 |
|
55331 lRGBFramePtr[4] = (uint8) lTemp; |
|
55332 |
|
55333 |
|
55334 /*B component*/ |
|
55335 lTemp = lY1 + lTemp3; |
|
55336 |
|
55337 if (lTemp < 0) |
|
55338 lTemp = 0; |
|
55339 if (lTemp > 255) |
|
55340 lTemp = 255; |
|
55341 |
|
55342 lRGBFramePtr[5] = (uint8) lTemp; |
|
55343 |
|
55344 |
|
55345 /*Third Pixel*/ |
|
55346 lCr3 -= 128; |
|
55347 lCb3 -= 128; |
|
55348 |
|
55349 lTemp1 = (26748 * lCr3) >> COLOR_CONV_PRECISION; |
|
55350 lTemp2 = ((6563 * lCb3) + (13621 * lCr3)) >> COLOR_CONV_PRECISION; |
|
55351 lTemp3 = (33802 * lCb3) >> COLOR_CONV_PRECISION; |
|
55352 |
|
55353 lY1 = lLumPtr[j + lLumWidth]; |
|
55354 lY1 -= 16; |
|
55355 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55356 |
|
55357 /*R component*/ |
|
55358 lTemp = lY1 + lTemp1; |
|
55359 if (lTemp < 0) |
|
55360 lTemp = 0; |
|
55361 if (lTemp > 255) |
|
55362 lTemp = 255; |
|
55363 lRGBFramePtr1[0] = (uint8) lTemp; |
|
55364 |
|
55365 /*G component*/ |
|
55366 lTemp = lY1 - lTemp2; |
|
55367 if (lTemp < 0) |
|
55368 lTemp = 0; |
|
55369 if (lTemp > 255) |
|
55370 lTemp = 255; |
|
55371 |
|
55372 lRGBFramePtr1[1] = (uint8) lTemp; |
|
55373 |
|
55374 /*B component*/ |
|
55375 lTemp = lY1 + lTemp3; |
|
55376 if (lTemp < 0) |
|
55377 lTemp = 0; |
|
55378 if (lTemp > 255) |
|
55379 lTemp = 255; |
|
55380 |
|
55381 lRGBFramePtr1[2] = (uint8) lTemp; |
|
55382 |
|
55383 /*Fourth Pixel*/ |
|
55384 lCr4 -= 128; |
|
55385 lCb4 -= 128; |
|
55386 |
|
55387 lTemp1 = (26748 * lCr4) >> COLOR_CONV_PRECISION; |
|
55388 lTemp2 = ((6563 * lCb4) + (13621 * lCr4)) >> COLOR_CONV_PRECISION; |
|
55389 lTemp3 = (33802 * lCb4) >> COLOR_CONV_PRECISION; |
|
55390 |
|
55391 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
55392 lY1 -= 16; |
|
55393 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55394 |
|
55395 /*R component*/ |
|
55396 lTemp = lY1 + lTemp1; |
|
55397 if (lTemp < 0) |
|
55398 lTemp = 0; |
|
55399 if (lTemp > 255) |
|
55400 lTemp = 255; |
|
55401 lRGBFramePtr1[3] = (uint8) lTemp; |
|
55402 |
|
55403 /*G component*/ |
|
55404 lTemp = lY1 - lTemp2; |
|
55405 if (lTemp < 0) |
|
55406 lTemp = 0; |
|
55407 if (lTemp > 255) |
|
55408 lTemp = 255; |
|
55409 lRGBFramePtr1[4] = (uint8) lTemp; |
|
55410 |
|
55411 /*B component*/ |
|
55412 lTemp = lY1 + lTemp3; |
|
55413 if (lTemp < 0) |
|
55414 lTemp = 0; |
|
55415 if (lTemp > 255) |
|
55416 lTemp = 255; |
|
55417 |
|
55418 lRGBFramePtr1[5] = (uint8) lTemp; |
|
55419 |
|
55420 lRGBFramePtr += 6; |
|
55421 lRGBFramePtr1 += 6; |
|
55422 } |
|
55423 |
|
55424 |
|
55425 lCr1 = lCrPtr[j >> 1]; |
|
55426 lCb1 = lCbPtr[j >> 1]; |
|
55427 |
|
55428 lCr1 -= 128; |
|
55429 lCb1 -= 128; |
|
55430 |
|
55431 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
55432 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
55433 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
55434 |
|
55435 /*First Pixel*/ |
|
55436 lY1 = lLumPtr[j]; |
|
55437 lY1 -= 16; |
|
55438 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55439 |
|
55440 /*R component*/ |
|
55441 lTemp = lY1 + lTemp1; |
|
55442 if (lTemp < 0) |
|
55443 lTemp = 0; |
|
55444 if (lTemp > 255) |
|
55445 lTemp = 255; |
|
55446 |
|
55447 lRGBFramePtr[0] = (uint8) lTemp; |
|
55448 |
|
55449 /*G component*/ |
|
55450 lTemp = lY1 - lTemp2; |
|
55451 if (lTemp < 0) |
|
55452 lTemp = 0; |
|
55453 if (lTemp > 255) |
|
55454 lTemp = 255; |
|
55455 |
|
55456 lRGBFramePtr[1] = (uint8) lTemp; |
|
55457 |
|
55458 /*B component*/ |
|
55459 lTemp = lY1 + lTemp3; |
|
55460 if (lTemp < 0) |
|
55461 lTemp = 0; |
|
55462 if (lTemp > 255) |
|
55463 lTemp = 255; |
|
55464 |
|
55465 lRGBFramePtr[2] = (uint8) lTemp; |
|
55466 |
|
55467 /*Second Pixel*/ |
|
55468 lY1 = lLumPtr[j + 1]; |
|
55469 lY1 -= 16; |
|
55470 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55471 |
|
55472 /*R component*/ |
|
55473 lTemp = lY1 + lTemp1; |
|
55474 if (lTemp < 0) |
|
55475 lTemp = 0; |
|
55476 if (lTemp > 255) |
|
55477 lTemp = 255; |
|
55478 |
|
55479 lRGBFramePtr[3] = (uint8) lTemp; |
|
55480 |
|
55481 /*G component*/ |
|
55482 lTemp = lY1 - lTemp2; |
|
55483 if (lTemp < 0) |
|
55484 lTemp = 0; |
|
55485 if (lTemp > 255) |
|
55486 lTemp = 255; |
|
55487 |
|
55488 lRGBFramePtr[4] = (uint8) lTemp; |
|
55489 |
|
55490 |
|
55491 /*B component*/ |
|
55492 lTemp = lY1 + lTemp3; |
|
55493 |
|
55494 if (lTemp < 0) |
|
55495 lTemp = 0; |
|
55496 if (lTemp > 255) |
|
55497 lTemp = 255; |
|
55498 |
|
55499 lRGBFramePtr[5] = (uint8) lTemp; |
|
55500 |
|
55501 |
|
55502 /*Third Pixel*/ |
|
55503 lY1 = lLumPtr[j + lLumWidth]; |
|
55504 lY1 -= 16; |
|
55505 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55506 |
|
55507 /*R component*/ |
|
55508 lTemp = lY1 + lTemp1; |
|
55509 if (lTemp < 0) |
|
55510 lTemp = 0; |
|
55511 if (lTemp > 255) |
|
55512 lTemp = 255; |
|
55513 lRGBFramePtr1[0] = (uint8) lTemp; |
|
55514 |
|
55515 /*G component*/ |
|
55516 lTemp = lY1 - lTemp2; |
|
55517 if (lTemp < 0) |
|
55518 lTemp = 0; |
|
55519 if (lTemp > 255) |
|
55520 lTemp = 255; |
|
55521 |
|
55522 lRGBFramePtr1[1] = (uint8) lTemp; |
|
55523 |
|
55524 /*B component*/ |
|
55525 lTemp = lY1 + lTemp3; |
|
55526 if (lTemp < 0) |
|
55527 lTemp = 0; |
|
55528 if (lTemp > 255) |
|
55529 lTemp = 255; |
|
55530 |
|
55531 lRGBFramePtr1[2] = (uint8) lTemp; |
|
55532 |
|
55533 /*Fourth Pixel*/ |
|
55534 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
55535 lY1 -= 16; |
|
55536 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55537 |
|
55538 /*R component*/ |
|
55539 lTemp = lY1 + lTemp1; |
|
55540 if (lTemp < 0) |
|
55541 lTemp = 0; |
|
55542 if (lTemp > 255) |
|
55543 lTemp = 255; |
|
55544 lRGBFramePtr1[3] = (uint8) lTemp; |
|
55545 |
|
55546 /*G component*/ |
|
55547 lTemp = lY1 - lTemp2; |
|
55548 if (lTemp < 0) |
|
55549 lTemp = 0; |
|
55550 if (lTemp > 255) |
|
55551 lTemp = 255; |
|
55552 lRGBFramePtr1[4] = (uint8) lTemp; |
|
55553 |
|
55554 /*B component*/ |
|
55555 lTemp = lY1 + lTemp3; |
|
55556 if (lTemp < 0) |
|
55557 lTemp = 0; |
|
55558 if (lTemp > 255) |
|
55559 lTemp = 255; |
|
55560 |
|
55561 lRGBFramePtr1[5] = (uint8) lTemp; |
|
55562 |
|
55563 lRGBFramePtr += 6; |
|
55564 lRGBFramePtr1 += 6; |
|
55565 |
|
55566 if(extraCol) |
|
55567 { |
|
55568 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
55569 lRGBFramePtr++; |
|
55570 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
55571 lRGBFramePtr++; |
|
55572 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
55573 lRGBFramePtr++; |
|
55574 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
55575 lRGBFramePtr1++; |
|
55576 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
55577 lRGBFramePtr1++; |
|
55578 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
55579 lRGBFramePtr1++; |
|
55580 |
|
55581 } |
|
55582 |
|
55583 lLumPtr += (lLumWidth << 1); |
|
55584 lCrPtr += (lLumWidth >> 1); |
|
55585 lCbPtr += (lLumWidth >> 1); |
|
55586 |
|
55587 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
55588 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
55589 } |
|
55590 |
|
55591 |
|
55592 for(j = 0; j < lWidth; j += 2) |
|
55593 { |
|
55594 lCr1 = lCrPtr[j >> 1]; |
|
55595 lCb1 = lCbPtr[j >> 1]; |
|
55596 |
|
55597 lCr1 -= 128; |
|
55598 lCb1 -= 128; |
|
55599 |
|
55600 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
55601 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
55602 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
55603 |
|
55604 /*First Pixel*/ |
|
55605 lY1 = lLumPtr[j]; |
|
55606 lY1 -= 16; |
|
55607 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55608 |
|
55609 /*R component*/ |
|
55610 lTemp = lY1 + lTemp1; |
|
55611 if (lTemp < 0) |
|
55612 lTemp = 0; |
|
55613 if (lTemp > 255) |
|
55614 lTemp = 255; |
|
55615 |
|
55616 lRGBFramePtr[0] = (uint8) lTemp; |
|
55617 |
|
55618 /*G component*/ |
|
55619 lTemp = lY1 - lTemp2; |
|
55620 if (lTemp < 0) |
|
55621 lTemp = 0; |
|
55622 if (lTemp > 255) |
|
55623 lTemp = 255; |
|
55624 |
|
55625 lRGBFramePtr[1] = (uint8) lTemp; |
|
55626 |
|
55627 /*B component*/ |
|
55628 lTemp = lY1 + lTemp3; |
|
55629 if (lTemp < 0) |
|
55630 lTemp = 0; |
|
55631 if (lTemp > 255) |
|
55632 lTemp = 255; |
|
55633 |
|
55634 lRGBFramePtr[2] = (uint8) lTemp; |
|
55635 |
|
55636 /*Second Pixel*/ |
|
55637 lY1 = lLumPtr[j + 1]; |
|
55638 lY1 -= 16; |
|
55639 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55640 |
|
55641 /*R component*/ |
|
55642 lTemp = lY1 + lTemp1; |
|
55643 if (lTemp < 0) |
|
55644 lTemp = 0; |
|
55645 if (lTemp > 255) |
|
55646 lTemp = 255; |
|
55647 |
|
55648 lRGBFramePtr[3] = (uint8) lTemp; |
|
55649 |
|
55650 /*G component*/ |
|
55651 lTemp = lY1 - lTemp2; |
|
55652 if (lTemp < 0) |
|
55653 lTemp = 0; |
|
55654 if (lTemp > 255) |
|
55655 lTemp = 255; |
|
55656 |
|
55657 lRGBFramePtr[4] = (uint8) lTemp; |
|
55658 |
|
55659 |
|
55660 /*B component*/ |
|
55661 lTemp = lY1 + lTemp3; |
|
55662 |
|
55663 if (lTemp < 0) |
|
55664 lTemp = 0; |
|
55665 if (lTemp > 255) |
|
55666 lTemp = 255; |
|
55667 |
|
55668 lRGBFramePtr[5] = (uint8) lTemp; |
|
55669 |
|
55670 |
|
55671 /*Third Pixel*/ |
|
55672 lY1 = lLumPtr[j + lLumWidth]; |
|
55673 lY1 -= 16; |
|
55674 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55675 |
|
55676 /*R component*/ |
|
55677 lTemp = lY1 + lTemp1; |
|
55678 if (lTemp < 0) |
|
55679 lTemp = 0; |
|
55680 if (lTemp > 255) |
|
55681 lTemp = 255; |
|
55682 lRGBFramePtr1[0] = (uint8) lTemp; |
|
55683 |
|
55684 /*G component*/ |
|
55685 lTemp = lY1 - lTemp2; |
|
55686 if (lTemp < 0) |
|
55687 lTemp = 0; |
|
55688 if (lTemp > 255) |
|
55689 lTemp = 255; |
|
55690 |
|
55691 lRGBFramePtr1[1] = (uint8) lTemp; |
|
55692 |
|
55693 /*B component*/ |
|
55694 lTemp = lY1 + lTemp3; |
|
55695 if (lTemp < 0) |
|
55696 lTemp = 0; |
|
55697 if (lTemp > 255) |
|
55698 lTemp = 255; |
|
55699 |
|
55700 lRGBFramePtr1[2] = (uint8) lTemp; |
|
55701 |
|
55702 /*Fourth Pixel*/ |
|
55703 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
55704 lY1 -= 16; |
|
55705 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
55706 |
|
55707 /*R component*/ |
|
55708 lTemp = lY1 + lTemp1; |
|
55709 if (lTemp < 0) |
|
55710 lTemp = 0; |
|
55711 if (lTemp > 255) |
|
55712 lTemp = 255; |
|
55713 lRGBFramePtr1[3] = (uint8) lTemp; |
|
55714 |
|
55715 /*G component*/ |
|
55716 lTemp = lY1 - lTemp2; |
|
55717 if (lTemp < 0) |
|
55718 lTemp = 0; |
|
55719 if (lTemp > 255) |
|
55720 lTemp = 255; |
|
55721 lRGBFramePtr1[4] = (uint8) lTemp; |
|
55722 |
|
55723 /*B component*/ |
|
55724 lTemp = lY1 + lTemp3; |
|
55725 if (lTemp < 0) |
|
55726 lTemp = 0; |
|
55727 if (lTemp > 255) |
|
55728 lTemp = 255; |
|
55729 |
|
55730 lRGBFramePtr1[5] = (uint8) lTemp; |
|
55731 |
|
55732 lRGBFramePtr += 6; |
|
55733 lRGBFramePtr1 += 6; |
|
55734 } |
|
55735 |
|
55736 if(extraCol) |
|
55737 { |
|
55738 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
55739 lRGBFramePtr++; |
|
55740 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
55741 lRGBFramePtr++; |
|
55742 *lRGBFramePtr = lRGBFramePtr[-3]; |
|
55743 lRGBFramePtr++; |
|
55744 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
55745 lRGBFramePtr1++; |
|
55746 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
55747 lRGBFramePtr1++; |
|
55748 *lRGBFramePtr1 = lRGBFramePtr1[-3]; |
|
55749 lRGBFramePtr1++; |
|
55750 |
|
55751 } |
|
55752 |
|
55753 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
55754 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
55755 |
|
55756 |
|
55757 if(extraRow) |
|
55758 { |
|
55759 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
55760 for(j = 0; j < lWidth * 3; j += 2) |
|
55761 { |
|
55762 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
55763 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
55764 } |
|
55765 if(extraCol) |
|
55766 { |
|
55767 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
55768 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
55769 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
55770 } |
|
55771 } |
|
55772 return; |
|
55773 } |
|
55774 |
|
55775 |
|
55776 /* |
|
55777 ****************************************************************************** |
|
55778 Name : sEmz_VDec_YUV420Chr3toColor16MU_709_FR |
|
55779 Description : Converts YUV420 Chroma3 Planar to XRGB (8:8:8:8) Interleaved format |
|
55780 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
55781 uint8 *dstImage : Pointer to rgb data (o/p). |
|
55782 tWndParam *srcWindow : Pointer to structure containing source window |
|
55783 parameters like xOffset,yOffset,cropWidth, |
|
55784 cropHeight. (i/p) |
|
55785 tWndParam *dstWindow : Pointer to structure containing destination window |
|
55786 parameters like xOffset,yOffset,windWidth, |
|
55787 windHeight. (i/p) |
|
55788 Return Value : void |
|
55789 ****************************************************************************** |
|
55790 */ |
|
55791 |
|
55792 void sEmz_VDec_YUV420Chr3toColor16MU_709_FR |
|
55793 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
55794 tWndParam* srcWindow, tWndParam* dstWindow) |
|
55795 { |
|
55796 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
55797 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
55798 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
55799 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
55800 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
55801 int32 i, j, extraRow, extraCol; |
|
55802 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
55803 cropWidth,cropHeight,wndWidth,wndHeight; |
|
55804 |
|
55805 srcXOffset = srcWindow->xOffset; |
|
55806 srcYOffset = srcWindow->yOffset; |
|
55807 cropWidth = srcWindow->wndWidth; |
|
55808 cropHeight = srcWindow->wndHeight; |
|
55809 |
|
55810 dstXOffset = dstWindow->xOffset; |
|
55811 dstYOffset = dstWindow->yOffset; |
|
55812 wndWidth = dstWindow->wndWidth; |
|
55813 wndHeight = dstWindow->wndHeight; |
|
55814 |
|
55815 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
55816 { |
|
55817 lWidth = cropWidth; |
|
55818 } |
|
55819 else |
|
55820 { |
|
55821 lWidth = srcImage->width - srcXOffset; |
|
55822 } |
|
55823 |
|
55824 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
55825 { |
|
55826 lHeight = cropHeight; |
|
55827 } |
|
55828 else |
|
55829 { |
|
55830 lHeight = srcImage->height - srcYOffset; |
|
55831 } |
|
55832 |
|
55833 if (lWidth > (wndWidth - dstXOffset)) |
|
55834 { |
|
55835 lWidth = wndWidth - dstXOffset; |
|
55836 } |
|
55837 |
|
55838 if (lHeight > (wndHeight - dstYOffset)) |
|
55839 { |
|
55840 lHeight = wndHeight - dstYOffset; |
|
55841 } |
|
55842 |
|
55843 extraCol = lWidth & 0x01; |
|
55844 extraRow = lHeight & 0x01; |
|
55845 |
|
55846 lTempWidth = lWidth; |
|
55847 lWidth = (lWidth >> 1) << 1; |
|
55848 lHeight = (lHeight >> 1) << 1; |
|
55849 |
|
55850 lLumWidth = (srcImage->width >> 1) << 1; |
|
55851 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
55852 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
55853 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
55854 |
|
55855 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
55856 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
55857 |
|
55858 for(i = 0; i < (lHeight - 2); i += 2) |
|
55859 { |
|
55860 for(j = 0; j < (lWidth - 2); j += 2) |
|
55861 { |
|
55862 lCr1 = lCrPtr[j >> 1]; |
|
55863 lCb1 = lCbPtr[j >> 1]; |
|
55864 |
|
55865 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
55866 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
55867 |
|
55868 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
55869 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
55870 |
|
55871 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
55872 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
55873 |
|
55874 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
55875 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
55876 |
|
55877 lCr2 = (lCr1 + lCr2) >> 1; |
|
55878 lCb2 = (lCb1 + lCb2) >> 1; |
|
55879 |
|
55880 lCr3 = (lCr1 + lCr3) >> 1; |
|
55881 lCb3 = (lCb1 + lCb3) >> 1; |
|
55882 |
|
55883 /*First Pixel*/ |
|
55884 lCr1 -= 128; |
|
55885 lCb1 -= 128; |
|
55886 |
|
55887 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
55888 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
55889 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
55890 |
|
55891 lY1 = lLumPtr[j]; |
|
55892 |
|
55893 /*B component*/ |
|
55894 lTemp = lY1 + lTemp3; |
|
55895 if (lTemp < 0) |
|
55896 lTemp = 0; |
|
55897 if (lTemp > 255) |
|
55898 lTemp = 255; |
|
55899 lTemp4 = (uint8) lTemp; |
|
55900 |
|
55901 /*G component*/ |
|
55902 lTemp = lY1 - lTemp2; |
|
55903 if (lTemp < 0) |
|
55904 lTemp = 0; |
|
55905 if (lTemp > 255) |
|
55906 lTemp = 255; |
|
55907 lTemp4 |= lTemp << 8; |
|
55908 |
|
55909 /*R component*/ |
|
55910 lTemp = lY1 + lTemp1; |
|
55911 if (lTemp < 0) |
|
55912 lTemp = 0; |
|
55913 if (lTemp > 255) |
|
55914 lTemp = 255; |
|
55915 lTemp4 |= lTemp << 16; |
|
55916 |
|
55917 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
55918 |
|
55919 /*Second Pixel*/ |
|
55920 lCr2 -= 128; |
|
55921 lCb2 -= 128; |
|
55922 |
|
55923 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
55924 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
55925 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
55926 |
|
55927 lY1 = lLumPtr[j + 1]; |
|
55928 |
|
55929 /*B component*/ |
|
55930 lTemp = lY1 + lTemp3; |
|
55931 if (lTemp < 0) |
|
55932 lTemp = 0; |
|
55933 if (lTemp > 255) |
|
55934 lTemp = 255; |
|
55935 lTemp4 = (uint8) lTemp; |
|
55936 |
|
55937 /*G component*/ |
|
55938 lTemp = lY1 - lTemp2; |
|
55939 if (lTemp < 0) |
|
55940 lTemp = 0; |
|
55941 if (lTemp > 255) |
|
55942 lTemp = 255; |
|
55943 lTemp4 |= lTemp << 8; |
|
55944 |
|
55945 /*R component*/ |
|
55946 lTemp = lY1 + lTemp1; |
|
55947 if (lTemp < 0) |
|
55948 lTemp = 0; |
|
55949 if (lTemp > 255) |
|
55950 lTemp = 255; |
|
55951 lTemp4 |= lTemp << 16; |
|
55952 |
|
55953 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
55954 |
|
55955 |
|
55956 /*Third Pixel*/ |
|
55957 lCr3 -= 128; |
|
55958 lCb3 -= 128; |
|
55959 |
|
55960 lTemp1 = (25801 * lCr3) >> COLOR_CONV_PRECISION; |
|
55961 lTemp2 = ((3072 * lCb3) + (7670 * lCr3)) >> COLOR_CONV_PRECISION; |
|
55962 lTemp3 = (30397 * lCb3) >> COLOR_CONV_PRECISION; |
|
55963 |
|
55964 lY1 = lLumPtr[j + lLumWidth]; |
|
55965 |
|
55966 /*B component*/ |
|
55967 lTemp = lY1 + lTemp3; |
|
55968 if (lTemp < 0) |
|
55969 lTemp = 0; |
|
55970 if (lTemp > 255) |
|
55971 lTemp = 255; |
|
55972 lTemp4 = (uint8) lTemp; |
|
55973 |
|
55974 /*G component*/ |
|
55975 lTemp = lY1 - lTemp2; |
|
55976 if (lTemp < 0) |
|
55977 lTemp = 0; |
|
55978 if (lTemp > 255) |
|
55979 lTemp = 255; |
|
55980 lTemp4 |= lTemp << 8; |
|
55981 |
|
55982 /*R component*/ |
|
55983 lTemp = lY1 + lTemp1; |
|
55984 if (lTemp < 0) |
|
55985 lTemp = 0; |
|
55986 if (lTemp > 255) |
|
55987 lTemp = 255; |
|
55988 lTemp4 |= lTemp << 16; |
|
55989 |
|
55990 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
55991 |
|
55992 /*Fourth Pixel*/ |
|
55993 lCr4 -= 128; |
|
55994 lCb4 -= 128; |
|
55995 |
|
55996 lTemp1 = (25801 * lCr4) >> COLOR_CONV_PRECISION; |
|
55997 lTemp2 = ((3072 * lCb4) + (7670 * lCr4)) >> COLOR_CONV_PRECISION; |
|
55998 lTemp3 = (30397 * lCb4) >> COLOR_CONV_PRECISION; |
|
55999 |
|
56000 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
56001 |
|
56002 /*B component*/ |
|
56003 lTemp = lY1 + lTemp3; |
|
56004 if (lTemp < 0) |
|
56005 lTemp = 0; |
|
56006 if (lTemp > 255) |
|
56007 lTemp = 255; |
|
56008 lTemp4 = (uint8) lTemp; |
|
56009 |
|
56010 /*G component*/ |
|
56011 lTemp = lY1 - lTemp2; |
|
56012 if (lTemp < 0) |
|
56013 lTemp = 0; |
|
56014 if (lTemp > 255) |
|
56015 lTemp = 255; |
|
56016 lTemp4 |= lTemp << 8; |
|
56017 |
|
56018 /*R component*/ |
|
56019 lTemp = lY1 + lTemp1; |
|
56020 if (lTemp < 0) |
|
56021 lTemp = 0; |
|
56022 if (lTemp > 255) |
|
56023 lTemp = 255; |
|
56024 lTemp4 |= lTemp << 16; |
|
56025 |
|
56026 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
56027 |
|
56028 lRGBFramePtr += 2; |
|
56029 lRGBFramePtr1 += 2; |
|
56030 } |
|
56031 |
|
56032 lCr1 = lCrPtr[j >> 1]; |
|
56033 lCb1 = lCbPtr[j >> 1]; |
|
56034 |
|
56035 lCr1 -= 128; |
|
56036 lCb1 -= 128; |
|
56037 |
|
56038 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
56039 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
56040 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
56041 |
|
56042 /*First Pixel*/ |
|
56043 lY1 = lLumPtr[j]; |
|
56044 |
|
56045 /*B component*/ |
|
56046 lTemp = lY1 + lTemp3; |
|
56047 if (lTemp < 0) |
|
56048 lTemp = 0; |
|
56049 if (lTemp > 255) |
|
56050 lTemp = 255; |
|
56051 lTemp4 = (uint8) lTemp; |
|
56052 |
|
56053 /*G component*/ |
|
56054 lTemp = lY1 - lTemp2; |
|
56055 if (lTemp < 0) |
|
56056 lTemp = 0; |
|
56057 if (lTemp > 255) |
|
56058 lTemp = 255; |
|
56059 lTemp4 |= lTemp << 8; |
|
56060 |
|
56061 /*R component*/ |
|
56062 lTemp = lY1 + lTemp1; |
|
56063 if (lTemp < 0) |
|
56064 lTemp = 0; |
|
56065 if (lTemp > 255) |
|
56066 lTemp = 255; |
|
56067 lTemp4 |= lTemp << 16; |
|
56068 |
|
56069 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
56070 |
|
56071 /*Second Pixel*/ |
|
56072 lY1 = lLumPtr[j + 1]; |
|
56073 |
|
56074 /*B component*/ |
|
56075 lTemp = lY1 + lTemp3; |
|
56076 if (lTemp < 0) |
|
56077 lTemp = 0; |
|
56078 if (lTemp > 255) |
|
56079 lTemp = 255; |
|
56080 lTemp4 = (uint8) lTemp; |
|
56081 |
|
56082 /*G component*/ |
|
56083 lTemp = lY1 - lTemp2; |
|
56084 if (lTemp < 0) |
|
56085 lTemp = 0; |
|
56086 if (lTemp > 255) |
|
56087 lTemp = 255; |
|
56088 lTemp4 |= lTemp << 8; |
|
56089 |
|
56090 /*R component*/ |
|
56091 lTemp = lY1 + lTemp1; |
|
56092 if (lTemp < 0) |
|
56093 lTemp = 0; |
|
56094 if (lTemp > 255) |
|
56095 lTemp = 255; |
|
56096 lTemp4 |= lTemp << 16; |
|
56097 |
|
56098 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
56099 |
|
56100 |
|
56101 /*Third Pixel*/ |
|
56102 lY1 = lLumPtr[j + lLumWidth]; |
|
56103 |
|
56104 /*B component*/ |
|
56105 lTemp = lY1 + lTemp3; |
|
56106 if (lTemp < 0) |
|
56107 lTemp = 0; |
|
56108 if (lTemp > 255) |
|
56109 lTemp = 255; |
|
56110 lTemp4 = (uint8) lTemp; |
|
56111 |
|
56112 /*G component*/ |
|
56113 lTemp = lY1 - lTemp2; |
|
56114 if (lTemp < 0) |
|
56115 lTemp = 0; |
|
56116 if (lTemp > 255) |
|
56117 lTemp = 255; |
|
56118 lTemp4 |= lTemp << 8; |
|
56119 |
|
56120 /*R component*/ |
|
56121 lTemp = lY1 + lTemp1; |
|
56122 if (lTemp < 0) |
|
56123 lTemp = 0; |
|
56124 if (lTemp > 255) |
|
56125 lTemp = 255; |
|
56126 lTemp4 |= lTemp << 16; |
|
56127 |
|
56128 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
56129 |
|
56130 /*Fourth Pixel*/ |
|
56131 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
56132 |
|
56133 /*B component*/ |
|
56134 lTemp = lY1 + lTemp3; |
|
56135 if (lTemp < 0) |
|
56136 lTemp = 0; |
|
56137 if (lTemp > 255) |
|
56138 lTemp = 255; |
|
56139 lTemp4 = (uint8) lTemp; |
|
56140 |
|
56141 /*G component*/ |
|
56142 lTemp = lY1 - lTemp2; |
|
56143 if (lTemp < 0) |
|
56144 lTemp = 0; |
|
56145 if (lTemp > 255) |
|
56146 lTemp = 255; |
|
56147 lTemp4 |= lTemp << 8; |
|
56148 |
|
56149 /*R component*/ |
|
56150 lTemp = lY1 + lTemp1; |
|
56151 if (lTemp < 0) |
|
56152 lTemp = 0; |
|
56153 if (lTemp > 255) |
|
56154 lTemp = 255; |
|
56155 lTemp4 |= lTemp << 16; |
|
56156 |
|
56157 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
56158 |
|
56159 lRGBFramePtr += 2; |
|
56160 lRGBFramePtr1 += 2; |
|
56161 |
|
56162 if(extraCol) |
|
56163 { |
|
56164 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
56165 lRGBFramePtr++; |
|
56166 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
56167 lRGBFramePtr1++; |
|
56168 } |
|
56169 |
|
56170 lLumPtr += (lLumWidth << 1); |
|
56171 lCrPtr += (lLumWidth >> 1); |
|
56172 lCbPtr += (lLumWidth >> 1); |
|
56173 |
|
56174 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
56175 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
56176 } |
|
56177 |
|
56178 |
|
56179 for(j = 0; j < lWidth; j += 2) |
|
56180 { |
|
56181 lCr1 = lCrPtr[j >> 1]; |
|
56182 lCb1 = lCbPtr[j >> 1]; |
|
56183 |
|
56184 lCr1 -= 128; |
|
56185 lCb1 -= 128; |
|
56186 |
|
56187 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
56188 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
56189 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
56190 |
|
56191 /*First Pixel*/ |
|
56192 lY1 = lLumPtr[j]; |
|
56193 |
|
56194 /*B component*/ |
|
56195 lTemp = lY1 + lTemp3; |
|
56196 if (lTemp < 0) |
|
56197 lTemp = 0; |
|
56198 if (lTemp > 255) |
|
56199 lTemp = 255; |
|
56200 lTemp4 = (uint8) lTemp; |
|
56201 |
|
56202 /*G component*/ |
|
56203 lTemp = lY1 - lTemp2; |
|
56204 if (lTemp < 0) |
|
56205 lTemp = 0; |
|
56206 if (lTemp > 255) |
|
56207 lTemp = 255; |
|
56208 lTemp4 |= lTemp << 8; |
|
56209 |
|
56210 /*R component*/ |
|
56211 lTemp = lY1 + lTemp1; |
|
56212 if (lTemp < 0) |
|
56213 lTemp = 0; |
|
56214 if (lTemp > 255) |
|
56215 lTemp = 255; |
|
56216 lTemp4 |= lTemp << 16; |
|
56217 |
|
56218 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
56219 |
|
56220 /*Second Pixel*/ |
|
56221 lY1 = lLumPtr[j + 1]; |
|
56222 |
|
56223 /*B component*/ |
|
56224 lTemp = lY1 + lTemp3; |
|
56225 if (lTemp < 0) |
|
56226 lTemp = 0; |
|
56227 if (lTemp > 255) |
|
56228 lTemp = 255; |
|
56229 lTemp4 = (uint8) lTemp; |
|
56230 |
|
56231 /*G component*/ |
|
56232 lTemp = lY1 - lTemp2; |
|
56233 if (lTemp < 0) |
|
56234 lTemp = 0; |
|
56235 if (lTemp > 255) |
|
56236 lTemp = 255; |
|
56237 lTemp4 |= lTemp << 8; |
|
56238 |
|
56239 /*R component*/ |
|
56240 lTemp = lY1 + lTemp1; |
|
56241 if (lTemp < 0) |
|
56242 lTemp = 0; |
|
56243 if (lTemp > 255) |
|
56244 lTemp = 255; |
|
56245 lTemp4 |= lTemp << 16; |
|
56246 |
|
56247 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
56248 |
|
56249 |
|
56250 /*Third Pixel*/ |
|
56251 lY1 = lLumPtr[j + lLumWidth]; |
|
56252 |
|
56253 /*B component*/ |
|
56254 lTemp = lY1 + lTemp3; |
|
56255 if (lTemp < 0) |
|
56256 lTemp = 0; |
|
56257 if (lTemp > 255) |
|
56258 lTemp = 255; |
|
56259 lTemp4 = (uint8) lTemp; |
|
56260 |
|
56261 /*G component*/ |
|
56262 lTemp = lY1 - lTemp2; |
|
56263 if (lTemp < 0) |
|
56264 lTemp = 0; |
|
56265 if (lTemp > 255) |
|
56266 lTemp = 255; |
|
56267 lTemp4 |= lTemp << 8; |
|
56268 |
|
56269 /*R component*/ |
|
56270 lTemp = lY1 + lTemp1; |
|
56271 if (lTemp < 0) |
|
56272 lTemp = 0; |
|
56273 if (lTemp > 255) |
|
56274 lTemp = 255; |
|
56275 lTemp4 |= lTemp << 16; |
|
56276 |
|
56277 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
56278 |
|
56279 /*Fourth Pixel*/ |
|
56280 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
56281 |
|
56282 /*B component*/ |
|
56283 lTemp = lY1 + lTemp3; |
|
56284 if (lTemp < 0) |
|
56285 lTemp = 0; |
|
56286 if (lTemp > 255) |
|
56287 lTemp = 255; |
|
56288 lTemp4 = (uint8) lTemp; |
|
56289 |
|
56290 /*G component*/ |
|
56291 lTemp = lY1 - lTemp2; |
|
56292 if (lTemp < 0) |
|
56293 lTemp = 0; |
|
56294 if (lTemp > 255) |
|
56295 lTemp = 255; |
|
56296 lTemp4 |= lTemp << 8; |
|
56297 |
|
56298 /*R component*/ |
|
56299 lTemp = lY1 + lTemp1; |
|
56300 if (lTemp < 0) |
|
56301 lTemp = 0; |
|
56302 if (lTemp > 255) |
|
56303 lTemp = 255; |
|
56304 lTemp4 |= lTemp << 16; |
|
56305 |
|
56306 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
56307 |
|
56308 lRGBFramePtr += 2; |
|
56309 lRGBFramePtr1 += 2; |
|
56310 } |
|
56311 |
|
56312 if(extraCol) |
|
56313 { |
|
56314 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
56315 lRGBFramePtr++; |
|
56316 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
56317 lRGBFramePtr1++; |
|
56318 } |
|
56319 |
|
56320 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
56321 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
56322 |
|
56323 if(extraRow) |
|
56324 { |
|
56325 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
56326 for(j = 0; j < lWidth; j += 2) |
|
56327 { |
|
56328 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
56329 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
56330 } |
|
56331 if(extraCol) |
|
56332 { |
|
56333 *lRGBFramePtr = *lRGBFramePtr1; |
|
56334 } |
|
56335 } |
|
56336 return; |
|
56337 } |
|
56338 |
|
56339 /* |
|
56340 ****************************************************************************** |
|
56341 Name : sEmz_VDec_YUV420Chr3toColor16MU_601_5_FR |
|
56342 Description : Converts YUV420 Chroma3 Planar to XRGB (8:8:8:8) Interleaved format |
|
56343 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
56344 uint8 *dstImage : Pointer to rgb data (o/p). |
|
56345 tWndParam *srcWindow : Pointer to structure containing source window |
|
56346 parameters like xOffset,yOffset,cropWidth, |
|
56347 cropHeight. (i/p) |
|
56348 tWndParam *dstWindow : Pointer to structure containing destination window |
|
56349 parameters like xOffset,yOffset,windWidth, |
|
56350 windHeight. (i/p) |
|
56351 Return Value : void |
|
56352 ****************************************************************************** |
|
56353 */ |
|
56354 |
|
56355 void sEmz_VDec_YUV420Chr3toColor16MU_601_5_FR |
|
56356 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
56357 tWndParam* srcWindow, tWndParam* dstWindow) |
|
56358 { |
|
56359 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
56360 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
56361 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
56362 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
56363 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
56364 int32 i, j, extraRow, extraCol; |
|
56365 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
56366 cropWidth,cropHeight,wndWidth,wndHeight; |
|
56367 |
|
56368 srcXOffset = srcWindow->xOffset; |
|
56369 srcYOffset = srcWindow->yOffset; |
|
56370 cropWidth = srcWindow->wndWidth; |
|
56371 cropHeight = srcWindow->wndHeight; |
|
56372 |
|
56373 dstXOffset = dstWindow->xOffset; |
|
56374 dstYOffset = dstWindow->yOffset; |
|
56375 wndWidth = dstWindow->wndWidth; |
|
56376 wndHeight = dstWindow->wndHeight; |
|
56377 |
|
56378 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
56379 { |
|
56380 lWidth = cropWidth; |
|
56381 } |
|
56382 else |
|
56383 { |
|
56384 lWidth = srcImage->width - srcXOffset; |
|
56385 } |
|
56386 |
|
56387 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
56388 { |
|
56389 lHeight = cropHeight; |
|
56390 } |
|
56391 else |
|
56392 { |
|
56393 lHeight = srcImage->height - srcYOffset; |
|
56394 } |
|
56395 |
|
56396 if (lWidth > (wndWidth - dstXOffset)) |
|
56397 { |
|
56398 lWidth = wndWidth - dstXOffset; |
|
56399 } |
|
56400 |
|
56401 if (lHeight > (wndHeight - dstYOffset)) |
|
56402 { |
|
56403 lHeight = wndHeight - dstYOffset; |
|
56404 } |
|
56405 |
|
56406 extraCol = lWidth & 0x01; |
|
56407 extraRow = lHeight & 0x01; |
|
56408 |
|
56409 lTempWidth = lWidth; |
|
56410 lWidth = (lWidth >> 1) << 1; |
|
56411 lHeight = (lHeight >> 1) << 1; |
|
56412 |
|
56413 lLumWidth = (srcImage->width >> 1) << 1; |
|
56414 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
56415 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
56416 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
56417 |
|
56418 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
56419 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
56420 |
|
56421 for(i = 0; i < (lHeight - 2); i += 2) |
|
56422 { |
|
56423 for(j = 0; j < (lWidth - 2); j += 2) |
|
56424 { |
|
56425 lCr1 = lCrPtr[j >> 1]; |
|
56426 lCb1 = lCbPtr[j >> 1]; |
|
56427 |
|
56428 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
56429 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
56430 |
|
56431 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
56432 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
56433 |
|
56434 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
56435 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
56436 |
|
56437 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
56438 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
56439 |
|
56440 lCr2 = (lCr1 + lCr2) >> 1; |
|
56441 lCb2 = (lCb1 + lCb2) >> 1; |
|
56442 |
|
56443 lCr3 = (lCr1 + lCr3) >> 1; |
|
56444 lCb3 = (lCb1 + lCb3) >> 1; |
|
56445 |
|
56446 /*First Pixel*/ |
|
56447 lCr1 -= 128; |
|
56448 lCb1 -= 128; |
|
56449 |
|
56450 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
56451 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
56452 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
56453 |
|
56454 lY1 = lLumPtr[j]; |
|
56455 |
|
56456 /*B component*/ |
|
56457 lTemp = lY1 + lTemp3; |
|
56458 if (lTemp < 0) |
|
56459 lTemp = 0; |
|
56460 if (lTemp > 255) |
|
56461 lTemp = 255; |
|
56462 lTemp4 = (uint8) lTemp; |
|
56463 |
|
56464 /*G component*/ |
|
56465 lTemp = lY1 - lTemp2; |
|
56466 if (lTemp < 0) |
|
56467 lTemp = 0; |
|
56468 if (lTemp > 255) |
|
56469 lTemp = 255; |
|
56470 lTemp4 |= lTemp << 8; |
|
56471 |
|
56472 /*R component*/ |
|
56473 lTemp = lY1 + lTemp1; |
|
56474 if (lTemp < 0) |
|
56475 lTemp = 0; |
|
56476 if (lTemp > 255) |
|
56477 lTemp = 255; |
|
56478 lTemp4 |= lTemp << 16; |
|
56479 |
|
56480 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
56481 |
|
56482 /*Second Pixel*/ |
|
56483 lCr2 -= 128; |
|
56484 lCb2 -= 128; |
|
56485 |
|
56486 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
56487 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
56488 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
56489 |
|
56490 lY1 = lLumPtr[j + 1]; |
|
56491 |
|
56492 /*B component*/ |
|
56493 lTemp = lY1 + lTemp3; |
|
56494 if (lTemp < 0) |
|
56495 lTemp = 0; |
|
56496 if (lTemp > 255) |
|
56497 lTemp = 255; |
|
56498 lTemp4 = (uint8) lTemp; |
|
56499 |
|
56500 /*G component*/ |
|
56501 lTemp = lY1 - lTemp2; |
|
56502 if (lTemp < 0) |
|
56503 lTemp = 0; |
|
56504 if (lTemp > 255) |
|
56505 lTemp = 255; |
|
56506 lTemp4 |= lTemp << 8; |
|
56507 |
|
56508 /*R component*/ |
|
56509 lTemp = lY1 + lTemp1; |
|
56510 if (lTemp < 0) |
|
56511 lTemp = 0; |
|
56512 if (lTemp > 255) |
|
56513 lTemp = 255; |
|
56514 lTemp4 |= lTemp << 16; |
|
56515 |
|
56516 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
56517 |
|
56518 |
|
56519 /*Third Pixel*/ |
|
56520 lCr3 -= 128; |
|
56521 lCb3 -= 128; |
|
56522 |
|
56523 lTemp1 = (22973 * lCr3) >> COLOR_CONV_PRECISION; |
|
56524 lTemp2 = ((5637 * lCb3) + (11699 * lCr3)) >> COLOR_CONV_PRECISION; |
|
56525 lTemp3 = (29032 * lCb3) >> COLOR_CONV_PRECISION; |
|
56526 |
|
56527 lY1 = lLumPtr[j + lLumWidth]; |
|
56528 |
|
56529 /*B component*/ |
|
56530 lTemp = lY1 + lTemp3; |
|
56531 if (lTemp < 0) |
|
56532 lTemp = 0; |
|
56533 if (lTemp > 255) |
|
56534 lTemp = 255; |
|
56535 lTemp4 = (uint8) lTemp; |
|
56536 |
|
56537 /*G component*/ |
|
56538 lTemp = lY1 - lTemp2; |
|
56539 if (lTemp < 0) |
|
56540 lTemp = 0; |
|
56541 if (lTemp > 255) |
|
56542 lTemp = 255; |
|
56543 lTemp4 |= lTemp << 8; |
|
56544 |
|
56545 /*R component*/ |
|
56546 lTemp = lY1 + lTemp1; |
|
56547 if (lTemp < 0) |
|
56548 lTemp = 0; |
|
56549 if (lTemp > 255) |
|
56550 lTemp = 255; |
|
56551 lTemp4 |= lTemp << 16; |
|
56552 |
|
56553 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
56554 |
|
56555 /*Fourth Pixel*/ |
|
56556 lCr4 -= 128; |
|
56557 lCb4 -= 128; |
|
56558 |
|
56559 lTemp1 = (22973 * lCr4) >> COLOR_CONV_PRECISION; |
|
56560 lTemp2 = ((5637 * lCb4) + (11699 * lCr4)) >> COLOR_CONV_PRECISION; |
|
56561 lTemp3 = (29032 * lCb4) >> COLOR_CONV_PRECISION; |
|
56562 |
|
56563 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
56564 |
|
56565 /*B component*/ |
|
56566 lTemp = lY1 + lTemp3; |
|
56567 if (lTemp < 0) |
|
56568 lTemp = 0; |
|
56569 if (lTemp > 255) |
|
56570 lTemp = 255; |
|
56571 lTemp4 = (uint8) lTemp; |
|
56572 |
|
56573 /*G component*/ |
|
56574 lTemp = lY1 - lTemp2; |
|
56575 if (lTemp < 0) |
|
56576 lTemp = 0; |
|
56577 if (lTemp > 255) |
|
56578 lTemp = 255; |
|
56579 lTemp4 |= lTemp << 8; |
|
56580 |
|
56581 /*R component*/ |
|
56582 lTemp = lY1 + lTemp1; |
|
56583 if (lTemp < 0) |
|
56584 lTemp = 0; |
|
56585 if (lTemp > 255) |
|
56586 lTemp = 255; |
|
56587 lTemp4 |= lTemp << 16; |
|
56588 |
|
56589 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
56590 |
|
56591 lRGBFramePtr += 2; |
|
56592 lRGBFramePtr1 += 2; |
|
56593 } |
|
56594 |
|
56595 lCr1 = lCrPtr[j >> 1]; |
|
56596 lCb1 = lCbPtr[j >> 1]; |
|
56597 |
|
56598 lCr1 -= 128; |
|
56599 lCb1 -= 128; |
|
56600 |
|
56601 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
56602 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
56603 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
56604 |
|
56605 /*First Pixel*/ |
|
56606 lY1 = lLumPtr[j]; |
|
56607 |
|
56608 /*B component*/ |
|
56609 lTemp = lY1 + lTemp3; |
|
56610 if (lTemp < 0) |
|
56611 lTemp = 0; |
|
56612 if (lTemp > 255) |
|
56613 lTemp = 255; |
|
56614 lTemp4 = (uint8) lTemp; |
|
56615 |
|
56616 /*G component*/ |
|
56617 lTemp = lY1 - lTemp2; |
|
56618 if (lTemp < 0) |
|
56619 lTemp = 0; |
|
56620 if (lTemp > 255) |
|
56621 lTemp = 255; |
|
56622 lTemp4 |= lTemp << 8; |
|
56623 |
|
56624 /*R component*/ |
|
56625 lTemp = lY1 + lTemp1; |
|
56626 if (lTemp < 0) |
|
56627 lTemp = 0; |
|
56628 if (lTemp > 255) |
|
56629 lTemp = 255; |
|
56630 lTemp4 |= lTemp << 16; |
|
56631 |
|
56632 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
56633 |
|
56634 /*Second Pixel*/ |
|
56635 lY1 = lLumPtr[j + 1]; |
|
56636 |
|
56637 /*B component*/ |
|
56638 lTemp = lY1 + lTemp3; |
|
56639 if (lTemp < 0) |
|
56640 lTemp = 0; |
|
56641 if (lTemp > 255) |
|
56642 lTemp = 255; |
|
56643 lTemp4 = (uint8) lTemp; |
|
56644 |
|
56645 /*G component*/ |
|
56646 lTemp = lY1 - lTemp2; |
|
56647 if (lTemp < 0) |
|
56648 lTemp = 0; |
|
56649 if (lTemp > 255) |
|
56650 lTemp = 255; |
|
56651 lTemp4 |= lTemp << 8; |
|
56652 |
|
56653 /*R component*/ |
|
56654 lTemp = lY1 + lTemp1; |
|
56655 if (lTemp < 0) |
|
56656 lTemp = 0; |
|
56657 if (lTemp > 255) |
|
56658 lTemp = 255; |
|
56659 lTemp4 |= lTemp << 16; |
|
56660 |
|
56661 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
56662 |
|
56663 |
|
56664 /*Third Pixel*/ |
|
56665 lY1 = lLumPtr[j + lLumWidth]; |
|
56666 |
|
56667 /*B component*/ |
|
56668 lTemp = lY1 + lTemp3; |
|
56669 if (lTemp < 0) |
|
56670 lTemp = 0; |
|
56671 if (lTemp > 255) |
|
56672 lTemp = 255; |
|
56673 lTemp4 = (uint8) lTemp; |
|
56674 |
|
56675 /*G component*/ |
|
56676 lTemp = lY1 - lTemp2; |
|
56677 if (lTemp < 0) |
|
56678 lTemp = 0; |
|
56679 if (lTemp > 255) |
|
56680 lTemp = 255; |
|
56681 lTemp4 |= lTemp << 8; |
|
56682 |
|
56683 /*R component*/ |
|
56684 lTemp = lY1 + lTemp1; |
|
56685 if (lTemp < 0) |
|
56686 lTemp = 0; |
|
56687 if (lTemp > 255) |
|
56688 lTemp = 255; |
|
56689 lTemp4 |= lTemp << 16; |
|
56690 |
|
56691 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
56692 |
|
56693 /*Fourth Pixel*/ |
|
56694 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
56695 |
|
56696 /*B component*/ |
|
56697 lTemp = lY1 + lTemp3; |
|
56698 if (lTemp < 0) |
|
56699 lTemp = 0; |
|
56700 if (lTemp > 255) |
|
56701 lTemp = 255; |
|
56702 lTemp4 = (uint8) lTemp; |
|
56703 |
|
56704 /*G component*/ |
|
56705 lTemp = lY1 - lTemp2; |
|
56706 if (lTemp < 0) |
|
56707 lTemp = 0; |
|
56708 if (lTemp > 255) |
|
56709 lTemp = 255; |
|
56710 lTemp4 |= lTemp << 8; |
|
56711 |
|
56712 /*R component*/ |
|
56713 lTemp = lY1 + lTemp1; |
|
56714 if (lTemp < 0) |
|
56715 lTemp = 0; |
|
56716 if (lTemp > 255) |
|
56717 lTemp = 255; |
|
56718 lTemp4 |= lTemp << 16; |
|
56719 |
|
56720 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
56721 |
|
56722 lRGBFramePtr += 2; |
|
56723 lRGBFramePtr1 += 2; |
|
56724 |
|
56725 |
|
56726 if(extraCol) |
|
56727 { |
|
56728 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
56729 lRGBFramePtr++; |
|
56730 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
56731 lRGBFramePtr1++; |
|
56732 } |
|
56733 |
|
56734 lLumPtr += (lLumWidth << 1); |
|
56735 lCrPtr += (lLumWidth >> 1); |
|
56736 lCbPtr += (lLumWidth >> 1); |
|
56737 |
|
56738 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
56739 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
56740 } |
|
56741 |
|
56742 |
|
56743 for(j = 0; j < lWidth; j += 2) |
|
56744 { |
|
56745 lCr1 = lCrPtr[j >> 1]; |
|
56746 lCb1 = lCbPtr[j >> 1]; |
|
56747 |
|
56748 lCr1 -= 128; |
|
56749 lCb1 -= 128; |
|
56750 |
|
56751 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
56752 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
56753 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
56754 |
|
56755 /*First Pixel*/ |
|
56756 lY1 = lLumPtr[j]; |
|
56757 |
|
56758 /*B component*/ |
|
56759 lTemp = lY1 + lTemp3; |
|
56760 if (lTemp < 0) |
|
56761 lTemp = 0; |
|
56762 if (lTemp > 255) |
|
56763 lTemp = 255; |
|
56764 lTemp4 = (uint8) lTemp; |
|
56765 |
|
56766 /*G component*/ |
|
56767 lTemp = lY1 - lTemp2; |
|
56768 if (lTemp < 0) |
|
56769 lTemp = 0; |
|
56770 if (lTemp > 255) |
|
56771 lTemp = 255; |
|
56772 lTemp4 |= lTemp << 8; |
|
56773 |
|
56774 /*R component*/ |
|
56775 lTemp = lY1 + lTemp1; |
|
56776 if (lTemp < 0) |
|
56777 lTemp = 0; |
|
56778 if (lTemp > 255) |
|
56779 lTemp = 255; |
|
56780 lTemp4 |= lTemp << 16; |
|
56781 |
|
56782 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
56783 |
|
56784 /*Second Pixel*/ |
|
56785 lY1 = lLumPtr[j + 1]; |
|
56786 |
|
56787 /*B component*/ |
|
56788 lTemp = lY1 + lTemp3; |
|
56789 if (lTemp < 0) |
|
56790 lTemp = 0; |
|
56791 if (lTemp > 255) |
|
56792 lTemp = 255; |
|
56793 lTemp4 = (uint8) lTemp; |
|
56794 |
|
56795 /*G component*/ |
|
56796 lTemp = lY1 - lTemp2; |
|
56797 if (lTemp < 0) |
|
56798 lTemp = 0; |
|
56799 if (lTemp > 255) |
|
56800 lTemp = 255; |
|
56801 lTemp4 |= lTemp << 8; |
|
56802 |
|
56803 /*R component*/ |
|
56804 lTemp = lY1 + lTemp1; |
|
56805 if (lTemp < 0) |
|
56806 lTemp = 0; |
|
56807 if (lTemp > 255) |
|
56808 lTemp = 255; |
|
56809 lTemp4 |= lTemp << 16; |
|
56810 |
|
56811 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
56812 |
|
56813 |
|
56814 /*Third Pixel*/ |
|
56815 lY1 = lLumPtr[j + lLumWidth]; |
|
56816 |
|
56817 /*B component*/ |
|
56818 lTemp = lY1 + lTemp3; |
|
56819 if (lTemp < 0) |
|
56820 lTemp = 0; |
|
56821 if (lTemp > 255) |
|
56822 lTemp = 255; |
|
56823 lTemp4 = (uint8) lTemp; |
|
56824 |
|
56825 /*G component*/ |
|
56826 lTemp = lY1 - lTemp2; |
|
56827 if (lTemp < 0) |
|
56828 lTemp = 0; |
|
56829 if (lTemp > 255) |
|
56830 lTemp = 255; |
|
56831 lTemp4 |= lTemp << 8; |
|
56832 |
|
56833 /*R component*/ |
|
56834 lTemp = lY1 + lTemp1; |
|
56835 if (lTemp < 0) |
|
56836 lTemp = 0; |
|
56837 if (lTemp > 255) |
|
56838 lTemp = 255; |
|
56839 lTemp4 |= lTemp << 16; |
|
56840 |
|
56841 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
56842 |
|
56843 /*Fourth Pixel*/ |
|
56844 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
56845 |
|
56846 /*B component*/ |
|
56847 lTemp = lY1 + lTemp3; |
|
56848 if (lTemp < 0) |
|
56849 lTemp = 0; |
|
56850 if (lTemp > 255) |
|
56851 lTemp = 255; |
|
56852 lTemp4 = (uint8) lTemp; |
|
56853 |
|
56854 /*G component*/ |
|
56855 lTemp = lY1 - lTemp2; |
|
56856 if (lTemp < 0) |
|
56857 lTemp = 0; |
|
56858 if (lTemp > 255) |
|
56859 lTemp = 255; |
|
56860 lTemp4 |= lTemp << 8; |
|
56861 |
|
56862 /*R component*/ |
|
56863 lTemp = lY1 + lTemp1; |
|
56864 if (lTemp < 0) |
|
56865 lTemp = 0; |
|
56866 if (lTemp > 255) |
|
56867 lTemp = 255; |
|
56868 lTemp4 |= lTemp << 16; |
|
56869 |
|
56870 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
56871 |
|
56872 lRGBFramePtr += 2; |
|
56873 lRGBFramePtr1 += 2; |
|
56874 } |
|
56875 |
|
56876 if(extraCol) |
|
56877 { |
|
56878 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
56879 lRGBFramePtr++; |
|
56880 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
56881 lRGBFramePtr1++; |
|
56882 } |
|
56883 |
|
56884 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
56885 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
56886 |
|
56887 if(extraRow) |
|
56888 { |
|
56889 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
56890 for(j = 0; j < lWidth; j += 2) |
|
56891 { |
|
56892 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
56893 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
56894 } |
|
56895 if(extraCol) |
|
56896 { |
|
56897 *lRGBFramePtr = *lRGBFramePtr1; |
|
56898 } |
|
56899 } |
|
56900 return; |
|
56901 } |
|
56902 |
|
56903 /* |
|
56904 ****************************************************************************** |
|
56905 Name : sEmz_VDec_YUV420Chr3toColor16MU_709_RR |
|
56906 Description : Converts YUV420 Chroma3 Planar to XRGB (8:8:8:8) Interleaved format |
|
56907 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
56908 uint8 *dstImage : Pointer to rgb data (o/p). |
|
56909 tWndParam *srcWindow : Pointer to structure containing source window |
|
56910 parameters like xOffset,yOffset,cropWidth, |
|
56911 cropHeight. (i/p) |
|
56912 tWndParam *dstWindow : Pointer to structure containing destination window |
|
56913 parameters like xOffset,yOffset,windWidth, |
|
56914 windHeight. (i/p) |
|
56915 Return Value : void |
|
56916 ****************************************************************************** |
|
56917 */ |
|
56918 |
|
56919 void sEmz_VDec_YUV420Chr3toColor16MU_709_RR |
|
56920 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
56921 tWndParam* srcWindow, tWndParam* dstWindow) |
|
56922 { |
|
56923 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
56924 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
56925 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
56926 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
56927 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
56928 int32 i, j, extraRow, extraCol; |
|
56929 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
56930 cropWidth,cropHeight,wndWidth,wndHeight; |
|
56931 |
|
56932 srcXOffset = srcWindow->xOffset; |
|
56933 srcYOffset = srcWindow->yOffset; |
|
56934 cropWidth = srcWindow->wndWidth; |
|
56935 cropHeight = srcWindow->wndHeight; |
|
56936 |
|
56937 dstXOffset = dstWindow->xOffset; |
|
56938 dstYOffset = dstWindow->yOffset; |
|
56939 wndWidth = dstWindow->wndWidth; |
|
56940 wndHeight = dstWindow->wndHeight; |
|
56941 |
|
56942 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
56943 { |
|
56944 lWidth = cropWidth; |
|
56945 } |
|
56946 else |
|
56947 { |
|
56948 lWidth = srcImage->width - srcXOffset; |
|
56949 } |
|
56950 |
|
56951 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
56952 { |
|
56953 lHeight = cropHeight; |
|
56954 } |
|
56955 else |
|
56956 { |
|
56957 lHeight = srcImage->height - srcYOffset; |
|
56958 } |
|
56959 |
|
56960 if (lWidth > (wndWidth - dstXOffset)) |
|
56961 { |
|
56962 lWidth = wndWidth - dstXOffset; |
|
56963 } |
|
56964 |
|
56965 if (lHeight > (wndHeight - dstYOffset)) |
|
56966 { |
|
56967 lHeight = wndHeight - dstYOffset; |
|
56968 } |
|
56969 |
|
56970 extraCol = lWidth & 0x01; |
|
56971 extraRow = lHeight & 0x01; |
|
56972 |
|
56973 lTempWidth = lWidth; |
|
56974 lWidth = (lWidth >> 1) << 1; |
|
56975 lHeight = (lHeight >> 1) << 1; |
|
56976 |
|
56977 lLumWidth = (srcImage->width >> 1) << 1; |
|
56978 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
56979 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
56980 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
56981 |
|
56982 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
56983 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
56984 |
|
56985 for(i = 0; i < (lHeight - 2); i += 2) |
|
56986 { |
|
56987 for(j = 0; j < (lWidth - 2); j += 2) |
|
56988 { |
|
56989 lCr1 = lCrPtr[j >> 1]; |
|
56990 lCb1 = lCbPtr[j >> 1]; |
|
56991 |
|
56992 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
56993 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
56994 |
|
56995 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
56996 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
56997 |
|
56998 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
56999 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
57000 |
|
57001 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
57002 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
57003 |
|
57004 lCr2 = (lCr1 + lCr2) >> 1; |
|
57005 lCb2 = (lCb1 + lCb2) >> 1; |
|
57006 |
|
57007 lCr3 = (lCr1 + lCr3) >> 1; |
|
57008 lCb3 = (lCb1 + lCb3) >> 1; |
|
57009 |
|
57010 /*First Pixel*/ |
|
57011 lCr1 -= 128; |
|
57012 lCb1 -= 128; |
|
57013 |
|
57014 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
57015 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
57016 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
57017 |
|
57018 lY1 = lLumPtr[j]; |
|
57019 lY1 -= 16; |
|
57020 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57021 |
|
57022 /*B component*/ |
|
57023 lTemp = lY1 + lTemp3; |
|
57024 if (lTemp < 0) |
|
57025 lTemp = 0; |
|
57026 if (lTemp > 255) |
|
57027 lTemp = 255; |
|
57028 lTemp4 = (uint8) lTemp; |
|
57029 |
|
57030 /*G component*/ |
|
57031 lTemp = lY1 - lTemp2; |
|
57032 if (lTemp < 0) |
|
57033 lTemp = 0; |
|
57034 if (lTemp > 255) |
|
57035 lTemp = 255; |
|
57036 lTemp4 |= lTemp << 8; |
|
57037 |
|
57038 /*R component*/ |
|
57039 lTemp = lY1 + lTemp1; |
|
57040 if (lTemp < 0) |
|
57041 lTemp = 0; |
|
57042 if (lTemp > 255) |
|
57043 lTemp = 255; |
|
57044 lTemp4 |= lTemp << 16; |
|
57045 |
|
57046 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
57047 |
|
57048 /*Second Pixel*/ |
|
57049 lCr2 -= 128; |
|
57050 lCb2 -= 128; |
|
57051 |
|
57052 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
57053 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
57054 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
57055 |
|
57056 lY1 = lLumPtr[j + 1]; |
|
57057 lY1 -= 16; |
|
57058 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57059 |
|
57060 /*B component*/ |
|
57061 lTemp = lY1 + lTemp3; |
|
57062 if (lTemp < 0) |
|
57063 lTemp = 0; |
|
57064 if (lTemp > 255) |
|
57065 lTemp = 255; |
|
57066 lTemp4 = (uint8) lTemp; |
|
57067 |
|
57068 /*G component*/ |
|
57069 lTemp = lY1 - lTemp2; |
|
57070 if (lTemp < 0) |
|
57071 lTemp = 0; |
|
57072 if (lTemp > 255) |
|
57073 lTemp = 255; |
|
57074 lTemp4 |= lTemp << 8; |
|
57075 |
|
57076 /*R component*/ |
|
57077 lTemp = lY1 + lTemp1; |
|
57078 if (lTemp < 0) |
|
57079 lTemp = 0; |
|
57080 if (lTemp > 255) |
|
57081 lTemp = 255; |
|
57082 lTemp4 |= lTemp << 16; |
|
57083 |
|
57084 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
57085 |
|
57086 |
|
57087 /*Third Pixel*/ |
|
57088 lCr3 -= 128; |
|
57089 lCb3 -= 128; |
|
57090 |
|
57091 lTemp1 = (29374 * lCr3) >> COLOR_CONV_PRECISION; |
|
57092 lTemp2 = ((3494 * lCb3) + (8731 * lCr3)) >> COLOR_CONV_PRECISION; |
|
57093 lTemp3 = (34603 * lCb3) >> COLOR_CONV_PRECISION; |
|
57094 |
|
57095 lY1 = lLumPtr[j + lLumWidth]; |
|
57096 lY1 -= 16; |
|
57097 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57098 |
|
57099 /*B component*/ |
|
57100 lTemp = lY1 + lTemp3; |
|
57101 if (lTemp < 0) |
|
57102 lTemp = 0; |
|
57103 if (lTemp > 255) |
|
57104 lTemp = 255; |
|
57105 lTemp4 = (uint8) lTemp; |
|
57106 |
|
57107 /*G component*/ |
|
57108 lTemp = lY1 - lTemp2; |
|
57109 if (lTemp < 0) |
|
57110 lTemp = 0; |
|
57111 if (lTemp > 255) |
|
57112 lTemp = 255; |
|
57113 lTemp4 |= lTemp << 8; |
|
57114 |
|
57115 /*R component*/ |
|
57116 lTemp = lY1 + lTemp1; |
|
57117 if (lTemp < 0) |
|
57118 lTemp = 0; |
|
57119 if (lTemp > 255) |
|
57120 lTemp = 255; |
|
57121 lTemp4 |= lTemp << 16; |
|
57122 |
|
57123 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
57124 |
|
57125 /*Fourth Pixel*/ |
|
57126 lCr4 -= 128; |
|
57127 lCb4 -= 128; |
|
57128 |
|
57129 lTemp1 = (29374 * lCr4) >> COLOR_CONV_PRECISION; |
|
57130 lTemp2 = ((3494 * lCb4) + (8731 * lCr4)) >> COLOR_CONV_PRECISION; |
|
57131 lTemp3 = (34603 * lCb4) >> COLOR_CONV_PRECISION; |
|
57132 |
|
57133 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
57134 lY1 -= 16; |
|
57135 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57136 |
|
57137 /*B component*/ |
|
57138 lTemp = lY1 + lTemp3; |
|
57139 if (lTemp < 0) |
|
57140 lTemp = 0; |
|
57141 if (lTemp > 255) |
|
57142 lTemp = 255; |
|
57143 lTemp4 = (uint8) lTemp; |
|
57144 |
|
57145 /*G component*/ |
|
57146 lTemp = lY1 - lTemp2; |
|
57147 if (lTemp < 0) |
|
57148 lTemp = 0; |
|
57149 if (lTemp > 255) |
|
57150 lTemp = 255; |
|
57151 lTemp4 |= lTemp << 8; |
|
57152 |
|
57153 /*R component*/ |
|
57154 lTemp = lY1 + lTemp1; |
|
57155 if (lTemp < 0) |
|
57156 lTemp = 0; |
|
57157 if (lTemp > 255) |
|
57158 lTemp = 255; |
|
57159 lTemp4 |= lTemp << 16; |
|
57160 |
|
57161 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
57162 |
|
57163 lRGBFramePtr += 2; |
|
57164 lRGBFramePtr1 += 2; |
|
57165 } |
|
57166 |
|
57167 lCr1 = lCrPtr[j >> 1]; |
|
57168 lCb1 = lCbPtr[j >> 1]; |
|
57169 |
|
57170 lCr1 -= 128; |
|
57171 lCb1 -= 128; |
|
57172 |
|
57173 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
57174 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
57175 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
57176 |
|
57177 /*First Pixel*/ |
|
57178 lY1 = lLumPtr[j]; |
|
57179 lY1 -= 16; |
|
57180 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57181 |
|
57182 /*B component*/ |
|
57183 lTemp = lY1 + lTemp3; |
|
57184 if (lTemp < 0) |
|
57185 lTemp = 0; |
|
57186 if (lTemp > 255) |
|
57187 lTemp = 255; |
|
57188 lTemp4 = (uint8) lTemp; |
|
57189 |
|
57190 /*G component*/ |
|
57191 lTemp = lY1 - lTemp2; |
|
57192 if (lTemp < 0) |
|
57193 lTemp = 0; |
|
57194 if (lTemp > 255) |
|
57195 lTemp = 255; |
|
57196 lTemp4 |= lTemp << 8; |
|
57197 |
|
57198 /*R component*/ |
|
57199 lTemp = lY1 + lTemp1; |
|
57200 if (lTemp < 0) |
|
57201 lTemp = 0; |
|
57202 if (lTemp > 255) |
|
57203 lTemp = 255; |
|
57204 lTemp4 |= lTemp << 16; |
|
57205 |
|
57206 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
57207 |
|
57208 /*Second Pixel*/ |
|
57209 lY1 = lLumPtr[j + 1]; |
|
57210 lY1 -= 16; |
|
57211 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57212 |
|
57213 /*B component*/ |
|
57214 lTemp = lY1 + lTemp3; |
|
57215 if (lTemp < 0) |
|
57216 lTemp = 0; |
|
57217 if (lTemp > 255) |
|
57218 lTemp = 255; |
|
57219 lTemp4 = (uint8) lTemp; |
|
57220 |
|
57221 /*G component*/ |
|
57222 lTemp = lY1 - lTemp2; |
|
57223 if (lTemp < 0) |
|
57224 lTemp = 0; |
|
57225 if (lTemp > 255) |
|
57226 lTemp = 255; |
|
57227 lTemp4 |= lTemp << 8; |
|
57228 |
|
57229 /*R component*/ |
|
57230 lTemp = lY1 + lTemp1; |
|
57231 if (lTemp < 0) |
|
57232 lTemp = 0; |
|
57233 if (lTemp > 255) |
|
57234 lTemp = 255; |
|
57235 lTemp4 |= lTemp << 16; |
|
57236 |
|
57237 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
57238 |
|
57239 |
|
57240 /*Third Pixel*/ |
|
57241 lY1 = lLumPtr[j + lLumWidth]; |
|
57242 lY1 -= 16; |
|
57243 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57244 |
|
57245 /*B component*/ |
|
57246 lTemp = lY1 + lTemp3; |
|
57247 if (lTemp < 0) |
|
57248 lTemp = 0; |
|
57249 if (lTemp > 255) |
|
57250 lTemp = 255; |
|
57251 lTemp4 = (uint8) lTemp; |
|
57252 |
|
57253 /*G component*/ |
|
57254 lTemp = lY1 - lTemp2; |
|
57255 if (lTemp < 0) |
|
57256 lTemp = 0; |
|
57257 if (lTemp > 255) |
|
57258 lTemp = 255; |
|
57259 lTemp4 |= lTemp << 8; |
|
57260 |
|
57261 /*R component*/ |
|
57262 lTemp = lY1 + lTemp1; |
|
57263 if (lTemp < 0) |
|
57264 lTemp = 0; |
|
57265 if (lTemp > 255) |
|
57266 lTemp = 255; |
|
57267 lTemp4 |= lTemp << 16; |
|
57268 |
|
57269 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
57270 |
|
57271 /*Fourth Pixel*/ |
|
57272 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
57273 lY1 -= 16; |
|
57274 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57275 |
|
57276 /*B component*/ |
|
57277 lTemp = lY1 + lTemp3; |
|
57278 if (lTemp < 0) |
|
57279 lTemp = 0; |
|
57280 if (lTemp > 255) |
|
57281 lTemp = 255; |
|
57282 lTemp4 = (uint8) lTemp; |
|
57283 |
|
57284 /*G component*/ |
|
57285 lTemp = lY1 - lTemp2; |
|
57286 if (lTemp < 0) |
|
57287 lTemp = 0; |
|
57288 if (lTemp > 255) |
|
57289 lTemp = 255; |
|
57290 lTemp4 |= lTemp << 8; |
|
57291 |
|
57292 /*R component*/ |
|
57293 lTemp = lY1 + lTemp1; |
|
57294 if (lTemp < 0) |
|
57295 lTemp = 0; |
|
57296 if (lTemp > 255) |
|
57297 lTemp = 255; |
|
57298 lTemp4 |= lTemp << 16; |
|
57299 |
|
57300 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
57301 |
|
57302 lRGBFramePtr += 2; |
|
57303 lRGBFramePtr1 += 2; |
|
57304 |
|
57305 |
|
57306 if(extraCol) |
|
57307 { |
|
57308 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
57309 lRGBFramePtr++; |
|
57310 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
57311 lRGBFramePtr1++; |
|
57312 } |
|
57313 |
|
57314 lLumPtr += (lLumWidth << 1); |
|
57315 lCrPtr += (lLumWidth >> 1); |
|
57316 lCbPtr += (lLumWidth >> 1); |
|
57317 |
|
57318 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
57319 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
57320 } |
|
57321 |
|
57322 |
|
57323 for(j = 0; j < lWidth; j += 2) |
|
57324 { |
|
57325 lCr1 = lCrPtr[j >> 1]; |
|
57326 lCb1 = lCbPtr[j >> 1]; |
|
57327 |
|
57328 lCr1 -= 128; |
|
57329 lCb1 -= 128; |
|
57330 |
|
57331 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
57332 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
57333 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
57334 |
|
57335 /*First Pixel*/ |
|
57336 lY1 = lLumPtr[j]; |
|
57337 lY1 -= 16; |
|
57338 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57339 |
|
57340 /*B component*/ |
|
57341 lTemp = lY1 + lTemp3; |
|
57342 if (lTemp < 0) |
|
57343 lTemp = 0; |
|
57344 if (lTemp > 255) |
|
57345 lTemp = 255; |
|
57346 lTemp4 = (uint8) lTemp; |
|
57347 |
|
57348 /*G component*/ |
|
57349 lTemp = lY1 - lTemp2; |
|
57350 if (lTemp < 0) |
|
57351 lTemp = 0; |
|
57352 if (lTemp > 255) |
|
57353 lTemp = 255; |
|
57354 lTemp4 |= lTemp << 8; |
|
57355 |
|
57356 /*R component*/ |
|
57357 lTemp = lY1 + lTemp1; |
|
57358 if (lTemp < 0) |
|
57359 lTemp = 0; |
|
57360 if (lTemp > 255) |
|
57361 lTemp = 255; |
|
57362 lTemp4 |= lTemp << 16; |
|
57363 |
|
57364 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
57365 |
|
57366 /*Second Pixel*/ |
|
57367 lY1 = lLumPtr[j + 1]; |
|
57368 lY1 -= 16; |
|
57369 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57370 |
|
57371 /*B component*/ |
|
57372 lTemp = lY1 + lTemp3; |
|
57373 if (lTemp < 0) |
|
57374 lTemp = 0; |
|
57375 if (lTemp > 255) |
|
57376 lTemp = 255; |
|
57377 lTemp4 = (uint8) lTemp; |
|
57378 |
|
57379 /*G component*/ |
|
57380 lTemp = lY1 - lTemp2; |
|
57381 if (lTemp < 0) |
|
57382 lTemp = 0; |
|
57383 if (lTemp > 255) |
|
57384 lTemp = 255; |
|
57385 lTemp4 |= lTemp << 8; |
|
57386 |
|
57387 /*R component*/ |
|
57388 lTemp = lY1 + lTemp1; |
|
57389 if (lTemp < 0) |
|
57390 lTemp = 0; |
|
57391 if (lTemp > 255) |
|
57392 lTemp = 255; |
|
57393 lTemp4 |= lTemp << 16; |
|
57394 |
|
57395 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
57396 |
|
57397 |
|
57398 /*Third Pixel*/ |
|
57399 lY1 = lLumPtr[j + lLumWidth]; |
|
57400 lY1 -= 16; |
|
57401 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57402 |
|
57403 /*B component*/ |
|
57404 lTemp = lY1 + lTemp3; |
|
57405 if (lTemp < 0) |
|
57406 lTemp = 0; |
|
57407 if (lTemp > 255) |
|
57408 lTemp = 255; |
|
57409 lTemp4 = (uint8) lTemp; |
|
57410 |
|
57411 /*G component*/ |
|
57412 lTemp = lY1 - lTemp2; |
|
57413 if (lTemp < 0) |
|
57414 lTemp = 0; |
|
57415 if (lTemp > 255) |
|
57416 lTemp = 255; |
|
57417 lTemp4 |= lTemp << 8; |
|
57418 |
|
57419 /*R component*/ |
|
57420 lTemp = lY1 + lTemp1; |
|
57421 if (lTemp < 0) |
|
57422 lTemp = 0; |
|
57423 if (lTemp > 255) |
|
57424 lTemp = 255; |
|
57425 lTemp4 |= lTemp << 16; |
|
57426 |
|
57427 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
57428 |
|
57429 /*Fourth Pixel*/ |
|
57430 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
57431 lY1 -= 16; |
|
57432 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57433 |
|
57434 /*B component*/ |
|
57435 lTemp = lY1 + lTemp3; |
|
57436 if (lTemp < 0) |
|
57437 lTemp = 0; |
|
57438 if (lTemp > 255) |
|
57439 lTemp = 255; |
|
57440 lTemp4 = (uint8) lTemp; |
|
57441 |
|
57442 /*G component*/ |
|
57443 lTemp = lY1 - lTemp2; |
|
57444 if (lTemp < 0) |
|
57445 lTemp = 0; |
|
57446 if (lTemp > 255) |
|
57447 lTemp = 255; |
|
57448 lTemp4 |= lTemp << 8; |
|
57449 |
|
57450 /*R component*/ |
|
57451 lTemp = lY1 + lTemp1; |
|
57452 if (lTemp < 0) |
|
57453 lTemp = 0; |
|
57454 if (lTemp > 255) |
|
57455 lTemp = 255; |
|
57456 lTemp4 |= lTemp << 16; |
|
57457 |
|
57458 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
57459 |
|
57460 lRGBFramePtr += 2; |
|
57461 lRGBFramePtr1 += 2; |
|
57462 } |
|
57463 |
|
57464 if(extraCol) |
|
57465 { |
|
57466 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
57467 lRGBFramePtr++; |
|
57468 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
57469 lRGBFramePtr1++; |
|
57470 } |
|
57471 |
|
57472 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
57473 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
57474 |
|
57475 if(extraRow) |
|
57476 { |
|
57477 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
57478 for(j = 0; j < lWidth; j += 2) |
|
57479 { |
|
57480 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
57481 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
57482 } |
|
57483 if(extraCol) |
|
57484 { |
|
57485 *lRGBFramePtr = *lRGBFramePtr1; |
|
57486 } |
|
57487 } |
|
57488 return; |
|
57489 } |
|
57490 |
|
57491 /* |
|
57492 ****************************************************************************** |
|
57493 Name : sEmz_VDec_YUV420Chr3toColor16MU_601_5_RR |
|
57494 Description : Converts YUV420 Chroma3 Planar to XRGB (8:8:8:8) Interleaved format |
|
57495 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
57496 uint8 *dstImage : Pointer to rgb data (o/p). |
|
57497 tWndParam *srcWindow : Pointer to structure containing source window |
|
57498 parameters like xOffset,yOffset,cropWidth, |
|
57499 cropHeight. (i/p) |
|
57500 tWndParam *dstWindow : Pointer to structure containing destination window |
|
57501 parameters like xOffset,yOffset,windWidth, |
|
57502 windHeight. (i/p) |
|
57503 Return Value : void |
|
57504 ****************************************************************************** |
|
57505 */ |
|
57506 |
|
57507 void sEmz_VDec_YUV420Chr3toColor16MU_601_5_RR |
|
57508 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
57509 tWndParam* srcWindow, tWndParam* dstWindow) |
|
57510 { |
|
57511 uint32 *lRGBFramePtr, *lRGBFramePtr1; |
|
57512 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
57513 int32 lLumWidth, lWidth, lHeight, lTempWidth; |
|
57514 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
57515 int32 lTemp, lTemp1, lTemp2, lTemp3, lTemp4; |
|
57516 int32 i, j, extraRow, extraCol; |
|
57517 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
57518 cropWidth,cropHeight,wndWidth,wndHeight; |
|
57519 |
|
57520 srcXOffset = srcWindow->xOffset; |
|
57521 srcYOffset = srcWindow->yOffset; |
|
57522 cropWidth = srcWindow->wndWidth; |
|
57523 cropHeight = srcWindow->wndHeight; |
|
57524 |
|
57525 dstXOffset = dstWindow->xOffset; |
|
57526 dstYOffset = dstWindow->yOffset; |
|
57527 wndWidth = dstWindow->wndWidth; |
|
57528 wndHeight = dstWindow->wndHeight; |
|
57529 |
|
57530 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
57531 { |
|
57532 lWidth = cropWidth; |
|
57533 } |
|
57534 else |
|
57535 { |
|
57536 lWidth = srcImage->width - srcXOffset; |
|
57537 } |
|
57538 |
|
57539 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
57540 { |
|
57541 lHeight = cropHeight; |
|
57542 } |
|
57543 else |
|
57544 { |
|
57545 lHeight = srcImage->height - srcYOffset; |
|
57546 } |
|
57547 |
|
57548 if (lWidth > (wndWidth - dstXOffset)) |
|
57549 { |
|
57550 lWidth = wndWidth - dstXOffset; |
|
57551 } |
|
57552 |
|
57553 if (lHeight > (wndHeight - dstYOffset)) |
|
57554 { |
|
57555 lHeight = wndHeight - dstYOffset; |
|
57556 } |
|
57557 |
|
57558 extraCol = lWidth & 0x01; |
|
57559 extraRow = lHeight & 0x01; |
|
57560 |
|
57561 lTempWidth = lWidth; |
|
57562 lWidth = (lWidth >> 1) << 1; |
|
57563 lHeight = (lHeight >> 1) << 1; |
|
57564 |
|
57565 lLumWidth = (srcImage->width >> 1) << 1; |
|
57566 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
57567 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
57568 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
57569 |
|
57570 lRGBFramePtr = (uint32*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
57571 lRGBFramePtr1 = lRGBFramePtr + wndWidth; |
|
57572 |
|
57573 for(i = 0; i < (lHeight - 2); i += 2) |
|
57574 { |
|
57575 for(j = 0; j < (lWidth - 2); j += 2) |
|
57576 { |
|
57577 lCr1 = lCrPtr[j >> 1]; |
|
57578 lCb1 = lCbPtr[j >> 1]; |
|
57579 |
|
57580 lCr2 = lCrPtr[(j >> 1) + 1]; |
|
57581 lCb2 = lCbPtr[(j >> 1) + 1]; |
|
57582 |
|
57583 lCr3 = lCrPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
57584 lCb3 = lCbPtr[(j >> 1) + (lLumWidth >> 1)]; |
|
57585 |
|
57586 lCr4 = lCrPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
57587 lCb4 = lCbPtr[(j >> 1) + (lLumWidth >> 1) + 1]; |
|
57588 |
|
57589 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
57590 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
57591 |
|
57592 lCr2 = (lCr1 + lCr2) >> 1; |
|
57593 lCb2 = (lCb1 + lCb2) >> 1; |
|
57594 |
|
57595 lCr3 = (lCr1 + lCr3) >> 1; |
|
57596 lCb3 = (lCb1 + lCb3) >> 1; |
|
57597 |
|
57598 /*First Pixel*/ |
|
57599 lCr1 -= 128; |
|
57600 lCb1 -= 128; |
|
57601 |
|
57602 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
57603 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
57604 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
57605 |
|
57606 lY1 = lLumPtr[j]; |
|
57607 lY1 -= 16; |
|
57608 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57609 |
|
57610 /*B component*/ |
|
57611 lTemp = lY1 + lTemp3; |
|
57612 if (lTemp < 0) |
|
57613 lTemp = 0; |
|
57614 if (lTemp > 255) |
|
57615 lTemp = 255; |
|
57616 lTemp4 = (uint8) lTemp; |
|
57617 |
|
57618 /*G component*/ |
|
57619 lTemp = lY1 - lTemp2; |
|
57620 if (lTemp < 0) |
|
57621 lTemp = 0; |
|
57622 if (lTemp > 255) |
|
57623 lTemp = 255; |
|
57624 lTemp4 |= lTemp << 8; |
|
57625 |
|
57626 /*R component*/ |
|
57627 lTemp = lY1 + lTemp1; |
|
57628 if (lTemp < 0) |
|
57629 lTemp = 0; |
|
57630 if (lTemp > 255) |
|
57631 lTemp = 255; |
|
57632 lTemp4 |= lTemp << 16; |
|
57633 |
|
57634 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
57635 |
|
57636 /*Second Pixel*/ |
|
57637 lCr2 -= 128; |
|
57638 lCb2 -= 128; |
|
57639 |
|
57640 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
57641 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
57642 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
57643 |
|
57644 lY1 = lLumPtr[j + 1]; |
|
57645 lY1 -= 16; |
|
57646 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57647 |
|
57648 /*B component*/ |
|
57649 lTemp = lY1 + lTemp3; |
|
57650 if (lTemp < 0) |
|
57651 lTemp = 0; |
|
57652 if (lTemp > 255) |
|
57653 lTemp = 255; |
|
57654 lTemp4 = (uint8) lTemp; |
|
57655 |
|
57656 /*G component*/ |
|
57657 lTemp = lY1 - lTemp2; |
|
57658 if (lTemp < 0) |
|
57659 lTemp = 0; |
|
57660 if (lTemp > 255) |
|
57661 lTemp = 255; |
|
57662 lTemp4 |= lTemp << 8; |
|
57663 |
|
57664 /*R component*/ |
|
57665 lTemp = lY1 + lTemp1; |
|
57666 if (lTemp < 0) |
|
57667 lTemp = 0; |
|
57668 if (lTemp > 255) |
|
57669 lTemp = 255; |
|
57670 lTemp4 |= lTemp << 16; |
|
57671 |
|
57672 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
57673 |
|
57674 |
|
57675 /*Third Pixel*/ |
|
57676 lCr3 -= 128; |
|
57677 lCb3 -= 128; |
|
57678 |
|
57679 lTemp1 = (26748 * lCr3) >> COLOR_CONV_PRECISION; |
|
57680 lTemp2 = ((6563 * lCb3) + (13621 * lCr3)) >> COLOR_CONV_PRECISION; |
|
57681 lTemp3 = (33802 * lCb3) >> COLOR_CONV_PRECISION; |
|
57682 |
|
57683 lY1 = lLumPtr[j + lLumWidth]; |
|
57684 lY1 -= 16; |
|
57685 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57686 |
|
57687 /*B component*/ |
|
57688 lTemp = lY1 + lTemp3; |
|
57689 if (lTemp < 0) |
|
57690 lTemp = 0; |
|
57691 if (lTemp > 255) |
|
57692 lTemp = 255; |
|
57693 lTemp4 = (uint8) lTemp; |
|
57694 |
|
57695 /*G component*/ |
|
57696 lTemp = lY1 - lTemp2; |
|
57697 if (lTemp < 0) |
|
57698 lTemp = 0; |
|
57699 if (lTemp > 255) |
|
57700 lTemp = 255; |
|
57701 lTemp4 |= lTemp << 8; |
|
57702 |
|
57703 /*R component*/ |
|
57704 lTemp = lY1 + lTemp1; |
|
57705 if (lTemp < 0) |
|
57706 lTemp = 0; |
|
57707 if (lTemp > 255) |
|
57708 lTemp = 255; |
|
57709 lTemp4 |= lTemp << 16; |
|
57710 |
|
57711 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
57712 |
|
57713 /*Fourth Pixel*/ |
|
57714 lCr4 -= 128; |
|
57715 lCb4 -= 128; |
|
57716 |
|
57717 lTemp1 = (26748 * lCr4) >> COLOR_CONV_PRECISION; |
|
57718 lTemp2 = ((6563 * lCb4) + (13621 * lCr4)) >> COLOR_CONV_PRECISION; |
|
57719 lTemp3 = (33802 * lCb4) >> COLOR_CONV_PRECISION; |
|
57720 |
|
57721 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
57722 lY1 -= 16; |
|
57723 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57724 |
|
57725 /*B component*/ |
|
57726 lTemp = lY1 + lTemp3; |
|
57727 if (lTemp < 0) |
|
57728 lTemp = 0; |
|
57729 if (lTemp > 255) |
|
57730 lTemp = 255; |
|
57731 lTemp4 = (uint8) lTemp; |
|
57732 |
|
57733 /*G component*/ |
|
57734 lTemp = lY1 - lTemp2; |
|
57735 if (lTemp < 0) |
|
57736 lTemp = 0; |
|
57737 if (lTemp > 255) |
|
57738 lTemp = 255; |
|
57739 lTemp4 |= lTemp << 8; |
|
57740 |
|
57741 /*R component*/ |
|
57742 lTemp = lY1 + lTemp1; |
|
57743 if (lTemp < 0) |
|
57744 lTemp = 0; |
|
57745 if (lTemp > 255) |
|
57746 lTemp = 255; |
|
57747 lTemp4 |= lTemp << 16; |
|
57748 |
|
57749 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
57750 |
|
57751 lRGBFramePtr += 2; |
|
57752 lRGBFramePtr1 += 2; |
|
57753 } |
|
57754 |
|
57755 lCr1 = lCrPtr[j >> 1]; |
|
57756 lCb1 = lCbPtr[j >> 1]; |
|
57757 |
|
57758 lCr1 -= 128; |
|
57759 lCb1 -= 128; |
|
57760 |
|
57761 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
57762 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
57763 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
57764 |
|
57765 /*First Pixel*/ |
|
57766 lY1 = lLumPtr[j]; |
|
57767 lY1 -= 16; |
|
57768 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57769 |
|
57770 /*B component*/ |
|
57771 lTemp = lY1 + lTemp3; |
|
57772 if (lTemp < 0) |
|
57773 lTemp = 0; |
|
57774 if (lTemp > 255) |
|
57775 lTemp = 255; |
|
57776 lTemp4 = (uint8) lTemp; |
|
57777 |
|
57778 /*G component*/ |
|
57779 lTemp = lY1 - lTemp2; |
|
57780 if (lTemp < 0) |
|
57781 lTemp = 0; |
|
57782 if (lTemp > 255) |
|
57783 lTemp = 255; |
|
57784 lTemp4 |= lTemp << 8; |
|
57785 |
|
57786 /*R component*/ |
|
57787 lTemp = lY1 + lTemp1; |
|
57788 if (lTemp < 0) |
|
57789 lTemp = 0; |
|
57790 if (lTemp > 255) |
|
57791 lTemp = 255; |
|
57792 lTemp4 |= lTemp << 16; |
|
57793 |
|
57794 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
57795 |
|
57796 /*Second Pixel*/ |
|
57797 lY1 = lLumPtr[j + 1]; |
|
57798 lY1 -= 16; |
|
57799 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57800 |
|
57801 /*B component*/ |
|
57802 lTemp = lY1 + lTemp3; |
|
57803 if (lTemp < 0) |
|
57804 lTemp = 0; |
|
57805 if (lTemp > 255) |
|
57806 lTemp = 255; |
|
57807 lTemp4 = (uint8) lTemp; |
|
57808 |
|
57809 /*G component*/ |
|
57810 lTemp = lY1 - lTemp2; |
|
57811 if (lTemp < 0) |
|
57812 lTemp = 0; |
|
57813 if (lTemp > 255) |
|
57814 lTemp = 255; |
|
57815 lTemp4 |= lTemp << 8; |
|
57816 |
|
57817 /*R component*/ |
|
57818 lTemp = lY1 + lTemp1; |
|
57819 if (lTemp < 0) |
|
57820 lTemp = 0; |
|
57821 if (lTemp > 255) |
|
57822 lTemp = 255; |
|
57823 lTemp4 |= lTemp << 16; |
|
57824 |
|
57825 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
57826 |
|
57827 |
|
57828 /*Third Pixel*/ |
|
57829 lY1 = lLumPtr[j + lLumWidth]; |
|
57830 lY1 -= 16; |
|
57831 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57832 |
|
57833 /*B component*/ |
|
57834 lTemp = lY1 + lTemp3; |
|
57835 if (lTemp < 0) |
|
57836 lTemp = 0; |
|
57837 if (lTemp > 255) |
|
57838 lTemp = 255; |
|
57839 lTemp4 = (uint8) lTemp; |
|
57840 |
|
57841 /*G component*/ |
|
57842 lTemp = lY1 - lTemp2; |
|
57843 if (lTemp < 0) |
|
57844 lTemp = 0; |
|
57845 if (lTemp > 255) |
|
57846 lTemp = 255; |
|
57847 lTemp4 |= lTemp << 8; |
|
57848 |
|
57849 /*R component*/ |
|
57850 lTemp = lY1 + lTemp1; |
|
57851 if (lTemp < 0) |
|
57852 lTemp = 0; |
|
57853 if (lTemp > 255) |
|
57854 lTemp = 255; |
|
57855 lTemp4 |= lTemp << 16; |
|
57856 |
|
57857 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
57858 |
|
57859 /*Fourth Pixel*/ |
|
57860 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
57861 lY1 -= 16; |
|
57862 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57863 |
|
57864 /*B component*/ |
|
57865 lTemp = lY1 + lTemp3; |
|
57866 if (lTemp < 0) |
|
57867 lTemp = 0; |
|
57868 if (lTemp > 255) |
|
57869 lTemp = 255; |
|
57870 lTemp4 = (uint8) lTemp; |
|
57871 |
|
57872 /*G component*/ |
|
57873 lTemp = lY1 - lTemp2; |
|
57874 if (lTemp < 0) |
|
57875 lTemp = 0; |
|
57876 if (lTemp > 255) |
|
57877 lTemp = 255; |
|
57878 lTemp4 |= lTemp << 8; |
|
57879 |
|
57880 /*R component*/ |
|
57881 lTemp = lY1 + lTemp1; |
|
57882 if (lTemp < 0) |
|
57883 lTemp = 0; |
|
57884 if (lTemp > 255) |
|
57885 lTemp = 255; |
|
57886 lTemp4 |= lTemp << 16; |
|
57887 |
|
57888 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
57889 |
|
57890 lRGBFramePtr += 2; |
|
57891 lRGBFramePtr1 += 2; |
|
57892 |
|
57893 |
|
57894 if(extraCol) |
|
57895 { |
|
57896 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
57897 lRGBFramePtr++; |
|
57898 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
57899 lRGBFramePtr1++; |
|
57900 } |
|
57901 |
|
57902 lLumPtr += (lLumWidth << 1); |
|
57903 lCrPtr += (lLumWidth >> 1); |
|
57904 lCbPtr += (lLumWidth >> 1); |
|
57905 |
|
57906 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
57907 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
57908 } |
|
57909 |
|
57910 |
|
57911 for(j = 0; j < lWidth; j += 2) |
|
57912 { |
|
57913 lCr1 = lCrPtr[j >> 1]; |
|
57914 lCb1 = lCbPtr[j >> 1]; |
|
57915 |
|
57916 lCr1 -= 128; |
|
57917 lCb1 -= 128; |
|
57918 |
|
57919 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
57920 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
57921 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
57922 |
|
57923 /*First Pixel*/ |
|
57924 lY1 = lLumPtr[j]; |
|
57925 lY1 -= 16; |
|
57926 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57927 |
|
57928 /*B component*/ |
|
57929 lTemp = lY1 + lTemp3; |
|
57930 if (lTemp < 0) |
|
57931 lTemp = 0; |
|
57932 if (lTemp > 255) |
|
57933 lTemp = 255; |
|
57934 lTemp4 = (uint8) lTemp; |
|
57935 |
|
57936 /*G component*/ |
|
57937 lTemp = lY1 - lTemp2; |
|
57938 if (lTemp < 0) |
|
57939 lTemp = 0; |
|
57940 if (lTemp > 255) |
|
57941 lTemp = 255; |
|
57942 lTemp4 |= lTemp << 8; |
|
57943 |
|
57944 /*R component*/ |
|
57945 lTemp = lY1 + lTemp1; |
|
57946 if (lTemp < 0) |
|
57947 lTemp = 0; |
|
57948 if (lTemp > 255) |
|
57949 lTemp = 255; |
|
57950 lTemp4 |= lTemp << 16; |
|
57951 |
|
57952 lRGBFramePtr[0] = (uint32)(lTemp4); |
|
57953 |
|
57954 /*Second Pixel*/ |
|
57955 lY1 = lLumPtr[j + 1]; |
|
57956 lY1 -= 16; |
|
57957 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57958 |
|
57959 /*B component*/ |
|
57960 lTemp = lY1 + lTemp3; |
|
57961 if (lTemp < 0) |
|
57962 lTemp = 0; |
|
57963 if (lTemp > 255) |
|
57964 lTemp = 255; |
|
57965 lTemp4 = (uint8) lTemp; |
|
57966 |
|
57967 /*G component*/ |
|
57968 lTemp = lY1 - lTemp2; |
|
57969 if (lTemp < 0) |
|
57970 lTemp = 0; |
|
57971 if (lTemp > 255) |
|
57972 lTemp = 255; |
|
57973 lTemp4 |= lTemp << 8; |
|
57974 |
|
57975 /*R component*/ |
|
57976 lTemp = lY1 + lTemp1; |
|
57977 if (lTemp < 0) |
|
57978 lTemp = 0; |
|
57979 if (lTemp > 255) |
|
57980 lTemp = 255; |
|
57981 lTemp4 |= lTemp << 16; |
|
57982 |
|
57983 lRGBFramePtr[1] = (uint32)(lTemp4); |
|
57984 |
|
57985 |
|
57986 /*Third Pixel*/ |
|
57987 lY1 = lLumPtr[j + lLumWidth]; |
|
57988 lY1 -= 16; |
|
57989 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
57990 |
|
57991 /*B component*/ |
|
57992 lTemp = lY1 + lTemp3; |
|
57993 if (lTemp < 0) |
|
57994 lTemp = 0; |
|
57995 if (lTemp > 255) |
|
57996 lTemp = 255; |
|
57997 lTemp4 = (uint8) lTemp; |
|
57998 |
|
57999 /*G component*/ |
|
58000 lTemp = lY1 - lTemp2; |
|
58001 if (lTemp < 0) |
|
58002 lTemp = 0; |
|
58003 if (lTemp > 255) |
|
58004 lTemp = 255; |
|
58005 lTemp4 |= lTemp << 8; |
|
58006 |
|
58007 /*R component*/ |
|
58008 lTemp = lY1 + lTemp1; |
|
58009 if (lTemp < 0) |
|
58010 lTemp = 0; |
|
58011 if (lTemp > 255) |
|
58012 lTemp = 255; |
|
58013 lTemp4 |= lTemp << 16; |
|
58014 |
|
58015 lRGBFramePtr1[0] = (uint32)(lTemp4); |
|
58016 |
|
58017 /*Fourth Pixel*/ |
|
58018 lY1 = lLumPtr[j + lLumWidth + 1]; |
|
58019 lY1 -= 16; |
|
58020 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
58021 |
|
58022 /*B component*/ |
|
58023 lTemp = lY1 + lTemp3; |
|
58024 if (lTemp < 0) |
|
58025 lTemp = 0; |
|
58026 if (lTemp > 255) |
|
58027 lTemp = 255; |
|
58028 lTemp4 = (uint8) lTemp; |
|
58029 |
|
58030 /*G component*/ |
|
58031 lTemp = lY1 - lTemp2; |
|
58032 if (lTemp < 0) |
|
58033 lTemp = 0; |
|
58034 if (lTemp > 255) |
|
58035 lTemp = 255; |
|
58036 lTemp4 |= lTemp << 8; |
|
58037 |
|
58038 /*R component*/ |
|
58039 lTemp = lY1 + lTemp1; |
|
58040 if (lTemp < 0) |
|
58041 lTemp = 0; |
|
58042 if (lTemp > 255) |
|
58043 lTemp = 255; |
|
58044 lTemp4 |= lTemp << 16; |
|
58045 |
|
58046 lRGBFramePtr1[1] = (uint32)(lTemp4); |
|
58047 |
|
58048 lRGBFramePtr += 2; |
|
58049 lRGBFramePtr1 += 2; |
|
58050 } |
|
58051 |
|
58052 if(extraCol) |
|
58053 { |
|
58054 *lRGBFramePtr = lRGBFramePtr[-1]; |
|
58055 lRGBFramePtr++; |
|
58056 *lRGBFramePtr1 = lRGBFramePtr1[-1]; |
|
58057 lRGBFramePtr1++; |
|
58058 } |
|
58059 |
|
58060 lRGBFramePtr += ((wndWidth << 1) - lTempWidth); |
|
58061 lRGBFramePtr1 += ((wndWidth << 1) - lTempWidth); |
|
58062 |
|
58063 if(extraRow) |
|
58064 { |
|
58065 lRGBFramePtr1 = lRGBFramePtr - wndWidth; |
|
58066 for(j = 0; j < lWidth; j += 2) |
|
58067 { |
|
58068 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
58069 *lRGBFramePtr++ = *lRGBFramePtr1++; |
|
58070 } |
|
58071 if(extraCol) |
|
58072 { |
|
58073 *lRGBFramePtr = *lRGBFramePtr1; |
|
58074 } |
|
58075 } |
|
58076 return; |
|
58077 } |
|
58078 |
|
58079 /* |
|
58080 ****************************************************************************** |
|
58081 Name : sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_709_FR |
|
58082 Description : Converts YUV420 Chroma3 Planar to RGB565 Interleaved format |
|
58083 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
58084 uint8 *dstImage : Pointer to rgb data (o/p). |
|
58085 tWndParam *srcWindow : Pointer to structure containing source window |
|
58086 parameters like xOffset,yOffset,cropWidth, |
|
58087 cropHeight. (i/p) |
|
58088 tWndParam *dstWindow : Pointer to structure containing destination window |
|
58089 parameters like xOffset,yOffset,windWidth, |
|
58090 windHeight. (i/p) |
|
58091 Return Value : void |
|
58092 ****************************************************************************** |
|
58093 */ |
|
58094 |
|
58095 void sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_709_FR |
|
58096 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
58097 tWndParam* srcWindow, tWndParam* dstWindow) |
|
58098 { |
|
58099 uint16 *dest1, *dest2; |
|
58100 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
58101 uint8 *lBuffer; |
|
58102 uint8 *src1, *src2; |
|
58103 uint8 *lPtr1, *lPtr2; |
|
58104 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
58105 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
58106 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
58107 int32 diff1, diff2, diff3; |
|
58108 int32 i, j, k, extraRow, extraCol; |
|
58109 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
58110 cropWidth,cropHeight,wndWidth,wndHeight; |
|
58111 |
|
58112 srcXOffset = srcWindow->xOffset; |
|
58113 srcYOffset = srcWindow->yOffset; |
|
58114 cropWidth = srcWindow->wndWidth; |
|
58115 cropHeight = srcWindow->wndHeight; |
|
58116 |
|
58117 dstXOffset = dstWindow->xOffset; |
|
58118 dstYOffset = dstWindow->yOffset; |
|
58119 wndWidth = dstWindow->wndWidth; |
|
58120 wndHeight = dstWindow->wndHeight; |
|
58121 |
|
58122 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
58123 { |
|
58124 lWidth = cropWidth; |
|
58125 } |
|
58126 else |
|
58127 { |
|
58128 lWidth = srcImage->width - srcXOffset; |
|
58129 } |
|
58130 |
|
58131 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
58132 { |
|
58133 lHeight = cropHeight; |
|
58134 } |
|
58135 else |
|
58136 { |
|
58137 lHeight = srcImage->height - srcYOffset; |
|
58138 } |
|
58139 |
|
58140 if (lWidth > (wndWidth - dstXOffset)) |
|
58141 { |
|
58142 lWidth = wndWidth - dstXOffset; |
|
58143 } |
|
58144 |
|
58145 if (lHeight > (wndHeight - dstYOffset)) |
|
58146 { |
|
58147 lHeight = wndHeight - dstYOffset; |
|
58148 } |
|
58149 |
|
58150 extraCol = lWidth & 0x01; |
|
58151 extraRow = lHeight & 0x01; |
|
58152 |
|
58153 lTempWidth = lWidth; |
|
58154 lWidth = (lWidth >> 1) << 1; |
|
58155 lHeight = (lHeight >> 1) << 1; |
|
58156 |
|
58157 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
58158 |
|
58159 lSrcWidth = lWidth * 3; |
|
58160 |
|
58161 lLumWidth = (srcImage->width >> 1) << 1; |
|
58162 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
58163 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
58164 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
58165 |
|
58166 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
58167 dest2 = dest1 + wndWidth; |
|
58168 |
|
58169 for(i = 0; i < (lHeight - 2); i += 2) |
|
58170 { |
|
58171 lPtr1 = src1 = lBuffer; |
|
58172 lPtr2 = src2 = src1 + lSrcWidth; |
|
58173 |
|
58174 for(k = 0; k < (lWidth - 2); k += 2) |
|
58175 { |
|
58176 lCr1 = lCrPtr[k >> 1]; |
|
58177 lCb1 = lCbPtr[k >> 1]; |
|
58178 |
|
58179 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
58180 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
58181 |
|
58182 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
58183 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
58184 |
|
58185 lCr4 = lCrPtr[((k + lLumWidth)>> 1) + 1]; |
|
58186 lCb4 = lCbPtr[((k + lLumWidth)>> 1) + 1]; |
|
58187 |
|
58188 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
58189 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
58190 |
|
58191 lCr2 = (lCr1 + lCr2) >> 1; |
|
58192 lCb2 = (lCb1 + lCb2) >> 1; |
|
58193 |
|
58194 lCr3 = (lCr1 + lCr3) >> 1; |
|
58195 lCb3 = (lCb1 + lCb3) >> 1; |
|
58196 |
|
58197 /*First Pixel*/ |
|
58198 lCr1 -= 128; |
|
58199 lCb1 -= 128; |
|
58200 |
|
58201 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
58202 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
58203 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
58204 |
|
58205 lY1 = lLumPtr[k]; |
|
58206 |
|
58207 lTemp = lY1 + lTemp1; |
|
58208 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58209 |
|
58210 lTemp = lY1 - lTemp2; |
|
58211 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58212 |
|
58213 lTemp = lY1 + lTemp3; |
|
58214 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58215 |
|
58216 /*Second Pixel*/ |
|
58217 lCr2 -= 128; |
|
58218 lCb2 -= 128; |
|
58219 |
|
58220 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
58221 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
58222 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
58223 |
|
58224 lY1 = lLumPtr[k + 1]; |
|
58225 |
|
58226 lTemp = lY1 + lTemp1; |
|
58227 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58228 |
|
58229 lTemp = lY1 - lTemp2; |
|
58230 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58231 |
|
58232 lTemp = lY1 + lTemp3; |
|
58233 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58234 |
|
58235 |
|
58236 /*Third Pixel*/ |
|
58237 lCr3 -= 128; |
|
58238 lCb3 -= 128; |
|
58239 |
|
58240 lTemp1 = (25801 * lCr3) >> COLOR_CONV_PRECISION; |
|
58241 lTemp2 = ((3072 * lCb3) + (7670 * lCr3)) >> COLOR_CONV_PRECISION; |
|
58242 lTemp3 = (30397 * lCb3) >> COLOR_CONV_PRECISION; |
|
58243 |
|
58244 lY1 = lLumPtr[k + lLumWidth]; |
|
58245 |
|
58246 lTemp = lY1 + lTemp1; |
|
58247 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58248 |
|
58249 lTemp = lY1 - lTemp2; |
|
58250 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58251 |
|
58252 lTemp = lY1 + lTemp3; |
|
58253 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58254 |
|
58255 /*Fourth Pixel*/ |
|
58256 lCr4 -= 128; |
|
58257 lCb4 -= 128; |
|
58258 |
|
58259 lTemp1 = (25801 * lCr4) >> COLOR_CONV_PRECISION; |
|
58260 lTemp2 = ((3072 * lCb4) + (7670 * lCr4)) >> COLOR_CONV_PRECISION; |
|
58261 lTemp3 = (30397 * lCb4) >> COLOR_CONV_PRECISION; |
|
58262 |
|
58263 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
58264 |
|
58265 lTemp = lY1 + lTemp1; |
|
58266 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58267 |
|
58268 lTemp = lY1 - lTemp2; |
|
58269 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58270 |
|
58271 lTemp = lY1 + lTemp3; |
|
58272 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58273 |
|
58274 |
|
58275 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
58276 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
58277 |
|
58278 lCr2 = lCrPtr[((k + lLumWidth) >> 1) + 1]; |
|
58279 lCb2 = lCbPtr[((k + lLumWidth) >> 1) + 1]; |
|
58280 |
|
58281 lCr2 = (lCr1 + lCr2) >> 1; |
|
58282 lCb2 = (lCb1 + lCb2) >> 1; |
|
58283 |
|
58284 /*Fifth Pixel*/ |
|
58285 lCr1 -= 128; |
|
58286 lCb1 -= 128; |
|
58287 |
|
58288 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
58289 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
58290 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
58291 |
|
58292 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
58293 |
|
58294 lTemp = lY1 + lTemp1; |
|
58295 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58296 |
|
58297 lTemp = lY1 - lTemp2; |
|
58298 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58299 |
|
58300 lTemp = lY1 + lTemp3; |
|
58301 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58302 |
|
58303 /*Sixth Pixel*/ |
|
58304 lCr2 -= 128; |
|
58305 lCb2 -= 128; |
|
58306 |
|
58307 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
58308 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
58309 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
58310 |
|
58311 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
58312 |
|
58313 lTemp = lY1 + lTemp1; |
|
58314 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58315 |
|
58316 lTemp = lY1 - lTemp2; |
|
58317 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58318 |
|
58319 lTemp = lY1 + lTemp3; |
|
58320 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58321 |
|
58322 src1 += 6; |
|
58323 src2 += 6; |
|
58324 } |
|
58325 |
|
58326 lCr1 = lCrPtr[k >> 1]; |
|
58327 lCb1 = lCbPtr[k >> 1]; |
|
58328 |
|
58329 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
58330 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
58331 |
|
58332 lCr4 = (lCr1 + lCr3) >> 1; |
|
58333 lCb4 = (lCb1 + lCb3) >> 1; |
|
58334 |
|
58335 lCr1 -= 128; |
|
58336 lCb1 -= 128; |
|
58337 |
|
58338 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
58339 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
58340 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
58341 |
|
58342 /*First Pixel*/ |
|
58343 lY1 = lLumPtr[k]; |
|
58344 |
|
58345 lTemp = lY1 + lTemp1; |
|
58346 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58347 |
|
58348 lTemp = lY1 - lTemp2; |
|
58349 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58350 |
|
58351 lTemp = lY1 + lTemp3; |
|
58352 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58353 |
|
58354 /*Second Pixel*/ |
|
58355 lY1 = lLumPtr[k + 1]; |
|
58356 |
|
58357 lTemp = lY1 + lTemp1; |
|
58358 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58359 |
|
58360 lTemp = lY1 - lTemp2; |
|
58361 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58362 |
|
58363 lTemp = lY1 + lTemp3; |
|
58364 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58365 |
|
58366 |
|
58367 lCr4 -= 128; |
|
58368 lCb4 -= 128; |
|
58369 |
|
58370 lTemp1 = (25801 * lCr4) >> COLOR_CONV_PRECISION; |
|
58371 lTemp2 = ((3072 * lCb4) + (7670 * lCr4)) >> COLOR_CONV_PRECISION; |
|
58372 lTemp3 = (30397 * lCb4) >> COLOR_CONV_PRECISION; |
|
58373 |
|
58374 /*Third Pixel*/ |
|
58375 lY1 = lLumPtr[k + lLumWidth]; |
|
58376 |
|
58377 lTemp = lY1 + lTemp1; |
|
58378 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58379 |
|
58380 lTemp = lY1 - lTemp2; |
|
58381 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58382 |
|
58383 lTemp = lY1 + lTemp3; |
|
58384 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58385 |
|
58386 /*Fourth Pixel*/ |
|
58387 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
58388 |
|
58389 lTemp = lY1 + lTemp1; |
|
58390 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58391 |
|
58392 lTemp = lY1 - lTemp2; |
|
58393 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58394 |
|
58395 lTemp = lY1 + lTemp3; |
|
58396 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58397 |
|
58398 |
|
58399 lCr3 -= 128; |
|
58400 lCb3 -= 128; |
|
58401 |
|
58402 lTemp1 = (25801 * lCr3) >> COLOR_CONV_PRECISION; |
|
58403 lTemp2 = ((3072 * lCb3) + (7670 * lCr3)) >> COLOR_CONV_PRECISION; |
|
58404 lTemp3 = (30397 * lCb3) >> COLOR_CONV_PRECISION; |
|
58405 |
|
58406 /*Fifth Pixel*/ |
|
58407 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
58408 |
|
58409 lTemp = lY1 + lTemp1; |
|
58410 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58411 |
|
58412 lTemp = lY1 - lTemp2; |
|
58413 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58414 |
|
58415 lTemp = lY1 + lTemp3; |
|
58416 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58417 |
|
58418 /*Sixth Pixel*/ |
|
58419 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
58420 |
|
58421 lTemp = lY1 + lTemp1; |
|
58422 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58423 |
|
58424 lTemp = lY1 - lTemp2; |
|
58425 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58426 |
|
58427 lTemp = lY1 + lTemp3; |
|
58428 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58429 |
|
58430 src1 += 6; |
|
58431 src2 += 6; |
|
58432 |
|
58433 |
|
58434 src1 = lPtr1; |
|
58435 src2 = lPtr2; |
|
58436 |
|
58437 for(j = 0; j < lWidth; j += 2) |
|
58438 { |
|
58439 /* First Pixel */ |
|
58440 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
58441 diff1 = *src1 & 0x7; |
|
58442 diff2 = *(src1 + 1) & 0x3; |
|
58443 diff3 = *(src1 + 2) & 0x7; |
|
58444 |
|
58445 // diffuse the error |
|
58446 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
58447 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
58448 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
58449 |
|
58450 /* Second Pixel */ |
|
58451 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
58452 diff1 = *(src1 + 3) & 0x7; |
|
58453 diff2 = *(src1 + 4) & 0x3; |
|
58454 diff3 = *(src1 + 5) & 0x7; |
|
58455 // diffuse the error |
|
58456 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
58457 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
58458 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
58459 |
|
58460 src1 += 6; |
|
58461 dest1 += 2; |
|
58462 |
|
58463 /* Third Pixel */ |
|
58464 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
58465 diff1 = *src2 & 0x7; |
|
58466 diff2 = *(src2 + 1) & 0x3; |
|
58467 diff3 = *(src2 + 2) & 0x7; |
|
58468 //diffuse the error |
|
58469 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
58470 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
58471 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
58472 |
|
58473 /* Fourth Pixel */ |
|
58474 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
58475 diff1 = *(src2 + 3) & 0x7; |
|
58476 diff2 = *(src2 + 4) & 0x3; |
|
58477 diff3 = *(src2 + 5) & 0x7; |
|
58478 //diffuse the error |
|
58479 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
58480 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
58481 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
58482 |
|
58483 src2 += 6; |
|
58484 dest2 += 2; |
|
58485 } |
|
58486 if(extraCol) |
|
58487 { |
|
58488 *dest1 = dest1[-1]; |
|
58489 dest1++; |
|
58490 *dest2 = dest2[-1]; |
|
58491 dest2++; |
|
58492 } |
|
58493 |
|
58494 lLumPtr += (lLumWidth << 1); |
|
58495 lCrPtr += (lLumWidth >> 1); |
|
58496 lCbPtr += (lLumWidth >> 1); |
|
58497 |
|
58498 dest1 += ((wndWidth << 1) - lTempWidth); |
|
58499 dest2 += ((wndWidth << 1) - lTempWidth); |
|
58500 } |
|
58501 |
|
58502 |
|
58503 lPtr1 = src1 = lBuffer; |
|
58504 lPtr2 = src2 = src1 + lSrcWidth; |
|
58505 |
|
58506 for(k = 0; k < (lWidth - 2); k += 2) |
|
58507 { |
|
58508 lCr1 = lCrPtr[k >> 1]; |
|
58509 lCb1 = lCbPtr[k >> 1]; |
|
58510 |
|
58511 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
58512 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
58513 |
|
58514 lCr2 = (lCr1 + lCr2) >> 1; |
|
58515 lCb2 = (lCb1 + lCb2) >> 1; |
|
58516 |
|
58517 |
|
58518 lCr1 -= 128; |
|
58519 lCb1 -= 128; |
|
58520 |
|
58521 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
58522 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
58523 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
58524 |
|
58525 /*First Pixel*/ |
|
58526 lY1 = lLumPtr[k]; |
|
58527 |
|
58528 lTemp = lY1 + lTemp1; |
|
58529 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58530 |
|
58531 lTemp = lY1 - lTemp2; |
|
58532 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58533 |
|
58534 lTemp = lY1 + lTemp3; |
|
58535 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58536 |
|
58537 /*Third Pixel*/ |
|
58538 lY1 = lLumPtr[k + lLumWidth]; |
|
58539 |
|
58540 lTemp = lY1 + lTemp1; |
|
58541 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58542 |
|
58543 lTemp = lY1 - lTemp2; |
|
58544 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58545 |
|
58546 lTemp = lY1 + lTemp3; |
|
58547 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58548 |
|
58549 |
|
58550 lCr2 -= 128; |
|
58551 lCb2 -= 128; |
|
58552 |
|
58553 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
58554 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
58555 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
58556 |
|
58557 /*Second Pixel*/ |
|
58558 lY1 = lLumPtr[k + 1]; |
|
58559 |
|
58560 lTemp = lY1 + lTemp1; |
|
58561 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58562 |
|
58563 lTemp = lY1 - lTemp2; |
|
58564 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58565 |
|
58566 lTemp = lY1 + lTemp3; |
|
58567 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58568 |
|
58569 /*Fourth Pixel*/ |
|
58570 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
58571 |
|
58572 lTemp = lY1 + lTemp1; |
|
58573 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58574 |
|
58575 lTemp = lY1 - lTemp2; |
|
58576 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58577 |
|
58578 lTemp = lY1 + lTemp3; |
|
58579 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58580 |
|
58581 src1 += 6; |
|
58582 src2 += 6; |
|
58583 } |
|
58584 |
|
58585 lCr1 = lCrPtr[k >> 1]; |
|
58586 lCb1 = lCbPtr[k >> 1]; |
|
58587 |
|
58588 lCr1 -= 128; |
|
58589 lCb1 -= 128; |
|
58590 |
|
58591 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
58592 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
58593 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
58594 |
|
58595 /*First Pixel*/ |
|
58596 lY1 = lLumPtr[k]; |
|
58597 |
|
58598 lTemp = lY1 + lTemp1; |
|
58599 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58600 |
|
58601 lTemp = lY1 - lTemp2; |
|
58602 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58603 |
|
58604 lTemp = lY1 + lTemp3; |
|
58605 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58606 |
|
58607 /*Second Pixel*/ |
|
58608 lY1 = lLumPtr[k + 1]; |
|
58609 |
|
58610 lTemp = lY1 + lTemp1; |
|
58611 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58612 |
|
58613 lTemp = lY1 - lTemp2; |
|
58614 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58615 |
|
58616 lTemp = lY1 + lTemp3; |
|
58617 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58618 |
|
58619 /*Third Pixel*/ |
|
58620 lY1 = lLumPtr[k + lLumWidth]; |
|
58621 |
|
58622 lTemp = lY1 + lTemp1; |
|
58623 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58624 |
|
58625 lTemp = lY1 - lTemp2; |
|
58626 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58627 |
|
58628 lTemp = lY1 + lTemp3; |
|
58629 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58630 |
|
58631 /*Fourth Pixel*/ |
|
58632 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
58633 |
|
58634 lTemp = lY1 + lTemp1; |
|
58635 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58636 |
|
58637 lTemp = lY1 - lTemp2; |
|
58638 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58639 |
|
58640 lTemp = lY1 + lTemp3; |
|
58641 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58642 |
|
58643 src1 += 6; |
|
58644 src2 += 6; |
|
58645 |
|
58646 |
|
58647 src1 = lPtr1; |
|
58648 src2 = lPtr2; |
|
58649 |
|
58650 for(j = 0; j < lWidth; j += 2) |
|
58651 { |
|
58652 /* First Pixel */ |
|
58653 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
58654 diff1 = *src1 & 0x7; |
|
58655 diff2 = *(src1 + 1) & 0x3; |
|
58656 diff3 = *(src1 + 2) & 0x7; |
|
58657 |
|
58658 // diffuse the error |
|
58659 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
58660 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
58661 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
58662 |
|
58663 /* Second Pixel */ |
|
58664 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
58665 diff1 = *(src1 + 3) & 0x7; |
|
58666 diff2 = *(src1 + 4) & 0x3; |
|
58667 diff3 = *(src1 + 5) & 0x7; |
|
58668 // diffuse the error |
|
58669 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
58670 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
58671 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
58672 |
|
58673 src1 += 6; |
|
58674 dest1 += 2; |
|
58675 |
|
58676 /* Third Pixel */ |
|
58677 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
58678 diff1 = *src2 & 0x7; |
|
58679 diff2 = *(src2 + 1) & 0x3; |
|
58680 diff3 = *(src2 + 2) & 0x7; |
|
58681 //diffuse the error |
|
58682 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
58683 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
58684 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
58685 |
|
58686 /* Fourth Pixel */ |
|
58687 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
58688 diff1 = *(src2 + 3) & 0x7; |
|
58689 diff2 = *(src2 + 4) & 0x3; |
|
58690 diff3 = *(src2 + 5) & 0x7; |
|
58691 //diffuse the error |
|
58692 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
58693 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
58694 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
58695 |
|
58696 src2 += 6; |
|
58697 dest2 += 2; |
|
58698 } |
|
58699 |
|
58700 if(extraCol) |
|
58701 { |
|
58702 *dest1 = dest1[-1]; |
|
58703 dest1++; |
|
58704 *dest2 = dest2[-1]; |
|
58705 dest2++; |
|
58706 } |
|
58707 |
|
58708 dest1 += ((wndWidth << 1) - lTempWidth); |
|
58709 dest2 += ((wndWidth << 1) - lTempWidth); |
|
58710 |
|
58711 if(extraRow) |
|
58712 { |
|
58713 dest2 = dest1 - wndWidth; |
|
58714 for(j = 0; j < lWidth; j += 2) |
|
58715 { |
|
58716 *dest1++ = *dest2++; |
|
58717 *dest1++ = *dest2++; |
|
58718 } |
|
58719 if(extraCol) |
|
58720 { |
|
58721 *dest1 = *dest2; |
|
58722 } |
|
58723 } |
|
58724 |
|
58725 free(lBuffer); |
|
58726 return; |
|
58727 } |
|
58728 |
|
58729 /* |
|
58730 ****************************************************************************** |
|
58731 Name : sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_601_5_FR |
|
58732 Description : Converts YUV420 Chroma3 Planar to RGB565 Interleaved format |
|
58733 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
58734 uint8 *dstImage : Pointer to rgb data (o/p). |
|
58735 tWndParam *srcWindow : Pointer to structure containing source window |
|
58736 parameters like xOffset,yOffset,cropWidth, |
|
58737 cropHeight. (i/p) |
|
58738 tWndParam *dstWindow : Pointer to structure containing destination window |
|
58739 parameters like xOffset,yOffset,windWidth, |
|
58740 windHeight. (i/p) |
|
58741 Return Value : void |
|
58742 ****************************************************************************** |
|
58743 */ |
|
58744 |
|
58745 void sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_601_5_FR |
|
58746 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
58747 tWndParam* srcWindow, tWndParam* dstWindow) |
|
58748 { |
|
58749 uint16 *dest1, *dest2; |
|
58750 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
58751 uint8 *lBuffer; |
|
58752 uint8 *src1, *src2; |
|
58753 uint8 *lPtr1, *lPtr2; |
|
58754 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
58755 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
58756 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
58757 int32 diff1, diff2, diff3; |
|
58758 int32 i, j, k, extraRow, extraCol; |
|
58759 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
58760 cropWidth,cropHeight,wndWidth,wndHeight; |
|
58761 |
|
58762 srcXOffset = srcWindow->xOffset; |
|
58763 srcYOffset = srcWindow->yOffset; |
|
58764 cropWidth = srcWindow->wndWidth; |
|
58765 cropHeight = srcWindow->wndHeight; |
|
58766 |
|
58767 dstXOffset = dstWindow->xOffset; |
|
58768 dstYOffset = dstWindow->yOffset; |
|
58769 wndWidth = dstWindow->wndWidth; |
|
58770 wndHeight = dstWindow->wndHeight; |
|
58771 |
|
58772 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
58773 { |
|
58774 lWidth = cropWidth; |
|
58775 } |
|
58776 else |
|
58777 { |
|
58778 lWidth = srcImage->width - srcXOffset; |
|
58779 } |
|
58780 |
|
58781 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
58782 { |
|
58783 lHeight = cropHeight; |
|
58784 } |
|
58785 else |
|
58786 { |
|
58787 lHeight = srcImage->height - srcYOffset; |
|
58788 } |
|
58789 |
|
58790 if (lWidth > (wndWidth - dstXOffset)) |
|
58791 { |
|
58792 lWidth = wndWidth - dstXOffset; |
|
58793 } |
|
58794 |
|
58795 if (lHeight > (wndHeight - dstYOffset)) |
|
58796 { |
|
58797 lHeight = wndHeight - dstYOffset; |
|
58798 } |
|
58799 |
|
58800 extraCol = lWidth & 0x01; |
|
58801 extraRow = lHeight & 0x01; |
|
58802 |
|
58803 lTempWidth = lWidth; |
|
58804 lWidth = (lWidth >> 1) << 1; |
|
58805 lHeight = (lHeight >> 1) << 1; |
|
58806 |
|
58807 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
58808 |
|
58809 lSrcWidth = lWidth * 3; |
|
58810 |
|
58811 lLumWidth = (srcImage->width >> 1) << 1; |
|
58812 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
58813 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
58814 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
58815 |
|
58816 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
58817 dest2 = dest1 + wndWidth; |
|
58818 |
|
58819 for(i = 0; i < (lHeight - 2); i += 2) |
|
58820 { |
|
58821 lPtr1 = src1 = lBuffer; |
|
58822 lPtr2 = src2 = src1 + lSrcWidth; |
|
58823 |
|
58824 for(k = 0; k < (lWidth - 2); k += 2) |
|
58825 { |
|
58826 lCr1 = lCrPtr[k >> 1]; |
|
58827 lCb1 = lCbPtr[k >> 1]; |
|
58828 |
|
58829 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
58830 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
58831 |
|
58832 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
58833 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
58834 |
|
58835 lCr4 = lCrPtr[((k + lLumWidth)>> 1) + 1]; |
|
58836 lCb4 = lCbPtr[((k + lLumWidth)>> 1) + 1]; |
|
58837 |
|
58838 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
58839 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
58840 |
|
58841 lCr2 = (lCr1 + lCr2) >> 1; |
|
58842 lCb2 = (lCb1 + lCb2) >> 1; |
|
58843 |
|
58844 lCr3 = (lCr1 + lCr3) >> 1; |
|
58845 lCb3 = (lCb1 + lCb3) >> 1; |
|
58846 |
|
58847 /*First Pixel*/ |
|
58848 lCr1 -= 128; |
|
58849 lCb1 -= 128; |
|
58850 |
|
58851 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
58852 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
58853 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
58854 |
|
58855 lY1 = lLumPtr[k]; |
|
58856 |
|
58857 lTemp = lY1 + lTemp1; |
|
58858 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58859 |
|
58860 lTemp = lY1 - lTemp2; |
|
58861 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58862 |
|
58863 lTemp = lY1 + lTemp3; |
|
58864 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58865 |
|
58866 /*Second Pixel*/ |
|
58867 lCr2 -= 128; |
|
58868 lCb2 -= 128; |
|
58869 |
|
58870 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
58871 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
58872 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
58873 |
|
58874 lY1 = lLumPtr[k + 1]; |
|
58875 |
|
58876 lTemp = lY1 + lTemp1; |
|
58877 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58878 |
|
58879 lTemp = lY1 - lTemp2; |
|
58880 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58881 |
|
58882 lTemp = lY1 + lTemp3; |
|
58883 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58884 |
|
58885 |
|
58886 /*Third Pixel*/ |
|
58887 lCr3 -= 128; |
|
58888 lCb3 -= 128; |
|
58889 |
|
58890 lTemp1 = (22973 * lCr3) >> COLOR_CONV_PRECISION; |
|
58891 lTemp2 = ((5637 * lCb3) + (11699 * lCr3)) >> COLOR_CONV_PRECISION; |
|
58892 lTemp3 = (29032 * lCb3) >> COLOR_CONV_PRECISION; |
|
58893 |
|
58894 lY1 = lLumPtr[k + lLumWidth]; |
|
58895 |
|
58896 lTemp = lY1 + lTemp1; |
|
58897 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58898 |
|
58899 lTemp = lY1 - lTemp2; |
|
58900 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58901 |
|
58902 lTemp = lY1 + lTemp3; |
|
58903 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58904 |
|
58905 /*Fourth Pixel*/ |
|
58906 lCr4 -= 128; |
|
58907 lCb4 -= 128; |
|
58908 |
|
58909 lTemp1 = (22973 * lCr4) >> COLOR_CONV_PRECISION; |
|
58910 lTemp2 = ((5637 * lCb4) + (11699 * lCr4)) >> COLOR_CONV_PRECISION; |
|
58911 lTemp3 = (29032 * lCb4) >> COLOR_CONV_PRECISION; |
|
58912 |
|
58913 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
58914 |
|
58915 lTemp = lY1 + lTemp1; |
|
58916 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58917 |
|
58918 lTemp = lY1 - lTemp2; |
|
58919 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58920 |
|
58921 lTemp = lY1 + lTemp3; |
|
58922 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58923 |
|
58924 |
|
58925 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
58926 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
58927 |
|
58928 lCr2 = lCrPtr[((k + lLumWidth) >> 1) + 1]; |
|
58929 lCb2 = lCbPtr[((k + lLumWidth) >> 1) + 1]; |
|
58930 |
|
58931 lCr2 = (lCr1 + lCr2) >> 1; |
|
58932 lCb2 = (lCb1 + lCb2) >> 1; |
|
58933 |
|
58934 /*Fifth Pixel*/ |
|
58935 lCr1 -= 128; |
|
58936 lCb1 -= 128; |
|
58937 |
|
58938 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
58939 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
58940 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
58941 |
|
58942 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
58943 |
|
58944 lTemp = lY1 + lTemp1; |
|
58945 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58946 |
|
58947 lTemp = lY1 - lTemp2; |
|
58948 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58949 |
|
58950 lTemp = lY1 + lTemp3; |
|
58951 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58952 |
|
58953 /*Sixth Pixel*/ |
|
58954 lCr2 -= 128; |
|
58955 lCb2 -= 128; |
|
58956 |
|
58957 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
58958 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
58959 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
58960 |
|
58961 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
58962 |
|
58963 lTemp = lY1 + lTemp1; |
|
58964 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58965 |
|
58966 lTemp = lY1 - lTemp2; |
|
58967 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58968 |
|
58969 lTemp = lY1 + lTemp3; |
|
58970 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58971 |
|
58972 src1 += 6; |
|
58973 src2 += 6; |
|
58974 } |
|
58975 |
|
58976 lCr1 = lCrPtr[k >> 1]; |
|
58977 lCb1 = lCbPtr[k >> 1]; |
|
58978 |
|
58979 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
58980 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
58981 |
|
58982 lCr4 = (lCr1 + lCr3) >> 1; |
|
58983 lCb4 = (lCb1 + lCb3) >> 1; |
|
58984 |
|
58985 lCr1 -= 128; |
|
58986 lCb1 -= 128; |
|
58987 |
|
58988 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
58989 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
58990 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
58991 |
|
58992 /*First Pixel*/ |
|
58993 lY1 = lLumPtr[k]; |
|
58994 |
|
58995 lTemp = lY1 + lTemp1; |
|
58996 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
58997 |
|
58998 lTemp = lY1 - lTemp2; |
|
58999 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59000 |
|
59001 lTemp = lY1 + lTemp3; |
|
59002 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59003 |
|
59004 /*Second Pixel*/ |
|
59005 lY1 = lLumPtr[k + 1]; |
|
59006 |
|
59007 lTemp = lY1 + lTemp1; |
|
59008 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59009 |
|
59010 lTemp = lY1 - lTemp2; |
|
59011 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59012 |
|
59013 lTemp = lY1 + lTemp3; |
|
59014 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59015 |
|
59016 |
|
59017 lCr4 -= 128; |
|
59018 lCb4 -= 128; |
|
59019 |
|
59020 lTemp1 = (22973 * lCr4) >> COLOR_CONV_PRECISION; |
|
59021 lTemp2 = ((5637 * lCb4) + (11699 * lCr4)) >> COLOR_CONV_PRECISION; |
|
59022 lTemp3 = (29032 * lCb4) >> COLOR_CONV_PRECISION; |
|
59023 |
|
59024 /*Third Pixel*/ |
|
59025 lY1 = lLumPtr[k + lLumWidth]; |
|
59026 |
|
59027 lTemp = lY1 + lTemp1; |
|
59028 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59029 |
|
59030 lTemp = lY1 - lTemp2; |
|
59031 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59032 |
|
59033 lTemp = lY1 + lTemp3; |
|
59034 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59035 |
|
59036 /*Fourth Pixel*/ |
|
59037 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
59038 |
|
59039 lTemp = lY1 + lTemp1; |
|
59040 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59041 |
|
59042 lTemp = lY1 - lTemp2; |
|
59043 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59044 |
|
59045 lTemp = lY1 + lTemp3; |
|
59046 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59047 |
|
59048 |
|
59049 lCr3 -= 128; |
|
59050 lCb3 -= 128; |
|
59051 |
|
59052 lTemp1 = (22973 * lCr3) >> COLOR_CONV_PRECISION; |
|
59053 lTemp2 = ((5637 * lCb3) + (11699 * lCr3)) >> COLOR_CONV_PRECISION; |
|
59054 lTemp3 = (29032 * lCb3) >> COLOR_CONV_PRECISION; |
|
59055 |
|
59056 /*Fifth Pixel*/ |
|
59057 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
59058 |
|
59059 lTemp = lY1 + lTemp1; |
|
59060 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59061 |
|
59062 lTemp = lY1 - lTemp2; |
|
59063 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59064 |
|
59065 lTemp = lY1 + lTemp3; |
|
59066 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59067 |
|
59068 /*Sixth Pixel*/ |
|
59069 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
59070 |
|
59071 lTemp = lY1 + lTemp1; |
|
59072 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59073 |
|
59074 lTemp = lY1 - lTemp2; |
|
59075 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59076 |
|
59077 lTemp = lY1 + lTemp3; |
|
59078 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59079 |
|
59080 src1 += 6; |
|
59081 src2 += 6; |
|
59082 |
|
59083 |
|
59084 src1 = lPtr1; |
|
59085 src2 = lPtr2; |
|
59086 |
|
59087 for(j = 0; j < lWidth; j += 2) |
|
59088 { |
|
59089 /* First Pixel */ |
|
59090 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
59091 diff1 = *src1 & 0x7; |
|
59092 diff2 = *(src1 + 1) & 0x3; |
|
59093 diff3 = *(src1 + 2) & 0x7; |
|
59094 |
|
59095 // diffuse the error |
|
59096 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
59097 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
59098 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
59099 |
|
59100 /* Second Pixel */ |
|
59101 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
59102 diff1 = *(src1 + 3) & 0x7; |
|
59103 diff2 = *(src1 + 4) & 0x3; |
|
59104 diff3 = *(src1 + 5) & 0x7; |
|
59105 // diffuse the error |
|
59106 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
59107 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
59108 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
59109 |
|
59110 src1 += 6; |
|
59111 dest1 += 2; |
|
59112 |
|
59113 /* Third Pixel */ |
|
59114 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
59115 diff1 = *src2 & 0x7; |
|
59116 diff2 = *(src2 + 1) & 0x3; |
|
59117 diff3 = *(src2 + 2) & 0x7; |
|
59118 //diffuse the error |
|
59119 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
59120 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
59121 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
59122 |
|
59123 /* Fourth Pixel */ |
|
59124 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
59125 diff1 = *(src2 + 3) & 0x7; |
|
59126 diff2 = *(src2 + 4) & 0x3; |
|
59127 diff3 = *(src2 + 5) & 0x7; |
|
59128 //diffuse the error |
|
59129 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
59130 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
59131 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
59132 |
|
59133 src2 += 6; |
|
59134 dest2 += 2; |
|
59135 } |
|
59136 if(extraCol) |
|
59137 { |
|
59138 *dest1 = dest1[-1]; |
|
59139 dest1++; |
|
59140 *dest2 = dest2[-1]; |
|
59141 dest2++; |
|
59142 } |
|
59143 |
|
59144 lLumPtr += (lLumWidth << 1); |
|
59145 lCrPtr += (lLumWidth >> 1); |
|
59146 lCbPtr += (lLumWidth >> 1); |
|
59147 |
|
59148 dest1 += ((wndWidth << 1) - lTempWidth); |
|
59149 dest2 += ((wndWidth << 1) - lTempWidth); |
|
59150 } |
|
59151 |
|
59152 |
|
59153 lPtr1 = src1 = lBuffer; |
|
59154 lPtr2 = src2 = src1 + lSrcWidth; |
|
59155 |
|
59156 for(k = 0; k < (lWidth - 2); k += 2) |
|
59157 { |
|
59158 lCr1 = lCrPtr[k >> 1]; |
|
59159 lCb1 = lCbPtr[k >> 1]; |
|
59160 |
|
59161 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
59162 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
59163 |
|
59164 lCr2 = (lCr1 + lCr2) >> 1; |
|
59165 lCb2 = (lCb1 + lCb2) >> 1; |
|
59166 |
|
59167 |
|
59168 lCr1 -= 128; |
|
59169 lCb1 -= 128; |
|
59170 |
|
59171 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
59172 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
59173 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
59174 |
|
59175 /*First Pixel*/ |
|
59176 lY1 = lLumPtr[k]; |
|
59177 |
|
59178 lTemp = lY1 + lTemp1; |
|
59179 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59180 |
|
59181 lTemp = lY1 - lTemp2; |
|
59182 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59183 |
|
59184 lTemp = lY1 + lTemp3; |
|
59185 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59186 |
|
59187 /*Third Pixel*/ |
|
59188 lY1 = lLumPtr[k + lLumWidth]; |
|
59189 |
|
59190 lTemp = lY1 + lTemp1; |
|
59191 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59192 |
|
59193 lTemp = lY1 - lTemp2; |
|
59194 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59195 |
|
59196 lTemp = lY1 + lTemp3; |
|
59197 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59198 |
|
59199 |
|
59200 lCr2 -= 128; |
|
59201 lCb2 -= 128; |
|
59202 |
|
59203 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
59204 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
59205 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
59206 |
|
59207 /*Second Pixel*/ |
|
59208 lY1 = lLumPtr[k + 1]; |
|
59209 |
|
59210 lTemp = lY1 + lTemp1; |
|
59211 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59212 |
|
59213 lTemp = lY1 - lTemp2; |
|
59214 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59215 |
|
59216 lTemp = lY1 + lTemp3; |
|
59217 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59218 |
|
59219 /*Fourth Pixel*/ |
|
59220 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
59221 |
|
59222 lTemp = lY1 + lTemp1; |
|
59223 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59224 |
|
59225 lTemp = lY1 - lTemp2; |
|
59226 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59227 |
|
59228 lTemp = lY1 + lTemp3; |
|
59229 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59230 |
|
59231 src1 += 6; |
|
59232 src2 += 6; |
|
59233 } |
|
59234 |
|
59235 lCr1 = lCrPtr[k >> 1]; |
|
59236 lCb1 = lCbPtr[k >> 1]; |
|
59237 |
|
59238 lCr1 -= 128; |
|
59239 lCb1 -= 128; |
|
59240 |
|
59241 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
59242 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
59243 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
59244 |
|
59245 /*First Pixel*/ |
|
59246 lY1 = lLumPtr[k]; |
|
59247 |
|
59248 lTemp = lY1 + lTemp1; |
|
59249 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59250 |
|
59251 lTemp = lY1 - lTemp2; |
|
59252 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59253 |
|
59254 lTemp = lY1 + lTemp3; |
|
59255 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59256 |
|
59257 /*Second Pixel*/ |
|
59258 lY1 = lLumPtr[k + 1]; |
|
59259 |
|
59260 lTemp = lY1 + lTemp1; |
|
59261 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59262 |
|
59263 lTemp = lY1 - lTemp2; |
|
59264 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59265 |
|
59266 lTemp = lY1 + lTemp3; |
|
59267 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59268 |
|
59269 /*Third Pixel*/ |
|
59270 lY1 = lLumPtr[k + lLumWidth]; |
|
59271 |
|
59272 lTemp = lY1 + lTemp1; |
|
59273 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59274 |
|
59275 lTemp = lY1 - lTemp2; |
|
59276 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59277 |
|
59278 lTemp = lY1 + lTemp3; |
|
59279 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59280 |
|
59281 /*Fourth Pixel*/ |
|
59282 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
59283 |
|
59284 lTemp = lY1 + lTemp1; |
|
59285 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59286 |
|
59287 lTemp = lY1 - lTemp2; |
|
59288 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59289 |
|
59290 lTemp = lY1 + lTemp3; |
|
59291 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
59292 |
|
59293 src1 += 6; |
|
59294 src2 += 6; |
|
59295 |
|
59296 |
|
59297 src1 = lPtr1; |
|
59298 src2 = lPtr2; |
|
59299 |
|
59300 for(j = 0; j < lWidth; j += 2) |
|
59301 { |
|
59302 /* First Pixel */ |
|
59303 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
59304 diff1 = *src1 & 0x7; |
|
59305 diff2 = *(src1 + 1) & 0x3; |
|
59306 diff3 = *(src1 + 2) & 0x7; |
|
59307 |
|
59308 // diffuse the error |
|
59309 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
59310 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
59311 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
59312 |
|
59313 /* Second Pixel */ |
|
59314 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
59315 diff1 = *(src1 + 3) & 0x7; |
|
59316 diff2 = *(src1 + 4) & 0x3; |
|
59317 diff3 = *(src1 + 5) & 0x7; |
|
59318 // diffuse the error |
|
59319 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
59320 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
59321 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
59322 |
|
59323 src1 += 6; |
|
59324 dest1 += 2; |
|
59325 |
|
59326 /* Third Pixel */ |
|
59327 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
59328 diff1 = *src2 & 0x7; |
|
59329 diff2 = *(src2 + 1) & 0x3; |
|
59330 diff3 = *(src2 + 2) & 0x7; |
|
59331 //diffuse the error |
|
59332 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
59333 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
59334 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
59335 |
|
59336 /* Fourth Pixel */ |
|
59337 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
59338 diff1 = *(src2 + 3) & 0x7; |
|
59339 diff2 = *(src2 + 4) & 0x3; |
|
59340 diff3 = *(src2 + 5) & 0x7; |
|
59341 //diffuse the error |
|
59342 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
59343 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
59344 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
59345 |
|
59346 src2 += 6; |
|
59347 dest2 += 2; |
|
59348 } |
|
59349 |
|
59350 if(extraCol) |
|
59351 { |
|
59352 *dest1 = dest1[-1]; |
|
59353 dest1++; |
|
59354 *dest2 = dest2[-1]; |
|
59355 dest2++; |
|
59356 } |
|
59357 |
|
59358 dest1 += ((wndWidth << 1) - lTempWidth); |
|
59359 dest2 += ((wndWidth << 1) - lTempWidth); |
|
59360 |
|
59361 if(extraRow) |
|
59362 { |
|
59363 dest2 = dest1 - wndWidth; |
|
59364 for(j = 0; j < lWidth; j += 2) |
|
59365 { |
|
59366 *dest1++ = *dest2++; |
|
59367 *dest1++ = *dest2++; |
|
59368 } |
|
59369 if(extraCol) |
|
59370 { |
|
59371 *dest1 = *dest2; |
|
59372 } |
|
59373 } |
|
59374 |
|
59375 free(lBuffer); |
|
59376 return; |
|
59377 } |
|
59378 |
|
59379 /* |
|
59380 ****************************************************************************** |
|
59381 Name : sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_709_RR |
|
59382 Description : Converts YUV420 Chroma3 Planar to RGB565 Interleaved format |
|
59383 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
59384 uint8 *dstImage : Pointer to rgb data (o/p). |
|
59385 tWndParam *srcWindow : Pointer to structure containing source window |
|
59386 parameters like xOffset,yOffset,cropWidth, |
|
59387 cropHeight. (i/p) |
|
59388 tWndParam *dstWindow : Pointer to structure containing destination window |
|
59389 parameters like xOffset,yOffset,windWidth, |
|
59390 windHeight. (i/p) |
|
59391 Return Value : void |
|
59392 ****************************************************************************** |
|
59393 */ |
|
59394 |
|
59395 void sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_709_RR |
|
59396 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
59397 tWndParam* srcWindow, tWndParam* dstWindow) |
|
59398 { |
|
59399 uint16 *dest1, *dest2; |
|
59400 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
59401 uint8 *lBuffer; |
|
59402 uint8 *src1, *src2; |
|
59403 uint8 *lPtr1, *lPtr2; |
|
59404 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
59405 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
59406 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
59407 int32 diff1, diff2, diff3; |
|
59408 int32 i, j, k, extraRow, extraCol; |
|
59409 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
59410 cropWidth,cropHeight,wndWidth,wndHeight; |
|
59411 |
|
59412 srcXOffset = srcWindow->xOffset; |
|
59413 srcYOffset = srcWindow->yOffset; |
|
59414 cropWidth = srcWindow->wndWidth; |
|
59415 cropHeight = srcWindow->wndHeight; |
|
59416 |
|
59417 dstXOffset = dstWindow->xOffset; |
|
59418 dstYOffset = dstWindow->yOffset; |
|
59419 wndWidth = dstWindow->wndWidth; |
|
59420 wndHeight = dstWindow->wndHeight; |
|
59421 |
|
59422 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
59423 { |
|
59424 lWidth = cropWidth; |
|
59425 } |
|
59426 else |
|
59427 { |
|
59428 lWidth = srcImage->width - srcXOffset; |
|
59429 } |
|
59430 |
|
59431 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
59432 { |
|
59433 lHeight = cropHeight; |
|
59434 } |
|
59435 else |
|
59436 { |
|
59437 lHeight = srcImage->height - srcYOffset; |
|
59438 } |
|
59439 |
|
59440 if (lWidth > (wndWidth - dstXOffset)) |
|
59441 { |
|
59442 lWidth = wndWidth - dstXOffset; |
|
59443 } |
|
59444 |
|
59445 if (lHeight > (wndHeight - dstYOffset)) |
|
59446 { |
|
59447 lHeight = wndHeight - dstYOffset; |
|
59448 } |
|
59449 |
|
59450 extraCol = lWidth & 0x01; |
|
59451 extraRow = lHeight & 0x01; |
|
59452 |
|
59453 lTempWidth = lWidth; |
|
59454 lWidth = (lWidth >> 1) << 1; |
|
59455 lHeight = (lHeight >> 1) << 1; |
|
59456 |
|
59457 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
59458 |
|
59459 lSrcWidth = lWidth * 3; |
|
59460 |
|
59461 lLumWidth = (srcImage->width >> 1) << 1; |
|
59462 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
59463 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
59464 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
59465 |
|
59466 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
59467 dest2 = dest1 + wndWidth; |
|
59468 |
|
59469 for(i = 0; i < (lHeight - 2); i += 2) |
|
59470 { |
|
59471 lPtr1 = src1 = lBuffer; |
|
59472 lPtr2 = src2 = src1 + lSrcWidth; |
|
59473 |
|
59474 for(k = 0; k < (lWidth - 2); k += 2) |
|
59475 { |
|
59476 lCr1 = lCrPtr[k >> 1]; |
|
59477 lCb1 = lCbPtr[k >> 1]; |
|
59478 |
|
59479 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
59480 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
59481 |
|
59482 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
59483 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
59484 |
|
59485 lCr4 = lCrPtr[((k + lLumWidth)>> 1) + 1]; |
|
59486 lCb4 = lCbPtr[((k + lLumWidth)>> 1) + 1]; |
|
59487 |
|
59488 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
59489 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
59490 |
|
59491 lCr2 = (lCr1 + lCr2) >> 1; |
|
59492 lCb2 = (lCb1 + lCb2) >> 1; |
|
59493 |
|
59494 lCr3 = (lCr1 + lCr3) >> 1; |
|
59495 lCb3 = (lCb1 + lCb3) >> 1; |
|
59496 |
|
59497 /*First Pixel*/ |
|
59498 lCr1 -= 128; |
|
59499 lCb1 -= 128; |
|
59500 |
|
59501 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
59502 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
59503 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
59504 |
|
59505 lY1 = lLumPtr[k]; |
|
59506 lY1 -= 16; |
|
59507 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59508 |
|
59509 lTemp = lY1 + lTemp1; |
|
59510 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59511 |
|
59512 lTemp = lY1 - lTemp2; |
|
59513 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59514 |
|
59515 lTemp = lY1 + lTemp3; |
|
59516 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59517 |
|
59518 /*Second Pixel*/ |
|
59519 lCr2 -= 128; |
|
59520 lCb2 -= 128; |
|
59521 |
|
59522 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
59523 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
59524 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
59525 |
|
59526 lY1 = lLumPtr[k + 1]; |
|
59527 lY1 -= 16; |
|
59528 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59529 |
|
59530 lTemp = lY1 + lTemp1; |
|
59531 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59532 |
|
59533 lTemp = lY1 - lTemp2; |
|
59534 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59535 |
|
59536 lTemp = lY1 + lTemp3; |
|
59537 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59538 |
|
59539 |
|
59540 /*Third Pixel*/ |
|
59541 lCr3 -= 128; |
|
59542 lCb3 -= 128; |
|
59543 |
|
59544 lTemp1 = (29374 * lCr3) >> COLOR_CONV_PRECISION; |
|
59545 lTemp2 = ((3494 * lCb3) + (8731 * lCr3)) >> COLOR_CONV_PRECISION; |
|
59546 lTemp3 = (34603 * lCb3) >> COLOR_CONV_PRECISION; |
|
59547 |
|
59548 lY1 = lLumPtr[k + lLumWidth]; |
|
59549 lY1 -= 16; |
|
59550 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59551 |
|
59552 lTemp = lY1 + lTemp1; |
|
59553 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59554 |
|
59555 lTemp = lY1 - lTemp2; |
|
59556 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59557 |
|
59558 lTemp = lY1 + lTemp3; |
|
59559 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59560 |
|
59561 /*Fourth Pixel*/ |
|
59562 lCr4 -= 128; |
|
59563 lCb4 -= 128; |
|
59564 |
|
59565 lTemp1 = (29374 * lCr4) >> COLOR_CONV_PRECISION; |
|
59566 lTemp2 = ((3494 * lCb4) + (8731 * lCr4)) >> COLOR_CONV_PRECISION; |
|
59567 lTemp3 = (34603 * lCb4) >> COLOR_CONV_PRECISION; |
|
59568 |
|
59569 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
59570 lY1 -= 16; |
|
59571 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59572 |
|
59573 lTemp = lY1 + lTemp1; |
|
59574 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59575 |
|
59576 lTemp = lY1 - lTemp2; |
|
59577 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59578 |
|
59579 lTemp = lY1 + lTemp3; |
|
59580 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59581 |
|
59582 |
|
59583 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
59584 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
59585 |
|
59586 lCr2 = lCrPtr[((k + lLumWidth) >> 1) + 1]; |
|
59587 lCb2 = lCbPtr[((k + lLumWidth) >> 1) + 1]; |
|
59588 |
|
59589 lCr2 = (lCr1 + lCr2) >> 1; |
|
59590 lCb2 = (lCb1 + lCb2) >> 1; |
|
59591 |
|
59592 /*Fifth Pixel*/ |
|
59593 lCr1 -= 128; |
|
59594 lCb1 -= 128; |
|
59595 |
|
59596 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
59597 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
59598 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
59599 |
|
59600 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
59601 lY1 -= 16; |
|
59602 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59603 |
|
59604 lTemp = lY1 + lTemp1; |
|
59605 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59606 |
|
59607 lTemp = lY1 - lTemp2; |
|
59608 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59609 |
|
59610 lTemp = lY1 + lTemp3; |
|
59611 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59612 |
|
59613 /*Sixth Pixel*/ |
|
59614 lCr2 -= 128; |
|
59615 lCb2 -= 128; |
|
59616 |
|
59617 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
59618 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
59619 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
59620 |
|
59621 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
59622 lY1 -= 16; |
|
59623 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59624 |
|
59625 lTemp = lY1 + lTemp1; |
|
59626 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59627 |
|
59628 lTemp = lY1 - lTemp2; |
|
59629 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59630 |
|
59631 lTemp = lY1 + lTemp3; |
|
59632 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59633 |
|
59634 src1 += 6; |
|
59635 src2 += 6; |
|
59636 } |
|
59637 |
|
59638 lCr1 = lCrPtr[k >> 1]; |
|
59639 lCb1 = lCbPtr[k >> 1]; |
|
59640 |
|
59641 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
59642 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
59643 |
|
59644 lCr4 = (lCr1 + lCr3) >> 1; |
|
59645 lCb4 = (lCb1 + lCb3) >> 1; |
|
59646 |
|
59647 lCr1 -= 128; |
|
59648 lCb1 -= 128; |
|
59649 |
|
59650 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
59651 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
59652 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
59653 |
|
59654 /*First Pixel*/ |
|
59655 lY1 = lLumPtr[k]; |
|
59656 lY1 -= 16; |
|
59657 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59658 |
|
59659 lTemp = lY1 + lTemp1; |
|
59660 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59661 |
|
59662 lTemp = lY1 - lTemp2; |
|
59663 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59664 |
|
59665 lTemp = lY1 + lTemp3; |
|
59666 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59667 |
|
59668 /*Second Pixel*/ |
|
59669 lY1 = lLumPtr[k + 1]; |
|
59670 lY1 -= 16; |
|
59671 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59672 |
|
59673 lTemp = lY1 + lTemp1; |
|
59674 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59675 |
|
59676 lTemp = lY1 - lTemp2; |
|
59677 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59678 |
|
59679 lTemp = lY1 + lTemp3; |
|
59680 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59681 |
|
59682 |
|
59683 lCr4 -= 128; |
|
59684 lCb4 -= 128; |
|
59685 |
|
59686 lTemp1 = (29374 * lCr4) >> COLOR_CONV_PRECISION; |
|
59687 lTemp2 = ((3494 * lCb4) + (8731 * lCr4)) >> COLOR_CONV_PRECISION; |
|
59688 lTemp3 = (34603 * lCb4) >> COLOR_CONV_PRECISION; |
|
59689 |
|
59690 /*Third Pixel*/ |
|
59691 lY1 = lLumPtr[k + lLumWidth]; |
|
59692 lY1 -= 16; |
|
59693 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59694 |
|
59695 lTemp = lY1 + lTemp1; |
|
59696 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59697 |
|
59698 lTemp = lY1 - lTemp2; |
|
59699 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59700 |
|
59701 lTemp = lY1 + lTemp3; |
|
59702 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59703 |
|
59704 /*Fourth Pixel*/ |
|
59705 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
59706 lY1 -= 16; |
|
59707 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59708 |
|
59709 lTemp = lY1 + lTemp1; |
|
59710 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59711 |
|
59712 lTemp = lY1 - lTemp2; |
|
59713 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59714 |
|
59715 lTemp = lY1 + lTemp3; |
|
59716 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59717 |
|
59718 |
|
59719 lCr3 -= 128; |
|
59720 lCb3 -= 128; |
|
59721 |
|
59722 lTemp1 = (29374 * lCr3) >> COLOR_CONV_PRECISION; |
|
59723 lTemp2 = ((3494 * lCb3) + (8731 * lCr3)) >> COLOR_CONV_PRECISION; |
|
59724 lTemp3 = (34603 * lCb3) >> COLOR_CONV_PRECISION; |
|
59725 |
|
59726 /*Fifth Pixel*/ |
|
59727 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
59728 lY1 -= 16; |
|
59729 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59730 |
|
59731 lTemp = lY1 + lTemp1; |
|
59732 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59733 |
|
59734 lTemp = lY1 - lTemp2; |
|
59735 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59736 |
|
59737 lTemp = lY1 + lTemp3; |
|
59738 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59739 |
|
59740 /*Sixth Pixel*/ |
|
59741 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
59742 lY1 -= 16; |
|
59743 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59744 |
|
59745 lTemp = lY1 + lTemp1; |
|
59746 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59747 |
|
59748 lTemp = lY1 - lTemp2; |
|
59749 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59750 |
|
59751 lTemp = lY1 + lTemp3; |
|
59752 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59753 |
|
59754 src1 += 6; |
|
59755 src2 += 6; |
|
59756 |
|
59757 |
|
59758 src1 = lPtr1; |
|
59759 src2 = lPtr2; |
|
59760 |
|
59761 for(j = 0; j < lWidth; j += 2) |
|
59762 { |
|
59763 /* First Pixel */ |
|
59764 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
59765 diff1 = *src1 & 0x7; |
|
59766 diff2 = *(src1 + 1) & 0x3; |
|
59767 diff3 = *(src1 + 2) & 0x7; |
|
59768 |
|
59769 // diffuse the error |
|
59770 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
59771 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
59772 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
59773 |
|
59774 /* Second Pixel */ |
|
59775 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
59776 diff1 = *(src1 + 3) & 0x7; |
|
59777 diff2 = *(src1 + 4) & 0x3; |
|
59778 diff3 = *(src1 + 5) & 0x7; |
|
59779 // diffuse the error |
|
59780 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
59781 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
59782 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
59783 |
|
59784 src1 += 6; |
|
59785 dest1 += 2; |
|
59786 |
|
59787 /* Third Pixel */ |
|
59788 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
59789 diff1 = *src2 & 0x7; |
|
59790 diff2 = *(src2 + 1) & 0x3; |
|
59791 diff3 = *(src2 + 2) & 0x7; |
|
59792 //diffuse the error |
|
59793 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
59794 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
59795 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
59796 |
|
59797 /* Fourth Pixel */ |
|
59798 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
59799 diff1 = *(src2 + 3) & 0x7; |
|
59800 diff2 = *(src2 + 4) & 0x3; |
|
59801 diff3 = *(src2 + 5) & 0x7; |
|
59802 //diffuse the error |
|
59803 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
59804 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
59805 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
59806 |
|
59807 src2 += 6; |
|
59808 dest2 += 2; |
|
59809 } |
|
59810 if(extraCol) |
|
59811 { |
|
59812 *dest1 = dest1[-1]; |
|
59813 dest1++; |
|
59814 *dest2 = dest2[-1]; |
|
59815 dest2++; |
|
59816 } |
|
59817 |
|
59818 lLumPtr += (lLumWidth << 1); |
|
59819 lCrPtr += (lLumWidth >> 1); |
|
59820 lCbPtr += (lLumWidth >> 1); |
|
59821 |
|
59822 dest1 += ((wndWidth << 1) - lTempWidth); |
|
59823 dest2 += ((wndWidth << 1) - lTempWidth); |
|
59824 } |
|
59825 |
|
59826 |
|
59827 lPtr1 = src1 = lBuffer; |
|
59828 lPtr2 = src2 = src1 + lSrcWidth; |
|
59829 |
|
59830 for(k = 0; k < (lWidth - 2); k += 2) |
|
59831 { |
|
59832 lCr1 = lCrPtr[k >> 1]; |
|
59833 lCb1 = lCbPtr[k >> 1]; |
|
59834 |
|
59835 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
59836 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
59837 |
|
59838 lCr2 = (lCr1 + lCr2) >> 1; |
|
59839 lCb2 = (lCb1 + lCb2) >> 1; |
|
59840 |
|
59841 |
|
59842 lCr1 -= 128; |
|
59843 lCb1 -= 128; |
|
59844 |
|
59845 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
59846 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
59847 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
59848 |
|
59849 /*First Pixel*/ |
|
59850 lY1 = lLumPtr[k]; |
|
59851 lY1 -= 16; |
|
59852 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59853 |
|
59854 lTemp = lY1 + lTemp1; |
|
59855 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59856 |
|
59857 lTemp = lY1 - lTemp2; |
|
59858 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59859 |
|
59860 lTemp = lY1 + lTemp3; |
|
59861 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59862 |
|
59863 /*Third Pixel*/ |
|
59864 lY1 = lLumPtr[k + lLumWidth]; |
|
59865 lY1 -= 16; |
|
59866 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59867 |
|
59868 lTemp = lY1 + lTemp1; |
|
59869 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59870 |
|
59871 lTemp = lY1 - lTemp2; |
|
59872 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59873 |
|
59874 lTemp = lY1 + lTemp3; |
|
59875 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59876 |
|
59877 |
|
59878 lCr2 -= 128; |
|
59879 lCb2 -= 128; |
|
59880 |
|
59881 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
59882 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
59883 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
59884 |
|
59885 /*Second Pixel*/ |
|
59886 lY1 = lLumPtr[k + 1]; |
|
59887 lY1 -= 16; |
|
59888 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59889 |
|
59890 lTemp = lY1 + lTemp1; |
|
59891 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59892 |
|
59893 lTemp = lY1 - lTemp2; |
|
59894 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59895 |
|
59896 lTemp = lY1 + lTemp3; |
|
59897 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59898 |
|
59899 /*Fourth Pixel*/ |
|
59900 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
59901 lY1 -= 16; |
|
59902 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59903 |
|
59904 lTemp = lY1 + lTemp1; |
|
59905 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59906 |
|
59907 lTemp = lY1 - lTemp2; |
|
59908 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59909 |
|
59910 lTemp = lY1 + lTemp3; |
|
59911 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59912 |
|
59913 src1 += 6; |
|
59914 src2 += 6; |
|
59915 } |
|
59916 |
|
59917 lCr1 = lCrPtr[k >> 1]; |
|
59918 lCb1 = lCbPtr[k >> 1]; |
|
59919 |
|
59920 lCr1 -= 128; |
|
59921 lCb1 -= 128; |
|
59922 |
|
59923 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
59924 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
59925 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
59926 |
|
59927 /*First Pixel*/ |
|
59928 lY1 = lLumPtr[k]; |
|
59929 lY1 -= 16; |
|
59930 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59931 |
|
59932 lTemp = lY1 + lTemp1; |
|
59933 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59934 |
|
59935 lTemp = lY1 - lTemp2; |
|
59936 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59937 |
|
59938 lTemp = lY1 + lTemp3; |
|
59939 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59940 |
|
59941 /*Second Pixel*/ |
|
59942 lY1 = lLumPtr[k + 1]; |
|
59943 lY1 -= 16; |
|
59944 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59945 |
|
59946 lTemp = lY1 + lTemp1; |
|
59947 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59948 |
|
59949 lTemp = lY1 - lTemp2; |
|
59950 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59951 |
|
59952 lTemp = lY1 + lTemp3; |
|
59953 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59954 |
|
59955 /*Third Pixel*/ |
|
59956 lY1 = lLumPtr[k + lLumWidth]; |
|
59957 lY1 -= 16; |
|
59958 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59959 |
|
59960 lTemp = lY1 + lTemp1; |
|
59961 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59962 |
|
59963 lTemp = lY1 - lTemp2; |
|
59964 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59965 |
|
59966 lTemp = lY1 + lTemp3; |
|
59967 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59968 |
|
59969 /*Fourth Pixel*/ |
|
59970 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
59971 lY1 -= 16; |
|
59972 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
59973 |
|
59974 lTemp = lY1 + lTemp1; |
|
59975 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59976 |
|
59977 lTemp = lY1 - lTemp2; |
|
59978 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59979 |
|
59980 lTemp = lY1 + lTemp3; |
|
59981 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
59982 |
|
59983 src1 += 6; |
|
59984 src2 += 6; |
|
59985 |
|
59986 |
|
59987 src1 = lPtr1; |
|
59988 src2 = lPtr2; |
|
59989 |
|
59990 for(j = 0; j < lWidth; j += 2) |
|
59991 { |
|
59992 /* First Pixel */ |
|
59993 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
59994 diff1 = *src1 & 0x7; |
|
59995 diff2 = *(src1 + 1) & 0x3; |
|
59996 diff3 = *(src1 + 2) & 0x7; |
|
59997 |
|
59998 // diffuse the error |
|
59999 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
60000 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
60001 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
60002 |
|
60003 /* Second Pixel */ |
|
60004 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
60005 diff1 = *(src1 + 3) & 0x7; |
|
60006 diff2 = *(src1 + 4) & 0x3; |
|
60007 diff3 = *(src1 + 5) & 0x7; |
|
60008 // diffuse the error |
|
60009 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
60010 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
60011 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
60012 |
|
60013 src1 += 6; |
|
60014 dest1 += 2; |
|
60015 |
|
60016 /* Third Pixel */ |
|
60017 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
60018 diff1 = *src2 & 0x7; |
|
60019 diff2 = *(src2 + 1) & 0x3; |
|
60020 diff3 = *(src2 + 2) & 0x7; |
|
60021 //diffuse the error |
|
60022 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
60023 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
60024 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
60025 |
|
60026 /* Fourth Pixel */ |
|
60027 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
60028 diff1 = *(src2 + 3) & 0x7; |
|
60029 diff2 = *(src2 + 4) & 0x3; |
|
60030 diff3 = *(src2 + 5) & 0x7; |
|
60031 //diffuse the error |
|
60032 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
60033 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
60034 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
60035 |
|
60036 src2 += 6; |
|
60037 dest2 += 2; |
|
60038 } |
|
60039 |
|
60040 if(extraCol) |
|
60041 { |
|
60042 *dest1 = dest1[-1]; |
|
60043 dest1++; |
|
60044 *dest2 = dest2[-1]; |
|
60045 dest2++; |
|
60046 } |
|
60047 |
|
60048 dest1 += ((wndWidth << 1) - lTempWidth); |
|
60049 dest2 += ((wndWidth << 1) - lTempWidth); |
|
60050 |
|
60051 if(extraRow) |
|
60052 { |
|
60053 dest2 = dest1 - wndWidth; |
|
60054 for(j = 0; j < lWidth; j += 2) |
|
60055 { |
|
60056 *dest1++ = *dest2++; |
|
60057 *dest1++ = *dest2++; |
|
60058 } |
|
60059 if(extraCol) |
|
60060 { |
|
60061 *dest1 = *dest2; |
|
60062 } |
|
60063 } |
|
60064 |
|
60065 free(lBuffer); |
|
60066 return; |
|
60067 } |
|
60068 |
|
60069 /* |
|
60070 ****************************************************************************** |
|
60071 Name : sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_601_5_RR |
|
60072 Description : Converts YUV420 Chroma3 Planar to RGB565 Interleaved format |
|
60073 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
60074 uint8 *dstImage : Pointer to rgb data (o/p). |
|
60075 tWndParam *srcWindow : Pointer to structure containing source window |
|
60076 parameters like xOffset,yOffset,cropWidth, |
|
60077 cropHeight. (i/p) |
|
60078 tWndParam *dstWindow : Pointer to structure containing destination window |
|
60079 parameters like xOffset,yOffset,windWidth, |
|
60080 windHeight. (i/p) |
|
60081 Return Value : void |
|
60082 ****************************************************************************** |
|
60083 */ |
|
60084 |
|
60085 void sEmz_VDec_YUV420Chr3toColor64k_ErrDiff_601_5_RR |
|
60086 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
60087 tWndParam* srcWindow, tWndParam* dstWindow) |
|
60088 { |
|
60089 uint16 *dest1, *dest2; |
|
60090 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
60091 uint8 *lBuffer; |
|
60092 uint8 *src1, *src2; |
|
60093 uint8 *lPtr1, *lPtr2; |
|
60094 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
60095 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
60096 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
60097 int32 diff1, diff2, diff3; |
|
60098 int32 i, j, k, extraRow, extraCol; |
|
60099 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
60100 cropWidth,cropHeight,wndWidth,wndHeight; |
|
60101 |
|
60102 srcXOffset = srcWindow->xOffset; |
|
60103 srcYOffset = srcWindow->yOffset; |
|
60104 cropWidth = srcWindow->wndWidth; |
|
60105 cropHeight = srcWindow->wndHeight; |
|
60106 |
|
60107 dstXOffset = dstWindow->xOffset; |
|
60108 dstYOffset = dstWindow->yOffset; |
|
60109 wndWidth = dstWindow->wndWidth; |
|
60110 wndHeight = dstWindow->wndHeight; |
|
60111 |
|
60112 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
60113 { |
|
60114 lWidth = cropWidth; |
|
60115 } |
|
60116 else |
|
60117 { |
|
60118 lWidth = srcImage->width - srcXOffset; |
|
60119 } |
|
60120 |
|
60121 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
60122 { |
|
60123 lHeight = cropHeight; |
|
60124 } |
|
60125 else |
|
60126 { |
|
60127 lHeight = srcImage->height - srcYOffset; |
|
60128 } |
|
60129 |
|
60130 if (lWidth > (wndWidth - dstXOffset)) |
|
60131 { |
|
60132 lWidth = wndWidth - dstXOffset; |
|
60133 } |
|
60134 |
|
60135 if (lHeight > (wndHeight - dstYOffset)) |
|
60136 { |
|
60137 lHeight = wndHeight - dstYOffset; |
|
60138 } |
|
60139 |
|
60140 extraCol = lWidth & 0x01; |
|
60141 extraRow = lHeight & 0x01; |
|
60142 |
|
60143 lTempWidth = lWidth; |
|
60144 lWidth = (lWidth >> 1) << 1; |
|
60145 lHeight = (lHeight >> 1) << 1; |
|
60146 |
|
60147 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
60148 |
|
60149 lSrcWidth = lWidth * 3; |
|
60150 |
|
60151 lLumWidth = (srcImage->width >> 1) << 1; |
|
60152 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
60153 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
60154 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
60155 |
|
60156 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
60157 dest2 = dest1 + wndWidth; |
|
60158 |
|
60159 for(i = 0; i < (lHeight - 2); i += 2) |
|
60160 { |
|
60161 lPtr1 = src1 = lBuffer; |
|
60162 lPtr2 = src2 = src1 + lSrcWidth; |
|
60163 |
|
60164 for(k = 0; k < (lWidth - 2); k += 2) |
|
60165 { |
|
60166 lCr1 = lCrPtr[k >> 1]; |
|
60167 lCb1 = lCbPtr[k >> 1]; |
|
60168 |
|
60169 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
60170 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
60171 |
|
60172 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
60173 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
60174 |
|
60175 lCr4 = lCrPtr[((k + lLumWidth)>> 1) + 1]; |
|
60176 lCb4 = lCbPtr[((k + lLumWidth)>> 1) + 1]; |
|
60177 |
|
60178 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
60179 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
60180 |
|
60181 lCr2 = (lCr1 + lCr2) >> 1; |
|
60182 lCb2 = (lCb1 + lCb2) >> 1; |
|
60183 |
|
60184 lCr3 = (lCr1 + lCr3) >> 1; |
|
60185 lCb3 = (lCb1 + lCb3) >> 1; |
|
60186 |
|
60187 /*First Pixel*/ |
|
60188 lCr1 -= 128; |
|
60189 lCb1 -= 128; |
|
60190 |
|
60191 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
60192 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
60193 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
60194 |
|
60195 lY1 = lLumPtr[k]; |
|
60196 lY1 -= 16; |
|
60197 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60198 |
|
60199 lTemp = lY1 + lTemp1; |
|
60200 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60201 |
|
60202 lTemp = lY1 - lTemp2; |
|
60203 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60204 |
|
60205 lTemp = lY1 + lTemp3; |
|
60206 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60207 |
|
60208 /*Second Pixel*/ |
|
60209 lCr2 -= 128; |
|
60210 lCb2 -= 128; |
|
60211 |
|
60212 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
60213 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
60214 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
60215 |
|
60216 lY1 = lLumPtr[k + 1]; |
|
60217 lY1 -= 16; |
|
60218 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60219 |
|
60220 lTemp = lY1 + lTemp1; |
|
60221 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60222 |
|
60223 lTemp = lY1 - lTemp2; |
|
60224 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60225 |
|
60226 lTemp = lY1 + lTemp3; |
|
60227 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60228 |
|
60229 |
|
60230 /*Third Pixel*/ |
|
60231 lCr3 -= 128; |
|
60232 lCb3 -= 128; |
|
60233 |
|
60234 lTemp1 = (26748 * lCr3) >> COLOR_CONV_PRECISION; |
|
60235 lTemp2 = ((6563 * lCb3) + (13621 * lCr3)) >> COLOR_CONV_PRECISION; |
|
60236 lTemp3 = (33802 * lCb3) >> COLOR_CONV_PRECISION; |
|
60237 |
|
60238 lY1 = lLumPtr[k + lLumWidth]; |
|
60239 lY1 -= 16; |
|
60240 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60241 |
|
60242 lTemp = lY1 + lTemp1; |
|
60243 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60244 |
|
60245 lTemp = lY1 - lTemp2; |
|
60246 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60247 |
|
60248 lTemp = lY1 + lTemp3; |
|
60249 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60250 |
|
60251 /*Fourth Pixel*/ |
|
60252 lCr4 -= 128; |
|
60253 lCb4 -= 128; |
|
60254 |
|
60255 lTemp1 = (26748 * lCr4) >> COLOR_CONV_PRECISION; |
|
60256 lTemp2 = ((6563 * lCb4) + (13621 * lCr4)) >> COLOR_CONV_PRECISION; |
|
60257 lTemp3 = (33802 * lCb4) >> COLOR_CONV_PRECISION; |
|
60258 |
|
60259 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
60260 lY1 -= 16; |
|
60261 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60262 |
|
60263 lTemp = lY1 + lTemp1; |
|
60264 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60265 |
|
60266 lTemp = lY1 - lTemp2; |
|
60267 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60268 |
|
60269 lTemp = lY1 + lTemp3; |
|
60270 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60271 |
|
60272 |
|
60273 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
60274 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
60275 |
|
60276 lCr2 = lCrPtr[((k + lLumWidth) >> 1) + 1]; |
|
60277 lCb2 = lCbPtr[((k + lLumWidth) >> 1) + 1]; |
|
60278 |
|
60279 lCr2 = (lCr1 + lCr2) >> 1; |
|
60280 lCb2 = (lCb1 + lCb2) >> 1; |
|
60281 |
|
60282 /*Fifth Pixel*/ |
|
60283 lCr1 -= 128; |
|
60284 lCb1 -= 128; |
|
60285 |
|
60286 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
60287 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
60288 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
60289 |
|
60290 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
60291 lY1 -= 16; |
|
60292 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60293 |
|
60294 lTemp = lY1 + lTemp1; |
|
60295 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60296 |
|
60297 lTemp = lY1 - lTemp2; |
|
60298 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60299 |
|
60300 lTemp = lY1 + lTemp3; |
|
60301 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60302 |
|
60303 /*Sixth Pixel*/ |
|
60304 lCr2 -= 128; |
|
60305 lCb2 -= 128; |
|
60306 |
|
60307 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
60308 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
60309 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
60310 |
|
60311 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
60312 lY1 -= 16; |
|
60313 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60314 |
|
60315 lTemp = lY1 + lTemp1; |
|
60316 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60317 |
|
60318 lTemp = lY1 - lTemp2; |
|
60319 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60320 |
|
60321 lTemp = lY1 + lTemp3; |
|
60322 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60323 |
|
60324 src1 += 6; |
|
60325 src2 += 6; |
|
60326 } |
|
60327 |
|
60328 lCr1 = lCrPtr[k >> 1]; |
|
60329 lCb1 = lCbPtr[k >> 1]; |
|
60330 |
|
60331 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
60332 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
60333 |
|
60334 lCr4 = (lCr1 + lCr3) >> 1; |
|
60335 lCb4 = (lCb1 + lCb3) >> 1; |
|
60336 |
|
60337 lCr1 -= 128; |
|
60338 lCb1 -= 128; |
|
60339 |
|
60340 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
60341 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
60342 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
60343 |
|
60344 /*First Pixel*/ |
|
60345 lY1 = lLumPtr[k]; |
|
60346 lY1 -= 16; |
|
60347 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60348 |
|
60349 lTemp = lY1 + lTemp1; |
|
60350 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60351 |
|
60352 lTemp = lY1 - lTemp2; |
|
60353 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60354 |
|
60355 lTemp = lY1 + lTemp3; |
|
60356 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60357 |
|
60358 /*Second Pixel*/ |
|
60359 lY1 = lLumPtr[k + 1]; |
|
60360 lY1 -= 16; |
|
60361 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60362 |
|
60363 lTemp = lY1 + lTemp1; |
|
60364 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60365 |
|
60366 lTemp = lY1 - lTemp2; |
|
60367 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60368 |
|
60369 lTemp = lY1 + lTemp3; |
|
60370 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60371 |
|
60372 |
|
60373 lCr4 -= 128; |
|
60374 lCb4 -= 128; |
|
60375 |
|
60376 lTemp1 = (26748 * lCr4) >> COLOR_CONV_PRECISION; |
|
60377 lTemp2 = ((6563 * lCb4) + (13621 * lCr4)) >> COLOR_CONV_PRECISION; |
|
60378 lTemp3 = (33802 * lCb4) >> COLOR_CONV_PRECISION; |
|
60379 |
|
60380 /*Third Pixel*/ |
|
60381 lY1 = lLumPtr[k + lLumWidth]; |
|
60382 lY1 -= 16; |
|
60383 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60384 |
|
60385 lTemp = lY1 + lTemp1; |
|
60386 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60387 |
|
60388 lTemp = lY1 - lTemp2; |
|
60389 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60390 |
|
60391 lTemp = lY1 + lTemp3; |
|
60392 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60393 |
|
60394 /*Fourth Pixel*/ |
|
60395 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
60396 lY1 -= 16; |
|
60397 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60398 |
|
60399 lTemp = lY1 + lTemp1; |
|
60400 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60401 |
|
60402 lTemp = lY1 - lTemp2; |
|
60403 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60404 |
|
60405 lTemp = lY1 + lTemp3; |
|
60406 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60407 |
|
60408 |
|
60409 lCr3 -= 128; |
|
60410 lCb3 -= 128; |
|
60411 |
|
60412 lTemp1 = (26748 * lCr3) >> COLOR_CONV_PRECISION; |
|
60413 lTemp2 = ((6563 * lCb3) + (13621 * lCr3)) >> COLOR_CONV_PRECISION; |
|
60414 lTemp3 = (33802 * lCb3) >> COLOR_CONV_PRECISION; |
|
60415 |
|
60416 /*Fifth Pixel*/ |
|
60417 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
60418 lY1 -= 16; |
|
60419 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60420 |
|
60421 lTemp = lY1 + lTemp1; |
|
60422 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60423 |
|
60424 lTemp = lY1 - lTemp2; |
|
60425 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60426 |
|
60427 lTemp = lY1 + lTemp3; |
|
60428 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60429 |
|
60430 /*Sixth Pixel*/ |
|
60431 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
60432 lY1 -= 16; |
|
60433 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60434 |
|
60435 lTemp = lY1 + lTemp1; |
|
60436 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60437 |
|
60438 lTemp = lY1 - lTemp2; |
|
60439 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60440 |
|
60441 lTemp = lY1 + lTemp3; |
|
60442 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60443 |
|
60444 src1 += 6; |
|
60445 src2 += 6; |
|
60446 |
|
60447 |
|
60448 src1 = lPtr1; |
|
60449 src2 = lPtr2; |
|
60450 |
|
60451 for(j = 0; j < lWidth; j += 2) |
|
60452 { |
|
60453 /* First Pixel */ |
|
60454 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
60455 diff1 = *src1 & 0x7; |
|
60456 diff2 = *(src1 + 1) & 0x3; |
|
60457 diff3 = *(src1 + 2) & 0x7; |
|
60458 |
|
60459 // diffuse the error |
|
60460 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
60461 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
60462 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
60463 |
|
60464 /* Second Pixel */ |
|
60465 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
60466 diff1 = *(src1 + 3) & 0x7; |
|
60467 diff2 = *(src1 + 4) & 0x3; |
|
60468 diff3 = *(src1 + 5) & 0x7; |
|
60469 // diffuse the error |
|
60470 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
60471 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
60472 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
60473 |
|
60474 src1 += 6; |
|
60475 dest1 += 2; |
|
60476 |
|
60477 /* Third Pixel */ |
|
60478 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
60479 diff1 = *src2 & 0x7; |
|
60480 diff2 = *(src2 + 1) & 0x3; |
|
60481 diff3 = *(src2 + 2) & 0x7; |
|
60482 //diffuse the error |
|
60483 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
60484 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
60485 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
60486 |
|
60487 /* Fourth Pixel */ |
|
60488 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
60489 diff1 = *(src2 + 3) & 0x7; |
|
60490 diff2 = *(src2 + 4) & 0x3; |
|
60491 diff3 = *(src2 + 5) & 0x7; |
|
60492 //diffuse the error |
|
60493 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
60494 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
60495 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
60496 |
|
60497 src2 += 6; |
|
60498 dest2 += 2; |
|
60499 } |
|
60500 if(extraCol) |
|
60501 { |
|
60502 *dest1 = dest1[-1]; |
|
60503 dest1++; |
|
60504 *dest2 = dest2[-1]; |
|
60505 dest2++; |
|
60506 } |
|
60507 |
|
60508 lLumPtr += (lLumWidth << 1); |
|
60509 lCrPtr += (lLumWidth >> 1); |
|
60510 lCbPtr += (lLumWidth >> 1); |
|
60511 |
|
60512 dest1 += ((wndWidth << 1) - lTempWidth); |
|
60513 dest2 += ((wndWidth << 1) - lTempWidth); |
|
60514 } |
|
60515 |
|
60516 |
|
60517 lPtr1 = src1 = lBuffer; |
|
60518 lPtr2 = src2 = src1 + lSrcWidth; |
|
60519 |
|
60520 for(k = 0; k < (lWidth - 2); k += 2) |
|
60521 { |
|
60522 lCr1 = lCrPtr[k >> 1]; |
|
60523 lCb1 = lCbPtr[k >> 1]; |
|
60524 |
|
60525 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
60526 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
60527 |
|
60528 lCr2 = (lCr1 + lCr2) >> 1; |
|
60529 lCb2 = (lCb1 + lCb2) >> 1; |
|
60530 |
|
60531 |
|
60532 lCr1 -= 128; |
|
60533 lCb1 -= 128; |
|
60534 |
|
60535 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
60536 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
60537 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
60538 |
|
60539 /*First Pixel*/ |
|
60540 lY1 = lLumPtr[k]; |
|
60541 lY1 -= 16; |
|
60542 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60543 |
|
60544 lTemp = lY1 + lTemp1; |
|
60545 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60546 |
|
60547 lTemp = lY1 - lTemp2; |
|
60548 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60549 |
|
60550 lTemp = lY1 + lTemp3; |
|
60551 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60552 |
|
60553 /*Third Pixel*/ |
|
60554 lY1 = lLumPtr[k + lLumWidth]; |
|
60555 lY1 -= 16; |
|
60556 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60557 |
|
60558 lTemp = lY1 + lTemp1; |
|
60559 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60560 |
|
60561 lTemp = lY1 - lTemp2; |
|
60562 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60563 |
|
60564 lTemp = lY1 + lTemp3; |
|
60565 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60566 |
|
60567 |
|
60568 lCr2 -= 128; |
|
60569 lCb2 -= 128; |
|
60570 |
|
60571 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
60572 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
60573 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
60574 |
|
60575 /*Second Pixel*/ |
|
60576 lY1 = lLumPtr[k + 1]; |
|
60577 lY1 -= 16; |
|
60578 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60579 |
|
60580 lTemp = lY1 + lTemp1; |
|
60581 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60582 |
|
60583 lTemp = lY1 - lTemp2; |
|
60584 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60585 |
|
60586 lTemp = lY1 + lTemp3; |
|
60587 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60588 |
|
60589 /*Fourth Pixel*/ |
|
60590 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
60591 lY1 -= 16; |
|
60592 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60593 |
|
60594 lTemp = lY1 + lTemp1; |
|
60595 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60596 |
|
60597 lTemp = lY1 - lTemp2; |
|
60598 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60599 |
|
60600 lTemp = lY1 + lTemp3; |
|
60601 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60602 |
|
60603 src1 += 6; |
|
60604 src2 += 6; |
|
60605 } |
|
60606 |
|
60607 lCr1 = lCrPtr[k >> 1]; |
|
60608 lCb1 = lCbPtr[k >> 1]; |
|
60609 |
|
60610 lCr1 -= 128; |
|
60611 lCb1 -= 128; |
|
60612 |
|
60613 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
60614 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
60615 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
60616 |
|
60617 /*First Pixel*/ |
|
60618 lY1 = lLumPtr[k]; |
|
60619 lY1 -= 16; |
|
60620 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60621 |
|
60622 lTemp = lY1 + lTemp1; |
|
60623 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60624 |
|
60625 lTemp = lY1 - lTemp2; |
|
60626 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60627 |
|
60628 lTemp = lY1 + lTemp3; |
|
60629 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60630 |
|
60631 /*Second Pixel*/ |
|
60632 lY1 = lLumPtr[k + 1]; |
|
60633 lY1 -= 16; |
|
60634 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60635 |
|
60636 lTemp = lY1 + lTemp1; |
|
60637 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60638 |
|
60639 lTemp = lY1 - lTemp2; |
|
60640 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60641 |
|
60642 lTemp = lY1 + lTemp3; |
|
60643 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60644 |
|
60645 /*Third Pixel*/ |
|
60646 lY1 = lLumPtr[k + lLumWidth]; |
|
60647 lY1 -= 16; |
|
60648 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60649 |
|
60650 lTemp = lY1 + lTemp1; |
|
60651 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60652 |
|
60653 lTemp = lY1 - lTemp2; |
|
60654 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60655 |
|
60656 lTemp = lY1 + lTemp3; |
|
60657 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60658 |
|
60659 /*Fourth Pixel*/ |
|
60660 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
60661 lY1 -= 16; |
|
60662 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
60663 |
|
60664 lTemp = lY1 + lTemp1; |
|
60665 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60666 |
|
60667 lTemp = lY1 - lTemp2; |
|
60668 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60669 |
|
60670 lTemp = lY1 + lTemp3; |
|
60671 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
60672 |
|
60673 src1 += 6; |
|
60674 src2 += 6; |
|
60675 |
|
60676 |
|
60677 src1 = lPtr1; |
|
60678 src2 = lPtr2; |
|
60679 |
|
60680 for(j = 0; j < lWidth; j += 2) |
|
60681 { |
|
60682 /* First Pixel */ |
|
60683 *dest1 = (uint16) (*(src1 + 2) >> 3 | (*(src1 + 1) >> 2) << 5 | (*src1 >> 3) << 11); |
|
60684 diff1 = *src1 & 0x7; |
|
60685 diff2 = *(src1 + 1) & 0x3; |
|
60686 diff3 = *(src1 + 2) & 0x7; |
|
60687 |
|
60688 // diffuse the error |
|
60689 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
60690 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
60691 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
60692 |
|
60693 /* Second Pixel */ |
|
60694 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 3 | (*(src1 + 4) >> 2) << 5 | (*(src1 + 3) >> 3) << 11); |
|
60695 diff1 = *(src1 + 3) & 0x7; |
|
60696 diff2 = *(src1 + 4) & 0x3; |
|
60697 diff3 = *(src1 + 5) & 0x7; |
|
60698 // diffuse the error |
|
60699 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
60700 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
60701 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
60702 |
|
60703 src1 += 6; |
|
60704 dest1 += 2; |
|
60705 |
|
60706 /* Third Pixel */ |
|
60707 *dest2 = (uint16) (*(src2 + 2) >> 3 | (*(src2 + 1) >> 2) << 5 | (*src2 >> 3) << 11); |
|
60708 diff1 = *src2 & 0x7; |
|
60709 diff2 = *(src2 + 1) & 0x3; |
|
60710 diff3 = *(src2 + 2) & 0x7; |
|
60711 //diffuse the error |
|
60712 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
60713 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
60714 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
60715 |
|
60716 /* Fourth Pixel */ |
|
60717 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 3 | (*(src2 + 4) >> 2) << 5 | (*(src2 + 3) >> 3) << 11); |
|
60718 diff1 = *(src2 + 3) & 0x7; |
|
60719 diff2 = *(src2 + 4) & 0x3; |
|
60720 diff3 = *(src2 + 5) & 0x7; |
|
60721 //diffuse the error |
|
60722 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
60723 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
60724 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
60725 |
|
60726 src2 += 6; |
|
60727 dest2 += 2; |
|
60728 } |
|
60729 |
|
60730 if(extraCol) |
|
60731 { |
|
60732 *dest1 = dest1[-1]; |
|
60733 dest1++; |
|
60734 *dest2 = dest2[-1]; |
|
60735 dest2++; |
|
60736 } |
|
60737 |
|
60738 dest1 += ((wndWidth << 1) - lTempWidth); |
|
60739 dest2 += ((wndWidth << 1) - lTempWidth); |
|
60740 |
|
60741 if(extraRow) |
|
60742 { |
|
60743 dest2 = dest1 - wndWidth; |
|
60744 for(j = 0; j < lWidth; j += 2) |
|
60745 { |
|
60746 *dest1++ = *dest2++; |
|
60747 *dest1++ = *dest2++; |
|
60748 } |
|
60749 if(extraCol) |
|
60750 { |
|
60751 *dest1 = *dest2; |
|
60752 } |
|
60753 } |
|
60754 |
|
60755 free(lBuffer); |
|
60756 return; |
|
60757 } |
|
60758 |
|
60759 |
|
60760 /* |
|
60761 ****************************************************************************** |
|
60762 Name : sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_709_FR |
|
60763 Description : Converts YUV420 Chroma3 Planar to XRGB (4:4:4:4) Interleaved format |
|
60764 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
60765 uint8 *dstImage : Pointer to rgb data (o/p). |
|
60766 tWndParam *srcWindow : Pointer to structure containing source window |
|
60767 parameters like xOffset,yOffset,cropWidth, |
|
60768 cropHeight. (i/p) |
|
60769 tWndParam *dstWindow : Pointer to structure containing destination window |
|
60770 parameters like xOffset,yOffset,windWidth, |
|
60771 windHeight. (i/p) |
|
60772 Return Value : void |
|
60773 ****************************************************************************** |
|
60774 */ |
|
60775 |
|
60776 void sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_709_FR |
|
60777 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
60778 tWndParam* srcWindow, tWndParam* dstWindow) |
|
60779 { |
|
60780 uint16 *dest1, *dest2; |
|
60781 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
60782 uint8 *lBuffer; |
|
60783 uint8 *src1, *src2; |
|
60784 uint8 *lPtr1, *lPtr2; |
|
60785 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
60786 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
60787 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
60788 int32 diff1, diff2, diff3; |
|
60789 int32 i, j, k, extraRow, extraCol; |
|
60790 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
60791 cropWidth,cropHeight,wndWidth,wndHeight; |
|
60792 |
|
60793 srcXOffset = srcWindow->xOffset; |
|
60794 srcYOffset = srcWindow->yOffset; |
|
60795 cropWidth = srcWindow->wndWidth; |
|
60796 cropHeight = srcWindow->wndHeight; |
|
60797 |
|
60798 dstXOffset = dstWindow->xOffset; |
|
60799 dstYOffset = dstWindow->yOffset; |
|
60800 wndWidth = dstWindow->wndWidth; |
|
60801 wndHeight = dstWindow->wndHeight; |
|
60802 |
|
60803 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
60804 { |
|
60805 lWidth = cropWidth; |
|
60806 } |
|
60807 else |
|
60808 { |
|
60809 lWidth = srcImage->width - srcXOffset; |
|
60810 } |
|
60811 |
|
60812 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
60813 { |
|
60814 lHeight = cropHeight; |
|
60815 } |
|
60816 else |
|
60817 { |
|
60818 lHeight = srcImage->height - srcYOffset; |
|
60819 } |
|
60820 |
|
60821 if (lWidth > (wndWidth - dstXOffset)) |
|
60822 { |
|
60823 lWidth = wndWidth - dstXOffset; |
|
60824 } |
|
60825 |
|
60826 if (lHeight > (wndHeight - dstYOffset)) |
|
60827 { |
|
60828 lHeight = wndHeight - dstYOffset; |
|
60829 } |
|
60830 |
|
60831 extraCol = lWidth & 0x01; |
|
60832 extraRow = lHeight & 0x01; |
|
60833 |
|
60834 lTempWidth = lWidth; |
|
60835 lWidth = (lWidth >> 1) << 1; |
|
60836 lHeight = (lHeight >> 1) << 1; |
|
60837 |
|
60838 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
60839 |
|
60840 lSrcWidth = lWidth * 3; |
|
60841 |
|
60842 lLumWidth = (srcImage->width >> 1) << 1; |
|
60843 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
60844 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
60845 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
60846 |
|
60847 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
60848 dest2 = dest1 + wndWidth; |
|
60849 |
|
60850 for(i = 0; i < (lHeight - 2); i += 2) |
|
60851 { |
|
60852 lPtr1 = src1 = lBuffer; |
|
60853 lPtr2 = src2 = src1 + lSrcWidth; |
|
60854 |
|
60855 for(k = 0; k < (lWidth - 2); k += 2) |
|
60856 { |
|
60857 lCr1 = lCrPtr[k >> 1]; |
|
60858 lCb1 = lCbPtr[k >> 1]; |
|
60859 |
|
60860 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
60861 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
60862 |
|
60863 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
60864 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
60865 |
|
60866 lCr4 = lCrPtr[((k + lLumWidth)>> 1) + 1]; |
|
60867 lCb4 = lCbPtr[((k + lLumWidth)>> 1) + 1]; |
|
60868 |
|
60869 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
60870 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
60871 |
|
60872 lCr2 = (lCr1 + lCr2) >> 1; |
|
60873 lCb2 = (lCb1 + lCb2) >> 1; |
|
60874 |
|
60875 lCr3 = (lCr1 + lCr3) >> 1; |
|
60876 lCb3 = (lCb1 + lCb3) >> 1; |
|
60877 |
|
60878 /*First Pixel*/ |
|
60879 lCr1 -= 128; |
|
60880 lCb1 -= 128; |
|
60881 |
|
60882 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
60883 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
60884 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
60885 |
|
60886 lY1 = lLumPtr[k]; |
|
60887 |
|
60888 lTemp = lY1 + lTemp1; |
|
60889 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60890 |
|
60891 lTemp = lY1 - lTemp2; |
|
60892 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60893 |
|
60894 lTemp = lY1 + lTemp3; |
|
60895 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60896 |
|
60897 /*Second Pixel*/ |
|
60898 lCr2 -= 128; |
|
60899 lCb2 -= 128; |
|
60900 |
|
60901 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
60902 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
60903 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
60904 |
|
60905 lY1 = lLumPtr[k + 1]; |
|
60906 |
|
60907 lTemp = lY1 + lTemp1; |
|
60908 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60909 |
|
60910 lTemp = lY1 - lTemp2; |
|
60911 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60912 |
|
60913 lTemp = lY1 + lTemp3; |
|
60914 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60915 |
|
60916 |
|
60917 /*Third Pixel*/ |
|
60918 lCr3 -= 128; |
|
60919 lCb3 -= 128; |
|
60920 |
|
60921 lTemp1 = (25801 * lCr3) >> COLOR_CONV_PRECISION; |
|
60922 lTemp2 = ((3072 * lCb3) + (7670 * lCr3)) >> COLOR_CONV_PRECISION; |
|
60923 lTemp3 = (30397 * lCb3) >> COLOR_CONV_PRECISION; |
|
60924 |
|
60925 lY1 = lLumPtr[k + lLumWidth]; |
|
60926 |
|
60927 lTemp = lY1 + lTemp1; |
|
60928 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60929 |
|
60930 lTemp = lY1 - lTemp2; |
|
60931 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60932 |
|
60933 lTemp = lY1 + lTemp3; |
|
60934 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60935 |
|
60936 /*Fourth Pixel*/ |
|
60937 lCr4 -= 128; |
|
60938 lCb4 -= 128; |
|
60939 |
|
60940 lTemp1 = (25801 * lCr4) >> COLOR_CONV_PRECISION; |
|
60941 lTemp2 = ((3072 * lCb4) + (7670 * lCr4)) >> COLOR_CONV_PRECISION; |
|
60942 lTemp3 = (30397 * lCb4) >> COLOR_CONV_PRECISION; |
|
60943 |
|
60944 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
60945 |
|
60946 lTemp = lY1 + lTemp1; |
|
60947 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60948 |
|
60949 lTemp = lY1 - lTemp2; |
|
60950 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60951 |
|
60952 lTemp = lY1 + lTemp3; |
|
60953 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60954 |
|
60955 |
|
60956 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
60957 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
60958 |
|
60959 lCr2 = lCrPtr[((k + lLumWidth) >> 1) + 1]; |
|
60960 lCb2 = lCbPtr[((k + lLumWidth) >> 1) + 1]; |
|
60961 |
|
60962 lCr2 = (lCr1 + lCr2) >> 1; |
|
60963 lCb2 = (lCb1 + lCb2) >> 1; |
|
60964 |
|
60965 /*Fifth Pixel*/ |
|
60966 lCr1 -= 128; |
|
60967 lCb1 -= 128; |
|
60968 |
|
60969 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
60970 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
60971 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
60972 |
|
60973 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
60974 |
|
60975 lTemp = lY1 + lTemp1; |
|
60976 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60977 |
|
60978 lTemp = lY1 - lTemp2; |
|
60979 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60980 |
|
60981 lTemp = lY1 + lTemp3; |
|
60982 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60983 |
|
60984 /*Sixth Pixel*/ |
|
60985 lCr2 -= 128; |
|
60986 lCb2 -= 128; |
|
60987 |
|
60988 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
60989 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
60990 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
60991 |
|
60992 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
60993 |
|
60994 lTemp = lY1 + lTemp1; |
|
60995 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60996 |
|
60997 lTemp = lY1 - lTemp2; |
|
60998 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
60999 |
|
61000 lTemp = lY1 + lTemp3; |
|
61001 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61002 |
|
61003 src1 += 6; |
|
61004 src2 += 6; |
|
61005 } |
|
61006 |
|
61007 lCr1 = lCrPtr[k >> 1]; |
|
61008 lCb1 = lCbPtr[k >> 1]; |
|
61009 |
|
61010 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
61011 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
61012 |
|
61013 lCr4 = (lCr1 + lCr3) >> 1; |
|
61014 lCb4 = (lCb1 + lCb3) >> 1; |
|
61015 |
|
61016 lCr1 -= 128; |
|
61017 lCb1 -= 128; |
|
61018 |
|
61019 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
61020 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
61021 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
61022 |
|
61023 /*First Pixel*/ |
|
61024 lY1 = lLumPtr[k]; |
|
61025 |
|
61026 lTemp = lY1 + lTemp1; |
|
61027 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61028 |
|
61029 lTemp = lY1 - lTemp2; |
|
61030 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61031 |
|
61032 lTemp = lY1 + lTemp3; |
|
61033 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61034 |
|
61035 /*Second Pixel*/ |
|
61036 lY1 = lLumPtr[k + 1]; |
|
61037 |
|
61038 lTemp = lY1 + lTemp1; |
|
61039 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61040 |
|
61041 lTemp = lY1 - lTemp2; |
|
61042 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61043 |
|
61044 lTemp = lY1 + lTemp3; |
|
61045 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61046 |
|
61047 |
|
61048 lCr4 -= 128; |
|
61049 lCb4 -= 128; |
|
61050 |
|
61051 lTemp1 = (25801 * lCr4) >> COLOR_CONV_PRECISION; |
|
61052 lTemp2 = ((3072 * lCb4) + (7670 * lCr4)) >> COLOR_CONV_PRECISION; |
|
61053 lTemp3 = (30397 * lCb4) >> COLOR_CONV_PRECISION; |
|
61054 |
|
61055 /*Third Pixel*/ |
|
61056 lY1 = lLumPtr[k + lLumWidth]; |
|
61057 |
|
61058 lTemp = lY1 + lTemp1; |
|
61059 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61060 |
|
61061 lTemp = lY1 - lTemp2; |
|
61062 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61063 |
|
61064 lTemp = lY1 + lTemp3; |
|
61065 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61066 |
|
61067 /*Fourth Pixel*/ |
|
61068 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
61069 |
|
61070 lTemp = lY1 + lTemp1; |
|
61071 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61072 |
|
61073 lTemp = lY1 - lTemp2; |
|
61074 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61075 |
|
61076 lTemp = lY1 + lTemp3; |
|
61077 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61078 |
|
61079 |
|
61080 lCr3 -= 128; |
|
61081 lCb3 -= 128; |
|
61082 |
|
61083 lTemp1 = (25801 * lCr3) >> COLOR_CONV_PRECISION; |
|
61084 lTemp2 = ((3072 * lCb3) + (7670 * lCr3)) >> COLOR_CONV_PRECISION; |
|
61085 lTemp3 = (30397 * lCb3) >> COLOR_CONV_PRECISION; |
|
61086 |
|
61087 /*Fifth Pixel*/ |
|
61088 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
61089 |
|
61090 lTemp = lY1 + lTemp1; |
|
61091 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61092 |
|
61093 lTemp = lY1 - lTemp2; |
|
61094 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61095 |
|
61096 lTemp = lY1 + lTemp3; |
|
61097 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61098 |
|
61099 /*Sixth Pixel*/ |
|
61100 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
61101 |
|
61102 lTemp = lY1 + lTemp1; |
|
61103 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61104 |
|
61105 lTemp = lY1 - lTemp2; |
|
61106 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61107 |
|
61108 lTemp = lY1 + lTemp3; |
|
61109 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61110 |
|
61111 src1 += 6; |
|
61112 src2 += 6; |
|
61113 |
|
61114 |
|
61115 src1 = lPtr1; |
|
61116 src2 = lPtr2; |
|
61117 |
|
61118 for(j = 0; j < lWidth; j += 2) |
|
61119 { |
|
61120 /* First Pixel */ |
|
61121 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
61122 diff1 = *src1 & 0xf; |
|
61123 diff2 = *(src1 + 1) & 0xf; |
|
61124 diff3 = *(src1 + 2) & 0xf; |
|
61125 |
|
61126 // diffuse the error |
|
61127 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
61128 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
61129 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
61130 |
|
61131 /* Second Pixel */ |
|
61132 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
61133 diff1 = *(src1 + 3) & 0xf; |
|
61134 diff2 = *(src1 + 4) & 0xf; |
|
61135 diff3 = *(src1 + 5) & 0xf; |
|
61136 // diffuse the error |
|
61137 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
61138 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
61139 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
61140 |
|
61141 src1 += 6; |
|
61142 dest1 += 2; |
|
61143 |
|
61144 /* Third Pixel */ |
|
61145 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
61146 diff1 = *src2 & 0xf; |
|
61147 diff2 = *(src2 + 1) & 0xf; |
|
61148 diff3 = *(src2 + 2) & 0xf; |
|
61149 //diffuse the error |
|
61150 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
61151 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
61152 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
61153 |
|
61154 /* Fourth Pixel */ |
|
61155 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
61156 diff1 = *(src2 + 3) & 0xf; |
|
61157 diff2 = *(src2 + 4) & 0xf; |
|
61158 diff3 = *(src2 + 5) & 0xf; |
|
61159 //diffuse the error |
|
61160 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
61161 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
61162 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
61163 |
|
61164 src2 += 6; |
|
61165 dest2 += 2; |
|
61166 } |
|
61167 if(extraCol) |
|
61168 { |
|
61169 *dest1 = dest1[-1]; |
|
61170 dest1++; |
|
61171 *dest2 = dest2[-1]; |
|
61172 dest2++; |
|
61173 } |
|
61174 |
|
61175 lLumPtr += (lLumWidth << 1); |
|
61176 lCrPtr += (lLumWidth >> 1); |
|
61177 lCbPtr += (lLumWidth >> 1); |
|
61178 |
|
61179 dest1 += ((wndWidth << 1) - lTempWidth); |
|
61180 dest2 += ((wndWidth << 1) - lTempWidth); |
|
61181 } |
|
61182 |
|
61183 |
|
61184 lPtr1 = src1 = lBuffer; |
|
61185 lPtr2 = src2 = src1 + lSrcWidth; |
|
61186 |
|
61187 for(k = 0; k < (lWidth - 2); k += 2) |
|
61188 { |
|
61189 lCr1 = lCrPtr[k >> 1]; |
|
61190 lCb1 = lCbPtr[k >> 1]; |
|
61191 |
|
61192 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
61193 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
61194 |
|
61195 lCr2 = (lCr1 + lCr2) >> 1; |
|
61196 lCb2 = (lCb1 + lCb2) >> 1; |
|
61197 |
|
61198 |
|
61199 lCr1 -= 128; |
|
61200 lCb1 -= 128; |
|
61201 |
|
61202 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
61203 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
61204 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
61205 |
|
61206 /*First Pixel*/ |
|
61207 lY1 = lLumPtr[k]; |
|
61208 |
|
61209 lTemp = lY1 + lTemp1; |
|
61210 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61211 |
|
61212 lTemp = lY1 - lTemp2; |
|
61213 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61214 |
|
61215 lTemp = lY1 + lTemp3; |
|
61216 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61217 |
|
61218 /*Third Pixel*/ |
|
61219 lY1 = lLumPtr[k + lLumWidth]; |
|
61220 |
|
61221 lTemp = lY1 + lTemp1; |
|
61222 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61223 |
|
61224 lTemp = lY1 - lTemp2; |
|
61225 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61226 |
|
61227 lTemp = lY1 + lTemp3; |
|
61228 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61229 |
|
61230 |
|
61231 lCr2 -= 128; |
|
61232 lCb2 -= 128; |
|
61233 |
|
61234 lTemp1 = (25801 * lCr2) >> COLOR_CONV_PRECISION; |
|
61235 lTemp2 = ((3072 * lCb2) + (7670 * lCr2)) >> COLOR_CONV_PRECISION; |
|
61236 lTemp3 = (30397 * lCb2) >> COLOR_CONV_PRECISION; |
|
61237 |
|
61238 /*Second Pixel*/ |
|
61239 lY1 = lLumPtr[k + 1]; |
|
61240 |
|
61241 lTemp = lY1 + lTemp1; |
|
61242 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61243 |
|
61244 lTemp = lY1 - lTemp2; |
|
61245 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61246 |
|
61247 lTemp = lY1 + lTemp3; |
|
61248 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61249 |
|
61250 /*Fourth Pixel*/ |
|
61251 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
61252 |
|
61253 lTemp = lY1 + lTemp1; |
|
61254 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61255 |
|
61256 lTemp = lY1 - lTemp2; |
|
61257 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61258 |
|
61259 lTemp = lY1 + lTemp3; |
|
61260 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61261 |
|
61262 src1 += 6; |
|
61263 src2 += 6; |
|
61264 } |
|
61265 |
|
61266 lCr1 = lCrPtr[k >> 1]; |
|
61267 lCb1 = lCbPtr[k >> 1]; |
|
61268 |
|
61269 lCr1 -= 128; |
|
61270 lCb1 -= 128; |
|
61271 |
|
61272 lTemp1 = (25801 * lCr1) >> COLOR_CONV_PRECISION; |
|
61273 lTemp2 = ((3072 * lCb1) + (7670 * lCr1)) >> COLOR_CONV_PRECISION; |
|
61274 lTemp3 = (30397 * lCb1) >> COLOR_CONV_PRECISION; |
|
61275 |
|
61276 /*First Pixel*/ |
|
61277 lY1 = lLumPtr[k]; |
|
61278 |
|
61279 lTemp = lY1 + lTemp1; |
|
61280 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61281 |
|
61282 lTemp = lY1 - lTemp2; |
|
61283 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61284 |
|
61285 lTemp = lY1 + lTemp3; |
|
61286 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61287 |
|
61288 /*Second Pixel*/ |
|
61289 lY1 = lLumPtr[k + 1]; |
|
61290 |
|
61291 lTemp = lY1 + lTemp1; |
|
61292 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61293 |
|
61294 lTemp = lY1 - lTemp2; |
|
61295 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61296 |
|
61297 lTemp = lY1 + lTemp3; |
|
61298 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61299 |
|
61300 /*Third Pixel*/ |
|
61301 lY1 = lLumPtr[k + lLumWidth]; |
|
61302 |
|
61303 lTemp = lY1 + lTemp1; |
|
61304 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61305 |
|
61306 lTemp = lY1 - lTemp2; |
|
61307 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61308 |
|
61309 lTemp = lY1 + lTemp3; |
|
61310 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61311 |
|
61312 /*Fourth Pixel*/ |
|
61313 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
61314 |
|
61315 lTemp = lY1 + lTemp1; |
|
61316 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61317 |
|
61318 lTemp = lY1 - lTemp2; |
|
61319 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61320 |
|
61321 lTemp = lY1 + lTemp3; |
|
61322 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61323 |
|
61324 src1 += 6; |
|
61325 src2 += 6; |
|
61326 |
|
61327 |
|
61328 src1 = lPtr1; |
|
61329 src2 = lPtr2; |
|
61330 |
|
61331 for(j = 0; j < lWidth; j += 2) |
|
61332 { |
|
61333 /* First Pixel */ |
|
61334 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
61335 diff1 = *src1 & 0xf; |
|
61336 diff2 = *(src1 + 1) & 0xf; |
|
61337 diff3 = *(src1 + 2) & 0xf; |
|
61338 |
|
61339 // diffuse the error |
|
61340 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
61341 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
61342 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
61343 |
|
61344 /* Second Pixel */ |
|
61345 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
61346 diff1 = *(src1 + 3) & 0xf; |
|
61347 diff2 = *(src1 + 4) & 0xf; |
|
61348 diff3 = *(src1 + 5) & 0xf; |
|
61349 // diffuse the error |
|
61350 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
61351 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
61352 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
61353 |
|
61354 src1 += 6; |
|
61355 dest1 += 2; |
|
61356 |
|
61357 /* Third Pixel */ |
|
61358 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
61359 diff1 = *src2 & 0xf; |
|
61360 diff2 = *(src2 + 1) & 0xf; |
|
61361 diff3 = *(src2 + 2) & 0xf; |
|
61362 //diffuse the error |
|
61363 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
61364 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
61365 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
61366 |
|
61367 /* Fourth Pixel */ |
|
61368 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
61369 diff1 = *(src2 + 3) & 0xf; |
|
61370 diff2 = *(src2 + 4) & 0xf; |
|
61371 diff3 = *(src2 + 5) & 0xf; |
|
61372 //diffuse the error |
|
61373 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
61374 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
61375 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
61376 |
|
61377 src2 += 6; |
|
61378 dest2 += 2; |
|
61379 } |
|
61380 |
|
61381 if(extraCol) |
|
61382 { |
|
61383 *dest1 = dest1[-1]; |
|
61384 dest1++; |
|
61385 *dest2 = dest2[-1]; |
|
61386 dest2++; |
|
61387 } |
|
61388 |
|
61389 dest1 += ((wndWidth << 1) - lTempWidth); |
|
61390 dest2 += ((wndWidth << 1) - lTempWidth); |
|
61391 |
|
61392 if(extraRow) |
|
61393 { |
|
61394 dest2 = dest1 - wndWidth; |
|
61395 for(j = 0; j < lWidth; j += 2) |
|
61396 { |
|
61397 *dest1++ = *dest2++; |
|
61398 *dest1++ = *dest2++; |
|
61399 } |
|
61400 if(extraCol) |
|
61401 { |
|
61402 *dest1 = *dest2; |
|
61403 } |
|
61404 } |
|
61405 |
|
61406 free(lBuffer); |
|
61407 return; |
|
61408 } |
|
61409 |
|
61410 /* |
|
61411 ****************************************************************************** |
|
61412 Name : sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_601_5_FR |
|
61413 Description : Converts YUV420 Chroma3 Planar to XRGB (4:4:4:4) Interleaved format |
|
61414 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
61415 uint8 *dstImage : Pointer to rgb data (o/p). |
|
61416 tWndParam *srcWindow : Pointer to structure containing source window |
|
61417 parameters like xOffset,yOffset,cropWidth, |
|
61418 cropHeight. (i/p) |
|
61419 tWndParam *dstWindow : Pointer to structure containing destination window |
|
61420 parameters like xOffset,yOffset,windWidth, |
|
61421 windHeight. (i/p) |
|
61422 Return Value : void |
|
61423 ****************************************************************************** |
|
61424 */ |
|
61425 |
|
61426 void sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_601_5_FR |
|
61427 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
61428 tWndParam* srcWindow, tWndParam* dstWindow) |
|
61429 { |
|
61430 uint16 *dest1, *dest2; |
|
61431 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
61432 uint8 *lBuffer; |
|
61433 uint8 *src1, *src2; |
|
61434 uint8 *lPtr1, *lPtr2; |
|
61435 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
61436 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
61437 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
61438 int32 diff1, diff2, diff3; |
|
61439 int32 i, j, k, extraRow, extraCol; |
|
61440 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
61441 cropWidth,cropHeight,wndWidth,wndHeight; |
|
61442 |
|
61443 srcXOffset = srcWindow->xOffset; |
|
61444 srcYOffset = srcWindow->yOffset; |
|
61445 cropWidth = srcWindow->wndWidth; |
|
61446 cropHeight = srcWindow->wndHeight; |
|
61447 |
|
61448 dstXOffset = dstWindow->xOffset; |
|
61449 dstYOffset = dstWindow->yOffset; |
|
61450 wndWidth = dstWindow->wndWidth; |
|
61451 wndHeight = dstWindow->wndHeight; |
|
61452 |
|
61453 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
61454 { |
|
61455 lWidth = cropWidth; |
|
61456 } |
|
61457 else |
|
61458 { |
|
61459 lWidth = srcImage->width - srcXOffset; |
|
61460 } |
|
61461 |
|
61462 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
61463 { |
|
61464 lHeight = cropHeight; |
|
61465 } |
|
61466 else |
|
61467 { |
|
61468 lHeight = srcImage->height - srcYOffset; |
|
61469 } |
|
61470 |
|
61471 if (lWidth > (wndWidth - dstXOffset)) |
|
61472 { |
|
61473 lWidth = wndWidth - dstXOffset; |
|
61474 } |
|
61475 |
|
61476 if (lHeight > (wndHeight - dstYOffset)) |
|
61477 { |
|
61478 lHeight = wndHeight - dstYOffset; |
|
61479 } |
|
61480 |
|
61481 extraCol = lWidth & 0x01; |
|
61482 extraRow = lHeight & 0x01; |
|
61483 |
|
61484 lTempWidth = lWidth; |
|
61485 lWidth = (lWidth >> 1) << 1; |
|
61486 lHeight = (lHeight >> 1) << 1; |
|
61487 |
|
61488 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
61489 |
|
61490 lSrcWidth = lWidth * 3; |
|
61491 |
|
61492 lLumWidth = (srcImage->width >> 1) << 1; |
|
61493 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
61494 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
61495 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
61496 |
|
61497 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
61498 dest2 = dest1 + wndWidth; |
|
61499 |
|
61500 for(i = 0; i < (lHeight - 2); i += 2) |
|
61501 { |
|
61502 lPtr1 = src1 = lBuffer; |
|
61503 lPtr2 = src2 = src1 + lSrcWidth; |
|
61504 |
|
61505 for(k = 0; k < (lWidth - 2); k += 2) |
|
61506 { |
|
61507 lCr1 = lCrPtr[k >> 1]; |
|
61508 lCb1 = lCbPtr[k >> 1]; |
|
61509 |
|
61510 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
61511 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
61512 |
|
61513 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
61514 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
61515 |
|
61516 lCr4 = lCrPtr[((k + lLumWidth)>> 1) + 1]; |
|
61517 lCb4 = lCbPtr[((k + lLumWidth)>> 1) + 1]; |
|
61518 |
|
61519 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
61520 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
61521 |
|
61522 lCr2 = (lCr1 + lCr2) >> 1; |
|
61523 lCb2 = (lCb1 + lCb2) >> 1; |
|
61524 |
|
61525 lCr3 = (lCr1 + lCr3) >> 1; |
|
61526 lCb3 = (lCb1 + lCb3) >> 1; |
|
61527 |
|
61528 /*First Pixel*/ |
|
61529 lCr1 -= 128; |
|
61530 lCb1 -= 128; |
|
61531 |
|
61532 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
61533 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
61534 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
61535 |
|
61536 lY1 = lLumPtr[k]; |
|
61537 |
|
61538 lTemp = lY1 + lTemp1; |
|
61539 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61540 |
|
61541 lTemp = lY1 - lTemp2; |
|
61542 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61543 |
|
61544 lTemp = lY1 + lTemp3; |
|
61545 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61546 |
|
61547 /*Second Pixel*/ |
|
61548 lCr2 -= 128; |
|
61549 lCb2 -= 128; |
|
61550 |
|
61551 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
61552 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
61553 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
61554 |
|
61555 lY1 = lLumPtr[k + 1]; |
|
61556 |
|
61557 lTemp = lY1 + lTemp1; |
|
61558 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61559 |
|
61560 lTemp = lY1 - lTemp2; |
|
61561 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61562 |
|
61563 lTemp = lY1 + lTemp3; |
|
61564 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61565 |
|
61566 |
|
61567 /*Third Pixel*/ |
|
61568 lCr3 -= 128; |
|
61569 lCb3 -= 128; |
|
61570 |
|
61571 lTemp1 = (22973 * lCr3) >> COLOR_CONV_PRECISION; |
|
61572 lTemp2 = ((5637 * lCb3) + (11699 * lCr3)) >> COLOR_CONV_PRECISION; |
|
61573 lTemp3 = (29032 * lCb3) >> COLOR_CONV_PRECISION; |
|
61574 |
|
61575 lY1 = lLumPtr[k + lLumWidth]; |
|
61576 |
|
61577 lTemp = lY1 + lTemp1; |
|
61578 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61579 |
|
61580 lTemp = lY1 - lTemp2; |
|
61581 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61582 |
|
61583 lTemp = lY1 + lTemp3; |
|
61584 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61585 |
|
61586 /*Fourth Pixel*/ |
|
61587 lCr4 -= 128; |
|
61588 lCb4 -= 128; |
|
61589 |
|
61590 lTemp1 = (22973 * lCr4) >> COLOR_CONV_PRECISION; |
|
61591 lTemp2 = ((5637 * lCb4) + (11699 * lCr4)) >> COLOR_CONV_PRECISION; |
|
61592 lTemp3 = (29032 * lCb4) >> COLOR_CONV_PRECISION; |
|
61593 |
|
61594 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
61595 |
|
61596 lTemp = lY1 + lTemp1; |
|
61597 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61598 |
|
61599 lTemp = lY1 - lTemp2; |
|
61600 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61601 |
|
61602 lTemp = lY1 + lTemp3; |
|
61603 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61604 |
|
61605 |
|
61606 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
61607 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
61608 |
|
61609 lCr2 = lCrPtr[((k + lLumWidth) >> 1) + 1]; |
|
61610 lCb2 = lCbPtr[((k + lLumWidth) >> 1) + 1]; |
|
61611 |
|
61612 lCr2 = (lCr1 + lCr2) >> 1; |
|
61613 lCb2 = (lCb1 + lCb2) >> 1; |
|
61614 |
|
61615 /*Fifth Pixel*/ |
|
61616 lCr1 -= 128; |
|
61617 lCb1 -= 128; |
|
61618 |
|
61619 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
61620 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
61621 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
61622 |
|
61623 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
61624 |
|
61625 lTemp = lY1 + lTemp1; |
|
61626 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61627 |
|
61628 lTemp = lY1 - lTemp2; |
|
61629 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61630 |
|
61631 lTemp = lY1 + lTemp3; |
|
61632 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61633 |
|
61634 /*Sixth Pixel*/ |
|
61635 lCr2 -= 128; |
|
61636 lCb2 -= 128; |
|
61637 |
|
61638 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
61639 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
61640 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
61641 |
|
61642 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
61643 |
|
61644 lTemp = lY1 + lTemp1; |
|
61645 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61646 |
|
61647 lTemp = lY1 - lTemp2; |
|
61648 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61649 |
|
61650 lTemp = lY1 + lTemp3; |
|
61651 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61652 |
|
61653 src1 += 6; |
|
61654 src2 += 6; |
|
61655 } |
|
61656 |
|
61657 lCr1 = lCrPtr[k >> 1]; |
|
61658 lCb1 = lCbPtr[k >> 1]; |
|
61659 |
|
61660 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
61661 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
61662 |
|
61663 lCr4 = (lCr1 + lCr3) >> 1; |
|
61664 lCb4 = (lCb1 + lCb3) >> 1; |
|
61665 |
|
61666 lCr1 -= 128; |
|
61667 lCb1 -= 128; |
|
61668 |
|
61669 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
61670 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
61671 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
61672 |
|
61673 /*First Pixel*/ |
|
61674 lY1 = lLumPtr[k]; |
|
61675 |
|
61676 lTemp = lY1 + lTemp1; |
|
61677 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61678 |
|
61679 lTemp = lY1 - lTemp2; |
|
61680 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61681 |
|
61682 lTemp = lY1 + lTemp3; |
|
61683 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61684 |
|
61685 /*Second Pixel*/ |
|
61686 lY1 = lLumPtr[k + 1]; |
|
61687 |
|
61688 lTemp = lY1 + lTemp1; |
|
61689 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61690 |
|
61691 lTemp = lY1 - lTemp2; |
|
61692 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61693 |
|
61694 lTemp = lY1 + lTemp3; |
|
61695 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61696 |
|
61697 |
|
61698 lCr4 -= 128; |
|
61699 lCb4 -= 128; |
|
61700 |
|
61701 lTemp1 = (22973 * lCr4) >> COLOR_CONV_PRECISION; |
|
61702 lTemp2 = ((5637 * lCb4) + (11699 * lCr4)) >> COLOR_CONV_PRECISION; |
|
61703 lTemp3 = (29032 * lCb4) >> COLOR_CONV_PRECISION; |
|
61704 |
|
61705 /*Third Pixel*/ |
|
61706 lY1 = lLumPtr[k + lLumWidth]; |
|
61707 |
|
61708 lTemp = lY1 + lTemp1; |
|
61709 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61710 |
|
61711 lTemp = lY1 - lTemp2; |
|
61712 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61713 |
|
61714 lTemp = lY1 + lTemp3; |
|
61715 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61716 |
|
61717 /*Fourth Pixel*/ |
|
61718 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
61719 |
|
61720 lTemp = lY1 + lTemp1; |
|
61721 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61722 |
|
61723 lTemp = lY1 - lTemp2; |
|
61724 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61725 |
|
61726 lTemp = lY1 + lTemp3; |
|
61727 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61728 |
|
61729 |
|
61730 lCr3 -= 128; |
|
61731 lCb3 -= 128; |
|
61732 |
|
61733 lTemp1 = (22973 * lCr3) >> COLOR_CONV_PRECISION; |
|
61734 lTemp2 = ((5637 * lCb3) + (11699 * lCr3)) >> COLOR_CONV_PRECISION; |
|
61735 lTemp3 = (29032 * lCb3) >> COLOR_CONV_PRECISION; |
|
61736 |
|
61737 /*Fifth Pixel*/ |
|
61738 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
61739 |
|
61740 lTemp = lY1 + lTemp1; |
|
61741 *(src2 + lSrcWidth) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61742 |
|
61743 lTemp = lY1 - lTemp2; |
|
61744 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61745 |
|
61746 lTemp = lY1 + lTemp3; |
|
61747 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61748 |
|
61749 /*Sixth Pixel*/ |
|
61750 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
61751 |
|
61752 lTemp = lY1 + lTemp1; |
|
61753 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61754 |
|
61755 lTemp = lY1 - lTemp2; |
|
61756 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61757 |
|
61758 lTemp = lY1 + lTemp3; |
|
61759 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61760 |
|
61761 src1 += 6; |
|
61762 src2 += 6; |
|
61763 |
|
61764 |
|
61765 src1 = lPtr1; |
|
61766 src2 = lPtr2; |
|
61767 |
|
61768 for(j = 0; j < lWidth; j += 2) |
|
61769 { |
|
61770 /* First Pixel */ |
|
61771 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
61772 diff1 = *src1 & 0xf; |
|
61773 diff2 = *(src1 + 1) & 0xf; |
|
61774 diff3 = *(src1 + 2) & 0xf; |
|
61775 |
|
61776 // diffuse the error |
|
61777 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
61778 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
61779 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
61780 |
|
61781 /* Second Pixel */ |
|
61782 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
61783 diff1 = *(src1 + 3) & 0xf; |
|
61784 diff2 = *(src1 + 4) & 0xf; |
|
61785 diff3 = *(src1 + 5) & 0xf; |
|
61786 // diffuse the error |
|
61787 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
61788 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
61789 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
61790 |
|
61791 src1 += 6; |
|
61792 dest1 += 2; |
|
61793 |
|
61794 /* Third Pixel */ |
|
61795 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
61796 diff1 = *src2 & 0xf; |
|
61797 diff2 = *(src2 + 1) & 0xf; |
|
61798 diff3 = *(src2 + 2) & 0xf; |
|
61799 //diffuse the error |
|
61800 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
61801 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
61802 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
61803 |
|
61804 /* Fourth Pixel */ |
|
61805 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
61806 diff1 = *(src2 + 3) & 0xf; |
|
61807 diff2 = *(src2 + 4) & 0xf; |
|
61808 diff3 = *(src2 + 5) & 0xf; |
|
61809 //diffuse the error |
|
61810 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
61811 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
61812 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
61813 |
|
61814 src2 += 6; |
|
61815 dest2 += 2; |
|
61816 } |
|
61817 if(extraCol) |
|
61818 { |
|
61819 *dest1 = dest1[-1]; |
|
61820 dest1++; |
|
61821 *dest2 = dest2[-1]; |
|
61822 dest2++; |
|
61823 } |
|
61824 |
|
61825 lLumPtr += (lLumWidth << 1); |
|
61826 lCrPtr += (lLumWidth >> 1); |
|
61827 lCbPtr += (lLumWidth >> 1); |
|
61828 |
|
61829 dest1 += ((wndWidth << 1) - lTempWidth); |
|
61830 dest2 += ((wndWidth << 1) - lTempWidth); |
|
61831 } |
|
61832 |
|
61833 |
|
61834 lPtr1 = src1 = lBuffer; |
|
61835 lPtr2 = src2 = src1 + lSrcWidth; |
|
61836 |
|
61837 for(k = 0; k < (lWidth - 2); k += 2) |
|
61838 { |
|
61839 lCr1 = lCrPtr[k >> 1]; |
|
61840 lCb1 = lCbPtr[k >> 1]; |
|
61841 |
|
61842 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
61843 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
61844 |
|
61845 lCr2 = (lCr1 + lCr2) >> 1; |
|
61846 lCb2 = (lCb1 + lCb2) >> 1; |
|
61847 |
|
61848 |
|
61849 lCr1 -= 128; |
|
61850 lCb1 -= 128; |
|
61851 |
|
61852 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
61853 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
61854 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
61855 |
|
61856 /*First Pixel*/ |
|
61857 lY1 = lLumPtr[k]; |
|
61858 |
|
61859 lTemp = lY1 + lTemp1; |
|
61860 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61861 |
|
61862 lTemp = lY1 - lTemp2; |
|
61863 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61864 |
|
61865 lTemp = lY1 + lTemp3; |
|
61866 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61867 |
|
61868 /*Third Pixel*/ |
|
61869 lY1 = lLumPtr[k + lLumWidth]; |
|
61870 |
|
61871 lTemp = lY1 + lTemp1; |
|
61872 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61873 |
|
61874 lTemp = lY1 - lTemp2; |
|
61875 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61876 |
|
61877 lTemp = lY1 + lTemp3; |
|
61878 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61879 |
|
61880 |
|
61881 lCr2 -= 128; |
|
61882 lCb2 -= 128; |
|
61883 |
|
61884 lTemp1 = (22973 * lCr2) >> COLOR_CONV_PRECISION; |
|
61885 lTemp2 = ((5637 * lCb2) + (11699 * lCr2)) >> COLOR_CONV_PRECISION; |
|
61886 lTemp3 = (29032 * lCb2) >> COLOR_CONV_PRECISION; |
|
61887 |
|
61888 /*Second Pixel*/ |
|
61889 lY1 = lLumPtr[k + 1]; |
|
61890 |
|
61891 lTemp = lY1 + lTemp1; |
|
61892 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61893 |
|
61894 lTemp = lY1 - lTemp2; |
|
61895 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61896 |
|
61897 lTemp = lY1 + lTemp3; |
|
61898 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61899 |
|
61900 /*Fourth Pixel*/ |
|
61901 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
61902 |
|
61903 lTemp = lY1 + lTemp1; |
|
61904 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61905 |
|
61906 lTemp = lY1 - lTemp2; |
|
61907 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61908 |
|
61909 lTemp = lY1 + lTemp3; |
|
61910 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61911 |
|
61912 src1 += 6; |
|
61913 src2 += 6; |
|
61914 } |
|
61915 |
|
61916 lCr1 = lCrPtr[k >> 1]; |
|
61917 lCb1 = lCbPtr[k >> 1]; |
|
61918 |
|
61919 lCr1 -= 128; |
|
61920 lCb1 -= 128; |
|
61921 |
|
61922 lTemp1 = (22973 * lCr1) >> COLOR_CONV_PRECISION; |
|
61923 lTemp2 = ((5637 * lCb1) + (11699 * lCr1)) >> COLOR_CONV_PRECISION; |
|
61924 lTemp3 = (29032 * lCb1) >> COLOR_CONV_PRECISION; |
|
61925 |
|
61926 /*First Pixel*/ |
|
61927 lY1 = lLumPtr[k]; |
|
61928 |
|
61929 lTemp = lY1 + lTemp1; |
|
61930 *src1 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61931 |
|
61932 lTemp = lY1 - lTemp2; |
|
61933 *(src1 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61934 |
|
61935 lTemp = lY1 + lTemp3; |
|
61936 *(src1 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61937 |
|
61938 /*Second Pixel*/ |
|
61939 lY1 = lLumPtr[k + 1]; |
|
61940 |
|
61941 lTemp = lY1 + lTemp1; |
|
61942 *(src1 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61943 |
|
61944 lTemp = lY1 - lTemp2; |
|
61945 *(src1 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61946 |
|
61947 lTemp = lY1 + lTemp3; |
|
61948 *(src1 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61949 |
|
61950 /*Third Pixel*/ |
|
61951 lY1 = lLumPtr[k + lLumWidth]; |
|
61952 |
|
61953 lTemp = lY1 + lTemp1; |
|
61954 *src2 = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61955 |
|
61956 lTemp = lY1 - lTemp2; |
|
61957 *(src2 + 1) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61958 |
|
61959 lTemp = lY1 + lTemp3; |
|
61960 *(src2 + 2) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61961 |
|
61962 /*Fourth Pixel*/ |
|
61963 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
61964 |
|
61965 lTemp = lY1 + lTemp1; |
|
61966 *(src2 + 3) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61967 |
|
61968 lTemp = lY1 - lTemp2; |
|
61969 *(src2 + 4) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61970 |
|
61971 lTemp = lY1 + lTemp3; |
|
61972 *(src2 + 5) = (uint8)((lTemp > 255) ? 255 : ((lTemp < 0) ? 0 : lTemp)); |
|
61973 |
|
61974 src1 += 6; |
|
61975 src2 += 6; |
|
61976 |
|
61977 |
|
61978 src1 = lPtr1; |
|
61979 src2 = lPtr2; |
|
61980 |
|
61981 for(j = 0; j < lWidth; j += 2) |
|
61982 { |
|
61983 /* First Pixel */ |
|
61984 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
61985 diff1 = *src1 & 0xf; |
|
61986 diff2 = *(src1 + 1) & 0xf; |
|
61987 diff3 = *(src1 + 2) & 0xf; |
|
61988 |
|
61989 // diffuse the error |
|
61990 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
61991 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
61992 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
61993 |
|
61994 /* Second Pixel */ |
|
61995 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
61996 diff1 = *(src1 + 3) & 0xf; |
|
61997 diff2 = *(src1 + 4) & 0xf; |
|
61998 diff3 = *(src1 + 5) & 0xf; |
|
61999 // diffuse the error |
|
62000 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
62001 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
62002 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
62003 |
|
62004 src1 += 6; |
|
62005 dest1 += 2; |
|
62006 |
|
62007 /* Third Pixel */ |
|
62008 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
62009 diff1 = *src2 & 0xf; |
|
62010 diff2 = *(src2 + 1) & 0xf; |
|
62011 diff3 = *(src2 + 2) & 0xf; |
|
62012 //diffuse the error |
|
62013 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
62014 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
62015 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
62016 |
|
62017 /* Fourth Pixel */ |
|
62018 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
62019 diff1 = *(src2 + 3) & 0xf; |
|
62020 diff2 = *(src2 + 4) & 0xf; |
|
62021 diff3 = *(src2 + 5) & 0xf; |
|
62022 //diffuse the error |
|
62023 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
62024 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
62025 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
62026 |
|
62027 src2 += 6; |
|
62028 dest2 += 2; |
|
62029 } |
|
62030 |
|
62031 if(extraCol) |
|
62032 { |
|
62033 *dest1 = dest1[-1]; |
|
62034 dest1++; |
|
62035 *dest2 = dest2[-1]; |
|
62036 dest2++; |
|
62037 } |
|
62038 |
|
62039 dest1 += ((wndWidth << 1) - lTempWidth); |
|
62040 dest2 += ((wndWidth << 1) - lTempWidth); |
|
62041 |
|
62042 if(extraRow) |
|
62043 { |
|
62044 dest2 = dest1 - wndWidth; |
|
62045 for(j = 0; j < lWidth; j += 2) |
|
62046 { |
|
62047 *dest1++ = *dest2++; |
|
62048 *dest1++ = *dest2++; |
|
62049 } |
|
62050 if(extraCol) |
|
62051 { |
|
62052 *dest1 = *dest2; |
|
62053 } |
|
62054 } |
|
62055 |
|
62056 free(lBuffer); |
|
62057 return; |
|
62058 } |
|
62059 |
|
62060 /* |
|
62061 ****************************************************************************** |
|
62062 Name : sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_709_RR |
|
62063 Description : Converts YUV420 Chroma3 Planar to XRGB (4:4:4:4) Interleaved format |
|
62064 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
62065 uint8 *dstImage : Pointer to rgb data (o/p). |
|
62066 tWndParam *srcWindow : Pointer to structure containing source window |
|
62067 parameters like xOffset,yOffset,cropWidth, |
|
62068 cropHeight. (i/p) |
|
62069 tWndParam *dstWindow : Pointer to structure containing destination window |
|
62070 parameters like xOffset,yOffset,windWidth, |
|
62071 windHeight. (i/p) |
|
62072 Return Value : void |
|
62073 ****************************************************************************** |
|
62074 */ |
|
62075 |
|
62076 void sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_709_RR |
|
62077 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
62078 tWndParam* srcWindow, tWndParam* dstWindow) |
|
62079 { |
|
62080 uint16 *dest1, *dest2; |
|
62081 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
62082 uint8 *lBuffer; |
|
62083 uint8 *src1, *src2; |
|
62084 uint8 *lPtr1, *lPtr2; |
|
62085 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
62086 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
62087 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
62088 int32 diff1, diff2, diff3; |
|
62089 int32 i, j, k, extraRow, extraCol; |
|
62090 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
62091 cropWidth,cropHeight,wndWidth,wndHeight; |
|
62092 |
|
62093 srcXOffset = srcWindow->xOffset; |
|
62094 srcYOffset = srcWindow->yOffset; |
|
62095 cropWidth = srcWindow->wndWidth; |
|
62096 cropHeight = srcWindow->wndHeight; |
|
62097 |
|
62098 dstXOffset = dstWindow->xOffset; |
|
62099 dstYOffset = dstWindow->yOffset; |
|
62100 wndWidth = dstWindow->wndWidth; |
|
62101 wndHeight = dstWindow->wndHeight; |
|
62102 |
|
62103 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
62104 { |
|
62105 lWidth = cropWidth; |
|
62106 } |
|
62107 else |
|
62108 { |
|
62109 lWidth = srcImage->width - srcXOffset; |
|
62110 } |
|
62111 |
|
62112 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
62113 { |
|
62114 lHeight = cropHeight; |
|
62115 } |
|
62116 else |
|
62117 { |
|
62118 lHeight = srcImage->height - srcYOffset; |
|
62119 } |
|
62120 |
|
62121 if (lWidth > (wndWidth - dstXOffset)) |
|
62122 { |
|
62123 lWidth = wndWidth - dstXOffset; |
|
62124 } |
|
62125 |
|
62126 if (lHeight > (wndHeight - dstYOffset)) |
|
62127 { |
|
62128 lHeight = wndHeight - dstYOffset; |
|
62129 } |
|
62130 |
|
62131 extraCol = lWidth & 0x01; |
|
62132 extraRow = lHeight & 0x01; |
|
62133 |
|
62134 lTempWidth = lWidth; |
|
62135 lWidth = (lWidth >> 1) << 1; |
|
62136 lHeight = (lHeight >> 1) << 1; |
|
62137 |
|
62138 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
62139 |
|
62140 lSrcWidth = lWidth * 3; |
|
62141 |
|
62142 lLumWidth = (srcImage->width >> 1) << 1; |
|
62143 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
62144 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
62145 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
62146 |
|
62147 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
62148 dest2 = dest1 + wndWidth; |
|
62149 |
|
62150 for(i = 0; i < (lHeight - 2); i += 2) |
|
62151 { |
|
62152 lPtr1 = src1 = lBuffer; |
|
62153 lPtr2 = src2 = src1 + lSrcWidth; |
|
62154 |
|
62155 for(k = 0; k < (lWidth - 2); k += 2) |
|
62156 { |
|
62157 lCr1 = lCrPtr[k >> 1]; |
|
62158 lCb1 = lCbPtr[k >> 1]; |
|
62159 |
|
62160 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
62161 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
62162 |
|
62163 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
62164 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
62165 |
|
62166 lCr4 = lCrPtr[((k + lLumWidth)>> 1) + 1]; |
|
62167 lCb4 = lCbPtr[((k + lLumWidth)>> 1) + 1]; |
|
62168 |
|
62169 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
62170 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
62171 |
|
62172 lCr2 = (lCr1 + lCr2) >> 1; |
|
62173 lCb2 = (lCb1 + lCb2) >> 1; |
|
62174 |
|
62175 lCr3 = (lCr1 + lCr3) >> 1; |
|
62176 lCb3 = (lCb1 + lCb3) >> 1; |
|
62177 |
|
62178 /*First Pixel*/ |
|
62179 lCr1 -= 128; |
|
62180 lCb1 -= 128; |
|
62181 |
|
62182 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
62183 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
62184 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
62185 |
|
62186 lY1 = lLumPtr[k]; |
|
62187 lY1 -= 16; |
|
62188 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62189 |
|
62190 lTemp = lY1 + lTemp1; |
|
62191 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62192 |
|
62193 lTemp = lY1 - lTemp2; |
|
62194 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62195 |
|
62196 lTemp = lY1 + lTemp3; |
|
62197 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62198 |
|
62199 /*Second Pixel*/ |
|
62200 lCr2 -= 128; |
|
62201 lCb2 -= 128; |
|
62202 |
|
62203 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
62204 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
62205 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
62206 |
|
62207 lY1 = lLumPtr[k + 1]; |
|
62208 lY1 -= 16; |
|
62209 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62210 |
|
62211 lTemp = lY1 + lTemp1; |
|
62212 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62213 |
|
62214 lTemp = lY1 - lTemp2; |
|
62215 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62216 |
|
62217 lTemp = lY1 + lTemp3; |
|
62218 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62219 |
|
62220 |
|
62221 /*Third Pixel*/ |
|
62222 lCr3 -= 128; |
|
62223 lCb3 -= 128; |
|
62224 |
|
62225 lTemp1 = (29374 * lCr3) >> COLOR_CONV_PRECISION; |
|
62226 lTemp2 = ((3494 * lCb3) + (8731 * lCr3)) >> COLOR_CONV_PRECISION; |
|
62227 lTemp3 = (34603 * lCb3) >> COLOR_CONV_PRECISION; |
|
62228 |
|
62229 lY1 = lLumPtr[k + lLumWidth]; |
|
62230 lY1 -= 16; |
|
62231 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62232 |
|
62233 lTemp = lY1 + lTemp1; |
|
62234 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62235 |
|
62236 lTemp = lY1 - lTemp2; |
|
62237 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62238 |
|
62239 lTemp = lY1 + lTemp3; |
|
62240 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62241 |
|
62242 /*Fourth Pixel*/ |
|
62243 lCr4 -= 128; |
|
62244 lCb4 -= 128; |
|
62245 |
|
62246 lTemp1 = (29374 * lCr4) >> COLOR_CONV_PRECISION; |
|
62247 lTemp2 = ((3494 * lCb4) + (8731 * lCr4)) >> COLOR_CONV_PRECISION; |
|
62248 lTemp3 = (34603 * lCb4) >> COLOR_CONV_PRECISION; |
|
62249 |
|
62250 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
62251 lY1 -= 16; |
|
62252 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62253 |
|
62254 lTemp = lY1 + lTemp1; |
|
62255 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62256 |
|
62257 lTemp = lY1 - lTemp2; |
|
62258 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62259 |
|
62260 lTemp = lY1 + lTemp3; |
|
62261 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62262 |
|
62263 |
|
62264 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
62265 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
62266 |
|
62267 lCr2 = lCrPtr[((k + lLumWidth) >> 1) + 1]; |
|
62268 lCb2 = lCbPtr[((k + lLumWidth) >> 1) + 1]; |
|
62269 |
|
62270 lCr2 = (lCr1 + lCr2) >> 1; |
|
62271 lCb2 = (lCb1 + lCb2) >> 1; |
|
62272 |
|
62273 /*Fifth Pixel*/ |
|
62274 lCr1 -= 128; |
|
62275 lCb1 -= 128; |
|
62276 |
|
62277 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
62278 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
62279 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
62280 |
|
62281 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
62282 lY1 -= 16; |
|
62283 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62284 |
|
62285 lTemp = lY1 + lTemp1; |
|
62286 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62287 |
|
62288 lTemp = lY1 - lTemp2; |
|
62289 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62290 |
|
62291 lTemp = lY1 + lTemp3; |
|
62292 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62293 |
|
62294 /*Sixth Pixel*/ |
|
62295 lCr2 -= 128; |
|
62296 lCb2 -= 128; |
|
62297 |
|
62298 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
62299 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
62300 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
62301 |
|
62302 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
62303 lY1 -= 16; |
|
62304 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62305 |
|
62306 lTemp = lY1 + lTemp1; |
|
62307 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62308 |
|
62309 lTemp = lY1 - lTemp2; |
|
62310 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62311 |
|
62312 lTemp = lY1 + lTemp3; |
|
62313 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62314 |
|
62315 src1 += 6; |
|
62316 src2 += 6; |
|
62317 } |
|
62318 |
|
62319 lCr1 = lCrPtr[k >> 1]; |
|
62320 lCb1 = lCbPtr[k >> 1]; |
|
62321 |
|
62322 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
62323 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
62324 |
|
62325 lCr4 = (lCr1 + lCr3) >> 1; |
|
62326 lCb4 = (lCb1 + lCb3) >> 1; |
|
62327 |
|
62328 lCr1 -= 128; |
|
62329 lCb1 -= 128; |
|
62330 |
|
62331 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
62332 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
62333 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
62334 |
|
62335 /*First Pixel*/ |
|
62336 lY1 = lLumPtr[k]; |
|
62337 lY1 -= 16; |
|
62338 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62339 |
|
62340 lTemp = lY1 + lTemp1; |
|
62341 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62342 |
|
62343 lTemp = lY1 - lTemp2; |
|
62344 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62345 |
|
62346 lTemp = lY1 + lTemp3; |
|
62347 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62348 |
|
62349 /*Second Pixel*/ |
|
62350 lY1 = lLumPtr[k + 1]; |
|
62351 lY1 -= 16; |
|
62352 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62353 |
|
62354 lTemp = lY1 + lTemp1; |
|
62355 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62356 |
|
62357 lTemp = lY1 - lTemp2; |
|
62358 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62359 |
|
62360 lTemp = lY1 + lTemp3; |
|
62361 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62362 |
|
62363 |
|
62364 lCr4 -= 128; |
|
62365 lCb4 -= 128; |
|
62366 |
|
62367 lTemp1 = (29374 * lCr4) >> COLOR_CONV_PRECISION; |
|
62368 lTemp2 = ((3494 * lCb4) + (8731 * lCr4)) >> COLOR_CONV_PRECISION; |
|
62369 lTemp3 = (34603 * lCb4) >> COLOR_CONV_PRECISION; |
|
62370 |
|
62371 /*Third Pixel*/ |
|
62372 lY1 = lLumPtr[k + lLumWidth]; |
|
62373 lY1 -= 16; |
|
62374 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62375 |
|
62376 lTemp = lY1 + lTemp1; |
|
62377 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62378 |
|
62379 lTemp = lY1 - lTemp2; |
|
62380 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62381 |
|
62382 lTemp = lY1 + lTemp3; |
|
62383 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62384 |
|
62385 /*Fourth Pixel*/ |
|
62386 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
62387 lY1 -= 16; |
|
62388 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62389 |
|
62390 lTemp = lY1 + lTemp1; |
|
62391 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62392 |
|
62393 lTemp = lY1 - lTemp2; |
|
62394 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62395 |
|
62396 lTemp = lY1 + lTemp3; |
|
62397 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62398 |
|
62399 |
|
62400 lCr3 -= 128; |
|
62401 lCb3 -= 128; |
|
62402 |
|
62403 lTemp1 = (29374 * lCr3) >> COLOR_CONV_PRECISION; |
|
62404 lTemp2 = ((3494 * lCb3) + (8731 * lCr3)) >> COLOR_CONV_PRECISION; |
|
62405 lTemp3 = (34603 * lCb3) >> COLOR_CONV_PRECISION; |
|
62406 |
|
62407 /*Fifth Pixel*/ |
|
62408 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
62409 lY1 -= 16; |
|
62410 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62411 |
|
62412 lTemp = lY1 + lTemp1; |
|
62413 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62414 |
|
62415 lTemp = lY1 - lTemp2; |
|
62416 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62417 |
|
62418 lTemp = lY1 + lTemp3; |
|
62419 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62420 |
|
62421 /*Sixth Pixel*/ |
|
62422 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
62423 lY1 -= 16; |
|
62424 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62425 |
|
62426 lTemp = lY1 + lTemp1; |
|
62427 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62428 |
|
62429 lTemp = lY1 - lTemp2; |
|
62430 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62431 |
|
62432 lTemp = lY1 + lTemp3; |
|
62433 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62434 |
|
62435 src1 += 6; |
|
62436 src2 += 6; |
|
62437 |
|
62438 |
|
62439 src1 = lPtr1; |
|
62440 src2 = lPtr2; |
|
62441 |
|
62442 for(j = 0; j < lWidth; j += 2) |
|
62443 { |
|
62444 /* First Pixel */ |
|
62445 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
62446 diff1 = *src1 & 0xf; |
|
62447 diff2 = *(src1 + 1) & 0xf; |
|
62448 diff3 = *(src1 + 2) & 0xf; |
|
62449 |
|
62450 // diffuse the error |
|
62451 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
62452 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
62453 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
62454 |
|
62455 /* Second Pixel */ |
|
62456 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
62457 diff1 = *(src1 + 3) & 0xf; |
|
62458 diff2 = *(src1 + 4) & 0xf; |
|
62459 diff3 = *(src1 + 5) & 0xf; |
|
62460 // diffuse the error |
|
62461 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
62462 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
62463 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
62464 |
|
62465 src1 += 6; |
|
62466 dest1 += 2; |
|
62467 |
|
62468 /* Third Pixel */ |
|
62469 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
62470 diff1 = *src2 & 0xf; |
|
62471 diff2 = *(src2 + 1) & 0xf; |
|
62472 diff3 = *(src2 + 2) & 0xf; |
|
62473 //diffuse the error |
|
62474 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
62475 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
62476 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
62477 |
|
62478 /* Fourth Pixel */ |
|
62479 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
62480 diff1 = *(src2 + 3) & 0xf; |
|
62481 diff2 = *(src2 + 4) & 0xf; |
|
62482 diff3 = *(src2 + 5) & 0xf; |
|
62483 //diffuse the error |
|
62484 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
62485 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
62486 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
62487 |
|
62488 src2 += 6; |
|
62489 dest2 += 2; |
|
62490 } |
|
62491 if(extraCol) |
|
62492 { |
|
62493 *dest1 = dest1[-1]; |
|
62494 dest1++; |
|
62495 *dest2 = dest2[-1]; |
|
62496 dest2++; |
|
62497 } |
|
62498 |
|
62499 lLumPtr += (lLumWidth << 1); |
|
62500 lCrPtr += (lLumWidth >> 1); |
|
62501 lCbPtr += (lLumWidth >> 1); |
|
62502 |
|
62503 dest1 += ((wndWidth << 1) - lTempWidth); |
|
62504 dest2 += ((wndWidth << 1) - lTempWidth); |
|
62505 } |
|
62506 |
|
62507 |
|
62508 lPtr1 = src1 = lBuffer; |
|
62509 lPtr2 = src2 = src1 + lSrcWidth; |
|
62510 |
|
62511 for(k = 0; k < (lWidth - 2); k += 2) |
|
62512 { |
|
62513 lCr1 = lCrPtr[k >> 1]; |
|
62514 lCb1 = lCbPtr[k >> 1]; |
|
62515 |
|
62516 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
62517 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
62518 |
|
62519 lCr2 = (lCr1 + lCr2) >> 1; |
|
62520 lCb2 = (lCb1 + lCb2) >> 1; |
|
62521 |
|
62522 |
|
62523 lCr1 -= 128; |
|
62524 lCb1 -= 128; |
|
62525 |
|
62526 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
62527 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
62528 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
62529 |
|
62530 /*First Pixel*/ |
|
62531 lY1 = lLumPtr[k]; |
|
62532 lY1 -= 16; |
|
62533 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62534 |
|
62535 lTemp = lY1 + lTemp1; |
|
62536 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62537 |
|
62538 lTemp = lY1 - lTemp2; |
|
62539 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62540 |
|
62541 lTemp = lY1 + lTemp3; |
|
62542 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62543 |
|
62544 /*Third Pixel*/ |
|
62545 lY1 = lLumPtr[k + lLumWidth]; |
|
62546 lY1 -= 16; |
|
62547 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62548 |
|
62549 lTemp = lY1 + lTemp1; |
|
62550 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62551 |
|
62552 lTemp = lY1 - lTemp2; |
|
62553 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62554 |
|
62555 lTemp = lY1 + lTemp3; |
|
62556 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62557 |
|
62558 |
|
62559 lCr2 -= 128; |
|
62560 lCb2 -= 128; |
|
62561 |
|
62562 lTemp1 = (29374 * lCr2) >> COLOR_CONV_PRECISION; |
|
62563 lTemp2 = ((3494 * lCb2) + (8731 * lCr2)) >> COLOR_CONV_PRECISION; |
|
62564 lTemp3 = (34603 * lCb2) >> COLOR_CONV_PRECISION; |
|
62565 |
|
62566 /*Second Pixel*/ |
|
62567 lY1 = lLumPtr[k + 1]; |
|
62568 lY1 -= 16; |
|
62569 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62570 |
|
62571 lTemp = lY1 + lTemp1; |
|
62572 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62573 |
|
62574 lTemp = lY1 - lTemp2; |
|
62575 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62576 |
|
62577 lTemp = lY1 + lTemp3; |
|
62578 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62579 |
|
62580 /*Fourth Pixel*/ |
|
62581 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
62582 lY1 -= 16; |
|
62583 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62584 |
|
62585 lTemp = lY1 + lTemp1; |
|
62586 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62587 |
|
62588 lTemp = lY1 - lTemp2; |
|
62589 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62590 |
|
62591 lTemp = lY1 + lTemp3; |
|
62592 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62593 |
|
62594 src1 += 6; |
|
62595 src2 += 6; |
|
62596 } |
|
62597 |
|
62598 lCr1 = lCrPtr[k >> 1]; |
|
62599 lCb1 = lCbPtr[k >> 1]; |
|
62600 |
|
62601 lCr1 -= 128; |
|
62602 lCb1 -= 128; |
|
62603 |
|
62604 lTemp1 = (29374 * lCr1) >> COLOR_CONV_PRECISION; |
|
62605 lTemp2 = ((3494 * lCb1) + (8731 * lCr1)) >> COLOR_CONV_PRECISION; |
|
62606 lTemp3 = (34603 * lCb1) >> COLOR_CONV_PRECISION; |
|
62607 |
|
62608 /*First Pixel*/ |
|
62609 lY1 = lLumPtr[k]; |
|
62610 lY1 -= 16; |
|
62611 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62612 |
|
62613 lTemp = lY1 + lTemp1; |
|
62614 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62615 |
|
62616 lTemp = lY1 - lTemp2; |
|
62617 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62618 |
|
62619 lTemp = lY1 + lTemp3; |
|
62620 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62621 |
|
62622 /*Second Pixel*/ |
|
62623 lY1 = lLumPtr[k + 1]; |
|
62624 lY1 -= 16; |
|
62625 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62626 |
|
62627 lTemp = lY1 + lTemp1; |
|
62628 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62629 |
|
62630 lTemp = lY1 - lTemp2; |
|
62631 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62632 |
|
62633 lTemp = lY1 + lTemp3; |
|
62634 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62635 |
|
62636 /*Third Pixel*/ |
|
62637 lY1 = lLumPtr[k + lLumWidth]; |
|
62638 lY1 -= 16; |
|
62639 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62640 |
|
62641 lTemp = lY1 + lTemp1; |
|
62642 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62643 |
|
62644 lTemp = lY1 - lTemp2; |
|
62645 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62646 |
|
62647 lTemp = lY1 + lTemp3; |
|
62648 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62649 |
|
62650 /*Fourth Pixel*/ |
|
62651 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
62652 lY1 -= 16; |
|
62653 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62654 |
|
62655 lTemp = lY1 + lTemp1; |
|
62656 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62657 |
|
62658 lTemp = lY1 - lTemp2; |
|
62659 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62660 |
|
62661 lTemp = lY1 + lTemp3; |
|
62662 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62663 |
|
62664 src1 += 6; |
|
62665 src2 += 6; |
|
62666 |
|
62667 |
|
62668 src1 = lPtr1; |
|
62669 src2 = lPtr2; |
|
62670 |
|
62671 for(j = 0; j < lWidth; j += 2) |
|
62672 { |
|
62673 /* First Pixel */ |
|
62674 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
62675 diff1 = *src1 & 0xf; |
|
62676 diff2 = *(src1 + 1) & 0xf; |
|
62677 diff3 = *(src1 + 2) & 0xf; |
|
62678 |
|
62679 // diffuse the error |
|
62680 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
62681 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
62682 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
62683 |
|
62684 /* Second Pixel */ |
|
62685 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
62686 diff1 = *(src1 + 3) & 0xf; |
|
62687 diff2 = *(src1 + 4) & 0xf; |
|
62688 diff3 = *(src1 + 5) & 0xf; |
|
62689 // diffuse the error |
|
62690 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
62691 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
62692 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
62693 |
|
62694 src1 += 6; |
|
62695 dest1 += 2; |
|
62696 |
|
62697 /* Third Pixel */ |
|
62698 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
62699 diff1 = *src2 & 0xf; |
|
62700 diff2 = *(src2 + 1) & 0xf; |
|
62701 diff3 = *(src2 + 2) & 0xf; |
|
62702 //diffuse the error |
|
62703 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
62704 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
62705 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
62706 |
|
62707 /* Fourth Pixel */ |
|
62708 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
62709 diff1 = *(src2 + 3) & 0xf; |
|
62710 diff2 = *(src2 + 4) & 0xf; |
|
62711 diff3 = *(src2 + 5) & 0xf; |
|
62712 //diffuse the error |
|
62713 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
62714 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
62715 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
62716 |
|
62717 src2 += 6; |
|
62718 dest2 += 2; |
|
62719 } |
|
62720 |
|
62721 if(extraCol) |
|
62722 { |
|
62723 *dest1 = dest1[-1]; |
|
62724 dest1++; |
|
62725 *dest2 = dest2[-1]; |
|
62726 dest2++; |
|
62727 } |
|
62728 |
|
62729 dest1 += ((wndWidth << 1) - lTempWidth); |
|
62730 dest2 += ((wndWidth << 1) - lTempWidth); |
|
62731 |
|
62732 if(extraRow) |
|
62733 { |
|
62734 dest2 = dest1 - wndWidth; |
|
62735 for(j = 0; j < lWidth; j += 2) |
|
62736 { |
|
62737 *dest1++ = *dest2++; |
|
62738 *dest1++ = *dest2++; |
|
62739 } |
|
62740 if(extraCol) |
|
62741 { |
|
62742 *dest1 = *dest2; |
|
62743 } |
|
62744 } |
|
62745 |
|
62746 free(lBuffer); |
|
62747 return; |
|
62748 } |
|
62749 |
|
62750 /* |
|
62751 ****************************************************************************** |
|
62752 Name : sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_601_5_RR |
|
62753 Description : Converts YUV420 Chroma3 Planar to XRGB (4:4:4:4) Interleaved format |
|
62754 Parameter : tBaseVideoFrame *srcImage : Pointer to the source frame (i/p), |
|
62755 uint8 *dstImage : Pointer to rgb data (o/p). |
|
62756 tWndParam *srcWindow : Pointer to structure containing source window |
|
62757 parameters like xOffset,yOffset,cropWidth, |
|
62758 cropHeight. (i/p) |
|
62759 tWndParam *dstWindow : Pointer to structure containing destination window |
|
62760 parameters like xOffset,yOffset,windWidth, |
|
62761 windHeight. (i/p) |
|
62762 Return Value : void |
|
62763 ****************************************************************************** |
|
62764 */ |
|
62765 |
|
62766 void sEmz_VDec_YUV420Chr3toColor4k_ErrDiff_601_5_RR |
|
62767 (tBaseVideoFrame* srcImage, uint8* dstImage, |
|
62768 tWndParam* srcWindow, tWndParam* dstWindow) |
|
62769 { |
|
62770 uint16 *dest1, *dest2; |
|
62771 uint8 *lLumPtr, *lCrPtr, *lCbPtr; |
|
62772 uint8 *lBuffer; |
|
62773 uint8 *src1, *src2; |
|
62774 uint8 *lPtr1, *lPtr2; |
|
62775 int32 lLumWidth, lWidth, lHeight, lTempWidth, lSrcWidth; |
|
62776 int32 lY1, lCr1, lCb1, lCr2, lCb2, lCr3, lCb3, lCr4, lCb4; |
|
62777 int32 lTemp, lTemp1, lTemp2, lTemp3; |
|
62778 int32 diff1, diff2, diff3; |
|
62779 int32 i, j, k, extraRow, extraCol; |
|
62780 int32 srcXOffset,srcYOffset,dstXOffset,dstYOffset, |
|
62781 cropWidth,cropHeight,wndWidth,wndHeight; |
|
62782 |
|
62783 srcXOffset = srcWindow->xOffset; |
|
62784 srcYOffset = srcWindow->yOffset; |
|
62785 cropWidth = srcWindow->wndWidth; |
|
62786 cropHeight = srcWindow->wndHeight; |
|
62787 |
|
62788 dstXOffset = dstWindow->xOffset; |
|
62789 dstYOffset = dstWindow->yOffset; |
|
62790 wndWidth = dstWindow->wndWidth; |
|
62791 wndHeight = dstWindow->wndHeight; |
|
62792 |
|
62793 if ((srcImage->width - srcXOffset) >= cropWidth) |
|
62794 { |
|
62795 lWidth = cropWidth; |
|
62796 } |
|
62797 else |
|
62798 { |
|
62799 lWidth = srcImage->width - srcXOffset; |
|
62800 } |
|
62801 |
|
62802 if ((srcImage->height - srcYOffset) >= cropHeight) |
|
62803 { |
|
62804 lHeight = cropHeight; |
|
62805 } |
|
62806 else |
|
62807 { |
|
62808 lHeight = srcImage->height - srcYOffset; |
|
62809 } |
|
62810 |
|
62811 if (lWidth > (wndWidth - dstXOffset)) |
|
62812 { |
|
62813 lWidth = wndWidth - dstXOffset; |
|
62814 } |
|
62815 |
|
62816 if (lHeight > (wndHeight - dstYOffset)) |
|
62817 { |
|
62818 lHeight = wndHeight - dstYOffset; |
|
62819 } |
|
62820 |
|
62821 extraCol = lWidth & 0x01; |
|
62822 extraRow = lHeight & 0x01; |
|
62823 |
|
62824 lTempWidth = lWidth; |
|
62825 lWidth = (lWidth >> 1) << 1; |
|
62826 lHeight = (lHeight >> 1) << 1; |
|
62827 |
|
62828 lBuffer = (uint8*) malloc(lWidth * 3 * 3); |
|
62829 |
|
62830 lSrcWidth = lWidth * 3; |
|
62831 |
|
62832 lLumWidth = (srcImage->width >> 1) << 1; |
|
62833 lLumPtr = srcImage->lum + (srcYOffset * lLumWidth) + srcXOffset; |
|
62834 lCbPtr = srcImage->cb + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
62835 lCrPtr = srcImage->cr + (((srcYOffset * (lLumWidth >> 1)) + srcXOffset) >> 1); |
|
62836 |
|
62837 dest1 = (uint16*)(dstImage) + (dstYOffset * wndWidth) + dstXOffset; |
|
62838 dest2 = dest1 + wndWidth; |
|
62839 |
|
62840 for(i = 0; i < (lHeight - 2); i += 2) |
|
62841 { |
|
62842 lPtr1 = src1 = lBuffer; |
|
62843 lPtr2 = src2 = src1 + lSrcWidth; |
|
62844 |
|
62845 for(k = 0; k < (lWidth - 2); k += 2) |
|
62846 { |
|
62847 lCr1 = lCrPtr[k >> 1]; |
|
62848 lCb1 = lCbPtr[k >> 1]; |
|
62849 |
|
62850 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
62851 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
62852 |
|
62853 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
62854 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
62855 |
|
62856 lCr4 = lCrPtr[((k + lLumWidth)>> 1) + 1]; |
|
62857 lCb4 = lCbPtr[((k + lLumWidth)>> 1) + 1]; |
|
62858 |
|
62859 lCr4 = (lCr1 + lCr2 + lCr3 + lCr4) >> 2; |
|
62860 lCb4 = (lCb1 + lCb2 + lCb3 + lCb4) >> 2; |
|
62861 |
|
62862 lCr2 = (lCr1 + lCr2) >> 1; |
|
62863 lCb2 = (lCb1 + lCb2) >> 1; |
|
62864 |
|
62865 lCr3 = (lCr1 + lCr3) >> 1; |
|
62866 lCb3 = (lCb1 + lCb3) >> 1; |
|
62867 |
|
62868 /*First Pixel*/ |
|
62869 lCr1 -= 128; |
|
62870 lCb1 -= 128; |
|
62871 |
|
62872 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
62873 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
62874 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
62875 |
|
62876 lY1 = lLumPtr[k]; |
|
62877 lY1 -= 16; |
|
62878 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62879 |
|
62880 lTemp = lY1 + lTemp1; |
|
62881 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62882 |
|
62883 lTemp = lY1 - lTemp2; |
|
62884 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62885 |
|
62886 lTemp = lY1 + lTemp3; |
|
62887 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62888 |
|
62889 /*Second Pixel*/ |
|
62890 lCr2 -= 128; |
|
62891 lCb2 -= 128; |
|
62892 |
|
62893 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
62894 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
62895 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
62896 |
|
62897 lY1 = lLumPtr[k + 1]; |
|
62898 lY1 -= 16; |
|
62899 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62900 |
|
62901 lTemp = lY1 + lTemp1; |
|
62902 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62903 |
|
62904 lTemp = lY1 - lTemp2; |
|
62905 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62906 |
|
62907 lTemp = lY1 + lTemp3; |
|
62908 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62909 |
|
62910 |
|
62911 /*Third Pixel*/ |
|
62912 lCr3 -= 128; |
|
62913 lCb3 -= 128; |
|
62914 |
|
62915 lTemp1 = (26748 * lCr3) >> COLOR_CONV_PRECISION; |
|
62916 lTemp2 = ((6563 * lCb3) + (13621 * lCr3)) >> COLOR_CONV_PRECISION; |
|
62917 lTemp3 = (33802 * lCb3) >> COLOR_CONV_PRECISION; |
|
62918 |
|
62919 lY1 = lLumPtr[k + lLumWidth]; |
|
62920 lY1 -= 16; |
|
62921 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62922 |
|
62923 lTemp = lY1 + lTemp1; |
|
62924 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62925 |
|
62926 lTemp = lY1 - lTemp2; |
|
62927 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62928 |
|
62929 lTemp = lY1 + lTemp3; |
|
62930 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62931 |
|
62932 /*Fourth Pixel*/ |
|
62933 lCr4 -= 128; |
|
62934 lCb4 -= 128; |
|
62935 |
|
62936 lTemp1 = (26748 * lCr4) >> COLOR_CONV_PRECISION; |
|
62937 lTemp2 = ((6563 * lCb4) + (13621 * lCr4)) >> COLOR_CONV_PRECISION; |
|
62938 lTemp3 = (33802 * lCb4) >> COLOR_CONV_PRECISION; |
|
62939 |
|
62940 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
62941 lY1 -= 16; |
|
62942 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62943 |
|
62944 lTemp = lY1 + lTemp1; |
|
62945 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62946 |
|
62947 lTemp = lY1 - lTemp2; |
|
62948 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62949 |
|
62950 lTemp = lY1 + lTemp3; |
|
62951 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62952 |
|
62953 |
|
62954 lCr1 = lCrPtr[(k + lLumWidth) >> 1]; |
|
62955 lCb1 = lCbPtr[(k + lLumWidth) >> 1]; |
|
62956 |
|
62957 lCr2 = lCrPtr[((k + lLumWidth) >> 1) + 1]; |
|
62958 lCb2 = lCbPtr[((k + lLumWidth) >> 1) + 1]; |
|
62959 |
|
62960 lCr2 = (lCr1 + lCr2) >> 1; |
|
62961 lCb2 = (lCb1 + lCb2) >> 1; |
|
62962 |
|
62963 /*Fifth Pixel*/ |
|
62964 lCr1 -= 128; |
|
62965 lCb1 -= 128; |
|
62966 |
|
62967 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
62968 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
62969 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
62970 |
|
62971 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
62972 lY1 -= 16; |
|
62973 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62974 |
|
62975 lTemp = lY1 + lTemp1; |
|
62976 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62977 |
|
62978 lTemp = lY1 - lTemp2; |
|
62979 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62980 |
|
62981 lTemp = lY1 + lTemp3; |
|
62982 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62983 |
|
62984 /*Sixth Pixel*/ |
|
62985 lCr2 -= 128; |
|
62986 lCb2 -= 128; |
|
62987 |
|
62988 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
62989 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
62990 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
62991 |
|
62992 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
62993 lY1 -= 16; |
|
62994 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
62995 |
|
62996 lTemp = lY1 + lTemp1; |
|
62997 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
62998 |
|
62999 lTemp = lY1 - lTemp2; |
|
63000 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63001 |
|
63002 lTemp = lY1 + lTemp3; |
|
63003 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63004 |
|
63005 src1 += 6; |
|
63006 src2 += 6; |
|
63007 } |
|
63008 |
|
63009 lCr1 = lCrPtr[k >> 1]; |
|
63010 lCb1 = lCbPtr[k >> 1]; |
|
63011 |
|
63012 lCr3 = lCrPtr[(k + lLumWidth)>> 1]; |
|
63013 lCb3 = lCbPtr[(k + lLumWidth)>> 1]; |
|
63014 |
|
63015 lCr4 = (lCr1 + lCr3) >> 1; |
|
63016 lCb4 = (lCb1 + lCb3) >> 1; |
|
63017 |
|
63018 lCr1 -= 128; |
|
63019 lCb1 -= 128; |
|
63020 |
|
63021 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
63022 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
63023 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
63024 |
|
63025 /*First Pixel*/ |
|
63026 lY1 = lLumPtr[k]; |
|
63027 lY1 -= 16; |
|
63028 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63029 |
|
63030 lTemp = lY1 + lTemp1; |
|
63031 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63032 |
|
63033 lTemp = lY1 - lTemp2; |
|
63034 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63035 |
|
63036 lTemp = lY1 + lTemp3; |
|
63037 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63038 |
|
63039 /*Second Pixel*/ |
|
63040 lY1 = lLumPtr[k + 1]; |
|
63041 lY1 -= 16; |
|
63042 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63043 |
|
63044 lTemp = lY1 + lTemp1; |
|
63045 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63046 |
|
63047 lTemp = lY1 - lTemp2; |
|
63048 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63049 |
|
63050 lTemp = lY1 + lTemp3; |
|
63051 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63052 |
|
63053 |
|
63054 lCr4 -= 128; |
|
63055 lCb4 -= 128; |
|
63056 |
|
63057 lTemp1 = (26748 * lCr4) >> COLOR_CONV_PRECISION; |
|
63058 lTemp2 = ((6563 * lCb4) + (13621 * lCr4)) >> COLOR_CONV_PRECISION; |
|
63059 lTemp3 = (33802 * lCb4) >> COLOR_CONV_PRECISION; |
|
63060 |
|
63061 /*Third Pixel*/ |
|
63062 lY1 = lLumPtr[k + lLumWidth]; |
|
63063 lY1 -= 16; |
|
63064 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63065 |
|
63066 lTemp = lY1 + lTemp1; |
|
63067 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63068 |
|
63069 lTemp = lY1 - lTemp2; |
|
63070 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63071 |
|
63072 lTemp = lY1 + lTemp3; |
|
63073 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63074 |
|
63075 /*Fourth Pixel*/ |
|
63076 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
63077 lY1 -= 16; |
|
63078 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63079 |
|
63080 lTemp = lY1 + lTemp1; |
|
63081 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63082 |
|
63083 lTemp = lY1 - lTemp2; |
|
63084 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63085 |
|
63086 lTemp = lY1 + lTemp3; |
|
63087 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63088 |
|
63089 |
|
63090 lCr3 -= 128; |
|
63091 lCb3 -= 128; |
|
63092 |
|
63093 lTemp1 = (26748 * lCr3) >> COLOR_CONV_PRECISION; |
|
63094 lTemp2 = ((6563 * lCb3) + (13621 * lCr3)) >> COLOR_CONV_PRECISION; |
|
63095 lTemp3 = (33802 * lCb3) >> COLOR_CONV_PRECISION; |
|
63096 |
|
63097 /*Fifth Pixel*/ |
|
63098 lY1 = lLumPtr[k + (lLumWidth << 1)]; |
|
63099 lY1 -= 16; |
|
63100 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63101 |
|
63102 lTemp = lY1 + lTemp1; |
|
63103 *(src2 + lSrcWidth) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63104 |
|
63105 lTemp = lY1 - lTemp2; |
|
63106 *(src2 + lSrcWidth + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63107 |
|
63108 lTemp = lY1 + lTemp3; |
|
63109 *(src2 + lSrcWidth + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63110 |
|
63111 /*Sixth Pixel*/ |
|
63112 lY1 = lLumPtr[k + (lLumWidth << 1) + 1]; |
|
63113 lY1 -= 16; |
|
63114 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63115 |
|
63116 lTemp = lY1 + lTemp1; |
|
63117 *(src2 + lSrcWidth + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63118 |
|
63119 lTemp = lY1 - lTemp2; |
|
63120 *(src2 + lSrcWidth + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63121 |
|
63122 lTemp = lY1 + lTemp3; |
|
63123 *(src2 + lSrcWidth + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63124 |
|
63125 src1 += 6; |
|
63126 src2 += 6; |
|
63127 |
|
63128 |
|
63129 src1 = lPtr1; |
|
63130 src2 = lPtr2; |
|
63131 |
|
63132 for(j = 0; j < lWidth; j += 2) |
|
63133 { |
|
63134 /* First Pixel */ |
|
63135 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
63136 diff1 = *src1 & 0xf; |
|
63137 diff2 = *(src1 + 1) & 0xf; |
|
63138 diff3 = *(src1 + 2) & 0xf; |
|
63139 |
|
63140 // diffuse the error |
|
63141 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
63142 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
63143 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
63144 |
|
63145 /* Second Pixel */ |
|
63146 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
63147 diff1 = *(src1 + 3) & 0xf; |
|
63148 diff2 = *(src1 + 4) & 0xf; |
|
63149 diff3 = *(src1 + 5) & 0xf; |
|
63150 // diffuse the error |
|
63151 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
63152 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
63153 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
63154 |
|
63155 src1 += 6; |
|
63156 dest1 += 2; |
|
63157 |
|
63158 /* Third Pixel */ |
|
63159 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
63160 diff1 = *src2 & 0xf; |
|
63161 diff2 = *(src2 + 1) & 0xf; |
|
63162 diff3 = *(src2 + 2) & 0xf; |
|
63163 //diffuse the error |
|
63164 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
63165 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
63166 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
63167 |
|
63168 /* Fourth Pixel */ |
|
63169 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
63170 diff1 = *(src2 + 3) & 0xf; |
|
63171 diff2 = *(src2 + 4) & 0xf; |
|
63172 diff3 = *(src2 + 5) & 0xf; |
|
63173 //diffuse the error |
|
63174 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
63175 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
63176 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
63177 |
|
63178 src2 += 6; |
|
63179 dest2 += 2; |
|
63180 } |
|
63181 if(extraCol) |
|
63182 { |
|
63183 *dest1 = dest1[-1]; |
|
63184 dest1++; |
|
63185 *dest2 = dest2[-1]; |
|
63186 dest2++; |
|
63187 } |
|
63188 |
|
63189 lLumPtr += (lLumWidth << 1); |
|
63190 lCrPtr += (lLumWidth >> 1); |
|
63191 lCbPtr += (lLumWidth >> 1); |
|
63192 |
|
63193 dest1 += ((wndWidth << 1) - lTempWidth); |
|
63194 dest2 += ((wndWidth << 1) - lTempWidth); |
|
63195 } |
|
63196 |
|
63197 |
|
63198 lPtr1 = src1 = lBuffer; |
|
63199 lPtr2 = src2 = src1 + lSrcWidth; |
|
63200 |
|
63201 for(k = 0; k < (lWidth - 2); k += 2) |
|
63202 { |
|
63203 lCr1 = lCrPtr[k >> 1]; |
|
63204 lCb1 = lCbPtr[k >> 1]; |
|
63205 |
|
63206 lCr2 = lCrPtr[(k >> 1) + 1]; |
|
63207 lCb2 = lCbPtr[(k >> 1) + 1]; |
|
63208 |
|
63209 lCr2 = (lCr1 + lCr2) >> 1; |
|
63210 lCb2 = (lCb1 + lCb2) >> 1; |
|
63211 |
|
63212 |
|
63213 lCr1 -= 128; |
|
63214 lCb1 -= 128; |
|
63215 |
|
63216 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
63217 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
63218 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
63219 |
|
63220 /*First Pixel*/ |
|
63221 lY1 = lLumPtr[k]; |
|
63222 lY1 -= 16; |
|
63223 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63224 |
|
63225 lTemp = lY1 + lTemp1; |
|
63226 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63227 |
|
63228 lTemp = lY1 - lTemp2; |
|
63229 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63230 |
|
63231 lTemp = lY1 + lTemp3; |
|
63232 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63233 |
|
63234 /*Third Pixel*/ |
|
63235 lY1 = lLumPtr[k + lLumWidth]; |
|
63236 lY1 -= 16; |
|
63237 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63238 |
|
63239 lTemp = lY1 + lTemp1; |
|
63240 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63241 |
|
63242 lTemp = lY1 - lTemp2; |
|
63243 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63244 |
|
63245 lTemp = lY1 + lTemp3; |
|
63246 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63247 |
|
63248 |
|
63249 lCr2 -= 128; |
|
63250 lCb2 -= 128; |
|
63251 |
|
63252 lTemp1 = (26748 * lCr2) >> COLOR_CONV_PRECISION; |
|
63253 lTemp2 = ((6563 * lCb2) + (13621 * lCr2)) >> COLOR_CONV_PRECISION; |
|
63254 lTemp3 = (33802 * lCb2) >> COLOR_CONV_PRECISION; |
|
63255 |
|
63256 /*Second Pixel*/ |
|
63257 lY1 = lLumPtr[k + 1]; |
|
63258 lY1 -= 16; |
|
63259 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63260 |
|
63261 lTemp = lY1 + lTemp1; |
|
63262 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63263 |
|
63264 lTemp = lY1 - lTemp2; |
|
63265 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63266 |
|
63267 lTemp = lY1 + lTemp3; |
|
63268 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63269 |
|
63270 /*Fourth Pixel*/ |
|
63271 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
63272 lY1 -= 16; |
|
63273 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63274 |
|
63275 lTemp = lY1 + lTemp1; |
|
63276 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63277 |
|
63278 lTemp = lY1 - lTemp2; |
|
63279 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63280 |
|
63281 lTemp = lY1 + lTemp3; |
|
63282 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63283 |
|
63284 src1 += 6; |
|
63285 src2 += 6; |
|
63286 } |
|
63287 |
|
63288 lCr1 = lCrPtr[k >> 1]; |
|
63289 lCb1 = lCbPtr[k >> 1]; |
|
63290 |
|
63291 lCr1 -= 128; |
|
63292 lCb1 -= 128; |
|
63293 |
|
63294 lTemp1 = (26748 * lCr1) >> COLOR_CONV_PRECISION; |
|
63295 lTemp2 = ((6563 * lCb1) + (13621 * lCr1)) >> COLOR_CONV_PRECISION; |
|
63296 lTemp3 = (33802 * lCb1) >> COLOR_CONV_PRECISION; |
|
63297 |
|
63298 /*First Pixel*/ |
|
63299 lY1 = lLumPtr[k]; |
|
63300 lY1 -= 16; |
|
63301 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63302 |
|
63303 lTemp = lY1 + lTemp1; |
|
63304 *src1 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63305 |
|
63306 lTemp = lY1 - lTemp2; |
|
63307 *(src1 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63308 |
|
63309 lTemp = lY1 + lTemp3; |
|
63310 *(src1 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63311 |
|
63312 /*Second Pixel*/ |
|
63313 lY1 = lLumPtr[k + 1]; |
|
63314 lY1 -= 16; |
|
63315 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63316 |
|
63317 lTemp = lY1 + lTemp1; |
|
63318 *(src1 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63319 |
|
63320 lTemp = lY1 - lTemp2; |
|
63321 *(src1 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63322 |
|
63323 lTemp = lY1 + lTemp3; |
|
63324 *(src1 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63325 |
|
63326 /*Third Pixel*/ |
|
63327 lY1 = lLumPtr[k + lLumWidth]; |
|
63328 lY1 -= 16; |
|
63329 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63330 |
|
63331 lTemp = lY1 + lTemp1; |
|
63332 *src2 = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63333 |
|
63334 lTemp = lY1 - lTemp2; |
|
63335 *(src2 + 1) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63336 |
|
63337 lTemp = lY1 + lTemp3; |
|
63338 *(src2 + 2) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63339 |
|
63340 /*Fourth Pixel*/ |
|
63341 lY1 = lLumPtr[k + lLumWidth + 1]; |
|
63342 lY1 -= 16; |
|
63343 lY1 = (lY1 * 19075) >> COLOR_CONV_PRECISION; |
|
63344 |
|
63345 lTemp = lY1 + lTemp1; |
|
63346 *(src2 + 3) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63347 |
|
63348 lTemp = lY1 - lTemp2; |
|
63349 *(src2 + 4) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63350 |
|
63351 lTemp = lY1 + lTemp3; |
|
63352 *(src2 + 5) = (uint8)((lTemp > 235) ? 235 : ((lTemp < 16) ? 16 : lTemp)); |
|
63353 |
|
63354 src1 += 6; |
|
63355 src2 += 6; |
|
63356 |
|
63357 |
|
63358 src1 = lPtr1; |
|
63359 src2 = lPtr2; |
|
63360 |
|
63361 for(j = 0; j < lWidth; j += 2) |
|
63362 { |
|
63363 /* First Pixel */ |
|
63364 *dest1 = (uint16) (*(src1 + 2) >> 4 | (*(src1 + 1) >> 4) << 4 | (*src1 >> 4) << 8); |
|
63365 diff1 = *src1 & 0xf; |
|
63366 diff2 = *(src1 + 1) & 0xf; |
|
63367 diff3 = *(src1 + 2) & 0xf; |
|
63368 |
|
63369 // diffuse the error |
|
63370 sDiffuse(i,j,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
63371 sDiffuse(i,j,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
63372 sDiffuse(i,j,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
63373 |
|
63374 /* Second Pixel */ |
|
63375 *(dest1 + 1) = (uint16) (*(src1 + 5) >> 4 | (*(src1 + 4) >> 4) << 4 | (*(src1 + 3) >> 4) << 8); |
|
63376 diff1 = *(src1 + 3) & 0xf; |
|
63377 diff2 = *(src1 + 4) & 0xf; |
|
63378 diff3 = *(src1 + 5) & 0xf; |
|
63379 // diffuse the error |
|
63380 sDiffuse(i,j+1,diff1,lWidth,lHeight,lPtr1,lSrcWidth, 3); //r |
|
63381 sDiffuse(i,j+1,diff2,lWidth,lHeight,lPtr1 + 1,lSrcWidth, 3); //g |
|
63382 sDiffuse(i,j+1,diff3,lWidth,lHeight,lPtr1 + 2,lSrcWidth, 3); //b |
|
63383 |
|
63384 src1 += 6; |
|
63385 dest1 += 2; |
|
63386 |
|
63387 /* Third Pixel */ |
|
63388 *dest2 = (uint16) (*(src2 + 2) >> 4 | (*(src2 + 1) >> 4) << 4 | (*src2 >> 4) << 8); |
|
63389 diff1 = *src2 & 0xf; |
|
63390 diff2 = *(src2 + 1) & 0xf; |
|
63391 diff3 = *(src2 + 2) & 0xf; |
|
63392 //diffuse the error |
|
63393 sDiffuse(i+1,j,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
63394 sDiffuse(i+1,j,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
63395 sDiffuse(i+1,j,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
63396 |
|
63397 /* Fourth Pixel */ |
|
63398 *(dest2 + 1) = (uint16) (*(src2 + 5) >> 4 | (*(src2 + 4) >> 4) << 4 | (*(src2 + 3) >> 4) << 8); |
|
63399 diff1 = *(src2 + 3) & 0xf; |
|
63400 diff2 = *(src2 + 4) & 0xf; |
|
63401 diff3 = *(src2 + 5) & 0xf; |
|
63402 //diffuse the error |
|
63403 sDiffuse(i+1,j+1,diff1,lWidth,lHeight,lPtr2,lSrcWidth, 3); //r |
|
63404 sDiffuse(i+1,j+1,diff2,lWidth,lHeight,lPtr2 + 1,lSrcWidth, 3); //g |
|
63405 sDiffuse(i+1,j+1,diff3,lWidth,lHeight,lPtr2 + 2,lSrcWidth, 3); //b |
|
63406 |
|
63407 src2 += 6; |
|
63408 dest2 += 2; |
|
63409 } |
|
63410 |
|
63411 if(extraCol) |
|
63412 { |
|
63413 *dest1 = dest1[-1]; |
|
63414 dest1++; |
|
63415 *dest2 = dest2[-1]; |
|
63416 dest2++; |
|
63417 } |
|
63418 |
|
63419 dest1 += ((wndWidth << 1) - lTempWidth); |
|
63420 dest2 += ((wndWidth << 1) - lTempWidth); |
|
63421 |
|
63422 if(extraRow) |
|
63423 { |
|
63424 dest2 = dest1 - wndWidth; |
|
63425 for(j = 0; j < lWidth; j += 2) |
|
63426 { |
|
63427 *dest1++ = *dest2++; |
|
63428 *dest1++ = *dest2++; |
|
63429 } |
|
63430 if(extraCol) |
|
63431 { |
|
63432 *dest1 = *dest2; |
|
63433 } |
|
63434 } |
|
63435 |
|
63436 free(lBuffer); |
|
63437 return; |
|
63438 } |
|
63439 |
|
63440 /* |
|
63441 ****************************************************************************** |
|
63442 Name : sDiffuse |
|
63443 Description : Diffuses the quantization error to the neighbouring pixels. |
|
63444 Parameter : int32 i : x position of the current pixel. |
|
63445 int32 j : y position of the current pixel. |
|
63446 int32 diff : error to be diffused. |
|
63447 int32 actWidth : Source Width |
|
63448 int32 actHeight : Source Height |
|
63449 uint8 *lLumPtr : |
|
63450 int32 lLumWidth : |
|
63451 uint8 skip : |
|
63452 |
|
63453 Return Value : void |
|
63454 ****************************************************************************** |
|
63455 */ |
|
63456 |
|
63457 void sDiffuse(int32 i, int32 j, int32 diff, int32 actWidth, int32 actHeight, uint8 *lLumPtr, |
|
63458 int32 lLumWidth, uint8 skip) |
|
63459 { |
|
63460 int32 tmp; |
|
63461 |
|
63462 if(i < actHeight - 2) |
|
63463 { |
|
63464 if(j < actWidth - 2) |
|
63465 { |
|
63466 if(j > 1) |
|
63467 { |
|
63468 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63469 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63470 |
|
63471 tmp = lLumPtr[(j - 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63472 lLumPtr[(j - 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63473 |
|
63474 tmp = lLumPtr[j * skip + lLumWidth] + ((diff << 4) >> 6); |
|
63475 lLumPtr[j * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63476 |
|
63477 tmp = lLumPtr[(j + 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63478 lLumPtr[(j + 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63479 |
|
63480 } |
|
63481 else if(j > 0) |
|
63482 { |
|
63483 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63484 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63485 |
|
63486 tmp = lLumPtr[(j - 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63487 lLumPtr[(j - 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63488 |
|
63489 tmp = lLumPtr[j * skip + lLumWidth] + ((diff << 4) >> 6); |
|
63490 lLumPtr[j * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63491 |
|
63492 tmp = lLumPtr[(j + 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63493 lLumPtr[(j + 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63494 |
|
63495 } |
|
63496 else |
|
63497 { |
|
63498 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63499 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63500 |
|
63501 tmp = lLumPtr[j * skip + lLumWidth] + ((diff << 4) >> 6); |
|
63502 lLumPtr[j * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63503 |
|
63504 tmp = lLumPtr[(j + 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63505 lLumPtr[(j + 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63506 |
|
63507 } |
|
63508 } |
|
63509 else if(j < actWidth - 1) |
|
63510 { |
|
63511 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63512 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63513 |
|
63514 tmp = lLumPtr[(j - 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63515 lLumPtr[(j - 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63516 |
|
63517 tmp = lLumPtr[j * skip + lLumWidth] + ((diff << 4) >> 6); |
|
63518 lLumPtr[j * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63519 |
|
63520 tmp = lLumPtr[(j + 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63521 lLumPtr[(j + 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63522 |
|
63523 } |
|
63524 else |
|
63525 { |
|
63526 tmp = lLumPtr[(j - 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63527 lLumPtr[(j - 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63528 |
|
63529 tmp = lLumPtr[j * skip + lLumWidth] + ((diff << 4) >> 6); |
|
63530 lLumPtr[j * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63531 |
|
63532 } |
|
63533 } |
|
63534 else if(i < actHeight - 1) |
|
63535 { |
|
63536 if(j < actWidth - 2) |
|
63537 { |
|
63538 if(j > 1) |
|
63539 { |
|
63540 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63541 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63542 |
|
63543 tmp = lLumPtr[(j - 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63544 lLumPtr[(j - 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63545 |
|
63546 tmp = lLumPtr[j * skip + lLumWidth] + ((diff << 4) >> 6); |
|
63547 lLumPtr[j * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63548 |
|
63549 tmp = lLumPtr[(j + 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63550 lLumPtr[(j + 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63551 |
|
63552 } |
|
63553 else if(j > 0) |
|
63554 { |
|
63555 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63556 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63557 |
|
63558 tmp = lLumPtr[(j - 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63559 lLumPtr[(j - 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63560 |
|
63561 tmp = lLumPtr[j * skip + lLumWidth] + ((diff << 4) >> 6); |
|
63562 lLumPtr[j * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63563 |
|
63564 tmp = lLumPtr[(j + 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63565 lLumPtr[(j + 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63566 |
|
63567 } |
|
63568 else |
|
63569 { |
|
63570 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63571 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63572 |
|
63573 tmp = lLumPtr[j * skip + lLumWidth] + ((diff << 4) >> 6); |
|
63574 lLumPtr[j * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63575 |
|
63576 tmp = lLumPtr[(j + 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63577 lLumPtr[(j + 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63578 |
|
63579 } |
|
63580 } |
|
63581 else if(j < actWidth - 1) |
|
63582 { |
|
63583 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63584 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63585 |
|
63586 tmp = lLumPtr[(j - 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63587 lLumPtr[(j - 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63588 |
|
63589 tmp = lLumPtr[j * skip + lLumWidth] + ((diff << 4) >> 6); |
|
63590 lLumPtr[j * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63591 |
|
63592 tmp = lLumPtr[(j + 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63593 lLumPtr[(j + 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63594 |
|
63595 } |
|
63596 else |
|
63597 { |
|
63598 tmp = lLumPtr[(j - 1) * skip + lLumWidth] + ((diff << 3) >> 6); |
|
63599 lLumPtr[(j - 1) * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63600 |
|
63601 tmp = lLumPtr[j * skip + lLumWidth] + ((diff << 4) >> 6); |
|
63602 lLumPtr[j * skip + lLumWidth] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63603 |
|
63604 } |
|
63605 } |
|
63606 else |
|
63607 { |
|
63608 if(j < actWidth - 2) |
|
63609 { |
|
63610 if(j > 1) |
|
63611 { |
|
63612 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63613 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63614 |
|
63615 } |
|
63616 else if(j > 0) |
|
63617 { |
|
63618 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63619 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63620 |
|
63621 } |
|
63622 else |
|
63623 { |
|
63624 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63625 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63626 |
|
63627 } |
|
63628 } |
|
63629 else if(j < actWidth - 1) |
|
63630 { |
|
63631 tmp = lLumPtr[(j + 1) * skip] + ((diff * 24) >> 6); |
|
63632 lLumPtr[(j + 1) * skip] = (uint8)((tmp > 255) ? 255 : ((tmp < 0) ? 0 : tmp)); |
|
63633 |
|
63634 } |
|
63635 else |
|
63636 { |
|
63637 return; |
|
63638 } |
|
63639 } |
|
63640 |
|
63641 return; |
|
63642 } |
|
63643 |
|
63644 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
63645 /**************** End of Chroma3 format *********************/ |
|
63646 /*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ |
|
63647 |
|
63648 |