Line data Source code
1 : /*
2 : * Copyright(c) 2019 Intel Corporation
3 : * SPDX - License - Identifier: BSD - 2 - Clause - Patent
4 : */
5 :
6 : #include <stdlib.h>
7 : #include <string.h>
8 :
9 : #include "EbNeighborArrays.h"
10 : #include "EbUtility.h"
11 : #include "EbPictureOperators.h"
12 :
13 : #define UNUSED(x) (void)(x)
14 :
15 30 : static void neighbor_array_unit_dctor32(EbPtr p)
16 : {
17 30 : NeighborArrayUnit32 *obj = (NeighborArrayUnit32*)p;
18 30 : EB_FREE(obj->left_array);
19 30 : EB_FREE(obj->top_array);
20 30 : EB_FREE(obj->top_left_array);
21 30 : }
22 : /*************************************************
23 : * Neighbor Array Unit Ctor
24 : *************************************************/
25 30 : EbErrorType neighbor_array_unit_ctor32(
26 : NeighborArrayUnit32 *na_unit_ptr,
27 : uint32_t max_picture_width,
28 : uint32_t max_picture_height,
29 : uint32_t unit_size,
30 : uint32_t granularity_normal,
31 : uint32_t granularity_top_left,
32 : uint32_t type_mask)
33 : {
34 30 : na_unit_ptr->dctor = neighbor_array_unit_dctor32;
35 30 : na_unit_ptr->unit_size = (uint8_t)(unit_size);
36 30 : na_unit_ptr->granularity_normal = (uint8_t)(granularity_normal);
37 30 : na_unit_ptr->granularity_normal_log2 = (uint8_t)(Log2f(na_unit_ptr->granularity_normal));
38 30 : na_unit_ptr->granularity_top_left = (uint8_t)(granularity_top_left);
39 30 : na_unit_ptr->granularity_top_left_log2 = (uint8_t)(Log2f(na_unit_ptr->granularity_top_left));
40 30 : na_unit_ptr->left_array_size = (uint16_t)((type_mask & NEIGHBOR_ARRAY_UNIT_LEFT_MASK) ? max_picture_height >> na_unit_ptr->granularity_normal_log2 : 0);
41 30 : na_unit_ptr->top_array_size = (uint16_t)((type_mask & NEIGHBOR_ARRAY_UNIT_TOP_MASK) ? max_picture_width >> na_unit_ptr->granularity_normal_log2 : 0);
42 30 : na_unit_ptr->top_left_array_size = (uint16_t)((type_mask & NEIGHBOR_ARRAY_UNIT_TOPLEFT_MASK) ? (max_picture_width + max_picture_height) >> na_unit_ptr->granularity_top_left_log2 : 0);
43 :
44 30 : if (na_unit_ptr->left_array_size) {
45 30 : EB_MALLOC(na_unit_ptr->left_array, na_unit_ptr->unit_size * na_unit_ptr->left_array_size);
46 : }
47 :
48 30 : if (na_unit_ptr->top_array_size) {
49 30 : EB_MALLOC(na_unit_ptr->top_array, na_unit_ptr->unit_size * na_unit_ptr->top_array_size);
50 : }
51 :
52 30 : if (na_unit_ptr->top_left_array_size) {
53 0 : EB_MALLOC(na_unit_ptr->top_left_array, na_unit_ptr->unit_size * na_unit_ptr->top_left_array_size);
54 : }
55 30 : return EB_ErrorNone;
56 : }
57 :
58 600 : static void neighbor_array_unit_dctor(EbPtr p)
59 : {
60 600 : NeighborArrayUnit *obj = (NeighborArrayUnit*)p;
61 600 : EB_FREE(obj->left_array);
62 600 : EB_FREE(obj->top_array);
63 600 : EB_FREE(obj->top_left_array);
64 600 : }
65 :
66 600 : EbErrorType neighbor_array_unit_ctor(
67 : NeighborArrayUnit *na_unit_ptr,
68 : uint32_t max_picture_width,
69 : uint32_t max_picture_height,
70 : uint32_t unit_size,
71 : uint32_t granularity_normal,
72 : uint32_t granularity_top_left,
73 : uint32_t type_mask)
74 : {
75 600 : na_unit_ptr->dctor = neighbor_array_unit_dctor;
76 600 : na_unit_ptr->unit_size = (uint8_t)(unit_size);
77 600 : na_unit_ptr->granularity_normal = (uint8_t)(granularity_normal);
78 600 : na_unit_ptr->granularity_normal_log2 = (uint8_t)(Log2f(na_unit_ptr->granularity_normal));
79 600 : na_unit_ptr->granularity_top_left = (uint8_t)(granularity_top_left);
80 600 : na_unit_ptr->granularity_top_left_log2 = (uint8_t)(Log2f(na_unit_ptr->granularity_top_left));
81 600 : na_unit_ptr->left_array_size = (uint16_t)((type_mask & NEIGHBOR_ARRAY_UNIT_LEFT_MASK) ? max_picture_height >> na_unit_ptr->granularity_normal_log2 : 0);
82 600 : na_unit_ptr->top_array_size = (uint16_t)((type_mask & NEIGHBOR_ARRAY_UNIT_TOP_MASK) ? max_picture_width >> na_unit_ptr->granularity_normal_log2 : 0);
83 600 : na_unit_ptr->top_left_array_size = (uint16_t)((type_mask & NEIGHBOR_ARRAY_UNIT_TOPLEFT_MASK) ? (max_picture_width + max_picture_height) >> na_unit_ptr->granularity_top_left_log2 : 0);
84 :
85 600 : if (na_unit_ptr->left_array_size) {
86 600 : EB_MALLOC(na_unit_ptr->left_array, na_unit_ptr->unit_size * na_unit_ptr->left_array_size);
87 : }
88 600 : if (na_unit_ptr->top_array_size) {
89 600 : EB_MALLOC(na_unit_ptr->top_array, na_unit_ptr->unit_size * na_unit_ptr->top_array_size);
90 : }
91 600 : if (na_unit_ptr->top_left_array_size) {
92 180 : EB_MALLOC(na_unit_ptr->top_left_array, na_unit_ptr->unit_size * na_unit_ptr->top_left_array_size);
93 : }
94 600 : return EB_ErrorNone;
95 : }
96 :
97 : /*************************************************
98 : * Neighbor Array Unit Reset
99 : *************************************************/
100 :
101 600 : void neighbor_array_unit_reset32(NeighborArrayUnit32 *na_unit_ptr)
102 : {
103 600 : if (na_unit_ptr->left_array) {
104 600 : EB_MEMSET(na_unit_ptr->left_array, ~0, na_unit_ptr->unit_size * na_unit_ptr->left_array_size);
105 : }
106 :
107 600 : if (na_unit_ptr->top_array) {
108 600 : EB_MEMSET(na_unit_ptr->top_array, ~0, na_unit_ptr->unit_size * na_unit_ptr->top_array_size);
109 : }
110 :
111 600 : if (na_unit_ptr->top_left_array) {
112 0 : EB_MEMSET(na_unit_ptr->top_left_array, ~0, na_unit_ptr->unit_size * na_unit_ptr->top_left_array_size);
113 : }
114 :
115 600 : return;
116 : }
117 12000 : void neighbor_array_unit_reset(NeighborArrayUnit *na_unit_ptr)
118 : {
119 12000 : if (na_unit_ptr->left_array) {
120 12000 : EB_MEMSET(na_unit_ptr->left_array, ~0, na_unit_ptr->unit_size * na_unit_ptr->left_array_size);
121 : }
122 :
123 12000 : if (na_unit_ptr->top_array) {
124 12000 : EB_MEMSET(na_unit_ptr->top_array, ~0, na_unit_ptr->unit_size * na_unit_ptr->top_array_size);
125 : }
126 :
127 12000 : if (na_unit_ptr->top_left_array) {
128 3600 : EB_MEMSET(na_unit_ptr->top_left_array, ~0, na_unit_ptr->unit_size * na_unit_ptr->top_left_array_size);
129 : }
130 :
131 12000 : return;
132 : }
133 :
134 : /*************************************************
135 : * Neighbor Array Unit Get Top Index
136 : *************************************************/
137 0 : uint32_t GetNeighborArrayUnitTopLeftIndex32(
138 : NeighborArrayUnit32 *na_unit_ptr,
139 : int32_t loc_x,
140 : int32_t loc_y)
141 : {
142 0 : return na_unit_ptr->left_array_size + (loc_x >> na_unit_ptr->granularity_top_left_log2) - (loc_y >> na_unit_ptr->granularity_top_left_log2);
143 : }
144 :
145 13143100 : uint32_t get_neighbor_array_unit_top_left_index(
146 : NeighborArrayUnit *na_unit_ptr,
147 : int32_t loc_x,
148 : int32_t loc_y)
149 : {
150 13143100 : return na_unit_ptr->left_array_size + (loc_x >> na_unit_ptr->granularity_top_left_log2) - (loc_y >> na_unit_ptr->granularity_top_left_log2);
151 : }
152 :
153 2844740 : void update_recon_neighbor_array(
154 : NeighborArrayUnit *na_unit_ptr,
155 : uint8_t *src_ptr_top,
156 : uint8_t *src_ptr_left,
157 : uint32_t pic_origin_x,
158 : uint32_t pic_origin_y,
159 : uint32_t block_width,
160 : uint32_t block_height)
161 : {
162 : uint8_t *dst_ptr;
163 :
164 5689460 : dst_ptr = na_unit_ptr->top_array +
165 2844740 : get_neighbor_array_unit_top_index(
166 : na_unit_ptr,
167 2844720 : pic_origin_x) * na_unit_ptr->unit_size;
168 2844720 : EB_MEMCPY(dst_ptr, src_ptr_top, block_width);
169 :
170 5689360 : dst_ptr = na_unit_ptr->left_array +
171 2844680 : get_neighbor_array_unit_left_index(
172 : na_unit_ptr,
173 2844680 : pic_origin_y) * na_unit_ptr->unit_size;
174 2844680 : EB_MEMCPY(dst_ptr, src_ptr_left, block_height);
175 :
176 : //na_unit_ptr->top_left_array[ (MAX_PICTURE_HEIGHT_SIZE>>is_chroma) + pic_origin_x - pic_origin_y] = srcPtr2[block_height-1];
177 :
178 : /*
179 : // Top-left Neighbor Array
180 : //
181 : // 4-5--6--7--------------
182 : // 3 \ \
183 : // 2 \ \
184 : // 1 \ \
185 : // |\ xxxxxx7
186 : // | \ x 6
187 : // | \ x 5
188 : // | \1x2x3x4
189 : // |
190 : //
191 : // The top-left neighbor array is updated with the reversed samples
192 : // from the right column and bottom row of the source block
193 : //
194 : // Index = origin_x - origin_y
195 : */
196 :
197 : uint32_t idx;
198 :
199 : uint8_t *readPtr;
200 :
201 : int32_t dstStep;
202 : int32_t readStep;
203 : uint32_t count;
204 :
205 2844640 : readPtr = src_ptr_top;//+ ((block_height - 1) * stride);
206 :
207 : // Copy bottom row
208 2844680 : dst_ptr =
209 : // topLeftArray_chkn+
210 2844640 : na_unit_ptr->top_left_array +
211 2844640 : get_neighbor_array_unit_top_left_index(
212 : na_unit_ptr,
213 : pic_origin_x,
214 2844640 : pic_origin_y + (block_height - 1)) * na_unit_ptr->unit_size;
215 :
216 2844680 : EB_MEMCPY(dst_ptr, readPtr, block_width);
217 :
218 : // Reset readPtr to the right-column
219 2844670 : readPtr = src_ptr_left;// + (block_width - 1);
220 :
221 : // Copy right column
222 2844780 : dst_ptr =
223 : // topLeftArray_chkn+
224 2844670 : na_unit_ptr->top_left_array +
225 2844670 : get_neighbor_array_unit_top_left_index(
226 : na_unit_ptr,
227 2844670 : pic_origin_x + (block_width - 1),
228 2844780 : pic_origin_y) * na_unit_ptr->unit_size;
229 :
230 2844780 : dstStep = -1;
231 2844780 : readStep = 1;//stride;
232 2844780 : count = block_height;
233 :
234 30872900 : for (idx = 0; idx < count; ++idx) {
235 28028100 : *dst_ptr = *readPtr;
236 :
237 28028100 : dst_ptr += dstStep;
238 28028100 : readPtr += readStep;
239 : }
240 :
241 2844780 : return;
242 : }
243 :
244 0 : void update_recon_neighbor_array16bit(
245 : NeighborArrayUnit *na_unit_ptr,
246 : uint16_t *src_ptr_top,
247 : uint16_t *src_ptr_left,
248 : uint32_t pic_origin_x,
249 : uint32_t pic_origin_y,
250 : uint32_t block_width,
251 : uint32_t block_height)
252 : {
253 : uint16_t *dst_ptr;
254 0 : dst_ptr = (uint16_t *) (na_unit_ptr->top_array +
255 0 : get_neighbor_array_unit_top_index(na_unit_ptr, pic_origin_x) *
256 0 : na_unit_ptr->unit_size);
257 0 : EB_MEMCPY(dst_ptr, src_ptr_top, block_width * sizeof(uint16_t));
258 :
259 0 : dst_ptr = (uint16_t *) (na_unit_ptr->left_array +
260 0 : get_neighbor_array_unit_left_index(na_unit_ptr, pic_origin_y) *
261 0 : na_unit_ptr->unit_size);
262 0 : EB_MEMCPY(dst_ptr, src_ptr_left, block_height * sizeof(uint16_t));
263 :
264 : // Top-left Neighbor Array
265 : uint32_t idx;
266 0 : uint16_t *readPtr = src_ptr_top;
267 : int32_t dstStep;
268 : int32_t readStep;
269 : uint32_t count;
270 :
271 : // Copy bottom row
272 0 : dst_ptr = (uint16_t *) (na_unit_ptr->top_left_array +
273 0 : get_neighbor_array_unit_top_left_index(na_unit_ptr, pic_origin_x,
274 0 : pic_origin_y + (block_height - 1)) * na_unit_ptr->unit_size);
275 0 : EB_MEMCPY(dst_ptr, readPtr, block_width * sizeof(uint16_t));
276 :
277 : // Reset readPtr to the right-column
278 0 : readPtr = src_ptr_left;
279 :
280 : // Copy right column
281 0 : dst_ptr = (uint16_t *) (na_unit_ptr->top_left_array +
282 0 : get_neighbor_array_unit_top_left_index(
283 0 : na_unit_ptr, pic_origin_x + (block_width - 1), pic_origin_y) *
284 0 : na_unit_ptr->unit_size);
285 :
286 0 : dstStep = -1;
287 0 : readStep = 1;
288 0 : count = block_height;
289 0 : for (idx = 0; idx < count; ++idx) {
290 0 : *dst_ptr = *readPtr;
291 0 : dst_ptr += dstStep;
292 0 : readPtr += readStep;
293 : }
294 :
295 0 : return;
296 : }
297 :
298 : /*************************************************
299 : * Neighbor Array Sample Update
300 : *************************************************/
301 1572520 : void neighbor_array_unit_sample_write(
302 : NeighborArrayUnit *na_unit_ptr,
303 : uint8_t *src_ptr,
304 : uint32_t stride,
305 : uint32_t src_origin_x,
306 : uint32_t src_origin_y,
307 : uint32_t pic_origin_x,
308 : uint32_t pic_origin_y,
309 : uint32_t block_width,
310 : uint32_t block_height,
311 : uint32_t neighbor_array_type_mask)
312 : {
313 : uint32_t idx;
314 : uint8_t *dst_ptr;
315 : uint8_t *readPtr;
316 :
317 : int32_t dstStep;
318 : int32_t readStep;
319 : uint32_t count;
320 :
321 : // Adjust the Source ptr to start at the origin of the block being updated.
322 1572520 : src_ptr += ((src_origin_y * stride) + src_origin_x) * na_unit_ptr->unit_size;
323 :
324 1572520 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOP_MASK) {
325 : //
326 : // ----------12345678--------------------- Top Neighbor Array
327 : // ^ ^
328 : // | |
329 : // | |
330 : // xxxxxxxx
331 : // x x
332 : // x x
333 : // 12345678
334 : //
335 : // The top neighbor array is updated with the samples from the
336 : // bottom row of the source block
337 : //
338 : // Index = origin_x
339 :
340 : // Adjust readPtr to the bottom-row
341 1572530 : readPtr = src_ptr + ((block_height - 1) * stride);
342 :
343 3145060 : dst_ptr = na_unit_ptr->top_array +
344 1572530 : get_neighbor_array_unit_top_index(
345 : na_unit_ptr,
346 1572520 : pic_origin_x) * na_unit_ptr->unit_size;
347 :
348 1572520 : dstStep = na_unit_ptr->unit_size;
349 1572520 : readStep = na_unit_ptr->unit_size;
350 1572520 : count = block_width;
351 :
352 12823700 : for (idx = 0; idx < count; ++idx) {
353 11251100 : *dst_ptr = *readPtr;
354 :
355 11251100 : dst_ptr += dstStep;
356 11251100 : readPtr += readStep;
357 : }
358 : }
359 :
360 1572510 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_LEFT_MASK) {
361 : // Left Neighbor Array
362 : //
363 : // |
364 : // |
365 : // 1 xxxxxxx1
366 : // 2 <---- x 2
367 : // 3 <---- x 3
368 : // 4 xxxxxxx4
369 : // |
370 : // |
371 : //
372 : // The left neighbor array is updated with the samples from the
373 : // right column of the source block
374 : //
375 : // Index = origin_y
376 :
377 : // Adjust readPtr to the right-column
378 1572460 : readPtr = src_ptr + (block_width - 1);
379 :
380 3144950 : dst_ptr = na_unit_ptr->left_array +
381 1572460 : get_neighbor_array_unit_left_index(
382 : na_unit_ptr,
383 1572490 : pic_origin_y) * na_unit_ptr->unit_size;
384 :
385 1572490 : dstStep = 1;
386 1572490 : readStep = stride;
387 1572490 : count = block_height;
388 :
389 12871900 : for (idx = 0; idx < count; ++idx) {
390 11299400 : *dst_ptr = *readPtr;
391 :
392 11299400 : dst_ptr += dstStep;
393 11299400 : readPtr += readStep;
394 : }
395 : }
396 :
397 1572530 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOPLEFT_MASK) {
398 : /*
399 : // Top-left Neighbor Array
400 : //
401 : // 4-5--6--7--------------
402 : // 3 \ \
403 : // 2 \ \
404 : // 1 \ \
405 : // |\ xxxxxx7
406 : // | \ x 6
407 : // | \ x 5
408 : // | \1x2x3x4
409 : // |
410 : //
411 : // The top-left neighbor array is updated with the reversed samples
412 : // from the right column and bottom row of the source block
413 : //
414 : // Index = origin_x - origin_y
415 : */
416 :
417 : // Adjust readPtr to the bottom-row
418 1572460 : readPtr = src_ptr + ((block_height - 1) * stride);
419 :
420 : // Copy bottom row
421 1572450 : dst_ptr =
422 1572460 : na_unit_ptr->top_left_array +
423 1572460 : get_neighbor_array_unit_top_left_index(
424 : na_unit_ptr,
425 : pic_origin_x,
426 1572460 : pic_origin_y + (block_height - 1)) * na_unit_ptr->unit_size;
427 :
428 1572450 : EB_MEMCPY(dst_ptr, readPtr, block_width);
429 :
430 : // Reset readPtr to the right-column
431 1572440 : readPtr = src_ptr + (block_width - 1);
432 :
433 : // Copy right column
434 1572410 : dst_ptr =
435 1572440 : na_unit_ptr->top_left_array +
436 1572440 : get_neighbor_array_unit_top_left_index(
437 : na_unit_ptr,
438 1572440 : pic_origin_x + (block_width - 1),
439 1572410 : pic_origin_y) * na_unit_ptr->unit_size;
440 :
441 1572410 : dstStep = -1;
442 1572410 : readStep = stride;
443 1572410 : count = block_height;
444 :
445 12871400 : for (idx = 0; idx < count; ++idx) {
446 11299000 : *dst_ptr = *readPtr;
447 :
448 11299000 : dst_ptr += dstStep;
449 11299000 : readPtr += readStep;
450 : }
451 : }
452 :
453 1572480 : return;
454 : }
455 :
456 : /*************************************************
457 : * Neighbor Array Sample Update for 16 bit case
458 : *************************************************/
459 0 : void neighbor_array_unit16bit_sample_write(
460 : NeighborArrayUnit *na_unit_ptr,
461 : uint16_t *src_ptr,
462 : uint32_t stride,
463 : uint32_t src_origin_x,
464 : uint32_t src_origin_y,
465 : uint32_t pic_origin_x,
466 : uint32_t pic_origin_y,
467 : uint32_t block_width,
468 : uint32_t block_height,
469 : uint32_t neighbor_array_type_mask)
470 : {
471 : uint32_t idx;
472 : uint16_t *dst_ptr;
473 : uint16_t *readPtr;
474 :
475 : int32_t dstStep;
476 : int32_t readStep;
477 : uint32_t count;
478 :
479 : // Adjust the Source ptr to start at the origin of the block being updated.
480 0 : src_ptr += ((src_origin_y * stride) + src_origin_x)/*CHKN * na_unit_ptr->unit_size*/;
481 :
482 0 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOP_MASK) {
483 : //
484 : // ----------12345678--------------------- Top Neighbor Array
485 : // ^ ^
486 : // | |
487 : // | |
488 : // xxxxxxxx
489 : // x x
490 : // x x
491 : // 12345678
492 : //
493 : // The top neighbor array is updated with the samples from the
494 : // bottom row of the source block
495 : //
496 : // Index = origin_x
497 :
498 : // Adjust readPtr to the bottom-row
499 0 : readPtr = src_ptr + ((block_height - 1) * stride);
500 :
501 0 : dst_ptr = (uint16_t*)(na_unit_ptr->top_array) +
502 0 : get_neighbor_array_unit_top_index(
503 : na_unit_ptr,
504 : pic_origin_x);//CHKN * na_unit_ptr->unit_size;
505 :
506 0 : dstStep = na_unit_ptr->unit_size;
507 0 : readStep = na_unit_ptr->unit_size;
508 0 : count = block_width;
509 :
510 0 : for (idx = 0; idx < count; ++idx) {
511 0 : *dst_ptr = *readPtr;
512 :
513 0 : dst_ptr += 1;
514 0 : readPtr += 1;
515 : }
516 : }
517 :
518 0 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_LEFT_MASK) {
519 : // Left Neighbor Array
520 : //
521 : // |
522 : // |
523 : // 1 xxxxxxx1
524 : // 2 <---- x 2
525 : // 3 <---- x 3
526 : // 4 xxxxxxx4
527 : // |
528 : // |
529 : //
530 : // The left neighbor array is updated with the samples from the
531 : // right column of the source block
532 : //
533 : // Index = origin_y
534 :
535 : // Adjust readPtr to the right-column
536 0 : readPtr = src_ptr + (block_width - 1);
537 :
538 0 : dst_ptr = (uint16_t*)(na_unit_ptr->left_array) +
539 0 : get_neighbor_array_unit_left_index(
540 : na_unit_ptr,
541 : pic_origin_y);//CHKN * na_unit_ptr->unit_size;
542 :
543 0 : dstStep = 1;
544 0 : readStep = stride;
545 0 : count = block_height;
546 :
547 0 : for (idx = 0; idx < count; ++idx) {
548 0 : *dst_ptr = *readPtr;
549 :
550 0 : dst_ptr += dstStep;
551 0 : readPtr += readStep;
552 : }
553 : }
554 :
555 0 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOPLEFT_MASK) {
556 : /*
557 : // Top-left Neighbor Array
558 : //
559 : // 4-5--6--7--------------
560 : // 3 \ \
561 : // 2 \ \
562 : // 1 \ \
563 : // |\ xxxxxx7
564 : // | \ x 6
565 : // | \ x 5
566 : // | \1x2x3x4
567 : // |
568 : //
569 : // The top-left neighbor array is updated with the reversed samples
570 : // from the right column and bottom row of the source block
571 : //
572 : // Index = origin_x - origin_y
573 : */
574 :
575 : // Adjust readPtr to the bottom-row
576 0 : readPtr = src_ptr + ((block_height - 1) * stride);
577 :
578 : // Copy bottom row
579 0 : dst_ptr =
580 0 : (uint16_t*)(na_unit_ptr->top_left_array) +
581 0 : get_neighbor_array_unit_top_left_index(
582 : na_unit_ptr,
583 : pic_origin_x,
584 0 : pic_origin_y + (block_height - 1));
585 :
586 0 : dstStep = 1;
587 0 : readStep = 1;
588 0 : count = block_width;
589 :
590 0 : for (idx = 0; idx < count; ++idx) {
591 0 : *dst_ptr = *readPtr;
592 :
593 0 : dst_ptr += dstStep;
594 0 : readPtr += readStep;
595 : }
596 :
597 : // Reset readPtr to the right-column
598 0 : readPtr = src_ptr + (block_width - 1);
599 :
600 : // Copy right column
601 0 : dst_ptr =
602 0 : (uint16_t*)(na_unit_ptr->top_left_array) +
603 0 : get_neighbor_array_unit_top_left_index(
604 : na_unit_ptr,
605 0 : pic_origin_x + (block_width - 1),
606 : pic_origin_y);//CHKN * na_unit_ptr->unit_size;
607 :
608 0 : dstStep = -1;
609 0 : readStep = stride;
610 0 : count = block_height;
611 :
612 0 : for (idx = 0; idx < count; ++idx) {
613 0 : *dst_ptr = *readPtr;
614 :
615 0 : dst_ptr += dstStep;
616 0 : readPtr += readStep;
617 : }
618 : }
619 :
620 0 : return;
621 : }
622 : /*************************************************
623 : * Neighbor Array Unit Mode Write
624 : *************************************************/
625 1166690 : void neighbor_array_unit_mode_write32(
626 : NeighborArrayUnit32 *na_unit_ptr,
627 : uint32_t value,
628 : uint32_t origin_x,
629 : uint32_t origin_y,
630 : uint32_t block_width,
631 : uint32_t block_height,
632 : uint32_t neighbor_array_type_mask)
633 : {
634 : uint32_t idx;
635 : uint32_t *dst_ptr;
636 :
637 : uint32_t count;
638 : uint32_t naOffset;
639 : uint32_t naUnitSize;
640 :
641 1166690 : naUnitSize = 1;//na_unit_ptr->unit_size;
642 :
643 1166690 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOP_MASK) {
644 : //
645 : // ----------12345678--------------------- Top Neighbor Array
646 : // ^ ^
647 : // | |
648 : // | |
649 : // xxxxxxxx
650 : // x x
651 : // x x
652 : // 12345678
653 : //
654 : // The top neighbor array is updated with the samples from the
655 : // bottom row of the source block
656 : //
657 : // Index = origin_x
658 :
659 1166700 : naOffset = get_neighbor_array_unit_top_index32(
660 : na_unit_ptr,
661 : origin_x);
662 :
663 1166700 : dst_ptr = na_unit_ptr->top_array +
664 1166700 : naOffset * naUnitSize;
665 :
666 1166700 : count = block_width >> na_unit_ptr->granularity_normal_log2;
667 :
668 4809440 : for (idx = 0; idx < count; ++idx) {
669 3642760 : memset32bit(dst_ptr, value, naUnitSize);
670 :
671 3642750 : dst_ptr += naUnitSize;
672 : }
673 : }
674 :
675 1166680 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_LEFT_MASK) {
676 : // Left Neighbor Array
677 : //
678 : // |
679 : // |
680 : // 1 xxxxxxx1
681 : // 2 <---- x 2
682 : // 3 <---- x 3
683 : // 4 xxxxxxx4
684 : // |
685 : // |
686 : //
687 : // The left neighbor array is updated with the samples from the
688 : // right column of the source block
689 : //
690 : // Index = origin_y
691 :
692 1166700 : naOffset = get_neighbor_array_unit_left_index32(
693 : na_unit_ptr,
694 : origin_y);
695 :
696 1166700 : dst_ptr = na_unit_ptr->left_array +
697 1166700 : naOffset * naUnitSize;
698 :
699 1166700 : count = block_height >> na_unit_ptr->granularity_normal_log2;
700 :
701 4821340 : for (idx = 0; idx < count; ++idx) {
702 3654660 : memset32bit(dst_ptr, value, naUnitSize);
703 :
704 3654650 : dst_ptr += naUnitSize;
705 : }
706 : }
707 :
708 1166660 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOPLEFT_MASK) {
709 : /*
710 : // Top-left Neighbor Array
711 : //
712 : // 4-5--6--7------------
713 : // 3 \ \
714 : // 2 \ \
715 : // 1 \ \
716 : // |\ xxxxxx7
717 : // | \ x 6
718 : // | \ x 5
719 : // | \1x2x3x4
720 : // |
721 : //
722 : // The top-left neighbor array is updated with the reversed samples
723 : // from the right column and bottom row of the source block
724 : //
725 : // Index = origin_x - origin_y
726 : */
727 :
728 0 : naOffset = GetNeighborArrayUnitTopLeftIndex32(
729 : na_unit_ptr,
730 : origin_x,
731 0 : origin_y + (block_height - 1));
732 :
733 : // Copy bottom-row + right-column
734 : // *Note - start from the bottom-left corner
735 0 : dst_ptr = na_unit_ptr->top_left_array +
736 0 : naOffset * naUnitSize;
737 :
738 0 : count = ((block_width + block_height) >> na_unit_ptr->granularity_top_left_log2) - 1;
739 :
740 0 : for (idx = 0; idx < count; ++idx) {
741 0 : memset32bit(dst_ptr, value, naUnitSize);
742 :
743 0 : dst_ptr += naUnitSize;
744 : }
745 : }
746 :
747 1166660 : return;
748 : }
749 :
750 17863200 : void neighbor_array_unit_mode_write(
751 : NeighborArrayUnit *na_unit_ptr,
752 : uint8_t *value,
753 : uint32_t origin_x,
754 : uint32_t origin_y,
755 : uint32_t block_width,
756 : uint32_t block_height,
757 : uint32_t neighbor_array_type_mask)
758 : {
759 : uint32_t idx, j;
760 : uint8_t *dst_ptr;
761 :
762 : uint32_t count;
763 : uint32_t naOffset;
764 : uint32_t naUnitSize;
765 :
766 17863200 : naUnitSize = na_unit_ptr->unit_size;
767 :
768 17863200 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOP_MASK) {
769 : //
770 : // ----------12345678--------------------- Top Neighbor Array
771 : // ^ ^
772 : // | |
773 : // | |
774 : // xxxxxxxx
775 : // x x
776 : // x x
777 : // 12345678
778 : //
779 : // The top neighbor array is updated with the samples from the
780 : // bottom row of the source block
781 : //
782 : // Index = origin_x
783 :
784 16648400 : naOffset = get_neighbor_array_unit_top_index(
785 : na_unit_ptr,
786 : origin_x);
787 :
788 16647100 : dst_ptr = na_unit_ptr->top_array +
789 16647100 : naOffset * naUnitSize;
790 :
791 16647100 : count = block_width >> na_unit_ptr->granularity_normal_log2;
792 :
793 62228800 : for (idx = 0; idx < count; ++idx) {
794 : /* memcpy less that 10 bytes*/
795 96403700 : for (j = 0; j < naUnitSize; ++j)
796 50822000 : dst_ptr[j] = value[j];
797 :
798 45581800 : dst_ptr += naUnitSize;
799 : }
800 : }
801 :
802 17861800 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_LEFT_MASK) {
803 : // Left Neighbor Array
804 : //
805 : // |
806 : // |
807 : // 1 xxxxxxx1
808 : // 2 <---- x 2
809 : // 3 <---- x 3
810 : // 4 xxxxxxx4
811 : // |
812 : // |
813 : //
814 : // The left neighbor array is updated with the samples from the
815 : // right column of the source block
816 : //
817 : // Index = origin_y
818 :
819 16649000 : naOffset = get_neighbor_array_unit_left_index(
820 : na_unit_ptr,
821 : origin_y);
822 :
823 16647500 : dst_ptr = na_unit_ptr->left_array +
824 16647500 : naOffset * naUnitSize;
825 :
826 16647500 : count = block_height >> na_unit_ptr->granularity_normal_log2;
827 :
828 62366900 : for (idx = 0; idx < count; ++idx) {
829 : /* memcpy less that 10 bytes*/
830 96741100 : for (j = 0; j < naUnitSize; ++j)
831 51021600 : dst_ptr[j] = value[j];
832 :
833 45719500 : dst_ptr += naUnitSize;
834 : }
835 : }
836 :
837 17860300 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOPLEFT_MASK) {
838 : /*
839 : // Top-left Neighbor Array
840 : //
841 : // 4-5--6--7------------
842 : // 3 \ \
843 : // 2 \ \
844 : // 1 \ \
845 : // |\ xxxxxx7
846 : // | \ x 6
847 : // | \ x 5
848 : // | \1x2x3x4
849 : // |
850 : //
851 : // The top-left neighbor array is updated with the reversed samples
852 : // from the right column and bottom row of the source block
853 : //
854 : // Index = origin_x - origin_y
855 : */
856 :
857 1278300 : naOffset = get_neighbor_array_unit_top_left_index(
858 : na_unit_ptr,
859 : origin_x,
860 1278300 : origin_y + (block_height - 1));
861 :
862 : // Copy bottom-row + right-column
863 : // *Note - start from the bottom-left corner
864 1278220 : dst_ptr = na_unit_ptr->top_left_array +
865 1278220 : naOffset * naUnitSize;
866 :
867 1278220 : count = ((block_width + block_height) >> na_unit_ptr->granularity_top_left_log2) - 1;
868 :
869 8205710 : for (idx = 0; idx < count; ++idx) {
870 : /* memcpy less that 10 bytes*/
871 16325600 : for (j = 0; j < naUnitSize; ++j)
872 9398120 : dst_ptr[j] = value[j];
873 :
874 6927490 : dst_ptr += naUnitSize;
875 : }
876 : }
877 :
878 17860200 : return;
879 : }
880 :
881 12030900 : void copy_neigh_arr(
882 : NeighborArrayUnit *na_src,
883 : NeighborArrayUnit *na_dst,
884 : uint32_t origin_x,
885 : uint32_t origin_y,
886 : uint32_t bw,
887 : uint32_t bh,
888 : uint32_t neighbor_array_type_mask)
889 : {
890 : uint32_t idx;
891 : uint8_t *dst_ptr, *src_ptr;
892 :
893 : uint32_t count;
894 : uint32_t naOffset;
895 : uint32_t naUnitSize;
896 :
897 : UNUSED(idx);
898 12030900 : naUnitSize = na_src->unit_size;
899 :
900 12030900 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOP_MASK) {
901 12031300 : naOffset = get_neighbor_array_unit_top_index(na_src, origin_x);
902 12031300 : src_ptr = na_src->top_array + naOffset * naUnitSize;
903 12031300 : dst_ptr = na_dst->top_array + naOffset * naUnitSize;
904 12031300 : count = bw >> na_src->granularity_normal_log2;
905 :
906 12031300 : EB_MEMCPY(dst_ptr, src_ptr, naUnitSize*count);
907 : }
908 :
909 12030700 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_LEFT_MASK) {
910 12030700 : naOffset = get_neighbor_array_unit_left_index(na_src, origin_y);
911 12030500 : src_ptr = na_src->left_array + naOffset * naUnitSize;
912 12030500 : dst_ptr = na_dst->left_array + naOffset * naUnitSize;
913 12030500 : count = bh >> na_src->granularity_normal_log2;
914 :
915 12030500 : EB_MEMCPY(dst_ptr, src_ptr, naUnitSize*count);
916 : }
917 :
918 12032000 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOPLEFT_MASK) {
919 : /*
920 : // Top-left Neighbor Array
921 : //
922 : // 4-5--6--7------------
923 : // 3 \ \
924 : // 2 \ \
925 : // 1 \ \
926 : // |\ xxxxxx7
927 : // | \ x 6
928 : // | \ x 5
929 : // | \1x2x3x4
930 : // |
931 : //
932 : // The top-left neighbor array is updated with the reversed samples
933 : // from the right column and bottom row of the source block
934 : //
935 : // Index = origin_x - origin_y
936 : */
937 :
938 3034200 : naOffset = get_neighbor_array_unit_top_left_index(
939 : na_src,
940 : origin_x,
941 3034200 : origin_y + (bh - 1));
942 :
943 : // Copy bottom-row + right-column
944 : // *Note - start from the bottom-left corner
945 3034150 : src_ptr = na_src->top_left_array + naOffset * naUnitSize;
946 3034150 : dst_ptr = na_dst->top_left_array + naOffset * naUnitSize;
947 :
948 3034150 : count = ((bw + bh) >> na_src->granularity_top_left_log2) - 1;
949 :
950 3034150 : EB_MEMCPY(dst_ptr, src_ptr, naUnitSize*count);
951 : }
952 :
953 12030400 : return;
954 : }
955 :
956 629689 : void copy_neigh_arr_32(
957 : NeighborArrayUnit32 *na_src,
958 : NeighborArrayUnit32 *na_dst,
959 : uint32_t origin_x,
960 : uint32_t origin_y,
961 : uint32_t bw,
962 : uint32_t bh,
963 : uint32_t neighbor_array_type_mask)
964 : {
965 : uint32_t idx;
966 : uint32_t *dst_ptr, *src_ptr;
967 :
968 : uint32_t count;
969 : uint32_t naOffset;
970 : uint32_t naUnitSize;
971 :
972 : UNUSED(idx);
973 :
974 629689 : naUnitSize = na_src->unit_size;
975 :
976 629689 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOP_MASK) {
977 629694 : naOffset = get_neighbor_array_unit_top_index32(na_src, origin_x);
978 629725 : src_ptr = na_src->top_array + naOffset;
979 629725 : dst_ptr = na_dst->top_array + naOffset;
980 629725 : count = bw >> na_src->granularity_normal_log2;
981 :
982 629725 : EB_MEMCPY(dst_ptr, src_ptr, naUnitSize*count);
983 : }
984 :
985 629747 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_LEFT_MASK) {
986 629747 : naOffset = get_neighbor_array_unit_left_index32(na_src, origin_y);
987 629743 : src_ptr = na_src->left_array + naOffset;
988 629743 : dst_ptr = na_dst->left_array + naOffset;
989 629743 : count = bh >> na_src->granularity_normal_log2;
990 :
991 629743 : EB_MEMCPY(dst_ptr, src_ptr, naUnitSize*count);
992 : }
993 629740 : if (neighbor_array_type_mask & NEIGHBOR_ARRAY_UNIT_TOPLEFT_MASK) {
994 : /*
995 : // Top-left Neighbor Array
996 : //
997 : // 4-5--6--7------------
998 : // 3 \ \
999 : // 2 \ \
1000 : // 1 \ \
1001 : // |\ xxxxxx7
1002 : // | \ x 6
1003 : // | \ x 5
1004 : // | \1x2x3x4
1005 : // |
1006 : //
1007 : // The top-left neighbor array is updated with the reversed samples
1008 : // from the right column and bottom row of the source block
1009 : //
1010 : // Index = origin_x - origin_y
1011 : */
1012 :
1013 0 : naOffset = GetNeighborArrayUnitTopLeftIndex32(
1014 : na_src,
1015 : origin_x,
1016 0 : origin_y + (bh - 1));
1017 :
1018 : // Copy bottom-row + right-column
1019 : // *Note - start from the bottom-left corner
1020 0 : src_ptr = na_src->top_left_array + naOffset;
1021 0 : dst_ptr = na_dst->top_left_array + naOffset;
1022 :
1023 0 : count = ((bw + bh) >> na_src->granularity_top_left_log2) - 1;
1024 :
1025 0 : EB_MEMCPY(dst_ptr, src_ptr, naUnitSize*count);
1026 : }
1027 629740 : return;
1028 : }
1029 :
1030 : /*************************************************
1031 : * Neighbor Array Unit Mode Write
1032 : *************************************************/
1033 0 : void neighbor_array_unit_mv_write(
1034 : NeighborArrayUnit *na_unit_ptr,
1035 : uint8_t *value,
1036 : uint32_t origin_x,
1037 : uint32_t origin_y,
1038 : uint32_t block_size)
1039 : {
1040 : uint32_t idx;
1041 : uint8_t *dst_ptr;
1042 : uint8_t *naUnittopArray;
1043 : uint8_t *naUnitleftArray;
1044 : uint8_t *naUnittopLeftArray;
1045 :
1046 : uint32_t count;
1047 : uint32_t naOffset;
1048 : uint32_t naUnitSize;
1049 :
1050 0 : naUnitSize = na_unit_ptr->unit_size;
1051 0 : naUnittopArray = na_unit_ptr->top_array;
1052 0 : naUnitleftArray = na_unit_ptr->left_array;
1053 0 : naUnittopLeftArray = na_unit_ptr->top_left_array;
1054 :
1055 : //
1056 : // ----------12345678--------------------- Top Neighbor Array
1057 : // ^ ^
1058 : // | |
1059 : // | |
1060 : // xxxxxxxx
1061 : // x x
1062 : // x x
1063 : // 12345678
1064 : //
1065 : // The top neighbor array is updated with the samples from the
1066 : // bottom row of the source block
1067 : //
1068 : // Index = origin_x
1069 :
1070 0 : naOffset = origin_x >> 2;
1071 :
1072 0 : dst_ptr = naUnittopArray +
1073 0 : naOffset * naUnitSize;
1074 :
1075 : //dstStep = naUnitSize;
1076 0 : count = block_size >> 2;
1077 :
1078 0 : for (idx = 0; idx < count; ++idx) {
1079 0 : EB_MEMCPY(dst_ptr, value, naUnitSize);
1080 :
1081 0 : dst_ptr += naUnitSize;
1082 : }
1083 :
1084 : // Left Neighbor Array
1085 : //
1086 : // |
1087 : // |
1088 : // 1 xxxxxxx1
1089 : // 2 <---- x 2
1090 : // 3 <---- x 3
1091 : // 4 xxxxxxx4
1092 : // |
1093 : // |
1094 : //
1095 : // The left neighbor array is updated with the samples from the
1096 : // right column of the source block
1097 : //
1098 : // Index = origin_y
1099 :
1100 0 : naOffset = origin_y >> 2;
1101 :
1102 0 : dst_ptr = naUnitleftArray +
1103 0 : naOffset * naUnitSize;
1104 :
1105 0 : for (idx = 0; idx < count; ++idx) {
1106 0 : EB_MEMCPY(dst_ptr, value, naUnitSize);
1107 :
1108 0 : dst_ptr += naUnitSize;
1109 : }
1110 :
1111 : /*
1112 : // Top-left Neighbor Array
1113 : //
1114 : // 4-5--6--7------------
1115 : // 3 \ \
1116 : // 2 \ \
1117 : // 1 \ \
1118 : // |\ xxxxxx7
1119 : // | \ x 6
1120 : // | \ x 5
1121 : // | \1x2x3x4
1122 : // |
1123 : //
1124 : // The top-left neighbor array is updated with the reversed samples
1125 : // from the right column and bottom row of the source block
1126 : //
1127 : // Index = origin_x - origin_y
1128 : */
1129 :
1130 0 : naOffset = get_neighbor_array_unit_top_left_index(
1131 : na_unit_ptr,
1132 : origin_x,
1133 0 : origin_y + (block_size - 1));
1134 :
1135 : // Copy bottom-row + right-column
1136 : // *Note - start from the bottom-left corner
1137 0 : dst_ptr = naUnittopLeftArray +
1138 0 : naOffset * naUnitSize;
1139 :
1140 0 : count = ((block_size + block_size) >> 2) - 1;
1141 :
1142 0 : for (idx = 0; idx < count; ++idx) {
1143 0 : EB_MEMCPY(dst_ptr, value, naUnitSize);
1144 :
1145 0 : dst_ptr += naUnitSize;
1146 : }
1147 :
1148 0 : return;
1149 : }
|
