History

Initial Commit

Ethan Hugg committed 12 years ago

Commit 70e5e621 parent bd509b2308 files · +97095 −-5Browse files

Showing the changes to codec/decoder (82 of 308 files). Show all

Unified · Split

82 files
  1. codec/decoder/core/asm/asm_inc.asm +235 −0
  2. codec/decoder/core/asm/block_add.asm +413 −0
  3. codec/decoder/core/asm/cpuid.asm +169 −0
  4. codec/decoder/core/asm/dct.asm +129 −0
  5. codec/decoder/core/asm/deblock.asm +2113 −0
  6. codec/decoder/core/asm/expand_picture.asm +655 −0
  7. codec/decoder/core/asm/intra_pred.asm +1498 −0
  8. codec/decoder/core/asm/mb_copy.asm +330 −0
  9. codec/decoder/core/asm/mc_chroma.asm +317 −0
  10. codec/decoder/core/asm/mc_luma.asm +615 −0
  11. codec/decoder/core/asm/memzero.asm +135 −0
  12. codec/decoder/core/inc/as264_common.h +67 −0
  13. codec/decoder/core/inc/au_parser.h +158 −0
  14. codec/decoder/core/inc/bit_stream.h +77 −0
  15. codec/decoder/core/inc/cpu.h +80 −0
  16. codec/decoder/core/inc/cpu_core.h +80 −0
  17. codec/decoder/core/inc/crt_util_safe_x.h +104 −0
  18. codec/decoder/core/inc/deblocking.h +128 −0
  19. codec/decoder/core/inc/dec_frame.h +143 −0
  20. codec/decoder/core/inc/dec_golomb.h +243 −0
  21. codec/decoder/core/inc/decode_mb_aux.h +61 −0
  22. codec/decoder/core/inc/decode_slice.h +90 −0
  23. codec/decoder/core/inc/decoder.h +151 −0
  24. codec/decoder/core/inc/decoder_context.h +340 −0
  25. codec/decoder/core/inc/decoder_core.h +138 −0
  26. codec/decoder/core/inc/error_code.h +171 −0
  27. codec/decoder/core/inc/expand_pic.h +78 −0
  28. codec/decoder/core/inc/fmo.h +113 −0
  29. codec/decoder/core/inc/get_intra_predictor.h +121 −0
  30. codec/decoder/core/inc/ls_defines.h +86 −0
  31. codec/decoder/core/inc/macros.h +306 −0
  32. codec/decoder/core/inc/manage_dec_ref.h +81 −0
  33. codec/decoder/core/inc/mb_cache.h +84 −0
  34. codec/decoder/core/inc/mc.h +79 −0
  35. codec/decoder/core/inc/measure_time.h +100 −0
  36. codec/decoder/core/inc/mem_align.h +92 −0
  37. codec/decoder/core/inc/memmgr_nal_unit.h +65 −0
  38. codec/decoder/core/inc/mv_pred.h +98 −0
  39. codec/decoder/core/inc/nal_prefix.h +89 −0
  40. codec/decoder/core/inc/nalu.h +79 −0
  41. codec/decoder/core/inc/parameter_sets.h +173 −0
  42. codec/decoder/core/inc/parse_mb_syn_cavlc.h +213 −0
  43. codec/decoder/core/inc/pic_queue.h +63 −0
  44. codec/decoder/core/inc/picture.h +87 −0
  45. codec/decoder/core/inc/rec_mb.h +76 −0
  46. codec/decoder/core/inc/slice.h +207 −0
  47. codec/decoder/core/inc/typedefs.h +91 −0
  48. codec/decoder/core/inc/utils.h +99 −0
  49. codec/decoder/core/inc/vlc_decoder.h +176 −0
  50. codec/decoder/core/inc/wels_common_basis.h +298 −0
  51. codec/decoder/core/inc/wels_const.h +104 −0
  52. codec/decoder/core/src/au_parser.cpp +1027 −0
  53. codec/decoder/core/src/bit_stream.cpp +123 −0
  54. codec/decoder/core/src/cpu.cpp +211 −0
  55. codec/decoder/core/src/deblocking.cpp +1013 −0
  56. codec/decoder/core/src/decode_mb_aux.cpp +134 −0
  57. codec/decoder/core/src/decode_slice.cpp +1361 −0
  58. codec/decoder/core/src/decoder.cpp +850 −0
  59. codec/decoder/core/src/decoder_core.cpp +2106 −0
  60. codec/decoder/core/src/decoder_data_tables.cpp +661 −0
  61. codec/decoder/core/src/expand_pic.cpp +165 −0
  62. codec/decoder/core/src/fmo.cpp +355 −0
  63. codec/decoder/core/src/get_intra_predictor.cpp +700 −0
  64. codec/decoder/core/src/manage_dec_ref.cpp +575 −0
  65. codec/decoder/core/src/mc.cpp +757 −0
  66. codec/decoder/core/src/mem_align.cpp +115 −0
  67. codec/decoder/core/src/memmgr_nal_unit.cpp +153 −0
  68. codec/decoder/core/src/mv_pred.cpp +251 −0
  69. codec/decoder/core/src/parse_mb_syn_cavlc.cpp +1627 −0
  70. codec/decoder/core/src/pic_queue.cpp +166 −0
  71. codec/decoder/core/src/rec_mb.cpp +589 −0
  72. codec/decoder/core/src/utils.cpp +307 −0
  73. codec/decoder/plus/inc/StdAfx.h +56 −0
  74. codec/decoder/plus/inc/welsCodecTrace.h +172 −0
  75. codec/decoder/plus/inc/welsDecoderExt.h +121 −0
  76. codec/decoder/plus/res/resource.h +15 −0
  77. codec/decoder/plus/res/welsdec.aps +0 −0
  78. codec/decoder/plus/res/welsdec.rc +115 −0
  79. codec/decoder/plus/src/StdAfx.cpp +40 −0
  80. codec/decoder/plus/src/welsCodecTrace.cpp +419 −0
  81. codec/decoder/plus/src/welsDecoderExt.cpp +532 −0
  82. codec/decoder/plus/src/wels_dec_export.def +3 −0
codec/decoder/core/asm/asm_inc.asm+235−0
@@ -0,0 +1,235 @@
1;*!
2;* \copy
3;* Copyright (c) 2009-2013, Cisco Systems
4;* All rights reserved.
5;*
6;* Redistribution and use in source and binary forms, with or without
7;* modification, are permitted provided that the following conditions
8;* are met:
9;*
10;* * Redistributions of source code must retain the above copyright
11;* notice, this list of conditions and the following disclaimer.
12;*
13;* * Redistributions in binary form must reproduce the above copyright
14;* notice, this list of conditions and the following disclaimer in
15;* the documentation and/or other materials provided with the
16;* distribution.
17;*
18;* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19;* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20;* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21;* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22;* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23;* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24;* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25;* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26;* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27;* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28;* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29;* POSSIBILITY OF SUCH DAMAGE.
30;*
31;*
32;* sse2inc.asm
33;*
34;* Abstract
35;* macro and constant
36;*
37;* History
38;* 8/5/2009 Created
39;*
40;*
41;*************************************************************************/
42;***********************************************************************
43; Options, for DEBUG
44;***********************************************************************
45
46%if 1
47 %define MOVDQ movdqa
48%else
49 %define MOVDQ movdqu
50%endif
51
52%if 1
53 %define WELSEMMS emms
54%else
55 %define WELSEMMS
56%endif
57
58BITS 32
59
60;***********************************************************************
61; Macros
62;***********************************************************************
63
64%macro WELS_EXTERN 1
65 %ifdef PREFIX
66 global _%1
67 %define %1 _%1
68 %else
69 global %1
70 %endif
71%endmacro
72
73%macro WELS_AbsW 2
74 pxor %2, %2
75 psubw %2, %1
76 pmaxsw %1, %2
77%endmacro
78
79%macro MMX_XSwap 4
80 movq %4, %2
81 punpckh%1 %4, %3
82 punpckl%1 %2, %3
83%endmacro
84
85; pOut mm1, mm4, mm5, mm3
86%macro MMX_Trans4x4W 5
87 MMX_XSwap wd, %1, %2, %5
88 MMX_XSwap wd, %3, %4, %2
89 MMX_XSwap dq, %1, %3, %4
90 MMX_XSwap dq, %5, %2, %3
91%endmacro
92
93;for TRANSPOSE
94%macro SSE2_XSawp 4
95 movdqa %4, %2
96 punpckl%1 %2, %3
97 punpckh%1 %4, %3
98%endmacro
99
100; in: xmm1, xmm2, xmm3, xmm4 pOut: xmm1, xmm4, xmm5, mm3
101%macro SSE2_Trans4x4D 5
102 SSE2_XSawp dq, %1, %2, %5
103 SSE2_XSawp dq, %3, %4, %2
104 SSE2_XSawp qdq, %1, %3, %4
105 SSE2_XSawp qdq, %5, %2, %3
106%endmacro
107
108;in: xmm0, xmm1, xmm2, xmm3 pOut: xmm0, xmm1, xmm3, xmm4
109%macro SSE2_TransTwo4x4W 5
110 SSE2_XSawp wd, %1, %2, %5
111 SSE2_XSawp wd, %3, %4, %2
112 SSE2_XSawp dq, %1, %3, %4
113 SSE2_XSawp dq, %5, %2, %3
114 SSE2_XSawp qdq, %1, %5, %2
115 SSE2_XSawp qdq, %4, %3, %5
116%endmacro
117
118;in: m1, m2, m3, m4, m5, m6, m7, m8
119;pOut: m5, m3, m4, m8, m6, m2, m7, m1
120%macro SSE2_TransTwo8x8B 9
121 movdqa %9, %8
122 SSE2_XSawp bw, %1, %2, %8
123 SSE2_XSawp bw, %3, %4, %2
124 SSE2_XSawp bw, %5, %6, %4
125 movdqa %6, %9
126 movdqa %9, %4
127 SSE2_XSawp bw, %7, %6, %4
128
129 SSE2_XSawp wd, %1, %3, %6
130 SSE2_XSawp wd, %8, %2, %3
131 SSE2_XSawp wd, %5, %7, %2
132 movdqa %7, %9
133 movdqa %9, %3
134 SSE2_XSawp wd, %7, %4, %3
135
136 SSE2_XSawp dq, %1, %5, %4
137 SSE2_XSawp dq, %6, %2, %5
138 SSE2_XSawp dq, %8, %7, %2
139 movdqa %7, %9
140 movdqa %9, %5
141 SSE2_XSawp dq, %7, %3, %5
142
143 SSE2_XSawp qdq, %1, %8, %3
144 SSE2_XSawp qdq, %4, %2, %8
145 SSE2_XSawp qdq, %6, %7, %2
146 movdqa %7, %9
147 movdqa %9, %1
148 SSE2_XSawp qdq, %7, %5, %1
149 movdqa %5, %9
150%endmacro
151
152;xmm0, xmm6, xmm7, [eax], [ecx]
153;xmm7 = 0, eax = pix1, ecx = pix2, xmm0 save the result
154%macro SSE2_LoadDiff8P 5
155 movq %1, %4
156 punpcklbw %1, %3
157 movq %2, %5
158 punpcklbw %2, %3
159 psubw %1, %2
160%endmacro
161
162; m2 = m1 + m2, m1 = m1 - m2
163%macro SSE2_SumSub 3
164 movdqa %3, %2
165 paddw %2, %1
166 psubw %1, %3
167%endmacro
168
169
170%macro butterfly_1to16_sse 3 ; xmm? for dst, xmm? for tmp, one byte for pSrc [generic register name: a/b/c/d]
171 mov %3h, %3l
172 movd %1, e%3x ; i.e, 1% = eax (=b0)
173 pshuflw %2, %1, 00h ; ..., b0 b0 b0 b0 b0 b0 b0 b0
174 pshufd %1, %2, 00h ; b0 b0 b0 b0, b0 b0 b0 b0, b0 b0 b0 b0, b0 b0 b0 b0
175%endmacro
176
177;copy a dw into a xmm for 8 times
178%macro SSE2_Copy8Times 2
179 movd %1, %2
180 punpcklwd %1, %1
181 pshufd %1, %1, 0
182%endmacro
183
184;copy a db into a xmm for 16 times
185%macro SSE2_Copy16Times 2
186 movd %1, %2
187 pshuflw %1, %1, 0
188 punpcklqdq %1, %1
189 packuswb %1, %1
190%endmacro
191
192
193
194;***********************************************************************
195;preprocessor constants
196;***********************************************************************
197;dw 32,32,32,32,32,32,32,32 for xmm
198;dw 32,32,32,32 for mm
199%macro WELS_DW32 1
200 pcmpeqw %1,%1
201 psrlw %1,15
202 psllw %1,5
203%endmacro
204
205;dw 1, 1, 1, 1, 1, 1, 1, 1 for xmm
206;dw 1, 1, 1, 1 for mm
207%macro WELS_DW1 1
208 pcmpeqw %1,%1
209 psrlw %1,15
210%endmacro
211
212;all 0 for xmm and mm
213%macro WELS_Zero 1
214 pxor %1, %1
215%endmacro
216
217;dd 1, 1, 1, 1 for xmm
218;dd 1, 1 for mm
219%macro WELS_DD1 1
220 pcmpeqw %1,%1
221 psrld %1,31
222%endmacro
223
224;dB 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
225%macro WELS_DB1 1
226 pcmpeqw %1,%1
227 psrlw %1,15
228 packuswb %1,%1
229%endmacro
230
231
232
233
234
235
codec/decoder/core/asm/block_add.asm+413−0
@@ -0,0 +1,413 @@
1;*!
2;* \copy
3;* Copyright (c) 2009-2013, Cisco Systems
4;* All rights reserved.
5;*
6;* Redistribution and use in source and binary forms, with or without
7;* modification, are permitted provided that the following conditions
8;* are met:
9;*
10;* * Redistributions of source code must retain the above copyright
11;* notice, this list of conditions and the following disclaimer.
12;*
13;* * Redistributions in binary form must reproduce the above copyright
14;* notice, this list of conditions and the following disclaimer in
15;* the documentation and/or other materials provided with the
16;* distribution.
17;*
18;* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19;* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20;* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21;* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22;* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23;* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24;* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25;* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26;* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27;* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28;* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29;* POSSIBILITY OF SUCH DAMAGE.
30;*
31;*
32;* block_add.asm
33;*
34;* Abstract
35;* add block
36;*
37;* History
38;* 09/21/2009 Created
39;*
40;*
41;*************************************************************************/
42
43%include "asm_inc.asm"
44
45BITS 32
46
47;*******************************************************************************
48; Macros and other preprocessor constants
49;*******************************************************************************
50
51%macro BLOCK_ADD_16_SSE2 4
52 movdqa xmm0, [%2]
53 movdqa xmm1, [%3]
54 movdqa xmm2, [%3+10h]
55 movdqa xmm6, xmm0
56
57 punpcklbw xmm0, xmm7
58 punpckhbw xmm6, xmm7
59
60 paddw xmm0, xmm1
61 paddw xmm6, xmm2
62
63 packuswb xmm0, xmm6
64 movdqa [%1], xmm0
65
66 lea %2, [%2+%4]
67 lea %3, [%3+%4*2]
68 lea %1, [%1+%4]
69%endmacro
70
71%macro BLOCK_ADD_8_MMXEXT 4
72 movq mm0, [%2]
73 movq mm1, [%3]
74 movq mm2, [%3+08h]
75 movq mm6, mm0
76
77 punpcklbw mm0, mm7
78 punpckhbw mm6, mm7
79
80 paddw mm0, mm1
81 paddw mm6, mm2
82
83 packuswb mm0, mm6
84 movq [%1], mm0
85
86 lea %2, [%2+%4]
87 lea %3, [%3+%4*2]
88 lea %1, [%1+%4]
89%endmacro
90
91
92%macro BLOCK_ADD_16_STRIDE_SSE2 5
93 movdqa xmm0, [%2]
94 movdqa xmm1, [%3]
95 movdqa xmm2, [%3+10h]
96 movdqa xmm6, xmm0
97
98 punpcklbw xmm0, xmm7
99 punpckhbw xmm6, xmm7
100
101 paddw xmm0, xmm1
102 paddw xmm6, xmm2
103
104 packuswb xmm0, xmm6
105 movdqa [%1], xmm0
106
107 lea %2, [%2+%4]
108 lea %3, [%3+%5*2]
109 lea %1, [%1+%4]
110%endmacro
111
112
113%macro BLOCK_ADD_8_STRIDE_MMXEXT 5
114 movq mm0, [%2]
115 movq mm1, [%3]
116 movq mm2, [%3+08h]
117 movq mm6, mm0
118
119 punpcklbw mm0, mm7
120 punpckhbw mm6, mm7
121
122 paddw mm0, mm1
123 paddw mm6, mm2
124
125 packuswb mm0, mm6
126 movq [%1], mm0
127
128 lea %2, [%2+%4]
129 lea %3, [%3+%5*2]
130 lea %1, [%1+%4]
131%endmacro
132
133%macro BLOCK_ADD_8_STRIDE_2_LINES_SSE2 5
134 movdqa xmm1, [%3]
135 movq xmm0, [%2]
136 punpcklbw xmm0, xmm7
137 paddw xmm0, xmm1
138 packuswb xmm0, xmm7
139 movq [%1], xmm0
140
141 movdqa xmm3, [%3+%5*2]
142 movq xmm2, [%2+%4]
143 punpcklbw xmm2, xmm7
144 paddw xmm2, xmm3
145 packuswb xmm2, xmm7
146 movq [%1+%4], xmm2
147
148 lea %1, [%1+%4*2]
149 lea %2, [%2+%4*2]
150 lea %3, [%3+%5*4]
151%endmacro
152
153%macro CHECK_DATA_16_ZERO_SSE4 3
154 mov eax, 0h
155 movdqa xmm0, [%1]
156 movdqa xmm1, [%1+10h]
157 mov ebx, [ecx]
158
159 por xmm0, xmm1
160 ptest xmm7, xmm0
161 cmovae eax, %3
162
163 add %1, 20h
164 add ecx, 04h
165 mov byte [%2+ebx], al
166%endmacro
167
168%macro CHECK_RS_4x4_BLOCK_2_ZERO_SSE4 5
169 movdqa xmm0, [%1]
170 movdqa xmm1, [%1+%3]
171 movdqa xmm2, [%1+%3*2]
172 movdqa xmm3, [%1+%4]
173
174 mov eax, 0h
175 mov ebx, 0h
176 movdqa xmm4, xmm0
177 movdqa xmm5, xmm2
178
179 punpcklqdq xmm0, xmm1
180 punpckhqdq xmm4, xmm1
181 punpcklqdq xmm2, xmm3
182 punpckhqdq xmm5, xmm3
183
184 por xmm0, xmm2
185 por xmm4, xmm5
186
187 ptest xmm7, xmm0
188 cmovae eax, %5
189 ptest xmm7, xmm4
190 cmovae ebx, %5
191
192 mov byte [%2], al
193 mov byte [%2+1], bl
194%endmacro
195
196%macro DATA_COPY_16x2_SSE2 3
197 movdqa xmm0, [%1]
198 movdqa xmm1, [%1+10h]
199 movdqa xmm2, [%1+%3]
200 movdqa xmm3, [%1+%3+10h]
201
202 movdqa [%2], xmm0
203 movdqa [%2+10h], xmm1
204 movdqa [%2+20h], xmm2
205 movdqa [%2+30h], xmm3
206
207 lea %1, [%1+%3*2]
208 lea %2, [%2+40h]
209%endmacro
210
211
212%macro DATA_COPY_8x4_SSE2 4
213 movdqa xmm0, [%1]
214 movdqa xmm1, [%1+%3]
215 movdqa xmm2, [%1+%3*2]
216 movdqa xmm3, [%1+%4]
217
218 movdqa [%2], xmm0
219 movdqa [%2+10h], xmm1
220 movdqa [%2+20h], xmm2
221 movdqa [%2+30h], xmm3
222
223 lea %1, [%1+%3*4]
224 lea %2, [%2+40h]
225%endmacro
226
227
228%macro CHECK_DATA_16_ZERO_SSE2 3
229 mov eax, 0h
230 movdqa xmm0, [%1]
231 movdqa xmm1, [%1+10h]
232 mov ebx, [ecx]
233
234 pcmpeqw xmm0, xmm7
235 pcmpeqw xmm1, xmm7
236 packsswb xmm0, xmm1
237 pmovmskb edx, xmm0
238 sub edx, 0ffffh
239
240 cmovb eax, ebp
241 add ecx, 4
242 add %1, 20h
243 mov byte [%2+ebx], al
244%endmacro
245
246
247
248%macro CHECK_RS_4x4_BLOCK_2_ZERO_SSE2 5
249 movdqa xmm0, [%1]
250 movdqa xmm1, [%1 + %3]
251 movdqa xmm2, [%1 + %3*2]
252 movdqa xmm3, [%1 + %4]
253
254 movdqa xmm4, xmm0
255 movdqa xmm5, xmm2
256
257 punpcklqdq xmm0, xmm1
258 punpckhqdq xmm4, xmm1
259 punpcklqdq xmm2, xmm3
260 punpckhqdq xmm5, xmm3
261
262 pcmpeqw xmm0, xmm7
263 pcmpeqw xmm2, xmm7
264 pcmpeqw xmm4, xmm7
265 pcmpeqw xmm5, xmm7
266
267 packsswb xmm0, xmm2
268 packsswb xmm4, xmm5
269 pmovmskb eax, xmm0
270 pmovmskb ebx, xmm4
271
272 sub eax, 0ffffh
273 mov eax, 0
274 cmovb eax, %5
275 sub ebx, 0ffffh
276 mov ebx, 0
277 cmovb ebx, %5
278 mov byte [%2], al
279 mov byte [%2+1], bl
280%endmacro
281
282;*******************************************************************************
283; Data
284;*******************************************************************************
285
286%ifdef FORMAT_COFF
287SECTION .rodata data
288%else
289SECTION .rodata align=16
290%endif
291
292ALIGN 16
293SubMbScanIdx:
294 dd 0x0, 0x1, 0x4, 0x5,
295 dd 0x2, 0x3, 0x6, 0x7,
296 dd 0x8, 0x9, 0xc, 0xd,
297 dd 0xa, 0xb, 0xe, 0xf,
298 dd 0x10, 0x11, 0x14, 0x15,
299 dd 0x12, 0x13, 0x16, 0x17,
300
301;*******************************************************************************
302; Code
303;*******************************************************************************
304
305SECTION .text
306
307
308WELS_EXTERN WelsResBlockZero16x16_sse2
309
310ALIGN 16
311;*******************************************************************************
312; void_t WelsResBlockZero16x16_sse2(int16_t* pBlock,int32_t iStride)
313;*******************************************************************************
314WelsResBlockZero16x16_sse2:
315 push esi
316
317 mov esi, [esp+08h]
318 mov ecx, [esp+0ch]
319 lea ecx, [ecx*2]
320 lea eax, [ecx*3]
321
322 pxor xmm7, xmm7
323
324 ; four lines
325 movdqa [esi], xmm7
326 movdqa [esi+10h], xmm7
327
328 movdqa [esi+ecx], xmm7
329 movdqa [esi+ecx+10h], xmm7
330
331 movdqa [esi+ecx*2], xmm7
332 movdqa [esi+ecx*2+10h], xmm7
333
334 movdqa [esi+eax], xmm7
335 movdqa [esi+eax+10h], xmm7
336
337 ; four lines
338 lea esi, [esi+ecx*4]
339 movdqa [esi], xmm7
340 movdqa [esi+10h], xmm7
341
342 movdqa [esi+ecx], xmm7
343 movdqa [esi+ecx+10h], xmm7
344
345 movdqa [esi+ecx*2], xmm7
346 movdqa [esi+ecx*2+10h], xmm7
347
348 movdqa [esi+eax], xmm7
349 movdqa [esi+eax+10h], xmm7
350
351 ; four lines
352 lea esi, [esi+ecx*4]
353 movdqa [esi], xmm7
354 movdqa [esi+10h], xmm7
355
356 movdqa [esi+ecx], xmm7
357 movdqa [esi+ecx+10h], xmm7
358
359 movdqa [esi+ecx*2], xmm7
360 movdqa [esi+ecx*2+10h], xmm7
361
362 movdqa [esi+eax], xmm7
363 movdqa [esi+eax+10h], xmm7
364
365 ; four lines
366 lea esi, [esi+ecx*4]
367 movdqa [esi], xmm7
368 movdqa [esi+10h], xmm7
369
370 movdqa [esi+ecx], xmm7
371 movdqa [esi+ecx+10h], xmm7
372
373 movdqa [esi+ecx*2], xmm7
374 movdqa [esi+ecx*2+10h], xmm7
375
376 movdqa [esi+eax], xmm7
377 movdqa [esi+eax+10h], xmm7
378
379 pop esi
380 ret
381
382
383WELS_EXTERN WelsResBlockZero8x8_sse2
384
385ALIGN 16
386;*******************************************************************************
387; void_t WelsResBlockZero8x8_sse2(int16_t * pBlock, int32_t iStride)
388;*******************************************************************************
389WelsResBlockZero8x8_sse2:
390 push esi
391
392 mov esi, [esp+08h]
393 mov ecx, [esp+0ch]
394 lea ecx, [ecx*2]
395 lea eax, [ecx*3]
396
397 pxor xmm7, xmm7
398
399 movdqa [esi], xmm7
400 movdqa [esi+ecx], xmm7
401 movdqa [esi+ecx*2], xmm7
402 movdqa [esi+eax], xmm7
403
404 lea esi, [esi+ecx*4]
405 movdqa [esi], xmm7
406 movdqa [esi+ecx], xmm7
407 movdqa [esi+ecx*2], xmm7
408 movdqa [esi+eax], xmm7
409
410
411 pop esi
412 ret
413
codec/decoder/core/asm/cpuid.asm+169−0
@@ -0,0 +1,169 @@
1;*!
2;* \copy
3;* Copyright (c) 2009-2013, Cisco Systems
4;* All rights reserved.
5;*
6;* Redistribution and use in source and binary forms, with or without
7;* modification, are permitted provided that the following conditions
8;* are met:
9;*
10;* * Redistributions of source code must retain the above copyright
11;* notice, this list of conditions and the following disclaimer.
12;*
13;* * Redistributions in binary form must reproduce the above copyright
14;* notice, this list of conditions and the following disclaimer in
15;* the documentation and/or other materials provided with the
16;* distribution.
17;*
18;* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19;* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20;* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21;* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22;* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23;* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24;* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25;* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26;* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27;* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28;* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29;* POSSIBILITY OF SUCH DAMAGE.
30;*
31;*
32;* cpu_mmx.asm
33;*
34;* Abstract
35;* verify cpuid feature support and cpuid detection
36;*
37;* History
38;* 04/29/2009 Created
39;*
40;*************************************************************************/
41
42bits 32
43
44;******************************************************************************************
45; Macros
46;******************************************************************************************
47
48%macro WELS_EXTERN 1
49 %ifdef PREFIX
50 global _%1
51 %define %1 _%1
52 %else
53 global %1
54 %endif
55%endmacro
56
57;******************************************************************************************
58; Code
59;******************************************************************************************
60
61SECTION .text
62
63; refer to "The IA-32 Intel(R) Architecture Software Developers Manual, Volume 2A A-M"
64; section CPUID - CPU Identification
65
66WELS_EXTERN WelsCPUIdVerify
67ALIGN 16
68;******************************************************************************************
69; int32_t WelsCPUIdVerify()
70;******************************************************************************************
71WelsCPUIdVerify:
72 pushfd ; decrease the SP by 4 and load EFLAGS register onto stack, pushfd 32 bit and pushf for 16 bit
73 pushfd ; need push 2 EFLAGS, one for processing and the another one for storing purpose
74 pop ecx ; get EFLAGS to bit manipulation
75 mov eax, ecx ; store into ecx followed
76 xor eax, 00200000h ; get ID flag (bit 21) of EFLAGS to directly indicate cpuid support or not
77 xor eax, ecx ; get the ID flag bitwise, eax - 0: not support; otherwise: support
78 popfd ; store back EFLAGS and keep unchanged for system
79 ret
80
81WELS_EXTERN WelsCPUId
82ALIGN 16
83;****************************************************************************************************
84; void WelsCPUId( int32_t index, int32_t *uiFeatureA, int32_t *uiFeatureB, int32_t *uiFeatureC, int32_t *uiFeatureD )
85;****************************************************************************************************
86WelsCPUId:
87 push ebx
88 push edi
89
90 mov eax, [esp+12] ; operating index
91 cpuid ; cpuid
92
93 ; processing various information return
94 mov edi, [esp+16]
95 mov [edi], eax
96 mov edi, [esp+20]
97 mov [edi], ebx
98 mov edi, [esp+24]
99 mov [edi], ecx
100 mov edi, [esp+28]
101 mov [edi], edx
102
103 pop edi
104 pop ebx
105 ret
106
107WELS_EXTERN WelsCPUSupportAVX
108; need call after cpuid=1 and eax, ecx flag got then
109ALIGN 16
110;****************************************************************************************************
111; int32_t WelsCPUSupportAVX( uint32_t eax, uint32_t ecx )
112;****************************************************************************************************
113WelsCPUSupportAVX:
114 mov eax, [esp+4]
115 mov ecx, [esp+8]
116
117 ; refer to detection of AVX addressed in INTEL AVX manual document
118 and ecx, 018000000H
119 cmp ecx, 018000000H ; check both OSXSAVE and AVX feature flags
120 jne avx_not_supported
121 ; processor supports AVX instructions and XGETBV is enabled by OS
122 mov ecx, 0 ; specify 0 for XFEATURE_ENABLED_MASK register
123 XGETBV ; result in EDX:EAX
124 and eax, 06H
125 cmp eax, 06H ; check OS has enabled both XMM and YMM state support
126 jne avx_not_supported
127 mov eax, 1
128 ret
129avx_not_supported:
130 mov eax, 0
131 ret
132
133WELS_EXTERN WelsCPUSupportFMA
134; need call after cpuid=1 and eax, ecx flag got then
135ALIGN 16
136;****************************************************************************************************
137; int32_t WelsCPUSupportFMA( uint32_t eax, uint32_t ecx )
138;****************************************************************************************************
139WelsCPUSupportFMA:
140 mov eax, [esp+4]
141 mov ecx, [esp+8]
142
143 ; refer to detection of FMA addressed in INTEL AVX manual document
144 and ecx, 018001000H
145 cmp ecx, 018001000H ; check OSXSAVE, AVX, FMA feature flags
146 jne fma_not_supported
147 ; processor supports AVX,FMA instructions and XGETBV is enabled by OS
148 mov ecx, 0 ; specify 0 for XFEATURE_ENABLED_MASK register
149 XGETBV ; result in EDX:EAX
150 and eax, 06H
151 cmp eax, 06H ; check OS has enabled both XMM and YMM state support
152 jne fma_not_supported
153 mov eax, 1
154 ret
155fma_not_supported:
156 mov eax, 0
157 ret
158
159WELS_EXTERN WelsEmms
160ALIGN 16
161;******************************************************************************************
162; void WelsEmms()
163;******************************************************************************************
164WelsEmms:
165 emms ; empty mmx technology states
166 ret
167
168
169
codec/decoder/core/asm/dct.asm+129−0
@@ -0,0 +1,129 @@
1;*!
2;* \copy
3;* Copyright (c) 2009-2013, Cisco Systems
4;* All rights reserved.
5;*
6;* Redistribution and use in source and binary forms, with or without
7;* modification, are permitted provided that the following conditions
8;* are met:
9;*
10;* ?Redistributions of source code must retain the above copyright
11;* notice, this list of conditions and the following disclaimer.
12;*
13;* ?Redistributions in binary form must reproduce the above copyright
14;* notice, this list of conditions and the following disclaimer in
15;* the documentation and/or other materials provided with the
16;* distribution.
17;*
18;* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19;* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20;* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21;* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22;* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23;* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24;* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25;* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26;* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27;* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28;* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29;* POSSIBILITY OF SUCH DAMAGE.
30;*
31;*
32;* dct.asm
33;*
34;* Abstract
35;* WelsDctFourT4_sse2
36;*
37;* History
38;* 8/4/2009 Created
39;*
40;*
41;*************************************************************************/
42
43%include "asm_inc.asm"
44
45BITS 32
46
47;*******************************************************************************
48; Macros and other preprocessor constants
49;*******************************************************************************
50%macro MMX_SumSubDiv2 3
51 movq %3, %2
52 psraw %3, $1
53 paddw %3, %1
54 psraw %1, $1
55 psubw %1, %2
56%endmacro
57
58%macro MMX_SumSub 3
59 movq %3, %2
60 psubw %2, %1
61 paddw %1, %3
62%endmacro
63
64%macro MMX_IDCT 6
65 MMX_SumSub %4, %5, %6
66 MMX_SumSubDiv2 %3, %2, %1
67 MMX_SumSub %1, %4, %6
68 MMX_SumSub %3, %5, %6
69%endmacro
70
71
72%macro MMX_StoreDiff4P 5
73 movd %2, %5
74 punpcklbw %2, %4
75 paddw %1, %3
76 psraw %1, $6
77 paddsw %1, %2
78 packuswb %1, %2
79 movd %5, %1
80%endmacro
81
82;*******************************************************************************
83; Code
84;*******************************************************************************
85
86SECTION .text
87
88WELS_EXTERN IdctResAddPred_mmx
89
90ALIGN 16
91;*******************************************************************************
92; void_t __cdecl IdctResAddPred_mmx( uint8_t *pPred, const int32_t kiStride, int16_t *pRs )
93;*******************************************************************************
94
95IdctResAddPred_mmx:
96
97%define pushsize 0
98%define pPred esp+pushsize+4
99%define kiStride esp+pushsize+8
100%define pRs esp+pushsize+12
101
102 mov eax, [pRs ]
103 mov edx, [pPred ]
104 mov ecx, [kiStride]
105 movq mm0, [eax+ 0]
106 movq mm1, [eax+ 8]
107 movq mm2, [eax+16]
108 movq mm3, [eax+24]
109
110 MMX_Trans4x4W mm0, mm1, mm2, mm3, mm4
111 MMX_IDCT mm1, mm2, mm3, mm4, mm0, mm6
112 MMX_Trans4x4W mm1, mm3, mm0, mm4, mm2
113 MMX_IDCT mm3, mm0, mm4, mm2, mm1, mm6
114
115 WELS_Zero mm7
116 WELS_DW32 mm6
117
118 MMX_StoreDiff4P mm3, mm0, mm6, mm7, [edx]
119 MMX_StoreDiff4P mm4, mm0, mm6, mm7, [edx+ecx]
120 lea edx, [edx+2*ecx]
121 MMX_StoreDiff4P mm1, mm0, mm6, mm7, [edx]
122 MMX_StoreDiff4P mm2, mm0, mm6, mm7, [edx+ecx]
123
124%undef pushsize
125%undef pPred
126%undef kiStride
127%undef pRs
128 emms
129 ret
codec/decoder/core/asm/deblock.asm+2113−0
@@ -0,0 +1,2113 @@
1;*!
2;* \copy
3;* Copyright (c) 2009-2013, Cisco Systems
4;* All rights reserved.
5;*
6;* Redistribution and use in source and binary forms, with or without
7;* modification, are permitted provided that the following conditions
8;* are met:
9;*
10;* * Redistributions of source code must retain the above copyright
11;* notice, this list of conditions and the following disclaimer.
12;*
13;* * Redistributions in binary form must reproduce the above copyright
14;* notice, this list of conditions and the following disclaimer in
15;* the documentation and/or other materials provided with the
16;* distribution.
17;*
18;* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19;* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20;* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21;* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22;* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23;* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24;* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25;* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26;* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27;* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28;* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29;* POSSIBILITY OF SUCH DAMAGE.
30;*
31;*
32;* deblock.asm
33;*
34;* Abstract
35;* edge loop
36;*
37;* History
38;* 08/07/2009 Created
39;*
40;*
41;*************************************************************************/
42%include "asm_inc.asm"
43BITS 32
44
45;*******************************************************************************
46; Macros and other preprocessor constants
47;*******************************************************************************
48
49%ifdef FORMAT_COFF
50SECTION .rodata pData
51%else
52SECTION .rodata align=16
53%endif
54
55SECTION .text
56
57;********************************************************************************
58; void DeblockChromaEq4V_sse2(uint8_t * pPixCb, uint8_t * pPixCr, int32_t iStride,
59; int32_t iAlpha, int32_t iBeta)
60;********************************************************************************
61WELS_EXTERN DeblockChromaEq4V_sse2
62
63ALIGN 16
64DeblockChromaEq4V_sse2:
65 push ebp
66 mov ebp,esp
67 and esp,0FFFFFFF0h
68 sub esp,68h
69 mov edx,[ebp+10h] ; iStride
70 mov eax,[ebp+8] ; pPixCb
71 mov ecx,[ebp+0Ch] ; pPixCr
72 movq xmm4,[ecx]
73 movq xmm5,[edx+ecx]
74 push esi
75 push edi
76 lea esi,[edx+edx]
77 mov edi,eax
78 sub edi,esi
79 movq xmm1,[edi]
80 mov edi,ecx
81 sub edi,esi
82 movq xmm2,[edi]
83 punpcklqdq xmm1,xmm2
84 mov esi,eax
85 sub esi,edx
86 movq xmm2,[esi]
87 mov edi,ecx
88 sub edi,edx
89 movq xmm3,[edi]
90 punpcklqdq xmm2,xmm3
91 movq xmm3,[eax]
92 punpcklqdq xmm3,xmm4
93 movq xmm4,[edx+eax]
94 mov edx, [ebp + 14h]
95 punpcklqdq xmm4,xmm5
96 movd xmm5,edx
97 mov edx, [ebp + 18h]
98 pxor xmm0,xmm0
99 movdqa xmm6,xmm5
100 punpcklwd xmm6,xmm5
101 pshufd xmm5,xmm6,0
102 movd xmm6,edx
103 movdqa xmm7,xmm6
104 punpcklwd xmm7,xmm6
105 pshufd xmm6,xmm7,0
106 movdqa xmm7,xmm1
107 punpckhbw xmm1,xmm0
108 punpcklbw xmm7,xmm0
109 movdqa [esp+40h],xmm1
110 movdqa [esp+60h],xmm7
111 movdqa xmm7,xmm2
112 punpcklbw xmm7,xmm0
113 movdqa [esp+10h],xmm7
114 movdqa xmm7,xmm3
115 punpcklbw xmm7,xmm0
116 punpckhbw xmm3,xmm0
117 movdqa [esp+50h],xmm7
118 movdqa xmm7,xmm4
119 punpckhbw xmm4,xmm0
120 punpckhbw xmm2,xmm0
121 punpcklbw xmm7,xmm0
122 movdqa [esp+30h],xmm3
123 movdqa xmm3,[esp+10h]
124 movdqa xmm1,xmm3
125 psubw xmm1,[esp+50h]
126 pabsw xmm1,xmm1
127 movdqa [esp+20h],xmm4
128 movdqa xmm0,xmm5
129 pcmpgtw xmm0,xmm1
130 movdqa xmm1,[esp+60h]
131 psubw xmm1,xmm3
132 pabsw xmm1,xmm1
133 movdqa xmm4,xmm6
134 pcmpgtw xmm4,xmm1
135 pand xmm0,xmm4
136 movdqa xmm1,xmm7
137 psubw xmm1,[esp+50h]
138 pabsw xmm1,xmm1
139 movdqa xmm4,xmm6
140 pcmpgtw xmm4,xmm1
141 movdqa xmm1,xmm2
142 psubw xmm1,[esp+30h]
143 pabsw xmm1,xmm1
144 pcmpgtw xmm5,xmm1
145 movdqa xmm1,[esp+40h]
146 pand xmm0,xmm4
147 psubw xmm1,xmm2
148 pabsw xmm1,xmm1
149 movdqa xmm4,xmm6
150 pcmpgtw xmm4,xmm1
151 movdqa xmm1,[esp+20h]
152 psubw xmm1,[esp+30h]
153 pand xmm5,xmm4
154 pabsw xmm1,xmm1
155 pcmpgtw xmm6,xmm1
156 pand xmm5,xmm6
157 mov edx,2
158 movsx edx,dx
159 movd xmm1,edx
160 movdqa xmm4,xmm1
161 punpcklwd xmm4,xmm1
162 pshufd xmm1,xmm4,0
163 movdqa xmm4,[esp+60h]
164 movdqa xmm6,xmm4
165 paddw xmm6,xmm4
166 paddw xmm6,xmm3
167 paddw xmm6,xmm7
168 movdqa [esp+10h],xmm1
169 paddw xmm6,[esp+10h]
170 psraw xmm6,2
171 movdqa xmm4,xmm0
172 pandn xmm4,xmm3
173 movdqa xmm3,[esp+40h]
174 movdqa xmm1,xmm0
175 pand xmm1,xmm6
176 por xmm1,xmm4
177 movdqa xmm6,xmm3
178 paddw xmm6,xmm3
179 movdqa xmm3,[esp+10h]
180 paddw xmm6,xmm2
181 paddw xmm6,[esp+20h]
182 paddw xmm6,xmm3
183 psraw xmm6,2
184 movdqa xmm4,xmm5
185 pand xmm4,xmm6
186 movdqa xmm6,xmm5
187 pandn xmm6,xmm2
188 por xmm4,xmm6
189 packuswb xmm1,xmm4
190 movdqa xmm4,[esp+50h]
191 movdqa xmm6,xmm7
192 paddw xmm6,xmm7
193 paddw xmm6,xmm4
194 paddw xmm6,[esp+60h]
195 paddw xmm6,xmm3
196 psraw xmm6,2
197 movdqa xmm2,xmm0
198 pand xmm2,xmm6
199 pandn xmm0,xmm4
200 por xmm2,xmm0
201 movdqa xmm0,[esp+20h]
202 movdqa xmm6,xmm0
203 paddw xmm6,xmm0
204 movdqa xmm0,[esp+30h]
205 paddw xmm6,xmm0
206 paddw xmm6,[esp+40h]
207 movdqa xmm4,xmm5
208 paddw xmm6,xmm3
209 movq [esi],xmm1
210 psraw xmm6,2
211 pand xmm4,xmm6
212 pandn xmm5,xmm0
213 por xmm4,xmm5
214 packuswb xmm2,xmm4
215 movq [eax],xmm2
216 psrldq xmm1,8
217 movq [edi],xmm1
218 pop edi
219 psrldq xmm2,8
220 movq [ecx],xmm2
221 pop esi
222 mov esp,ebp
223 pop ebp
224 ret
225
226;******************************************************************************
227; void DeblockChromaLt4V_sse2(uint8_t * pPixCb, uint8_t * pPixCr, int32_t iStride,
228; int32_t iAlpha, int32_t iBeta, int8_t * pTC);
229;*******************************************************************************
230
231WELS_EXTERN DeblockChromaLt4V_sse2
232
233DeblockChromaLt4V_sse2:
234 push ebp
235 mov ebp,esp
236 and esp,0FFFFFFF0h
237 sub esp,0E4h
238 push ebx
239 push esi
240 mov esi, [ebp+1Ch] ; pTC
241 movsx ebx, byte [esi+2]
242 push edi
243 movsx di,byte [esi+3]
244 mov word [esp+0Ch],bx
245 movsx bx,byte [esi+1]
246 movsx esi,byte [esi]
247 mov word [esp+0Eh],si
248 movzx esi,di
249 movd xmm1,esi
250 movzx esi,di
251 movd xmm2,esi
252 mov si,word [esp+0Ch]
253 mov edx, [ebp + 10h]
254 mov eax, [ebp + 08h]
255 movzx edi,si
256 movzx esi,si
257 mov ecx, [ebp + 0Ch]
258 movd xmm4,esi
259 movzx esi,bx
260 movd xmm5,esi
261 movd xmm3,edi
262 movzx esi,bx
263 movd xmm6,esi
264 mov si,word [esp+0Eh]
265 movzx edi,si
266 movzx esi,si
267 punpcklwd xmm6,xmm2
268 pxor xmm0,xmm0
269 movdqa [esp+40h],xmm0
270 movd xmm7,edi
271 movd xmm0,esi
272 lea esi,[edx+edx]
273 mov edi,eax
274 sub edi,esi
275 punpcklwd xmm5,xmm1
276 movdqa xmm1,[esp+40h]
277 punpcklwd xmm0,xmm4
278 movq xmm4,[edx+ecx]
279 punpcklwd xmm7,xmm3
280 movq xmm3,[eax]
281 punpcklwd xmm0,xmm6
282 movq xmm6,[edi]
283 punpcklwd xmm7,xmm5
284 punpcklwd xmm0,xmm7
285 mov edi,ecx
286 sub edi,esi
287 movdqa xmm2,xmm1
288 psubw xmm2,xmm0
289 movdqa [esp+60h],xmm2
290 movq xmm2, [edi]
291 punpcklqdq xmm6,xmm2
292 mov esi,eax
293 sub esi,edx
294 movq xmm7,[esi]
295 mov edi,ecx
296 sub edi,edx
297 movq xmm2,[edi]
298 punpcklqdq xmm7,xmm2
299 movq xmm2,[ecx]
300 punpcklqdq xmm3,xmm2
301 movq xmm2,[edx+eax]
302 movsx edx,word [ebp + 14h]
303 punpcklqdq xmm2,xmm4
304 movdqa [esp+0E0h],xmm2
305 movd xmm2,edx
306 movsx edx,word [ebp + 18h]
307 movdqa xmm4,xmm2
308 punpcklwd xmm4,xmm2
309 movd xmm2,edx
310 movdqa xmm5,xmm2
311 punpcklwd xmm5,xmm2
312 pshufd xmm2,xmm5,0
313 movdqa [esp+50h],xmm2
314 movdqa xmm2,xmm6
315 punpcklbw xmm2,xmm1
316 movdqa [esp+0D0h],xmm3
317 pshufd xmm4,xmm4,0
318 movdqa [esp+30h],xmm2
319 punpckhbw xmm6,xmm1
320 movdqa [esp+80h],xmm6
321 movdqa xmm6,[esp+0D0h]
322 punpckhbw xmm6,xmm1
323 movdqa [esp+70h],xmm6
324 movdqa xmm6, [esp+0E0h]
325 punpckhbw xmm6,xmm1
326 movdqa [esp+90h],xmm6
327 movdqa xmm5, [esp+0E0h]
328 movdqa xmm2,xmm7
329 punpckhbw xmm7,xmm1
330 punpcklbw xmm5,xmm1
331 movdqa [esp+0A0h],xmm7
332 punpcklbw xmm3,xmm1
333 mov edx,4
334 punpcklbw xmm2,xmm1
335 movsx edx,dx
336 movd xmm6,edx
337 movdqa xmm7,xmm6
338 punpcklwd xmm7,xmm6
339 pshufd xmm6,xmm7,0
340 movdqa xmm7,[esp+30h]
341 movdqa [esp+20h],xmm6
342 psubw xmm7,xmm5
343 movdqa xmm6,xmm0
344 pcmpgtw xmm6,xmm1
345 movdqa xmm1,[esp+60h]
346 movdqa [esp+40h],xmm6
347 movdqa xmm6,xmm3
348 psubw xmm6,xmm2
349 psllw xmm6,2
350 paddw xmm6,xmm7
351 paddw xmm6, [esp+20h]
352 movdqa xmm7, [esp+50h]
353 psraw xmm6,3
354 pmaxsw xmm1,xmm6
355 movdqa [esp+10h],xmm0
356 movdqa xmm6, [esp+10h]
357 pminsw xmm6,xmm1
358 movdqa [esp+10h],xmm6
359 movdqa xmm1,xmm2
360 psubw xmm1,xmm3
361 pabsw xmm1,xmm1
362 movdqa xmm6,xmm4
363 pcmpgtw xmm6,xmm1
364 movdqa xmm1, [esp+30h]
365 psubw xmm1,xmm2
366 pabsw xmm1,xmm1
367 pcmpgtw xmm7,xmm1
368 movdqa xmm1,[esp+50h]
369 pand xmm6,xmm7
370 movdqa xmm7,[esp+50h]
371 psubw xmm5,xmm3
372 pabsw xmm5,xmm5
373 pcmpgtw xmm1,xmm5
374 movdqa xmm5,[esp+80h]
375 psubw xmm5,[esp+90h]
376 pand xmm6,xmm1
377 pand xmm6,[esp+40h]
378 movdqa xmm1,[esp+10h]
379 pand xmm1,xmm6
380 movdqa xmm6,[esp+70h]
381 movdqa [esp+30h],xmm1
382 movdqa xmm1,[esp+0A0h]
383 psubw xmm6,xmm1
384 psllw xmm6,2
385 paddw xmm6,xmm5
386 paddw xmm6,[esp+20h]
387 movdqa xmm5,[esp+60h]
388 psraw xmm6,3
389 pmaxsw xmm5,xmm6
390 pminsw xmm0,xmm5
391 movdqa xmm5,[esp+70h]
392 movdqa xmm6,xmm1
393 psubw xmm6,xmm5
394 pabsw xmm6,xmm6
395 pcmpgtw xmm4,xmm6
396 movdqa xmm6,[esp+80h]
397 psubw xmm6,xmm1
398 pabsw xmm6,xmm6
399 pcmpgtw xmm7,xmm6
400 movdqa xmm6,[esp+90h]
401 pand xmm4,xmm7
402 movdqa xmm7,[esp+50h]
403 psubw xmm6,xmm5
404 pabsw xmm6,xmm6
405 pcmpgtw xmm7,xmm6
406 pand xmm4,xmm7
407 pand xmm4,[esp+40h]
408 pand xmm0,xmm4
409 movdqa xmm4,[esp+30h]
410 paddw xmm2,xmm4
411 paddw xmm1,xmm0
412 packuswb xmm2,xmm1
413 movq [esi],xmm2
414 psubw xmm3,xmm4
415 psubw xmm5,xmm0
416 packuswb xmm3,xmm5
417 movq [eax],xmm3
418 psrldq xmm2,8
419 movq [edi],xmm2
420 pop edi
421 pop esi
422 psrldq xmm3,8
423 movq [ecx],xmm3
424 pop ebx
425 mov esp,ebp
426 pop ebp
427 ret
428
429;***************************************************************************
430; void DeblockChromaEq4H_sse2(uint8_t * pPixCb, uint8_t * pPixCr, int32_t iStride,
431; int32_t iAlpha, int32_t iBeta)
432;***************************************************************************
433
434WELS_EXTERN DeblockChromaEq4H_sse2
435
436ALIGN 16
437
438DeblockChromaEq4H_sse2:
439 push ebp
440 mov ebp,esp
441 and esp,0FFFFFFF0h
442 sub esp,0C8h
443 mov ecx,dword [ebp+8]
444 mov edx,dword [ebp+0Ch]
445 mov eax,dword [ebp+10h]
446 sub ecx,2
447 sub edx,2
448 push esi
449 lea esi,[eax+eax*2]
450 mov dword [esp+18h],ecx
451 mov dword [esp+4],edx
452 lea ecx,[ecx+eax*4]
453 lea edx,[edx+eax*4]
454 lea eax,[esp+7Ch]
455 push edi
456 mov dword [esp+14h],esi
457 mov dword [esp+18h],ecx
458 mov dword [esp+0Ch],edx
459 mov dword [esp+10h],eax
460 mov esi,dword [esp+1Ch]
461 mov ecx,dword [ebp+10h]
462 mov edx,dword [esp+14h]
463 movd xmm0,dword [esi]
464 movd xmm1,dword [esi+ecx]
465 movd xmm2,dword [esi+ecx*2]
466 movd xmm3,dword [esi+edx]
467 mov esi,dword [esp+8]
468 movd xmm4,dword [esi]
469 movd xmm5,dword [esi+ecx]
470 movd xmm6,dword [esi+ecx*2]
471 movd xmm7,dword [esi+edx]
472 punpckldq xmm0,xmm4
473 punpckldq xmm1,xmm5
474 punpckldq xmm2,xmm6
475 punpckldq xmm3,xmm7
476 mov esi,dword [esp+18h]
477 mov edi,dword [esp+0Ch]
478 movd xmm4,dword [esi]
479 movd xmm5,dword [edi]
480 punpckldq xmm4,xmm5
481 punpcklqdq xmm0,xmm4
482 movd xmm4,dword [esi+ecx]
483 movd xmm5,dword [edi+ecx]
484 punpckldq xmm4,xmm5
485 punpcklqdq xmm1,xmm4
486 movd xmm4,dword [esi+ecx*2]
487 movd xmm5,dword [edi+ecx*2]
488 punpckldq xmm4,xmm5
489 punpcklqdq xmm2,xmm4
490 movd xmm4,dword [esi+edx]
491 movd xmm5,dword [edi+edx]
492 punpckldq xmm4,xmm5
493 punpcklqdq xmm3,xmm4
494 movdqa xmm6,xmm0
495 punpcklbw xmm0,xmm1
496 punpckhbw xmm6,xmm1
497 movdqa xmm7,xmm2
498 punpcklbw xmm2,xmm3
499 punpckhbw xmm7,xmm3
500 movdqa xmm4,xmm0
501 movdqa xmm5,xmm6
502 punpcklwd xmm0,xmm2
503 punpckhwd xmm4,xmm2
504 punpcklwd xmm6,xmm7
505 punpckhwd xmm5,xmm7
506 movdqa xmm1,xmm0
507 movdqa xmm2,xmm4
508 punpckldq xmm0,xmm6
509 punpckhdq xmm1,xmm6
510 punpckldq xmm4,xmm5
511 punpckhdq xmm2,xmm5
512 movdqa xmm5,xmm0
513 movdqa xmm6,xmm1
514 punpcklqdq xmm0,xmm4
515 punpckhqdq xmm5,xmm4
516 punpcklqdq xmm1,xmm2
517 punpckhqdq xmm6,xmm2
518 mov edi,dword [esp+10h]
519 movdqa [edi],xmm0
520 movdqa [edi+10h],xmm5
521 movdqa [edi+20h],xmm1
522 movdqa [edi+30h],xmm6
523 movsx ecx,word [ebp+14h]
524 movsx edx,word [ebp+18h]
525 movdqa xmm6,[esp+80h]
526 movdqa xmm4,[esp+90h]
527 movdqa xmm5,[esp+0A0h]
528 movdqa xmm7,[esp+0B0h]
529 pxor xmm0,xmm0
530 movd xmm1,ecx
531 movdqa xmm2,xmm1
532 punpcklwd xmm2,xmm1
533 pshufd xmm1,xmm2,0
534 movd xmm2,edx
535 movdqa xmm3,xmm2
536 punpcklwd xmm3,xmm2
537 pshufd xmm2,xmm3,0
538 movdqa xmm3,xmm6
539 punpckhbw xmm6,xmm0
540 movdqa [esp+60h],xmm6
541 movdqa xmm6,[esp+90h]
542 punpckhbw xmm6,xmm0
543 movdqa [esp+30h],xmm6
544 movdqa xmm6,[esp+0A0h]
545 punpckhbw xmm6,xmm0
546 movdqa [esp+40h],xmm6
547 movdqa xmm6,[esp+0B0h]
548 punpckhbw xmm6,xmm0
549 movdqa [esp+70h],xmm6
550 punpcklbw xmm7,xmm0
551 punpcklbw xmm4,xmm0
552 punpcklbw xmm5,xmm0
553 punpcklbw xmm3,xmm0
554 movdqa [esp+50h],xmm7
555 movdqa xmm6,xmm4
556 psubw xmm6,xmm5
557 pabsw xmm6,xmm6
558 movdqa xmm0,xmm1
559 pcmpgtw xmm0,xmm6
560 movdqa xmm6,xmm3
561 psubw xmm6,xmm4
562 pabsw xmm6,xmm6
563 movdqa xmm7,xmm2
564 pcmpgtw xmm7,xmm6
565 movdqa xmm6,[esp+50h]
566 psubw xmm6,xmm5
567 pabsw xmm6,xmm6
568 pand xmm0,xmm7
569 movdqa xmm7,xmm2
570 pcmpgtw xmm7,xmm6
571 movdqa xmm6,[esp+30h]
572 psubw xmm6,[esp+40h]
573 pabsw xmm6,xmm6
574 pcmpgtw xmm1,xmm6
575 movdqa xmm6,[esp+60h]
576 psubw xmm6,[esp+30h]
577 pabsw xmm6,xmm6
578 pand xmm0,xmm7
579 movdqa xmm7,xmm2
580 pcmpgtw xmm7,xmm6
581 movdqa xmm6,[esp+70h]
582 psubw xmm6,[esp+40h]
583 pabsw xmm6,xmm6
584 pand xmm1,xmm7
585 pcmpgtw xmm2,xmm6
586 pand xmm1,xmm2
587 mov eax,2
588 movsx ecx,ax
589 movd xmm2,ecx
590 movdqa xmm6,xmm2
591 punpcklwd xmm6,xmm2
592 pshufd xmm2,xmm6,0
593 movdqa [esp+20h],xmm2
594 movdqa xmm2,xmm3
595 paddw xmm2,xmm3
596 paddw xmm2,xmm4
597 paddw xmm2,[esp+50h]
598 paddw xmm2,[esp+20h]
599 psraw xmm2,2
600 movdqa xmm6,xmm0
601 pand xmm6,xmm2
602 movdqa xmm2,xmm0
603 pandn xmm2,xmm4
604 por xmm6,xmm2
605 movdqa xmm2,[esp+60h]
606 movdqa xmm7,xmm2
607 paddw xmm7,xmm2
608 paddw xmm7,[esp+30h]
609 paddw xmm7,[esp+70h]
610 paddw xmm7,[esp+20h]
611 movdqa xmm4,xmm1
612 movdqa xmm2,xmm1
613 pandn xmm2,[esp+30h]
614 psraw xmm7,2
615 pand xmm4,xmm7
616 por xmm4,xmm2
617 movdqa xmm2,[esp+50h]
618 packuswb xmm6,xmm4
619 movdqa [esp+90h],xmm6
620 movdqa xmm6,xmm2
621 paddw xmm6,xmm2
622 movdqa xmm2,[esp+20h]
623 paddw xmm6,xmm5
624 paddw xmm6,xmm3
625 movdqa xmm4,xmm0
626 pandn xmm0,xmm5
627 paddw xmm6,xmm2
628 psraw xmm6,2
629 pand xmm4,xmm6
630 por xmm4,xmm0
631 movdqa xmm0,[esp+70h]
632 movdqa xmm5,xmm0
633 paddw xmm5,xmm0
634 movdqa xmm0,[esp+40h]
635 paddw xmm5,xmm0
636 paddw xmm5,[esp+60h]
637 movdqa xmm3,xmm1
638 paddw xmm5,xmm2
639 psraw xmm5,2
640 pand xmm3,xmm5
641 pandn xmm1,xmm0
642 por xmm3,xmm1
643 packuswb xmm4,xmm3
644 movdqa [esp+0A0h],xmm4
645 mov esi,dword [esp+10h]
646 movdqa xmm0,[esi]
647 movdqa xmm1,[esi+10h]
648 movdqa xmm2,[esi+20h]
649 movdqa xmm3,[esi+30h]
650 movdqa xmm6,xmm0
651 punpcklbw xmm0,xmm1
652 punpckhbw xmm6,xmm1
653 movdqa xmm7,xmm2
654 punpcklbw xmm2,xmm3
655 punpckhbw xmm7,xmm3
656 movdqa xmm4,xmm0
657 movdqa xmm5,xmm6
658 punpcklwd xmm0,xmm2
659 punpckhwd xmm4,xmm2
660 punpcklwd xmm6,xmm7
661 punpckhwd xmm5,xmm7
662 movdqa xmm1,xmm0
663 movdqa xmm2,xmm4
664 punpckldq xmm0,xmm6
665 punpckhdq xmm1,xmm6
666 punpckldq xmm4,xmm5
667 punpckhdq xmm2,xmm5
668 movdqa xmm5,xmm0
669 movdqa xmm6,xmm1
670 punpcklqdq xmm0,xmm4
671 punpckhqdq xmm5,xmm4
672 punpcklqdq xmm1,xmm2
673 punpckhqdq xmm6,xmm2
674 mov esi,dword [esp+1Ch]
675 mov ecx,dword [ebp+10h]
676 mov edx,dword [esp+14h]
677 mov edi,dword [esp+8]
678 movd dword [esi],xmm0
679 movd dword [esi+ecx],xmm5
680 movd dword [esi+ecx*2],xmm1
681 movd dword [esi+edx],xmm6
682 psrldq xmm0,4
683 psrldq xmm5,4
684 psrldq xmm1,4
685 psrldq xmm6,4
686 mov esi,dword [esp+18h]
687 movd dword [edi],xmm0
688 movd dword [edi+ecx],xmm5
689 movd dword [edi+ecx*2],xmm1
690 movd dword [edi+edx],xmm6
691 psrldq xmm0,4
692 psrldq xmm5,4
693 psrldq xmm1,4
694 psrldq xmm6,4
695 movd dword [esi],xmm0
696 movd dword [esi+ecx],xmm5
697 movd dword [esi+ecx*2],xmm1
698 movd dword [esi+edx],xmm6
699 psrldq xmm0,4
700 psrldq xmm5,4
701 psrldq xmm1,4
702 psrldq xmm6,4
703 mov edi,dword [esp+0Ch]
704 movd dword [edi],xmm0
705 movd dword [edi+ecx],xmm5
706 movd dword [edi+ecx*2],xmm1
707 movd dword [edi+edx],xmm6
708 pop edi
709 pop esi
710 mov esp,ebp
711 pop ebp
712 ret
713
714;*******************************************************************************
715; void DeblockChromaLt4H_sse2(uint8_t * pPixCb, uint8_t * pPixCr, int32_t iStride,
716; int32_t iAlpha, int32_t iBeta, int8_t * pTC);
717;*******************************************************************************
718
719WELS_EXTERN DeblockChromaLt4H_sse2
720
721ALIGN 16
722
723DeblockChromaLt4H_sse2:
724 push ebp
725 mov ebp,esp
726 and esp,0FFFFFFF0h
727 sub esp,108h
728 mov ecx,dword [ebp+8]
729 mov edx,dword [ebp+0Ch]
730 mov eax,dword [ebp+10h]
731 sub ecx,2
732 sub edx,2
733 push esi
734 lea esi,[eax+eax*2]
735 mov dword [esp+10h],ecx
736 mov dword [esp+4],edx
737 lea ecx,[ecx+eax*4]
738 lea edx,[edx+eax*4]
739 lea eax,[esp+6Ch]
740 push edi
741 mov dword [esp+0Ch],esi
742 mov dword [esp+18h],ecx
743 mov dword [esp+10h],edx
744 mov dword [esp+1Ch],eax
745 mov esi,dword [esp+14h]
746 mov ecx,dword [ebp+10h]
747 mov edx,dword [esp+0Ch]
748 movd xmm0,dword [esi]
749 movd xmm1,dword [esi+ecx]
750 movd xmm2,dword [esi+ecx*2]
751 movd xmm3,dword [esi+edx]
752 mov esi,dword [esp+8]
753 movd xmm4,dword [esi]
754 movd xmm5,dword [esi+ecx]
755 movd xmm6,dword [esi+ecx*2]
756 movd xmm7,dword [esi+edx]
757 punpckldq xmm0,xmm4
758 punpckldq xmm1,xmm5
759 punpckldq xmm2,xmm6
760 punpckldq xmm3,xmm7
761 mov esi,dword [esp+18h]
762 mov edi,dword [esp+10h]
763 movd xmm4,dword [esi]
764 movd xmm5,dword [edi]
765 punpckldq xmm4,xmm5
766 punpcklqdq xmm0,xmm4
767 movd xmm4,dword [esi+ecx]
768 movd xmm5,dword [edi+ecx]
769 punpckldq xmm4,xmm5
770 punpcklqdq xmm1,xmm4
771 movd xmm4,dword [esi+ecx*2]
772 movd xmm5,dword [edi+ecx*2]
773 punpckldq xmm4,xmm5
774 punpcklqdq xmm2,xmm4
775 movd xmm4,dword [esi+edx]
776 movd xmm5,dword [edi+edx]
777 punpckldq xmm4,xmm5
778 punpcklqdq xmm3,xmm4
779 movdqa xmm6,xmm0
780 punpcklbw xmm0,xmm1
781 punpckhbw xmm6,xmm1
782 movdqa xmm7,xmm2
783 punpcklbw xmm2,xmm3
784 punpckhbw xmm7,xmm3
785 movdqa xmm4,xmm0
786 movdqa xmm5,xmm6
787 punpcklwd xmm0,xmm2
788 punpckhwd xmm4,xmm2
789 punpcklwd xmm6,xmm7
790 punpckhwd xmm5,xmm7
791 movdqa xmm1,xmm0
792 movdqa xmm2,xmm4
793 punpckldq xmm0,xmm6
794 punpckhdq xmm1,xmm6
795 punpckldq xmm4,xmm5
796 punpckhdq xmm2,xmm5
797 movdqa xmm5,xmm0
798 movdqa xmm6,xmm1
799 punpcklqdq xmm0,xmm4
800 punpckhqdq xmm5,xmm4
801 punpcklqdq xmm1,xmm2
802 punpckhqdq xmm6,xmm2
803 mov edi,dword [esp+1Ch]
804 movdqa [edi],xmm0
805 movdqa [edi+10h],xmm5
806 movdqa [edi+20h],xmm1
807 movdqa [edi+30h],xmm6
808 mov eax,dword [ebp+1Ch]
809 movsx cx,byte [eax+3]
810 movsx dx,byte [eax+2]
811 movsx si,byte [eax+1]
812 movsx ax,byte [eax]
813 movzx edi,cx
814 movzx ecx,cx
815 movd xmm2,ecx
816 movzx ecx,dx
817 movzx edx,dx
818 movd xmm3,ecx
819 movd xmm4,edx
820 movzx ecx,si
821 movzx edx,si
822 movd xmm5,ecx
823 pxor xmm0,xmm0
824 movd xmm6,edx
825 movzx ecx,ax
826 movdqa [esp+60h],xmm0
827 movzx edx,ax
828 movsx eax,word [ebp+14h]
829 punpcklwd xmm6,xmm2
830 movd xmm1,edi
831 movd xmm7,ecx
832 movsx ecx,word [ebp+18h]
833 movd xmm0,edx
834 punpcklwd xmm7,xmm3
835 punpcklwd xmm5,xmm1
836 movdqa xmm1,[esp+60h]
837 punpcklwd xmm7,xmm5
838 movdqa xmm5,[esp+0A0h]
839 punpcklwd xmm0,xmm4
840 punpcklwd xmm0,xmm6
841 movdqa xmm6, [esp+70h]
842 punpcklwd xmm0,xmm7
843 movdqa xmm7,[esp+80h]
844 movdqa xmm2,xmm1
845 psubw xmm2,xmm0
846 movdqa [esp+0D0h],xmm2
847 movd xmm2,eax
848 movdqa xmm3,xmm2
849 punpcklwd xmm3,xmm2
850 pshufd xmm4,xmm3,0
851 movd xmm2,ecx
852 movdqa xmm3,xmm2
853 punpcklwd xmm3,xmm2
854 pshufd xmm2,xmm3,0
855 movdqa xmm3, [esp+90h]
856 movdqa [esp+50h],xmm2
857 movdqa xmm2,xmm6
858 punpcklbw xmm2,xmm1
859 punpckhbw xmm6,xmm1
860 movdqa [esp+40h],xmm2
861 movdqa [esp+0B0h],xmm6
862 movdqa xmm6,[esp+90h]
863 movdqa xmm2,xmm7
864 punpckhbw xmm7,xmm1
865 punpckhbw xmm6,xmm1
866 punpcklbw xmm2,xmm1
867 punpcklbw xmm3,xmm1
868 punpcklbw xmm5,xmm1
869 movdqa [esp+0F0h],xmm7
870 movdqa [esp+0C0h],xmm6
871 movdqa xmm6, [esp+0A0h]
872 punpckhbw xmm6,xmm1
873 movdqa [esp+0E0h],xmm6
874 mov edx,4
875 movsx eax,dx
876 movd xmm6,eax
877 movdqa xmm7,xmm6
878 punpcklwd xmm7,xmm6
879 pshufd xmm6,xmm7,0
880 movdqa [esp+30h],xmm6
881 movdqa xmm7, [esp+40h]
882 psubw xmm7,xmm5
883 movdqa xmm6,xmm0
884 pcmpgtw xmm6,xmm1
885 movdqa [esp+60h],xmm6
886 movdqa xmm1, [esp+0D0h]
887 movdqa xmm6,xmm3
888 psubw xmm6,xmm2
889 psllw xmm6,2
890 paddw xmm6,xmm7
891 paddw xmm6,[esp+30h]
892 psraw xmm6,3
893 pmaxsw xmm1,xmm6
894 movdqa xmm7,[esp+50h]
895 movdqa [esp+20h],xmm0
896 movdqa xmm6, [esp+20h]
897 pminsw xmm6,xmm1
898 movdqa [esp+20h],xmm6
899 movdqa xmm6,xmm4
900 movdqa xmm1,xmm2
901 psubw xmm1,xmm3
902 pabsw xmm1,xmm1
903 pcmpgtw xmm6,xmm1
904 movdqa xmm1, [esp+40h]
905 psubw xmm1,xmm2
906 pabsw xmm1,xmm1
907 pcmpgtw xmm7,xmm1
908 movdqa xmm1, [esp+50h]
909 pand xmm6,xmm7
910 movdqa xmm7, [esp+50h]
911 psubw xmm5,xmm3
912 pabsw xmm5,xmm5
913 pcmpgtw xmm1,xmm5
914 movdqa xmm5, [esp+0B0h]
915 psubw xmm5,[esp+0E0h]
916 pand xmm6,xmm1
917 pand xmm6, [esp+60h]
918 movdqa xmm1, [esp+20h]
919 pand xmm1,xmm6
920 movdqa xmm6, [esp+0C0h]
921 movdqa [esp+40h],xmm1
922 movdqa xmm1, [esp+0F0h]
923 psubw xmm6,xmm1
924 psllw xmm6,2
925 paddw xmm6,xmm5
926 paddw xmm6, [esp+30h]
927 movdqa xmm5, [esp+0D0h]
928 psraw xmm6,3
929 pmaxsw xmm5,xmm6
930 pminsw xmm0,xmm5
931 movdqa xmm5,[esp+0C0h]
932 movdqa xmm6,xmm1
933 psubw xmm6,xmm5
934 pabsw xmm6,xmm6
935 pcmpgtw xmm4,xmm6
936 movdqa xmm6,[esp+0B0h]
937 psubw xmm6,xmm1
938 pabsw xmm6,xmm6
939 pcmpgtw xmm7,xmm6
940 movdqa xmm6, [esp+0E0h]
941 pand xmm4,xmm7
942 movdqa xmm7, [esp+50h]
943 psubw xmm6,xmm5
944 pabsw xmm6,xmm6
945 pcmpgtw xmm7,xmm6
946 pand xmm4,xmm7
947 pand xmm4,[esp+60h]
948 pand xmm0,xmm4
949 movdqa xmm4, [esp+40h]
950 paddw xmm2,xmm4
951 paddw xmm1,xmm0
952 psubw xmm3,xmm4
953 psubw xmm5,xmm0
954 packuswb xmm2,xmm1
955 packuswb xmm3,xmm5
956 movdqa [esp+80h],xmm2
957 movdqa [esp+90h],xmm3
958 mov esi,dword [esp+1Ch]
959 movdqa xmm0, [esi]
960 movdqa xmm1, [esi+10h]
961 movdqa xmm2, [esi+20h]
962 movdqa xmm3, [esi+30h]
963 movdqa xmm6,xmm0
964 punpcklbw xmm0,xmm1
965 punpckhbw xmm6,xmm1
966 movdqa xmm7,xmm2
967 punpcklbw xmm2,xmm3
968 punpckhbw xmm7,xmm3
969 movdqa xmm4,xmm0
970 movdqa xmm5,xmm6
971 punpcklwd xmm0,xmm2
972 punpckhwd xmm4,xmm2
973 punpcklwd xmm6,xmm7
974 punpckhwd xmm5,xmm7
975 movdqa xmm1,xmm0
976 movdqa xmm2,xmm4
977 punpckldq xmm0,xmm6
978 punpckhdq xmm1,xmm6
979 punpckldq xmm4,xmm5
980 punpckhdq xmm2,xmm5
981 movdqa xmm5,xmm0
982 movdqa xmm6,xmm1
983 punpcklqdq xmm0,xmm4
984 punpckhqdq xmm5,xmm4
985 punpcklqdq xmm1,xmm2
986 punpckhqdq xmm6,xmm2
987 mov esi,dword [esp+14h]
988 mov ecx,dword [ebp+10h]
989 mov edx,dword [esp+0Ch]
990 mov edi,dword [esp+8]
991 movd dword [esi],xmm0
992 movd dword [esi+ecx],xmm5
993 movd dword [esi+ecx*2],xmm1
994 movd dword [esi+edx],xmm6
995 psrldq xmm0,4
996 psrldq xmm5,4
997 psrldq xmm1,4
998 psrldq xmm6,4
999 mov esi,dword [esp+18h]
1000 movd dword [edi],xmm0
1001 movd dword [edi+ecx],xmm5
1002 movd dword [edi+ecx*2],xmm1
1003 movd dword [edi+edx],xmm6
1004 psrldq xmm0,4
1005 psrldq xmm5,4
1006 psrldq xmm1,4
1007 psrldq xmm6,4
1008 movd dword [esi],xmm0
1009 movd dword [esi+ecx],xmm5
1010 movd dword [esi+ecx*2],xmm1
1011 movd dword [esi+edx],xmm6
1012 psrldq xmm0,4
1013 psrldq xmm5,4
1014 psrldq xmm1,4
1015 psrldq xmm6,4
1016 mov edi,dword [esp+10h]
1017 movd dword [edi],xmm0
1018 movd dword [edi+ecx],xmm5
1019 movd dword [edi+ecx*2],xmm1
1020 movd dword [edi+edx],xmm6
1021 pop edi
1022 pop esi
1023 mov esp,ebp
1024 pop ebp
1025 ret
1026
1027
1028
1029;*******************************************************************************
1030; void DeblockLumaLt4V_sse2(uint8_t * pPix, int32_t iStride, int32_t iAlpha,
1031; int32_t iBeta, int8_t * pTC)
1032;*******************************************************************************
1033
1034
1035WELS_EXTERN DeblockLumaLt4V_sse2
1036
1037ALIGN 16
1038
1039DeblockLumaLt4V_sse2:
1040 push ebp
1041 mov ebp, esp
1042 and esp, -16 ; fffffff0H
1043 sub esp, 420 ; 000001a4H
1044 mov eax, dword [ebp+8]
1045 mov ecx, dword [ebp+12]
1046
1047 pxor xmm0, xmm0
1048 push ebx
1049 mov edx, dword [ebp+24]
1050 movdqa [esp+424-384], xmm0
1051 push esi
1052
1053 lea esi, [ecx+ecx*2]
1054 push edi
1055 mov edi, eax
1056 sub edi, esi
1057 movdqa xmm0, [edi]
1058
1059 lea esi, [ecx+ecx]
1060 movdqa [esp+432-208], xmm0
1061 mov edi, eax
1062 sub edi, esi
1063 movdqa xmm0, [edi]
1064 movdqa [esp+448-208], xmm0
1065
1066 mov ebx, eax
1067 sub ebx, ecx
1068 movdqa xmm0, [ebx]
1069 movdqa [esp+464-208], xmm0
1070
1071 movdqa xmm0, [eax]
1072
1073 add ecx, eax
1074 movdqa [esp+480-208], xmm0
1075 movdqa xmm0, [ecx]
1076 mov dword [esp+432-404], ecx
1077
1078 movsx ecx, word [ebp+16]
1079 movdqa [esp+496-208], xmm0
1080 movdqa xmm0, [esi+eax]
1081
1082 movsx si, byte [edx]
1083 movdqa [esp+512-208], xmm0
1084 movd xmm0, ecx
1085 movsx ecx, word [ebp+20]
1086 movdqa xmm1, xmm0
1087 punpcklwd xmm1, xmm0
1088 pshufd xmm0, xmm1, 0
1089 movdqa [esp+432-112], xmm0
1090 movd xmm0, ecx
1091 movsx cx, byte [edx+1]
1092 movdqa xmm1, xmm0
1093 punpcklwd xmm1, xmm0
1094 mov dword [esp+432-408], ebx
1095 movzx ebx, cx
1096 pshufd xmm0, xmm1, 0
1097 movd xmm1, ebx
1098 movzx ebx, cx
1099 movd xmm2, ebx
1100 movzx ebx, cx
1101 movzx ecx, cx
1102 movd xmm4, ecx
1103 movzx ecx, si
1104 movd xmm5, ecx
1105 movzx ecx, si
1106 movd xmm6, ecx
1107 movzx ecx, si
1108 movd xmm7, ecx
1109 movzx ecx, si
1110 movdqa [esp+432-336], xmm0
1111 movd xmm0, ecx
1112
1113 movsx cx, byte [edx+3]
1114 movsx dx, byte [edx+2]
1115 movd xmm3, ebx
1116 punpcklwd xmm0, xmm4
1117 movzx esi, cx
1118 punpcklwd xmm6, xmm2
1119 punpcklwd xmm5, xmm1
1120 punpcklwd xmm0, xmm6
1121 punpcklwd xmm7, xmm3
1122 punpcklwd xmm7, xmm5
1123 punpcklwd xmm0, xmm7
1124 movdqa [esp+432-400], xmm0
1125 movd xmm0, esi
1126 movzx esi, cx
1127 movd xmm2, esi
1128 movzx esi, cx
1129 movzx ecx, cx
1130 movd xmm4, ecx
1131 movzx ecx, dx
1132 movd xmm3, esi
1133 movd xmm5, ecx
1134 punpcklwd xmm5, xmm0
1135
1136 movdqa xmm0, [esp+432-384]
1137 movzx ecx, dx
1138 movd xmm6, ecx
1139 movzx ecx, dx
1140 movzx edx, dx
1141 punpcklwd xmm6, xmm2
1142 movd xmm7, ecx
1143 movd xmm1, edx
1144
1145 movdqa xmm2, [esp+448-208]
1146 punpcklbw xmm2, xmm0
1147
1148 mov ecx, 4
1149 movsx edx, cx
1150 punpcklwd xmm7, xmm3
1151 punpcklwd xmm7, xmm5
1152 movdqa xmm5, [esp+496-208]
1153 movdqa xmm3, [esp+464-208]
1154 punpcklbw xmm5, xmm0
1155 movdqa [esp+432-240], xmm5
1156 movdqa xmm5, [esp+512-208]
1157 punpcklbw xmm5, xmm0
1158 movdqa [esp+432-352], xmm5
1159 punpcklwd xmm1, xmm4
1160 movdqa xmm4, [esp+432-208]
1161 punpcklwd xmm1, xmm6
1162 movdqa xmm6, [esp+480-208]
1163 punpcklwd xmm1, xmm7
1164 punpcklbw xmm6, xmm0
1165 punpcklbw xmm3, xmm0
1166 punpcklbw xmm4, xmm0
1167 movdqa xmm7, xmm3
1168 psubw xmm7, xmm4
1169 pabsw xmm7, xmm7
1170 movdqa [esp+432-272], xmm4
1171 movdqa xmm4, [esp+432-336]
1172 movdqa xmm5, xmm4
1173 pcmpgtw xmm5, xmm7
1174 movdqa [esp+432-288], xmm5
1175 movdqa xmm7, xmm6
1176 psubw xmm7, [esp+432-352]
1177 pabsw xmm7, xmm7
1178 movdqa xmm5, xmm4
1179 pcmpgtw xmm5, xmm7
1180 movdqa [esp+432-256], xmm5
1181 movdqa xmm5, xmm3
1182 pavgw xmm5, xmm6
1183 movdqa [esp+432-304], xmm5
1184 movdqa xmm5, [esp+432-400]
1185 psubw xmm5, [esp+432-288]
1186 psubw xmm5, [esp+432-256]
1187 movdqa [esp+432-224], xmm5
1188 movdqa xmm5, xmm6
1189 psubw xmm5, xmm3
1190 movdqa [esp+432-32], xmm6
1191 psubw xmm6, [esp+432-240]
1192 movdqa xmm7, xmm5
1193 movdqa [esp+432-384], xmm5
1194 movdqa xmm5, [esp+432-112]
1195 pabsw xmm7, xmm7
1196 pcmpgtw xmm5, xmm7
1197 pabsw xmm6, xmm6
1198 movdqa xmm7, xmm4
1199 pcmpgtw xmm7, xmm6
1200
1201 pand xmm5, xmm7
1202 movdqa xmm6, xmm3
1203 psubw xmm6, xmm2
1204 pabsw xmm6, xmm6
1205 movdqa xmm7, xmm4
1206 pcmpgtw xmm7, xmm6
1207 movdqa xmm6, [esp+432-400]
1208 pand xmm5, xmm7
1209 movdqa xmm7, xmm6
1210 pcmpeqw xmm6, xmm0
1211 pcmpgtw xmm7, xmm0
1212 por xmm7, xmm6
1213 pand xmm5, xmm7
1214 movdqa [esp+432-320], xmm5
1215 movd xmm5, edx
1216 movdqa xmm6, xmm5
1217 punpcklwd xmm6, xmm5
1218 pshufd xmm5, xmm6, 0
1219 movdqa [esp+432-336], xmm5
1220 movdqa xmm5, [esp+432-224]
1221 movdqa [esp+432-368], xmm5
1222 movdqa xmm6, xmm0
1223 psubw xmm6, xmm5
1224 movdqa xmm5, [esp+432-384]
1225 psllw xmm5, 2
1226 movdqa xmm7, xmm2
1227 psubw xmm7, [esp+432-240]
1228 paddw xmm7, xmm5
1229 paddw xmm7, [esp+432-336]
1230 movdqa xmm5, [esp+432-368]
1231 psraw xmm7, 3
1232 pmaxsw xmm6, xmm7
1233 pminsw xmm5, xmm6
1234
1235 pand xmm5, [esp+432-320]
1236 movdqa xmm6, [esp+432-400]
1237 movdqa [esp+432-64], xmm5
1238 movdqa [esp+432-384], xmm6
1239 movdqa xmm5, xmm0
1240 psubw xmm5, xmm6
1241 movdqa [esp+432-368], xmm5
1242 movdqa xmm6, xmm5
1243 movdqa xmm5, [esp+432-272]
1244 paddw xmm5, [esp+432-304]
1245 movdqa xmm7, xmm2
1246 paddw xmm7, xmm2
1247 psubw xmm5, xmm7
1248 psraw xmm5, 1
1249 pmaxsw xmm6, xmm5
1250 movdqa xmm5, [esp+432-384]
1251 pminsw xmm5, xmm6
1252
1253 pand xmm5, [esp+432-320]
1254 pand xmm5, [esp+432-288]
1255 movdqa xmm6, [esp+432-240]
1256 movdqa [esp+432-96], xmm5
1257 movdqa xmm5, [esp+432-352]
1258 paddw xmm5, [esp+432-304]
1259 movdqa xmm7, xmm6
1260 paddw xmm7, xmm6
1261 movdqa xmm6, [esp+432-368]
1262 psubw xmm5, xmm7
1263
1264 movdqa xmm7, [esp+496-208]
1265 psraw xmm5, 1
1266 pmaxsw xmm6, xmm5
1267 movdqa xmm5, [esp+432-400]
1268 pminsw xmm5, xmm6
1269 pand xmm5, [esp+432-320]
1270 pand xmm5, [esp+432-256]
1271 movdqa xmm6, [esp+448-208]
1272 punpckhbw xmm7, xmm0
1273 movdqa [esp+432-352], xmm7
1274
1275 movdqa xmm7, [esp+512-208]
1276 punpckhbw xmm6, xmm0
1277 movdqa [esp+432-48], xmm5
1278 movdqa xmm5, [esp+432-208]
1279 movdqa [esp+432-368], xmm6
1280 movdqa xmm6, [esp+464-208]
1281 punpckhbw xmm7, xmm0
1282 punpckhbw xmm5, xmm0
1283 movdqa [esp+432-384], xmm7
1284 punpckhbw xmm6, xmm0
1285 movdqa [esp+432-400], xmm6
1286
1287 movdqa xmm7, [esp+432-400]
1288 movdqa xmm6, [esp+480-208]
1289 psubw xmm7, xmm5
1290 movdqa [esp+432-16], xmm5
1291 pabsw xmm7, xmm7
1292 punpckhbw xmm6, xmm0
1293 movdqa xmm5, xmm4
1294 pcmpgtw xmm5, xmm7
1295 movdqa [esp+432-288], xmm5
1296
1297 movdqa xmm7, xmm6
1298 psubw xmm7, [esp+432-384]
1299 pabsw xmm7, xmm7
1300 movdqa xmm5, xmm4
1301 pcmpgtw xmm5, xmm7
1302 movdqa [esp+432-256], xmm5
1303
1304 movdqa xmm5, [esp+432-400]
1305 movdqa [esp+432-80], xmm6
1306 pavgw xmm5, xmm6
1307 movdqa [esp+432-304], xmm5
1308
1309 movdqa xmm5, xmm1
1310 psubw xmm5, [esp+432-288]
1311 psubw xmm5, [esp+432-256]
1312 movdqa [esp+432-224], xmm5
1313 movdqa xmm5, xmm6
1314 psubw xmm5, [esp+432-400]
1315 psubw xmm6, [esp+432-352]
1316 movdqa [esp+432-272], xmm5
1317 movdqa xmm7, xmm5
1318 movdqa xmm5, [esp+432-112]
1319 pabsw xmm7, xmm7
1320 pcmpgtw xmm5, xmm7
1321 movdqa xmm7, xmm4
1322 pabsw xmm6, xmm6
1323 pcmpgtw xmm7, xmm6
1324 movdqa xmm6, [esp+432-368]
1325
1326 pand xmm5, xmm7
1327 movdqa xmm7, [esp+432-400]
1328 psubw xmm7, xmm6
1329 psubw xmm6, [esp+432-352]
1330 pabsw xmm7, xmm7
1331 pcmpgtw xmm4, xmm7
1332 pand xmm5, xmm4
1333
1334 paddw xmm2, [esp+432-96]
1335 movdqa xmm4, xmm1
1336 pcmpgtw xmm4, xmm0
1337 movdqa xmm7, xmm1
1338 pcmpeqw xmm7, xmm0
1339 por xmm4, xmm7
1340 pand xmm5, xmm4
1341 movdqa xmm4, [esp+432-224]
1342 movdqa [esp+432-320], xmm5
1343 movdqa xmm5, [esp+432-272]
1344 movdqa xmm7, xmm0
1345 psubw xmm7, xmm4
1346 psubw xmm0, xmm1
1347 psllw xmm5, 2
1348 paddw xmm6, xmm5
1349 paddw xmm6, [esp+432-336]
1350 movdqa xmm5, [esp+432-368]
1351 movdqa [esp+432-336], xmm0
1352 psraw xmm6, 3
1353 pmaxsw xmm7, xmm6
1354 pminsw xmm4, xmm7
1355 pand xmm4, [esp+432-320]
1356 movdqa xmm6, xmm0
1357 movdqa xmm0, [esp+432-16]
1358 paddw xmm0, [esp+432-304]
1359 movdqa [esp+432-272], xmm4
1360 movdqa xmm4, [esp+432-368]
1361 paddw xmm4, xmm4
1362 psubw xmm0, xmm4
1363
1364 movdqa xmm4, [esp+432-64]
1365 psraw xmm0, 1
1366 pmaxsw xmm6, xmm0
1367 movdqa xmm0, [esp+432-400]
1368 movdqa xmm7, xmm1
1369 pminsw xmm7, xmm6
1370 movdqa xmm6, [esp+432-320]
1371 pand xmm7, xmm6
1372 pand xmm7, [esp+432-288]
1373 paddw xmm5, xmm7
1374 packuswb xmm2, xmm5
1375 movdqa xmm5, [esp+432-272]
1376 paddw xmm0, xmm5
1377 paddw xmm3, xmm4
1378 packuswb xmm3, xmm0
1379
1380 movdqa xmm0, [esp+432-32]
1381 psubw xmm0, xmm4
1382 movdqa xmm4, [esp+432-80]
1383 psubw xmm4, xmm5
1384
1385 movdqa xmm5, [esp+432-240]
1386 paddw xmm5, [esp+432-48]
1387 packuswb xmm0, xmm4
1388 movdqa xmm4, [esp+432-384]
1389 paddw xmm4, [esp+432-304]
1390 movdqa [esp+480-208], xmm0
1391 movdqa xmm0, [esp+432-352]
1392 movdqa xmm7, xmm0
1393 paddw xmm0, xmm0
1394
1395 mov ecx, dword [esp+432-408]
1396
1397 mov edx, dword [esp+432-404]
1398 psubw xmm4, xmm0
1399 movdqa xmm0, [esp+432-336]
1400 movdqa [edi], xmm2
1401 psraw xmm4, 1
1402 pmaxsw xmm0, xmm4
1403 pminsw xmm1, xmm0
1404 movdqa xmm0, [esp+480-208]
1405
1406 pop edi
1407 pand xmm1, xmm6
1408 pand xmm1, [esp+428-256]
1409 movdqa [ecx], xmm3
1410 paddw xmm7, xmm1
1411 pop esi
1412 packuswb xmm5, xmm7
1413 movdqa [eax], xmm0
1414 movdqa [edx], xmm5
1415 pop ebx
1416 mov esp, ebp
1417 pop ebp
1418 ret
1419
1420
1421;*******************************************************************************
1422; void DeblockLumaEq4V_sse2(uint8_t * pPix, int32_t iStride, int32_t iAlpha,
1423; int32_t iBeta)
1424;*******************************************************************************
1425
1426WELS_EXTERN DeblockLumaEq4V_sse2
1427
1428ALIGN 16
1429
1430DeblockLumaEq4V_sse2:
1431
1432 push ebp
1433 mov ebp, esp
1434 and esp, -16 ; fffffff0H
1435 sub esp, 628 ; 00000274H
1436 mov eax, dword [ebp+8]
1437 mov ecx, dword [ebp+12]
1438 push ebx
1439 push esi
1440
1441 lea edx, [ecx*4]
1442 pxor xmm0, xmm0
1443 movdqa xmm2, xmm0
1444
1445 movdqa xmm0, [ecx+eax]
1446 mov esi, eax
1447 sub esi, edx
1448 movdqa xmm3, [esi]
1449 movdqa xmm5, [eax]
1450 push edi
1451 lea edi, [ecx+ecx]
1452 lea ebx, [ecx+ecx*2]
1453 mov dword [esp+640-600], edi
1454 mov esi, eax
1455 sub esi, edi
1456 movdqa xmm1, [esi]
1457 movdqa [esp+720-272], xmm0
1458 mov edi, eax
1459 sub edi, ecx
1460 movdqa xmm4, [edi]
1461 add ecx, eax
1462 mov dword [esp+640-596], ecx
1463
1464 mov ecx, dword [esp+640-600]
1465 movdqa xmm0, [ecx+eax]
1466 movdqa [esp+736-272], xmm0
1467
1468 movdqa xmm0, [eax+ebx]
1469 mov edx, eax
1470 sub edx, ebx
1471
1472 movsx ebx, word [ebp+16]
1473 movdqa xmm6, [edx]
1474 add ecx, eax
1475 movdqa [esp+752-272], xmm0
1476 movd xmm0, ebx
1477
1478 movsx ebx, word [ebp+20]
1479 movdqa xmm7, xmm0
1480 punpcklwd xmm7, xmm0
1481 pshufd xmm0, xmm7, 0
1482 movdqa [esp+640-320], xmm0
1483 movd xmm0, ebx
1484 movdqa xmm7, xmm0
1485 punpcklwd xmm7, xmm0
1486 pshufd xmm0, xmm7, 0
1487
1488 movdqa xmm7, [esp+736-272]
1489 punpcklbw xmm7, xmm2
1490 movdqa [esp+640-416], xmm7
1491 movdqa [esp+640-512], xmm0
1492 movdqa xmm0, xmm1
1493 movdqa [esp+672-272], xmm1
1494 movdqa xmm1, xmm4
1495 movdqa [esp+704-272], xmm5
1496 punpcklbw xmm5, xmm2
1497 punpcklbw xmm1, xmm2
1498
1499 movdqa xmm7, xmm5
1500 psubw xmm7, xmm1
1501 pabsw xmm7, xmm7
1502 movdqa [esp+640-560], xmm7
1503 punpcklbw xmm0, xmm2
1504 movdqa [esp+688-272], xmm4
1505 movdqa xmm4, [esp+720-272]
1506 movdqa [esp+640-480], xmm0
1507
1508 movdqa xmm7, xmm1
1509 psubw xmm7, xmm0
1510
1511 movdqa xmm0, [esp+640-512]
1512 pabsw xmm7, xmm7
1513 punpcklbw xmm4, xmm2
1514 pcmpgtw xmm0, xmm7
1515 movdqa [esp+640-384], xmm4
1516 movdqa xmm7, xmm5
1517 psubw xmm7, xmm4
1518 movdqa xmm4, [esp+640-512]
1519 movdqa [esp+656-272], xmm6
1520 punpcklbw xmm6, xmm2
1521 pabsw xmm7, xmm7
1522 movdqa [esp+640-48], xmm2
1523 movdqa [esp+640-368], xmm6
1524 movdqa [esp+640-144], xmm1
1525 movdqa [esp+640-400], xmm5
1526 pcmpgtw xmm4, xmm7
1527 pand xmm0, xmm4
1528 movdqa xmm4, [esp+640-320]
1529 pcmpgtw xmm4, [esp+640-560]
1530 pand xmm0, xmm4
1531
1532 mov ebx, 2
1533 movsx ebx, bx
1534 movd xmm4, ebx
1535 movdqa xmm7, xmm4
1536 punpcklwd xmm7, xmm4
1537 movdqa xmm4, [esp+640-320]
1538 psraw xmm4, 2
1539 pshufd xmm7, xmm7, 0
1540 paddw xmm4, xmm7
1541 movdqa [esp+640-576], xmm4
1542 pcmpgtw xmm4, [esp+640-560]
1543 movdqa [esp+640-560], xmm4
1544
1545 movdqa xmm4, [esp+640-512]
1546 movdqa [esp+640-624], xmm7
1547 movdqa xmm7, xmm1
1548 psubw xmm7, xmm6
1549 pabsw xmm7, xmm7
1550 pcmpgtw xmm4, xmm7
1551
1552 pand xmm4, [esp+640-560]
1553 movdqa [esp+640-544], xmm4
1554 movdqa xmm4, [esp+640-512]
1555 movdqa xmm7, xmm5
1556 psubw xmm7, [esp+640-416]
1557 pabsw xmm7, xmm7
1558 pcmpgtw xmm4, xmm7
1559
1560 pand xmm4, [esp+640-560]
1561 movdqa [esp+640-560], xmm4
1562
1563 movdqa xmm4, [esp+640-544]
1564 pandn xmm4, xmm6
1565 movdqa [esp+640-16], xmm4
1566 mov ebx, 4
1567 movsx ebx, bx
1568 movd xmm4, ebx
1569 movdqa xmm7, xmm4
1570 punpcklwd xmm7, xmm4
1571 movdqa xmm4, xmm3
1572 punpcklbw xmm4, xmm2
1573 psllw xmm4, 1
1574 paddw xmm4, xmm6
1575 paddw xmm4, xmm6
1576 paddw xmm4, xmm6
1577 paddw xmm4, [esp+640-480]
1578
1579 movdqa xmm6, [esp+640-560]
1580 pshufd xmm7, xmm7, 0
1581 paddw xmm4, xmm1
1582 movdqa [esp+640-592], xmm7
1583 paddw xmm4, xmm5
1584 paddw xmm4, xmm7
1585 movdqa xmm7, [esp+640-416]
1586 pandn xmm6, xmm7
1587 movdqa [esp+640-80], xmm6
1588 movdqa xmm6, [esp+752-272]
1589 punpcklbw xmm6, xmm2
1590 psllw xmm6, 1
1591 paddw xmm6, xmm7
1592 paddw xmm6, xmm7
1593 paddw xmm6, xmm7
1594 paddw xmm6, [esp+640-384]
1595
1596 movdqa xmm7, [esp+640-480]
1597 paddw xmm6, xmm5
1598 paddw xmm6, xmm1
1599 paddw xmm6, [esp+640-592]
1600 psraw xmm6, 3
1601 pand xmm6, [esp+640-560]
1602 movdqa [esp+640-112], xmm6
1603 movdqa xmm6, [esp+640-544]
1604 pandn xmm6, xmm7
1605 movdqa [esp+640-336], xmm6
1606 movdqa xmm6, [esp+640-544]
1607 movdqa [esp+640-528], xmm6
1608 movdqa xmm6, [esp+640-368]
1609 paddw xmm6, xmm7
1610 movdqa xmm7, xmm1
1611 psraw xmm4, 3
1612 pand xmm4, [esp+640-544]
1613 paddw xmm7, xmm5
1614 paddw xmm6, xmm7
1615 paddw xmm6, [esp+640-624]
1616 movdqa xmm7, [esp+640-528]
1617
1618 paddw xmm5, xmm1
1619 psraw xmm6, 2
1620 pand xmm7, xmm6
1621
1622 movdqa xmm6, [esp+640-384]
1623 movdqa [esp+640-64], xmm7
1624 movdqa xmm7, [esp+640-560]
1625 pandn xmm7, xmm6
1626 movdqa [esp+640-304], xmm7
1627 movdqa xmm7, [esp+640-560]
1628 movdqa [esp+640-528], xmm7
1629 movdqa xmm7, [esp+640-416]
1630 paddw xmm7, xmm6
1631 paddw xmm7, xmm5
1632 paddw xmm7, [esp+640-624]
1633 movdqa xmm5, [esp+640-528]
1634 psraw xmm7, 2
1635 pand xmm5, xmm7
1636 movdqa [esp+640-32], xmm5
1637
1638 movdqa xmm5, [esp+640-544]
1639 movdqa [esp+640-528], xmm5
1640 movdqa xmm5, [esp+640-480]
1641 movdqa xmm7, xmm5
1642 paddw xmm7, xmm5
1643 movdqa xmm5, xmm1
1644 paddw xmm5, xmm6
1645 paddw xmm6, [esp+640-592]
1646 paddw xmm7, xmm5
1647 paddw xmm7, [esp+640-624]
1648 movdqa xmm5, [esp+640-528]
1649 psraw xmm7, 2
1650 pandn xmm5, xmm7
1651 movdqa xmm7, [esp+640-480]
1652 paddw xmm7, xmm1
1653 paddw xmm7, [esp+640-400]
1654 movdqa xmm1, [esp+640-544]
1655 movdqa [esp+640-352], xmm5
1656 movdqa xmm5, [esp+640-368]
1657 psllw xmm7, 1
1658 paddw xmm7, xmm6
1659 paddw xmm5, xmm7
1660
1661 movdqa xmm7, [esp+640-400]
1662 psraw xmm5, 3
1663 pand xmm1, xmm5
1664 movdqa xmm5, [esp+640-480]
1665 movdqa [esp+640-96], xmm1
1666 movdqa xmm1, [esp+640-560]
1667 movdqa [esp+640-528], xmm1
1668 movdqa xmm1, [esp+640-384]
1669 movdqa xmm6, xmm1
1670 paddw xmm6, xmm1
1671 paddw xmm1, [esp+640-400]
1672 paddw xmm1, [esp+640-144]
1673 paddw xmm7, xmm5
1674 paddw xmm5, [esp+640-592]
1675 paddw xmm6, xmm7
1676 paddw xmm6, [esp+640-624]
1677 movdqa xmm7, [esp+640-528]
1678 psraw xmm6, 2
1679 psllw xmm1, 1
1680 paddw xmm1, xmm5
1681
1682 movdqa xmm5, [esp+656-272]
1683 pandn xmm7, xmm6
1684 movdqa xmm6, [esp+640-416]
1685 paddw xmm6, xmm1
1686 movdqa xmm1, [esp+640-560]
1687 psraw xmm6, 3
1688 pand xmm1, xmm6
1689
1690 movdqa xmm6, [esp+704-272]
1691 movdqa [esp+640-128], xmm1
1692 movdqa xmm1, [esp+672-272]
1693 punpckhbw xmm1, xmm2
1694 movdqa [esp+640-448], xmm1
1695 movdqa xmm1, [esp+688-272]
1696 punpckhbw xmm1, xmm2
1697 punpckhbw xmm6, xmm2
1698 movdqa [esp+640-288], xmm7
1699 punpckhbw xmm5, xmm2
1700 movdqa [esp+640-496], xmm1
1701 movdqa [esp+640-432], xmm6
1702
1703 movdqa xmm7, [esp+720-272]
1704 punpckhbw xmm7, xmm2
1705 movdqa [esp+640-464], xmm7
1706
1707 movdqa xmm7, [esp+736-272]
1708 punpckhbw xmm7, xmm2
1709 movdqa [esp+640-528], xmm7
1710
1711 movdqa xmm7, xmm6
1712
1713 psubw xmm6, [esp+640-464]
1714 psubw xmm7, xmm1
1715 pabsw xmm7, xmm7
1716 movdqa [esp+640-560], xmm7
1717 por xmm4, [esp+640-16]
1718 pabsw xmm6, xmm6
1719 movdqa xmm7, xmm1
1720 psubw xmm7, [esp+640-448]
1721
1722 movdqa xmm1, [esp+640-512]
1723 pabsw xmm7, xmm7
1724 pcmpgtw xmm1, xmm7
1725 movdqa xmm7, [esp+640-512]
1726 pcmpgtw xmm7, xmm6
1727 movdqa xmm6, [esp+640-320]
1728 pand xmm1, xmm7
1729 movdqa xmm7, [esp+640-560]
1730 pcmpgtw xmm6, xmm7
1731 pand xmm1, xmm6
1732
1733 movdqa xmm6, [esp+640-576]
1734 pcmpgtw xmm6, xmm7
1735
1736 movdqa xmm7, [esp+640-496]
1737 punpckhbw xmm3, xmm2
1738 movdqa [esp+640-560], xmm6
1739 movdqa xmm6, [esp+640-512]
1740 psubw xmm7, xmm5
1741 pabsw xmm7, xmm7
1742 pcmpgtw xmm6, xmm7
1743
1744 pand xmm6, [esp+640-560]
1745 movdqa xmm7, [esp+640-432]
1746 psubw xmm7, [esp+640-528]
1747
1748 psllw xmm3, 1
1749 movdqa [esp+640-544], xmm6
1750 movdqa xmm6, [esp+640-512]
1751
1752 movdqa xmm2, [esp+640-544]
1753 paddw xmm3, xmm5
1754 paddw xmm3, xmm5
1755 paddw xmm3, xmm5
1756 paddw xmm3, [esp+640-448]
1757 paddw xmm3, [esp+640-496]
1758 pabsw xmm7, xmm7
1759 pcmpgtw xmm6, xmm7
1760 pand xmm6, [esp+640-560]
1761 movdqa [esp+640-560], xmm6
1762
1763 movdqa xmm6, xmm0
1764 pand xmm6, xmm4
1765 movdqa xmm4, xmm0
1766 pandn xmm4, [esp+640-368]
1767 por xmm6, xmm4
1768 movdqa xmm4, [esp+640-432]
1769 paddw xmm3, xmm4
1770 paddw xmm3, [esp+640-592]
1771 psraw xmm3, 3
1772 pand xmm3, xmm2
1773 pandn xmm2, xmm5
1774 por xmm3, xmm2
1775 movdqa xmm7, xmm1
1776 pand xmm7, xmm3
1777 movdqa xmm3, [esp+640-64]
1778 por xmm3, [esp+640-336]
1779 movdqa xmm2, xmm1
1780 pandn xmm2, xmm5
1781 por xmm7, xmm2
1782
1783 movdqa xmm2, xmm0
1784 pand xmm2, xmm3
1785 movdqa xmm3, xmm0
1786 pandn xmm3, [esp+640-480]
1787 por xmm2, xmm3
1788 packuswb xmm6, xmm7
1789 movdqa [esp+640-336], xmm2
1790 movdqa [esp+656-272], xmm6
1791 movdqa xmm6, [esp+640-544]
1792 movdqa xmm2, xmm5
1793 paddw xmm2, [esp+640-448]
1794 movdqa xmm3, xmm1
1795 movdqa xmm7, [esp+640-496]
1796 paddw xmm7, xmm4
1797 paddw xmm2, xmm7
1798 paddw xmm2, [esp+640-624]
1799 movdqa xmm7, [esp+640-544]
1800 psraw xmm2, 2
1801 pand xmm6, xmm2
1802 movdqa xmm2, [esp+640-448]
1803 pandn xmm7, xmm2
1804 por xmm6, xmm7
1805 pand xmm3, xmm6
1806 movdqa xmm6, xmm1
1807 pandn xmm6, xmm2
1808 paddw xmm2, [esp+640-496]
1809 paddw xmm2, xmm4
1810 por xmm3, xmm6
1811 movdqa xmm6, [esp+640-336]
1812 packuswb xmm6, xmm3
1813 psllw xmm2, 1
1814 movdqa [esp+672-272], xmm6
1815 movdqa xmm6, [esp+640-96]
1816 por xmm6, [esp+640-352]
1817
1818 movdqa xmm3, xmm0
1819 pand xmm3, xmm6
1820 movdqa xmm6, xmm0
1821 pandn xmm6, [esp+640-144]
1822 por xmm3, xmm6
1823 movdqa xmm6, [esp+640-544]
1824 movdqa [esp+640-352], xmm3
1825 movdqa xmm3, [esp+640-464]
1826 paddw xmm3, [esp+640-592]
1827 paddw xmm2, xmm3
1828 movdqa xmm3, [esp+640-448]
1829 paddw xmm5, xmm2
1830 movdqa xmm2, [esp+640-496]
1831 psraw xmm5, 3
1832 pand xmm6, xmm5
1833 movdqa xmm5, [esp+640-464]
1834 paddw xmm2, xmm5
1835 paddw xmm5, [esp+640-432]
1836 movdqa xmm4, xmm3
1837 paddw xmm4, xmm3
1838 paddw xmm4, xmm2
1839 paddw xmm4, [esp+640-624]
1840 movdqa xmm2, [esp+640-544]
1841 paddw xmm3, [esp+640-592]
1842 psraw xmm4, 2
1843 pandn xmm2, xmm4
1844 por xmm6, xmm2
1845 movdqa xmm7, xmm1
1846 pand xmm7, xmm6
1847 movdqa xmm6, [esp+640-496]
1848 movdqa xmm2, xmm1
1849 pandn xmm2, xmm6
1850 por xmm7, xmm2
1851 movdqa xmm2, [esp+640-352]
1852 packuswb xmm2, xmm7
1853 movdqa [esp+688-272], xmm2
1854 movdqa xmm2, [esp+640-128]
1855 por xmm2, [esp+640-288]
1856
1857 movdqa xmm4, xmm0
1858 pand xmm4, xmm2
1859 paddw xmm5, xmm6
1860 movdqa xmm2, xmm0
1861 pandn xmm2, [esp+640-400]
1862 por xmm4, xmm2
1863 movdqa xmm2, [esp+640-528]
1864 psllw xmm5, 1
1865 paddw xmm5, xmm3
1866 movdqa xmm3, [esp+640-560]
1867 paddw xmm2, xmm5
1868 psraw xmm2, 3
1869 movdqa [esp+640-288], xmm4
1870 movdqa xmm4, [esp+640-560]
1871 pand xmm4, xmm2
1872 movdqa xmm2, [esp+640-464]
1873 movdqa xmm5, xmm2
1874 paddw xmm5, xmm2
1875 movdqa xmm2, [esp+640-432]
1876 paddw xmm2, [esp+640-448]
1877 movdqa xmm7, xmm1
1878 paddw xmm5, xmm2
1879 paddw xmm5, [esp+640-624]
1880 movdqa xmm6, [esp+640-560]
1881 psraw xmm5, 2
1882 pandn xmm3, xmm5
1883 por xmm4, xmm3
1884 movdqa xmm3, [esp+640-32]
1885 por xmm3, [esp+640-304]
1886 pand xmm7, xmm4
1887 movdqa xmm4, [esp+640-432]
1888 movdqa xmm5, [esp+640-464]
1889 movdqa xmm2, xmm1
1890 pandn xmm2, xmm4
1891 paddw xmm4, [esp+640-496]
1892 por xmm7, xmm2
1893 movdqa xmm2, [esp+640-288]
1894 packuswb xmm2, xmm7
1895 movdqa [esp+704-272], xmm2
1896
1897 movdqa xmm2, xmm0
1898 pand xmm2, xmm3
1899 movdqa xmm3, xmm0
1900 pandn xmm3, [esp+640-384]
1901 por xmm2, xmm3
1902 movdqa [esp+640-304], xmm2
1903 movdqa xmm2, [esp+640-528]
1904 movdqa xmm3, xmm2
1905 paddw xmm3, [esp+640-464]
1906 paddw xmm3, xmm4
1907 paddw xmm3, [esp+640-624]
1908 psraw xmm3, 2
1909 pand xmm6, xmm3
1910 movdqa xmm3, [esp+640-560]
1911 movdqa xmm4, xmm3
1912 pandn xmm4, xmm5
1913 por xmm6, xmm4
1914 movdqa xmm7, xmm1
1915 pand xmm7, xmm6
1916 movdqa xmm6, [esp+640-304]
1917 movdqa xmm4, xmm1
1918 pandn xmm4, xmm5
1919 por xmm7, xmm4
1920
1921 movdqa xmm4, xmm0
1922 pandn xmm0, [esp+640-416]
1923 packuswb xmm6, xmm7
1924 movdqa xmm7, [esp+640-112]
1925 por xmm7, [esp+640-80]
1926 pand xmm4, xmm7
1927 por xmm4, xmm0
1928 movdqa xmm0, [esp+752-272]
1929 punpckhbw xmm0, [esp+640-48]
1930 psllw xmm0, 1
1931 paddw xmm0, xmm2
1932 paddw xmm0, xmm2
1933 paddw xmm0, xmm2
1934 paddw xmm0, xmm5
1935 paddw xmm0, [esp+640-432]
1936 paddw xmm0, [esp+640-496]
1937 paddw xmm0, [esp+640-592]
1938 psraw xmm0, 3
1939 pand xmm0, xmm3
1940 movdqa xmm7, xmm1
1941 pandn xmm3, xmm2
1942 por xmm0, xmm3
1943 pand xmm7, xmm0
1944
1945 movdqa xmm0, [esp+656-272]
1946 movdqa [edx], xmm0
1947
1948 movdqa xmm0, [esp+672-272]
1949
1950 mov edx, dword [esp+640-596]
1951 movdqa [esi], xmm0
1952 movdqa xmm0, [esp+688-272]
1953 movdqa [edi], xmm0
1954 movdqa xmm0, [esp+704-272]
1955
1956 pop edi
1957 pandn xmm1, xmm2
1958 movdqa [eax], xmm0
1959 por xmm7, xmm1
1960 pop esi
1961 packuswb xmm4, xmm7
1962 movdqa [edx], xmm6
1963 movdqa [ecx], xmm4
1964 pop ebx
1965 mov esp, ebp
1966 pop ebp
1967 ret
1968
1969
1970;********************************************************************************
1971;
1972; void DeblockLumaTransposeH2V_sse2(uint8_t * pPixY, int32_t iStride, uint8_t * pDst);
1973;
1974;********************************************************************************
1975
1976WELS_EXTERN DeblockLumaTransposeH2V_sse2
1977
1978ALIGN 16
1979
1980DeblockLumaTransposeH2V_sse2:
1981 push ebp
1982 push ebx
1983 mov ebp, esp
1984 and esp,0FFFFFFF0h
1985 sub esp, 10h
1986
1987 mov eax, [ebp + 0Ch]
1988 mov ecx, [ebp + 10h]
1989 lea edx, [eax + ecx * 8]
1990 lea ebx, [ecx*3]
1991
1992 movq xmm0, [eax]
1993 movq xmm7, [edx]
1994 punpcklqdq xmm0, xmm7
1995 movq xmm1, [eax + ecx]
1996 movq xmm7, [edx + ecx]
1997 punpcklqdq xmm1, xmm7
1998 movq xmm2, [eax + ecx*2]
1999 movq xmm7, [edx + ecx*2]
2000 punpcklqdq xmm2, xmm7
2001 movq xmm3, [eax + ebx]
2002 movq xmm7, [edx + ebx]
2003 punpcklqdq xmm3, xmm7
2004
2005 lea eax, [eax + ecx * 4]
2006 lea edx, [edx + ecx * 4]
2007 movq xmm4, [eax]
2008 movq xmm7, [edx]
2009 punpcklqdq xmm4, xmm7
2010 movq xmm5, [eax + ecx]
2011 movq xmm7, [edx + ecx]
2012 punpcklqdq xmm5, xmm7
2013 movq xmm6, [eax + ecx*2]
2014 movq xmm7, [edx + ecx*2]
2015 punpcklqdq xmm6, xmm7
2016
2017 movdqa [esp], xmm0
2018 movq xmm7, [eax + ebx]
2019 movq xmm0, [edx + ebx]
2020 punpcklqdq xmm7, xmm0
2021 movdqa xmm0, [esp]
2022
2023 SSE2_TransTwo8x8B xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, [esp]
2024 ;pOut: m5, m3, m4, m8, m6, m2, m7, m1
2025
2026 mov eax, [ebp + 14h]
2027 movdqa [eax], xmm4
2028 movdqa [eax + 10h], xmm2
2029 movdqa [eax + 20h], xmm3
2030 movdqa [eax + 30h], xmm7
2031 movdqa [eax + 40h], xmm5
2032 movdqa [eax + 50h], xmm1
2033 movdqa [eax + 60h], xmm6
2034 movdqa [eax + 70h], xmm0
2035
2036 mov esp, ebp
2037 pop ebx
2038 pop ebp
2039 ret
2040
2041
2042
2043;*******************************************************************************************
2044;
2045; void DeblockLumaTransposeV2H_sse2(uint8_t * pPixY, int32_t iStride, uint8_t * pSrc);
2046;
2047;*******************************************************************************************
2048
2049WELS_EXTERN DeblockLumaTransposeV2H_sse2
2050
2051ALIGN 16
2052
2053DeblockLumaTransposeV2H_sse2:
2054 push ebp
2055 mov ebp, esp
2056
2057 and esp, 0FFFFFFF0h
2058 sub esp, 10h
2059
2060 mov eax, [ebp + 10h]
2061 mov ecx, [ebp + 0Ch]
2062 mov edx, [ebp + 08h]
2063
2064 movdqa xmm0, [eax]
2065 movdqa xmm1, [eax + 10h]
2066 movdqa xmm2, [eax + 20h]
2067 movdqa xmm3, [eax + 30h]
2068 movdqa xmm4, [eax + 40h]
2069 movdqa xmm5, [eax + 50h]
2070 movdqa xmm6, [eax + 60h]
2071 movdqa xmm7, [eax + 70h]
2072
2073 SSE2_TransTwo8x8B xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, [esp]
2074 ;pOut: m5, m3, m4, m8, m6, m2, m7, m1
2075
2076 lea eax, [ecx * 3]
2077
2078 movq [edx], xmm4
2079 movq [edx + ecx], xmm2
2080 movq [edx + ecx*2], xmm3
2081 movq [edx + eax], xmm7
2082
2083 lea edx, [edx + ecx*4]
2084 movq [edx], xmm5
2085 movq [edx + ecx], xmm1
2086 movq [edx + ecx*2], xmm6
2087 movq [edx + eax], xmm0
2088
2089 psrldq xmm4, 8
2090 psrldq xmm2, 8
2091 psrldq xmm3, 8
2092 psrldq xmm7, 8
2093 psrldq xmm5, 8
2094 psrldq xmm1, 8
2095 psrldq xmm6, 8
2096 psrldq xmm0, 8
2097
2098 lea edx, [edx + ecx*4]
2099 movq [edx], xmm4
2100 movq [edx + ecx], xmm2
2101 movq [edx + ecx*2], xmm3
2102 movq [edx + eax], xmm7
2103
2104 lea edx, [edx + ecx*4]
2105 movq [edx], xmm5
2106 movq [edx + ecx], xmm1
2107 movq [edx + ecx*2], xmm6
2108 movq [edx + eax], xmm0
2109
2110
2111 mov esp, ebp
2112 pop ebp
2113 ret
codec/decoder/core/asm/expand_picture.asm+655−0
@@ -0,0 +1,655 @@
1;*!
2;* \copy
3;* Copyright (c) 2009-2013, Cisco Systems
4;* All rights reserved.
5;*
6;* Redistribution and use in source and binary forms, with or without
7;* modification, are permitted provided that the following conditions
8;* are met:
9;*
10;* * Redistributions of source code must retain the above copyright
11;* notice, this list of conditions and the following disclaimer.
12;*
13;* * Redistributions in binary form must reproduce the above copyright
14;* notice, this list of conditions and the following disclaimer in
15;* the documentation and/or other materials provided with the
16;* distribution.
17;*
18;* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19;* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20;* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21;* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22;* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23;* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24;* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25;* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26;* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27;* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28;* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29;* POSSIBILITY OF SUCH DAMAGE.
30;*
31;*
32;* expand_picture.asm
33;*
34;* Abstract
35;* mmxext/sse for expand_frame
36;*
37;* History
38;* 09/25/2009 Created
39;*
40;*
41;*************************************************************************/
42
43%include "asm_inc.asm"
44
45BITS 32
46
47;***********************************************************************
48; Macros and other preprocessor constants
49;***********************************************************************
50
51;***********************************************************************
52; Local Data (Read Only)
53;***********************************************************************
54
55;SECTION .rodata pData align=16
56
57;***********************************************************************
58; Various memory constants (trigonometric values or rounding values)
59;***********************************************************************
60;%define PADDING_SIZE_ASM 32 ; PADDING_LENGTH
61
62;***********************************************************************
63; Code
64;***********************************************************************
65
66
67
68SECTION .text
69
70;WELS_EXTERN expand_picture_luma_mmx
71;WELS_EXTERN expand_picture_chroma_mmx
72WELS_EXTERN ExpandPictureLuma_sse2
73WELS_EXTERN ExpandPictureChromaAlign_sse2 ; for chroma alignment
74WELS_EXTERN ExpandPictureChromaUnalign_sse2 ; for chroma unalignment
75
76;;;;;;;expanding result;;;;;;;
77
78;aaaa|attttttttttttttttb|bbbb
79;aaaa|attttttttttttttttb|bbbb
80;aaaa|attttttttttttttttb|bbbb
81;aaaa|attttttttttttttttb|bbbb
82;----------------------------
83;aaaa|attttttttttttttttb|bbbb
84;llll|l r|rrrr
85;llll|l r|rrrr
86;llll|l r|rrrr
87;llll|l r|rrrr
88;llll|l r|rrrr
89;cccc|ceeeeeeeeeeeeeeeed|dddd
90;----------------------------
91;cccc|ceeeeeeeeeeeeeeeed|dddd
92;cccc|ceeeeeeeeeeeeeeeed|dddd
93;cccc|ceeeeeeeeeeeeeeeed|dddd
94;cccc|ceeeeeeeeeeeeeeeed|dddd
95
96%macro mov_line_8x4_mmx 3 ; dst, stride, mm?
97 movq [%1], %3
98 movq [%1+%2], %3
99 lea %1, [%1+2*%2]
100 movq [%1], %3
101 movq [%1+%2], %3
102 lea %1, [%1+2*%2]
103%endmacro
104
105%macro mov_line_end8x4_mmx 3 ; dst, stride, mm?
106 movq [%1], %3
107 movq [%1+%2], %3
108 lea %1, [%1+2*%2]
109 movq [%1], %3
110 movq [%1+%2], %3
111 lea %1, [%1+%2]
112%endmacro
113
114%macro mov_line_16x4_sse2 4 ; dst, stride, xmm?, u/a
115 movdq%4 [%1], %3 ; top(bottom)_0
116 movdq%4 [%1+%2], %3 ; top(bottom)_1
117 lea %1, [%1+2*%2]
118 movdq%4 [%1], %3 ; top(bottom)_2
119 movdq%4 [%1+%2], %3 ; top(bottom)_3
120 lea %1, [%1+2*%2]
121%endmacro
122
123%macro mov_line_end16x4_sse2 4 ; dst, stride, xmm?, u/a
124 movdq%4 [%1], %3 ; top(bottom)_0
125 movdq%4 [%1+%2], %3 ; top(bottom)_1
126 lea %1, [%1+2*%2]
127 movdq%4 [%1], %3 ; top(bottom)_2
128 movdq%4 [%1+%2], %3 ; top(bottom)_3
129 lea %1, [%1+%2]
130%endmacro
131
132%macro mov_line_32x4_sse2 3 ; dst, stride, xmm?
133 movdqa [%1], %3 ; top(bottom)_0
134 movdqa [%1+16], %3 ; top(bottom)_0
135 movdqa [%1+%2], %3 ; top(bottom)_1
136 movdqa [%1+%2+16], %3 ; top(bottom)_1
137 lea %1, [%1+2*%2]
138 movdqa [%1], %3 ; top(bottom)_2
139 movdqa [%1+16], %3 ; top(bottom)_2
140 movdqa [%1+%2], %3 ; top(bottom)_3
141 movdqa [%1+%2+16], %3 ; top(bottom)_3
142 lea %1, [%1+2*%2]
143%endmacro
144
145%macro mov_line_end32x4_sse2 3 ; dst, stride, xmm?
146 movdqa [%1], %3 ; top(bottom)_0
147 movdqa [%1+16], %3 ; top(bottom)_0
148 movdqa [%1+%2], %3 ; top(bottom)_1
149 movdqa [%1+%2+16], %3 ; top(bottom)_1
150 lea %1, [%1+2*%2]
151 movdqa [%1], %3 ; top(bottom)_2
152 movdqa [%1+16], %3 ; top(bottom)_2
153 movdqa [%1+%2], %3 ; top(bottom)_3
154 movdqa [%1+%2+16], %3 ; top(bottom)_3
155 lea %1, [%1+%2]
156%endmacro
157
158%macro exp_top_bottom_sse2 1 ; iPaddingSize [luma(32)/chroma(16)]
159 ; ebx [width/16(8)]
160 ; esi [pSrc+0], edi [pSrc-1], ecx [-stride], 32(16) ; top
161 ; eax [pSrc+(h-1)*stride], ebp [pSrc+(h+31)*stride], 32(16) ; bottom
162
163%if %1 == 32 ; for luma
164 sar ebx, 04h ; width / 16(8) pixels
165.top_bottom_loops:
166 ; top
167 movdqa xmm0, [esi] ; first line of picture pData
168 mov_line_16x4_sse2 edi, ecx, xmm0, a ; dst, stride, xmm?
169 mov_line_16x4_sse2 edi, ecx, xmm0, a
170 mov_line_16x4_sse2 edi, ecx, xmm0, a
171 mov_line_16x4_sse2 edi, ecx, xmm0, a
172 mov_line_16x4_sse2 edi, ecx, xmm0, a ; dst, stride, xmm?
173 mov_line_16x4_sse2 edi, ecx, xmm0, a
174 mov_line_16x4_sse2 edi, ecx, xmm0, a
175 mov_line_end16x4_sse2 edi, ecx, xmm0, a
176
177 ; bottom
178 movdqa xmm1, [eax] ; last line of picture pData
179 mov_line_16x4_sse2 ebp, ecx, xmm1, a ; dst, stride, xmm?
180 mov_line_16x4_sse2 ebp, ecx, xmm1, a
181 mov_line_16x4_sse2 ebp, ecx, xmm1, a
182 mov_line_16x4_sse2 ebp, ecx, xmm1, a
183 mov_line_16x4_sse2 ebp, ecx, xmm1, a ; dst, stride, xmm?
184 mov_line_16x4_sse2 ebp, ecx, xmm1, a
185 mov_line_16x4_sse2 ebp, ecx, xmm1, a
186 mov_line_end16x4_sse2 ebp, ecx, xmm1, a
187
188 lea esi, [esi+16] ; top pSrc
189 lea edi, [edi+16] ; top dst
190 lea eax, [eax+16] ; bottom pSrc
191 lea ebp, [ebp+16] ; bottom dst
192 neg ecx ; positive/negative stride need for next loop?
193
194 dec ebx
195 jnz near .top_bottom_loops
196%elif %1 == 16 ; for chroma ??
197 mov edx, ebx
198 sar ebx, 04h ; (width / 16) pixels
199.top_bottom_loops:
200 ; top
201 movdqa xmm0, [esi] ; first line of picture pData
202 mov_line_16x4_sse2 edi, ecx, xmm0, a ; dst, stride, xmm?
203 mov_line_16x4_sse2 edi, ecx, xmm0, a
204 mov_line_16x4_sse2 edi, ecx, xmm0, a
205 mov_line_end16x4_sse2 edi, ecx, xmm0, a
206
207 ; bottom
208 movdqa xmm1, [eax] ; last line of picture pData
209 mov_line_16x4_sse2 ebp, ecx, xmm1, a ; dst, stride, xmm?
210 mov_line_16x4_sse2 ebp, ecx, xmm1, a
211 mov_line_16x4_sse2 ebp, ecx, xmm1, a
212 mov_line_end16x4_sse2 ebp, ecx, xmm1, a
213
214 lea esi, [esi+16] ; top pSrc
215 lea edi, [edi+16] ; top dst
216 lea eax, [eax+16] ; bottom pSrc
217 lea ebp, [ebp+16] ; bottom dst
218 neg ecx ; positive/negative stride need for next loop?
219
220 dec ebx
221 jnz near .top_bottom_loops
222
223 ; for remaining 8 bytes
224 and edx, 0fh ; any 8 bytes left?
225 test edx, edx
226 jz near .to_be_continued ; no left to exit here
227
228 ; top
229 movq mm0, [esi] ; remained 8 byte
230 mov_line_8x4_mmx edi, ecx, mm0 ; dst, stride, mm?
231 mov_line_8x4_mmx edi, ecx, mm0 ; dst, stride, mm?
232 mov_line_8x4_mmx edi, ecx, mm0 ; dst, stride, mm?
233 mov_line_end8x4_mmx edi, ecx, mm0 ; dst, stride, mm?
234 ; bottom
235 movq mm1, [eax]
236 mov_line_8x4_mmx ebp, ecx, mm1 ; dst, stride, mm?
237 mov_line_8x4_mmx ebp, ecx, mm1 ; dst, stride, mm?
238 mov_line_8x4_mmx ebp, ecx, mm1 ; dst, stride, mm?
239 mov_line_end8x4_mmx ebp, ecx, mm1 ; dst, stride, mm?
240 WELSEMMS
241
242.to_be_continued:
243%endif
244%endmacro
245
246%macro exp_left_right_sse2 2 ; iPaddingSize [luma(32)/chroma(16)], u/a
247 ; ecx [height]
248 ; esi [pSrc+0], edi [pSrc-32], edx [stride], 32(16) ; left
249 ; ebx [pSrc+(w-1)], ebp [pSrc+w], 32(16) ; right
250; xor eax, eax ; for pixel pData (uint8_t) ; make sure eax=0 at least high 24 bits of eax = 0
251
252%if %1 == 32 ; for luma
253.left_right_loops:
254 ; left
255 mov al, byte [esi] ; pixel pData for left border
256 butterfly_1to16_sse xmm0, xmm1, a ; dst, tmp, pSrc [generic register name: a/b/c/d]
257 movdqa [edi], xmm0
258 movdqa [edi+16], xmm0
259
260 ; right
261 mov al, byte [ebx]
262 butterfly_1to16_sse xmm1, xmm2, a ; dst, tmp, pSrc [generic register name: a/b/c/d]
263 movdqa [ebp], xmm1
264 movdqa [ebp+16], xmm1
265
266 lea esi, [esi+edx] ; left pSrc
267 lea edi, [edi+edx] ; left dst
268 lea ebx, [ebx+edx] ; right pSrc
269 lea ebp, [ebp+edx] ; right dst
270
271 dec ecx
272 jnz near .left_right_loops
273%elif %1 == 16 ; for chroma ??
274.left_right_loops:
275 ; left
276 mov al, byte [esi] ; pixel pData for left border
277 butterfly_1to16_sse xmm0, xmm1, a ; dst, tmp, pSrc [generic register name: a/b/c/d]
278 movdqa [edi], xmm0
279
280 ; right
281 mov al, byte [ebx]
282 butterfly_1to16_sse xmm1, xmm2, a ; dst, tmp, pSrc [generic register name: a/b/c/d]
283 movdq%2 [ebp], xmm1 ; might not be aligned 16 bytes in case chroma planes
284
285 lea esi, [esi+edx] ; left pSrc
286 lea edi, [edi+edx] ; left dst
287 lea ebx, [ebx+edx] ; right pSrc
288 lea ebp, [ebp+edx] ; right dst
289
290 dec ecx
291 jnz near .left_right_loops
292%endif
293%endmacro
294
295%macro exp_cross_sse2 2 ; iPaddingSize [luma(32)/chroma(16)], u/a
296 ; top-left: (x)mm3, top-right: (x)mm4, bottom-left: (x)mm5, bottom-right: (x)mm6
297 ; edi: TL, ebp: TR, eax: BL, ebx: BR, ecx, -stride
298%if %1 == 32 ; luma
299 ; TL
300 mov_line_32x4_sse2 edi, ecx, xmm3 ; dst, stride, xmm?
301 mov_line_32x4_sse2 edi, ecx, xmm3 ; dst, stride, xmm?
302 mov_line_32x4_sse2 edi, ecx, xmm3 ; dst, stride, xmm?
303 mov_line_32x4_sse2 edi, ecx, xmm3 ; dst, stride, xmm?
304 mov_line_32x4_sse2 edi, ecx, xmm3 ; dst, stride, xmm?
305 mov_line_32x4_sse2 edi, ecx, xmm3 ; dst, stride, xmm?
306 mov_line_32x4_sse2 edi, ecx, xmm3 ; dst, stride, xmm?
307 mov_line_end32x4_sse2 edi, ecx, xmm3 ; dst, stride, xmm?
308
309 ; TR
310 mov_line_32x4_sse2 ebp, ecx, xmm4 ; dst, stride, xmm?
311 mov_line_32x4_sse2 ebp, ecx, xmm4 ; dst, stride, xmm?
312 mov_line_32x4_sse2 ebp, ecx, xmm4 ; dst, stride, xmm?
313 mov_line_32x4_sse2 ebp, ecx, xmm4 ; dst, stride, xmm?
314 mov_line_32x4_sse2 ebp, ecx, xmm4 ; dst, stride, xmm?
315 mov_line_32x4_sse2 ebp, ecx, xmm4 ; dst, stride, xmm?
316 mov_line_32x4_sse2 ebp, ecx, xmm4 ; dst, stride, xmm?
317 mov_line_end32x4_sse2 ebp, ecx, xmm4 ; dst, stride, xmm?
318
319 ; BL
320 mov_line_32x4_sse2 eax, ecx, xmm5 ; dst, stride, xmm?
321 mov_line_32x4_sse2 eax, ecx, xmm5 ; dst, stride, xmm?
322 mov_line_32x4_sse2 eax, ecx, xmm5 ; dst, stride, xmm?
323 mov_line_32x4_sse2 eax, ecx, xmm5 ; dst, stride, xmm?
324 mov_line_32x4_sse2 eax, ecx, xmm5 ; dst, stride, xmm?
325 mov_line_32x4_sse2 eax, ecx, xmm5 ; dst, stride, xmm?
326 mov_line_32x4_sse2 eax, ecx, xmm5 ; dst, stride, xmm?
327 mov_line_end32x4_sse2 eax, ecx, xmm5 ; dst, stride, xmm?
328
329 ; BR
330 mov_line_32x4_sse2 ebx, ecx, xmm6 ; dst, stride, xmm?
331 mov_line_32x4_sse2 ebx, ecx, xmm6 ; dst, stride, xmm?
332 mov_line_32x4_sse2 ebx, ecx, xmm6 ; dst, stride, xmm?
333 mov_line_32x4_sse2 ebx, ecx, xmm6 ; dst, stride, xmm?
334 mov_line_32x4_sse2 ebx, ecx, xmm6 ; dst, stride, xmm?
335 mov_line_32x4_sse2 ebx, ecx, xmm6 ; dst, stride, xmm?
336 mov_line_32x4_sse2 ebx, ecx, xmm6 ; dst, stride, xmm?
337 mov_line_end32x4_sse2 ebx, ecx, xmm6 ; dst, stride, xmm?
338%elif %1 == 16 ; chroma
339 ; TL
340 mov_line_16x4_sse2 edi, ecx, xmm3, a ; dst, stride, xmm?
341 mov_line_16x4_sse2 edi, ecx, xmm3, a ; dst, stride, xmm?
342 mov_line_16x4_sse2 edi, ecx, xmm3, a ; dst, stride, xmm?
343 mov_line_end16x4_sse2 edi, ecx, xmm3, a ; dst, stride, xmm?
344
345 ; TR
346 mov_line_16x4_sse2 ebp, ecx, xmm4, %2 ; dst, stride, xmm?
347 mov_line_16x4_sse2 ebp, ecx, xmm4, %2 ; dst, stride, xmm?
348 mov_line_16x4_sse2 ebp, ecx, xmm4, %2 ; dst, stride, xmm?
349 mov_line_end16x4_sse2 ebp, ecx, xmm4, %2 ; dst, stride, xmm?
350
351 ; BL
352 mov_line_16x4_sse2 eax, ecx, xmm5, a ; dst, stride, xmm?
353 mov_line_16x4_sse2 eax, ecx, xmm5, a ; dst, stride, xmm?
354 mov_line_16x4_sse2 eax, ecx, xmm5, a ; dst, stride, xmm?
355 mov_line_end16x4_sse2 eax, ecx, xmm5, a ; dst, stride, xmm?
356
357 ; BR
358 mov_line_16x4_sse2 ebx, ecx, xmm6, %2 ; dst, stride, xmm?
359 mov_line_16x4_sse2 ebx, ecx, xmm6, %2 ; dst, stride, xmm?
360 mov_line_16x4_sse2 ebx, ecx, xmm6, %2 ; dst, stride, xmm?
361 mov_line_end16x4_sse2 ebx, ecx, xmm6, %2 ; dst, stride, xmm?
362%endif
363%endmacro
364
365ALIGN 16
366;***********************************************************************----------------
367; void ExpandPictureLuma_sse2( uint8_t *pDst,
368; const int32_t kiStride,
369; const int32_t kiWidth,
370; const int32_t kiHeight );
371;***********************************************************************----------------
372ExpandPictureLuma_sse2:
373 push ebx
374 push edx
375 push esi
376 push edi
377 push ebp
378
379 ; for both top and bottom border
380 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
381 mov esi, [esp+24] ; pDst
382 mov edx, [esp+28] ; kiStride
383 mov ebx, [esp+32] ; kiWidth
384 mov eax, [esp+36] ; kiHeight
385 ; also prepare for cross border pData top-left: xmm3
386; xor ecx, ecx
387 mov cl, byte [esi]
388 butterfly_1to16_sse xmm3, xmm4, c ; pDst, tmp, pSrc [generic register name: a/b/c/d]
389 ; load top border
390 mov ecx, edx ; kiStride
391 neg ecx ; -kiStride
392 lea edi, [esi+ecx] ; last line of top border
393 ; load bottom border
394 dec eax ; h-1
395 imul eax, edx ; (h-1)*kiStride
396 lea eax, [esi+eax] ; last line of picture pData
397 sal edx, 05h ; 32*kiStride
398 lea ebp, [eax+edx] ; last line of bottom border, (h-1)*stride + 32 * stride
399 ; also prepare for cross border pData: bottom-left with xmm5, bottom-right xmm6
400 dec ebx ; kiWidth-1
401 lea ebx, [eax+ebx] ; dst[w-1][h-1]
402; xor edx, edx
403 mov dl, byte [eax] ; bottom-left
404 butterfly_1to16_sse xmm5, xmm6, d ; dst, tmp, pSrc [generic register name: a/b/c/d]
405 mov dl, byte [ebx] ; bottom-right
406 butterfly_1to16_sse xmm6, xmm4, d ; dst, tmp, pSrc [generic register name: a/b/c/d]
407 ; for top & bottom expanding
408 mov ebx, [esp+32] ; kiWidth
409 exp_top_bottom_sse2 32
410
411 ; for both left and right border
412 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
413 mov esi, [esp+24] ; p_dst: left border pSrc
414 mov edx, [esp+28] ; kiStride
415 mov ebx, [esp+32] ; kiWidth
416 mov ecx, [esp+36] ; kiHeight
417 ; load left border
418 mov eax, -32 ; luma=-32, chroma=-16
419 lea edi, [esi+eax] ; left border dst
420 dec ebx
421 lea ebx, [esi+ebx] ; right border pSrc, (p_dst + width - 1)
422 lea ebp, [ebx+1] ; right border dst
423 ; prepare for cross border pData: top-right with xmm4
424; xor eax, eax
425 mov al, byte [ebx] ; top-right
426 butterfly_1to16_sse xmm4, xmm0, a ; pDst, tmp, pSrc [generic register name: a/b/c/d]
427 ; for left & right border expanding
428 exp_left_right_sse2 32, a
429
430 ; for cross border [top-left, top-right, bottom-left, bottom-right]
431 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
432 mov esi, [esp+24] ; pDst
433 mov ecx, [esp+28] ; kiStride
434 mov ebx, [esp+32] ; kiWidth
435 mov edx, [esp+36] ; kiHeight
436 ; have done xmm3,..,xmm6 cross pData initialization above, perform pading as below, To be continued..
437 mov eax, -32 ; luma=-32, chroma=-16
438 neg ecx ; -stride
439 lea edi, [esi+eax]
440 lea edi, [edi+ecx] ; last line of top-left border
441 lea ebp, [esi+ebx]
442 lea ebp, [ebp+ecx] ; last line of top-right border
443 add edx, 32 ; height+32(16), luma=32, chroma=16
444 mov ecx, [esp+28] ; kiStride
445 imul edx, ecx ; (height+32(16)) * stride
446 lea eax, [edi+edx] ; last line of bottom-left border
447 lea ebx, [ebp+edx] ; last line of bottom-right border
448 neg ecx ; -kiStride
449 ; for left & right border expanding
450 exp_cross_sse2 32, a
451
452; sfence ; commit cache write back memory
453
454 pop ebp
455 pop edi
456 pop esi
457 pop edx
458 pop ebx
459
460 ret
461
462ALIGN 16
463;***********************************************************************----------------
464; void ExpandPictureChromaAlign_sse2( uint8_t *pDst,
465; const int32_t kiStride,
466; const int32_t kiWidth,
467; const int32_t kiHeight );
468;***********************************************************************----------------
469ExpandPictureChromaAlign_sse2:
470 push ebx
471 push edx
472 push esi
473 push edi
474 push ebp
475
476 ; for both top and bottom border
477 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
478 mov esi, [esp+24] ; pDst
479 mov edx, [esp+28] ; kiStride
480 mov ebx, [esp+32] ; kiWidth
481 mov eax, [esp+36] ; kiHeight
482 ; also prepare for cross border pData top-left: xmm3
483; xor ecx, ecx
484 mov cl, byte [esi]
485 butterfly_1to16_sse xmm3, xmm4, c ; pDst, tmp, pSrc [generic register name: a/b/c/d]
486 ; load top border
487 mov ecx, edx ; kiStride
488 neg ecx ; -kiStride
489 lea edi, [esi+ecx] ; last line of top border
490 ; load bottom border
491 dec eax ; h-1
492 imul eax, edx ; (h-1)*kiStride
493 lea eax, [esi+eax] ; last line of picture pData
494 sal edx, 04h ; 16*kiStride
495 lea ebp, [eax+edx] ; last line of bottom border, (h-1)*kiStride + 16 * kiStride
496 ; also prepare for cross border pData: bottom-left with xmm5, bottom-right xmm6
497 dec ebx ; kiWidth-1
498 lea ebx, [eax+ebx] ; pDst[w-1][h-1]
499; xor edx, edx
500 mov dl, byte [eax] ; bottom-left
501 butterfly_1to16_sse xmm5, xmm6, d ; dst, tmp, pSrc [generic register name: a/b/c/d]
502 mov dl, byte [ebx] ; bottom-right
503 butterfly_1to16_sse xmm6, xmm4, d ; dst, tmp, pSrc [generic register name: a/b/c/d]
504 ; for top & bottom expanding
505 mov ebx, [esp+32] ; kiWidth
506 exp_top_bottom_sse2 16
507
508 ; for both left and right border
509 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
510 mov esi, [esp+24] ; pDst: left border pSrc
511 mov edx, [esp+28] ; kiStride
512 mov ebx, [esp+32] ; kiWidth
513 mov ecx, [esp+36] ; kiHeight
514 ; load left border
515 mov eax, -16 ; luma=-32, chroma=-16
516 lea edi, [esi+eax] ; left border dst
517 dec ebx
518 lea ebx, [esi+ebx] ; right border pSrc, (p_dst + width - 1)
519 lea ebp, [ebx+1] ; right border dst
520 ; prepare for cross border pData: top-right with xmm4
521; xor eax, eax
522 mov al, byte [ebx] ; top-right
523 butterfly_1to16_sse xmm4, xmm0, a ; pDst, tmp, pSrc [generic register name: a/b/c/d]
524 ; for left & right border expanding
525 exp_left_right_sse2 16, a
526
527 ; for cross border [top-left, top-right, bottom-left, bottom-right]
528 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
529 mov esi, [esp+24] ; pDst
530 mov ecx, [esp+28] ; kiStride
531 mov ebx, [esp+32] ; kiWidth
532 mov edx, [esp+36] ; kiHeight
533 ; have done xmm3,..,xmm6 cross pData initialization above, perform pading as below, To be continued..
534 mov eax, -16 ; chroma=-16
535 neg ecx ; -stride
536 lea edi, [esi+eax]
537 lea edi, [edi+ecx] ; last line of top-left border
538 lea ebp, [esi+ebx]
539 lea ebp, [ebp+ecx] ; last line of top-right border
540 mov ecx, [esp+28] ; kiStride
541 add edx, 16 ; height+16, luma=32, chroma=16
542 imul edx, ecx ; (kiHeight+16) * kiStride
543 lea eax, [edi+edx] ; last line of bottom-left border
544 lea ebx, [ebp+edx] ; last line of bottom-right border
545 neg ecx ; -kiStride
546 ; for left & right border expanding
547 exp_cross_sse2 16, a
548
549; sfence ; commit cache write back memory
550
551 pop ebp
552 pop edi
553 pop esi
554 pop edx
555 pop ebx
556
557 ret
558
559ALIGN 16
560;***********************************************************************----------------
561; void ExpandPictureChromaUnalign_sse2( uint8_t *pDst,
562; const int32_t kiStride,
563; const int32_t kiWidth,
564; const int32_t kiHeight );
565;***********************************************************************----------------
566ExpandPictureChromaUnalign_sse2:
567 push ebx
568 push edx
569 push esi
570 push edi
571 push ebp
572
573 ; for both top and bottom border
574 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
575 mov esi, [esp+24] ; pDst
576 mov edx, [esp+28] ; kiStride
577 mov ebx, [esp+32] ; kiWidth
578 mov eax, [esp+36] ; kiHeight
579 ; also prepare for cross border pData top-left: xmm3
580; xor ecx, ecx
581 mov cl, byte [esi]
582 butterfly_1to16_sse xmm3, xmm4, c ; pDst, tmp, pSrc [generic register name: a/b/c/d]
583 ; load top border
584 mov ecx, edx ; kiStride
585 neg ecx ; -kiStride
586 lea edi, [esi+ecx] ; last line of top border
587 ; load bottom border
588 dec eax ; h-1
589 imul eax, edx ; (h-1)*kiStride
590 lea eax, [esi+eax] ; last line of picture pData
591 sal edx, 04h ; 16*kiStride
592 lea ebp, [eax+edx] ; last line of bottom border, (h-1)*kiStride + 16 * kiStride
593 ; also prepare for cross border pData: bottom-left with xmm5, bottom-right xmm6
594 dec ebx ; kiWidth-1
595 lea ebx, [eax+ebx] ; dst[w-1][h-1]
596; xor edx, edx
597 mov dl, byte [eax] ; bottom-left
598 butterfly_1to16_sse xmm5, xmm6, d ; dst, tmp, pSrc [generic register name: a/b/c/d]
599 mov dl, byte [ebx] ; bottom-right
600 butterfly_1to16_sse xmm6, xmm4, d ; dst, tmp, pSrc [generic register name: a/b/c/d]
601 ; for top & bottom expanding
602 mov ebx, [esp+32] ; kiWidth
603 exp_top_bottom_sse2 16
604
605 ; for both left and right border
606 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
607 mov esi, [esp+24] ; p_dst: left border pSrc
608 mov edx, [esp+28] ; kiStride
609 mov ebx, [esp+32] ; kiWidth
610 mov ecx, [esp+36] ; kiHeight
611 ; load left border
612 mov eax, -16 ; luma=-32, chroma=-16
613 lea edi, [esi+eax] ; left border dst
614 dec ebx
615 lea ebx, [esi+ebx] ; right border pSrc, (p_dst + width - 1)
616 lea ebp, [ebx+1] ; right border dst
617 ; prepare for cross border pData: top-right with xmm4
618; xor eax, eax
619 mov al, byte [ebx] ; top-right
620 butterfly_1to16_sse xmm4, xmm0, a ; dst, tmp, pSrc [generic register name: a/b/c/d]
621 ; for left & right border expanding
622 exp_left_right_sse2 16, u
623
624 ; for cross border [top-left, top-right, bottom-left, bottom-right]
625 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
626 mov esi, [esp+24] ; p_dst
627 mov ecx, [esp+28] ; kiStride
628 mov ebx, [esp+32] ; kiWidth
629 mov edx, [esp+36] ; kiHeight
630 ; have done xmm3,..,xmm6 cross pData initialization above, perform pading as below, To be continued..
631 neg ecx ; -kiStride
632 mov eax, -16 ; chroma=-16
633 lea edi, [esi+eax]
634 lea edi, [edi+ecx] ; last line of top-left border
635 lea ebp, [esi+ebx]
636 lea ebp, [ebp+ecx] ; last line of top-right border
637 mov ecx, [esp+28] ; kiStride
638 add edx, 16 ; kiHeight+16, luma=32, chroma=16
639 imul edx, ecx ; (kiHeight+16) * kiStride
640 lea eax, [edi+edx] ; last line of bottom-left border
641 lea ebx, [ebp+edx] ; last line of bottom-right border
642 neg ecx ; -kiStride
643 ; for left & right border expanding
644 exp_cross_sse2 16, u
645
646; sfence ; commit cache write back memory
647
648 pop ebp
649 pop edi
650 pop esi
651 pop edx
652 pop ebx
653
654 ret
655
codec/decoder/core/asm/intra_pred.asm+1498−0
@@ -0,0 +1,1498 @@
1;*!
2;* \copy
3;* Copyright (c) 2009-2013, Cisco Systems
4;* All rights reserved.
5;*
6;* Redistribution and use in source and binary forms, with or without
7;* modification, are permitted provided that the following conditions
8;* are met:
9;*
10;* * Redistributions of source code must retain the above copyright
11;* notice, this list of conditions and the following disclaimer.
12;*
13;* * Redistributions in binary form must reproduce the above copyright
14;* notice, this list of conditions and the following disclaimer in
15;* the documentation and/or other materials provided with the
16;* distribution.
17;*
18;* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19;* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20;* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21;* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22;* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23;* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24;* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25;* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26;* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27;* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28;* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29;* POSSIBILITY OF SUCH DAMAGE.
30;*
31;*
32;* intra_pred.asm
33;*
34;* Abstract
35;* sse2 and mmx function for intra predict operations(decoder)
36;*
37;* History
38;* 18/09/2009 Created
39;* 19/11/2010 Added
40;* WelsI16x16LumaPredDcTop_sse2, WelsI16x16LumaPredDcNA_sse2,
41;* WelsIChromaPredDcLeft_mmx, WelsIChromaPredDcTop_sse2
42;* and WelsIChromaPredDcNA_mmx
43;*
44;*
45;*************************************************************************/
46
47%include "asm_inc.asm"
48BITS 32
49;*******************************************************************************
50; Local Data (Read Only)
51;*******************************************************************************
52
53%ifdef FORMAT_COFF
54SECTION .rodata data
55%else
56SECTION .rodata align=16
57%endif
58%if 1
59 %define WELSEMMS emms
60%else
61 %define WELSEMMS
62%endif
63
64align 16
65sse2_plane_inc_minus dw -7, -6, -5, -4, -3, -2, -1, 0
66align 16
67sse2_plane_inc dw 1, 2, 3, 4, 5, 6, 7, 8
68align 16
69sse2_plane_dec dw 8, 7, 6, 5, 4, 3, 2, 1
70
71; for chroma plane mode
72sse2_plane_inc_c dw 1, 2, 3, 4
73sse2_plane_dec_c dw 4, 3, 2, 1
74align 16
75sse2_plane_mul_b_c dw -3, -2, -1, 0, 1, 2, 3, 4
76
77align 16
78mmx_01bytes: times 16 db 1
79
80align 16
81mmx_0x02: dw 0x02, 0x00, 0x00, 0x00
82
83align 16
84sse2_dc_0x80: times 16 db 0x80
85align 16
86sse2_wd_0x02: times 8 dw 0x02
87
88;*******************************************************************************
89; macros
90;*******************************************************************************
91;xmm0, xmm1, xmm2, eax, ecx
92;lower 64 bits of xmm0 save the result
93%macro SSE2_PRED_H_4X4_TWO_LINE 5
94 movd %1, [%4-1]
95 movdqa %3, %1
96 punpcklbw %1, %3
97 movdqa %3, %1
98 punpcklbw %1, %3
99
100 ;add %4, %5
101 movd %2, [%4+%5-1]
102 movdqa %3, %2
103 punpcklbw %2, %3
104 movdqa %3, %2
105 punpcklbw %2, %3
106 punpckldq %1, %2
107%endmacro
108
109
110%macro LOAD_COLUMN 6
111 movd %1, [%5]
112 movd %2, [%5+%6]
113 punpcklbw %1, %2
114 lea %5, [%5+2*%6]
115 movd %3, [%5]
116 movd %2, [%5+%6]
117 punpcklbw %3, %2
118 punpcklwd %1, %3
119 lea %5, [%5+2*%6]
120 movd %4, [%5]
121 movd %2, [%5+%6]
122 punpcklbw %4, %2
123 lea %5, [%5+2*%6]
124 movd %3, [%5]
125 movd %2, [%5+%6]
126 lea %5, [%5+2*%6]
127 punpcklbw %3, %2
128 punpcklwd %4, %3
129 punpckhdq %1, %4
130%endmacro
131
132%macro SUMW_HORIZON 3
133 movhlps %2, %1 ; x2 = xx xx xx xx d7 d6 d5 d4
134 paddw %1, %2 ; x1 = xx xx xx xx d37 d26 d15 d04
135 punpcklwd %1, %3 ; x1 = d37 d26 d15 d04
136 movhlps %2, %1 ; x2 = xxxx xxxx d37 d26
137 paddd %1, %2 ; x1 = xxxx xxxx d1357 d0246
138 pshuflw %2, %1, 0x4e ; x2 = xxxx xxxx d0246 d1357
139 paddd %1, %2 ; x1 = xxxx xxxx xxxx d01234567
140%endmacro
141
142%macro COPY_16_TIMES 2
143 movdqa %2, [%1-16]
144 psrldq %2, 15
145 pmuludq %2, [mmx_01bytes]
146 pshufd %2, %2, 0
147%endmacro
148
149%macro COPY_16_TIMESS 3
150 movdqa %2, [%1+%3-16]
151 psrldq %2, 15
152 pmuludq %2, [mmx_01bytes]
153 pshufd %2, %2, 0
154%endmacro
155
156%macro LOAD_COLUMN_C 6
157 movd %1, [%5]
158 movd %2, [%5+%6]
159 punpcklbw %1,%2
160 lea %5, [%5+2*%6]
161 movd %3, [%5]
162 movd %2, [%5+%6]
163 punpcklbw %3, %2
164 punpckhwd %1, %3
165 lea %5, [%5+2*%6]
166%endmacro
167
168%macro LOAD_2_LEFT_AND_ADD 0
169 lea eax, [eax+2*ecx]
170 movzx edx, byte [eax-0x01]
171 add ebx, edx
172 movzx edx, byte [eax+ecx-0x01]
173 add ebx, edx
174%endmacro
175
176;*******************************************************************************
177; Code
178;*******************************************************************************
179
180SECTION .text
181WELS_EXTERN WelsI4x4LumaPredH_sse2
182WELS_EXTERN WelsI4x4LumaPredDDR_mmx
183WELS_EXTERN WelsI16x16LumaPredPlane_sse2
184WELS_EXTERN WelsI4x4LumaPredDc_sse2
185
186ALIGN 16
187;*******************************************************************************
188; void_t __cdecl WelsI4x4LumaPredH_sse2(uint8_t *pPred, const int32_t kiStride)
189;
190; pPred must align to 16
191;*******************************************************************************
192WelsI4x4LumaPredH_sse2:
193 mov eax, [esp+4] ;pPred
194 mov ecx, [esp+8] ;kiStride
195
196 movzx edx, byte [eax-1]
197 movd xmm0, edx
198 pmuludq xmm0, [mmx_01bytes]
199
200 movzx edx, byte [eax+ecx-1]
201 movd xmm1, edx
202 pmuludq xmm1, [mmx_01bytes]
203
204 lea eax, [eax+ecx]
205 movzx edx, byte [eax+ecx-1]
206 movd xmm2, edx
207 pmuludq xmm2, [mmx_01bytes]
208
209 movzx edx, byte [eax+2*ecx-1]
210 movd xmm3, edx
211 pmuludq xmm3, [mmx_01bytes]
212
213 sub eax, ecx
214 movd [eax], xmm0
215 movd [eax+ecx], xmm1
216 lea eax, [eax+2*ecx]
217 movd [eax], xmm2
218 movd [eax+ecx], xmm3
219
220 ret
221
222;*******************************************************************************
223; void_t WelsI16x16LumaPredPlane_sse2(uint8_t *pPred, const int32_t kiStride);
224;*******************************************************************************
225WelsI16x16LumaPredPlane_sse2:
226%define pushsize 4
227 push esi
228 mov esi, [esp + pushsize + 4]
229 mov ecx, [esp + pushsize + 8]
230 sub esi, 1
231 sub esi, ecx
232
233 ;for H
234 pxor xmm7, xmm7
235 movq xmm0, [esi]
236 movdqa xmm5, [sse2_plane_dec]
237 punpcklbw xmm0, xmm7
238 pmullw xmm0, xmm5
239 movq xmm1, [esi + 9]
240 movdqa xmm6, [sse2_plane_inc]
241 punpcklbw xmm1, xmm7
242 pmullw xmm1, xmm6
243 psubw xmm1, xmm0
244
245 SUMW_HORIZON xmm1,xmm0,xmm2
246 movd eax, xmm1 ; H += (i + 1) * (top[8 + i] - top[6 - i]);
247 movsx eax, ax
248 imul eax, 5
249 add eax, 32
250 sar eax, 6 ; b = (5 * H + 32) >> 6;
251 SSE2_Copy8Times xmm1, eax ; xmm1 = b,b,b,b,b,b,b,b
252
253 movzx edx, BYTE [esi+16]
254 sub esi, 3
255 LOAD_COLUMN xmm0, xmm2, xmm3, xmm4, esi, ecx
256
257 add esi, 3
258 movzx eax, BYTE [esi+8*ecx]
259 add edx, eax
260 shl edx, 4 ; a = (left[15*kiStride] + top[15]) << 4;
261
262 sub esi, 3
263 add esi, ecx
264 LOAD_COLUMN xmm7, xmm2, xmm3, xmm4, esi, ecx
265 pxor xmm4, xmm4
266 punpckhbw xmm0, xmm4
267 pmullw xmm0, xmm5
268 punpckhbw xmm7, xmm4
269 pmullw xmm7, xmm6
270 psubw xmm7, xmm0
271
272 SUMW_HORIZON xmm7,xmm0,xmm2
273 movd eax, xmm7 ; V
274 movsx eax, ax
275
276 imul eax, 5
277 add eax, 32
278 sar eax, 6 ; c = (5 * V + 32) >> 6;
279 SSE2_Copy8Times xmm4, eax ; xmm4 = c,c,c,c,c,c,c,c
280
281 mov esi, [esp + pushsize + 4]
282 add edx, 16
283 imul eax, -7
284 add edx, eax ; s = a + 16 + (-7)*c
285 SSE2_Copy8Times xmm0, edx ; xmm0 = s,s,s,s,s,s,s,s
286
287 xor eax, eax
288 movdqa xmm5, [sse2_plane_inc_minus]
289
290get_i16x16_luma_pred_plane_sse2_1:
291 movdqa xmm2, xmm1
292 pmullw xmm2, xmm5
293 paddw xmm2, xmm0
294 psraw xmm2, 5
295 movdqa xmm3, xmm1
296 pmullw xmm3, xmm6
297 paddw xmm3, xmm0
298 psraw xmm3, 5
299 packuswb xmm2, xmm3
300 movdqa [esi], xmm2
301 paddw xmm0, xmm4
302 add esi, ecx
303 inc eax
304 cmp eax, 16
305 jnz get_i16x16_luma_pred_plane_sse2_1
306
307 pop esi
308 ret
309
310
311
312;*******************************************************************************
313; void_t WelsI16x16LumaPredH_sse2(uint8_t *pPred, const int32_t kiStride);
314;*******************************************************************************
315
316%macro SSE2_PRED_H_16X16_TWO_LINE_DEC 0
317 lea eax, [eax+ecx*2]
318
319 COPY_16_TIMES eax, xmm0
320 movdqa [eax], xmm0
321 COPY_16_TIMESS eax, xmm0, ecx
322 movdqa [eax+ecx], xmm0
323%endmacro
324
325WELS_EXTERN WelsI16x16LumaPredH_sse2
326WelsI16x16LumaPredH_sse2:
327 mov eax, [esp+4] ; pPred
328 mov ecx, [esp+8] ; kiStride
329
330 COPY_16_TIMES eax, xmm0
331 movdqa [eax], xmm0
332 COPY_16_TIMESS eax, xmm0, ecx
333 movdqa [eax+ecx], xmm0
334
335 SSE2_PRED_H_16X16_TWO_LINE_DEC
336 SSE2_PRED_H_16X16_TWO_LINE_DEC
337 SSE2_PRED_H_16X16_TWO_LINE_DEC
338 SSE2_PRED_H_16X16_TWO_LINE_DEC
339 SSE2_PRED_H_16X16_TWO_LINE_DEC
340 SSE2_PRED_H_16X16_TWO_LINE_DEC
341 SSE2_PRED_H_16X16_TWO_LINE_DEC
342
343 ret
344
345;*******************************************************************************
346; void_t WelsI16x16LumaPredV_sse2(uint8_t *pPred, const int32_t kiStride);
347;*******************************************************************************
348WELS_EXTERN WelsI16x16LumaPredV_sse2
349WelsI16x16LumaPredV_sse2:
350 mov edx, [esp+4] ; pPred
351 mov ecx, [esp+8] ; kiStride
352
353 sub edx, ecx
354 movdqa xmm0, [edx]
355
356 movdqa [edx+ecx], xmm0
357 lea edx, [edx+2*ecx]
358 movdqa [edx], xmm0
359 movdqa [edx+ecx], xmm0
360 lea edx, [edx+2*ecx]
361 movdqa [edx], xmm0
362 movdqa [edx+ecx], xmm0
363 lea edx, [edx+2*ecx]
364 movdqa [edx], xmm0
365 movdqa [edx+ecx], xmm0
366 lea edx, [edx+2*ecx]
367 movdqa [edx], xmm0
368 movdqa [edx+ecx], xmm0
369 lea edx, [edx+2*ecx]
370 movdqa [edx], xmm0
371 movdqa [edx+ecx], xmm0
372 lea edx, [edx+2*ecx]
373 movdqa [edx], xmm0
374 movdqa [edx+ecx], xmm0
375 lea edx, [edx+2*ecx]
376 movdqa [edx], xmm0
377 movdqa [edx+ecx], xmm0
378 lea edx, [edx+2*ecx]
379 movdqa [edx], xmm0
380
381 ret
382
383;*******************************************************************************
384; void_t WelsIChromaPredPlane_sse2(uint8_t *pPred, const int32_t kiStride);
385;*******************************************************************************
386WELS_EXTERN WelsIChromaPredPlane_sse2
387WelsIChromaPredPlane_sse2:
388%define pushsize 4
389 push esi
390 mov esi, [esp + pushsize + 4] ;pPred
391 mov ecx, [esp + pushsize + 8] ;kiStride
392 sub esi, 1
393 sub esi, ecx
394
395 pxor mm7, mm7
396 movq mm0, [esi]
397 movq mm5, [sse2_plane_dec_c]
398 punpcklbw mm0, mm7
399 pmullw mm0, mm5
400 movq mm1, [esi + 5]
401 movq mm6, [sse2_plane_inc_c]
402 punpcklbw mm1, mm7
403 pmullw mm1, mm6
404 psubw mm1, mm0
405
406 movq2dq xmm1, mm1
407 pxor xmm2, xmm2
408 SUMW_HORIZON xmm1,xmm0,xmm2
409 movd eax, xmm1
410 movsx eax, ax
411 imul eax, 17
412 add eax, 16
413 sar eax, 5 ; b = (17 * H + 16) >> 5;
414 SSE2_Copy8Times xmm1, eax ; mm1 = b,b,b,b,b,b,b,b
415
416 movzx edx, BYTE [esi+8]
417 sub esi, 3
418 LOAD_COLUMN_C mm0, mm2, mm3, mm4, esi, ecx
419
420 add esi, 3
421 movzx eax, BYTE [esi+4*ecx]
422 add edx, eax
423 shl edx, 4 ; a = (left[7*kiStride] + top[7]) << 4;
424
425 sub esi, 3
426 add esi, ecx
427 LOAD_COLUMN_C mm7, mm2, mm3, mm4, esi, ecx
428 pxor mm4, mm4
429 punpckhbw mm0, mm4
430 pmullw mm0, mm5
431 punpckhbw mm7, mm4
432 pmullw mm7, mm6
433 psubw mm7, mm0
434
435 movq2dq xmm7, mm7
436 pxor xmm2, xmm2
437 SUMW_HORIZON xmm7,xmm0,xmm2
438 movd eax, xmm7 ; V
439 movsx eax, ax
440
441 imul eax, 17
442 add eax, 16
443 sar eax, 5 ; c = (17 * V + 16) >> 5;
444 SSE2_Copy8Times xmm4, eax ; mm4 = c,c,c,c,c,c,c,c
445
446 mov esi, [esp + pushsize + 4]
447 add edx, 16
448 imul eax, -3
449 add edx, eax ; s = a + 16 + (-3)*c
450 SSE2_Copy8Times xmm0, edx ; xmm0 = s,s,s,s,s,s,s,s
451
452 xor eax, eax
453 movdqa xmm5, [sse2_plane_mul_b_c]
454
455get_i_chroma_pred_plane_sse2_1:
456 movdqa xmm2, xmm1
457 pmullw xmm2, xmm5
458 paddw xmm2, xmm0
459 psraw xmm2, 5
460 packuswb xmm2, xmm2
461 movq [esi], xmm2
462 paddw xmm0, xmm4
463 add esi, ecx
464 inc eax
465 cmp eax, 8
466 jnz get_i_chroma_pred_plane_sse2_1
467
468 pop esi
469 WELSEMMS
470 ret
471
472ALIGN 16
473;*******************************************************************************
474; 0 |1 |2 |3 |4 |
475; 6 |7 |8 |9 |10|
476; 11|12|13|14|15|
477; 16|17|18|19|20|
478; 21|22|23|24|25|
479; 7 is the start pixel of current 4x4 block
480; pPred[7] = ([6]+[0]*2+[1]+2)/4
481;
482; void_t __cdecl WelsI4x4LumaPredDDR_mmx(uint8_t *pPred, const int32_t kiStride)
483;
484;*******************************************************************************
485WelsI4x4LumaPredDDR_mmx:
486 mov edx,[esp+4] ;pPred
487 mov eax,edx
488 mov ecx,[esp+8] ;kiStride
489
490 movq mm1,[eax+ecx-8] ;get value of 11,decreasing 8 is trying to improve the performance of movq mm1[8] = 11
491 movq mm2,[eax-8] ;get value of 6 mm2[8] = 6
492 sub eax, ecx ;mov eax to above line of current block(postion of 1)
493 punpckhbw mm2,[eax-8] ;mm2[8](high 8th byte of mm2) = [0](value of 0), mm2[7]= [6]
494 movd mm3,[eax] ;get value 1, mm3[1] = [1],mm3[2]=[2],mm3[3]=[3]
495 punpckhwd mm1,mm2 ;mm1[8]=[0],mm1[7]=[6],mm1[6]=[11]
496 psllq mm3,18h ;mm3[5]=[1]
497 psrlq mm1,28h ;mm1[3]=[0],mm1[2]=[6],mm1[1]=[11]
498 por mm3,mm1 ;mm3[6]=[3],mm3[5]=[2],mm3[4]=[1],mm3[3]=[0],mm3[2]=[6],mm3[1]=[11]
499 movq mm1,mm3 ;mm1[6]=[3],mm1[5]=[2],mm1[4]=[1],mm1[3]=[0],mm1[2]=[6],mm1[1]=[11]
500 lea eax,[eax+ecx*2-8h] ;set eax point to 12
501 movq mm4,[eax+ecx] ;get value of 16, mm4[8]=[16]
502 psllq mm3,8 ;mm3[7]=[3],mm3[6]=[2],mm3[5]=[1],mm3[4]=[0],mm3[3]=[6],mm3[2]=[11],mm3[1]=0
503 psrlq mm4,38h ;mm4[1]=[16]
504 por mm3,mm4 ;mm3[7]=[3],mm3[6]=[2],mm3[5]=[1],mm3[4]=[0],mm3[3]=[6],mm3[2]=[11],mm3[1]=[16]
505 movq mm2,mm3 ;mm2[7]=[3],mm2[6]=[2],mm2[5]=[1],mm2[4]=[0],mm2[3]=[6],mm2[2]=[11],mm2[1]=[16]
506 movq mm4,[eax+ecx*2] ;mm4[8]=[21]
507 psllq mm3,8 ;mm3[8]=[3],mm3[7]=[2],mm3[6]=[1],mm3[5]=[0],mm3[4]=[6],mm3[3]=[11],mm3[2]=[16],mm3[1]=0
508 psrlq mm4,38h ;mm4[1]=[21]
509 por mm3,mm4 ;mm3[8]=[3],mm3[7]=[2],mm3[6]=[1],mm3[5]=[0],mm3[4]=[6],mm3[3]=[11],mm3[2]=[16],mm3[1]=[21]
510 movq mm4,mm3 ;mm4[8]=[3],mm4[7]=[2],mm4[6]=[1],mm4[5]=[0],mm4[4]=[6],mm4[3]=[11],mm4[2]=[16],mm4[1]=[21]
511 pavgb mm3,mm1 ;mm3=([11]+[21]+1)/2
512 pxor mm1,mm4 ;find odd value in the lowest bit of each byte
513 pand mm1,[mmx_01bytes] ;set the odd bit
514 psubusb mm3,mm1 ;decrease 1 from odd bytes
515 pavgb mm2,mm3 ;mm2=(([11]+[21]+1)/2+1+[16])/2
516
517 lea edx,[edx+ecx]
518 movd [edx+2*ecx],mm2
519 sub edx,ecx
520 psrlq mm2,8
521 movd [edx+2*ecx],mm2
522 psrlq mm2,8
523 movd [edx+ecx],mm2
524 psrlq mm2,8
525 movd [edx],mm2
526 WELSEMMS
527 ret
528
529ALIGN 16
530;*******************************************************************************
531; 0 |1 |2 |3 |4 |
532; 5 |6 |7 |8 |9 |
533; 10|11|12|13|14|
534; 15|16|17|18|19|
535; 20|21|22|23|24|
536; 6 is the start pixel of current 4x4 block
537; pPred[6] = ([1]+[2]+[3]+[4]+[5]+[10]+[15]+[20]+4)/8
538;
539; void_t __cdecl WelsI4x4LumaPredDc_sse2(uint8_t *pPred, const int32_t kiStride)
540;
541;*******************************************************************************
542WelsI4x4LumaPredDc_sse2:
543 mov eax,[esp+4] ;pPred
544 mov ecx,[esp+8] ;kiStride
545 push ebx
546
547 movzx edx, byte [eax-1h]
548
549 sub eax, ecx
550 movd xmm0, [eax]
551 pxor xmm1, xmm1
552 psadbw xmm0, xmm1
553
554 movd ebx, xmm0
555 add ebx, edx
556
557 movzx edx, byte [eax+ecx*2-1h]
558 add ebx, edx
559
560 lea eax, [eax+ecx*2-1]
561 movzx edx, byte [eax+ecx]
562 add ebx, edx
563
564 movzx edx, byte [eax+ecx*2]
565 add ebx, edx
566 add ebx, 4
567 sar ebx, 3
568 imul ebx, 0x01010101
569
570 mov edx, [esp+8] ;pPred
571 mov [edx], ebx
572 mov [edx+ecx], ebx
573 mov [edx+2*ecx], ebx
574 lea edx, [edx+2*ecx]
575 mov [edx+ecx], ebx
576
577 pop ebx
578 ret
579
580ALIGN 16
581;*******************************************************************************
582; void_t __cdecl WelsIChromaPredH_mmx(uint8_t *pPred, const int32_t kiStride)
583; copy 8 pixel of 8 line from left
584;*******************************************************************************
585%macro MMX_PRED_H_8X8_ONE_LINE 4
586 movq %1, [%3-8]
587 psrlq %1, 38h
588
589 pmullw %1, [mmx_01bytes]
590 pshufw %1, %1, 0
591 movq [%4], %1
592%endmacro
593
594%macro MMX_PRED_H_8X8_ONE_LINEE 4
595 movq %1, [%3+ecx-8]
596 psrlq %1, 38h
597
598 pmullw %1, [mmx_01bytes]
599 pshufw %1, %1, 0
600 movq [%4], %1
601%endmacro
602
603WELS_EXTERN WelsIChromaPredH_mmx
604WelsIChromaPredH_mmx:
605 mov edx, [esp+4] ;pPred
606 mov eax, edx
607 mov ecx, [esp+8] ;kiStride
608
609 movq mm0, [eax-8]
610 psrlq mm0, 38h
611
612 pmullw mm0, [mmx_01bytes]
613 pshufw mm0, mm0, 0
614 movq [edx], mm0
615
616 MMX_PRED_H_8X8_ONE_LINEE mm0, mm1, eax, edx+ecx
617
618 lea eax, [eax+ecx*2]
619 MMX_PRED_H_8X8_ONE_LINE mm0, mm1, eax, edx+2*ecx
620
621 lea edx, [edx+2*ecx]
622 MMX_PRED_H_8X8_ONE_LINEE mm0, mm1, eax, edx+ecx
623
624 lea eax, [eax+ecx*2]
625 MMX_PRED_H_8X8_ONE_LINE mm0, mm1, eax, edx+2*ecx
626
627 lea edx, [edx+2*ecx]
628 MMX_PRED_H_8X8_ONE_LINEE mm0, mm1, eax, edx+ecx
629
630 lea eax, [eax+ecx*2]
631 MMX_PRED_H_8X8_ONE_LINE mm0, mm1, eax, edx+2*ecx
632
633 lea edx, [edx+2*ecx]
634 MMX_PRED_H_8X8_ONE_LINEE mm0, mm1, eax, edx+ecx
635
636 WELSEMMS
637 ret
638
639ALIGN 16
640;*******************************************************************************
641; void_t __cdecl get_i4x4_luma_pred_v_asm(uint8_t *pPred, const int32_t kiStride)
642; copy pixels from top 4 pixels
643;*******************************************************************************
644WELS_EXTERN get_i4x4_luma_pred_v_asm
645get_i4x4_luma_pred_v_asm:
646 mov eax, [esp+4] ;pPred
647 mov ecx, [esp+8] ;kiStride
648
649 sub eax, ecx
650 mov edx, [eax]
651 mov [eax+ecx], edx
652 mov [eax+2*ecx], edx
653 lea eax, [eax+2*ecx]
654 mov [eax+ecx], edx
655 mov [eax+2*ecx], edx
656
657 ret
658
659ALIGN 16
660;*******************************************************************************
661; void_t __cdecl WelsIChromaPredV_mmx(uint8_t *pPred, const int32_t kiStride)
662; copy 8 pixels from top 8 pixels
663;*******************************************************************************
664WELS_EXTERN WelsIChromaPredV_mmx
665WelsIChromaPredV_mmx:
666 mov eax, [esp+4] ;pPred
667 mov ecx, [esp+8] ;kiStride
668
669 sub eax, ecx
670 movq mm0, [eax]
671
672 movq [eax+ecx], mm0
673 movq [eax+2*ecx], mm0
674 lea eax, [eax+2*ecx]
675 movq [eax+ecx], mm0
676 movq [eax+2*ecx], mm0
677 lea eax, [eax+2*ecx]
678 movq [eax+ecx], mm0
679 movq [eax+2*ecx], mm0
680 lea eax, [eax+2*ecx]
681 movq [eax+ecx], mm0
682 movq [eax+2*ecx], mm0
683
684 WELSEMMS
685 ret
686
687
688 ALIGN 16
689;*******************************************************************************
690; lt|t0|t1|t2|t3|
691; l0|
692; l1|
693; l2|
694; l3|
695; t3 will never been used
696; destination:
697; |a |b |c |d |
698; |e |f |a |b |
699; |g |h |e |f |
700; |i |j |g |h |
701
702; a = (1 + lt + l0)>>1
703; e = (1 + l0 + l1)>>1
704; g = (1 + l1 + l2)>>1
705; i = (1 + l2 + l3)>>1
706
707; d = (2 + t0 + (t1<<1) + t2)>>2
708; c = (2 + lt + (t0<<1) + t1)>>2
709; b = (2 + l0 + (lt<<1) + t0)>>2
710
711; f = (2 + l1 + (l0<<1) + lt)>>2
712; h = (2 + l2 + (l1<<1) + l0)>>2
713; j = (2 + l3 + (l2<<1) + l1)>>2
714; [b a f e h g j i] + [d c b a] --> mov to memory
715;
716; void_t WelsI4x4LumaPredHD_mmx(uint8_t *pPred, const int32_t kiStride)
717;*******************************************************************************
718WELS_EXTERN WelsI4x4LumaPredHD_mmx
719WelsI4x4LumaPredHD_mmx:
720 mov edx, [esp+4] ; pPred
721 mov eax, edx
722 mov ecx, [esp+8] ; kiStride
723 sub eax, ecx
724 movd mm0, [eax-1] ; mm0 = [xx xx xx xx t2 t1 t0 lt]
725 psllq mm0, 20h ; mm0 = [t2 t1 t0 lt xx xx xx xx]
726
727 movd mm1, [eax+2*ecx-4]
728 punpcklbw mm1, [eax+ecx-4] ; mm1[7] = l0, mm1[6] = l1
729 lea eax, [eax+2*ecx]
730 movd mm2, [eax+2*ecx-4]
731 punpcklbw mm2, [eax+ecx-4] ; mm2[7] = l2, mm2[6] = l3
732 punpckhwd mm2, mm1 ; mm2 = [l0 l1 l2 l3 xx xx xx xx]
733 psrlq mm2, 20h
734 pxor mm0, mm2 ; mm0 = [t2 t1 t0 lt l0 l1 l2 l3]
735
736 movq mm1, mm0
737 psrlq mm1, 10h ; mm1 = [xx xx t2 t1 t0 lt l0 l1]
738 movq mm2, mm0
739 psrlq mm2, 8h ; mm2 = [xx t2 t1 t0 lt l0 l1 l2]
740 movq mm3, mm2
741 movq mm4, mm1
742 pavgb mm1, mm0
743
744 pxor mm4, mm0 ; find odd value in the lowest bit of each byte
745 pand mm4, [mmx_01bytes] ; set the odd bit
746 psubusb mm1, mm4 ; decrease 1 from odd bytes
747
748 pavgb mm2, mm1 ; mm2 = [xx xx d c b f h j]
749
750 movq mm4, mm0
751 pavgb mm3, mm4 ; mm3 = [xx xx xx xx a e g i]
752 punpcklbw mm3, mm2 ; mm3 = [b a f e h g j i]
753
754 psrlq mm2, 20h
755 psllq mm2, 30h ; mm2 = [d c 0 0 0 0 0 0]
756 movq mm4, mm3
757 psrlq mm4, 10h ; mm4 = [0 0 b a f e h j]
758 pxor mm2, mm4 ; mm2 = [d c b a xx xx xx xx]
759 psrlq mm2, 20h ; mm2 = [xx xx xx xx d c b a]
760
761 movd [edx], mm2
762 lea edx, [edx+ecx]
763 movd [edx+2*ecx], mm3
764 sub edx, ecx
765 psrlq mm3, 10h
766 movd [edx+2*ecx], mm3
767 psrlq mm3, 10h
768 movd [edx+ecx], mm3
769 WELSEMMS
770 ret
771
772
773
774ALIGN 16
775;*******************************************************************************
776; lt|t0|t1|t2|t3|
777; l0|
778; l1|
779; l2|
780; l3|
781; t3 will never been used
782; destination:
783; |a |b |c |d |
784; |c |d |e |f |
785; |e |f |g |g |
786; |g |g |g |g |
787
788; a = (1 + l0 + l1)>>1
789; c = (1 + l1 + l2)>>1
790; e = (1 + l2 + l3)>>1
791; g = l3
792
793; b = (2 + l0 + (l1<<1) + l2)>>2
794; d = (2 + l1 + (l2<<1) + l3)>>2
795; f = (2 + l2 + (l3<<1) + l3)>>2
796
797; [g g f e d c b a] + [g g g g] --> mov to memory
798;
799; void_t WelsI4x4LumaPredHU_mmx(uint8_t *pPred, const int32_t kiStride)
800;*******************************************************************************
801WELS_EXTERN WelsI4x4LumaPredHU_mmx
802WelsI4x4LumaPredHU_mmx:
803 mov edx, [esp+4] ; pPred
804 mov eax, edx
805 mov ecx, [esp+8] ; kiStride
806
807 movd mm0, [eax-4] ; mm0[3] = l0
808 punpcklbw mm0, [eax+ecx-4] ; mm0[7] = l1, mm0[6] = l0
809 lea eax, [eax+2*ecx]
810 movd mm2, [eax-4] ; mm2[3] = l2
811 movd mm4, [eax+ecx-4] ; mm4[3] = l3
812 punpcklbw mm2, mm4
813 punpckhwd mm0, mm2 ; mm0 = [l3 l2 l1 l0 xx xx xx xx]
814
815 psrlq mm4, 18h
816 psllq mm4, 38h ; mm4 = [l3 xx xx xx xx xx xx xx]
817 psrlq mm0, 8h
818 pxor mm0, mm4 ; mm0 = [l3 l3 l2 l1 l0 xx xx xx]
819
820 movq mm1, mm0
821 psllq mm1, 8h ; mm1 = [l3 l2 l1 l0 xx xx xx xx]
822 movq mm3, mm1 ; mm3 = [l3 l2 l1 l0 xx xx xx xx]
823 pavgb mm1, mm0 ; mm1 = [g e c a xx xx xx xx]
824
825 movq mm2, mm0
826 psllq mm2, 10h ; mm2 = [l2 l1 l0 xx xx xx xx xx]
827 movq mm5, mm2
828 pavgb mm2, mm0
829
830 pxor mm5, mm0 ; find odd value in the lowest bit of each byte
831 pand mm5, [mmx_01bytes] ; set the odd bit
832 psubusb mm2, mm5 ; decrease 1 from odd bytes
833
834 pavgb mm2, mm3 ; mm2 = [f d b xx xx xx xx xx]
835
836 psrlq mm2, 8h
837 pxor mm2, mm4 ; mm2 = [g f d b xx xx xx xx]
838
839 punpckhbw mm1, mm2 ; mm1 = [g g f e d c b a]
840 punpckhbw mm4, mm4 ; mm4 = [g g xx xx xx xx xx xx]
841 punpckhbw mm4, mm4 ; mm4 = [g g g g xx xx xx xx]
842
843 psrlq mm4, 20h
844 lea edx, [edx+ecx]
845 movd [edx+2*ecx], mm4
846
847 sub edx, ecx
848 movd [edx], mm1
849 psrlq mm1, 10h
850 movd [edx+ecx], mm1
851 psrlq mm1, 10h
852 movd [edx+2*ecx], mm1
853 WELSEMMS
854 ret
855
856
857
858ALIGN 16
859;*******************************************************************************
860; lt|t0|t1|t2|t3|
861; l0|
862; l1|
863; l2|
864; l3|
865; l3 will never been used
866; destination:
867; |a |b |c |d |
868; |e |f |g |h |
869; |i |a |b |c |
870; |j |e |f |g |
871
872; a = (1 + lt + t0)>>1
873; b = (1 + t0 + t1)>>1
874; c = (1 + t1 + t2)>>1
875; d = (1 + t2 + t3)>>1
876
877; e = (2 + l0 + (lt<<1) + t0)>>2
878; f = (2 + lt + (t0<<1) + t1)>>2
879; g = (2 + t0 + (t1<<1) + t2)>>2
880
881; h = (2 + t1 + (t2<<1) + t3)>>2
882; i = (2 + lt + (l0<<1) + l1)>>2
883; j = (2 + l0 + (l1<<1) + l2)>>2
884;
885; void_t WelsI4x4LumaPredVR_mmx(uint8_t *pPred, const int32_t kiStride)
886;*******************************************************************************
887WELS_EXTERN WelsI4x4LumaPredVR_mmx
888WelsI4x4LumaPredVR_mmx:
889 mov edx, [esp+4] ; pPred
890 mov eax, edx
891 mov ecx, [esp+8] ; kiStride
892 sub eax, ecx
893 movq mm0, [eax-1] ; mm0 = [xx xx xx t3 t2 t1 t0 lt]
894 psllq mm0, 18h ; mm0 = [t3 t2 t1 t0 lt xx xx xx]
895
896 movd mm1, [eax+2*ecx-4]
897 punpcklbw mm1, [eax+ecx-4] ; mm1[7] = l0, mm1[6] = l1
898 lea eax, [eax+2*ecx]
899 movq mm2, [eax+ecx-8] ; mm2[7] = l2
900 punpckhwd mm2, mm1 ; mm2 = [l0 l1 l2 xx xx xx xx xx]
901 psrlq mm2, 28h
902 pxor mm0, mm2 ; mm0 = [t3 t2 t1 t0 lt l0 l1 l2]
903
904 movq mm1, mm0
905 psllq mm1, 8h ; mm1 = [t2 t1 t0 lt l0 l1 l2 xx]
906 pavgb mm1, mm0 ; mm1 = [d c b a xx xx xx xx]
907
908 movq mm2, mm0
909 psllq mm2, 10h ; mm2 = [t1 t0 lt l0 l1 l2 xx xx]
910 movq mm3, mm2
911 pavgb mm2, mm0
912
913 pxor mm3, mm0 ; find odd value in the lowest bit of each byte
914 pand mm3, [mmx_01bytes] ; set the odd bit
915 psubusb mm2, mm3 ; decrease 1 from odd bytes
916
917 movq mm3, mm0
918 psllq mm3, 8h ; mm3 = [t2 t1 t0 lt l0 l1 l2 xx]
919 pavgb mm3, mm2 ; mm3 = [h g f e i j xx xx]
920 movq mm2, mm3
921
922 psrlq mm1, 20h ; mm1 = [xx xx xx xx d c b a]
923 movd [edx], mm1
924
925 psrlq mm2, 20h ; mm2 = [xx xx xx xx h g f e]
926 movd [edx+ecx], mm2
927
928 movq mm4, mm3
929 psllq mm4, 20h
930 psrlq mm4, 38h ; mm4 = [xx xx xx xx xx xx xx i]
931
932 movq mm5, mm3
933 psllq mm5, 28h
934 psrlq mm5, 38h ; mm5 = [xx xx xx xx xx xx xx j]
935
936 psllq mm1, 8h
937 pxor mm4, mm1 ; mm4 = [xx xx xx xx c b a i]
938 movd [edx+2*ecx], mm4
939
940 psllq mm2, 8h
941 pxor mm5, mm2 ; mm5 = [xx xx xx xx g f e j]
942 lea edx, [edx+2*ecx]
943 movd [edx+ecx], mm5
944 WELSEMMS
945 ret
946
947ALIGN 16
948;*******************************************************************************
949; lt|t0|t1|t2|t3|t4|t5|t6|t7
950; l0|
951; l1|
952; l2|
953; l3|
954; lt,t0,t1,t2,t3 will never been used
955; destination:
956; |a |b |c |d |
957; |b |c |d |e |
958; |c |d |e |f |
959; |d |e |f |g |
960
961; a = (2 + t0 + t2 + (t1<<1))>>2
962; b = (2 + t1 + t3 + (t2<<1))>>2
963; c = (2 + t2 + t4 + (t3<<1))>>2
964; d = (2 + t3 + t5 + (t4<<1))>>2
965
966; e = (2 + t4 + t6 + (t5<<1))>>2
967; f = (2 + t5 + t7 + (t6<<1))>>2
968; g = (2 + t6 + t7 + (t7<<1))>>2
969
970; [g f e d c b a] --> mov to memory
971;
972; void_t WelsI4x4LumaPredDDL_mmx(uint8_t *pPred, const int32_t kiStride)
973;*******************************************************************************
974WELS_EXTERN WelsI4x4LumaPredDDL_mmx
975WelsI4x4LumaPredDDL_mmx:
976 mov edx, [esp+4] ; pPred
977 mov eax, edx
978 mov ecx, [esp+8] ; kiStride
979 sub eax, ecx
980 movq mm0, [eax] ; mm0 = [t7 t6 t5 t4 t3 t2 t1 t0]
981 movq mm1, mm0
982 movq mm2, mm0
983
984 movq mm3, mm0
985 psrlq mm3, 38h
986 psllq mm3, 38h ; mm3 = [t7 xx xx xx xx xx xx xx]
987
988 psllq mm1, 8h ; mm1 = [t6 t5 t4 t3 t2 t1 t0 xx]
989 psrlq mm2, 8h
990 pxor mm2, mm3 ; mm2 = [t7 t7 t6 t5 t4 t3 t2 t1]
991
992 movq mm3, mm1
993 pavgb mm1, mm2
994 pxor mm3, mm2 ; find odd value in the lowest bit of each byte
995 pand mm3, [mmx_01bytes] ; set the odd bit
996 psubusb mm1, mm3 ; decrease 1 from odd bytes
997
998 pavgb mm0, mm1 ; mm0 = [g f e d c b a xx]
999
1000 psrlq mm0, 8h
1001 movd [edx], mm0
1002 psrlq mm0, 8h
1003 movd [edx+ecx], mm0
1004 psrlq mm0, 8h
1005 movd [edx+2*ecx], mm0
1006 psrlq mm0, 8h
1007 lea edx, [edx+2*ecx]
1008 movd [edx+ecx], mm0
1009 WELSEMMS
1010 ret
1011
1012
1013ALIGN 16
1014;*******************************************************************************
1015; lt|t0|t1|t2|t3|t4|t5|t6|t7
1016; l0|
1017; l1|
1018; l2|
1019; l3|
1020; lt,t0,t1,t2,t3 will never been used
1021; destination:
1022; |a |b |c |d |
1023; |e |f |g |h |
1024; |b |c |d |i |
1025; |f |g |h |j |
1026
1027; a = (1 + t0 + t1)>>1
1028; b = (1 + t1 + t2)>>1
1029; c = (1 + t2 + t3)>>1
1030; d = (1 + t3 + t4)>>1
1031; i = (1 + t4 + t5)>>1
1032
1033; e = (2 + t0 + (t1<<1) + t2)>>2
1034; f = (2 + t1 + (t2<<1) + t3)>>2
1035; g = (2 + t2 + (t3<<1) + t4)>>2
1036; h = (2 + t3 + (t4<<1) + t5)>>2
1037; j = (2 + t4 + (t5<<1) + t6)>>2
1038
1039; [i d c b a] + [j h g f e] --> mov to memory
1040;
1041; void_t WelsI4x4LumaPredVL_mmx(uint8_t *pPred, const int32_t kiStride)
1042;*******************************************************************************
1043WELS_EXTERN WelsI4x4LumaPredVL_mmx
1044WelsI4x4LumaPredVL_mmx:
1045 mov edx, [esp+4] ; pPred
1046 mov eax, edx
1047 mov ecx, [esp+8] ; kiStride
1048
1049 sub eax, ecx
1050 movq mm0, [eax] ; mm0 = [t7 t6 t5 t4 t3 t2 t1 t0]
1051 movq mm1, mm0
1052 movq mm2, mm0
1053
1054 psrlq mm1, 8h ; mm1 = [xx t7 t6 t5 t4 t3 t2 t1]
1055 psrlq mm2, 10h ; mm2 = [xx xx t7 t6 t5 t4 t3 t2]
1056
1057 movq mm3, mm1
1058 pavgb mm3, mm0 ; mm3 = [xx xx xx i d c b a]
1059
1060 movq mm4, mm2
1061 pavgb mm2, mm0
1062 pxor mm4, mm0 ; find odd value in the lowest bit of each byte
1063 pand mm4, [mmx_01bytes] ; set the odd bit
1064 psubusb mm2, mm4 ; decrease 1 from odd bytes
1065
1066 pavgb mm2, mm1 ; mm2 = [xx xx xx j h g f e]
1067
1068 movd [edx], mm3
1069 psrlq mm3, 8h
1070 movd [edx+2*ecx], mm3
1071
1072 movd [edx+ecx], mm2
1073 psrlq mm2, 8h
1074 lea edx, [edx+2*ecx]
1075 movd [edx+ecx], mm2
1076 WELSEMMS
1077 ret
1078
1079ALIGN 16
1080;*******************************************************************************
1081;
1082; void_t WelsIChromaPredDc_sse2(uint8_t *pPred, const int32_t kiStride)
1083;*******************************************************************************
1084WELS_EXTERN WelsIChromaPredDc_sse2
1085WelsIChromaPredDc_sse2:
1086 push ebx
1087 mov eax, [esp+8] ; pPred
1088 mov ecx, [esp+12] ; kiStride
1089
1090 sub eax, ecx
1091 movq mm0, [eax]
1092
1093 movzx ebx, byte [eax+ecx-0x01] ; l1
1094 lea eax, [eax+2*ecx]
1095 movzx edx, byte [eax-0x01] ; l2
1096 add ebx, edx
1097 movzx edx, byte [eax+ecx-0x01] ; l3
1098 add ebx, edx
1099 lea eax, [eax+2*ecx]
1100 movzx edx, byte [eax-0x01] ; l4
1101 add ebx, edx
1102 movd mm1, ebx ; mm1 = l1+l2+l3+l4
1103
1104 movzx ebx, byte [eax+ecx-0x01] ; l5
1105 lea eax, [eax+2*ecx]
1106 movzx edx, byte [eax-0x01] ; l6
1107 add ebx, edx
1108 movzx edx, byte [eax+ecx-0x01] ; l7
1109 add ebx, edx
1110 lea eax, [eax+2*ecx]
1111 movzx edx, byte [eax-0x01] ; l8
1112 add ebx, edx
1113 movd mm2, ebx ; mm2 = l5+l6+l7+l8
1114
1115 movq mm3, mm0
1116 psrlq mm0, 0x20
1117 psllq mm3, 0x20
1118 psrlq mm3, 0x20
1119 pxor mm4, mm4
1120 psadbw mm0, mm4
1121 psadbw mm3, mm4 ; sum1 = mm3+mm1, sum2 = mm0, sum3 = mm2
1122
1123 paddq mm3, mm1
1124 movq mm1, mm2
1125 paddq mm1, mm0; ; sum1 = mm3, sum2 = mm0, sum3 = mm2, sum4 = mm1
1126
1127 movq mm4, [mmx_0x02]
1128
1129 paddq mm0, mm4
1130 psrlq mm0, 0x02
1131
1132 paddq mm2, mm4
1133 psrlq mm2, 0x02
1134
1135 paddq mm3, mm4
1136 paddq mm3, mm4
1137 psrlq mm3, 0x03
1138
1139 paddq mm1, mm4
1140 paddq mm1, mm4
1141 psrlq mm1, 0x03
1142
1143 pmuludq mm0, [mmx_01bytes]
1144 pmuludq mm3, [mmx_01bytes]
1145 psllq mm0, 0x20
1146 pxor mm0, mm3 ; mm0 = m_up
1147
1148 pmuludq mm2, [mmx_01bytes]
1149 pmuludq mm1, [mmx_01bytes]
1150 psllq mm1, 0x20
1151 pxor mm1, mm2 ; mm2 = m_down
1152
1153 mov edx, [esp+8] ; pPred
1154
1155 movq [edx], mm0
1156 movq [edx+ecx], mm0
1157 movq [edx+2*ecx], mm0
1158 lea edx, [edx+2*ecx]
1159 movq [edx+ecx], mm0
1160
1161 movq [edx+2*ecx], mm1
1162 lea edx, [edx+2*ecx]
1163 movq [edx+ecx], mm1
1164 movq [edx+2*ecx], mm1
1165 lea edx, [edx+2*ecx]
1166 movq [edx+ecx], mm1
1167
1168 pop ebx
1169 WELSEMMS
1170 ret
1171
1172
1173
1174ALIGN 16
1175;*******************************************************************************
1176;
1177; void_t WelsI16x16LumaPredDc_sse2(uint8_t *pPred, const int32_t kiStride)
1178;*******************************************************************************
1179WELS_EXTERN WelsI16x16LumaPredDc_sse2
1180WelsI16x16LumaPredDc_sse2:
1181 push ebx
1182 mov eax, [esp+8] ; pPred
1183 mov ecx, [esp+12] ; kiStride
1184
1185 sub eax, ecx
1186 movdqa xmm0, [eax] ; read one row
1187 pxor xmm1, xmm1
1188 psadbw xmm0, xmm1
1189 movdqa xmm1, xmm0
1190 psrldq xmm1, 0x08
1191 pslldq xmm0, 0x08
1192 psrldq xmm0, 0x08
1193 paddw xmm0, xmm1
1194
1195 movzx ebx, byte [eax+ecx-0x01]
1196 movzx edx, byte [eax+2*ecx-0x01]
1197 add ebx, edx
1198 lea eax, [eax+ecx]
1199 LOAD_2_LEFT_AND_ADD
1200 LOAD_2_LEFT_AND_ADD
1201 LOAD_2_LEFT_AND_ADD
1202 LOAD_2_LEFT_AND_ADD
1203 LOAD_2_LEFT_AND_ADD
1204 LOAD_2_LEFT_AND_ADD
1205 LOAD_2_LEFT_AND_ADD
1206 add ebx, 0x10
1207 movd xmm1, ebx
1208 paddw xmm0, xmm1
1209 psrld xmm0, 0x05
1210 pmuludq xmm0, [mmx_01bytes]
1211 pshufd xmm0, xmm0, 0
1212
1213 mov edx, [esp+8] ; pPred
1214
1215 movdqa [edx], xmm0
1216 movdqa [edx+ecx], xmm0
1217 movdqa [edx+2*ecx], xmm0
1218 lea edx, [edx+2*ecx]
1219
1220 movdqa [edx+ecx], xmm0
1221 movdqa [edx+2*ecx], xmm0
1222 lea edx, [edx+2*ecx]
1223
1224 movdqa [edx+ecx], xmm0
1225 movdqa [edx+2*ecx], xmm0
1226 lea edx, [edx+2*ecx]
1227
1228 movdqa [edx+ecx], xmm0
1229 movdqa [edx+2*ecx], xmm0
1230 lea edx, [edx+2*ecx]
1231
1232 movdqa [edx+ecx], xmm0
1233 movdqa [edx+2*ecx], xmm0
1234 lea edx, [edx+2*ecx]
1235
1236 movdqa [edx+ecx], xmm0
1237 movdqa [edx+2*ecx], xmm0
1238 lea edx, [edx+2*ecx]
1239
1240 movdqa [edx+ecx], xmm0
1241 movdqa [edx+2*ecx], xmm0
1242 lea edx, [edx+2*ecx]
1243
1244 movdqa [edx+ecx], xmm0
1245
1246 pop ebx
1247
1248 ret
1249
1250;*******************************************************************************
1251; for intra prediction as follows, 11/19/2010
1252;*******************************************************************************
1253
1254ALIGN 16
1255;*******************************************************************************
1256; void_t WelsI16x16LumaPredDcTop_sse2(uint8_t *pPred, const int32_t kiStride)
1257;*******************************************************************************
1258WELS_EXTERN WelsI16x16LumaPredDcTop_sse2
1259WelsI16x16LumaPredDcTop_sse2:
1260 push ebx
1261
1262 %define PUSH_SIZE 4
1263
1264 mov eax, [esp+PUSH_SIZE+4] ; pPred
1265 mov ebx, [esp+PUSH_SIZE+8] ; kiStride
1266
1267 mov ecx, ebx
1268 neg ecx
1269 movdqa xmm0, [eax+ecx] ; pPred-kiStride, top line
1270 pxor xmm7, xmm7
1271 movdqa xmm1, xmm0
1272 punpcklbw xmm0, xmm7
1273 punpckhbw xmm1, xmm7
1274
1275 paddw xmm0, xmm1 ; (ub.max(ff) << 4) will not excceed of uw, so can perform it in unit of unsigned word scope
1276 pshufd xmm1, xmm0, 04eh ; 01001110, w3w2w1w0,w7w6w5w4
1277 paddw xmm0, xmm1 ; w3+7 w2+6 w1+5 w0+4 w3+7 w2+6 w1+5 w0+4
1278 pshufd xmm1, xmm0, 0b1h ; 10110001, w1+5 w0+4 w3+7 w2+6 w1+5 w0+4 w3+7 w2+6
1279 paddw xmm0, xmm1 ; w_o w_e w_o w_e w_o w_e w_o w_e (w_o=1+3+5+7, w_e=0+2+4+6)
1280 pshuflw xmm1, xmm0, 0b1h ; 10110001
1281 paddw xmm0, xmm1 ; sum in word unit (x8)
1282 movd edx, xmm0
1283 and edx, 0ffffh
1284
1285 add edx, 08h
1286 sar edx, 04h
1287 mov dh, dl
1288 mov ecx, edx
1289 shl ecx, 010h
1290 or edx, ecx
1291 movd xmm1, edx
1292 pshufd xmm0, xmm1, 00h
1293 movdqa xmm1, xmm0
1294
1295 lea ecx, [2*ebx+ebx] ; 3*kiStride
1296
1297 movdqa [eax], xmm0
1298 movdqa [eax+ebx], xmm1
1299 movdqa [eax+2*ebx], xmm0
1300 movdqa [eax+ecx], xmm1
1301
1302 lea eax, [eax+4*ebx]
1303 movdqa [eax], xmm0
1304 movdqa [eax+ebx], xmm1
1305 movdqa [eax+2*ebx], xmm0
1306 movdqa [eax+ecx], xmm1
1307
1308 lea eax, [eax+4*ebx]
1309 movdqa [eax], xmm0
1310 movdqa [eax+ebx], xmm1
1311 movdqa [eax+2*ebx], xmm0
1312 movdqa [eax+ecx], xmm1
1313
1314 lea eax, [eax+4*ebx]
1315 movdqa [eax], xmm0
1316 movdqa [eax+ebx], xmm1
1317 movdqa [eax+2*ebx], xmm0
1318 movdqa [eax+ecx], xmm1
1319
1320 %undef PUSH_SIZE
1321 pop ebx
1322 ret
1323
1324ALIGN 16
1325;*******************************************************************************
1326; void_t WelsI16x16LumaPredDcNA_sse2(uint8_t *pPred, const int32_t kiStride)
1327;*******************************************************************************
1328WELS_EXTERN WelsI16x16LumaPredDcNA_sse2
1329WelsI16x16LumaPredDcNA_sse2:
1330 push ebx
1331
1332 %define PUSH_SIZE 4
1333
1334 mov eax, [esp+PUSH_SIZE+4] ; pPred
1335 mov ebx, [esp+PUSH_SIZE+8] ; kiStride
1336
1337 lea ecx, [2*ebx+ebx] ; 3*kiStride
1338
1339 movdqa xmm0, [sse2_dc_0x80]
1340 movdqa xmm1, xmm0
1341 movdqa [eax], xmm0
1342 movdqa [eax+ebx], xmm1
1343 movdqa [eax+2*ebx], xmm0
1344 movdqa [eax+ecx], xmm1
1345 lea eax, [eax+4*ebx]
1346 movdqa [eax], xmm0
1347 movdqa [eax+ebx], xmm1
1348 movdqa [eax+2*ebx], xmm0
1349 movdqa [eax+ecx], xmm1
1350 lea eax, [eax+4*ebx]
1351 movdqa [eax], xmm0
1352 movdqa [eax+ebx], xmm1
1353 movdqa [eax+2*ebx], xmm0
1354 movdqa [eax+ecx], xmm1
1355 lea eax, [eax+4*ebx]
1356 movdqa [eax], xmm0
1357 movdqa [eax+ebx], xmm1
1358 movdqa [eax+2*ebx], xmm0
1359 movdqa [eax+ecx], xmm1
1360
1361 %undef PUSH_SIZE
1362
1363 pop ebx
1364 ret
1365
1366ALIGN 16
1367;*******************************************************************************
1368; void_t WelsIChromaPredDcLeft_mmx(uint8_t *pPred, const int32_t kiStride)
1369;*******************************************************************************
1370WELS_EXTERN WelsIChromaPredDcLeft_mmx
1371WelsIChromaPredDcLeft_mmx:
1372 push ebx
1373 push esi
1374 %define PUSH_SIZE 8
1375 mov esi, [esp+PUSH_SIZE+4] ; pPred
1376 mov ecx, [esp+PUSH_SIZE+8] ; kiStride
1377 mov eax, esi
1378 ; for left
1379 dec eax
1380 xor ebx, ebx
1381 xor edx, edx
1382 mov bl, [eax]
1383 mov dl, [eax+ecx]
1384 add ebx, edx
1385 lea eax, [eax+2*ecx]
1386 mov dl, [eax]
1387 add ebx, edx
1388 mov dl, [eax+ecx]
1389 add ebx, edx
1390 add ebx, 02h
1391 sar ebx, 02h
1392 mov bh, bl
1393 movd mm1, ebx
1394 pshufw mm0, mm1, 00h ; up64
1395 movq mm1, mm0
1396 xor ebx, ebx
1397 lea eax, [eax+2*ecx]
1398 mov bl, [eax]
1399 mov dl, [eax+ecx]
1400 add ebx, edx
1401 lea eax, [eax+2*ecx]
1402 mov dl, [eax]
1403 add ebx, edx
1404 mov dl, [eax+ecx]
1405 add ebx, edx
1406 add ebx, 02h
1407 sar ebx, 02h
1408 mov bh, bl
1409 movd mm3, ebx
1410 pshufw mm2, mm3, 00h ; down64
1411 movq mm3, mm2
1412 lea ebx, [2*ecx+ecx]
1413 movq [esi], mm0
1414 movq [esi+ecx], mm1
1415 movq [esi+2*ecx], mm0
1416 movq [esi+ebx], mm1
1417 lea esi, [esi+4*ecx]
1418 movq [esi], mm2
1419 movq [esi+ecx], mm3
1420 movq [esi+2*ecx], mm2
1421 movq [esi+ebx], mm3
1422 pop esi
1423 pop ebx
1424 emms
1425 ret
1426
1427ALIGN 16
1428;*******************************************************************************
1429; void_t WelsIChromaPredDcTop_sse2(uint8_t *pPred, const int32_t kiStride)
1430;*******************************************************************************
1431WELS_EXTERN WelsIChromaPredDcTop_sse2
1432WelsIChromaPredDcTop_sse2:
1433 push ebx
1434 %define PUSH_SIZE 4
1435 mov eax, [esp+PUSH_SIZE+4] ; pPred
1436 mov ecx, [esp+PUSH_SIZE+8] ; kiStride
1437 mov ebx, ecx
1438 neg ebx
1439 movq xmm0, [eax+ebx] ; top: 8x1 pixels
1440 pxor xmm7, xmm7
1441 punpcklbw xmm0, xmm7 ; ext 8x2 words
1442 pshufd xmm1, xmm0, 0B1h ; 10110001 B, w5 w4 w7 w6 w1 w0 w3 w2
1443 paddw xmm0, xmm1 ; w5+7 w4+6 w5+7 w4+6 w1+3 w0+2 w1+3 w0+2
1444 movdqa xmm1, xmm0
1445 pshuflw xmm2, xmm0, 0B1h ; 10110001 B, .. w0+2 w1+3 w0+2 w1+3
1446 pshufhw xmm3, xmm1, 0B1h ; 10110001 B, w4+6 w5+7 w4+6 w5+7 ..
1447 paddw xmm0, xmm2 ; .. w0+..+3 w0+..+3 w0+..+3 w0+..+3
1448 paddw xmm1, xmm3 ; w4+..+7 w4+..+7 w4+..+7 w4+..+7 ..
1449 punpckhqdq xmm1, xmm7
1450 punpcklqdq xmm0, xmm1 ; sum1 sum1 sum1 sum1 sum0 sum0 sum0 sum0
1451 movdqa xmm6, [sse2_wd_0x02]
1452 paddw xmm0, xmm6
1453 psraw xmm0, 02h
1454 packuswb xmm0, xmm7
1455 lea ebx, [2*ecx+ecx]
1456 movq [eax], xmm0
1457 movq [eax+ecx], xmm0
1458 movq [eax+2*ecx], xmm0
1459 movq [eax+ebx], xmm0
1460 lea eax, [eax+4*ecx]
1461 movq [eax], xmm0
1462 movq [eax+ecx], xmm0
1463 movq [eax+2*ecx], xmm0
1464 movq [eax+ebx], xmm0
1465 %undef PUSH_SIZE
1466 pop ebx
1467 ret
1468
1469
1470ALIGN 16
1471;*******************************************************************************
1472; void_t WelsIChromaPredDcNA_mmx(uint8_t *pPred, const int32_t kiStride)
1473;*******************************************************************************
1474WELS_EXTERN WelsIChromaPredDcNA_mmx
1475WelsIChromaPredDcNA_mmx:
1476 push ebx
1477 %define PUSH_SIZE 4
1478 mov eax, [esp+PUSH_SIZE+4] ; pPred
1479 mov ebx, [esp+PUSH_SIZE+8] ; kiStride
1480 lea ecx, [2*ebx+ebx]
1481 movq mm0, [sse2_dc_0x80]
1482 movq mm1, mm0
1483 movq [eax], mm0
1484 movq [eax+ebx], mm1
1485 movq [eax+2*ebx], mm0
1486 movq [eax+ecx], mm1
1487 lea eax, [eax+4*ebx]
1488 movq [eax], mm0
1489 movq [eax+ebx], mm1
1490 movq [eax+2*ebx], mm0
1491 movq [eax+ecx], mm1
1492 %undef PUSH_SIZE
1493 pop ebx
1494 emms
1495 ret
1496
1497
1498
codec/decoder/core/asm/mb_copy.asm+330−0
@@ -0,0 +1,330 @@
1;*!
2;* \copy
3;* Copyright (c) 2009-2013, Cisco Systems
4;* All rights reserved.
5;*
6;* Redistribution and use in source and binary forms, with or without
7;* modification, are permitted provided that the following conditions
8;* are met:
9;*
10;* * Redistributions of source code must retain the above copyright
11;* notice, this list of conditions and the following disclaimer.
12;*
13;* * Redistributions in binary form must reproduce the above copyright
14;* notice, this list of conditions and the following disclaimer in
15;* the documentation and/or other materials provided with the
16;* distribution.
17;*
18;* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19;* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20;* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21;* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22;* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23;* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24;* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25;* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26;* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27;* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28;* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29;* POSSIBILITY OF SUCH DAMAGE.
30;*
31;*
32;* mb_copy.asm
33;*
34;* Abstract
35;* mb_copy and mb_copy1
36;*
37;* History
38;* 15/09/2009 Created
39;* 12/28/2009 Modified with larger throughput
40;* 12/29/2011 Tuned WelsCopy16x16NotAligned_sse2, added UpdateMbMv_sse2 WelsCopy16x8NotAligned_sse2,
41;* WelsCopy16x8_mmx, WelsCopy8x16_mmx etc;
42;*
43;*
44;*********************************************************************************************/
45%include "asm_inc.asm"
46BITS 32
47
48;*******************************************************************************
49; Macros and other preprocessor constants
50;*******************************************************************************
51
52;*******************************************************************************
53; Local Data (Read Only)
54;*******************************************************************************
55
56;SECTION .rodata data align=16
57
58;*******************************************************************************
59; Various memory constants (trigonometric values or rounding values)
60;*******************************************************************************
61
62ALIGN 16
63
64;*******************************************************************************
65; Code
66;*******************************************************************************
67
68SECTION .text
69
70WELS_EXTERN PixelAvgWidthEq4_mmx
71WELS_EXTERN PixelAvgWidthEq8_mmx
72WELS_EXTERN PixelAvgWidthEq16_sse2
73
74WELS_EXTERN McCopyWidthEq4_mmx
75WELS_EXTERN McCopyWidthEq8_mmx
76WELS_EXTERN McCopyWidthEq16_sse2
77
78
79ALIGN 16
80;*******************************************************************************
81; void_t PixelAvgWidthEq4_mmx( uint8_t *pDst, int iDstStride,
82; uint8_t *pSrcA, int iSrcAStride,
83; uint8_t *pSrcB, int iSrcBStride,
84; int iHeight );
85;*******************************************************************************
86PixelAvgWidthEq4_mmx:
87
88 push esi
89 push edi
90 push ebp
91 push ebx
92
93 mov edi, [esp+20] ; pDst
94 mov eax, [esp+24] ; iDstStride
95 mov esi, [esp+28] ; pSrcA
96 mov ecx, [esp+32] ; iSrcAStride
97 mov ebp, [esp+36] ; pSrcB
98 mov edx, [esp+40] ; iSrcBStride
99 mov ebx, [esp+44] ; iHeight
100ALIGN 4
101.height_loop:
102 movd mm0, [ebp]
103 pavgb mm0, [esi]
104 movd [edi], mm0
105
106 dec ebx
107 lea edi, [edi+eax]
108 lea esi, [esi+ecx]
109 lea ebp, [ebp+edx]
110 jne .height_loop
111
112 WELSEMMS
113 pop ebx
114 pop ebp
115 pop edi
116 pop esi
117 ret
118
119ALIGN 16
120;*******************************************************************************
121; void_t PixelAvgWidthEq8_mmx( uint8_t *pDst, int iDstStride,
122; uint8_t *pSrcA, int iSrcAStride,
123; uint8_t *pSrcB, int iSrcBStride,
124; int iHeight );
125;*******************************************************************************
126PixelAvgWidthEq8_mmx:
127
128 push esi
129 push edi
130 push ebp
131 push ebx
132
133 mov edi, [esp+20] ; pDst
134 mov eax, [esp+24] ; iDstStride
135 mov esi, [esp+28] ; pSrcA
136 mov ecx, [esp+32] ; iSrcAStride
137 mov ebp, [esp+36] ; pSrcB
138 mov edx, [esp+40] ; iSrcBStride
139 mov ebx, [esp+44] ; iHeight
140ALIGN 4
141.height_loop:
142 movq mm0, [esi]
143 pavgb mm0, [ebp]
144 movq [edi], mm0
145 movq mm0, [esi+ecx]
146 pavgb mm0, [ebp+edx]
147 movq [edi+eax], mm0
148
149 lea esi, [esi+2*ecx]
150 lea ebp, [ebp+2*edx]
151 lea edi, [edi+2*eax]
152
153 sub ebx, 2
154 jnz .height_loop
155
156 WELSEMMS
157 pop ebx
158 pop ebp
159 pop edi
160 pop esi
161 ret
162
163
164
165ALIGN 16
166;*******************************************************************************
167; void_t PixelAvgWidthEq16_sse2( uint8_t *pDst, int iDstStride,
168; uint8_t *pSrcA, int iSrcAStride,
169; uint8_t *pSrcB, int iSrcBStride,
170; int iHeight );
171;*******************************************************************************
172PixelAvgWidthEq16_sse2:
173 push esi
174 push edi
175 push ebp
176 push ebx
177
178
179 mov edi, [esp+20] ; pDst
180 mov eax, [esp+24] ; iDstStride
181 mov esi, [esp+28] ; pSrcA
182 mov ecx, [esp+32] ; iSrcAStride
183 mov ebp, [esp+36] ; pSrcB
184 mov edx, [esp+40] ; iSrcBStride
185 mov ebx, [esp+44] ; iHeight
186ALIGN 4
187.height_loop:
188 movdqu xmm0, [esi]
189 pavgb xmm0, [ebp]
190 movdqu [edi], xmm0
191
192 movdqu xmm0, [esi+ecx]
193 pavgb xmm0, [ebp+edx]
194 movdqu [edi+eax], xmm0
195
196 movdqu xmm0, [esi+2*ecx]
197 pavgb xmm0, [ebp+2*edx]
198 movdqu [edi+2*eax], xmm0
199
200 lea esi, [esi+2*ecx]
201 lea ebp, [ebp+2*edx]
202 lea edi, [edi+2*eax]
203
204 movdqu xmm0, [esi+ecx]
205 pavgb xmm0, [ebp+edx]
206 movdqu [edi+eax], xmm0
207
208 lea esi, [esi+2*ecx]
209 lea ebp, [ebp+2*edx]
210 lea edi, [edi+2*eax]
211
212
213 sub ebx, 4
214 jne .height_loop
215
216 WELSEMMS
217 pop ebx
218 pop ebp
219 pop edi
220 pop esi
221
222 ret
223
224
225ALIGN 16
226;*******************************************************************************
227; void_t McCopyWidthEq4_mmx( uint8_t *pSrc, int iSrcStride,
228; uint8_t *pDst, int iDstStride, int iHeight )
229;*******************************************************************************
230McCopyWidthEq4_mmx:
231 push esi
232 push edi
233 push ebx
234
235
236 mov esi, [esp+16]
237 mov eax, [esp+20]
238 mov edi, [esp+24]
239 mov ecx, [esp+28]
240 mov edx, [esp+32]
241ALIGN 4
242.height_loop:
243 mov ebx, [esi]
244 mov [edi], ebx
245
246 add esi, eax
247 add edi, ecx
248 dec edx
249 jnz .height_loop
250 WELSEMMS
251 pop ebx
252 pop edi
253 pop esi
254 ret
255
256ALIGN 16
257;*******************************************************************************
258; void_t McCopyWidthEq8_mmx( uint8_t *pSrc, int iSrcStride,
259; uint8_t *pDst, int iDstStride, int iHeight )
260;*******************************************************************************
261McCopyWidthEq8_mmx:
262 push esi
263 push edi
264 mov esi, [esp+12]
265 mov eax, [esp+16]
266 mov edi, [esp+20]
267 mov ecx, [esp+24]
268 mov edx, [esp+28]
269
270ALIGN 4
271.height_loop:
272 movq mm0, [esi]
273 movq [edi], mm0
274 add esi, eax
275 add edi, ecx
276 dec edx
277 jnz .height_loop
278
279 WELSEMMS
280 pop edi
281 pop esi
282 ret
283
284
285
286
287
288
289
290
291ALIGN 16
292;*******************************************************************************
293; void_t McCopyWidthEq16_sse2( uint8_t *pSrc, int iSrcStride, uint8_t *pDst, int iDstStride, int iHeight )
294;*******************************************************************************
295;read unaligned memory
296%macro SSE_READ_UNA 2
297 movq %1, [%2]
298 movhps %1, [%2+8]
299%endmacro
300
301;write unaligned memory
302%macro SSE_WRITE_UNA 2
303 movq [%1], %2
304 movhps [%1+8], %2
305%endmacro
306McCopyWidthEq16_sse2:
307 push esi
308 push edi
309
310 mov esi, [esp+12] ; pSrc
311 mov eax, [esp+16] ; iSrcStride
312 mov edi, [esp+20] ; pDst
313 mov edx, [esp+24] ; iDstStride
314 mov ecx, [esp+28] ; iHeight
315
316ALIGN 4
317.height_loop:
318 SSE_READ_UNA xmm0, esi
319 SSE_READ_UNA xmm1, esi+eax
320 SSE_WRITE_UNA edi, xmm0
321 SSE_WRITE_UNA edi+edx, xmm1
322
323 sub ecx, 2
324 lea esi, [esi+eax*2]
325 lea edi, [edi+edx*2]
326 jnz .height_loop
327
328 pop edi
329 pop esi
330 ret
codec/decoder/core/asm/mc_chroma.asm+317−0
@@ -0,0 +1,317 @@
1;*!
2;* \copy
3;* Copyright (c) 2004-2013, Cisco Systems
4;* All rights reserved.
5;*
6;* Redistribution and use in source and binary forms, with or without
7;* modification, are permitted provided that the following conditions
8;* are met:
9;*
10;* * Redistributions of source code must retain the above copyright
11;* notice, this list of conditions and the following disclaimer.
12;*
13;* * Redistributions in binary form must reproduce the above copyright
14;* notice, this list of conditions and the following disclaimer in
15;* the documentation and/or other materials provided with the
16;* distribution.
17;*
18;* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19;* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20;* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21;* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22;* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23;* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24;* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25;* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26;* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27;* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28;* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29;* POSSIBILITY OF SUCH DAMAGE.
30;*
31;*
32;* mc_chroma.asm
33;*
34;* Abstract
35;* mmx motion compensation for chroma
36;*
37;* History
38;* 10/13/2004 Created
39;*
40;*
41;*************************************************************************/
42%include "asm_inc.asm"
43
44BITS 32
45
46;***********************************************************************
47; Local Data (Read Only)
48;***********************************************************************
49
50SECTION .rodata align=16
51
52;***********************************************************************
53; Various memory constants (trigonometric values or rounding values)
54;***********************************************************************
55
56ALIGN 16
57h264_d0x20_sse2:
58 dw 32,32,32,32,32,32,32,32
59ALIGN 16
60h264_d0x20_mmx:
61 dw 32,32,32,32
62
63
64;=============================================================================
65; Code
66;=============================================================================
67
68SECTION .text
69
70ALIGN 16
71;*******************************************************************************
72; void McChromaWidthEq4_mmx( uint8_t *src,
73; int32_t iSrcStride,
74; uint8_t *pDst,
75; int32_t iDstStride,
76; uint8_t *pABCD,
77; int32_t iHeigh );
78;*******************************************************************************
79WELS_EXTERN McChromaWidthEq4_mmx
80McChromaWidthEq4_mmx:
81 push esi
82 push edi
83 push ebx
84
85 mov eax, [esp +12 + 20]
86 movd mm3, [eax]
87 WELS_Zero mm7
88 punpcklbw mm3, mm3
89 movq mm4, mm3
90 punpcklwd mm3, mm3
91 punpckhwd mm4, mm4
92
93 movq mm5, mm3
94 punpcklbw mm3, mm7
95 punpckhbw mm5, mm7
96
97 movq mm6, mm4
98 punpcklbw mm4, mm7
99 punpckhbw mm6, mm7
100
101 mov esi, [esp +12+ 4]
102 mov eax, [esp + 12 + 8]
103 mov edi, [esp + 12 + 12]
104 mov edx, [esp + 12 + 16]
105 mov ecx, [esp + 12 + 24]
106
107 lea ebx, [esi + eax]
108 movd mm0, [esi]
109 movd mm1, [esi+1]
110 punpcklbw mm0, mm7
111 punpcklbw mm1, mm7
112.xloop:
113
114 pmullw mm0, mm3
115 pmullw mm1, mm5
116 paddw mm0, mm1
117
118 movd mm1, [ebx]
119 punpcklbw mm1, mm7
120 movq mm2, mm1
121 pmullw mm1, mm4
122 paddw mm0, mm1
123
124 movd mm1, [ebx+1]
125 punpcklbw mm1, mm7
126 movq mm7, mm1
127 pmullw mm1,mm6
128 paddw mm0, mm1
129 movq mm1,mm7
130
131 paddw mm0, [h264_d0x20_mmx]
132 psrlw mm0, 6
133
134 WELS_Zero mm7
135 packuswb mm0, mm7
136 movd [edi], mm0
137
138 movq mm0, mm2
139
140 lea edi, [edi +edx ]
141 lea ebx, [ebx + eax]
142
143 dec ecx
144 jnz near .xloop
145 WELSEMMS
146 pop ebx
147 pop edi
148 pop esi
149 ret
150
151
152ALIGN 16
153;*******************************************************************************
154; void McChromaWidthEq8_sse2( uint8_t *pSrc,
155; int32_t iSrcStride,
156; uint8_t *pDst,
157; int32_t iDstStride,
158; uint8_t *pABCD,
159; int32_t iheigh );
160;*******************************************************************************
161WELS_EXTERN McChromaWidthEq8_sse2
162McChromaWidthEq8_sse2:
163 push esi
164 push edi
165 push ebx
166
167 mov eax, [esp +12 + 20]
168 movd xmm3, [eax]
169 WELS_Zero xmm7
170 punpcklbw xmm3, xmm3
171 punpcklwd xmm3, xmm3
172
173 movdqa xmm4, xmm3
174 punpckldq xmm3, xmm3
175 punpckhdq xmm4, xmm4
176 movdqa xmm5, xmm3
177 movdqa xmm6, xmm4
178
179 punpcklbw xmm3, xmm7
180 punpckhbw xmm5, xmm7
181 punpcklbw xmm4, xmm7
182 punpckhbw xmm6, xmm7
183
184 mov esi, [esp +12+ 4]
185 mov eax, [esp + 12 + 8]
186 mov edi, [esp + 12 + 12]
187 mov edx, [esp + 12 + 16]
188 mov ecx, [esp + 12 + 24]
189
190 lea ebx, [esi + eax]
191 movq xmm0, [esi]
192 movq xmm1, [esi+1]
193 punpcklbw xmm0, xmm7
194 punpcklbw xmm1, xmm7
195.xloop:
196
197 pmullw xmm0, xmm3
198 pmullw xmm1, xmm5
199 paddw xmm0, xmm1
200
201 movq xmm1, [ebx]
202 punpcklbw xmm1, xmm7
203 movdqa xmm2, xmm1
204 pmullw xmm1, xmm4
205 paddw xmm0, xmm1
206
207 movq xmm1, [ebx+1]
208 punpcklbw xmm1, xmm7
209 movdqa xmm7, xmm1
210 pmullw xmm1, xmm6
211 paddw xmm0, xmm1
212 movdqa xmm1,xmm7
213
214 paddw xmm0, [h264_d0x20_sse2]
215 psrlw xmm0, 6
216
217 WELS_Zero xmm7
218 packuswb xmm0, xmm7
219 movq [edi], xmm0
220
221 movdqa xmm0, xmm2
222
223 lea edi, [edi +edx ]
224 lea ebx, [ebx + eax]
225
226 dec ecx
227 jnz near .xloop
228
229 pop ebx
230 pop edi
231 pop esi
232 ret
233
234
235
236
237ALIGN 16
238;***********************************************************************
239; void McChromaWidthEq8_ssse3( uint8_t *pSrc,
240; int32_t iSrcStride,
241; uint8_t *pDst,
242; int32_t iDstStride,
243; uint8_t *pABCD,
244; int32_t iHeigh);
245;***********************************************************************
246WELS_EXTERN McChromaWidthEq8_ssse3
247McChromaWidthEq8_ssse3:
248 push ebx
249 push esi
250 push edi
251
252 mov eax, [esp + 12 + 20]
253
254 pxor xmm7, xmm7
255 movd xmm5, [eax]
256 punpcklwd xmm5, xmm5
257 punpckldq xmm5, xmm5
258 movdqa xmm6, xmm5
259 punpcklqdq xmm5, xmm5
260 punpckhqdq xmm6, xmm6
261
262 mov eax, [esp + 12 + 4]
263 mov edx, [esp + 12 + 8]
264 mov esi, [esp + 12 + 12]
265 mov edi, [esp + 12 + 16]
266 mov ecx, [esp + 12 + 24]
267
268 sub esi, edi
269 sub esi, edi
270 movdqa xmm7, [h264_d0x20_sse2]
271
272 movdqu xmm0, [eax]
273 movdqa xmm1, xmm0
274 psrldq xmm1, 1
275 punpcklbw xmm0, xmm1
276
277.hloop_chroma:
278 lea esi, [esi+2*edi]
279
280 movdqu xmm2, [eax+edx]
281 movdqa xmm3, xmm2
282 psrldq xmm3, 1
283 punpcklbw xmm2, xmm3
284 movdqa xmm4, xmm2
285
286 pmaddubsw xmm0, xmm5
287 pmaddubsw xmm2, xmm6
288 paddw xmm0, xmm2
289 paddw xmm0, xmm7
290 psrlw xmm0, 6
291 packuswb xmm0, xmm0
292 movq [esi],xmm0
293
294 lea eax, [eax+2*edx]
295 movdqu xmm2, [eax]
296 movdqa xmm3, xmm2
297 psrldq xmm3, 1
298 punpcklbw xmm2, xmm3
299 movdqa xmm0, xmm2
300
301 pmaddubsw xmm4, xmm5
302 pmaddubsw xmm2, xmm6
303 paddw xmm4, xmm2
304 paddw xmm4, xmm7
305 psrlw xmm4, 6
306 packuswb xmm4, xmm4
307 movq [esi+edi],xmm4
308
309 sub ecx, 2
310 jnz .hloop_chroma
311 pop edi
312 pop esi
313 pop ebx
314
315 ret
316
317
codec/decoder/core/asm/mc_luma.asm+615−0
@@ -0,0 +1,615 @@
1;*!
2;* \copy
3;* Copyright (c) 2009-2013, Cisco Systems
4;* All rights reserved.
5;*
6;* Redistribution and use in source and binary forms, with or without
7;* modification, are permitted provided that the following conditions
8;* are met:
9;*
10;* * Redistributions of source code must retain the above copyright
11;* notice, this list of conditions and the following disclaimer.
12;*
13;* * Redistributions in binary form must reproduce the above copyright
14;* notice, this list of conditions and the following disclaimer in
15;* the documentation and/or other materials provided with the
16;* distribution.
17;*
18;* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19;* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20;* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21;* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22;* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23;* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24;* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25;* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26;* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27;* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28;* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29;* POSSIBILITY OF SUCH DAMAGE.
30;*
31;*
32;* mc_luma.asm
33;*
34;* Abstract
35;* sse2 motion compensation
36;*
37;* History
38;* 17/08/2009 Created
39;*
40;*
41;*************************************************************************/
42%include "asm_inc.asm"
43
44BITS 32
45
46;*******************************************************************************
47; Local Data (Read Only)
48;*******************************************************************************
49
50SECTION .rodata align=16
51
52;*******************************************************************************
53; Various memory constants (trigonometric values or rounding values)
54;*******************************************************************************
55
56ALIGN 16
57h264_w0x10:
58 dw 16, 16, 16, 16
59
60
61;*******************************************************************************
62; Code
63;*******************************************************************************
64
65SECTION .text
66
67WELS_EXTERN McHorVer20WidthEq4_mmx
68
69
70ALIGN 16
71;*******************************************************************************
72; void_t McHorVer20WidthEq4_mmx( uint8_t *pSrc,
73; int iSrcStride,
74; uint8_t *pDst,
75; int iDstStride,
76; int iHeight)
77;*******************************************************************************
78McHorVer20WidthEq4_mmx:
79 push esi
80 push edi
81
82 mov esi, [esp+12]
83 mov eax, [esp+16]
84 mov edi, [esp+20]
85 mov ecx, [esp+24]
86 mov edx, [esp+28]
87 sub esi, 2
88 WELS_Zero mm7
89 movq mm6, [h264_w0x10]
90.height_loop:
91 movd mm0, [esi]
92 punpcklbw mm0, mm7
93 movd mm1, [esi+5]
94 punpcklbw mm1, mm7
95 movd mm2, [esi+1]
96 punpcklbw mm2, mm7
97 movd mm3, [esi+4]
98 punpcklbw mm3, mm7
99 movd mm4, [esi+2]
100 punpcklbw mm4, mm7
101 movd mm5, [esi+3]
102 punpcklbw mm5, mm7
103
104 paddw mm2, mm3
105 paddw mm4, mm5
106 psllw mm4, 2
107 psubw mm4, mm2
108 paddw mm0, mm1
109 paddw mm0, mm4
110 psllw mm4, 2
111 paddw mm0, mm4
112 paddw mm0, mm6
113 psraw mm0, 5
114 packuswb mm0, mm7
115 movd [edi], mm0
116
117 add esi, eax
118 add edi, ecx
119 dec edx
120 jnz .height_loop
121
122 WELSEMMS
123 pop edi
124 pop esi
125 ret
126
127;*******************************************************************************
128; Macros and other preprocessor constants
129;*******************************************************************************
130
131
132%macro SSE_LOAD_8P 3
133 movq %1, %3
134 punpcklbw %1, %2
135%endmacro
136
137%macro FILTER_HV_W8 9
138 paddw %1, %6
139 movdqa %8, %3
140 movdqa %7, %2
141 paddw %1, [h264_w0x10_1]
142 paddw %8, %4
143 paddw %7, %5
144 psllw %8, 2
145 psubw %8, %7
146 paddw %1, %8
147 psllw %8, 2
148 paddw %1, %8
149 psraw %1, 5
150 WELS_Zero %8
151 packuswb %1, %8
152 movq %9, %1
153%endmacro
154
155;*******************************************************************************
156; Local Data (Read Only)
157;*******************************************************************************
158
159SECTION .rodata align=16
160
161;*******************************************************************************
162; Various memory constants (trigonometric values or rounding values)
163;*******************************************************************************
164
165ALIGN 16
166h264_w0x10_1:
167 dw 16, 16, 16, 16, 16, 16, 16, 16
168ALIGN 16
169h264_mc_hc_32:
170dw 32, 32, 32, 32, 32, 32, 32, 32
171;*******************************************************************************
172; Code
173;*******************************************************************************
174
175SECTION .text
176WELS_EXTERN McHorVer22Width8HorFirst_sse2
177WELS_EXTERN McHorVer22VerLast_sse2
178WELS_EXTERN McHorVer02WidthEq8_sse2
179WELS_EXTERN McHorVer20WidthEq8_sse2
180WELS_EXTERN McHorVer20WidthEq16_sse2
181
182ALIGN 16
183;***********************************************************************
184; void_t McHorVer22Width8HorFirst_sse2(int16_t *pSrc,
185; int16_t iSrcStride,
186; uint8_t *pDst,
187; int32_t iDstStride
188; int32_t iHeight
189; )
190;***********************************************************************
191McHorVer22Width8HorFirst_sse2:
192 push esi
193 push edi
194 push ebx
195 mov esi, [esp+16] ;pSrc
196 mov eax, [esp+20] ;iSrcStride
197 mov edi, [esp+24] ;pDst
198 mov edx, [esp+28] ;iDstStride
199 mov ebx, [esp+32] ;iHeight
200 pxor xmm7, xmm7
201
202 sub esi, eax ;;;;;;;;need more 5 lines.
203 sub esi, eax
204
205.yloop_width_8:
206 movq xmm0, [esi]
207 punpcklbw xmm0, xmm7
208 movq xmm1, [esi+5]
209 punpcklbw xmm1, xmm7
210 movq xmm2, [esi+1]
211 punpcklbw xmm2, xmm7
212 movq xmm3, [esi+4]
213 punpcklbw xmm3, xmm7
214 movq xmm4, [esi+2]
215 punpcklbw xmm4, xmm7
216 movq xmm5, [esi+3]
217 punpcklbw xmm5, xmm7
218
219 paddw xmm2, xmm3
220 paddw xmm4, xmm5
221 psllw xmm4, 2
222 psubw xmm4, xmm2
223 paddw xmm0, xmm1
224 paddw xmm0, xmm4
225 psllw xmm4, 2
226 paddw xmm0, xmm4
227 movdqa [edi], xmm0
228
229 add esi, eax
230 add edi, edx
231 dec ebx
232 jnz .yloop_width_8
233 pop ebx
234 pop edi
235 pop esi
236 ret
237
238ALIGN 16
239;***********************************************************************
240;void_t McHorVer22VerLast_sse2(
241; uint8_t *pSrc,
242; int32_t pSrcStride,
243; uint8_t * pDst,
244; int32_t iDstStride,
245; int32_t iWidth,
246; int32_t iHeight);
247;***********************************************************************
248
249%macro FILTER_VER 9
250 paddw %1, %6
251 movdqa %7, %2
252 movdqa %8, %3
253
254
255 paddw %7, %5
256 paddw %8, %4
257
258 psubw %1, %7
259 psraw %1, 2
260 paddw %1, %8
261 psubw %1, %7
262 psraw %1, 2
263 paddw %8, %1
264 paddw %8, [h264_mc_hc_32]
265 psraw %8, 6
266 packuswb %8, %8
267 movq %9, %8
268%endmacro
269
270McHorVer22VerLast_sse2:
271 push esi
272 push edi
273 push ebx
274 push ebp
275
276 mov esi, [esp+20]
277 mov eax, [esp+24]
278 mov edi, [esp+28]
279 mov edx, [esp+32]
280 mov ebx, [esp+36]
281 mov ecx, [esp+40]
282 shr ebx, 3
283
284.width_loop:
285 movdqa xmm0, [esi]
286 movdqa xmm1, [esi+eax]
287 lea esi, [esi+2*eax]
288 movdqa xmm2, [esi]
289 movdqa xmm3, [esi+eax]
290 lea esi, [esi+2*eax]
291 movdqa xmm4, [esi]
292 movdqa xmm5, [esi+eax]
293
294 FILTER_VER xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, [edi]
295 dec ecx
296 lea esi, [esi+2*eax]
297 movdqa xmm6, [esi]
298
299 movdqa xmm0, xmm1
300 movdqa xmm1, xmm2
301 movdqa xmm2, xmm3
302 movdqa xmm3, xmm4
303 movdqa xmm4, xmm5
304 movdqa xmm5, xmm6
305
306 add edi, edx
307 sub esi, eax
308
309.start:
310 FILTER_VER xmm0,xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, [edi]
311 dec ecx
312 jz near .x_loop_dec
313
314 lea esi, [esi+2*eax]
315 movdqa xmm6, [esi]
316 FILTER_VER xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm0,[edi+edx]
317 dec ecx
318 jz near .x_loop_dec
319
320 lea edi, [edi+2*edx]
321 movdqa xmm7, [esi+eax]
322 FILTER_VER xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm0, xmm1, [edi]
323 dec ecx
324 jz near .x_loop_dec
325
326 lea esi, [esi+2*eax]
327 movdqa xmm0, [esi]
328 FILTER_VER xmm3, xmm4, xmm5, xmm6, xmm7, xmm0, xmm1, xmm2,[edi+edx]
329 dec ecx
330 jz near .x_loop_dec
331
332 lea edi, [edi+2*edx]
333 movdqa xmm1, [esi+eax]
334 FILTER_VER xmm4, xmm5, xmm6, xmm7, xmm0, xmm1, xmm2, xmm3,[edi]
335 dec ecx
336 jz near .x_loop_dec
337
338 lea esi, [esi+2*eax]
339 movdqa xmm2, [esi]
340 FILTER_VER xmm5, xmm6, xmm7, xmm0, xmm1, xmm2, xmm3,xmm4,[edi+edx]
341 dec ecx
342 jz near .x_loop_dec
343
344 lea edi, [edi+2*edx]
345 movdqa xmm3, [esi+eax]
346 FILTER_VER xmm6, xmm7, xmm0, xmm1, xmm2, xmm3,xmm4,xmm5,[edi]
347 dec ecx
348 jz near .x_loop_dec
349
350 lea esi, [esi+2*eax]
351 movdqa xmm4, [esi]
352 FILTER_VER xmm7, xmm0, xmm1, xmm2, xmm3,xmm4,xmm5,xmm6, [edi+edx]
353 dec ecx
354 jz near .x_loop_dec
355
356 lea edi, [edi+2*edx]
357 movdqa xmm5, [esi+eax]
358 jmp near .start
359
360.x_loop_dec:
361 dec ebx
362 jz near .exit
363 mov esi, [esp+20]
364 mov edi, [esp+28]
365 mov ecx, [esp+40]
366 add esi, 16
367 add edi, 8
368 jmp .width_loop
369
370
371
372.exit:
373 pop ebp
374 pop ebx
375 pop edi
376 pop esi
377 ret
378
379
380ALIGN 16
381;*******************************************************************************
382; void_t McHorVer20WidthEq8_sse2( uint8_t *pSrc,
383; int iSrcStride,
384; uint8_t *pDst,
385; int iDstStride,
386; int iHeight,
387; );
388;*******************************************************************************
389McHorVer20WidthEq8_sse2:
390 push esi
391 push edi
392
393 mov esi, [esp + 12] ;pSrc
394 mov eax, [esp + 16] ;iSrcStride
395 mov edi, [esp + 20] ;pDst
396 mov ecx, [esp + 28] ;iHeight
397 mov edx, [esp + 24] ;iDstStride
398
399 lea esi, [esi-2] ;pSrc -= 2;
400
401 pxor xmm7, xmm7
402 movdqa xmm6, [h264_w0x10_1]
403.y_loop:
404 movq xmm0, [esi]
405 punpcklbw xmm0, xmm7
406 movq xmm1, [esi+5]
407 punpcklbw xmm1, xmm7
408 movq xmm2, [esi+1]
409 punpcklbw xmm2, xmm7
410 movq xmm3, [esi+4]
411 punpcklbw xmm3, xmm7
412 movq xmm4, [esi+2]
413 punpcklbw xmm4, xmm7
414 movq xmm5, [esi+3]
415 punpcklbw xmm5, xmm7
416
417 paddw xmm2, xmm3
418 paddw xmm4, xmm5
419 psllw xmm4, 2
420 psubw xmm4, xmm2
421 paddw xmm0, xmm1
422 paddw xmm0, xmm4
423 psllw xmm4, 2
424 paddw xmm0, xmm4
425 paddw xmm0, xmm6
426 psraw xmm0, 5
427
428 packuswb xmm0, xmm7
429 movq [edi], xmm0
430
431 lea edi, [edi+edx]
432 lea esi, [esi+eax]
433 dec ecx
434 jnz near .y_loop
435
436 pop edi
437 pop esi
438 ret
439
440ALIGN 16
441;*******************************************************************************
442; void_t McHorVer20WidthEq16_sse2( uint8_t *pSrc,
443; int iSrcStride,
444; uint8_t *pDst,
445; int iDstStride,
446; int iHeight,
447; );
448;*******************************************************************************
449McHorVer20WidthEq16_sse2:
450 push esi
451 push edi
452
453
454 mov esi, [esp + 12] ;pSrc
455 mov eax, [esp + 16] ;iSrcStride
456 mov edi, [esp + 20] ;pDst
457 mov ecx, [esp + 28] ;iHeight
458 mov edx, [esp + 24] ;iDstStride
459
460 lea esi, [esi-2] ;pSrc -= 2;
461
462 pxor xmm7, xmm7
463 movdqa xmm6, [h264_w0x10_1]
464.y_loop:
465
466 movq xmm0, [esi]
467 punpcklbw xmm0, xmm7
468 movq xmm1, [esi+5]
469 punpcklbw xmm1, xmm7
470 movq xmm2, [esi+1]
471 punpcklbw xmm2, xmm7
472 movq xmm3, [esi+4]
473 punpcklbw xmm3, xmm7
474 movq xmm4, [esi+2]
475 punpcklbw xmm4, xmm7
476 movq xmm5, [esi+3]
477 punpcklbw xmm5, xmm7
478
479 paddw xmm2, xmm3
480 paddw xmm4, xmm5
481 psllw xmm4, 2
482 psubw xmm4, xmm2
483 paddw xmm0, xmm1
484 paddw xmm0, xmm4
485 psllw xmm4, 2
486 paddw xmm0, xmm4
487 paddw xmm0, xmm6
488 psraw xmm0, 5
489 packuswb xmm0, xmm7
490 movq [edi], xmm0
491
492 movq xmm0, [esi+8]
493 punpcklbw xmm0, xmm7
494 movq xmm1, [esi+5+8]
495 punpcklbw xmm1, xmm7
496 movq xmm2, [esi+1+8]
497 punpcklbw xmm2, xmm7
498 movq xmm3, [esi+4+8]
499 punpcklbw xmm3, xmm7
500 movq xmm4, [esi+2+8]
501 punpcklbw xmm4, xmm7
502 movq xmm5, [esi+3+8]
503 punpcklbw xmm5, xmm7
504
505 paddw xmm2, xmm3
506 paddw xmm4, xmm5
507 psllw xmm4, 2
508 psubw xmm4, xmm2
509 paddw xmm0, xmm1
510 paddw xmm0, xmm4
511 psllw xmm4, 2
512 paddw xmm0, xmm4
513 paddw xmm0, xmm6
514 psraw xmm0, 5
515 packuswb xmm0, xmm7
516 movq [edi+8], xmm0
517
518 lea edi, [edi+edx]
519 lea esi, [esi+eax]
520 dec ecx
521 jnz near .y_loop
522 pop edi
523 pop esi
524 ret
525
526
527;*******************************************************************************
528; void_t McHorVer02WidthEq8_sse2( uint8_t *pSrc,
529; int iSrcStride,
530; uint8_t *pDst,
531; int iDstStride,
532; int iHeight )
533;*******************************************************************************
534ALIGN 16
535McHorVer02WidthEq8_sse2:
536 push esi
537 push edi
538
539 mov esi, [esp + 12] ;pSrc
540 mov edx, [esp + 16] ;iSrcStride
541 mov edi, [esp + 20] ;pDst
542 mov eax, [esp + 24] ;iDstStride
543 mov ecx, [esp + 28] ;iHeight
544
545 sub esi, edx
546 sub esi, edx
547
548 WELS_Zero xmm7
549
550 SSE_LOAD_8P xmm0, xmm7, [esi]
551 SSE_LOAD_8P xmm1, xmm7, [esi+edx]
552 lea esi, [esi+2*edx]
553 SSE_LOAD_8P xmm2, xmm7, [esi]
554 SSE_LOAD_8P xmm3, xmm7, [esi+edx]
555 lea esi, [esi+2*edx]
556 SSE_LOAD_8P xmm4, xmm7, [esi]
557 SSE_LOAD_8P xmm5, xmm7, [esi+edx]
558
559.start:
560 FILTER_HV_W8 xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, [edi]
561 dec ecx
562 jz near .xx_exit
563
564 lea esi, [esi+2*edx]
565 SSE_LOAD_8P xmm6, xmm7, [esi]
566 FILTER_HV_W8 xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm0, [edi+eax]
567 dec ecx
568 jz near .xx_exit
569
570 lea edi, [edi+2*eax]
571 SSE_LOAD_8P xmm7, xmm0, [esi+edx]
572 FILTER_HV_W8 xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm0, xmm1, [edi]
573 dec ecx
574 jz near .xx_exit
575
576 lea esi, [esi+2*edx]
577 SSE_LOAD_8P xmm0, xmm1, [esi]
578 FILTER_HV_W8 xmm3, xmm4, xmm5, xmm6, xmm7, xmm0, xmm1, xmm2, [edi+eax]
579 dec ecx
580 jz near .xx_exit
581
582 lea edi, [edi+2*eax]
583 SSE_LOAD_8P xmm1, xmm2, [esi+edx]
584 FILTER_HV_W8 xmm4, xmm5, xmm6, xmm7, xmm0, xmm1, xmm2, xmm3, [edi]
585 dec ecx
586 jz near .xx_exit
587
588 lea esi, [esi+2*edx]
589 SSE_LOAD_8P xmm2, xmm3, [esi]
590 FILTER_HV_W8 xmm5, xmm6, xmm7, xmm0, xmm1, xmm2, xmm3, xmm4, [edi+eax]
591 dec ecx
592 jz near .xx_exit
593
594 lea edi, [edi+2*eax]
595 SSE_LOAD_8P xmm3, xmm4, [esi+edx]
596 FILTER_HV_W8 xmm6, xmm7, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, [edi]
597 dec ecx
598 jz near .xx_exit
599
600 lea esi, [esi+2*edx]
601 SSE_LOAD_8P xmm4, xmm5, [esi]
602 FILTER_HV_W8 xmm7, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, [edi+eax]
603 dec ecx
604 jz near .xx_exit
605
606 lea edi, [edi+2*eax]
607 SSE_LOAD_8P xmm5, xmm6, [esi+edx]
608 jmp near .start
609
610.xx_exit:
611 pop edi
612 pop esi
613 ret
614
615
codec/decoder/core/asm/memzero.asm+135−0
@@ -0,0 +1,135 @@
1;*!
2;* \copy
3;* Copyright (c) 2009-2013, Cisco Systems
4;* All rights reserved.
5;*
6;* Redistribution and use in source and binary forms, with or without
7;* modification, are permitted provided that the following conditions
8;* are met:
9;*
10;* * Redistributions of source code must retain the above copyright
11;* notice, this list of conditions and the following disclaimer.
12;*
13;* * Redistributions in binary form must reproduce the above copyright
14;* notice, this list of conditions and the following disclaimer in
15;* the documentation and/or other materials provided with the
16;* distribution.
17;*
18;* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19;* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20;* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21;* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22;* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23;* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24;* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25;* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26;* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27;* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28;* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29;* POSSIBILITY OF SUCH DAMAGE.
30;*
31;*
32;* memzero.asm
33;*
34;* Abstract
35;*
36;*
37;* History
38;* 9/16/2009 Created
39;*
40;*
41;*************************************************************************/
42
43BITS 32
44
45%include "asm_inc.asm"
46;***********************************************************************
47; Code
48;***********************************************************************
49
50SECTION .text
51
52ALIGN 16
53;***********************************************************************
54;_inline void __cdecl WelsPrefetchZero_mmx(int8_t const*_A);
55;***********************************************************************
56WELS_EXTERN WelsPrefetchZero_mmx
57WelsPrefetchZero_mmx:
58 mov eax,[esp+4]
59 prefetchnta [eax]
60 ret
61
62
63ALIGN 16
64;***********************************************************************
65; void WelsSetMemZeroAligned64_sse2(void *dst, int32_t size)
66;***********************************************************************
67WELS_EXTERN WelsSetMemZeroAligned64_sse2
68WelsSetMemZeroAligned64_sse2:
69 mov eax, [esp + 4] ; dst
70 mov ecx, [esp + 8]
71 neg ecx
72
73 pxor xmm0, xmm0
74.memzeroa64_sse2_loops:
75 movdqa [eax], xmm0
76 movdqa [eax+16], xmm0
77 movdqa [eax+32], xmm0
78 movdqa [eax+48], xmm0
79 add eax, 0x40
80
81 add ecx, 0x40
82 jnz near .memzeroa64_sse2_loops
83
84 ret
85
86ALIGN 16
87;***********************************************************************
88; void WelsSetMemZeroSize64_mmx(void *dst, int32_t size)
89;***********************************************************************
90WELS_EXTERN WelsSetMemZeroSize64_mmx
91WelsSetMemZeroSize64_mmx:
92 mov eax, [esp + 4] ; dst
93 mov ecx, [esp + 8]
94 neg ecx
95
96 pxor mm0, mm0
97.memzero64_mmx_loops:
98 movq [eax], mm0
99 movq [eax+8], mm0
100 movq [eax+16], mm0
101 movq [eax+24], mm0
102 movq [eax+32], mm0
103 movq [eax+40], mm0
104 movq [eax+48], mm0
105 movq [eax+56], mm0
106 add eax, 0x40
107
108 add ecx, 0x40
109 jnz near .memzero64_mmx_loops
110
111 WELSEMMS
112 ret
113
114ALIGN 16
115;***********************************************************************
116; void WelsSetMemZeroSize8_mmx(void *dst, int32_t size)
117;***********************************************************************
118WELS_EXTERN WelsSetMemZeroSize8_mmx
119WelsSetMemZeroSize8_mmx:
120 mov eax, [esp + 4] ; dst
121 mov ecx, [esp + 8] ; size
122 neg ecx
123 pxor mm0, mm0
124
125.memzero8_mmx_loops:
126 movq [eax], mm0
127 add eax, 0x08
128
129 add ecx, 0x08
130 jnz near .memzero8_mmx_loops
131
132 WELSEMMS
133 ret
134
135
codec/decoder/core/inc/as264_common.h+67−0
@@ -0,0 +1,67 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file common.h
33 *
34 * \brief common flag definitions
35 *
36 * \date 7/6/2009 Created
37 *************************************************************************************
38 */
39#ifndef WELS_AS264_COMMON_H__
40#define WELS_AS264_COMMON_H__
41#define NO_WAITING_AU //slice level decoding
42#define LONG_TERM_REF //for app
43
44#if defined(__cplusplus)
45extern "C" {
46#endif//__cplusplus
47
48#ifdef X86_ASM
49
50void MemZeroUnalign32Bytes(void *pSrc);
51void MemZeroAlign32Bytes(void *pSrc);
52void MemZeroUnalign16Bytes(void *pSrc);
53void MemZeroAlign16Bytes(void *pSrc);
54void MemZeroAlign128Bytes(void *pSrc);
55void MemZeroUnalign128Bytes(void *pSrc);
56void MemZeroAlign256Bytes(void *pSrc);
57void MemZeroAlign240Bytes(void *pSrc);
58void MmPrefetch0(char const *kpA);
59
60#endif// X86_ASM
61
62#if defined(__cplusplus)
63}
64#endif//__cplusplus
65
66
67#endif // WELS_AS264_COMMON_H__
codec/decoder/core/inc/au_parser.h+158−0
@@ -0,0 +1,158 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 * \file au_parser.h
32 *
33 * \brief Interfaces introduced in Access Unit level based parser
34 *
35 * \date 03/10/2009 Created
36 *
37 *************************************************************************************
38 */
39#ifndef WELS_ACCESS_UNIT_PARSER_H__
40#define WELS_ACCESS_UNIT_PARSER_H__
41#include "typedefs.h"
42#include "wels_common_basis.h"
43#include "nal_prefix.h"
44#include "dec_frame.h"
45#include "bit_stream.h"
46#include "parameter_sets.h"
47#include "decoder_context.h"
48
49namespace WelsDec {
50
51/*!
52 *************************************************************************************
53 * \brief Start Code Prefix (0x 00 00 00 01) detection
54 *
55 * \param pBuf bitstream payload buffer
56 * \param pOffset offset between NAL rbsp and original bitsteam that
57 * start code prefix is seperated from.
58 * \param iBufSize count size of buffer
59 *
60 * \return RBSP buffer of start code prefix exclusive
61 *
62 * \note N/A
63 *************************************************************************************
64 */
65uint8_t* DetectStartCodePrefix( const uint8_t *kpBuf, int32_t *pOffset, int32_t iBufSize );
66
67/*!
68 *************************************************************************************
69 * \brief to parse network abstraction layer unit,
70 * escape emulation_prevention_three_byte within it
71 former name is parse_nal
72 *
73 * \param pCtx decoder context
74 * \param pNalUnitHeader parsed result of NAL Unit Header to output
75 * \param pSrcRbsp bitstream buffer to input
76 * \param iSrcRbspLen length size of bitstream buffer payload
77 * \param pSrcNal
78 * \param iSrcNalLen
79 * \param pConsumedBytes consumed bytes during parsing
80 *
81 * \return decoded bytes payload, might be (pSrcRbsp+1) if no escapes
82 *
83 * \note N/A
84 *************************************************************************************
85 */
86uint8_t* ParseNalHeader( PWelsDecoderContext pCtx, SNalUnitHeader *pNalUnitHeader, uint8_t *pSrcRbsp, int32_t iSrcRbspLen, uint8_t *pSrcNal, int32_t iSrcNalLen, int32_t* pConsumedBytes );
87
88int32_t ParseNonVclNal( PWelsDecoderContext pCtx, uint8_t *pRbsp, const int32_t kiSrcLen );
89
90void_t ParseRefBasePicMarking ( PBitStringAux pBs, PRefBasePicMarking pRefBasePicMarking );
91
92void_t ParsePrefixNalUnit ( PWelsDecoderContext pCtx, PBitStringAux pBs );
93
94bool_t CheckAccessUnitBoundary( const PNalUnit kpCurNal, const PNalUnit kpLastNal, const PSps kpSps );
95bool_t CheckAccessUnitBoundaryExt( PNalUnitHeaderExt pLastNalHdrExt, PNalUnitHeaderExt pCurNalHeaderExt, PSliceHeader pLastSliceHeader, PSliceHeader pCurSliceHeader );
96/*!
97 *************************************************************************************
98 * \brief to parse Sequence Parameter Set (SPS)
99 *
100 * \param pCtx Decoder context
101 * \param pBsAux bitstream reader auxiliary
102 * \param pPicWidth picture width current Sps represented
103 * \param pPicHeight picture height current Sps represented
104 *
105 * \return 0 - successed
106 * 1 - failed
107 *
108 * \note Call it in case eNalUnitType is SPS.
109 *************************************************************************************
110 */
111int32_t ParseSps( PWelsDecoderContext pCtx, PBitStringAux pBsAux, int32_t *pPicWidth, int32_t *pPicHeight );
112
113/*!
114 *************************************************************************************
115 * \brief to parse Picture Parameter Set (PPS)
116 *
117 * \param pCtx Decoder context
118 * \param pPpsList pps list
119 * \param pBsAux bitstream reader auxiliary
120 *
121 * \return 0 - successed
122 * 1 - failed
123 *
124 * \note Call it in case eNalUnitType is PPS.
125 *************************************************************************************
126 */
127int32_t ParsePps( PWelsDecoderContext pCtx, PPps pPpsList, PBitStringAux pBsAux );
128
129/*!
130 *************************************************************************************
131 * \brief to parse SEI message payload
132 *
133 * \param pSei sei message to be parsed output
134 * \param pBsAux bitstream reader auxiliary
135 *
136 * \return 0 - successed
137 * 1 - failed
138 *
139 * \note Call it in case eNalUnitType is NAL_UNIT_SEI.
140 *************************************************************************************
141 */
142int32_t ParseSei( void_t *pSei, PBitStringAux pBsAux ); // reserved Sei_Msg type
143
144/*!
145 *************************************************************************************
146 * \brief reset fmo list due to got Sps now
147 *
148 * \param pCtx decoder context
149 *
150 * \return count number of fmo context units are reset
151 *************************************************************************************
152 */
153int32_t ResetFmoList( PWelsDecoderContext pCtx );
154
155} // namespace WelsDec
156
157#endif//WELS_ACCESS_UNIT_PARSER_H__
158
codec/decoder/core/inc/bit_stream.h+77−0
@@ -0,0 +1,77 @@
1/*!
2 * \copy
3 * Copyright (c) 2004-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33 //bit_stream.h - bit-stream reading and / writing auxiliary data
34#ifndef WELS_BIT_STREAM_H__
35#define WELS_BIT_STREAM_H__
36
37#include "typedefs.h"
38
39namespace WelsDec {
40
41/*
42 * Bit-stream auxiliary reading / writing
43 */
44typedef struct TagBitStringAux {
45 uint8_t *pStartBuf; // buffer to start position
46 uint8_t *pEndBuf; // buffer + length
47 int32_t iBits; // count bits of overall bitstreaming input
48
49 int32_t iIndex; //only for cavlc usage
50 uint8_t *pCurBuf; // current reading position
51 uint32_t uiCurBits;
52 int32_t iLeftBits; // count number of available bits left ([1, 8]),
53 // need pointer to next byte start position in case 0 bit left then 8 instead
54}SBitStringAux, *PBitStringAux;
55
56//#pragma pack()
57
58/*!
59 * \brief input bits for decoder or initialize bitstream writing in encoder
60 *
61 * \param pBitString Bit string auxiliary pointer
62 * \param kpBuf bit-stream buffer
63 * \param kiSize size in bits for decoder; size in bytes for encoder
64 *
65 * \return size of buffer data in byte; failed in -1 return
66 */
67int32_t InitBits( PBitStringAux pBitString, const uint8_t *kpBuf, const int32_t kiSize );
68
69void_t InitReadBits( PBitStringAux pBitString );
70
71uint32_t EndianFix(uint32_t uiX);
72
73
74
75} // namespace WelsDec
76
77#endif//WELS_BIT_STREAM_H__
codec/decoder/core/inc/cpu.h+80−0
@@ -0,0 +1,80 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file cpu.h
33 *
34 * \brief CPU feature compatibility detection
35 *
36 * \date 04/29/2009 Created
37 *
38 *************************************************************************************
39 */
40#if !defined(WELS_CPU_DETECTION_H__)
41#define WELS_CPU_DETECTION_H__
42
43#include "typedefs.h"
44
45namespace WelsDec {
46
47#if defined(__cplusplus)
48extern "C" {
49#endif//__cplusplus
50
51#if defined(X86_ASM)
52/*
53 * cpuid support verify routine
54 * return 0 if cpuid is not supported by cpu
55 */
56int32_t WelsCPUIdVerify();
57
58void_t WelsCPUId( uint32_t uiIndex, uint32_t *pFeatureA, uint32_t *pFeatureB, uint32_t *pFeatureC, uint32_t *pFeatureD );
59
60int32_t WelsCPUSupportAVX( uint32_t eax, uint32_t ecx );
61int32_t WelsCPUSupportFMA( uint32_t eax, uint32_t ecx );
62
63void_t WelsEmms();
64
65uint32_t WelsCPUFeatureDetect( int32_t *pNumberOfLogicProcessors );
66
67/*
68 * clear FPU registers states for potential float based calculation if support
69 */
70void WelsCPURestore( const uint32_t kuiCPU );
71
72#endif
73
74#if defined(__cplusplus)
75}
76#endif//__cplusplus
77
78} // namespace WelsDec
79
80#endif//WELS_CPU_DETECTION_H__
codec/decoder/core/inc/cpu_core.h+80−0
@@ -0,0 +1,80 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file cpu_core.h
33 *
34 * \brief cpu core feature detection
35 *
36 * \date 4/24/2009 Created
37 *
38 *************************************************************************************
39 */
40#if !defined(WELS_CPU_CORE_FEATURE_DETECTION_H__)
41#define WELS_CPU_CORE_FEATURE_DETECTION_H__
42
43/*
44 * WELS CPU feature flags
45 */
46#define WELS_CPU_MMX 0x00000001 /* mmx */
47#define WELS_CPU_MMXEXT 0x00000002 /* mmx-ext*/
48#define WELS_CPU_SSE 0x00000004 /* sse */
49#define WELS_CPU_SSE2 0x00000008 /* sse 2 */
50#define WELS_CPU_SSE3 0x00000010 /* sse 3 */
51#define WELS_CPU_SSE41 0x00000020 /* sse 4.1 */
52#define WELS_CPU_3DNOW 0x00000040 /* 3dnow! */
53#define WELS_CPU_3DNOWEXT 0x00000080 /* 3dnow! ext */
54#define WELS_CPU_ALTIVEC 0x00000100 /* altivec */
55#define WELS_CPU_SSSE3 0x00000200 /* ssse3 */
56#define WELS_CPU_SSE42 0x00000400 /* sse 4.2 */
57
58/* CPU features application extensive */
59#define WELS_CPU_AVX 0x00000800 /* Advanced Vector eXtentions */
60#define WELS_CPU_FPU 0x00001000 /* x87-FPU on chip */
61#define WELS_CPU_HTT 0x00002000 /* Hyper-Threading Technology (HTT), Multi-threading enabled feature:
62 physical processor package is capable of supporting more than one logic processor
63 */
64#define WELS_CPU_CMOV 0x00004000 /* Conditional Move Instructions,
65 also if x87-FPU is present at indicated by the CPUID.FPU feature bit, then FCOMI and FCMOV are supported
66 */
67#define WELS_CPU_MOVBE 0x00008000 /* MOVBE instruction */
68#define WELS_CPU_AES 0x00010000 /* AES instruction extensions */
69#define WELS_CPU_FMA 0x00020000 /* AVX VEX FMA instruction sets */
70
71#define WELS_CPU_CACHELINE_16 0x10000000 /* CacheLine Size 16 */
72#define WELS_CPU_CACHELINE_32 0x20000000 /* CacheLine Size 32 */
73#define WELS_CPU_CACHELINE_64 0x40000000 /* CacheLine Size 64 */
74#define WELS_CPU_CACHELINE_128 0x80000000 /* CacheLine Size 128 */
75
76/*
77 * Interfaces for CPU core feature detection as below
78 */
79
80#endif//WELS_CPU_CORE_FEATURE_DETECTION_H__
codec/decoder/core/inc/crt_util_safe_x.h+104−0
@@ -0,0 +1,104 @@
1/*!
2 * \copy
3 * Copyright (c) 2010-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file crt_util_safe_x.h
33 *
34 * \brief Safe CRT like util for cross platfroms support
35 *
36 * \date 06/04/2010 Created
37 *
38 *************************************************************************************
39 */
40#ifndef WELS_CRT_UTIL_SAFE_CROSS_PLATFORMS_H__
41#define WELS_CRT_UTIL_SAFE_CROSS_PLATFORMS_H__
42
43#include <string.h>
44#include <stdlib.h>
45#include <stdarg.h>
46#include <stdio.h>
47#include <math.h>
48#include <time.h>
49
50#if defined(WIN32)
51#include <windows.h>
52#include <sys/types.h>
53#include <sys/timeb.h>
54#else
55#include <sys/timeb.h>
56#include <sys/time.h>
57#include "typedefs.h"
58#endif//WIN32
59
60#include "typedefs.h"
61
62namespace WelsDec {
63
64#ifdef __cplusplus
65extern "C" {
66#endif
67
68#define WELS_FILE_SEEK_SET SEEK_SET
69#define WELS_FILE_SEEK_CUR SEEK_CUR
70#define WESL_FILE_SEEK_END SEEK_END
71
72typedef FILE WelsFileHandle;
73
74#ifdef WIN32
75typedef struct _timeb SWelsTime;
76#else
77typedef struct timeb SWelsTime;
78#endif
79
80int32_t WelsSnprintf( str_t * buffer, int32_t sizeOfBuffer, const str_t * format, ... );
81str_t * WelsStrncpy(str_t * dest, int32_t sizeInBytes, const str_t * src, int32_t count);
82str_t * WelsStrcat(str_t * dest, int32_t sizeInBytes, str_t * src);
83int32_t WelsStrnlen(const str_t * str, int32_t maxlen);
84int32_t WelsVsprintf(str_t * buffer, int32_t sizeOfBuffer, const str_t * format, va_list argptr);
85
86WelsFileHandle * WelsFopen(const str_t * filename, const str_t * mode);
87int32_t WelsFclose(WelsFileHandle * fp);
88int32_t WelsFread(void * buffer, int32_t size, int32_t count, WelsFileHandle * fp);
89int32_t WelsFwrite(const void * buffer, int32_t size, int32_t count, WelsFileHandle * fp);
90int32_t WelsFseek(WelsFileHandle * fp, int32_t offset, int32_t origin);
91int32_t WelsFflush(WelsFileHandle * fp);
92
93int32_t WelsGetTimeOfDay(SWelsTime * tp);
94int32_t WelsStrftime(str_t * buffer, int32_t size, const str_t * format, const SWelsTime * tp);
95uint16_t WelsGetMillsecond(const SWelsTime * tp);
96
97
98#ifdef __cplusplus
99}
100#endif
101
102} // namespace WelsDec
103
104#endif//WELS_CRT_UTIL_SAFE_CROSS_PLATFORMS_H__
codec/decoder/core/inc/deblocking.h+128−0
@@ -0,0 +1,128 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file deblocking.h
33 *
34 * \brief Interfaces introduced in frame deblocking filtering
35 *
36 * \date 05/14/2009 Created
37 *
38 *************************************************************************************
39 */
40
41#ifndef WELS_DEBLOCKING_H__
42#define WELS_DEBLOCKING_H__
43
44#include "decoder_context.h"
45
46//#pragma pack(1)
47
48namespace WelsDec {
49
50/*!
51 * \brief deblocking module initialize
52 *
53 * \param pf
54 * cpu
55 *
56 * \return NONE
57 */
58
59void_t DeblockingInit( PDeblockingFunc pDeblockingFunc, int32_t iCpu );
60
61
62/*!
63 * \brief deblocking filtering target slice
64 *
65 * \param dec Wels decoder context
66 *
67 * \return NONE
68 */
69void_t WelsDeblockingFilterSlice( PWelsDecoderContext pCtx, PDeblockingFilterMbFunc pDeblockMb );
70
71/*!
72 * \brief pixel deblocking filtering
73 *
74 * \param filter deblocking filter
75 * \param pix pixel value
76 * \param stride frame stride
77 * \param bs boundary strength
78 *
79 * \return NONE
80 */
81
82uint32_t DeblockingBsMarginalMBAvcbase( PDqLayer pCurDqLayer, int32_t iEdge, int32_t iNeighMb, int32_t iMbXy);
83
84int32_t DeblockingAvailableNoInterlayer( PDqLayer pCurDqLayer, int32_t iFilterIdc );
85
86void_t DeblockingIntraMb( PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag );
87void_t DeblockingInterMb( PDqLayer pCurDqLayer, PDeblockingFilter pFilter, uint8_t nBS[2][4][4], int32_t iBoundryFlag );
88
89void_t WelsDeblockingMb( PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag );
90
91void_t DeblockLumaLt4V_c( uint8_t *pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *pTc );
92void_t DeblockLumaEq4V_c( uint8_t *pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta );
93
94void_t DeblockLumaLt4H_c( uint8_t *pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *pTc );
95void_t DeblockLumaEq4H_c( uint8_t *pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta );
96
97void_t DeblockChromaLt4V_c( uint8_t *pPixCb, uint8_t *pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *pTc );
98void_t DeblockChromaEq4V_c( uint8_t *pPixCb, uint8_t *pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta );
99
100void_t DeblockChromaLt4H_c( uint8_t *pPixCb, uint8_t *pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *pTc );
101void_t DeblockChromaEq4H_c( uint8_t *pPixCb, uint8_t *pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta );
102
103#if defined(__cplusplus)
104extern "C" {
105#endif//__cplusplus
106
107#ifdef X86_ASM
108void DeblockLumaLt4V_sse2( uint8_t *pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *pTc );
109void DeblockLumaEq4V_sse2( uint8_t *pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta );
110void DeblockLumaTransposeH2V_sse2(uint8_t * pPixY, int32_t iStride, uint8_t * pDst);
111void DeblockLumaTransposeV2H_sse2(uint8_t * pPixY, int32_t iStride, uint8_t * pSrc);
112void DeblockLumaLt4H_sse2(uint8_t *pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *pTc);
113void DeblockLumaEq4H_sse2(uint8_t *pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta);
114void DeblockChromaEq4V_sse2(uint8_t * pPixCb, uint8_t * pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta);
115void DeblockChromaLt4V_sse2(uint8_t * pPixCb, uint8_t * pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t * pTC);
116void DeblockChromaEq4H_sse2(uint8_t * pPixCb, uint8_t * pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta);
117void DeblockChromaLt4H_sse2(uint8_t * pPixCb, uint8_t * pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t * pTC);
118#endif
119#if defined(__cplusplus)
120}
121#endif//__cplusplus
122
123} // namespace WelsDec
124
125//#pragma pack()
126
127#endif //WELS_DEBLOCKING_H__
128
codec/decoder/core/inc/dec_frame.h+143−0
@@ -0,0 +1,143 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33//dec_frame.h
34#ifndef WELS_DEC_FRAME_H__
35#define WELS_DEC_FRAME_H__
36
37#include "typedefs.h"
38#include "wels_const.h"
39#include "wels_common_basis.h"
40#include "parameter_sets.h"
41#include "nal_prefix.h"
42#include "slice.h"
43#include "picture.h"
44#include "bit_stream.h"
45#include "fmo.h"
46
47namespace WelsDec {
48
49///////////////////////////////////DQ Layer level///////////////////////////////////
50typedef struct TagDqLayer SDqLayer;
51typedef SDqLayer* PDqLayer;
52typedef struct TagLayerInfo{
53 SNalUnitHeaderExt sNalHeaderExt;
54 SSlice sSliceInLayer; // Here Slice identify to Frame on concept
55 PSubsetSps pSubsetSps; // current pSubsetSps used, memory alloc in external
56 PSps pSps; // current sps based avc used, memory alloc in external
57 PPps pPps; // current pps used
58} SLayerInfo, *PLayerInfo;
59/* Layer Representation */
60
61struct TagDqLayer{
62 SLayerInfo sLayerInfo;
63
64 uint8_t *pCsData[3]; // pointer to reconstructed picture data
65 int32_t iCsStride[3]; // Cs stride
66 PBitStringAux pBitStringAux; // pointer to SBitStringAux
67 PFmo pFmo; // Current fmo context pointer used
68 int8_t *pMbType;
69 int32_t *pSliceIdc; // using int32_t for slice_idc
70 int16_t (*pMv[LIST_A])[MB_BLOCK4x4_NUM][MV_A];
71 int8_t (*pRefIndex[LIST_A])[MB_BLOCK4x4_NUM];
72 int8_t *pLumaQp;
73 int8_t *pChromaQp;
74 int8_t *pCbp;
75 int8_t (*pNzc)[24];
76 int8_t (*pNzcRs)[24];
77 int8_t *pResidualPredFlag;
78 int8_t *pInterPredictionDoneFlag;
79 int16_t (*pScaledTCoeff)[MB_COEFF_LIST_SIZE];
80 int8_t (*pIntraPredMode)[8]; //0~3 top4x4 ; 4~6 left 4x4; 7 intra16x16
81 int8_t (*pIntra4x4FinalMode)[MB_BLOCK4x4_NUM];
82 int8_t *pChromaPredMode;
83 //uint8_t (*motion_pred_flag[LIST_A])[MB_PARTITION_SIZE]; // 8x8
84 int8_t (*pSubMbType)[MB_SUB_PARTITION_SIZE];
85 int32_t iLumaStride;
86 int32_t iChromaStride;
87 uint8_t *pPred[3];
88 int32_t iMbX;
89 int32_t iMbY;
90 int32_t iMbXyIndex;
91 int32_t iMbWidth; // MB width of this picture, equal to sSps.iMbWidth
92 int32_t iMbHeight; // MB height of this picture, equal to sSps.iMbHeight;
93
94 /* Common syntax elements across all slices of a DQLayer */
95 int32_t iSliceIdcBackup;
96 uint32_t uiSpsId;
97 uint32_t uiPpsId;
98 uint32_t uiDisableInterLayerDeblockingFilterIdc;
99 int32_t iInterLayerSliceAlphaC0Offset;
100 int32_t iInterLayerSliceBetaOffset;
101 //SPosOffset sScaledRefLayer;
102 int32_t iSliceGroupChangeCycle;
103 PRefPicListReorderSyn pRefPicListReordering;
104 PRefPicMarking pRefPicMarking; // Decoded reference picture marking syntaxs
105 PRefBasePicMarking pRefPicBaseMarking;
106
107 PPicture pRef; // reference picture pointer
108 PPicture pDec; // reconstruction picture pointer for layer
109
110 bool_t bStoreRefBasePicFlag; // iCurTid == 0 && iCurQid = 0 && bEncodeKeyPic = 1
111 bool_t bTCoeffLevelPredFlag;
112 bool_t bConstrainedIntraResamplingFlag;
113 uint8_t uiRefLayerDqId;
114 uint8_t uiRefLayerChromaPhaseXPlus1Flag;
115 uint8_t uiRefLayerChromaPhaseYPlus1;
116 uint8_t uiLayerDqId; // dq_id of current layer
117 bool_t bUseRefBasePicFlag; // whether reference pic or reference base pic is referred?
118};
119
120typedef struct TagGpuAvcLayer{
121 SLayerInfo sLayerInfo;
122 PBitStringAux pBitStringAux; // pointer to SBitStringAux
123
124 int8_t *pMbType;
125 int32_t *pSliceIdc; // using int32_t for slice_idc
126 int8_t *pLumaQp;
127 int8_t *pCbp;
128 int8_t (*pNzc)[24];
129 int8_t (*pIntraPredMode)[8]; //0~3 top4x4 ; 4~6 left 4x4; 7 intra16x16
130
131 int32_t iMbX;
132 int32_t iMbY;
133 int32_t iMbXyIndex;
134 int32_t iMbWidth; // MB width of this picture, equal to sSps.iMbWidth
135 int32_t iMbHeight; // MB height of this picture, equal to sSps.iMbHeight;
136
137}SGpuAvcDqLayer, *PGpuAvcDqLayer;
138
139///////////////////////////////////////////////////////////////////////
140
141} // namespace WelsDec
142
143#endif//WELS_DEC_FRAME_H__
codec/decoder/core/inc/dec_golomb.h+243−0
@@ -0,0 +1,243 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file golomb.h
33 *
34 * \brief Exponential Golomb entropy coding/decoding routine
35 *
36 * \date 03/13/2009 Created
37 *
38 *************************************************************************************
39 */
40#ifndef WELS_EXPONENTIAL_GOLOMB_ENTROPY_CODING_H__
41#define WELS_EXPONENTIAL_GOLOMB_ENTROPY_CODING_H__
42
43#include "typedefs.h"
44#include "bit_stream.h"
45#include "macros.h"
46//#include <assert.h>
47#include "ls_defines.h"
48
49namespace WelsDec {
50
51#define GET_WORD(iCurBits, pBufPtr, iLeftBits) { \
52 iCurBits |= ((pBufPtr[0] << 8) | pBufPtr[1]) << (iLeftBits); \
53 iLeftBits -= 16; \
54 pBufPtr +=2; \
55}
56#define NEED_BITS(iCurBits, pBufPtr, iLeftBits) { \
57 if( iLeftBits > 0 ) { \
58 GET_WORD(iCurBits, pBufPtr, iLeftBits); \
59 } \
60}
61#define UBITS(iCurBits, iNumBits) (iCurBits>>(32-(iNumBits)))
62#define DUMP_BITS(iCurBits, pBufPtr, iLeftBits, iNumBits) { \
63 iCurBits <<= (iNumBits); \
64 iLeftBits += (iNumBits); \
65 NEED_BITS(iCurBits, pBufPtr, iLeftBits); \
66}
67
68static inline int32_t ShowBits( PBitStringAux pBs, int32_t iNumBits )
69{
70 return UBITS( pBs->uiCurBits, iNumBits );
71}
72static inline void_t FlushBits( PBitStringAux pBs, int32_t iNumBits )
73{
74 DUMP_BITS( pBs->uiCurBits, pBs->pCurBuf, pBs->iLeftBits, iNumBits );
75}
76static inline int32_t BsGetBits( PBitStringAux pBs, int32_t iNumBits )
77{
78 int32_t iRc = UBITS( pBs->uiCurBits, iNumBits );
79 DUMP_BITS( pBs->uiCurBits, pBs->pCurBuf, pBs->iLeftBits, iNumBits );
80 return iRc;
81}
82
83/*
84 * Exponential Golomb codes decoding routines
85 */
86
87// for data sharing cross modules and try to reduce size of binary generated, 12/10/2009
88extern const uint8_t g_kuiIntra4x4CbpTable[48];
89extern const uint8_t g_kuiInterCbpTable[48];
90
91extern const uint8_t g_kuiLeadingZeroTable[256];
92
93static const uint32_t g_kuiPrefix8BitsTable[16] =
94{
95 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3
96};
97
98
99static inline uint32_t GetPrefixBits(uint32_t uiValue)
100{
101 uint32_t iNumBit = 0;
102
103 if (uiValue & 0xffff0000)
104 {
105 uiValue >>= 16;
106 iNumBit += 16;
107 }
108 if (uiValue & 0xff00)
109 {
110 uiValue >>= 8;
111 iNumBit += 8;
112 }
113
114 if (uiValue & 0xf0)
115 {
116 uiValue >>= 4;
117 iNumBit += 4;
118 }
119 iNumBit += g_kuiPrefix8BitsTable[uiValue];
120
121 return (32-iNumBit);
122}
123
124/*
125 * Read one bit from bit stream followed
126 */
127static inline uint32_t BsGetOneBit(PBitStringAux pBs)
128{
129 return ( BsGetBits(pBs, 1) );
130}
131
132static inline int32_t GetLeadingZeroBits( uint32_t iCurBits ) //<=16 bits
133{
134 int32_t iValue;
135
136 iValue = UBITS( iCurBits, 8 );//ShowBits( bs, 8 );
137 if( iValue )
138 {
139 return g_kuiLeadingZeroTable[iValue];
140 }
141
142 iValue = UBITS( iCurBits, 16 );//ShowBits( bs, 16 );
143 if( iValue )
144 {
145 return (g_kuiLeadingZeroTable[iValue] + 8);
146 }
147
148 //ASSERT(FALSE); // should not go here
149 return -1;
150}
151
152static inline uint32_t BsGetUe( PBitStringAux pBs )
153{
154 uint32_t iValue = 0;
155 int32_t iLeadingZeroBits = GetLeadingZeroBits( pBs->uiCurBits );
156
157 if ( iLeadingZeroBits == -1 ) //bistream error
158 {
159 return 0xffffffff;//-1
160 }
161
162 DUMP_BITS( pBs->uiCurBits, pBs->pCurBuf, pBs->iLeftBits, iLeadingZeroBits + 1 );
163
164 if( iLeadingZeroBits )
165 {
166 iValue = UBITS( pBs->uiCurBits, iLeadingZeroBits );
167 DUMP_BITS( pBs->uiCurBits, pBs->pCurBuf, pBs->iLeftBits, iLeadingZeroBits );
168 }
169
170 return ((1<<iLeadingZeroBits) - 1 + iValue);
171}
172
173
174/*
175 * Read signed exp golomb codes
176 */
177static inline int32_t BsGetSe(PBitStringAux pBs)
178{
179 uint32_t uiCodeNum;
180
181 uiCodeNum = BsGetUe( pBs );
182
183 if(uiCodeNum&0x01)
184 {
185 return (int32_t)((uiCodeNum+1)>>1);
186 }
187 else
188 {
189 return NEG_NUM( (int32_t)(uiCodeNum>>1) );
190 }
191}
192
193/*
194 * Read truncated exp golomb codes
195 */
196static inline uint32_t BsGetTe(PBitStringAux pBs, uint8_t uiRange)
197{
198 if ( 1 == uiRange )
199 {
200 return BsGetOneBit(pBs)^1;
201 }
202 else
203 {
204 return BsGetUe(pBs);
205 }
206}
207
208/*
209 * Get unsigned truncated exp golomb code.
210 */
211static inline int32_t BsGetTe0(PBitStringAux pBs, int32_t iRange)
212{
213 if(iRange==1)
214 return 0;
215 else if(iRange==2)
216 return BsGetOneBit(pBs)^1;
217 else
218 return BsGetUe(pBs);
219}
220
221/*
222 * Get number of trailing bits
223 */
224static inline int32_t BsGetTrailingBits( uint8_t *pBuf )
225{
226 // TODO
227 uint32_t uiValue = *pBuf;
228 int32_t iRetNum = 1;
229
230 do
231 {
232 if (uiValue&1)
233 return iRetNum;
234 uiValue >>= 1;
235 ++ iRetNum;
236 } while(iRetNum < 9);
237
238 return 0;
239}
240
241} // namespace WelsDec
242
243#endif//WELS_EXPONENTIAL_GOLOMB_ENTROPY_CODING_H__
codec/decoder/core/inc/decode_mb_aux.h+61−0
@@ -0,0 +1,61 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33#ifndef WELS_DECODE_MB_AUX_H__
34#define WELS_DECODE_MB_AUX_H__
35
36#include "typedefs.h"
37#include "macros.h"
38
39namespace WelsDec {
40
41void_t InitDctClipTable(void_t);
42
43void_t IdctResAddPred_c(uint8_t *pPred, const int32_t kiStride, int16_t *pRs);
44
45#if defined(__cplusplus)
46extern "C" {
47#endif//__cplusplus
48
49#if defined(X86_ASM)
50 void_t IdctResAddPred_mmx(uint8_t *pPred, const int32_t kiStride, int16_t *pRs);
51#endif//X86_ASM
52
53#if defined(__cplusplus)
54}
55#endif//__cplusplus
56
57void_t GetI4LumaIChromaAddrTable(int32_t *pBlockOffset, const int32_t kiYStride, const int32_t kiUVStride);
58
59} // namespace WelsDec
60
61#endif//WELS_DECODE_MB_AUX_H__
codec/decoder/core/inc/decode_slice.h+90−0
@@ -0,0 +1,90 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33#ifndef WELS_DECODE_SLICE_H__
34#define WELS_DECODE_SLICE_H__
35
36#include "decoder_context.h"
37
38namespace WelsDec {
39
40void_t WelsBlockInit(int16_t* pBlock, int32_t iWidth, int32_t iHeight, int32_t iStride, uint8_t uiVal);
41
42int32_t WelsActualDecodeMbCavlcISlice (PWelsDecoderContext pCtx);
43int32_t WelsDecodeMbCavlcISlice (PWelsDecoderContext pCtx, PNalUnit pNalCur);
44
45int32_t WelsActualDecodeMbCavlcPSlice (PWelsDecoderContext pCtx);
46int32_t WelsDecodeMbCavlcPSlice (PWelsDecoderContext pCtx, PNalUnit pNalCur);
47typedef int32_t (*PWelsDecMbCavlcFunc) (PWelsDecoderContext pCtx, PNalUnit pNalCur);
48
49int32_t WelsTargetSliceConstruction(PWelsDecoderContext pCtx); //construction based on slice
50
51int32_t WelsDecodeSlice(PWelsDecoderContext pCtx, bool_t bFirstSliceInLayer, PNalUnit pNalCur);
52
53
54int32_t WelsTargetMbConstruction(PWelsDecoderContext pCtx);
55
56int32_t WelsMbIntraPredictionConstruction(PWelsDecoderContext pCtx, PDqLayer pCurLayer, bool_t bOutput);
57int32_t WelsMbInterSampleConstruction( PWelsDecoderContext pCtx, PDqLayer pCurLayer,
58 uint8_t* pDstY, uint8_t* pDstU, uint8_t* pDstV, int32_t iStrideL, int32_t iStrideC );
59int32_t WelsMbInterConstruction(PWelsDecoderContext pCtx, PDqLayer pCurLayer);
60void_t WelsLumaDcDequantIdct(int16_t *pBlock, int32_t iQp);
61int32_t WelsMbInterPrediction (PWelsDecoderContext pCtx, PDqLayer pCurLayer);
62void_t WelsMbCopy( uint8_t *pDst, int32_t iStrideDst, uint8_t *pSrc, int32_t iStrideSrc,
63 int32_t iHeight, int32_t iWidth );
64
65void_t WelsChromaDcIdct( int16_t *pBlock );
66
67#ifdef __cplusplus
68extern "C" {
69#endif//__cplusplus
70
71#ifdef X86_ASM
72void_t WelsResBlockZero16x16_sse2 (int16_t* pBlock, int32_t iStride);
73void_t WelsResBlockZero8x8_sse2 (int16_t* pBlock, int32_t iStride);
74#endif
75
76#ifdef __cplusplus
77}
78#endif//__cplusplus
79
80void_t WelsBlockZero16x16_c(int16_t * pBlock, int32_t iStride);
81void_t WelsBlockZero8x8_c (int16_t * pBlock, int32_t iStride);
82void_t SetNonZeroCount_c (int16_t * pBlock, int8_t * pNonZeroCount);
83
84void_t WelsBlockFuncInit(SBlockFunc *pFunc, int32_t iCpu);
85
86} // namespace WelsDec
87
88#endif //WELS_DECODE_SLICE_H__
89
90
codec/decoder/core/inc/decoder.h+151−0
@@ -0,0 +1,151 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file decoder.h
33 *
34 * \brief Interfaces introduced in decoder system architecture
35 *
36 * \date 03/10/2009 Created
37 *
38 *************************************************************************************
39 */
40#ifndef WELS_DECODER_SYSTEM_ARCHITECTURE_H__
41#define WELS_DECODER_SYSTEM_ARCHITECTURE_H__
42
43#include "typedefs.h"
44#include "decoder_context.h"
45
46namespace WelsDec {
47
48#ifdef __cplusplus
49extern "C" {
50#endif//__cplusplus
51
52/*!
53 * \brief configure decoder parameters
54 */
55int32_t DecoderConfigParam ( PWelsDecoderContext pCtx, const void_t* kpParam );
56
57/*!
58 *************************************************************************************
59 * \brief Initialize Wels decoder parameters and memory
60 *
61 * \param pCtx input context to be initialized at first stage
62 * \param pTraceHandle handle for trace
63 * \param pLo log info pointer
64 *
65 * \return 0 - successed
66 * \return 1 - failed
67 *
68 * \note N/A
69 *************************************************************************************
70 */
71int32_t WelsInitDecoder( PWelsDecoderContext pCtx, void_t * pTraceHandle, PWelsLogCallbackFunc pLog );
72
73/*!
74 *************************************************************************************
75 * \brief Uninitialize Wels decoder parameters and memory
76 *
77 * \param pCtx input context to be uninitialized at release stage
78 *
79 * \return NONE
80 *
81 * \note N/A
82 *************************************************************************************
83 */
84void_t WelsEndDecoder( PWelsDecoderContext pCtx );
85
86/*!
87 *************************************************************************************
88 * \brief First entrance to decoding core interface.
89 *
90 * \param pCtx decoder context
91 * \param pBufBs bit streaming buffer
92 * \param kBsLen size in bytes length of bit streaming buffer input
93 * \param ppDst picture payload data to be output
94 * \param pDstBufInfo buf information of ouput data
95 *
96 * \return 0 - successed
97 * \return 1 - failed
98 *
99 * \note N/A
100 *************************************************************************************
101 */
102
103int32_t WelsDecodeBs( PWelsDecoderContext pCtx, const uint8_t *kpBsBuf, const int32_t kiBsLen,
104 uint8_t **ppDst, SBufferInfo* pDstBufInfo);
105
106/*
107 * request memory blocks for decoder avc part
108 */
109int32_t WelsRequestMem( PWelsDecoderContext pCtx, const int32_t kiMbWidth, const int32_t kiMbHeight );
110
111
112/*
113 * free memory blocks in avc
114 */
115void_t WelsFreeMem( PWelsDecoderContext pCtx );
116
117/*
118 * set colorspace format in decoder
119 */
120int32_t DecoderSetCsp(PWelsDecoderContext pCtx, const int32_t kiColorFormat);
121
122/*!
123 * \brief make sure synchonozization picture resolution (get from slice header) among different parts (i.e, memory related and so on)
124 * over decoder internal
125 * ( MB coordinate and parts of data within decoder context structure )
126 * \param pCtx Wels decoder context
127 * \param iMbWidth MB width
128 * \pram iMbHeight MB height
129 * \return 0 - successful; none 0 - something wrong
130 */
131int32_t SyncPictureResolutionExt( PWelsDecoderContext pCtx, const int32_t kiMbWidth, const int32_t kiMbHeight );
132
133/*!
134 * \brief update maximal picture width and height if applicable when receiving a SPS NAL
135 */
136void_t UpdateMaxPictureResolution( PWelsDecoderContext pCtx, const int32_t kiCurWidth, const int32_t kiCurHeight );
137
138void_t AssignFuncPointerForRec( PWelsDecoderContext pCtx );
139
140void_t ResetParameterSetsState( PWelsDecoderContext pCtx );
141
142void_t GetVclNalTemporalId( PWelsDecoderContext pCtx );//get the info that whether or not have VCL NAL in current AU,
143 //and if YES, get the temporal ID
144
145#ifdef __cplusplus
146}
147#endif//__cplusplus
148
149} // namespace WelsDec
150
151#endif//WELS_DECODER_SYSTEM_ARCHITECTURE_H__
codec/decoder/core/inc/decoder_context.h+340−0
@@ -0,0 +1,340 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file decoder_context.h
33 *
34 * \brief mainly interface introduced in Wels decoder side
35 *
36 * \date 3/4/2009 Created
37 *
38 *************************************************************************************
39 */
40#ifndef WELS_DECODER_FRAMEWORK_H__
41#define WELS_DECODER_FRAMEWORK_H__
42#include "typedefs.h"
43#include "utils.h"
44#include "wels_const.h"
45#include "wels_common_basis.h"
46#include "codec_app_def.h"
47#include "parameter_sets.h"
48#include "nalu.h"
49#include "dec_frame.h"
50#include "pic_queue.h"
51#include "vlc_decoder.h"
52#include "fmo.h"
53#include "as264_common.h" // for LONG_TERM_REF macro,can be delete if not need this macro
54#include "crt_util_safe_x.h"
55#include "mb_cache.h"
56
57namespace WelsDec {
58
59#ifndef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
60//#define MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
61#endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
62
63typedef struct TagDataBuffer
64{
65 uint8_t* pHead;
66 uint8_t* pEnd;
67
68 uint8_t* pStartPos;
69 uint8_t* pCurPos;
70}SDataBuffer;
71
72//#ifdef __cplusplus
73//extern "C" {
74//#endif//__cplusplus
75
76//#pragma pack(1)
77
78/*
79 * Need move below structures to function pointer to seperate module/file later
80 */
81
82//typedef int32_t (*rec_mb) (Mb *cur_mb, PWelsDecoderContext pCtx);
83
84/*typedef for get intra predictor func pointer*/
85typedef void_t (*PGetIntraPredFunc)(uint8_t *pPred, const int32_t kiLumaStride);
86typedef void_t (*PIdctResAddPredFunc)(uint8_t *pPred, const int32_t kiStride, int16_t *pRs);
87typedef void_t (*PExpandPictureFunc)( uint8_t *pDst, const int32_t kiStride, const int32_t kiPicWidth, const int32_t kiPicHeight );
88
89/**/
90typedef struct TagRefPic {
91 PPicture pRefList[LIST_A][MAX_REF_PIC_COUNT]; // reference picture marking plus FIFO scheme
92 PPicture pShortRefList[LIST_A][MAX_SHORT_REF_COUNT];
93 PPicture pLongRefList[LIST_A][MAX_LONG_REF_COUNT];
94 uint8_t uiRefCount[LIST_A];
95 uint8_t uiShortRefCount[LIST_A];
96 uint8_t uiLongRefCount[LIST_A]; // dependend on ref pic module
97 int32_t iMaxLongTermFrameIdx;
98} SRefPic, *PRefPic;
99
100typedef void_t (*PWelsMcFunc) (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
101 int16_t iMvX, int16_t iMvY, int32_t iWidth, int32_t iHeight);
102typedef struct TagMcFunc{
103 PWelsMcFunc pMcLumaFunc;
104 PWelsMcFunc pMcChromaFunc;
105}SMcFunc;
106
107//deblock module defination
108struct TagDeblockingFunc;
109
110typedef struct tagDeblockingFilter {
111 uint8_t *pCsData[3]; // pointer to reconstructed picture data
112 int32_t iCsStride[2]; // Cs stride
113 ESliceType eSliceType;
114 int8_t iSliceAlphaC0Offset;
115 int8_t iSliceBetaOffset;
116 int8_t iChromaQP;
117 int8_t iLumaQP;
118 struct TagDeblockingFunc *pLoopf;
119}SDeblockingFilter, *PDeblockingFilter;
120
121typedef void_t (*PDeblockingFilterMbFunc)( PDqLayer pCurDqLayer, PDeblockingFilter filter, int32_t boundry_flag );
122typedef void_t (*PLumaDeblockingLT4Func)( uint8_t *iSampleY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *iTc );
123typedef void_t (*PLumaDeblockingEQ4Func)( uint8_t *iSampleY, int32_t iStride, int32_t iAlpha, int32_t iBeta );
124typedef void_t (*PChromaDeblockingLT4Func)( uint8_t *iSampleCb, uint8_t *iSampleCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *iTc );
125typedef void_t (*PChromaDeblockingEQ4Func)( uint8_t *iSampleCb, uint8_t *iSampleCr, int32_t iStride, int32_t iAlpha, int32_t iBeta );
126
127typedef struct TagDeblockingFunc {
128 PLumaDeblockingLT4Func pfLumaDeblockingLT4Ver;
129 PLumaDeblockingEQ4Func pfLumaDeblockingEQ4Ver;
130 PLumaDeblockingLT4Func pfLumaDeblockingLT4Hor;
131 PLumaDeblockingEQ4Func pfLumaDeblockingEQ4Hor;
132
133 PChromaDeblockingLT4Func pfChromaDeblockingLT4Ver;
134 PChromaDeblockingEQ4Func pfChromaDeblockingEQ4Ver;
135 PChromaDeblockingLT4Func pfChromaDeblockingLT4Hor;
136 PChromaDeblockingEQ4Func pfChromaDeblockinEQ4Hor;
137} SDeblockingFunc, *PDeblockingFunc;
138
139typedef void_t (*PWelsBlockAddStrideFunc)(uint8_t *pDest, uint8_t *pPred, int16_t *pRes, int32_t iPredStride, int32_t iResStride);
140typedef void_t (*PWelsBlockZeroFunc) (int16_t* pBlock, int32_t iStride);
141typedef void_t (*PWelsNonZeroCountFunc) (int16_t *pBlock, int8_t *pNonZeroCount);
142typedef void_t (*PWelsSimpleIdct4x4AddFunc) (int16_t *pDest, int16_t *pSrc, int32_t iStride);
143
144typedef struct TagBlockFunc {
145 PWelsBlockZeroFunc pWelsBlockZero16x16Func;
146 PWelsBlockZeroFunc pWelsBlockZero8x8Func;
147 PWelsNonZeroCountFunc pWelsSetNonZeroCountFunc;
148} SBlockFunc;
149
150typedef void_t ( *PWelsFillNeighborMbInfoIntra4x4Func )( PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, int8_t* pIntraPredMode, PDqLayer pCurLayer );
151typedef int32_t (*PWelsParseIntra4x4ModeFunc) ( PNeighAvail pNeighAvail, int8_t* pIntraPredMode, PBitStringAux pBs, PDqLayer pCurDqLayer);
152typedef int32_t (*PWelsParseIntra16x16ModeFunc) ( PNeighAvail pNeighAvail, PBitStringAux pBs, PDqLayer pCurDqLayer);
153
154typedef struct TagExpandPicFunc{
155 PExpandPictureFunc pExpandLumaPicture;
156 PExpandPictureFunc pExpandChromaPicture[2];
157}SExpandPicFunc;
158
159/*
160 * SWelsDecoderContext: to maintail all modules data over decoder@framework
161 */
162
163typedef struct TagWelsDecoderContext {
164 // Input
165 void_t *pArgDec; // structured arguments for decoder, reserved here for extension in the future
166
167 SDataBuffer sRawData;
168
169 // Configuration
170 SDecodingParam *pParam;
171 uint32_t uiCpuFlag; // CPU compatibility detected
172 int32_t iDecoderMode; // indicate decoder running mode
173 int32_t iSetMode; // indicate decoder mode set from upper layer, this is read-only for decoder internal
174 int32_t iDecoderOutputProperty; // indicate the output buffer property
175 int32_t iModeSwitchType; // 1: optimal decision; 2: forced switch to the other mode; 0: no switch
176
177 int32_t iOutputColorFormat; // color space format to be outputed
178 VIDEO_BITSTREAM_TYPE eVideoType; //indicate the type of video to decide whether or not to do qp_delta error detection.
179 bool_t bErrorResilienceFlag; // error resilience flag
180 bool_t bHaveGotMemory; // global memory for decoder context related ever requested?
181
182 int32_t iImgWidthInPixel; // width of image in pixel reconstruction picture to be output
183 int32_t iImgHeightInPixel;// height of image in pixel reconstruction picture to be output
184 int32_t iMaxWidthInSps; // maximal width of pixel in SPS sets
185 int32_t iMaxHeightInSps; // maximal height of pixel in SPS sets
186
187 // Derived common elements
188 SNalUnitHeader sCurNalHead;
189 ESliceType eSliceType; // Slice type
190 int32_t iFrameNum;
191 int32_t iPrevFrameNum; // frame number of previous frame well decoded for non-truncated mode yet
192 bool_t bLastHasMmco5; //
193 int32_t iErrorCode; // error code return while decoding in case packets lost
194 SFmo sFmoList[MAX_PPS_COUNT]; // list for FMO storage
195 PFmo pFmo; // current fmo context after parsed slice_header
196 int32_t iActiveFmoNum; // active count number of fmo context in list
197
198 /*needed info by decode slice level and mb level*/
199 int32_t iDecBlockOffsetArray[24]; // address talbe for sub 4x4 block in intra4x4_mb, so no need to caculta the address every time.
200
201 struct
202 {
203 int8_t *pMbType[LAYER_NUM_EXCHANGEABLE]; /* mb type */
204 int16_t (*pMv[LAYER_NUM_EXCHANGEABLE][LIST_A])[MB_BLOCK4x4_NUM][MV_A]; //[LAYER_NUM_EXCHANGEABLE MB_BLOCK4x4_NUM*]
205 int8_t (*pRefIndex[LAYER_NUM_EXCHANGEABLE][LIST_A])[MB_BLOCK4x4_NUM];
206 int8_t *pLumaQp[LAYER_NUM_EXCHANGEABLE]; /*mb luma_qp*/
207 int8_t *pChromaQp[LAYER_NUM_EXCHANGEABLE]; /*mb chroma_qp*/
208 int8_t (*pNzc[LAYER_NUM_EXCHANGEABLE])[24];
209 int8_t (*pNzcRs[LAYER_NUM_EXCHANGEABLE])[24];
210 int16_t (*pScaledTCoeff[LAYER_NUM_EXCHANGEABLE])[MB_COEFF_LIST_SIZE]; /*need be aligned*/
211 int8_t (*pIntraPredMode[LAYER_NUM_EXCHANGEABLE])[8]; //0~3 top4x4 ; 4~6 left 4x4; 7 intra16x16
212 int8_t (*pIntra4x4FinalMode[LAYER_NUM_EXCHANGEABLE])[MB_BLOCK4x4_NUM];
213 int8_t *pChromaPredMode[LAYER_NUM_EXCHANGEABLE];
214 int8_t *pCbp[LAYER_NUM_EXCHANGEABLE];
215 uint8_t (*pMotionPredFlag[LAYER_NUM_EXCHANGEABLE][LIST_A])[MB_PARTITION_SIZE]; // 8x8
216 int8_t (*pSubMbType[LAYER_NUM_EXCHANGEABLE])[MB_SUB_PARTITION_SIZE];
217 int32_t *pSliceIdc[LAYER_NUM_EXCHANGEABLE]; // using int32_t for slice_idc
218 int8_t *pResidualPredFlag[LAYER_NUM_EXCHANGEABLE];
219 int8_t *pInterPredictionDoneFlag[LAYER_NUM_EXCHANGEABLE];
220 int16_t iMbWidth;
221 int16_t iMbHeight;
222 }sMb;
223
224
225 // reconstruction picture
226 PPicture pDec; //pointer to current picture being reconstructed
227
228 // reference pictures
229 SRefPic sRefPic;
230
231 SVlcTable sVlcTable; // vlc table
232
233 SBitStringAux sBs;
234
235 /* Global memory external */
236
237 SPosOffset sFrameCrop;
238
239#ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
240 int32_t iSpsTotalNum; //the number of SPS in current IDR interval
241 int32_t iSubspsTotalNum; //the number of subsps in current IDR interval
242 int32_t iPpsTotalNum; //the number of PPS in current IDR interval.
243#endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
244
245 SSps sSpsBuffer[MAX_SPS_COUNT];
246 SPps sPpsBuffer[MAX_PPS_COUNT];
247 PSliceHeader pSliceHeader;
248
249 PPicBuff pPicBuff[LIST_A]; // Initially allocated memory for pictures which are used in decoding.
250 int32_t iPicQueueNumber;
251
252 SSubsetSps sSubsetSpsBuffer[MAX_SPS_COUNT];
253 SNalUnit sPrefixNal;
254
255 PAccessUnit pAccessUnitList; // current access unit list to be performed
256 PSps pSps; // used by current AU
257 PPps pPps; // used by current AU
258 // Memory for pAccessUnitList is dynamically held till decoder destruction.
259 PDqLayer pCurDqLayer; // current DQ layer representation, also carry reference base layer if applicable
260 PDqLayer pDqLayersList[LAYER_NUM_EXCHANGEABLE]; // DQ layers list with memory allocated
261 uint8_t *pCsListXchg[LAYER_NUM_EXCHANGEABLE][3]; // Constructed picture buffer: 0- cur layer, 1- ref layer;
262 int16_t *pRsListXchg[LAYER_NUM_EXCHANGEABLE][3];// Residual picture buffer: 0- cur layer, 1- ref layer;
263
264 int32_t iCsStride[3]; // strides for Cs
265 int32_t iRsStride[3]; // strides for Rs
266
267 int32_t iPicWidthReq; // picture width have requested the memory
268 int32_t iPicHeightReq; // picture height have requested the memory
269
270 uint8_t uiTargetDqId; // maximal DQ ID in current access unit, meaning target layer ID
271 bool_t bAvcBasedFlag; // For decoding bitstream:
272 bool_t bEndOfStreamFlag; // Flag on end of stream requested by external application layer
273 bool_t bInitialDqLayersMem; // dq layers related memory is available?
274
275 bool_t bOnlyOneLayerInCurAuFlag; //only one layer in current AU: 1
276
277 // for EC parameter sets
278 bool_t bSpsExistAheadFlag; // whether does SPS NAL exist ahead of sequence?
279 bool_t bSubspsExistAheadFlag;// whether does Subset SPS NAL exist ahead of sequence?
280 bool_t bPpsExistAheadFlag; // whether does PPS NAL exist ahead of sequence?
281
282 bool_t bSpsAvailFlags[MAX_SPS_COUNT];
283 bool_t bSubspsAvailFlags[MAX_SPS_COUNT];
284 bool_t bPpsAvailFlags[MAX_PPS_COUNT];
285 bool_t bReferenceLostAtT0Flag;
286#ifdef LONG_TERM_REF
287 bool_t bParamSetsLostFlag; //sps or pps do not exist or not correct
288
289 bool_t bCurAuContainLtrMarkSeFlag; //current AU has the LTR marking syntax element, mark the previous frame or self
290 int32_t iFrameNumOfAuMarkedLtr; //if bCurAuContainLtrMarkSeFlag==true, SHOULD set this variable
291
292 uint16_t uiCurIdrPicId;
293#endif
294
295 PGetIntraPredFunc pGetI16x16LumaPredFunc[7]; //h264_predict_copy_16x16;
296 PGetIntraPredFunc pGetI4x4LumaPredFunc[14]; // h264_predict_4x4_t
297 PGetIntraPredFunc pGetIChromaPredFunc[7]; // h264_predict_8x8_t
298 PIdctResAddPredFunc pIdctResAddPredFunc;
299 SMcFunc sMcFunc;
300 /* For Deblocking */
301 SDeblockingFunc sDeblockingFunc;
302 SExpandPicFunc sExpandPicFunc;
303
304 /* For Block */
305 SBlockFunc sBlockFunc;
306 /* For EC */
307 int32_t iCurSeqIntervalTargetDependId;
308 int32_t iCurSeqIntervalMaxPicWidth;
309 int32_t iCurSeqIntervalMaxPicHeight;
310
311 PWelsFillNeighborMbInfoIntra4x4Func pFillInfoCacheIntra4x4Func;
312 PWelsParseIntra4x4ModeFunc pParseIntra4x4ModeFunc;
313 PWelsParseIntra16x16ModeFunc pParseIntra16x16ModeFunc;
314
315 //feedback whether or not have VCL in current AU, and the temporal ID
316 int32_t iFeedbackVclNalInAu;
317 int32_t iFeedbackTidInAu;
318
319 bool_t bAuReadyFlag; // TRUE: one au is ready for decoding; FALSE: default value
320
321 //trace handle
322 void_t * pTraceHandle;
323
324#ifdef NO_WAITING_AU
325 //Save the last nal header info
326 SNalUnitHeaderExt sLastNalHdrExt;
327 SSliceHeader sLastSliceHeader;
328#endif
329
330}SWelsDecoderContext, *PWelsDecoderContext;
331
332//#pragma pack()
333
334//#ifdef __cplusplus
335//}
336//#endif//__cplusplus
337
338} // namespace WelsDec
339
340#endif//WELS_DECODER_FRAMEWORK_H__
codec/decoder/core/inc/decoder_core.h+138−0
@@ -0,0 +1,138 @@
1/*!
2 * \copy
3 * Copyright (c) 2008-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * decoder_core.h
33 *
34 * Abstract
35 * Encapsulative core interfaces
36 *
37 * History
38 * 07/10/2008 Created
39 *
40 *****************************************************************************/
41#ifndef WELS_DECODER_CORE_H__
42#define WELS_DECODER_CORE_H__
43
44#include "typedefs.h"
45#include "wels_common_basis.h"
46#include "decoder_context.h"
47
48#include "codec_def.h"
49
50namespace WelsDec {
51
52/*
53 * WelsInitMemory
54 * Memory request for introduced data
55 * Especially for:
56 * rbsp_au_buffer, cur_dq_layer_ptr and ref_dq_layer_ptr in MB info cache.
57 * return:
58 * 0 - success; otherwise returned error_no defined in error_no.h.
59*/
60int32_t WelsInitMemory( PWelsDecoderContext pCtx );
61
62/*
63 * WelsFreeMemory
64 * Free memory introduced in WelsInitMemory at destruction of decoder.
65 *
66 */
67void_t WelsFreeMemory( PWelsDecoderContext pCtx );
68
69/*!
70 * \brief request memory when maximal picture width and height are available
71 */
72int32_t InitialDqLayersContext ( PWelsDecoderContext pCtx, const int32_t kiMaxWidth, const int32_t kiMaxHeight );
73
74/*!
75 * \brief free dq layer context memory related
76 */
77void_t UninitialDqLayersContext ( PWelsDecoderContext pCtx );
78
79/*
80 * DecodeNalHeaderExt
81 * Trigger condition: NAL_UNIT_TYPE = NAL_UNIT_PREFIX or NAL_UNIT_CODED_SLICE_EXT
82 * Parameter:
83 * pNal: target NALUnit ptr
84 * pSrc: NAL Unit bitstream
85 */
86void_t DecodeNalHeaderExt( PNalUnit pNal, uint8_t* pSrc );
87
88/*
89 * ParseSliceHeaderSyntaxs
90 * Parse slice header of bitstream
91 */
92int32_t ParseSliceHeaderSyntaxs ( PWelsDecoderContext pCtx, PBitStringAux pBs, const bool_t kbExtensionFlag );
93/*
94 * Copy relative syntax elements of NALUnitHeaderExt, sRefPicBaseMarking and bStoreRefBasePicFlag in prefix nal unit.
95 * pSrc: mark as decoded prefix NAL
96 * pDst: succeeded VCL NAL based AVC (I/P Slice)
97 */
98bool_t PrefetchNalHeaderExtSyntax ( PWelsDecoderContext pCtx, PNalUnit const kpDst, PNalUnit const kpSrc);
99
100
101/*
102 * ConstructAccessUnit
103 * construct an access unit for given input bitstream, maybe partial NAL Unit, one or more Units are involved to
104 * joint a collective access unit.
105 * parameter\
106 * buf: bitstream data buffer
107 * bit_len: size in bit length of data
108 * buf_len: size in byte length of data
109 * coded_au: mark an Access Unit decoding finished
110 * return:
111 * 0 - success; otherwise returned error_no defined in error_no.h
112 */
113int32_t ConstructAccessUnit( PWelsDecoderContext pCtx, uint8_t** ppDst, SBufferInfo *pDstInfo);
114
115
116/*
117 * DecodeCurrentAccessUnit
118 * Decode current access unit when current AU is completed.
119 */
120int32_t DecodeCurrentAccessUnit( PWelsDecoderContext pCtx, uint8_t **ppDst, int32_t *iDstLen, int32_t *pWidth, int32_t *pHeight, SBufferInfo *pDstInfo );
121
122/*
123 * Prepare current dq layer context initialization.
124 */
125void_t WelsDqLayerDecodeStart ( PWelsDecoderContext pCtx, PNalUnit pCurNal, PSps pSps, PPps pPps );
126
127
128int32_t WelsDecodeAccessUnitStart ( PWelsDecoderContext pCtx );
129void_t WelsDecodeAccessUnitEnd ( PWelsDecoderContext pCtx );
130
131void_t ForceResetCurrentAccessUnit( PAccessUnit pAu );
132void_t ForceClearCurrentNal( PAccessUnit pAu );
133
134} // namespace WelsDec
135
136#endif//WELS_DECODER_CORE_H__
137
138
codec/decoder/core/inc/error_code.h+171−0
@@ -0,0 +1,171 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file error_code.h
33 *
34 * \brief Error codes used in Wels decoder side
35 *
36 * \date 3/4/2009 Created
37 *
38 *************************************************************************************
39 */
40#ifndef WELS_ERROR_CODE_H__
41#define WELS_ERROR_CODE_H__
42
43namespace WelsDec {
44
45typedef enum TagWelsErr
46{
47 ERR_NONE = 0,
48 ERR_INVALID_PARAMETERS = 1,
49 ERR_MALLOC_FAILED = 2,
50 ERR_API_FAILED = 3,
51
52 ERR_BOUND = 31,
53}EWelsErr;
54
55/*
56 * Specified error format:
57 * ERR_NO = (ERR_LEVEL_FROM (HIGH WORD) << 16) | (ERR_INFO_FROM (LOW WORD))
58 *
59 */
60#define GENERATE_ERROR_NO(iErrLevel, iErrInfo) ((iErrLevel << 16) | (iErrInfo & 0xFFFF))
61
62
63/* ERR_LEVEL */
64//-----------------------------------------------------------------------------------------------------------
65enum{
66 ERR_LEVEL_ACCESS_UNIT = 1,
67 ERR_LEVEL_NAL_UNIT_HEADER,
68 ERR_LEVEL_PREFIX_NAL,
69 ERR_LEVEL_PARAM_SETS,
70 ERR_LEVEL_SLICE_HEADER,
71 ERR_LEVEL_SLICE_DATA,
72 ERR_LEVEL_MB_DATA,
73};
74
75//-----------------------------------------------------------------------------------------------------------
76
77/* More detailed error information, maximal value is 65535 */
78//-----------------------------------------------------------------------------------------------------------
79#define ERR_INFO_COMMON_BASE 1
80#define ERR_INFO_SYNTAX_BASE 1001
81#define ERR_INFO_LOGIC_BASE 10001
82enum{
83 /* Error from common system level: 1-1000 */
84 ERR_INFO_OUT_OF_MEMORY = ERR_INFO_COMMON_BASE,
85 ERR_INFO_INVALID_ACCESS,
86 ERR_INFO_INVALID_PTR,
87 ERR_INFO_INVALID_PARAM,
88 ERR_INFO_FILE_NO_FOUND,
89 ERR_INFO_PATH_NO_FOUND,
90 ERR_INFO_ACCESS_DENIED,
91 ERR_INFO_NOT_READY,
92 ERR_INFO_WRITE_FAULT,
93 ERR_INFO_READ_FAULT,
94 /* Error from H.264 syntax elements parser: 1001-10000 */
95 ERR_INFO_NO_PREFIX_CODE = ERR_INFO_SYNTAX_BASE, // No start prefix code indication
96 ERR_INFO_NO_PARAM_SETS, // No SPS and/ PPS before sequence header
97 ERR_INFO_PARAM_SETS_NOT_INTEGRATED, // Parameters sets (sps/pps) are not integrated at all before to decode VCL nal
98 ERR_INFO_SPS_ID_OVERFLOW,
99 ERR_INFO_PPS_ID_OVERFLOW,
100 ERR_INFO_INVALID_PROFILE_IDC,
101 ERR_INFO_UNMATCHED_LEVEL_IDC,
102 ERR_INFO_INVALID_POC_TYPE,
103 ERR_INFO_REF_COUNT_OVERFLOW,
104 ERR_INFO_CROPPING_NO_SUPPORTED,
105 ERR_INFO_INVALID_SLICEGROUP,
106 ERR_INFO_INVALID_SLICEGROUP_MAP_TYPE,
107 ERR_INFO_INVALID_FRAME_NUM,
108 ERR_INFO_FMO_INIT_FAIL,
109 ERR_INFO_SLICE_TYPE_OVERFLOW,
110 ERR_INFO_INVALID_QP,
111 ERR_INFO_INVALID_DBLOCKING_IDC,
112 ERR_INFO_INVALID_MB_TYPE,
113 ERR_INFO_INVALID_SUB_MB_TYPE,
114 ERR_INFO_UNAVAILABLE_TOP_BLOCK_FOR_INTRA,
115 ERR_INFO_UNAVAILABLE_LEFT_BLOCK_FOR_INTRA,
116 ERR_INFO_INVALID_REF_INDEX,
117 ERR_INFO_INVALID_CBP,
118 ERR_INFO_DQUANT_OUT_OF_RANGE,
119 ERR_INFO_CAVLC_INVALID_PREFIX,
120 ERR_INFO_CAVLC_INVALID_TOTAL_COEFF,
121 ERR_INFO_CAVLC_INVALID_ZERO_LEFT,
122 ERR_INFO_MV_OUT_OF_RANGE,
123
124 ERR_INFO_INVALID_I4x4_PRED_MODE,
125 ERR_INFO_INVALID_I16x16_PRED_MODE,
126 ERR_INFO_INVALID_I_CHROMA_PRED_MODE,
127
128 ERR_INFO_UNSUPPORTED_NON_BASELINE,
129 ERR_INFO_UNSUPPORTED_FMOTYPE,
130 ERR_INFO_UNSUPPORTED_MBAFF,
131 ERR_INFO_UNSUPPORTED_ILP,
132 ERR_INFO_UNSUPPORTED_CABAC_EL,
133 ERR_INFO_UNSUPPORTED_SPSI,
134 ERR_INFO_UNSUPPORTED_MGS,
135 ERR_INFO_UNSUPPORTED_BIPRED,
136 ERR_INFO_UNSUPPORTED_WP,
137
138 ERR_INFO_FRAMES_LOST,
139 ERR_INFO_DEPENDENCY_SPATIAL_LAYER_LOST,
140 ERR_INFO_DEPENDENCY_QUALIT_LAYER_LOST,
141 ERR_INFO_REFERENCE_PIC_LOST,
142 ERR_INFO_INVALID_REORDERING,
143 ERR_INFO_INVALID_MARKING,
144
145 ERR_INFO_FMO_NOT_SUPPORTED_IN_BASE_LAYER,
146 ERR_INFO_INVALID_ESS,
147 ERR_INFO_INVALID_SLICE_TYPE,
148 ERR_INFO_INVALID_REF_MARKING,
149 ERR_INFO_INVALID_REF_REORDERING,
150
151 /* Error from corresponding logic, 10001-65535 */
152 ERR_INFO_NO_IDR_PIC = ERR_INFO_LOGIC_BASE, // NO IDR picture available before sequence header
153 ERR_INFO_EC_NO_NEIGHBOUR_MBS,
154 ERR_INFO_EC_UNEXPECTED_MB_TYPE,
155 ERR_INFO_EC_NO_ENOUGH_NEIGHBOUR_MBS,
156 //for LTR
157 ERR_INFO_INVALID_MMCO_OPCODE_BASE,
158 ERR_INFO_INVALID_MMCO_SHORT2UNUSED,
159 EER_INFO_INVALID_MMCO_LONG2UNUSED,
160 ERR_INFO_INVALID_MMCO_SHOART2LONG,
161 ERR_INFO_INVALID_MMCO_REF_NUM_OVERFLOW,
162 ERR_INFO_INVALID_MMCO_REF_NUM_NOT_ENOUGH,
163 ERR_INFO_INVALID_MMCO_LONG_TERM_IDX_EXCEED_MAX,
164};
165//-----------------------------------------------------------------------------------------------------------
166
167} // namespace WelsDec
168
169#endif//WELS_ERROR_CODE_H__
170
171
codec/decoder/core/inc/expand_pic.h+78−0
@@ -0,0 +1,78 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file expand_pic.h
33 *
34 * \brief Interface for expanding reconstructed picture to be used for reference
35 *
36 * \date 06/08/2009 Created
37 *************************************************************************************
38 */
39
40#ifndef WELS_EXPAND_PIC_H__
41#define WELS_EXPAND_PIC_H__
42
43#include "decoder_context.h"
44#include "picture.h"
45
46namespace WelsDec {
47
48void_t ExpandReferencingPicture(PPicture pPic, PExpandPictureFunc pExpandPictureLuma, PExpandPictureFunc pExpandPictureChroma[2]);
49
50#if defined(__cplusplus)
51extern "C" {
52#endif//__cplusplus
53
54#if defined(X86_ASM)
55void_t ExpandPictureLuma_sse2( uint8_t *pDst,
56 const int32_t kiStride,
57 const int32_t kiPicWidth,
58 const int32_t kiPicHeight );
59void_t ExpandPictureChromaAlign_sse2( uint8_t *pDst,
60 const int32_t kiStride,
61 const int32_t kiPicWidth,
62 const int32_t kiPicHeight );
63void_t ExpandPictureChromaUnalign_sse2( uint8_t *pDst,
64 const int32_t kiStride,
65 const int32_t kiPicWidth,
66 const int32_t kiPicHeight );
67#endif//X86_ASM
68
69#if defined(__cplusplus)
70}
71#endif//__cplusplus
72
73//
74void_t InitExpandPictureFunc( SExpandPicFunc *pExpandPicFunc, const uint32_t kuiCpuFlags );
75
76} // namespace WelsDec
77
78#endif//WELS_EXPAND_PIC_H__
codec/decoder/core/inc/fmo.h+113−0
@@ -0,0 +1,113 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file fmo.h
33 *
34 * \brief Flexible Macroblock Ordering implementation
35 *
36 * \date 2/4/2009 Created
37 *
38 *************************************************************************************
39 */
40#ifndef WELS_FLEXIBLE_MACROBLOCK_ORDERING_H__
41#define WELS_FLEXIBLE_MACROBLOCK_ORDERING_H__
42
43#include "typedefs.h"
44#include "wels_const.h"
45#include "parameter_sets.h"
46
47namespace WelsDec {
48
49#ifndef MB_XY_T
50#define MB_XY_T int16_t
51#endif//MB_XY_T
52
53/*!
54 * \brief Wels Flexible Macroblock Ordering (FMO)
55 */
56typedef struct TagFmo{
57 uint8_t *pMbAllocMap;
58 int32_t iCountMbNum;
59 int32_t iSliceGroupCount;
60 int32_t iSliceGroupType;
61 bool_t bActiveFlag;
62 uint8_t uiReserved[3]; // reserved padding bytes
63} SFmo, *PFmo;
64
65
66/*!
67 * \brief Initialize Wels Flexible Macroblock Ordering (FMO)
68 *
69 * \param pFmo Wels fmo to be initialized
70 * \param pPps PPps
71 * \param kiMbWidth mb width
72 * \param kiMbHeight mb height
73 *
74 * \return 0 - successful; none 0 - failed;
75 */
76int32_t InitFmo( PFmo pFmo, PPps pPps, const int32_t kiMbWidth, const int32_t kiMbHeight );
77
78/*!
79 * \brief Uninitialize Wels Flexible Macroblock Ordering (FMO) list
80 *
81 * \param pFmo Wels base fmo ptr to be uninitialized
82 * \param kiCnt count number of PPS per list
83 * \param kiAvail count available number of PPS in list
84 *
85 * \return NONE
86 */
87void_t UninitFmoList( PFmo pFmo, const int32_t kiCnt, const int32_t kiAvail );
88
89/*!
90 * \brief update/insert FMO parameter unit
91 *
92 * \param pFmo FMO context
93 * \param pSps PSps
94 * \param pPps PPps
95 * \param pActiveFmoNum int32_t* [in/out]
96 *
97 * \return true - update/insert successfully; false - failed;
98 */
99bool_t FmoParamUpdate( PFmo pFmo, PSps pSps, PPps pPps, int32_t *pActiveFmoNum );
100
101/*!
102 * \brief Get successive mb to be processed with given current mb_xy
103 *
104 * \param pFmo Wels fmo context
105 * \param iMbXy current mb_xy
106 *
107 * \return iNextMb - successful; -1 - failed;
108 */
109MB_XY_T FmoNextMb( PFmo pFmo, const MB_XY_T kiMbXy );
110
111} // namespace WelsDec
112
113#endif//WELS_FLEXIBLE_MACROBLOCK_ORDERING_H__
codec/decoder/core/inc/get_intra_predictor.h+121−0
@@ -0,0 +1,121 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file get_intra_predictor.h
33 *
34 * \brief interfaces for get intra predictor about 16x16, 4x4, chroma.
35 *
36 * \date 4/2/2009 Created
37 *
38 *************************************************************************************
39 */
40
41#ifndef WELS_GET_INTRA_PREDICTOR_H__
42#define WELS_GET_INTRA_PREDICTOR_H__
43
44#include "typedefs.h"
45
46//#pragma pack(1)
47
48namespace WelsDec {
49
50void_t WelsI4x4LumaPredV_c (uint8_t *pPred, const int32_t kiStride);
51void_t WelsI4x4LumaPredH_c (uint8_t *pPred, const int32_t kiStride);
52void_t WelsI4x4LumaPredDc_c (uint8_t *pPred, const int32_t kiStride);
53void_t WelsI4x4LumaPredDcLeft_c(uint8_t *pPred, const int32_t kiStride);
54void_t WelsI4x4LumaPredDcTop_c (uint8_t *pPred, const int32_t kiStride);
55void_t WelsI4x4LumaPredDcNA_c (uint8_t *pPred, const int32_t kiStride);
56void_t WelsI4x4LumaPredDDL_c (uint8_t *pPred, const int32_t kiStride);
57void_t WelsI4x4LumaPredDDLTop_c(uint8_t *pPred, const int32_t kiStride);
58void_t WelsI4x4LumaPredDDR_c (uint8_t *pPred, const int32_t kiStride);
59void_t WelsI4x4LumaPredVL_c (uint8_t *pPred, const int32_t kiStride);
60void_t WelsI4x4LumaPredVLTop_c (uint8_t *pPred, const int32_t kiStride);
61void_t WelsI4x4LumaPredVR_c (uint8_t *pPred, const int32_t kiStride);
62void_t WelsI4x4LumaPredHU_c (uint8_t *pPred, const int32_t kiStride);
63void_t WelsI4x4LumaPredHD_c (uint8_t *pPred, const int32_t kiStride);
64
65void_t WelsIChromaPredV_c (uint8_t *pPred, const int32_t kiStride);
66void_t WelsIChromaPredH_c (uint8_t *pPred, const int32_t kiStride);
67void_t WelsIChromaPredPlane_c (uint8_t *pPred, const int32_t kiStride);
68void_t WelsIChromaPredDc_c (uint8_t *pPred, const int32_t kiStride);
69void_t WelsIChromaPredDcLeft_c (uint8_t *pPred, const int32_t kiStride);
70void_t WelsIChromaPredDcTop_c (uint8_t *pPred, const int32_t kiStride);
71void_t WelsIChromaPredDcNA_c (uint8_t *pPred, const int32_t kiStride);
72
73void_t WelsI16x16LumaPredV_c (uint8_t *pPred, const int32_t kiStride);
74void_t WelsI16x16LumaPredH_c (uint8_t *pPred, const int32_t kiStride);
75void_t WelsI16x16LumaPredPlane_c (uint8_t *pPred, const int32_t kiStride);
76void_t WelsI16x16LumaPredDc_c (uint8_t *pPred, const int32_t kiStride);
77void_t WelsI16x16LumaPredDcTop_c (uint8_t *pPred, const int32_t kiStride);
78void_t WelsI16x16LumaPredDcLeft_c(uint8_t *pPred, const int32_t kiStride);
79void_t WelsI16x16LumaPredDcNA_c (uint8_t *pPred, const int32_t kiStride);
80
81#if defined(__cplusplus)
82extern "C" {
83#endif//__cplusplus
84
85#if defined(X86_ASM)
86void_t WelsI16x16LumaPredPlane_sse2(uint8_t *pPred, const int32_t kiStride);
87void_t WelsI16x16LumaPredH_sse2 (uint8_t *pPred, const int32_t kiStride);
88void_t WelsI16x16LumaPredV_sse2 (uint8_t *pPred, const int32_t kiStride);
89void_t WelsI16x16LumaPredDc_sse2 (uint8_t *pPred, const int32_t kiStride);
90void_t WelsI16x16LumaPredDcTop_sse2(uint8_t *pPred, const int32_t kiStride);
91void_t WelsI16x16LumaPredDcNA_sse2 (uint8_t *pPred, const int32_t kiStride);
92
93void_t WelsIChromaPredDcTop_sse2 (uint8_t *pPred, const int32_t kiStride);
94void_t WelsIChromaPredPlane_sse2 (uint8_t *pPred, const int32_t kiStride);
95void_t WelsIChromaPredDc_sse2 (uint8_t *pPred, const int32_t kiStride);
96void_t WelsIChromaPredH_mmx (uint8_t *pPred, const int32_t kiStride);
97void_t WelsIChromaPredV_mmx (uint8_t *pPred, const int32_t kiStride);
98void_t WelsIChromaPredDcLeft_mmx(uint8_t *pPred, const int32_t kiStride);
99void_t WelsIChromaPredDcNA_mmx (uint8_t *pPred, const int32_t kiStride);
100
101void_t WelsI4x4LumaPredH_sse2 (uint8_t *pPred, const int32_t kiStride);
102void_t WelsI4x4LumaPredDc_sse2(uint8_t *pPred, const int32_t kiStride);
103void_t WelsI4x4LumaPredDDR_mmx(uint8_t *pPred, const int32_t kiStride);
104void_t WelsI4x4LumaPredHD_mmx (uint8_t *pPred, const int32_t kiStride);
105void_t WelsI4x4LumaPredHU_mmx (uint8_t *pPred, const int32_t kiStride);
106void_t WelsI4x4LumaPredVR_mmx (uint8_t *pPred, const int32_t kiStride);
107void_t WelsI4x4LumaPredDDL_mmx(uint8_t *pPred, const int32_t kiStride);
108void_t WelsI4x4LumaPredVL_mmx (uint8_t *pPred, const int32_t kiStride);
109#endif//X86_ASM
110
111#if defined(__cplusplus)
112}
113#endif//__cplusplus
114
115} // namespace WelsDec
116
117//#pragma pack()
118
119#endif //WELS_GET_INTRA_PREDICTOR_H__
120
121
codec/decoder/core/inc/ls_defines.h+86−0
@@ -0,0 +1,86 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33#ifndef ___LD_ST_MACROS___
34#define ___LD_ST_MACROS___
35
36#include "typedefs.h"
37
38#ifdef __GNUC__
39
40 struct tagUnaligned_64 { uint64_t l; } __attribute__((packed));
41 struct tagUnaligned_32 { uint32_t l; } __attribute__((packed));
42 struct tagUnaligned_16 { uint16_t l; } __attribute__((packed));
43
44 #define LD16(a) (((struct tagUnaligned_16 *) (a))->l)
45 #define LD32(a) (((struct tagUnaligned_32 *) (a))->l)
46 #define LD64(a) (((struct tagUnaligned_64 *) (a))->l)
47 //#define _USE_STRUCT_INT_CVT
48// #ifdef _USE_STRUCT_INT_CVT
49 #define ST16(a, b) (((struct tagUnaligned_16 *) (a))->l) = (b)
50 #define ST32(a, b) (((struct tagUnaligned_32 *) (a))->l) = (b)
51 #define ST64(a, b) (((struct tagUnaligned_64 *) (a))->l) = (b)
52// #else
53// inline void_t __ST16(void_t *dst, uint16_t v) { memcpy(dst, &v, 2); }
54// inline void_t __ST32(void_t *dst, uint32_t v) { memcpy(dst, &v, 4); }
55 //inline void_t __ST64(void_t *dst, uint64_t v) { memcpy(dst, &v, 8); }
56// #endif
57
58#else
59
60//#define INTD16(a) (*((int16_t*)(a)))
61//#define INTD32(a) (*((int32_t*)(a)))
62//#define INTD64(a) (*((int64_t*)(a)))
63
64#define LD16(a) (*((uint16_t*)(a)))
65#define LD32(a) (*((uint32_t*)(a)))
66#define LD64(a) (*((uint64_t*)(a)))
67
68#define ST16(a, b) *((uint16_t*)(a)) = (b)
69#define ST32(a, b) *((uint32_t*)(a)) = (b)
70#define ST64(a, b) *((uint64_t*)(a)) = (b)
71
72#endif /* !__GNUC__ */
73
74#ifndef INTD16
75#define INTD16 LD16
76#endif//INTD16
77
78#ifndef INTD32
79#define INTD32 LD32
80#endif//INTD32
81
82#ifndef INTD64
83#define INTD64 LD64
84#endif//INTD64
85
86#endif//___LD_ST_MACROS___
codec/decoder/core/inc/macros.h+306−0
@@ -0,0 +1,306 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file macros.h
33 *
34 * \brief MACRO based tool utilization
35 *
36 * \date 3/13/2009 Created
37 *
38 *************************************************************************************
39 */
40#ifndef WELS_MACRO_UTILIZATIONS_H__
41#define WELS_MACRO_UTILIZATIONS_H__
42
43#include <math.h>
44#include <assert.h>
45#include "typedefs.h"
46
47
48namespace WelsDec {
49
50/*
51* FORCE_STACK_ALIGN_1D: force 1 dimension local data aligned in stack
52* _tp: type
53* _nm: var name
54* _sz: size
55* _al: align bytes
56* auxiliary var: _nm ## _tEmP
57*/
58#define FORCE_STACK_ALIGN_1D(_tp, _nm, _sz, _al) \
59 _tp _nm ## _tEmP[(_sz)+(_al)-1]; \
60 _tp *_nm = _nm ## _tEmP + ((_al)-1) - (((int32_t)(_nm ## _tEmP + ((_al)-1)) & ((_al)-1))/sizeof(_tp))
61
62
63#define ENFORCE_STACK_ALIGN_2D(_tp, _nm, _cx, _cy, _al) \
64 assert( ((_al) && !((_al) & ((_al) - 1))) && ((_al) >= sizeof(_tp)) ); /*_al should be power-of-2 and >= sizeof(_tp)*/\
65 _tp _nm ## _tEmP[(_cx)*(_cy)+(_al)/sizeof(_tp)-1]; \
66 _tp *_nm ## _tEmP_al = _nm ## _tEmP + ((_al)/sizeof(_tp)-1); \
67 _nm ## _tEmP_al -= (((int32_t)_nm ## _tEmP_al & ((_al)-1))/sizeof(_tp)); \
68 _tp (*_nm)[(_cy)] = (_tp (*)[(_cy)])_nm ## _tEmP_al;
69
70
71///////////// from encoder
72#if defined(_MSC_VER)
73 #define inline __inline
74 #define __FASTCALL __fastcall
75// #define __align8(t,v) __declspec(align(8)) t v
76 #define __align16(t,v) __declspec(align(16)) t v
77#elif defined(__GNUC__)
78#if !defined(MAC_POWERPC) && !defined(UNIX) && !defined(ANDROID_NDK) && !defined(APPLE_IOS)
79 #define __FASTCALL __attribute__ ((fastcall))// linux, centos, mac_x86 can be used
80#else
81 #define __FASTCALL // mean NULL for mac_ppc, solaris(sparc/x86)
82#endif//MAC_POWERPC
83// #define __align8(t,v) t v __attribute__ ((aligned (8)))
84 #define __align16(t,v) t v __attribute__ ((aligned (16)))
85
86#if defined(APPLE_IOS)
87 #define inline //For iOS platform
88#endif
89
90#endif//_MSC_VER
91
92
93#if !defined(SIZEOFRGB24)
94#define SIZEOFRGB24(cx, cy) (3 * (cx) * (cy))
95#endif//SIZEOFRGB24
96
97#if !defined(SIZEOFRGB32)
98#define SIZEOFRGB32(cx, cy) (4 * (cx) * (cy))
99#endif//SIZEOFRGB32
100#if 1
101#ifndef WELS_ALIGN
102#define WELS_ALIGN(x, n) (((x)+(n)-1)&~((n)-1))
103#endif//WELS_ALIGN
104
105#ifndef WELS_MAX
106#define WELS_MAX(x, y) ((x) > (y) ? (x) : (y))
107#endif//WELS_MAX
108
109#ifndef WELS_MIN
110#define WELS_MIN(x, y) ((x) < (y) ? (x) : (y))
111#endif//WELS_MIN
112#else
113
114#ifndef WELS_ALIGN
115#define WELS_ALIGN(x, n) (((x)+(n)-1)&~((n)-1))
116#endif//WELS_ALIGN
117
118#ifndef WELS_MAX
119#define WELS_MAX(x, y) ((x) - (((x)-(y))&(((x)-(y))>>31)))
120#endif//WELS_MAX
121
122#ifndef WELS_MIN
123#define WELS_MIN(x, y) ((y) + (((x)-(y))&(((x)-(y))>>31)))
124#endif//WELS_MIN
125
126#endif
127
128#ifndef WELS_CEIL
129#define WELS_CEIL(x) ceil(x) // FIXME: low complexity instead of math library used
130#endif//WELS_CEIL
131
132#ifndef WELS_FLOOR
133#define WELS_FLOOR(x) floor(x) // FIXME: low complexity instead of math library used
134#endif//WELS_FLOOR
135
136#ifndef WELS_ROUND
137#define WELS_ROUND(x) ((int32_t)(0.5f+(x)))
138#endif//WELS_ROUND
139
140#define WELS_NON_ZERO_COUNT_AVERAGE(nC,nA,nB) { \
141 nC = nA + nB + 1; \
142 nC >>= (uint8_t)( nA != -1 && nB != -1); \
143 nC += (uint8_t)(nA == -1 && nB == -1); \
144}
145
146static __inline int32_t CeilLog2( int32_t i )
147{
148 int32_t s = 0; i--;
149 while( i > 0 )
150 {
151 s++;
152 i >>= 1;
153 }
154 return s;
155}
156/*
157the second path will degrades the performance
158*/
159#if 1
160static inline int32_t WelsMedian(int32_t iX, int32_t iY, int32_t iZ)
161{
162 int32_t iMin = iX, iMax = iX;
163
164 if ( iY < iMin )
165 iMin = iY;
166 else
167 iMax = iY;
168
169 if ( iZ < iMin )
170 iMin = iZ;
171 else if ( iZ > iMax )
172 iMax = iZ;
173
174 return (iX + iY + iZ) - (iMin + iMax);
175}
176#else
177static inline int32_t WelsMedian(int32_t iX, int32_t iY, int32_t iZ)
178{
179 int32_t iTmp = (iX-iY)&((iX-iY)>>31);
180 iX -= iTmp;
181 iY += iTmp;
182 iY -= (iY-iZ)&((iY-iZ)>>31);
183 iY += (iX-iY)&((iX-iY)>>31);
184 return iY;
185}
186
187#endif
188
189#ifndef NEG_NUM
190//#define NEG_NUM( num ) (-num)
191#define NEG_NUM(iX) (1+(~(iX)))
192#endif// NEG_NUM
193
194#ifndef WELS_CLIP1
195//#define WELS_CLIP1(x) (x & ~255) ? (-x >> 31) : x
196#define WELS_CLIP1(iX) (((iX) & ~255) ? (-(iX) >> 31) : (iX)) //iX not only a value but also can be an expression
197#endif//WELS_CLIP1
198
199
200#ifndef WELS_SIGN
201#define WELS_SIGN(iX) ((int32_t)(iX) >> 31)
202#endif //WELS_SIGN
203#ifndef WELS_ABS
204#define WELS_ABS(iX) ((WELS_SIGN(iX) ^ (int32_t)(iX)) - WELS_SIGN(iX))
205#endif //WELS_ABS
206
207// WELS_CLIP3
208#ifndef WELS_CLIP3
209#define WELS_CLIP3(iX, iY, iZ) ((iX) < (iY) ? (iY) : ((iX) > (iZ) ? (iZ) : (iX)))
210#endif //WELS_CLIP3
211
212/*
213 * Description: to check variable validation and return the specified result
214 * iResult: value to be return
215 * bCaseIf: negative condition to be verified
216 */
217#ifndef WELS_VERIFY_RETURN_IF
218#define WELS_VERIFY_RETURN_IF(iResult, bCaseIf) \
219 if ( bCaseIf ){ \
220 return iResult; \
221 }
222#endif//#if WELS_VERIFY_RETURN_IF
223
224/*
225 * Description: to check variable validation and return the specified result
226 * with correspoinding process advance.
227 * result: value to be return
228 * case_if: negative condition to be verified
229 * proc: process need perform
230 */
231#ifndef WELS_VERIFY_RETURN_PROC_IF
232#define WELS_VERIFY_RETURN_PROC_IF(iResult, bCaseIf, fProc) \
233 if ( bCaseIf ){ \
234 fProc; \
235 return iResult; \
236 }
237#endif//#if WELS_VERIFY_RETURN_PROC_IF
238
239/*
240 * Description: to check variable validation and return
241 * case_if: negtive condition to be verified
242 * return: NONE
243 */
244#ifndef WELS_VERIFY_IF
245#define WELS_VERIFY_IF(bCaseIf) \
246 if ( bCaseIf ){ \
247 return; \
248 }
249#endif//#if WELS_VERIFY_IF
250
251/*
252 * Description: to check variable validation and return with correspoinding process advance.
253 * case_if: negtive condition to be verified
254 * proc: process need preform
255 * return: NONE
256 */
257#ifndef WELS_VERIFY_PROC_IF
258#define WELS_VERIFY_PROC_IF(bCaseIf, fProc) \
259 if ( bCaseIf ){ \
260 fProc; \
261 return; \
262 }
263#endif//#if WELS_VERIFY_IF
264
265/*
266 * Description: to safe free a ptr with free function pointer
267 * p: pointer to be destroyed
268 * free_fn: free function pointer used
269 */
270#ifndef WELS_SAFE_FREE_P
271#define WELS_SAFE_FREE_P(pPtr, fFreeFunc) \
272 do{ \
273 if ( NULL != (pPtr) ){ \
274 fFreeFunc( (pPtr) ); \
275 (pPtr) = NULL; \
276 } \
277 }while( 0 );
278#endif//#if WELS_SAFE_FREE_P
279
280/*
281 * Description: to safe free an array ptr with free function pointer
282 * arr: pointer to an array, something like "**p";
283 * num: number of elements in array
284 * free_fn: free function pointer
285 */
286#ifndef WELS_SAFE_FREE_ARR
287#define WELS_SAFE_FREE_ARR(pArray, iNum, fFreeFunc) \
288 do{ \
289 if ( NULL != (pArray) ){ \
290 int32_t iIdx = 0; \
291 while( iIdx < iNum ){ \
292 if ( NULL != (pArray)[iIdx] ){ \
293 fFreeFunc( (pArray)[iIdx] ); \
294 (pArray)[iIdx] = NULL; \
295 } \
296 ++ iIdx; \
297 } \
298 fFreeFunc((pArray)); \
299 (pArray) = NULL; \
300 } \
301 }while( 0 );
302#endif//#if WELS_SAFE_FREE_ARR
303
304} // namespace WelsDec
305
306#endif//WELS_MACRO_UTILIZATIONS_H__
codec/decoder/core/inc/manage_dec_ref.h+81−0
@@ -0,0 +1,81 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file manage_dec_ref.h
33 *
34 * Abstract
35 * Interface for managing reference picture
36 *
37 * History
38 * 08/14/2009 Created
39 *
40 *****************************************************************************/
41#ifndef WELS_MANAGE_DEC_REF_H__
42#define WELS_MANAGE_DEC_REF_H__
43
44
45#include "typedefs.h"
46#include "decoder_context.h"
47
48namespace WelsDec {
49
50typedef enum TagRemoveFlag{
51 REMOVE_TARGET = 0,
52 REMOVE_BASE = 1,
53 REMOVE_BASE_FIRST = 2
54}ERemoveFlag;
55
56void_t WelsResetRefPic (PWelsDecoderContext pCtx);
57int32_t WelsInitRefList (PWelsDecoderContext pCtx, int32_t iPoc);
58int32_t WelsReorderRefList(PWelsDecoderContext pCtx);
59int32_t WelsMarkAsRef (PWelsDecoderContext pCtx, const bool_t kbRefBaseMarkingFlag);
60
61static PPicture WelsDelShortFromList (PRefPic pRefPic, int32_t iFrameNum, ERemoveFlag eRemoveFlag);
62static PPicture WelsDelLongFromList (PRefPic pRefPic, uint32_t uiLongTermFrameIdx, ERemoveFlag eRemoveFlag);
63static PPicture WelsDelShortFromListSetUnref(PRefPic pRefPic, int32_t iFrameNum, ERemoveFlag eRemoveFlag);
64static PPicture WelsDelLongFromListSetUnref (PRefPic pRefPic, uint32_t uiLongTermFrameIdx, ERemoveFlag eRemoveFlag);
65
66static int32_t MMCOBase (PWelsDecoderContext pCtx, PRefBasePicMarking pRefPicBaseMarking);
67static int32_t MMCO (PWelsDecoderContext pCtx, PRefPicMarking pRefPicMarking);
68static int32_t MMCOProcess (PWelsDecoderContext pCtx, uint32_t uiMmcoType, bool_t bRefBasePic,
69 int32_t iShortFrameNum, uint32_t uiLongTermPicNum, int32_t iLongTermFrameIdx, int32_t iMaxLongTermFrameIdx);
70static int32_t SlidingWindow(PWelsDecoderContext pCtx);
71
72static int32_t AddShortTermToList(PRefPic pRefPic, PPicture pPic);
73static int32_t AddLongTermToList (PRefPic pRefPic, PPicture pPic, int32_t iLongTermFrameIdx);
74static int32_t AssignLongTermIdx (PRefPic pRefPic, int32_t iFrameNum, int32_t iLongTermFrameIdx);
75static int32_t MarkAsLongTerm (PRefPic pRefPic, int32_t iFrameNum, int32_t iLongTermFrameIdx);
76
77} // namespace WelsDec
78
79#endif//WELS_MANAGE_DEC_REF_H__
80
81
codec/decoder/core/inc/mb_cache.h+84−0
@@ -0,0 +1,84 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33//mb_cache.h
34#ifndef WELS_MACROBLOCK_CACHE_H__
35#define WELS_MACROBLOCK_CACHE_H__
36
37#include "typedefs.h"
38
39namespace WelsDec {
40
41//#pragma pack(1)
42
43#define REF_NOT_AVAIL -2
44#define REF_NOT_IN_LIST -1 //intra
45
46/*
47 * MB Cache information, such one cache should be defined within a slice
48 */
49/*
50 * Cache for Luma Cache for Chroma(Cb, Cr)
51 *
52 * TL T T T T TL T T
53 * L - - - - L - -
54 * L - - - - L - - TR
55 * L - - - -
56 * L - - - - TR
57 *
58 */
59
60////////////////////////mapping scan index////////////////////////
61
62// for data sharing cross modules and try to reduce size of binary generated
63extern const uint8_t g_kuiMbNonZeroCountIdx[24];
64extern const uint8_t g_kuiCache30ScanIdx[16];
65extern const uint8_t g_kuiCacheNzcScanIdx[24];
66
67extern const uint8_t g_kuiScan4[16];
68
69typedef struct TagNeighborAvail
70{
71 int32_t iTopAvail;
72 int32_t iLeftAvail;
73 int32_t iRightTopAvail;
74 int32_t iLeftTopAvail; //used for check intra_pred_mode avail or not //1: avail; 0: unavail
75
76 int32_t iLeftType;
77 int32_t iTopType;
78 int32_t iLeftTopType;
79 int32_t iRightTopType;
80}SNeighAvail, *PNeighAvail;
81
82} // namespace WelsDec
83
84#endif//WELS_MACROBLOCK_CACHE_H__
codec/decoder/core/inc/mc.h+79−0
@@ -0,0 +1,79 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33#ifndef WELS_MC_H__
34#define WELS_MC_H__
35
36#include "wels_const.h"
37#include "macros.h"
38#include "decoder_context.h"
39
40namespace WelsDec {
41
42void_t InitMcFunc(SMcFunc *pMcFunc, int32_t iCpu);
43
44#if defined(__cplusplus)
45extern "C" {
46#endif//__cplusplus
47
48//***************************************************************************//
49// MMXEXT definition //
50//***************************************************************************//
51#if defined(X86_ASM)
52typedef void_t (*PMcChromaWidthExtFunc)( uint8_t *pSrc, int32_t iSrcStride, uint8_t *pDst, int32_t iDstStride, const uint8_t *kpABCD, int32_t iHeight );
53extern void_t McHorVer20WidthEq4_mmx (uint8_t *pSrc, int32_t iSrcStride, uint8_t *pDst, int32_t iDstStride, int32_t iHeight);
54extern void_t McChromaWidthEq4_mmx (uint8_t *pSrc, int32_t iSrcStride, uint8_t *pDst, int32_t iDstStride, const uint8_t *kpABCD, int32_t iHeight );
55extern void_t McCopyWidthEq4_mmx (uint8_t *pSrc, int32_t iSrcStride, uint8_t *pDst, int32_t iDstStride, int32_t iHeight);
56extern void_t McCopyWidthEq8_mmx (uint8_t *pSrc, int32_t iSrcStride, uint8_t *pDst, int32_t iDstStride, int32_t iHeight);
57extern void_t PixelAvgWidthEq4_mmx (uint8_t *pDst, int32_t iDstStride, uint8_t *pSrcA, int32_t iSrcAStride, uint8_t *pSrcB, int32_t iSrcBStride, int32_t iHeight);
58extern void_t PixelAvgWidthEq8_mmx (uint8_t *pDst, int32_t iDstStride, uint8_t *pSrcA, int32_t iSrcAStride, uint8_t *pSrcB, int32_t iSrcBStride, int32_t iHeight);
59//***************************************************************************//
60// SSE2 definition //
61//***************************************************************************//
62extern void_t McChromaWidthEq8_sse2 (uint8_t *pSrc, int32_t iSrcStride, uint8_t *pDst, int32_t iDstStride, const uint8_t* kpABCD, int32_t iHeight );
63extern void_t McCopyWidthEq16_sse2 (uint8_t *pSrc, int32_t iSrcStride, uint8_t *pDst, int32_t iDstStride, int32_t iHeight);
64extern void_t McHorVer20WidthEq8_sse2 (uint8_t *pSrc, int32_t iSrcStride, uint8_t *pDst, int32_t iDstStride, int32_t iHeight);
65extern void_t McHorVer20WidthEq16_sse2(uint8_t *pSrc, int32_t iSrcStride, uint8_t *pDst, int32_t iDstStride, int32_t iHeight);
66extern void_t McHorVer02WidthEq8_sse2 (uint8_t *pSrc, int32_t iSrcStride, uint8_t *pDst, int32_t iDstStride, int32_t iHeight);
67extern void_t McHorVer22Width8HorFirst_sse2(uint8_t *pSrc, int32_t iSrcStride, uint8_t *pDst, int32_t iDstStride, int32_t iHeight);
68extern void_t McHorVer22VerLast_sse2(uint8_t * pTap, int32_t iTapStride, uint8_t * pDst,int32_t iDstStride,int32_t iWidth,int32_t iHeight);
69extern void_t PixelAvgWidthEq16_sse2 (uint8_t *pDst, int32_t iDstStride, uint8_t *pSrcA, int32_t iSrcAStride, uint8_t *pSrcB, int32_t iSrcBStride, int32_t iHeight);
70
71#endif //X86_ASM
72
73#if defined(__cplusplus)
74}
75#endif//__cplusplus
76
77} // namespace WelsDec
78
79#endif//WELS_MC_H__
codec/decoder/core/inc/measure_time.h+100−0
@@ -0,0 +1,100 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file measure_time.h
33 *
34 * \brief time cost measure utilization
35 *
36 * \date 04/28/2009 Created
37 *
38 *************************************************************************************
39 */
40#ifndef WELS_TIME_COST_MEASURE_UTIL_H__
41#define WELS_TIME_COST_MEASURE_UTIL_H__
42
43#include <stdlib.h>
44
45#if !(defined(_MSC_VER) || defined(__MINGW32__))
46#include <sys/time.h>
47#else
48#include "typedefs.h"
49//#include <sys/types.h>
50#include <sys/timeb.h>
51#endif
52#include <time.h>
53#if defined(WIN32)
54#include <windows.h>
55#endif//#if WIN32
56
57#ifdef __cplusplus
58extern "C" {
59#endif//__cplusplus
60
61/*!
62 * \brief time cost measure utilization
63 * \param void_t
64 * \return time elapsed since run (unit: microsecond)
65 */
66
67int64_t WelsTime( void_t )
68{
69#if !(defined(_MSC_VER) || defined(__MINGW32__))
70 struct timeval tv_date;
71
72 gettimeofday( &tv_date, NULL );
73 return( (int64_t) tv_date.tv_sec * 1000000 + (int64_t) tv_date.tv_usec );
74#else
75#if defined (WIN32)
76 static int64_t iMtimeFreq = 0;
77 int64_t iMtimeCur = 0;
78 int64_t iResult = 0;
79 if ( !iMtimeFreq ){
80 QueryPerformanceFrequency((LARGE_INTEGER *)&iMtimeFreq);
81 if ( !iMtimeFreq )
82 iMtimeFreq = 1;
83 }
84 QueryPerformanceCounter((LARGE_INTEGER *)&iMtimeCur);
85 iResult = (int64_t)((double)iMtimeCur * 1e6 / (double)iMtimeFreq + 0.5);
86 return iResult;
87#else
88 struct _timeb sTime;
89
90 _ftime(&sTime);
91 return ((int64_t)sTime.time * (1000) + (int64_t)sTime.millitm) * (1000);
92#endif//#if WIN32
93#endif//!(defined(_MSC_VER) || defined(__MINGW32__))
94}
95
96#ifdef __cplusplus
97}
98#endif
99
100#endif//WELS_TIME_COST_MEASURE_UTIL_H__
codec/decoder/core/inc/mem_align.h+92−0
@@ -0,0 +1,92 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 * memory alignment utilization
32 */
33
34#ifndef WELS_MEM_ALIGN_H__
35#define WELS_MEM_ALIGN_H__
36
37
38
39#include <stdlib.h>
40#include <string.h>
41#include "utils.h"
42
43namespace WelsDec {
44
45//#define CACHE_LINE 64
46
47#ifdef __cplusplus
48extern "C" {
49#endif//__cplusplus
50
51
52
53/*!
54*************************************************************************************
55* \brief malloc with zero filled utilization in Wels
56*
57* \param kuiSize size of memory block required
58*
59* \return allocated memory pointer exactly, failed in case of NULL return
60*
61* \note N/A
62*************************************************************************************
63*/
64void_t * WelsMalloc( const uint32_t kuiSize, const str_t *kpTag );
65
66/*!
67*************************************************************************************
68* \brief free utilization in Wels
69*
70* \param pPtr data pointer to be free.
71* i.e, uint8_t *pPtr = actual data to be free, argv = &pPtr.
72*
73* \return NONE
74*
75* \note N/A
76*************************************************************************************
77*/
78void_t WelsFree( void_t * pPtr, const str_t *kpTag );
79
80#define WELS_SAFE_FREE(pPtr, pTag) if (pPtr) { WelsFree(pPtr, pTag); pPtr = NULL; }
81
82/*
83 * memory operation routines
84 */
85
86#ifdef __cplusplus
87}
88#endif//__cplusplus
89
90} // namespace WelsDec
91
92#endif //WELS_MEM_ALIGN_H__
codec/decoder/core/inc/memmgr_nal_unit.h+65−0
@@ -0,0 +1,65 @@
1/*!
2 * \copy
3 * Copyright (c) 2008-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * memmgr_nal_unit.h
33 *
34 * Abstract
35 * memory manager utils for NAL Unit list available
36 *
37 * History
38 * 07/10/2008 Created
39 *
40 *****************************************************************************/
41#ifndef WELS_MEMORY_MANAGER_NAL_UNIT_H__
42#define WELS_MEMORY_MANAGER_NAL_UNIT_H__
43
44#include "typedefs.h"
45#include "wels_common_basis.h"
46#include "nalu.h"
47
48namespace WelsDec {
49
50int32_t MemInitNalList(PAccessUnit *ppAu, const uint32_t kuiSize);
51
52int32_t MemFreeNalList(PAccessUnit *ppAu);
53
54/*
55 * MemGetNextNal
56 * Get next NAL Unit for using.
57 * Need expand NAL Unit list if exceeding count number of available NAL Units withing an Access Unit
58 */
59PNalUnit MemGetNextNal(PAccessUnit *ppAu);
60
61} // namespace WelsDec
62
63#endif//WELS_MEMORY_MANAGER_NAL_UNIT_H__
64
65
codec/decoder/core/inc/mv_pred.h+98−0
@@ -0,0 +1,98 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file mv_pred.h
33 *
34 * \brief Get MV predictor and update motion vector of mb cache
35 *
36 * \date 05/22/2009 Created
37 *
38 *************************************************************************************
39 */
40
41#ifndef WELS_MV_PRED_H__
42#define WELS_MV_PRED_H__
43
44#include "dec_frame.h"
45
46namespace WelsDec {
47
48/*!
49* \brief update mv and ref_index cache for current MB, only for P_16x16 (SKIP inclusive)
50* \param
51* \param
52*/
53void_t UpdateP16x16MotionInfo(PDqLayer pCurDqLayer, int8_t iRef, int16_t iMVs[2]);
54
55 /*!
56 * \brief update mv and ref_index cache for current MB, only for P_16x8
57 * \param
58 * \param
59 */
60void_t UpdateP16x8MotionInfo(PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30],
61 int32_t iPartIdx, int8_t iRef, int16_t iMVs[2]);
62
63
64 /*!
65 * \brief update mv and ref_index cache for current MB, only for P_8x16
66 * \param
67 * \param
68 */
69void_t UpdateP8x16MotionInfo(PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30],
70 int32_t iPartIdx, int8_t iRef, int16_t iMVs[2]);
71
72/*!
73 * \brief get the motion predictor for 4*4 or 8*8 or 16*16 block
74 * \param
75 * \param output mvp_x and mvp_y
76 */
77void_t PredMv(int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30],
78 int32_t iPartIdx, int32_t iPartWidth, int8_t iRef, int16_t iMVP[2]);
79
80/*!
81 * \brief get the motion predictor for inter16x8 MB
82 * \param
83 * \param output mvp_x and mvp_y
84 */
85void_t PredInter16x8Mv(int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30],
86 int32_t iPartIdx, int8_t iRef, int16_t iMVP[2]);
87
88/*!
89 * \brief get the motion predictor for inter8x16 MB
90 * \param
91 * \param output mvp_x and mvp_y
92 */
93void_t PredInter8x16Mv(int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30],
94 int32_t iPartIdx, int8_t iRef, int16_t iMVP[2]);
95
96} // namespace WelsDec
97
98#endif//WELS_MV_PRED_H__
codec/decoder/core/inc/nal_prefix.h+89−0
@@ -0,0 +1,89 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33//nal_prefix.h - definitions for NAL Unit Header(/Ext) and PrefixNALUnit
34#ifndef WELS_NAL_UNIT_PREFIX_H__
35#define WELS_NAL_UNIT_PREFIX_H__
36
37#include "typedefs.h"
38#include "wels_common_basis.h"
39#include "slice.h"
40
41namespace WelsDec {
42
43//#pragma pack(1)
44
45///////////////////////////////////NAL Unit prefix/headers///////////////////////////////////
46
47/* NAL Unix Header in AVC, refer to Page 56 in JVT X201wcm */
48typedef struct TagNalUnitHeader{
49 uint8_t uiForbiddenZeroBit;
50 uint8_t uiNalRefIdc;
51 ENalUnitType eNalUnitType;
52 uint8_t uiReservedOneByte; // only padding usage
53}SNalUnitHeader, *PNalUnitHeader;
54
55/* NAL Unit Header in scalable extension syntax, refer to Page 390 in JVT X201wcm */
56typedef struct TagNalUnitHeaderExt{
57 SNalUnitHeader sNalUnitHeader;
58
59// uint8_t reserved_one_bit;
60 bool_t bIdrFlag;
61 uint8_t uiPriorityId;
62 int8_t iNoInterLayerPredFlag; // change as int8_t to support 3 values probably in encoder
63 uint8_t uiDependencyId;
64
65 uint8_t uiQualityId;
66 uint8_t uiTemporalId;
67 bool_t bUseRefBasePicFlag;
68 bool_t bDiscardableFlag;
69
70 bool_t bOutputFlag;
71 uint8_t uiReservedThree2Bits;
72 // Derived variable(s)
73 uint8_t uiLayerDqId;
74 bool_t bNalExtFlag;
75}SNalUnitHeaderExt, *PNalUnitHeaderExt;
76
77/* Prefix NAL Unix syntax, refer to Page 392 in JVT X201wcm */
78typedef struct TagPrefixNalUnit{
79 SRefBasePicMarking sRefPicBaseMarking;
80 bool_t bStoreRefBasePicFlag;
81 bool_t bPrefixNalUnitAdditionalExtFlag;
82 bool_t bPrefixNalUnitExtFlag;
83}SPrefixNalUnit, *PPrefixNalUnit;
84
85//#pragma pack()
86
87} // namespace WelsDec
88
89#endif//WELS_NAL_UNIT_PREFIX_H__
codec/decoder/core/inc/nalu.h+79−0
@@ -0,0 +1,79 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33//nalu.h: NAL Unit definition
34#ifndef WELS_NAL_UNIT_H__
35#define WELS_NAL_UNIT_H__
36
37#include "typedefs.h"
38#include "wels_common_basis.h"
39#include "nal_prefix.h"
40#include "bit_stream.h"
41
42namespace WelsDec {
43
44///////////////////////////////////NAL UNIT level///////////////////////////////////
45
46/* NAL Unit Structure */
47typedef struct TagNalUnit{
48 SNalUnitHeaderExt sNalHeaderExt;
49
50 union{
51 struct SVclNal{
52 SSliceHeaderExt sSliceHeaderExt;
53 SBitStringAux sSliceBitsRead;
54 uint8_t *pNalPos; // save the address of slice nal for GPU function
55 int32_t iNalLength; // save the nal length for GPU function
56 bool_t bSliceHeaderExtFlag;
57 } sVclNal;
58 SPrefixNalUnit sPrefixNal;
59 } sNalData;
60
61}SNalUnit, *PNalUnit;
62
63///////////////////////////////////ACCESS Unit level///////////////////////////////////
64
65/* Access Unit structure */
66typedef struct TagAccessUnits{
67 PNalUnit *pNalUnitsList; // list of NAL Units pointer in this AU
68 uint32_t uiAvailUnitsNum; // Number of NAL Units available in each AU list based current bitstream,
69 uint32_t uiActualUnitsNum; // actual number of NAL units belong to current au
70 // While available number exceeds count size below, need realloc extra NAL Units for list space.
71 uint32_t uiCountUnitsNum; // Count size number of malloced NAL Units in each AU list
72 uint32_t uiStartPos;
73 uint32_t uiEndPos;
74 bool_t bCompletedAuFlag; // Indicate whether it is a completed AU
75}SAccessUnit, *PAccessUnit;
76
77} // namespace WelsDec
78
79#endif//WELS_NAL_UNIT_H__
codec/decoder/core/inc/parameter_sets.h+173−0
@@ -0,0 +1,173 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33#ifndef WELS_PARAMETER_SETS_H__
34#define WELS_PARAMETER_SETS_H__
35
36#include "typedefs.h"
37#include "wels_const.h"
38#include "wels_common_basis.h"
39
40namespace WelsDec {
41
42//#pragma pack(1)
43
44/* Sequence Parameter Set, refer to Page 57 in JVT X201wcm */
45typedef struct TagSps{
46 int32_t iSpsId;
47 uint32_t iMbWidth;
48 uint32_t iMbHeight;
49 uint32_t uiTotalMbCount; //used in decode_slice_data()
50
51 uint32_t uiLog2MaxFrameNum;
52 uint32_t uiPocType;
53 /* POC type 0 */
54 int32_t iLog2MaxPocLsb;
55 /* POC type 1 */
56 int32_t iOffsetForNonRefPic;
57
58 int32_t iOffsetForTopToBottomField;
59 int32_t iNumRefFramesInPocCycle;
60 int8_t iOffsetForRefFrame[256];
61 int32_t iNumRefFrames;
62
63 SPosOffset sFrameCrop;
64
65 ProfileIdc uiProfileIdc;
66 uint8_t uiLevelIdc;
67 uint8_t uiChromaFormatIdc;
68 uint8_t uiChromaArrayType;
69
70 uint8_t uiBitDepthLuma;
71 uint8_t uiBitDepthChroma;
72 /* TO BE CONTINUE: POC type 1 */
73 bool_t bDeltaPicOrderAlwaysZeroFlag;
74 bool_t bGapsInFrameNumValueAllowedFlag;
75
76 bool_t bFrameMbsOnlyFlag;
77 bool_t bMbaffFlag; // MB Adapative Frame Field
78 bool_t bDirect8x8InferenceFlag;
79 bool_t bFrameCroppingFlag;
80
81 bool_t bVuiParamPresentFlag;
82// bool_t bTimingInfoPresentFlag;
83// bool_t bFixedFrameRateFlag;
84 bool_t bConstraintSet0Flag;
85 bool_t bConstraintSet1Flag;
86 bool_t bConstraintSet2Flag;
87 bool_t bConstraintSet3Flag;
88 bool_t bSeparateColorPlaneFlag;
89 bool_t bQpPrimeYZeroTransfBypassFlag;
90 bool_t bSeqScalingMatrixPresentFlag;
91 bool_t bSeqScalingListPresentFlag[12];
92}SSps, *PSps;
93
94
95/* Sequence Parameter Set extension syntax, refer to Page 58 in JVT X201wcm */
96//typedef struct TagSpsExt{
97// uint32_t iSpsId;
98// uint32_t uiAuxFormatIdc;
99// int32_t iAlphaOpaqueValue;
100// int32_t iAlphaTransparentValue;
101
102// uint8_t uiBitDepthAux;
103// bool_t bAlphaIncrFlag;
104// bool_t bAdditionalExtFlag;
105//}SSpsExt, *PSpsExt;
106
107/* Sequence Parameter Set extension syntax, refer to Page 391 in JVT X201wcm */
108typedef struct TagSpsSvcExt{
109 SPosOffset sSeqScaledRefLayer;
110
111 uint8_t uiExtendedSpatialScalability; // ESS
112 uint8_t uiChromaPhaseXPlus1Flag;
113 uint8_t uiChromaPhaseYPlus1;
114 uint8_t uiSeqRefLayerChromaPhaseXPlus1Flag;
115 uint8_t uiSeqRefLayerChromaPhaseYPlus1;
116 bool_t bInterLayerDeblockingFilterCtrlPresentFlag;
117 bool_t bSeqTCoeffLevelPredFlag;
118 bool_t bAdaptiveTCoeffLevelPredFlag;
119 bool_t bSliceHeaderRestrictionFlag;
120}SSpsSvcExt, *PSpsSvcExt;
121
122/* Subset sequence parameter set syntax, refer to Page 391 in JVT X201wcm */
123typedef struct TagSubsetSps{
124 SSps sSps;
125 SSpsSvcExt sSpsSvcExt;
126 bool_t bSvcVuiParamPresentFlag;
127 bool_t bAdditionalExtension2Flag;
128 bool_t bAdditionalExtension2DataFlag;
129}SSubsetSps, *PSubsetSps;
130
131/* Picture parameter set syntax, refer to Page 59 in JVT X201wcm */
132typedef struct TagPps{
133 int32_t iSpsId;
134 int32_t iPpsId;
135
136 uint32_t uiNumSliceGroups;
137 uint32_t uiSliceGroupMapType;
138 /* slice_group_map_type = 0 */
139 uint32_t uiRunLength[MAX_SLICEGROUP_IDS];
140 /* slice_group_map_type = 2 */
141 uint32_t uiTopLeft[MAX_SLICEGROUP_IDS];
142 uint32_t uiBottomRight[MAX_SLICEGROUP_IDS];
143 /* slice_group_map_type = 3, 4 or 5 */
144 uint32_t uiSliceGroupChangeRate;
145 /* slice_group_map_type = 6 */
146 uint32_t uiPicSizeInMapUnits;
147 uint32_t uiSliceGroupId[MAX_SLICEGROUP_IDS];
148
149 uint32_t uiNumRefIdxL0Active;
150 uint32_t uiNumRefIdxL1Active;
151
152 int32_t iPicInitQp;
153 int32_t iPicInitQs;
154 int32_t iChromaQpIndexOffset;
155
156 bool_t bEntropyCodingModeFlag;
157 bool_t bPicOrderPresentFlag;
158 /* slice_group_map_type = 3, 4 or 5 */
159 bool_t bSliceGroupChangeDirectionFlag;
160 bool_t bDeblockingFilterControlPresentFlag;
161
162 bool_t bConstainedIntraPredFlag;
163 bool_t bRedundantPicCntPresentFlag;
164 bool_t bWeightedPredFlag;
165 uint8_t uiWeightedBipredIdc;
166
167} SPps, *PPps;
168
169//#pragma pack()
170
171} // namespace WelsDec
172
173#endif //WELS_PARAMETER_SETS_H__
codec/decoder/core/inc/parse_mb_syn_cavlc.h+213−0
@@ -0,0 +1,213 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file parse_mb_syn_cavlc.h
33 *
34 * \brief Parsing all syntax elements of mb and decoding residual with cavlc
35 *
36 * \date 03/17/2009 Created
37 *
38 *************************************************************************************
39 */
40
41
42#ifndef WELS_PARSE_MB_SYN_CAVLC_H__
43#define WELS_PARSE_MB_SYN_CAVLC_H__
44
45#include "wels_common_basis.h"
46#include "decoder_context.h"
47#include "dec_frame.h"
48#include "slice.h"
49
50namespace WelsDec {
51
52#define I16_LUMA_DC 1
53#define I16_LUMA_AC 2
54#define LUMA_DC_AC 3
55#define CHROMA_DC 4
56#define CHROMA_AC 5
57
58typedef struct TagReadBitsCache
59{
60 uint32_t uiCache32Bit;
61 uint8_t uiRemainBits;
62 uint8_t *pBuf;
63}SReadBitsCache;
64
65#define SHIFT_BUFFER(pBitsCache) { pBitsCache->pBuf+=2; pBitsCache->uiRemainBits += 16; pBitsCache->uiCache32Bit |= (((pBitsCache->pBuf[2] << 8) | pBitsCache->pBuf[3]) << (32 - pBitsCache->uiRemainBits)); }
66#define POP_BUFFER(pBitsCache, iCount) { pBitsCache->uiCache32Bit <<= iCount; pBitsCache->uiRemainBits -= iCount; }
67
68static const uint8_t g_kuiZigzagScan[16]={//4*4block residual zig-zag scan order
69 0, 1, 4, 8,
70 5, 2, 3, 6,
71 9, 12, 13, 10,
72 7, 11, 14, 15,
73};
74
75
76typedef struct TagI16PredInfo{
77 int8_t iPredMode;
78 int8_t iLeftAvail;
79 int8_t iTopAvail;
80 int8_t iLeftTopAvail;
81} SI16PredInfo;
82static const SI16PredInfo g_ksI16PredInfo[4] = {
83 {I16_PRED_V, 0, 1, 0},
84 {I16_PRED_H, 1, 0, 0},
85 { 0, 0, 0, 0},
86 {I16_PRED_P, 1, 1, 1},
87};
88
89static const SI16PredInfo g_ksChromaPredInfo[4] = {
90 { 0, 0, 0, 0},
91 {C_PRED_H, 1, 0, 0},
92 {C_PRED_V, 0, 1, 0},
93 {C_PRED_P, 1, 1, 1},
94};
95
96
97typedef struct TagI4PredInfo {
98 int8_t iPredMode;
99 int8_t iLeftAvail;
100 int8_t iTopAvail;
101 int8_t iLeftTopAvail;
102// int8_t right_top_avail; //when right_top unavailable but top avail, we can pad the right-top with the rightmost pixel of top
103} SI4PredInfo;
104static const SI4PredInfo g_ksI4PredInfo[9] = {
105 { I4_PRED_V, 0, 1, 0},
106 { I4_PRED_H, 1, 0, 0},
107 { 0, 0, 0, 0},
108 {I4_PRED_DDL, 0, 1, 0},
109 {I4_PRED_DDR, 1, 1, 1},
110 { I4_PRED_VR, 1, 1, 1},
111 { I4_PRED_HD, 1, 1, 1},
112 { I4_PRED_VL, 0, 1, 0},
113 { I4_PRED_HU, 1, 0, 0},
114};
115
116static const uint8_t g_kuiI16CbpTable[6] = {0, 16, 32, 15, 31, 47}; //reference to JM
117
118
119typedef struct TagPartMbInfo{
120 MbType iType;
121 int8_t iPartCount; //P_16*16, P_16*8, P_8*16, P_8*8 based on 8*8 block; P_8*4, P_4*8, P_4*4 based on 4*4 block
122 int8_t iPartWidth; //based on 4*4 block
123} SPartMbInfo;
124static const SPartMbInfo g_ksInterMbTypeInfo[5]={
125{MB_TYPE_16x16, 1, 4},
126{MB_TYPE_16x8, 2, 4},
127{MB_TYPE_8x16, 2, 2},
128{MB_TYPE_8x8, 4, 4},
129{MB_TYPE_8x8_REF0, 4, 4}, //ref0--ref_idx not present in bit-stream and default as 0
130};
131static const SPartMbInfo g_ksInterSubMbTypeInfo[4]={
132{SUB_MB_TYPE_8x8, 1, 2},
133{SUB_MB_TYPE_8x4, 2, 2},
134{SUB_MB_TYPE_4x8, 2, 1},
135{SUB_MB_TYPE_4x4, 4, 1},
136};
137
138void_t GetNeighborAvailMbType (PNeighAvail pNeighAvail, PDqLayer pCurLayer);
139void_t WelsFillCacheNonZeroCount (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, PDqLayer pCurLayer);
140void_t WelsFillCacheConstrain0Intra4x4(PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, int8_t* pIntraPredMode, PDqLayer pCurLayer);
141void_t WelsFillCacheConstrain1Intra4x4(PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, int8_t* pIntraPredMode, PDqLayer pCurLayer);
142void_t WelsFillCacheInter (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount,
143 int16_t iMvArray[LIST_A][30][MV_A], int8_t iRefIdxArray[LIST_A][30], PDqLayer pCurLayer);
144
145void_t PredPSkipMvFromNeighbor (PDqLayer pCurLayer, int16_t iMvp[2]);
146
147/*!
148 * \brief check iPredMode for intra16x16 eligible or not
149 * \param input : current iPredMode
150 * \param output: 0 indicating decoding correctly; -1 means error occurence
151 */
152 int32_t CheckIntra16x16PredMode(uint8_t uiSampleAvail, int8_t* pMode);
153
154/*!
155 * \brief check iPredMode for intra4x4 eligible or not
156 * \param input : current iPredMode
157 * \param output: 0 indicating decoding correctly; -1 means error occurence
158 */
159 int32_t CheckIntra4x4PredMode(int32_t* pSampleAvail, int8_t* pMode, int32_t iIndex);
160
161/*!
162 * \brief check iPredMode for chroma eligible or not
163 * \param input : current iPredMode
164 * \param output: 0 indicating decoding correctly; -1 means error occurence
165 */
166 int32_t CheckIntraChromaPredMode(uint8_t uiSampleAvail, int8_t* pMode);
167
168/*!
169 * \brief predict the mode of intra4x4
170 * \param input : current intra4x4 block index
171 * \param output: mode index
172 */
173int32_t PredIntra4x4Mode(int8_t* pIntraPredMode, int32_t iIdx4);
174
175
176void_t BsStartCavlc( PBitStringAux pBs );
177void_t BsEndCavlc( PBitStringAux pBs );
178
179int32_t WelsResidualBlockCavlc( SVlcTable* pVlcTable,
180 uint8_t* pNonZeroCountCache,
181 PBitStringAux pBs,
182 /*int16_t* coeff_level,*/
183 int32_t iIndex,
184 int32_t iMaxNumCoeff,
185 const uint8_t *kpZigzagTable,
186 int32_t iResidualProperty,
187 /*short *tCoeffLevel,*/
188 int16_t *pTCoeff,
189 int32_t iMbMode,
190 uint8_t uiQp,
191 PWelsDecoderContext pCtx);
192
193/*!
194 * \brief parsing intra mode
195 * \param input : current mb, bit-stream
196 * \param output: 0 indicating decoding correctly; -1 means error
197 */
198int32_t ParseIntra4x4ModeConstrain0 (PNeighAvail pNeighAvail, int8_t* pIntraPredMode, PBitStringAux pBs, PDqLayer pCurDqLayer);
199int32_t ParseIntra4x4ModeConstrain1 (PNeighAvail pNeighAvail, int8_t* pIntraPredMode, PBitStringAux pBs, PDqLayer pCurDqLayer);
200int32_t ParseIntra16x16ModeConstrain0(PNeighAvail pNeighAvail, PBitStringAux pBs, PDqLayer pCurDqLayer);
201int32_t ParseIntra16x16ModeConstrain1(PNeighAvail pNeighAvail, PBitStringAux pBs, PDqLayer pCurDqLayer);
202
203/*!
204 * \brief parsing inter info (including ref_index and mvd)
205 * \param input : decoding context, current mb, bit-stream
206 * \param output: 0 indicating decoding correctly; -1 means error
207 */
208int32_t ParseInterInfo(PWelsDecoderContext pCtx, int16_t iMvArray[LIST_A][30][MV_A], int8_t iRefIdxArray[LIST_A][30], PBitStringAux pBs);
209
210//#pragma pack()
211
212} // namespace WelsDec
213#endif//WELS_PARSE_MB_SYN_CAVLC_H__
codec/decoder/core/inc/pic_queue.h+63−0
@@ -0,0 +1,63 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33//pic_queue.h
34#ifndef WELS_PICTURE_QUEUE_H__
35#define WELS_PICTURE_QUEUE_H__
36
37
38#include "picture.h"
39
40//#pragma pack(1)
41
42namespace WelsDec {
43
44#define PICTURE_RESOLUTION_ALIGNMENT 32
45
46
47typedef struct TagPicBuff{
48 PPicture* ppPic;
49 int32_t iCapacity; // capacity size of queue
50 int32_t iCurrentIdx;
51}SPicBuff, *PPicBuff;
52
53/*
54 * Interfaces
55 */
56
57PPicture PrefetchPic( PPicBuff pPicBuff ); // To get current node applicable
58
59} // namespace WelsDec
60
61//#pragma pack()
62
63#endif//WELS_PICTURE_QUEUE_H__
codec/decoder/core/inc/picture.h+87−0
@@ -0,0 +1,87 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33//picture.h - reconstruction picture/ reference picture/ residual picture are declared here
34#ifndef WELS_PICTURE_H__
35#define WELS_PICTURE_H__
36
37#include "typedefs.h"
38
39//#pragma pack(1)
40
41namespace WelsDec {
42
43/*
44 * Reconstructed Picture definition
45 * It is used to express reference picture, also consequent reconstruction picture for output
46 */
47typedef struct TagPicture{
48 /************************************payload data*********************************/
49 uint8_t *pBuffer[4]; // pointer to the first allocated byte, basical offset of buffer, dimension:
50 uint8_t *pData[4]; // pointer to picture planes respectively
51 int32_t iLinesize[4];// linesize of picture planes respectively used currently
52 int32_t iPlanes; // How many planes are introduced due to color space format?
53 // picture information
54
55 /*******************************from other standard syntax****************************/
56 /*from sps*/
57 int32_t iWidthInPixel; // picture width in pixel
58 int32_t iHeightInPixel;// picture height in pixel
59 /*from slice header*/
60 int32_t iFramePoc; // frame POC
61
62 /*******************************sef_definition for misc use****************************/
63 bool_t bUsedAsRef; //for ref pic management
64 bool_t bIsLongRef; // long term reference frame flag //for ref pic management
65 uint8_t uiRefCount;
66 bool_t bAvailableFlag; // indicate whether it is available in this picture memory block.
67
68 /*******************************for future use****************************/
69 uint8_t uiTemporalId;
70 uint8_t uiSpatialId;
71 uint8_t uiQualityId;
72 bool_t bRefBaseFlag;
73
74 int32_t iFrameNum; // frame number //for ref pic management
75 int32_t iLongTermFrameIdx; //id for long term ref pic
76
77 int32_t iTotalNumMbRec; //show how many MB constructed
78
79 int32_t iSpsId; //against mosaic caused by cross-IDR interval reference.
80 int32_t iPpsId;
81}SPicture, *PPicture; // "Picture" declaration is comflict with Mac system
82
83} // namespace WelsDec
84
85//#pragma pack()
86
87#endif//WELS_PICTURE_H__
codec/decoder/core/inc/rec_mb.h+76−0
@@ -0,0 +1,76 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file rec_mb.h
33 *
34 * \brief interfaces for all macroblock decoding process after mb syntax parsing and residual decoding with cavlc.
35 *
36 * \date 3/4/2009 Created
37 *
38 *************************************************************************************
39 */
40
41#ifndef WELS_REC_MB_H__
42#define WELS_REC_MB_H__
43
44#include "typedefs.h"
45#include "wels_common_basis.h"
46#include "error_code.h"
47
48#include "decoder_context.h"
49
50//#pragma pack(1)
51
52namespace WelsDec {
53
54void_t WelsFillRecNeededMbInfo(PWelsDecoderContext pCtx, bool_t bOutput, PDqLayer pCurLayer);
55
56int32_t RecI4x4Mb (int32_t iMBXY, PWelsDecoderContext pCtx, int16_t *pScoeffLevel, PDqLayer pDqLayer);
57
58int32_t RecI4x4Luma (int32_t iMBXY, PWelsDecoderContext pCtx, int16_t *pScoeffLevel, PDqLayer pDqLayer);
59
60int32_t RecI4x4Chroma(int32_t iMBXY, PWelsDecoderContext pCtx, int16_t *pScoeffLevel, PDqLayer pDqLayer);
61
62int32_t RecI16x16Mb (int32_t iMBXY, PWelsDecoderContext pCtx, int16_t *pScoeffLevel, PDqLayer pDqLayer);
63
64int32_t RecChroma (int32_t iMBXY, PWelsDecoderContext pCtx, int16_t *pScoeffLevel, PDqLayer pDqLayer);
65
66void_t GetInterPred (uint8_t *pPredY, uint8_t *pPredCb, uint8_t *pPredCr, PWelsDecoderContext pCtx);
67
68void_t FillBufForMc(uint8_t *pBuf, int32_t iBufStride, uint8_t *pSrc, int32_t iSrcStride, int32_t iSrcOffset,
69 int32_t iBlockWidth, int32_t iBlockHeight, int32_t iSrcX, int32_t iSrcY, int32_t iPicWidth, int32_t iPicHeight);
70
71} // namespace WelsDec
72
73//#pragma pack()
74
75#endif //WELS_REC_MB_H__
76
codec/decoder/core/inc/slice.h+207−0
@@ -0,0 +1,207 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33//wels_slice.h
34#ifndef WELS_SLICE_H__
35#define WELS_SLICE_H__
36
37#include "typedefs.h"
38#include "wels_const.h"
39#include "wels_common_basis.h"
40#include "picture.h"
41#include "parameter_sets.h"
42
43//#pragma pack(1)
44
45namespace WelsDec {
46
47/*
48 * Reference picture list reordering syntax, refer to page 64 in JVT X201wcm
49 */
50typedef struct TagRefPicListReorderSyntax {
51 struct {
52 uint32_t uiAbsDiffPicNumMinus1;
53 uint16_t uiLongTermPicNum;
54 uint16_t uiReorderingOfPicNumsIdc;
55 } sReorderingSyn[LIST_A][MAX_REF_PIC_COUNT];
56 bool_t bRefPicListReorderingFlag[LIST_A];
57}SRefPicListReorderSyn, *PRefPicListReorderSyn;
58
59/*
60 * Prediction weight table syntax, refer to page 65 in JVT X201wcm
61 */
62typedef struct TagPredWeightTabSyntax{
63 uint32_t uiLumaLog2WeightDenom;
64 uint32_t uiChromaLog2WeightDenom;
65 struct{
66 int32_t iLumaWeight[MAX_REF_PIC_COUNT];
67 int32_t iLumaOffset[MAX_REF_PIC_COUNT];
68 int32_t iChromaWeight[MAX_REF_PIC_COUNT][2];
69 int32_t iChromaOffset[MAX_REF_PIC_COUNT][2];
70 bool_t bLumaWeightFlag;
71 bool_t bChromaWeightFlag;
72 }sPredList[LIST_A];
73}SPredWeightTabSyn;
74
75/* Decoded reference picture marking syntax, refer to Page 66 in JVT X201wcm */
76typedef struct TagRefPicMarking {
77 struct {
78 uint32_t uiMmcoType;
79 int32_t iShortFrameNum;
80 int32_t iDiffOfPicNum;
81 uint32_t uiLongTermPicNum;
82 int32_t iLongTermFrameIdx;
83 int32_t iMaxLongTermFrameIdx;
84 } sMmcoRef[MAX_MMCO_COUNT];
85
86 bool_t bNoOutputOfPriorPicsFlag;
87 bool_t bLongTermRefFlag;
88 bool_t bAdaptiveRefPicMarkingModeFlag;
89} SRefPicMarking, *PRefPicMarking;
90
91/* Decode reference base picture marking syntax in Page 396 of JVT X201wcm */
92typedef struct TagRefBasePicMarkingSyn {
93 struct {
94 uint32_t uiMmcoType;
95 int32_t iShortFrameNum;
96 uint32_t uiDiffOfPicNums;
97 uint32_t uiLongTermPicNum; //should uint32_t, cover larger range of iFrameNum.
98 } mmco_base[MAX_MMCO_COUNT]; // MAX_REF_PIC for reference picture based on frame
99
100 bool_t bAdaptiveRefBasePicMarkingModeFlag;
101} SRefBasePicMarking, *PRefBasePicMarking;
102
103/* Header of slice syntax elements, refer to Page 63 in JVT X201wcm */
104typedef struct TagSliceHeaders{
105 /*****************************slice header syntax and generated****************************/
106 int32_t iFirstMbInSlice;
107 int32_t iFrameNum;
108 int32_t iPicOrderCntLsb;
109 int32_t iDeltaPicOrderCntBottom;
110 int32_t iDeltaPicOrderCnt[2];
111 int32_t iRedundantPicCnt;
112 int32_t uiRefCount[LIST_A];
113 int32_t iSliceQpDelta; //no use for iSliceQp is used directly
114 int32_t iSliceQp;
115 int32_t iSliceQsDelta; // For SP/SI slices
116 uint32_t uiDisableDeblockingFilterIdc;
117 int32_t iSliceAlphaC0Offset;
118 int32_t iSliceBetaOffset;
119 int32_t iSliceGroupChangeCycle;
120
121 PSps pSps;
122 PPps pPps;
123 int32_t iSpsId;
124 int32_t iPpsId;
125
126 /*********************got from other layer for efficency if possible*********************/
127 SRefPicListReorderSyn pRefPicListReordering; // Reference picture list reordering syntaxs
128 SPredWeightTabSyn sPredWeightTable;
129 int32_t iCabacInitIdc;
130 int32_t iMbWidth; //from?
131 int32_t iMbHeight; //from?
132 SRefPicMarking sRefMarking; // Decoded reference picture marking syntaxs
133
134 uint16_t uiIdrPicId;
135 ESliceType eSliceType;
136 bool_t bNumRefIdxActiveOverrideFlag;
137 bool_t bFieldPicFlag; //not supported in base profile
138 bool_t bBottomFiledFlag; //not supported in base profile
139 uint8_t uiPadding1Byte;
140 bool_t bSpForSwitchFlag; // For SP/SI slices
141 int16_t iPadding2Bytes;
142}SSliceHeader, *PSliceHeader;
143
144
145/* Slice header in scalable extension syntax, refer to Page 394 in JVT X201wcm */
146typedef struct TagSliceHeaderExt{
147 SSliceHeader sSliceHeader;
148 PSubsetSps pSubsetSps;
149
150 uint32_t uiNumMbsInSlice;
151 uint32_t uiDisableInterLayerDeblockingFilterIdc;
152 int32_t iInterLayerSliceAlphaC0Offset;
153 int32_t iInterLayerSliceBetaOffset;
154
155 //SPosOffset sScaledRefLayer;
156 int32_t iScaledRefLayerPicWidthInSampleLuma;
157 int32_t iScaledRefLayerPicHeightInSampleLuma;
158
159 SRefBasePicMarking sRefBasePicMarking;
160 bool_t bBasePredWeightTableFlag;
161 bool_t bStoreRefBasePicFlag;
162 bool_t bConstrainedIntraResamplingFlag;
163 bool_t bSliceSkipFlag;
164
165 bool_t bAdaptiveBaseModeFlag;
166 bool_t bDefaultBaseModeFlag;
167 bool_t bAdaptiveMotionPredFlag;
168 bool_t bDefaultMotionPredFlag;
169 bool_t bAdaptiveResidualPredFlag;
170 bool_t bDefaultResidualPredFlag;
171 bool_t bTCoeffLevelPredFlag;
172 uint8_t uiRefLayerChromaPhaseXPlus1Flag;
173
174 uint8_t uiRefLayerChromaPhaseYPlus1;
175 uint8_t uiRefLayerDqId;
176 uint8_t uiScanIdxStart;
177 uint8_t uiScanIdxEnd;
178}SSliceHeaderExt, *PSliceHeaderExt;
179
180
181typedef struct TagSlice{
182 /*******************************slice_header****************************/
183 SSliceHeaderExt sSliceHeaderExt;
184
185 /*******************************use for future****************************/
186 // for Macroblock coding within slice
187 int32_t iLastMbQp; // stored qp for last mb coded, maybe more efficient for mb skip detection etc.
188
189 /*******************************slice_data****************************/
190 /*slice_data_ext()*/
191 int32_t iMbSkipRun;
192 int32_t iTotalMbInCurSlice; //record the total number of MB in current slice.
193
194 /*slice_data_ext() generate*/
195
196 /*******************************misc use****************************/
197 bool_t bSliceHeaderExtFlag; // Indicate which slice header is used, avc or ext?
198 /*************got from other layer for effiency if possible***************/
199 /*from lower layer: slice header*/
200 uint8_t eSliceType;
201 uint8_t uiPadding[2];
202}SSlice, *PSlice;
203
204} // namespace WelsDec
205
206//#pragma pack()
207#endif//WELS_SLICE_H__
codec/decoder/core/inc/typedefs.h+91−0
@@ -0,0 +1,91 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33// typedef.h
34#ifndef WELS_TYPE_DEFINES_H__
35#define WELS_TYPE_DEFINES_H__
36
37#include <limits.h>
38
39////////////////////////////////////////////////////////////////////////////
40// NOTICE : ALL internal implement MUST use the data type defined as below
41// ONLY except with the interface file !!!!!
42////////////////////////////////////////////////////////////////////////////
43
44#ifndef _MSC_VER
45
46#include <stdint.h>
47
48#else
49
50// FIXME: all singed type should be declared explicit, for example, int8_t should be declared as signed char.
51typedef signed char int8_t ;
52typedef unsigned char uint8_t ;
53typedef short int16_t ;
54typedef unsigned short uint16_t;
55typedef int int32_t ;
56typedef unsigned int uint32_t;
57typedef __int64 int64_t ;
58typedef unsigned __int64 uint64_t;
59
60#endif // _MSC_VER defined
61
62// FIXME: all string type should be declared explicit as char.
63typedef char str_t;
64typedef float real32_t;
65
66#ifdef PESN
67#undef PESN
68#endif//PESN
69#define PESN (0.000001f) // (1e-6) // desired float precision
70
71#ifndef NULL
72#define NULL 0
73#endif
74
75typedef bool bool_t;
76typedef int32_t BOOL_T;
77
78#ifndef FALSE
79#define FALSE ((int32_t)0)
80#endif//FALSE
81
82#ifndef TRUE
83#define TRUE ((int32_t)1)
84#endif//TRUE
85
86#ifndef void_t
87#define void_t void
88#endif
89
90#endif //WELS_TYPE_DEFINES_H__
91
codec/decoder/core/inc/utils.h+99−0
@@ -0,0 +1,99 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file utils.h
33 *
34 * \brief Tool kits for decoder
35 * ( malloc, realloc, free, log output and PSNR calculation and so on )
36 *
37 * \date 03/10/2009 Created
38 *
39 *************************************************************************************
40 */
41#ifndef WELS_UTILS_H__
42#define WELS_UTILS_H__
43
44#include <stdio.h>
45#include <stdlib.h>
46#include <stdarg.h>
47#include "typedefs.h"
48
49namespace WelsDec {
50
51#ifdef __cplusplus
52extern "C" {
53#endif//__cplusplus
54
55// cache line size
56extern uint32_t g_uiCacheLineSize;
57
58/*
59 * Function pointer declaration for various tool sets
60 */
61// wels log output
62typedef void_t (*PWelsLogCallbackFunc)(void_t *pPtr, const int32_t kiLevel, const char *kpFmt, va_list pArgv);
63
64extern PWelsLogCallbackFunc g_pLog;
65
66#ifdef __GNUC__
67extern void_t WelsLog(void_t *pPtr, int32_t iLevel, const char *kpFmt, ...) __attribute__ ((__format__ (__printf__, 3, 4)));
68#else
69extern void_t WelsLog(void_t *pPtr, int32_t iLevel, const char *kpFmt, ...);
70#endif
71
72#define DECODER_MODE_NAME(a) ((a == SW_MODE)?"SW_MODE":((a == GPU_MODE)?"GPU_MODE":((a == AUTO_MODE)?"AUTO_MODE":"SWITCH_MODE")))
73#define OUTPUT_PROPERTY_NAME(a) ((a == 0)?"system_memory":"video_memory")
74#define BUFFER_STATUS_NAME(a) ((a == 0)?"unvalid":"valid")
75
76
77/*
78 * Log output routines
79 */
80
81typedef int32_t WelsLogLevel;
82enum{
83 WELS_LOG_QUIET = 0x00, // Quiet mode
84 WELS_LOG_ERROR = 1 << 0, // Error log level
85 WELS_LOG_WARNING = 1 << 1, // Warning log level
86 WELS_LOG_INFO = 1 << 2, // Information log level
87 WELS_LOG_DEBUG = 1 << 3, // Debug log level
88 WELS_LOG_RESV = 1 << 4, // Resversed log level
89 WELS_LOG_LEVEL_COUNT= 5,
90 WELS_LOG_DEFAULT = WELS_LOG_ERROR | WELS_LOG_WARNING | WELS_LOG_INFO | WELS_LOG_DEBUG // Default log level in Wels codec
91};
92
93#ifdef __cplusplus
94}
95#endif//__cplusplus
96
97} // namespace WelsDec
98
99#endif//WELS_UTILS_H__
codec/decoder/core/inc/vlc_decoder.h+176−0
@@ -0,0 +1,176 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33#ifndef WELS_VLC_DECODER_H__
34#define WELS_VLC_DECODER_H__
35
36#include "bit_stream.h"
37#include "dec_golomb.h"
38
39namespace WelsDec {
40
41typedef struct TagVlcTable
42{
43 const uint8_t (*kpCoeffTokenVlcTable[4][8])[2];
44 const uint8_t (*kpChromaCoeffTokenVlcTable)[2];
45 const uint8_t (*kpZeroTable[7])[2];
46 const uint8_t (*kpTotalZerosTable[2][15])[2];
47}SVlcTable;
48
49// for data sharing cross modules and try to reduce size of binary generated
50extern const uint8_t g_kuiVlcChromaTable[256][2];
51extern const uint8_t g_kuiVlcTable_0[256][2];
52extern const uint8_t g_kuiVlcTable_0_0[256][2];
53extern const uint8_t g_kuiVlcTable_0_1[4][2];
54extern const uint8_t g_kuiVlcTable_0_2[2][2];
55extern const uint8_t g_kuiVlcTable_0_3[2][2];
56extern const uint8_t g_kuiVlcTable_1[256][2];
57extern const uint8_t g_kuiVlcTable_1_0[64][2];
58extern const uint8_t g_kuiVlcTable_1_1[8][2];
59extern const uint8_t g_kuiVlcTable_1_2[2][2];
60extern const uint8_t g_kuiVlcTable_1_3[2][2];
61extern const uint8_t g_kuiVlcTable_2[256][2];
62extern const uint8_t g_kuiVlcTable_2_0[4][2];
63extern const uint8_t g_kuiVlcTable_2_1[4][2];
64extern const uint8_t g_kuiVlcTable_2_2[4][2];
65extern const uint8_t g_kuiVlcTable_2_3[4][2];
66extern const uint8_t g_kuiVlcTable_2_4[2][2];
67extern const uint8_t g_kuiVlcTable_2_5[2][2];
68extern const uint8_t g_kuiVlcTable_2_6[2][2];
69extern const uint8_t g_kuiVlcTable_2_7[2][2];
70extern const uint8_t g_kuiVlcTable_3[64][2];
71extern const uint8_t g_kuiVlcTableNeedMoreBitsThread[3];
72extern const uint8_t g_kuiVlcTableMoreBitsCount0[4];
73extern const uint8_t g_kuiVlcTableMoreBitsCount1[4];
74extern const uint8_t g_kuiVlcTableMoreBitsCount2[8];
75extern const uint8_t g_kuiNcMapTable[17];
76extern const uint8_t g_kuiVlcTrailingOneTotalCoeffTable[62][2];
77extern const uint8_t g_kuiTotalZerosTable0[512][2];
78extern const uint8_t g_kuiTotalZerosTable1[64][2];
79extern const uint8_t g_kuiTotalZerosTable2[64][2];
80extern const uint8_t g_kuiTotalZerosTable3[32][2];
81extern const uint8_t g_kuiTotalZerosTable4[32][2];
82extern const uint8_t g_kuiTotalZerosTable5[64][2];
83extern const uint8_t g_kuiTotalZerosTable6[64][2];
84extern const uint8_t g_kuiTotalZerosTable7[64][2];
85extern const uint8_t g_kuiTotalZerosTable8[64][2];
86extern const uint8_t g_kuiTotalZerosTable9[32][2];
87extern const uint8_t g_kuiTotalZerosTable10[16][2];
88extern const uint8_t g_kuiTotalZerosTable11[16][2];
89extern const uint8_t g_kuiTotalZerosTable12[8][2];
90extern const uint8_t g_kuiTotalZerosTable13[4][2];
91extern const uint8_t g_kuiTotalZerosTable14[2][2];
92extern const uint8_t g_kuiTotalZerosBitNumMap[15];
93extern const uint8_t g_kuiTotalZerosChromaTable0[8][2];
94extern const uint8_t g_kuiTotalZerosChromaTable1[4][2];
95extern const uint8_t g_kuiTotalZerosChromaTable2[2][2];
96extern const uint8_t g_kuiTotalZerosBitNumChromaMap[3];
97extern const uint8_t g_kuiZeroLeftTable0[2][2];
98extern const uint8_t g_kuiZeroLeftTable1[4][2];
99extern const uint8_t g_kuiZeroLeftTable2[4][2];
100extern const uint8_t g_kuiZeroLeftTable3[8][2];
101extern const uint8_t g_kuiZeroLeftTable4[8][2];
102extern const uint8_t g_kuiZeroLeftTable5[8][2];
103extern const uint8_t g_kuiZeroLeftTable6[8][2];
104extern const uint8_t g_kuiZeroLeftBitNumMap[16];
105
106#ifdef WIN32
107//TODO need linux version
108#define WELS_GET_PREFIX_BITS(inval,outval){\
109 __asm xor eax, eax\
110 __asm bsr eax, inval\
111 __asm sub eax, 32\
112 __asm neg eax\
113 __asm mov outval, eax\
114}
115#endif
116
117static inline void_t InitVlcTable(SVlcTable * pVlcTable)
118{
119 pVlcTable->kpChromaCoeffTokenVlcTable = g_kuiVlcChromaTable;
120
121 pVlcTable->kpCoeffTokenVlcTable[0][0] = g_kuiVlcTable_0;
122 pVlcTable->kpCoeffTokenVlcTable[0][1] = g_kuiVlcTable_1;
123 pVlcTable->kpCoeffTokenVlcTable[0][2] = g_kuiVlcTable_2;
124 pVlcTable->kpCoeffTokenVlcTable[0][3] = g_kuiVlcTable_3;
125
126 pVlcTable->kpCoeffTokenVlcTable[1][0] = g_kuiVlcTable_0_0;
127 pVlcTable->kpCoeffTokenVlcTable[1][1] = g_kuiVlcTable_0_1;
128 pVlcTable->kpCoeffTokenVlcTable[1][2] = g_kuiVlcTable_0_2;
129 pVlcTable->kpCoeffTokenVlcTable[1][3] = g_kuiVlcTable_0_3;
130
131 pVlcTable->kpCoeffTokenVlcTable[2][0] = g_kuiVlcTable_1_0;
132 pVlcTable->kpCoeffTokenVlcTable[2][1] = g_kuiVlcTable_1_1;
133 pVlcTable->kpCoeffTokenVlcTable[2][2] = g_kuiVlcTable_1_2;
134 pVlcTable->kpCoeffTokenVlcTable[2][3] = g_kuiVlcTable_1_3;
135
136 pVlcTable->kpCoeffTokenVlcTable[3][0] = g_kuiVlcTable_2_0;
137 pVlcTable->kpCoeffTokenVlcTable[3][1] = g_kuiVlcTable_2_1;
138 pVlcTable->kpCoeffTokenVlcTable[3][2] = g_kuiVlcTable_2_2;
139 pVlcTable->kpCoeffTokenVlcTable[3][3] = g_kuiVlcTable_2_3;
140 pVlcTable->kpCoeffTokenVlcTable[3][4] = g_kuiVlcTable_2_4;
141 pVlcTable->kpCoeffTokenVlcTable[3][5] = g_kuiVlcTable_2_5;
142 pVlcTable->kpCoeffTokenVlcTable[3][6] = g_kuiVlcTable_2_6;
143 pVlcTable->kpCoeffTokenVlcTable[3][7] = g_kuiVlcTable_2_7;
144
145 pVlcTable->kpZeroTable[0] = g_kuiZeroLeftTable0;
146 pVlcTable->kpZeroTable[1] = g_kuiZeroLeftTable1;
147 pVlcTable->kpZeroTable[2] = g_kuiZeroLeftTable2;
148 pVlcTable->kpZeroTable[3] = g_kuiZeroLeftTable3;
149 pVlcTable->kpZeroTable[4] = g_kuiZeroLeftTable4;
150 pVlcTable->kpZeroTable[5] = g_kuiZeroLeftTable5;
151 pVlcTable->kpZeroTable[6] = g_kuiZeroLeftTable6;
152
153 pVlcTable->kpTotalZerosTable[0][0] = g_kuiTotalZerosTable0;
154 pVlcTable->kpTotalZerosTable[0][1] = g_kuiTotalZerosTable1;
155 pVlcTable->kpTotalZerosTable[0][2] = g_kuiTotalZerosTable2;
156 pVlcTable->kpTotalZerosTable[0][3] = g_kuiTotalZerosTable3;
157 pVlcTable->kpTotalZerosTable[0][4] = g_kuiTotalZerosTable4;
158 pVlcTable->kpTotalZerosTable[0][5] = g_kuiTotalZerosTable5;
159 pVlcTable->kpTotalZerosTable[0][6] = g_kuiTotalZerosTable6;
160 pVlcTable->kpTotalZerosTable[0][7] = g_kuiTotalZerosTable7;
161 pVlcTable->kpTotalZerosTable[0][8] = g_kuiTotalZerosTable8;
162 pVlcTable->kpTotalZerosTable[0][9] = g_kuiTotalZerosTable9;
163 pVlcTable->kpTotalZerosTable[0][10] = g_kuiTotalZerosTable10;
164 pVlcTable->kpTotalZerosTable[0][11] = g_kuiTotalZerosTable11;
165 pVlcTable->kpTotalZerosTable[0][12] = g_kuiTotalZerosTable12;
166 pVlcTable->kpTotalZerosTable[0][13] = g_kuiTotalZerosTable13;
167 pVlcTable->kpTotalZerosTable[0][14] = g_kuiTotalZerosTable14;
168 pVlcTable->kpTotalZerosTable[1][0] = g_kuiTotalZerosChromaTable0;
169 pVlcTable->kpTotalZerosTable[1][1] = g_kuiTotalZerosChromaTable1;
170 pVlcTable->kpTotalZerosTable[1][2] = g_kuiTotalZerosChromaTable2;
171
172}
173
174} // namespace WelsDec
175
176#endif//WELS_VLC_DECODER_H__
codec/decoder/core/inc/wels_common_basis.h+298−0
@@ -0,0 +1,298 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33//wels_common_basis.h
34#ifndef WELS_COMMON_BASIS_H__
35#define WELS_COMMON_BASIS_H__
36
37#include "typedefs.h"
38#include "macros.h"
39
40namespace WelsDec {
41
42// for data sharing cross modules and try to reduce size of binary generated
43
44extern const uint8_t g_kuiChromaQp[52];
45
46/*common use table*/
47extern const uint8_t g_kuiScan8[24];
48extern const uint8_t g_kuiLumaDcZigzagScan[16];
49extern const uint8_t g_kuiChromaDcScan[4];
50extern __align16( const uint16_t, g_kuiDequantCoeff[52][8]);
51/* Profile IDC */
52typedef uint8_t ProfileIdc;
53enum{
54 PRO_BASELINE = 66,
55 PRO_MAIN = 77,
56 PRO_EXTENDED = 88,
57 PRO_HIGH = 100,
58 PRO_HIGH10 = 110,
59 PRO_HIGH422 = 122,
60 PRO_HIGH444 = 144,
61 PRO_CAVLC444 = 244,
62
63 PRO_SCALABLE_BASELINE = 83,
64 PRO_SCALABLE_HIGH = 86,
65};
66
67/*
68 * NAL Unit Type (5 Bits)
69 */
70typedef enum TagNalUnitType
71{
72 NAL_UNIT_UNSPEC_0 = 0,
73 NAL_UNIT_CODED_SLICE = 1,
74 NAL_UNIT_CODED_SLICE_DPA = 2,
75 NAL_UNIT_CODED_SLICE_DPB = 3,
76 NAL_UNIT_CODED_SLICE_DPC = 4,
77 NAL_UNIT_CODED_SLICE_IDR = 5,
78 NAL_UNIT_SEI = 6,
79 NAL_UNIT_SPS = 7,
80 NAL_UNIT_PPS = 8,
81 NAL_UNIT_AU_DELIMITER = 9,
82 NAL_UNIT_END_OF_SEQ = 10,
83 NAL_UNIT_END_OF_STR = 11,
84 NAL_UNIT_FILLER_DATA = 12,
85 NAL_UNIT_SPS_EXT = 13,
86 NAL_UNIT_PREFIX = 14,
87 NAL_UNIT_SUBSET_SPS = 15,
88 NAL_UNIT_RESV_16 = 16,
89 NAL_UNIT_RESV_17 = 17,
90 NAL_UNIT_RESV_18 = 18,
91 NAL_UNIT_AUX_CODED_SLICE = 19,
92 NAL_UNIT_CODED_SLICE_EXT = 20,
93 NAL_UNIT_RESV_21 = 21,
94 NAL_UNIT_RESV_22 = 22,
95 NAL_UNIT_RESV_23 = 23,
96 NAL_UNIT_UNSPEC_24 = 24,
97 NAL_UNIT_UNSPEC_25 = 25,
98 NAL_UNIT_UNSPEC_26 = 26,
99 NAL_UNIT_UNSPEC_27 = 27,
100 NAL_UNIT_UNSPEC_28 = 28,
101 NAL_UNIT_UNSPEC_29 = 29,
102 NAL_UNIT_UNSPEC_30 = 30,
103 NAL_UNIT_UNSPEC_31 = 31
104}ENalUnitType;
105
106static const uint8_t g_kuiEmulationPreventionThreeByte = 0x03;
107
108/*
109 * NAL Reference IDC (2 Bits)
110 */
111typedef uint8_t NalRefIdc;
112enum{
113 NRI_PRI_LOWEST = 0,
114 NRI_PRI_LOW = 1,
115 NRI_PRI_HIGH = 2,
116 NRI_PRI_HIGHEST = 3
117};
118
119/*
120 * VCL TYPE
121 */
122typedef uint8_t VclType;
123enum{
124 NON_VCL = 0,
125 VCL = 1,
126 NOT_APP = 2
127};
128
129/*
130 * vcl type map for given NAL unit type and corresponding H264 type
131 */
132extern const VclType g_kuiVclTypeMap[32][2];
133
134#define IS_VCL_NAL(t, ext_idx) (g_kuiVclTypeMap[t][ext_idx] == VCL)
135#define IS_PARAM_SETS_NALS(t) ( (t) == NAL_UNIT_SPS || (t) == NAL_UNIT_PPS || (t) == NAL_UNIT_SUBSET_SPS )
136#define IS_SPS_NAL(t) ( (t) == NAL_UNIT_SPS )
137#define IS_SUBSET_SPS_NAL(t) ( (t) == NAL_UNIT_SUBSET_SPS )
138#define IS_PPS_NAL(t) ( (t) == NAL_UNIT_PPS )
139#define IS_SEI_NAL(t) ( (t) == NAL_UNIT_SEI )
140#define IS_PREFIX_NAL(t) ( (t) == NAL_UNIT_PREFIX )
141#define IS_SUBSET_SPS_USED(t) ( (t) == NAL_UNIT_SUBSET_SPS || (t) == NAL_UNIT_CODED_SLICE_EXT )
142#define IS_VCL_NAL_AVC_BASE(t) ( (t) == NAL_UNIT_CODED_SLICE || (t) == NAL_UNIT_CODED_SLICE_IDR )
143#define IS_NEW_INTRODUCED_NAL(t) ( (t) == NAL_UNIT_PREFIX || (t) == NAL_UNIT_CODED_SLICE_EXT )
144
145/* Base Slice Types
146 * Invalid in case of eSliceType exceeds 9,
147 * Need trim when eSliceType > 4 as fixed SliceType(eSliceType-4),
148 * meaning mapped version after eSliceType minus 4.
149 */
150typedef enum TagSliceType{
151 P_SLICE = 0,
152 B_SLICE = 1,
153 I_SLICE = 2,
154 SP_SLICE= 3,
155 SI_SLICE= 4,
156 UNKNOWN_SLICE= 5
157}ESliceType;
158
159/* Slice Types in scalable extension */
160typedef uint8_t SliceTypeExt;
161enum{
162 EP_SLICE = 0, // EP_SLICE: 0, 5
163 EB_SLICE = 1, // EB_SLICE: 1, 6
164 EI_SLICE = 2 // EI_SLICE: 2, 7
165};
166
167/* List Index */
168typedef uint8_t ListIndex;
169enum{
170 LIST_0 = 0,
171 LIST_1 = 1,
172 LIST_A = 2
173};
174
175/* Picture Size */
176typedef struct TagPictureSize{
177 int32_t iWidth;
178 int32_t iHeight;
179}SPictureSize;
180
181/* Motion Vector components */
182typedef uint8_t MvComp;
183enum{
184 MV_X = 0,
185 MV_Y = 1,
186 MV_A = 2
187};
188
189/* Chroma Components */
190typedef uint8_t ChromaComp;
191enum{
192 CHROMA_CB = 0,
193 CHROMA_CR = 1,
194 CHROMA_A = 2
195};
196
197/* Position Offset structure */
198typedef struct TagPosOffset{
199 int32_t iLeftOffset;
200 int32_t iTopOffset;
201 int32_t iRightOffset;
202 int32_t iBottomOffset;
203}SPosOffset;
204
205enum EMbPosition //
206{
207 MB_LEFT = 0x01, // A
208 MB_TOP = 0x02, // B
209 MB_TOPRIGHT = 0x04, // C
210 MB_TOPLEFT = 0x08, // D,
211 MB_PRIVATE = 0x10,
212};
213/* MB Type & Sub-MB Type */
214typedef int32_t MbType;
215typedef int32_t SubMbType;
216
217#define MB_TYPE_INTRA4x4 0x01
218#define MB_TYPE_INTRA16x16 0x02
219#define MB_TYPE_INTRA8x8 0x03
220#define MB_TYPE_INTRA_PCM 0x04
221
222#define MB_TYPE_INTRA_BL 0x05// I_BL new MB type
223
224#define MB_TYPE_16x16 0x06
225#define MB_TYPE_16x8 0x07
226#define MB_TYPE_8x16 0x08
227#define MB_TYPE_8x8 0x09
228#define MB_TYPE_8x8_REF0 0x0a
229
230#define SUB_MB_TYPE_8x8 0x0b
231#define SUB_MB_TYPE_8x4 0x0c
232#define SUB_MB_TYPE_4x8 0x0d
233#define SUB_MB_TYPE_4x4 0x0e
234#define MB_TYPE_SKIP 0x0f
235#define MB_TYPE_DIRECT2 0x10
236#define not_available 0x20
237
238#define IS_INTRA4x4(type) ( MB_TYPE_INTRA4x4 == (type) )
239#define IS_INTRA16x16(type) ( MB_TYPE_INTRA16x16 == (type) )
240#define IS_INTRA(type) ( (type) > 0 && (type) < 5 )
241#define IS_INTER(type) ( (type) > 5 && (type) < 16 )
242
243#define IS_I_BL(type) ( (type) == MB_TYPE_INTRA_BL )
244#define IS_SUB8x8(type) (MB_TYPE_8x8 == (type) || MB_TYPE_8x8_REF0 == (type))
245
246/*
247 * Memory Management Control Operation (MMCO) code
248 */
249enum{
250 MMCO_END =0,
251 MMCO_SHORT2UNUSED =1,
252 MMCO_LONG2UNUSED =2,
253 MMCO_SHORT2LONG =3,
254 MMCO_SET_MAX_LONG =4,
255 MMCO_RESET =5,
256 MMCO_LONG =6
257};
258
259/////////intra16x16 Luma
260#define I16_PRED_V 0
261#define I16_PRED_H 1
262#define I16_PRED_DC 2
263#define I16_PRED_P 3
264
265#define I16_PRED_DC_L 4
266#define I16_PRED_DC_T 5
267#define I16_PRED_DC_128 6
268//////////intra4x4 Luma
269#define I4_PRED_V 0
270#define I4_PRED_H 1
271#define I4_PRED_DC 2
272#define I4_PRED_DDL 3 //diagonal_down_left
273#define I4_PRED_DDR 4 //diagonal_down_right
274#define I4_PRED_VR 5 //vertical_right
275#define I4_PRED_HD 6 //horizon_down
276#define I4_PRED_VL 7 //vertical_left
277#define I4_PRED_HU 8 //horizon_up
278
279#define I4_PRED_DC_L 9
280#define I4_PRED_DC_T 10
281#define I4_PRED_DC_128 11
282
283#define I4_PRED_DDL_TOP 12 //right-top replacing by padding rightmost pixel of top
284#define I4_PRED_VL_TOP 13 //right-top replacing by padding rightmost pixel of top
285
286//////////intra Chroma
287#define C_PRED_DC 0
288#define C_PRED_H 1
289#define C_PRED_V 2
290#define C_PRED_P 3
291
292#define C_PRED_DC_L 4
293#define C_PRED_DC_T 5
294#define C_PRED_DC_128 6
295
296} // namespace WelsDec
297
298#endif//WELS_COMMON_BASIS_H__
codec/decoder/core/inc/wels_const.h+104−0
@@ -0,0 +1,104 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33//wels_const.h
34#ifndef WELS_CONSTANCE_H__
35#define WELS_CONSTANCE_H__
36
37// Miscellaneous sizing infos
38#ifndef MAX_FNAME_LEN
39#define MAX_FNAME_LEN 256 // maximal length of file name in char size
40#endif//MAX_FNAME_LEN
41
42#ifndef WELS_LOG_BUF_SIZE
43#define WELS_LOG_BUF_SIZE 4096
44#endif//WELS_LOG_BUF_SIZE
45
46#ifndef MAX_TRACE_LOG_SIZE
47#define MAX_TRACE_LOG_SIZE (50 * (1<<20)) // max trace log size: 50 MB, overwrite occur if log file size exceeds this size
48#endif//MAX_TRACE_LOG_SIZE
49
50/* MB width in pixels for specified colorspace I420 usually used in codec */
51#define MB_WIDTH_LUMA 16
52#define MB_WIDTH_CHROMA (MB_WIDTH_LUMA>>1)
53/* MB height in pixels for specified colorspace I420 usually used in codec */
54#define MB_HEIGHT_LUMA 16
55#define MB_HEIGHT_CHROMA (MB_HEIGHT_LUMA>>1)
56
57/* Some list size */
58#define MB_COEFF_LIST_SIZE (256+((MB_WIDTH_CHROMA*MB_HEIGHT_CHROMA)<<1))
59
60#define MB_PARTITION_SIZE 4 // Macroblock partition size in 8x8 sub-blocks
61#define MB_SUB_PARTITION_SIZE 4 // Sub partition size in a 8x8 sub-block
62#define MB_BLOCK4x4_NUM 16
63#define MB_BLOCK8x8_NUM 4
64
65#define NAL_UNIT_HEADER_EXT_SIZE 3 // Size of NAL unit header for extension in byte
66
67#define MAX_SPS_COUNT 32 // Count number of SPS
68#define MAX_PPS_COUNT 256 // Count number of PPS
69
70#define MAX_FRAME_RATE 30 // maximal frame rate to support
71#define MIN_FRAME_RATE 1 // minimal frame rate need support
72
73#define MAX_REF_PIC_COUNT 16 // MAX Short + Long reference pictures
74#define MIN_REF_PIC_COUNT 1 // minimal count number of reference pictures, 1 short + 2 key reference based?
75#define MAX_SHORT_REF_COUNT 16 // maximal count number of short reference pictures
76#define MAX_LONG_REF_COUNT 16 // maximal count number of long reference pictures
77
78#define MAX_MMCO_COUNT 66
79
80#define MAX_SLICEGROUP_IDS 8 // Count number of Slice Groups
81
82#define ALIGN_RBSP_LEN_FIX 4
83
84#define PADDING_LENGTH 32 // reference extension
85
86#define BASE_QUALITY_ID 0
87//#define BASE_DEPENDENCY_ID 0
88#define BASE_DQ_ID 0
89#define MAX_DQ_ID ((uint8_t)-1)
90//#define MAX_LAYER_NUM (MAX_DEPENDENCY_LAYER * MAX_TEMPORAL_LEVEL * MAX_QUALITY_LEVEL) // Layer number of Three-tuple
91
92#define LAYER_NUM_EXCHANGEABLE 1
93
94#define MAX_NAL_UNIT_NUM_IN_AU 32 // predefined maximal number of NAL Units in an access unit
95#define MAX_ACCESS_UINT_CAPACITY 1048576 // Maximal AU capacity in bytes: (1<<20) = 1024 KB predefined
96
97enum {
98 BASE_MB = 0,
99 NON_AVC_REWRITE_ENHANCE_MB =1,
100 AVC_REWRITE_ENHANCE_MB = 2
101
102};
103
104#endif//WELS_CONSTANCE_H__
codec/decoder/core/src/au_parser.cpp+1027−0
@@ -0,0 +1,1027 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file au_parser.c
33 *
34 * \brief Interfaces introduced in Access Unit level based parser
35 *
36 * \date 03/10/2009 Created
37 *
38 *************************************************************************************
39 */
40#include <string.h>
41#include "codec_def.h"
42#include "ls_defines.h"
43#include "macros.h"
44#include "au_parser.h"
45#include "decoder.h"
46#include "error_code.h"
47#include "dec_frame.h"
48#include "dec_golomb.h"
49#include "bit_stream.h"
50#include "utils.h"
51#include "codec_app_def.h"
52#include "memmgr_nal_unit.h"
53#include "decoder_core.h"
54#include "wels_common_basis.h"
55#include "decoder_core.h"
56#include "manage_dec_ref.h"
57#include "mem_align.h"
58
59namespace WelsDec {
60/*!
61 *************************************************************************************
62 * \brief Start Code Prefix (0x 00 00 00 01) detection
63 *
64 * \param pBuf bitstream payload buffer
65 * \param pOffset offset between NAL rbsp and original bitsteam that
66 * start code prefix is seperated from.
67 * \param iBufSize count size of buffer
68 *
69 * \return RBSP buffer of start code prefix exclusive
70 *
71 * \note N/A
72 *************************************************************************************
73 */
74uint8_t* DetectStartCodePrefix( const uint8_t *kpBuf, int32_t *pOffset, int32_t iBufSize )
75{
76 uint8_t *pBits = (uint8_t *)kpBuf;
77
78 do {
79 int32_t iIdx = 0;
80 while( (iIdx<iBufSize) && (!(*pBits)) ){
81 ++ pBits;
82 ++ iIdx;
83 }
84 if( iIdx >= iBufSize ) break;
85
86 ++ iIdx;
87 ++ pBits;
88
89 if( (iIdx>=3) && ((*(pBits-1)) == 0x1) ){
90 *pOffset = ((uint32_t)pBits) - ((uint32_t)kpBuf);
91 return pBits;
92 }
93
94 iBufSize -= iIdx;
95 } while (1);
96
97 return NULL;
98}
99
100/*!
101 *************************************************************************************
102 * \brief to parse nal unit
103 *
104 * \param pCtx decoder context
105 * \param pNalUnitHeader parsed result of NAL Unit Header to output
106 * \param pSrcRbsp bitstream buffer to input
107 * \param iSrcRbspLen length size of bitstream buffer payload
108 * \param pSrcNal
109 * \param iSrcNalLen
110 * \param pConsumedBytes consumed bytes during parsing
111 *
112 * \return decoded bytes payload, might be (pSrcRbsp+1) if no escapes
113 *
114 * \note N/A
115 *************************************************************************************
116 */
117uint8_t* ParseNalHeader( PWelsDecoderContext pCtx, SNalUnitHeader *pNalUnitHeader, uint8_t *pSrcRbsp, int32_t iSrcRbspLen, uint8_t *pSrcNal, int32_t iSrcNalLen, int32_t* pConsumedBytes )
118{
119 PNalUnit pCurNal = NULL;
120 uint8_t* pNal = pSrcRbsp;
121 int32_t iNalSize = iSrcRbspLen;
122 PBitStringAux pBs = NULL;
123 bool_t bExtensionFlag = false;
124 int32_t iErr = ERR_NONE;
125 int32_t iBitSize = 0;
126
127 pNalUnitHeader->eNalUnitType = NAL_UNIT_UNSPEC_0;//SHOULD init it. because pCtx->sCurNalHead is common variable.
128
129 //remove the consecutive ZERO at the end of current NAL in the reverse order.--2011.6.1
130 {
131 int32_t iIndex = iSrcRbspLen - 1;
132 uint8_t uiBsZero = 0;
133 while ( iIndex >= 0 )
134 {
135 uiBsZero = pSrcRbsp[iIndex];
136 if ( 0 == uiBsZero )
137 {
138 --iNalSize;
139 --iIndex;
140 }
141 else
142 {
143 break;
144 }
145 }
146 }
147
148 pNalUnitHeader->uiForbiddenZeroBit = (uint8_t)(pNal[0] >> 7); // uiForbiddenZeroBit
149 if ( pNalUnitHeader->uiForbiddenZeroBit )//2010.4.14
150 {
151 return NULL; //uiForbiddenZeroBit should always equal to 0
152 }
153
154 pNalUnitHeader->uiNalRefIdc = (uint8_t)(pNal[0] >> 5); // uiNalRefIdc
155 pNalUnitHeader->eNalUnitType = (ENalUnitType)(pNal[0] & 0x1f); // eNalUnitType
156
157 ++pNal;
158 --iNalSize;
159 ++(*pConsumedBytes);
160
161#ifdef DEBUG_PARSE_INFO
162 WelsLog(pCtx, WELS_LOG_INFO, "nal type: %d \n", pNalUnitHeader->eNalUnitType);
163#endif
164
165 if ( !(IS_SEI_NAL(pNalUnitHeader->eNalUnitType) || IS_SPS_NAL(pNalUnitHeader->eNalUnitType) || pCtx->bSpsExistAheadFlag) )
166 {
167 WelsLog( pCtx, WELS_LOG_WARNING, "parse_nal(), no exist Sequence Parameter Sets ahead of sequence when try to decode NAL(type:%d).\n", pNalUnitHeader->eNalUnitType);
168 pCtx->iErrorCode = dsNoParamSets;
169 return NULL;
170 }
171 if ( !(IS_SEI_NAL(pNalUnitHeader->eNalUnitType) || IS_PARAM_SETS_NALS(pNalUnitHeader->eNalUnitType) || pCtx->bPpsExistAheadFlag) )
172 {
173 WelsLog( pCtx, WELS_LOG_WARNING, "parse_nal(), no exist Picture Parameter Sets ahead of sequence when try to decode NAL(type:%d).\n", pNalUnitHeader->eNalUnitType);
174 pCtx->iErrorCode = dsNoParamSets;
175 return NULL;
176 }
177 if ( (IS_VCL_NAL_AVC_BASE(pNalUnitHeader->eNalUnitType) && !(pCtx->bSpsExistAheadFlag || pCtx->bPpsExistAheadFlag)) ||
178 (IS_NEW_INTRODUCED_NAL(pNalUnitHeader->eNalUnitType) && !(pCtx->bSpsExistAheadFlag || pCtx->bSubspsExistAheadFlag || pCtx->bPpsExistAheadFlag) ) )
179 {
180 WelsLog( pCtx, WELS_LOG_WARNING, "ParseNalHeader(), no exist Parameter Sets ahead of sequence when try to decode slice(type:%d).\n", pNalUnitHeader->eNalUnitType);
181 pCtx->iErrorCode |= dsNoParamSets;
182 return NULL;
183 }
184
185
186 switch(pNalUnitHeader->eNalUnitType){
187 case NAL_UNIT_SEI:
188
189 if ( pCtx->pAccessUnitList->uiAvailUnitsNum > 0 )
190 {
191 pCtx->pAccessUnitList->uiEndPos = pCtx->pAccessUnitList->uiAvailUnitsNum - 1;
192 pCtx->bAuReadyFlag = true;
193 }
194
195 break;
196
197 case NAL_UNIT_SPS:
198
199 if ( pCtx->pAccessUnitList->uiAvailUnitsNum > 0 )
200 {
201 pCtx->pAccessUnitList->uiEndPos = pCtx->pAccessUnitList->uiAvailUnitsNum - 1;
202 pCtx->bAuReadyFlag = true;
203 }
204
205 break;
206
207 case NAL_UNIT_PREFIX:
208 pCurNal = &pCtx->sPrefixNal;
209
210 if ( iNalSize < NAL_UNIT_HEADER_EXT_SIZE )
211 {
212 return NULL;
213 }
214
215 DecodeNalHeaderExt( pCurNal, pNal );
216
217 pNal += NAL_UNIT_HEADER_EXT_SIZE;
218 iNalSize -= NAL_UNIT_HEADER_EXT_SIZE;
219 *pConsumedBytes += NAL_UNIT_HEADER_EXT_SIZE;
220
221 pCurNal->sNalHeaderExt.sNalUnitHeader.uiForbiddenZeroBit = pNalUnitHeader->uiForbiddenZeroBit;
222 pCurNal->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc = pNalUnitHeader->uiNalRefIdc;
223 pCurNal->sNalHeaderExt.sNalUnitHeader.eNalUnitType = pNalUnitHeader->eNalUnitType;
224
225 pBs = &pCtx->sBs;
226
227 iBitSize = (iNalSize<<3) - BsGetTrailingBits( pNal + iNalSize - 1 ); // convert into bit
228
229 InitBits( pBs, pNal, iBitSize);
230
231 ParsePrefixNalUnit( pCtx, pBs );
232
233 break;
234 case NAL_UNIT_CODED_SLICE_EXT:
235 bExtensionFlag = true;
236 case NAL_UNIT_CODED_SLICE:
237 case NAL_UNIT_CODED_SLICE_IDR:
238 {
239 PAccessUnit pCurAu = NULL;
240 uint32_t uiAvailNalNum;
241 pCurNal = MemGetNextNal( &pCtx->pAccessUnitList );
242 if( NULL == pCurNal )
243 {
244 WelsLog( pCtx, WELS_LOG_WARNING, "MemGetNextNal() fail due out of memory.\n");
245 pCtx->iErrorCode |= dsOutOfMemory;
246 return NULL;
247 }
248
249 pCurNal->sNalHeaderExt.sNalUnitHeader.uiForbiddenZeroBit = pNalUnitHeader->uiForbiddenZeroBit;
250 pCurNal->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc = pNalUnitHeader->uiNalRefIdc;
251 pCurNal->sNalHeaderExt.sNalUnitHeader.eNalUnitType = pNalUnitHeader->eNalUnitType;
252 pCurAu = pCtx->pAccessUnitList;
253 uiAvailNalNum = pCurAu->uiAvailUnitsNum;
254
255
256 if( pNalUnitHeader->eNalUnitType == NAL_UNIT_CODED_SLICE_EXT )
257 {
258 if ( iNalSize < NAL_UNIT_HEADER_EXT_SIZE )
259 {
260 return NULL;
261 }
262
263 DecodeNalHeaderExt( pCurNal, pNal );
264 if( pCurNal->sNalHeaderExt.uiQualityId != 0 ||
265 pCurNal->sNalHeaderExt.bUseRefBasePicFlag )
266 {
267 if( pCurNal->sNalHeaderExt.uiQualityId != 0 )
268 WelsLog(pCtx, WELS_LOG_WARNING, "ParseNalHeader():uiQualityId (%d) != 0, MGS not supported!\n", pCurNal->sNalHeaderExt.uiQualityId);
269 if( pCurNal->sNalHeaderExt.bUseRefBasePicFlag != 0 )
270 WelsLog(pCtx, WELS_LOG_WARNING, "ParseNalHeader():bUseRefBasePicFlag (%d) != 0, MGS not supported!\n", pCurNal->sNalHeaderExt.bUseRefBasePicFlag);
271
272 pCtx->iErrorCode |= dsInvalidArgument;
273 ForceClearCurrentNal( pCurAu );
274
275 if ( uiAvailNalNum > 1 )
276 {
277 pCurAu->uiEndPos = uiAvailNalNum - 2;
278 pCtx->bAuReadyFlag = true;
279 }
280 return NULL;
281 }
282 pNal += NAL_UNIT_HEADER_EXT_SIZE;
283 iNalSize -= NAL_UNIT_HEADER_EXT_SIZE;
284 *pConsumedBytes += NAL_UNIT_HEADER_EXT_SIZE;
285
286 }
287 else
288 {
289
290
291 if ( NAL_UNIT_PREFIX == pCtx->sPrefixNal.sNalHeaderExt.sNalUnitHeader.eNalUnitType )
292 {
293 PrefetchNalHeaderExtSyntax( pCtx, pCurNal, &pCtx->sPrefixNal );
294 }
295
296 pCurNal->sNalHeaderExt.bIdrFlag = ( NAL_UNIT_CODED_SLICE_IDR == pNalUnitHeader->eNalUnitType ) ? true : false; //SHOULD update this flag for AVC if no prefix NAL
297 pCurNal->sNalHeaderExt.iNoInterLayerPredFlag = 1;
298 }
299
300 pBs = &pCurAu->pNalUnitsList[uiAvailNalNum-1]->sNalData.sVclNal.sSliceBitsRead;
301 iBitSize = (iNalSize<<3) - BsGetTrailingBits( pNal+ iNalSize - 1 ); // convert into bit
302 InitBits( pBs, pNal, iBitSize);
303 iErr = ParseSliceHeaderSyntaxs( pCtx, pBs, bExtensionFlag );
304 if ( iErr != ERR_NONE )
305 {
306 //if current NAL occur error when parsing, should clean it from pNalUnitsList
307 //otherwise, when Next good NAL decoding, this corrupt NAL is considered as normal NAL and lead to decoder crash
308 ForceClearCurrentNal( pCurAu );
309
310 if ( uiAvailNalNum > 1 )
311 {
312 pCurAu->uiEndPos = uiAvailNalNum - 2;
313 pCtx->bAuReadyFlag = true;
314
315
316 }
317#ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
318 if ( dsNoParamSets & pCtx->iErrorCode )
319 {
320 if ( uiAvailNalNum <= 1 ) //no any data to decode and SPS/PPS ID mismatch, SHOULD request IDR
321 {
322#ifdef LONG_TERM_REF
323 pCtx->bParamSetsLostFlag = true;
324#else
325 pCtx->bReferenceLostAtT0Flag = true;
326#endif
327 ResetParameterSetsState( pCtx );
328 }
329 return NULL;
330 }
331 else
332 {
333 return NULL;
334 }
335#else
336 return NULL;
337#endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
338 }
339
340 if ( (uiAvailNalNum > 1) &&
341 CheckAccessUnitBoundary( pCurAu->pNalUnitsList[uiAvailNalNum-1], pCurAu->pNalUnitsList[uiAvailNalNum-2],
342 pCurAu->pNalUnitsList[uiAvailNalNum-1]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.pSps) )
343 {
344 pCurAu->uiEndPos = uiAvailNalNum - 2;
345 pCtx->bAuReadyFlag = true;
346
347
348 }
349 }
350 break;
351 default:
352 break;
353 }
354
355 return pNal;
356}
357
358
359bool_t CheckAccessUnitBoundaryExt( PNalUnitHeaderExt pLastNalHdrExt, PNalUnitHeaderExt pCurNalHeaderExt, PSliceHeader pLastSliceHeader, PSliceHeader pCurSliceHeader )
360{
361 const PSps kpSps = pCurSliceHeader->pSps;
362
363 //Sub-clause 7.1.4.1.1 temporal_id
364 if (pLastNalHdrExt->uiTemporalId != pCurNalHeaderExt->uiTemporalId) {
365 return TRUE;
366 }
367
368 // Subclause 7.4.1.2.5
369 if ( pLastSliceHeader->iRedundantPicCnt < pCurSliceHeader->iRedundantPicCnt )
370 return FALSE;
371 else if ( pLastSliceHeader->iRedundantPicCnt > pCurSliceHeader->iRedundantPicCnt )
372 return TRUE;
373
374 // Subclause G7.4.1.2.4
375 if ( pLastNalHdrExt->uiDependencyId < pCurNalHeaderExt->uiDependencyId )
376 return FALSE;
377 else if ( pLastNalHdrExt->uiDependencyId > pCurNalHeaderExt->uiDependencyId )
378 return TRUE;
379 if ( pLastNalHdrExt->uiQualityId < pCurNalHeaderExt->uiQualityId )
380 return FALSE;
381 else if ( pLastNalHdrExt->uiQualityId > pCurNalHeaderExt->uiQualityId )
382 return TRUE;
383
384 // Subclause 7.4.1.2.4
385 if ( pLastSliceHeader->iFrameNum != pCurSliceHeader->iFrameNum )
386 return TRUE;
387 if ( pLastSliceHeader->iPpsId != pCurSliceHeader->iPpsId )
388 return TRUE;
389 if ( pLastSliceHeader->bFieldPicFlag != pCurSliceHeader->bFieldPicFlag )
390 return TRUE;
391 if ( pLastSliceHeader->bBottomFiledFlag != pCurSliceHeader->bBottomFiledFlag )
392 return TRUE;
393 if ( (pLastNalHdrExt->sNalUnitHeader.uiNalRefIdc != NRI_PRI_LOWEST) != (pCurNalHeaderExt->sNalUnitHeader.uiNalRefIdc != NRI_PRI_LOWEST) )
394 return TRUE;
395 if ( pLastNalHdrExt->bIdrFlag != pCurNalHeaderExt->bIdrFlag )
396 return TRUE;
397 if ( pCurNalHeaderExt->bIdrFlag ){
398 if ( pLastSliceHeader->uiIdrPicId != pCurSliceHeader->uiIdrPicId )
399 return TRUE;
400 }
401 if ( kpSps->uiPocType == 0 ){
402 if ( pLastSliceHeader->iPicOrderCntLsb != pCurSliceHeader->iPicOrderCntLsb )
403 return TRUE;
404 if ( pLastSliceHeader->iDeltaPicOrderCntBottom != pCurSliceHeader->iDeltaPicOrderCntBottom )
405 return TRUE;
406 }
407 else if ( kpSps->uiPocType == 1 ){
408 if ( pLastSliceHeader->iDeltaPicOrderCnt[0] != pCurSliceHeader->iDeltaPicOrderCnt[0] )
409 return TRUE;
410 if ( pLastSliceHeader->iDeltaPicOrderCnt[1] != pCurSliceHeader->iDeltaPicOrderCnt[1] )
411 return TRUE;
412 }
413
414 return FALSE;
415}
416
417
418bool_t CheckAccessUnitBoundary( const PNalUnit kpCurNal, const PNalUnit kpLastNal, const PSps kpSps )
419{
420 const PNalUnitHeaderExt kpLastNalHeaderExt = &kpLastNal->sNalHeaderExt;
421 const PNalUnitHeaderExt kpCurNalHeaderExt = &kpCurNal->sNalHeaderExt;
422 const SSliceHeader *kpLastSliceHeader = &kpLastNal->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader;
423 const SSliceHeader *kpCurSliceHeader = &kpCurNal->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader;
424
425 //Sub-clause 7.1.4.1.1 temporal_id
426 if (kpLastNalHeaderExt->uiTemporalId != kpCurNalHeaderExt->uiTemporalId) {
427 return TRUE;
428 }
429
430 // Subclause 7.4.1.2.5
431 if ( kpLastSliceHeader->iRedundantPicCnt < kpCurSliceHeader->iRedundantPicCnt )
432 return FALSE;
433 else if ( kpLastSliceHeader->iRedundantPicCnt > kpCurSliceHeader->iRedundantPicCnt )
434 return TRUE;
435
436 // Subclause G7.4.1.2.4
437 if ( kpLastNalHeaderExt->uiDependencyId < kpCurNalHeaderExt->uiDependencyId )
438 return FALSE;
439 else if ( kpLastNalHeaderExt->uiDependencyId > kpCurNalHeaderExt->uiDependencyId )
440 return TRUE;
441 if ( kpLastNalHeaderExt->uiQualityId < kpCurNalHeaderExt->uiQualityId )
442 return FALSE;
443 else if ( kpLastNalHeaderExt->uiQualityId > kpCurNalHeaderExt->uiQualityId )
444 return TRUE;
445
446 // Subclause 7.4.1.2.4
447 if ( kpLastSliceHeader->iFrameNum != kpCurSliceHeader->iFrameNum )
448 return TRUE;
449 if ( kpLastSliceHeader->iPpsId != kpCurSliceHeader->iPpsId )
450 return TRUE;
451 if ( kpLastSliceHeader->bFieldPicFlag != kpCurSliceHeader->bFieldPicFlag )
452 return TRUE;
453 if ( kpLastSliceHeader->bBottomFiledFlag != kpCurSliceHeader->bBottomFiledFlag )
454 return TRUE;
455 if ( (kpLastNalHeaderExt->sNalUnitHeader.uiNalRefIdc != NRI_PRI_LOWEST) != (kpCurNalHeaderExt->sNalUnitHeader.uiNalRefIdc != NRI_PRI_LOWEST) )
456 return TRUE;
457 if ( kpLastNalHeaderExt->bIdrFlag != kpCurNalHeaderExt->bIdrFlag )
458 return TRUE;
459 if ( kpCurNalHeaderExt->bIdrFlag ){
460 if ( kpLastSliceHeader->uiIdrPicId != kpCurSliceHeader->uiIdrPicId )
461 return TRUE;
462 }
463 if ( kpSps->uiPocType == 0 ){
464 if ( kpLastSliceHeader->iPicOrderCntLsb != kpCurSliceHeader->iPicOrderCntLsb )
465 return TRUE;
466 if ( kpLastSliceHeader->iDeltaPicOrderCntBottom != kpCurSliceHeader->iDeltaPicOrderCntBottom )
467 return TRUE;
468 }
469 else if ( kpSps->uiPocType == 1 ){
470 if ( kpLastSliceHeader->iDeltaPicOrderCnt[0] != kpCurSliceHeader->iDeltaPicOrderCnt[0] )
471 return TRUE;
472 if ( kpLastSliceHeader->iDeltaPicOrderCnt[1] != kpCurSliceHeader->iDeltaPicOrderCnt[1] )
473 return TRUE;
474 }
475
476 return FALSE;
477}
478
479/*!
480 *************************************************************************************
481 * \brief to parse NON VCL NAL Units
482 *
483 * \param pCtx decoder context
484 * \param rbsp rbsp buffer of NAL Unit
485 * \param src_len length of rbsp buffer
486 *
487 * \return 0 - successed
488 * 1 - failed
489 *
490 *************************************************************************************
491 */
492int32_t ParseNonVclNal( PWelsDecoderContext pCtx, uint8_t *pRbsp, const int32_t kiSrcLen )
493{
494 PBitStringAux pBs = NULL;
495 ENalUnitType eNalType = NAL_UNIT_UNSPEC_0; // make initial value as unspecified
496 int32_t iPicWidth = 0;
497 int32_t iPicHeight = 0;
498 int32_t iBitSize = 0;
499 int32_t iErr = ERR_NONE;
500
501 pBs = &pCtx->sBs; // SBitStringAux instance for non VCL NALs decoding
502 iBitSize = (kiSrcLen<<3) - BsGetTrailingBits( pRbsp + kiSrcLen - 1 ); // convert into bit
503 eNalType = pCtx->sCurNalHead.eNalUnitType;
504
505 switch( eNalType ) {
506 case NAL_UNIT_SPS:
507 case NAL_UNIT_SUBSET_SPS:
508 if ( iBitSize > 0 )
509 InitBits( pBs, pRbsp, iBitSize );
510#ifdef DEBUG_PARSE_INFO
511 WelsLog(pCtx, WELS_LOG_INFO, "parsing nal: %d \n", eNalType);
512#endif
513 iErr = ParseSps( pCtx, pBs, &iPicWidth, &iPicHeight );
514 if ( ERR_NONE != iErr ) // modified for pSps/pSubsetSps invalid, 12/1/2009
515 {
516 pCtx->iErrorCode |= dsNoParamSets;
517 return iErr;
518 }
519
520 if ( ERR_NONE == iErr )
521 UpdateMaxPictureResolution( pCtx, iPicWidth, iPicHeight );
522
523 break;
524
525 case NAL_UNIT_PPS:
526 if ( iBitSize > 0 )
527 InitBits( pBs, pRbsp, iBitSize );
528#ifdef DEBUG_PARSE_INFO
529 WelsLog(pCtx, WELS_LOG_INFO, "parsing nal: %d \n", eNalType);
530#endif
531 iErr = ParsePps( pCtx, &pCtx->sPpsBuffer[0], pBs );
532 if ( ERR_NONE != iErr ) // modified for pps invalid, 12/1/2009
533 {
534 pCtx->iErrorCode |= dsNoParamSets;
535 return iErr;
536 }
537
538 pCtx->bPpsExistAheadFlag = true;
539
540 break;
541
542 case NAL_UNIT_SEI:
543
544 break;
545
546 case NAL_UNIT_PREFIX:
547 break;
548 case NAL_UNIT_CODED_SLICE_DPA:
549 case NAL_UNIT_CODED_SLICE_DPB:
550 case NAL_UNIT_CODED_SLICE_DPC:
551
552 break;
553
554 default:
555 break;
556 }
557
558 return iErr;
559}
560
561void_t ParseRefBasePicMarking ( PBitStringAux pBs, PRefBasePicMarking pRefBasePicMarking )
562{
563 const bool_t kbAdaptiveMarkingModeFlag = !!BsGetOneBit( pBs );
564 pRefBasePicMarking->bAdaptiveRefBasePicMarkingModeFlag = kbAdaptiveMarkingModeFlag;
565 if ( kbAdaptiveMarkingModeFlag ){
566 int32_t iIdx = 0;
567 do {
568 const uint32_t kuiMmco = BsGetUe( pBs );
569
570 pRefBasePicMarking->mmco_base[iIdx].uiMmcoType = kuiMmco;
571
572 if (kuiMmco == MMCO_END)
573 break;
574
575 if (kuiMmco == MMCO_SHORT2UNUSED){
576 pRefBasePicMarking->mmco_base[iIdx].uiDiffOfPicNums = 1 + BsGetUe( pBs );
577 pRefBasePicMarking->mmco_base[iIdx].iShortFrameNum = 0;
578 }
579 else if (kuiMmco == MMCO_LONG2UNUSED){
580 pRefBasePicMarking->mmco_base[iIdx].uiLongTermPicNum = BsGetUe( pBs );
581 }
582 ++ iIdx;
583 } while(iIdx < MAX_MMCO_COUNT);
584 }
585}
586
587void_t ParsePrefixNalUnit ( PWelsDecoderContext pCtx, PBitStringAux pBs )
588{
589 PNalUnit pCurNal = &pCtx->sPrefixNal;
590
591 if ( pCurNal->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc != 0 ){
592 PNalUnitHeaderExt head_ext = &pCurNal->sNalHeaderExt;
593 PPrefixNalUnit sPrefixNal = &pCurNal->sNalData.sPrefixNal;
594 sPrefixNal->bStoreRefBasePicFlag = !!BsGetOneBit( pBs );
595 if ( (head_ext->bUseRefBasePicFlag || sPrefixNal->bStoreRefBasePicFlag) && !head_ext->bIdrFlag )
596 {
597 ParseRefBasePicMarking ( pBs, &sPrefixNal->sRefPicBaseMarking );
598 }
599 sPrefixNal->bPrefixNalUnitAdditionalExtFlag = !!BsGetOneBit( pBs );
600 if ( sPrefixNal->bPrefixNalUnitAdditionalExtFlag ){
601 sPrefixNal->bPrefixNalUnitExtFlag = !!BsGetOneBit( pBs );
602 }
603 }
604}
605
606
607int32_t DecodeSpsSvcExt( PWelsDecoderContext pCtx, PSubsetSps pSpsExt, PBitStringAux pBs )
608{
609 PSpsSvcExt pExt = NULL;
610 uint8_t uiChromaArrayType = 1;
611
612 pExt = &pSpsExt->sSpsSvcExt;
613
614 pExt->bInterLayerDeblockingFilterCtrlPresentFlag = !!BsGetOneBit( pBs );
615 pExt->uiExtendedSpatialScalability = BsGetBits( pBs, 2 );
616 if ( pExt->uiExtendedSpatialScalability > 2 )
617 {
618 WelsLog(pCtx, WELS_LOG_WARNING, "DecodeSpsSvcExt():extended_spatial_scalability (%d) != 0, ESS not supported!\n", pExt->uiExtendedSpatialScalability);
619 return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_ESS);
620 }
621
622 pExt->uiChromaPhaseXPlus1Flag = 0; // FIXME: Incoherent with JVT X201 standard (= 1), but conformance to JSVM (= 0) implementation.
623 pExt->uiChromaPhaseYPlus1 = 1;
624 uiChromaArrayType = pSpsExt->sSps.uiChromaArrayType;
625
626 pExt->uiChromaPhaseXPlus1Flag = BsGetOneBit( pBs );
627 pExt->uiChromaPhaseYPlus1 = BsGetBits( pBs, 2 );
628
629 pExt->uiSeqRefLayerChromaPhaseXPlus1Flag = pExt->uiChromaPhaseXPlus1Flag;
630 pExt->uiSeqRefLayerChromaPhaseYPlus1 = pExt->uiChromaPhaseYPlus1;
631 memset(&pExt->sSeqScaledRefLayer, 0, sizeof(SPosOffset));
632
633 if ( pExt->uiExtendedSpatialScalability == 1 ){
634 SPosOffset* const kpPos = &pExt->sSeqScaledRefLayer;
635 pExt->uiSeqRefLayerChromaPhaseXPlus1Flag = BsGetOneBit( pBs );
636 pExt->uiSeqRefLayerChromaPhaseYPlus1 = BsGetBits( pBs, 2 );
637
638 kpPos->iLeftOffset = BsGetSe( pBs );
639 kpPos->iTopOffset = BsGetSe( pBs );
640 kpPos->iRightOffset = BsGetSe( pBs );
641 kpPos->iBottomOffset= BsGetSe( pBs );
642 }
643
644 pExt->bSeqTCoeffLevelPredFlag = !!BsGetOneBit( pBs );
645 pExt->bAdaptiveTCoeffLevelPredFlag = false;
646 if ( pExt->bSeqTCoeffLevelPredFlag )
647 pExt->bAdaptiveTCoeffLevelPredFlag = !!BsGetOneBit( pBs );
648 pExt->bSliceHeaderRestrictionFlag = !!BsGetOneBit( pBs );
649
650
651
652 return 0;
653}
654
655/*!
656 *************************************************************************************
657 * \brief to parse Sequence Parameter Set (SPS)
658 *
659 * \param pCtx Decoder context
660 * \param pBsAux bitstream reader auxiliary
661 * \param pPicWidth picture width current Sps represented
662 * \param pPicHeight picture height current Sps represented
663 *
664 * \return 0 - successed
665 * 1 - failed
666 *
667 * \note Call it in case eNalUnitType is SPS.
668 *************************************************************************************
669 */
670
671
672int32_t ParseSps( PWelsDecoderContext pCtx, PBitStringAux pBsAux, int32_t *pPicWidth, int32_t *pPicHeight )
673{
674 PBitStringAux pBs = pBsAux;
675 PSps pSps = NULL;
676 PSubsetSps pSubsetSps = NULL;
677 SNalUnitHeader *pNalHead= &pCtx->sCurNalHead;
678 ProfileIdc uiProfileIdc;
679 uint8_t uiLevelIdc;
680 int32_t iSpsId;
681 bool_t bConstraintSetFlags[6] = { false };
682 const bool_t kbUseSubsetFlag = IS_SUBSET_SPS_NAL(pNalHead->eNalUnitType);
683
684
685 if ( kbUseSubsetFlag ) // SubsetSps
686 {
687 pCtx->bSubspsExistAheadFlag = true;
688 }
689 else // Sps
690 {
691 pCtx->bSpsExistAheadFlag = true;
692
693 // added for EC, 10/28/2009
694 // for safe
695 memset( &pCtx->bSpsAvailFlags[0], 0, sizeof(pCtx->bSpsAvailFlags) );
696 memset( &pCtx->bSubspsAvailFlags[0], 0, sizeof(pCtx->bSubspsAvailFlags) );
697 memset( &pCtx->bPpsAvailFlags[0], 0, sizeof(pCtx->bPpsAvailFlags) );
698
699#ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
700 pCtx->iSpsTotalNum = 0;
701 pCtx->iSubspsTotalNum = 0;
702 pCtx->iPpsTotalNum = 0;
703#endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
704 }
705
706 uiProfileIdc = BsGetBits( pBs, 8 );
707 bConstraintSetFlags[0] = !!BsGetOneBit( pBs ); // constraint_set0_flag
708 bConstraintSetFlags[1] = !!BsGetOneBit( pBs ); // constraint_set1_flag
709 bConstraintSetFlags[2] = !!BsGetOneBit( pBs ); // constraint_set2_flag
710 bConstraintSetFlags[3] = !!BsGetOneBit( pBs ); // constraint_set3_flag
711 bConstraintSetFlags[4] = !!BsGetOneBit( pBs ); // constraint_set4_flag
712 bConstraintSetFlags[5] = !!BsGetOneBit( pBs ); // constraint_set5_flag
713 BsGetBits( pBs, 2 ); // reserved_zero_2bits, equal to 0
714 uiLevelIdc = BsGetBits( pBs, 8 ); // level_idc
715
716 iSpsId = BsGetUe( pBs ); // seq_parameter_set_id
717
718
719 if ( iSpsId >= MAX_SPS_COUNT || iSpsId < 0 ) // Modified to check invalid negative iSpsId, 12/1/2009
720 {
721 WelsLog( pCtx, WELS_LOG_WARNING, " iSpsId is out of range! \n");
722 return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_SPS_ID_OVERFLOW);
723 }
724
725 if ( kbUseSubsetFlag )
726 {
727#ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
728 pSubsetSps = &pCtx->sSubsetSpsBuffer[pCtx->iSubspsTotalNum];
729 pCtx->bSubspsAvailFlags[pCtx->iSubspsTotalNum] = true;
730
731 pSubsetSps->sSps.iSpsId = iSpsId;
732 pSps = &pSubsetSps->sSps;
733 ++pCtx->iSubspsTotalNum;
734#else
735 pSubsetSps = &pCtx->sSubsetSpsBuffer[iSpsId];
736 pSps = &pSubsetSps->sSps;
737 pCtx->bSubspsAvailFlags[iSpsId] = true; // added for EC, 10/28/2009
738#endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
739 }
740 else
741 {
742#ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
743 pSps = &pCtx->sSpsBuffer[pCtx->iSpsTotalNum];
744 pCtx->bSpsAvailFlags[pCtx->iSpsTotalNum] = true;
745
746 pSps->iSpsId = iSpsId;
747 ++pCtx->iSpsTotalNum;
748#else
749 pSps = &pCtx->sSpsBuffer[iSpsId];
750 pCtx->bSpsAvailFlags[iSpsId] = true; // added for EC, 10/28/2009
751#endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
752 }
753
754 // syntax elements in default
755 pSps->uiChromaFormatIdc = 1;
756 pSps->uiBitDepthLuma =
757 pSps->uiBitDepthChroma = 8;
758
759 pSps->uiProfileIdc = uiProfileIdc;
760 pSps->uiLevelIdc = uiLevelIdc;
761 pSps->iSpsId = iSpsId;
762
763 if ( PRO_SCALABLE_BASELINE == uiProfileIdc || PRO_SCALABLE_HIGH == uiProfileIdc ||
764 PRO_HIGH == uiProfileIdc || PRO_HIGH10 == uiProfileIdc ||
765 PRO_HIGH422 == uiProfileIdc || PRO_HIGH444 == uiProfileIdc ||
766 PRO_CAVLC444 == uiProfileIdc || 44 == uiProfileIdc ){
767
768 pSps->uiChromaFormatIdc = BsGetUe( pBs );
769 if( pSps->uiChromaFormatIdc != 1 )
770 {
771 WelsLog( pCtx, WELS_LOG_WARNING, "ParseSps(): chroma_format_idc (%d) = 1 supported.\n", pSps->uiChromaFormatIdc);
772 return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE);
773 }
774 pSps->uiChromaArrayType = pSps->uiChromaFormatIdc;
775 pSps->uiBitDepthLuma = 8 + BsGetUe( pBs );
776 if( pSps->uiBitDepthLuma != 8 )
777 {
778 WelsLog( pCtx, WELS_LOG_WARNING, "ParseSps(): bit_depth_luma (%d) Only 8 bit supported.\n", pSps->uiBitDepthLuma);
779 return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE);
780 }
781
782 pSps->uiBitDepthChroma = 8 + BsGetUe( pBs );
783 if( pSps->uiBitDepthChroma != 8 )
784 {
785 WelsLog( pCtx, WELS_LOG_WARNING, "ParseSps(): bit_depth_chroma (%d). Only 8 bit supported.\n", pSps->uiBitDepthChroma);
786 return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE);
787 }
788 pSps->bQpPrimeYZeroTransfBypassFlag = !!BsGetOneBit( pBs );
789 pSps->bSeqScalingMatrixPresentFlag = !!BsGetOneBit( pBs );
790
791 if ( pSps->bSeqScalingMatrixPresentFlag ){ // For high profile, it is not used in current application. FIXME
792 WelsLog( pCtx, WELS_LOG_WARNING, "ParseSps(): seq_scaling_matrix_present_flag (%d). Feature not supported.\n", pSps->bSeqScalingMatrixPresentFlag);
793 return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE);
794 }
795 }
796
797 pSps->uiLog2MaxFrameNum = 4 + BsGetUe( pBs ); // log2_max_frame_num_minus4
798 pSps->uiPocType = BsGetUe( pBs ); // pic_order_cnt_type
799
800 if ( 0 == pSps->uiPocType )
801 {
802 pSps->iLog2MaxPocLsb = 4 + BsGetUe( pBs ); // log2_max_pic_order_cnt_lsb_minus4
803
804 }
805 else if ( 1 == pSps->uiPocType )
806 {
807 int32_t i;
808 pSps->bDeltaPicOrderAlwaysZeroFlag = !!BsGetOneBit( pBs ); // bDeltaPicOrderAlwaysZeroFlag
809 pSps->iOffsetForNonRefPic = BsGetSe( pBs ); // iOffsetForNonRefPic
810 pSps->iOffsetForTopToBottomField = BsGetSe( pBs ); // iOffsetForTopToBottomField
811 pSps->iNumRefFramesInPocCycle = BsGetUe( pBs ); // num_ref_frames_in_pic_order_cnt_cycle
812 for( i = 0; i < pSps->iNumRefFramesInPocCycle; i++ )
813 pSps->iOffsetForRefFrame[ i ] = BsGetSe( pBs ); // iOffsetForRefFrame[ i ]
814 }
815 if ( pSps->uiPocType > 2 )
816 {
817 WelsLog( pCtx, WELS_LOG_WARNING, " illegal pic_order_cnt_type: %d ! \n", pSps->uiPocType );
818 return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_POC_TYPE);
819 }
820
821 pSps->iNumRefFrames = BsGetUe( pBs ); // max_num_ref_frames
822 pSps->bGapsInFrameNumValueAllowedFlag = !!BsGetOneBit( pBs ); // bGapsInFrameNumValueAllowedFlag
823 pSps->iMbWidth = 1 + BsGetUe( pBs ); // pic_width_in_mbs_minus1
824 pSps->iMbHeight = 1 + BsGetUe( pBs ); // pic_height_in_map_units_minus1
825 pSps->uiTotalMbCount = pSps->iMbWidth * pSps->iMbHeight;
826 pSps->bFrameMbsOnlyFlag = !!BsGetOneBit( pBs ); // frame_mbs_only_flag
827
828 if ( !pSps->bFrameMbsOnlyFlag )
829 {
830 WelsLog( pCtx, WELS_LOG_WARNING, "ParseSps(): frame_mbs_only_flag (%d) not supported.\n", pSps->bFrameMbsOnlyFlag);
831 return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_MBAFF);
832 }
833 pSps->bDirect8x8InferenceFlag = !!BsGetOneBit( pBs ); // direct_8x8_inference_flag
834 pSps->bFrameCroppingFlag = !!BsGetOneBit( pBs ); // frame_cropping_flag
835 if ( pSps->bFrameCroppingFlag )
836 {
837 pSps->sFrameCrop.iLeftOffset = BsGetUe( pBs ); // frame_crop_left_offset
838 pSps->sFrameCrop.iRightOffset = BsGetUe( pBs ); // frame_crop_right_offset
839 pSps->sFrameCrop.iTopOffset = BsGetUe( pBs ); // frame_crop_top_offset
840 pSps->sFrameCrop.iBottomOffset = BsGetUe( pBs ); // frame_crop_bottom_offset
841 }
842 else
843 {
844 pSps->sFrameCrop.iLeftOffset = 0; // frame_crop_left_offset
845 pSps->sFrameCrop.iRightOffset = 0; // frame_crop_right_offset
846 pSps->sFrameCrop.iTopOffset = 0; // frame_crop_top_offset
847 pSps->sFrameCrop.iBottomOffset = 0; // frame_crop_bottom_offset
848 }
849 pSps->bVuiParamPresentFlag = !!BsGetOneBit( pBs ); // vui_parameters_present_flag
850
851 // Check if SPS SVC extension applicated
852 if ( kbUseSubsetFlag && ( PRO_SCALABLE_BASELINE == uiProfileIdc || PRO_SCALABLE_HIGH == uiProfileIdc ) )
853 {
854 if ( DecodeSpsSvcExt( pCtx, pSubsetSps, pBs ) != ERR_NONE ){
855 return -1;
856 }
857
858 pSubsetSps->bSvcVuiParamPresentFlag = !!BsGetOneBit( pBs );
859 if ( pSubsetSps->bSvcVuiParamPresentFlag ){
860 }
861 }
862
863
864 if ( PRO_SCALABLE_BASELINE == uiProfileIdc || PRO_SCALABLE_HIGH == uiProfileIdc )
865 pCtx->bAvcBasedFlag = false;
866 else
867 pCtx->bAvcBasedFlag = true; // added for avc base pBs
868
869 *pPicWidth = pSps->iMbWidth << 4;
870 *pPicHeight = pSps->iMbHeight << 4;
871
872 return 0;
873}
874
875/*!
876 *************************************************************************************
877 * \brief to parse Picture Parameter Set (PPS)
878 *
879 * \param pCtx Decoder context
880 * \param pPpsList pps list
881 * \param pBsAux bitstream reader auxiliary
882 *
883 * \return 0 - successed
884 * 1 - failed
885 *
886 * \note Call it in case eNalUnitType is PPS.
887 *************************************************************************************
888 */
889int32_t ParsePps( PWelsDecoderContext pCtx, PPps pPpsList, PBitStringAux pBsAux )
890{
891
892 PPps pPps = NULL;
893 uint32_t uiPpsId = 0;
894 uint32_t iTmp;
895
896 uiPpsId = BsGetUe(pBsAux);
897 if ( uiPpsId >= MAX_PPS_COUNT )
898 {
899 return ERR_INFO_PPS_ID_OVERFLOW;
900 }
901
902#ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
903 pPps = &pPpsList[pCtx->iPpsTotalNum];
904#else
905 pPps = &pPpsList[uiPpsId];
906#endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
907
908
909 pPps->iPpsId = uiPpsId;
910 pPps->iSpsId = BsGetUe(pBsAux);
911
912 if (pPps->iSpsId >= MAX_SPS_COUNT)
913 {
914 return ERR_INFO_SPS_ID_OVERFLOW;
915 }
916
917 pPps->bEntropyCodingModeFlag = !!BsGetOneBit(pBsAux);
918 pPps->bPicOrderPresentFlag = !!BsGetOneBit(pBsAux);
919
920 pPps->uiNumSliceGroups = 1 + BsGetUe(pBsAux);
921
922 if (pPps->uiNumSliceGroups > MAX_SLICEGROUP_IDS)
923 {
924 return ERR_INFO_INVALID_SLICEGROUP;
925 }
926
927 if (pPps->uiNumSliceGroups > 1)
928 {
929 pPps->uiSliceGroupMapType = BsGetUe(pBsAux);
930 if( pPps->uiSliceGroupMapType > 1)
931 {
932 WelsLog( pCtx, WELS_LOG_WARNING, "ParsePps(): slice_group_map_type (%d): support only 0,1.\n", pPps->uiSliceGroupMapType);
933 return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_FMOTYPE);
934 }
935
936 switch(pPps->uiSliceGroupMapType)
937 {
938 case 0:
939 for (iTmp = 0; iTmp < pPps->uiNumSliceGroups; iTmp++)
940 {
941 pPps->uiRunLength[iTmp] = 1 + BsGetUe(pBsAux);
942 }
943 break;
944 default:
945 break;
946 }
947 }
948
949 pPps->uiNumRefIdxL0Active = 1 + BsGetUe(pBsAux);
950 pPps->uiNumRefIdxL1Active = 1 + BsGetUe(pBsAux);
951
952 if (pPps->uiNumRefIdxL0Active > MAX_REF_PIC_COUNT ||
953 pPps->uiNumRefIdxL1Active > MAX_REF_PIC_COUNT)
954 {
955 return ERR_INFO_REF_COUNT_OVERFLOW;
956 }
957
958 pPps->bWeightedPredFlag = !!BsGetOneBit(pBsAux);
959 pPps->uiWeightedBipredIdc = BsGetBits(pBsAux, 2);
960 if( pPps->bWeightedPredFlag || pPps->uiWeightedBipredIdc != 0 )
961 {
962 WelsLog( pCtx, WELS_LOG_WARNING, "ParsePps(): weighted_pred_flag (%d) weighted_bipred_idc (%d) neither supported.\n", pPps->bWeightedPredFlag, pPps->uiWeightedBipredIdc);
963 return GENERATE_ERROR_NO(ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_WP);
964 }
965
966 pPps->iPicInitQp = 26 + BsGetSe(pBsAux);
967 pPps->iPicInitQs = 26 + BsGetSe(pBsAux);
968
969 pPps->iChromaQpIndexOffset = BsGetSe(pBsAux);
970 pPps->bDeblockingFilterControlPresentFlag = !!BsGetOneBit(pBsAux);
971 pPps->bConstainedIntraPredFlag = !!BsGetOneBit(pBsAux);
972 pPps->bRedundantPicCntPresentFlag = !!BsGetOneBit(pBsAux);
973
974
975#ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
976 pCtx->bPpsAvailFlags[pCtx->iPpsTotalNum] = true;
977 ++pCtx->iPpsTotalNum;
978#else
979 pCtx->bPpsAvailFlags[uiPpsId] = true; // added for EC, 10/28/2009
980#endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
981
982 return ERR_NONE;
983}
984
985/*!
986 *************************************************************************************
987 * \brief to parse SEI message payload
988 *
989 * \param pSei sei message to be parsed output
990 * \param pBsAux bitstream reader auxiliary
991 *
992 * \return 0 - successed
993 * 1 - failed
994 *
995 * \note Call it in case eNalUnitType is NAL_UNIT_SEI.
996 *************************************************************************************
997 */
998int32_t ParseSei( void_t *pSei, PBitStringAux pBsAux ) // reserved Sei_Msg type
999{
1000
1001
1002 return ERR_NONE;
1003}
1004
1005/*!
1006 *************************************************************************************
1007 * \brief reset fmo list due to got Sps now
1008 *
1009 * \param pCtx decoder context
1010 *
1011 * \return count number of fmo context units are reset
1012 *************************************************************************************
1013 */
1014int32_t ResetFmoList( PWelsDecoderContext pCtx )
1015{
1016 int32_t iCountNum = 0;
1017 if ( NULL != pCtx )
1018 {
1019 // Fixed memory leak due to PPS_ID might not be continuous sometimes, 1/5/2010
1020 UninitFmoList( &pCtx->sFmoList[0], MAX_PPS_COUNT, pCtx->iActiveFmoNum );
1021 iCountNum = pCtx->iActiveFmoNum;
1022 pCtx->iActiveFmoNum = 0;
1023 }
1024 return iCountNum;
1025}
1026
1027} // namespace WelsDec
codec/decoder/core/src/bit_stream.cpp+123−0
@@ -0,0 +1,123 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file bit_stream.cpp
33 *
34 * \brief Reading / writing bit-stream
35 *
36 * \date 03/10/2009 Created
37 *
38 *************************************************************************************
39 */
40#include "bit_stream.h"
41#include "macros.h"
42
43namespace WelsDec {
44
45#ifdef WORDS_BIGENDIAN
46inline uint32_t EndianFix(uint32_t uiX)
47{
48 return uiX;
49}
50#else //WORDS_BIGENDIAN
51
52#ifdef _MSC_VER
53inline uint32_t EndianFix(uint32_t uiX)
54{
55 __asm
56 {
57 mov eax, uiX
58 bswap eax
59 mov uiX, eax
60 }
61 return uiX;
62}
63#else //_MSC_VER
64
65inline uint32_t EndianFix(uint32_t uiX)
66{
67#ifdef ARM_ARCHv7
68 __asm__ __volatile__("rev %0, %0":"+r"(uiX)); //Just for the ARMv7
69#elif defined (X86_ARCH)
70 __asm__ __volatile__("bswap %0":"+r"(uiX));
71#else
72 uiX = ((uiX & 0xff000000)>> 24) | ((uiX & 0xff0000) >> 8) |
73 ((uiX & 0xff00) << 8) | ((uiX&0xff) << 24);
74#endif
75 return uiX;
76}
77#endif //_MSC_VER
78
79#endif //WORDS_BIGENDIAN
80
81inline uint32_t GetValue4Bytes( uint8_t* pDstNal )
82{
83 uint32_t uiValue = 0;
84 uiValue = (pDstNal[0]<<24) | (pDstNal[1]<<16) | (pDstNal[2]<<8) | (pDstNal[3]);
85 return uiValue;
86}
87
88void_t InitReadBits( PBitStringAux pBitString )
89{
90 pBitString->uiCurBits = GetValue4Bytes( pBitString->pCurBuf );
91 pBitString->pCurBuf += 4;
92 pBitString->iLeftBits = -16;
93}
94
95/*!
96 * \brief input bits for decoder or initialize bitstream writing in encoder
97 *
98 * \param pBitString Bit string auxiliary pointer
99 * \param kpBuf bit-stream buffer
100 * \param kiSize size in bits for decoder; size in bytes for encoder
101 *
102 * \return size of buffer data in byte; failed in -1 return
103 */
104int32_t InitBits( PBitStringAux pBitString, const uint8_t *kpBuf, const int32_t kiSize )
105{
106 const int32_t kiSizeBuf = (kiSize + 7) >> 3;
107 uint8_t *pTmp = (uint8_t *)kpBuf;
108
109 if ( NULL == pTmp )
110 return -1;
111
112 pBitString->pStartBuf = pTmp; // buffer to start position
113 pBitString->pEndBuf = pTmp + kiSizeBuf; // buffer + length
114 pBitString->iBits = kiSize; // count bits of overall bitstreaming inputindex;
115
116 pBitString->pCurBuf = pBitString->pStartBuf;
117 InitReadBits( pBitString );
118
119 return kiSizeBuf;
120}
121
122} // namespace WelsDec
123
codec/decoder/core/src/cpu.cpp+211−0
@@ -0,0 +1,211 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file cpu.cpp
33 *
34 * \brief CPU compatibility detection
35 *
36 * \date 04/29/2009 Created
37 *
38 *************************************************************************************
39 */
40#include <string.h>
41
42#include "cpu.h"
43#include "cpu_core.h"
44
45namespace WelsDec {
46
47#define CPU_Vender_AMD "AuthenticAMD"
48#define CPU_Vender_INTEL "GenuineIntel"
49#define CPU_Vender_CYRIX "CyrixInstead"
50
51#if defined(X86_ASM)
52
53uint32_t WelsCPUFeatureDetect( int32_t *pNumberOfLogicProcessors )
54{
55 uint32_t uiCPU = 0;
56 uint32_t uiFeatureA = 0, uiFeatureB = 0, uiFeatureC = 0, uiFeatureD = 0;
57 int32_t CacheLineSize = 0;
58 int8_t chVenderName[16] = { 0 };
59
60 if( !WelsCPUIdVerify() )
61 {
62 /* cpuid is not supported in cpu */
63 return 0;
64 }
65
66 WelsCPUId( 0, &uiFeatureA, (uint32_t*)&chVenderName[0],(uint32_t*)&chVenderName[8],(uint32_t*)&chVenderName[4] );
67 if( uiFeatureA == 0 )
68 {
69 /* maximum input value for basic cpuid information */
70 return 0;
71 }
72
73 WelsCPUId( 1, &uiFeatureA, &uiFeatureB, &uiFeatureC, &uiFeatureD );
74 if( (uiFeatureD & 0x00800000) == 0 )
75 {
76 /* Basic MMX technology is not support in cpu, mean nothing for us so return here */
77 return 0;
78 }
79
80 uiCPU = WELS_CPU_MMX;
81 if( uiFeatureD & 0x02000000 )
82 {
83 /* SSE technology is identical to AMD MMX extensions */
84 uiCPU |= WELS_CPU_MMXEXT|WELS_CPU_SSE;
85 }
86 if( uiFeatureD & 0x04000000 )
87 {
88 /* SSE2 support here */
89 uiCPU |= WELS_CPU_SSE2;
90 }
91 if ( uiFeatureD & 0x00000001 )
92 {
93 /* x87 FPU on-chip checking */
94 uiCPU |= WELS_CPU_FPU;
95 }
96 if ( uiFeatureD & 0x00008000 )
97 {
98 /* CMOV instruction checking */
99 uiCPU |= WELS_CPU_CMOV;
100 }
101 if ( !strcmp((const str_t*)chVenderName,CPU_Vender_INTEL) ) // confirmed_safe_unsafe_usage
102 {
103 if ( uiFeatureD & 0x10000000 )
104 {
105 /* Multi-Threading checking: contains of multiple logic processors */
106 uiCPU |= WELS_CPU_HTT;
107 }
108 }
109
110 if( uiFeatureC & 0x00000001 ){
111 /* SSE3 support here */
112 uiCPU |= WELS_CPU_SSE3;
113 }
114 if( uiFeatureC & 0x00000200 ){
115 /* SSSE3 support here */
116 uiCPU |= WELS_CPU_SSSE3;
117 }
118 if( uiFeatureC & 0x00080000 ){
119 /* SSE4.1 support here, 45nm Penryn processor */
120 uiCPU |= WELS_CPU_SSE41;
121 }
122 if( uiFeatureC & 0x00100000 ){
123 /* SSE4.2 support here, next generation Nehalem processor */
124 uiCPU |= WELS_CPU_SSE42;
125 }
126 if ( WelsCPUSupportAVX( uiFeatureA, uiFeatureC ) )
127 {
128 /* AVX supported */
129 uiCPU |= WELS_CPU_AVX;
130 }
131 if ( WelsCPUSupportFMA( uiFeatureA, uiFeatureC ) )
132 {
133 /* AVX FMA supported */
134 uiCPU |= WELS_CPU_FMA;
135 }
136 if ( uiFeatureC & 0x02000000 )
137 {
138 /* AES checking */
139 uiCPU |= WELS_CPU_AES;
140 }
141 if ( uiFeatureC & 0x00400000 )
142 {
143 /* MOVBE checking */
144 uiCPU |= WELS_CPU_MOVBE;
145 }
146
147 if ( pNumberOfLogicProcessors != NULL )
148 {
149 // HTT enabled on chip
150 *pNumberOfLogicProcessors = (uiFeatureB & 0x00ff0000) >> 16; // feature bits: 23-16 on returned EBX
151 }
152
153 WelsCPUId( 0x80000000, &uiFeatureA, &uiFeatureB, &uiFeatureC, &uiFeatureD );
154
155 if( (!strcmp((const str_t*)chVenderName,CPU_Vender_AMD)) && (uiFeatureA>=0x80000001) ){ // confirmed_safe_unsafe_usage
156 WelsCPUId(0x80000001, &uiFeatureA, &uiFeatureB, &uiFeatureC, &uiFeatureD );
157 if( uiFeatureD&0x00400000 ){
158 uiCPU |= WELS_CPU_MMXEXT;
159 }
160 if( uiFeatureD&0x80000000 ){
161 uiCPU |= WELS_CPU_3DNOW;
162 }
163 }
164
165 if( !strcmp((const str_t*)chVenderName,CPU_Vender_INTEL) ){ // confirmed_safe_unsafe_usage
166 int32_t family, model;
167
168 WelsCPUId(1, &uiFeatureA, &uiFeatureB, &uiFeatureC, &uiFeatureD);
169 family = ((uiFeatureA>>8)&0xf) + ((uiFeatureA>>20)&0xff);
170 model = ((uiFeatureA>>4)&0xf) + ((uiFeatureA>>12)&0xf0);
171
172 if( (family==6) && (model==9 || model==13 || model==14) ){
173 uiCPU &= ~(WELS_CPU_SSE2|WELS_CPU_SSE3);
174 }
175 }
176
177 // get cache line size
178 if( (!strcmp((const str_t*)chVenderName,CPU_Vender_INTEL)) || !(strcmp((const str_t*)chVenderName,CPU_Vender_CYRIX)) ){ // confirmed_safe_unsafe_usage
179 WelsCPUId(1, &uiFeatureA, &uiFeatureB, &uiFeatureC, &uiFeatureD);
180
181 CacheLineSize = (uiFeatureB&0xff00)>>5; // ((clflush_line_size >> 8) << 3), CLFLUSH_line_size * 8 = CacheLineSize_in_byte
182
183 if( CacheLineSize == 128 ){
184 uiCPU |= WELS_CPU_CACHELINE_128;
185 }
186 else if( CacheLineSize == 64 ){
187 uiCPU |= WELS_CPU_CACHELINE_64;
188 }
189 else if( CacheLineSize == 32 ){
190 uiCPU |= WELS_CPU_CACHELINE_32;
191 }
192 else if( CacheLineSize == 16 ){
193 uiCPU |= WELS_CPU_CACHELINE_16;
194 }
195 }
196
197 return uiCPU;
198}
199
200
201void WelsCPURestore( const uint32_t kuiCPU )
202{
203 if( kuiCPU & (WELS_CPU_MMX|WELS_CPU_MMXEXT|WELS_CPU_3DNOW|WELS_CPU_3DNOWEXT) )
204 {
205 WelsEmms();
206 }
207}
208
209#endif
210
211} // namespace WelsDec
codec/decoder/core/src/deblocking.cpp+1013−0
@@ -0,0 +1,1013 @@
1/*!
2 * \copy
3 * Copyright (c) 2010-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file deblocking.c
33 *
34 * \brief Interfaces introduced in frame deblocking filtering
35 *
36 * \date 08/02/2010
37 *
38 *************************************************************************************
39 */
40
41#include "deblocking.h"
42#include "cpu_core.h"
43#include "fmo.h"
44
45namespace WelsDec {
46
47#define NO_SUPPORTED_FILTER_IDX (-1)
48#define LEFT_FLAG_BIT 0
49#define TOP_FLAG_BIT 1
50#define LEFT_FLAG_MASK 0x01
51#define TOP_FLAG_MASK 0x02
52
53#define SAME_MB_DIFF_REFIDX
54#define g_kuiAlphaTable(x) g_kuiAlphaTable[(x)+12]
55#define g_kiBetaTable(x) g_kiBetaTable[(x)+12]
56#define g_kiTc0Table(x) g_kiTc0Table[(x)+12]
57
58#define MB_BS_MV(iRefIndex, iMotionVector, iMbXy, iMbBn, iIndex, iNeighIndex) \
59(\
60 ( iRefIndex[iMbXy][iIndex] - iRefIndex[iMbBn][iNeighIndex] )||\
61 ( WELS_ABS( iMotionVector[iMbXy][iIndex][0] - iMotionVector[iMbBn][iNeighIndex][0] ) >= 4 ) ||\
62 ( WELS_ABS( iMotionVector[iMbXy][iIndex][1] - iMotionVector[iMbBn][iNeighIndex][1] ) >= 4 )\
63)
64
65#if defined(SAME_MB_DIFF_REFIDX)
66#define SMB_EDGE_MV(iRefIndex, iMotionVector, iIndex, iNeighIndex) \
67(\
68 ( iRefIndex[iIndex] - iRefIndex[iNeighIndex] )||(\
69 ( WELS_ABS( iMotionVector[iIndex][0] - iMotionVector[iNeighIndex][0] ) &(~3) ) |\
70 ( WELS_ABS( iMotionVector[iIndex][1] - iMotionVector[iNeighIndex][1] ) &(~3) ))\
71)
72#else
73#define SMB_EDGE_MV(iRefIndex, iMotionVector, iIndex, iNeighIndex) \
74(\
75 !!(( WELS_ABS( iMotionVector[iIndex][0] - iMotionVector[iNeighIndex][0] ) &(~3) ) |( WELS_ABS( iMotionVector[iIndex][1] - iMotionVector[iNeighIndex][1] ) &(~3) ))\
76)
77#endif
78
79#define BS_EDGE(bsx1, iRefIndex, iMotionVector, iIndex, iNeighIndex) \
80( (bsx1|SMB_EDGE_MV(iRefIndex, iMotionVector, iIndex, iNeighIndex))<<((uint8_t)(!!bsx1)))
81
82#define GET_ALPHA_BETA_FROM_QP(iQp, iAlphaOffset, iBetaOffset, iIndex, iAlpha, iBeta) \
83{\
84 iIndex = (iQp + iAlphaOffset);\
85 iAlpha = g_kuiAlphaTable(iIndex);\
86 iBeta = g_kiBetaTable((iQp + iBetaOffset));\
87}
88
89static const uint8_t g_kuiAlphaTable[52+24] = { //this table refers to Table 8-16 in H.264/AVC standard
90 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
91 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
92 0, 0, 0, 0, 0, 0, 4, 4, 5, 6,
93 7, 8, 9, 10, 12, 13, 15, 17, 20, 22,
94 25, 28, 32, 36, 40, 45, 50, 56, 63, 71,
95 80, 90,101,113,127,144,162,182,203,226,
96 255, 255
97 ,255, 255,255, 255,255, 255,255, 255,255, 255,255, 255
98};
99
100static const int8_t g_kiBetaTable[52+24] = { //this table refers to Table 8-16 in H.264/AVC standard
101 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
102 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
103 0, 0, 0, 0, 0, 0, 2, 2, 2, 3,
104 3, 3, 3, 4, 4, 4, 6, 6, 7, 7,
105 8, 8, 9, 9, 10, 10, 11, 11, 12, 12,
106 13, 13, 14, 14, 15, 15, 16, 16, 17, 17,
107 18, 18
108 ,18, 18,18, 18,18, 18,18, 18,18, 18,18, 18
109};
110
111static const int8_t g_kiTc0Table[52+24][4] = { //this table refers Table 8-17 in H.264/AVC standard
112 { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 },
113 { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 },
114 { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 },
115 { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 },
116 { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 0 }, { -1, 0, 0, 1 },
117 { -1, 0, 0, 1 }, { -1, 0, 0, 1 }, { -1, 0, 0, 1 }, { -1, 0, 1, 1 }, { -1, 0, 1, 1 }, { -1, 1, 1, 1 },
118 { -1, 1, 1, 1 }, { -1, 1, 1, 1 }, { -1, 1, 1, 1 }, { -1, 1, 1, 2 }, { -1, 1, 1, 2 }, { -1, 1, 1, 2 },
119 { -1, 1, 1, 2 }, { -1, 1, 2, 3 }, { -1, 1, 2, 3 }, { -1, 2, 2, 3 }, { -1, 2, 2, 4 }, { -1, 2, 3, 4 },
120 { -1, 2, 3, 4 }, { -1, 3, 3, 5 }, { -1, 3, 4, 6 }, { -1, 3, 4, 6 }, { -1, 4, 5, 7 }, { -1, 4, 5, 8 },
121 { -1, 4, 6, 9 }, { -1, 5, 7,10 }, { -1, 6, 8,11 }, { -1, 6, 8,13 }, { -1, 7,10,14 }, { -1, 8,11,16 },
122 { -1, 9,12,18 }, { -1, 10,13,20 }, {-1,11,15,23 }, { -1,13,17,25 }
123 ,{ -1,13,17,25 },{ -1,13,17,25 },{ -1,13,17,25 },{ -1,13,17,25 },{ -1,13,17,25 },{ -1,13,17,25 }
124 ,{ -1,13,17,25 },{ -1,13,17,25 },{ -1,13,17,25 },{ -1,13,17,25 },{ -1,13,17,25 },{ -1,13,17,25 }
125};
126
127static const uint8_t g_kuiTableBIdx[2][8] =
128{
129 {0, 4, 8, 12,
130 3, 7, 11, 15},
131
132 {0, 1, 2, 3 ,
133 12, 13, 14, 15},
134};
135
136#define TC0_TBL_LOOKUP(tc, iIndexA, pBS, bChroma) \
137{\
138 tc[0] = g_kiTc0Table(iIndexA)[pBS[0]] + bChroma;\
139 tc[1] = g_kiTc0Table(iIndexA)[pBS[1]] + bChroma;\
140 tc[2] = g_kiTc0Table(iIndexA)[pBS[2]] + bChroma;\
141 tc[3] = g_kiTc0Table(iIndexA)[pBS[3]] + bChroma;\
142}
143
144void_t inline DeblockingBSInsideMBAvsbase( int8_t* pNnzTab, uint8_t nBS[2][4][4], int32_t iLShiftFactor )
145{
146 uint32_t uiNnz32b0, uiNnz32b1, uiNnz32b2, uiNnz32b3;
147 FORCE_STACK_ALIGN_1D( uint8_t, uiBsx3, 4, 4 );
148
149 uiNnz32b0 = *(uint32_t *)(pNnzTab+0);
150 uiNnz32b1 = *(uint32_t *)(pNnzTab+4);
151 uiNnz32b2 = *(uint32_t *)(pNnzTab+8);
152 uiNnz32b3 = *(uint32_t *)(pNnzTab+12);
153
154 *(uint32_t *)uiBsx3 = (uiNnz32b0|(uiNnz32b0>>8))<<iLShiftFactor;
155 nBS[0][1][0] = uiBsx3[0];
156 nBS[0][2][0] = uiBsx3[1];
157 nBS[0][3][0] = uiBsx3[2];
158
159 *(uint32_t *)uiBsx3 = (uiNnz32b1|(uiNnz32b1>>8))<<iLShiftFactor;
160 nBS[0][1][1] = uiBsx3[0];
161 nBS[0][2][1] = uiBsx3[1];
162 nBS[0][3][1] = uiBsx3[2];
163 *(uint32_t *)nBS[1][1] = (uiNnz32b0|uiNnz32b1)<<iLShiftFactor;
164
165 *(uint32_t *)uiBsx3 = (uiNnz32b2|(uiNnz32b2>>8))<<iLShiftFactor;
166 nBS[0][1][2] = uiBsx3[0];
167 nBS[0][2][2] = uiBsx3[1];
168 nBS[0][3][2] = uiBsx3[2];
169 *(uint32_t *)nBS[1][2] = (uiNnz32b1|uiNnz32b2)<<iLShiftFactor;
170
171 *(uint32_t *)uiBsx3 = (uiNnz32b3|(uiNnz32b3>>8))<<iLShiftFactor;
172 nBS[0][1][3] = uiBsx3[0];
173 nBS[0][2][3] = uiBsx3[1];
174 nBS[0][3][3] = uiBsx3[2];
175 *(uint32_t *)nBS[1][3] = (uiNnz32b2|uiNnz32b3)<<iLShiftFactor;
176
177}
178
179void_t static inline DeblockingBSInsideMBNormal( PDqLayer pCurDqLayer, uint8_t nBS[2][4][4], int8_t* pNnzTab, int32_t iMbXy )
180{
181 uint32_t uiNnz32b0, uiNnz32b1, uiNnz32b2, uiNnz32b3;
182 int8_t* iRefIndex = pCurDqLayer->pRefIndex[LIST_0][iMbXy];
183 FORCE_STACK_ALIGN_1D( uint8_t, uiBsx4, 4, 4 );
184
185 uiNnz32b0 = *(uint32_t *)(pNnzTab+0);
186 uiNnz32b1 = *(uint32_t *)(pNnzTab+4);
187 uiNnz32b2 = *(uint32_t *)(pNnzTab+8);
188 uiNnz32b3 = *(uint32_t *)(pNnzTab+12);
189
190 *(uint32_t *)uiBsx4 = (uiNnz32b0|(uiNnz32b0>>8));
191 nBS[0][1][0] = BS_EDGE(uiBsx4[0], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 1, 0);
192 nBS[0][2][0] = BS_EDGE(uiBsx4[1], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 2, 1);
193 nBS[0][3][0] = BS_EDGE(uiBsx4[2], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 3, 2);
194
195 *(uint32_t *)uiBsx4 = (uiNnz32b1|(uiNnz32b1>>8));
196 nBS[0][1][1] = BS_EDGE(uiBsx4[0], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 5, 4);
197 nBS[0][2][1] = BS_EDGE(uiBsx4[1], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 6, 5);
198 nBS[0][3][1] = BS_EDGE(uiBsx4[2], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 7, 6);
199
200 *(uint32_t *)uiBsx4 = (uiNnz32b2|(uiNnz32b2>>8));
201 nBS[0][1][2] = BS_EDGE(uiBsx4[0], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 9, 8);
202 nBS[0][2][2] = BS_EDGE(uiBsx4[1], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 10,9);
203 nBS[0][3][2] = BS_EDGE(uiBsx4[2], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 11,10);
204
205 *(uint32_t *)uiBsx4 = (uiNnz32b3|(uiNnz32b3>>8));
206 nBS[0][1][3] = BS_EDGE(uiBsx4[0], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 13,12);
207 nBS[0][2][3] = BS_EDGE(uiBsx4[1], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 14,13);
208 nBS[0][3][3] = BS_EDGE(uiBsx4[2], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 15,14);
209
210 // horizontal
211 *(uint32_t *)uiBsx4 = (uiNnz32b0|uiNnz32b1);
212 nBS[1][1][0] = BS_EDGE(uiBsx4[0], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 4, 0);
213 nBS[1][1][1] = BS_EDGE(uiBsx4[1], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 5, 1);
214 nBS[1][1][2] = BS_EDGE(uiBsx4[2], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 6, 2);
215 nBS[1][1][3] = BS_EDGE(uiBsx4[3], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 7, 3);
216
217 *(uint32_t *)uiBsx4 = (uiNnz32b1|uiNnz32b2);
218 nBS[1][2][0] = BS_EDGE(uiBsx4[0], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 8, 4);
219 nBS[1][2][1] = BS_EDGE(uiBsx4[1], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 9, 5);
220 nBS[1][2][2] = BS_EDGE(uiBsx4[2], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 10, 6);
221 nBS[1][2][3] = BS_EDGE(uiBsx4[3], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 11, 7);
222
223 *(uint32_t *)uiBsx4 = (uiNnz32b2|uiNnz32b3);
224 nBS[1][3][0] = BS_EDGE(uiBsx4[0], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 12, 8);
225 nBS[1][3][1] = BS_EDGE(uiBsx4[1], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 13, 9);
226 nBS[1][3][2] = BS_EDGE(uiBsx4[2], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 14, 10);
227 nBS[1][3][3] = BS_EDGE(uiBsx4[3], iRefIndex, pCurDqLayer->pMv[LIST_0][iMbXy], 15, 11);
228}
229
230uint32_t DeblockingBsMarginalMBAvcbase( PDqLayer pCurDqLayer, int32_t iEdge, int32_t iNeighMb, int32_t iMbXy)
231{
232 int32_t i;
233 uint32_t uiBSx4;
234 //uint8_t* bS = static_cast<uint8_t*>(&uiBSx4);
235 uint8_t* pBS = (uint8_t*)(&uiBSx4);
236 uint32_t uiBIdx = *(uint32_t *)(&g_kuiTableBIdx[iEdge][0]);
237 uint32_t uiBnIdx = *(uint32_t *)(&g_kuiTableBIdx[iEdge][4]);
238
239 for( i = 0; i < 4; i++ )
240 {
241 if( pCurDqLayer->pNzc[iMbXy][uiBIdx&0xff] | pCurDqLayer->pNzc[iNeighMb][uiBnIdx&0xff] )
242 {
243 pBS[i] = 2;
244 }
245 else
246 {
247 pBS[i] = MB_BS_MV(pCurDqLayer->pRefIndex[LIST_0], pCurDqLayer->pMv[LIST_0], iMbXy, iNeighMb, (uiBIdx&0xff), (uiBnIdx&0xff));
248 }
249 uiBIdx = uiBIdx >> 8;
250 uiBnIdx = uiBnIdx >> 8;
251 }
252 return uiBSx4;
253}
254int32_t DeblockingAvailableNoInterlayer( PDqLayer pCurDqLayer, int32_t iFilterIdc )
255{
256 int32_t iMbY = pCurDqLayer->iMbY;
257 int32_t iMbX = pCurDqLayer->iMbX;
258 int32_t iMbXy = pCurDqLayer->iMbXyIndex;
259 BOOL_T bLeftFlag = FALSE;
260 BOOL_T bTopFlag = FALSE;
261
262 if ( 2 == iFilterIdc )
263 {
264 bLeftFlag = ( iMbX > 0 ) && ( pCurDqLayer->pSliceIdc[iMbXy] == pCurDqLayer->pSliceIdc[iMbXy-1] );
265 bTopFlag = ( iMbY > 0 ) && ( pCurDqLayer->pSliceIdc[iMbXy] == pCurDqLayer->pSliceIdc[iMbXy-pCurDqLayer->iMbWidth] );
266 }
267 else //if ( 0 == iFilterIdc )
268 {
269 bLeftFlag = ( iMbX > 0 );
270 bTopFlag = ( iMbY > 0 );
271 }
272 return (bLeftFlag<<LEFT_FLAG_BIT)|(bTopFlag<<TOP_FLAG_BIT);
273}
274
275void_t FilteringEdgeLumaH(SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS )
276{
277 int32_t iIndexA;
278 int32_t iAlpha;
279 int32_t iBeta;
280 FORCE_STACK_ALIGN_1D( int8_t, tc, 4, 16 );
281
282 GET_ALPHA_BETA_FROM_QP(pFilter->iLumaQP, pFilter->iSliceAlphaC0Offset, pFilter->iSliceBetaOffset, iIndexA, iAlpha, iBeta);
283
284 if( iAlpha | iBeta )
285 {
286 TC0_TBL_LOOKUP(tc, iIndexA, pBS, 0);
287 pFilter->pLoopf->pfLumaDeblockingLT4Ver(pPix, iStride, iAlpha, iBeta, tc);
288 }
289 return;
290}
291
292
293void_t FilteringEdgeLumaV(SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS )
294{
295 int32_t iIndexA;
296 int32_t iAlpha;
297 int32_t iBeta;
298 FORCE_STACK_ALIGN_1D( int8_t, tc, 4, 16 );
299
300 GET_ALPHA_BETA_FROM_QP(pFilter->iLumaQP, pFilter->iSliceAlphaC0Offset, pFilter->iSliceBetaOffset, iIndexA, iAlpha, iBeta);
301
302 if( iAlpha | iBeta )
303 {
304 TC0_TBL_LOOKUP(tc, iIndexA, pBS, 0);
305 pFilter->pLoopf->pfLumaDeblockingLT4Hor(pPix, iStride, iAlpha, iBeta, tc);
306 }
307 return;
308}
309
310
311void_t FilteringEdgeLumaIntraH( SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS )
312{
313 int32_t iIndexA;
314 int32_t iAlpha;
315 int32_t iBeta;
316
317 GET_ALPHA_BETA_FROM_QP(pFilter->iLumaQP, pFilter->iSliceAlphaC0Offset, pFilter->iSliceBetaOffset, iIndexA, iAlpha, iBeta);
318
319 if( iAlpha | iBeta )
320 {
321 pFilter->pLoopf->pfLumaDeblockingEQ4Ver(pPix, iStride, iAlpha, iBeta);
322 }
323 return;
324}
325
326void_t FilteringEdgeLumaIntraV( SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS )
327{
328 int32_t iIndexA;
329 int32_t iAlpha;
330 int32_t iBeta;
331
332 GET_ALPHA_BETA_FROM_QP(pFilter->iLumaQP, pFilter->iSliceAlphaC0Offset, pFilter->iSliceBetaOffset, iIndexA, iAlpha, iBeta);
333
334 if( iAlpha | iBeta )
335 {
336 pFilter->pLoopf->pfLumaDeblockingEQ4Hor(pPix, iStride, iAlpha, iBeta);
337 }
338 return;
339}
340void_t FilteringEdgeChromaH( SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, uint8_t* pBS )
341{
342 int32_t iIndexA;
343 int32_t iAlpha;
344 int32_t iBeta;
345 FORCE_STACK_ALIGN_1D( int8_t, tc, 4, 16 );
346
347 GET_ALPHA_BETA_FROM_QP(pFilter->iChromaQP, pFilter->iSliceAlphaC0Offset, pFilter->iSliceBetaOffset, iIndexA, iAlpha, iBeta);
348
349 if( iAlpha | iBeta )
350 {
351 TC0_TBL_LOOKUP(tc, iIndexA, pBS, 1);
352 pFilter->pLoopf->pfChromaDeblockingLT4Ver(pPixCb, pPixCr, iStride,iAlpha, iBeta, tc);
353 }
354 return;
355}
356void_t FilteringEdgeChromaV( SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, uint8_t* pBS )
357{
358 int32_t iIndexA;
359 int32_t iAlpha;
360 int32_t iBeta;
361 FORCE_STACK_ALIGN_1D( int8_t, tc, 4, 16 );
362
363 GET_ALPHA_BETA_FROM_QP(pFilter->iChromaQP, pFilter->iSliceAlphaC0Offset, pFilter->iSliceBetaOffset, iIndexA, iAlpha, iBeta);
364
365 if( iAlpha | iBeta )
366 {
367 TC0_TBL_LOOKUP(tc, iIndexA, pBS, 1);
368 pFilter->pLoopf->pfChromaDeblockingLT4Hor(pPixCb, pPixCr, iStride, iAlpha, iBeta, tc);
369 }
370 return;
371}
372
373void_t FilteringEdgeChromaIntraH( SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, uint8_t* pBS )
374{
375 int32_t iIndexA;
376 int32_t iAlpha;
377 int32_t iBeta;
378
379 GET_ALPHA_BETA_FROM_QP(pFilter->iChromaQP, pFilter->iSliceAlphaC0Offset, pFilter->iSliceBetaOffset, iIndexA, iAlpha, iBeta);
380
381 if( iAlpha | iBeta )
382 {
383 pFilter->pLoopf->pfChromaDeblockingEQ4Ver(pPixCb, pPixCr, iStride, iAlpha, iBeta);
384 }
385 return;
386}
387
388void_t FilteringEdgeChromaIntraV( SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, uint8_t* pBS )
389{
390 int32_t iIndexA;
391 int32_t iAlpha;
392 int32_t iBeta;
393
394 GET_ALPHA_BETA_FROM_QP(pFilter->iChromaQP, pFilter->iSliceAlphaC0Offset, pFilter->iSliceBetaOffset, iIndexA, iAlpha, iBeta);
395
396 if( iAlpha | iBeta )
397 {
398 pFilter->pLoopf->pfChromaDeblockinEQ4Hor(pPixCb, pPixCr, iStride, iAlpha, iBeta);
399 }
400 return;
401}
402
403
404void_t DeblockingInterMb( PDqLayer pCurDqLayer, PDeblockingFilter pFilter, uint8_t nBS[2][4][4], int32_t iBoundryFlag )
405{
406 int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex;
407 int32_t iMbX = pCurDqLayer->iMbX;
408 int32_t iMbY = pCurDqLayer->iMbY;
409
410 int32_t iCurLumaQp = pCurDqLayer->pLumaQp[iMbXyIndex];
411 int32_t iCurChromaQp = pCurDqLayer->pChromaQp[iMbXyIndex];
412 int32_t iLineSize = pFilter->iCsStride[0];
413 int32_t iLineSizeUV = pFilter->iCsStride[1];
414
415 uint8_t * pDestY, * pDestCb, * pDestCr;
416 pDestY = pFilter->pCsData[0] + ((iMbY * iLineSize + iMbX) << 4);
417 pDestCb = pFilter->pCsData[1] + ((iMbY * iLineSizeUV + iMbX) << 3);
418 pDestCr = pFilter->pCsData[2] + ((iMbY * iLineSizeUV + iMbX) << 3);
419
420 if( iBoundryFlag & LEFT_FLAG_MASK)
421 {
422 int32_t iLeftXyIndex = iMbXyIndex - 1;
423 pFilter->iLumaQP = (iCurLumaQp + pCurDqLayer->pLumaQp[iLeftXyIndex] + 1) >> 1;
424 pFilter->iChromaQP = (iCurChromaQp + pCurDqLayer->pChromaQp[iLeftXyIndex]+ 1) >> 1;
425
426 if( nBS[0][0][0] == 0x04 )
427 {
428 FilteringEdgeLumaIntraV( pFilter, pDestY, iLineSize, NULL );
429 FilteringEdgeChromaIntraV( pFilter, pDestCb, pDestCr, iLineSizeUV, NULL );
430 }
431 else
432 {
433 if(*(uint32_t *)nBS[0][0] != 0)
434 {
435 FilteringEdgeLumaV( pFilter, pDestY, iLineSize, nBS[0][0] );
436 FilteringEdgeChromaV( pFilter, pDestCb, pDestCr, iLineSizeUV, nBS[0][0] );
437 }
438 }
439 }
440
441 pFilter->iLumaQP = iCurLumaQp;
442 pFilter->iChromaQP = iCurChromaQp;
443
444 if(*(uint32_t *)nBS[0][1] != 0)
445 {
446 FilteringEdgeLumaV( pFilter, &pDestY[1<<2], iLineSize, nBS[0][1]);
447 }
448
449 if(*(uint32_t *)nBS[0][2] != 0)
450 {
451 FilteringEdgeLumaV( pFilter, &pDestY[2<<2], iLineSize, nBS[0][2]);
452 FilteringEdgeChromaV( pFilter, &pDestCb[2<<1], &pDestCr[2<<1], iLineSizeUV, nBS[0][2] );
453 }
454
455 if(*(uint32_t *)nBS[0][3] != 0)
456 {
457 FilteringEdgeLumaV( pFilter, &pDestY[3<<2], iLineSize, nBS[0][3] );
458 }
459
460 if( iBoundryFlag & TOP_FLAG_MASK)
461 {
462 int32_t iTopXyIndex = iMbXyIndex - pCurDqLayer->iMbWidth;
463 pFilter->iLumaQP = (iCurLumaQp + pCurDqLayer->pLumaQp[iTopXyIndex] + 1) >> 1;
464 pFilter->iChromaQP = (iCurChromaQp + pCurDqLayer->pChromaQp[iTopXyIndex] + 1) >> 1;
465
466 if( nBS[1][0][0] == 0x04)
467 {
468 FilteringEdgeLumaIntraH( pFilter, pDestY, iLineSize, NULL );
469 FilteringEdgeChromaIntraH( pFilter, pDestCb, pDestCr, iLineSizeUV, NULL );
470 }
471 else
472 {
473 if(*(uint32_t *)nBS[1][0] != 0)
474 {
475 FilteringEdgeLumaH( pFilter, pDestY, iLineSize, nBS[1][0] );
476 FilteringEdgeChromaH( pFilter, pDestCb, pDestCr, iLineSizeUV, nBS[1][0] );
477 }
478 }
479 }
480
481 pFilter->iLumaQP = iCurLumaQp;
482 pFilter->iChromaQP = iCurChromaQp;
483
484 if(*(uint32_t *)nBS[1][1] != 0)
485 {
486 FilteringEdgeLumaH( pFilter, &pDestY[(1<<2)*iLineSize], iLineSize, nBS[1][1] );
487 }
488
489 if(*(uint32_t *)nBS[1][2] != 0)
490 {
491 FilteringEdgeLumaH( pFilter, &pDestY[(2<<2)*iLineSize], iLineSize, nBS[1][2] );
492 FilteringEdgeChromaH( pFilter, &pDestCb[(2<<1)*iLineSizeUV], &pDestCr[(2<<1)*iLineSizeUV], iLineSizeUV, nBS[1][2] );
493 }
494
495 if(*(uint32_t *)nBS[1][3] != 0)
496 {
497 FilteringEdgeLumaH( pFilter, &pDestY[(3<<2)*iLineSize], iLineSize, nBS[1][3] );
498 }
499}
500
501void_t /*__FASTCALL*/ FilteringEdgeLumaHV( PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag )
502{
503 int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex;
504 int32_t iMbX = pCurDqLayer->iMbX;
505 int32_t iMbY = pCurDqLayer->iMbY;
506 int32_t iMbWidth = pCurDqLayer->iMbWidth;
507 int32_t iLineSize = pFilter->iCsStride[0];
508
509 uint8_t *pDestY;
510 int32_t iCurQp;
511 int32_t iIndexA, iAlpha, iBeta;
512
513 FORCE_STACK_ALIGN_1D(int8_t, iTc, 4, 16 );
514 FORCE_STACK_ALIGN_1D(uint8_t, uiBSx4, 4, 4 );
515
516 pDestY = pFilter->pCsData[0] + ((iMbY * iLineSize + iMbX) << 4);
517 iCurQp = pCurDqLayer->pLumaQp[iMbXyIndex];
518
519 *(uint32_t*)uiBSx4 = 0x03030303;
520
521 // luma v
522 if( iBoundryFlag & LEFT_FLAG_MASK)
523 {
524 pFilter->iLumaQP = ( iCurQp + pCurDqLayer->pLumaQp[iMbXyIndex-1] + 1 ) >> 1;
525 FilteringEdgeLumaIntraV( pFilter, pDestY, iLineSize, NULL );
526 }
527
528 pFilter->iLumaQP = iCurQp;
529 GET_ALPHA_BETA_FROM_QP(pFilter->iLumaQP, pFilter->iSliceAlphaC0Offset, pFilter->iSliceBetaOffset, iIndexA, iAlpha, iBeta);
530 if( iAlpha | iBeta )
531 {
532 TC0_TBL_LOOKUP(iTc, iIndexA, uiBSx4, 0);
533 pFilter->pLoopf->pfLumaDeblockingLT4Hor( &pDestY[1 << 2],iLineSize,iAlpha,iBeta,iTc );
534 pFilter->pLoopf->pfLumaDeblockingLT4Hor( &pDestY[2 << 2],iLineSize,iAlpha,iBeta,iTc );
535 pFilter->pLoopf->pfLumaDeblockingLT4Hor( &pDestY[3 << 2],iLineSize,iAlpha,iBeta,iTc );
536 }
537
538 // luma h
539 if( iBoundryFlag & TOP_FLAG_MASK)
540 {
541 pFilter->iLumaQP = ( iCurQp + pCurDqLayer->pLumaQp[iMbXyIndex-iMbWidth] + 1 ) >> 1;
542 FilteringEdgeLumaIntraH( pFilter, pDestY, iLineSize, NULL );
543 }
544
545 pFilter->iLumaQP = iCurQp;
546 if( iAlpha | iBeta )
547 {
548 pFilter->pLoopf->pfLumaDeblockingLT4Ver( &pDestY[(1<<2)*iLineSize],iLineSize,iAlpha,iBeta,iTc );
549 pFilter->pLoopf->pfLumaDeblockingLT4Ver( &pDestY[(2<<2)*iLineSize],iLineSize,iAlpha,iBeta,iTc );
550 pFilter->pLoopf->pfLumaDeblockingLT4Ver( &pDestY[(3<<2)*iLineSize],iLineSize,iAlpha,iBeta,iTc );
551 }
552}
553void_t /*__FASTCALL*/ FilteringEdgeChromaHV( PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag )
554{
555 int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex;
556 int32_t iMbX = pCurDqLayer->iMbX;
557 int32_t iMbY = pCurDqLayer->iMbY;
558 int32_t iMbWidth = pCurDqLayer->iMbWidth;
559 int32_t iLineSize = pFilter->iCsStride[1];
560
561 uint8_t *pDestCb, *pDestCr;
562 int32_t iCurQp;
563 int32_t iIndexA, iAlpha, iBeta;
564
565 FORCE_STACK_ALIGN_1D( int8_t, iTc, 4, 16 );
566 FORCE_STACK_ALIGN_1D( uint8_t, uiBSx4, 4, 4 );
567
568 pDestCb = pFilter->pCsData[1] + ((iMbY * iLineSize + iMbX) << 3);
569 pDestCr = pFilter->pCsData[2] + ((iMbY * iLineSize + iMbX) << 3);
570 iCurQp = pCurDqLayer->pChromaQp[iMbXyIndex];
571 *(uint32_t*)uiBSx4 = 0x03030303;
572
573 // chroma v
574 if( iBoundryFlag & LEFT_FLAG_MASK)
575 {
576 pFilter->iChromaQP = ( iCurQp + pCurDqLayer->pChromaQp[iMbXyIndex-1] + 1 ) >> 1;
577 FilteringEdgeChromaIntraV( pFilter, pDestCb, pDestCr, iLineSize, NULL);
578 }
579
580 pFilter->iChromaQP = iCurQp;
581 GET_ALPHA_BETA_FROM_QP(pFilter->iChromaQP, pFilter->iSliceAlphaC0Offset, pFilter->iSliceBetaOffset, iIndexA, iAlpha, iBeta);
582 if( iAlpha | iBeta )
583 {
584 TC0_TBL_LOOKUP(iTc, iIndexA, uiBSx4, 1);
585 pFilter->pLoopf->pfChromaDeblockingLT4Hor( &pDestCb[2 << 1],&pDestCr[2 << 1],iLineSize,iAlpha,iBeta,iTc );
586 }
587
588 // chroma h
589 if( iBoundryFlag & TOP_FLAG_MASK)
590 {
591 pFilter->iChromaQP = ( iCurQp + pCurDqLayer->pChromaQp[iMbXyIndex-iMbWidth] + 1 ) >> 1;
592 FilteringEdgeChromaIntraH( pFilter, pDestCb, pDestCr, iLineSize, NULL);
593 }
594
595 pFilter->iChromaQP = iCurQp;
596 if( iAlpha | iBeta )
597 {
598 pFilter->pLoopf->pfChromaDeblockingLT4Ver( &pDestCb[(2<<1)*iLineSize],&pDestCr[(2<<1)*iLineSize],iLineSize,iAlpha,iBeta,iTc );
599 }
600}
601
602// merge h&v lookup table operation to save performance
603void_t DeblockingIntraMb( PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag )
604{
605 FilteringEdgeLumaHV(pCurDqLayer, pFilter, iBoundryFlag);
606 FilteringEdgeChromaHV(pCurDqLayer, pFilter, iBoundryFlag);
607}
608
609void_t WelsDeblockingMb( PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag )
610{
611 uint8_t nBS[2][4][4] = { 0 };
612
613 int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex;
614 int32_t iCurMbType = pCurDqLayer->pMbType[iMbXyIndex];
615 int32_t iMbNb;
616
617 switch( iCurMbType )
618 {
619 case MB_TYPE_INTRA4x4:
620 case MB_TYPE_INTRA16x16:
621 case MB_TYPE_INTRA_PCM:
622 DeblockingIntraMb( pCurDqLayer, pFilter, iBoundryFlag );
623 break;
624 default:
625
626 if(iBoundryFlag & LEFT_FLAG_MASK)
627 {
628 iMbNb = iMbXyIndex - 1;
629 *(uint32_t*)nBS[0][0] = IS_INTRA(pCurDqLayer->pMbType[iMbNb])?0x04040404:DeblockingBsMarginalMBAvcbase( pCurDqLayer, 0, iMbNb, iMbXyIndex);
630 }
631 else
632 {
633 *(uint32_t*)nBS[0][0] = 0;
634 }
635 if(iBoundryFlag & TOP_FLAG_MASK)
636 {
637 iMbNb = iMbXyIndex - pCurDqLayer->iMbWidth;
638 *(uint32_t*)nBS[1][0] = IS_INTRA(pCurDqLayer->pMbType[iMbNb])?0x04040404:DeblockingBsMarginalMBAvcbase( pCurDqLayer, 1, iMbNb, iMbXyIndex);
639 }
640 else
641 {
642 *(uint32_t*)nBS[1][0] = 0;
643 }
644 //SKIP MB_16x16 or others
645 if( iCurMbType != MB_TYPE_SKIP )
646 {
647 if( iCurMbType == MB_TYPE_16x16 )
648 {
649 DeblockingBSInsideMBAvsbase( pCurDqLayer->pNzc[iMbXyIndex], nBS, 1 );
650 }
651 else
652 {
653 DeblockingBSInsideMBNormal(pCurDqLayer, nBS, pCurDqLayer->pNzc[iMbXyIndex], iMbXyIndex);
654 }
655 }
656 else
657 {
658 *(uint32_t*)nBS[0][1] = *(uint32_t*)nBS[0][2] = *(uint32_t*)nBS[0][3] =
659 *(uint32_t*)nBS[1][1] = *(uint32_t*)nBS[1][2] = *(uint32_t*)nBS[1][3] = 0;
660 }
661 DeblockingInterMb( pCurDqLayer, pFilter, nBS, iBoundryFlag );
662 break;
663 }
664}
665
666// C code only
667void_t DeblockLumaLt4_c( uint8_t *pPix, int32_t iStrideX,int32_t iStrideY, int32_t iAlpha, int32_t iBeta, int8_t *pTc )
668{
669 for( int32_t i = 0;i<16;i++)
670 {
671 int32_t iTc0 = pTc[i>>2];
672 if(iTc0>=0)
673 {
674 int32_t p0 = pPix[-iStrideX];
675 int32_t p1 = pPix[-2*iStrideX];
676 int32_t p2 = pPix[-3*iStrideX];
677 int32_t q0 = pPix[0];
678 int32_t q1 = pPix[iStrideX];
679 int32_t q2 = pPix[2*iStrideX];
680 bool_t bDetaP0Q0= WELS_ABS( p0 - q0 )<iAlpha;
681 bool_t bDetaP1P0 = WELS_ABS( p1 - p0 ) < iBeta;
682 bool_t bDetaQ1Q0 = WELS_ABS( q1 - q0 ) < iBeta;
683 int32_t iTc = iTc0;
684 if ( bDetaP0Q0&& bDetaP1P0 && bDetaQ1Q0 )
685 {
686 bool_t bDetaP2P0 = WELS_ABS( p2 - p0 ) < iBeta;
687 bool_t bDetaQ2Q0 = WELS_ABS( q2 - q0 ) < iBeta;
688 if ( bDetaP2P0)
689 {
690 pPix[-2*iStrideX] = p1 + WELS_CLIP3( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -iTc0, iTc0 );
691 iTc++;
692 }
693 if (bDetaQ2Q0)
694 {
695 pPix[iStrideX] = q1 + WELS_CLIP3( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -iTc0, iTc0 );
696 iTc++;
697 }
698 int32_t iDeta = WELS_CLIP3( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -iTc, iTc );
699 pPix[-iStrideX] = WELS_CLIP1( p0 + iDeta ); /* p0' */
700 pPix[0] = WELS_CLIP1( q0 - iDeta ); /* q0' */
701 }
702 }
703 pPix +=iStrideY;
704 }
705}
706void_t DeblockLumaEq4_c( uint8_t *pPix, int32_t iStrideX, int32_t iStrideY, int32_t iAlpha, int32_t iBeta )
707{
708 int32_t p0,p1,p2,q0,q1,q2;
709 int32_t iDetaP0Q0;
710 bool_t bDetaP1P0,bDetaQ1Q0;
711 for (int32_t i = 0;i<16;i++)
712 {
713 p0 = pPix[-iStrideX];
714 p1 = pPix[-2*iStrideX];
715 p2 = pPix[-3*iStrideX];
716 q0 = pPix[0];
717 q1 = pPix[iStrideX];
718 q2 = pPix[2*iStrideX];
719 iDetaP0Q0 = WELS_ABS( p0 - q0 );
720 bDetaP1P0 = WELS_ABS( p1 - p0 ) < iBeta;
721 bDetaQ1Q0 = WELS_ABS( q1 - q0 ) < iBeta;
722 if ((iDetaP0Q0<iAlpha) && bDetaP1P0 &&bDetaQ1Q0)
723 {
724 if (iDetaP0Q0< (( iAlpha >> 2 ) + 2 ) )
725 {
726 bool_t bDetaP2P0 = WELS_ABS( p2 - p0 ) < iBeta;
727 bool_t bDetaQ2Q0 = WELS_ABS( q2 - q0 ) < iBeta;
728 if(bDetaP2P0)
729 {
730 const int32_t p3 = pPix[-4*iStrideX];
731 pPix[-iStrideX] = ( p2 + (p1 << 1) + (p0 << 1) + (q0 << 1) + q1 + 4 ) >> 3; //p0
732 pPix[-2*iStrideX] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; //p1
733 pPix[-3*iStrideX] = ( (p3 << 1) + p2 + (p2 << 1) + p1 + p0 + q0 + 4 ) >> 3;//p2
734 }
735 else
736 {
737 pPix[-1*iStrideX] = ( (p1 << 1) + p0 + q1 + 2 ) >> 2; //p0
738 }
739 if (bDetaQ2Q0)
740 {
741 const int32_t q3 = pPix[3*iStrideX];
742 pPix[0] = ( p1 + (p0 << 1) + (q0 << 1) + (q1 << 1) + q2 + 4 ) >> 3; //q0
743 pPix[iStrideX] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; //q1
744 pPix[2*iStrideX] = ( (q3 << 1) + q2 + (q2 << 1) + q1 + q0 + p0 + 4 ) >> 3;//q2
745 }
746 else
747 {
748 pPix[0] = ( (q1 << 1) + q0 + p1 + 2 ) >> 2; //q0
749 }
750 }
751 else
752 {
753 pPix[-iStrideX] = ( (p1 << 1) + p0 + q1 + 2 ) >> 2; //p0
754 pPix[ 0] = ( (q1 << 1) + q0 + p1 + 2 ) >> 2; //q0
755 }
756 }
757 pPix += iStrideY;
758 }
759}
760void_t DeblockLumaLt4V_c( uint8_t *pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *tc )
761{
762 DeblockLumaLt4_c( pPix, iStride, 1, iAlpha, iBeta, tc );
763}
764void_t DeblockLumaLt4H_c( uint8_t *pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *tc )
765{
766 DeblockLumaLt4_c( pPix, 1, iStride, iAlpha, iBeta, tc );
767}
768void_t DeblockLumaEq4V_c( uint8_t *pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta )
769{
770 DeblockLumaEq4_c( pPix, iStride, 1, iAlpha, iBeta);
771}
772void_t DeblockLumaEq4H_c( uint8_t *pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta )
773{
774 DeblockLumaEq4_c( pPix, 1, iStride, iAlpha, iBeta );
775}
776void_t DeblockChromaLt4_c( uint8_t *pPixCb, uint8_t *pPixCr, int32_t iStrideX, int32_t iStrideY, int32_t iAlpha, int32_t iBeta, int8_t *pTc )
777{
778 int32_t p0, p1, q0, q1,iDeta;
779 bool_t bDetaP0Q0,bDetaP1P0,bDetaQ1Q0;
780
781 for(int32_t i = 0;i<8;i++)
782 {
783 int32_t iTc0 = pTc[i>>1];
784 if(iTc0 >0)
785 {
786 p0 = pPixCb[-iStrideX];
787 p1 = pPixCb[-2*iStrideX];
788 q0 = pPixCb[0];
789 q1 = pPixCb[iStrideX];
790
791 bDetaP0Q0 = WELS_ABS( p0 - q0 ) < iAlpha;
792 bDetaP1P0 = WELS_ABS( p1 - p0 ) < iBeta;
793 bDetaQ1Q0 = WELS_ABS( q1 - q0 ) < iBeta;
794 if( bDetaP0Q0&&bDetaP1P0 && bDetaQ1Q0)
795 {
796 iDeta = WELS_CLIP3( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -iTc0, iTc0 );
797 pPixCb[-iStrideX] = WELS_CLIP1( p0 + iDeta ); /* p0' */
798 pPixCb[0] = WELS_CLIP1( q0 - iDeta ); /* q0' */
799 }
800
801
802 p0 = pPixCr[-iStrideX];
803 p1 = pPixCr[-2*iStrideX];
804 q0 = pPixCr[0];
805 q1 = pPixCr[iStrideX];
806
807 bDetaP0Q0 = WELS_ABS( p0 - q0 ) < iAlpha;
808 bDetaP1P0 = WELS_ABS( p1 - p0 ) < iBeta;
809 bDetaQ1Q0 = WELS_ABS( q1 - q0 ) < iBeta;
810
811 if( bDetaP0Q0&&bDetaP1P0 && bDetaQ1Q0)
812 {
813 iDeta = WELS_CLIP3( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -iTc0, iTc0 );
814 pPixCr[-iStrideX] = WELS_CLIP1( p0 + iDeta ); /* p0' */
815 pPixCr[0] = WELS_CLIP1( q0 - iDeta ); /* q0' */
816 }
817 }
818 pPixCb += iStrideY;
819 pPixCr += iStrideY;
820 }
821}
822void_t DeblockChromaEq4_c( uint8_t *pPixCb, uint8_t *pPixCr, int32_t iStrideX, int32_t iStrideY, int32_t iAlpha, int32_t iBeta )
823{
824 int32_t i = 0, d = 0;
825 int32_t p0, p1, q0, q1;
826 bool_t bDetaP0Q0,bDetaP1P0,bDetaQ1Q0;
827 for(int32_t i =0;i<8;i++)
828 {
829 //cb
830 p0 = pPixCb[-iStrideX];
831 p1 = pPixCb[-2*iStrideX];
832 q0 = pPixCb[0];
833 q1 = pPixCb[iStrideX];
834 bDetaP0Q0 = WELS_ABS( p0 - q0 ) < iAlpha;
835 bDetaP1P0 = WELS_ABS( p1 - p0 ) < iBeta;
836 bDetaQ1Q0 = WELS_ABS( q1 - q0 ) < iBeta;
837 if(bDetaP0Q0&&bDetaP1P0&&bDetaQ1Q0)
838 {
839 pPixCb[-iStrideX] = ( (p1 << 1) + p0 + q1 + 2 ) >> 2; /* p0' */
840 pPixCb[0] = ( (q1 << 1) + q0 + p1 + 2 ) >> 2; /* q0' */
841 }
842
843 //cr
844 p0 = pPixCr[-iStrideX];
845 p1 = pPixCr[-2*iStrideX];
846 q0 = pPixCr[0];
847 q1 = pPixCr[iStrideX];
848 bDetaP0Q0 = WELS_ABS( p0 - q0 ) < iAlpha;
849 bDetaP1P0 = WELS_ABS( p1 - p0 ) < iBeta;
850 bDetaQ1Q0 = WELS_ABS( q1 - q0 ) < iBeta;
851 if(bDetaP0Q0&&bDetaP1P0&&bDetaQ1Q0)
852 {
853 pPixCr[-iStrideX] = ( (p1 << 1) + p0 + q1 + 2 ) >> 2; /* p0' */
854 pPixCr[0] = ( (q1 << 1) + q0 + p1 + 2 ) >> 2; /* q0' */
855 }
856 pPixCr += iStrideY;
857 pPixCb += iStrideY;
858 }
859}
860void_t DeblockChromaLt4V_c( uint8_t *pPixCb, uint8_t *pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *tc )
861{
862 DeblockChromaLt4_c( pPixCb, pPixCr, iStride, 1, iAlpha, iBeta, tc );
863}
864void_t DeblockChromaLt4H_c( uint8_t *pPixCb, uint8_t *pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *tc )
865{
866 DeblockChromaLt4_c( pPixCb, pPixCr, 1, iStride, iAlpha, iBeta, tc );
867}
868void_t DeblockChromaEq4V_c( uint8_t *pPixCb, uint8_t *pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta )
869{
870 DeblockChromaEq4_c( pPixCb, pPixCr, iStride, 1, iAlpha, iBeta );
871}
872void_t DeblockChromaEq4H_c( uint8_t *pPixCb, uint8_t *pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta )
873{
874 DeblockChromaEq4_c( pPixCb, pPixCr, 1, iStride, iAlpha, iBeta );
875}
876
877#ifdef X86_ASM
878extern "C" {
879void DeblockLumaLt4H_sse2(uint8_t *pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t *pTc)
880{
881 FORCE_STACK_ALIGN_1D(uint8_t, uiBuf, 16*8, 16);
882
883 DeblockLumaTransposeH2V_sse2(pPixY - 4, iStride, &uiBuf[0]);
884 DeblockLumaLt4V_sse2(&uiBuf[4*16], 16, iAlpha, iBeta, pTc);
885 DeblockLumaTransposeV2H_sse2(pPixY - 4, iStride, &uiBuf[0]);
886}
887
888void DeblockLumaEq4H_sse2(uint8_t *pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta)
889{
890 FORCE_STACK_ALIGN_1D(uint8_t, uiBuf, 16*8, 16);
891
892 DeblockLumaTransposeH2V_sse2(pPixY - 4, iStride, &uiBuf[0]);
893 DeblockLumaEq4V_sse2(&uiBuf[4*16], 16, iAlpha, iBeta);
894 DeblockLumaTransposeV2H_sse2(pPixY - 4, iStride, &uiBuf[0]);
895}
896
897}
898
899#endif
900/*!
901 * \brief AVC slice deblocking filtering target layer
902 *
903 * \param dec Wels avc decoder context
904 *
905 * \return NONE
906 */
907void_t WelsDeblockingFilterSlice( PWelsDecoderContext pCtx, PDeblockingFilterMbFunc pDeblockMb )
908{
909 PDqLayer pCurDqLayer = pCtx->pCurDqLayer;
910 PSliceHeaderExt pSliceHeaderExt = &pCurDqLayer->sLayerInfo.sSliceInLayer.sSliceHeaderExt;
911 int32_t iMbWidth = pCurDqLayer->iMbWidth;
912 int32_t iTotalMbCount = pSliceHeaderExt->sSliceHeader.pSps->uiTotalMbCount;
913
914 SDeblockingFilter pFilter = {0};
915
916 PFmo pFmo = pCtx->pFmo;
917 int32_t iNextMbXyIndex = 0;
918 int32_t iTotalNumMb = pCurDqLayer->sLayerInfo.sSliceInLayer.iTotalMbInCurSlice;
919 int32_t iCountNumMb = 0;
920 int32_t iBoundryFlag;
921 int32_t iFilterIdc = pCurDqLayer->sLayerInfo.sSliceInLayer.sSliceHeaderExt.sSliceHeader.uiDisableDeblockingFilterIdc;
922
923 /* Step1: parameters set */
924 pFilter.pCsData[0] = pCtx->pDec->pData[0];
925 pFilter.pCsData[1] = pCtx->pDec->pData[1];
926 pFilter.pCsData[2] = pCtx->pDec->pData[2];
927
928 pFilter.iCsStride[0] = pCtx->pDec->iLinesize[0];
929 pFilter.iCsStride[1] = pCtx->pDec->iLinesize[1];
930
931 pFilter.eSliceType = (ESliceType) pCurDqLayer->sLayerInfo.sSliceInLayer.eSliceType;
932
933 pFilter.iSliceAlphaC0Offset = pSliceHeaderExt->sSliceHeader.iSliceAlphaC0Offset;
934 pFilter.iSliceBetaOffset = pSliceHeaderExt->sSliceHeader.iSliceBetaOffset;
935
936 pFilter.pLoopf = &pCtx->sDeblockingFunc;
937
938 /* Step2: macroblock deblocking */
939 if( 0 == iFilterIdc || 2 == iFilterIdc )
940 {
941 iNextMbXyIndex = pSliceHeaderExt->sSliceHeader.iFirstMbInSlice;
942 pCurDqLayer->iMbX = iNextMbXyIndex % iMbWidth;
943 pCurDqLayer->iMbY = iNextMbXyIndex / iMbWidth;
944 pCurDqLayer->iMbXyIndex = iNextMbXyIndex;
945
946 do
947 {
948 iBoundryFlag = DeblockingAvailableNoInterlayer(pCurDqLayer, iFilterIdc);
949
950 pDeblockMb( pCurDqLayer, &pFilter, iBoundryFlag );
951
952 ++iCountNumMb;
953 if ( iCountNumMb >= iTotalNumMb )
954 {
955 break;
956 }
957
958 if ( pSliceHeaderExt->sSliceHeader.pPps->uiNumSliceGroups > 1 )
959 {
960 iNextMbXyIndex = FmoNextMb( pFmo, iNextMbXyIndex );
961 }
962 else
963 {
964 ++iNextMbXyIndex;
965 }
966 if ( -1 == iNextMbXyIndex || iNextMbXyIndex >= iTotalMbCount ) // slice group boundary or end of a frame
967 {
968 break;
969 }
970
971 pCurDqLayer->iMbX = iNextMbXyIndex % iMbWidth;
972 pCurDqLayer->iMbY = iNextMbXyIndex / iMbWidth;
973 pCurDqLayer->iMbXyIndex = iNextMbXyIndex;
974 } while ( 1 );
975 }
976}
977/*!
978 * \brief deblocking module initialize
979 *
980 * \param pf
981 * cpu
982 *
983 * \return NONE
984 */
985
986void_t DeblockingInit( SDeblockingFunc *pFunc, int32_t iCpu )
987{
988 pFunc->pfLumaDeblockingLT4Ver = DeblockLumaLt4V_c;
989 pFunc->pfLumaDeblockingEQ4Ver = DeblockLumaEq4V_c;
990 pFunc->pfLumaDeblockingLT4Hor = DeblockLumaLt4H_c;
991 pFunc->pfLumaDeblockingEQ4Hor = DeblockLumaEq4H_c;
992
993 pFunc->pfChromaDeblockingLT4Ver = DeblockChromaLt4V_c;
994 pFunc->pfChromaDeblockingEQ4Ver = DeblockChromaEq4V_c;
995 pFunc->pfChromaDeblockingLT4Hor = DeblockChromaLt4H_c;
996 pFunc->pfChromaDeblockinEQ4Hor = DeblockChromaEq4H_c;
997
998#ifdef X86_ASM
999 if( iCpu & WELS_CPU_SSE2 ){
1000 pFunc->pfLumaDeblockingLT4Ver = DeblockLumaLt4V_sse2;
1001 pFunc->pfLumaDeblockingEQ4Ver = DeblockLumaEq4V_sse2;
1002 pFunc->pfLumaDeblockingLT4Hor = DeblockLumaLt4H_sse2;
1003 pFunc->pfLumaDeblockingEQ4Hor = DeblockLumaEq4H_sse2;
1004 pFunc->pfChromaDeblockingLT4Ver = DeblockChromaLt4V_sse2;
1005 pFunc->pfChromaDeblockingEQ4Ver = DeblockChromaEq4V_sse2;
1006 pFunc->pfChromaDeblockingLT4Hor = DeblockChromaLt4H_sse2;
1007 pFunc->pfChromaDeblockinEQ4Hor = DeblockChromaEq4H_sse2;
1008 }
1009#endif
1010
1011}
1012
1013} // namespace WelsDec
codec/decoder/core/src/decode_mb_aux.cpp+134−0
@@ -0,0 +1,134 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33#include <string.h>
34
35#include "decode_mb_aux.h"
36#include "wels_common_basis.h"
37
38namespace WelsDec {
39
40#define MAX_NEG_CROP 1024
41uint8_t g_ClipTable[256 + 2 * MAX_NEG_CROP]; //the front 1024 is 0, the back 1024 is 255, the middle 256 elements is 0-255
42
43
44/* init pClip table to pClip the final dct data */
45void_t InitDctClipTable(void_t)
46{
47 uint8_t *p = &g_ClipTable[0];
48 const int32_t kiLength = MAX_NEG_CROP * sizeof(uint8_t);
49 int32_t i = 0;
50
51 do
52 {
53 const int32_t kiIdx = MAX_NEG_CROP + i;
54
55 p[kiIdx] = i;
56 p[1+kiIdx] = 1+i;
57 p[2+kiIdx] = 2+i;
58 p[3+kiIdx] = 3+i;
59
60 i += 4;
61 } while(i < 256);
62
63 memset( p, 0, kiLength);
64 memset( p + MAX_NEG_CROP + 256, 0xFF, kiLength);
65}
66
67//NOTE::: p_RS should NOT be modified and it will lead to mismatch with JSVM.
68// so should allocate kA array to store the temporary value (idct).
69void_t IdctResAddPred_c(uint8_t *pPred, const int32_t kiStride, int16_t *pRs)
70{
71 int16_t iSrc[16];
72
73 uint8_t *pDst = pPred;
74 const int32_t kiStride2 = kiStride<<1;
75 const int32_t kiStride3 = kiStride + kiStride2;
76 uint8_t *pClip = &g_ClipTable[MAX_NEG_CROP];
77 int32_t i;
78
79 for(i=0; i<4; i++)
80 {
81 const int32_t kiY = i<<2;
82 const int32_t kiT0 = pRs[kiY] + pRs[kiY+2];
83 const int32_t kiT1 = pRs[kiY] - pRs[kiY+2];
84 const int32_t kiT2 = (pRs[kiY+1]>>1) - pRs[kiY+3];
85 const int32_t kiT3 = pRs[kiY+1] + (pRs[kiY+3]>>1);
86
87 iSrc[kiY] = kiT0 + kiT3;
88 iSrc[kiY+1] = kiT1 + kiT2;
89 iSrc[kiY+2] = kiT1 - kiT2;
90 iSrc[kiY+3] = kiT0 - kiT3;
91 }
92
93 for(i=0; i<4; i++)
94 {
95 int32_t kT1 = iSrc[i] + iSrc[i+8];
96 int32_t kT2 = iSrc[i+4] + (iSrc[i+12]>>1);
97 int32_t kT3 = (32 + kT1 + kT2) >> 6;
98 int32_t kT4 = (32 + kT1 - kT2) >> 6;
99
100 pDst[i] = pClip[ kT3 + pPred[i] ];
101 pDst[i+kiStride3] = pClip[ kT4 + pPred[i+kiStride3] ];
102
103 kT1 = iSrc[i] - iSrc[i+8];
104 kT2 = (iSrc[i+4]>>1) - iSrc[i+12];
105 pDst[i+kiStride] = pClip[ ((32 + kT1 + kT2) >> 6) + pDst[i+kiStride] ];
106 pDst[i+kiStride2] = pClip[ ((32 + kT1 - kT2) >> 6) + pDst[i+kiStride2] ];
107 }
108}
109
110void_t GetI4LumaIChromaAddrTable(int32_t *pBlockOffset, const int32_t kiYStride, const int32_t kiUVStride)
111{
112 int32_t *pOffset = pBlockOffset;
113 int32_t i;
114 const uint8_t kuiScan0 = g_kuiScan8[0];
115
116 for(i=0; i<16; i++)
117 {
118 const uint32_t kuiA = g_kuiScan8[i] - kuiScan0;
119 const uint32_t kuiX = kuiA & 0x07;
120 const uint32_t kuiY = kuiA >> 3;
121
122 pOffset[i]= (kuiX + kiYStride* kuiY) << 2;
123 }
124
125 for(i=0; i<4; i++)
126 {
127 const uint32_t kuiA = g_kuiScan8[i] - kuiScan0;
128
129 pOffset[16+i]=
130 pOffset[20+i]= ((kuiA & 0x07) + (kiUVStride/*>>1*/) * (kuiA >> 3)) << 2;
131 }
132}
133
134} // namespace WelsDec
codec/decoder/core/src/decode_slice.cpp+1361−0
@@ -0,0 +1,1361 @@
1/*!
2 * \copy
3 * Copyright (c) 2008-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * Abstract
33 * current slice decoding
34 *
35 * History
36 * 07/10/2008 Created
37 * 08/09/2013 Modified
38 *
39 *****************************************************************************/
40#include <memory.h>
41
42#include "typedefs.h"
43#include "dec_golomb.h"
44
45#include "fmo.h"
46#include "deblocking.h"
47#include "utils.h"
48
49#include "decode_slice.h"
50
51#include "error_code.h"
52#include "decode_mb_aux.h"
53#include "parse_mb_syn_cavlc.h"
54#include "rec_mb.h"
55#include "mv_pred.h"
56
57#include "as264_common.h"
58#include "cpu_core.h"
59#include "expand_pic.h"
60
61namespace WelsDec {
62
63int32_t WelsTargetSliceConstruction( PWelsDecoderContext pCtx )
64{
65 int32_t iPreQP = 0;
66
67 PDqLayer pCurLayer = pCtx->pCurDqLayer;
68 PSlice pCurSlice = &pCurLayer->sLayerInfo.sSliceInLayer;
69 PSliceHeader pSliceHeader = &pCurSlice->sSliceHeaderExt.sSliceHeader;
70
71 int32_t iTotalMbTargetLayer = pSliceHeader->pSps->uiTotalMbCount;
72
73 int32_t iCurLayerWidth = pCurLayer->iMbWidth << 4;
74 int32_t iCurLayerHeight = pCurLayer->iMbHeight << 4;
75
76 int32_t iNextMbXyIndex = 0;
77 PFmo pFmo = pCtx->pFmo;
78
79 int32_t iTotalNumMb = pCurSlice->iTotalMbInCurSlice;
80 int32_t iCountNumMb = 0;
81 PDeblockingFilterMbFunc pDeblockMb;
82
83 if ( !pCtx->bAvcBasedFlag && iCurLayerWidth != pCtx->iCurSeqIntervalMaxPicWidth )
84 {
85 return -1;
86 }
87
88 iNextMbXyIndex = pSliceHeader->iFirstMbInSlice;
89 pCurLayer->iMbX = iNextMbXyIndex % pCurLayer->iMbWidth;
90 pCurLayer->iMbY = iNextMbXyIndex / pCurLayer->iMbWidth;
91 pCurLayer->iMbXyIndex = iNextMbXyIndex;
92
93 if ( 0 == iNextMbXyIndex )
94 {
95 pCurLayer->pDec->iSpsId = pSliceHeader->iSpsId;
96 pCurLayer->pDec->iPpsId = pSliceHeader->iPpsId;
97
98 pCurLayer->pDec->uiQualityId = pCurLayer->sLayerInfo.sNalHeaderExt.uiQualityId;
99 }
100
101 do
102 {
103 iPreQP = pCurLayer->pLumaQp[pCurLayer->iMbXyIndex];
104
105 if ( WelsTargetMbConstruction( pCtx ) )
106 {
107 WelsLog( pCtx, WELS_LOG_WARNING, "WelsTargetSliceConstruction():::MB(%d, %d) construction error. pCurSlice_type:%d\n",
108 pCurLayer->iMbX, pCurLayer->iMbY, pCurSlice->eSliceType );
109
110 return -1;
111 }
112
113 ++iCountNumMb;
114 ++pCurLayer->pDec->iTotalNumMbRec;
115 if ( iCountNumMb >= iTotalNumMb )
116 {
117 break;
118 }
119 if ( pCurLayer->pDec->iTotalNumMbRec > iTotalMbTargetLayer )
120 {
121 WelsLog( pCtx, WELS_LOG_WARNING, "WelsTargetSliceConstruction():::fdec->iTotalNumMbRec:%d, iTotalMbTargetLayer:%d\n",
122 pCurLayer->pDec->iTotalNumMbRec, iTotalMbTargetLayer );
123
124 return -1;
125 }
126
127 if ( pSliceHeader->pPps->uiNumSliceGroups > 1 )
128 {
129 iNextMbXyIndex = FmoNextMb( pFmo, iNextMbXyIndex );
130 }
131 else
132 {
133 ++iNextMbXyIndex;
134 }
135 if ( -1 == iNextMbXyIndex || iNextMbXyIndex >= iTotalMbTargetLayer ) // slice group boundary or end of a frame
136 {
137 break;
138 }
139 pCurLayer->iMbX = iNextMbXyIndex % pCurLayer->iMbWidth;
140 pCurLayer->iMbY = iNextMbXyIndex / pCurLayer->iMbWidth;
141 pCurLayer->iMbXyIndex = iNextMbXyIndex;
142 } while (1);
143
144 pCtx->pDec->iWidthInPixel = iCurLayerWidth;
145 pCtx->pDec->iHeightInPixel = iCurLayerHeight;
146
147 if((pCurSlice->eSliceType != I_SLICE)&&(pCurSlice->eSliceType != P_SLICE))
148 return 0;
149
150 pDeblockMb = WelsDeblockingMb;
151
152 if ( 1 == pSliceHeader->uiDisableDeblockingFilterIdc )
153 {
154 return 0;//NO_SUPPORTED_FILTER_IDX
155 }
156 else
157 {
158 WelsDeblockingFilterSlice( pCtx, pDeblockMb );
159
160 }
161 // any other filter_idc not supported here, 7/22/2010
162
163 return 0;
164}
165
166int32_t WelsMbInterSampleConstruction( PWelsDecoderContext pCtx, PDqLayer pCurLayer,
167 uint8_t* pDstY, uint8_t* pDstU, uint8_t* pDstV, int32_t iStrideL, int32_t iStrideC )
168{
169 int32_t iMbXy = pCurLayer->iMbXyIndex;
170 int32_t i, iIndex, iOffset;
171
172 WelsChromaDcIdct( pCurLayer->pScaledTCoeff[iMbXy] + 256 ); // 256 = 16*16
173 WelsChromaDcIdct( pCurLayer->pScaledTCoeff[iMbXy] + 320 ); // 320 = 16*16 + 16*4
174
175 for(i=0; i<16; i++) //luma
176 {
177 iIndex = g_kuiMbNonZeroCountIdx[i];
178 if( pCurLayer->pNzc[iMbXy][iIndex] )
179 {
180 iOffset = ((iIndex>>2)<<2) * iStrideL + ((iIndex%4)<<2);
181 pCtx->pIdctResAddPredFunc( pDstY+iOffset, iStrideL, pCurLayer->pScaledTCoeff[iMbXy]+(i<<4) );
182 }
183 }
184
185 for ( i = 0; i < 4; i++ ) //chroma
186 {
187 iIndex = g_kuiMbNonZeroCountIdx[i+16]; //Cb
188 if ( pCurLayer->pNzc[iMbXy][iIndex] || *(pCurLayer->pScaledTCoeff[iMbXy]+((i+16)<<4)) )
189 {
190 iOffset = (((iIndex-16)>>2)<<2) * iStrideC + (((iIndex-16)%4)<<2);
191 pCtx->pIdctResAddPredFunc( pDstU+iOffset, iStrideC, pCurLayer->pScaledTCoeff[iMbXy]+((i+16)<<4) );
192 }
193
194 iIndex = g_kuiMbNonZeroCountIdx[i+20]; //Cr
195 if ( pCurLayer->pNzc[iMbXy][iIndex] || *(pCurLayer->pScaledTCoeff[iMbXy]+((i+20)<<4)) )
196 {
197 iOffset = (((iIndex-18)>>2)<<2) * iStrideC + (((iIndex-18)%4)<<2);
198 pCtx->pIdctResAddPredFunc( pDstV+iOffset, iStrideC , pCurLayer->pScaledTCoeff[iMbXy]+((i+20)<<4));
199 }
200 }
201
202 return 0;
203}
204int32_t WelsMbInterConstruction(PWelsDecoderContext pCtx, PDqLayer pCurLayer)
205{
206 int32_t iMbX = pCurLayer->iMbX;
207 int32_t iMbY = pCurLayer->iMbY;
208 uint8_t *pDstY, *pDstCb, *pDstCr;
209
210 int32_t iLumaStride = pCtx->pDec->iLinesize[0];
211 int32_t iChromaStride = pCtx->pDec->iLinesize[1];
212
213 pDstY = pCurLayer->pDec->pData[0] + ((iMbY * iLumaStride + iMbX)<<4);
214 pDstCb = pCurLayer->pDec->pData[1] + ((iMbY * iChromaStride + iMbX)<<3);
215 pDstCr = pCurLayer->pDec->pData[2] + ((iMbY * iChromaStride + iMbX)<<3);
216
217 GetInterPred(pDstY, pDstCb, pDstCr, pCtx);
218 WelsMbInterSampleConstruction( pCtx, pCurLayer, pDstY, pDstCb, pDstCr, iLumaStride, iChromaStride );
219
220 pCtx->sBlockFunc.pWelsSetNonZeroCountFunc(NULL, pCurLayer->pNzc[pCurLayer->iMbXyIndex]);// set all none-zero nzc to 1; dbk can be opti!
221 return 0;
222}
223
224void_t WelsLumaDcDequantIdct(int16_t *pBlock, int32_t iQp){
225 const int32_t kiQMul= g_kuiDequantCoeff[iQp][0];
226#define STRIDE 16
227 int32_t i;
228 int32_t iTemp[16]; //FIXME check if this is a good idea
229 int16_t* pBlk = pBlock;
230 static const int32_t kiXOffset[4]={0, STRIDE, STRIDE<<2, 5*STRIDE};
231 static const int32_t kiYOffset[4]={0, STRIDE<<1, STRIDE<<3, 10*STRIDE};
232
233 for(i=0; i<4; i++){
234 const int32_t kiOffset= kiYOffset[i];
235 const int32_t kiX1 = kiOffset + kiXOffset[2];
236 const int32_t kiX2 = STRIDE + kiOffset;
237 const int32_t kiX3 = kiOffset + kiXOffset[3];
238 const int32_t kiI4 = i << 2; // 4*i
239 const int32_t kiZ0= pBlk[kiOffset] + pBlk[kiX1];
240 const int32_t kiZ1= pBlk[kiOffset] - pBlk[kiX1];
241 const int32_t kiZ2= pBlk[kiX2] - pBlk[kiX3];
242 const int32_t kiZ3= pBlk[kiX2] + pBlk[kiX3];
243
244 iTemp[kiI4] = kiZ0+kiZ3;
245 iTemp[1+kiI4]= kiZ1+kiZ2;
246 iTemp[2+kiI4]= kiZ1-kiZ2;
247 iTemp[3+kiI4]= kiZ0-kiZ3;
248 }
249
250 for(i=0; i<4; i++){
251 const int32_t kiOffset= kiXOffset[i];
252 const int32_t kiI4 = 4 + i;
253 const int32_t kiZ0= iTemp[i] + iTemp[4+kiI4];
254 const int32_t kiZ1= iTemp[i] - iTemp[4+kiI4];
255 const int32_t kiZ2= iTemp[kiI4] - iTemp[8+kiI4];
256 const int32_t kiZ3= iTemp[kiI4] + iTemp[8+kiI4];
257
258 pBlk[kiOffset]= ((kiZ0 + kiZ3)*kiQMul + 2)>>2; //FIXME think about merging this into decode_resdual
259 pBlk[kiYOffset[1] +kiOffset]= ((kiZ1 + kiZ2)*kiQMul + 2)>>2;
260 pBlk[kiYOffset[2] +kiOffset]= ((kiZ1 - kiZ2)*kiQMul + 2)>>2;
261 pBlk[kiYOffset[3] +kiOffset]= ((kiZ0 - kiZ3)*kiQMul + 2)>>2;
262 }
263 #undef STRIDE
264}
265
266int32_t WelsMbIntraPredictionConstruction(PWelsDecoderContext pCtx, PDqLayer pCurLayer, bool_t bOutput)
267{
268//seems IPCM should not enter this path
269 int32_t iMbXy = pCurLayer->iMbXyIndex;
270
271 FORCE_STACK_ALIGN_1D( int16_t, pTempScaledTCoeff, MB_COEFF_LIST_SIZE, 16 );
272
273 memcpy(pTempScaledTCoeff, pCurLayer->pScaledTCoeff[iMbXy], 384*sizeof(pCurLayer->pScaledTCoeff[iMbXy][0]));
274
275 WelsFillRecNeededMbInfo(pCtx, bOutput, pCurLayer);
276
277 if(IS_INTRA16x16(pCurLayer->pMbType[iMbXy]))
278 {
279 int32_t i,j;
280 // really need?
281 for(i=0; i<16; i++)
282 {
283 j = g_kuiLumaDcZigzagScan[i];
284 pTempScaledTCoeff[j] = pCurLayer->pScaledTCoeff[iMbXy][j];
285 }
286 WelsLumaDcDequantIdct(pTempScaledTCoeff, pCurLayer->pLumaQp[iMbXy]);
287 RecI16x16Mb(iMbXy, pCtx,pTempScaledTCoeff,pCurLayer);
288
289 return 0;
290 }
291
292 if(IS_INTRA4x4(pCurLayer->pMbType[iMbXy]))
293 RecI4x4Mb(iMbXy, pCtx,pTempScaledTCoeff,pCurLayer);
294
295 return 0;
296}
297
298int32_t WelsMbInterPrediction(PWelsDecoderContext pCtx, PDqLayer pCurLayer)
299{
300 int32_t iMbX = pCurLayer->iMbX;
301 int32_t iMbY = pCurLayer->iMbY;
302 uint8_t *pDstY, *pDstCb, *pDstCr;
303
304 int32_t iLumaStride = pCtx->pDec->iLinesize[0];
305 int32_t iChromaStride = pCtx->pDec->iLinesize[1];
306
307 pDstY = pCurLayer->pDec->pData[0] + ((iMbY * iLumaStride + iMbX)<<4);
308 pDstCb = pCurLayer->pDec->pData[1] + ((iMbY * iChromaStride + iMbX)<<3);
309 pDstCr = pCurLayer->pDec->pData[2] + ((iMbY * iChromaStride + iMbX)<<3);
310
311 GetInterPred(pDstY, pDstCb, pDstCr, pCtx);
312
313 return 0;
314}
315
316void_t WelsMbCopy( uint8_t *pDst, int32_t iStrideDst, uint8_t *pSrc, int32_t iStrideSrc,
317 int32_t iHeight, int32_t iWidth )
318{
319 int32_t i;
320 int32_t iOffsetDst = 0, iOffsetSrc = 0;
321 for ( i = 0; i < iHeight; i++ )
322 {
323 memcpy( pDst+iOffsetDst, pSrc+iOffsetSrc, iWidth );
324 iOffsetDst += iStrideDst;
325 iOffsetSrc += iStrideSrc;
326 }
327}
328
329
330int32_t WelsTargetMbConstruction(PWelsDecoderContext pCtx)
331{
332 PDqLayer pCurLayer = pCtx->pCurDqLayer;
333 if ( MB_TYPE_INTRA_PCM == pCurLayer->pMbType[pCurLayer->iMbXyIndex] )
334 {
335 //copy cs into fdec
336 int32_t iCsStrideL = pCurLayer->iCsStride[0];
337 int32_t iCsStrideC = pCurLayer->iCsStride[1];
338
339 int32_t iDecStrideL = pCurLayer->pDec->iLinesize[0];
340 int32_t iDecStrideC = pCurLayer->pDec->iLinesize[1];
341
342 int32_t iCsOffsetL = ( pCurLayer->iMbX + pCurLayer->iMbY * iCsStrideL ) << 4;
343 int32_t iCsOffsetC = ( pCurLayer->iMbX + pCurLayer->iMbY * iCsStrideC ) << 3;
344
345 int32_t iDecOffsetL = ( pCurLayer->iMbX + pCurLayer->iMbY * iDecStrideL ) << 4;
346 int32_t iDecOffsetC = ( pCurLayer->iMbX + pCurLayer->iMbY * iDecStrideC ) << 3;
347
348 uint8_t* pSrcY = pCurLayer->pCsData[0] + iCsOffsetL;
349 uint8_t* pSrcU = pCurLayer->pCsData[1] + iCsOffsetC;
350 uint8_t* pSrcV = pCurLayer->pCsData[2] + iCsOffsetC;
351
352 uint8_t* pDecY = pCurLayer->pDec->pData[0] + iDecOffsetL;
353 uint8_t* pDecU = pCurLayer->pDec->pData[1] + iDecOffsetC;
354 uint8_t* pDecV = pCurLayer->pDec->pData[2] + iDecOffsetC;
355
356 WelsMbCopy( pDecY, iDecStrideL, pSrcY, iCsStrideL, 16, 16 );
357 WelsMbCopy( pDecU, iDecStrideC, pSrcU, iCsStrideC, 8, 8 );
358 WelsMbCopy( pDecV, iDecStrideC, pSrcV, iCsStrideC, 8, 8 );
359
360 return 0;
361 }
362 else if(IS_INTRA(pCurLayer->pMbType[pCurLayer->iMbXyIndex]))
363 {
364 WelsMbIntraPredictionConstruction(pCtx, pCurLayer, 1);
365 }
366 else if ( IS_INTER( pCurLayer->pMbType[pCurLayer->iMbXyIndex] ) ) //InterMB
367 {
368 if ( 0 == pCurLayer->pCbp[pCurLayer->iMbXyIndex] ) //uiCbp==0 include SKIP
369 {
370 WelsMbInterPrediction( pCtx, pCurLayer );
371 }
372 else
373 {
374 WelsMbInterConstruction( pCtx, pCurLayer );
375 }
376 }
377 else
378 {
379 WelsLog( pCtx, WELS_LOG_WARNING, "WelsTargetMbConstruction():::::Unknown MB type: %d\n", pCurLayer->pMbType[pCurLayer->iMbXyIndex] );
380 return -1;
381 }
382
383 return 0;
384}
385
386void_t WelsChromaDcIdct( int16_t *pBlock )
387{
388 int32_t iStride= 32;
389 int32_t iXStride= 16;
390 int32_t iStride1 = iXStride + iStride;
391 int16_t* pBlk = pBlock;
392 int32_t iA,iB,iC,iD,iE;
393
394 iA= pBlk[0];
395 iB= pBlk[iXStride];
396 iC= pBlk[iStride];
397 iD= pBlk[iStride1];
398
399 iE = iA-iB;
400 iA += iB;
401 iB = iC-iD;
402 iC += iD;
403
404 pBlk[0]= (iA+iC) >> 1;
405 pBlk[iXStride]= (iE+iB) >> 1;
406 pBlk[iStride]= (iA-iC) >> 1;
407 pBlk[iStride1]= (iE-iB) >> 1;
408}
409
410int32_t WelsDecodeSlice(PWelsDecoderContext pCtx, bool_t bFirstSliceInLayer, PNalUnit pNalCur)
411{
412 PDqLayer pCurLayer = pCtx->pCurDqLayer;
413 PFmo pFmo = pCtx->pFmo;
414 int32_t i, iRet;
415 int32_t iNextMbXyIndex, iSliceIdc;
416
417 PSlice pSlice = &pCurLayer->sLayerInfo.sSliceInLayer;
418 PSliceHeaderExt pSliceHeaderExt = &pSlice->sSliceHeaderExt;
419 PSliceHeader pSliceHeader = &pSliceHeaderExt->sSliceHeader;
420 int32_t iMbX, iMbY;
421 const int32_t kiCountNumMb = pSliceHeader->pSps->uiTotalMbCount; //need to be correct when fmo or multi slice
422 PBitStringAux pBs = pCurLayer->pBitStringAux;
423 int32_t iUsedBits = 0;
424
425 PWelsDecMbCavlcFunc pDecMbCavlcFunc;
426
427 pSlice->iTotalMbInCurSlice = 0; //initialize at the starting of slice decoding.
428
429 if ( P_SLICE == pSliceHeader->eSliceType )
430 {
431 pDecMbCavlcFunc = WelsDecodeMbCavlcPSlice;
432 }
433 else //I_SLICE
434 {
435 pDecMbCavlcFunc = WelsDecodeMbCavlcISlice;
436 }
437
438 if ( pSliceHeader->pPps->bConstainedIntraPredFlag )
439 {
440 pCtx->pFillInfoCacheIntra4x4Func = WelsFillCacheConstrain1Intra4x4;
441 pCtx->pParseIntra4x4ModeFunc = ParseIntra4x4ModeConstrain1;
442 pCtx->pParseIntra16x16ModeFunc = ParseIntra16x16ModeConstrain1;
443 }
444 else
445 {
446 pCtx->pFillInfoCacheIntra4x4Func = WelsFillCacheConstrain0Intra4x4;
447 pCtx->pParseIntra4x4ModeFunc = ParseIntra4x4ModeConstrain0;
448 pCtx->pParseIntra16x16ModeFunc = ParseIntra16x16ModeConstrain0;
449 }
450
451 pCtx->eSliceType = pSliceHeader->eSliceType;
452
453 if (pCurLayer->sLayerInfo.pPps->bEntropyCodingModeFlag == 1)
454 {
455 //CABAC encoding is unsupported yet!
456 return -1;
457 }
458
459 iNextMbXyIndex = pSliceHeader->iFirstMbInSlice;
460
461 if ( iNextMbXyIndex >= kiCountNumMb )
462 {
463 WelsLog(pCtx, WELS_LOG_ERROR, "WelsDecodeSlice()::iFirstMbInSlice(%d) > pSps->kiTotalMb(%d). ERROR!!! resolution change....\n",
464 iNextMbXyIndex, kiCountNumMb);
465 pCtx->iErrorCode |= dsNoParamSets;
466 return dsNoParamSets;
467 }
468
469 iMbX = iNextMbXyIndex % pCurLayer->iMbWidth;
470 iMbY = iNextMbXyIndex / pCurLayer->iMbWidth; // error is introduced by multiple slices case, 11/23/2009
471 pSlice->iMbSkipRun = -1;
472 iSliceIdc = (pSliceHeader->iFirstMbInSlice<<7)+pCurLayer->uiLayerDqId;
473
474 pCurLayer->iMbX = iMbX;
475 pCurLayer->iMbY = iMbY;
476 pCurLayer->iMbXyIndex = iNextMbXyIndex;
477
478 if(pSliceHeaderExt->bSliceSkipFlag == 1)
479 {
480 for(i=0; i<(int32_t)pSliceHeaderExt->uiNumMbsInSlice; i++)
481 {
482 pCurLayer->pSliceIdc[iNextMbXyIndex] = iSliceIdc;
483
484
485 pCurLayer->pResidualPredFlag[iNextMbXyIndex] = 1;
486
487 if ( pSliceHeaderExt->sSliceHeader.pPps->uiNumSliceGroups > 1 )
488 {
489 iNextMbXyIndex = FmoNextMb( pFmo, iNextMbXyIndex );
490 }
491 else
492 {
493 ++iNextMbXyIndex;
494 }
495
496 iMbX = iNextMbXyIndex%pCurLayer->iMbWidth;
497 iMbY = iNextMbXyIndex%pCurLayer->iMbHeight;
498
499 pCurLayer->iMbX = iMbX;
500 pCurLayer->iMbY = iMbY;
501 pCurLayer->iMbXyIndex = iNextMbXyIndex;
502 }
503 return 0;
504 }
505
506 do{
507 pCurLayer->pSliceIdc[iNextMbXyIndex] = iSliceIdc;
508 iRet = pDecMbCavlcFunc( pCtx, pNalCur );
509
510 if (iRet != ERR_NONE){
511 return iRet;
512 }
513
514 ++pSlice->iTotalMbInCurSlice;
515
516 if ( pSliceHeader->pPps->uiNumSliceGroups > 1 )
517 {
518 iNextMbXyIndex = FmoNextMb( pFmo, iNextMbXyIndex );
519 }
520 else
521 {
522 ++iNextMbXyIndex;
523 }
524 if ( (-1 == iNextMbXyIndex) || (iNextMbXyIndex >= kiCountNumMb) ) // slice group boundary or end of a frame
525 {
526 break;
527 }
528
529 // check whether there is left bits to read next time in case multiple slices
530 iUsedBits = ((pBs->pCurBuf-pBs->pStartBuf)<<3) - (16-pBs->iLeftBits);
531 if ( iUsedBits == pBs->iBits && 0 >= pCurLayer->sLayerInfo.sSliceInLayer.iMbSkipRun ) // slice boundary
532 {
533 break;
534 }
535 if ( iUsedBits > pBs->iBits )//When BS incomplete, as long as find it, SHOULD stop decoding to avoid mosaic or crash.
536 {
537 WelsLog( pCtx, WELS_LOG_WARNING, "WelsDecodeSlice()::::pBs incomplete, iUsedBits:%d > pBs->iBits:%d, MUST stop decoding.\n",
538 iUsedBits, pBs->iBits );
539 return -1;
540 }
541 iMbX = iNextMbXyIndex % pCurLayer->iMbWidth;
542 iMbY = iNextMbXyIndex / pCurLayer->iMbWidth;
543 pCurLayer->iMbX = iMbX;
544 pCurLayer->iMbY = iMbY;
545 pCurLayer->iMbXyIndex = iNextMbXyIndex;
546 }while(1);
547
548 return ERR_NONE;
549}
550
551int32_t WelsActualDecodeMbCavlcISlice(PWelsDecoderContext pCtx)
552{
553 SVlcTable* pVlcTable = &pCtx->sVlcTable;
554 PDqLayer pCurLayer = pCtx->pCurDqLayer;
555 PBitStringAux pBs = pCurLayer->pBitStringAux;
556 PSlice pSlice = &pCurLayer->sLayerInfo.sSliceInLayer;
557 PSliceHeader pSliceHeader = &pSlice->sSliceHeaderExt.sSliceHeader;
558
559 SNeighAvail sNeighAvail;
560
561 int32_t iScanIdxStart = pSlice->sSliceHeaderExt.uiScanIdxStart;
562 int32_t iScanIdxEnd = pSlice->sSliceHeaderExt.uiScanIdxEnd;
563
564 int32_t iMbX = pCurLayer->iMbX;
565 int32_t iMbY = pCurLayer->iMbY;
566 int32_t iMbXy = pCurLayer->iMbXyIndex;
567 int32_t iNMbMode, i;
568 uint32_t uiMbType = 0, uiCbp = 0, uiCbpL = 0, uiCbpC = 0;
569
570 FORCE_STACK_ALIGN_1D( uint8_t, pNonZeroCount, 48, 16 );
571
572 pCurLayer->pInterPredictionDoneFlag[iMbXy] = 0;
573 pCurLayer->pResidualPredFlag[iMbXy] = pSlice->sSliceHeaderExt.bDefaultResidualPredFlag;
574
575 uiMbType = BsGetUe(pBs);
576 if ( uiMbType > 25 )
577 {
578 return ERR_INFO_INVALID_MB_TYPE;
579 }
580
581 if ( 25 == uiMbType )
582 {
583 int32_t iDecStrideL = pCurLayer->pDec->iLinesize[0];
584 int32_t iDecStrideC = pCurLayer->pDec->iLinesize[1];
585
586 int32_t iOffsetL = ( iMbX + iMbY * iDecStrideL ) << 4;
587 int32_t iOffsetC = ( iMbX + iMbY * iDecStrideC ) << 3;
588
589 uint8_t* pDecY = pCurLayer->pCsData[0] + iOffsetL;
590 uint8_t* pDecU = pCurLayer->pCsData[1] + iOffsetC;
591 uint8_t* pDecV = pCurLayer->pCsData[2] + iOffsetC;
592
593 uint8_t *pTmpBsBuf;
594
595 int32_t i;
596 int32_t iCopySizeY = ( sizeof( uint8_t ) << 4 );
597 int32_t iCopySizeUV = ( sizeof( uint8_t ) << 3 );
598
599 int32_t iIndex = ((-pBs->iLeftBits)>>3) + 2;
600
601 pCurLayer->pMbType[iMbXy] = MB_TYPE_INTRA_PCM;
602
603 //step 1: locating bit-stream pointer [must align into integer byte]
604 pBs->pCurBuf -= iIndex;
605
606 //step 2: copy pixel from bit-stream into fdec [reconstruction]
607 pTmpBsBuf = pBs->pCurBuf;
608 for ( i = 0; i < 16; i++ ) //luma
609 {
610 memcpy( pDecY , pTmpBsBuf, iCopySizeY );
611 pDecY += iDecStrideL;
612 pTmpBsBuf += 16;
613 }
614 for ( i = 0; i < 8; i++ ) //cb
615 {
616 memcpy( pDecU, pTmpBsBuf, iCopySizeUV );
617 pDecU += iDecStrideC;
618 pTmpBsBuf += 8;
619 }
620 for ( i = 0; i < 8; i++ ) //cr
621 {
622 memcpy( pDecV, pTmpBsBuf, iCopySizeUV );
623 pDecV += iDecStrideC;
624 pTmpBsBuf += 8;
625 }
626
627 pBs->pCurBuf += 384;
628 InitReadBits( pBs );
629
630 //step 3: update QP and pNonZeroCount
631 pCurLayer->pLumaQp[iMbXy] = 0;
632 pCurLayer->pChromaQp[iMbXy] = 0;
633 memset( pCurLayer->pNzc[iMbXy], 16, sizeof( pCurLayer->pNzc[iMbXy] ) ); //JVT-x201wcm1.doc, page229, 2009.10.23
634 return 0;
635 }
636 else if (0 == uiMbType) //reference to JM
637 {
638 FORCE_STACK_ALIGN_1D( int8_t, pIntraPredMode, 48, 16 );
639 pCurLayer->pMbType[iMbXy] = MB_TYPE_INTRA4x4;
640 pCtx->pFillInfoCacheIntra4x4Func( &sNeighAvail, pNonZeroCount, pIntraPredMode, pCurLayer );
641 if ( pCtx->pParseIntra4x4ModeFunc( &sNeighAvail, pIntraPredMode, pBs, pCurLayer ) )
642 {
643 return -1;
644 }
645
646 //uiCbp
647 uiCbp = BsGetUe(pBs);
648 //G.9.1 Alternative parsing process for coded pBlock pattern
649 if ( uiCbp > 47 )
650 return ERR_INFO_INVALID_CBP;
651
652 uiCbp = g_kuiIntra4x4CbpTable[uiCbp];
653
654 pCurLayer->pCbp[iMbXy] = uiCbp;
655 uiCbpC = uiCbp >> 4;
656 uiCbpL = uiCbp & 15;
657 }
658 else //I_PCM exclude, we can ignore it
659 {
660 pCurLayer->pMbType[iMbXy] = MB_TYPE_INTRA16x16;
661 pCurLayer->pIntraPredMode[iMbXy][7] = (uiMbType-1) & 3;
662 pCurLayer->pCbp[iMbXy] = g_kuiI16CbpTable[(uiMbType-1)>>2];
663 uiCbpC = pCurLayer->pCbp[iMbXy] >> 4;
664 uiCbpL = pCurLayer->pCbp[iMbXy] & 15;
665 WelsFillCacheNonZeroCount( &sNeighAvail, pNonZeroCount, pCurLayer );
666 if ( pCtx->pParseIntra16x16ModeFunc( &sNeighAvail, pBs, pCurLayer ) )
667 {
668 return -1;
669 }
670 }
671
672 iNMbMode = BASE_MB;
673
674 memset(pCurLayer->pScaledTCoeff[iMbXy], 0, 384*sizeof(pCurLayer->pScaledTCoeff[iMbXy][0]));
675 ST32(&pCurLayer->pNzc[iMbXy][0], 0);
676 ST32(&pCurLayer->pNzc[iMbXy][4], 0);
677 ST32(&pCurLayer->pNzc[iMbXy][8], 0);
678 ST32(&pCurLayer->pNzc[iMbXy][12], 0);
679 ST32(&pCurLayer->pNzc[iMbXy][16], 0);
680 ST32(&pCurLayer->pNzc[iMbXy][20], 0);
681
682 if( pCurLayer->pCbp[iMbXy] == 0 && IS_INTRA4x4(pCurLayer->pMbType[iMbXy]))
683 {
684 pCurLayer->pLumaQp[iMbXy] = pSlice->iLastMbQp;
685 pCurLayer->pChromaQp[iMbXy] = g_kuiChromaQp[WELS_CLIP3(pCurLayer->pLumaQp[iMbXy] +
686 pSliceHeader->pPps->iChromaQpIndexOffset, 0, 51)];
687
688 }
689
690 if ( pCurLayer->pCbp[iMbXy] || MB_TYPE_INTRA16x16 == pCurLayer->pMbType[iMbXy] )
691 {
692 int32_t iQpDelta, iId8x8, iId4x4;
693
694 iQpDelta = BsGetSe(pBs);
695
696 if (iQpDelta > 25 || iQpDelta < -26) //out of iQpDelta range
697 {
698 return ERR_INFO_INVALID_QP;
699 }
700
701 pCurLayer->pLumaQp[iMbXy] = pSlice->iLastMbQp + iQpDelta; //update iLastMbQp
702 //refer to JVT-X201wcm1.doc equation(7-35)
703 if ( (unsigned)(pCurLayer->pLumaQp[iMbXy]) > 51 )
704 {
705 if ( pCurLayer->pLumaQp[iMbXy] < 0 )
706 {
707 pCurLayer->pLumaQp[iMbXy] += 52;
708 }
709 else
710 {
711 pCurLayer->pLumaQp[iMbXy] -= 52;
712 }
713 }
714 //QP should be in the range of [0, 51]
715 if ( pCurLayer->pLumaQp[iMbXy] < 0 || pCurLayer->pLumaQp[iMbXy] > 51 )
716 {
717 return ERR_INFO_INVALID_QP;
718 }
719 pSlice->iLastMbQp = pCurLayer->pLumaQp[iMbXy];
720 pCurLayer->pChromaQp[iMbXy] = g_kuiChromaQp[WELS_CLIP3(pSlice->iLastMbQp + pSliceHeader->pPps->iChromaQpIndexOffset, 0, 51)];
721
722
723 BsStartCavlc( pBs );
724
725 if ( MB_TYPE_INTRA16x16 == pCurLayer->pMbType[iMbXy] )
726 {
727 //step1: Luma DC
728 if ( WelsResidualBlockCavlc( pVlcTable, pNonZeroCount, pBs, 0, 16,
729 g_kuiLumaDcZigzagScan, I16_LUMA_DC, pCurLayer->pScaledTCoeff[iMbXy], iNMbMode, pCurLayer->pLumaQp[iMbXy], pCtx) )
730 {
731 return -1;//abnormal
732 }
733 //step2: Luma AC
734 if (uiCbpL)
735 {
736 for (i = 0; i < 16; i++)
737 {
738 if ( WelsResidualBlockCavlc( pVlcTable, pNonZeroCount, pBs, i,
739 iScanIdxEnd - WELS_MAX(iScanIdxStart, 1) + 1, g_kuiZigzagScan+ WELS_MAX(iScanIdxStart,1),
740 I16_LUMA_AC, pCurLayer->pScaledTCoeff[iMbXy] + (i<<4), iNMbMode, pCurLayer->pLumaQp[iMbXy], pCtx) )
741 {
742 return -1;//abnormal
743 }
744 }
745 ST32(&pCurLayer->pNzc[iMbXy][0], LD32(&pNonZeroCount[1+8*1]));
746 ST32(&pCurLayer->pNzc[iMbXy][4], LD32(&pNonZeroCount[1+8*2]));
747 ST32(&pCurLayer->pNzc[iMbXy][8], LD32(&pNonZeroCount[1+8*3]));
748 ST32(&pCurLayer->pNzc[iMbXy][12], LD32(&pNonZeroCount[1+8*4]));
749 }
750 else //pNonZeroCount = 0
751 {
752 ST32(&pCurLayer->pNzc[iMbXy][0], 0);
753 ST32(&pCurLayer->pNzc[iMbXy][4], 0);
754 ST32(&pCurLayer->pNzc[iMbXy][8], 0);
755 ST32(&pCurLayer->pNzc[iMbXy][12], 0);
756 }
757 }
758 else //non-MB_TYPE_INTRA16x16
759 {
760 for (iId8x8 = 0; iId8x8 < 4; iId8x8++)
761 {
762 if (uiCbpL & (1 << iId8x8))
763 {
764 int32_t iIndex = (iId8x8 << 2);
765 for (iId4x4 = 0; iId4x4 < 4; iId4x4++)
766 {
767 //Luma (DC and AC decoding together)
768 if ( WelsResidualBlockCavlc( pVlcTable, pNonZeroCount, pBs, iIndex,
769 iScanIdxEnd - iScanIdxStart + 1, g_kuiZigzagScan+iScanIdxStart,
770 LUMA_DC_AC, pCurLayer->pScaledTCoeff[iMbXy] + (iIndex<<4), iNMbMode, pCurLayer->pLumaQp[iMbXy], pCtx) )
771 {
772 return -1;//abnormal
773 }
774 iIndex++;
775 }
776 }
777 else
778 {
779 ST16(&pNonZeroCount[g_kuiCacheNzcScanIdx[(iId8x8<<2)]], 0);
780 ST16(&pNonZeroCount[g_kuiCacheNzcScanIdx[(iId8x8<<2)+2]], 0);
781 }
782 }
783 ST32(&pCurLayer->pNzc[iMbXy][0], LD32(&pNonZeroCount[1+8*1]));
784 ST32(&pCurLayer->pNzc[iMbXy][4], LD32(&pNonZeroCount[1+8*2]));
785 ST32(&pCurLayer->pNzc[iMbXy][8], LD32(&pNonZeroCount[1+8*3]));
786 ST32(&pCurLayer->pNzc[iMbXy][12], LD32(&pNonZeroCount[1+8*4]));
787 }
788
789 //chroma
790 //step1: DC
791 if ( 1 == uiCbpC || 2 == uiCbpC )
792 {
793 for (i = 0; i < 2; i++) //Cb Cr
794 {
795 if ( WelsResidualBlockCavlc( pVlcTable, pNonZeroCount, pBs,
796 16 + (i << 2), 4, g_kuiChromaDcScan, CHROMA_DC, pCurLayer->pScaledTCoeff[iMbXy] + 256 + (i<<6),
797 iNMbMode, pCurLayer->pChromaQp[iMbXy], pCtx) )
798 {
799 return -1;//abnormal
800 }
801 }
802 }
803
804 //step2: AC
805 if (2 == uiCbpC)
806 {
807 for (i = 0; i < 2; i++) //Cb Cr
808 {
809 int32_t iIndex = 16 + (i<<2);
810 for (iId4x4 = 0; iId4x4 < 4; iId4x4++)
811 {
812 if ( WelsResidualBlockCavlc( pVlcTable, pNonZeroCount, pBs, iIndex,
813 iScanIdxEnd - WELS_MAX(iScanIdxStart, 1) + 1, g_kuiZigzagScan + WELS_MAX(iScanIdxStart,1),
814 CHROMA_AC, pCurLayer->pScaledTCoeff[iMbXy]+(iIndex<<4), iNMbMode, pCurLayer->pChromaQp[iMbXy], pCtx) )
815 {
816 return -1;//abnormal
817 }
818 iIndex++;
819 }
820 }
821 ST16(&pCurLayer->pNzc[iMbXy][16], LD16(&pNonZeroCount[6+8*1]));
822 ST16(&pCurLayer->pNzc[iMbXy][20], LD16(&pNonZeroCount[6+8*2]));
823 ST16(&pCurLayer->pNzc[iMbXy][18], LD16(&pNonZeroCount[6+8*4]));
824 ST16(&pCurLayer->pNzc[iMbXy][22], LD16(&pNonZeroCount[6+8*5]));
825 }
826 else
827 {
828 ST16(&pCurLayer->pNzc[iMbXy][16], 0);
829 ST16(&pCurLayer->pNzc[iMbXy][20], 0);
830 ST16(&pCurLayer->pNzc[iMbXy][18], 0);
831 ST16(&pCurLayer->pNzc[iMbXy][22], 0);
832 }
833 BsEndCavlc( pBs );
834 }
835 else
836 {
837 ST32(&pCurLayer->pNzc[iMbXy][0], 0);
838 ST32(&pCurLayer->pNzc[iMbXy][4], 0);
839 ST32(&pCurLayer->pNzc[iMbXy][8], 0);
840 ST32(&pCurLayer->pNzc[iMbXy][12], 0);
841 ST32(&pCurLayer->pNzc[iMbXy][16], 0);
842 ST32(&pCurLayer->pNzc[iMbXy][20], 0);
843 }
844
845 return 0;
846}
847
848int32_t WelsDecodeMbCavlcISlice(PWelsDecoderContext pCtx, PNalUnit pNalCur)
849{
850 PDqLayer pCurLayer = pCtx->pCurDqLayer;
851 PBitStringAux pBs = pCurLayer->pBitStringAux;
852 PSliceHeaderExt pSliceHeaderExt = &pCurLayer->sLayerInfo.sSliceInLayer.sSliceHeaderExt;
853 int32_t iBaseModeFlag;
854 int32_t iRet = 0; //should have the return value to indicate decoding error or not, It's NECESSARY--2010.4.15
855
856 if( pSliceHeaderExt->bAdaptiveBaseModeFlag == 1)
857 {
858 iBaseModeFlag = BsGetOneBit(pBs);
859 }
860 else
861 {
862 iBaseModeFlag = pSliceHeaderExt->bDefaultBaseModeFlag;
863 }
864 if( !iBaseModeFlag )
865 {
866 iRet = WelsActualDecodeMbCavlcISlice( pCtx);
867 }
868 else
869 {
870 WelsLog( pCtx, WELS_LOG_WARNING, "iBaseModeFlag (%d) != 0, inter-layer prediction not supported.\n", iBaseModeFlag);
871 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_ILP);
872 }
873 if ( iRet ) //occur error when parsing, MUST STOP decoding
874 {
875 return iRet;
876 }
877
878 return 0;
879}
880
881int32_t WelsActualDecodeMbCavlcPSlice(PWelsDecoderContext pCtx)
882{
883 SVlcTable* pVlcTable = &pCtx->sVlcTable;
884 PDqLayer pCurLayer = pCtx->pCurDqLayer;
885 PBitStringAux pBs = pCurLayer->pBitStringAux;
886 PSlice pSlice = &pCurLayer->sLayerInfo.sSliceInLayer;
887 PSliceHeader pSliceHeader = &pSlice->sSliceHeaderExt.sSliceHeader;
888
889 SNeighAvail sNeighAvail;
890
891 int32_t iScanIdxStart = pSlice->sSliceHeaderExt.uiScanIdxStart;
892 int32_t iScanIdxEnd = pSlice->sSliceHeaderExt.uiScanIdxEnd;
893
894 int32_t iMbX = pCurLayer->iMbX;
895 int32_t iMbY = pCurLayer->iMbY;
896 int32_t iMbXy = pCurLayer->iMbXyIndex;
897
898 int32_t iNMbMode, i;
899 uint32_t uiMbType = 0, uiCbp = 0, uiCbpL = 0, uiCbpC = 0;
900
901 FORCE_STACK_ALIGN_1D( uint8_t, pNonZeroCount, 48, 16 );
902 pCurLayer->pInterPredictionDoneFlag[iMbXy] = 0;//2009.10.23
903
904 uiMbType = BsGetUe(pBs);
905 if (uiMbType < 5) //inter MB type
906 {
907 int16_t iMotionVector[LIST_A][30][MV_A];
908
909 int8_t iRefIndex[LIST_A][30];
910 pCurLayer->pMbType[iMbXy] = g_ksInterMbTypeInfo[uiMbType].iType;
911 WelsFillCacheInter( &sNeighAvail, pNonZeroCount, iMotionVector, iRefIndex, pCurLayer );
912 if ( ParseInterInfo(pCtx, iMotionVector, iRefIndex, pBs) )
913 {
914 return -1;//abnormal
915 }
916
917 if( pSlice->sSliceHeaderExt.bAdaptiveResidualPredFlag ==1 )
918 {
919 pCurLayer->pResidualPredFlag[iMbXy] = BsGetOneBit(pBs);
920 }
921 else
922 {
923 pCurLayer->pResidualPredFlag[iMbXy] = pSlice->sSliceHeaderExt.bDefaultResidualPredFlag;
924 }
925
926 if(pCurLayer->pResidualPredFlag[iMbXy] == 0)
927 {
928 iNMbMode = BASE_MB;
929 pCurLayer->pInterPredictionDoneFlag[iMbXy] = 0;
930 }
931 else
932 {
933 WelsLog(pCtx, WELS_LOG_WARNING, "residual_pred_flag = 1 not supported.\n");
934 return -1;
935 }
936 }
937 else //intra MB type
938 {
939 uiMbType -= 5;
940 if ( uiMbType > 25 )
941 {
942 return ERR_INFO_INVALID_MB_TYPE;
943 }
944
945 if ( 25 == uiMbType )
946 {
947 int32_t iDecStrideL = pCurLayer->pDec->iLinesize[0];
948 int32_t iDecStrideC = pCurLayer->pDec->iLinesize[1];
949
950 int32_t iOffsetL = ( iMbX + iMbY * iDecStrideL ) << 4;
951 int32_t iOffsetC = ( iMbX + iMbY * iDecStrideC ) << 3;
952
953 uint8_t* pDecY = pCurLayer->pCsData[0] + iOffsetL;
954 uint8_t* pDecU = pCurLayer->pCsData[1] + iOffsetC;
955 uint8_t* pDecV = pCurLayer->pCsData[2] + iOffsetC;
956
957 uint8_t *pTmpBsBuf;
958
959 int32_t i;
960 int32_t iCopySizeY = ( sizeof( uint8_t ) << 4 );
961 int32_t iCopySizeUV = ( sizeof( uint8_t ) << 3 );
962
963 int32_t iIndex = ((-pBs->iLeftBits)>>3) + 2;
964
965 pCurLayer->pMbType[iMbXy] = MB_TYPE_INTRA_PCM;
966
967 //step 1: locating bit-stream pointer [must align into integer byte]
968 pBs->pCurBuf -= iIndex;
969
970 //step 2: copy pixel from bit-stream into fdec [reconstruction]
971 pTmpBsBuf = pBs->pCurBuf;
972 for ( i = 0; i < 16; i++ ) //luma
973 {
974 memcpy( pDecY , pTmpBsBuf, iCopySizeY );
975 pDecY += iDecStrideL;
976 pTmpBsBuf += 16;
977 }
978
979 for ( i = 0; i < 8; i++ ) //cb
980 {
981 memcpy( pDecU, pTmpBsBuf, iCopySizeUV );
982 pDecU += iDecStrideC;
983 pTmpBsBuf += 8;
984 }
985 for ( i = 0; i < 8; i++ ) //cr
986 {
987 memcpy( pDecV, pTmpBsBuf, iCopySizeUV );
988 pDecV += iDecStrideC;
989 pTmpBsBuf += 8;
990 }
991
992 pBs->pCurBuf += 384;
993 InitReadBits( pBs );
994
995 //step 3: update QP and pNonZeroCount
996 pCurLayer->pLumaQp[iMbXy] = 0;
997 pCurLayer->pChromaQp[iMbXy] = 0;
998 ST32(&pCurLayer->pNzc[iMbXy][0], 0);
999 ST32(&pCurLayer->pNzc[iMbXy][4], 0);
1000 ST32(&pCurLayer->pNzc[iMbXy][8], 0);
1001 ST32(&pCurLayer->pNzc[iMbXy][12], 0);
1002 return 0;
1003 }
1004 else
1005 {
1006 if (0 == uiMbType)
1007 {
1008 FORCE_STACK_ALIGN_1D( int8_t, pIntraPredMode, 48, 16 );
1009 pCurLayer->pMbType[iMbXy] = MB_TYPE_INTRA4x4;
1010 pCtx->pFillInfoCacheIntra4x4Func( &sNeighAvail, pNonZeroCount, pIntraPredMode, pCurLayer );
1011 if ( pCtx->pParseIntra4x4ModeFunc( &sNeighAvail, pIntraPredMode, pBs, pCurLayer ) )
1012 {
1013 return -1;
1014 }
1015 iNMbMode = BASE_MB;
1016 }
1017 else //I_PCM exclude, we can ignore it
1018 {
1019 pCurLayer->pMbType[iMbXy] = MB_TYPE_INTRA16x16;
1020 pCurLayer->pIntraPredMode[iMbXy][7] = (uiMbType-1) & 3;
1021 pCurLayer->pCbp[iMbXy] = g_kuiI16CbpTable[(uiMbType-1)>>2];
1022 uiCbpC = pCurLayer->pCbp[iMbXy] >> 4;
1023 uiCbpL = pCurLayer->pCbp[iMbXy] & 15;
1024 WelsFillCacheNonZeroCount( &sNeighAvail, pNonZeroCount, pCurLayer );
1025 if ( pCtx->pParseIntra16x16ModeFunc( &sNeighAvail, pBs, pCurLayer ) )
1026 {
1027 return -1;
1028 }
1029 iNMbMode = BASE_MB;
1030 }
1031 }
1032 }
1033
1034 if ( MB_TYPE_INTRA16x16 != pCurLayer->pMbType[iMbXy] )
1035 {
1036 uiCbp = BsGetUe(pBs);
1037 {
1038 if ( uiCbp > 47 )
1039 return ERR_INFO_INVALID_CBP;
1040
1041 if (MB_TYPE_INTRA4x4 == pCurLayer->pMbType[iMbXy])
1042 {
1043 uiCbp = g_kuiIntra4x4CbpTable[uiCbp];
1044 }
1045 else //inter
1046 uiCbp = g_kuiInterCbpTable[uiCbp];
1047 }
1048
1049 pCurLayer->pCbp[iMbXy] = uiCbp;
1050 uiCbpC = pCurLayer->pCbp[iMbXy] >> 4;
1051 uiCbpL = pCurLayer->pCbp[iMbXy] & 15;
1052 }
1053
1054 if(iNMbMode == BASE_MB)
1055 {
1056 pCtx->sBlockFunc.pWelsBlockZero16x16Func(pCurLayer->pScaledTCoeff[iMbXy], 16);
1057 pCtx->sBlockFunc.pWelsBlockZero8x8Func(pCurLayer->pScaledTCoeff[iMbXy]+256, 8);
1058 pCtx->sBlockFunc.pWelsBlockZero8x8Func(pCurLayer->pScaledTCoeff[iMbXy]+256+64, 8);
1059
1060 ST32(&pCurLayer->pNzc[iMbXy][0], 0);
1061 ST32(&pCurLayer->pNzc[iMbXy][4], 0);
1062 ST32(&pCurLayer->pNzc[iMbXy][8], 0);
1063 ST32(&pCurLayer->pNzc[iMbXy][12], 0);
1064 ST32(&pCurLayer->pNzc[iMbXy][20], 0);
1065 if( pCurLayer->pCbp[iMbXy] == 0 && !IS_INTRA16x16(pCurLayer->pMbType[iMbXy]) && !IS_I_BL(pCurLayer->pMbType[iMbXy]))
1066 {
1067 pCurLayer->pLumaQp[iMbXy] = pSlice->iLastMbQp;
1068 pCurLayer->pChromaQp[iMbXy] = g_kuiChromaQp[WELS_CLIP3(pCurLayer->pLumaQp[iMbXy] + pSliceHeader->pPps->iChromaQpIndexOffset, 0, 51)];
1069 }
1070 }
1071
1072 if ( pCurLayer->pCbp[iMbXy] || MB_TYPE_INTRA16x16 == pCurLayer->pMbType[iMbXy] )
1073 {
1074 int32_t iQpDelta, iId8x8, iId4x4;
1075
1076 iQpDelta = BsGetSe(pBs);
1077
1078 if (iQpDelta > 25 || iQpDelta < -26) //out of iQpDelta range
1079 {
1080 return ERR_INFO_INVALID_QP;
1081 }
1082
1083 pCurLayer->pLumaQp[iMbXy] = pSlice->iLastMbQp + iQpDelta; //update iLastMbQp
1084 //refer to JVT-X201wcm1.doc equation(7-35)
1085 if ( (unsigned)(pCurLayer->pLumaQp[iMbXy]) > 51 )
1086 {
1087 if ( pCurLayer->pLumaQp[iMbXy] < 0 )
1088 {
1089 pCurLayer->pLumaQp[iMbXy] += 52;
1090 }
1091 else
1092 {
1093 pCurLayer->pLumaQp[iMbXy] -= 52;
1094 }
1095 }
1096 //QP should be in the range of [0, 51]
1097 if ( pCurLayer->pLumaQp[iMbXy] < 0 || pCurLayer->pLumaQp[iMbXy] > 51 )
1098 {
1099 return ERR_INFO_INVALID_QP;
1100 }
1101 pSlice->iLastMbQp = pCurLayer->pLumaQp[iMbXy];
1102 pCurLayer->pChromaQp[iMbXy] = g_kuiChromaQp[WELS_CLIP3(pSlice->iLastMbQp + pSliceHeader->pPps->iChromaQpIndexOffset, 0, 51)];
1103
1104 BsStartCavlc( pBs );
1105
1106 if ( MB_TYPE_INTRA16x16 == pCurLayer->pMbType[iMbXy] )
1107 {
1108 //step1: Luma DC
1109 if ( WelsResidualBlockCavlc( pVlcTable, pNonZeroCount, pBs, 0, 16, g_kuiLumaDcZigzagScan,
1110 I16_LUMA_DC, pCurLayer->pScaledTCoeff[iMbXy], iNMbMode, pCurLayer->pLumaQp[iMbXy], pCtx) )
1111 {
1112 return -1;//abnormal
1113 }
1114 //step2: Luma AC
1115 if (uiCbpL)
1116 {
1117 for (i = 0; i < 16; i++)
1118 {
1119 if ( WelsResidualBlockCavlc( pVlcTable, pNonZeroCount,pBs, i,
1120 iScanIdxEnd - WELS_MAX(iScanIdxStart, 1) + 1, g_kuiZigzagScan + WELS_MAX(iScanIdxStart,1),
1121 I16_LUMA_AC, pCurLayer->pScaledTCoeff[iMbXy] + (i<<4), iNMbMode, pCurLayer->pLumaQp[iMbXy], pCtx) )
1122 {
1123 return -1;//abnormal
1124 }
1125 }
1126 ST32(&pCurLayer->pNzc[iMbXy][0], LD32(&pNonZeroCount[1+8*1]));
1127 ST32(&pCurLayer->pNzc[iMbXy][4], LD32(&pNonZeroCount[1+8*2]));
1128 ST32(&pCurLayer->pNzc[iMbXy][8], LD32(&pNonZeroCount[1+8*3]));
1129 ST32(&pCurLayer->pNzc[iMbXy][12], LD32(&pNonZeroCount[1+8*4]));
1130 }
1131 else //pNonZeroCount = 0
1132 {
1133 ST32(&pCurLayer->pNzc[iMbXy][0], 0);
1134 ST32(&pCurLayer->pNzc[iMbXy][4], 0);
1135 ST32(&pCurLayer->pNzc[iMbXy][8], 0);
1136 ST32(&pCurLayer->pNzc[iMbXy][12], 0);
1137 }
1138 }
1139 else //non-MB_TYPE_INTRA16x16
1140 {
1141 for (iId8x8 = 0; iId8x8 < 4; iId8x8++)
1142 {
1143 if (uiCbpL & (1 << iId8x8))
1144 {
1145 int32_t iIndex = (iId8x8 << 2);
1146 for (iId4x4 = 0; iId4x4 < 4; iId4x4++)
1147 {
1148 //Luma (DC and AC decoding together)
1149 if ( WelsResidualBlockCavlc( pVlcTable, pNonZeroCount, pBs, iIndex,
1150 iScanIdxEnd - iScanIdxStart + 1, g_kuiZigzagScan+iScanIdxStart, LUMA_DC_AC,
1151 pCurLayer->pScaledTCoeff[iMbXy] + (iIndex<<4), iNMbMode, pCurLayer->pLumaQp[iMbXy], pCtx) )
1152 {
1153 return -1;//abnormal
1154 }
1155 iIndex++;
1156 }
1157 }
1158 else
1159 {
1160 ST16(&pNonZeroCount[g_kuiCacheNzcScanIdx[iId8x8<<2]],0);
1161 ST16(&pNonZeroCount[g_kuiCacheNzcScanIdx[(iId8x8<<2)+2]],0);
1162 }
1163 }
1164 ST32(&pCurLayer->pNzc[iMbXy][0], LD32(&pNonZeroCount[1+8*1]));
1165 ST32(&pCurLayer->pNzc[iMbXy][4], LD32(&pNonZeroCount[1+8*2]));
1166 ST32(&pCurLayer->pNzc[iMbXy][8], LD32(&pNonZeroCount[1+8*3]));
1167 ST32(&pCurLayer->pNzc[iMbXy][12], LD32(&pNonZeroCount[1+8*4]));
1168 }
1169
1170
1171 //chroma
1172 //step1: DC
1173 if ( 1 == uiCbpC || 2 == uiCbpC )
1174 {
1175 for (i = 0; i < 2; i++) //Cb Cr
1176 {
1177 if ( WelsResidualBlockCavlc( pVlcTable, pNonZeroCount, pBs,
1178 16 + (i << 2), 4, g_kuiChromaDcScan, CHROMA_DC, pCurLayer->pScaledTCoeff[iMbXy] + 256 + (i<<6),
1179 iNMbMode, pCurLayer->pChromaQp[iMbXy], pCtx) )
1180 {
1181 return -1;//abnormal
1182 }
1183 }
1184 }
1185 else
1186 {
1187 }
1188 //step2: AC
1189 if (2 == uiCbpC)
1190 {
1191 for (i = 0; i < 2; i++) //Cb Cr
1192 {
1193 int32_t iIndex= 16 + (i<<2);
1194 for (iId4x4 = 0; iId4x4 < 4; iId4x4++)
1195 {
1196 if ( WelsResidualBlockCavlc( pVlcTable, pNonZeroCount, pBs, iIndex,
1197 iScanIdxEnd - WELS_MAX(iScanIdxStart, 1) + 1, g_kuiZigzagScan + WELS_MAX(iScanIdxStart,1),
1198 CHROMA_AC, pCurLayer->pScaledTCoeff[iMbXy]+(iIndex<<4), iNMbMode, pCurLayer->pChromaQp[iMbXy], pCtx) )
1199 {
1200 return -1;//abnormal
1201 }
1202 iIndex++;
1203 }
1204 }
1205 ST16(&pCurLayer->pNzc[iMbXy][16], LD16(&pNonZeroCount[6+8*1]));
1206 ST16(&pCurLayer->pNzc[iMbXy][20], LD16(&pNonZeroCount[6+8*2]));
1207 ST16(&pCurLayer->pNzc[iMbXy][18], LD16(&pNonZeroCount[6+8*4]));
1208 ST16(&pCurLayer->pNzc[iMbXy][22], LD16(&pNonZeroCount[6+8*5]));
1209 }
1210 else
1211 {
1212 ST32(&pCurLayer->pNzc[iMbXy][16], 0);
1213 ST32(&pCurLayer->pNzc[iMbXy][20], 0);
1214 }
1215 BsEndCavlc( pBs );
1216 }
1217 else
1218 {
1219 ST32(&pCurLayer->pNzc[iMbXy][0], 0);
1220 ST32(&pCurLayer->pNzc[iMbXy][4], 0);
1221 ST32(&pCurLayer->pNzc[iMbXy][8], 0);
1222 ST32(&pCurLayer->pNzc[iMbXy][12], 0);
1223 ST32(&pCurLayer->pNzc[iMbXy][16], 0);
1224 ST32(&pCurLayer->pNzc[iMbXy][20], 0);
1225 }
1226
1227 return 0;
1228}
1229
1230int32_t WelsDecodeMbCavlcPSlice(PWelsDecoderContext pCtx, PNalUnit pNalCur)
1231{
1232 PDqLayer pCurLayer = pCtx->pCurDqLayer;
1233 PBitStringAux pBs = pCurLayer->pBitStringAux;
1234 PSlice pSlice = &pCurLayer->sLayerInfo.sSliceInLayer;
1235 PSliceHeader pSliceHeader = &pSlice->sSliceHeaderExt.sSliceHeader;
1236
1237 int32_t iMbXy = pCurLayer->iMbXyIndex;
1238 int32_t iBaseModeFlag, i;
1239 int32_t iRet = 0; //should have the return value to indicate decoding error or not, It's NECESSARY--2010.4.15
1240
1241 if (-1 == pSlice->iMbSkipRun)
1242 {
1243 pSlice->iMbSkipRun = BsGetUe(pBs);
1244 if ( -1 == pSlice->iMbSkipRun )
1245 {
1246 return -1;
1247 }
1248
1249 }
1250 if (pSlice->iMbSkipRun--)
1251 {
1252 int16_t iMv[2] = {0};
1253
1254 pCurLayer->pMbType[iMbXy] = MB_TYPE_SKIP;
1255 ST32(&pCurLayer->pNzc[iMbXy][0], 0);
1256 ST32(&pCurLayer->pNzc[iMbXy][4], 0);
1257 ST32(&pCurLayer->pNzc[iMbXy][8], 0);
1258 ST32(&pCurLayer->pNzc[iMbXy][12], 0);
1259 ST32(&pCurLayer->pNzc[iMbXy][16], 0);
1260 ST32(&pCurLayer->pNzc[iMbXy][20], 0);
1261
1262 pCurLayer->pInterPredictionDoneFlag[iMbXy] = 0;
1263 memset(pCurLayer->pRefIndex[0][iMbXy], 0, sizeof(int8_t) * 16);
1264
1265 //predict iMv
1266 PredPSkipMvFromNeighbor( pCurLayer, iMv );
1267 for (i = 0; i < 16; i++)
1268 {
1269 ST32( pCurLayer->pMv[0][iMbXy][i], *(uint32_t*)iMv );
1270 }
1271
1272 if(!pSlice->sSliceHeaderExt.bDefaultResidualPredFlag)
1273 {
1274 memset(pCurLayer->pScaledTCoeff[iMbXy], 0, 384*sizeof(int16_t));
1275 }
1276
1277 //reset rS
1278 if(!pSlice->sSliceHeaderExt.bDefaultResidualPredFlag ||
1279 (pNalCur->sNalHeaderExt.uiQualityId==0 && pNalCur->sNalHeaderExt.uiDependencyId==0))
1280 {
1281 pCurLayer->pLumaQp[iMbXy] = pSlice->iLastMbQp;
1282 pCurLayer->pChromaQp[iMbXy] = g_kuiChromaQp[WELS_CLIP3(pCurLayer->pLumaQp[iMbXy] + pSliceHeader->pPps->iChromaQpIndexOffset, 0, 51)];
1283 }
1284
1285 pCurLayer->pCbp[iMbXy] = 0;
1286
1287 return 0;
1288 }
1289
1290 if( pSlice->sSliceHeaderExt.bAdaptiveBaseModeFlag == 1)
1291 {
1292 iBaseModeFlag = BsGetOneBit(pBs);
1293 }
1294 else
1295 {
1296 iBaseModeFlag = pSlice->sSliceHeaderExt.bDefaultBaseModeFlag;
1297 }
1298 if( !iBaseModeFlag )
1299 {
1300 iRet = WelsActualDecodeMbCavlcPSlice( pCtx );
1301 }
1302 else
1303 {
1304 WelsLog( pCtx, WELS_LOG_WARNING, "iBaseModeFlag (%d) != 0, inter-layer prediction not supported.\n", iBaseModeFlag);
1305 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_ILP);
1306 }
1307 if ( iRet ) //occur error when parsing, MUST STOP decoding
1308 {
1309 return iRet;
1310 }
1311
1312 return 0;
1313}
1314
1315void_t WelsBlockInit(int16_t* pBlock, int32_t iWidth, int32_t iHeight, int32_t iStride, uint8_t uiVal)
1316{
1317 int32_t i;
1318 int16_t* pDst = pBlock;
1319
1320 for(i=0; i<iHeight; i++)
1321 {
1322 memset(pDst, uiVal, iWidth*sizeof(int16_t));
1323 pDst += iStride;
1324 }
1325}
1326
1327void_t WelsBlockFuncInit(SBlockFunc * pFunc, int32_t iCpu)
1328{
1329 pFunc->pWelsBlockZero16x16Func = WelsBlockZero16x16_c;
1330 pFunc->pWelsBlockZero8x8Func = WelsBlockZero8x8_c;
1331 pFunc->pWelsSetNonZeroCountFunc = SetNonZeroCount_c;
1332
1333#ifdef X86_ASM
1334 if( iCpu & WELS_CPU_SSE2 ){
1335 pFunc->pWelsBlockZero16x16Func = WelsResBlockZero16x16_sse2;
1336 pFunc->pWelsBlockZero8x8Func = WelsResBlockZero8x8_sse2;
1337 }
1338#endif
1339}
1340void_t WelsBlockZero16x16_c(int16_t * pBlock, int32_t iStride)
1341{
1342 WelsBlockInit(pBlock,16,16,iStride,0);
1343}
1344
1345void_t WelsBlockZero8x8_c(int16_t * pBlock, int32_t iStride)
1346{
1347 WelsBlockInit(pBlock,8,8,iStride,0);
1348}
1349
1350void_t SetNonZeroCount_c(int16_t* pBlock, int8_t* pNonZeroCount)
1351{
1352 int32_t i;
1353 int32_t iIndex;
1354
1355 for( i=0;i<24;i++ ){
1356 iIndex = g_kuiMbNonZeroCountIdx[i];
1357 pNonZeroCount[iIndex] = !!pNonZeroCount[iIndex];
1358 }
1359}
1360
1361} // namespace WelsDec
codec/decoder/core/src/decoder.cpp+850−0
@@ -0,0 +1,850 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file decoder.c
33 *
34 * \brief Interfaces implementation introduced in decoder system architecture
35 *
36 * \date 03/10/2009 Created
37 *
38 *************************************************************************************
39 */
40#include <string.h>
41#include "macros.h"
42#include "codec_def.h"
43#include "decoder.h"
44#include "error_code.h"
45#include "cpu.h"
46#include "cpu_core.h"
47#include "au_parser.h"
48#include "utils.h"
49#include "nal_prefix.h"
50#include "dec_frame.h"
51#include "pic_queue.h"
52#include "vlc_decoder.h"
53#include "get_intra_predictor.h"
54#include "rec_mb.h"
55#include "mc.h"
56#include "decode_mb_aux.h"
57#include "manage_dec_ref.h"
58#include "codec_app_def.h"
59#include "decoder_core.h"
60#include "deblocking.h"
61#include "expand_pic.h"
62#include "decode_slice.h"
63#include "crt_util_safe_x.h" // Safe CRT routines like utils for cross platforms
64#include "mem_align.h"
65
66namespace WelsDec {
67
68extern PPicture AllocPicture( PWelsDecoderContext pCtx,const int32_t kiPicWidth, const int32_t kiPicHeight );
69
70extern void_t FreePicture( PPicture pPic );
71
72#ifdef WORDS_BIGENDIAN
73inline void_t GetValueOf4Bytes( uint8_t* pDstNal, int32_t iDdstIdx )
74{
75 pDstNal[0] = (iDdstIdx & 0xff000000) >> 24;
76 pDstNal[1] = (iDdstIdx & 0xff0000) >> 16;
77 pDstNal[2] = (iDdstIdx & 0xff00) >> 8;
78 pDstNal[3] = (iDdstIdx & 0xff);
79}
80#else //WORDS_BIGENDIAN
81inline void_t GetValueOf4Bytes( uint8_t* pDstNal, int32_t iDdstIdx )
82{
83 pDstNal[0] = (iDdstIdx & 0xff);
84 pDstNal[1] = (iDdstIdx & 0xff00) >> 8;
85 pDstNal[2] = (iDdstIdx & 0xff0000) >> 16;
86 pDstNal[3] = (iDdstIdx & 0xff000000) >> 24;
87}
88#endif //WORDS_BIGENDIAN
89
90static int32_t CreatePicBuff(PWelsDecoderContext pCtx, PPicBuff *ppPicBuf, const int32_t kiSize, const int32_t kiPicWidth, const int32_t kiPicHeight)
91{
92 PPicBuff pPicBuf = NULL;
93 int32_t iPicIdx = 0;
94 if (kiSize <= 0 || kiPicWidth <= 0 || kiPicHeight <= 0)
95 {
96 return 1;
97 }
98
99 pPicBuf = (PPicBuff)WelsMalloc( sizeof(SPicBuff), "PPicBuff" );
100
101 if ( NULL == pPicBuf )
102 {
103 return 1;
104 }
105
106 pPicBuf->ppPic = (PPicture *)WelsMalloc(kiSize * sizeof(PPicture), "PPicture*");
107
108 if ( NULL == pPicBuf->ppPic )
109 {
110 return 1;
111 }
112 for (iPicIdx = 0; iPicIdx < kiSize; ++ iPicIdx)
113 {
114 PPicture pPic = AllocPicture( pCtx, kiPicWidth, kiPicHeight );
115 if ( NULL == pPic )
116 {
117 return 1;
118 }
119 pPicBuf->ppPic[iPicIdx] = pPic;
120 }
121
122 // initialize context in queue
123 pPicBuf->iCapacity = kiSize;
124 pPicBuf->iCurrentIdx = 0;
125 *ppPicBuf = pPicBuf;
126
127 return 0;
128}
129
130static void_t DestroyPicBuff( PPicBuff *ppPicBuf )
131{
132 PPicBuff pPicBuf = NULL;
133
134 if ( NULL == ppPicBuf || NULL == *ppPicBuf )
135 return;
136
137 pPicBuf = *ppPicBuf;
138 while(pPicBuf->ppPic != NULL)
139 {
140 int32_t iPicIdx = 0;
141 while (iPicIdx < pPicBuf->iCapacity)
142 {
143 PPicture pPic = pPicBuf->ppPic[iPicIdx];
144 if(pPic != NULL)
145 {
146 FreePicture( pPic );
147 }
148 pPic = NULL;
149 ++ iPicIdx;
150 }
151
152 WelsFree(pPicBuf->ppPic, "pPicBuf->queue");
153
154 pPicBuf->ppPic = NULL;
155 }
156 pPicBuf->iCapacity = 0;
157 pPicBuf->iCurrentIdx= 0;
158
159 WelsFree( pPicBuf, "pPicBuf" );
160
161 pPicBuf = NULL;
162 *ppPicBuf = NULL;
163}
164/*
165 * fill data fields in default for decoder context
166 */
167void_t WelsDecoderDefaults( PWelsDecoderContext pCtx )
168{
169 int32_t iCpuCores = 1;
170 memset( pCtx, 0, sizeof(SWelsDecoderContext) ); // fill zero first
171
172 pCtx->pArgDec = NULL;
173
174 pCtx->iOutputColorFormat = videoFormatI420; // yuv in default
175 pCtx->bHaveGotMemory = false; // not ever request memory blocks for decoder context related
176 pCtx->uiCpuFlag = 0;
177
178 pCtx->bAuReadyFlag = 0; // au data is not ready
179
180
181 g_uiCacheLineSize = 16;
182#if defined(X86_ASM)
183 pCtx->uiCpuFlag = WelsCPUFeatureDetect(&iCpuCores);
184#ifdef HAVE_CACHE_LINE_ALIGN
185 if ( pCtx->uiCpuFlag & WELS_CPU_CACHELINE_64 )
186 {
187 g_uiCacheLineSize = 64;
188 }
189 else if ( pCtx->uiCpuFlag & WELS_CPU_CACHELINE_32 )
190 {
191 g_uiCacheLineSize = 32;
192 }
193#endif//HAVE_CACHE_LINE_ALIGN
194#endif//X86_ASM
195
196 pCtx->iImgWidthInPixel = 0;
197 pCtx->iImgHeightInPixel = 0; // alloc picture data when picture size is available
198
199 pCtx->iFrameNum = -1;
200 pCtx->iPrevFrameNum = -1;
201 pCtx->iErrorCode = ERR_NONE;
202
203 pCtx->pDec = NULL;
204
205 WelsResetRefPic(pCtx);
206
207 pCtx->iActiveFmoNum = 0;
208
209 pCtx->pPicBuff[LIST_0] = NULL;
210 pCtx->pPicBuff[LIST_1] = NULL;
211
212 pCtx->bAvcBasedFlag = true;
213
214}
215
216/*
217 * destory_mb_blocks
218 */
219
220
221/*
222 * get size of reference picture list in target layer incoming, = (iNumRefFrames x 2)
223 */
224static inline int32_t GetTargetRefListSize( PWelsDecoderContext pCtx )
225{
226 bool_t *pSubsetSpsAvail= &pCtx->bSubspsAvailFlags[0];
227 bool_t *pSpsAvail = &pCtx->bSpsAvailFlags[0];
228 int32_t iSubsetIdx = -1;
229 int32_t iSpsIdx = -1;
230 bool_t bExistSubsetSps = false;
231 int32_t bExistSps = false;
232 int32_t iPos = MAX_SPS_COUNT - 1;
233 int32_t iNumRefFrames = 0;
234
235 while (iPos >= 0)
236 {
237 if ( pSubsetSpsAvail[iPos] )
238 {
239 bExistSubsetSps = true;
240 iSubsetIdx = iPos;
241 break;
242 }
243 -- iPos;
244 }
245
246 if ( !bExistSubsetSps )
247 {
248 iPos = MAX_SPS_COUNT - 1;
249 while (iPos >= 0)
250 {
251 if ( pSpsAvail[iPos] )
252 {
253 bExistSps = true;
254 iSpsIdx = iPos;
255 break;
256 }
257 -- iPos;
258 }
259 }
260
261 if ( !(bExistSubsetSps || bExistSps) )
262 {
263 iNumRefFrames = MAX_REF_PIC_COUNT;
264 }
265 else
266 {
267 PSps pSps = bExistSubsetSps ? (&pCtx->sSubsetSpsBuffer[iSubsetIdx].sSps) : (&pCtx->sSpsBuffer[iSpsIdx]);
268
269 iNumRefFrames = (pSps->iNumRefFrames ) + 1;
270 }
271
272 if ( 0 == iNumRefFrames )
273 iNumRefFrames = (MIN_REF_PIC_COUNT);
274
275#ifdef LONG_TERM_REF
276 //pic_queue size minimum set 2
277 if (iNumRefFrames <2)
278 {
279 iNumRefFrames = 2;
280 }
281#endif
282
283 return iNumRefFrames;
284}
285
286/*
287 * request memory blocks for decoder avc part
288 */
289int32_t WelsRequestMem( PWelsDecoderContext pCtx, const int32_t kiMbWidth, const int32_t kiMbHeight )
290{
291 const int32_t kiPicWidth = kiMbWidth << 4;
292 const int32_t kiPicHeight = kiMbHeight << 4;
293 int32_t iErr = ERR_NONE;
294
295 int32_t iListIdx = 0; //, mb_blocks = 0;
296 int32_t iPicQueueSize = 0; // adaptive size of picture queue, = (pSps->iNumRefFrames x 2)
297 bool_t bNeedChangePicQueue = true;
298
299 WELS_VERIFY_RETURN_IF( ERR_INFO_INVALID_PARAM, ( NULL == pCtx || kiPicWidth <= 0 || kiPicHeight <= 0 ) )
300
301 // Fixed the issue about different gop size over last, 5/17/2010
302 // get picture queue size currently
303 iPicQueueSize = GetTargetRefListSize( pCtx ); // adaptive size of picture queue, = (pSps->iNumRefFrames x 2)
304 pCtx->iPicQueueNumber = iPicQueueSize;
305 if ( pCtx->pPicBuff[LIST_0] != NULL && pCtx->pPicBuff[LIST_0]->iCapacity == iPicQueueSize ) // comparing current picture queue size requested and previous allocation picture queue
306 bNeedChangePicQueue = false;
307 // HD based pic buffer need consider memory size consumed when switch from 720p to other lower size
308 WELS_VERIFY_RETURN_IF( ERR_NONE, pCtx->bHaveGotMemory && ( kiPicWidth == pCtx->iImgWidthInPixel && kiPicHeight == pCtx->iImgHeightInPixel ) && (!bNeedChangePicQueue) ) // have same scaled buffer
309
310 // sync update pRefList
311 WelsResetRefPic( pCtx ); // added to sync update ref list due to pictures are free
312
313 // for Recycled_Pic_Queue
314 for ( iListIdx = LIST_0; iListIdx < LIST_A; ++ iListIdx )
315 {
316 PPicBuff *ppPic = &pCtx->pPicBuff[iListIdx];
317 if ( NULL != ppPic && NULL != *ppPic )
318 {
319 DestroyPicBuff( ppPic );
320 }
321 }
322
323 // currently only active for LIST_0 due to have no B frames
324 iErr = CreatePicBuff( pCtx, &pCtx->pPicBuff[LIST_0], iPicQueueSize, kiPicWidth, kiPicHeight );
325 if ( iErr != ERR_NONE )
326 return iErr;
327
328
329 pCtx->iImgWidthInPixel = kiPicWidth; // target width of image to be reconstruted while decoding
330 pCtx->iImgHeightInPixel = kiPicHeight; // target height of image to be reconstruted while decoding
331
332 pCtx->bHaveGotMemory = true; // global memory for decoder context related is requested
333 pCtx->pDec = NULL; // need prefetch a new pic due to spatial size changed
334 return ERR_NONE;
335}
336
337/*
338 * free memory blocks in avc
339 */
340void_t WelsFreeMem( PWelsDecoderContext pCtx )
341{
342 int32_t iListIdx = 0;
343
344 /* TODO: free memory blocks introduced in avc */
345 ResetFmoList( pCtx );
346
347 WelsResetRefPic( pCtx );
348
349 // for sPicBuff
350 for ( iListIdx = LIST_0; iListIdx < LIST_A; ++ iListIdx )
351 {
352 PPicBuff *pPicBuff = &pCtx->pPicBuff[iListIdx];
353 if ( NULL != pPicBuff && NULL != *pPicBuff )
354 {
355 DestroyPicBuff( pPicBuff );
356 }
357 }
358
359 // added for safe memory
360 pCtx->iImgWidthInPixel = 0;
361 pCtx->iImgHeightInPixel = 0;
362 pCtx->bHaveGotMemory = false;
363
364}
365
366/*!
367 * \brief Open decoder
368 */
369void_t WelsOpenDecoder( PWelsDecoderContext pCtx )
370{
371 // function pointers
372 //initial MC function pointer--
373 InitMcFunc(&(pCtx->sMcFunc), pCtx->uiCpuFlag);
374
375 InitExpandPictureFunc(&(pCtx->sExpandPicFunc), pCtx->uiCpuFlag);
376 AssignFuncPointerForRec(pCtx);
377
378 // vlc tables
379 InitVlcTable(&pCtx->sVlcTable);
380
381 // startup memory
382 if ( ERR_NONE != WelsInitMemory( pCtx ) )
383 return;
384
385 pCtx->iMaxWidthInSps = 0;
386 pCtx->iMaxHeightInSps = 0;
387#ifdef LONG_TERM_REF
388 pCtx->bParamSetsLostFlag = true;
389#else
390 pCtx->bReferenceLostAtT0Flag = true; // should be true to waiting IDR at incoming AU bits following, 6/4/2010
391#endif //LONG_TERM_REF
392}
393
394/*!
395 * \brief Close decoder
396 */
397void_t WelsCloseDecoder( PWelsDecoderContext pCtx )
398{
399 WelsFreeMem( pCtx );
400
401 WelsFreeMemory( pCtx );
402
403 UninitialDqLayersContext( pCtx );
404
405#ifdef LONG_TERM_REF
406 pCtx->bParamSetsLostFlag = false;
407#else
408 pCtx->bReferenceLostAtT0Flag = false;
409#endif
410}
411
412/*!
413 * \brief configure decoder parameters
414 */
415int32_t DecoderConfigParam ( PWelsDecoderContext pCtx, const void_t* kpParam )
416{
417 if ( NULL == pCtx || NULL == kpParam )
418 return 1;
419
420 pCtx->pParam = (SDecodingParam *)WelsMalloc( sizeof(SDecodingParam), "SDecodingParam" );
421
422 if ( NULL == pCtx->pParam )
423 return 1;
424
425 memcpy( pCtx->pParam, kpParam, sizeof(SDecodingParam) );
426 pCtx->iOutputColorFormat = pCtx->pParam->iOutputColorFormat;
427 pCtx->bErrorResilienceFlag = pCtx->pParam->uiEcActiveFlag ? true : false;
428
429 if ( VIDEO_BITSTREAM_SVC == pCtx->pParam->sVideoProperty.eVideoBsType ||
430 VIDEO_BITSTREAM_AVC == pCtx->pParam->sVideoProperty.eVideoBsType )
431 {
432 pCtx->eVideoType = pCtx->pParam->sVideoProperty.eVideoBsType;
433 }
434 else
435 {
436 pCtx->eVideoType = VIDEO_BITSTREAM_DEFAULT;
437 }
438
439 WelsLog(pCtx, WELS_LOG_INFO, "eVideoType: %d\n", pCtx->eVideoType);
440
441 return 0;
442}
443
444/*!
445 *************************************************************************************
446 * \brief Initialize Wels decoder parameters and memory
447 *
448 * \param pCtx input context to be initialized at first stage
449 *
450 * \return 0 - successed
451 * \return 1 - failed
452 *
453 * \note N/A
454 *************************************************************************************
455 */
456int32_t WelsInitDecoder( PWelsDecoderContext pCtx, void_t * pTraceHandle, PWelsLogCallbackFunc pLog )
457{
458 if ( pCtx == NULL ){
459 return ERR_INFO_INVALID_PTR;
460 }
461
462 // default
463 WelsDecoderDefaults( pCtx );
464
465 pCtx->pTraceHandle = pTraceHandle;
466
467 g_pLog = pLog;
468
469 // open decoder
470 WelsOpenDecoder( pCtx );
471
472 // decode mode setting
473 pCtx->iDecoderMode = SW_MODE;
474 pCtx->iSetMode = AUTO_MODE;
475 pCtx->iDecoderOutputProperty = BUFFER_HOST;
476 pCtx->iModeSwitchType = 0; // 0: do not do mode switch
477
478
479 return ERR_NONE;
480}
481
482/*!
483 *************************************************************************************
484 * \brief Uninitialize Wels decoder parameters and memory
485 *
486 * \param pCtx input context to be uninitialized at release stage
487 *
488 * \return NONE
489 *
490 * \note N/A
491 *************************************************************************************
492 */
493void_t WelsEndDecoder( PWelsDecoderContext pCtx )
494{
495 // close decoder
496 WelsCloseDecoder( pCtx );
497}
498
499void_t GetVclNalTemporalId( PWelsDecoderContext pCtx )
500{
501 PAccessUnit pAccessUnit = pCtx->pAccessUnitList;
502 int32_t idx = pAccessUnit->uiStartPos;
503
504 pCtx->iFeedbackVclNalInAu = FEEDBACK_VCL_NAL;
505 pCtx->iFeedbackTidInAu = pAccessUnit->pNalUnitsList[idx]->sNalHeaderExt.uiTemporalId;
506}
507
508/*!
509 *************************************************************************************
510 * \brief First entrance to decoding core interface.
511 *
512 * \param pCtx decoder context
513 * \param pBufBs bit streaming buffer
514 * \param kBsLen size in bytes length of bit streaming buffer input
515 * \param ppDst picture payload data to be output
516 * \param pDstBufInfo buf information of ouput data
517 *
518 * \return 0 - successed
519 * \return 1 - failed
520 *
521 * \note N/A
522 *************************************************************************************
523 */
524int32_t WelsDecodeBs( PWelsDecoderContext pCtx, const uint8_t *kpBsBuf, const int32_t kiBsLen,
525 uint8_t **ppDst, SBufferInfo* pDstBufInfo)
526{
527 if ( !pCtx->bEndOfStreamFlag)
528 {
529 SDataBuffer* pRawData = &pCtx->sRawData;
530
531 int32_t iSrcIdx = 0; //the index of source bit-stream till now after parsing one or more NALs
532 int32_t iSrcConsumed = 0; // consumed bit count of source bs
533 int32_t iDstIdx = 0; //the size of current NAL after 0x03 removal and 00 00 01 removal
534 int32_t iSrcLength = 0; //the total size of current AU or NAL
535
536 int32_t iConsumedBytes = 0;
537 int32_t iOffset = 0;
538
539 uint8_t* pSrcNal = NULL;
540 uint8_t* pDstNal = NULL;
541 uint8_t *pNalPayload = NULL;
542
543
544 if ( NULL == DetectStartCodePrefix( kpBsBuf, &iOffset, kiBsLen ) ) //CAN'T find the 00 00 01 start prefix from the source buffer
545 {
546 return dsBitstreamError;
547 }
548
549 pSrcNal = const_cast<uint8_t*> (kpBsBuf) + iOffset;
550 iSrcLength = kiBsLen - iOffset;
551
552 if ( (kiBsLen + 4) > ( pRawData->pEnd - pRawData->pCurPos ) )
553 {
554 pRawData->pCurPos = pRawData->pHead;
555 }
556
557
558 //copy raw data from source buffer (application) to raw data buffer (codec inside)
559 //0x03 removal and extract all of NAL Unit from current raw data
560 pDstNal = pRawData->pCurPos + 4; //4-bytes used to write the length of current NAL rbsp
561
562 while ( iSrcConsumed < iSrcLength )
563 {
564 if ( ( 2 + iSrcConsumed < iSrcLength ) &&
565 ( 0 == LD16(pSrcNal+iSrcIdx) ) &&
566 ( (pSrcNal[2+iSrcIdx]==0x03) || (pSrcNal[2+iSrcIdx]==0x01) ) )
567 {
568 if ( pSrcNal[2+iSrcIdx] == 0x03 )
569 {
570 ST16(pDstNal+iDstIdx, 0);
571 iDstIdx += 2;
572 iSrcIdx += 3;
573 iSrcConsumed += 3;
574 }
575 else
576 {
577 GetValueOf4Bytes( pDstNal-4, iDstIdx ); //pDstNal-4 (non-aligned by 4) in Solaris10(SPARC). Given value by byte.
578
579 iConsumedBytes = 0;
580 pNalPayload = ParseNalHeader( pCtx, &pCtx->sCurNalHead, pDstNal, iDstIdx, pSrcNal-3, iSrcIdx+3, &iConsumedBytes );
581
582 if (pCtx->bAuReadyFlag)
583 {
584 ConstructAccessUnit( pCtx, ppDst, pDstBufInfo );
585
586 if ( (dsOutOfMemory | dsNoParamSets) & pCtx->iErrorCode)
587 {
588#ifdef LONG_TERM_REF
589 pCtx->bParamSetsLostFlag = true;
590#else
591 pCtx->bReferenceLostAtT0Flag = true;
592#endif
593 ResetParameterSetsState( pCtx );
594
595 if( dsOutOfMemory & pCtx->iErrorCode){
596 return pCtx->iErrorCode;
597 }
598 }
599 }
600
601 if( (IS_PARAM_SETS_NALS(pCtx->sCurNalHead.eNalUnitType) || IS_SEI_NAL(pCtx->sCurNalHead.eNalUnitType)) &&
602 pNalPayload )
603 {
604 if ( ParseNonVclNal( pCtx, pNalPayload, iDstIdx-iConsumedBytes ) )
605 {
606 if ( dsNoParamSets & pCtx->iErrorCode )
607 {
608#ifdef LONG_TERM_REF
609 pCtx->bParamSetsLostFlag = true;
610#else
611 pCtx->bReferenceLostAtT0Flag = true;
612#endif
613 ResetParameterSetsState( pCtx );
614 }
615 return pCtx->iErrorCode;
616 }
617 }
618
619 pDstNal += iDstIdx; //update current position
620 if ( (iSrcLength - iSrcConsumed + 4) > (pRawData->pEnd - pDstNal) )
621 {
622 pRawData->pCurPos = pRawData->pHead;
623 }
624 else
625 {
626 pRawData->pCurPos = pDstNal;
627 }
628 pDstNal = pRawData->pCurPos + 4; //init, 4 bytes used to store the next NAL
629
630 pSrcNal += iSrcIdx+3;
631 iSrcConsumed += 3;
632 iSrcIdx = 0;
633 iDstIdx = 0; //reset 0, used to statistic the length of next NAL
634 }
635 continue;
636 }
637 pDstNal[iDstIdx++] = pSrcNal[iSrcIdx++];
638 iSrcConsumed++;
639 }
640
641 //last NAL decoding
642 GetValueOf4Bytes( pDstNal-4, iDstIdx ); //pDstNal-4 (non-aligned by 4) in Solaris10(SPARC). Given value by byte.
643
644 iConsumedBytes = 0;
645 pNalPayload = ParseNalHeader( pCtx, &pCtx->sCurNalHead, pDstNal, iDstIdx, pSrcNal-3, iSrcIdx+3, &iConsumedBytes );
646
647 if (pCtx->bAuReadyFlag)
648 {
649 ConstructAccessUnit( pCtx, ppDst, pDstBufInfo );
650
651 if ( (dsOutOfMemory | dsNoParamSets) & pCtx->iErrorCode)
652 {
653#ifdef LONG_TERM_REF
654 pCtx->bParamSetsLostFlag = true;
655#else
656 pCtx->bReferenceLostAtT0Flag = true;
657#endif
658 ResetParameterSetsState( pCtx );
659 return pCtx->iErrorCode;
660 }
661 }
662
663 if( (IS_PARAM_SETS_NALS(pCtx->sCurNalHead.eNalUnitType) || IS_SEI_NAL(pCtx->sCurNalHead.eNalUnitType)) && pNalPayload )
664 {
665 if ( ParseNonVclNal( pCtx, pNalPayload, iDstIdx-iConsumedBytes ) )
666 {
667 if ( dsNoParamSets & pCtx->iErrorCode )
668 {
669#ifdef LONG_TERM_REF
670 pCtx->bParamSetsLostFlag = true;
671#else
672 pCtx->bReferenceLostAtT0Flag = true;
673#endif
674 ResetParameterSetsState( pCtx );
675 }
676 return pCtx->iErrorCode;
677 }
678 }
679
680 pDstNal += iDstIdx;
681 pRawData->pCurPos = pDstNal; //init the pCurPos for next NAL(s) storage
682 }
683 else /* no supplementary picture payload input, but stored a picture */
684 {
685 PAccessUnit pCurAu = pCtx->pAccessUnitList; // current access unit, it will never point to NULL after decode's successful initialization
686
687 if ( pCurAu->uiAvailUnitsNum == 0 )
688 {
689 return pCtx->iErrorCode;
690 }
691 else
692 {
693 pCtx->pAccessUnitList->uiEndPos = pCtx->pAccessUnitList->uiAvailUnitsNum - 1;
694
695 ConstructAccessUnit( pCtx, ppDst, pDstBufInfo );
696
697 if ( (dsOutOfMemory | dsNoParamSets) & pCtx->iErrorCode)
698 {
699#ifdef LONG_TERM_REF
700 pCtx->bParamSetsLostFlag = true;
701#else
702 pCtx->bReferenceLostAtT0Flag = true;
703#endif
704 ResetParameterSetsState( pCtx );
705 return pCtx->iErrorCode;
706 }
707
708 }
709 }
710
711 return pCtx->iErrorCode;
712}
713
714/*
715 * set colorspace format in decoder
716 */
717int32_t DecoderSetCsp(PWelsDecoderContext pCtx, const int32_t kiColorFormat)
718{
719 WELS_VERIFY_RETURN_IF( 1, (NULL == pCtx) );
720
721 pCtx->iOutputColorFormat = kiColorFormat;
722 if ( pCtx->pParam != NULL )
723 {
724 pCtx->pParam->iOutputColorFormat = kiColorFormat;
725 }
726
727 return 0;
728}
729
730/*!
731 * \brief make sure synchonozization picture resolution (get from slice header) among different parts (i.e, memory related and so on)
732 * over decoder internal
733 * ( MB coordinate and parts of data within decoder context structure )
734 * \param pCtx Wels decoder context
735 * \param iMbWidth MB width
736 * \pram iMbHeight MB height
737 * \return 0 - successful; none 0 - something wrong
738 */
739int32_t SyncPictureResolutionExt( PWelsDecoderContext pCtx, const int32_t kiMbWidth, const int32_t kiMbHeight )
740{
741 int32_t iErr = ERR_NONE;
742 const int32_t kiPicWidth = kiMbWidth << 4;
743 const int32_t kiPicHeight = kiMbHeight<< 4;
744
745 iErr = WelsRequestMem( pCtx, kiMbWidth, kiMbHeight ); // common memory used
746 if ( ERR_NONE != iErr )
747 {
748 WelsLog( pCtx, WELS_LOG_WARNING, "SyncPictureResolutionExt()::WelsRequestMem--buffer allocated failure.\n" );
749 pCtx->iErrorCode = dsOutOfMemory;
750 return iErr;
751 }
752
753 iErr = InitialDqLayersContext( pCtx, kiPicWidth, kiPicHeight );
754 if ( ERR_NONE != iErr )
755 {
756 WelsLog( pCtx, WELS_LOG_WARNING, "SyncPictureResolutionExt()::InitialDqLayersContext--buffer allocated failure.\n" );
757 pCtx->iErrorCode = dsOutOfMemory;
758 }
759
760 return iErr;
761}
762
763/*!
764 * \brief update maximal picture width and height if applicable when receiving a SPS NAL
765 */
766void_t UpdateMaxPictureResolution( PWelsDecoderContext pCtx, const int32_t kiCurWidth, const int32_t kiCurHeight )
767{
768 //any dimension larger than that of current dimension, should modify the max-dimension
769 if ( kiCurWidth > pCtx->iMaxWidthInSps || kiCurHeight > pCtx->iMaxHeightInSps)
770 {
771 pCtx->iMaxWidthInSps = kiCurWidth;
772 pCtx->iMaxHeightInSps = kiCurHeight;
773 }
774
775 return;
776}
777
778void_t AssignFuncPointerForRec(PWelsDecoderContext pCtx)
779{
780 pCtx->pGetI16x16LumaPredFunc[I16_PRED_V ] = WelsI16x16LumaPredV_c;
781 pCtx->pGetI16x16LumaPredFunc[I16_PRED_H ] = WelsI16x16LumaPredH_c;
782 pCtx->pGetI16x16LumaPredFunc[I16_PRED_DC ] = WelsI16x16LumaPredDc_c;
783 pCtx->pGetI16x16LumaPredFunc[I16_PRED_P ] = WelsI16x16LumaPredPlane_c;
784 pCtx->pGetI16x16LumaPredFunc[I16_PRED_DC_L ] = WelsI16x16LumaPredDcLeft_c;
785 pCtx->pGetI16x16LumaPredFunc[I16_PRED_DC_T ] = WelsI16x16LumaPredDcTop_c;
786 pCtx->pGetI16x16LumaPredFunc[I16_PRED_DC_128] = WelsI16x16LumaPredDcNA_c;
787
788 pCtx->pGetI4x4LumaPredFunc[I4_PRED_V ] = WelsI4x4LumaPredV_c;
789 pCtx->pGetI4x4LumaPredFunc[I4_PRED_H ] = WelsI4x4LumaPredH_c;
790 pCtx->pGetI4x4LumaPredFunc[I4_PRED_DC ] = WelsI4x4LumaPredDc_c;
791 pCtx->pGetI4x4LumaPredFunc[I4_PRED_DC_L ] = WelsI4x4LumaPredDcLeft_c;
792 pCtx->pGetI4x4LumaPredFunc[I4_PRED_DC_T ] = WelsI4x4LumaPredDcTop_c;
793 pCtx->pGetI4x4LumaPredFunc[I4_PRED_DC_128] = WelsI4x4LumaPredDcNA_c;
794 pCtx->pGetI4x4LumaPredFunc[I4_PRED_DDL ] = WelsI4x4LumaPredDDL_c;
795 pCtx->pGetI4x4LumaPredFunc[I4_PRED_DDL_TOP] = WelsI4x4LumaPredDDLTop_c;
796 pCtx->pGetI4x4LumaPredFunc[I4_PRED_DDR ] = WelsI4x4LumaPredDDR_c;
797 pCtx->pGetI4x4LumaPredFunc[I4_PRED_VL ] = WelsI4x4LumaPredVL_c;
798 pCtx->pGetI4x4LumaPredFunc[I4_PRED_VL_TOP] = WelsI4x4LumaPredVLTop_c;
799 pCtx->pGetI4x4LumaPredFunc[I4_PRED_VR ] = WelsI4x4LumaPredVR_c;
800 pCtx->pGetI4x4LumaPredFunc[I4_PRED_HU ] = WelsI4x4LumaPredHU_c;
801 pCtx->pGetI4x4LumaPredFunc[I4_PRED_HD ] = WelsI4x4LumaPredHD_c;
802
803 pCtx->pGetIChromaPredFunc[C_PRED_DC ] = WelsIChromaPredDc_c;
804 pCtx->pGetIChromaPredFunc[C_PRED_H ] = WelsIChromaPredH_c;
805 pCtx->pGetIChromaPredFunc[C_PRED_V ] = WelsIChromaPredV_c;
806 pCtx->pGetIChromaPredFunc[C_PRED_P ] = WelsIChromaPredPlane_c;
807 pCtx->pGetIChromaPredFunc[C_PRED_DC_L ] = WelsIChromaPredDcLeft_c;
808 pCtx->pGetIChromaPredFunc[C_PRED_DC_T ] = WelsIChromaPredDcTop_c;
809 pCtx->pGetIChromaPredFunc[C_PRED_DC_128] = WelsIChromaPredDcNA_c;
810
811 InitDctClipTable();
812 pCtx->pIdctResAddPredFunc = IdctResAddPred_c;
813
814#if defined(X86_ASM)
815 if ( pCtx->uiCpuFlag & WELS_CPU_MMXEXT )
816 {
817 pCtx->pIdctResAddPredFunc = IdctResAddPred_mmx;
818
819 /////////mmx code opt---
820 pCtx->pGetIChromaPredFunc[C_PRED_H] = WelsIChromaPredH_mmx;
821 pCtx->pGetIChromaPredFunc[C_PRED_V] = WelsIChromaPredV_mmx;
822 pCtx->pGetIChromaPredFunc[C_PRED_DC_L ] = WelsIChromaPredDcLeft_mmx;
823 pCtx->pGetIChromaPredFunc[C_PRED_DC_128] = WelsIChromaPredDcNA_mmx;
824 pCtx->pGetI4x4LumaPredFunc[I4_PRED_DDR] = WelsI4x4LumaPredDDR_mmx;
825 pCtx->pGetI4x4LumaPredFunc[I4_PRED_HD ] = WelsI4x4LumaPredHD_mmx;
826 pCtx->pGetI4x4LumaPredFunc[I4_PRED_HU ] = WelsI4x4LumaPredHU_mmx;
827 pCtx->pGetI4x4LumaPredFunc[I4_PRED_VR ] = WelsI4x4LumaPredVR_mmx;
828 pCtx->pGetI4x4LumaPredFunc[I4_PRED_DDL] = WelsI4x4LumaPredDDL_mmx;
829 pCtx->pGetI4x4LumaPredFunc[I4_PRED_VL ] = WelsI4x4LumaPredVL_mmx;
830 }
831 if ( pCtx->uiCpuFlag & WELS_CPU_SSE2 )
832 {
833 /////////sse2 code opt---
834 pCtx->pGetI16x16LumaPredFunc[I16_PRED_DC] = WelsI16x16LumaPredDc_sse2;
835 pCtx->pGetI16x16LumaPredFunc[I16_PRED_P] = WelsI16x16LumaPredPlane_sse2;
836 pCtx->pGetI16x16LumaPredFunc[I16_PRED_H] = WelsI16x16LumaPredH_sse2;
837 pCtx->pGetI16x16LumaPredFunc[I16_PRED_V] = WelsI16x16LumaPredV_sse2;
838 pCtx->pGetI16x16LumaPredFunc[I16_PRED_DC_T ] = WelsI16x16LumaPredDcTop_sse2;
839 pCtx->pGetI16x16LumaPredFunc[I16_PRED_DC_128] = WelsI16x16LumaPredDcNA_sse2;
840 pCtx->pGetIChromaPredFunc[C_PRED_P ] = WelsIChromaPredPlane_sse2;
841 pCtx->pGetIChromaPredFunc[C_PRED_DC] = WelsIChromaPredDc_sse2;
842 pCtx->pGetIChromaPredFunc[C_PRED_DC_T] = WelsIChromaPredDcTop_sse2;
843 }
844#endif
845 DeblockingInit(&pCtx->sDeblockingFunc, pCtx->uiCpuFlag);
846
847 WelsBlockFuncInit(&pCtx->sBlockFunc, pCtx->uiCpuFlag);
848}
849
850} // namespace WelsDec
codec/decoder/core/src/decoder_core.cpp+2106−0
@@ -0,0 +1,2106 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 * decoder_core.c: Wels decoder framework core implementation
32 */
33
34#include <string.h>
35#include "codec_def.h"
36#include "decoder_core.h"
37#include "typedefs.h"
38#include "wels_const.h"
39#include "wels_common_basis.h"
40#include "codec_app_def.h"
41#include "decoder_context.h"
42#include "dec_golomb.h"
43#include "bit_stream.h"
44#include "error_code.h"
45#include "parameter_sets.h"
46#include "fmo.h"
47#include "utils.h"
48#include "memmgr_nal_unit.h"
49#include "dec_frame.h"
50#include "au_parser.h"
51#include "pic_queue.h"
52#include "ls_defines.h"
53#include "decode_slice.h"
54#include "manage_dec_ref.h"
55#include "expand_pic.h"
56#include "decoder.h"
57#include "decode_mb_aux.h"
58#include "mem_align.h"
59
60namespace WelsDec {
61
62static inline int32_t DecodeFrameConstruction( PWelsDecoderContext pCtx, uint8_t **ppDst, int32_t *pDstLen, int32_t *pWidth, int32_t *pHeight, SBufferInfo *pDstInfo )
63{
64 PDqLayer pCurDq = pCtx->pCurDqLayer;
65 PPicture pPic = pCtx->pDec;
66
67 const int32_t kiWidth = pCurDq->iMbWidth << 4;
68 const int32_t kiHeight= pCurDq->iMbHeight << 4;
69
70 const int32_t kiTotalNumMbInCurLayer = pCurDq->iMbWidth * pCurDq->iMbHeight;
71
72 if ( pPic->iTotalNumMbRec != kiTotalNumMbInCurLayer )
73 {
74 WelsLog( pCtx, WELS_LOG_WARNING, "DecodeFrameConstruction():::iTotalNumMbRec:%d, total_num_mb_sps:%d, cur_layer_mb_width:%d, cur_layer_mb_height:%d \n",
75 pPic->iTotalNumMbRec, kiTotalNumMbInCurLayer, pCurDq->iMbWidth, pCurDq->iMbHeight );
76 return -1;
77 }
78#ifdef NO_WAITING_AU
79 pPic->iTotalNumMbRec = 0;
80#endif
81
82 if ( I_SLICE == pCurDq->sLayerInfo.sSliceInLayer.eSliceType )
83 {
84 memcpy( &(pCtx->sFrameCrop), &(pCurDq->sLayerInfo.sSliceInLayer.sSliceHeaderExt.sSliceHeader.pSps->sFrameCrop), sizeof(SPosOffset) );//confirmed_safe_unsafe_usage
85#ifdef LONG_TERM_REF
86 pCtx->bParamSetsLostFlag = false;
87#else
88 pCtx->bReferenceLostAtT0Flag = false; // need initialize it due I_SLICE, 6/4/2010
89#endif //LONG_TERM_REF
90 WelsLog( pCtx, WELS_LOG_INFO, "DecodeFrameConstruction()::::output good I frame, %d x %d, crop_left:%d, crop_right:%d, crop_top:%d, crop_bottom:%d.\n",
91 kiWidth, kiHeight, pCtx->sFrameCrop.iLeftOffset, pCtx->sFrameCrop.iRightOffset, pCtx->sFrameCrop.iTopOffset, pCtx->sFrameCrop.iBottomOffset );
92 WelsLog( pCtx, WELS_LOG_INFO, "After decoding, set_mode:[%s], eWorkMode:[%s], eBufferProperty:[%s]\n",
93 DECODER_MODE_NAME(pCtx->iSetMode), DECODER_MODE_NAME(pCtx->iDecoderMode), OUTPUT_PROPERTY_NAME(pDstInfo->eBufferProperty));
94 }
95
96 //////output:::normal path
97 ppDst[0] = pPic->pData[0];
98 ppDst[1] = pPic->pData[1];
99 ppDst[2] = pPic->pData[2];
100 *pDstLen = pPic->iLinesize[0];
101 *(pDstLen+1) = pPic->iLinesize[1];
102 *pWidth = kiWidth;
103 *pHeight = kiHeight;
104
105 pDstInfo->UsrData.sSystemBuffer.iFormat = videoFormatI420;
106
107 pDstInfo->UsrData.sSystemBuffer.iWidth = kiWidth - (pCtx->sFrameCrop.iLeftOffset + pCtx->sFrameCrop.iRightOffset)*2;
108 pDstInfo->UsrData.sSystemBuffer.iHeight = kiHeight - (pCtx->sFrameCrop.iTopOffset + pCtx->sFrameCrop.iBottomOffset)*2;
109 pDstInfo->UsrData.sSystemBuffer.iStride[0] = pPic->iLinesize[0];
110 pDstInfo->UsrData.sSystemBuffer.iStride[1] = pPic->iLinesize[1];
111 ppDst[0] = ppDst[0] + pCtx->sFrameCrop.iTopOffset*2*pPic->iLinesize[0] + pCtx->sFrameCrop.iLeftOffset*2;
112 ppDst[1] = ppDst[1] + pCtx->sFrameCrop.iTopOffset *pPic->iLinesize[1] + pCtx->sFrameCrop.iLeftOffset;
113 ppDst[2] = ppDst[2] + pCtx->sFrameCrop.iTopOffset *pPic->iLinesize[1] + pCtx->sFrameCrop.iLeftOffset;
114 pDstInfo->eBufferProperty = BUFFER_HOST;
115 pDstInfo->iBufferStatus = 1;
116
117 return 0;
118}
119
120inline BOOL_T CheckSliceNeedReconstruct(int16_t iCurDid, int16_t iCurQid, bool_t bStoreRefBasePicFlag,
121 uint8_t uiDidMax, uint8_t uiLayerDqId, uint8_t uiTargetDqId)
122{
123 return ( (iCurDid == uiDidMax) && (iCurQid == BASE_QUALITY_ID) && (bStoreRefBasePicFlag) ) // store base
124 || (uiLayerDqId == uiTargetDqId); // target layer
125}
126
127inline uint8_t GetTargetDqId(uint8_t uiTargetDqId, SDecodingParam * psParam)
128{
129 uint8_t uiRequiredDqId = psParam ? psParam->uiTargetDqLayer : (uint8_t)255;
130
131 return WELS_MIN(uiTargetDqId, uiRequiredDqId);
132}
133
134
135inline void_t HandleReferenceLostL0(PWelsDecoderContext pCtx, PNalUnit pCurNal)
136{
137 if( 0 == pCurNal->sNalHeaderExt.uiTemporalId ){
138 pCtx->bReferenceLostAtT0Flag = true;
139 }
140#ifndef LONG_TERM_REF
141 if( pCtx->bReferenceLostAtT0Flag ){
142 ResetParameterSetsState(pCtx);
143 }
144#endif
145 pCtx->iErrorCode |= dsBitstreamError;
146}
147
148inline void_t HandleReferenceLost(PWelsDecoderContext pCtx, PNalUnit pCurNal)
149{
150 if( (0 == pCurNal->sNalHeaderExt.uiTemporalId) || (1 == pCurNal->sNalHeaderExt.uiTemporalId) ){
151 pCtx->bReferenceLostAtT0Flag = true;
152 }
153#ifndef LONG_TERM_REF
154 if( pCtx->bReferenceLostAtT0Flag ){
155 ResetParameterSetsState(pCtx);
156 }
157#endif
158 pCtx->iErrorCode |= dsRefLost;
159}
160
161inline int32_t WelsDecodeConstructSlice(PWelsDecoderContext pCtx, PNalUnit pCurNal)
162{
163 int32_t iRet = WelsTargetSliceConstruction(pCtx);
164
165 if( iRet ){
166 HandleReferenceLostL0(pCtx, pCurNal);
167 }
168
169 return iRet;
170}
171
172/*
173 * Predeclared function routines ..
174 */
175int32_t ParseRefPicListReordering ( PBitStringAux pBs, PSliceHeader pSh )
176{
177 int32_t iList = 0;
178 const ESliceType keSt = pSh->eSliceType;
179 PRefPicListReorderSyn pRefPicListReordering = &pSh->pRefPicListReordering;
180
181 if ( keSt == I_SLICE || keSt == SI_SLICE )
182 return ERR_NONE;
183
184 // Common syntaxs for P or B slices: list0, list1 followed if B slices used.
185 do {
186 pRefPicListReordering->bRefPicListReorderingFlag[iList] = !!BsGetOneBit( pBs);
187
188 if ( pRefPicListReordering->bRefPicListReorderingFlag[iList] ){
189 int32_t iIdx = 0;
190 do {
191 const uint8_t kuiIdc = BsGetUe( pBs );
192
193 //Fixed the referrence list reordering crash issue.(fault kIdc value > 3 case)---
194 if ((iIdx >= MAX_REF_PIC_COUNT )||(kuiIdc > 3))
195 {
196 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_REF_REORDERING);
197 }
198 pRefPicListReordering->sReorderingSyn[iList][iIdx].uiReorderingOfPicNumsIdc = kuiIdc;
199 if ( kuiIdc == 3 )
200 break;
201
202 if ( iIdx >= pSh->uiRefCount[iList] || iIdx >= MAX_REF_PIC_COUNT )
203 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_REF_REORDERING);
204
205 if (kuiIdc == 0 || kuiIdc == 1){
206 pRefPicListReordering->sReorderingSyn[iList][iIdx].uiAbsDiffPicNumMinus1 = BsGetUe( pBs ); // uiAbsDiffPicNumMinus1
207 }
208 else if (kuiIdc == 2){
209 pRefPicListReordering->sReorderingSyn[iList][iIdx].uiLongTermPicNum= BsGetUe( pBs );
210 }
211
212 ++ iIdx;
213 } while(true);
214 }
215 if (keSt != B_SLICE)
216 break;
217 ++ iList;
218 } while(iList < LIST_A);
219
220 return ERR_NONE;
221}
222
223int32_t ParseDecRefPicMarking ( PWelsDecoderContext pCtx, PBitStringAux pBs, PSliceHeader pSh, PSps pSps, const bool_t kbIdrFlag)
224{
225 PRefPicMarking const kpRefMarking = &pSh->sRefMarking;
226
227 if ( kbIdrFlag ){
228 kpRefMarking->bNoOutputOfPriorPicsFlag = !!BsGetOneBit( pBs );
229 kpRefMarking->bLongTermRefFlag = !!BsGetOneBit( pBs );
230 }
231 else{
232 kpRefMarking->bAdaptiveRefPicMarkingModeFlag = !!BsGetOneBit( pBs );
233 if (kpRefMarking->bAdaptiveRefPicMarkingModeFlag){
234 int32_t iIdx = 0;
235 do {
236 const int32_t kiMmco = BsGetUe( pBs );
237
238 kpRefMarking->sMmcoRef[iIdx].uiMmcoType = kiMmco;
239 if (kiMmco == MMCO_END)
240 break;
241
242 if (kiMmco == MMCO_SHORT2UNUSED || kiMmco == MMCO_SHORT2LONG)
243 {
244 kpRefMarking->sMmcoRef[iIdx].iDiffOfPicNum = 1 + BsGetUe( pBs );
245 kpRefMarking->sMmcoRef[iIdx].iShortFrameNum = (pSh->iFrameNum - kpRefMarking->sMmcoRef[iIdx].iDiffOfPicNum) & ((1<<pSps->uiLog2MaxFrameNum)-1);
246 }
247 else if (kiMmco == MMCO_LONG2UNUSED)
248 kpRefMarking->sMmcoRef[iIdx].uiLongTermPicNum = BsGetUe( pBs );
249
250 if (kiMmco == MMCO_SHORT2LONG || kiMmco == MMCO_LONG)
251 {
252 kpRefMarking->sMmcoRef[iIdx].iLongTermFrameIdx = BsGetUe( pBs );
253 }
254 else if (kiMmco == MMCO_SET_MAX_LONG)
255 kpRefMarking->sMmcoRef[iIdx].iMaxLongTermFrameIdx = -1 + BsGetUe( pBs );
256 ++ iIdx;
257
258 } while(iIdx < MAX_MMCO_COUNT);
259 }
260 }
261
262 return ERR_NONE;
263}
264
265bool_t FillDefaultSliceHeaderExt ( PSliceHeaderExt pShExt, PNalUnitHeaderExt pNalExt )
266{
267 if ( pShExt == NULL || pNalExt == NULL )
268 return false;
269
270 if ( pNalExt->iNoInterLayerPredFlag || pNalExt->uiQualityId > 0 )
271 pShExt->bBasePredWeightTableFlag = false;
272 else
273 pShExt->bBasePredWeightTableFlag = true;
274 pShExt->uiRefLayerDqId = (uint8_t)-1;
275 pShExt->uiDisableInterLayerDeblockingFilterIdc = 0;
276 pShExt->iInterLayerSliceAlphaC0Offset = 0;
277 pShExt->iInterLayerSliceBetaOffset = 0;
278 pShExt->bConstrainedIntraResamplingFlag = false;
279 pShExt->uiRefLayerChromaPhaseXPlus1Flag = 0;
280 pShExt->uiRefLayerChromaPhaseYPlus1 = 1;
281 //memset(&pShExt->sScaledRefLayer, 0, sizeof(SPosOffset));
282
283 pShExt->iScaledRefLayerPicWidthInSampleLuma = pShExt->sSliceHeader.iMbWidth << 4;
284 pShExt->iScaledRefLayerPicHeightInSampleLuma = pShExt->sSliceHeader.iMbHeight << 4;
285
286 pShExt->bSliceSkipFlag = false;
287 pShExt->bAdaptiveBaseModeFlag = false;
288 pShExt->bDefaultBaseModeFlag = false;
289 pShExt->bAdaptiveMotionPredFlag = false;
290 pShExt->bDefaultMotionPredFlag = false;
291 pShExt->bAdaptiveResidualPredFlag = false;
292 pShExt->bDefaultResidualPredFlag = false;
293 pShExt->bTCoeffLevelPredFlag = false;
294 pShExt->uiScanIdxStart = 0;
295 pShExt->uiScanIdxEnd = 15;
296
297 return true;
298}
299
300/*
301 * WelsInitMemory
302 * Memory request for new introduced data
303 * Especially for:
304 * rbsp_au_buffer, cur_dq_layer_ptr and ref_dq_layer_ptr in MB info cache.
305 * return:
306 * 0 - success; otherwise returned error_no defined in error_no.h.
307*/
308int32_t WelsInitMemory( PWelsDecoderContext pCtx )
309{
310 if (pCtx == NULL){
311 return ERR_INFO_INVALID_PTR;
312 }
313
314 if ( MemInitNalList( &pCtx->pAccessUnitList, MAX_NAL_UNIT_NUM_IN_AU ) != 0 )
315 return ERR_INFO_OUT_OF_MEMORY;
316
317 if ( ( pCtx->sRawData.pHead = static_cast<uint8_t*> (WelsMalloc( MAX_ACCESS_UINT_CAPACITY, "pCtx->sRawData->pHead" )) ) == NULL )
318 {
319 return ERR_INFO_OUT_OF_MEMORY;
320 }
321 pCtx->sRawData.pStartPos =
322 pCtx->sRawData.pCurPos = pCtx->sRawData.pHead;
323 pCtx->sRawData.pEnd = pCtx->sRawData.pHead + MAX_ACCESS_UINT_CAPACITY;
324
325 pCtx->uiTargetDqId = (uint8_t)-1;
326 pCtx->bEndOfStreamFlag = false;
327 pCtx->iImgWidthInPixel = 0;
328 pCtx->iImgHeightInPixel = 0;
329
330 return ERR_NONE;
331}
332
333/*
334 * WelsFreeMemory
335 * Free memory introduced in WelsInitMemory at destruction of decoder.
336 *
337 */
338void_t WelsFreeMemory( PWelsDecoderContext pCtx )
339{
340 if ( pCtx == NULL )
341 return;
342
343 if ( NULL != pCtx->pParam )
344 {
345 WelsFree( pCtx->pParam, "pCtx->pParam" );
346
347 pCtx->pParam = NULL;
348 }
349
350 MemFreeNalList( &pCtx->pAccessUnitList );
351
352 if ( pCtx->sRawData.pHead )
353 {
354 WelsFree(pCtx->sRawData.pHead, "pCtx->sRawData->pHead");
355 }
356 pCtx->sRawData.pHead = NULL;
357 pCtx->sRawData.pEnd = NULL;
358 pCtx->sRawData.pStartPos = NULL;
359 pCtx->sRawData.pCurPos = NULL;
360}
361
362/*
363 * DecodeNalHeaderExt
364 * Trigger condition: NAL_UNIT_TYPE = NAL_UNIT_PREFIX or NAL_UNIT_CODED_SLICE_EXT
365 * Parameter:
366 * pNal: target NALUnit ptr
367 * pSrc: NAL Unit bitstream
368 */
369void_t DecodeNalHeaderExt( PNalUnit pNal, uint8_t* pSrc )
370{
371 PNalUnitHeaderExt pHeaderExt = &pNal->sNalHeaderExt;
372
373 uint8_t uiCurByte = *pSrc;
374 pHeaderExt->bIdrFlag = !!(uiCurByte & 0x40);
375 pHeaderExt->uiPriorityId = uiCurByte & 0x3F;
376
377 uiCurByte = *(++pSrc);
378 pHeaderExt->iNoInterLayerPredFlag = uiCurByte >> 7;
379 pHeaderExt->uiDependencyId = (uiCurByte & 0x70) >> 4;
380 pHeaderExt->uiQualityId = uiCurByte & 0x0F;
381 uiCurByte = *(++pSrc);
382 pHeaderExt->uiTemporalId = uiCurByte >> 5;
383 pHeaderExt->bUseRefBasePicFlag = !!(uiCurByte & 0x10);
384 pHeaderExt->bDiscardableFlag = !!(uiCurByte & 0x08);
385 pHeaderExt->bOutputFlag = !!(uiCurByte & 0x04);
386 pHeaderExt->uiReservedThree2Bits = uiCurByte & 0x03;
387 pHeaderExt->uiLayerDqId = (pHeaderExt->uiDependencyId << 4) | pHeaderExt->uiQualityId;
388}
389
390
391#ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
392int32_t CheckPpsId( PWelsDecoderContext pCtx, PPps* ppPps, uint32_t uiPpsId )
393{
394 PPps pPpsList = pCtx->sPpsBuffer;
395 int32_t iPpsNum = pCtx->iPpsTotalNum;
396 int32_t i = 0;
397
398 if ( iPpsNum <= 0 )
399 {
400 pCtx->iErrorCode |= dsNoParamSets;
401
402 WelsLog( pCtx, WELS_LOG_WARNING, "CheckPpsId():::::PPS list is empty...NO PPS!!!\n" );
403 return dsNoParamSets;
404 }
405
406 while ( i < iPpsNum )
407 {
408 if ( uiPpsId == pPpsList[i].iPpsId )
409 {
410 *ppPps = &pPpsList[i];
411 break;
412 }
413 else
414 {
415 ++i;
416 }
417 }
418
419 if ( i == iPpsNum )
420 {
421 pCtx->iErrorCode |= dsNoParamSets;
422
423 WelsLog( pCtx, WELS_LOG_WARNING, "CheckPpsId()::::::CAN NOT find the matching from the PPS List. iPpsId:%d\n", uiPpsId );
424 return dsNoParamSets;
425 }
426
427 return 0;
428}
429
430int32_t CheckSpsId( PWelsDecoderContext pCtx, PSubsetSps* ppSubsetSps, PSps* ppSps, int32_t iSpsId, bool_t bExtensionFlag )
431{
432 PSps pSpsList = pCtx->sSpsBuffer;
433 PSubsetSps pSubspsList = pCtx->sSubsetSpsBuffer;
434
435 int32_t iSpsNum = pCtx->iSpsTotalNum;
436 int32_t iSubspsNum = pCtx->iSubspsTotalNum;
437 int32_t i = 0;
438
439 if ( bExtensionFlag )
440 {
441 if ( iSubspsNum <= 0 )
442 {
443 pCtx->iErrorCode |= dsNoParamSets;
444
445 WelsLog( pCtx, WELS_LOG_WARNING, "CheckSpsId()::::SUBSPS list is empty....NO SUBSPS\n" );
446 return dsNoParamSets;
447 }
448 while ( i < iSubspsNum )
449 {
450 if ( iSpsId == pSubspsList[i].sSps.iSpsId )
451 {
452 *ppSubsetSps = &pSubspsList[i];
453 *ppSps = &pSubspsList[i].sSps;
454 break;
455 }
456 else
457 {
458 ++i;
459 }
460 }
461 if ( i == iSubspsNum )
462 {
463 pCtx->iErrorCode |= dsNoParamSets;
464
465 WelsLog( pCtx, WELS_LOG_WARNING, "CheckSpsId()::::::CAN NOT find the matching from the SUBSPS List. iSpsId:%d\n", iSpsId );
466 return dsNoParamSets;
467 }
468 }
469 else
470 {
471 if ( iSpsNum <= 0 )
472 {
473 pCtx->iErrorCode |= dsNoParamSets;
474
475 WelsLog( pCtx, WELS_LOG_WARNING, "CheckSpsId()::::SPS list is empty....NO SPS\n" );
476 return dsNoParamSets;
477 }
478 while ( i < iSpsNum )
479 {
480 if ( iSpsId == pSpsList[i].iSpsId )
481 {
482 *ppSubsetSps = NULL;
483 *ppSps = &pSpsList[i];
484 break;
485 }
486 else
487 {
488 ++i;
489 }
490 }
491 if ( i == iSpsNum )
492 {
493 pCtx->iErrorCode |= dsNoParamSets;
494
495 WelsLog( pCtx, WELS_LOG_WARNING, "CheckSpsId()::::::CAN NOT find the matching from the SPS List. iSpsId:%d\n", iSpsId );
496 return dsNoParamSets;
497 }
498 }
499
500 return 0;
501}
502
503#endif
504/*
505 * decode_slice_header_avc
506 * Parse slice header of bitstream in avc for storing data structure
507 */
508int32_t ParseSliceHeaderSyntaxs ( PWelsDecoderContext pCtx, PBitStringAux pBs, const bool_t kbExtensionFlag )
509{
510 PNalUnit const kpCurNal = pCtx->pAccessUnitList->pNalUnitsList[pCtx->pAccessUnitList->uiAvailUnitsNum-1];
511
512 PNalUnitHeaderExt pNalHeaderExt = NULL;
513 PSliceHeader pSliceHead = NULL;
514 PSliceHeaderExt pSliceHeadExt = NULL;
515 PSubsetSps pSubsetSps = NULL;
516 PSps pSps = NULL;
517 PPps pPps = NULL;
518 ENalUnitType eNalType = static_cast<ENalUnitType> (0);
519 int32_t iPpsId = 0;
520 int32_t iRet = ERR_NONE;
521 uint8_t uiSliceType = 0;
522 uint8_t uiQualityId = BASE_QUALITY_ID;
523 bool_t bIdrFlag = false;
524 bool_t bSgChangeCycleInvolved = false; // involved slice group change cycle ?
525
526 if (kpCurNal == NULL)
527 {
528 return ERR_INFO_OUT_OF_MEMORY;
529 }
530
531 pNalHeaderExt = &kpCurNal->sNalHeaderExt;
532 pSliceHead = &kpCurNal->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader;
533 eNalType = pNalHeaderExt->sNalUnitHeader.eNalUnitType;
534
535 pSliceHeadExt = &kpCurNal->sNalData.sVclNal.sSliceHeaderExt;
536
537 if ( pSliceHeadExt ){
538 SRefBasePicMarking sBaseMarking;
539 const bool_t kbStoreRefBaseFlag = pSliceHeadExt->bStoreRefBasePicFlag;
540 memcpy(&sBaseMarking, &pSliceHeadExt->sRefBasePicMarking, sizeof(SRefBasePicMarking));//confirmed_safe_unsafe_usage
541 memset(pSliceHeadExt, 0, sizeof(SSliceHeaderExt));
542 pSliceHeadExt->bStoreRefBasePicFlag = kbStoreRefBaseFlag;
543 memcpy(&pSliceHeadExt->sRefBasePicMarking, &sBaseMarking, sizeof(SRefBasePicMarking));//confirmed_safe_unsafe_usage
544 }
545
546 kpCurNal->sNalData.sVclNal.bSliceHeaderExtFlag = kbExtensionFlag;
547
548 pSliceHead->iFirstMbInSlice = BsGetUe( pBs );
549
550 uiSliceType= BsGetUe( pBs );
551 if(uiSliceType > 9)
552 {
553 WelsLog( pCtx, WELS_LOG_WARNING, "slice type too large (%d) at first_mb(%d)\n", uiSliceType, pSliceHead->iFirstMbInSlice);
554 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SLICE_TYPE);
555 }
556 if(uiSliceType > 4)
557 uiSliceType -= 5;
558
559 if ( kbExtensionFlag ){
560 if (uiSliceType > 2){
561 WelsLog( pCtx, WELS_LOG_WARNING, "Invalid slice type(%d).\n", uiSliceType);
562 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SLICE_TYPE);
563 }
564 }
565
566 pSliceHead->eSliceType = static_cast <ESliceType> (uiSliceType);
567
568 iPpsId= BsGetUe( pBs );
569
570 if(iPpsId >= MAX_PPS_COUNT){
571 WelsLog( pCtx, WELS_LOG_WARNING, "iPpsId out of range\n");
572 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_PPS_ID_OVERFLOW);
573 }
574
575#ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
576 if ( CheckPpsId( pCtx, &pPps, iPpsId ) )
577 {
578 return dsNoParamSets;
579 }
580#else
581 pPps = &pCtx->sPpsBuffer[iPpsId];
582#endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
583
584 if (pPps->uiNumSliceGroups == 0){
585 WelsLog( pCtx, WELS_LOG_WARNING, "non existing PPS referenced\n");
586 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_NO_PARAM_SETS);
587 }
588
589 if (pPps->iSpsId >= MAX_SPS_COUNT){
590 WelsLog( pCtx, WELS_LOG_WARNING, "iSpsId out of range\n");
591 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_SPS_ID_OVERFLOW);
592 }
593
594
595#ifdef MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
596 if ( CheckSpsId( pCtx, &pSubsetSps, &pSps, pPps->iSpsId, kExtensionFlag ) )
597 {
598 return dsNoParamSets;
599 }
600#else
601 if ( kbExtensionFlag )
602 {
603 pSubsetSps = &pCtx->sSubsetSpsBuffer[pPps->iSpsId];
604 pSps = &pSubsetSps->sSps;
605 }
606 else
607 {
608 pSps = &pCtx->sSpsBuffer[pPps->iSpsId];
609 }
610 pCtx->pSps = pSps;
611#endif //MOSAIC_AVOID_BASED_ON_SPS_PPS_ID
612 pSliceHead->iPpsId = iPpsId;
613 pSliceHead->iSpsId = pPps->iSpsId;
614 pSliceHead->pPps = pPps;
615 pSliceHead->pSps = pSps;
616
617 pSliceHeadExt->pSubsetSps = pSubsetSps;
618
619 bIdrFlag = (!kbExtensionFlag && eNalType == NAL_UNIT_CODED_SLICE_IDR) || (kbExtensionFlag && pNalHeaderExt->bIdrFlag);
620
621 if(pSps->uiLog2MaxFrameNum == 0){
622 WelsLog( pCtx, WELS_LOG_WARNING, "non existing SPS referenced\n");
623 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_NO_PARAM_SETS);
624 }
625 pSliceHead->iFrameNum = BsGetBits(pBs, pSps->uiLog2MaxFrameNum);
626
627 pSliceHead->bFieldPicFlag = false;
628 pSliceHead->bBottomFiledFlag = false;
629 if( !pSps->bFrameMbsOnlyFlag ){
630 WelsLog( pCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(): frame_mbs_only_flag = %d not supported. \n", pSps->bFrameMbsOnlyFlag );
631 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_MBAFF);
632 }
633 pSliceHead->iMbWidth = pSps->iMbWidth;
634 pSliceHead->iMbHeight = pSps->iMbHeight / (1 + pSliceHead->bFieldPicFlag);
635
636 if ( bIdrFlag ){
637 if ( pSliceHead->iFrameNum != 0 ){
638 WelsLog( pCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(), invaild frame number: %d due to IDR frame introduced!\n", pSliceHead->iFrameNum);
639 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_FRAME_NUM);
640 }
641 pSliceHead->uiIdrPicId = BsGetUe(pBs); /* uiIdrPicId */
642#ifdef LONG_TERM_REF
643 pCtx->uiCurIdrPicId = pSliceHead->uiIdrPicId;
644#endif
645 }
646
647 pSliceHead->iDeltaPicOrderCntBottom = 0;
648 pSliceHead->iDeltaPicOrderCnt[0] =
649 pSliceHead->iDeltaPicOrderCnt[1] = 0;
650 if(pSps->uiPocType == 0){
651 pSliceHead->iPicOrderCntLsb = BsGetBits(pBs, pSps->iLog2MaxPocLsb);
652 if( pPps->bPicOrderPresentFlag && !pSliceHead->bFieldPicFlag ){
653 pSliceHead->iDeltaPicOrderCntBottom = BsGetSe(pBs);
654 }
655 }
656 else if(pSps->uiPocType == 1 && !pSps->bDeltaPicOrderAlwaysZeroFlag ){
657 pSliceHead->iDeltaPicOrderCnt[0] = BsGetSe(pBs);
658 if( pPps->bPicOrderPresentFlag && !pSliceHead->bFieldPicFlag )
659 pSliceHead->iDeltaPicOrderCnt[1]= BsGetSe(pBs);
660 }
661
662 pSliceHead->iRedundantPicCnt = 0;
663 if( pPps->bRedundantPicCntPresentFlag ){
664 pSliceHead->iRedundantPicCnt = BsGetUe(pBs);
665 }
666
667 //set defaults, might be overriden a few line later
668 pSliceHead->uiRefCount[0] = pPps->uiNumRefIdxL0Active;
669 pSliceHead->uiRefCount[1] = pPps->uiNumRefIdxL1Active;
670 if ( kbExtensionFlag ){
671 uiQualityId = pNalHeaderExt->uiQualityId;
672 if ( BASE_QUALITY_ID == uiQualityId && (EP_SLICE == uiSliceType || EB_SLICE == uiSliceType) ){
673 const bool_t kbBipredFlag = (EB_SLICE == uiSliceType);
674 if ( kbBipredFlag )
675 {
676 WelsLog ( pCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(): kbBipredFlag = 1 not supported.\n");
677 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_BIPRED);
678 }
679 pSliceHead->bNumRefIdxActiveOverrideFlag = !!BsGetOneBit(pBs);
680 if ( pSliceHead->bNumRefIdxActiveOverrideFlag ){
681 pSliceHead->uiRefCount[0] = 1 + BsGetUe(pBs);
682 }
683 }
684 }
685 else if(uiSliceType == P_SLICE || uiSliceType == SP_SLICE || uiSliceType == B_SLICE){
686 const bool_t kbBipredFlag = (B_SLICE == uiSliceType);
687 if( kbBipredFlag ){
688 WelsLog ( pCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(): kbBipredFlag = 1 not supported.\n");
689 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_BIPRED);
690 }
691 pSliceHead->bNumRefIdxActiveOverrideFlag = !!BsGetOneBit(pBs);
692 if( pSliceHead->bNumRefIdxActiveOverrideFlag ){
693 pSliceHead->uiRefCount[0] = 1 + BsGetUe(pBs);
694 }
695 }
696
697 if( pSliceHead->uiRefCount[0] > MAX_REF_PIC_COUNT || pSliceHead->uiRefCount[1] > MAX_REF_PIC_COUNT){
698 WelsLog( pCtx, WELS_LOG_WARNING, "reference overflow\n");
699 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_REF_COUNT_OVERFLOW);
700 }
701
702 if ( BASE_QUALITY_ID == uiQualityId ){
703 iRet = ParseRefPicListReordering(pBs, pSliceHead);
704 if (iRet != ERR_NONE){
705 WelsLog( pCtx, WELS_LOG_WARNING, "invalid ref pPic list reordering syntaxs!\n");
706 return iRet;
707 }
708
709 if ( kbExtensionFlag ){
710 if ( pNalHeaderExt->iNoInterLayerPredFlag || pNalHeaderExt->uiQualityId > 0 )
711 pSliceHeadExt->bBasePredWeightTableFlag = false;
712 else
713 pSliceHeadExt->bBasePredWeightTableFlag = true;
714 }
715
716 if( kpCurNal->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc != 0 ){
717 iRet = ParseDecRefPicMarking(pCtx, pBs, pSliceHead, pSps, bIdrFlag );
718 if (iRet != ERR_NONE){
719 return iRet;
720 }
721
722 if ( kbExtensionFlag && !pSubsetSps->sSpsSvcExt.bSliceHeaderRestrictionFlag ){
723 pSliceHeadExt->bStoreRefBasePicFlag = !!BsGetOneBit(pBs);
724 if ( (pNalHeaderExt->bUseRefBasePicFlag || pSliceHeadExt->bStoreRefBasePicFlag) && !bIdrFlag ){
725 WelsLog( pCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(): bUseRefBasePicFlag or bStoreRefBasePicFlag = 1 not supported.\n" );
726 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_ILP);
727 }
728 }
729 }
730 }
731
732 if ( pPps->bEntropyCodingModeFlag ){
733 WelsLog( pCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(): CABAC in Enhancement layer not supported.\n" );
734 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_CABAC_EL);
735 }
736
737 pSliceHead->iSliceQpDelta = BsGetSe(pBs);
738 pSliceHead->iSliceQp = pPps->iPicInitQp + pSliceHead->iSliceQpDelta;
739 if( pSliceHead->iSliceQp < 0 || pSliceHead->iSliceQp > 51 ){
740 WelsLog( pCtx, WELS_LOG_WARNING, "QP %d out of range\n", pSliceHead->iSliceQp);
741 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_QP);
742 }
743
744 //FIXME qscale / qp ... stuff
745 if ( !kbExtensionFlag ){
746 if( uiSliceType == SP_SLICE || uiSliceType == SI_SLICE )
747 {
748 WelsLog( pCtx, WELS_LOG_WARNING, "SP/SI not supported\n");
749 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_SPSI);
750 }
751 }
752
753 pSliceHead->uiDisableDeblockingFilterIdc = 0;
754 pSliceHead->iSliceAlphaC0Offset = 0;
755 pSliceHead->iSliceBetaOffset = 0;
756 if ( pPps->bDeblockingFilterControlPresentFlag ){
757 pSliceHead->uiDisableDeblockingFilterIdc = BsGetUe(pBs);
758 //refer to JVT-X201wcm1.doc G.7.4.3.4--2010.4.20
759 if ( pSliceHead->uiDisableDeblockingFilterIdc > 6 )
760 {
761 WelsLog( pCtx, WELS_LOG_WARNING, "disable_deblock_filter_idc (%d) out of range [0, 6]\n", pSliceHead->uiDisableDeblockingFilterIdc );
762 return ERR_INFO_INVALID_DBLOCKING_IDC;
763 }
764 if (pSliceHead->uiDisableDeblockingFilterIdc != 1){
765 pSliceHead->iSliceAlphaC0Offset = BsGetSe(pBs) << 1; // slice_alpha_c0_offset_div2
766 pSliceHead->iSliceBetaOffset = BsGetSe(pBs) << 1; // iSliceBetaOffset
767 }
768 }
769
770 bSgChangeCycleInvolved = (pPps->uiNumSliceGroups > 1 && pPps->uiSliceGroupMapType >= 3 && pPps->uiSliceGroupMapType <= 5);
771 if ( kbExtensionFlag && bSgChangeCycleInvolved )
772 bSgChangeCycleInvolved= (bSgChangeCycleInvolved && (uiQualityId == BASE_QUALITY_ID));
773 if ( bSgChangeCycleInvolved ){
774 if ( pPps->uiSliceGroupChangeRate > 0 ){
775 const int32_t kiNumBits = (int32_t)WELS_CEIL(log(static_cast<double>(1 + pPps->uiPicSizeInMapUnits / pPps->uiSliceGroupChangeRate)));
776 pSliceHead->iSliceGroupChangeCycle = BsGetBits(pBs, kiNumBits); // For FMO extra types
777 }
778 else
779 pSliceHead->iSliceGroupChangeCycle = 0;
780 }
781
782 if ( !kbExtensionFlag ){
783 FillDefaultSliceHeaderExt ( pSliceHeadExt, pNalHeaderExt );
784 }
785 else{
786 /* Extra syntax elements newly introduced */
787 pSliceHeadExt->pSubsetSps = pSubsetSps;
788
789 if ( !pNalHeaderExt->iNoInterLayerPredFlag && BASE_QUALITY_ID == uiQualityId ){
790 //the following should be deleted for CODE_CLEAN
791 pSliceHeadExt->uiRefLayerDqId = BsGetUe(pBs);
792 if ( pSubsetSps->sSpsSvcExt.bInterLayerDeblockingFilterCtrlPresentFlag )
793 {
794 pSliceHeadExt->uiDisableInterLayerDeblockingFilterIdc = BsGetUe(pBs);
795 //refer to JVT-X201wcm1.doc G.7.4.3.4--2010.4.20
796 if ( pSliceHeadExt->uiDisableInterLayerDeblockingFilterIdc > 6 )
797 {
798 WelsLog( pCtx, WELS_LOG_WARNING, "disable_inter_layer_deblock_filter_idc (%d) out of range [0, 6]\n", pSliceHeadExt->uiDisableInterLayerDeblockingFilterIdc );
799 return ERR_INFO_INVALID_DBLOCKING_IDC;
800 }
801 if ( pSliceHeadExt->uiDisableInterLayerDeblockingFilterIdc != 1 ){
802 pSliceHeadExt->iInterLayerSliceAlphaC0Offset = BsGetSe(pBs) << 1;
803 pSliceHeadExt->iInterLayerSliceBetaOffset = BsGetSe(pBs) << 1;
804 }
805 }
806
807 pSliceHeadExt->uiRefLayerChromaPhaseXPlus1Flag = pSubsetSps->sSpsSvcExt.uiSeqRefLayerChromaPhaseXPlus1Flag;
808 pSliceHeadExt->uiRefLayerChromaPhaseYPlus1 = pSubsetSps->sSpsSvcExt.uiSeqRefLayerChromaPhaseYPlus1;
809
810 pSliceHeadExt->bConstrainedIntraResamplingFlag = !!BsGetOneBit(pBs);
811
812 {
813 SPosOffset pos;
814 pos.iLeftOffset = pSubsetSps->sSpsSvcExt.sSeqScaledRefLayer.iLeftOffset;
815 pos.iTopOffset = pSubsetSps->sSpsSvcExt.sSeqScaledRefLayer.iTopOffset * (2 - pSps->bFrameMbsOnlyFlag);
816 pos.iRightOffset= pSubsetSps->sSpsSvcExt.sSeqScaledRefLayer.iRightOffset;
817 pos.iBottomOffset=pSubsetSps->sSpsSvcExt.sSeqScaledRefLayer.iBottomOffset * (2 - pSps->bFrameMbsOnlyFlag);
818 //memcpy(&pSliceHeadExt->sScaledRefLayer, &pos, sizeof(SPosOffset));//confirmed_safe_unsafe_usage
819 pSliceHeadExt->iScaledRefLayerPicWidthInSampleLuma = (pSliceHead->iMbWidth << 4) - (pos.iLeftOffset+pos.iRightOffset);
820 pSliceHeadExt->iScaledRefLayerPicHeightInSampleLuma = (pSliceHead->iMbHeight << 4) - (pos.iTopOffset+pos.iBottomOffset) / (1 + pSliceHead->bFieldPicFlag);
821 }
822 }
823 else if (uiQualityId > BASE_QUALITY_ID){
824 WelsLog( pCtx, WELS_LOG_WARNING, "MGS not supported.\n" );
825 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_MGS);
826 pSliceHeadExt->uiRefLayerDqId = pNalHeaderExt->uiLayerDqId - 1;
827 }
828 else{
829 pSliceHeadExt->uiRefLayerDqId = (uint8_t)-1;
830 }
831
832 pSliceHeadExt->bSliceSkipFlag = false;
833 pSliceHeadExt->bAdaptiveBaseModeFlag = false;
834 pSliceHeadExt->bDefaultBaseModeFlag = false;
835 pSliceHeadExt->bAdaptiveMotionPredFlag = false;
836 pSliceHeadExt->bDefaultMotionPredFlag = false;
837 pSliceHeadExt->bAdaptiveResidualPredFlag = false;
838 pSliceHeadExt->bDefaultResidualPredFlag = false;
839 if ( pNalHeaderExt->iNoInterLayerPredFlag )
840 pSliceHeadExt->bTCoeffLevelPredFlag = false;
841 else
842 pSliceHeadExt->bTCoeffLevelPredFlag = pSubsetSps->sSpsSvcExt.bSeqTCoeffLevelPredFlag;
843
844 if ( !pNalHeaderExt->iNoInterLayerPredFlag ){
845 pSliceHeadExt->bSliceSkipFlag = !!BsGetOneBit(pBs);
846 if ( pSliceHeadExt->bSliceSkipFlag ){
847 pSliceHeadExt->uiNumMbsInSlice = 1 + BsGetUe(pBs);
848 }
849 else{
850 pSliceHeadExt->bAdaptiveBaseModeFlag = !!BsGetOneBit(pBs);
851 if ( !pSliceHeadExt->bAdaptiveBaseModeFlag ){
852 pSliceHeadExt->bDefaultBaseModeFlag = !!BsGetOneBit(pBs);
853 }
854 if ( !pSliceHeadExt->bDefaultBaseModeFlag ){
855 pSliceHeadExt->bAdaptiveMotionPredFlag = !!BsGetOneBit(pBs);
856 if ( !pSliceHeadExt->bAdaptiveMotionPredFlag )
857 pSliceHeadExt->bDefaultMotionPredFlag = !!BsGetOneBit(pBs);
858 }
859
860 pSliceHeadExt->bAdaptiveResidualPredFlag = !!BsGetOneBit(pBs);
861 if ( !pSliceHeadExt->bAdaptiveResidualPredFlag ){
862 pSliceHeadExt->bDefaultResidualPredFlag = !!BsGetOneBit(pBs);
863 }
864 }
865 if ( pSubsetSps->sSpsSvcExt.bAdaptiveTCoeffLevelPredFlag )
866 pSliceHeadExt->bTCoeffLevelPredFlag = !!BsGetOneBit(pBs);
867 }
868
869 if ( !pSubsetSps->sSpsSvcExt.bSliceHeaderRestrictionFlag )
870 {
871 pSliceHeadExt->uiScanIdxStart = BsGetBits(pBs, 4);
872 pSliceHeadExt->uiScanIdxEnd = BsGetBits(pBs, 4);
873 if( pSliceHeadExt->uiScanIdxStart != 0 || pSliceHeadExt->uiScanIdxEnd != 15 )
874 {
875 WelsLog( pCtx, WELS_LOG_WARNING, "uiScanIdxStart (%d) != 0 and uiScanIdxEnd (%d) !=15 not supported here\n", pSliceHeadExt->uiScanIdxStart, pSliceHeadExt->uiScanIdxEnd );
876 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_MGS);
877 }
878 }
879 else{
880 pSliceHeadExt->uiScanIdxStart = 0;
881 pSliceHeadExt->uiScanIdxEnd = 15;
882 }
883 }
884
885 return ERR_NONE;
886}
887
888/*
889 * Copy relative syntax elements of NALUnitHeaderExt, sRefPicBaseMarking and bStoreRefBasePicFlag in prefix nal unit.
890 * pSrc: mark as decoded prefix NAL
891 * ppDst: succeeded VCL NAL based AVC (I/P Slice)
892 */
893bool_t PrefetchNalHeaderExtSyntax ( PWelsDecoderContext pCtx, PNalUnit const kppDst, PNalUnit const kpSrc)
894{
895 PNalUnitHeaderExt pNalHdrExtD = NULL, pNalHdrExtS = NULL;
896 PSliceHeaderExt pShExtD = NULL;
897 PPrefixNalUnit pPrefixS = NULL;
898 PSps pSps = NULL;
899 int32_t iIdx = 0;
900
901 if ( kppDst == NULL || kpSrc == NULL )
902 return false;
903
904 pNalHdrExtD = &kppDst->sNalHeaderExt;
905 pNalHdrExtS = &kpSrc->sNalHeaderExt;
906 pShExtD = &kppDst->sNalData.sVclNal.sSliceHeaderExt;
907 pPrefixS = &kpSrc->sNalData.sPrefixNal;
908 pSps = &pCtx->sSpsBuffer[pCtx->sPpsBuffer[pShExtD->sSliceHeader.iPpsId].iSpsId];
909
910 pNalHdrExtD->uiDependencyId = pNalHdrExtS->uiDependencyId;
911 pNalHdrExtD->uiQualityId = pNalHdrExtS->uiQualityId;
912 pNalHdrExtD->uiTemporalId = pNalHdrExtS->uiTemporalId;
913 pNalHdrExtD->uiPriorityId = pNalHdrExtS->uiPriorityId;
914 pNalHdrExtD->bIdrFlag = pNalHdrExtS->bIdrFlag;
915 pNalHdrExtD->iNoInterLayerPredFlag = pNalHdrExtS->iNoInterLayerPredFlag;
916 pNalHdrExtD->bDiscardableFlag = pNalHdrExtS->bDiscardableFlag;
917 pNalHdrExtD->bOutputFlag = pNalHdrExtS->bOutputFlag;
918 pNalHdrExtD->bUseRefBasePicFlag = pNalHdrExtS->bUseRefBasePicFlag;
919 pNalHdrExtD->uiLayerDqId = pNalHdrExtS->uiLayerDqId;
920
921 pShExtD->bStoreRefBasePicFlag = pPrefixS->bStoreRefBasePicFlag;
922 memcpy(&pShExtD->sRefBasePicMarking, &pPrefixS->sRefPicBaseMarking, sizeof(SRefBasePicMarking));//confirmed_safe_unsafe_usage
923 if (pShExtD->sRefBasePicMarking.bAdaptiveRefBasePicMarkingModeFlag){
924 PRefBasePicMarking pRefBasePicMarking = &pShExtD->sRefBasePicMarking;
925 iIdx = 0;
926 do {
927 if (pRefBasePicMarking->mmco_base[iIdx].uiMmcoType == MMCO_END)
928 break;
929 if (pRefBasePicMarking->mmco_base[iIdx].uiMmcoType == MMCO_SHORT2UNUSED)
930 pRefBasePicMarking->mmco_base[iIdx].iShortFrameNum = (pShExtD->sSliceHeader.iFrameNum-pRefBasePicMarking->mmco_base[iIdx].uiDiffOfPicNums) & ((1<<pSps->uiLog2MaxFrameNum)-1);
931 ++ iIdx;
932 } while(iIdx < MAX_MMCO_COUNT);
933 }
934
935 return true;
936}
937
938
939
940int32_t UpdateAccessUnit ( PWelsDecoderContext pCtx )
941{
942 PAccessUnit pCurAu = pCtx->pAccessUnitList;
943 int32_t iIdx = pCurAu->uiEndPos;
944
945 // Conversed iterator
946 pCtx->uiTargetDqId = pCurAu->pNalUnitsList[iIdx]->sNalHeaderExt.uiLayerDqId;
947 pCurAu->uiActualUnitsNum = iIdx + 1;
948 pCurAu->bCompletedAuFlag = true;
949
950 // Added for mosaic avoidance, 11/19/2009
951#ifdef LONG_TERM_REF
952 if ( pCtx->bParamSetsLostFlag )
953#else
954 if ( pCtx->bReferenceLostAtT0Flag )
955#endif
956 {
957 uint32_t uiActualIdx = 0;
958 while ( uiActualIdx < pCurAu->uiActualUnitsNum ) {
959 PNalUnit nal = pCurAu->pNalUnitsList[uiActualIdx];
960
961 if ( nal->sNalHeaderExt.sNalUnitHeader.eNalUnitType == NAL_UNIT_CODED_SLICE_IDR || nal->sNalHeaderExt.bIdrFlag )
962 {
963 break;
964 }
965 ++ uiActualIdx;
966 }
967 if ( uiActualIdx == pCurAu->uiActualUnitsNum ) // no found IDR nal within incoming AU, need exit to avoid mosaic issue, 11/19/2009
968 {
969 WelsLog( pCtx, WELS_LOG_WARNING, "UpdateAccessUnit():::::Key frame lost.....CAN NOT find IDR from current AU.\n" );
970#ifdef LONG_TERM_REF
971 pCtx->iErrorCode |= dsNoParamSets;
972 return dsNoParamSets;
973#else
974 pCtx->iErrorCode |= dsRefLost;
975 return ERR_INFO_REFERENCE_PIC_LOST;
976#endif
977 }
978 }
979
980 return ERR_NONE;
981}
982
983int32_t InitialDqLayersContext ( PWelsDecoderContext pCtx, const int32_t kiMaxWidth, const int32_t kiMaxHeight )
984{
985 const int32_t kiPicStride = ((kiMaxWidth + 15) & 0xfffff0) + (PADDING_LENGTH<<1);
986 const int32_t kiPicLines = ((kiMaxHeight + 15) & 0xfffff0);
987
988 int32_t i = 0;
989
990 WELS_VERIFY_RETURN_IF( ERR_INFO_INVALID_PARAM, ( NULL == pCtx || kiMaxWidth <= 0 || kiMaxHeight <= 0 ) )
991 pCtx->sMb.iMbWidth = (kiMaxWidth + 15) >> 4;
992 pCtx->sMb.iMbHeight = (kiMaxHeight + 15) >> 4;
993
994 if ( pCtx->bInitialDqLayersMem && kiMaxWidth <= pCtx->iPicWidthReq && kiMaxHeight <= pCtx->iPicHeightReq ) // have same dimension memory, skipped
995 return ERR_NONE;
996
997
998 UninitialDqLayersContext( pCtx );
999
1000 do {
1001 PDqLayer pDq = (PDqLayer )WelsMalloc(sizeof(SDqLayer), "PDqLayer");
1002
1003 int32_t iPlaneIdx = 0;
1004
1005 if ( pDq == NULL )
1006 return ERR_INFO_OUT_OF_MEMORY;
1007
1008 memset(pDq, 0, sizeof(SDqLayer));
1009 if(pCtx->iDecoderMode == SW_MODE)
1010 {
1011
1012 do {
1013 const int32_t kiHshift = iPlaneIdx ? 1 : 0;
1014 const int32_t kiVshift = kiHshift;
1015 const int32_t kiStride = WELS_ALIGN( (kiPicStride >> kiHshift), (16 << (1-kiHshift)) );
1016 const int32_t kiLine = (kiPicLines + (PADDING_LENGTH<<1)) >> kiVshift;
1017 const int32_t kiSize = kiStride * kiLine;
1018
1019 pCtx->pCsListXchg[i][iPlaneIdx] = (uint8_t *)WelsMalloc( kiSize * sizeof(uint8_t), "pCtx->pCsListXchg[][]" );
1020
1021 WELS_VERIFY_RETURN_IF( ERR_INFO_OUT_OF_MEMORY, (NULL == pCtx->pCsListXchg[i][iPlaneIdx]) )
1022 pCtx->iCsStride[iPlaneIdx] = kiStride;
1023
1024
1025 pCtx->pRsListXchg[i][iPlaneIdx] = (int16_t *)WelsMalloc( kiSize * sizeof(int16_t), "pCtx->pRsListXchg[][]" );
1026
1027 WELS_VERIFY_RETURN_IF( ERR_INFO_OUT_OF_MEMORY , (NULL == pCtx->pRsListXchg[i][iPlaneIdx]) )
1028 pCtx->iRsStride[iPlaneIdx] = kiStride;
1029
1030 ++ iPlaneIdx;
1031 } while(iPlaneIdx < 3);
1032
1033
1034 pCtx->sMb.pMbType[i] = (int8_t *)WelsMalloc( pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight *sizeof(int8_t), "pCtx->sMb.pMbType[]" );
1035 pCtx->sMb.pMv[i][0] = (int16_t (*)[16][2])WelsMalloc( pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int16_t) * MV_A * MB_BLOCK4x4_NUM, "pCtx->sMb.pMv[][]");
1036 pCtx->sMb.pRefIndex[i][0] = (int8_t (*)[MB_BLOCK4x4_NUM])WelsMalloc( pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int8_t) * MB_BLOCK4x4_NUM, "pCtx->sMb.pRefIndex[][]");
1037 pCtx->sMb.pLumaQp[i] = (int8_t *)WelsMalloc( pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int8_t), "pCtx->sMb.pLumaQp[]");
1038 pCtx->sMb.pChromaQp[i] = (int8_t *)WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int8_t), "pCtx->sMb.pChromaQp[]");
1039 pCtx->sMb.pNzc[i] = (int8_t (*)[24])WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int8_t) * 24, "pCtx->sMb.pNzc[]");
1040 pCtx->sMb.pNzcRs[i] = (int8_t (*)[24])WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int8_t) * 24, "pCtx->sMb.pNzcRs[]");
1041 pCtx->sMb.pScaledTCoeff[i] = (int16_t (*)[MB_COEFF_LIST_SIZE])WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int16_t) * MB_COEFF_LIST_SIZE, "pCtx->sMb.pScaledTCoeff[]");
1042 pCtx->sMb.pIntraPredMode[i] = (int8_t (*)[8])WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int8_t) * 8, "pCtx->sMb.pIntraPredMode[]");
1043 pCtx->sMb.pIntra4x4FinalMode[i] = (int8_t (*)[MB_BLOCK4x4_NUM])WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int8_t) * MB_BLOCK4x4_NUM, "pCtx->sMb.pIntra4x4FinalMode[]");
1044 pCtx->sMb.pChromaPredMode[i] = (int8_t *)WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int8_t), "pCtx->sMb.pChromaPredMode[]");
1045 pCtx->sMb.pCbp[i] = (int8_t *)WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight *sizeof(int8_t), "pCtx->sMb.pCbp[]");
1046 pCtx->sMb.pSubMbType[i] = (int8_t (*)[MB_PARTITION_SIZE])WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int8_t) * MB_PARTITION_SIZE, "pCtx->sMb.pSubMbType[]");
1047 pCtx->sMb.pSliceIdc[i] = (int32_t *) WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int32_t), "pCtx->sMb.pSliceIdc[]"); // using int32_t for slice_idc, 4/21/2010
1048 if ( pCtx->sMb.pSliceIdc[i] != NULL )
1049 memset(pCtx->sMb.pSliceIdc[i], 0xff, (pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int32_t)) );
1050 pCtx->sMb.pResidualPredFlag[i] = (int8_t *) WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int8_t), "pCtx->sMb.pResidualPredFlag[]");
1051 //pCtx->sMb.pMotionPredFlag[i] = (uint8_t *) WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(uint8_t), "pCtx->sMb.pMotionPredFlag[]");
1052 pCtx->sMb.pInterPredictionDoneFlag[i] = (int8_t *) WelsMalloc(pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int8_t), "pCtx->sMb.pInterPredictionDoneFlag[]");
1053
1054 // check memory block valid due above allocated..
1055 WELS_VERIFY_RETURN_IF ( ERR_INFO_OUT_OF_MEMORY,
1056 ( (NULL == pCtx->sMb.pMbType[i]) ||
1057 (NULL == pCtx->sMb.pMv[i][0]) ||
1058 (NULL == pCtx->sMb.pRefIndex[i][0]) ||
1059 (NULL == pCtx->sMb.pLumaQp[i]) ||
1060 (NULL == pCtx->sMb.pChromaQp[i]) ||
1061 (NULL == pCtx->sMb.pNzc[i]) ||
1062 (NULL == pCtx->sMb.pNzcRs[i]) ||
1063 (NULL == pCtx->sMb.pScaledTCoeff[i]) ||
1064 (NULL == pCtx->sMb.pIntraPredMode[i]) ||
1065 (NULL == pCtx->sMb.pIntra4x4FinalMode[i]) ||
1066 (NULL == pCtx->sMb.pChromaPredMode[i]) ||
1067 (NULL == pCtx->sMb.pCbp[i]) ||
1068 (NULL == pCtx->sMb.pSubMbType[i]) ||
1069 (NULL == pCtx->sMb.pSliceIdc[i]) ||
1070 (NULL == pCtx->sMb.pResidualPredFlag[i]) ||
1071 (NULL == pCtx->sMb.pInterPredictionDoneFlag[i])
1072 )
1073 )
1074 } // end of if(pCtx->iDecoderMode == SW_MODE)
1075
1076 pCtx->pDqLayersList[i] = pDq;
1077 ++ i;
1078 } while( i < LAYER_NUM_EXCHANGEABLE );
1079
1080
1081 pCtx->bInitialDqLayersMem = true;
1082 pCtx->iPicWidthReq = kiMaxWidth;
1083 pCtx->iPicHeightReq = kiMaxHeight;
1084
1085 return ERR_NONE;
1086}
1087
1088void_t UninitialDqLayersContext ( PWelsDecoderContext pCtx )
1089{
1090 int32_t i = 0;
1091 int32_t j = 0;
1092
1093 do {
1094 PDqLayer pDq = pCtx->pDqLayersList[i];
1095 if ( pDq == NULL ){
1096 ++ i;
1097 continue;
1098 }
1099
1100 if ( pCtx->pCsListXchg[i] ){ // cs picture
1101 j = 0;
1102 do {
1103 if ( NULL != pCtx->pCsListXchg[i][j] )
1104 {
1105 WelsFree( pCtx->pCsListXchg[i][j], "pCtx->pCsListXchg[][]" );
1106
1107 pCtx->pCsListXchg[i][j] = NULL;
1108 }
1109 pCtx->iCsStride[j] = 0;
1110 ++ j;
1111 } while( j < 3 );
1112
1113 pDq->pCsData[i] = NULL; // for safe
1114 pDq->iCsStride[i] = 0;
1115 }
1116 if ( pCtx->pRsListXchg[i] ){
1117 j = 0;
1118 do {
1119 if ( NULL != pCtx->pRsListXchg[i][j] )
1120 {
1121 WelsFree( pCtx->pRsListXchg[i][j], "pCtx->pRsListXchg[][]" );
1122
1123 pCtx->pRsListXchg[i][j] = NULL;
1124 }
1125 pCtx->iRsStride[j] = 0;
1126 ++ j;
1127 } while(j < 3);
1128 }
1129
1130 if (pCtx->sMb.pMbType[i])
1131 {
1132 WelsFree( pCtx->sMb.pMbType[i], "pCtx->sMb.pMbType[]");
1133
1134 pCtx->sMb.pMbType[i] = NULL;
1135 }
1136
1137 if (pCtx->sMb.pMv[i][0])
1138 {
1139 WelsFree( pCtx->sMb.pMv[i][0], "pCtx->sMb.pMv[][]" );
1140
1141 pCtx->sMb.pMv[i][0] = NULL;
1142 }
1143
1144 if (pCtx->sMb.pRefIndex[i][0])
1145 {
1146 WelsFree( pCtx->sMb.pRefIndex[i][0], "pCtx->sMb.pRefIndex[][]" );
1147
1148 pCtx->sMb.pRefIndex[i][0] = NULL;
1149 }
1150
1151 if (pCtx->sMb.pLumaQp[i])
1152 {
1153 WelsFree(pCtx->sMb.pLumaQp[i], "pCtx->sMb.pLumaQp[]");
1154
1155 pCtx->sMb.pLumaQp[i] = NULL;
1156 }
1157
1158 if (pCtx->sMb.pChromaQp[i])
1159 {
1160 WelsFree(pCtx->sMb.pChromaQp[i], "pCtx->sMb.pChromaQp[]");
1161
1162 pCtx->sMb.pChromaQp[i] = NULL;
1163 }
1164
1165 if (pCtx->sMb.pNzc[i])
1166 {
1167 WelsFree(pCtx->sMb.pNzc[i], "pCtx->sMb.pNzc[]");
1168
1169 pCtx->sMb.pNzc[i] = NULL;
1170 }
1171
1172 if (pCtx->sMb.pNzcRs[i])
1173 {
1174 WelsFree(pCtx->sMb.pNzcRs[i], "pCtx->sMb.pNzcRs[]");
1175
1176 pCtx->sMb.pNzcRs[i] = NULL;
1177 }
1178
1179 if (pCtx->sMb.pScaledTCoeff[i])
1180 {
1181 WelsFree(pCtx->sMb.pScaledTCoeff[i], "pCtx->sMb.pScaledTCoeff[]");
1182
1183 pCtx->sMb.pScaledTCoeff[i] = NULL;
1184 }
1185
1186 if (pCtx->sMb.pIntraPredMode[i])
1187 {
1188 WelsFree(pCtx->sMb.pIntraPredMode[i], "pCtx->sMb.pIntraPredMode[]");
1189
1190 pCtx->sMb.pIntraPredMode[i] = NULL;
1191 }
1192
1193 if (pCtx->sMb.pIntra4x4FinalMode[i])
1194 {
1195 WelsFree(pCtx->sMb.pIntra4x4FinalMode[i], "pCtx->sMb.pIntra4x4FinalMode[]");
1196
1197 pCtx->sMb.pIntra4x4FinalMode[i] = NULL;
1198 }
1199
1200 if (pCtx->sMb.pChromaPredMode[i])
1201 {
1202 WelsFree(pCtx->sMb.pChromaPredMode[i], "pCtx->sMb.pChromaPredMode[]");
1203
1204 pCtx->sMb.pChromaPredMode[i] = NULL;
1205 }
1206
1207 if (pCtx->sMb.pCbp[i])
1208 {
1209 WelsFree( pCtx->sMb.pCbp[i], "pCtx->sMb.pCbp[]" );
1210
1211 pCtx->sMb.pCbp[i] = NULL;
1212 }
1213
1214 // if (pCtx->sMb.pMotionPredFlag[i])
1215 //{
1216 // WelsFree( pCtx->sMb.pMotionPredFlag[i], "pCtx->sMb.pMotionPredFlag[]" );
1217
1218 // pCtx->sMb.pMotionPredFlag[i] = NULL;
1219 //}
1220
1221 if (pCtx->sMb.pSubMbType[i])
1222 {
1223 WelsFree(pCtx->sMb.pSubMbType[i], "pCtx->sMb.pSubMbType[]");
1224
1225 pCtx->sMb.pSubMbType[i] = NULL;
1226 }
1227
1228 if (pCtx->sMb.pSliceIdc[i])
1229 {
1230 WelsFree( pCtx->sMb.pSliceIdc[i], "pCtx->sMb.pSliceIdc[]" );
1231
1232 pCtx->sMb.pSliceIdc[i] = NULL;
1233 }
1234
1235 if (pCtx->sMb.pResidualPredFlag[i])
1236 {
1237 WelsFree( pCtx->sMb.pResidualPredFlag[i], "pCtx->sMb.pResidualPredFlag[]" );
1238
1239 pCtx->sMb.pResidualPredFlag[i] = NULL;
1240 }
1241
1242 if (pCtx->sMb.pInterPredictionDoneFlag[i])
1243 {
1244 WelsFree( pCtx->sMb.pInterPredictionDoneFlag[i], "pCtx->sMb.pInterPredictionDoneFlag[]" );
1245
1246 pCtx->sMb.pInterPredictionDoneFlag[i] = NULL;
1247 }
1248 WelsFree( pDq, "pDq" );
1249
1250 pDq = NULL;
1251 pCtx->pDqLayersList[i] = NULL;
1252
1253 ++ i;
1254 } while( i < LAYER_NUM_EXCHANGEABLE );
1255
1256 pCtx->iPicWidthReq = 0;
1257 pCtx->iPicHeightReq = 0;
1258 pCtx->bInitialDqLayersMem = false;
1259}
1260
1261void_t ResetCurrentAccessUnit ( PWelsDecoderContext pCtx )
1262{
1263 PAccessUnit pCurAu = pCtx->pAccessUnitList;
1264
1265 pCurAu->uiEndPos = 0;
1266 pCurAu->bCompletedAuFlag = false;
1267 if (pCurAu->uiActualUnitsNum > 0){
1268 uint32_t iIdx = 0;
1269 const uint32_t kuiActualNum = pCurAu->uiActualUnitsNum;
1270 // a more simpler method to do nal units list management prefered here
1271 const uint32_t kuiAvailNum = pCurAu->uiAvailUnitsNum;
1272 const uint32_t kuiLeftNum = kuiAvailNum - kuiActualNum;
1273
1274 // Swapping active nal unit nodes of succeeding AU with leading of list
1275 while (iIdx < kuiLeftNum)
1276 {
1277 PNalUnit t = pCurAu->pNalUnitsList[kuiActualNum+iIdx];
1278 pCurAu->pNalUnitsList[kuiActualNum+iIdx] = pCurAu->pNalUnitsList[iIdx];
1279 pCurAu->pNalUnitsList[iIdx] = t;
1280 ++ iIdx;
1281 }
1282 pCurAu->uiActualUnitsNum = pCurAu->uiAvailUnitsNum = kuiLeftNum;
1283 }
1284}
1285
1286/*!
1287 * \brief Force reset current Acess Unit Nal list in case error parsing/decoding in current AU
1288 * \author
1289 * \history 11/16/2009
1290 */
1291void_t ForceResetCurrentAccessUnit( PAccessUnit pAu )
1292{
1293 uint32_t uiSucAuIdx = pAu->uiEndPos + 1;
1294 uint32_t uiCurAuIdx = 0;
1295
1296 // swap the succeeding AU's nal units to the front
1297 while(uiSucAuIdx < pAu->uiAvailUnitsNum)
1298 {
1299 PNalUnit t = pAu->pNalUnitsList[uiSucAuIdx];
1300 pAu->pNalUnitsList[uiSucAuIdx] = pAu->pNalUnitsList[uiCurAuIdx];
1301 pAu->pNalUnitsList[uiCurAuIdx] = t;
1302 ++ uiSucAuIdx;
1303 ++ uiCurAuIdx;
1304 }
1305
1306 // Update avail/actual units num accordingly for next AU parsing
1307 if ( pAu->uiAvailUnitsNum > pAu->uiEndPos )
1308 pAu->uiAvailUnitsNum -= (pAu->uiEndPos+1);
1309 else
1310 pAu->uiAvailUnitsNum = 0;
1311 pAu->uiActualUnitsNum = 0;
1312 pAu->uiEndPos = 0;
1313 pAu->bCompletedAuFlag = false;
1314}
1315
1316//clear current corrupted NAL from pNalUnitsList
1317void_t ForceClearCurrentNal( PAccessUnit pAu )
1318{
1319 if (pAu->uiAvailUnitsNum > 0)
1320 -- pAu->uiAvailUnitsNum;
1321}
1322
1323
1324void_t CheckAvailNalUnitsListContinuity( PWelsDecoderContext pCtx, int32_t iStartIdx, int32_t iEndIdx )
1325{
1326 PAccessUnit pCurAu = pCtx->pAccessUnitList;
1327
1328 uint8_t uiLastNuDependencyId, uiLastNuLayerDqId;
1329 uint8_t uiCurNuDependencyId, uiCurNuQualityId, uiCurNuLayerDqId, uiCurNuRefLayerDqId;
1330
1331 int32_t iCurNalUnitIdx = 0;
1332
1333 //check the continuity of pNalUnitsList forwards (from pIdxNoInterLayerPred to end_postion)
1334 uiLastNuDependencyId = pCurAu->pNalUnitsList[iStartIdx]->sNalHeaderExt.uiDependencyId;//starting nal unit
1335 uiLastNuLayerDqId = pCurAu->pNalUnitsList[iStartIdx]->sNalHeaderExt.uiLayerDqId;//starting nal unit
1336 iCurNalUnitIdx = iStartIdx + 1;//current nal unit
1337 while ( iCurNalUnitIdx <= iEndIdx )
1338 {
1339 uiCurNuDependencyId = pCurAu->pNalUnitsList[iCurNalUnitIdx]->sNalHeaderExt.uiDependencyId;
1340 uiCurNuQualityId = pCurAu->pNalUnitsList[iCurNalUnitIdx]->sNalHeaderExt.uiQualityId;
1341 uiCurNuLayerDqId = pCurAu->pNalUnitsList[iCurNalUnitIdx]->sNalHeaderExt.uiLayerDqId;
1342 uiCurNuRefLayerDqId = pCurAu->pNalUnitsList[iCurNalUnitIdx]->sNalData.sVclNal.sSliceHeaderExt.uiRefLayerDqId;
1343
1344 if ( uiCurNuDependencyId == uiLastNuDependencyId )
1345 {
1346 uiLastNuLayerDqId = uiCurNuLayerDqId;
1347 ++ iCurNalUnitIdx;
1348 }
1349 else //uiCurNuDependencyId != uiLastNuDependencyId, new dependency arrive
1350 {
1351 if ( uiCurNuQualityId == 0 )
1352 {
1353 uiLastNuDependencyId = uiCurNuDependencyId;
1354 if ( uiCurNuRefLayerDqId == uiLastNuLayerDqId )
1355 {
1356 uiLastNuLayerDqId = uiCurNuLayerDqId;
1357 ++ iCurNalUnitIdx;
1358 }
1359 else //cur_nu_layer_id != next_nu_ref_layer_dq_id, the chain is broken at this point
1360 {
1361 break;
1362 }
1363 }
1364 else //new dependency arrive, but no base quality layer, so we must stop in this point
1365 {
1366 break;
1367 }
1368 }
1369 }
1370
1371 -- iCurNalUnitIdx;
1372 pCurAu->uiEndPos = iCurNalUnitIdx;
1373 pCtx->uiTargetDqId = pCurAu->pNalUnitsList[iCurNalUnitIdx]->sNalHeaderExt.uiLayerDqId;
1374}
1375
1376//main purpose: to support multi-slice and to include all slice which have the same uiDependencyId, uiQualityId and frame_num
1377//for single slice, pIdxNoInterLayerPred SHOULD NOT be modified
1378void_t RefineIdxNoInterLayerPred( PAccessUnit pCurAu, int32_t* pIdxNoInterLayerPred )
1379{
1380 int32_t iLastNalDependId = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalHeaderExt.uiDependencyId;
1381 int32_t iLastNalQualityId = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalHeaderExt.uiQualityId;
1382 uint8_t uiLastNalTId = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalHeaderExt.uiTemporalId;
1383 int32_t iLastNalFrameNum = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.iFrameNum;
1384 int32_t iLastNalPoc = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.iPicOrderCntLsb;
1385 int32_t iLastNalFirstMb = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.iFirstMbInSlice;
1386 int32_t iCurNalDependId, iCurNalQualityId, iCurNalTId, iCurNalFrameNum, iCurNalPoc, iCurNalFirstMb, iCurIdx, iFinalIdxNoInterLayerPred;
1387
1388 bool_t bMultiSliceFind = false;
1389
1390 iFinalIdxNoInterLayerPred = 0;
1391 iCurIdx = *pIdxNoInterLayerPred - 1;
1392 while ( iCurIdx >= 0 )
1393 {
1394 if ( pCurAu->pNalUnitsList[iCurIdx]->sNalHeaderExt.iNoInterLayerPredFlag )
1395 {
1396 iCurNalDependId = pCurAu->pNalUnitsList[iCurIdx]->sNalHeaderExt.uiDependencyId;
1397 iCurNalQualityId = pCurAu->pNalUnitsList[iCurIdx]->sNalHeaderExt.uiQualityId;
1398 iCurNalTId = pCurAu->pNalUnitsList[iCurIdx]->sNalHeaderExt.uiTemporalId;
1399 iCurNalFrameNum = pCurAu->pNalUnitsList[iCurIdx]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.iFrameNum;
1400 iCurNalPoc = pCurAu->pNalUnitsList[iCurIdx]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.iPicOrderCntLsb;
1401 iCurNalFirstMb = pCurAu->pNalUnitsList[iCurIdx]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.iFirstMbInSlice;
1402
1403 if ( iCurNalDependId == iLastNalDependId &&
1404 iCurNalQualityId == iLastNalQualityId &&
1405 iCurNalTId == uiLastNalTId &&
1406 iCurNalFrameNum == iLastNalFrameNum &&
1407 iCurNalPoc == iLastNalPoc &&
1408 iCurNalFirstMb != iLastNalFirstMb )
1409 {
1410 bMultiSliceFind = true;
1411 iFinalIdxNoInterLayerPred = iCurIdx;
1412 --iCurIdx;
1413 continue;
1414 }
1415 else
1416 {
1417 break;
1418 }
1419 }
1420 --iCurIdx;
1421 }
1422
1423 if ( bMultiSliceFind && *pIdxNoInterLayerPred != iFinalIdxNoInterLayerPred )
1424 {
1425 *pIdxNoInterLayerPred = iFinalIdxNoInterLayerPred;
1426 }
1427}
1428
1429bool_t CheckPocOfCurValidNalUnits( PAccessUnit pCurAu, int32_t pIdxNoInterLayerPred )
1430{
1431 int32_t iEndIdx = pCurAu->uiEndPos;
1432 int32_t iCurAuPoc = pCurAu->pNalUnitsList[pIdxNoInterLayerPred]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.iPicOrderCntLsb;
1433 int32_t iTmpPoc, i;
1434 for ( i = pIdxNoInterLayerPred+1; i < iEndIdx; i++ )
1435 {
1436 iTmpPoc = pCurAu->pNalUnitsList[i]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.iPicOrderCntLsb;
1437 if ( iTmpPoc != iCurAuPoc )
1438 {
1439 return false;
1440 }
1441 }
1442
1443 return true;
1444}
1445
1446bool_t CheckIntegrityNalUnitsList( PWelsDecoderContext pCtx )
1447{
1448 PAccessUnit pCurAu = pCtx->pAccessUnitList;
1449 const int32_t kiEndPos = pCurAu->uiEndPos;
1450 int32_t iIdxNoInterLayerPred = 0;
1451 int32_t iCurNalUnitIdx = kiEndPos;
1452
1453 ESliceType eSliceType = static_cast<ESliceType> (0);//EC 2009.11.12
1454
1455 if ( !pCurAu->bCompletedAuFlag )
1456 return false;
1457
1458 eSliceType = pCurAu->pNalUnitsList[iCurNalUnitIdx]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.eSliceType;
1459
1460 if ( I_SLICE == eSliceType )
1461 {
1462 pCurAu->uiStartPos = 0;
1463 //step1: search the pNalUnit whose iNoInterLayerPredFlag equal to 1 backwards (from uiEndPos to 0)
1464 iIdxNoInterLayerPred = kiEndPos;
1465 while ( iIdxNoInterLayerPred >= 0 )
1466 {
1467 if ( pCurAu->pNalUnitsList[iIdxNoInterLayerPred]->sNalHeaderExt.iNoInterLayerPredFlag )
1468 {
1469 break;
1470 }
1471 --iIdxNoInterLayerPred;
1472 }
1473 if ( iIdxNoInterLayerPred < 0 )
1474 {
1475 //can not find the Nal Unit whose no_inter_pred_falg equal to 1, MUST STOP decode
1476 return false;
1477 }
1478
1479 //step2: support multi-slice, to include all base layer slice
1480 RefineIdxNoInterLayerPred( pCurAu, &iIdxNoInterLayerPred );
1481 pCurAu->uiStartPos = iIdxNoInterLayerPred;
1482 CheckAvailNalUnitsListContinuity( pCtx, iIdxNoInterLayerPred, kiEndPos );
1483
1484 if ( !CheckPocOfCurValidNalUnits( pCurAu, iIdxNoInterLayerPred ) )
1485 {
1486 return false;
1487 }
1488
1489 pCtx->iCurSeqIntervalTargetDependId = pCurAu->pNalUnitsList[pCurAu->uiEndPos]->sNalHeaderExt.uiDependencyId;
1490 pCtx->iCurSeqIntervalMaxPicWidth = pCurAu->pNalUnitsList[pCurAu->uiEndPos]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.iMbWidth << 4;
1491 pCtx->iCurSeqIntervalMaxPicHeight = pCurAu->pNalUnitsList[pCurAu->uiEndPos]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.iMbHeight << 4;
1492 }
1493 else //P_SLICE
1494 {
1495 //step 1: search uiDependencyId equal to pCtx->cur_seq_interval_target_dependency_id
1496 bool_t bGetDependId = false;
1497 int32_t iIdxDependId = 0;
1498
1499 iIdxDependId = kiEndPos;
1500 while ( iIdxDependId >= 0 )
1501 {
1502 if ( pCtx->iCurSeqIntervalTargetDependId == pCurAu->pNalUnitsList[iIdxDependId]->sNalHeaderExt.uiDependencyId )
1503 {
1504 bGetDependId = true;
1505 break;
1506 }
1507 else
1508 {
1509 --iIdxDependId;
1510 }
1511 }
1512
1513 //step 2: switch according to whether or not find the index of pNalUnit whose uiDependencyId equal to iCurSeqIntervalTargetDependId
1514 if ( bGetDependId ) //get the index of pNalUnit whose uiDependencyId equal to iCurSeqIntervalTargetDependId
1515 {
1516 bool_t bGetNoInterPredFront = false;
1517 //step 2a: search iNoInterLayerPredFlag [0....iIdxDependId]
1518 iIdxNoInterLayerPred = iIdxDependId;
1519 while ( iIdxNoInterLayerPred >= 0 )
1520 {
1521 if ( pCurAu->pNalUnitsList[iIdxNoInterLayerPred]->sNalHeaderExt.iNoInterLayerPredFlag )
1522 {
1523 bGetNoInterPredFront = true;
1524 break;
1525 }
1526 --iIdxNoInterLayerPred;
1527 }
1528 //step 2b: switch, whether or not find the NAL unit whose no_inter_pred_flag equal to 1 among [0....iIdxDependId]
1529 if ( bGetNoInterPredFront ) //YES
1530 {
1531 RefineIdxNoInterLayerPred( pCurAu, &iIdxNoInterLayerPred );
1532 pCurAu->uiStartPos = iIdxNoInterLayerPred;
1533 CheckAvailNalUnitsListContinuity( pCtx, iIdxNoInterLayerPred, iIdxDependId );
1534
1535 if ( !CheckPocOfCurValidNalUnits( pCurAu, iIdxNoInterLayerPred ) )
1536 {
1537 return false;
1538 }
1539 }
1540 else //NO, should find the NAL unit whose no_inter_pred_flag equal to 1 among [iIdxDependId....uiEndPos]
1541 {
1542 iIdxNoInterLayerPred = iIdxDependId;
1543 while ( iIdxNoInterLayerPred <= kiEndPos )
1544 {
1545 if ( pCurAu->pNalUnitsList[iIdxNoInterLayerPred]->sNalHeaderExt.iNoInterLayerPredFlag )
1546 {
1547 break;
1548 }
1549 ++iIdxNoInterLayerPred;
1550 }
1551
1552 if ( iIdxNoInterLayerPred > kiEndPos )
1553 {
1554 return false; //cann't find the index of pNalUnit whose no_inter_pred_flag = 1
1555 }
1556
1557 RefineIdxNoInterLayerPred( pCurAu, &iIdxNoInterLayerPred );
1558 pCurAu->uiStartPos = iIdxNoInterLayerPred;
1559 CheckAvailNalUnitsListContinuity( pCtx, iIdxNoInterLayerPred, kiEndPos );
1560
1561 if ( !CheckPocOfCurValidNalUnits( pCurAu, iIdxNoInterLayerPred ) )
1562 {
1563 return false;
1564 }
1565 }
1566 }
1567 else //without the index of pNalUnit, should process this AU as common case
1568 {
1569 iIdxNoInterLayerPred = kiEndPos;
1570 while (iIdxNoInterLayerPred >= 0)
1571 {
1572 if ( pCurAu->pNalUnitsList[iIdxNoInterLayerPred]->sNalHeaderExt.iNoInterLayerPredFlag )
1573 {
1574 break;
1575 }
1576 --iIdxNoInterLayerPred;
1577 }
1578 if (iIdxNoInterLayerPred < 0)
1579 {
1580 return false; //cann't find the index of pNalUnit whose iNoInterLayerPredFlag = 1
1581 }
1582
1583 RefineIdxNoInterLayerPred( pCurAu, &iIdxNoInterLayerPred );
1584 pCurAu->uiStartPos = iIdxNoInterLayerPred;
1585 CheckAvailNalUnitsListContinuity( pCtx, iIdxNoInterLayerPred, kiEndPos );
1586
1587 if ( !CheckPocOfCurValidNalUnits( pCurAu, iIdxNoInterLayerPred ) )
1588 {
1589 return false;
1590 }
1591 }
1592 }
1593
1594 return true;
1595}
1596
1597void_t CheckOnlyOneLayerInAu( PWelsDecoderContext pCtx )
1598{
1599 PAccessUnit pCurAu = pCtx->pAccessUnitList;
1600
1601 int32_t iEndIdx = pCurAu->uiEndPos;
1602 int32_t iCurIdx = pCurAu->uiStartPos;
1603 uint8_t uiDId = pCurAu->pNalUnitsList[iCurIdx]->sNalHeaderExt.uiDependencyId;
1604 uint8_t uiQId = pCurAu->pNalUnitsList[iCurIdx]->sNalHeaderExt.uiQualityId;
1605 uint8_t uiTId = pCurAu->pNalUnitsList[iCurIdx]->sNalHeaderExt.uiTemporalId;
1606
1607 uint8_t uiCurDId, uiCurQId, uiCurTId;
1608
1609 pCtx->bOnlyOneLayerInCurAuFlag = true;
1610
1611 if ( iEndIdx == iCurIdx ) //only one NAL in pNalUnitsList
1612 {
1613 return;
1614 }
1615
1616 ++iCurIdx;
1617 while ( iCurIdx <= iEndIdx )
1618 {
1619 uiCurDId = pCurAu->pNalUnitsList[iCurIdx]->sNalHeaderExt.uiDependencyId;
1620 uiCurQId = pCurAu->pNalUnitsList[iCurIdx]->sNalHeaderExt.uiQualityId;
1621 uiCurTId = pCurAu->pNalUnitsList[iCurIdx]->sNalHeaderExt.uiTemporalId;
1622
1623 if ( uiDId != uiCurDId || uiQId != uiCurQId || uiTId != uiCurTId )
1624 {
1625 pCtx->bOnlyOneLayerInCurAuFlag = false;
1626 return;
1627 }
1628
1629 ++iCurIdx;
1630 }
1631}
1632
1633int32_t WelsDecodeAccessUnitStart ( PWelsDecoderContext pCtx )
1634{
1635 // Roll back NAL units not being belong to current access unit list for proceeded access unit
1636 int32_t iRet = UpdateAccessUnit ( pCtx );
1637 if ( iRet != ERR_NONE )
1638 return iRet;
1639
1640 pCtx->pAccessUnitList->uiStartPos = 0;
1641 if ( !pCtx->bAvcBasedFlag && !CheckIntegrityNalUnitsList( pCtx ) )
1642 {
1643 pCtx->iErrorCode |= dsBitstreamError;
1644 return dsBitstreamError;
1645 }
1646
1647 //check current AU has only one layer or not
1648 //If YES, can use deblocking based on AVC
1649 if ( !pCtx->bAvcBasedFlag )
1650 {
1651 CheckOnlyOneLayerInAu( pCtx );
1652 }
1653
1654 return ERR_NONE;
1655}
1656
1657void_t WelsDecodeAccessUnitEnd ( PWelsDecoderContext pCtx )
1658{
1659 // uninitialize context of current access unit and rbsp buffer clean
1660 ResetCurrentAccessUnit ( pCtx );
1661}
1662
1663
1664int32_t CheckBSBound(int32_t iWidth, int32_t iHeight, int32_t sliceNum, int32_t ppsId)
1665{
1666 int32_t iRet = 0;
1667
1668#if defined(WIN32)
1669 iRet = ((iWidth == 80) && (iHeight = 45) && (sliceNum < 60));
1670
1671#elif defined(MACOS)
1672 iRet = ((iWidth == 80) && (iHeight = 45) && (ppsId < 57));
1673
1674#elif defined(ANDROID)
1675 iRet = ((iWidth == 40) && (iHeight = 22));
1676
1677#endif
1678
1679 return iRet;
1680
1681}
1682
1683
1684
1685/*
1686 * ConstructAccessUnit
1687 * construct an access unit for given input bitstream, maybe partial NAL Unit, one or more Units are involved to
1688 * joint a collective access unit.
1689 * parameter\
1690 * buf: bitstream data buffer
1691 * bit_len: size in bit length of data
1692 * buf_len: size in byte length of data
1693 * coded_au: mark an Access Unit decoding finished
1694 * return:
1695 * 0 - success; otherwise returned error_no defined in error_no.h
1696 */
1697int32_t ConstructAccessUnit( PWelsDecoderContext pCtx, uint8_t** ppDst, SBufferInfo *pDstInfo)
1698{
1699 int32_t iErr;
1700 int32_t iWidth;
1701 int32_t iHeight;
1702 int32_t iStride[2] = { 0 };
1703
1704 PAccessUnit pCurAu = pCtx->pAccessUnitList;
1705
1706 pCtx->bAuReadyFlag = false;
1707 pCtx->bLastHasMmco5 = false;
1708
1709 iErr = WelsDecodeAccessUnitStart( pCtx );
1710 GetVclNalTemporalId( pCtx );
1711
1712 if ( ERR_NONE != iErr )
1713 {
1714 ForceResetCurrentAccessUnit( pCtx->pAccessUnitList );
1715 pDstInfo->iBufferStatus = 0;
1716 return iErr;
1717 }
1718
1719 pCtx->pSps = pCurAu->pNalUnitsList[pCurAu->uiStartPos]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.pSps;
1720 pCtx->pPps = pCurAu->pNalUnitsList[pCurAu->uiStartPos]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader.pPps;
1721
1722 //try to allocate or relocate DPB memory only when IDR arrival.
1723 if ( NAL_UNIT_CODED_SLICE_IDR == pCurAu->pNalUnitsList[pCurAu->uiStartPos]->sNalHeaderExt.sNalUnitHeader.eNalUnitType ||
1724 pCurAu->pNalUnitsList[pCurAu->uiStartPos]->sNalHeaderExt.bIdrFlag )
1725 {
1726 WelsResetRefPic(pCtx); //clear ref pPic when IDR NAL
1727 iErr = SyncPictureResolutionExt( pCtx, (pCtx->iMaxWidthInSps+15)>>4, (pCtx->iMaxHeightInSps+15)>>4 );
1728
1729 if( ERR_NONE != iErr ){
1730 WelsLog(pCtx, WELS_LOG_WARNING, "sync picture resolution ext failed, the error is %d", iErr);
1731 return iErr;
1732 }
1733 }
1734
1735
1736 pDstInfo->eBufferProperty = (EBufferProperty)pCtx->iDecoderOutputProperty;
1737
1738 iErr = DecodeCurrentAccessUnit( pCtx, ppDst, iStride, &iWidth, &iHeight, pDstInfo );
1739
1740 WelsDecodeAccessUnitEnd( pCtx );
1741
1742 if ( ERR_NONE != iErr )
1743 {
1744 WelsLog( pCtx, WELS_LOG_INFO, "returned error from decoding:[0x%x]\n", iErr);
1745
1746 pDstInfo->iBufferStatus = 0;
1747 return iErr;
1748 }
1749
1750 return 0;
1751}
1752
1753static inline void_t InitDqLayerInfo( PDqLayer pDqLayer, PLayerInfo pLayerInfo, PNalUnit pNalUnit, PPicture pPicDec )
1754{
1755 PNalUnitHeaderExt pNalHdrExt = &pNalUnit->sNalHeaderExt;
1756 PSliceHeaderExt pShExt = &pNalUnit->sNalData.sVclNal.sSliceHeaderExt;
1757 PSliceHeader pSh = &pShExt->sSliceHeader;
1758 const uint8_t kuiQualityId = pNalHdrExt->uiQualityId;
1759
1760 memcpy(&pDqLayer->sLayerInfo, pLayerInfo, sizeof(SLayerInfo));//confirmed_safe_unsafe_usage
1761
1762 pDqLayer->pDec = pPicDec;
1763 pDqLayer->iMbWidth = pSh->iMbWidth; // MB width of this picture
1764 pDqLayer->iMbHeight = pSh->iMbHeight;// MB height of this picture
1765
1766 pDqLayer->iSliceIdcBackup = (pSh->iFirstMbInSlice << 7) | (pNalHdrExt->uiDependencyId << 4) | (pNalHdrExt->uiQualityId);
1767
1768 /* Common syntax elements across all slices of a DQLayer */
1769 pDqLayer->uiPpsId = pLayerInfo->pPps->iPpsId;
1770 pDqLayer->uiDisableInterLayerDeblockingFilterIdc = pShExt->uiDisableInterLayerDeblockingFilterIdc;
1771 pDqLayer->iInterLayerSliceAlphaC0Offset = pShExt->iInterLayerSliceAlphaC0Offset;
1772 pDqLayer->iInterLayerSliceBetaOffset = pShExt->iInterLayerSliceBetaOffset;
1773 pDqLayer->iSliceGroupChangeCycle = pSh->iSliceGroupChangeCycle;
1774 pDqLayer->bStoreRefBasePicFlag = pShExt->bStoreRefBasePicFlag;
1775 pDqLayer->bTCoeffLevelPredFlag = pShExt->bTCoeffLevelPredFlag;
1776 pDqLayer->bConstrainedIntraResamplingFlag = pShExt->bConstrainedIntraResamplingFlag;
1777 pDqLayer->uiRefLayerDqId = pShExt->uiRefLayerDqId;
1778 pDqLayer->uiRefLayerChromaPhaseXPlus1Flag = pShExt->uiRefLayerChromaPhaseXPlus1Flag;
1779 pDqLayer->uiRefLayerChromaPhaseYPlus1 = pShExt->uiRefLayerChromaPhaseYPlus1;
1780 //memcpy(&pDqLayer->sScaledRefLayer, &pShExt->sScaledRefLayer, sizeof(SPosOffset));//confirmed_safe_unsafe_usage
1781
1782 if ( kuiQualityId == BASE_QUALITY_ID ){
1783 pDqLayer->pRefPicListReordering = &pSh->pRefPicListReordering;
1784 pDqLayer->pRefPicMarking = &pSh->sRefMarking;
1785 pDqLayer->pRefPicBaseMarking = &pShExt->sRefBasePicMarking;
1786 }
1787
1788 pDqLayer->uiLayerDqId = pNalHdrExt->uiLayerDqId; // dq_id of current layer
1789 pDqLayer->bUseRefBasePicFlag = pNalHdrExt->bUseRefBasePicFlag;
1790}
1791
1792void_t WelsDqLayerDecodeStart ( PWelsDecoderContext pCtx, PNalUnit pCurNal, PSps pSps, PPps pPps )
1793{
1794 SNalUnitHeader *pNalHdr = &pCurNal->sNalHeaderExt.sNalUnitHeader;
1795 PSliceHeader pSh = &pCurNal->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader;
1796
1797 pCtx->eSliceType = pSh->eSliceType;
1798 pCtx->pSliceHeader = pSh;
1799
1800 pCtx->iFrameNum = pSh->iFrameNum;
1801
1802 if ((pNalHdr->eNalUnitType == NAL_UNIT_CODED_SLICE_IDR ||
1803 (pCurNal->sNalHeaderExt.uiQualityId == BASE_QUALITY_ID && pCurNal->sNalHeaderExt.bIdrFlag)) &&
1804 pSh->iFrameNum == 0) //pSh->iFrameNum == 0 this condition can deleted??????
1805 {
1806 WelsResetRefPic ( pCtx ); // Reset decoded picture buffer lists due to an IDR frame incomes
1807 }
1808}
1809
1810int32_t InitRefPicList ( PWelsDecoderContext pCtx, const uint8_t kuiNRi, const bool_t kbFirstSlice, int32_t iPoc)
1811{
1812 int32_t iRet = ERR_NONE;
1813 if( kbFirstSlice)
1814 iRet = WelsInitRefList( pCtx, iPoc );
1815 if ( (pCtx->eSliceType!=I_SLICE && pCtx->eSliceType!=SI_SLICE) && kbFirstSlice ){
1816 iRet = WelsReorderRefList ( pCtx );
1817 }
1818
1819 return iRet;
1820}
1821
1822void_t InitCurDqLayerData( PWelsDecoderContext pCtx, PDqLayer pCurDq )
1823{
1824 if ( NULL != pCtx && NULL != pCurDq )
1825 {
1826 pCurDq->pCsData[0] = pCtx->pCsListXchg[0][0];
1827 pCurDq->pCsData[1] = pCtx->pCsListXchg[0][1];
1828 pCurDq->pCsData[2] = pCtx->pCsListXchg[0][2];
1829 pCurDq->iCsStride[0] = pCtx->iCsStride[0];
1830 pCurDq->iCsStride[1] = pCtx->iCsStride[1];
1831 pCurDq->iCsStride[2] = pCtx->iCsStride[2];
1832
1833 pCurDq->pMbType = pCtx->sMb.pMbType[0];
1834 pCurDq->pSliceIdc = pCtx->sMb.pSliceIdc[0];
1835 pCurDq->pMv[0] = pCtx->sMb.pMv[0][0];
1836 pCurDq->pRefIndex[0] = pCtx->sMb.pRefIndex[0][0];
1837 pCurDq->pLumaQp = pCtx->sMb.pLumaQp[0];
1838 pCurDq->pChromaQp = pCtx->sMb.pChromaQp[0];
1839 pCurDq->pNzc = pCtx->sMb.pNzc[0];
1840 pCurDq->pNzcRs = pCtx->sMb.pNzcRs[0];
1841 pCurDq->pScaledTCoeff = pCtx->sMb.pScaledTCoeff[0];
1842 pCurDq->pIntraPredMode = pCtx->sMb.pIntraPredMode[0];
1843 pCurDq->pIntra4x4FinalMode = pCtx->sMb.pIntra4x4FinalMode[0];
1844 pCurDq->pChromaPredMode = pCtx->sMb.pChromaPredMode[0];
1845 pCurDq->pCbp = pCtx->sMb.pCbp[0];
1846 pCurDq->pSubMbType = pCtx->sMb.pSubMbType[0];
1847 pCurDq->pInterPredictionDoneFlag = pCtx->sMb.pInterPredictionDoneFlag[0];
1848 pCurDq->pResidualPredFlag = pCtx->sMb.pResidualPredFlag[0];
1849 }
1850}
1851
1852// added to reset state of parameter sets to waiting successive incoming IDR, 6/4/2010
1853// It will be called in case packets lost/ broken and decoded failed at temporal level 0
1854void_t ResetParameterSetsState( PWelsDecoderContext pCtx )
1855{
1856 pCtx->bSpsExistAheadFlag = false;
1857 pCtx->bSubspsExistAheadFlag = false;
1858 pCtx->bPpsExistAheadFlag = false;
1859}
1860
1861/*
1862 * DecodeCurrentAccessUnit
1863 * Decode current access unit when current AU is completed.
1864 */
1865int32_t DecodeCurrentAccessUnit( PWelsDecoderContext pCtx, uint8_t **ppDst, int32_t *pDstLen, int32_t *pWidth, int32_t *pHeight, SBufferInfo *pDstInfo )
1866{
1867 int32_t iRefCount[LIST_A];
1868 PNalUnit pNalCur = NULL;
1869 PAccessUnit pCurAu = pCtx->pAccessUnitList;
1870
1871 int32_t iIdx = pCurAu->uiStartPos;
1872 int32_t iEndIdx = pCurAu->uiEndPos;
1873
1874 int32_t iPpsId = 0;
1875 int32_t iRet = ERR_NONE;
1876
1877 const uint8_t kuiTargetLayerDqId = GetTargetDqId(pCtx->uiTargetDqId, pCtx->pParam);
1878 const uint8_t kuiDependencyIdMax = (kuiTargetLayerDqId & 0x7F) >> 4;
1879 int16_t iLastIdD = -1, iLastIdQ = -1;
1880 int16_t iCurrIdD = 0, iCurrIdQ = 0;
1881 uint8_t uiNalRefIdc = 0;
1882 bool_t bFreshSliceAvailable = true; // Another fresh slice comingup for given dq layer, for multiple slices in case of header parts of slices sometimes loss over error-prone channels, 8/14/2008
1883 PPicture pStoreBasePic = NULL;
1884
1885 //update pCurDqLayer at the starting of AU decoding
1886 if ( pCtx->bInitialDqLayersMem )
1887 {
1888 pCtx->pCurDqLayer = pCtx->pDqLayersList[0];
1889 }
1890
1891 InitCurDqLayerData( pCtx, pCtx->pCurDqLayer );
1892
1893 pNalCur = pCurAu->pNalUnitsList[iIdx];
1894 while ( iIdx <= iEndIdx )
1895 {
1896 PDqLayer dq_cur = pCtx->pCurDqLayer;
1897 SLayerInfo pLayerInfo;
1898 PSliceHeaderExt pShExt = NULL;
1899 PSliceHeader pSh = NULL;
1900
1901 if( pCtx->pDec == NULL ){
1902 pCtx->pDec = PrefetchPic(pCtx->pPicBuff[0]);
1903
1904 if( NULL == pCtx->pDec ){
1905 WelsLog( pCtx, WELS_LOG_ERROR, "DecodeCurrentAccessUnit()::::::PrefetchPic ERROR, pSps->iNumRefFrames:%d.\n",
1906 pCtx->pSps->iNumRefFrames );
1907 pCtx->iErrorCode |= dsOutOfMemory;
1908 return ERR_INFO_REF_COUNT_OVERFLOW;
1909 }
1910 }
1911
1912#ifdef NO_WAITING_AU
1913 //For fixing the nal lossing issue
1914 if ((pCtx->pDec->iTotalNumMbRec != 0)&&
1915 (CheckAccessUnitBoundaryExt(&pCtx->sLastNalHdrExt, &pNalCur->sNalHeaderExt, &pCtx->sLastSliceHeader, &pNalCur->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader)))
1916 {
1917 pCtx->pDec->iTotalNumMbRec = 0;
1918 }
1919#else
1920 //initialize at the starting of AU.
1921 pCtx->pDec->iTotalNumMbRec = 0;
1922#endif
1923 if(pCtx->pDec->iTotalNumMbRec == 0) //Picture start to decode
1924 {
1925 for( int32_t i = 0; i < LAYER_NUM_EXCHANGEABLE; ++ i)
1926 memset(pCtx->sMb.pSliceIdc[i], 0xff, (pCtx->sMb.iMbWidth * pCtx->sMb.iMbHeight * sizeof(int32_t)) );
1927 }
1928 GetI4LumaIChromaAddrTable(pCtx->iDecBlockOffsetArray, pCtx->pDec->iLinesize[0], pCtx->pDec->iLinesize[1]);
1929
1930 if ( pNalCur->sNalHeaderExt.uiLayerDqId > kuiTargetLayerDqId ) {
1931 break; // Per formance it need not to decode the remaining bits any more due to given uiLayerDqId required, 9/2/2009
1932 }
1933
1934 memset(&pLayerInfo, 0, sizeof(SLayerInfo));
1935
1936 /*
1937 * Loop decoding for slices (even FMO and/ multiple slices) within a dq layer
1938 */
1939 while ( iIdx <= iEndIdx )
1940 {
1941 BOOL_T bReconstructSlice;
1942 iCurrIdQ = pNalCur->sNalHeaderExt.uiQualityId;
1943 iCurrIdD = pNalCur->sNalHeaderExt.uiDependencyId;
1944 pSh = &pNalCur->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader;
1945 pShExt = &pNalCur->sNalData.sVclNal.sSliceHeaderExt;
1946
1947 bReconstructSlice = CheckSliceNeedReconstruct(iCurrIdD, iCurrIdQ, pShExt->bStoreRefBasePicFlag,
1948 kuiDependencyIdMax, pNalCur->sNalHeaderExt.uiLayerDqId, kuiTargetLayerDqId);
1949
1950 memcpy(&pLayerInfo.sNalHeaderExt, &pNalCur->sNalHeaderExt, sizeof(SNalUnitHeaderExt));//confirmed_safe_unsafe_usage
1951
1952 pCtx->pDec->iFrameNum = pSh->iFrameNum;
1953
1954 memcpy(&pLayerInfo.sSliceInLayer.sSliceHeaderExt, pShExt, sizeof(SSliceHeaderExt));//confirmed_safe_unsafe_usage
1955 pLayerInfo.sSliceInLayer.bSliceHeaderExtFlag = pNalCur->sNalData.sVclNal.bSliceHeaderExtFlag;
1956 pLayerInfo.sSliceInLayer.eSliceType = pSh->eSliceType;
1957 pLayerInfo.sSliceInLayer.iLastMbQp = pSh->iSliceQp;
1958 dq_cur->pBitStringAux = &pNalCur->sNalData.sVclNal.sSliceBitsRead;
1959
1960 uiNalRefIdc = pNalCur->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc;
1961
1962 iPpsId = pSh->iPpsId;
1963
1964 pLayerInfo.pPps = pSh->pPps;
1965 pLayerInfo.pSps = pSh->pSps;
1966 pLayerInfo.pSubsetSps = pShExt->pSubsetSps;
1967
1968 pCtx->pFmo = &pCtx->sFmoList[iPpsId];
1969 if ( !FmoParamUpdate( pCtx->pFmo, pLayerInfo.pSps, pLayerInfo.pPps, &pCtx->iActiveFmoNum ) ) {
1970 pCtx->iErrorCode |= dsBitstreamError;
1971 WelsLog( pCtx, WELS_LOG_WARNING, "DecodeCurrentAccessUnit(), FmoParamUpdate failed, eSliceType: %d.\n", pSh->eSliceType);
1972 return GENERATE_ERROR_NO(ERR_LEVEL_SLICE_HEADER, ERR_INFO_FMO_INIT_FAIL);
1973 }
1974
1975 bFreshSliceAvailable = (iCurrIdD != iLastIdD || iCurrIdQ != iLastIdQ); // do not need condition of (first_mb == 0) due multiple slices might be disorder
1976
1977 WelsDqLayerDecodeStart ( pCtx, pNalCur, pLayerInfo.pSps, pLayerInfo.pPps );
1978
1979 if ( iCurrIdQ == BASE_QUALITY_ID )
1980 {
1981 ST64(iRefCount, LD64(pLayerInfo.sSliceInLayer.sSliceHeaderExt.sSliceHeader.uiRefCount));
1982 }
1983
1984 if ( (iLastIdD < 0) || //case 1: first layer
1985 ( iLastIdD == iCurrIdD) ) //case 2: same uiDId
1986 {
1987 InitDqLayerInfo( dq_cur, &pLayerInfo, pNalCur, pCtx->pDec );
1988
1989 if ( !dq_cur->sLayerInfo.pSps->bGapsInFrameNumValueAllowedFlag )
1990 {
1991 const bool_t kbIdrFlag = dq_cur->sLayerInfo.sNalHeaderExt.bIdrFlag || (dq_cur->sLayerInfo.sNalHeaderExt.sNalUnitHeader.eNalUnitType == NAL_UNIT_CODED_SLICE_IDR);
1992 // Subclause 8.2.5.2 Decoding process for gaps in frame_num
1993 if ( !kbIdrFlag &&
1994 pSh->iFrameNum != pCtx->iPrevFrameNum &&
1995 pSh->iFrameNum != ((pCtx->iPrevFrameNum+1) & ((1<<dq_cur->sLayerInfo.pSps->uiLog2MaxFrameNum)-1)) )
1996 {
1997 WelsLog( pCtx, WELS_LOG_WARNING, "referencing pictures lost due frame gaps exist, prev_frame_num: %d, curr_frame_num: %d\n", pCtx->iPrevFrameNum, pSh->iFrameNum);
1998
1999#ifdef LONG_TERM_REF
2000 pCtx->bParamSetsLostFlag = true;
2001#else
2002 pCtx->bReferenceLostAtT0Flag = true;
2003#endif
2004 ResetParameterSetsState( pCtx );
2005
2006 pCtx->iErrorCode |= dsRefLost;
2007 return ERR_INFO_REFERENCE_PIC_LOST;
2008 }
2009 }
2010
2011 if ( iCurrIdD == kuiDependencyIdMax && iCurrIdQ == BASE_QUALITY_ID )
2012 {
2013 iRet = InitRefPicList ( pCtx, uiNalRefIdc, bFreshSliceAvailable, pSh->iPicOrderCntLsb);
2014 if ( iRet )
2015 {
2016 HandleReferenceLost(pCtx, pNalCur);
2017 WelsLog( pCtx, WELS_LOG_WARNING, "reference picture introduced by this frame is lost during transmission! uiTId: %d\n", pNalCur->sNalHeaderExt.uiTemporalId );
2018 return iRet;
2019 }
2020 }
2021
2022 iRet = WelsDecodeSlice ( pCtx, bFreshSliceAvailable, pNalCur );
2023
2024 //Output good store_base reconstruction when enhancement quality layer occurred error for MGS key picture case
2025 if ( iRet != ERR_NONE )
2026 {
2027 WelsLog( pCtx, WELS_LOG_WARNING, "DecodeCurrentAccessUnit() failed (%d) in frame: %d uiDId: %d uiQId: %d\n",
2028 iRet, pSh->iFrameNum, iCurrIdD, iCurrIdQ);
2029 HandleReferenceLostL0(pCtx, pNalCur);
2030 return iRet;
2031 }
2032 if( bReconstructSlice ) {
2033 if( WelsDecodeConstructSlice(pCtx, pNalCur) ){
2034 return -1;
2035 }
2036 }
2037 }
2038#if defined (_DEBUG) && !defined (CODEC_FOR_TESTBED)
2039 fprintf( stderr, "cur_frame : %d iCurrIdD : %d\n ",
2040 dq_cur->sLayerInfo.sSliceInLayer.sSliceHeaderExt.sSliceHeader.iFrameNum, iCurrIdD );
2041#endif//#if !CODEC_FOR_TESTBED
2042 iLastIdD = iCurrIdD;
2043 iLastIdQ = iCurrIdQ;
2044
2045 //pNalUnitsList overflow.
2046 ++ iIdx;
2047 if (iIdx <= iEndIdx)
2048 {
2049 pNalCur = pCurAu->pNalUnitsList[iIdx];
2050 }
2051 else
2052 {
2053 pNalCur = NULL;
2054 }
2055
2056 if ( pNalCur == NULL ||
2057 iLastIdD != pNalCur->sNalHeaderExt.uiDependencyId ||
2058 iLastIdQ != pNalCur->sNalHeaderExt.uiQualityId )
2059 break;
2060 }
2061
2062 // A dq layer decoded here
2063#if defined (_DEBUG) && !defined (CODEC_FOR_TESTBED)
2064#undef fprintf
2065 fprintf(stderr, "POC: #%d, FRAME: #%d, D: %d, Q: %d, T: %d, P: %d, %d\n",
2066 pSh->iPicOrderCntLsb, pSh->iFrameNum, iCurrIdD, iCurrIdQ, dq_cur->sLayerInfo.sNalHeaderExt.uiTemporalId, dq_cur->sLayerInfo.sNalHeaderExt.uiPriorityId,dq_cur->sLayerInfo.sSliceInLayer.sSliceHeaderExt.sSliceHeader.iSliceQp);
2067#endif//#if !CODEC_FOR_TESTBED
2068
2069 if( dq_cur->uiLayerDqId == kuiTargetLayerDqId ){
2070 if( DecodeFrameConstruction( pCtx, ppDst, pDstLen, pWidth, pHeight, pDstInfo) ){
2071#ifdef NO_WAITING_AU
2072 memcpy(&pCtx->sLastNalHdrExt, &pCurAu->pNalUnitsList[iIdx-1]->sNalHeaderExt, sizeof(SNalUnitHeaderExt));
2073 memcpy(&pCtx->sLastSliceHeader, &pCurAu->pNalUnitsList[iIdx-1]->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader, sizeof(SSliceHeader));
2074 return ERR_NONE;
2075#else
2076 pCtx->iErrorCode |= dsBitstreamError;
2077 return -1;
2078#endif
2079
2080 }
2081 if( (uiNalRefIdc > 0) && ( iCurrIdQ || (!dq_cur->bStoreRefBasePicFlag) ) ){
2082 WelsMarkAsRef(pCtx, false);
2083 ExpandReferencingPicture(pCtx->pDec, pCtx->sExpandPicFunc.pExpandLumaPicture, pCtx->sExpandPicFunc.pExpandChromaPicture);
2084 pCtx->pDec = NULL;
2085 }
2086 }
2087
2088 if( (iCurrIdD == kuiDependencyIdMax) && (iCurrIdQ == BASE_QUALITY_ID) && (dq_cur->bStoreRefBasePicFlag) ){
2089 pStoreBasePic = pCtx->pDec;
2090
2091 if( uiNalRefIdc > 0 ){
2092 WelsMarkAsRef(pCtx, true);
2093 ExpandReferencingPicture(pCtx->pDec, pCtx->sExpandPicFunc.pExpandLumaPicture, pCtx->sExpandPicFunc.pExpandChromaPicture);
2094 pCtx->pDec = NULL;
2095 }
2096 }
2097 // need update frame_num due current frame is well decoded
2098 pCtx->iPrevFrameNum = pSh->iFrameNum;
2099 if( pCtx->bLastHasMmco5 )
2100 pCtx->iPrevFrameNum = 0;
2101 }
2102
2103 return ERR_NONE;
2104}
2105
2106} // namespace WelsDec
codec/decoder/core/src/decoder_data_tables.cpp+661−0
@@ -0,0 +1,661 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33// exp_data.c
34// export date cross various modules (.c)
35#include "typedefs.h"
36#include "wels_common_basis.h"
37#include "mb_cache.h"
38#include "utils.h"
39#include "vlc_decoder.h"
40
41namespace WelsDec {
42
43///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
44
45//////non_zero_count[16+8] mapping scan index
46const uint8_t g_kuiMbNonZeroCountIdx[24] =
47{ // 0 1 | 4 5 luma 8*8 block non_zero_count[16+8]
48 0, 1, 4, 5, // 2 3 | 6 7 0 | 1 0 1 2 3
49 2, 3, 6, 7, //--------------- --------- 4 5 6 7
50 8, 9, 12, 13, // 8 9 | 12 13 2 | 3 8 9 10 11
51 10, 11, 14, 15, // 10 11 | 14 15-----------------------------> 12 13 14 15
52 16, 17, 20, 21, //---------------- chroma 8*8 block 16 17 18 19
53 18, 19, 22, 23 // 16 17 | 20 21 0 1 20 21 22 23
54};
55//cache element equal to 26
56
57const uint8_t g_kuiCacheNzcScanIdx[24] =
58{
59 /* Luma */
60 9, 10, 17, 18, // 1+1*8, 2+1*8, 1+2*8, 2+2*8,
61 11, 12, 19, 20, // 3+1*8, 4+1*8, 3+2*8, 4+2*8,
62 25, 26, 33, 34, // 1+3*8, 2+3*8, 1+4*8, 2+4*8,
63 27, 28, 35, 36, // 3+3*8, 4+3*8, 3+4*8, 4+4*8,
64 /* Cb */
65 14, 15, // 6+1*8, 7+1*8,
66 22, 23, // 6+2*8, 7+2*8,
67
68 /* Cr */
69 38, 39, // 6+4*8, 7+4*8,
70 46, 47, // 6+5*8, 7+5*8,
71};
72
73//cache element equal to 30
74const uint8_t g_kuiCache30ScanIdx[16] = //mv or ref_index cache scan index, 4*4 block as basic unit
75{
76 7, 8, 13, 14,
77 9, 10, 15, 16,
78 19, 20, 25, 26,
79 21, 22, 27, 28
80};
81
82const uint8_t g_kuiScan4[16] = //for mb cache in sMb (only current element, without neighbor)
83{ // 4*4block scan mb cache order
84 0, 1, 4, 5, // 0 1 | 4 5 0 1 | 2 3
85 2, 3, 6, 7, // 2 3 | 6 7 4 5 | 6 7
86 8, 9, 12, 13, //----------------->-----------
87 10, 11, 14, 15 // 8 9 |12 13 8 9 |10 11
88}; //10 11 |14 15 12 13 |14 15
89
90///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
91
92// extern at wels_common_basis.h
93
94const uint8_t g_kuiChromaQp[52]={
95 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,
96 12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,
97 28,29,29,30,31,32,32,33,34,34,35,35,36,36,37,37,
98 37,38,38,38,39,39,39,39
99};
100
101/*
102 * vcl type map for given NAL unit type and corresponding H264 type
103 */
104const VclType g_kuiVclTypeMap[32][2] =
105{
106 { NON_VCL, NON_VCL }, // 0: NAL_UNIT_UNSPEC_0
107 { VCL, VCL, }, // 1: NAL_UNIT_CODED_SLICE
108 { VCL, NOT_APP }, // 2: NAL_UNIT_CODED_SLICE_DPA
109 { VCL, NOT_APP }, // 3: NAL_UNIT_CODED_SLICE_DPB
110 { VCL, NOT_APP }, // 4: NAL_UNIT_CODED_SLICE_DPC
111 { VCL, VCL }, // 5: NAL_UNIT_CODED_SLICE_IDR
112 { NON_VCL, NON_VCL }, // 6: NAL_UNIT_SEI
113 { NON_VCL, NON_VCL }, // 7: NAL_UNIT_SPS
114 { NON_VCL, NON_VCL }, // 8: NAL_UNIT_PPS
115 { NON_VCL, NON_VCL }, // 9: NAL_UNIT_AU_DELIMITER
116 { NON_VCL, NON_VCL }, // 10: NAL_UNIT_END_OF_SEQ
117 { NON_VCL, NON_VCL }, // 11: NAL_UNIT_END_OF_STR
118 { NON_VCL, NON_VCL }, // 12: NAL_UNIT_FILLER_DATA
119 { NON_VCL, NON_VCL }, // 13: NAL_UNIT_SPS_EXT
120 { NON_VCL, NON_VCL }, // 14: NAL_UNIT_PREFIX, NEED associate succeeded NAL to make a VCL
121 { NON_VCL, NON_VCL }, // 15: NAL_UNIT_SUBSET_SPS
122 { NON_VCL, NON_VCL }, // 16: NAL_UNIT_RESV_16
123 { NON_VCL, NON_VCL }, // 17: NAL_UNIT_RESV_17
124 { NON_VCL, NON_VCL }, // 18: NAL_UNIT_RESV_18
125 { NON_VCL, NON_VCL }, // 19: NAL_UNIT_AUX_CODED_SLICE
126 { NON_VCL, VCL }, // 20: NAL_UNIT_CODED_SLICE_EXT
127 { NON_VCL, NON_VCL }, // 21: NAL_UNIT_RESV_21
128 { NON_VCL, NON_VCL }, // 22: NAL_UNIT_RESV_22
129 { NON_VCL, NON_VCL }, // 23: NAL_UNIT_RESV_23
130 { NON_VCL, NON_VCL }, // 24: NAL_UNIT_UNSPEC_24
131 { NON_VCL, NON_VCL }, // 25: NAL_UNIT_UNSPEC_25
132 { NON_VCL, NON_VCL }, // 26: NAL_UNIT_UNSPEC_26
133 { NON_VCL, NON_VCL }, // 27: NAL_UNIT_UNSPEC_27
134 { NON_VCL, NON_VCL }, // 28: NAL_UNIT_UNSPEC_28
135 { NON_VCL, NON_VCL }, // 29: NAL_UNIT_UNSPEC_29
136 { NON_VCL, NON_VCL }, // 30: NAL_UNIT_UNSPEC_30
137 { NON_VCL, NON_VCL } // 31: NAL_UNIT_UNSPEC_31
138};
139
140/*common use table*/
141const uint8_t g_kuiScan8[24]={ // [16 + 2*4]
142 9, 10, 17, 18, // 1+1*8, 2+1*8, 1+2*8, 2+2*8,
143 11, 12, 19, 20, // 3+1*8, 4+1*8, 3+2*8, 4+2*8,
144 25, 26, 33, 34, // 1+3*8, 2+3*8, 1+4*8, 2+4*8,
145 27, 28, 35, 36, // 3+3*8, 4+3*8, 3+4*8, 4+4*8,
146 14, 15, // 6+1*8, 7+1*8,
147 22, 23, // 6+2*8, 7+2*8,
148 38, 39, // 6+4*8, 7+4*8,
149 46, 47, // 6+5*8, 7+5*8,
150};
151
152const uint8_t g_kuiLumaDcZigzagScan[16]={
153 0, 16, 32, 128, // 0*16 + 0*64, 1*16 + 0*64, 2*16 + 0*64, 0*16 + 2*64,
154 48, 64, 80, 96, // 3*16 + 0*64, 0*16 + 1*64, 1*16 + 1*64, 2*16 + 1*64,
155 144, 160, 176, 192, // 1*16 + 2*64, 2*16 + 2*64, 3*16 + 2*64, 0*16 + 3*64,
156 112, 208, 224, 240 // 3*16 + 1*64, 1*16 + 3*64, 2*16 + 3*64, 3*16 + 3*64,
157};
158
159const uint8_t g_kuiChromaDcScan[4]={
160 0, 16, 32, 48
161};
162
163__align16( const uint16_t, g_kuiDequantCoeff[52][8]) = {
164 /* 0*/{ 10, 13, 10, 13, 13, 16, 13, 16 }, /* 1*/{ 11, 14, 11, 14, 14, 18, 14, 18 },
165 /* 2*/{ 13, 16, 13, 16, 16, 20, 16, 20 }, /* 3*/{ 14, 18, 14, 18, 18, 23, 18, 23 },
166 /* 4*/{ 16, 20, 16, 20, 20, 25, 20, 25 }, /* 5*/{ 18, 23, 18, 23, 23, 29, 23, 29 },
167 /* 6*/{ 20, 26, 20, 26, 26, 32, 26, 32 }, /* 7*/{ 22, 28, 22, 28, 28, 36, 28, 36 },
168 /* 8*/{ 26, 32, 26, 32, 32, 40, 32, 40 }, /* 9*/{ 28, 36, 28, 36, 36, 46, 36, 46 },
169 /*10*/{ 32, 40, 32, 40, 40, 50, 40, 50 }, /*11*/{ 36, 46, 36, 46, 46, 58, 46, 58 },
170 /*12*/{ 40, 52, 40, 52, 52, 64, 52, 64 }, /*13*/{ 44, 56, 44, 56, 56, 72, 56, 72 },
171 /*14*/{ 52, 64, 52, 64, 64, 80, 64, 80 }, /*15*/{ 56, 72, 56, 72, 72, 92, 72, 92 },
172 /*16*/{ 64, 80, 64, 80, 80, 100, 80, 100 }, /*17*/{ 72, 92, 72, 92, 92, 116, 92, 116 },
173 /*18*/{ 80, 104, 80, 104, 104, 128, 104, 128 }, /*19*/{ 88, 112, 88, 112, 112, 144, 112, 144 },
174 /*20*/{ 104, 128, 104, 128, 128, 160, 128, 160 }, /*21*/{ 112, 144, 112, 144, 144, 184, 144, 184 },
175 /*22*/{ 128, 160, 128, 160, 160, 200, 160, 200 }, /*23*/{ 144, 184, 144, 184, 184, 232, 184, 232 },
176 /*24*/{ 160, 208, 160, 208, 208, 256, 208, 256 }, /*25*/{ 176, 224, 176, 224, 224, 288, 224, 288 },
177 /*26*/{ 208, 256, 208, 256, 256, 320, 256, 320 }, /*27*/{ 224, 288, 224, 288, 288, 368, 288, 368 },
178 /*28*/{ 256, 320, 256, 320, 320, 400, 320, 400 }, /*29*/{ 288, 368, 288, 368, 368, 464, 368, 464 },
179 /*30*/{ 320, 416, 320, 416, 416, 512, 416, 512 }, /*31*/{ 352, 448, 352, 448, 448, 576, 448, 576 },
180 /*32*/{ 416, 512, 416, 512, 512, 640, 512, 640 }, /*33*/{ 448, 576, 448, 576, 576, 736, 576, 736 },
181 /*34*/{ 512, 640, 512, 640, 640, 800, 640, 800 }, /*35*/{ 576, 736, 576, 736, 736, 928, 736, 928 },
182 /*36*/{ 640, 832, 640, 832, 832, 1024, 832, 1024 }, /*37*/{ 704, 896, 704, 896, 896, 1152, 896, 1152 },
183 /*38*/{ 832, 1024, 832, 1024, 1024, 1280, 1024, 1280 }, /*39*/{ 896, 1152, 896, 1152, 1152, 1472, 1152, 1472 },
184 /*40*/{ 1024, 1280, 1024, 1280, 1280, 1600, 1280, 1600 }, /*41*/{ 1152, 1472, 1152, 1472, 1472, 1856, 1472, 1856 },
185 /*42*/{ 1280, 1664, 1280, 1664, 1664, 2048, 1664, 2048 }, /*43*/{ 1408, 1792, 1408, 1792, 1792, 2304, 1792, 2304 },
186 /*44*/{ 1664, 2048, 1664, 2048, 2048, 2560, 2048, 2560 }, /*45*/{ 1792, 2304, 1792, 2304, 2304, 2944, 2304, 2944 },
187 /*46*/{ 2048, 2560, 2048, 2560, 2560, 3200, 2560, 3200 }, /*47*/{ 2304, 2944, 2304, 2944, 2944, 3712, 2944, 3712 },
188 /*48*/{ 2560, 3328, 2560, 3328, 3328, 4096, 3328, 4096 }, /*49*/{ 2816, 3584, 2816, 3584, 3584, 4608, 3584, 4608 },
189 /*50*/{ 3328, 4096, 3328, 4096, 4096, 5120, 4096, 5120 }, /*51*/{ 3584, 4608, 3584, 4608, 4608, 5888, 4608, 5888 },
190};
191
192///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
193
194const uint8_t g_kuiIntra4x4CbpTable[48] =
195{
196 47, 31, 15, 0, 23, 27, 29, 30, 7, 11, 13, 14, 39, 43, 45, 46, //15
197 16, 3, 5, 10, 12, 19, 21, 26, 28, 35, 37, 42, 44, 1, 2, 4, //31
198 8, 17, 18, 20, 24, 6, 9, 22, 25, 32, 33, 34, 36, 40, 38, 41 //47
199};
200
201const uint8_t g_kuiInterCbpTable[48] =
202{
203 0, 16, 1, 2, 4, 8, 32, 3, 5, 10, 12, 15, 47, 7, 11, 13, //15
204 14, 6, 9, 31, 35, 37, 42, 44, 33, 34, 36, 40, 39, 43, 45, 46, //31
205 17, 18, 20, 24, 19, 21, 26, 28, 23, 27, 29, 30, 22, 25, 38, 41 //47
206};
207
208const uint8_t g_kuiLeadingZeroTable[256] =
209{
210 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
211 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
212 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
213 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
214 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
215 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
216 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
217 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
218 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
219 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
221 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
222 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
223 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
224 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
225 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
226};
227
228///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
229
230// extern at vlc_decoder.h
231
232const uint8_t g_kuiVlcChromaTable[256][2] =
233{
234 {13, 7}, {13, 7}, {12, 8}, {11, 8}, {8, 7}, {8, 7}, {7, 7}, {7, 7}, {10, 6}, {10, 6}, {10, 6}, {10, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, //15
235 { 3, 6}, { 3, 6}, { 3, 6}, { 3, 6}, {9, 6}, {9, 6}, {9, 6}, {9, 6}, { 4, 6}, { 4, 6}, { 4, 6}, { 4, 6}, {1, 6}, {1, 6}, {1, 6}, {1, 6}, //31
236 { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, {5, 3}, {5, 3}, {5, 3}, {5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, {5, 3}, {5, 3}, {5, 3}, {5, 3}, //47
237 { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, {5, 3}, {5, 3}, {5, 3}, {5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, {5, 3}, {5, 3}, {5, 3}, {5, 3}, //63
238 { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, //79
239 { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, //95
240 { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, //111
241 { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, //127
242 { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, //143
243 { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, //159
244 { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, //175
245 { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, //191
246 { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, //207
247 { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, //223
248 { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, //239
249 { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1}, {2, 1}, {2, 1}, {2, 1}, {2, 1} //255
250};
251
252const uint8_t g_kuiVlcTable_0[256][2] = //[0] means the index of vlc table, [1] means the length of vlc code [256] value means the value of 8bits
253{
254 { 0, 0}, { 0, 0}, { 0, 0}, {0, 0}, {21, 8}, {12, 8}, {7, 8}, {3, 8}, {17, 7}, {17, 7}, {8, 7}, {8, 7}, {13, 6}, {13, 6}, {13, 6}, {13, 6}, //15
255 { 4, 6}, { 4, 6}, { 4, 6}, {4, 6}, { 1, 6}, { 1, 6}, {1, 6}, {1, 6}, { 9, 5}, { 9, 5}, {9, 5}, {9, 5}, { 9, 5}, { 9, 5}, { 9, 5}, { 9, 5}, //31
256 { 5, 3}, { 5, 3}, { 5, 3}, {5, 3}, { 5, 3}, { 5, 3}, {5, 3}, {5, 3}, { 5, 3}, { 5, 3}, {5, 3}, {5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, //47
257 { 5, 3}, { 5, 3}, { 5, 3}, {5, 3}, { 5, 3}, { 5, 3}, {5, 3}, {5, 3}, { 5, 3}, { 5, 3}, {5, 3}, {5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, //63
258 { 2, 2}, { 2, 2}, { 2, 2}, {2, 2}, { 2, 2}, { 2, 2}, {2, 2}, {2, 2}, { 2, 2}, { 2, 2}, {2, 2}, {2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, //79
259 { 2, 2}, { 2, 2}, { 2, 2}, {2, 2}, { 2, 2}, { 2, 2}, {2, 2}, {2, 2}, { 2, 2}, { 2, 2}, {2, 2}, {2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, //95
260 { 2, 2}, { 2, 2}, { 2, 2}, {2, 2}, { 2, 2}, { 2, 2}, {2, 2}, {2, 2}, { 2, 2}, { 2, 2}, {2, 2}, {2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, //111
261 { 2, 2}, { 2, 2}, { 2, 2}, {2, 2}, { 2, 2}, { 2, 2}, {2, 2}, {2, 2}, { 2, 2}, { 2, 2}, {2, 2}, {2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, //127
262 { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, //143
263 { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, //159
264 { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, //175
265 { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, //191
266 { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, //207
267 { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, //223
268 { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, //239
269 { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1} //255
270};
271
272const uint8_t g_kuiVlcTable_0_0[256][2] = // read 8 bits // for g_kuiVlcTable_0[0] //checked no error--
273{
274 { 0, 0}, { 0, 0}, {47, 7}, {47, 7}, {58, 8}, {60, 8}, {59, 8}, {54, 8}, {61, 8}, {56, 8}, {55, 8}, {50, 8}, {57, 8}, {52, 8}, {51, 8}, {46, 8}, //15
275 {53, 7}, {53, 7}, {48, 7}, {48, 7}, {43, 7}, {43, 7}, {42, 7}, {42, 7}, {49, 7}, {49, 7}, {44, 7}, {44, 7}, {39, 7}, {39, 7}, {38, 7}, {38, 7}, //31
276 {45, 6}, {45, 6}, {45, 6}, {45, 6}, {40, 6}, {40, 6}, {40, 6}, {40, 6}, {35, 6}, {35, 6}, {35, 6}, {35, 6}, {34, 6}, {34, 6}, {34, 6}, {34, 6}, //47
277 {41, 6}, {41, 6}, {41, 6}, {41, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {31, 6}, {31, 6}, {31, 6}, {31, 6}, {30, 6}, {30, 6}, {30, 6}, {30, 6}, //63
278 {26, 5}, {26, 5}, {26, 5}, {26, 5}, {26, 5}, {26, 5}, {26, 5}, {26, 5}, {32, 5}, {32, 5}, {32, 5}, {32, 5}, {32, 5}, {32, 5}, {32, 5}, {32, 5}, //79
279 {27, 5}, {27, 5}, {27, 5}, {27, 5}, {27, 5}, {27, 5}, {27, 5}, {27, 5}, {22, 5}, {22, 5}, {22, 5}, {22, 5}, {22, 5}, {22, 5}, {22, 5}, {22, 5}, //95
280 {37, 5}, {37, 5}, {37, 5}, {37, 5}, {37, 5}, {37, 5}, {37, 5}, {37, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, //111
281 {23, 5}, {23, 5}, {23, 5}, {23, 5}, {23, 5}, {23, 5}, {23, 5}, {23, 5}, {18, 5}, {18, 5}, {18, 5}, {18, 5}, {18, 5}, {18, 5}, {18, 5}, {18, 5}, //127
282 {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, //143
283 {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, {33, 3}, //159
284 {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, //175
285 {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, {24, 3}, //191
286 {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, //207
287 {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, //223
288 {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, //239
289 {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3}, {14, 3} //255
290};
291
292const uint8_t g_kuiVlcTable_0_1[4][2] = // read 2 bits // for g_kuiVlcTable_0[1] //checked no error--
293{
294 {29, 2}, {20, 2}, {15, 2}, {10, 2}
295};
296
297const uint8_t g_kuiVlcTable_0_2[2][2] = // read 1 bit // for g_kuiVlcTable_0[2] //checked no error--
298{
299 {25, 1}, {16, 1}
300};
301
302const uint8_t g_kuiVlcTable_0_3[2][2] = // read 1 bit // for g_kuiVlcTable_0[3] //checked no error--
303{
304 {11, 1}, {6, 1}
305};
306
307const uint8_t g_kuiVlcTable_1[256][2] = //checked no error--
308{
309 { 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, {14, 8}, {20, 8}, {19, 8}, {10, 8}, {29, 7}, {29, 7}, {16, 7}, {16, 7}, {15, 7}, {15, 7}, { 6, 7}, { 6, 7}, //15
310 {25, 6}, {25, 6}, {25, 6}, {25, 6}, {12, 6}, {12, 6}, {12, 6}, {12, 6}, {11, 6}, {11, 6}, {11, 6}, {11, 6}, { 3, 6}, { 3, 6}, { 3, 6}, { 3, 6}, //31
311 {21, 6}, {21, 6}, {21, 6}, {21, 6}, { 8, 6}, { 8, 6}, { 8, 6}, { 8, 6}, { 7, 6}, { 7, 6}, { 7, 6}, { 7, 6}, { 1, 6}, { 1, 6}, { 1, 6}, { 1, 6}, //47
312 {17, 5}, {17, 5}, {17, 5}, {17, 5}, {17, 5}, {17, 5}, {17, 5}, {17, 5}, { 4, 5}, { 4, 5}, { 4, 5}, { 4, 5}, { 4, 5}, { 4, 5}, { 4, 5}, { 4, 5}, //63
313 {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, //79
314 { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, //95
315 { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, //111
316 { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, //127
317 { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, //143
318 { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, //159
319 { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, //175
320 { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, //191
321 { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, //207
322 { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, //223
323 { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, //239
324 { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2} //255
325
326};
327
328const uint8_t g_kuiVlcTable_1_0[64][2] = // read 6 bits // for g_kuiVlcTable_1[0] //checked no error--
329{
330 { 0, 0}, { 0, 0}, {57, 5}, {57, 5}, {61, 6}, {60, 6}, {59, 6}, {58, 6}, {55, 6}, {54, 6}, {56, 6}, {51, 6}, {52, 5}, {52, 5}, {50, 5}, {50, 5}, //15
331 {53, 5}, {53, 5}, {48, 5}, {48, 5}, {47, 5}, {47, 5}, {46, 5}, {46, 5}, {49, 5}, {49, 5}, {44, 5}, {44, 5}, {43, 5}, {43, 5}, {42, 5}, {42, 5}, //31
332 {38, 4}, {38, 4}, {38, 4}, {38, 4}, {40, 4}, {40, 4}, {40, 4}, {40, 4}, {39, 4}, {39, 4}, {39, 4}, {39, 4}, {34, 4}, {34, 4}, {34, 4}, {34, 4}, //47
333 {45, 4}, {45, 4}, {45, 4}, {45, 4}, {36, 4}, {36, 4}, {36, 4}, {36, 4}, {35, 4}, {35, 4}, {35, 4}, {35, 4}, {30, 4}, {30, 4}, {30, 4}, {30, 4} //63
334};
335
336const uint8_t g_kuiVlcTable_1_1[8][2] = // read 3 bits // for g_kuiVlcTable_1[1] //checked no error--
337{
338 {41, 3}, {32, 3}, {31, 3}, {26, 3}, {37, 3}, {28, 3}, {27, 3}, {22, 3}
339};
340
341const uint8_t g_kuiVlcTable_1_2[2][2] = // read 1 bit // for g_kuiVlcTable_1[2] //checked no error--
342{
343 {33, 1}, {24, 1}
344};
345
346const uint8_t g_kuiVlcTable_1_3[2][2] = // read 1 bit // for g_kuiVlcTable_1[3] //checked no error--
347{
348 {23, 1}, {18, 1}
349};
350
351const uint8_t g_kuiVlcTable_2[256][2] = //checked no error--
352{
353 { 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, {45, 8}, {40, 8}, {35, 8}, {30, 8}, {41, 8}, {36, 8}, {31, 8}, {26, 8}, //15
354 {22, 7}, {22, 7}, {18, 7}, {18, 7}, {32, 7}, {32, 7}, {14, 7}, {14, 7}, {37, 7}, {37, 7}, {28, 7}, {28, 7}, {27, 7}, {27, 7}, {10, 7}, {10, 7}, //31
355 { 6, 6}, { 6, 6}, { 6, 6}, { 6, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {23, 6}, {23, 6}, {23, 6}, {23, 6}, { 3, 6}, { 3, 6}, { 3, 6}, { 3, 6}, //47
356 {33, 6}, {33, 6}, {33, 6}, {33, 6}, {20, 6}, {20, 6}, {20, 6}, {20, 6}, {19, 6}, {19, 6}, {19, 6}, {19, 6}, { 1, 6}, { 1, 6}, { 1, 6}, { 1, 6}, //63
357 {15, 5}, {15, 5}, {15, 5}, {15, 5}, {15, 5}, {15, 5}, {15, 5}, {15, 5}, {16, 5}, {16, 5}, {16, 5}, {16, 5}, {16, 5}, {16, 5}, {16, 5}, {16, 5}, //79
358 {11, 5}, {11, 5}, {11, 5}, {11, 5}, {11, 5}, {11, 5}, {11, 5}, {11, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, //95
359 { 7, 5}, { 7, 5}, { 7, 5}, { 7, 5}, { 7, 5}, { 7, 5}, { 7, 5}, { 7, 5}, {29, 5}, {29, 5}, {29, 5}, {29, 5}, {29, 5}, {29, 5}, {29, 5}, {29, 5}, //111
360 { 8, 5}, { 8, 5}, { 8, 5}, { 8, 5}, { 8, 5}, { 8, 5}, { 8, 5}, { 8, 5}, { 4, 5}, { 4, 5}, { 4, 5}, { 4, 5}, { 4, 5}, { 4, 5}, { 4, 5}, { 4, 5}, //127
361 {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, {25, 4}, //143
362 {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, {21, 4}, //159
363 {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, {17, 4}, //175
364 {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, {13, 4}, //191
365 { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, { 9, 4}, //207
366 { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, { 5, 4}, //223
367 { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, //239
368 { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4}, { 0, 4} //255
369};
370
371const uint8_t g_kuiVlcTable_2_0[4][2] = // read 2 bits // for g_kuiVlcTable_2[0] //checked
372{
373 {0, 0}, {58, 2}, {61, 2}, {60, 2}
374};
375
376
377const uint8_t g_kuiVlcTable_2_1[4][2] = // read 2 bits // for g_kuiVlcTable_2[1] //checked
378{
379 {59, 2}, {54, 2}, {57, 2}, {56, 2}
380};
381
382const uint8_t g_kuiVlcTable_2_2[4][2] = // read 2 bits // for g_kuiVlcTable_2[2] //checked
383{
384 {55, 2}, {50, 2}, {53, 2}, {52, 2}
385};
386
387const uint8_t g_kuiVlcTable_2_3[4][2] = // read 2 bits // for g_kuiVlcTable_2[3] //checked
388{
389 {51, 2}, {46, 2}, {47, 1}, {47, 1}
390};
391
392const uint8_t g_kuiVlcTable_2_4[2][2] = // read 1 bit // for g_kuiVlcTable_2[4] //checked
393{
394 {42, 1}, {48, 1}
395};
396
397const uint8_t g_kuiVlcTable_2_5[2][2] = // read 1 bit // for g_kuiVlcTable_2[5] //checked
398{
399 {43, 1}, {38, 1}
400};
401
402const uint8_t g_kuiVlcTable_2_6[2][2] = // read 1 bit // for g_kuiVlcTable_2[6] //checked no error--
403{
404 {49, 1}, {44, 1}
405};
406
407const uint8_t g_kuiVlcTable_2_7[2][2] = // read 1 bit // for g_kuiVlcTable_2[7] //checked no error--
408{
409 {39, 1}, {34, 1}
410};
411
412const uint8_t g_kuiVlcTable_3[64][2] = // read 6 bits //corrected
413{
414 { 1, 6}, { 2, 6}, { 0, 0}, { 0, 6}, { 3, 6}, { 4, 6}, { 5, 6}, { 0, 0}, { 6, 6}, { 7, 6}, { 8, 6}, { 9, 6}, {10, 6}, {11, 6}, {12, 6}, {13, 6}, //15
415 {14, 6}, {15, 6}, {16, 6}, {17, 6}, {18, 6}, {19, 6}, {20, 6}, {21, 6}, {22, 6}, {23, 6}, {24, 6}, {25, 6}, {26, 6}, {27, 6}, {28, 6}, {29, 6}, //31
416 {30, 6}, {31, 6}, {32, 6}, {33, 6}, {34, 6}, {35, 6}, {36, 6}, {37, 6}, {38, 6}, {39, 6}, {40, 6}, {41, 6}, {42, 6}, {43, 6}, {44, 6}, {45, 6}, //47
417 {46, 6}, {47, 6}, {48, 6}, {49, 6}, {50, 6}, {51, 6}, {52, 6}, {53, 6}, {54, 6}, {55, 6}, {56, 6}, {57, 6}, {58, 6}, {59, 6}, {60, 6}, {61, 6}, //63
418};
419
420
421const uint8_t g_kuiVlcTableNeedMoreBitsThread[3] =
422{
423 4, 4, 8
424};
425
426const uint8_t g_kuiVlcTableMoreBitsCount0[4] =
427{
428 8, 2, 1, 1
429};
430
431const uint8_t g_kuiVlcTableMoreBitsCount1[4] =
432{
433 6, 3, 1, 1
434};
435
436const uint8_t g_kuiVlcTableMoreBitsCount2[8] =
437{
438 2, 2, 2, 2, 1, 1, 1, 1
439};
440
441const uint8_t g_kuiNcMapTable[17] =
442{
443 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3
444};
445
446
447const uint8_t g_kuiVlcTrailingOneTotalCoeffTable[62][2] =
448{
449 {0, 0},
450 {0, 1}, {1, 1},
451 {0, 2}, {1, 2}, {2, 2},
452 {0, 3}, {1, 3}, {2, 3}, {3, 3},
453 {0, 4}, {1, 4}, {2, 4}, {3, 4},
454 {0, 5}, {1, 5}, {2, 5}, {3, 5},
455 {0, 6}, {1, 6}, {2, 6}, {3, 6},
456 {0, 7}, {1, 7}, {2, 7}, {3, 7},
457 {0, 8}, {1, 8}, {2, 8}, {3, 8},
458 {0, 9}, {1, 9}, {2, 9}, {3, 9},
459 {0, 10}, {1, 10}, {2, 10}, {3, 10},
460 {0, 11}, {1, 11}, {2, 11}, {3, 11},
461 {0, 12}, {1, 12}, {2, 12}, {3, 12},
462 {0, 13}, {1, 13}, {2, 13}, {3, 13},
463 {0, 14}, {1, 14}, {2, 14}, {3, 14},
464 {0, 15}, {1, 15}, {2, 15}, {3, 15},
465 {0, 16}, {1, 16}, {2, 16}, {3, 16}
466};
467
468const uint8_t g_kuiTotalZerosTable0[512][2] = //read 9 bits, generated by tzVlcIndex=1 in Table 9-7 in H.264/AVC standard
469{
470 {0, 0}, {15, 9}, {14, 9}, {13, 9}, {12, 8}, {12, 8}, {11, 8}, {11, 8}, {10, 7}, {10, 7}, {10, 7}, {10, 7}, {9, 7}, {9, 7}, {9, 7}, {9, 7}, //15
471 {8, 6}, { 8, 6}, { 8, 6}, { 8, 6}, { 8, 6}, { 8, 6}, { 8, 6}, { 8, 6}, { 7, 6}, { 7, 6}, { 7, 6}, { 7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, //31
472 {6, 5}, { 6, 5}, { 6, 5}, { 6, 5}, { 6, 5}, { 6, 5}, { 6, 5}, { 6, 5}, { 6, 5}, { 6, 5}, { 6, 5}, { 6, 5}, {6, 5}, {6, 5}, {6, 5}, {6, 5}, //47
473 {5, 5}, { 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}, {5, 5}, {5, 5}, {5, 5}, {5, 5}, //63
474 {4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, //79
475 {4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, //95
476 {3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, {3, 4}, {3, 4}, {3, 4}, {3, 4}, //111
477 {3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, { 3, 4}, {3, 4}, {3, 4}, {3, 4}, {3, 4}, //127
478 {2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, //143
479 {2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, //159
480 {2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, //175
481 {2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, //191
482 {1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, //207
483 {1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, //223
484 {1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, //239
485 {1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, //255
486 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //271
487 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //287
488 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //303
489 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //319
490 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //335
491 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //351
492 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //367
493 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //383
494 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //399
495 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //415
496 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //431
497 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //447
498 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //463
499 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //479
500 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, //495
501 {0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1} //511
502};
503
504const uint8_t g_kuiTotalZerosTable1[64][2] = //read 6 bits, generated by tzVlcIndex=2 in Table 9-7 in H.264/AVC standard
505{
506 {14, 6}, {13, 6}, {12, 6}, {11, 6}, {10, 5}, {10, 5}, {9, 5}, {9, 5}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {7, 4}, {7, 4}, {7, 4}, {7, 4}, //15
507 { 6, 4}, { 6, 4}, { 6, 4}, { 6, 4}, { 5, 4}, { 5, 4}, {5, 4}, {5, 4}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, //31
508 { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, {3, 3}, {3, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, //47
509 { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, { 1, 3}, {1, 3}, {1, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3} //63
510};
511
512const uint8_t g_kuiTotalZerosTable2[64][2] = //read 6 bits, generated by tzVlcIndex=3 in Table 9-7 in H.264/AVC standard
513{
514 {13, 6}, {11, 6}, {12, 5}, {12, 5}, {10, 5}, {10, 5}, {9, 5}, {9, 5}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {5, 4}, {5, 4}, {5, 4}, {5, 4}, //15
515 { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 0, 4}, { 0, 4}, {0, 4}, {0, 4}, {7, 3}, {7, 3}, {7, 3}, {7, 3}, {7, 3}, {7, 3}, {7, 3}, {7, 3}, //31
516 { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, {6, 3}, {6, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, //47
517 { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, {2, 3}, {2, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3} //63
518};
519
520const uint8_t g_kuiTotalZerosTable3[32][2] = //read 5 bits, generated by tzVlcIndex=4 in Table 9-7 in H.264/AVC standard
521{
522 {12, 5}, {11, 5}, {10, 5}, {0, 5}, {9, 4}, {9, 4}, {7, 4}, {7, 4}, {3, 4}, {3, 4}, {2, 4}, {2, 4}, {8, 3}, {8, 3}, {8, 3}, {8, 3}, //15
523 { 6, 3}, { 6, 3}, { 6, 3}, {6, 3}, {5, 3}, {5, 3}, {5, 3}, {5, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, //31
524};
525
526const uint8_t g_kuiTotalZerosTable4[32][2] = //read 5 bits, generated by tzVlcIndex=5 in Table 9-7 in H.264/AVC standard
527{
528 {11, 5}, { 9, 5}, {10, 4}, {10, 4}, { 8, 4}, { 8, 4}, { 2, 4}, { 2, 4}, { 1, 4}, { 1, 4}, { 0, 4}, { 0, 4}, { 7, 3}, { 7, 3}, { 7, 3}, { 7, 3}, //15
529 { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3} //31
530};
531
532const uint8_t g_kuiTotalZerosTable5[64][2] = //read 6 bits, generated by tzVlcIndex=6 in Table 9-7 in H.264/AVC standard
533{
534 {10, 6}, { 0, 6}, { 1, 5}, { 1, 5}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, //15
535 { 7, 3}, { 7, 3}, { 7, 3}, { 7, 3}, { 7, 3}, { 7, 3}, { 7, 3}, { 7, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, //31
536 { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 4, 3}, //47
537 { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3} //63
538};
539
540const uint8_t g_kuiTotalZerosTable6[64][2] = //read 6 bits, generated by tzVlcIndex=7 in Table 9-7 in H.264/AVC standard
541{
542 { 9, 6}, { 0, 6}, { 1, 5}, { 1, 5}, { 7, 4}, { 7, 4}, { 7, 4}, { 7, 4}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, //15
543 { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 4, 3}, { 4, 3}, //31
544 { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, //47
545 { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2} //63
546};
547
548const uint8_t g_kuiTotalZerosTable7[64][2] = //read 6 bits, generated by tzVlcIndex=8 in Table 9-7 in H.264/AVC standard
549{
550 { 8, 6}, { 0, 6}, { 2, 5}, { 2, 5}, { 1, 4}, { 1, 4}, { 1, 4}, { 1, 4}, { 7, 3}, { 7, 3}, { 7, 3}, { 7, 3}, { 7, 3}, { 7, 3}, { 7, 3}, { 7, 3}, //15
551 { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 6, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, { 3, 3}, //31
552 { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, //47
553 { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2} //63
554};
555
556const uint8_t g_kuiTotalZerosTable8[64][2] = //read 6 bits, generated by tzVlcIndex=9 in Table 9-7 in H.264/AVC standard
557{
558 { 1, 6}, { 0, 6}, { 7, 5}, { 7, 5}, { 2, 4}, { 2, 4}, { 2, 4}, { 2, 4}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, { 5, 3}, //15
559 { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, //31
560 { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, //47
561 { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2} //63
562};
563
564const uint8_t g_kuiTotalZerosTable9[32][2] = //read 5 bits, generated by tzVlcIndex=10 in Table 9-7 in H.264/AVC standard
565{
566 { 1, 5}, { 0, 5}, { 6, 4}, { 6, 4}, { 2, 3}, { 2, 3}, { 2, 3}, { 2, 3}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, { 5, 2}, //15
567 { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 4, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2}, { 3, 2} //31
568};
569
570const uint8_t g_kuiTotalZerosTable10[16][2] = //read 4 bits, generated by tzVlcIndex=11 in Table 9-7 in H.264/AVC standard
571{
572 { 0, 4}, { 1, 4}, { 2, 3}, { 2, 3}, { 3, 3}, { 3, 3}, { 5, 3}, { 5, 3}, { 4, 1}, { 4, 1}, { 4, 1}, { 4, 1}, { 4, 1}, { 4, 1}, { 4, 1}, { 4, 1} //15
573};
574
575const uint8_t g_kuiTotalZerosTable11[16][2] = //read 4 bits, generated by tzVlcIndex=12 in Table 9-7 in H.264/AVC standard
576{
577 { 0, 4}, { 1, 4}, { 4, 3}, { 4, 3}, { 2, 2}, { 2, 2}, { 2, 2}, { 2, 2}, { 3, 1}, { 3, 1}, { 3, 1}, { 3, 1}, { 3, 1}, { 3, 1}, { 3, 1}, { 3, 1} //15
578};
579
580const uint8_t g_kuiTotalZerosTable12[8][2] = //read 3 bits, generated by tzVlcIndex=13 in Table 9-7 in H.264/AVC standard
581{
582 { 0, 3}, { 1, 3}, { 3, 2}, { 3, 2}, { 2, 1}, { 2, 1}, { 2, 1}, { 2, 1} //8
583};
584
585const uint8_t g_kuiTotalZerosTable13[4][2] = //read 2 bits, generated by tzVlcIndex=14 in Table 9-7 in H.264/AVC standard
586{
587 { 0, 2}, { 1, 2}, { 2, 1}, { 2, 1}
588};
589
590const uint8_t g_kuiTotalZerosTable14[2][2] = //read 1 bits generated by tzVlcIndex=15 in Table 9-7 in H.264/AVC standard
591{
592 { 0, 1}, { 1, 1}
593};
594
595const uint8_t g_kuiTotalZerosBitNumMap[15] =
596{
597 9, 6, 6, 5, 5, 6, 6, 6, 6, 5, 4, 4, 3, 2, 1
598};
599
600
601const uint8_t g_kuiTotalZerosChromaTable0[8][2] = //read 3 bits, generated by tzVlcIndex=1 in Table 9-9(a) in H.264/AVC standard
602{
603 { 3, 3}, { 2, 3}, { 1, 2}, { 1, 2}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}
604};
605
606const uint8_t g_kuiTotalZerosChromaTable1[4][2] = //read 2 bits, generated by tzVlcIndex=2 in Table 9-9(a) in H.264/AVC standard
607{
608 { 2, 2}, { 1, 2}, { 0, 1}, { 0, 1}
609};
610
611const uint8_t g_kuiTotalZerosChromaTable2[2][2] = //read 1 bits, generated by tzVlcIndex=3 in Table 9-9(a) in H.264/AVC standard
612{
613 { 1, 1}, { 0, 1}
614};
615
616const uint8_t g_kuiTotalZerosBitNumChromaMap[3] =
617{
618 3, 2, 1
619};
620
621const uint8_t g_kuiZeroLeftTable0[2][2] = //read 1 bits
622{
623 {1, 1}, {0, 1}
624};
625
626const uint8_t g_kuiZeroLeftTable1[4][2] = //read 2 bits
627{
628 {2, 2}, {1, 2}, {0, 1}, {0, 1}
629};
630
631const uint8_t g_kuiZeroLeftTable2[4][2] = //read 2 bits
632{
633 {3, 2}, {2, 2}, {1, 2}, {0, 2}
634};
635
636const uint8_t g_kuiZeroLeftTable3[8][2] = //read 3 bits
637{
638 {4, 3}, {3, 3}, {2, 2}, {2, 2}, {1, 2}, {1, 2}, {0, 2}, {0, 2}
639};
640
641const uint8_t g_kuiZeroLeftTable4[8][2] = //read 3 bits
642{
643 {5, 3}, {4, 3}, {3, 3}, {2, 3}, {1, 2}, {1, 2}, {0, 2}, {0, 2}
644};
645
646const uint8_t g_kuiZeroLeftTable5[8][2] = //read 3 bits
647{
648 {1, 3}, {2, 3}, {4, 3}, {3, 3}, {6, 3}, {5, 3}, {0, 2}, {0, 2}
649};
650
651const uint8_t g_kuiZeroLeftTable6[8][2] = //read 3 bits
652{
653 {7, 3}, {6, 3}, {5, 3}, {4, 3}, {3, 3}, {2, 3}, {1, 3}, {0, 3}
654};
655
656const uint8_t g_kuiZeroLeftBitNumMap[16] =
657{
658 0, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
659};
660
661} // namespace WelsDec
codec/decoder/core/src/expand_pic.cpp+165−0
@@ -0,0 +1,165 @@
1/*!
2 * \copy
3 * Copyright (c) 2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 */
32
33#include <string.h>
34
35#include "typedefs.h"
36#include "expand_pic.h"
37#include "cpu_core.h"
38
39namespace WelsDec {
40
41// rewrite it (split into luma & chroma) that is helpful for mmx/sse2 optimization perform, 9/27/2009
42static inline void_t ExpandPictureLuma_c( uint8_t *pDst, const int32_t kiStride, const int32_t kiPicWidth, const int32_t kiPicHeight )
43{
44 uint8_t *pTmp = pDst;
45 uint8_t *pDstLastLine = pTmp + (kiPicHeight-1) * kiStride;
46 const int32_t kiPaddingLen = PADDING_LENGTH;
47 const uint8_t kuiTopLeft = pTmp[0];
48 const uint8_t kuiTopRight = pTmp[kiPicWidth-1];
49 const uint8_t kuiBottomLeft = pDstLastLine[0];
50 const uint8_t kuiBottomRight= pDstLastLine[kiPicWidth-1];
51 int32_t i = 0;
52
53 do {
54 const int32_t kiStrides = (1+i) * kiStride;
55 uint8_t* pTop = pTmp - kiStrides;
56 uint8_t* pBottom = pDstLastLine + kiStrides;
57
58 // pad pTop and pBottom
59 memcpy(pTop, pTmp, kiPicWidth);
60 memcpy(pBottom, pDstLastLine, kiPicWidth);
61
62 // pad corners
63 memset(pTop-kiPaddingLen, kuiTopLeft, kiPaddingLen); //pTop left
64 memset(pTop+kiPicWidth, kuiTopRight, kiPaddingLen); //pTop right
65 memset(pBottom-kiPaddingLen, kuiBottomLeft, kiPaddingLen); //pBottom left
66 memset(pBottom+kiPicWidth, kuiBottomRight, kiPaddingLen); //pBottom right
67
68 ++ i;
69 } while( i < kiPaddingLen );
70
71 // pad left and right
72 i = 0;
73 do {
74 memset(pTmp-kiPaddingLen, pTmp[0], kiPaddingLen);
75 memset(pTmp+kiPicWidth, pTmp[kiPicWidth-1], kiPaddingLen);
76
77 pTmp += kiStride;
78 ++ i;
79 } while( i < kiPicHeight );
80}
81
82static inline void_t ExpandPictureChroma_c( uint8_t *pDst, const int32_t kiStride, const int32_t kiPicWidth, const int32_t kiPicHeight )
83{
84 uint8_t *pTmp = pDst;
85 uint8_t *pDstLastLine = pTmp + (kiPicHeight-1) * kiStride;
86 const int32_t kiPaddingLen = (PADDING_LENGTH>>1);
87 const uint8_t kuiTopLeft = pTmp[0];
88 const uint8_t kuiTopRight = pTmp[kiPicWidth-1];
89 const uint8_t kuiBottomLeft = pDstLastLine[0];
90 const uint8_t kuiBottomRight= pDstLastLine[kiPicWidth-1];
91 int32_t i = 0;
92
93 do {
94 const int32_t kiStrides = (1+i) * kiStride;
95 uint8_t* pTop = pTmp - kiStrides;
96 uint8_t* pBottom = pDstLastLine + kiStrides;
97
98 // pad pTop and pBottom
99 memcpy(pTop, pTmp, kiPicWidth);
100 memcpy(pBottom, pDstLastLine, kiPicWidth);
101
102 // pad corners
103 memset(pTop-kiPaddingLen, kuiTopLeft, kiPaddingLen); //pTop left
104 memset(pTop+kiPicWidth, kuiTopRight, kiPaddingLen); //pTop right
105 memset(pBottom-kiPaddingLen, kuiBottomLeft, kiPaddingLen); //pBottom left
106 memset(pBottom+kiPicWidth, kuiBottomRight, kiPaddingLen); //pBottom right
107
108 ++ i;
109 } while( i < kiPaddingLen );
110
111 // pad left and right
112 i = 0;
113 do {
114 memset(pTmp-kiPaddingLen, pTmp[0], kiPaddingLen);
115 memset(pTmp+kiPicWidth, pTmp[kiPicWidth-1], kiPaddingLen);
116
117 pTmp += kiStride;
118 ++ i;
119 } while( i < kiPicHeight );
120}
121
122void_t InitExpandPictureFunc( SExpandPicFunc *pExpandPicFunc, const uint32_t kuiCpuFlags )
123{
124 pExpandPicFunc->pExpandLumaPicture = ExpandPictureLuma_c;
125 pExpandPicFunc->pExpandChromaPicture[0] = ExpandPictureChroma_c;
126 pExpandPicFunc->pExpandChromaPicture[1] = ExpandPictureChroma_c;
127
128#if defined(X86_ASM)
129 if ( (kuiCpuFlags & WELS_CPU_SSE2) == WELS_CPU_SSE2 )
130 {
131 pExpandPicFunc->pExpandLumaPicture = ExpandPictureLuma_sse2;
132 pExpandPicFunc->pExpandChromaPicture[0] = ExpandPictureChromaUnalign_sse2;
133 pExpandPicFunc->pExpandChromaPicture[1] = ExpandPictureChromaAlign_sse2;
134 }
135#endif//X86_ASM
136}
137
138void_t ExpandReferencingPicture(PPicture pPic, PExpandPictureFunc pExpLuma, PExpandPictureFunc pExpChroma[2])
139{
140 /*local variable*/
141 uint8_t *pPicY = pPic->pData[0];
142 uint8_t *pPicCb = pPic->pData[1];
143 uint8_t *pPicCr = pPic->pData[2];
144 const int32_t kiWidthY = pPic->iWidthInPixel;
145 const int32_t kiHeightY = pPic->iHeightInPixel;
146 const int32_t kiWidthUV = kiWidthY >> 1;
147 const int32_t kiHeightUV= kiHeightY >> 1;
148
149 pExpLuma(pPicY, pPic->iLinesize[0], kiWidthY, kiHeightY);
150 if ( kiWidthUV >= 16 )
151 {
152 // fix coding picture size as 16x16 issues 7/27/2010
153 const bool_t kbChrAligned= /*(kiWidthUV >= 16) && */((kiWidthUV & 0x0F) == 0); // chroma planes: (16+kiWidthUV) & 15
154 pExpChroma[kbChrAligned](pPicCb, pPic->iLinesize[1], kiWidthUV, kiHeightUV);
155 pExpChroma[kbChrAligned](pPicCr, pPic->iLinesize[2], kiWidthUV, kiHeightUV);
156 }
157 else
158 {
159 // fix coding picture size as 16x16 issues 7/27/2010
160 ExpandPictureChroma_c(pPicCb, pPic->iLinesize[1], kiWidthUV, kiHeightUV);
161 ExpandPictureChroma_c(pPicCr, pPic->iLinesize[2], kiWidthUV, kiHeightUV);
162 }
163}
164
165} // namespace WelsDec
codec/decoder/core/src/fmo.cpp+355−0
@@ -0,0 +1,355 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file fmo.c
33 *
34 * \brief Flexible Macroblock Ordering implementation
35 *
36 * \date 2/4/2009 Created
37 *
38 *************************************************************************************
39 */
40#include <string.h>
41
42#include "fmo.h"
43#include "macros.h"
44#include "utils.h"
45#include "mem_align.h"
46
47namespace WelsDec {
48
49/*!
50 * \brief Generate MB allocated map for interleaved slice group (TYPE 0)
51 *
52 * \param pFmo fmo context
53 * \param pPps pps context
54 *
55 * \return 0 - successful; none 0 - failed
56 */
57static inline int32_t FmoGenerateMbAllocMapType0( PFmo pFmo, PPps pPps )
58{
59 uint32_t uiNumSliceGroups = 0;
60 int32_t iMbNum = 0;
61 int32_t i = 0;
62
63 WELS_VERIFY_RETURN_IF( 1, ( NULL == pFmo || NULL == pPps ) )
64 uiNumSliceGroups = pPps->uiNumSliceGroups;
65 iMbNum = pFmo->iCountMbNum;
66 WELS_VERIFY_RETURN_IF( 1, ( NULL == pFmo->pMbAllocMap || iMbNum <= 0 || uiNumSliceGroups >= MAX_SLICEGROUP_IDS ) )
67
68 do
69 {
70 uint8_t uiGroup = 0;
71 do {
72 const int32_t kiRunIdx = pPps->uiRunLength[uiGroup];
73 int32_t j = 0;
74 do {
75 pFmo->pMbAllocMap[i+j] = uiGroup;
76 ++ j;
77 } while(j < kiRunIdx && i + j < iMbNum);
78 i += kiRunIdx;
79 ++ uiGroup;
80 } while(uiGroup < uiNumSliceGroups && i < iMbNum);
81 }while(i < iMbNum);
82
83 return 0; // well here
84}
85
86/*!
87 * \brief Generate MB allocated map for dispersed slice group (TYPE 1)
88 *
89 * \param pFmo fmo context
90 * \param pPps pps context
91 * \param iMbWidth MB width
92 *
93 * \return 0 - successful; none 0 - failed
94 */
95static inline int32_t FmoGenerateMbAllocMapType1( PFmo pFmo, PPps pPps, const int32_t kiMbWidth )
96{
97 uint32_t uiNumSliceGroups = 0;
98 int32_t iMbNum = 0;
99 int16_t i = 0;
100 WELS_VERIFY_RETURN_IF( 1, ( NULL == pFmo || NULL == pPps ) )
101 uiNumSliceGroups = pPps->uiNumSliceGroups;
102 iMbNum = pFmo->iCountMbNum;
103 WELS_VERIFY_RETURN_IF( 1, ( NULL == pFmo->pMbAllocMap || iMbNum <= 0 || kiMbWidth == 0 || uiNumSliceGroups >= MAX_SLICEGROUP_IDS ) )
104
105 do
106 {
107 pFmo->pMbAllocMap[i] = (uint8_t)(((i % kiMbWidth)+(((i / kiMbWidth)*uiNumSliceGroups)>>1)) % uiNumSliceGroups);
108 ++ i;
109 }while (i < iMbNum);
110
111 return 0; // well here
112}
113
114/*!
115 * \brief Generate MB allocated map for various type of slice group cases (TYPE 0, .., 6)
116 *
117 * \param pFmo fmo context
118 * \param pPps pps context
119 * \param kiMbWidth MB width
120 * \param kiMbHeight MB height
121 *
122 * \return 0 - successful; none 0 - failed
123 */
124static inline int32_t FmoGenerateSliceGroup( PFmo pFmo, const PPps kpPps, const int32_t kiMbWidth, const int32_t kiMbHeight )
125{
126 int32_t iNumMb = 0;
127 int32_t iErr = 0;
128 bool_t bResolutionChanged = false;
129
130 // the cases we would not like
131 WELS_VERIFY_RETURN_IF( 1, ( NULL == pFmo || NULL == kpPps ) )
132
133 iNumMb = pFmo->iCountMbNum;
134
135 iNumMb = kiMbWidth * kiMbHeight;
136
137 if ( 0 == iNumMb )
138 return 1;
139
140
141 WelsFree(pFmo->pMbAllocMap, "_fmo->pMbAllocMap");
142 pFmo->pMbAllocMap = (uint8_t *)WelsMalloc( iNumMb * sizeof(uint8_t), "_fmo->pMbAllocMap" );
143 WELS_VERIFY_RETURN_IF( 1, (NULL == pFmo->pMbAllocMap) ) // out of memory
144
145 pFmo->iCountMbNum = iNumMb;
146
147 if ( kpPps->uiNumSliceGroups < 2 && iNumMb > 0) // only one slice group, exactly it is single slice based
148 {
149 memset ( pFmo->pMbAllocMap, 0, iNumMb * sizeof(int8_t)); // for safe
150
151 pFmo->iSliceGroupCount = 1;
152
153 return 0;
154 }
155
156 if ( bResolutionChanged || ((int32_t)kpPps->uiSliceGroupMapType != pFmo->iSliceGroupType)
157 || ((int32_t)kpPps->uiNumSliceGroups != pFmo->iSliceGroupCount) )
158 {
159 switch ( kpPps->uiSliceGroupMapType )
160 {
161 case 0:
162 iErr = FmoGenerateMbAllocMapType0( pFmo, kpPps );
163 break;
164 case 1:
165 iErr = FmoGenerateMbAllocMapType1( pFmo, kpPps, kiMbWidth );
166 break;
167 case 2:
168 case 3:
169 case 4:
170 case 5:
171 case 6:
172 // Reserve for others slice group type
173 iErr = 1;
174 break;
175 default:
176 return 1;
177 }
178 }
179
180 if ( 0 == iErr ) // well now
181 {
182 pFmo->iSliceGroupCount = kpPps->uiNumSliceGroups;
183 pFmo->iSliceGroupType = kpPps->uiSliceGroupMapType;
184 }
185
186 return iErr;
187}
188
189/*!
190 * \brief Initialize Wels Flexible Macroblock Ordering (FMO)
191 *
192 * \param pFmo Wels fmo to be initialized
193 * \param pPps pps argument
194 * \param kiMbWidth mb width
195 * \param kiMbHeight mb height
196 *
197 * \return 0 - successful; none 0 - failed;
198 */
199int32_t InitFmo( PFmo pFmo, PPps pPps, const int32_t kiMbWidth, const int32_t kiMbHeight )
200{
201 return FmoGenerateSliceGroup( pFmo, pPps, kiMbWidth, kiMbHeight );
202}
203
204
205/*!
206 * \brief Uninitialize Wels Flexible Macroblock Ordering (FMO) list
207 *
208 * \param pFmo Wels base fmo ptr to be uninitialized
209 * \param kiCnt count number of PPS per list
210 * \param kiAvail count available number of PPS in list
211 *
212 * \return NONE
213 */
214void_t UninitFmoList( PFmo pFmo, const int32_t kiCnt, const int32_t kiAvail )
215{
216 PFmo pIter = pFmo;
217 int32_t i = 0;
218 int32_t iFreeNodes = 0;
219
220 if ( NULL == pIter || kiAvail <= 0 || kiCnt < kiAvail )
221 return;
222
223 while ( i < kiCnt ) {
224 if ( pIter != NULL && pIter->bActiveFlag )
225 {
226 if ( NULL != pIter->pMbAllocMap )
227 {
228 WelsFree( pIter->pMbAllocMap, "pIter->pMbAllocMap" );
229
230 pIter->pMbAllocMap = NULL;
231 }
232 pIter->iSliceGroupCount = 0;
233 pIter->iSliceGroupType = -1;
234 pIter->iCountMbNum = 0;
235 pIter->bActiveFlag = false;
236 ++ iFreeNodes;
237 if ( iFreeNodes >= kiAvail )
238 break;
239 }
240 ++ pIter;
241 ++ i;
242 }
243}
244
245/*!
246 * \brief detect parameter sets are changed or not
247 *
248 * \param pFmo fmo context
249 * \param kiCountNumMb (iMbWidth * iMbHeight) in Sps
250 * \param iSliceGroupType slice group type if fmo is exactly enabled
251 * \param iSliceGroupCount slice group count if fmo is exactly enabled
252 *
253 * \return true - changed or not initialized yet; false - not change at all
254 */
255bool_t FmoParamSetsChanged( PFmo pFmo, const int32_t kiCountNumMb, const int32_t kiSliceGroupType, const int32_t kiSliceGroupCount )
256{
257 WELS_VERIFY_RETURN_IF( false, (NULL == pFmo) )
258
259 return ( (!pFmo->bActiveFlag)
260 || (kiCountNumMb != pFmo->iCountMbNum)
261 || (kiSliceGroupType != pFmo->iSliceGroupType)
262 || (kiSliceGroupCount != pFmo->iSliceGroupCount) );
263}
264
265/*!
266 * \brief update/insert FMO parameter unit
267 *
268 * \param _fmo FMO context
269 * \param _sps PSps
270 * \param _pps PPps
271 * \param pActiveFmoNum int32_t* [in/out]
272 *
273 * \return true - update/insert successfully; false - failed;
274 */
275bool_t FmoParamUpdate( PFmo pFmo, PSps pSps, PPps pPps, int32_t *pActiveFmoNum )
276{
277 const uint32_t kuiMbWidth = pSps->iMbWidth;
278 const uint32_t kuiMbHeight= pSps->iMbHeight;
279
280 if ( FmoParamSetsChanged( pFmo,
281 kuiMbWidth * kuiMbHeight,
282 pPps->uiSliceGroupMapType,
283 pPps->uiNumSliceGroups ) )
284 {
285
286 if ( InitFmo( pFmo, pPps, kuiMbWidth, kuiMbHeight ) )
287 {
288 return false;
289 }
290 else
291 {
292 if ( !pFmo->bActiveFlag && *pActiveFmoNum < MAX_PPS_COUNT )
293 {
294 ++ (*pActiveFmoNum);
295 pFmo->bActiveFlag = true;
296 }
297 }
298 }
299
300 return true;
301}
302
303/*!
304 * \brief Convert kMbXy to slice group idc correspondingly
305 *
306 * \param pFmo Wels fmo context
307 * \param kMbXy kMbXy to be converted
308 *
309 * \return slice group idc - successful; -1 - failed;
310 */
311int32_t FmoMbToSliceGroup( PFmo pFmo, const MB_XY_T kiMbXy )
312{
313 const int32_t kiMbNum = pFmo->iCountMbNum;
314 const uint8_t* kpMbMap = pFmo->pMbAllocMap;
315
316 if ( kiMbXy < 0 || kiMbXy >= kiMbNum || kpMbMap == NULL)
317 return -1;
318
319 return kpMbMap[ kiMbXy ];
320}
321
322/*!
323 * \brief Get successive mb to be processed with given current kMbXy
324 *
325 * \param pFmo Wels fmo context
326 * \param kMbXy current kMbXy
327 *
328 * \return iNextMb - successful; -1 - failed;
329 */
330MB_XY_T FmoNextMb( PFmo pFmo, const MB_XY_T kiMbXy )
331{
332 const int32_t kiTotalMb = pFmo->iCountMbNum;
333 const uint8_t* kpMbMap = pFmo->pMbAllocMap;
334 MB_XY_T iNextMb = kiMbXy;
335 const uint8_t kuiSliceGroupIdc = (uint8_t)FmoMbToSliceGroup( pFmo, kiMbXy );
336
337 if (kuiSliceGroupIdc == (uint8_t)(-1))
338 return -1;
339
340 do {
341 ++ iNextMb;
342 if (iNextMb >= kiTotalMb){
343 iNextMb = -1;
344 break;
345 }
346 if (kpMbMap[iNextMb] == kuiSliceGroupIdc){
347 break;
348 }
349 } while( 1 );
350
351 // -1: No further MB in this slice (could be end of picture)
352 return iNextMb;
353}
354
355} // namespace WelsDec
codec/decoder/core/src/get_intra_predictor.cpp+700−0
@@ -0,0 +1,700 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file get_intra_predictor.c
33 *
34 * \brief implementation for get intra predictor about 16x16, 4x4, chroma.
35 *
36 * \date 4/2/2009 Created
37 * 9/14/2009 C level based optimization with high performance gained.
38 * [const, using ST32/ST64 to replace memset, memcpy and memmove etc.]
39 *
40 *************************************************************************************
41 */
42#include <string.h>
43
44#include "macros.h"
45#include "ls_defines.h"
46#include "get_intra_predictor.h"
47
48namespace WelsDec {
49
50#define I4x4_COUNT 4
51#define I8x8_COUNT 8
52#define I16x16_COUNT 16
53
54void_t WelsI4x4LumaPredV_c(uint8_t *pPred, const int32_t kiStride)
55{
56 const uint32_t kuiVal = LD32(pPred-kiStride);
57
58 ST32( pPred , kuiVal );
59 ST32( pPred+kiStride , kuiVal );
60 ST32( pPred+(kiStride<<1) , kuiVal );
61 ST32( pPred+(kiStride<<1)+kiStride , kuiVal );
62}
63
64void_t WelsI4x4LumaPredH_c(uint8_t *pPred, const int32_t kiStride)
65{
66 const int32_t kiStride2 = kiStride << 1;
67 const int32_t kiStride3 = kiStride2 + kiStride;
68 const uint32_t kuiL0 = 0x01010101U * pPred[-1 ];
69 const uint32_t kuiL1 = 0x01010101U * pPred[-1+kiStride ];
70 const uint32_t kuiL2 = 0x01010101U * pPred[-1+kiStride2];
71 const uint32_t kuiL3 = 0x01010101U * pPred[-1+kiStride3];
72
73 ST32( pPred , kuiL0 );
74 ST32( pPred+kiStride , kuiL1 );
75 ST32( pPred+kiStride2, kuiL2 );
76 ST32( pPred+kiStride3, kuiL3 );
77}
78
79void_t WelsI4x4LumaPredDc_c(uint8_t *pPred, const int32_t kiStride)
80{
81 const int32_t kiStride2 = kiStride << 1;
82 const int32_t kiStride3 = kiStride2 + kiStride;
83 const uint8_t kuiMean = ( pPred[-1] + pPred[-1+kiStride] + pPred[-1+kiStride2] + pPred[-1+kiStride3] +
84 pPred[-kiStride] + pPred[-kiStride+1] + pPred[-kiStride+2] + pPred[-kiStride+3] + 4 ) >> 3;
85 const uint32_t kuiMean32= 0x01010101U * kuiMean;
86
87 ST32( pPred , kuiMean32 );
88 ST32( pPred+kiStride , kuiMean32 );
89 ST32( pPred+kiStride2, kuiMean32 );
90 ST32( pPred+kiStride3, kuiMean32 );
91}
92
93void_t WelsI4x4LumaPredDcLeft_c(uint8_t *pPred, const int32_t kiStride)
94{
95 const int32_t kiStride2 = kiStride << 1;
96 const int32_t kiStride3 = kiStride2 + kiStride;
97 const uint8_t kuiMean = ( pPred[-1] + pPred[-1+kiStride] + pPred[-1+kiStride2] + pPred[-1+kiStride3] + 2 ) >> 2;
98 const uint32_t kuiMean32= 0x01010101U * kuiMean;
99
100 ST32( pPred , kuiMean32 );
101 ST32( pPred+kiStride , kuiMean32 );
102 ST32( pPred+kiStride2, kuiMean32 );
103 ST32( pPred+kiStride3, kuiMean32 );
104}
105
106void_t WelsI4x4LumaPredDcTop_c(uint8_t *pPred, const int32_t kiStride)
107{
108 const int32_t kiStride2 = kiStride << 1;
109 const int32_t kiStride3 = kiStride2 + kiStride;
110 const uint8_t kuiMean = (pPred[-kiStride] + pPred[-kiStride+1] + pPred[-kiStride+2] + pPred[-kiStride+3] + 2) >> 2;
111 const uint32_t kuiMean32= 0x01010101U * kuiMean;
112
113 ST32( pPred , kuiMean32 );
114 ST32( pPred+kiStride , kuiMean32 );
115 ST32( pPred+kiStride2, kuiMean32 );
116 ST32( pPred+kiStride3, kuiMean32 );
117}
118
119void_t WelsI4x4LumaPredDcNA_c(uint8_t *pPred, const int32_t kiStride)
120{
121 const uint32_t kuiDC32 = 0x80808080U;
122
123 ST32( pPred , kuiDC32 );
124 ST32( pPred+kiStride , kuiDC32 );
125 ST32( pPred+(kiStride<<1) , kuiDC32 );
126 ST32( pPred+(kiStride<<1)+kiStride, kuiDC32 );
127}
128
129/*down pLeft*/
130void_t WelsI4x4LumaPredDDL_c(uint8_t *pPred, const int32_t kiStride)
131{
132 const int32_t kiStride2 = kiStride<<1;
133 const int32_t kiStride3 = kiStride + kiStride2;
134 /*get pTop*/
135 uint8_t *ptop = &pPred[-kiStride];
136 const uint8_t kuiT0 = *ptop;
137 const uint8_t kuiT1 = *(ptop+1);
138 const uint8_t kuiT2 = *(ptop+2);
139 const uint8_t kuiT3 = *(ptop+3);
140 const uint8_t kuiT4 = *(ptop+4);
141 const uint8_t kuiT5 = *(ptop+5);
142 const uint8_t kuiT6 = *(ptop+6);
143 const uint8_t kuiT7 = *(ptop+7);
144 const uint8_t kuiDDL0 = (2 + kuiT0 + kuiT2 + (kuiT1<<1))>>2; // kDDL0
145 const uint8_t kuiDDL1 = (2 + kuiT1 + kuiT3 + (kuiT2<<1))>>2; // kDDL1
146 const uint8_t kuiDDL2 = (2 + kuiT2 + kuiT4 + (kuiT3<<1))>>2; // kDDL2
147 const uint8_t kuiDDL3 = (2 + kuiT3 + kuiT5 + (kuiT4<<1))>>2; // kDDL3
148 const uint8_t kuiDDL4 = (2 + kuiT4 + kuiT6 + (kuiT5<<1))>>2; // kDDL4
149 const uint8_t kuiDDL5 = (2 + kuiT5 + kuiT7 + (kuiT6<<1))>>2; // kDDL5
150 const uint8_t kuiDDL6 = (2 + kuiT6 + kuiT7 + (kuiT7<<1))>>2; // kDDL6
151 const uint8_t kuiList[8]= { kuiDDL0, kuiDDL1, kuiDDL2, kuiDDL3, kuiDDL4, kuiDDL5, kuiDDL6, 0 };
152
153 ST32( pPred , LD32(kuiList ) );
154 ST32( pPred+kiStride , LD32(kuiList+1) );
155 ST32( pPred+kiStride2, LD32(kuiList+2) );
156 ST32( pPred+kiStride3, LD32(kuiList+3) );
157}
158
159/*down pLeft*/
160void_t WelsI4x4LumaPredDDLTop_c(uint8_t *pPred, const int32_t kiStride)
161{
162 const int32_t kiStride2 = kiStride<<1;
163 const int32_t kiStride3 = kiStride + kiStride2;
164 /*get pTop*/
165 uint8_t *ptop = &pPred[-kiStride];
166 const uint8_t kuiT0 = *ptop;
167 const uint8_t kuiT1 = *(ptop+1);
168 const uint8_t kuiT2 = *(ptop+2);
169 const uint8_t kuiT3 = *(ptop+3);
170 const uint16_t kuiT01 = 1 + kuiT0 + kuiT1;
171 const uint16_t kuiT12 = 1 + kuiT1 + kuiT2;
172 const uint16_t kuiT23 = 1 + kuiT2 + kuiT3;
173 const uint16_t kuiT33 = 1 + (kuiT3 << 1);
174 const uint8_t kuiDLT0 = (kuiT01 + kuiT12) >> 2; // kDLT0
175 const uint8_t kuiDLT1 = (kuiT12 + kuiT23) >> 2; // kDLT1
176 const uint8_t kuiDLT2 = (kuiT23 + kuiT33) >> 2; // kDLT2
177 const uint8_t kuiDLT3 = kuiT33 >> 1; // kDLT3
178 const uint8_t kuiList[8]= { kuiDLT0, kuiDLT1, kuiDLT2, kuiDLT3, kuiDLT3, kuiDLT3, kuiDLT3 ,kuiDLT3 };
179
180 ST32( pPred, LD32(kuiList ) );
181 ST32( pPred+kiStride, LD32(kuiList+1) );
182 ST32( pPred+kiStride2, LD32(kuiList+2) );
183 ST32( pPred+kiStride3, LD32(kuiList+3) );
184}
185
186
187/*down right*/
188void_t WelsI4x4LumaPredDDR_c(uint8_t *pPred, const int32_t kiStride)
189{
190 const int32_t kiStride2 = kiStride<<1;
191 const int32_t kiStride3 = kiStride + kiStride2;
192 uint8_t *ptopleft = &pPred[-(kiStride+1)];
193 uint8_t *pleft = &pPred[-1];
194 const uint8_t kuiLT = *ptopleft;
195 /*get pLeft and pTop*/
196 const uint8_t kuiL0 = *pleft;
197 const uint8_t kuiL1 = *(pleft+kiStride );
198 const uint8_t kuiL2 = *(pleft+kiStride2);
199 const uint8_t kuiL3 = *(pleft+kiStride3);
200 const uint8_t kuiT0 = *(ptopleft+1);
201 const uint8_t kuiT1 = *(ptopleft+2);
202 const uint8_t kuiT2 = *(ptopleft+3);
203 const uint8_t kuiT3 = *(ptopleft+4);
204 const uint16_t kuiTL0 = 1 + kuiLT + kuiL0;
205 const uint16_t kuiLT0 = 1 + kuiLT + kuiT0;
206 const uint16_t kuiT01 = 1 + kuiT0 + kuiT1;
207 const uint16_t kuiT12 = 1 + kuiT1 + kuiT2;
208 const uint16_t kuiT23 = 1 + kuiT2 + kuiT3;
209 const uint16_t kuiL01 = 1 + kuiL0 + kuiL1;
210 const uint16_t kuiL12 = 1 + kuiL1 + kuiL2;
211 const uint16_t kuiL23 = 1 + kuiL2 + kuiL3;
212 const uint8_t kuiDDR0 = (kuiTL0 + kuiLT0) >> 2; // kuiDDR0
213 const uint8_t kuiDDR1 = (kuiLT0 + kuiT01) >> 2; // kuiDDR1
214 const uint8_t kuiDDR2 = (kuiT01 + kuiT12) >> 2; // kuiDDR2
215 const uint8_t kuiDDR3 = (kuiT12 + kuiT23) >> 2; // kuiDDR3
216 const uint8_t kuiDDR4 = (kuiTL0 + kuiL01) >> 2; // kuiDDR4
217 const uint8_t kuiDDR5 = (kuiL01 + kuiL12) >> 2; // kuiDDR5
218 const uint8_t kuiDDR6 = (kuiL12 + kuiL23) >> 2; // kuiDDR6
219 const uint8_t kuiList[8]= { kuiDDR6, kuiDDR5, kuiDDR4, kuiDDR0, kuiDDR1, kuiDDR2, kuiDDR3, 0 };
220
221 ST32( pPred , LD32(kuiList+3) );
222 ST32( pPred+kiStride , LD32(kuiList+2) );
223 ST32( pPred+kiStride2, LD32(kuiList+1) );
224 ST32( pPred+kiStride3, LD32(kuiList ) );
225}
226
227
228/*vertical pLeft*/
229void_t WelsI4x4LumaPredVL_c(uint8_t *pPred, const int32_t kiStride)
230{
231 const int32_t kiStride2 = kiStride<<1;
232 const int32_t kiStride3 = kiStride + kiStride2;
233 uint8_t *ptopleft = &pPred[-(kiStride+1)];

467 more lines aren’t shown here.

codec/decoder/core/src/manage_dec_ref.cpp+575−0

This diff is large: its 576 lines aren’t shown here.

codec/decoder/core/src/mc.cpp+757−0

This diff is large: its 758 lines aren’t shown here.

codec/decoder/core/src/mem_align.cpp+115−0

This diff is large: its 116 lines aren’t shown here.

codec/decoder/core/src/memmgr_nal_unit.cpp+153−0

This diff is large: its 154 lines aren’t shown here.

codec/decoder/core/src/mv_pred.cpp+251−0

This diff is large: its 252 lines aren’t shown here.

codec/decoder/core/src/parse_mb_syn_cavlc.cpp+1627−0

This diff is large: its 1628 lines aren’t shown here.

codec/decoder/core/src/pic_queue.cpp+166−0

This diff is large: its 167 lines aren’t shown here.

codec/decoder/core/src/rec_mb.cpp+589−0

This diff is large: its 590 lines aren’t shown here.

codec/decoder/core/src/utils.cpp+307−0

This diff is large: its 308 lines aren’t shown here.

codec/decoder/plus/inc/StdAfx.h+56−0

This diff is large: its 57 lines aren’t shown here.

codec/decoder/plus/inc/welsCodecTrace.h+172−0

This diff is large: its 173 lines aren’t shown here.

codec/decoder/plus/inc/welsDecoderExt.h+121−0

This diff is large: its 122 lines aren’t shown here.

codec/decoder/plus/res/resource.h+15−0

This diff is large: its 16 lines aren’t shown here.

codec/decoder/plus/res/welsdec.aps+0−0

Binary file not shown.

codec/decoder/plus/res/welsdec.rc+115−0

This diff is large: its 116 lines aren’t shown here.

codec/decoder/plus/src/StdAfx.cpp+40−0

This diff is large: its 41 lines aren’t shown here.

codec/decoder/plus/src/welsCodecTrace.cpp+419−0

This diff is large: its 420 lines aren’t shown here.

codec/decoder/plus/src/welsDecoderExt.cpp+532−0

This diff is large: its 533 lines aren’t shown here.

codec/decoder/plus/src/wels_dec_export.def+3−0

This diff is large: its 4 lines aren’t shown here.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t