Line data Source code
1 : /********************************************************************
2 : * *
3 : * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE. *
4 : * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
5 : * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
6 : * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
7 : * *
8 : * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2009 *
9 : * by the Xiph.Org Foundation and contributors http://www.xiph.org/ *
10 : * *
11 : ********************************************************************
12 :
13 : function:
14 : last mod: $Id: decode.c 17576 2010-10-29 01:07:51Z tterribe $
15 :
16 : ********************************************************************/
17 :
18 : #include <stdlib.h>
19 : #include <string.h>
20 : #include <ogg/ogg.h>
21 : #include "decint.h"
22 : #if defined(OC_DUMP_IMAGES)
23 : # include <stdio.h>
24 : # include "png.h"
25 : #endif
26 : #if defined(HAVE_CAIRO)
27 : # include <cairo.h>
28 : #endif
29 :
30 :
31 : /*No post-processing.*/
32 : #define OC_PP_LEVEL_DISABLED (0)
33 : /*Keep track of DC qi for each block only.*/
34 : #define OC_PP_LEVEL_TRACKDCQI (1)
35 : /*Deblock the luma plane.*/
36 : #define OC_PP_LEVEL_DEBLOCKY (2)
37 : /*Dering the luma plane.*/
38 : #define OC_PP_LEVEL_DERINGY (3)
39 : /*Stronger luma plane deringing.*/
40 : #define OC_PP_LEVEL_SDERINGY (4)
41 : /*Deblock the chroma planes.*/
42 : #define OC_PP_LEVEL_DEBLOCKC (5)
43 : /*Dering the chroma planes.*/
44 : #define OC_PP_LEVEL_DERINGC (6)
45 : /*Stronger chroma plane deringing.*/
46 : #define OC_PP_LEVEL_SDERINGC (7)
47 : /*Maximum valid post-processing level.*/
48 : #define OC_PP_LEVEL_MAX (7)
49 :
50 :
51 :
52 : /*The mode alphabets for the various mode coding schemes.
53 : Scheme 0 uses a custom alphabet, which is not stored in this table.*/
54 : static const unsigned char OC_MODE_ALPHABETS[7][OC_NMODES]={
55 : /*Last MV dominates */
56 : {
57 : OC_MODE_INTER_MV_LAST,OC_MODE_INTER_MV_LAST2,OC_MODE_INTER_MV,
58 : OC_MODE_INTER_NOMV,OC_MODE_INTRA,OC_MODE_GOLDEN_NOMV,OC_MODE_GOLDEN_MV,
59 : OC_MODE_INTER_MV_FOUR
60 : },
61 : {
62 : OC_MODE_INTER_MV_LAST,OC_MODE_INTER_MV_LAST2,OC_MODE_INTER_NOMV,
63 : OC_MODE_INTER_MV,OC_MODE_INTRA,OC_MODE_GOLDEN_NOMV,OC_MODE_GOLDEN_MV,
64 : OC_MODE_INTER_MV_FOUR
65 : },
66 : {
67 : OC_MODE_INTER_MV_LAST,OC_MODE_INTER_MV,OC_MODE_INTER_MV_LAST2,
68 : OC_MODE_INTER_NOMV,OC_MODE_INTRA,OC_MODE_GOLDEN_NOMV,OC_MODE_GOLDEN_MV,
69 : OC_MODE_INTER_MV_FOUR
70 : },
71 : {
72 : OC_MODE_INTER_MV_LAST,OC_MODE_INTER_MV,OC_MODE_INTER_NOMV,
73 : OC_MODE_INTER_MV_LAST2,OC_MODE_INTRA,OC_MODE_GOLDEN_NOMV,
74 : OC_MODE_GOLDEN_MV,OC_MODE_INTER_MV_FOUR
75 : },
76 : /*No MV dominates.*/
77 : {
78 : OC_MODE_INTER_NOMV,OC_MODE_INTER_MV_LAST,OC_MODE_INTER_MV_LAST2,
79 : OC_MODE_INTER_MV,OC_MODE_INTRA,OC_MODE_GOLDEN_NOMV,OC_MODE_GOLDEN_MV,
80 : OC_MODE_INTER_MV_FOUR
81 : },
82 : {
83 : OC_MODE_INTER_NOMV,OC_MODE_GOLDEN_NOMV,OC_MODE_INTER_MV_LAST,
84 : OC_MODE_INTER_MV_LAST2,OC_MODE_INTER_MV,OC_MODE_INTRA,OC_MODE_GOLDEN_MV,
85 : OC_MODE_INTER_MV_FOUR
86 : },
87 : /*Default ordering.*/
88 : {
89 : OC_MODE_INTER_NOMV,OC_MODE_INTRA,OC_MODE_INTER_MV,OC_MODE_INTER_MV_LAST,
90 : OC_MODE_INTER_MV_LAST2,OC_MODE_GOLDEN_NOMV,OC_MODE_GOLDEN_MV,
91 : OC_MODE_INTER_MV_FOUR
92 : }
93 : };
94 :
95 :
96 : /*The original DCT tokens are extended and reordered during the construction of
97 : the Huffman tables.
98 : The extension means more bits can be read with fewer calls to the bitpacker
99 : during the Huffman decoding process (at the cost of larger Huffman tables),
100 : and fewer tokens require additional extra bits (reducing the average storage
101 : per decoded token).
102 : The revised ordering reveals essential information in the token value
103 : itself; specifically, whether or not there are additional extra bits to read
104 : and the parameter to which those extra bits are applied.
105 : The token is used to fetch a code word from the OC_DCT_CODE_WORD table below.
106 : The extra bits are added into code word at the bit position inferred from the
107 : token value, giving the final code word from which all required parameters
108 : are derived.
109 : The number of EOBs and the leading zero run length can be extracted directly.
110 : The coefficient magnitude is optionally negated before extraction, according
111 : to a 'flip' bit.*/
112 :
113 : /*The number of additional extra bits that are decoded with each of the
114 : internal DCT tokens.*/
115 : static const unsigned char OC_INTERNAL_DCT_TOKEN_EXTRA_BITS[15]={
116 : 12,4,3,3,4,4,5,5,8,8,8,8,3,3,6
117 : };
118 :
119 : /*Whether or not an internal token needs any additional extra bits.*/
120 : #define OC_DCT_TOKEN_NEEDS_MORE(token) \
121 : (token<(int)(sizeof(OC_INTERNAL_DCT_TOKEN_EXTRA_BITS)/ \
122 : sizeof(*OC_INTERNAL_DCT_TOKEN_EXTRA_BITS)))
123 :
124 : /*This token (OC_DCT_REPEAT_RUN3_TOKEN) requires more than 8 extra bits.*/
125 : #define OC_DCT_TOKEN_FAT_EOB (0)
126 :
127 : /*The number of EOBs to use for an end-of-frame token.
128 : Note: We want to set eobs to PTRDIFF_MAX here, but that requires C99, which
129 : is not yet available everywhere; this should be equivalent.*/
130 : #define OC_DCT_EOB_FINISH (~(size_t)0>>1)
131 :
132 : /*The location of the (6) run length bits in the code word.
133 : These are placed at index 0 and given 8 bits (even though 6 would suffice)
134 : because it may be faster to extract the lower byte on some platforms.*/
135 : #define OC_DCT_CW_RLEN_SHIFT (0)
136 : /*The location of the (12) EOB bits in the code word.*/
137 : #define OC_DCT_CW_EOB_SHIFT (8)
138 : /*The location of the (1) flip bit in the code word.
139 : This must be right under the magnitude bits.*/
140 : #define OC_DCT_CW_FLIP_BIT (20)
141 : /*The location of the (11) token magnitude bits in the code word.
142 : These must be last, and rely on a sign-extending right shift.*/
143 : #define OC_DCT_CW_MAG_SHIFT (21)
144 :
145 : /*Pack the given fields into a code word.*/
146 : #define OC_DCT_CW_PACK(_eobs,_rlen,_mag,_flip) \
147 : ((_eobs)<<OC_DCT_CW_EOB_SHIFT| \
148 : (_rlen)<<OC_DCT_CW_RLEN_SHIFT| \
149 : (_flip)<<OC_DCT_CW_FLIP_BIT| \
150 : (_mag)-(_flip)<<OC_DCT_CW_MAG_SHIFT)
151 :
152 : /*A special code word value that signals the end of the frame (a long EOB run
153 : of zero).*/
154 : #define OC_DCT_CW_FINISH (0)
155 :
156 : /*The position at which to insert the extra bits in the code word.
157 : We use this formulation because Intel has no useful cmov.
158 : A real architecture would probably do better with two of those.
159 : This translates to 11 instructions(!), and is _still_ faster than either a
160 : table lookup (just barely) or the naive double-ternary implementation (which
161 : gcc translates to a jump and a cmov).
162 : This assumes OC_DCT_CW_RLEN_SHIFT is zero, but could easily be reworked if
163 : you want to make one of the other shifts zero.*/
164 : #define OC_DCT_TOKEN_EB_POS(_token) \
165 : ((OC_DCT_CW_EOB_SHIFT-OC_DCT_CW_MAG_SHIFT&-((_token)<2)) \
166 : +(OC_DCT_CW_MAG_SHIFT&-((_token)<12)))
167 :
168 : /*The code words for each internal token.
169 : See the notes at OC_DCT_TOKEN_MAP for the reasons why things are out of
170 : order.*/
171 : static const ogg_int32_t OC_DCT_CODE_WORD[92]={
172 : /*These tokens require additional extra bits for the EOB count.*/
173 : /*OC_DCT_REPEAT_RUN3_TOKEN (12 extra bits)*/
174 : OC_DCT_CW_FINISH,
175 : /*OC_DCT_REPEAT_RUN2_TOKEN (4 extra bits)*/
176 : OC_DCT_CW_PACK(16, 0, 0,0),
177 : /*These tokens require additional extra bits for the magnitude.*/
178 : /*OC_DCT_VAL_CAT5 (4 extra bits-1 already read)*/
179 : OC_DCT_CW_PACK( 0, 0, 13,0),
180 : OC_DCT_CW_PACK( 0, 0, 13,1),
181 : /*OC_DCT_VAL_CAT6 (5 extra bits-1 already read)*/
182 : OC_DCT_CW_PACK( 0, 0, 21,0),
183 : OC_DCT_CW_PACK( 0, 0, 21,1),
184 : /*OC_DCT_VAL_CAT7 (6 extra bits-1 already read)*/
185 : OC_DCT_CW_PACK( 0, 0, 37,0),
186 : OC_DCT_CW_PACK( 0, 0, 37,1),
187 : /*OC_DCT_VAL_CAT8 (10 extra bits-2 already read)*/
188 : OC_DCT_CW_PACK( 0, 0, 69,0),
189 : OC_DCT_CW_PACK( 0, 0,325,0),
190 : OC_DCT_CW_PACK( 0, 0, 69,1),
191 : OC_DCT_CW_PACK( 0, 0,325,1),
192 : /*These tokens require additional extra bits for the run length.*/
193 : /*OC_DCT_RUN_CAT1C (4 extra bits-1 already read)*/
194 : OC_DCT_CW_PACK( 0,10, +1,0),
195 : OC_DCT_CW_PACK( 0,10, -1,0),
196 : /*OC_DCT_ZRL_TOKEN (6 extra bits)
197 : Flip is set to distinguish this from OC_DCT_CW_FINISH.*/
198 : OC_DCT_CW_PACK( 0, 0, 0,1),
199 : /*The remaining tokens require no additional extra bits.*/
200 : /*OC_DCT_EOB1_TOKEN (0 extra bits)*/
201 : OC_DCT_CW_PACK( 1, 0, 0,0),
202 : /*OC_DCT_EOB2_TOKEN (0 extra bits)*/
203 : OC_DCT_CW_PACK( 2, 0, 0,0),
204 : /*OC_DCT_EOB3_TOKEN (0 extra bits)*/
205 : OC_DCT_CW_PACK( 3, 0, 0,0),
206 : /*OC_DCT_RUN_CAT1A (1 extra bit-1 already read)x5*/
207 : OC_DCT_CW_PACK( 0, 1, +1,0),
208 : OC_DCT_CW_PACK( 0, 1, -1,0),
209 : OC_DCT_CW_PACK( 0, 2, +1,0),
210 : OC_DCT_CW_PACK( 0, 2, -1,0),
211 : OC_DCT_CW_PACK( 0, 3, +1,0),
212 : OC_DCT_CW_PACK( 0, 3, -1,0),
213 : OC_DCT_CW_PACK( 0, 4, +1,0),
214 : OC_DCT_CW_PACK( 0, 4, -1,0),
215 : OC_DCT_CW_PACK( 0, 5, +1,0),
216 : OC_DCT_CW_PACK( 0, 5, -1,0),
217 : /*OC_DCT_RUN_CAT2A (2 extra bits-2 already read)*/
218 : OC_DCT_CW_PACK( 0, 1, +2,0),
219 : OC_DCT_CW_PACK( 0, 1, +3,0),
220 : OC_DCT_CW_PACK( 0, 1, -2,0),
221 : OC_DCT_CW_PACK( 0, 1, -3,0),
222 : /*OC_DCT_RUN_CAT1B (3 extra bits-3 already read)*/
223 : OC_DCT_CW_PACK( 0, 6, +1,0),
224 : OC_DCT_CW_PACK( 0, 7, +1,0),
225 : OC_DCT_CW_PACK( 0, 8, +1,0),
226 : OC_DCT_CW_PACK( 0, 9, +1,0),
227 : OC_DCT_CW_PACK( 0, 6, -1,0),
228 : OC_DCT_CW_PACK( 0, 7, -1,0),
229 : OC_DCT_CW_PACK( 0, 8, -1,0),
230 : OC_DCT_CW_PACK( 0, 9, -1,0),
231 : /*OC_DCT_RUN_CAT2B (3 extra bits-3 already read)*/
232 : OC_DCT_CW_PACK( 0, 2, +2,0),
233 : OC_DCT_CW_PACK( 0, 3, +2,0),
234 : OC_DCT_CW_PACK( 0, 2, +3,0),
235 : OC_DCT_CW_PACK( 0, 3, +3,0),
236 : OC_DCT_CW_PACK( 0, 2, -2,0),
237 : OC_DCT_CW_PACK( 0, 3, -2,0),
238 : OC_DCT_CW_PACK( 0, 2, -3,0),
239 : OC_DCT_CW_PACK( 0, 3, -3,0),
240 : /*OC_DCT_SHORT_ZRL_TOKEN (3 extra bits-3 already read)
241 : Flip is set on the first one to distinguish it from OC_DCT_CW_FINISH.*/
242 : OC_DCT_CW_PACK( 0, 0, 0,1),
243 : OC_DCT_CW_PACK( 0, 1, 0,0),
244 : OC_DCT_CW_PACK( 0, 2, 0,0),
245 : OC_DCT_CW_PACK( 0, 3, 0,0),
246 : OC_DCT_CW_PACK( 0, 4, 0,0),
247 : OC_DCT_CW_PACK( 0, 5, 0,0),
248 : OC_DCT_CW_PACK( 0, 6, 0,0),
249 : OC_DCT_CW_PACK( 0, 7, 0,0),
250 : /*OC_ONE_TOKEN (0 extra bits)*/
251 : OC_DCT_CW_PACK( 0, 0, +1,0),
252 : /*OC_MINUS_ONE_TOKEN (0 extra bits)*/
253 : OC_DCT_CW_PACK( 0, 0, -1,0),
254 : /*OC_TWO_TOKEN (0 extra bits)*/
255 : OC_DCT_CW_PACK( 0, 0, +2,0),
256 : /*OC_MINUS_TWO_TOKEN (0 extra bits)*/
257 : OC_DCT_CW_PACK( 0, 0, -2,0),
258 : /*OC_DCT_VAL_CAT2 (1 extra bit-1 already read)x4*/
259 : OC_DCT_CW_PACK( 0, 0, +3,0),
260 : OC_DCT_CW_PACK( 0, 0, -3,0),
261 : OC_DCT_CW_PACK( 0, 0, +4,0),
262 : OC_DCT_CW_PACK( 0, 0, -4,0),
263 : OC_DCT_CW_PACK( 0, 0, +5,0),
264 : OC_DCT_CW_PACK( 0, 0, -5,0),
265 : OC_DCT_CW_PACK( 0, 0, +6,0),
266 : OC_DCT_CW_PACK( 0, 0, -6,0),
267 : /*OC_DCT_VAL_CAT3 (2 extra bits-2 already read)*/
268 : OC_DCT_CW_PACK( 0, 0, +7,0),
269 : OC_DCT_CW_PACK( 0, 0, +8,0),
270 : OC_DCT_CW_PACK( 0, 0, -7,0),
271 : OC_DCT_CW_PACK( 0, 0, -8,0),
272 : /*OC_DCT_VAL_CAT4 (3 extra bits-3 already read)*/
273 : OC_DCT_CW_PACK( 0, 0, +9,0),
274 : OC_DCT_CW_PACK( 0, 0,+10,0),
275 : OC_DCT_CW_PACK( 0, 0,+11,0),
276 : OC_DCT_CW_PACK( 0, 0,+12,0),
277 : OC_DCT_CW_PACK( 0, 0, -9,0),
278 : OC_DCT_CW_PACK( 0, 0,-10,0),
279 : OC_DCT_CW_PACK( 0, 0,-11,0),
280 : OC_DCT_CW_PACK( 0, 0,-12,0),
281 : /*OC_DCT_REPEAT_RUN1_TOKEN (3 extra bits-3 already read)*/
282 : OC_DCT_CW_PACK( 8, 0, 0,0),
283 : OC_DCT_CW_PACK( 9, 0, 0,0),
284 : OC_DCT_CW_PACK(10, 0, 0,0),
285 : OC_DCT_CW_PACK(11, 0, 0,0),
286 : OC_DCT_CW_PACK(12, 0, 0,0),
287 : OC_DCT_CW_PACK(13, 0, 0,0),
288 : OC_DCT_CW_PACK(14, 0, 0,0),
289 : OC_DCT_CW_PACK(15, 0, 0,0),
290 : /*OC_DCT_REPEAT_RUN0_TOKEN (2 extra bits-2 already read)*/
291 : OC_DCT_CW_PACK( 4, 0, 0,0),
292 : OC_DCT_CW_PACK( 5, 0, 0,0),
293 : OC_DCT_CW_PACK( 6, 0, 0,0),
294 : OC_DCT_CW_PACK( 7, 0, 0,0),
295 : };
296 :
297 :
298 :
299 0 : static int oc_sb_run_unpack(oc_pack_buf *_opb){
300 : /*Coding scheme:
301 : Codeword Run Length
302 : 0 1
303 : 10x 2-3
304 : 110x 4-5
305 : 1110xx 6-9
306 : 11110xxx 10-17
307 : 111110xxxx 18-33
308 : 111111xxxxxxxxxxxx 34-4129*/
309 : static const ogg_int16_t OC_SB_RUN_TREE[22]={
310 : 4,
311 : -(1<<8|1),-(1<<8|1),-(1<<8|1),-(1<<8|1),
312 : -(1<<8|1),-(1<<8|1),-(1<<8|1),-(1<<8|1),
313 : -(3<<8|2),-(3<<8|2),-(3<<8|3),-(3<<8|3),
314 : -(4<<8|4),-(4<<8|5),-(4<<8|2<<4|6-6),17,
315 : 2,
316 : -(2<<8|2<<4|10-6),-(2<<8|2<<4|14-6),-(2<<8|4<<4|18-6),-(2<<8|12<<4|34-6)
317 : };
318 : int ret;
319 0 : ret=oc_huff_token_decode(_opb,OC_SB_RUN_TREE);
320 0 : if(ret>=0x10){
321 : int offs;
322 0 : offs=ret&0x1F;
323 0 : ret=6+offs+(int)oc_pack_read(_opb,ret-offs>>4);
324 : }
325 0 : return ret;
326 : }
327 :
328 0 : static int oc_block_run_unpack(oc_pack_buf *_opb){
329 : /*Coding scheme:
330 : Codeword Run Length
331 : 0x 1-2
332 : 10x 3-4
333 : 110x 5-6
334 : 1110xx 7-10
335 : 11110xx 11-14
336 : 11111xxxx 15-30*/
337 : static const ogg_int16_t OC_BLOCK_RUN_TREE[61]={
338 : 5,
339 : -(2<<8|1),-(2<<8|1),-(2<<8|1),-(2<<8|1),
340 : -(2<<8|1),-(2<<8|1),-(2<<8|1),-(2<<8|1),
341 : -(2<<8|2),-(2<<8|2),-(2<<8|2),-(2<<8|2),
342 : -(2<<8|2),-(2<<8|2),-(2<<8|2),-(2<<8|2),
343 : -(3<<8|3),-(3<<8|3),-(3<<8|3),-(3<<8|3),
344 : -(3<<8|4),-(3<<8|4),-(3<<8|4),-(3<<8|4),
345 : -(4<<8|5),-(4<<8|5),-(4<<8|6),-(4<<8|6),
346 : 33, 36, 39, 44,
347 : 1,-(1<<8|7),-(1<<8|8),
348 : 1,-(1<<8|9),-(1<<8|10),
349 : 2,-(2<<8|11),-(2<<8|12),-(2<<8|13),-(2<<8|14),
350 : 4,
351 : -(4<<8|15),-(4<<8|16),-(4<<8|17),-(4<<8|18),
352 : -(4<<8|19),-(4<<8|20),-(4<<8|21),-(4<<8|22),
353 : -(4<<8|23),-(4<<8|24),-(4<<8|25),-(4<<8|26),
354 : -(4<<8|27),-(4<<8|28),-(4<<8|29),-(4<<8|30)
355 : };
356 0 : return oc_huff_token_decode(_opb,OC_BLOCK_RUN_TREE);
357 : }
358 :
359 :
360 :
361 0 : void oc_dec_accel_init_c(oc_dec_ctx *_dec){
362 : # if defined(OC_DEC_USE_VTABLE)
363 : _dec->opt_vtable.dc_unpredict_mcu_plane=
364 : oc_dec_dc_unpredict_mcu_plane_c;
365 : # endif
366 0 : }
367 :
368 0 : static int oc_dec_init(oc_dec_ctx *_dec,const th_info *_info,
369 : const th_setup_info *_setup){
370 : int qti;
371 : int pli;
372 : int qi;
373 : int ret;
374 0 : ret=oc_state_init(&_dec->state,_info,3);
375 0 : if(ret<0)return ret;
376 0 : ret=oc_huff_trees_copy(_dec->huff_tables,
377 0 : (const ogg_int16_t *const *)_setup->huff_tables);
378 0 : if(ret<0){
379 0 : oc_state_clear(&_dec->state);
380 0 : return ret;
381 : }
382 : /*For each fragment, allocate one byte for every DCT coefficient token, plus
383 : one byte for extra-bits for each token, plus one more byte for the long
384 : EOB run, just in case it's the very last token and has a run length of
385 : one.*/
386 0 : _dec->dct_tokens=(unsigned char *)_ogg_malloc((64+64+1)*
387 0 : _dec->state.nfrags*sizeof(_dec->dct_tokens[0]));
388 0 : if(_dec->dct_tokens==NULL){
389 0 : oc_huff_trees_clear(_dec->huff_tables);
390 0 : oc_state_clear(&_dec->state);
391 0 : return TH_EFAULT;
392 : }
393 0 : for(qi=0;qi<64;qi++)for(pli=0;pli<3;pli++)for(qti=0;qti<2;qti++){
394 0 : _dec->state.dequant_tables[qi][pli][qti]=
395 0 : _dec->state.dequant_table_data[qi][pli][qti];
396 : }
397 0 : oc_dequant_tables_init(_dec->state.dequant_tables,_dec->pp_dc_scale,
398 : &_setup->qinfo);
399 0 : for(qi=0;qi<64;qi++){
400 : int qsum;
401 0 : qsum=0;
402 0 : for(qti=0;qti<2;qti++)for(pli=0;pli<3;pli++){
403 0 : qsum+=_dec->state.dequant_tables[qi][pli][qti][12]+
404 0 : _dec->state.dequant_tables[qi][pli][qti][17]+
405 0 : _dec->state.dequant_tables[qi][pli][qti][18]+
406 0 : _dec->state.dequant_tables[qi][pli][qti][24]<<(pli==0);
407 : }
408 0 : _dec->pp_sharp_mod[qi]=-(qsum>>11);
409 : }
410 0 : memcpy(_dec->state.loop_filter_limits,_setup->qinfo.loop_filter_limits,
411 : sizeof(_dec->state.loop_filter_limits));
412 0 : oc_dec_accel_init(_dec);
413 0 : _dec->pp_level=OC_PP_LEVEL_DISABLED;
414 0 : _dec->dc_qis=NULL;
415 0 : _dec->variances=NULL;
416 0 : _dec->pp_frame_data=NULL;
417 0 : _dec->stripe_cb.ctx=NULL;
418 0 : _dec->stripe_cb.stripe_decoded=NULL;
419 : #if defined(HAVE_CAIRO)
420 : _dec->telemetry=0;
421 : _dec->telemetry_bits=0;
422 : _dec->telemetry_qi=0;
423 : _dec->telemetry_mbmode=0;
424 : _dec->telemetry_mv=0;
425 : _dec->telemetry_frame_data=NULL;
426 : #endif
427 0 : return 0;
428 : }
429 :
430 0 : static void oc_dec_clear(oc_dec_ctx *_dec){
431 : #if defined(HAVE_CAIRO)
432 : _ogg_free(_dec->telemetry_frame_data);
433 : #endif
434 0 : _ogg_free(_dec->pp_frame_data);
435 0 : _ogg_free(_dec->variances);
436 0 : _ogg_free(_dec->dc_qis);
437 0 : _ogg_free(_dec->dct_tokens);
438 0 : oc_huff_trees_clear(_dec->huff_tables);
439 0 : oc_state_clear(&_dec->state);
440 0 : }
441 :
442 :
443 0 : static int oc_dec_frame_header_unpack(oc_dec_ctx *_dec){
444 : long val;
445 : /*Check to make sure this is a data packet.*/
446 0 : val=oc_pack_read1(&_dec->opb);
447 0 : if(val!=0)return TH_EBADPACKET;
448 : /*Read in the frame type (I or P).*/
449 0 : val=oc_pack_read1(&_dec->opb);
450 0 : _dec->state.frame_type=(int)val;
451 : /*Read in the qi list.*/
452 0 : val=oc_pack_read(&_dec->opb,6);
453 0 : _dec->state.qis[0]=(unsigned char)val;
454 0 : val=oc_pack_read1(&_dec->opb);
455 0 : if(!val)_dec->state.nqis=1;
456 : else{
457 0 : val=oc_pack_read(&_dec->opb,6);
458 0 : _dec->state.qis[1]=(unsigned char)val;
459 0 : val=oc_pack_read1(&_dec->opb);
460 0 : if(!val)_dec->state.nqis=2;
461 : else{
462 0 : val=oc_pack_read(&_dec->opb,6);
463 0 : _dec->state.qis[2]=(unsigned char)val;
464 0 : _dec->state.nqis=3;
465 : }
466 : }
467 0 : if(_dec->state.frame_type==OC_INTRA_FRAME){
468 : /*Keyframes have 3 unused configuration bits, holdovers from VP3 days.
469 : Most of the other unused bits in the VP3 headers were eliminated.
470 : I don't know why these remain.*/
471 : /*I wanted to eliminate wasted bits, but not all config wiggle room
472 : --Monty.*/
473 0 : val=oc_pack_read(&_dec->opb,3);
474 0 : if(val!=0)return TH_EIMPL;
475 : }
476 0 : return 0;
477 : }
478 :
479 : /*Mark all fragments as coded and in OC_MODE_INTRA.
480 : This also builds up the coded fragment list (in coded order), and clears the
481 : uncoded fragment list.
482 : It does not update the coded macro block list nor the super block flags, as
483 : those are not used when decoding INTRA frames.*/
484 0 : static void oc_dec_mark_all_intra(oc_dec_ctx *_dec){
485 : const oc_sb_map *sb_maps;
486 : const oc_sb_flags *sb_flags;
487 : oc_fragment *frags;
488 : ptrdiff_t *coded_fragis;
489 : ptrdiff_t ncoded_fragis;
490 : ptrdiff_t prev_ncoded_fragis;
491 : unsigned nsbs;
492 : unsigned sbi;
493 : int pli;
494 0 : coded_fragis=_dec->state.coded_fragis;
495 0 : prev_ncoded_fragis=ncoded_fragis=0;
496 0 : sb_maps=(const oc_sb_map *)_dec->state.sb_maps;
497 0 : sb_flags=_dec->state.sb_flags;
498 0 : frags=_dec->state.frags;
499 0 : sbi=nsbs=0;
500 0 : for(pli=0;pli<3;pli++){
501 0 : nsbs+=_dec->state.fplanes[pli].nsbs;
502 0 : for(;sbi<nsbs;sbi++){
503 : int quadi;
504 0 : for(quadi=0;quadi<4;quadi++)if(sb_flags[sbi].quad_valid&1<<quadi){
505 : int bi;
506 0 : for(bi=0;bi<4;bi++){
507 : ptrdiff_t fragi;
508 0 : fragi=sb_maps[sbi][quadi][bi];
509 0 : if(fragi>=0){
510 0 : frags[fragi].coded=1;
511 0 : frags[fragi].refi=OC_FRAME_SELF;
512 0 : frags[fragi].mb_mode=OC_MODE_INTRA;
513 0 : coded_fragis[ncoded_fragis++]=fragi;
514 : }
515 : }
516 : }
517 : }
518 0 : _dec->state.ncoded_fragis[pli]=ncoded_fragis-prev_ncoded_fragis;
519 0 : prev_ncoded_fragis=ncoded_fragis;
520 : }
521 0 : _dec->state.ntotal_coded_fragis=ncoded_fragis;
522 0 : }
523 :
524 : /*Decodes the bit flags indicating whether each super block is partially coded
525 : or not.
526 : Return: The number of partially coded super blocks.*/
527 0 : static unsigned oc_dec_partial_sb_flags_unpack(oc_dec_ctx *_dec){
528 : oc_sb_flags *sb_flags;
529 : unsigned nsbs;
530 : unsigned sbi;
531 : unsigned npartial;
532 : unsigned run_count;
533 : long val;
534 : int flag;
535 0 : val=oc_pack_read1(&_dec->opb);
536 0 : flag=(int)val;
537 0 : sb_flags=_dec->state.sb_flags;
538 0 : nsbs=_dec->state.nsbs;
539 0 : sbi=npartial=0;
540 0 : while(sbi<nsbs){
541 : int full_run;
542 0 : run_count=oc_sb_run_unpack(&_dec->opb);
543 0 : full_run=run_count>=4129;
544 : do{
545 0 : sb_flags[sbi].coded_partially=flag;
546 0 : sb_flags[sbi].coded_fully=0;
547 0 : npartial+=flag;
548 0 : sbi++;
549 : }
550 0 : while(--run_count>0&&sbi<nsbs);
551 0 : if(full_run&&sbi<nsbs){
552 0 : val=oc_pack_read1(&_dec->opb);
553 0 : flag=(int)val;
554 : }
555 0 : else flag=!flag;
556 : }
557 : /*TODO: run_count should be 0 here.
558 : If it's not, we should issue a warning of some kind.*/
559 0 : return npartial;
560 : }
561 :
562 : /*Decodes the bit flags for whether or not each non-partially-coded super
563 : block is fully coded or not.
564 : This function should only be called if there is at least one
565 : non-partially-coded super block.
566 : Return: The number of partially coded super blocks.*/
567 0 : static void oc_dec_coded_sb_flags_unpack(oc_dec_ctx *_dec){
568 : oc_sb_flags *sb_flags;
569 : unsigned nsbs;
570 : unsigned sbi;
571 : unsigned run_count;
572 : long val;
573 : int flag;
574 0 : sb_flags=_dec->state.sb_flags;
575 0 : nsbs=_dec->state.nsbs;
576 : /*Skip partially coded super blocks.*/
577 0 : for(sbi=0;sb_flags[sbi].coded_partially;sbi++);
578 0 : val=oc_pack_read1(&_dec->opb);
579 0 : flag=(int)val;
580 : do{
581 : int full_run;
582 0 : run_count=oc_sb_run_unpack(&_dec->opb);
583 0 : full_run=run_count>=4129;
584 0 : for(;sbi<nsbs;sbi++){
585 0 : if(sb_flags[sbi].coded_partially)continue;
586 0 : if(run_count--<=0)break;
587 0 : sb_flags[sbi].coded_fully=flag;
588 : }
589 0 : if(full_run&&sbi<nsbs){
590 0 : val=oc_pack_read1(&_dec->opb);
591 0 : flag=(int)val;
592 : }
593 0 : else flag=!flag;
594 : }
595 0 : while(sbi<nsbs);
596 : /*TODO: run_count should be 0 here.
597 : If it's not, we should issue a warning of some kind.*/
598 0 : }
599 :
600 0 : static void oc_dec_coded_flags_unpack(oc_dec_ctx *_dec){
601 : const oc_sb_map *sb_maps;
602 : const oc_sb_flags *sb_flags;
603 : signed char *mb_modes;
604 : oc_fragment *frags;
605 : unsigned nsbs;
606 : unsigned sbi;
607 : unsigned npartial;
608 : long val;
609 : int pli;
610 : int flag;
611 : int run_count;
612 : ptrdiff_t *coded_fragis;
613 : ptrdiff_t *uncoded_fragis;
614 : ptrdiff_t ncoded_fragis;
615 : ptrdiff_t nuncoded_fragis;
616 : ptrdiff_t prev_ncoded_fragis;
617 0 : npartial=oc_dec_partial_sb_flags_unpack(_dec);
618 0 : if(npartial<_dec->state.nsbs)oc_dec_coded_sb_flags_unpack(_dec);
619 0 : if(npartial>0){
620 0 : val=oc_pack_read1(&_dec->opb);
621 0 : flag=!(int)val;
622 : }
623 0 : else flag=0;
624 0 : sb_maps=(const oc_sb_map *)_dec->state.sb_maps;
625 0 : sb_flags=_dec->state.sb_flags;
626 0 : mb_modes=_dec->state.mb_modes;
627 0 : frags=_dec->state.frags;
628 0 : sbi=nsbs=run_count=0;
629 0 : coded_fragis=_dec->state.coded_fragis;
630 0 : uncoded_fragis=coded_fragis+_dec->state.nfrags;
631 0 : prev_ncoded_fragis=ncoded_fragis=nuncoded_fragis=0;
632 0 : for(pli=0;pli<3;pli++){
633 0 : nsbs+=_dec->state.fplanes[pli].nsbs;
634 0 : for(;sbi<nsbs;sbi++){
635 : int quadi;
636 0 : for(quadi=0;quadi<4;quadi++)if(sb_flags[sbi].quad_valid&1<<quadi){
637 : int quad_coded;
638 : int bi;
639 0 : quad_coded=0;
640 0 : for(bi=0;bi<4;bi++){
641 : ptrdiff_t fragi;
642 0 : fragi=sb_maps[sbi][quadi][bi];
643 0 : if(fragi>=0){
644 : int coded;
645 0 : if(sb_flags[sbi].coded_fully)coded=1;
646 0 : else if(!sb_flags[sbi].coded_partially)coded=0;
647 : else{
648 0 : if(run_count<=0){
649 0 : run_count=oc_block_run_unpack(&_dec->opb);
650 0 : flag=!flag;
651 : }
652 0 : run_count--;
653 0 : coded=flag;
654 : }
655 0 : if(coded)coded_fragis[ncoded_fragis++]=fragi;
656 0 : else *(uncoded_fragis-++nuncoded_fragis)=fragi;
657 0 : quad_coded|=coded;
658 0 : frags[fragi].coded=coded;
659 0 : frags[fragi].refi=OC_FRAME_NONE;
660 : }
661 : }
662 : /*Remember if there's a coded luma block in this macro block.*/
663 0 : if(!pli)mb_modes[sbi<<2|quadi]=quad_coded;
664 : }
665 : }
666 0 : _dec->state.ncoded_fragis[pli]=ncoded_fragis-prev_ncoded_fragis;
667 0 : prev_ncoded_fragis=ncoded_fragis;
668 : }
669 0 : _dec->state.ntotal_coded_fragis=ncoded_fragis;
670 : /*TODO: run_count should be 0 here.
671 : If it's not, we should issue a warning of some kind.*/
672 0 : }
673 :
674 :
675 : /*Coding scheme:
676 : Codeword Mode Index
677 : 0 0
678 : 10 1
679 : 110 2
680 : 1110 3
681 : 11110 4
682 : 111110 5
683 : 1111110 6
684 : 1111111 7*/
685 : static const ogg_int16_t OC_VLC_MODE_TREE[26]={
686 : 4,
687 : -(1<<8|0),-(1<<8|0),-(1<<8|0),-(1<<8|0),
688 : -(1<<8|0),-(1<<8|0),-(1<<8|0),-(1<<8|0),
689 : -(2<<8|1),-(2<<8|1),-(2<<8|1),-(2<<8|1),
690 : -(3<<8|2),-(3<<8|2),-(4<<8|3),17,
691 : 3,
692 : -(1<<8|4),-(1<<8|4),-(1<<8|4),-(1<<8|4),
693 : -(2<<8|5),-(2<<8|5),-(3<<8|6),-(3<<8|7)
694 : };
695 :
696 : static const ogg_int16_t OC_CLC_MODE_TREE[9]={
697 : 3,
698 : -(3<<8|0),-(3<<8|1),-(3<<8|2),-(3<<8|3),
699 : -(3<<8|4),-(3<<8|5),-(3<<8|6),-(3<<8|7)
700 : };
701 :
702 : /*Unpacks the list of macro block modes for INTER frames.*/
703 0 : static void oc_dec_mb_modes_unpack(oc_dec_ctx *_dec){
704 : signed char *mb_modes;
705 : const unsigned char *alphabet;
706 : unsigned char scheme0_alphabet[8];
707 : const ogg_int16_t *mode_tree;
708 : size_t nmbs;
709 : size_t mbi;
710 : long val;
711 : int mode_scheme;
712 0 : val=oc_pack_read(&_dec->opb,3);
713 0 : mode_scheme=(int)val;
714 0 : if(mode_scheme==0){
715 : int mi;
716 : /*Just in case, initialize the modes to something.
717 : If the bitstream doesn't contain each index exactly once, it's likely
718 : corrupt and the rest of the packet is garbage anyway, but this way we
719 : won't crash, and we'll decode SOMETHING.*/
720 : /*LOOP VECTORIZES*/
721 0 : for(mi=0;mi<OC_NMODES;mi++)scheme0_alphabet[mi]=OC_MODE_INTER_NOMV;
722 0 : for(mi=0;mi<OC_NMODES;mi++){
723 0 : val=oc_pack_read(&_dec->opb,3);
724 0 : scheme0_alphabet[val]=OC_MODE_ALPHABETS[6][mi];
725 : }
726 0 : alphabet=scheme0_alphabet;
727 : }
728 0 : else alphabet=OC_MODE_ALPHABETS[mode_scheme-1];
729 0 : mode_tree=mode_scheme==7?OC_CLC_MODE_TREE:OC_VLC_MODE_TREE;
730 0 : mb_modes=_dec->state.mb_modes;
731 0 : nmbs=_dec->state.nmbs;
732 0 : for(mbi=0;mbi<nmbs;mbi++){
733 0 : if(mb_modes[mbi]>0){
734 : /*We have a coded luma block; decode a mode.*/
735 0 : mb_modes[mbi]=alphabet[oc_huff_token_decode(&_dec->opb,mode_tree)];
736 : }
737 : /*For other valid macro blocks, INTER_NOMV is forced, but we rely on the
738 : fact that OC_MODE_INTER_NOMV is already 0.*/
739 : }
740 0 : }
741 :
742 :
743 :
744 : static const ogg_int16_t OC_VLC_MV_COMP_TREE[101]={
745 : 5,
746 : -(3<<8|32+0),-(3<<8|32+0),-(3<<8|32+0),-(3<<8|32+0),
747 : -(3<<8|32+1),-(3<<8|32+1),-(3<<8|32+1),-(3<<8|32+1),
748 : -(3<<8|32-1),-(3<<8|32-1),-(3<<8|32-1),-(3<<8|32-1),
749 : -(4<<8|32+2),-(4<<8|32+2),-(4<<8|32-2),-(4<<8|32-2),
750 : -(4<<8|32+3),-(4<<8|32+3),-(4<<8|32-3),-(4<<8|32-3),
751 : 33, 36, 39, 42,
752 : 45, 50, 55, 60,
753 : 65, 74, 83, 92,
754 : 1,-(1<<8|32+4),-(1<<8|32-4),
755 : 1,-(1<<8|32+5),-(1<<8|32-5),
756 : 1,-(1<<8|32+6),-(1<<8|32-6),
757 : 1,-(1<<8|32+7),-(1<<8|32-7),
758 : 2,-(2<<8|32+8),-(2<<8|32-8),-(2<<8|32+9),-(2<<8|32-9),
759 : 2,-(2<<8|32+10),-(2<<8|32-10),-(2<<8|32+11),-(2<<8|32-11),
760 : 2,-(2<<8|32+12),-(2<<8|32-12),-(2<<8|32+13),-(2<<8|32-13),
761 : 2,-(2<<8|32+14),-(2<<8|32-14),-(2<<8|32+15),-(2<<8|32-15),
762 : 3,
763 : -(3<<8|32+16),-(3<<8|32-16),-(3<<8|32+17),-(3<<8|32-17),
764 : -(3<<8|32+18),-(3<<8|32-18),-(3<<8|32+19),-(3<<8|32-19),
765 : 3,
766 : -(3<<8|32+20),-(3<<8|32-20),-(3<<8|32+21),-(3<<8|32-21),
767 : -(3<<8|32+22),-(3<<8|32-22),-(3<<8|32+23),-(3<<8|32-23),
768 : 3,
769 : -(3<<8|32+24),-(3<<8|32-24),-(3<<8|32+25),-(3<<8|32-25),
770 : -(3<<8|32+26),-(3<<8|32-26),-(3<<8|32+27),-(3<<8|32-27),
771 : 3,
772 : -(3<<8|32+28),-(3<<8|32-28),-(3<<8|32+29),-(3<<8|32-29),
773 : -(3<<8|32+30),-(3<<8|32-30),-(3<<8|32+31),-(3<<8|32-31)
774 : };
775 :
776 : static const ogg_int16_t OC_CLC_MV_COMP_TREE[65]={
777 : 6,
778 : -(6<<8|32 +0),-(6<<8|32 -0),-(6<<8|32 +1),-(6<<8|32 -1),
779 : -(6<<8|32 +2),-(6<<8|32 -2),-(6<<8|32 +3),-(6<<8|32 -3),
780 : -(6<<8|32 +4),-(6<<8|32 -4),-(6<<8|32 +5),-(6<<8|32 -5),
781 : -(6<<8|32 +6),-(6<<8|32 -6),-(6<<8|32 +7),-(6<<8|32 -7),
782 : -(6<<8|32 +8),-(6<<8|32 -8),-(6<<8|32 +9),-(6<<8|32 -9),
783 : -(6<<8|32+10),-(6<<8|32-10),-(6<<8|32+11),-(6<<8|32-11),
784 : -(6<<8|32+12),-(6<<8|32-12),-(6<<8|32+13),-(6<<8|32-13),
785 : -(6<<8|32+14),-(6<<8|32-14),-(6<<8|32+15),-(6<<8|32-15),
786 : -(6<<8|32+16),-(6<<8|32-16),-(6<<8|32+17),-(6<<8|32-17),
787 : -(6<<8|32+18),-(6<<8|32-18),-(6<<8|32+19),-(6<<8|32-19),
788 : -(6<<8|32+20),-(6<<8|32-20),-(6<<8|32+21),-(6<<8|32-21),
789 : -(6<<8|32+22),-(6<<8|32-22),-(6<<8|32+23),-(6<<8|32-23),
790 : -(6<<8|32+24),-(6<<8|32-24),-(6<<8|32+25),-(6<<8|32-25),
791 : -(6<<8|32+26),-(6<<8|32-26),-(6<<8|32+27),-(6<<8|32-27),
792 : -(6<<8|32+28),-(6<<8|32-28),-(6<<8|32+29),-(6<<8|32-29),
793 : -(6<<8|32+30),-(6<<8|32-30),-(6<<8|32+31),-(6<<8|32-31)
794 : };
795 :
796 :
797 0 : static oc_mv oc_mv_unpack(oc_pack_buf *_opb,const ogg_int16_t *_tree){
798 : int dx;
799 : int dy;
800 0 : dx=oc_huff_token_decode(_opb,_tree)-32;
801 0 : dy=oc_huff_token_decode(_opb,_tree)-32;
802 0 : return OC_MV(dx,dy);
803 : }
804 :
805 : /*Unpacks the list of motion vectors for INTER frames, and propagtes the macro
806 : block modes and motion vectors to the individual fragments.*/
807 0 : static void oc_dec_mv_unpack_and_frag_modes_fill(oc_dec_ctx *_dec){
808 : const oc_mb_map *mb_maps;
809 : const signed char *mb_modes;
810 : oc_set_chroma_mvs_func set_chroma_mvs;
811 : const ogg_int16_t *mv_comp_tree;
812 : oc_fragment *frags;
813 : oc_mv *frag_mvs;
814 : const unsigned char *map_idxs;
815 : int map_nidxs;
816 : oc_mv last_mv;
817 : oc_mv prior_mv;
818 : oc_mv cbmvs[4];
819 : size_t nmbs;
820 : size_t mbi;
821 : long val;
822 0 : set_chroma_mvs=OC_SET_CHROMA_MVS_TABLE[_dec->state.info.pixel_fmt];
823 0 : val=oc_pack_read1(&_dec->opb);
824 0 : mv_comp_tree=val?OC_CLC_MV_COMP_TREE:OC_VLC_MV_COMP_TREE;
825 0 : map_idxs=OC_MB_MAP_IDXS[_dec->state.info.pixel_fmt];
826 0 : map_nidxs=OC_MB_MAP_NIDXS[_dec->state.info.pixel_fmt];
827 0 : prior_mv=last_mv=0;
828 0 : frags=_dec->state.frags;
829 0 : frag_mvs=_dec->state.frag_mvs;
830 0 : mb_maps=(const oc_mb_map *)_dec->state.mb_maps;
831 0 : mb_modes=_dec->state.mb_modes;
832 0 : nmbs=_dec->state.nmbs;
833 0 : for(mbi=0;mbi<nmbs;mbi++){
834 : int mb_mode;
835 0 : mb_mode=mb_modes[mbi];
836 0 : if(mb_mode!=OC_MODE_INVALID){
837 : oc_mv mbmv;
838 : ptrdiff_t fragi;
839 : int mapi;
840 : int mapii;
841 : int refi;
842 0 : if(mb_mode==OC_MODE_INTER_MV_FOUR){
843 : oc_mv lbmvs[4];
844 : int bi;
845 0 : prior_mv=last_mv;
846 0 : for(bi=0;bi<4;bi++){
847 0 : fragi=mb_maps[mbi][0][bi];
848 0 : if(frags[fragi].coded){
849 0 : frags[fragi].refi=OC_FRAME_PREV;
850 0 : frags[fragi].mb_mode=OC_MODE_INTER_MV_FOUR;
851 0 : lbmvs[bi]=last_mv=oc_mv_unpack(&_dec->opb,mv_comp_tree);
852 0 : frag_mvs[fragi]=lbmvs[bi];
853 : }
854 0 : else lbmvs[bi]=0;
855 : }
856 0 : (*set_chroma_mvs)(cbmvs,lbmvs);
857 0 : for(mapii=4;mapii<map_nidxs;mapii++){
858 0 : mapi=map_idxs[mapii];
859 0 : bi=mapi&3;
860 0 : fragi=mb_maps[mbi][mapi>>2][bi];
861 0 : if(frags[fragi].coded){
862 0 : frags[fragi].refi=OC_FRAME_PREV;
863 0 : frags[fragi].mb_mode=OC_MODE_INTER_MV_FOUR;
864 0 : frag_mvs[fragi]=cbmvs[bi];
865 : }
866 : }
867 : }
868 : else{
869 0 : switch(mb_mode){
870 : case OC_MODE_INTER_MV:{
871 0 : prior_mv=last_mv;
872 0 : last_mv=mbmv=oc_mv_unpack(&_dec->opb,mv_comp_tree);
873 0 : }break;
874 0 : case OC_MODE_INTER_MV_LAST:mbmv=last_mv;break;
875 : case OC_MODE_INTER_MV_LAST2:{
876 0 : mbmv=prior_mv;
877 0 : prior_mv=last_mv;
878 0 : last_mv=mbmv;
879 0 : }break;
880 : case OC_MODE_GOLDEN_MV:{
881 0 : mbmv=oc_mv_unpack(&_dec->opb,mv_comp_tree);
882 0 : }break;
883 0 : default:mbmv=0;break;
884 : }
885 : /*Fill in the MVs for the fragments.*/
886 0 : refi=OC_FRAME_FOR_MODE(mb_mode);
887 0 : mapii=0;
888 : do{
889 0 : mapi=map_idxs[mapii];
890 0 : fragi=mb_maps[mbi][mapi>>2][mapi&3];
891 0 : if(frags[fragi].coded){
892 0 : frags[fragi].refi=refi;
893 0 : frags[fragi].mb_mode=mb_mode;
894 0 : frag_mvs[fragi]=mbmv;
895 : }
896 : }
897 0 : while(++mapii<map_nidxs);
898 : }
899 : }
900 : }
901 0 : }
902 :
903 0 : static void oc_dec_block_qis_unpack(oc_dec_ctx *_dec){
904 : oc_fragment *frags;
905 : const ptrdiff_t *coded_fragis;
906 : ptrdiff_t ncoded_fragis;
907 : ptrdiff_t fragii;
908 : ptrdiff_t fragi;
909 0 : ncoded_fragis=_dec->state.ntotal_coded_fragis;
910 0 : if(ncoded_fragis<=0)return;
911 0 : frags=_dec->state.frags;
912 0 : coded_fragis=_dec->state.coded_fragis;
913 0 : if(_dec->state.nqis==1){
914 : /*If this frame has only a single qi value, then just use it for all coded
915 : fragments.*/
916 0 : for(fragii=0;fragii<ncoded_fragis;fragii++){
917 0 : frags[coded_fragis[fragii]].qii=0;
918 : }
919 : }
920 : else{
921 : long val;
922 : int flag;
923 : int nqi1;
924 : int run_count;
925 : /*Otherwise, we decode a qi index for each fragment, using two passes of
926 : the same binary RLE scheme used for super-block coded bits.
927 : The first pass marks each fragment as having a qii of 0 or greater than
928 : 0, and the second pass (if necessary), distinguishes between a qii of
929 : 1 and 2.
930 : At first we just store the qii in the fragment.
931 : After all the qii's are decoded, we make a final pass to replace them
932 : with the corresponding qi's for this frame.*/
933 0 : val=oc_pack_read1(&_dec->opb);
934 0 : flag=(int)val;
935 0 : nqi1=0;
936 0 : fragii=0;
937 0 : while(fragii<ncoded_fragis){
938 : int full_run;
939 0 : run_count=oc_sb_run_unpack(&_dec->opb);
940 0 : full_run=run_count>=4129;
941 : do{
942 0 : frags[coded_fragis[fragii++]].qii=flag;
943 0 : nqi1+=flag;
944 : }
945 0 : while(--run_count>0&&fragii<ncoded_fragis);
946 0 : if(full_run&&fragii<ncoded_fragis){
947 0 : val=oc_pack_read1(&_dec->opb);
948 0 : flag=(int)val;
949 : }
950 0 : else flag=!flag;
951 : }
952 : /*TODO: run_count should be 0 here.
953 : If it's not, we should issue a warning of some kind.*/
954 : /*If we have 3 different qi's for this frame, and there was at least one
955 : fragment with a non-zero qi, make the second pass.*/
956 0 : if(_dec->state.nqis==3&&nqi1>0){
957 : /*Skip qii==0 fragments.*/
958 0 : for(fragii=0;frags[coded_fragis[fragii]].qii==0;fragii++);
959 0 : val=oc_pack_read1(&_dec->opb);
960 0 : flag=(int)val;
961 : do{
962 : int full_run;
963 0 : run_count=oc_sb_run_unpack(&_dec->opb);
964 0 : full_run=run_count>=4129;
965 0 : for(;fragii<ncoded_fragis;fragii++){
966 0 : fragi=coded_fragis[fragii];
967 0 : if(frags[fragi].qii==0)continue;
968 0 : if(run_count--<=0)break;
969 0 : frags[fragi].qii+=flag;
970 : }
971 0 : if(full_run&&fragii<ncoded_fragis){
972 0 : val=oc_pack_read1(&_dec->opb);
973 0 : flag=(int)val;
974 : }
975 0 : else flag=!flag;
976 : }
977 0 : while(fragii<ncoded_fragis);
978 : /*TODO: run_count should be 0 here.
979 : If it's not, we should issue a warning of some kind.*/
980 : }
981 : }
982 : }
983 :
984 :
985 :
986 : /*Unpacks the DC coefficient tokens.
987 : Unlike when unpacking the AC coefficient tokens, we actually need to decode
988 : the DC coefficient values now so that we can do DC prediction.
989 : _huff_idx: The index of the Huffman table to use for each color plane.
990 : _ntoks_left: The number of tokens left to be decoded in each color plane for
991 : each coefficient.
992 : This is updated as EOB tokens and zero run tokens are decoded.
993 : Return: The length of any outstanding EOB run.*/
994 0 : static ptrdiff_t oc_dec_dc_coeff_unpack(oc_dec_ctx *_dec,int _huff_idxs[2],
995 : ptrdiff_t _ntoks_left[3][64]){
996 : unsigned char *dct_tokens;
997 : oc_fragment *frags;
998 : const ptrdiff_t *coded_fragis;
999 : ptrdiff_t ncoded_fragis;
1000 : ptrdiff_t fragii;
1001 : ptrdiff_t eobs;
1002 : ptrdiff_t ti;
1003 : int pli;
1004 0 : dct_tokens=_dec->dct_tokens;
1005 0 : frags=_dec->state.frags;
1006 0 : coded_fragis=_dec->state.coded_fragis;
1007 0 : ncoded_fragis=fragii=eobs=ti=0;
1008 0 : for(pli=0;pli<3;pli++){
1009 : ptrdiff_t run_counts[64];
1010 : ptrdiff_t eob_count;
1011 : ptrdiff_t eobi;
1012 : int rli;
1013 0 : ncoded_fragis+=_dec->state.ncoded_fragis[pli];
1014 0 : memset(run_counts,0,sizeof(run_counts));
1015 0 : _dec->eob_runs[pli][0]=eobs;
1016 0 : _dec->ti0[pli][0]=ti;
1017 : /*Continue any previous EOB run, if there was one.*/
1018 0 : eobi=eobs;
1019 0 : if(ncoded_fragis-fragii<eobi)eobi=ncoded_fragis-fragii;
1020 0 : eob_count=eobi;
1021 0 : eobs-=eobi;
1022 0 : while(eobi-->0)frags[coded_fragis[fragii++]].dc=0;
1023 0 : while(fragii<ncoded_fragis){
1024 : int token;
1025 : int cw;
1026 : int eb;
1027 : int skip;
1028 0 : token=oc_huff_token_decode(&_dec->opb,
1029 0 : _dec->huff_tables[_huff_idxs[pli+1>>1]]);
1030 0 : dct_tokens[ti++]=(unsigned char)token;
1031 0 : if(OC_DCT_TOKEN_NEEDS_MORE(token)){
1032 0 : eb=(int)oc_pack_read(&_dec->opb,
1033 0 : OC_INTERNAL_DCT_TOKEN_EXTRA_BITS[token]);
1034 0 : dct_tokens[ti++]=(unsigned char)eb;
1035 0 : if(token==OC_DCT_TOKEN_FAT_EOB)dct_tokens[ti++]=(unsigned char)(eb>>8);
1036 0 : eb<<=OC_DCT_TOKEN_EB_POS(token);
1037 : }
1038 0 : else eb=0;
1039 0 : cw=OC_DCT_CODE_WORD[token]+eb;
1040 0 : eobs=cw>>OC_DCT_CW_EOB_SHIFT&0xFFF;
1041 0 : if(cw==OC_DCT_CW_FINISH)eobs=OC_DCT_EOB_FINISH;
1042 0 : if(eobs){
1043 0 : eobi=OC_MINI(eobs,ncoded_fragis-fragii);
1044 0 : eob_count+=eobi;
1045 0 : eobs-=eobi;
1046 0 : while(eobi-->0)frags[coded_fragis[fragii++]].dc=0;
1047 : }
1048 : else{
1049 : int coeff;
1050 0 : skip=(unsigned char)(cw>>OC_DCT_CW_RLEN_SHIFT);
1051 0 : cw^=-(cw&1<<OC_DCT_CW_FLIP_BIT);
1052 0 : coeff=cw>>OC_DCT_CW_MAG_SHIFT;
1053 0 : if(skip)coeff=0;
1054 0 : run_counts[skip]++;
1055 0 : frags[coded_fragis[fragii++]].dc=coeff;
1056 : }
1057 : }
1058 : /*Add the total EOB count to the longest run length.*/
1059 0 : run_counts[63]+=eob_count;
1060 : /*And convert the run_counts array to a moment table.*/
1061 0 : for(rli=63;rli-->0;)run_counts[rli]+=run_counts[rli+1];
1062 : /*Finally, subtract off the number of coefficients that have been
1063 : accounted for by runs started in this coefficient.*/
1064 0 : for(rli=64;rli-->0;)_ntoks_left[pli][rli]-=run_counts[rli];
1065 : }
1066 0 : _dec->dct_tokens_count=ti;
1067 0 : return eobs;
1068 : }
1069 :
1070 : /*Unpacks the AC coefficient tokens.
1071 : This can completely discard coefficient values while unpacking, and so is
1072 : somewhat simpler than unpacking the DC coefficient tokens.
1073 : _huff_idx: The index of the Huffman table to use for each color plane.
1074 : _ntoks_left: The number of tokens left to be decoded in each color plane for
1075 : each coefficient.
1076 : This is updated as EOB tokens and zero run tokens are decoded.
1077 : _eobs: The length of any outstanding EOB run from previous
1078 : coefficients.
1079 : Return: The length of any outstanding EOB run.*/
1080 0 : static int oc_dec_ac_coeff_unpack(oc_dec_ctx *_dec,int _zzi,int _huff_idxs[2],
1081 : ptrdiff_t _ntoks_left[3][64],ptrdiff_t _eobs){
1082 : unsigned char *dct_tokens;
1083 : ptrdiff_t ti;
1084 : int pli;
1085 0 : dct_tokens=_dec->dct_tokens;
1086 0 : ti=_dec->dct_tokens_count;
1087 0 : for(pli=0;pli<3;pli++){
1088 : ptrdiff_t run_counts[64];
1089 : ptrdiff_t eob_count;
1090 : size_t ntoks_left;
1091 : size_t ntoks;
1092 : int rli;
1093 0 : _dec->eob_runs[pli][_zzi]=_eobs;
1094 0 : _dec->ti0[pli][_zzi]=ti;
1095 0 : ntoks_left=_ntoks_left[pli][_zzi];
1096 0 : memset(run_counts,0,sizeof(run_counts));
1097 0 : eob_count=0;
1098 0 : ntoks=0;
1099 0 : while(ntoks+_eobs<ntoks_left){
1100 : int token;
1101 : int cw;
1102 : int eb;
1103 : int skip;
1104 0 : ntoks+=_eobs;
1105 0 : eob_count+=_eobs;
1106 0 : token=oc_huff_token_decode(&_dec->opb,
1107 0 : _dec->huff_tables[_huff_idxs[pli+1>>1]]);
1108 0 : dct_tokens[ti++]=(unsigned char)token;
1109 0 : if(OC_DCT_TOKEN_NEEDS_MORE(token)){
1110 0 : eb=(int)oc_pack_read(&_dec->opb,
1111 0 : OC_INTERNAL_DCT_TOKEN_EXTRA_BITS[token]);
1112 0 : dct_tokens[ti++]=(unsigned char)eb;
1113 0 : if(token==OC_DCT_TOKEN_FAT_EOB)dct_tokens[ti++]=(unsigned char)(eb>>8);
1114 0 : eb<<=OC_DCT_TOKEN_EB_POS(token);
1115 : }
1116 0 : else eb=0;
1117 0 : cw=OC_DCT_CODE_WORD[token]+eb;
1118 0 : skip=(unsigned char)(cw>>OC_DCT_CW_RLEN_SHIFT);
1119 0 : _eobs=cw>>OC_DCT_CW_EOB_SHIFT&0xFFF;
1120 0 : if(cw==OC_DCT_CW_FINISH)_eobs=OC_DCT_EOB_FINISH;
1121 0 : if(_eobs==0){
1122 0 : run_counts[skip]++;
1123 0 : ntoks++;
1124 : }
1125 : }
1126 : /*Add the portion of the last EOB run actually used by this coefficient.*/
1127 0 : eob_count+=ntoks_left-ntoks;
1128 : /*And remove it from the remaining EOB count.*/
1129 0 : _eobs-=ntoks_left-ntoks;
1130 : /*Add the total EOB count to the longest run length.*/
1131 0 : run_counts[63]+=eob_count;
1132 : /*And convert the run_counts array to a moment table.*/
1133 0 : for(rli=63;rli-->0;)run_counts[rli]+=run_counts[rli+1];
1134 : /*Finally, subtract off the number of coefficients that have been
1135 : accounted for by runs started in this coefficient.*/
1136 0 : for(rli=64-_zzi;rli-->0;)_ntoks_left[pli][_zzi+rli]-=run_counts[rli];
1137 : }
1138 0 : _dec->dct_tokens_count=ti;
1139 0 : return _eobs;
1140 : }
1141 :
1142 : /*Tokens describing the DCT coefficients that belong to each fragment are
1143 : stored in the bitstream grouped by coefficient, not by fragment.
1144 :
1145 : This means that we either decode all the tokens in order, building up a
1146 : separate coefficient list for each fragment as we go, and then go back and
1147 : do the iDCT on each fragment, or we have to create separate lists of tokens
1148 : for each coefficient, so that we can pull the next token required off the
1149 : head of the appropriate list when decoding a specific fragment.
1150 :
1151 : The former was VP3's choice, and it meant 2*w*h extra storage for all the
1152 : decoded coefficient values.
1153 :
1154 : We take the second option, which lets us store just one to three bytes per
1155 : token (generally far fewer than the number of coefficients, due to EOB
1156 : tokens and zero runs), and which requires us to only maintain a counter for
1157 : each of the 64 coefficients, instead of a counter for every fragment to
1158 : determine where the next token goes.
1159 :
1160 : We actually use 3 counters per coefficient, one for each color plane, so we
1161 : can decode all color planes simultaneously.
1162 : This lets color conversion, etc., be done as soon as a full MCU (one or
1163 : two super block rows) is decoded, while the image data is still in cache.*/
1164 :
1165 0 : static void oc_dec_residual_tokens_unpack(oc_dec_ctx *_dec){
1166 : static const unsigned char OC_HUFF_LIST_MAX[5]={1,6,15,28,64};
1167 : ptrdiff_t ntoks_left[3][64];
1168 : int huff_idxs[2];
1169 : ptrdiff_t eobs;
1170 : long val;
1171 : int pli;
1172 : int zzi;
1173 : int hgi;
1174 0 : for(pli=0;pli<3;pli++)for(zzi=0;zzi<64;zzi++){
1175 0 : ntoks_left[pli][zzi]=_dec->state.ncoded_fragis[pli];
1176 : }
1177 0 : val=oc_pack_read(&_dec->opb,4);
1178 0 : huff_idxs[0]=(int)val;
1179 0 : val=oc_pack_read(&_dec->opb,4);
1180 0 : huff_idxs[1]=(int)val;
1181 0 : _dec->eob_runs[0][0]=0;
1182 0 : eobs=oc_dec_dc_coeff_unpack(_dec,huff_idxs,ntoks_left);
1183 : #if defined(HAVE_CAIRO)
1184 : _dec->telemetry_dc_bytes=oc_pack_bytes_left(&_dec->opb);
1185 : #endif
1186 0 : val=oc_pack_read(&_dec->opb,4);
1187 0 : huff_idxs[0]=(int)val;
1188 0 : val=oc_pack_read(&_dec->opb,4);
1189 0 : huff_idxs[1]=(int)val;
1190 0 : zzi=1;
1191 0 : for(hgi=1;hgi<5;hgi++){
1192 0 : huff_idxs[0]+=16;
1193 0 : huff_idxs[1]+=16;
1194 0 : for(;zzi<OC_HUFF_LIST_MAX[hgi];zzi++){
1195 0 : eobs=oc_dec_ac_coeff_unpack(_dec,zzi,huff_idxs,ntoks_left,eobs);
1196 : }
1197 : }
1198 : /*TODO: eobs should be exactly zero, or 4096 or greater.
1199 : The second case occurs when an EOB run of size zero is encountered, which
1200 : gets treated as an infinite EOB run (where infinity is PTRDIFF_MAX).
1201 : If neither of these conditions holds, then a warning should be issued.*/
1202 0 : }
1203 :
1204 :
1205 0 : static int oc_dec_postprocess_init(oc_dec_ctx *_dec){
1206 : /*pp_level 0: disabled; free any memory used and return*/
1207 0 : if(_dec->pp_level<=OC_PP_LEVEL_DISABLED){
1208 0 : if(_dec->dc_qis!=NULL){
1209 0 : _ogg_free(_dec->dc_qis);
1210 0 : _dec->dc_qis=NULL;
1211 0 : _ogg_free(_dec->variances);
1212 0 : _dec->variances=NULL;
1213 0 : _ogg_free(_dec->pp_frame_data);
1214 0 : _dec->pp_frame_data=NULL;
1215 : }
1216 0 : return 1;
1217 : }
1218 0 : if(_dec->dc_qis==NULL){
1219 : /*If we haven't been tracking DC quantization indices, there's no point in
1220 : starting now.*/
1221 0 : if(_dec->state.frame_type!=OC_INTRA_FRAME)return 1;
1222 0 : _dec->dc_qis=(unsigned char *)_ogg_malloc(
1223 0 : _dec->state.nfrags*sizeof(_dec->dc_qis[0]));
1224 0 : if(_dec->dc_qis==NULL)return 1;
1225 0 : memset(_dec->dc_qis,_dec->state.qis[0],_dec->state.nfrags);
1226 : }
1227 : else{
1228 : unsigned char *dc_qis;
1229 : const ptrdiff_t *coded_fragis;
1230 : ptrdiff_t ncoded_fragis;
1231 : ptrdiff_t fragii;
1232 : unsigned char qi0;
1233 : /*Update the DC quantization index of each coded block.*/
1234 0 : dc_qis=_dec->dc_qis;
1235 0 : coded_fragis=_dec->state.coded_fragis;
1236 0 : ncoded_fragis=_dec->state.ncoded_fragis[0]+
1237 0 : _dec->state.ncoded_fragis[1]+_dec->state.ncoded_fragis[2];
1238 0 : qi0=(unsigned char)_dec->state.qis[0];
1239 0 : for(fragii=0;fragii<ncoded_fragis;fragii++){
1240 0 : dc_qis[coded_fragis[fragii]]=qi0;
1241 : }
1242 : }
1243 : /*pp_level 1: Stop after updating DC quantization indices.*/
1244 0 : if(_dec->pp_level<=OC_PP_LEVEL_TRACKDCQI){
1245 0 : if(_dec->variances!=NULL){
1246 0 : _ogg_free(_dec->variances);
1247 0 : _dec->variances=NULL;
1248 0 : _ogg_free(_dec->pp_frame_data);
1249 0 : _dec->pp_frame_data=NULL;
1250 : }
1251 0 : return 1;
1252 : }
1253 0 : if(_dec->variances==NULL){
1254 : size_t frame_sz;
1255 : size_t c_sz;
1256 : int c_w;
1257 : int c_h;
1258 0 : frame_sz=_dec->state.info.frame_width*(size_t)_dec->state.info.frame_height;
1259 0 : c_w=_dec->state.info.frame_width>>!(_dec->state.info.pixel_fmt&1);
1260 0 : c_h=_dec->state.info.frame_height>>!(_dec->state.info.pixel_fmt&2);
1261 0 : c_sz=c_w*(size_t)c_h;
1262 : /*Allocate space for the chroma planes, even if we're not going to use
1263 : them; this simplifies allocation state management, though it may waste
1264 : memory on the few systems that don't overcommit pages.*/
1265 0 : frame_sz+=c_sz<<1;
1266 0 : _dec->pp_frame_data=(unsigned char *)_ogg_malloc(
1267 : frame_sz*sizeof(_dec->pp_frame_data[0]));
1268 0 : _dec->variances=(int *)_ogg_malloc(
1269 0 : _dec->state.nfrags*sizeof(_dec->variances[0]));
1270 0 : if(_dec->variances==NULL||_dec->pp_frame_data==NULL){
1271 0 : _ogg_free(_dec->pp_frame_data);
1272 0 : _dec->pp_frame_data=NULL;
1273 0 : _ogg_free(_dec->variances);
1274 0 : _dec->variances=NULL;
1275 0 : return 1;
1276 : }
1277 : /*Force an update of the PP buffer pointers.*/
1278 0 : _dec->pp_frame_state=0;
1279 : }
1280 : /*Update the PP buffer pointers if necessary.*/
1281 0 : if(_dec->pp_frame_state!=1+(_dec->pp_level>=OC_PP_LEVEL_DEBLOCKC)){
1282 0 : if(_dec->pp_level<OC_PP_LEVEL_DEBLOCKC){
1283 : /*If chroma processing is disabled, just use the PP luma plane.*/
1284 0 : _dec->pp_frame_buf[0].width=_dec->state.info.frame_width;
1285 0 : _dec->pp_frame_buf[0].height=_dec->state.info.frame_height;
1286 0 : _dec->pp_frame_buf[0].stride=-_dec->pp_frame_buf[0].width;
1287 0 : _dec->pp_frame_buf[0].data=_dec->pp_frame_data+
1288 0 : (1-_dec->pp_frame_buf[0].height)*(ptrdiff_t)_dec->pp_frame_buf[0].stride;
1289 : }
1290 : else{
1291 : size_t y_sz;
1292 : size_t c_sz;
1293 : int c_w;
1294 : int c_h;
1295 : /*Otherwise, set up pointers to all three PP planes.*/
1296 0 : y_sz=_dec->state.info.frame_width*(size_t)_dec->state.info.frame_height;
1297 0 : c_w=_dec->state.info.frame_width>>!(_dec->state.info.pixel_fmt&1);
1298 0 : c_h=_dec->state.info.frame_height>>!(_dec->state.info.pixel_fmt&2);
1299 0 : c_sz=c_w*(size_t)c_h;
1300 0 : _dec->pp_frame_buf[0].width=_dec->state.info.frame_width;
1301 0 : _dec->pp_frame_buf[0].height=_dec->state.info.frame_height;
1302 0 : _dec->pp_frame_buf[0].stride=_dec->pp_frame_buf[0].width;
1303 0 : _dec->pp_frame_buf[0].data=_dec->pp_frame_data;
1304 0 : _dec->pp_frame_buf[1].width=c_w;
1305 0 : _dec->pp_frame_buf[1].height=c_h;
1306 0 : _dec->pp_frame_buf[1].stride=_dec->pp_frame_buf[1].width;
1307 0 : _dec->pp_frame_buf[1].data=_dec->pp_frame_buf[0].data+y_sz;
1308 0 : _dec->pp_frame_buf[2].width=c_w;
1309 0 : _dec->pp_frame_buf[2].height=c_h;
1310 0 : _dec->pp_frame_buf[2].stride=_dec->pp_frame_buf[2].width;
1311 0 : _dec->pp_frame_buf[2].data=_dec->pp_frame_buf[1].data+c_sz;
1312 0 : oc_ycbcr_buffer_flip(_dec->pp_frame_buf,_dec->pp_frame_buf);
1313 : }
1314 0 : _dec->pp_frame_state=1+(_dec->pp_level>=OC_PP_LEVEL_DEBLOCKC);
1315 : }
1316 : /*If we're not processing chroma, copy the reference frame's chroma planes.*/
1317 0 : if(_dec->pp_level<OC_PP_LEVEL_DEBLOCKC){
1318 0 : memcpy(_dec->pp_frame_buf+1,
1319 0 : _dec->state.ref_frame_bufs[_dec->state.ref_frame_idx[OC_FRAME_SELF]]+1,
1320 : sizeof(_dec->pp_frame_buf[1])*2);
1321 : }
1322 0 : return 0;
1323 : }
1324 :
1325 :
1326 : /*Initialize the main decoding pipeline.*/
1327 0 : static void oc_dec_pipeline_init(oc_dec_ctx *_dec,
1328 : oc_dec_pipeline_state *_pipe){
1329 : const ptrdiff_t *coded_fragis;
1330 : const ptrdiff_t *uncoded_fragis;
1331 : int flimit;
1332 : int pli;
1333 : int qii;
1334 : int qti;
1335 : int zzi;
1336 : /*If chroma is sub-sampled in the vertical direction, we have to decode two
1337 : super block rows of Y' for each super block row of Cb and Cr.*/
1338 0 : _pipe->mcu_nvfrags=4<<!(_dec->state.info.pixel_fmt&2);
1339 : /*Initialize the token and extra bits indices for each plane and
1340 : coefficient.*/
1341 0 : memcpy(_pipe->ti,_dec->ti0,sizeof(_pipe->ti));
1342 : /*Also copy over the initial the EOB run counts.*/
1343 0 : memcpy(_pipe->eob_runs,_dec->eob_runs,sizeof(_pipe->eob_runs));
1344 : /*Set up per-plane pointers to the coded and uncoded fragments lists.*/
1345 0 : coded_fragis=_dec->state.coded_fragis;
1346 0 : uncoded_fragis=coded_fragis+_dec->state.nfrags;
1347 0 : for(pli=0;pli<3;pli++){
1348 : ptrdiff_t ncoded_fragis;
1349 0 : _pipe->coded_fragis[pli]=coded_fragis;
1350 0 : _pipe->uncoded_fragis[pli]=uncoded_fragis;
1351 0 : ncoded_fragis=_dec->state.ncoded_fragis[pli];
1352 0 : coded_fragis+=ncoded_fragis;
1353 0 : uncoded_fragis+=ncoded_fragis-_dec->state.fplanes[pli].nfrags;
1354 : }
1355 : /*Set up condensed quantizer tables.*/
1356 0 : for(pli=0;pli<3;pli++){
1357 0 : for(qii=0;qii<_dec->state.nqis;qii++){
1358 0 : for(qti=0;qti<2;qti++){
1359 0 : _pipe->dequant[pli][qii][qti]=
1360 0 : _dec->state.dequant_tables[_dec->state.qis[qii]][pli][qti];
1361 : }
1362 : }
1363 : }
1364 : /*Set the previous DC predictor to 0 for all color planes and frame types.*/
1365 0 : memset(_pipe->pred_last,0,sizeof(_pipe->pred_last));
1366 : /*Initialize the bounding value array for the loop filter.*/
1367 0 : flimit=_dec->state.loop_filter_limits[_dec->state.qis[0]];
1368 0 : _pipe->loop_filter=flimit!=0;
1369 0 : if(flimit!=0)oc_loop_filter_init(&_dec->state,_pipe->bounding_values,flimit);
1370 : /*Initialize any buffers needed for post-processing.
1371 : We also save the current post-processing level, to guard against the user
1372 : changing it from a callback.*/
1373 0 : if(!oc_dec_postprocess_init(_dec))_pipe->pp_level=_dec->pp_level;
1374 : /*If we don't have enough information to post-process, disable it, regardless
1375 : of the user-requested level.*/
1376 : else{
1377 0 : _pipe->pp_level=OC_PP_LEVEL_DISABLED;
1378 0 : memcpy(_dec->pp_frame_buf,
1379 0 : _dec->state.ref_frame_bufs[_dec->state.ref_frame_idx[OC_FRAME_SELF]],
1380 : sizeof(_dec->pp_frame_buf[0])*3);
1381 : }
1382 : /*Clear down the DCT coefficient buffer for the first block.*/
1383 0 : for(zzi=0;zzi<64;zzi++)_pipe->dct_coeffs[zzi]=0;
1384 0 : }
1385 :
1386 : /*Undo the DC prediction in a single plane of an MCU (one or two super block
1387 : rows).
1388 : As a side effect, the number of coded and uncoded fragments in this plane of
1389 : the MCU is also computed.*/
1390 0 : void oc_dec_dc_unpredict_mcu_plane_c(oc_dec_ctx *_dec,
1391 : oc_dec_pipeline_state *_pipe,int _pli){
1392 : const oc_fragment_plane *fplane;
1393 : oc_fragment *frags;
1394 : int *pred_last;
1395 : ptrdiff_t ncoded_fragis;
1396 : ptrdiff_t fragi;
1397 : int fragx;
1398 : int fragy;
1399 : int fragy0;
1400 : int fragy_end;
1401 : int nhfrags;
1402 : /*Compute the first and last fragment row of the current MCU for this
1403 : plane.*/
1404 0 : fplane=_dec->state.fplanes+_pli;
1405 0 : fragy0=_pipe->fragy0[_pli];
1406 0 : fragy_end=_pipe->fragy_end[_pli];
1407 0 : nhfrags=fplane->nhfrags;
1408 0 : pred_last=_pipe->pred_last[_pli];
1409 0 : frags=_dec->state.frags;
1410 0 : ncoded_fragis=0;
1411 0 : fragi=fplane->froffset+fragy0*(ptrdiff_t)nhfrags;
1412 0 : for(fragy=fragy0;fragy<fragy_end;fragy++){
1413 0 : if(fragy==0){
1414 : /*For the first row, all of the cases reduce to just using the previous
1415 : predictor for the same reference frame.*/
1416 0 : for(fragx=0;fragx<nhfrags;fragx++,fragi++){
1417 0 : if(frags[fragi].coded){
1418 : int refi;
1419 0 : refi=frags[fragi].refi;
1420 0 : pred_last[refi]=frags[fragi].dc+=pred_last[refi];
1421 0 : ncoded_fragis++;
1422 : }
1423 : }
1424 : }
1425 : else{
1426 : oc_fragment *u_frags;
1427 : int l_ref;
1428 : int ul_ref;
1429 : int u_ref;
1430 0 : u_frags=frags-nhfrags;
1431 0 : l_ref=-1;
1432 0 : ul_ref=-1;
1433 0 : u_ref=u_frags[fragi].refi;
1434 0 : for(fragx=0;fragx<nhfrags;fragx++,fragi++){
1435 : int ur_ref;
1436 0 : if(fragx+1>=nhfrags)ur_ref=-1;
1437 0 : else ur_ref=u_frags[fragi+1].refi;
1438 0 : if(frags[fragi].coded){
1439 : int pred;
1440 : int refi;
1441 0 : refi=frags[fragi].refi;
1442 : /*We break out a separate case based on which of our neighbors use
1443 : the same reference frames.
1444 : This is somewhat faster than trying to make a generic case which
1445 : handles all of them, since it reduces lots of poorly predicted
1446 : jumps to one switch statement, and also lets a number of the
1447 : multiplications be optimized out by strength reduction.*/
1448 0 : switch((l_ref==refi)|(ul_ref==refi)<<1|
1449 0 : (u_ref==refi)<<2|(ur_ref==refi)<<3){
1450 0 : default:pred=pred_last[refi];break;
1451 : case 1:
1452 0 : case 3:pred=frags[fragi-1].dc;break;
1453 0 : case 2:pred=u_frags[fragi-1].dc;break;
1454 : case 4:
1455 : case 6:
1456 0 : case 12:pred=u_frags[fragi].dc;break;
1457 0 : case 5:pred=(frags[fragi-1].dc+u_frags[fragi].dc)/2;break;
1458 0 : case 8:pred=u_frags[fragi+1].dc;break;
1459 : case 9:
1460 : case 11:
1461 : case 13:{
1462 : /*The TI compiler mis-compiles this line.*/
1463 0 : pred=(75*frags[fragi-1].dc+53*u_frags[fragi+1].dc)/128;
1464 0 : }break;
1465 0 : case 10:pred=(u_frags[fragi-1].dc+u_frags[fragi+1].dc)/2;break;
1466 : case 14:{
1467 0 : pred=(3*(u_frags[fragi-1].dc+u_frags[fragi+1].dc)
1468 0 : +10*u_frags[fragi].dc)/16;
1469 0 : }break;
1470 : case 7:
1471 : case 15:{
1472 : int p0;
1473 : int p1;
1474 : int p2;
1475 0 : p0=frags[fragi-1].dc;
1476 0 : p1=u_frags[fragi-1].dc;
1477 0 : p2=u_frags[fragi].dc;
1478 0 : pred=(29*(p0+p2)-26*p1)/32;
1479 0 : if(abs(pred-p2)>128)pred=p2;
1480 0 : else if(abs(pred-p0)>128)pred=p0;
1481 0 : else if(abs(pred-p1)>128)pred=p1;
1482 0 : }break;
1483 : }
1484 0 : pred_last[refi]=frags[fragi].dc+=pred;
1485 0 : ncoded_fragis++;
1486 0 : l_ref=refi;
1487 : }
1488 0 : else l_ref=-1;
1489 0 : ul_ref=u_ref;
1490 0 : u_ref=ur_ref;
1491 : }
1492 : }
1493 : }
1494 0 : _pipe->ncoded_fragis[_pli]=ncoded_fragis;
1495 : /*Also save the number of uncoded fragments so we know how many to copy.*/
1496 0 : _pipe->nuncoded_fragis[_pli]=
1497 0 : (fragy_end-fragy0)*(ptrdiff_t)nhfrags-ncoded_fragis;
1498 0 : }
1499 :
1500 : /*Reconstructs all coded fragments in a single MCU (one or two super block
1501 : rows).
1502 : This requires that each coded fragment have a proper macro block mode and
1503 : motion vector (if not in INTRA mode), and have its DC value decoded, with
1504 : the DC prediction process reversed, and the number of coded and uncoded
1505 : fragments in this plane of the MCU be counted.
1506 : The token lists for each color plane and coefficient should also be filled
1507 : in, along with initial token offsets, extra bits offsets, and EOB run
1508 : counts.*/
1509 0 : static void oc_dec_frags_recon_mcu_plane(oc_dec_ctx *_dec,
1510 : oc_dec_pipeline_state *_pipe,int _pli){
1511 : unsigned char *dct_tokens;
1512 : const unsigned char *dct_fzig_zag;
1513 : ogg_uint16_t dc_quant[2];
1514 : const oc_fragment *frags;
1515 : const ptrdiff_t *coded_fragis;
1516 : ptrdiff_t ncoded_fragis;
1517 : ptrdiff_t fragii;
1518 : ptrdiff_t *ti;
1519 : ptrdiff_t *eob_runs;
1520 : int qti;
1521 0 : dct_tokens=_dec->dct_tokens;
1522 0 : dct_fzig_zag=_dec->state.opt_data.dct_fzig_zag;
1523 0 : frags=_dec->state.frags;
1524 0 : coded_fragis=_pipe->coded_fragis[_pli];
1525 0 : ncoded_fragis=_pipe->ncoded_fragis[_pli];
1526 0 : ti=_pipe->ti[_pli];
1527 0 : eob_runs=_pipe->eob_runs[_pli];
1528 0 : for(qti=0;qti<2;qti++)dc_quant[qti]=_pipe->dequant[_pli][0][qti][0];
1529 0 : for(fragii=0;fragii<ncoded_fragis;fragii++){
1530 : const ogg_uint16_t *ac_quant;
1531 : ptrdiff_t fragi;
1532 : int last_zzi;
1533 : int zzi;
1534 0 : fragi=coded_fragis[fragii];
1535 0 : qti=frags[fragi].mb_mode!=OC_MODE_INTRA;
1536 0 : ac_quant=_pipe->dequant[_pli][frags[fragi].qii][qti];
1537 : /*Decode the AC coefficients.*/
1538 0 : for(zzi=0;zzi<64;){
1539 : int token;
1540 0 : last_zzi=zzi;
1541 0 : if(eob_runs[zzi]){
1542 0 : eob_runs[zzi]--;
1543 0 : break;
1544 : }
1545 : else{
1546 : ptrdiff_t eob;
1547 : int cw;
1548 : int rlen;
1549 : int coeff;
1550 : int lti;
1551 0 : lti=ti[zzi];
1552 0 : token=dct_tokens[lti++];
1553 0 : cw=OC_DCT_CODE_WORD[token];
1554 : /*These parts could be done branchless, but the branches are fairly
1555 : predictable and the C code translates into more than a few
1556 : instructions, so it's worth it to avoid them.*/
1557 0 : if(OC_DCT_TOKEN_NEEDS_MORE(token)){
1558 0 : cw+=dct_tokens[lti++]<<OC_DCT_TOKEN_EB_POS(token);
1559 : }
1560 0 : eob=cw>>OC_DCT_CW_EOB_SHIFT&0xFFF;
1561 0 : if(token==OC_DCT_TOKEN_FAT_EOB){
1562 0 : eob+=dct_tokens[lti++]<<8;
1563 0 : if(eob==0)eob=OC_DCT_EOB_FINISH;
1564 : }
1565 0 : rlen=(unsigned char)(cw>>OC_DCT_CW_RLEN_SHIFT);
1566 0 : cw^=-(cw&1<<OC_DCT_CW_FLIP_BIT);
1567 0 : coeff=cw>>OC_DCT_CW_MAG_SHIFT;
1568 0 : eob_runs[zzi]=eob;
1569 0 : ti[zzi]=lti;
1570 0 : zzi+=rlen;
1571 0 : _pipe->dct_coeffs[dct_fzig_zag[zzi]]=
1572 0 : (ogg_int16_t)(coeff*(int)ac_quant[zzi]);
1573 0 : zzi+=!eob;
1574 : }
1575 : }
1576 : /*TODO: zzi should be exactly 64 here.
1577 : If it's not, we should report some kind of warning.*/
1578 0 : zzi=OC_MINI(zzi,64);
1579 0 : _pipe->dct_coeffs[0]=(ogg_int16_t)frags[fragi].dc;
1580 : /*last_zzi is always initialized.
1581 : If your compiler thinks otherwise, it is dumb.*/
1582 0 : oc_state_frag_recon(&_dec->state,fragi,_pli,
1583 0 : _pipe->dct_coeffs,last_zzi,dc_quant[qti]);
1584 : }
1585 0 : _pipe->coded_fragis[_pli]+=ncoded_fragis;
1586 : /*Right now the reconstructed MCU has only the coded blocks in it.*/
1587 : /*TODO: We make the decision here to always copy the uncoded blocks into it
1588 : from the reference frame.
1589 : We could also copy the coded blocks back over the reference frame, if we
1590 : wait for an additional MCU to be decoded, which might be faster if only a
1591 : small number of blocks are coded.
1592 : However, this introduces more latency, creating a larger cache footprint.
1593 : It's unknown which decision is better, but this one results in simpler
1594 : code, and the hard case (high bitrate, high resolution) is handled
1595 : correctly.*/
1596 : /*Copy the uncoded blocks from the previous reference frame.*/
1597 0 : if(_pipe->nuncoded_fragis[_pli]>0){
1598 0 : _pipe->uncoded_fragis[_pli]-=_pipe->nuncoded_fragis[_pli];
1599 0 : oc_frag_copy_list(&_dec->state,
1600 : _dec->state.ref_frame_data[OC_FRAME_SELF],
1601 : _dec->state.ref_frame_data[OC_FRAME_PREV],
1602 : _dec->state.ref_ystride[_pli],_pipe->uncoded_fragis[_pli],
1603 : _pipe->nuncoded_fragis[_pli],_dec->state.frag_buf_offs);
1604 : }
1605 0 : }
1606 :
1607 : /*Filter a horizontal block edge.*/
1608 0 : static void oc_filter_hedge(unsigned char *_dst,int _dst_ystride,
1609 : const unsigned char *_src,int _src_ystride,int _qstep,int _flimit,
1610 : int *_variance0,int *_variance1){
1611 : unsigned char *rdst;
1612 : const unsigned char *rsrc;
1613 : unsigned char *cdst;
1614 : const unsigned char *csrc;
1615 : int r[10];
1616 : int sum0;
1617 : int sum1;
1618 : int bx;
1619 : int by;
1620 0 : rdst=_dst;
1621 0 : rsrc=_src;
1622 0 : for(bx=0;bx<8;bx++){
1623 0 : cdst=rdst;
1624 0 : csrc=rsrc;
1625 0 : for(by=0;by<10;by++){
1626 0 : r[by]=*csrc;
1627 0 : csrc+=_src_ystride;
1628 : }
1629 0 : sum0=sum1=0;
1630 0 : for(by=0;by<4;by++){
1631 0 : sum0+=abs(r[by+1]-r[by]);
1632 0 : sum1+=abs(r[by+5]-r[by+6]);
1633 : }
1634 0 : *_variance0+=OC_MINI(255,sum0);
1635 0 : *_variance1+=OC_MINI(255,sum1);
1636 0 : if(sum0<_flimit&&sum1<_flimit&&r[5]-r[4]<_qstep&&r[4]-r[5]<_qstep){
1637 0 : *cdst=(unsigned char)(r[0]*3+r[1]*2+r[2]+r[3]+r[4]+4>>3);
1638 0 : cdst+=_dst_ystride;
1639 0 : *cdst=(unsigned char)(r[0]*2+r[1]+r[2]*2+r[3]+r[4]+r[5]+4>>3);
1640 0 : cdst+=_dst_ystride;
1641 0 : for(by=0;by<4;by++){
1642 0 : *cdst=(unsigned char)(r[by]+r[by+1]+r[by+2]+r[by+3]*2+
1643 0 : r[by+4]+r[by+5]+r[by+6]+4>>3);
1644 0 : cdst+=_dst_ystride;
1645 : }
1646 0 : *cdst=(unsigned char)(r[4]+r[5]+r[6]+r[7]*2+r[8]+r[9]*2+4>>3);
1647 0 : cdst+=_dst_ystride;
1648 0 : *cdst=(unsigned char)(r[5]+r[6]+r[7]+r[8]*2+r[9]*3+4>>3);
1649 : }
1650 : else{
1651 0 : for(by=1;by<=8;by++){
1652 0 : *cdst=(unsigned char)r[by];
1653 0 : cdst+=_dst_ystride;
1654 : }
1655 : }
1656 0 : rdst++;
1657 0 : rsrc++;
1658 : }
1659 0 : }
1660 :
1661 : /*Filter a vertical block edge.*/
1662 0 : static void oc_filter_vedge(unsigned char *_dst,int _dst_ystride,
1663 : int _qstep,int _flimit,int *_variances){
1664 : unsigned char *rdst;
1665 : const unsigned char *rsrc;
1666 : unsigned char *cdst;
1667 : int r[10];
1668 : int sum0;
1669 : int sum1;
1670 : int bx;
1671 : int by;
1672 0 : cdst=_dst;
1673 0 : for(by=0;by<8;by++){
1674 0 : rsrc=cdst-1;
1675 0 : rdst=cdst;
1676 0 : for(bx=0;bx<10;bx++)r[bx]=*rsrc++;
1677 0 : sum0=sum1=0;
1678 0 : for(bx=0;bx<4;bx++){
1679 0 : sum0+=abs(r[bx+1]-r[bx]);
1680 0 : sum1+=abs(r[bx+5]-r[bx+6]);
1681 : }
1682 0 : _variances[0]+=OC_MINI(255,sum0);
1683 0 : _variances[1]+=OC_MINI(255,sum1);
1684 0 : if(sum0<_flimit&&sum1<_flimit&&r[5]-r[4]<_qstep&&r[4]-r[5]<_qstep){
1685 0 : *rdst++=(unsigned char)(r[0]*3+r[1]*2+r[2]+r[3]+r[4]+4>>3);
1686 0 : *rdst++=(unsigned char)(r[0]*2+r[1]+r[2]*2+r[3]+r[4]+r[5]+4>>3);
1687 0 : for(bx=0;bx<4;bx++){
1688 0 : *rdst++=(unsigned char)(r[bx]+r[bx+1]+r[bx+2]+r[bx+3]*2+
1689 0 : r[bx+4]+r[bx+5]+r[bx+6]+4>>3);
1690 : }
1691 0 : *rdst++=(unsigned char)(r[4]+r[5]+r[6]+r[7]*2+r[8]+r[9]*2+4>>3);
1692 0 : *rdst=(unsigned char)(r[5]+r[6]+r[7]+r[8]*2+r[9]*3+4>>3);
1693 : }
1694 0 : cdst+=_dst_ystride;
1695 : }
1696 0 : }
1697 :
1698 0 : static void oc_dec_deblock_frag_rows(oc_dec_ctx *_dec,
1699 : th_img_plane *_dst,th_img_plane *_src,int _pli,int _fragy0,
1700 : int _fragy_end){
1701 : oc_fragment_plane *fplane;
1702 : int *variance;
1703 : unsigned char *dc_qi;
1704 : unsigned char *dst;
1705 : const unsigned char *src;
1706 : ptrdiff_t froffset;
1707 : int dst_ystride;
1708 : int src_ystride;
1709 : int nhfrags;
1710 : int width;
1711 : int notstart;
1712 : int notdone;
1713 : int flimit;
1714 : int qstep;
1715 : int y_end;
1716 : int y;
1717 : int x;
1718 0 : _dst+=_pli;
1719 0 : _src+=_pli;
1720 0 : fplane=_dec->state.fplanes+_pli;
1721 0 : nhfrags=fplane->nhfrags;
1722 0 : froffset=fplane->froffset+_fragy0*(ptrdiff_t)nhfrags;
1723 0 : variance=_dec->variances+froffset;
1724 0 : dc_qi=_dec->dc_qis+froffset;
1725 0 : notstart=_fragy0>0;
1726 0 : notdone=_fragy_end<fplane->nvfrags;
1727 : /*We want to clear an extra row of variances, except at the end.*/
1728 0 : memset(variance+(nhfrags&-notstart),0,
1729 0 : (_fragy_end+notdone-_fragy0-notstart)*(nhfrags*sizeof(variance[0])));
1730 : /*Except for the first time, we want to point to the middle of the row.*/
1731 0 : y=(_fragy0<<3)+(notstart<<2);
1732 0 : dst_ystride=_dst->stride;
1733 0 : src_ystride=_src->stride;
1734 0 : dst=_dst->data+y*(ptrdiff_t)dst_ystride;
1735 0 : src=_src->data+y*(ptrdiff_t)src_ystride;
1736 0 : width=_dst->width;
1737 0 : for(;y<4;y++){
1738 0 : memcpy(dst,src,width*sizeof(dst[0]));
1739 0 : dst+=dst_ystride;
1740 0 : src+=src_ystride;
1741 : }
1742 : /*We also want to skip the last row in the frame for this loop.*/
1743 0 : y_end=_fragy_end-!notdone<<3;
1744 0 : for(;y<y_end;y+=8){
1745 0 : qstep=_dec->pp_dc_scale[*dc_qi];
1746 0 : flimit=(qstep*3)>>2;
1747 0 : oc_filter_hedge(dst,dst_ystride,src-src_ystride,src_ystride,
1748 0 : qstep,flimit,variance,variance+nhfrags);
1749 0 : variance++;
1750 0 : dc_qi++;
1751 0 : for(x=8;x<width;x+=8){
1752 0 : qstep=_dec->pp_dc_scale[*dc_qi];
1753 0 : flimit=(qstep*3)>>2;
1754 0 : oc_filter_hedge(dst+x,dst_ystride,src+x-src_ystride,src_ystride,
1755 0 : qstep,flimit,variance,variance+nhfrags);
1756 0 : oc_filter_vedge(dst+x-(dst_ystride<<2)-4,dst_ystride,
1757 : qstep,flimit,variance-1);
1758 0 : variance++;
1759 0 : dc_qi++;
1760 : }
1761 0 : dst+=dst_ystride<<3;
1762 0 : src+=src_ystride<<3;
1763 : }
1764 : /*And finally, handle the last row in the frame, if it's in the range.*/
1765 0 : if(!notdone){
1766 : int height;
1767 0 : height=_dst->height;
1768 0 : for(;y<height;y++){
1769 0 : memcpy(dst,src,width*sizeof(dst[0]));
1770 0 : dst+=dst_ystride;
1771 0 : src+=src_ystride;
1772 : }
1773 : /*Filter the last row of vertical block edges.*/
1774 0 : dc_qi++;
1775 0 : for(x=8;x<width;x+=8){
1776 0 : qstep=_dec->pp_dc_scale[*dc_qi++];
1777 0 : flimit=(qstep*3)>>2;
1778 0 : oc_filter_vedge(dst+x-(dst_ystride<<3)-4,dst_ystride,
1779 : qstep,flimit,variance++);
1780 : }
1781 : }
1782 0 : }
1783 :
1784 0 : static void oc_dering_block(unsigned char *_idata,int _ystride,int _b,
1785 : int _dc_scale,int _sharp_mod,int _strong){
1786 : static const unsigned char OC_MOD_MAX[2]={24,32};
1787 : static const unsigned char OC_MOD_SHIFT[2]={1,0};
1788 : const unsigned char *psrc;
1789 : const unsigned char *src;
1790 : const unsigned char *nsrc;
1791 : unsigned char *dst;
1792 : int vmod[72];
1793 : int hmod[72];
1794 : int mod_hi;
1795 : int by;
1796 : int bx;
1797 0 : mod_hi=OC_MINI(3*_dc_scale,OC_MOD_MAX[_strong]);
1798 0 : dst=_idata;
1799 0 : src=dst;
1800 0 : psrc=src-(_ystride&-!(_b&4));
1801 0 : for(by=0;by<9;by++){
1802 0 : for(bx=0;bx<8;bx++){
1803 : int mod;
1804 0 : mod=32+_dc_scale-(abs(src[bx]-psrc[bx])<<OC_MOD_SHIFT[_strong]);
1805 0 : vmod[(by<<3)+bx]=mod<-64?_sharp_mod:OC_CLAMPI(0,mod,mod_hi);
1806 : }
1807 0 : psrc=src;
1808 0 : src+=_ystride&-(!(_b&8)|by<7);
1809 : }
1810 0 : nsrc=dst;
1811 0 : psrc=dst-!(_b&1);
1812 0 : for(bx=0;bx<9;bx++){
1813 0 : src=nsrc;
1814 0 : for(by=0;by<8;by++){
1815 : int mod;
1816 0 : mod=32+_dc_scale-(abs(*src-*psrc)<<OC_MOD_SHIFT[_strong]);
1817 0 : hmod[(bx<<3)+by]=mod<-64?_sharp_mod:OC_CLAMPI(0,mod,mod_hi);
1818 0 : psrc+=_ystride;
1819 0 : src+=_ystride;
1820 : }
1821 0 : psrc=nsrc;
1822 0 : nsrc+=!(_b&2)|bx<7;
1823 : }
1824 0 : src=dst;
1825 0 : psrc=src-(_ystride&-!(_b&4));
1826 0 : nsrc=src+_ystride;
1827 0 : for(by=0;by<8;by++){
1828 : int a;
1829 : int b;
1830 : int w;
1831 0 : a=128;
1832 0 : b=64;
1833 0 : w=hmod[by];
1834 0 : a-=w;
1835 0 : b+=w**(src-!(_b&1));
1836 0 : w=vmod[by<<3];
1837 0 : a-=w;
1838 0 : b+=w*psrc[0];
1839 0 : w=vmod[by+1<<3];
1840 0 : a-=w;
1841 0 : b+=w*nsrc[0];
1842 0 : w=hmod[(1<<3)+by];
1843 0 : a-=w;
1844 0 : b+=w*src[1];
1845 0 : dst[0]=OC_CLAMP255(a*src[0]+b>>7);
1846 0 : for(bx=1;bx<7;bx++){
1847 0 : a=128;
1848 0 : b=64;
1849 0 : w=hmod[(bx<<3)+by];
1850 0 : a-=w;
1851 0 : b+=w*src[bx-1];
1852 0 : w=vmod[(by<<3)+bx];
1853 0 : a-=w;
1854 0 : b+=w*psrc[bx];
1855 0 : w=vmod[(by+1<<3)+bx];
1856 0 : a-=w;
1857 0 : b+=w*nsrc[bx];
1858 0 : w=hmod[(bx+1<<3)+by];
1859 0 : a-=w;
1860 0 : b+=w*src[bx+1];
1861 0 : dst[bx]=OC_CLAMP255(a*src[bx]+b>>7);
1862 : }
1863 0 : a=128;
1864 0 : b=64;
1865 0 : w=hmod[(7<<3)+by];
1866 0 : a-=w;
1867 0 : b+=w*src[6];
1868 0 : w=vmod[(by<<3)+7];
1869 0 : a-=w;
1870 0 : b+=w*psrc[7];
1871 0 : w=vmod[(by+1<<3)+7];
1872 0 : a-=w;
1873 0 : b+=w*nsrc[7];
1874 0 : w=hmod[(8<<3)+by];
1875 0 : a-=w;
1876 0 : b+=w*src[7+!(_b&2)];
1877 0 : dst[7]=OC_CLAMP255(a*src[7]+b>>7);
1878 0 : dst+=_ystride;
1879 0 : psrc=src;
1880 0 : src=nsrc;
1881 0 : nsrc+=_ystride&-(!(_b&8)|by<6);
1882 : }
1883 0 : }
1884 :
1885 : #define OC_DERING_THRESH1 (384)
1886 : #define OC_DERING_THRESH2 (4*OC_DERING_THRESH1)
1887 : #define OC_DERING_THRESH3 (5*OC_DERING_THRESH1)
1888 : #define OC_DERING_THRESH4 (10*OC_DERING_THRESH1)
1889 :
1890 0 : static void oc_dec_dering_frag_rows(oc_dec_ctx *_dec,th_img_plane *_img,
1891 : int _pli,int _fragy0,int _fragy_end){
1892 : th_img_plane *iplane;
1893 : oc_fragment_plane *fplane;
1894 : oc_fragment *frag;
1895 : int *variance;
1896 : unsigned char *idata;
1897 : ptrdiff_t froffset;
1898 : int ystride;
1899 : int nhfrags;
1900 : int sthresh;
1901 : int strong;
1902 : int y_end;
1903 : int width;
1904 : int height;
1905 : int y;
1906 : int x;
1907 0 : iplane=_img+_pli;
1908 0 : fplane=_dec->state.fplanes+_pli;
1909 0 : nhfrags=fplane->nhfrags;
1910 0 : froffset=fplane->froffset+_fragy0*(ptrdiff_t)nhfrags;
1911 0 : variance=_dec->variances+froffset;
1912 0 : frag=_dec->state.frags+froffset;
1913 0 : strong=_dec->pp_level>=(_pli?OC_PP_LEVEL_SDERINGC:OC_PP_LEVEL_SDERINGY);
1914 0 : sthresh=_pli?OC_DERING_THRESH4:OC_DERING_THRESH3;
1915 0 : y=_fragy0<<3;
1916 0 : ystride=iplane->stride;
1917 0 : idata=iplane->data+y*(ptrdiff_t)ystride;
1918 0 : y_end=_fragy_end<<3;
1919 0 : width=iplane->width;
1920 0 : height=iplane->height;
1921 0 : for(;y<y_end;y+=8){
1922 0 : for(x=0;x<width;x+=8){
1923 : int b;
1924 : int qi;
1925 : int var;
1926 0 : qi=_dec->state.qis[frag->qii];
1927 0 : var=*variance;
1928 0 : b=(x<=0)|(x+8>=width)<<1|(y<=0)<<2|(y+8>=height)<<3;
1929 0 : if(strong&&var>sthresh){
1930 0 : oc_dering_block(idata+x,ystride,b,
1931 : _dec->pp_dc_scale[qi],_dec->pp_sharp_mod[qi],1);
1932 0 : if(_pli||!(b&1)&&*(variance-1)>OC_DERING_THRESH4||
1933 0 : !(b&2)&&variance[1]>OC_DERING_THRESH4||
1934 0 : !(b&4)&&*(variance-nhfrags)>OC_DERING_THRESH4||
1935 0 : !(b&8)&&variance[nhfrags]>OC_DERING_THRESH4){
1936 0 : oc_dering_block(idata+x,ystride,b,
1937 : _dec->pp_dc_scale[qi],_dec->pp_sharp_mod[qi],1);
1938 0 : oc_dering_block(idata+x,ystride,b,
1939 : _dec->pp_dc_scale[qi],_dec->pp_sharp_mod[qi],1);
1940 : }
1941 : }
1942 0 : else if(var>OC_DERING_THRESH2){
1943 0 : oc_dering_block(idata+x,ystride,b,
1944 : _dec->pp_dc_scale[qi],_dec->pp_sharp_mod[qi],1);
1945 : }
1946 0 : else if(var>OC_DERING_THRESH1){
1947 0 : oc_dering_block(idata+x,ystride,b,
1948 : _dec->pp_dc_scale[qi],_dec->pp_sharp_mod[qi],0);
1949 : }
1950 0 : frag++;
1951 0 : variance++;
1952 : }
1953 0 : idata+=ystride<<3;
1954 : }
1955 0 : }
1956 :
1957 :
1958 :
1959 0 : th_dec_ctx *th_decode_alloc(const th_info *_info,const th_setup_info *_setup){
1960 : oc_dec_ctx *dec;
1961 0 : if(_info==NULL||_setup==NULL)return NULL;
1962 0 : dec=oc_aligned_malloc(sizeof(*dec),16);
1963 0 : if(dec==NULL||oc_dec_init(dec,_info,_setup)<0){
1964 0 : oc_aligned_free(dec);
1965 0 : return NULL;
1966 : }
1967 0 : dec->state.curframe_num=0;
1968 0 : return dec;
1969 : }
1970 :
1971 0 : void th_decode_free(th_dec_ctx *_dec){
1972 0 : if(_dec!=NULL){
1973 0 : oc_dec_clear(_dec);
1974 0 : oc_aligned_free(_dec);
1975 : }
1976 0 : }
1977 :
1978 0 : int th_decode_ctl(th_dec_ctx *_dec,int _req,void *_buf,
1979 : size_t _buf_sz){
1980 0 : switch(_req){
1981 : case TH_DECCTL_GET_PPLEVEL_MAX:{
1982 0 : if(_dec==NULL||_buf==NULL)return TH_EFAULT;
1983 0 : if(_buf_sz!=sizeof(int))return TH_EINVAL;
1984 0 : (*(int *)_buf)=OC_PP_LEVEL_MAX;
1985 0 : return 0;
1986 : }break;
1987 : case TH_DECCTL_SET_PPLEVEL:{
1988 : int pp_level;
1989 0 : if(_dec==NULL||_buf==NULL)return TH_EFAULT;
1990 0 : if(_buf_sz!=sizeof(int))return TH_EINVAL;
1991 0 : pp_level=*(int *)_buf;
1992 0 : if(pp_level<0||pp_level>OC_PP_LEVEL_MAX)return TH_EINVAL;
1993 0 : _dec->pp_level=pp_level;
1994 0 : return 0;
1995 : }break;
1996 : case TH_DECCTL_SET_GRANPOS:{
1997 : ogg_int64_t granpos;
1998 0 : if(_dec==NULL||_buf==NULL)return TH_EFAULT;
1999 0 : if(_buf_sz!=sizeof(ogg_int64_t))return TH_EINVAL;
2000 0 : granpos=*(ogg_int64_t *)_buf;
2001 0 : if(granpos<0)return TH_EINVAL;
2002 0 : _dec->state.granpos=granpos;
2003 0 : _dec->state.keyframe_num=(granpos>>_dec->state.info.keyframe_granule_shift)
2004 0 : -_dec->state.granpos_bias;
2005 0 : _dec->state.curframe_num=_dec->state.keyframe_num
2006 0 : +(granpos&(1<<_dec->state.info.keyframe_granule_shift)-1);
2007 0 : return 0;
2008 : }break;
2009 : case TH_DECCTL_SET_STRIPE_CB:{
2010 : th_stripe_callback *cb;
2011 0 : if(_dec==NULL||_buf==NULL)return TH_EFAULT;
2012 0 : if(_buf_sz!=sizeof(th_stripe_callback))return TH_EINVAL;
2013 0 : cb=(th_stripe_callback *)_buf;
2014 0 : _dec->stripe_cb.ctx=cb->ctx;
2015 0 : _dec->stripe_cb.stripe_decoded=cb->stripe_decoded;
2016 0 : return 0;
2017 : }break;
2018 : #ifdef HAVE_CAIRO
2019 : case TH_DECCTL_SET_TELEMETRY_MBMODE:{
2020 : if(_dec==NULL||_buf==NULL)return TH_EFAULT;
2021 : if(_buf_sz!=sizeof(int))return TH_EINVAL;
2022 : _dec->telemetry=1;
2023 : _dec->telemetry_mbmode=*(int *)_buf;
2024 : return 0;
2025 : }break;
2026 : case TH_DECCTL_SET_TELEMETRY_MV:{
2027 : if(_dec==NULL||_buf==NULL)return TH_EFAULT;
2028 : if(_buf_sz!=sizeof(int))return TH_EINVAL;
2029 : _dec->telemetry=1;
2030 : _dec->telemetry_mv=*(int *)_buf;
2031 : return 0;
2032 : }break;
2033 : case TH_DECCTL_SET_TELEMETRY_QI:{
2034 : if(_dec==NULL||_buf==NULL)return TH_EFAULT;
2035 : if(_buf_sz!=sizeof(int))return TH_EINVAL;
2036 : _dec->telemetry=1;
2037 : _dec->telemetry_qi=*(int *)_buf;
2038 : return 0;
2039 : }break;
2040 : case TH_DECCTL_SET_TELEMETRY_BITS:{
2041 : if(_dec==NULL||_buf==NULL)return TH_EFAULT;
2042 : if(_buf_sz!=sizeof(int))return TH_EINVAL;
2043 : _dec->telemetry=1;
2044 : _dec->telemetry_bits=*(int *)_buf;
2045 : return 0;
2046 : }break;
2047 : #endif
2048 0 : default:return TH_EIMPL;
2049 : }
2050 : }
2051 :
2052 : /*We're decoding an INTER frame, but have no initialized reference
2053 : buffers (i.e., decoding did not start on a key frame).
2054 : We initialize them to a solid gray here.*/
2055 0 : static void oc_dec_init_dummy_frame(th_dec_ctx *_dec){
2056 : th_info *info;
2057 : size_t yplane_sz;
2058 : size_t cplane_sz;
2059 : ptrdiff_t yoffset;
2060 : int yhstride;
2061 : int yheight;
2062 : int chstride;
2063 : int cheight;
2064 0 : _dec->state.ref_frame_idx[OC_FRAME_GOLD]=0;
2065 0 : _dec->state.ref_frame_idx[OC_FRAME_PREV]=0;
2066 0 : _dec->state.ref_frame_idx[OC_FRAME_SELF]=0;
2067 0 : _dec->state.ref_frame_data[OC_FRAME_GOLD]=
2068 0 : _dec->state.ref_frame_data[OC_FRAME_PREV]=
2069 0 : _dec->state.ref_frame_data[OC_FRAME_SELF]=
2070 0 : _dec->state.ref_frame_bufs[0][0].data;
2071 0 : memcpy(_dec->pp_frame_buf,_dec->state.ref_frame_bufs[0],
2072 : sizeof(_dec->pp_frame_buf[0])*3);
2073 0 : info=&_dec->state.info;
2074 0 : yhstride=abs(_dec->state.ref_ystride[0]);
2075 0 : yheight=info->frame_height+2*OC_UMV_PADDING;
2076 0 : chstride=abs(_dec->state.ref_ystride[1]);
2077 0 : cheight=yheight>>!(info->pixel_fmt&2);
2078 0 : yplane_sz=yhstride*(size_t)yheight+16;
2079 0 : cplane_sz=chstride*(size_t)cheight;
2080 0 : yoffset=yhstride*(ptrdiff_t)(yheight-OC_UMV_PADDING-1)+OC_UMV_PADDING;
2081 0 : memset(_dec->state.ref_frame_data[0]-yoffset,0x80,yplane_sz+2*cplane_sz);
2082 0 : }
2083 :
2084 0 : int th_decode_packetin(th_dec_ctx *_dec,const ogg_packet *_op,
2085 : ogg_int64_t *_granpos){
2086 : int ret;
2087 0 : if(_dec==NULL||_op==NULL)return TH_EFAULT;
2088 : /*A completely empty packet indicates a dropped frame and is treated exactly
2089 : like an inter frame with no coded blocks.*/
2090 0 : if(_op->bytes==0){
2091 0 : _dec->state.frame_type=OC_INTER_FRAME;
2092 0 : _dec->state.ntotal_coded_fragis=0;
2093 : }
2094 : else{
2095 0 : oc_pack_readinit(&_dec->opb,_op->packet,_op->bytes);
2096 0 : ret=oc_dec_frame_header_unpack(_dec);
2097 0 : if(ret<0)return ret;
2098 0 : if(_dec->state.frame_type==OC_INTRA_FRAME)oc_dec_mark_all_intra(_dec);
2099 0 : else oc_dec_coded_flags_unpack(_dec);
2100 : }
2101 : /*If there have been no reference frames, and we need one, initialize one.*/
2102 0 : if(_dec->state.frame_type!=OC_INTRA_FRAME&&
2103 0 : (_dec->state.ref_frame_idx[OC_FRAME_GOLD]<0||
2104 0 : _dec->state.ref_frame_idx[OC_FRAME_PREV]<0)){
2105 0 : oc_dec_init_dummy_frame(_dec);
2106 : }
2107 : /*If this was an inter frame with no coded blocks...*/
2108 0 : if(_dec->state.ntotal_coded_fragis<=0){
2109 : /*Just update the granule position and return.*/
2110 0 : _dec->state.granpos=(_dec->state.keyframe_num+_dec->state.granpos_bias<<
2111 0 : _dec->state.info.keyframe_granule_shift)
2112 0 : +(_dec->state.curframe_num-_dec->state.keyframe_num);
2113 0 : _dec->state.curframe_num++;
2114 0 : if(_granpos!=NULL)*_granpos=_dec->state.granpos;
2115 0 : return TH_DUPFRAME;
2116 : }
2117 : else{
2118 : th_ycbcr_buffer stripe_buf;
2119 : int stripe_fragy;
2120 : int refi;
2121 : int pli;
2122 : int notstart;
2123 : int notdone;
2124 : /*Select a free buffer to use for the reconstructed version of this frame.*/
2125 0 : for(refi=0;refi==_dec->state.ref_frame_idx[OC_FRAME_GOLD]||
2126 0 : refi==_dec->state.ref_frame_idx[OC_FRAME_PREV];refi++);
2127 0 : _dec->state.ref_frame_idx[OC_FRAME_SELF]=refi;
2128 0 : _dec->state.ref_frame_data[OC_FRAME_SELF]=
2129 0 : _dec->state.ref_frame_bufs[refi][0].data;
2130 : #if defined(HAVE_CAIRO)
2131 : _dec->telemetry_frame_bytes=_op->bytes;
2132 : #endif
2133 0 : if(_dec->state.frame_type==OC_INTRA_FRAME){
2134 0 : _dec->state.keyframe_num=_dec->state.curframe_num;
2135 : #if defined(HAVE_CAIRO)
2136 : _dec->telemetry_coding_bytes=
2137 : _dec->telemetry_mode_bytes=
2138 : _dec->telemetry_mv_bytes=oc_pack_bytes_left(&_dec->opb);
2139 : #endif
2140 : }
2141 : else{
2142 : #if defined(HAVE_CAIRO)
2143 : _dec->telemetry_coding_bytes=oc_pack_bytes_left(&_dec->opb);
2144 : #endif
2145 0 : oc_dec_mb_modes_unpack(_dec);
2146 : #if defined(HAVE_CAIRO)
2147 : _dec->telemetry_mode_bytes=oc_pack_bytes_left(&_dec->opb);
2148 : #endif
2149 0 : oc_dec_mv_unpack_and_frag_modes_fill(_dec);
2150 : #if defined(HAVE_CAIRO)
2151 : _dec->telemetry_mv_bytes=oc_pack_bytes_left(&_dec->opb);
2152 : #endif
2153 : }
2154 0 : oc_dec_block_qis_unpack(_dec);
2155 : #if defined(HAVE_CAIRO)
2156 : _dec->telemetry_qi_bytes=oc_pack_bytes_left(&_dec->opb);
2157 : #endif
2158 0 : oc_dec_residual_tokens_unpack(_dec);
2159 : /*Update granule position.
2160 : This must be done before the striped decode callbacks so that the
2161 : application knows what to do with the frame data.*/
2162 0 : _dec->state.granpos=(_dec->state.keyframe_num+_dec->state.granpos_bias<<
2163 0 : _dec->state.info.keyframe_granule_shift)
2164 0 : +(_dec->state.curframe_num-_dec->state.keyframe_num);
2165 0 : _dec->state.curframe_num++;
2166 0 : if(_granpos!=NULL)*_granpos=_dec->state.granpos;
2167 : /*All of the rest of the operations -- DC prediction reversal,
2168 : reconstructing coded fragments, copying uncoded fragments, loop
2169 : filtering, extending borders, and out-of-loop post-processing -- should
2170 : be pipelined.
2171 : I.e., DC prediction reversal, reconstruction, and uncoded fragment
2172 : copying are done for one or two super block rows, then loop filtering is
2173 : run as far as it can, then bordering copying, then post-processing.
2174 : For 4:2:0 video a Minimum Codable Unit or MCU contains two luma super
2175 : block rows, and one chroma.
2176 : Otherwise, an MCU consists of one super block row from each plane.
2177 : Inside each MCU, we perform all of the steps on one color plane before
2178 : moving on to the next.
2179 : After reconstruction, the additional filtering stages introduce a delay
2180 : since they need some pixels from the next fragment row.
2181 : Thus the actual number of decoded rows available is slightly smaller for
2182 : the first MCU, and slightly larger for the last.
2183 :
2184 : This entire process allows us to operate on the data while it is still in
2185 : cache, resulting in big performance improvements.
2186 : An application callback allows further application processing (blitting
2187 : to video memory, color conversion, etc.) to also use the data while it's
2188 : in cache.*/
2189 0 : oc_dec_pipeline_init(_dec,&_dec->pipe);
2190 0 : oc_ycbcr_buffer_flip(stripe_buf,_dec->pp_frame_buf);
2191 0 : notstart=0;
2192 0 : notdone=1;
2193 0 : for(stripe_fragy=0;notdone;stripe_fragy+=_dec->pipe.mcu_nvfrags){
2194 : int avail_fragy0;
2195 : int avail_fragy_end;
2196 0 : avail_fragy0=avail_fragy_end=_dec->state.fplanes[0].nvfrags;
2197 0 : notdone=stripe_fragy+_dec->pipe.mcu_nvfrags<avail_fragy_end;
2198 0 : for(pli=0;pli<3;pli++){
2199 : oc_fragment_plane *fplane;
2200 : int frag_shift;
2201 : int pp_offset;
2202 : int sdelay;
2203 : int edelay;
2204 0 : fplane=_dec->state.fplanes+pli;
2205 : /*Compute the first and last fragment row of the current MCU for this
2206 : plane.*/
2207 0 : frag_shift=pli!=0&&!(_dec->state.info.pixel_fmt&2);
2208 0 : _dec->pipe.fragy0[pli]=stripe_fragy>>frag_shift;
2209 0 : _dec->pipe.fragy_end[pli]=OC_MINI(fplane->nvfrags,
2210 : _dec->pipe.fragy0[pli]+(_dec->pipe.mcu_nvfrags>>frag_shift));
2211 0 : oc_dec_dc_unpredict_mcu_plane(_dec,&_dec->pipe,pli);
2212 0 : oc_dec_frags_recon_mcu_plane(_dec,&_dec->pipe,pli);
2213 0 : sdelay=edelay=0;
2214 0 : if(_dec->pipe.loop_filter){
2215 0 : sdelay+=notstart;
2216 0 : edelay+=notdone;
2217 0 : oc_state_loop_filter_frag_rows(&_dec->state,
2218 0 : _dec->pipe.bounding_values,OC_FRAME_SELF,pli,
2219 0 : _dec->pipe.fragy0[pli]-sdelay,_dec->pipe.fragy_end[pli]-edelay);
2220 : }
2221 : /*To fill the borders, we have an additional two pixel delay, since a
2222 : fragment in the next row could filter its top edge, using two pixels
2223 : from a fragment in this row.
2224 : But there's no reason to delay a full fragment between the two.*/
2225 0 : oc_state_borders_fill_rows(&_dec->state,refi,pli,
2226 0 : (_dec->pipe.fragy0[pli]-sdelay<<3)-(sdelay<<1),
2227 0 : (_dec->pipe.fragy_end[pli]-edelay<<3)-(edelay<<1));
2228 : /*Out-of-loop post-processing.*/
2229 0 : pp_offset=3*(pli!=0);
2230 0 : if(_dec->pipe.pp_level>=OC_PP_LEVEL_DEBLOCKY+pp_offset){
2231 : /*Perform de-blocking in one plane.*/
2232 0 : sdelay+=notstart;
2233 0 : edelay+=notdone;
2234 0 : oc_dec_deblock_frag_rows(_dec,_dec->pp_frame_buf,
2235 0 : _dec->state.ref_frame_bufs[refi],pli,
2236 0 : _dec->pipe.fragy0[pli]-sdelay,_dec->pipe.fragy_end[pli]-edelay);
2237 0 : if(_dec->pipe.pp_level>=OC_PP_LEVEL_DERINGY+pp_offset){
2238 : /*Perform de-ringing in one plane.*/
2239 0 : sdelay+=notstart;
2240 0 : edelay+=notdone;
2241 0 : oc_dec_dering_frag_rows(_dec,_dec->pp_frame_buf,pli,
2242 0 : _dec->pipe.fragy0[pli]-sdelay,_dec->pipe.fragy_end[pli]-edelay);
2243 : }
2244 : }
2245 : /*If no post-processing is done, we still need to delay a row for the
2246 : loop filter, thanks to the strange filtering order VP3 chose.*/
2247 0 : else if(_dec->pipe.loop_filter){
2248 0 : sdelay+=notstart;
2249 0 : edelay+=notdone;
2250 : }
2251 : /*Compute the intersection of the available rows in all planes.
2252 : If chroma is sub-sampled, the effect of each of its delays is
2253 : doubled, but luma might have more post-processing filters enabled
2254 : than chroma, so we don't know up front which one is the limiting
2255 : factor.*/
2256 0 : avail_fragy0=OC_MINI(avail_fragy0,
2257 : _dec->pipe.fragy0[pli]-sdelay<<frag_shift);
2258 0 : avail_fragy_end=OC_MINI(avail_fragy_end,
2259 : _dec->pipe.fragy_end[pli]-edelay<<frag_shift);
2260 : }
2261 0 : if(_dec->stripe_cb.stripe_decoded!=NULL){
2262 : /*The callback might want to use the FPU, so let's make sure they can.
2263 : We violate all kinds of ABI restrictions by not doing this until
2264 : now, but none of them actually matter since we don't use floating
2265 : point ourselves.*/
2266 0 : oc_restore_fpu(&_dec->state);
2267 : /*Make the callback, ensuring we flip the sense of the "start" and
2268 : "end" of the available region upside down.*/
2269 0 : (*_dec->stripe_cb.stripe_decoded)(_dec->stripe_cb.ctx,stripe_buf,
2270 0 : _dec->state.fplanes[0].nvfrags-avail_fragy_end,
2271 0 : _dec->state.fplanes[0].nvfrags-avail_fragy0);
2272 : }
2273 0 : notstart=1;
2274 : }
2275 : /*Finish filling in the reference frame borders.*/
2276 0 : for(pli=0;pli<3;pli++)oc_state_borders_fill_caps(&_dec->state,refi,pli);
2277 : /*Update the reference frame indices.*/
2278 0 : if(_dec->state.frame_type==OC_INTRA_FRAME){
2279 : /*The new frame becomes both the previous and gold reference frames.*/
2280 0 : _dec->state.ref_frame_idx[OC_FRAME_GOLD]=
2281 0 : _dec->state.ref_frame_idx[OC_FRAME_PREV]=
2282 0 : _dec->state.ref_frame_idx[OC_FRAME_SELF];
2283 0 : _dec->state.ref_frame_data[OC_FRAME_GOLD]=
2284 0 : _dec->state.ref_frame_data[OC_FRAME_PREV]=
2285 0 : _dec->state.ref_frame_data[OC_FRAME_SELF];
2286 : }
2287 : else{
2288 : /*Otherwise, just replace the previous reference frame.*/
2289 0 : _dec->state.ref_frame_idx[OC_FRAME_PREV]=
2290 0 : _dec->state.ref_frame_idx[OC_FRAME_SELF];
2291 0 : _dec->state.ref_frame_data[OC_FRAME_PREV]=
2292 0 : _dec->state.ref_frame_data[OC_FRAME_SELF];
2293 : }
2294 : /*Restore the FPU before dump_frame, since that _does_ use the FPU (for PNG
2295 : gamma values, if nothing else).*/
2296 0 : oc_restore_fpu(&_dec->state);
2297 : #if defined(OC_DUMP_IMAGES)
2298 : /*We only dump images if there were some coded blocks.*/
2299 : oc_state_dump_frame(&_dec->state,OC_FRAME_SELF,"dec");
2300 : #endif
2301 0 : return 0;
2302 : }
2303 : }
2304 :
2305 0 : int th_decode_ycbcr_out(th_dec_ctx *_dec,th_ycbcr_buffer _ycbcr){
2306 0 : if(_dec==NULL||_ycbcr==NULL)return TH_EFAULT;
2307 0 : oc_ycbcr_buffer_flip(_ycbcr,_dec->pp_frame_buf);
2308 : #if defined(HAVE_CAIRO)
2309 : /*If telemetry ioctls are active, we need to draw to the output buffer.
2310 : Stuff the plane into cairo.*/
2311 : if(_dec->telemetry){
2312 : cairo_surface_t *cs;
2313 : unsigned char *data;
2314 : unsigned char *y_row;
2315 : unsigned char *u_row;
2316 : unsigned char *v_row;
2317 : unsigned char *rgb_row;
2318 : int cstride;
2319 : int w;
2320 : int h;
2321 : int x;
2322 : int y;
2323 : int hdec;
2324 : int vdec;
2325 : w=_ycbcr[0].width;
2326 : h=_ycbcr[0].height;
2327 : hdec=!(_dec->state.info.pixel_fmt&1);
2328 : vdec=!(_dec->state.info.pixel_fmt&2);
2329 : /*Lazy data buffer init.
2330 : We could try to re-use the post-processing buffer, which would save
2331 : memory, but complicate the allocation logic there.
2332 : I don't think anyone cares about memory usage when using telemetry; it is
2333 : not meant for embedded devices.*/
2334 : if(_dec->telemetry_frame_data==NULL){
2335 : _dec->telemetry_frame_data=_ogg_malloc(
2336 : (w*h+2*(w>>hdec)*(h>>vdec))*sizeof(*_dec->telemetry_frame_data));
2337 : if(_dec->telemetry_frame_data==NULL)return 0;
2338 : }
2339 : cs=cairo_image_surface_create(CAIRO_FORMAT_RGB24,w,h);
2340 : /*Sadly, no YUV support in Cairo (yet); convert into the RGB buffer.*/
2341 : data=cairo_image_surface_get_data(cs);
2342 : if(data==NULL){
2343 : cairo_surface_destroy(cs);
2344 : return 0;
2345 : }
2346 : cstride=cairo_image_surface_get_stride(cs);
2347 : y_row=_ycbcr[0].data;
2348 : u_row=_ycbcr[1].data;
2349 : v_row=_ycbcr[2].data;
2350 : rgb_row=data;
2351 : for(y=0;y<h;y++){
2352 : for(x=0;x<w;x++){
2353 : int r;
2354 : int g;
2355 : int b;
2356 : r=(1904000*y_row[x]+2609823*v_row[x>>hdec]-363703744)/1635200;
2357 : g=(3827562*y_row[x]-1287801*u_row[x>>hdec]
2358 : -2672387*v_row[x>>hdec]+447306710)/3287200;
2359 : b=(952000*y_row[x]+1649289*u_row[x>>hdec]-225932192)/817600;
2360 : rgb_row[4*x+0]=OC_CLAMP255(b);
2361 : rgb_row[4*x+1]=OC_CLAMP255(g);
2362 : rgb_row[4*x+2]=OC_CLAMP255(r);
2363 : }
2364 : y_row+=_ycbcr[0].stride;
2365 : u_row+=_ycbcr[1].stride&-((y&1)|!vdec);
2366 : v_row+=_ycbcr[2].stride&-((y&1)|!vdec);
2367 : rgb_row+=cstride;
2368 : }
2369 : /*Draw coded identifier for each macroblock (stored in Hilbert order).*/
2370 : {
2371 : cairo_t *c;
2372 : const oc_fragment *frags;
2373 : oc_mv *frag_mvs;
2374 : const signed char *mb_modes;
2375 : oc_mb_map *mb_maps;
2376 : size_t nmbs;
2377 : size_t mbi;
2378 : int row2;
2379 : int col2;
2380 : int qim[3]={0,0,0};
2381 : if(_dec->state.nqis==2){
2382 : int bqi;
2383 : bqi=_dec->state.qis[0];
2384 : if(_dec->state.qis[1]>bqi)qim[1]=1;
2385 : if(_dec->state.qis[1]<bqi)qim[1]=-1;
2386 : }
2387 : if(_dec->state.nqis==3){
2388 : int bqi;
2389 : int cqi;
2390 : int dqi;
2391 : bqi=_dec->state.qis[0];
2392 : cqi=_dec->state.qis[1];
2393 : dqi=_dec->state.qis[2];
2394 : if(cqi>bqi&&dqi>bqi){
2395 : if(dqi>cqi){
2396 : qim[1]=1;
2397 : qim[2]=2;
2398 : }
2399 : else{
2400 : qim[1]=2;
2401 : qim[2]=1;
2402 : }
2403 : }
2404 : else if(cqi<bqi&&dqi<bqi){
2405 : if(dqi<cqi){
2406 : qim[1]=-1;
2407 : qim[2]=-2;
2408 : }
2409 : else{
2410 : qim[1]=-2;
2411 : qim[2]=-1;
2412 : }
2413 : }
2414 : else{
2415 : if(cqi<bqi)qim[1]=-1;
2416 : else qim[1]=1;
2417 : if(dqi<bqi)qim[2]=-1;
2418 : else qim[2]=1;
2419 : }
2420 : }
2421 : c=cairo_create(cs);
2422 : frags=_dec->state.frags;
2423 : frag_mvs=_dec->state.frag_mvs;
2424 : mb_modes=_dec->state.mb_modes;
2425 : mb_maps=_dec->state.mb_maps;
2426 : nmbs=_dec->state.nmbs;
2427 : row2=0;
2428 : col2=0;
2429 : for(mbi=0;mbi<nmbs;mbi++){
2430 : float x;
2431 : float y;
2432 : int bi;
2433 : y=h-(row2+((col2+1>>1)&1))*16-16;
2434 : x=(col2>>1)*16;
2435 : cairo_set_line_width(c,1.);
2436 : /*Keyframe (all intra) red box.*/
2437 : if(_dec->state.frame_type==OC_INTRA_FRAME){
2438 : if(_dec->telemetry_mbmode&0x02){
2439 : cairo_set_source_rgba(c,1.,0,0,.5);
2440 : cairo_rectangle(c,x+2.5,y+2.5,11,11);
2441 : cairo_stroke_preserve(c);
2442 : cairo_set_source_rgba(c,1.,0,0,.25);
2443 : cairo_fill(c);
2444 : }
2445 : }
2446 : else{
2447 : ptrdiff_t fragi;
2448 : int frag_mvx;
2449 : int frag_mvy;
2450 : for(bi=0;bi<4;bi++){
2451 : fragi=mb_maps[mbi][0][bi];
2452 : if(fragi>=0&&frags[fragi].coded){
2453 : frag_mvx=OC_MV_X(frag_mvs[fragi]);
2454 : frag_mvy=OC_MV_Y(frag_mvs[fragi]);
2455 : break;
2456 : }
2457 : }
2458 : if(bi<4){
2459 : switch(mb_modes[mbi]){
2460 : case OC_MODE_INTRA:{
2461 : if(_dec->telemetry_mbmode&0x02){
2462 : cairo_set_source_rgba(c,1.,0,0,.5);
2463 : cairo_rectangle(c,x+2.5,y+2.5,11,11);
2464 : cairo_stroke_preserve(c);
2465 : cairo_set_source_rgba(c,1.,0,0,.25);
2466 : cairo_fill(c);
2467 : }
2468 : }break;
2469 : case OC_MODE_INTER_NOMV:{
2470 : if(_dec->telemetry_mbmode&0x01){
2471 : cairo_set_source_rgba(c,0,0,1.,.5);
2472 : cairo_rectangle(c,x+2.5,y+2.5,11,11);
2473 : cairo_stroke_preserve(c);
2474 : cairo_set_source_rgba(c,0,0,1.,.25);
2475 : cairo_fill(c);
2476 : }
2477 : }break;
2478 : case OC_MODE_INTER_MV:{
2479 : if(_dec->telemetry_mbmode&0x04){
2480 : cairo_rectangle(c,x+2.5,y+2.5,11,11);
2481 : cairo_set_source_rgba(c,0,1.,0,.5);
2482 : cairo_stroke(c);
2483 : }
2484 : if(_dec->telemetry_mv&0x04){
2485 : cairo_move_to(c,x+8+frag_mvx,y+8-frag_mvy);
2486 : cairo_set_source_rgba(c,1.,1.,1.,.9);
2487 : cairo_set_line_width(c,3.);
2488 : cairo_line_to(c,x+8+frag_mvx*.66,y+8-frag_mvy*.66);
2489 : cairo_stroke_preserve(c);
2490 : cairo_set_line_width(c,2.);
2491 : cairo_line_to(c,x+8+frag_mvx*.33,y+8-frag_mvy*.33);
2492 : cairo_stroke_preserve(c);
2493 : cairo_set_line_width(c,1.);
2494 : cairo_line_to(c,x+8,y+8);
2495 : cairo_stroke(c);
2496 : }
2497 : }break;
2498 : case OC_MODE_INTER_MV_LAST:{
2499 : if(_dec->telemetry_mbmode&0x08){
2500 : cairo_rectangle(c,x+2.5,y+2.5,11,11);
2501 : cairo_set_source_rgba(c,0,1.,0,.5);
2502 : cairo_move_to(c,x+13.5,y+2.5);
2503 : cairo_line_to(c,x+2.5,y+8);
2504 : cairo_line_to(c,x+13.5,y+13.5);
2505 : cairo_stroke(c);
2506 : }
2507 : if(_dec->telemetry_mv&0x08){
2508 : cairo_move_to(c,x+8+frag_mvx,y+8-frag_mvy);
2509 : cairo_set_source_rgba(c,1.,1.,1.,.9);
2510 : cairo_set_line_width(c,3.);
2511 : cairo_line_to(c,x+8+frag_mvx*.66,y+8-frag_mvy*.66);
2512 : cairo_stroke_preserve(c);
2513 : cairo_set_line_width(c,2.);
2514 : cairo_line_to(c,x+8+frag_mvx*.33,y+8-frag_mvy*.33);
2515 : cairo_stroke_preserve(c);
2516 : cairo_set_line_width(c,1.);
2517 : cairo_line_to(c,x+8,y+8);
2518 : cairo_stroke(c);
2519 : }
2520 : }break;
2521 : case OC_MODE_INTER_MV_LAST2:{
2522 : if(_dec->telemetry_mbmode&0x10){
2523 : cairo_rectangle(c,x+2.5,y+2.5,11,11);
2524 : cairo_set_source_rgba(c,0,1.,0,.5);
2525 : cairo_move_to(c,x+8,y+2.5);
2526 : cairo_line_to(c,x+2.5,y+8);
2527 : cairo_line_to(c,x+8,y+13.5);
2528 : cairo_move_to(c,x+13.5,y+2.5);
2529 : cairo_line_to(c,x+8,y+8);
2530 : cairo_line_to(c,x+13.5,y+13.5);
2531 : cairo_stroke(c);
2532 : }
2533 : if(_dec->telemetry_mv&0x10){
2534 : cairo_move_to(c,x+8+frag_mvx,y+8-frag_mvy);
2535 : cairo_set_source_rgba(c,1.,1.,1.,.9);
2536 : cairo_set_line_width(c,3.);
2537 : cairo_line_to(c,x+8+frag_mvx*.66,y+8-frag_mvy*.66);
2538 : cairo_stroke_preserve(c);
2539 : cairo_set_line_width(c,2.);
2540 : cairo_line_to(c,x+8+frag_mvx*.33,y+8-frag_mvy*.33);
2541 : cairo_stroke_preserve(c);
2542 : cairo_set_line_width(c,1.);
2543 : cairo_line_to(c,x+8,y+8);
2544 : cairo_stroke(c);
2545 : }
2546 : }break;
2547 : case OC_MODE_GOLDEN_NOMV:{
2548 : if(_dec->telemetry_mbmode&0x20){
2549 : cairo_set_source_rgba(c,1.,1.,0,.5);
2550 : cairo_rectangle(c,x+2.5,y+2.5,11,11);
2551 : cairo_stroke_preserve(c);
2552 : cairo_set_source_rgba(c,1.,1.,0,.25);
2553 : cairo_fill(c);
2554 : }
2555 : }break;
2556 : case OC_MODE_GOLDEN_MV:{
2557 : if(_dec->telemetry_mbmode&0x40){
2558 : cairo_rectangle(c,x+2.5,y+2.5,11,11);
2559 : cairo_set_source_rgba(c,1.,1.,0,.5);
2560 : cairo_stroke(c);
2561 : }
2562 : if(_dec->telemetry_mv&0x40){
2563 : cairo_move_to(c,x+8+frag_mvx,y+8-frag_mvy);
2564 : cairo_set_source_rgba(c,1.,1.,1.,.9);
2565 : cairo_set_line_width(c,3.);
2566 : cairo_line_to(c,x+8+frag_mvx*.66,y+8-frag_mvy*.66);
2567 : cairo_stroke_preserve(c);
2568 : cairo_set_line_width(c,2.);
2569 : cairo_line_to(c,x+8+frag_mvx*.33,y+8-frag_mvy*.33);
2570 : cairo_stroke_preserve(c);
2571 : cairo_set_line_width(c,1.);
2572 : cairo_line_to(c,x+8,y+8);
2573 : cairo_stroke(c);
2574 : }
2575 : }break;
2576 : case OC_MODE_INTER_MV_FOUR:{
2577 : if(_dec->telemetry_mbmode&0x80){
2578 : cairo_rectangle(c,x+2.5,y+2.5,4,4);
2579 : cairo_rectangle(c,x+9.5,y+2.5,4,4);
2580 : cairo_rectangle(c,x+2.5,y+9.5,4,4);
2581 : cairo_rectangle(c,x+9.5,y+9.5,4,4);
2582 : cairo_set_source_rgba(c,0,1.,0,.5);
2583 : cairo_stroke(c);
2584 : }
2585 : /*4mv is odd, coded in raster order.*/
2586 : fragi=mb_maps[mbi][0][0];
2587 : if(frags[fragi].coded&&_dec->telemetry_mv&0x80){
2588 : frag_mvx=OC_MV_X(frag_mvs[fragi]);
2589 : frag_mvx=OC_MV_Y(frag_mvs[fragi]);
2590 : cairo_move_to(c,x+4+frag_mvx,y+12-frag_mvy);
2591 : cairo_set_source_rgba(c,1.,1.,1.,.9);
2592 : cairo_set_line_width(c,3.);
2593 : cairo_line_to(c,x+4+frag_mvx*.66,y+12-frag_mvy*.66);
2594 : cairo_stroke_preserve(c);
2595 : cairo_set_line_width(c,2.);
2596 : cairo_line_to(c,x+4+frag_mvx*.33,y+12-frag_mvy*.33);
2597 : cairo_stroke_preserve(c);
2598 : cairo_set_line_width(c,1.);
2599 : cairo_line_to(c,x+4,y+12);
2600 : cairo_stroke(c);
2601 : }
2602 : fragi=mb_maps[mbi][0][1];
2603 : if(frags[fragi].coded&&_dec->telemetry_mv&0x80){
2604 : frag_mvx=OC_MV_X(frag_mvs[fragi]);
2605 : frag_mvx=OC_MV_Y(frag_mvs[fragi]);
2606 : cairo_move_to(c,x+12+frag_mvx,y+12-frag_mvy);
2607 : cairo_set_source_rgba(c,1.,1.,1.,.9);
2608 : cairo_set_line_width(c,3.);
2609 : cairo_line_to(c,x+12+frag_mvx*.66,y+12-frag_mvy*.66);
2610 : cairo_stroke_preserve(c);
2611 : cairo_set_line_width(c,2.);
2612 : cairo_line_to(c,x+12+frag_mvx*.33,y+12-frag_mvy*.33);
2613 : cairo_stroke_preserve(c);
2614 : cairo_set_line_width(c,1.);
2615 : cairo_line_to(c,x+12,y+12);
2616 : cairo_stroke(c);
2617 : }
2618 : fragi=mb_maps[mbi][0][2];
2619 : if(frags[fragi].coded&&_dec->telemetry_mv&0x80){
2620 : frag_mvx=OC_MV_X(frag_mvs[fragi]);
2621 : frag_mvx=OC_MV_Y(frag_mvs[fragi]);
2622 : cairo_move_to(c,x+4+frag_mvx,y+4-frag_mvy);
2623 : cairo_set_source_rgba(c,1.,1.,1.,.9);
2624 : cairo_set_line_width(c,3.);
2625 : cairo_line_to(c,x+4+frag_mvx*.66,y+4-frag_mvy*.66);
2626 : cairo_stroke_preserve(c);
2627 : cairo_set_line_width(c,2.);
2628 : cairo_line_to(c,x+4+frag_mvx*.33,y+4-frag_mvy*.33);
2629 : cairo_stroke_preserve(c);
2630 : cairo_set_line_width(c,1.);
2631 : cairo_line_to(c,x+4,y+4);
2632 : cairo_stroke(c);
2633 : }
2634 : fragi=mb_maps[mbi][0][3];
2635 : if(frags[fragi].coded&&_dec->telemetry_mv&0x80){
2636 : frag_mvx=OC_MV_X(frag_mvs[fragi]);
2637 : frag_mvx=OC_MV_Y(frag_mvs[fragi]);
2638 : cairo_move_to(c,x+12+frag_mvx,y+4-frag_mvy);
2639 : cairo_set_source_rgba(c,1.,1.,1.,.9);
2640 : cairo_set_line_width(c,3.);
2641 : cairo_line_to(c,x+12+frag_mvx*.66,y+4-frag_mvy*.66);
2642 : cairo_stroke_preserve(c);
2643 : cairo_set_line_width(c,2.);
2644 : cairo_line_to(c,x+12+frag_mvx*.33,y+4-frag_mvy*.33);
2645 : cairo_stroke_preserve(c);
2646 : cairo_set_line_width(c,1.);
2647 : cairo_line_to(c,x+12,y+4);
2648 : cairo_stroke(c);
2649 : }
2650 : }break;
2651 : }
2652 : }
2653 : }
2654 : /*qii illustration.*/
2655 : if(_dec->telemetry_qi&0x2){
2656 : cairo_set_line_cap(c,CAIRO_LINE_CAP_SQUARE);
2657 : for(bi=0;bi<4;bi++){
2658 : ptrdiff_t fragi;
2659 : int qiv;
2660 : int xp;
2661 : int yp;
2662 : xp=x+(bi&1)*8;
2663 : yp=y+8-(bi&2)*4;
2664 : fragi=mb_maps[mbi][0][bi];
2665 : if(fragi>=0&&frags[fragi].coded){
2666 : qiv=qim[frags[fragi].qii];
2667 : cairo_set_line_width(c,3.);
2668 : cairo_set_source_rgba(c,0.,0.,0.,.5);
2669 : switch(qiv){
2670 : /*Double plus:*/
2671 : case 2:{
2672 : if((bi&1)^((bi&2)>>1)){
2673 : cairo_move_to(c,xp+2.5,yp+1.5);
2674 : cairo_line_to(c,xp+2.5,yp+3.5);
2675 : cairo_move_to(c,xp+1.5,yp+2.5);
2676 : cairo_line_to(c,xp+3.5,yp+2.5);
2677 : cairo_move_to(c,xp+5.5,yp+4.5);
2678 : cairo_line_to(c,xp+5.5,yp+6.5);
2679 : cairo_move_to(c,xp+4.5,yp+5.5);
2680 : cairo_line_to(c,xp+6.5,yp+5.5);
2681 : cairo_stroke_preserve(c);
2682 : cairo_set_source_rgba(c,0.,1.,1.,1.);
2683 : }
2684 : else{
2685 : cairo_move_to(c,xp+5.5,yp+1.5);
2686 : cairo_line_to(c,xp+5.5,yp+3.5);
2687 : cairo_move_to(c,xp+4.5,yp+2.5);
2688 : cairo_line_to(c,xp+6.5,yp+2.5);
2689 : cairo_move_to(c,xp+2.5,yp+4.5);
2690 : cairo_line_to(c,xp+2.5,yp+6.5);
2691 : cairo_move_to(c,xp+1.5,yp+5.5);
2692 : cairo_line_to(c,xp+3.5,yp+5.5);
2693 : cairo_stroke_preserve(c);
2694 : cairo_set_source_rgba(c,0.,1.,1.,1.);
2695 : }
2696 : }break;
2697 : /*Double minus:*/
2698 : case -2:{
2699 : cairo_move_to(c,xp+2.5,yp+2.5);
2700 : cairo_line_to(c,xp+5.5,yp+2.5);
2701 : cairo_move_to(c,xp+2.5,yp+5.5);
2702 : cairo_line_to(c,xp+5.5,yp+5.5);
2703 : cairo_stroke_preserve(c);
2704 : cairo_set_source_rgba(c,1.,1.,1.,1.);
2705 : }break;
2706 : /*Plus:*/
2707 : case 1:{
2708 : if(bi&2==0)yp-=2;
2709 : if(bi&1==0)xp-=2;
2710 : cairo_move_to(c,xp+4.5,yp+2.5);
2711 : cairo_line_to(c,xp+4.5,yp+6.5);
2712 : cairo_move_to(c,xp+2.5,yp+4.5);
2713 : cairo_line_to(c,xp+6.5,yp+4.5);
2714 : cairo_stroke_preserve(c);
2715 : cairo_set_source_rgba(c,.1,1.,.3,1.);
2716 : break;
2717 : }
2718 : /*Fall through.*/
2719 : /*Minus:*/
2720 : case -1:{
2721 : cairo_move_to(c,xp+2.5,yp+4.5);
2722 : cairo_line_to(c,xp+6.5,yp+4.5);
2723 : cairo_stroke_preserve(c);
2724 : cairo_set_source_rgba(c,1.,.3,.1,1.);
2725 : }break;
2726 : default:continue;
2727 : }
2728 : cairo_set_line_width(c,1.);
2729 : cairo_stroke(c);
2730 : }
2731 : }
2732 : }
2733 : col2++;
2734 : if((col2>>1)>=_dec->state.nhmbs){
2735 : col2=0;
2736 : row2+=2;
2737 : }
2738 : }
2739 : /*Bit usage indicator[s]:*/
2740 : if(_dec->telemetry_bits){
2741 : int widths[6];
2742 : int fpsn;
2743 : int fpsd;
2744 : int mult;
2745 : int fullw;
2746 : int padw;
2747 : int i;
2748 : fpsn=_dec->state.info.fps_numerator;
2749 : fpsd=_dec->state.info.fps_denominator;
2750 : mult=(_dec->telemetry_bits>=0xFF?1:_dec->telemetry_bits);
2751 : fullw=250.f*h*fpsd*mult/fpsn;
2752 : padw=w-24;
2753 : /*Header and coded block bits.*/
2754 : if(_dec->telemetry_frame_bytes<0||
2755 : _dec->telemetry_frame_bytes==OC_LOTS_OF_BITS){
2756 : _dec->telemetry_frame_bytes=0;
2757 : }
2758 : if(_dec->telemetry_coding_bytes<0||
2759 : _dec->telemetry_coding_bytes>_dec->telemetry_frame_bytes){
2760 : _dec->telemetry_coding_bytes=0;
2761 : }
2762 : if(_dec->telemetry_mode_bytes<0||
2763 : _dec->telemetry_mode_bytes>_dec->telemetry_frame_bytes){
2764 : _dec->telemetry_mode_bytes=0;
2765 : }
2766 : if(_dec->telemetry_mv_bytes<0||
2767 : _dec->telemetry_mv_bytes>_dec->telemetry_frame_bytes){
2768 : _dec->telemetry_mv_bytes=0;
2769 : }
2770 : if(_dec->telemetry_qi_bytes<0||
2771 : _dec->telemetry_qi_bytes>_dec->telemetry_frame_bytes){
2772 : _dec->telemetry_qi_bytes=0;
2773 : }
2774 : if(_dec->telemetry_dc_bytes<0||
2775 : _dec->telemetry_dc_bytes>_dec->telemetry_frame_bytes){
2776 : _dec->telemetry_dc_bytes=0;
2777 : }
2778 : widths[0]=padw*(_dec->telemetry_frame_bytes-_dec->telemetry_coding_bytes)/fullw;
2779 : widths[1]=padw*(_dec->telemetry_coding_bytes-_dec->telemetry_mode_bytes)/fullw;
2780 : widths[2]=padw*(_dec->telemetry_mode_bytes-_dec->telemetry_mv_bytes)/fullw;
2781 : widths[3]=padw*(_dec->telemetry_mv_bytes-_dec->telemetry_qi_bytes)/fullw;
2782 : widths[4]=padw*(_dec->telemetry_qi_bytes-_dec->telemetry_dc_bytes)/fullw;
2783 : widths[5]=padw*(_dec->telemetry_dc_bytes)/fullw;
2784 : for(i=0;i<6;i++)if(widths[i]>w)widths[i]=w;
2785 : cairo_set_source_rgba(c,.0,.0,.0,.6);
2786 : cairo_rectangle(c,10,h-33,widths[0]+1,5);
2787 : cairo_rectangle(c,10,h-29,widths[1]+1,5);
2788 : cairo_rectangle(c,10,h-25,widths[2]+1,5);
2789 : cairo_rectangle(c,10,h-21,widths[3]+1,5);
2790 : cairo_rectangle(c,10,h-17,widths[4]+1,5);
2791 : cairo_rectangle(c,10,h-13,widths[5]+1,5);
2792 : cairo_fill(c);
2793 : cairo_set_source_rgb(c,1,0,0);
2794 : cairo_rectangle(c,10.5,h-32.5,widths[0],4);
2795 : cairo_fill(c);
2796 : cairo_set_source_rgb(c,0,1,0);
2797 : cairo_rectangle(c,10.5,h-28.5,widths[1],4);
2798 : cairo_fill(c);
2799 : cairo_set_source_rgb(c,0,0,1);
2800 : cairo_rectangle(c,10.5,h-24.5,widths[2],4);
2801 : cairo_fill(c);
2802 : cairo_set_source_rgb(c,.6,.4,.0);
2803 : cairo_rectangle(c,10.5,h-20.5,widths[3],4);
2804 : cairo_fill(c);
2805 : cairo_set_source_rgb(c,.3,.3,.3);
2806 : cairo_rectangle(c,10.5,h-16.5,widths[4],4);
2807 : cairo_fill(c);
2808 : cairo_set_source_rgb(c,.5,.5,.8);
2809 : cairo_rectangle(c,10.5,h-12.5,widths[5],4);
2810 : cairo_fill(c);
2811 : }
2812 : /*Master qi indicator[s]:*/
2813 : if(_dec->telemetry_qi&0x1){
2814 : cairo_text_extents_t extents;
2815 : char buffer[10];
2816 : int p;
2817 : int y;
2818 : p=0;
2819 : y=h-7.5;
2820 : if(_dec->state.qis[0]>=10)buffer[p++]=48+_dec->state.qis[0]/10;
2821 : buffer[p++]=48+_dec->state.qis[0]%10;
2822 : if(_dec->state.nqis>=2){
2823 : buffer[p++]=' ';
2824 : if(_dec->state.qis[1]>=10)buffer[p++]=48+_dec->state.qis[1]/10;
2825 : buffer[p++]=48+_dec->state.qis[1]%10;
2826 : }
2827 : if(_dec->state.nqis==3){
2828 : buffer[p++]=' ';
2829 : if(_dec->state.qis[2]>=10)buffer[p++]=48+_dec->state.qis[2]/10;
2830 : buffer[p++]=48+_dec->state.qis[2]%10;
2831 : }
2832 : buffer[p++]='\0';
2833 : cairo_select_font_face(c,"sans",
2834 : CAIRO_FONT_SLANT_NORMAL,CAIRO_FONT_WEIGHT_BOLD);
2835 : cairo_set_font_size(c,18);
2836 : cairo_text_extents(c,buffer,&extents);
2837 : cairo_set_source_rgb(c,1,1,1);
2838 : cairo_move_to(c,w-extents.x_advance-10,y);
2839 : cairo_show_text(c,buffer);
2840 : cairo_set_source_rgb(c,0,0,0);
2841 : cairo_move_to(c,w-extents.x_advance-10,y);
2842 : cairo_text_path(c,buffer);
2843 : cairo_set_line_width(c,.8);
2844 : cairo_set_line_join(c,CAIRO_LINE_JOIN_ROUND);
2845 : cairo_stroke(c);
2846 : }
2847 : cairo_destroy(c);
2848 : }
2849 : /*Out of the Cairo plane into the telemetry YUV buffer.*/
2850 : _ycbcr[0].data=_dec->telemetry_frame_data;
2851 : _ycbcr[0].stride=_ycbcr[0].width;
2852 : _ycbcr[1].data=_ycbcr[0].data+h*_ycbcr[0].stride;
2853 : _ycbcr[1].stride=_ycbcr[1].width;
2854 : _ycbcr[2].data=_ycbcr[1].data+(h>>vdec)*_ycbcr[1].stride;
2855 : _ycbcr[2].stride=_ycbcr[2].width;
2856 : y_row=_ycbcr[0].data;
2857 : u_row=_ycbcr[1].data;
2858 : v_row=_ycbcr[2].data;
2859 : rgb_row=data;
2860 : /*This is one of the few places it's worth handling chroma on a
2861 : case-by-case basis.*/
2862 : switch(_dec->state.info.pixel_fmt){
2863 : case TH_PF_420:{
2864 : for(y=0;y<h;y+=2){
2865 : unsigned char *y_row2;
2866 : unsigned char *rgb_row2;
2867 : y_row2=y_row+_ycbcr[0].stride;
2868 : rgb_row2=rgb_row+cstride;
2869 : for(x=0;x<w;x+=2){
2870 : int y;
2871 : int u;
2872 : int v;
2873 : y=(65481*rgb_row[4*x+2]+128553*rgb_row[4*x+1]
2874 : +24966*rgb_row[4*x+0]+4207500)/255000;
2875 : y_row[x]=OC_CLAMP255(y);
2876 : y=(65481*rgb_row[4*x+6]+128553*rgb_row[4*x+5]
2877 : +24966*rgb_row[4*x+4]+4207500)/255000;
2878 : y_row[x+1]=OC_CLAMP255(y);
2879 : y=(65481*rgb_row2[4*x+2]+128553*rgb_row2[4*x+1]
2880 : +24966*rgb_row2[4*x+0]+4207500)/255000;
2881 : y_row2[x]=OC_CLAMP255(y);
2882 : y=(65481*rgb_row2[4*x+6]+128553*rgb_row2[4*x+5]
2883 : +24966*rgb_row2[4*x+4]+4207500)/255000;
2884 : y_row2[x+1]=OC_CLAMP255(y);
2885 : u=(-8372*(rgb_row[4*x+2]+rgb_row[4*x+6]
2886 : +rgb_row2[4*x+2]+rgb_row2[4*x+6])
2887 : -16436*(rgb_row[4*x+1]+rgb_row[4*x+5]
2888 : +rgb_row2[4*x+1]+rgb_row2[4*x+5])
2889 : +24808*(rgb_row[4*x+0]+rgb_row[4*x+4]
2890 : +rgb_row2[4*x+0]+rgb_row2[4*x+4])+29032005)/225930;
2891 : v=(39256*(rgb_row[4*x+2]+rgb_row[4*x+6]
2892 : +rgb_row2[4*x+2]+rgb_row2[4*x+6])
2893 : -32872*(rgb_row[4*x+1]+rgb_row[4*x+5]
2894 : +rgb_row2[4*x+1]+rgb_row2[4*x+5])
2895 : -6384*(rgb_row[4*x+0]+rgb_row[4*x+4]
2896 : +rgb_row2[4*x+0]+rgb_row2[4*x+4])+45940035)/357510;
2897 : u_row[x>>1]=OC_CLAMP255(u);
2898 : v_row[x>>1]=OC_CLAMP255(v);
2899 : }
2900 : y_row+=_ycbcr[0].stride<<1;
2901 : u_row+=_ycbcr[1].stride;
2902 : v_row+=_ycbcr[2].stride;
2903 : rgb_row+=cstride<<1;
2904 : }
2905 : }break;
2906 : case TH_PF_422:{
2907 : for(y=0;y<h;y++){
2908 : for(x=0;x<w;x+=2){
2909 : int y;
2910 : int u;
2911 : int v;
2912 : y=(65481*rgb_row[4*x+2]+128553*rgb_row[4*x+1]
2913 : +24966*rgb_row[4*x+0]+4207500)/255000;
2914 : y_row[x]=OC_CLAMP255(y);
2915 : y=(65481*rgb_row[4*x+6]+128553*rgb_row[4*x+5]
2916 : +24966*rgb_row[4*x+4]+4207500)/255000;
2917 : y_row[x+1]=OC_CLAMP255(y);
2918 : u=(-16744*(rgb_row[4*x+2]+rgb_row[4*x+6])
2919 : -32872*(rgb_row[4*x+1]+rgb_row[4*x+5])
2920 : +49616*(rgb_row[4*x+0]+rgb_row[4*x+4])+29032005)/225930;
2921 : v=(78512*(rgb_row[4*x+2]+rgb_row[4*x+6])
2922 : -65744*(rgb_row[4*x+1]+rgb_row[4*x+5])
2923 : -12768*(rgb_row[4*x+0]+rgb_row[4*x+4])+45940035)/357510;
2924 : u_row[x>>1]=OC_CLAMP255(u);
2925 : v_row[x>>1]=OC_CLAMP255(v);
2926 : }
2927 : y_row+=_ycbcr[0].stride;
2928 : u_row+=_ycbcr[1].stride;
2929 : v_row+=_ycbcr[2].stride;
2930 : rgb_row+=cstride;
2931 : }
2932 : }break;
2933 : /*case TH_PF_444:*/
2934 : default:{
2935 : for(y=0;y<h;y++){
2936 : for(x=0;x<w;x++){
2937 : int y;
2938 : int u;
2939 : int v;
2940 : y=(65481*rgb_row[4*x+2]+128553*rgb_row[4*x+1]
2941 : +24966*rgb_row[4*x+0]+4207500)/255000;
2942 : u=(-33488*rgb_row[4*x+2]-65744*rgb_row[4*x+1]
2943 : +99232*rgb_row[4*x+0]+29032005)/225930;
2944 : v=(157024*rgb_row[4*x+2]-131488*rgb_row[4*x+1]
2945 : -25536*rgb_row[4*x+0]+45940035)/357510;
2946 : y_row[x]=OC_CLAMP255(y);
2947 : u_row[x]=OC_CLAMP255(u);
2948 : v_row[x]=OC_CLAMP255(v);
2949 : }
2950 : y_row+=_ycbcr[0].stride;
2951 : u_row+=_ycbcr[1].stride;
2952 : v_row+=_ycbcr[2].stride;
2953 : rgb_row+=cstride;
2954 : }
2955 : }break;
2956 : }
2957 : /*Finished.
2958 : Destroy the surface.*/
2959 : cairo_surface_destroy(cs);
2960 : }
2961 : #endif
2962 0 : return 0;
2963 : }
|
