PR/Applications/VSs/VSs__H264__App: libavcodec/sscc_h264

annotate libavcodec/sscc_h264_ompss.c @ 10:4d1f82230449

preprocessed source from newer mercurial ver.

author	Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date	Tue, 13 Aug 2013 13:12:57 +0200
parents	ea1ba68cf0ed
children

rev	line source
nengel@10	1 typedef unsigned int uint32_t;
nengel@10	2 static __inline __attribute__((always_inline)) uint32_t pack16to32(int a, int b)
nengel@9	3 {
nengel@10	4 return (a & 65535) + (b << 16);
nengel@10	5 }
nengel@10	6 typedef unsigned short int uint16_t;
nengel@10	7 static __inline __attribute__((always_inline)) uint16_t pack8to16(int a, int b)
nengel@9	8 {
nengel@10	9 return (a & 255) + (b << 8);
nengel@10	10 }
nengel@10	11 struct CABACContext;
nengel@10	12 typedef struct CABACContext CABACContext;
nengel@10	13 typedef unsigned char uint8_t;
nengel@10	14 struct CABACContext
nengel@10	15 {
nengel@10	16 int low;
nengel@10	17 int range;
nengel@10	18 int outstanding_count;
nengel@10	19 const uint8_t *bytestream_start;
nengel@10	20 const uint8_t *bytestream;
nengel@10	21 const uint8_t *bytestream_end;
nengel@10	22 uint8_t cabac_state[460];
nengel@9	23 };
nengel@10	24 static void refill(CABACContext *c)
nengel@9	25 {
nengel@10	26 (c).low += ((c).bytestream[0] << 9) + ((*c).bytestream[1] << 1);
nengel@10	27 (*c).low -= (1 << 16) - 1;
nengel@10	28 (*c).bytestream += 16 / 8;
nengel@10	29 }
nengel@10	30 extern const uint8_t ff_h264_norm_shift[512];
nengel@10	31 static void refill2(CABACContext *c)
nengel@9	32 {
nengel@10	33 int x;
nengel@10	34 int i;
nengel@10	35 x = (c).low ^ ((c).low - 1);
nengel@10	36 i = 7 - ff_h264_norm_shift[x >> (16 - 1)];
nengel@10	37 x = -((1 << 16) - 1);
nengel@10	38 x += ((c).bytestream[0] << 9) + ((c).bytestream[1] << 1);
nengel@10	39 (*c).low += x << i;
nengel@10	40 (*c).bytestream += 16 / 8;
nengel@10	41 }
nengel@10	42 static __inline void renorm_cabac_decoder(CABACContext *c)
nengel@9	43 {
nengel@10	44 while ((*c).range < 256)
nengel@9	45 {
nengel@10	46 {
nengel@10	47 (c).range += (c).range;
nengel@10	48 (c).low += (c).low;
nengel@10	49 if (!((*c).low & ((1 << 16) - 1)))
nengel@10	50 {
nengel@10	51 refill(c);
nengel@10	52 }
nengel@10	53 }
nengel@9	54 }
nengel@9	55 }
nengel@10	56 static __inline void renorm_cabac_decoder_once(CABACContext *c)
nengel@9	57 {
nengel@10	58 int shift = (uint32_t)((*c).range - 256) >> 31;
nengel@10	59 (*c).range <<= shift;
nengel@10	60 (*c).low <<= shift;
nengel@10	61 if (!((*c).low & ((1 << 16) - 1)))
nengel@9	62 {
nengel@10	63 refill(c);
nengel@9	64 }
nengel@9	65 }
nengel@10	66 extern uint8_t ff_h264_lps_range[512];
nengel@10	67 extern uint8_t ff_h264_mlps_state[256];
nengel@10	68 static __inline __attribute__((always_inline)) int get_cabac_inline(CABACContext c, uint8_t const state)
nengel@9	69 {
nengel@10	70 __attribute__((unused)) int lps_mask;
nengel@10	71 int bit;
nengel@10	72 int s = *state;
nengel@10	73 int RangeLPS = ff_h264_lps_range[2 * ((*c).range & 192) + s];
nengel@10	74 (*c).range -= RangeLPS;
nengel@10	75 lps_mask = (((c).range << (16 + 1)) - (c).low) >> 31;
nengel@10	76 (c).low -= (c).range << (16 + 1) & lps_mask;
nengel@10	77 (c).range += (RangeLPS - (c).range) & lps_mask;
nengel@10	78 s ^= lps_mask;
nengel@10	79 *state = (ff_h264_mlps_state + 128)[s];
nengel@10	80 bit = s & 1;
nengel@10	81 lps_mask = ff_h264_norm_shift[(*c).range];
nengel@10	82 (*c).range <<= lps_mask;
nengel@10	83 (*c).low <<= lps_mask;
nengel@10	84 if (!((*c).low & ((1 << 16) - 1)))
nengel@9	85 {
nengel@10	86 refill2(c);
nengel@9	87 }
nengel@10	88 return bit;
nengel@9	89 }
nengel@10	90 static __attribute__((noinline)) __attribute__((unused)) int get_cabac_noinline(CABACContext c, uint8_t const state)
nengel@9	91 {
nengel@10	92 return get_cabac_inline(c, state);
nengel@10	93 }
nengel@10	94 static __attribute__((unused)) int get_cabac(CABACContext c, uint8_t const state)
nengel@10	95 {
nengel@10	96 return get_cabac_inline(c, state);
nengel@10	97 }
nengel@10	98 static __attribute__((unused)) int get_cabac_bypass(CABACContext *c)
nengel@10	99 {
nengel@10	100 int range;
nengel@10	101 (c).low += (c).low;
nengel@10	102 if (!((*c).low & ((1 << 16) - 1)))
nengel@9	103 {
nengel@10	104 refill(c);
nengel@9	105 }
nengel@10	106 range = (*c).range << (16 + 1);
nengel@10	107 if ((*c).low < range)
nengel@10	108 {
nengel@10	109 {
nengel@10	110 return 0;
nengel@10	111 }
nengel@10	112 }
nengel@10	113 else
nengel@10	114 {
nengel@10	115 {
nengel@10	116 (*c).low -= range;
nengel@10	117 return 1;
nengel@10	118 }
nengel@10	119 }
nengel@9	120 }
nengel@10	121 static __inline __attribute__((always_inline)) int get_cabac_bypass_sign(CABACContext *c, int val)
nengel@9	122 {
nengel@10	123 int range;
nengel@10	124 int mask;
nengel@10	125 (c).low += (c).low;
nengel@10	126 if (!((*c).low & ((1 << 16) - 1)))
nengel@10	127 {
nengel@10	128 refill(c);
nengel@10	129 }
nengel@10	130 range = (*c).range << (16 + 1);
nengel@10	131 (*c).low -= range;
nengel@10	132 mask = (*c).low >> 31;
nengel@10	133 range &= mask;
nengel@10	134 (*c).low += range;
nengel@10	135 return (val ^ mask) - mask;
nengel@9	136 }
nengel@10	137 static __attribute__((unused)) int get_cabac_terminate(CABACContext *c)
nengel@9	138 {
nengel@10	139 (*c).range -= 2;
nengel@10	140 if ((c).low < (c).range << (16 + 1))
nengel@9	141 {
nengel@10	142 {
nengel@10	143 renorm_cabac_decoder_once(c);
nengel@10	144 return 0;
nengel@10	145 }
nengel@9	146 }
nengel@10	147 else
nengel@10	148 {
nengel@10	149 {
nengel@10	150 return (c).bytestream - (c).bytestream_start;
nengel@10	151 }
nengel@10	152 }
nengel@9	153 }
nengel@10	154 static __inline __attribute__((always_inline)) __attribute__((const)) uint16_t bswap_16(uint16_t x)
nengel@9	155 {
nengel@10	156 __asm__ ("rorw $8, %0" : "+r"(x) : );
nengel@10	157 return x;
nengel@10	158 }
nengel@10	159 static __inline __attribute__((always_inline)) __attribute__((const)) uint32_t bswap_32(uint32_t x)
nengel@10	160 {
nengel@10	161 __asm__ ("bswap %0" : "+r"(x) : );
nengel@10	162 return x;
nengel@10	163 }
nengel@10	164 typedef unsigned long int uint64_t;
nengel@10	165 static __inline __attribute__((const)) uint64_t bswap_64(uint64_t x)
nengel@10	166 {
nengel@10	167 __asm__ ("bswap %0" : "=r"(x) : "0"(x));
nengel@10	168 return x;
nengel@10	169 }
nengel@10	170 extern const uint8_t ff_log2_tab[256];
nengel@10	171 static __inline __attribute__((const)) int av_log2_c(unsigned int v)
nengel@10	172 {
nengel@10	173 int n = 0;
nengel@10	174 if (v & 4294901760U)
nengel@9	175 {
nengel@10	176 {
nengel@10	177 v >>= 16;
nengel@10	178 n += 16;
nengel@10	179 }
nengel@9	180 }
nengel@10	181 if (v & 65280)
nengel@10	182 {
nengel@10	183 {
nengel@10	184 v >>= 8;
nengel@10	185 n += 8;
nengel@10	186 }
nengel@10	187 }
nengel@10	188 n += ff_log2_tab[v];
nengel@10	189 return n;
nengel@9	190 }
nengel@10	191 static __inline __attribute__((const)) int av_log2_16bit_c(unsigned int v)
nengel@9	192 {
nengel@10	193 int n = 0;
nengel@10	194 if (v & 65280)
nengel@9	195 {
nengel@10	196 {
nengel@10	197 v >>= 8;
nengel@10	198 n += 8;
nengel@10	199 }
nengel@9	200 }
nengel@10	201 n += ff_log2_tab[v];
nengel@10	202 return n;
nengel@9	203 }
nengel@10	204 static __inline __attribute__((const)) int av_clip(int a, int amin, int amax)
nengel@9	205 {
nengel@10	206 if (a < amin)
nengel@9	207 {
nengel@10	208 return amin;
nengel@9	209 }
nengel@10	210 else
nengel@10	211 {
nengel@10	212 if (a > amax)
nengel@10	213 {
nengel@10	214 return amax;
nengel@10	215 }
nengel@10	216 else
nengel@10	217 {
nengel@10	218 return a;
nengel@10	219 }
nengel@10	220 }
nengel@9	221 }
nengel@10	222 static __inline __attribute__((const)) uint8_t av_clip_uint8(int a)
nengel@9	223 {
nengel@10	224 if (a & ~255)
nengel@9	225 {
nengel@10	226 return -a >> 31;
nengel@9	227 }
nengel@10	228 else
nengel@10	229 {
nengel@10	230 return a;
nengel@10	231 }
nengel@9	232 }
nengel@10	233 static __inline __attribute__((const)) uint16_t av_clip_uint16(int a)
nengel@9	234 {
nengel@10	235 if (a & ~65535)
nengel@9	236 {
nengel@10	237 return -a >> 31;
nengel@9	238 }
nengel@10	239 else
nengel@10	240 {
nengel@10	241 return a;
nengel@10	242 }
nengel@9	243 }
nengel@10	244 typedef short int int16_t;
nengel@10	245 static __inline __attribute__((const)) int16_t av_clip_int16(int a)
nengel@9	246 {
nengel@10	247 if ((a + 32768) & ~65535)
nengel@10	248 {
nengel@10	249 return a >> 31 ^ 32767;
nengel@10	250 }
nengel@10	251 else
nengel@10	252 {
nengel@10	253 return a;
nengel@10	254 }
nengel@9	255 }
nengel@9	256 typedef int int32_t;
nengel@9	257 typedef long int int64_t;
nengel@10	258 static __inline __attribute__((const)) int32_t av_clipl_int32(int64_t a)
nengel@9	259 {
nengel@10	260 if ((a + 2147483648U) & ~4294967295LU)
nengel@9	261 {
nengel@10	262 return a >> 63 ^ 2147483647;
nengel@10	263 }
nengel@10	264 else
nengel@10	265 {
nengel@10	266 return a;
nengel@9	267 }
nengel@9	268 }
nengel@10	269 static __inline __attribute__((const)) float av_clipf(float a, float amin, float amax)
nengel@9	270 {
nengel@10	271 if (a < amin)
nengel@9	272 {
nengel@10	273 return amin;
nengel@9	274 }
nengel@10	275 else
nengel@9	276 {
nengel@10	277 if (a > amax)
nengel@10	278 {
nengel@10	279 return amax;
nengel@10	280 }
nengel@10	281 else
nengel@10	282 {
nengel@10	283 return a;
nengel@10	284 }
nengel@9	285 }
nengel@9	286 }
nengel@10	287 static __inline __attribute__((const)) int av_ceil_log2(int x)
nengel@9	288 {
nengel@10	289 return av_log2_c((x - 1) << 1);
nengel@9	290 }
nengel@10	291 static __inline __attribute__((always_inline)) void AV_COPY64(void d, const void s)
nengel@9	292 {
nengel@10	293 __asm__ ("movq %1, %%mm0 \n\t""movq %%mm0, %0 \n\t" : "=m"(((uint64_t )d)) : "m"(((const uint64_t )s)) : "mm0");
nengel@10	294 }
nengel@10	295 static __inline __attribute__((always_inline)) void AV_SWAP64(void a, void b)
nengel@10	296 {
nengel@10	297 __asm__ ("movq %1, %%mm0 \n\t""movq %0, %%mm1 \n\t""movq %%mm0, %0 \n\t""movq %%mm1, %1 \n\t" : "+m"(((uint64_t )a)), "+m"(((uint64_t )b)) : : "mm0", "mm1");
nengel@10	298 }
nengel@10	299 static __inline __attribute__((always_inline)) void AV_ZERO64(void *d)
nengel@10	300 {
nengel@10	301 __asm__ ("pxor %%mm0, %%mm0 \n\t""movq %%mm0, %0 \n\t" : "=m"(((uint64_t )d)) : : "mm0");
nengel@10	302 }
nengel@10	303 static __inline __attribute__((always_inline)) void AV_COPY128(void d, const void s)
nengel@10	304 {
nengel@10	305 struct v;
nengel@10	306 struct v
nengel@10	307 {
nengel@10	308 uint64_t v[2];
nengel@10	309 };
nengel@10	310 __asm__ ("movaps %1, %%xmm0 \n\t""movaps %%xmm0, %0 \n\t" : "=m"(((struct v )d)) : "m"(((const struct v )s)) : "xmm0");
nengel@10	311 }
nengel@10	312 static __inline __attribute__((always_inline)) void AV_ZERO128(void *d)
nengel@10	313 {
nengel@10	314 struct v;
nengel@10	315 struct v
nengel@10	316 {
nengel@10	317 uint64_t v[2];
nengel@10	318 };
nengel@10	319 __asm__ ("pxor %%xmm0, %%xmm0 \n\t""movdqa %%xmm0, %0 \n\t" : "=m"(((struct v )d)) : : "xmm0");
nengel@10	320 }
nengel@10	321 static __inline uint32_t rnd_avg32(uint32_t a, uint32_t b)
nengel@10	322 {
nengel@10	323 return (a \| b) - (((a ^ b) & ~(1 * 16843009LU)) >> 1);
nengel@10	324 }
nengel@10	325 static __inline uint32_t no_rnd_avg32(uint32_t a, uint32_t b)
nengel@10	326 {
nengel@10	327 return (a & b) + (((a ^ b) & ~(1 * 16843009LU)) >> 1);
nengel@10	328 }
nengel@10	329 static __inline void emms(void)
nengel@10	330 {
nengel@10	331 __asm__ volatile("emms;" : : : "memory");
nengel@10	332 }
nengel@10	333 static __inline void copy_block2(uint8_t dst, const uint8_t src, int dstStride, int srcStride, int h)
nengel@10	334 {
nengel@10	335 int i;
nengel@10	336 for (i = 0; i < h; i++)
nengel@9	337 {
nengel@10	338 {
nengel@10	339 do
nengel@10	340 {
nengel@9	341 {
nengel@10	342 ((uint8_t )dst)[0] = ((const uint8_t )src)[1] << 8 \| ((const uint8_t *)src)[0];
nengel@10	343 ((uint8_t )dst)[1] = (((const uint8_t )src)[1] << 8 \| ((const uint8_t *)src)[0]) >> 8;
nengel@9	344 }
nengel@10	345 }
nengel@9	346 while (0);
nengel@9	347 dst += dstStride;
nengel@9	348 src += srcStride;
nengel@10	349 }
nengel@9	350 }
nengel@9	351 }
nengel@10	352 static __inline void copy_block4(uint8_t dst, const uint8_t src, int dstStride, int srcStride, int h)
nengel@9	353 {
nengel@10	354 int i;
nengel@10	355 for (i = 0; i < h; i++)
nengel@9	356 {
nengel@10	357 {
nengel@9	358 do
nengel@10	359 {
nengel@10	360 {
nengel@10	361 ((uint8_t )dst)[0] = ((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0];
nengel@10	362 ((uint8_t )dst)[1] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 8;
nengel@10	363 ((uint8_t )dst)[2] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 16;
nengel@10	364 ((uint8_t )dst)[3] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 24;
nengel@10	365 }
nengel@10	366 }
nengel@9	367 while (0);
nengel@9	368 dst += dstStride;
nengel@9	369 src += srcStride;
nengel@10	370 }
nengel@9	371 }
nengel@9	372 }
nengel@10	373 static __inline void copy_block8(uint8_t dst, const uint8_t src, int dstStride, int srcStride, int h)
nengel@9	374 {
nengel@10	375 int i;
nengel@10	376 for (i = 0; i < h; i++)
nengel@9	377 {
nengel@10	378 {
nengel@9	379 do
nengel@10	380 {
nengel@10	381 {
nengel@10	382 ((uint8_t )dst)[0] = ((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0];
nengel@10	383 ((uint8_t )dst)[1] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 8;
nengel@10	384 ((uint8_t )dst)[2] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 16;
nengel@10	385 ((uint8_t )dst)[3] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 24;
nengel@10	386 }
nengel@10	387 }
nengel@9	388 while (0);
nengel@9	389 do
nengel@10	390 {
nengel@10	391 {
nengel@10	392 ((uint8_t )(dst + 4))[0] = ((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0];
nengel@10	393 ((uint8_t )(dst + 4))[1] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 8;
nengel@10	394 ((uint8_t )(dst + 4))[2] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 16;
nengel@10	395 ((uint8_t )(dst + 4))[3] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 24;
nengel@10	396 }
nengel@10	397 }
nengel@9	398 while (0);
nengel@9	399 dst += dstStride;
nengel@9	400 src += srcStride;
nengel@10	401 }
nengel@9	402 }
nengel@9	403 }
nengel@10	404 static __inline void copy_block9(uint8_t dst, const uint8_t src, int dstStride, int srcStride, int h)
nengel@9	405 {
nengel@10	406 int i;
nengel@10	407 for (i = 0; i < h; i++)
nengel@9	408 {
nengel@10	409 {
nengel@9	410 do
nengel@10	411 {
nengel@10	412 {
nengel@10	413 ((uint8_t )dst)[0] = ((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0];
nengel@10	414 ((uint8_t )dst)[1] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 8;
nengel@10	415 ((uint8_t )dst)[2] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 16;
nengel@10	416 ((uint8_t )dst)[3] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 24;
nengel@10	417 }
nengel@10	418 }
nengel@9	419 while (0);
nengel@9	420 do
nengel@10	421 {
nengel@10	422 {
nengel@10	423 ((uint8_t )(dst + 4))[0] = ((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0];
nengel@10	424 ((uint8_t )(dst + 4))[1] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 8;
nengel@10	425 ((uint8_t )(dst + 4))[2] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 16;
nengel@10	426 ((uint8_t )(dst + 4))[3] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 24;
nengel@10	427 }
nengel@10	428 }
nengel@9	429 while (0);
nengel@9	430 dst[8] = src[8];
nengel@9	431 dst += dstStride;
nengel@9	432 src += srcStride;
nengel@10	433 }
nengel@9	434 }
nengel@9	435 }
nengel@10	436 static __inline void copy_block16(uint8_t dst, const uint8_t src, int dstStride, int srcStride, int h)
nengel@9	437 {
nengel@10	438 int i;
nengel@10	439 for (i = 0; i < h; i++)
nengel@9	440 {
nengel@10	441 {
nengel@9	442 do
nengel@10	443 {
nengel@10	444 {
nengel@10	445 ((uint8_t )dst)[0] = ((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0];
nengel@10	446 ((uint8_t )dst)[1] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 8;
nengel@10	447 ((uint8_t )dst)[2] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 16;
nengel@10	448 ((uint8_t )dst)[3] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 24;
nengel@10	449 }
nengel@10	450 }
nengel@9	451 while (0);
nengel@9	452 do
nengel@10	453 {
nengel@10	454 {
nengel@10	455 ((uint8_t )(dst + 4))[0] = ((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0];
nengel@10	456 ((uint8_t )(dst + 4))[1] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 8;
nengel@10	457 ((uint8_t )(dst + 4))[2] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 16;
nengel@10	458 ((uint8_t )(dst + 4))[3] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 24;
nengel@10	459 }
nengel@10	460 }
nengel@9	461 while (0);
nengel@9	462 do
nengel@10	463 {
nengel@10	464 {
nengel@10	465 ((uint8_t )(dst + 8))[0] = ((((const uint8_t )(src + 8))[3] << 24 \| ((const uint8_t )(src + 8))[2] << 16) \| ((const uint8_t )(src + 8))[1] << 8) \| ((const uint8_t *)(src + 8))[0];
nengel@10	466 ((uint8_t )(dst + 8))[1] = (((((const uint8_t )(src + 8))[3] << 24 \| ((const uint8_t )(src + 8))[2] << 16) \| ((const uint8_t )(src + 8))[1] << 8) \| ((const uint8_t *)(src + 8))[0]) >> 8;
nengel@10	467 ((uint8_t )(dst + 8))[2] = (((((const uint8_t )(src + 8))[3] << 24 \| ((const uint8_t )(src + 8))[2] << 16) \| ((const uint8_t )(src + 8))[1] << 8) \| ((const uint8_t *)(src + 8))[0]) >> 16;
nengel@10	468 ((uint8_t )(dst + 8))[3] = (((((const uint8_t )(src + 8))[3] << 24 \| ((const uint8_t )(src + 8))[2] << 16) \| ((const uint8_t )(src + 8))[1] << 8) \| ((const uint8_t *)(src + 8))[0]) >> 24;
nengel@10	469 }
nengel@10	470 }
nengel@9	471 while (0);
nengel@9	472 do
nengel@10	473 {
nengel@10	474 {
nengel@10	475 ((uint8_t )(dst + 12))[0] = ((((const uint8_t )(src + 12))[3] << 24 \| ((const uint8_t )(src + 12))[2] << 16) \| ((const uint8_t )(src + 12))[1] << 8) \| ((const uint8_t *)(src + 12))[0];
nengel@10	476 ((uint8_t )(dst + 12))[1] = (((((const uint8_t )(src + 12))[3] << 24 \| ((const uint8_t )(src + 12))[2] << 16) \| ((const uint8_t )(src + 12))[1] << 8) \| ((const uint8_t *)(src + 12))[0]) >> 8;
nengel@10	477 ((uint8_t )(dst + 12))[2] = (((((const uint8_t )(src + 12))[3] << 24 \| ((const uint8_t )(src + 12))[2] << 16) \| ((const uint8_t )(src + 12))[1] << 8) \| ((const uint8_t *)(src + 12))[0]) >> 16;
nengel@10	478 ((uint8_t )(dst + 12))[3] = (((((const uint8_t )(src + 12))[3] << 24 \| ((const uint8_t )(src + 12))[2] << 16) \| ((const uint8_t )(src + 12))[1] << 8) \| ((const uint8_t *)(src + 12))[0]) >> 24;
nengel@10	479 }
nengel@10	480 }
nengel@9	481 while (0);
nengel@9	482 dst += dstStride;
nengel@9	483 src += srcStride;
nengel@10	484 }
nengel@9	485 }
nengel@9	486 }
nengel@10	487 static __inline void copy_block17(uint8_t dst, const uint8_t src, int dstStride, int srcStride, int h)
nengel@9	488 {
nengel@10	489 int i;
nengel@10	490 for (i = 0; i < h; i++)
nengel@9	491 {
nengel@10	492 {
nengel@9	493 do
nengel@10	494 {
nengel@10	495 {
nengel@10	496 ((uint8_t )dst)[0] = ((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0];
nengel@10	497 ((uint8_t )dst)[1] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 8;
nengel@10	498 ((uint8_t )dst)[2] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 16;
nengel@10	499 ((uint8_t )dst)[3] = (((((const uint8_t )src)[3] << 24 \| ((const uint8_t )src)[2] << 16) \| ((const uint8_t )src)[1] << 8) \| ((const uint8_t *)src)[0]) >> 24;
nengel@10	500 }
nengel@10	501 }
nengel@9	502 while (0);
nengel@9	503 do
nengel@10	504 {
nengel@10	505 {
nengel@10	506 ((uint8_t )(dst + 4))[0] = ((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0];
nengel@10	507 ((uint8_t )(dst + 4))[1] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 8;
nengel@10	508 ((uint8_t )(dst + 4))[2] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 16;
nengel@10	509 ((uint8_t )(dst + 4))[3] = (((((const uint8_t )(src + 4))[3] << 24 \| ((const uint8_t )(src + 4))[2] << 16) \| ((const uint8_t )(src + 4))[1] << 8) \| ((const uint8_t *)(src + 4))[0]) >> 24;
nengel@10	510 }
nengel@10	511 }
nengel@9	512 while (0);
nengel@9	513 do
nengel@10	514 {
nengel@10	515 {
nengel@10	516 ((uint8_t )(dst + 8))[0] = ((((const uint8_t )(src + 8))[3] << 24 \| ((const uint8_t )(src + 8))[2] << 16) \| ((const uint8_t )(src + 8))[1] << 8) \| ((const uint8_t *)(src + 8))[0];
nengel@10	517 ((uint8_t )(dst + 8))[1] = (((((const uint8_t )(src + 8))[3] << 24 \| ((const uint8_t )(src + 8))[2] << 16) \| ((const uint8_t )(src + 8))[1] << 8) \| ((const uint8_t *)(src + 8))[0]) >> 8;
nengel@10	518 ((uint8_t )(dst + 8))[2] = (((((const uint8_t )(src + 8))[3] << 24 \| ((const uint8_t )(src + 8))[2] << 16) \| ((const uint8_t )(src + 8))[1] << 8) \| ((const uint8_t *)(src + 8))[0]) >> 16;
nengel@10	519 ((uint8_t )(dst + 8))[3] = (((((const uint8_t )(src + 8))[3] << 24 \| ((const uint8_t )(src + 8))[2] << 16) \| ((const uint8_t )(src + 8))[1] << 8) \| ((const uint8_t *)(src + 8))[0]) >> 24;
nengel@10	520 }
nengel@10	521 }
nengel@9	522 while (0);
nengel@9	523 do
nengel@10	524 {
nengel@10	525 {
nengel@10	526 ((uint8_t )(dst + 12))[0] = ((((const uint8_t )(src + 12))[3] << 24 \| ((const uint8_t )(src + 12))[2] << 16) \| ((const uint8_t )(src + 12))[1] << 8) \| ((const uint8_t *)(src + 12))[0];
nengel@10	527 ((uint8_t )(dst + 12))[1] = (((((const uint8_t )(src + 12))[3] << 24 \| ((const uint8_t )(src + 12))[2] << 16) \| ((const uint8_t )(src + 12))[1] << 8) \| ((const uint8_t *)(src + 12))[0]) >> 8;
nengel@10	528 ((uint8_t )(dst + 12))[2] = (((((const uint8_t )(src + 12))[3] << 24 \| ((const uint8_t )(src + 12))[2] << 16) \| ((const uint8_t )(src + 12))[1] << 8) \| ((const uint8_t *)(src + 12))[0]) >> 16;
nengel@10	529 ((uint8_t )(dst + 12))[3] = (((((const uint8_t )(src + 12))[3] << 24 \| ((const uint8_t )(src + 12))[2] << 16) \| ((const uint8_t )(src + 12))[1] << 8) \| ((const uint8_t *)(src + 12))[0]) >> 24;
nengel@10	530 }
nengel@10	531 }
nengel@9	532 while (0);
nengel@9	533 dst[16] = src[16];
nengel@9	534 dst += dstStride;
nengel@9	535 src += srcStride;
nengel@10	536 }
nengel@9	537 }
nengel@9	538 }
nengel@10	539 static __inline uint64_t read_time(void)
nengel@9	540 {
nengel@10	541 uint32_t a;
nengel@10	542 uint32_t d;
nengel@10	543 __asm__ volatile("rdtsc" : "=a"(a), "=d"(d) : );
nengel@10	544 return ((uint64_t)d << 32) + a;
nengel@10	545 }
nengel@10	546 typedef signed char int8_t;
nengel@10	547 static __inline int32_t NEG_SSR32(int32_t a, int8_t s)
nengel@9	548 {
nengel@10	549 __asm__ ("sarl %1, %0\n\t" : "+r"(a) : "ic"((uint8_t) -s));
nengel@10	550 return a;
nengel@10	551 }
nengel@10	552 static __inline uint32_t NEG_USR32(uint32_t a, int8_t s)
nengel@9	553 {
nengel@10	554 __asm__ ("shrl %1, %0\n\t" : "+r"(a) : "ic"((uint8_t) -s));
nengel@10	555 return a;
nengel@10	556 }
nengel@10	557 static __inline __attribute__((always_inline)) int MULH(int a, int b)
nengel@9	558 {
nengel@10	559 return (int64_t)a * (int64_t)b >> 32;
nengel@9	560 }
nengel@10	561 static __inline __attribute__((always_inline)) unsigned int UMULH(unsigned int a, unsigned int b)
nengel@9	562 {
nengel@10	563 return (uint64_t)a * (uint64_t)b >> 32;
nengel@9	564 }
nengel@10	565 static __inline __attribute__((const)) int mid_pred(int a, int b, int c)
nengel@9	566 {
nengel@10	567 if (a > b)
nengel@10	568 {
nengel@10	569 {
nengel@10	570 if (c > b)
nengel@10	571 {
nengel@10	572 {
nengel@10	573 if (c > a)
nengel@10	574 {
nengel@10	575 b = a;
nengel@10	576 }
nengel@10	577 else
nengel@10	578 {
nengel@10	579 b = c;
nengel@10	580 }
nengel@10	581 }
nengel@10	582 }
nengel@10	583 }
nengel@10	584 }
nengel@10	585 else
nengel@10	586 {
nengel@10	587 {
nengel@10	588 if (b > c)
nengel@10	589 {
nengel@10	590 {
nengel@10	591 if (c > a)
nengel@10	592 {
nengel@10	593 b = c;
nengel@10	594 }
nengel@10	595 else
nengel@10	596 {
nengel@10	597 b = a;
nengel@10	598 }
nengel@10	599 }
nengel@10	600 }
nengel@10	601 }
nengel@10	602 }
nengel@10	603 return b;
nengel@9	604 }
nengel@10	605 static __inline __attribute__((const)) int sign_extend(int val, unsigned int bits)
nengel@9	606 {
nengel@10	607 return val << (8 * sizeof(int) - bits) >> (8 * sizeof(int) - bits);
nengel@9	608 }
nengel@10	609 static __inline __attribute__((const)) unsigned int zero_extend(unsigned int val, unsigned int bits)
nengel@9	610 {
nengel@10	611 return val << (8 * sizeof(int) - bits) >> (8 * sizeof(int) - bits);
nengel@9	612 }
nengel@10	613 struct GetBitContext;
nengel@10	614 typedef struct GetBitContext GetBitContext;
nengel@10	615 struct GetBitContext
nengel@9	616 {
nengel@10	617 uint8_t *rbsp;
nengel@10	618 unsigned int rbsp_size;
nengel@10	619 uint8_t *raw;
nengel@10	620 const uint8_t *buffer;
nengel@10	621 const uint8_t *buffer_end;
nengel@10	622 unsigned int alloc_size;
nengel@10	623 unsigned int buf_size;
nengel@10	624 uint32_t *buffer_ptr;
nengel@10	625 uint32_t cache0;
nengel@10	626 uint32_t cache1;
nengel@10	627 int bit_count;
nengel@10	628 int size_in_bits;
nengel@10	629 };
nengel@10	630 static __inline int get_bits_count(const GetBitContext *s)
nengel@10	631 {
nengel@10	632 return ((uint8_t )(s).buffer_ptr - (s).buffer) 8 - 32 + (*s).bit_count;
nengel@10	633 }
nengel@10	634 static __inline void skip_bits_long(GetBitContext *s, int n)
nengel@10	635 {
nengel@10	636 int re_bit_count = (*s).bit_count;
nengel@10	637 uint32_t re_cache0 = (*s).cache0;
nengel@10	638 uint32_t re_cache1 = (*s).cache1;
nengel@10	639 uint32_t re_buffer_ptr = (s).buffer_ptr;
nengel@10	640 re_bit_count += n;
nengel@10	641 re_buffer_ptr += re_bit_count >> 5;
nengel@10	642 re_bit_count &= 31;
nengel@10	643 re_cache0 = bswap_32(re_buffer_ptr[ -1]) << re_bit_count;
nengel@10	644 re_cache1 = 0;
nengel@10	645 if (re_bit_count > 0)
nengel@9	646 {
nengel@10	647 {
nengel@9	648 const uint32_t next = bswap_32(*re_buffer_ptr);
nengel@9	649 re_cache0 \|= NEG_USR32(next, re_bit_count);
nengel@9	650 re_cache1 \|= next << re_bit_count;
nengel@9	651 re_buffer_ptr++;
nengel@9	652 re_bit_count -= 32;
nengel@10	653 }
nengel@9	654 }
nengel@10	655 (*s).bit_count = re_bit_count;
nengel@10	656 (*s).cache0 = re_cache0;
nengel@10	657 (*s).cache1 = re_cache1;
nengel@10	658 (*s).buffer_ptr = re_buffer_ptr;
nengel@9	659 }
nengel@10	660 static __inline int get_xbits(GetBitContext *s, int n)
nengel@9	661 {
nengel@10	662 register int32_t cache;
nengel@10	663 register int sign;
nengel@10	664 int re_bit_count = (*s).bit_count;
nengel@10	665 uint32_t re_cache0 = (*s).cache0;
nengel@10	666 uint32_t re_cache1 = (*s).cache1;
nengel@10	667 uint32_t re_buffer_ptr = (s).buffer_ptr;
nengel@10	668 if (re_bit_count > 0)
nengel@9	669 {
nengel@10	670 {
nengel@9	671 const uint32_t next = bswap_32(*re_buffer_ptr);
nengel@9	672 re_cache0 \|= NEG_USR32(next, re_bit_count);
nengel@9	673 re_cache1 \|= next << re_bit_count;
nengel@9	674 re_buffer_ptr++;
nengel@9	675 re_bit_count -= 32;
nengel@10	676 }
nengel@9	677 }
nengel@10	678 cache = re_cache0;
nengel@10	679 sign = ~cache >> 31;
nengel@10	680 {
nengel@10	681 __asm__ ("shldl %2, %1, %0 \n\t""shll %2, %1 \n\t" : "+r"(re_cache0), "+r"(re_cache1) : "Ic"((uint8_t)n));
nengel@10	682 re_bit_count += n;
nengel@10	683 }
nengel@10	684 (*s).bit_count = re_bit_count;
nengel@10	685 (*s).cache0 = re_cache0;
nengel@10	686 (*s).cache1 = re_cache1;
nengel@10	687 (*s).buffer_ptr = re_buffer_ptr;
nengel@10	688 return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
nengel@10	689 }
nengel@10	690 static __inline int get_sbits(GetBitContext *s, int n)
nengel@10	691 {
nengel@10	692 register int tmp;
nengel@10	693 int re_bit_count = (*s).bit_count;
nengel@10	694 uint32_t re_cache0 = (*s).cache0;
nengel@10	695 uint32_t re_cache1 = (*s).cache1;
nengel@10	696 uint32_t re_buffer_ptr = (s).buffer_ptr;
nengel@10	697 if (re_bit_count > 0)
nengel@9	698 {
nengel@10	699 {
nengel@9	700 const uint32_t next = bswap_32(*re_buffer_ptr);
nengel@9	701 re_cache0 \|= NEG_USR32(next, re_bit_count);
nengel@9	702 re_cache1 \|= next << re_bit_count;
nengel@9	703 re_buffer_ptr++;
nengel@9	704 re_bit_count -= 32;
nengel@10	705 }
nengel@9	706 }
nengel@10	707 tmp = NEG_SSR32(re_cache0, n);
nengel@10	708 {
nengel@10	709 __asm__ ("shldl %2, %1, %0 \n\t""shll %2, %1 \n\t" : "+r"(re_cache0), "+r"(re_cache1) : "Ic"((uint8_t)n));
nengel@10	710 re_bit_count += n;
nengel@10	711 }
nengel@10	712 (*s).bit_count = re_bit_count;
nengel@10	713 (*s).cache0 = re_cache0;
nengel@10	714 (*s).cache1 = re_cache1;
nengel@10	715 (*s).buffer_ptr = re_buffer_ptr;
nengel@10	716 return tmp;
nengel@10	717 }
nengel@10	718 static __inline unsigned int get_bits(GetBitContext *s, int n)
nengel@10	719 {
nengel@10	720 register int tmp;
nengel@10	721 int re_bit_count = (*s).bit_count;
nengel@10	722 uint32_t re_cache0 = (*s).cache0;
nengel@10	723 uint32_t re_cache1 = (*s).cache1;
nengel@10	724 uint32_t re_buffer_ptr = (s).buffer_ptr;
nengel@10	725 if (re_bit_count > 0)
nengel@9	726 {
nengel@10	727 {
nengel@9	728 const uint32_t next = bswap_32(*re_buffer_ptr);
nengel@9	729 re_cache0 \|= NEG_USR32(next, re_bit_count);
nengel@9	730 re_cache1 \|= next << re_bit_count;
nengel@9	731 re_buffer_ptr++;
nengel@9	732 re_bit_count -= 32;
nengel@10	733 }
nengel@9	734 }
nengel@10	735 tmp = NEG_USR32(re_cache0, n);
nengel@10	736 {
nengel@10	737 __asm__ ("shldl %2, %1, %0 \n\t""shll %2, %1 \n\t" : "+r"(re_cache0), "+r"(re_cache1) : "Ic"((uint8_t)n));
nengel@10	738 re_bit_count += n;
nengel@10	739 }
nengel@10	740 (*s).bit_count = re_bit_count;
nengel@10	741 (*s).cache0 = re_cache0;
nengel@10	742 (*s).cache1 = re_cache1;
nengel@10	743 (*s).buffer_ptr = re_buffer_ptr;
nengel@10	744 return tmp;
nengel@10	745 }
nengel@10	746 static __inline unsigned int show_bits(GetBitContext *s, int n)
nengel@10	747 {
nengel@10	748 register int tmp;
nengel@10	749 int re_bit_count = (*s).bit_count;
nengel@10	750 uint32_t re_cache0 = (*s).cache0;
nengel@10	751 uint32_t re_cache1 = (*s).cache1;
nengel@10	752 uint32_t re_buffer_ptr = (s).buffer_ptr;
nengel@10	753 if (re_bit_count > 0)
nengel@9	754 {
nengel@10	755 {
nengel@9	756 const uint32_t next = bswap_32(*re_buffer_ptr);
nengel@9	757 re_cache0 \|= NEG_USR32(next, re_bit_count);
nengel@9	758 re_cache1 \|= next << re_bit_count;
nengel@9	759 re_buffer_ptr++;
nengel@9	760 re_bit_count -= 32;
nengel@10	761 }
nengel@9	762 }
nengel@10	763 tmp = NEG_USR32(re_cache0, n);
nengel@10	764 return tmp;
nengel@9	765 }
nengel@10	766 static __inline void skip_bits(GetBitContext *s, int n)
nengel@9	767 {
nengel@10	768 int re_bit_count = (*s).bit_count;
nengel@10	769 uint32_t re_cache0 = (*s).cache0;
nengel@10	770 uint32_t re_cache1 = (*s).cache1;
nengel@10	771 uint32_t re_buffer_ptr = (s).buffer_ptr;
nengel@10	772 if (re_bit_count > 0)
nengel@9	773 {
nengel@10	774 {
nengel@9	775 const uint32_t next = bswap_32(*re_buffer_ptr);
nengel@9	776 re_cache0 \|= NEG_USR32(next, re_bit_count);
nengel@9	777 re_cache1 \|= next << re_bit_count;
nengel@9	778 re_buffer_ptr++;
nengel@9	779 re_bit_count -= 32;
nengel@10	780 }
nengel@9	781 }
nengel@10	782 {
nengel@10	783 __asm__ ("shldl %2, %1, %0 \n\t""shll %2, %1 \n\t" : "+r"(re_cache0), "+r"(re_cache1) : "Ic"((uint8_t)n));
nengel@10	784 re_bit_count += n;
nengel@10	785 }
nengel@10	786 (*s).bit_count = re_bit_count;
nengel@10	787 (*s).cache0 = re_cache0;
nengel@10	788 (*s).cache1 = re_cache1;
nengel@10	789 (*s).buffer_ptr = re_buffer_ptr;
nengel@10	790 }
nengel@10	791 static __inline unsigned int get_bits1(GetBitContext *s)
nengel@10	792 {
nengel@10	793 return get_bits(s, 1);
nengel@10	794 }
nengel@10	795 static __inline unsigned int show_bits1(GetBitContext *s)
nengel@10	796 {
nengel@10	797 return show_bits(s, 1);
nengel@10	798 }
nengel@10	799 static __inline void skip_bits1(GetBitContext *s)
nengel@10	800 {
nengel@10	801 skip_bits(s, 1);
nengel@10	802 }
nengel@10	803 static __inline unsigned int get_bits_long(GetBitContext *s, int n)
nengel@10	804 {
nengel@10	805 if (n <= 32)
nengel@9	806 {
nengel@10	807 return get_bits(s, n);
nengel@9	808 }
nengel@10	809 else
nengel@9	810 {
nengel@10	811 {
nengel@9	812 int ret = get_bits(s, 16) << (n - 16);
nengel@9	813 return ret \| get_bits(s, n - 16);
nengel@10	814 }
nengel@9	815 }
nengel@9	816 }
nengel@10	817 static __inline int get_sbits_long(GetBitContext *s, int n)
nengel@9	818 {
nengel@10	819 return sign_extend(get_bits_long(s, n), n);
nengel@9	820 }
nengel@10	821 static __inline unsigned int show_bits_long(GetBitContext *s, int n)
nengel@9	822 {
nengel@10	823 if (n <= 32)
nengel@9	824 {
nengel@10	825 return show_bits(s, n);
nengel@10	826 }
nengel@10	827 else
nengel@10	828 {
nengel@10	829 {
nengel@9	830 GetBitContext gb = *s;
nengel@9	831 return get_bits_long(&gb, n);
nengel@10	832 }
nengel@9	833 }
nengel@9	834 }
nengel@10	835 void av_log(int level, const char *fmt, ...);
nengel@10	836 static __inline int check_marker(GetBitContext s, const char msg)
nengel@9	837 {
nengel@10	838 int bit = get_bits1(s);
nengel@10	839 if (!bit)
nengel@10	840 {
nengel@10	841 av_log(32, "Marker bit missing %s\n", msg);
nengel@10	842 }
nengel@10	843 return bit;
nengel@9	844 }
nengel@10	845 typedef long int __intptr_t;
nengel@10	846 typedef __intptr_t intptr_t;
nengel@10	847 static __inline void init_get_bits(GetBitContext s, const uint8_t buffer, int bit_size)
nengel@9	848 {
nengel@10	849 int buffer_size = (bit_size + 7) >> 3;
nengel@10	850 if (buffer_size < 0 \|\| bit_size < 0)
nengel@9	851 {
nengel@10	852 {
nengel@9	853 buffer_size = bit_size = 0;
nengel@10	854 buffer = (void *)0;
nengel@10	855 }
nengel@9	856 }
nengel@10	857 (*s).buffer = buffer;
nengel@10	858 (*s).size_in_bits = bit_size;
nengel@10	859 (*s).buffer_end = buffer + buffer_size;
nengel@10	860 (s).buffer_ptr = (uint32_t )((intptr_t)buffer & ~3);
nengel@10	861 (s).bit_count = 32 + 8 ((intptr_t)buffer & 3);
nengel@10	862 skip_bits_long(s, 0);
nengel@9	863 }
nengel@10	864 static __inline void align_get_bits(GetBitContext *s)
nengel@9	865 {
nengel@10	866 int n = -get_bits_count(s) & 7;
nengel@10	867 if (n)
nengel@10	868 {
nengel@10	869 skip_bits(s, n);
nengel@10	870 }
nengel@9	871 }
nengel@10	872 static __inline int get_bits_left(GetBitContext *gb)
nengel@9	873 {
nengel@10	874 return (*gb).size_in_bits - get_bits_count(gb);
nengel@9	875 }
nengel@10	876 struct H264Slice;
nengel@10	877 typedef struct H264Slice H264Slice;
nengel@10	878 struct PPS
nengel@9	879 {
nengel@10	880 unsigned int sps_id;
nengel@10	881 int cabac;
nengel@10	882 int pic_order_present;
nengel@10	883 int slice_group_count;
nengel@10	884 int mb_slice_group_map_type;
nengel@10	885 unsigned int ref_count[2];
nengel@10	886 int weighted_pred;
nengel@10	887 int weighted_bipred_idc;
nengel@10	888 int init_qp;
nengel@10	889 int init_qs;
nengel@10	890 int chroma_qp_index_offset[2];
nengel@10	891 int deblocking_filter_parameters_present;
nengel@10	892 int constrained_intra_pred;
nengel@10	893 int redundant_pic_cnt_present;
nengel@10	894 int transform_8x8_mode;
nengel@10	895 uint8_t scaling_matrix4[6][16];
nengel@10	896 uint8_t scaling_matrix8[2][64];
nengel@10	897 uint8_t chroma_qp_table[2][64];
nengel@10	898 int chroma_qp_diff;
nengel@9	899 };
nengel@10	900 typedef struct PPS PPS;
nengel@10	901 struct PictureInfo;
nengel@10	902 typedef struct PictureInfo PictureInfo;
nengel@10	903 struct DecodedPicture;
nengel@10	904 typedef struct DecodedPicture DecodedPicture;
nengel@10	905 struct H264Slice
nengel@9	906 {
nengel@10	907 PPS pps;
nengel@10	908 PictureInfo *current_picture_info;
nengel@10	909 DecodedPicture *curr_pic;
nengel@10	910 int slice_num;
nengel@10	911 int release_ref_cpn[66];
nengel@10	912 int release_cnt;
nengel@10	913 int qp_thresh;
nengel@10	914 int use_weight;
nengel@10	915 int use_weight_chroma;
nengel@10	916 int luma_log2_weight_denom;
nengel@10	917 int chroma_log2_weight_denom;
nengel@10	918 int16_t luma_weight[16][2][2];
nengel@10	919 int16_t chroma_weight[16][2][2][2];
nengel@10	920 int16_t implicit_weight[16][16][2];
nengel@10	921 int ref_list_cpn[2][16];
nengel@10	922 PictureInfo *ref_list[2][16];
nengel@10	923 DecodedPicture *dp_ref_list[2][16];
nengel@10	924 int ref_count[2];
nengel@10	925 int slice_type;
nengel@10	926 int slice_type_nos;
nengel@10	927 int slice_alpha_c0_offset;
nengel@10	928 int slice_beta_offset;
nengel@10	929 int direct_8x8_inference_flag;
nengel@10	930 uint8_t list_count;
nengel@10	931 uint32_t coded_pic_num;
nengel@10	932 int poc;
nengel@10	933 int key_frame;
nengel@10	934 int mmco_reset;
nengel@10	935 int ip_id;
nengel@10	936 int transform_bypass;
nengel@10	937 int direct_spatial_mv_pred;
nengel@10	938 int map_col_to_list0[2][16];
nengel@10	939 int dist_scale_factor[16];
nengel@10	940 int cabac_init_idc;
nengel@10	941 int nal_ref_idc;
nengel@10	942 int nal_unit_type;
nengel@10	943 int ref2frm[2][64];
nengel@10	944 int qscale;
nengel@9	945 };
nengel@10	946 static __inline int get_chroma_qp(H264Slice *s, int t, int qscale)
nengel@9	947 {
nengel@10	948 return (*s).pps.chroma_qp_table[t][qscale];
nengel@10	949 }
nengel@10	950 struct H264Context;
nengel@10	951 typedef struct H264Context H264Context;
nengel@10	952 struct ParserContext;
nengel@10	953 typedef struct ParserContext ParserContext;
nengel@10	954 struct NalContext;
nengel@10	955 typedef struct NalContext NalContext;
nengel@10	956 struct mcc_struct_anon_54;
nengel@10	957 typedef struct mcc_struct_anon_54 SliceBufferEntry;
nengel@10	958 struct H264Mb;
nengel@10	959 typedef struct H264Mb H264Mb;
nengel@10	960 struct mcc_struct_anon_54
nengel@9	961 {
nengel@10	962 H264Slice slice;
nengel@10	963 H264Mb *mbs;
nengel@10	964 DecodedPicture *dp;
nengel@10	965 GetBitContext gb;
nengel@10	966 int lines_taken;
nengel@10	967 int lines_total;
nengel@10	968 int state;
nengel@10	969 int initialized;
nengel@10	970 };
nengel@10	971 void init_sb_entry(H264Context h, SliceBufferEntry sbe);
nengel@10	972 struct __pthread_internal_list;
nengel@10	973 struct __pthread_internal_list
nengel@9	974 {
nengel@10	975 struct __pthread_internal_list *__prev;
nengel@10	976 struct __pthread_internal_list *__next;
nengel@10	977 };
nengel@10	978 typedef struct __pthread_internal_list __pthread_list_t;
nengel@10	979 struct __pthread_mutex_s
nengel@9	980 {
nengel@10	981 int __lock;
nengel@10	982 unsigned int __count;
nengel@10	983 int __owner;
nengel@10	984 unsigned int __nusers;
nengel@10	985 int __kind;
nengel@10	986 int __spins;
nengel@10	987 __pthread_list_t __list;
nengel@10	988 };
nengel@10	989 union mcc_union_anon_26
nengel@9	990 {
nengel@10	991 struct __pthread_mutex_s __data;
nengel@10	992 char __size[40];
nengel@10	993 long int __align;
nengel@10	994 };
nengel@10	995 typedef union mcc_union_anon_26 pthread_mutex_t;
nengel@10	996 struct mcc_struct_anon_29
nengel@9	997 {
nengel@10	998 int __lock;
nengel@10	999 unsigned int __futex;
nengel@10	1000 __extension__ unsigned long long int __total_seq;
nengel@10	1001 __extension__ unsigned long long int __wakeup_seq;
nengel@10	1002 __extension__ unsigned long long int __woken_seq;
nengel@10	1003 void *__mutex;
nengel@10	1004 unsigned int __nwaiters;
nengel@10	1005 unsigned int __broadcast_seq;
nengel@10	1006 };
nengel@10	1007 union mcc_union_anon_28
nengel@9	1008 {
nengel@10	1009 struct mcc_struct_anon_29 __data;
nengel@10	1010 char __size[48];
nengel@10	1011 __extension__ long long int __align;
nengel@10	1012 };
nengel@10	1013 typedef union mcc_union_anon_28 pthread_cond_t;
nengel@10	1014 struct mcc_struct_anon_56
nengel@9	1015 {
nengel@10	1016 pthread_mutex_t lock;
nengel@10	1017 pthread_cond_t cond;
nengel@10	1018 SliceBufferEntry **queue;
nengel@10	1019 int size;
nengel@10	1020 int cnt;
nengel@10	1021 int fi;
nengel@10	1022 int fo;
nengel@10	1023 };
nengel@10	1024 typedef struct mcc_struct_anon_56 SliceBufferQueue;
nengel@10	1025 struct RingLineEntry;
nengel@10	1026 typedef struct RingLineEntry RingLineEntry;
nengel@10	1027 struct mcc_struct_anon_57
nengel@9	1028 {
nengel@10	1029 pthread_mutex_t wslock;
nengel@10	1030 pthread_cond_t wscond;
nengel@10	1031 pthread_mutex_t swlock;
nengel@10	1032 pthread_cond_t swcond;
nengel@10	1033 RingLineEntry **queue;
nengel@10	1034 int size;
nengel@10	1035 int ready;
nengel@10	1036 int free;
nengel@10	1037 int fi;
nengel@10	1038 int fo;
nengel@10	1039 };
nengel@10	1040 typedef struct mcc_struct_anon_57 RingLineQueue;
nengel@10	1041 union mcc_union_anon_25
nengel@9	1042 {
nengel@10	1043 char __size[56];
nengel@10	1044 long int __align;
nengel@10	1045 };
nengel@10	1046 typedef union mcc_union_anon_25 pthread_attr_t;
nengel@10	1047 typedef unsigned long int pthread_t;
nengel@10	1048 struct SuperMBContext;
nengel@10	1049 typedef struct SuperMBContext SuperMBContext;
nengel@10	1050 typedef long int __time_t;
nengel@10	1051 struct timespec
nengel@9	1052 {
nengel@10	1053 __time_t tv_sec;
nengel@10	1054 long int tv_nsec;
nengel@10	1055 };
nengel@10	1056 struct H264Context
nengel@9	1057 {
nengel@10	1058 SliceBufferQueue sb_q[6];
nengel@10	1059 RingLineQueue rl_q;
nengel@10	1060 pthread_mutex_t lock[6];
nengel@10	1061 pthread_cond_t cond[6];
nengel@10	1062 pthread_mutex_t task_lock;
nengel@10	1063 pthread_cond_t task_cond;
nengel@10	1064 pthread_attr_t ed_rec_attr[80];
nengel@10	1065 pthread_t ed_rec_thr[80];
nengel@10	1066 int init_threads;
nengel@10	1067 pthread_mutex_t ilock;
nengel@10	1068 pthread_cond_t icond;
nengel@10	1069 const char *file_name;
nengel@10	1070 int profile;
nengel@10	1071 int start;
nengel@10	1072 int touch_start;
nengel@10	1073 int setaff;
nengel@10	1074 int touch_done;
nengel@10	1075 int rl_side_touch;
nengel@10	1076 int statmbd;
nengel@10	1077 pthread_mutex_t slock;
nengel@10	1078 pthread_cond_t scond;
nengel@10	1079 pthread_mutex_t tlock;
nengel@10	1080 pthread_cond_t tcond;
nengel@10	1081 pthread_mutex_t tdlock;
nengel@10	1082 pthread_cond_t tdcond;
nengel@10	1083 int ed_ppe_threads;
nengel@10	1084 int threads;
nengel@10	1085 int smt;
nengel@10	1086 int acdpb_cnt;
nengel@10	1087 int reldpb_cnt;
nengel@10	1088 int sb_size;
nengel@10	1089 SliceBufferEntry *sb;
nengel@10	1090 int free_sb_cnt;
nengel@10	1091 int slice_bufs;
nengel@10	1092 int max_dpb_cnt;
nengel@10	1093 DecodedPicture *dpb;
nengel@10	1094 int free_dpb_cnt;
nengel@10	1095 int ifile;
nengel@10	1096 int ofile;
nengel@10	1097 int frame_width;
nengel@10	1098 int frame_height;
nengel@10	1099 int num_frames;
nengel@10	1100 int width;
nengel@10	1101 int height;
nengel@10	1102 int mb_width;
nengel@10	1103 int mb_height;
nengel@10	1104 int mb_stride;
nengel@10	1105 int b4_stride;
nengel@10	1106 int b_stride;
nengel@10	1107 int smb_height;
nengel@10	1108 int smb_width;
nengel@10	1109 pthread_mutex_t smb_lock;
nengel@10	1110 pthread_cond_t sdl_cond;
nengel@10	1111 pthread_mutex_t sdl_lock;
nengel@10	1112 SuperMBContext *smbc;
nengel@10	1113 int wave_order;
nengel@10	1114 int static_3d;
nengel@10	1115 int pipe_bufs;
nengel@10	1116 uint8_t zigzag_scan[16];
nengel@10	1117 uint8_t zigzag_scan8x8[64];
nengel@10	1118 int verbose;
nengel@10	1119 int no_mbd;
nengel@10	1120 int display;
nengel@10	1121 int fullscreen;
nengel@10	1122 int quit;
nengel@10	1123 struct timespec start_time[4];
nengel@10	1124 struct timespec end_time[4];
nengel@10	1125 double last_time[4];
nengel@10	1126 double total_time[4];
nengel@10	1127 };
nengel@10	1128 void av_read_frame_internal(ParserContext pc, GetBitContext gb);
nengel@10	1129 int decode_nal_units(NalContext n, H264Slice s, GetBitContext *gb);
nengel@10	1130 static void parse_task(H264Context h, ParserContext pc, NalContext nc, SliceBufferEntry sbe)
nengel@9	1131 {
nengel@10	1132 H264Slice *s;
nengel@10	1133 if (!(*sbe).initialized)
nengel@10	1134 {
nengel@10	1135 {
nengel@10	1136 init_sb_entry(h, sbe);
nengel@10	1137 (sbe).lines_total = (h).mb_height;
nengel@10	1138 }
nengel@10	1139 }
nengel@10	1140 av_read_frame_internal(pc, &(*sbe).gb);
nengel@10	1141 s = &(*sbe).slice;
nengel@10	1142 decode_nal_units(nc, s, &(*sbe).gb);
nengel@10	1143 }
nengel@10	1144 struct EntropyContext;
nengel@10	1145 typedef struct EntropyContext EntropyContext;
nengel@10	1146 struct EntropyContext
nengel@9	1147 {
nengel@10	1148 CABACContext c;
nengel@10	1149 H264Mb *m;
nengel@10	1150 int top_cbp;
nengel@10	1151 int left_cbp;
nengel@10	1152 int neighbor_transform_size;
nengel@10	1153 uint32_t top_type;
nengel@10	1154 uint32_t left_type;
nengel@10	1155 uint32_t topright_type;
nengel@10	1156 uint32_t topleft_type;
nengel@10	1157 int curr_qscale;
nengel@10	1158 int chroma_qp[2];
nengel@10	1159 int last_qscale_diff;
nengel@10	1160 uint32_t dequant4_buffer[6][52][16];
nengel@10	1161 uint32_t dequant8_buffer[2][52][64];
nengel@10	1162 uint32_t (*dequant4_coeff[6])[16];
nengel@10	1163 uint32_t (*dequant8_coeff[2])[64];
nengel@10	1164 uint8_t (*non_zero_count_top)[8];
nengel@10	1165 uint8_t (*non_zero_count)[8];
nengel@10	1166 uint8_t (*non_zero_count_row[2])[8];
nengel@10	1167 __attribute__((aligned(8))) uint8_t non_zero_count_left[8];
nengel@10	1168 uint8_t (*mvd_top[2])[2];
nengel@10	1169 uint8_t (*mvd[2])[2];
nengel@10	1170 uint8_t (*mvd_table[2][2])[2];
nengel@10	1171 uint8_t *direct_top;
nengel@10	1172 uint8_t *direct;
nengel@10	1173 uint8_t *direct_table[2];
nengel@10	1174 uint8_t *chroma_pred_mode_top;
nengel@10	1175 uint8_t *chroma_pred_mode;
nengel@10	1176 uint8_t *chroma_pred_mode_table[2];
nengel@10	1177 uint16_t *cbp_top;
nengel@10	1178 uint16_t *cbp;
nengel@10	1179 uint16_t *cbp_table[2];
nengel@10	1180 int8_t *qscale_top;
nengel@10	1181 int8_t *qscale;
nengel@10	1182 int8_t *qscale_table[2];
nengel@10	1183 int8_t *ref_index_top[2];
nengel@10	1184 int8_t *ref_index[2];
nengel@10	1185 int8_t *ref_index_table[2][2];
nengel@10	1186 uint32_t *mb_type_top;
nengel@10	1187 uint32_t *mb_type;
nengel@10	1188 uint32_t *mb_type_table[2];
nengel@10	1189 int b_stride;
nengel@10	1190 int mb_stride;
nengel@10	1191 int mb_width;
nengel@10	1192 int mb_height;
nengel@10	1193 uint8_t *zigzag_scan;
nengel@10	1194 uint8_t *zigzag_scan8x8;
nengel@10	1195 uint8_t direct_cache[40];
nengel@10	1196 __attribute__((aligned(8))) int8_t intra4x4_pred_mode_cache[40];
nengel@10	1197 __attribute__((aligned(16))) int16_t mv_cache[2][40][2];
nengel@10	1198 __attribute__((aligned(8))) int8_t ref_cache[2][40];
nengel@10	1199 __attribute__((aligned(8))) uint8_t non_zero_count_cache[48];
nengel@10	1200 __attribute__((aligned(16))) uint8_t mvd_cache[2][40][2];
nengel@10	1201 };
nengel@10	1202 void init_dequant_tables(H264Slice s, EntropyContext ec);
nengel@10	1203 void ff_init_cabac_decoder(CABACContext c, const uint8_t buf, int buf_size);
nengel@9	1204 void ff_h264_init_cabac_states(EntropyContext ec, H264Slice s, CABACContext *c);
nengel@9	1205 int init_entropy_buf(EntropyContext ec, H264Slice s, int line);
nengel@10	1206 struct H264Mb
nengel@9	1207 {
nengel@10	1208 int16_t mb_x;
nengel@10	1209 int16_t mb_y;
nengel@10	1210 int32_t mb_type;
nengel@10	1211 uint16_t cbp;
nengel@10	1212 int8_t qscale_mb_xy;
nengel@10	1213 int8_t qscale_left_mb_xy;
nengel@10	1214 int8_t qscale_top_mb_xy;
nengel@10	1215 __attribute__((aligned(8))) uint16_t sub_mb_type[4];
nengel@10	1216 __attribute__((aligned(8))) uint8_t non_zero_count[24];
nengel@10	1217 __attribute__((aligned(16))) int16_t mb[384];
nengel@10	1218 union
nengel@10	1219 {
nengel@10	1220 struct
nengel@9	1221 {
nengel@10	1222 __attribute__((aligned(8))) int8_t ref_index[2][4];
nengel@10	1223 __attribute__((aligned(16))) int16_t mvd[2][16][2];
nengel@10	1224 };
nengel@10	1225 struct
nengel@10	1226 {
nengel@10	1227 __attribute__((aligned(8))) int8_t intra4x4_pred_mode[16];
nengel@10	1228 int8_t chroma_pred_mode;
nengel@10	1229 int8_t intra16x16_pred_mode;
nengel@10	1230 };
nengel@10	1231 };
nengel@10	1232 __attribute__((aligned(8))) uint8_t top_border[32];
nengel@10	1233 __attribute__((aligned(8))) uint8_t top_border_next[8];
nengel@10	1234 __attribute__((aligned(8))) uint8_t left_border[35];
nengel@10	1235 int8_t intra4x4_pred_mode_left[4];
nengel@10	1236 };
nengel@10	1237 int ff_h264_decode_mb_cabac(EntropyContext ec, H264Slice s, CABACContext *c);
nengel@9	1238 static void decode_slice_entropy_task(H264Context h, EntropyContext ec, SliceBufferEntry *sbe)
nengel@9	1239 {
nengel@10	1240 int j;
nengel@10	1241 int i;
nengel@10	1242 H264Slice s = &(sbe).slice;
nengel@10	1243 GetBitContext gb = &(sbe).gb;
nengel@10	1244 H264Mb mbs = (sbe).mbs;
nengel@10	1245 CABACContext c = &(ec).c;
nengel@10	1246 if (!(*s).pps.cabac)
nengel@9	1247 {
nengel@10	1248 {
nengel@9	1249 av_log(16, "Only cabac encoded streams are supported\n");
nengel@10	1250 return ;
nengel@10	1251 }
nengel@9	1252 }
nengel@10	1253 init_dequant_tables(s, ec);
nengel@10	1254 (ec).curr_qscale = (s).qscale;
nengel@10	1255 (*ec).last_qscale_diff = 0;
nengel@10	1256 (ec).chroma_qp[0] = get_chroma_qp((H264Slice )s, 0, (*s).qscale);
nengel@10	1257 (ec).chroma_qp[1] = get_chroma_qp((H264Slice )s, 1, (*s).qscale);
nengel@10	1258 align_get_bits(gb);
nengel@10	1259 ff_init_cabac_decoder(c, (*gb).buffer + get_bits_count(gb) / 8, (get_bits_left(gb) + 7) / 8);
nengel@10	1260 ff_h264_init_cabac_states(ec, s, c);
nengel@10	1261 for (j = 0; j < (*ec).mb_height; j++)
nengel@9	1262 {
nengel@10	1263 {
nengel@9	1264 init_entropy_buf(ec, s, j);
nengel@10	1265 for (i = 0; i < (*ec).mb_width; i++)
nengel@10	1266 {
nengel@10	1267 {
nengel@10	1268 int ret;
nengel@10	1269 int eos;
nengel@10	1270 H264Mb m = &mbs[i + j (*ec).mb_width];
nengel@10	1271 (*m).mb_x = i;
nengel@10	1272 (*m).mb_y = j;
nengel@10	1273 (*ec).m = m;
nengel@10	1274 ret = ff_h264_decode_mb_cabac(ec, s, c);
nengel@10	1275 eos = get_cabac_terminate(c);
nengel@10	1276 (void)eos;
nengel@10	1277 if (ret < 0 \|\| (c).bytestream > (c).bytestream_end + 2)
nengel@10	1278 {
nengel@10	1279 {
nengel@10	1280 av_log(16, "error while decoding MB %d %d, bytestream (%td)\n", (m).mb_x, (m).mb_y, (c).bytestream_end - (c).bytestream);
nengel@10	1281 return ;
nengel@10	1282 }
nengel@10	1283 }
nengel@10	1284 }
nengel@10	1285 }
nengel@10	1286 }
nengel@10	1287 }
nengel@10	1288 }
nengel@10	1289 struct MBRecContext;
nengel@10	1290 typedef struct MBRecContext MBRecContext;
nengel@10	1291 struct SuperMBTask;
nengel@10	1292 typedef struct SuperMBTask SuperMBTask;
nengel@10	1293 struct SuperMBContext
nengel@10	1294 {
nengel@10	1295 int nsmb_width;
nengel@10	1296 int nsmb_height;
nengel@10	1297 int nsmb_3dheight;
nengel@10	1298 int smb_width;
nengel@10	1299 int smb_height;
nengel@10	1300 int refcount;
nengel@10	1301 int index;
nengel@10	1302 SuperMBTask *smbs[2];
nengel@10	1303 };
nengel@10	1304 struct MBRecState;
nengel@10	1305 typedef struct MBRecState MBRecState;
nengel@10	1306 void init_mbrec_context(MBRecContext mrc, MBRecState mrs, H264Slice *s, int line);
nengel@10	1307 struct MBRecState
nengel@10	1308 {
nengel@10	1309 int8_t *ref_index_top[2];
nengel@10	1310 int8_t *ref_index[2];
nengel@10	1311 int16_t (*motion_val_top[2])[2];
nengel@10	1312 int16_t (*motion_val[2])[2];
nengel@10	1313 uint32_t *mb_type_top;
nengel@10	1314 uint32_t *mb_type;
nengel@10	1315 int8_t *list1_ref_index[2];
nengel@10	1316 int16_t (*list1_motion_val[2])[2];
nengel@10	1317 uint32_t *list1_mb_type;
nengel@10	1318 int8_t *intra4x4_pred_mode_top;
nengel@10	1319 int8_t *intra4x4_pred_mode;
nengel@10	1320 int8_t *non_zero_count_top;
nengel@10	1321 int8_t *non_zero_count;
nengel@10	1322 unsigned int topleft_samples_available;
nengel@10	1323 unsigned int topright_samples_available;
nengel@10	1324 unsigned int top_samples_available;
nengel@10	1325 unsigned int left_samples_available;
nengel@10	1326 int top_type;
nengel@10	1327 int left_type;
nengel@10	1328 __attribute__((aligned(8))) int8_t intra4x4_pred_mode_cache[40];
nengel@10	1329 __attribute__((aligned(16))) int16_t mv_cache[2][40][2];
nengel@10	1330 __attribute__((aligned(8))) int8_t ref_cache[2][40];
nengel@10	1331 __attribute__((aligned(8))) uint8_t non_zero_count_cache[48];
nengel@10	1332 __attribute__((aligned(16))) uint8_t mvd_cache[2][40][2];
nengel@10	1333 __attribute__((aligned(8))) int16_t bS[2][4][4];
nengel@10	1334 uint8_t edges[2];
nengel@10	1335 };
nengel@10	1336 typedef short int DCTELEM;
nengel@10	1337 typedef void (op_pixels_func)(uint8_t , const uint8_t *, int, int);
nengel@10	1338 typedef void (qpel_mc_func)(uint8_t , uint8_t *, int);
nengel@10	1339 typedef void (h264_chroma_mc_func)(uint8_t , uint8_t *, int, int, int, int);
nengel@10	1340 struct DSPContext
nengel@10	1341 {
nengel@10	1342 void (get_pixels)(DCTELEM , const uint8_t *, int);
nengel@10	1343 void (diff_pixels)(DCTELEM , const uint8_t , const uint8_t , int);
nengel@10	1344 void (put_pixels_clamped)(const DCTELEM , uint8_t *, int);
nengel@10	1345 void (put_signed_pixels_clamped)(const DCTELEM , uint8_t *, int);
nengel@10	1346 void (put_pixels_nonclamped)(const DCTELEM , uint8_t *, int);
nengel@10	1347 void (add_pixels_clamped)(const DCTELEM , uint8_t *, int);
nengel@10	1348 void (add_pixels8)(uint8_t , DCTELEM *, int);
nengel@10	1349 void (add_pixels4)(uint8_t , DCTELEM *, int);
nengel@10	1350 void (clear_block)(DCTELEM );
nengel@10	1351 void (clear_blocks)(DCTELEM );
nengel@10	1352 void (put_pixels_tab[4][4])(uint8_t , const uint8_t *, int, int);
nengel@10	1353 void (avg_pixels_tab[4][4])(uint8_t , const uint8_t *, int, int);
nengel@10	1354 void (put_no_rnd_pixels_tab[4][4])(uint8_t , const uint8_t *, int, int);
nengel@10	1355 void (avg_no_rnd_pixels_tab[4][4])(uint8_t , const uint8_t *, int, int);
nengel@10	1356 void (put_no_rnd_pixels_l2[2])(uint8_t , const uint8_t , const uint8_t , int, int);
nengel@10	1357 void (put_qpel_pixels_tab[2][16])(uint8_t , uint8_t *, int);
nengel@10	1358 void (avg_qpel_pixels_tab[2][16])(uint8_t , uint8_t *, int);
nengel@10	1359 void (put_no_rnd_qpel_pixels_tab[2][16])(uint8_t , uint8_t *, int);
nengel@10	1360 void (avg_no_rnd_qpel_pixels_tab[2][16])(uint8_t , uint8_t *, int);
nengel@10	1361 void (put_mspel_pixels_tab[8])(uint8_t , uint8_t *, int);
nengel@10	1362 void (put_h264_chroma_pixels_tab[3])(uint8_t , uint8_t *, int, int, int, int);
nengel@10	1363 void (avg_h264_chroma_pixels_tab[3])(uint8_t , uint8_t *, int, int, int, int);
nengel@10	1364 void (put_no_rnd_vc1_chroma_pixels_tab[3])(uint8_t , uint8_t *, int, int, int, int);
nengel@10	1365 void (avg_no_rnd_vc1_chroma_pixels_tab[3])(uint8_t , uint8_t *, int, int, int, int);
nengel@10	1366 void (put_h264_qpel_pixels_tab[4][16])(uint8_t , uint8_t *, int);
nengel@10	1367 void (avg_h264_qpel_pixels_tab[4][16])(uint8_t , uint8_t *, int);
nengel@10	1368 void (put_2tap_qpel_pixels_tab[4][16])(uint8_t , uint8_t *, int);
nengel@10	1369 void (avg_2tap_qpel_pixels_tab[4][16])(uint8_t , uint8_t *, int);
nengel@10	1370 void (fdct)(DCTELEM );
nengel@10	1371 void (fdct248)(DCTELEM );
nengel@10	1372 void (idct)(DCTELEM );
nengel@10	1373 void (idct_put)(uint8_t , int, DCTELEM *);
nengel@10	1374 void (idct_add)(uint8_t , int, DCTELEM *);
nengel@10	1375 void (draw_edges)(uint8_t , int, int, int, int);
nengel@10	1376 void (prefetch)(void , int, int);
nengel@10	1377 };
nengel@10	1378 typedef struct DSPContext DSPContext;
nengel@10	1379 typedef void (h264_weight_func)(uint8_t , int, int, int, int);
nengel@10	1380 typedef void (h264_biweight_func)(uint8_t , uint8_t *, int, int, int, int, int);
nengel@10	1381 struct H264DSPContext
nengel@10	1382 {
nengel@10	1383 void (weight_h264_pixels_tab[10])(uint8_t , int, int, int, int);
nengel@10	1384 void (biweight_h264_pixels_tab[10])(uint8_t , uint8_t *, int, int, int, int, int);
nengel@10	1385 void (h264_v_loop_filter_luma)(uint8_t , int, int, int, int8_t *);
nengel@10	1386 void (h264_h_loop_filter_luma)(uint8_t , int, int, int, int8_t *);
nengel@10	1387 void (h264_v_loop_filter_luma_intra)(uint8_t , int, int, int);
nengel@10	1388 void (h264_h_loop_filter_luma_intra)(uint8_t , int, int, int);
nengel@10	1389 void (h264_v_loop_filter_chroma)(uint8_t , int, int, int, int8_t *);
nengel@10	1390 void (h264_h_loop_filter_chroma)(uint8_t , int, int, int, int8_t *);
nengel@10	1391 void (h264_v_loop_filter_chroma_intra)(uint8_t , int, int, int);
nengel@10	1392 void (h264_h_loop_filter_chroma_intra)(uint8_t , int, int, int);
nengel@10	1393 void (*h264_loop_filter_strength)(int16_t [2][4][4], uint8_t [40], int8_t [2][40], int16_t [2][40][2], int, int, int, int, int, int);
nengel@10	1394 void (h264_idct_add)(uint8_t , DCTELEM *, int);
nengel@10	1395 void (h264_idct8_add)(uint8_t , DCTELEM *, int);
nengel@10	1396 void (h264_idct_dc_add)(uint8_t , DCTELEM *, int);
nengel@10	1397 void (h264_idct8_dc_add)(uint8_t , DCTELEM *, int);
nengel@10	1398 void (*h264_dct)(DCTELEM [4][4]);
nengel@10	1399 void (h264_idct_add16)(uint8_t , const int , DCTELEM , int, const uint8_t [48]);
nengel@10	1400 void (h264_idct8_add4)(uint8_t , const int , DCTELEM , int, const uint8_t [48]);
nengel@10	1401 void (h264_idct_add8)(uint8_t , const int , DCTELEM *, int, const uint8_t [48]);
nengel@10	1402 void (h264_idct_add16intra)(uint8_t , const int , DCTELEM , int, const uint8_t [48]);
nengel@10	1403 void ((qpel_put)[16])(uint8_t , uint8_t , int);
nengel@10	1404 void ((qpel_avg)[16])(uint8_t , uint8_t , int);
nengel@10	1405 };
nengel@10	1406 typedef struct H264DSPContext H264DSPContext;
nengel@10	1407 struct H264PredContext
nengel@10	1408 {
nengel@10	1409 void (pred4x4[15])(uint8_t , uint8_t *, int);
nengel@10	1410 void (pred8x8l[12])(uint8_t , int, int, int);
nengel@10	1411 void (pred8x8[11])(uint8_t , int);
nengel@10	1412 void (pred16x16[7])(uint8_t , int);
nengel@10	1413 void (pred4x4_add[2])(uint8_t , const DCTELEM *, int);
nengel@10	1414 void (pred8x8l_add[2])(uint8_t , const DCTELEM *, int);
nengel@10	1415 void (pred8x8_add[3])(uint8_t , const int , const DCTELEM , int);
nengel@10	1416 void (pred16x16_add[3])(uint8_t , const int , const DCTELEM , int);
nengel@10	1417 };
nengel@10	1418 typedef struct H264PredContext H264PredContext;
nengel@10	1419 struct MBRecContext
nengel@10	1420 {
nengel@10	1421 DSPContext dsp;
nengel@10	1422 H264DSPContext hdsp;
nengel@10	1423 H264PredContext hpc;
nengel@10	1424 MBRecState *mrs;
nengel@10	1425 RingLineEntry *rle;
nengel@10	1426 uint8_t *scratchpad_y;
nengel@10	1427 uint8_t *scratchpad_cb;
nengel@10	1428 uint8_t *scratchpad_cr;
nengel@10	1429 int linesize;
nengel@10	1430 int uvlinesize;
nengel@10	1431 int mb_width;
nengel@10	1432 int mb_height;
nengel@10	1433 int mb_stride;
nengel@10	1434 int b_stride;
nengel@10	1435 int width;
nengel@10	1436 int height;
nengel@10	1437 int block_offset[24];
nengel@10	1438 };
nengel@10	1439 void h264_decode_mb_internal(MBRecContext d, MBRecState mrs, H264Slice s, H264Mb m);
nengel@10	1440 static void decode_super_mb_block(MBRecContext d, H264Slice s, SuperMBContext smbc, H264Mb mbs, int smb_x, int smb_y)
nengel@10	1441 {
nengel@10	1442 MBRecState mrs;
nengel@10	1443 for (int k = 0, i = smb_y; i < smb_y + (*smbc).smb_height; (i++, k++))
nengel@10	1444 {
nengel@10	1445 {
nengel@10	1446 init_mbrec_context(d, &mrs, s, i);
nengel@10	1447 for (int j = smb_x - k; j < smb_x - k + (*smbc).smb_width; j++)
nengel@10	1448 {
nengel@10	1449 {
nengel@10	1450 if ((i < (d).mb_height && j >= 0) && j < (d).mb_width)
nengel@10	1451 {
nengel@10	1452 {
nengel@10	1453 h264_decode_mb_internal(d, &mrs, s, &mbs[i * (*d).mb_width + j]);
nengel@10	1454 }
nengel@10	1455 }
nengel@10	1456 }
nengel@10	1457 }
nengel@10	1458 }
nengel@10	1459 }
nengel@10	1460 }
nengel@10	1461 struct SuperMBTask
nengel@10	1462 {
nengel@10	1463 int smb_x;
nengel@10	1464 int smb_y;
nengel@10	1465 };
nengel@10	1466 static void decode_super_mb_task(MBRecContext d, SliceBufferEntry sbe, SuperMBContext smbc, SuperMBTask ml, SuperMBTask mur, SuperMBTask m)
nengel@10	1467 {
nengel@10	1468 H264Slice s = &(sbe).slice;
nengel@10	1469 H264Mb mbs = (sbe).mbs;
nengel@10	1470 decode_super_mb_block(d, s, smbc, mbs, (m).smb_x, (m).smb_y);
nengel@10	1471 }
nengel@10	1472 void draw_edges(MBRecContext d, H264Slice s, int line);
nengel@10	1473 static void draw_edges_task(MBRecContext d, SliceBufferEntry sbe, SuperMBContext smbc, SuperMBTask sm, int line)
nengel@10	1474 {
nengel@10	1475 H264Slice s = &(sbe).slice;
nengel@10	1476 for (int i = line * (smbc).smb_height; i < (line + 1) (smbc).smb_height && i < (d).mb_height; i++)
nengel@10	1477 {
nengel@10	1478 draw_edges(d, s, i);
nengel@10	1479 }
nengel@10	1480 }
nengel@10	1481 SuperMBContext acquire_smbc(H264Context h);
nengel@10	1482 enum mcc_enum_anon_8
nengel@10	1483 {
nengel@10	1484 NANOS_OK = 0,
nengel@10	1485 NANOS_UNKNOWN_ERR = 1,
nengel@10	1486 NANOS_UNIMPLEMENTED = 2,
nengel@10	1487 NANOS_ENOMEM = 3,
nengel@10	1488 NANOS_INVALID_PARAM = 4
nengel@10	1489 };
nengel@10	1490 typedef enum mcc_enum_anon_8 nanos_err_t;
nengel@10	1491 extern nanos_err_t nanos_in_final(_Bool *result);
nengel@10	1492 struct mcc_struct_anon_20
nengel@10	1493 {
nengel@10	1494 void (outline)(void );
nengel@10	1495 };
nengel@10	1496 typedef struct mcc_struct_anon_20 nanos_smp_args_t;
nengel@10	1497 struct nanos_args_0_t
nengel@10	1498 {
nengel@10	1499 MBRecContext *d;
nengel@10	1500 SliceBufferEntry *sbe;
nengel@10	1501 SuperMBContext *smbc;
nengel@10	1502 SuperMBTask *ml;
nengel@10	1503 SuperMBTask *mur;
nengel@10	1504 SuperMBTask *m;
nengel@10	1505 };
nengel@10	1506 static void smp_ol_decode_super_mb_task_1(struct nanos_args_0_t *const args);
nengel@10	1507 struct mcc_struct_anon_16
nengel@10	1508 {
nengel@10	1509 _Bool mandatory_creation:1;
nengel@10	1510 _Bool tied:1;
nengel@10	1511 _Bool clear_chunk:1;
nengel@10	1512 _Bool reserved0:1;
nengel@10	1513 _Bool reserved1:1;
nengel@10	1514 _Bool reserved2:1;
nengel@10	1515 _Bool reserved3:1;
nengel@10	1516 _Bool reserved4:1;
nengel@10	1517 };
nengel@10	1518 typedef struct mcc_struct_anon_16 nanos_wd_props_t;
nengel@10	1519 typedef unsigned long int size_t;
nengel@10	1520 struct nanos_const_wd_definition_tag
nengel@10	1521 {
nengel@10	1522 nanos_wd_props_t props;
nengel@10	1523 size_t data_alignment;
nengel@10	1524 size_t num_copies;
nengel@10	1525 size_t num_devices;
nengel@10	1526 size_t num_dimensions;
nengel@10	1527 const char *description;
nengel@10	1528 };
nengel@10	1529 typedef struct nanos_const_wd_definition_tag nanos_const_wd_definition_t;
nengel@10	1530 struct mcc_struct_anon_19
nengel@10	1531 {
nengel@10	1532 void (factory)(void *);
nengel@10	1533 void *arg;
nengel@10	1534 };
nengel@10	1535 typedef struct mcc_struct_anon_19 nanos_device_t;
nengel@10	1536 struct nanos_const_wd_definition_1
nengel@10	1537 {
nengel@10	1538 nanos_const_wd_definition_t base;
nengel@10	1539 nanos_device_t devices[1];
nengel@10	1540 };
nengel@10	1541 extern void nanos_smp_factory(void args);
nengel@10	1542 struct mcc_struct_anon_17
nengel@10	1543 {
nengel@10	1544 _Bool is_final:1;
nengel@10	1545 _Bool reserved1:1;
nengel@10	1546 _Bool reserved2:1;
nengel@10	1547 _Bool reserved3:1;
nengel@10	1548 _Bool reserved4:1;
nengel@10	1549 _Bool reserved5:1;
nengel@10	1550 _Bool reserved6:1;
nengel@10	1551 _Bool reserved7:1;
nengel@10	1552 };
nengel@10	1553 typedef struct mcc_struct_anon_17 nanos_wd_dyn_flags_t;
nengel@10	1554 typedef void *nanos_thread_t;
nengel@10	1555 struct mcc_struct_anon_18
nengel@10	1556 {
nengel@10	1557 nanos_wd_dyn_flags_t flags;
nengel@10	1558 void *tie_to;
nengel@10	1559 unsigned int priority;
nengel@10	1560 };
nengel@10	1561 typedef struct mcc_struct_anon_18 nanos_wd_dyn_props_t;
nengel@10	1562 typedef void *nanos_wd_t;
nengel@10	1563 struct mcc_struct_anon_9;
nengel@10	1564 typedef struct mcc_struct_anon_9 nanos_copy_data_internal_t;
nengel@10	1565 typedef nanos_copy_data_internal_t nanos_copy_data_t;
nengel@10	1566 struct mcc_struct_anon_5;
nengel@10	1567 typedef struct mcc_struct_anon_5 nanos_region_dimension_internal_t;
nengel@10	1568 typedef void *nanos_wg_t;
nengel@10	1569 extern nanos_err_t nanos_create_wd_compact(void *wd, nanos_const_wd_definition_t const_data, nanos_wd_dyn_props_t dyn_props, size_t data_size, void data, void wg, nanos_copy_data_t copies, nanos_region_dimension_internal_t dimensions);
nengel@10	1570 extern void *nanos_current_wd(void);
nengel@10	1571 extern void nanos_handle_error(nanos_err_t err);
nengel@10	1572 struct mcc_struct_anon_5
nengel@10	1573 {
nengel@10	1574 size_t size;
nengel@10	1575 size_t lower_bound;
nengel@10	1576 size_t accessed_length;
nengel@10	1577 };
nengel@10	1578 typedef nanos_region_dimension_internal_t nanos_region_dimension_t;
nengel@10	1579 struct mcc_struct_anon_6
nengel@10	1580 {
nengel@10	1581 _Bool input:1;
nengel@10	1582 _Bool output:1;
nengel@10	1583 _Bool can_rename:1;
nengel@10	1584 _Bool concurrent:1;
nengel@10	1585 _Bool commutative:1;
nengel@10	1586 };
nengel@10	1587 typedef struct mcc_struct_anon_6 nanos_access_type_internal_t;
nengel@10	1588 typedef long int ptrdiff_t;
nengel@10	1589 struct mcc_struct_anon_7
nengel@10	1590 {
nengel@10	1591 void *address;
nengel@10	1592 nanos_access_type_internal_t flags;
nengel@10	1593 short int dimension_count;
nengel@10	1594 const nanos_region_dimension_internal_t *dimensions;
nengel@10	1595 ptrdiff_t offset;
nengel@10	1596 };
nengel@10	1597 typedef struct mcc_struct_anon_7 nanos_data_access_internal_t;
nengel@10	1598 typedef nanos_data_access_internal_t nanos_data_access_t;
nengel@10	1599 typedef void *nanos_team_t;
nengel@10	1600 extern nanos_err_t nanos_submit(void wd, size_t num_data_accesses, nanos_data_access_t data_accesses, void *team);
nengel@10	1601 typedef void (nanos_translate_args_t)(void , void *);
nengel@10	1602 extern nanos_err_t nanos_create_wd_and_run_compact(nanos_const_wd_definition_t const_data, nanos_wd_dyn_props_t dyn_props, size_t data_size, void data, size_t num_data_accesses, nanos_data_access_t data_accesses, nanos_copy_data_t copies, nanos_region_dimension_internal_t dimensions, void (translate_args)(void , void *));
nengel@10	1603 struct nanos_args_1_t
nengel@10	1604 {
nengel@10	1605 MBRecContext *d;
nengel@10	1606 SliceBufferEntry *sbe;
nengel@10	1607 SuperMBContext *smbc;
nengel@10	1608 SuperMBTask *sm;
nengel@10	1609 int line;
nengel@10	1610 };
nengel@10	1611 static void smp_ol_draw_edges_task_3(struct nanos_args_1_t *const args);
nengel@10	1612 extern nanos_err_t nanos_wait_on(size_t num_data_accesses, nanos_data_access_t *data_accesses);
nengel@10	1613 void release_smbc(H264Context h, SuperMBContext smbc);
nengel@10	1614 static void decode_mb_in_slice(H264Context h, MBRecContext d, SliceBufferEntry *sbe)
nengel@10	1615 {
nengel@10	1616 int j;
nengel@10	1617 int i;
nengel@10	1618 SuperMBTask *sml;
nengel@10	1619 SuperMBTask *smur;
nengel@10	1620 SuperMBContext *smbc = acquire_smbc(h);
nengel@10	1621 int smb_height = (*smbc).nsmb_height;
nengel@10	1622 int smb_width = (*smbc).nsmb_width;
nengel@10	1623 SuperMBTask smbs = (smbc).smbs[0];
nengel@10	1624 SuperMBTask sm = (void )0;
nengel@10	1625 for (j = 0; j < smb_height; j++)
nengel@10	1626 {
nengel@10	1627 {
nengel@10	1628 nanos_err_t mcc_err_in_final_1;
nengel@10	1629 _Bool mcc_is_in_final_1;
nengel@10	1630 for (i = 0; i < smb_width; i++)
nengel@10	1631 {
nengel@10	1632 {
nengel@10	1633 nanos_err_t mcc_err_in_final_0;
nengel@10	1634 _Bool mcc_is_in_final_0;
nengel@10	1635 sm = smbs + j * smb_width + i;
nengel@10	1636 sml = sm - (i > 0 ? 1 : 0);
nengel@10	1637 smur = sm + (i < smb_width - 1 && j > 0 ? -smb_width + 1 : 0);
nengel@10	1638 mcc_err_in_final_0 = nanos_in_final(&mcc_is_in_final_0);
nengel@10	1639 {
nengel@10	1640 MBRecContext *mcc_arg_0 = d;
nengel@10	1641 SliceBufferEntry *mcc_arg_1 = sbe;
nengel@10	1642 SuperMBContext *mcc_arg_2 = smbc;
nengel@10	1643 SuperMBTask *mcc_arg_3 = sml;
nengel@10	1644 SuperMBTask *mcc_arg_4 = smur;
nengel@10	1645 SuperMBTask *mcc_arg_5 = sm;
nengel@10	1646 if (mcc_is_in_final_0)
nengel@10	1647 {
nengel@10	1648 decode_super_mb_task(d, sbe, smbc, sml, smur, sm);
nengel@10	1649 }
nengel@10	1650 else
nengel@10	1651 {
nengel@10	1652 {
nengel@10	1653 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	1654 struct nanos_args_0_t *ol_args;
nengel@10	1655 nanos_err_t err;
nengel@10	1656 struct nanos_args_0_t imm_args;
nengel@10	1657 static nanos_smp_args_t smp_ol_decode_super_mb_task_1_args = { .outline = (void ()(void ))(void ()(struct nanos_args_0_t ))&smp_ol_decode_super_mb_task_1 };
nengel@10	1658 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_0_t), 0, 1, 0, "decode_super_mb_task" }, { { &nanos_smp_factory, &smp_ol_decode_super_mb_task_1_args } } };
nengel@10	1659 nanos_wd_dyn_props.tie_to = 0;
nengel@10	1660 nanos_wd_dyn_props.priority = 0;
nengel@10	1661 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	1662 ol_args = (struct nanos_args_0_t *)0;
nengel@10	1663 void nanos_wd_ = (void )0;
nengel@10	1664 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_0_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	1665 if (err != NANOS_OK)
nengel@10	1666 {
nengel@10	1667 nanos_handle_error(err);
nengel@10	1668 }
nengel@10	1669 /* Check pendant writes on subexpressions */
nengel@10	1670 /* End check pendant writes on subexpressions */
nengel@10	1671 if (nanos_wd_ != (void *)0)
nengel@10	1672 {
nengel@10	1673 {
nengel@10	1674 (*ol_args).d = mcc_arg_0;
nengel@10	1675 (*ol_args).sbe = mcc_arg_1;
nengel@10	1676 (*ol_args).smbc = mcc_arg_2;
nengel@10	1677 (*ol_args).ml = mcc_arg_3;
nengel@10	1678 (*ol_args).mur = mcc_arg_4;
nengel@10	1679 (*ol_args).m = mcc_arg_5;
nengel@10	1680 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	1681 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	1682 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	1683 nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	1684 nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	1685 nanos_data_access_t dependences[5] = { { (void )mcc_arg_0, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_1, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void )mcc_arg_3, { 1, 0, 0, 0, 0 }, 1, dimensions_2, 0 }, { (void )mcc_arg_4, { 1, 0, 0, 0, 0 }, 1, dimensions_3, 0 }, { (void *)mcc_arg_5, { 1, 1, 0, 0, 0 }, 1, dimensions_4, 0 } };
nengel@10	1686 ;
nengel@10	1687 err = nanos_submit(nanos_wd_, 5, dependences, (void *)0);
nengel@10	1688 if (err != NANOS_OK)
nengel@10	1689 {
nengel@10	1690 nanos_handle_error(err);
nengel@10	1691 }
nengel@10	1692 }
nengel@10	1693 }
nengel@10	1694 else
nengel@10	1695 {
nengel@10	1696 {
nengel@10	1697 imm_args.d = mcc_arg_0;
nengel@10	1698 imm_args.sbe = mcc_arg_1;
nengel@10	1699 imm_args.smbc = mcc_arg_2;
nengel@10	1700 imm_args.ml = mcc_arg_3;
nengel@10	1701 imm_args.mur = mcc_arg_4;
nengel@10	1702 imm_args.m = mcc_arg_5;
nengel@10	1703 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	1704 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	1705 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	1706 nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	1707 nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	1708 nanos_data_access_t dependences[5] = { { (void )mcc_arg_0, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_1, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void )mcc_arg_3, { 1, 0, 0, 0, 0 }, 1, dimensions_2, 0 }, { (void )mcc_arg_4, { 1, 0, 0, 0, 0 }, 1, dimensions_3, 0 }, { (void *)mcc_arg_5, { 1, 1, 0, 0, 0 }, 1, dimensions_4, 0 } };
nengel@10	1709 ;
nengel@10	1710 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_0_t), &imm_args, 5, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	1711 if (err != NANOS_OK)
nengel@10	1712 {
nengel@10	1713 nanos_handle_error(err);
nengel@10	1714 }
nengel@10	1715 }
nengel@10	1716 }
nengel@10	1717 }
nengel@10	1718 }
nengel@10	1719 }
nengel@10	1720 }
nengel@10	1721 }
nengel@10	1722 mcc_err_in_final_1 = nanos_in_final(&mcc_is_in_final_1);
nengel@9	1723 {
nengel@10	1724 MBRecContext *mcc_arg_6 = d;
nengel@10	1725 SliceBufferEntry *mcc_arg_7 = sbe;
nengel@10	1726 SuperMBContext *mcc_arg_8 = smbc;
nengel@10	1727 SuperMBTask *mcc_arg_9 = sm;
nengel@10	1728 int mcc_arg_10 = j;
nengel@10	1729 if (mcc_is_in_final_1)
nengel@9	1730 {
nengel@10	1731 draw_edges_task(d, sbe, smbc, sm, j);
nengel@10	1732 }
nengel@10	1733 else
nengel@10	1734 {
nengel@10	1735 {
nengel@10	1736 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	1737 struct nanos_args_1_t *ol_args;
nengel@10	1738 nanos_err_t err;
nengel@10	1739 struct nanos_args_1_t imm_args;
nengel@10	1740 static nanos_smp_args_t smp_ol_draw_edges_task_3_args = { .outline = (void ()(void ))(void ()(struct nanos_args_1_t ))&smp_ol_draw_edges_task_3 };
nengel@10	1741 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_1_t), 0, 1, 0, "draw_edges_task" }, { { &nanos_smp_factory, &smp_ol_draw_edges_task_3_args } } };
nengel@10	1742 nanos_wd_dyn_props.tie_to = 0;
nengel@10	1743 nanos_wd_dyn_props.priority = 0;
nengel@10	1744 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	1745 ol_args = (struct nanos_args_1_t *)0;
nengel@10	1746 void nanos_wd_ = (void )0;
nengel@10	1747 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_1_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	1748 if (err != NANOS_OK)
nengel@10	1749 {
nengel@10	1750 nanos_handle_error(err);
nengel@10	1751 }
nengel@10	1752 /* Check pendant writes on subexpressions */
nengel@10	1753 /* End check pendant writes on subexpressions */
nengel@10	1754 if (nanos_wd_ != (void *)0)
nengel@10	1755 {
nengel@10	1756 {
nengel@10	1757 (*ol_args).d = mcc_arg_6;
nengel@10	1758 (*ol_args).sbe = mcc_arg_7;
nengel@10	1759 (*ol_args).smbc = mcc_arg_8;
nengel@10	1760 (*ol_args).sm = mcc_arg_9;
nengel@10	1761 (*ol_args).line = mcc_arg_10;
nengel@10	1762 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	1763 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	1764 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	1765 nanos_data_access_t dependences[3] = { { (void )mcc_arg_6, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_7, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_9, { 1, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	1766 ;
nengel@10	1767 err = nanos_submit(nanos_wd_, 3, dependences, (void *)0);
nengel@10	1768 if (err != NANOS_OK)
nengel@10	1769 {
nengel@10	1770 nanos_handle_error(err);
nengel@10	1771 }
nengel@10	1772 }
nengel@10	1773 }
nengel@10	1774 else
nengel@10	1775 {
nengel@10	1776 {
nengel@10	1777 imm_args.d = mcc_arg_6;
nengel@10	1778 imm_args.sbe = mcc_arg_7;
nengel@10	1779 imm_args.smbc = mcc_arg_8;
nengel@10	1780 imm_args.sm = mcc_arg_9;
nengel@10	1781 imm_args.line = mcc_arg_10;
nengel@10	1782 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	1783 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	1784 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	1785 nanos_data_access_t dependences[3] = { { (void )mcc_arg_6, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_7, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_9, { 1, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	1786 ;
nengel@10	1787 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_1_t), &imm_args, 3, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	1788 if (err != NANOS_OK)
nengel@10	1789 {
nengel@10	1790 nanos_handle_error(err);
nengel@10	1791 }
nengel@10	1792 }
nengel@10	1793 }
nengel@10	1794 }
nengel@9	1795 }
nengel@9	1796 }
nengel@10	1797 }
nengel@9	1798 }
nengel@10	1799 {
nengel@10	1800 nanos_region_dimension_t dimensions_0[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	1801 nanos_data_access_t dependences[1] = { { (void *)sm, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 } };
nengel@10	1802 ;
nengel@10	1803 nanos_err_t err = nanos_wait_on(1, dependences);
nengel@10	1804 if (err != NANOS_OK)
nengel@10	1805 {
nengel@10	1806 nanos_handle_error(err);
nengel@10	1807 }
nengel@10	1808 }
nengel@10	1809 release_smbc(h, smbc);
nengel@9	1810 }
nengel@10	1811 struct DecodedPicture
nengel@9	1812 {
nengel@10	1813 int16_t (*motion_val[2])[2];
nengel@10	1814 int16_t (*motion_val_base[2])[2];
nengel@10	1815 int8_t *ref_index[2];
nengel@10	1816 uint32_t *mb_type;
nengel@10	1817 uint32_t *mb_type_base;
nengel@10	1818 int8_t *intra4x4_pred_mode;
nengel@10	1819 int8_t *non_zero_count;
nengel@10	1820 uint8_t *data[3];
nengel@10	1821 int linesize[3];
nengel@10	1822 uint8_t *base[3];
nengel@10	1823 int cpn;
nengel@10	1824 int poc;
nengel@10	1825 int reference;
nengel@10	1826 int key_frame;
nengel@10	1827 int mmco_reset;
nengel@10	1828 };
nengel@10	1829 struct nanos_lock_t;
nengel@10	1830 typedef struct nanos_lock_t nanos_lock_t;
nengel@10	1831 extern nanos_err_t nanos_set_lock(nanos_lock_t *lock);
nengel@10	1832 enum mcc_enum_anon_7
nengel@10	1833 {
nengel@10	1834 NANOS_LOCK_FREE = 0,
nengel@10	1835 NANOS_LOCK_BUSY = 1
nengel@10	1836 };
nengel@10	1837 typedef enum mcc_enum_anon_7 nanos_lock_state_t;
nengel@10	1838 struct nanos_lock_t
nengel@10	1839 {
nengel@10	1840 volatile nanos_lock_state_t state_;
nengel@10	1841 };
nengel@10	1842 __attribute__((weak)) nanos_lock_t nanos_critical_lock_dpb = { NANOS_LOCK_FREE };
nengel@10	1843 DecodedPicture get_dpb_entry(H264Context h, H264Slice *s);
nengel@10	1844 extern nanos_err_t nanos_unset_lock(nanos_lock_t *lock);
nengel@10	1845 void release_dpb_entry(H264Context h, DecodedPicture pic, int mode);
nengel@10	1846 static void decode_slice_mb_task(H264Context h, MBRecContext d, SliceBufferEntry *sbe)
nengel@10	1847 {
nengel@10	1848 H264Slice s = &(sbe).slice;
nengel@10	1849 for (int i = 0; i < 2; i++)
nengel@9	1850 {
nengel@10	1851 {
nengel@10	1852 for (int j = 0; j < (*s).ref_count[i]; j++)
nengel@10	1853 {
nengel@9	1854 {
nengel@10	1855 int k;
nengel@10	1856 if ((*s).ref_list_cpn[i][j] == -1)
nengel@9	1857 {
nengel@10	1858 continue;
nengel@10	1859 }
nengel@10	1860 for (k = 0; k < (*h).max_dpb_cnt; k++)
nengel@10	1861 {
nengel@10	1862 {
nengel@10	1863 if ((h).dpb[k].reference >= 2 && (h).dpb[k].cpn == (*s).ref_list_cpn[i][j])
nengel@10	1864 {
nengel@9	1865 {
nengel@10	1866 (s).dp_ref_list[i][j] = &(h).dpb[k];
nengel@10	1867 break;
nengel@9	1868 }
nengel@10	1869 }
nengel@10	1870 }
nengel@9	1871 }
nengel@9	1872 }
nengel@10	1873 }
nengel@10	1874 }
nengel@9	1875 }
nengel@10	1876 {
nengel@10	1877 nanos_err_t err;
nengel@10	1878 err = nanos_set_lock(&nanos_critical_lock_dpb);
nengel@10	1879 if (err != NANOS_OK)
nengel@10	1880 {
nengel@10	1881 nanos_handle_error(err);
nengel@10	1882 }
nengel@10	1883 get_dpb_entry(h, s);
nengel@10	1884 err = nanos_unset_lock(&nanos_critical_lock_dpb);
nengel@10	1885 if (err != NANOS_OK)
nengel@10	1886 {
nengel@10	1887 nanos_handle_error(err);
nengel@10	1888 }
nengel@10	1889 }
nengel@10	1890 if (!(*h).no_mbd)
nengel@9	1891 {
nengel@10	1892 {
nengel@10	1893 decode_mb_in_slice(h, d, sbe);
nengel@10	1894 }
nengel@10	1895 }
nengel@10	1896 for (int i = 0; i < (*s).release_cnt; i++)
nengel@10	1897 {
nengel@10	1898 {
nengel@10	1899 for (int j = 0; j < (*h).max_dpb_cnt; j++)
nengel@10	1900 {
nengel@9	1901 {
nengel@10	1902 if ((h).dpb[j].cpn == (s).release_ref_cpn[i])
nengel@9	1903 {
nengel@10	1904 {
nengel@10	1905 {
nengel@10	1906 nanos_err_t err;
nengel@10	1907 err = nanos_set_lock(&nanos_critical_lock_dpb);
nengel@10	1908 if (err != NANOS_OK)
nengel@10	1909 {
nengel@10	1910 nanos_handle_error(err);
nengel@10	1911 }
nengel@10	1912 release_dpb_entry(h, &(*h).dpb[j], 2);
nengel@10	1913 err = nanos_unset_lock(&nanos_critical_lock_dpb);
nengel@10	1914 if (err != NANOS_OK)
nengel@10	1915 {
nengel@10	1916 nanos_handle_error(err);
nengel@10	1917 }
nengel@10	1918 }
nengel@9	1919 break;
nengel@10	1920 }
nengel@9	1921 }
nengel@9	1922 }
nengel@10	1923 }
nengel@10	1924 }
nengel@9	1925 }
nengel@10	1926 (*s).release_cnt = 0;
nengel@9	1927 }
nengel@9	1928 static void decode_3dwave_super_mb_task(MBRecContext d, SliceBufferEntry sbe, SuperMBContext smbc, SuperMBTask ml, SuperMBTask mur, SuperMBTask mprev, SuperMBTask *m)
nengel@9	1929 {
nengel@10	1930 H264Slice s = &(sbe).slice;
nengel@10	1931 H264Mb mbs = (sbe).mbs;
nengel@10	1932 decode_super_mb_block(d, s, smbc, mbs, (m).smb_x, (m).smb_y);
nengel@9	1933 }
nengel@9	1934 static void init_ref_list_and_get_dpb_task(H264Context h, MBRecContext d, SliceBufferEntry sbe, int init)
nengel@9	1935 {
nengel@10	1936 H264Slice s = &(sbe).slice;
nengel@10	1937 for (int i = 0; i < 2; i++)
nengel@9	1938 {
nengel@10	1939 {
nengel@10	1940 for (int j = 0; j < (*s).ref_count[i]; j++)
nengel@10	1941 {
nengel@9	1942 {
nengel@10	1943 int k;
nengel@10	1944 if ((*s).ref_list_cpn[i][j] == -1)
nengel@9	1945 {
nengel@10	1946 continue;
nengel@10	1947 }
nengel@10	1948 for (k = 0; k < (*h).max_dpb_cnt; k++)
nengel@10	1949 {
nengel@10	1950 {
nengel@10	1951 if ((h).dpb[k].reference >= 2 && (h).dpb[k].cpn == (*s).ref_list_cpn[i][j])
nengel@10	1952 {
nengel@10	1953 {
nengel@10	1954 (s).dp_ref_list[i][j] = &(h).dpb[k];
nengel@10	1955 break;
nengel@10	1956 }
nengel@10	1957 }
nengel@10	1958 }
nengel@9	1959 }
nengel@9	1960 }
nengel@10	1961 }
nengel@10	1962 }
nengel@9	1963 }
nengel@10	1964 {
nengel@10	1965 nanos_err_t err;
nengel@10	1966 err = nanos_set_lock(&nanos_critical_lock_dpb);
nengel@10	1967 if (err != NANOS_OK)
nengel@10	1968 {
nengel@10	1969 nanos_handle_error(err);
nengel@10	1970 }
nengel@10	1971 get_dpb_entry(h, s);
nengel@10	1972 err = nanos_unset_lock(&nanos_critical_lock_dpb);
nengel@10	1973 if (err != NANOS_OK)
nengel@10	1974 {
nengel@10	1975 nanos_handle_error(err);
nengel@10	1976 }
nengel@10	1977 }
nengel@9	1978 }
nengel@10	1979 struct nanos_args_2_t
nengel@9	1980 {
nengel@10	1981 MBRecContext *d;
nengel@10	1982 SliceBufferEntry *sbe;
nengel@10	1983 SuperMBContext *smbc;
nengel@10	1984 SuperMBTask *ml;
nengel@10	1985 SuperMBTask *mur;
nengel@10	1986 SuperMBTask *mprev;
nengel@10	1987 SuperMBTask *m;
nengel@10	1988 };
nengel@10	1989 static void smp_ol_decode_3dwave_super_mb_task_5(struct nanos_args_2_t *const args);
nengel@10	1990 struct nanos_args_3_t
nengel@9	1991 {
nengel@10	1992 MBRecContext *d;
nengel@10	1993 SliceBufferEntry *sbe;
nengel@10	1994 SuperMBContext *smbc;
nengel@10	1995 SuperMBTask *sm;
nengel@10	1996 int line;
nengel@10	1997 };
nengel@10	1998 static void smp_ol_draw_edges_task_7(struct nanos_args_3_t *const args);
nengel@10	1999 struct nanos_args_4_t
nengel@9	2000 {
nengel@10	2001 MBRecContext *d;
nengel@10	2002 SliceBufferEntry *sbe;
nengel@10	2003 SuperMBContext *smbc;
nengel@10	2004 SuperMBTask *ml;
nengel@10	2005 SuperMBTask *mur;
nengel@10	2006 SuperMBTask *m;
nengel@10	2007 };
nengel@10	2008 static void smp_ol_decode_super_mb_task_9(struct nanos_args_4_t *const args);
nengel@10	2009 struct nanos_args_5_t
nengel@9	2010 {
nengel@10	2011 MBRecContext *d;
nengel@10	2012 SliceBufferEntry *sbe;
nengel@10	2013 SuperMBContext *smbc;
nengel@10	2014 SuperMBTask *sm;
nengel@10	2015 int line;
nengel@10	2016 };
nengel@10	2017 static void smp_ol_draw_edges_task_11(struct nanos_args_5_t *const args);
nengel@9	2018 static SuperMBTask add_decode_slice_3dwave_tasks(MBRecContext d, SliceBufferEntry sbe, SuperMBContext smbc)
nengel@9	2019 {
nengel@10	2020 int j;
nengel@10	2021 int i;
nengel@10	2022 SuperMBTask *sml;
nengel@10	2023 SuperMBTask *smur;
nengel@10	2024 SuperMBTask *smprev;
nengel@10	2025 int smb_3d_height = (*smbc).nsmb_3dheight;
nengel@10	2026 int smb_height = (*smbc).nsmb_height;
nengel@10	2027 int smb_width = (*smbc).nsmb_width;
nengel@10	2028 int smb_diff_prev = smb_height - smb_3d_height;
nengel@10	2029 SuperMBTask sm = (void )0;
nengel@10	2030 SuperMBTask smbs = (smbc).smbs[(*smbc).index++];
nengel@10	2031 (*smbc).index %= 2;
nengel@10	2032 SuperMBTask smbs_prev = (smbc).smbs[(*smbc).index];
nengel@10	2033 for (j = 0; j < smb_3d_height; j++)
nengel@9	2034 {
nengel@10	2035 {
nengel@10	2036 nanos_err_t mcc_err_in_final_3;
nengel@10	2037 _Bool mcc_is_in_final_3;
nengel@10	2038 for (i = 0; i < smb_width; i++)
nengel@10	2039 {
nengel@10	2040 {
nengel@10	2041 nanos_err_t mcc_err_in_final_2;
nengel@10	2042 _Bool mcc_is_in_final_2;
nengel@10	2043 sm = smbs + j * smb_width + i;
nengel@10	2044 sml = sm - (i > 0 ? 1 : 0);
nengel@10	2045 smur = sm + (i < smb_width - 1 && j > 0 ? -smb_width + 1 : 0);
nengel@10	2046 smprev = smbs_prev + (j + smb_diff_prev + 1) * smb_width - 1;
nengel@10	2047 mcc_err_in_final_2 = nanos_in_final(&mcc_is_in_final_2);
nengel@10	2048 {
nengel@10	2049 MBRecContext *mcc_arg_11 = d;
nengel@10	2050 SliceBufferEntry *mcc_arg_12 = sbe;
nengel@10	2051 SuperMBContext *mcc_arg_13 = smbc;
nengel@10	2052 SuperMBTask *mcc_arg_14 = sml;
nengel@10	2053 SuperMBTask *mcc_arg_15 = smur;
nengel@10	2054 SuperMBTask *mcc_arg_16 = smprev;
nengel@10	2055 SuperMBTask *mcc_arg_17 = sm;
nengel@10	2056 if (mcc_is_in_final_2)
nengel@10	2057 {
nengel@10	2058 decode_3dwave_super_mb_task(d, sbe, smbc, sml, smur, smprev, sm);
nengel@10	2059 }
nengel@10	2060 else
nengel@10	2061 {
nengel@10	2062 {
nengel@10	2063 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	2064 struct nanos_args_2_t *ol_args;
nengel@10	2065 nanos_err_t err;
nengel@10	2066 struct nanos_args_2_t imm_args;
nengel@10	2067 static nanos_smp_args_t smp_ol_decode_3dwave_super_mb_task_5_args = { .outline = (void ()(void ))(void ()(struct nanos_args_2_t ))&smp_ol_decode_3dwave_super_mb_task_5 };
nengel@10	2068 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_2_t), 0, 1, 0, "decode_3dwave_super_mb_task" }, { { &nanos_smp_factory, &smp_ol_decode_3dwave_super_mb_task_5_args } } };
nengel@10	2069 nanos_wd_dyn_props.tie_to = 0;
nengel@10	2070 nanos_wd_dyn_props.priority = 0;
nengel@10	2071 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	2072 ol_args = (struct nanos_args_2_t *)0;
nengel@10	2073 void nanos_wd_ = (void )0;
nengel@10	2074 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_2_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	2075 if (err != NANOS_OK)
nengel@10	2076 {
nengel@10	2077 nanos_handle_error(err);
nengel@10	2078 }
nengel@10	2079 /* Check pendant writes on subexpressions */
nengel@10	2080 /* End check pendant writes on subexpressions */
nengel@10	2081 if (nanos_wd_ != (void *)0)
nengel@10	2082 {
nengel@10	2083 {
nengel@10	2084 (*ol_args).d = mcc_arg_11;
nengel@10	2085 (*ol_args).sbe = mcc_arg_12;
nengel@10	2086 (*ol_args).smbc = mcc_arg_13;
nengel@10	2087 (*ol_args).ml = mcc_arg_14;
nengel@10	2088 (*ol_args).mur = mcc_arg_15;
nengel@10	2089 (*ol_args).mprev = mcc_arg_16;
nengel@10	2090 (*ol_args).m = mcc_arg_17;
nengel@10	2091 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	2092 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2093 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2094 nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2095 nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2096 nanos_region_dimension_t dimensions_5[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2097 nanos_data_access_t dependences[6] = { { (void )mcc_arg_11, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_12, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void )mcc_arg_14, { 1, 0, 0, 0, 0 }, 1, dimensions_2, 0 }, { (void )mcc_arg_15, { 1, 0, 0, 0, 0 }, 1, dimensions_3, 0 }, { (void )mcc_arg_16, { 1, 0, 0, 0, 0 }, 1, dimensions_4, 0 }, { (void )mcc_arg_17, { 1, 1, 0, 0, 0 }, 1, dimensions_5, 0 } };
nengel@10	2098 ;
nengel@10	2099 err = nanos_submit(nanos_wd_, 6, dependences, (void *)0);
nengel@10	2100 if (err != NANOS_OK)
nengel@10	2101 {
nengel@10	2102 nanos_handle_error(err);
nengel@10	2103 }
nengel@10	2104 }
nengel@10	2105 }
nengel@10	2106 else
nengel@10	2107 {
nengel@10	2108 {
nengel@10	2109 imm_args.d = mcc_arg_11;
nengel@10	2110 imm_args.sbe = mcc_arg_12;
nengel@10	2111 imm_args.smbc = mcc_arg_13;
nengel@10	2112 imm_args.ml = mcc_arg_14;
nengel@10	2113 imm_args.mur = mcc_arg_15;
nengel@10	2114 imm_args.mprev = mcc_arg_16;
nengel@10	2115 imm_args.m = mcc_arg_17;
nengel@10	2116 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	2117 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2118 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2119 nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2120 nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2121 nanos_region_dimension_t dimensions_5[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2122 nanos_data_access_t dependences[6] = { { (void )mcc_arg_11, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_12, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void )mcc_arg_14, { 1, 0, 0, 0, 0 }, 1, dimensions_2, 0 }, { (void )mcc_arg_15, { 1, 0, 0, 0, 0 }, 1, dimensions_3, 0 }, { (void )mcc_arg_16, { 1, 0, 0, 0, 0 }, 1, dimensions_4, 0 }, { (void )mcc_arg_17, { 1, 1, 0, 0, 0 }, 1, dimensions_5, 0 } };
nengel@10	2123 ;
nengel@10	2124 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_2_t), &imm_args, 6, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	2125 if (err != NANOS_OK)
nengel@10	2126 {
nengel@10	2127 nanos_handle_error(err);
nengel@10	2128 }
nengel@10	2129 }
nengel@10	2130 }
nengel@10	2131 }
nengel@10	2132 }
nengel@10	2133 }
nengel@10	2134 }
nengel@10	2135 }
nengel@10	2136 mcc_err_in_final_3 = nanos_in_final(&mcc_is_in_final_3);
nengel@9	2137 {
nengel@10	2138 MBRecContext *mcc_arg_18 = d;
nengel@10	2139 SliceBufferEntry *mcc_arg_19 = sbe;
nengel@10	2140 SuperMBContext *mcc_arg_20 = smbc;
nengel@10	2141 SuperMBTask *mcc_arg_21 = sm;
nengel@10	2142 int mcc_arg_22 = j;
nengel@10	2143 if (mcc_is_in_final_3)
nengel@9	2144 {
nengel@10	2145 draw_edges_task(d, sbe, smbc, sm, j);
nengel@10	2146 }
nengel@10	2147 else
nengel@10	2148 {
nengel@10	2149 {
nengel@10	2150 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	2151 struct nanos_args_3_t *ol_args;
nengel@10	2152 nanos_err_t err;
nengel@10	2153 struct nanos_args_3_t imm_args;
nengel@10	2154 static nanos_smp_args_t smp_ol_draw_edges_task_7_args = { .outline = (void ()(void ))(void ()(struct nanos_args_3_t ))&smp_ol_draw_edges_task_7 };
nengel@10	2155 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_3_t), 0, 1, 0, "draw_edges_task" }, { { &nanos_smp_factory, &smp_ol_draw_edges_task_7_args } } };
nengel@10	2156 nanos_wd_dyn_props.tie_to = 0;
nengel@10	2157 nanos_wd_dyn_props.priority = 0;
nengel@10	2158 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	2159 ol_args = (struct nanos_args_3_t *)0;
nengel@10	2160 void nanos_wd_ = (void )0;
nengel@10	2161 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_3_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	2162 if (err != NANOS_OK)
nengel@10	2163 {
nengel@10	2164 nanos_handle_error(err);
nengel@10	2165 }
nengel@10	2166 /* Check pendant writes on subexpressions */
nengel@10	2167 /* End check pendant writes on subexpressions */
nengel@10	2168 if (nanos_wd_ != (void *)0)
nengel@10	2169 {
nengel@9	2170 {
nengel@10	2171 (*ol_args).d = mcc_arg_18;
nengel@10	2172 (*ol_args).sbe = mcc_arg_19;
nengel@10	2173 (*ol_args).smbc = mcc_arg_20;
nengel@10	2174 (*ol_args).sm = mcc_arg_21;
nengel@10	2175 (*ol_args).line = mcc_arg_22;
nengel@10	2176 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	2177 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2178 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2179 nanos_data_access_t dependences[3] = { { (void )mcc_arg_18, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_19, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_21, { 1, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	2180 ;
nengel@10	2181 err = nanos_submit(nanos_wd_, 3, dependences, (void *)0);
nengel@10	2182 if (err != NANOS_OK)
nengel@9	2183 {
nengel@10	2184 nanos_handle_error(err);
nengel@10	2185 }
nengel@10	2186 }
nengel@10	2187 }
nengel@10	2188 else
nengel@10	2189 {
nengel@9	2190 {
nengel@10	2191 imm_args.d = mcc_arg_18;
nengel@10	2192 imm_args.sbe = mcc_arg_19;
nengel@10	2193 imm_args.smbc = mcc_arg_20;
nengel@10	2194 imm_args.sm = mcc_arg_21;
nengel@10	2195 imm_args.line = mcc_arg_22;
nengel@10	2196 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	2197 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2198 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2199 nanos_data_access_t dependences[3] = { { (void )mcc_arg_18, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_19, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_21, { 1, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	2200 ;
nengel@10	2201 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_3_t), &imm_args, 3, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	2202 if (err != NANOS_OK)
nengel@10	2203 {
nengel@10	2204 nanos_handle_error(err);
nengel@10	2205 }
nengel@9	2206 }
nengel@10	2207 }
nengel@10	2208 }
nengel@9	2209 }
nengel@9	2210 }
nengel@10	2211 }
nengel@10	2212 }
nengel@10	2213 for (; j < smb_height; j++)
nengel@10	2214 {
nengel@10	2215 {
nengel@10	2216 nanos_err_t mcc_err_in_final_5;
nengel@10	2217 _Bool mcc_is_in_final_5;
nengel@10	2218 for (i = 0; i < smb_width; i++)
nengel@10	2219 {
nengel@10	2220 {
nengel@10	2221 nanos_err_t mcc_err_in_final_4;
nengel@10	2222 _Bool mcc_is_in_final_4;
nengel@10	2223 sm = smbs + j * smb_width + i;
nengel@10	2224 sml = sm - (i > 0 ? 1 : 0);
nengel@10	2225 smur = sm + (i < smb_width - 1 && j > 0 ? -smb_width + 1 : 0);
nengel@10	2226 mcc_err_in_final_4 = nanos_in_final(&mcc_is_in_final_4);
nengel@10	2227 {
nengel@10	2228 MBRecContext *mcc_arg_23 = d;
nengel@10	2229 SliceBufferEntry *mcc_arg_24 = sbe;
nengel@10	2230 SuperMBContext *mcc_arg_25 = smbc;
nengel@10	2231 SuperMBTask *mcc_arg_26 = sml;
nengel@10	2232 SuperMBTask *mcc_arg_27 = smur;
nengel@10	2233 SuperMBTask *mcc_arg_28 = sm;
nengel@10	2234 if (mcc_is_in_final_4)
nengel@10	2235 {
nengel@10	2236 decode_super_mb_task(d, sbe, smbc, sml, smur, sm);
nengel@10	2237 }
nengel@10	2238 else
nengel@10	2239 {
nengel@10	2240 {
nengel@10	2241 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	2242 struct nanos_args_4_t *ol_args;
nengel@10	2243 nanos_err_t err;
nengel@10	2244 struct nanos_args_4_t imm_args;
nengel@10	2245 static nanos_smp_args_t smp_ol_decode_super_mb_task_9_args = { .outline = (void ()(void ))(void ()(struct nanos_args_4_t ))&smp_ol_decode_super_mb_task_9 };
nengel@10	2246 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_4_t), 0, 1, 0, "decode_super_mb_task" }, { { &nanos_smp_factory, &smp_ol_decode_super_mb_task_9_args } } };
nengel@10	2247 nanos_wd_dyn_props.tie_to = 0;
nengel@10	2248 nanos_wd_dyn_props.priority = 0;
nengel@10	2249 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	2250 ol_args = (struct nanos_args_4_t *)0;
nengel@10	2251 void nanos_wd_ = (void )0;
nengel@10	2252 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_4_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	2253 if (err != NANOS_OK)
nengel@10	2254 {
nengel@10	2255 nanos_handle_error(err);
nengel@10	2256 }
nengel@10	2257 /* Check pendant writes on subexpressions */
nengel@10	2258 /* End check pendant writes on subexpressions */
nengel@10	2259 if (nanos_wd_ != (void *)0)
nengel@10	2260 {
nengel@10	2261 {
nengel@10	2262 (*ol_args).d = mcc_arg_23;
nengel@10	2263 (*ol_args).sbe = mcc_arg_24;
nengel@10	2264 (*ol_args).smbc = mcc_arg_25;
nengel@10	2265 (*ol_args).ml = mcc_arg_26;
nengel@10	2266 (*ol_args).mur = mcc_arg_27;
nengel@10	2267 (*ol_args).m = mcc_arg_28;
nengel@10	2268 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	2269 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2270 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2271 nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2272 nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2273 nanos_data_access_t dependences[5] = { { (void )mcc_arg_23, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_24, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void )mcc_arg_26, { 1, 0, 0, 0, 0 }, 1, dimensions_2, 0 }, { (void )mcc_arg_27, { 1, 0, 0, 0, 0 }, 1, dimensions_3, 0 }, { (void *)mcc_arg_28, { 1, 1, 0, 0, 0 }, 1, dimensions_4, 0 } };
nengel@10	2274 ;
nengel@10	2275 err = nanos_submit(nanos_wd_, 5, dependences, (void *)0);
nengel@10	2276 if (err != NANOS_OK)
nengel@10	2277 {
nengel@10	2278 nanos_handle_error(err);
nengel@10	2279 }
nengel@10	2280 }
nengel@10	2281 }
nengel@10	2282 else
nengel@10	2283 {
nengel@10	2284 {
nengel@10	2285 imm_args.d = mcc_arg_23;
nengel@10	2286 imm_args.sbe = mcc_arg_24;
nengel@10	2287 imm_args.smbc = mcc_arg_25;
nengel@10	2288 imm_args.ml = mcc_arg_26;
nengel@10	2289 imm_args.mur = mcc_arg_27;
nengel@10	2290 imm_args.m = mcc_arg_28;
nengel@10	2291 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	2292 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2293 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2294 nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2295 nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2296 nanos_data_access_t dependences[5] = { { (void )mcc_arg_23, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_24, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void )mcc_arg_26, { 1, 0, 0, 0, 0 }, 1, dimensions_2, 0 }, { (void )mcc_arg_27, { 1, 0, 0, 0, 0 }, 1, dimensions_3, 0 }, { (void *)mcc_arg_28, { 1, 1, 0, 0, 0 }, 1, dimensions_4, 0 } };
nengel@10	2297 ;
nengel@10	2298 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_4_t), &imm_args, 5, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	2299 if (err != NANOS_OK)
nengel@10	2300 {
nengel@10	2301 nanos_handle_error(err);
nengel@10	2302 }
nengel@10	2303 }
nengel@10	2304 }
nengel@10	2305 }
nengel@10	2306 }
nengel@10	2307 }
nengel@10	2308 }
nengel@10	2309 }
nengel@10	2310 mcc_err_in_final_5 = nanos_in_final(&mcc_is_in_final_5);
nengel@9	2311 {
nengel@10	2312 MBRecContext *mcc_arg_29 = d;
nengel@10	2313 SliceBufferEntry *mcc_arg_30 = sbe;
nengel@10	2314 SuperMBContext *mcc_arg_31 = smbc;
nengel@10	2315 SuperMBTask *mcc_arg_32 = sm;
nengel@10	2316 int mcc_arg_33 = j;
nengel@10	2317 if (mcc_is_in_final_5)
nengel@9	2318 {
nengel@10	2319 draw_edges_task(d, sbe, smbc, sm, j);
nengel@10	2320 }
nengel@10	2321 else
nengel@10	2322 {
nengel@10	2323 {
nengel@10	2324 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	2325 struct nanos_args_5_t *ol_args;
nengel@10	2326 nanos_err_t err;
nengel@10	2327 struct nanos_args_5_t imm_args;
nengel@10	2328 static nanos_smp_args_t smp_ol_draw_edges_task_11_args = { .outline = (void ()(void ))(void ()(struct nanos_args_5_t ))&smp_ol_draw_edges_task_11 };
nengel@10	2329 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_5_t), 0, 1, 0, "draw_edges_task" }, { { &nanos_smp_factory, &smp_ol_draw_edges_task_11_args } } };
nengel@10	2330 nanos_wd_dyn_props.tie_to = 0;
nengel@10	2331 nanos_wd_dyn_props.priority = 0;
nengel@10	2332 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	2333 ol_args = (struct nanos_args_5_t *)0;
nengel@10	2334 void nanos_wd_ = (void )0;
nengel@10	2335 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_5_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	2336 if (err != NANOS_OK)
nengel@10	2337 {
nengel@10	2338 nanos_handle_error(err);
nengel@10	2339 }
nengel@10	2340 /* Check pendant writes on subexpressions */
nengel@10	2341 /* End check pendant writes on subexpressions */
nengel@10	2342 if (nanos_wd_ != (void *)0)
nengel@10	2343 {
nengel@9	2344 {
nengel@10	2345 (*ol_args).d = mcc_arg_29;
nengel@10	2346 (*ol_args).sbe = mcc_arg_30;
nengel@10	2347 (*ol_args).smbc = mcc_arg_31;
nengel@10	2348 (*ol_args).sm = mcc_arg_32;
nengel@10	2349 (*ol_args).line = mcc_arg_33;
nengel@10	2350 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	2351 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2352 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2353 nanos_data_access_t dependences[3] = { { (void )mcc_arg_29, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_30, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_32, { 1, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	2354 ;
nengel@10	2355 err = nanos_submit(nanos_wd_, 3, dependences, (void *)0);
nengel@10	2356 if (err != NANOS_OK)
nengel@9	2357 {
nengel@10	2358 nanos_handle_error(err);
nengel@10	2359 }
nengel@10	2360 }
nengel@10	2361 }
nengel@10	2362 else
nengel@10	2363 {
nengel@10	2364 {
nengel@10	2365 imm_args.d = mcc_arg_29;
nengel@10	2366 imm_args.sbe = mcc_arg_30;
nengel@10	2367 imm_args.smbc = mcc_arg_31;
nengel@10	2368 imm_args.sm = mcc_arg_32;
nengel@10	2369 imm_args.line = mcc_arg_33;
nengel@10	2370 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	2371 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2372 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	2373 nanos_data_access_t dependences[3] = { { (void )mcc_arg_29, { 1, 0, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_30, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_32, { 1, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	2374 ;
nengel@10	2375 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_5_t), &imm_args, 3, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	2376 if (err != NANOS_OK)
nengel@9	2377 {
nengel@10	2378 nanos_handle_error(err);
nengel@9	2379 }
nengel@9	2380 }
nengel@10	2381 }
nengel@10	2382 }
nengel@9	2383 }
nengel@9	2384 }
nengel@10	2385 }
nengel@9	2386 }
nengel@10	2387 return sm;
nengel@9	2388 }
nengel@9	2389 static void release_ref_list_task(H264Context h, SuperMBContext smbc, MBRecContext d, SliceBufferEntry sbe, SuperMBTask lastsmb, int release)
nengel@9	2390 {
nengel@10	2391 H264Slice s = &(sbe).slice;
nengel@10	2392 for (int i = 0; i < (*s).release_cnt; i++)
nengel@9	2393 {
nengel@10	2394 {
nengel@10	2395 for (int j = 0; j < (*h).max_dpb_cnt; j++)
nengel@10	2396 {
nengel@10	2397 {
nengel@10	2398 if ((h).dpb[j].cpn == (s).release_ref_cpn[i])
nengel@10	2399 {
nengel@10	2400 {
nengel@10	2401 {
nengel@10	2402 nanos_err_t err;
nengel@10	2403 err = nanos_set_lock(&nanos_critical_lock_dpb);
nengel@10	2404 if (err != NANOS_OK)
nengel@10	2405 {
nengel@10	2406 nanos_handle_error(err);
nengel@10	2407 }
nengel@10	2408 release_dpb_entry(h, &(*h).dpb[j], 2);
nengel@10	2409 err = nanos_unset_lock(&nanos_critical_lock_dpb);
nengel@10	2410 if (err != NANOS_OK)
nengel@10	2411 {
nengel@10	2412 nanos_handle_error(err);
nengel@10	2413 }
nengel@10	2414 }
nengel@10	2415 break;
nengel@10	2416 }
nengel@10	2417 }
nengel@10	2418 }
nengel@10	2419 }
nengel@10	2420 }
nengel@10	2421 }
nengel@10	2422 (*s).release_cnt = 0;
nengel@10	2423 release_smbc(h, smbc);
nengel@10	2424 }
nengel@10	2425 struct OutputContext;
nengel@10	2426 typedef struct OutputContext OutputContext;
nengel@10	2427 DecodedPicture output_frame(H264Context h, OutputContext oc, DecodedPicture pic, int fd, int frame_width, int frame_height);
nengel@10	2428 static void output_task(H264Context h, OutputContext oc, SliceBufferEntry *sbe)
nengel@10	2429 {
nengel@10	2430 DecodedPicture out = output_frame(h, oc, (sbe).slice.curr_pic, (h).ofile, (h).frame_width, (*h).frame_height);
nengel@10	2431 if (out)
nengel@10	2432 {
nengel@10	2433 {
nengel@9	2434 {
nengel@10	2435 nanos_err_t err;
nengel@10	2436 err = nanos_set_lock(&nanos_critical_lock_dpb);
nengel@10	2437 if (err != NANOS_OK)
nengel@9	2438 {
nengel@10	2439 nanos_handle_error(err);
nengel@10	2440 }
nengel@10	2441 release_dpb_entry(h, out, 1);
nengel@10	2442 err = nanos_unset_lock(&nanos_critical_lock_dpb);
nengel@10	2443 if (err != NANOS_OK)
nengel@10	2444 {
nengel@10	2445 nanos_handle_error(err);
nengel@9	2446 }
nengel@9	2447 }
nengel@10	2448 }
nengel@9	2449 }
nengel@9	2450 }
nengel@10	2451 void *av_mallocz(unsigned int size)__attribute__((__malloc__));
nengel@10	2452 ParserContext *get_parse_context(int ifile);
nengel@10	2453 NalContext *get_nal_context(int width, int height);
nengel@10	2454 EntropyContext get_entropy_context(H264Context h);
nengel@10	2455 MBRecContext get_mbrec_context(H264Context h);
nengel@10	2456 OutputContext get_output_context(H264Context h);
nengel@10	2457 void av_start_timer();
nengel@10	2458 struct ParserContext
nengel@9	2459 {
nengel@10	2460 int ifile;
nengel@10	2461 int ofile;
nengel@10	2462 int buffer_size;
nengel@10	2463 int eof_reached;
nengel@10	2464 uint8_t *data;
nengel@10	2465 int size;
nengel@10	2466 uint8_t *cur_ptr;
nengel@10	2467 int cur_len;
nengel@10	2468 int64_t frame_offset;
nengel@10	2469 int64_t cur_offset;
nengel@10	2470 int64_t next_frame_offset;
nengel@10	2471 int pict_type;
nengel@10	2472 int repeat_pict;
nengel@10	2473 int key_frame;
nengel@10	2474 int64_t pos;
nengel@10	2475 int64_t last_pos;
nengel@10	2476 int final_frame;
nengel@10	2477 uint8_t overread[5];
nengel@10	2478 int overread_cnt;
nengel@10	2479 int index;
nengel@10	2480 int last_index;
nengel@10	2481 int frame_start_found;
nengel@10	2482 uint32_t state;
nengel@10	2483 };
nengel@10	2484 struct nanos_args_6_t
nengel@9	2485 {
nengel@10	2486 H264Context *h;
nengel@10	2487 ParserContext *pc;
nengel@10	2488 NalContext *nc;
nengel@10	2489 SliceBufferEntry *sbe;
nengel@10	2490 };
nengel@10	2491 static void smp_ol_parse_task_13(struct nanos_args_6_t *const args);
nengel@10	2492 struct SPS;
nengel@10	2493 typedef struct SPS SPS;
nengel@10	2494 enum AVColorPrimaries
nengel@9	2495 {
nengel@10	2496 AVCOL_PRI_BT709 = 1,
nengel@10	2497 AVCOL_PRI_UNSPECIFIED = 2,
nengel@10	2498 AVCOL_PRI_BT470M = 4,
nengel@10	2499 AVCOL_PRI_BT470BG = 5,
nengel@10	2500 AVCOL_PRI_SMPTE170M = 6,
nengel@10	2501 AVCOL_PRI_SMPTE240M = 7,
nengel@10	2502 AVCOL_PRI_FILM = 8,
nengel@10	2503 AVCOL_PRI_NB = 9
nengel@10	2504 };
nengel@10	2505 enum AVColorTransferCharacteristic
nengel@9	2506 {
nengel@10	2507 AVCOL_TRC_BT709 = 1,
nengel@10	2508 AVCOL_TRC_UNSPECIFIED = 2,
nengel@10	2509 AVCOL_TRC_GAMMA22 = 4,
nengel@10	2510 AVCOL_TRC_GAMMA28 = 5,
nengel@10	2511 AVCOL_TRC_NB = 6
nengel@10	2512 };
nengel@10	2513 enum AVColorSpace
nengel@9	2514 {
nengel@10	2515 AVCOL_SPC_RGB = 0,
nengel@10	2516 AVCOL_SPC_BT709 = 1,
nengel@10	2517 AVCOL_SPC_UNSPECIFIED = 2,
nengel@10	2518 AVCOL_SPC_FCC = 4,
nengel@10	2519 AVCOL_SPC_BT470BG = 5,
nengel@10	2520 AVCOL_SPC_SMPTE170M = 6,
nengel@10	2521 AVCOL_SPC_SMPTE240M = 7,
nengel@10	2522 AVCOL_SPC_NB = 8
nengel@10	2523 };
nengel@10	2524 struct SPS
nengel@9	2525 {
nengel@10	2526 int profile_idc;
nengel@10	2527 int level_idc;
nengel@10	2528 int chroma_format_idc;
nengel@10	2529 int transform_bypass;
nengel@10	2530 int log2_max_frame_num;
nengel@10	2531 int poc_type;
nengel@10	2532 int log2_max_poc_lsb;
nengel@10	2533 int delta_pic_order_always_zero_flag;
nengel@10	2534 int offset_for_non_ref_pic;
nengel@10	2535 int offset_for_top_to_bottom_field;
nengel@10	2536 int poc_cycle_length;
nengel@10	2537 int ref_frame_count;
nengel@10	2538 int gaps_in_frame_num_allowed_flag;
nengel@10	2539 int mb_width;
nengel@10	2540 int mb_height;
nengel@10	2541 int frame_mbs_only_flag;
nengel@10	2542 int mb_aff;
nengel@10	2543 int direct_8x8_inference_flag;
nengel@10	2544 int crop;
nengel@10	2545 unsigned int crop_left;
nengel@10	2546 unsigned int crop_right;
nengel@10	2547 unsigned int crop_top;
nengel@10	2548 unsigned int crop_bottom;
nengel@10	2549 int vui_parameters_present_flag;
nengel@10	2550 int num;
nengel@10	2551 int den;
nengel@10	2552 int video_signal_type_present_flag;
nengel@10	2553 int full_range;
nengel@10	2554 int colour_description_present_flag;
nengel@10	2555 enum AVColorPrimaries color_primaries;
nengel@10	2556 enum AVColorTransferCharacteristic color_trc;
nengel@10	2557 enum AVColorSpace colorspace;
nengel@10	2558 int timing_info_present_flag;
nengel@10	2559 uint32_t num_units_in_tick;
nengel@10	2560 uint32_t time_scale;
nengel@10	2561 int fixed_frame_rate_flag;
nengel@10	2562 short int offset_for_ref_frame[256];
nengel@10	2563 int bitstream_restriction_flag;
nengel@10	2564 int num_reorder_frames;
nengel@10	2565 int scaling_matrix_present;
nengel@10	2566 uint8_t scaling_matrix4[6][16];
nengel@10	2567 uint8_t scaling_matrix8[2][64];
nengel@10	2568 int nal_hrd_parameters_present_flag;
nengel@10	2569 int vcl_hrd_parameters_present_flag;
nengel@10	2570 int pic_struct_present_flag;
nengel@10	2571 int time_offset_length;
nengel@10	2572 int cpb_cnt;
nengel@10	2573 int initial_cpb_removal_delay_length;
nengel@10	2574 int cpb_removal_delay_length;
nengel@10	2575 int dpb_output_delay_length;
nengel@10	2576 int bit_depth_luma;
nengel@10	2577 int bit_depth_chroma;
nengel@10	2578 int residual_color_transform_flag;
nengel@10	2579 };
nengel@10	2580 struct PictureInfo
nengel@9	2581 {
nengel@10	2582 int ref_poc[2][16];
nengel@10	2583 int ref_count[2];
nengel@10	2584 int poc;
nengel@10	2585 int frame_num;
nengel@10	2586 int pic_id;
nengel@10	2587 int long_ref;
nengel@10	2588 int cpn;
nengel@10	2589 int slice_type_nos;
nengel@10	2590 int reference;
nengel@10	2591 };
nengel@10	2592 enum mcc_enum_anon_20
nengel@9	2593 {
nengel@10	2594 SEI_PIC_STRUCT_FRAME = 0,
nengel@10	2595 SEI_PIC_STRUCT_TOP_FIELD = 1,
nengel@10	2596 SEI_PIC_STRUCT_BOTTOM_FIELD = 2,
nengel@10	2597 SEI_PIC_STRUCT_TOP_BOTTOM = 3,
nengel@10	2598 SEI_PIC_STRUCT_BOTTOM_TOP = 4,
nengel@10	2599 SEI_PIC_STRUCT_TOP_BOTTOM_TOP = 5,
nengel@10	2600 SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6,
nengel@10	2601 SEI_PIC_STRUCT_FRAME_DOUBLING = 7,
nengel@10	2602 SEI_PIC_STRUCT_FRAME_TRIPLING = 8
nengel@10	2603 };
nengel@10	2604 typedef enum mcc_enum_anon_20 SEI_PicStructType;
nengel@10	2605 struct NalContext
nengel@9	2606 {
nengel@10	2607 SPS *sps_buffers[32];
nengel@10	2608 PPS *pps_buffers[256];
nengel@10	2609 SPS sps;
nengel@10	2610 PictureInfo picture[17];
nengel@10	2611 PictureInfo *release_ref[66];
nengel@10	2612 PictureInfo *short_ref[32];
nengel@10	2613 PictureInfo *long_ref[32];
nengel@10	2614 int long_ref_count;
nengel@10	2615 int short_ref_count;
nengel@10	2616 uint32_t coded_pic_num;
nengel@10	2617 int poc_lsb;
nengel@10	2618 int poc_msb;
nengel@10	2619 uint32_t poc_offset;
nengel@10	2620 int delta_poc;
nengel@10	2621 int frame_num;
nengel@10	2622 int prev_poc_msb;
nengel@10	2623 int prev_poc_lsb;
nengel@10	2624 int frame_num_offset;
nengel@10	2625 int prev_frame_num_offset;
nengel@10	2626 int prev_frame_num;
nengel@10	2627 int max_pic_num;
nengel@10	2628 int redundant_pic_count;
nengel@10	2629 int outputed_poc;
nengel@10	2630 int ip_id;
nengel@10	2631 int b4_stride;
nengel@10	2632 int mb_stride;
nengel@10	2633 int mb_width;
nengel@10	2634 int mb_height;
nengel@10	2635 int width;
nengel@10	2636 int height;
nengel@10	2637 int has_b_frames;
nengel@10	2638 SEI_PicStructType sei_pic_struct;
nengel@10	2639 int sei_ct_type;
nengel@10	2640 int sei_dpb_output_delay;
nengel@10	2641 int sei_cpb_removal_delay;
nengel@10	2642 int sei_recovery_frame_cnt;
nengel@10	2643 int sei_buffering_period_present;
nengel@10	2644 int initial_cpb_removal_delay[32];
nengel@10	2645 };
nengel@10	2646 struct nanos_args_7_t
nengel@9	2647 {
nengel@10	2648 H264Context *h;
nengel@10	2649 EntropyContext *ec;
nengel@10	2650 SliceBufferEntry *sbe;
nengel@10	2651 };
nengel@10	2652 static void smp_ol_decode_slice_entropy_task_15(struct nanos_args_7_t *const args);
nengel@10	2653 struct nanos_args_8_t
nengel@9	2654 {
nengel@10	2655 H264Context *h;
nengel@10	2656 ParserContext *pc;
nengel@10	2657 NalContext *nc;
nengel@10	2658 SliceBufferEntry *sbe;
nengel@10	2659 };
nengel@10	2660 static void smp_ol_parse_task_17(struct nanos_args_8_t *const args);
nengel@10	2661 struct nanos_args_9_t
nengel@9	2662 {
nengel@10	2663 H264Context *h;
nengel@10	2664 EntropyContext *ec;
nengel@10	2665 SliceBufferEntry *sbe;
nengel@10	2666 };
nengel@10	2667 static void smp_ol_decode_slice_entropy_task_19(struct nanos_args_9_t *const args);
nengel@10	2668 struct nanos_args_10_t
nengel@9	2669 {
nengel@10	2670 H264Context *h;
nengel@10	2671 MBRecContext *d;
nengel@10	2672 SliceBufferEntry *sbe;
nengel@10	2673 int *init;
nengel@10	2674 };
nengel@10	2675 static void smp_ol_init_ref_list_and_get_dpb_task_21(struct nanos_args_10_t *const args);
nengel@10	2676 struct nanos_args_11_t
nengel@9	2677 {
nengel@10	2678 H264Context *h;
nengel@10	2679 SuperMBContext *smbc;
nengel@10	2680 MBRecContext *d;
nengel@10	2681 SliceBufferEntry *sbe;
nengel@10	2682 SuperMBTask *lastsmb;
nengel@10	2683 int *release;
nengel@10	2684 };
nengel@10	2685 static void smp_ol_release_ref_list_task_23(struct nanos_args_11_t *const args);
nengel@10	2686 struct nanos_args_12_t
nengel@9	2687 {
nengel@10	2688 H264Context *h;
nengel@10	2689 OutputContext *oc;
nengel@10	2690 SliceBufferEntry *sbe;
nengel@10	2691 };
nengel@10	2692 static void smp_ol_output_task_25(struct nanos_args_12_t *const args);
nengel@10	2693 struct OutputContext
nengel@9	2694 {
nengel@10	2695 int bit_buffer_size;
nengel@10	2696 uint8_t *bit_buffer;
nengel@10	2697 uint64_t video_size;
nengel@10	2698 int frame_number;
nengel@10	2699 DecodedPicture *delayed_pic[33];
nengel@10	2700 int dp_cnt;
nengel@10	2701 };
nengel@10	2702 struct nanos_args_13_t
nengel@9	2703 {
nengel@10	2704 H264Context *h;
nengel@10	2705 MBRecContext *d;
nengel@10	2706 SliceBufferEntry *sbe;
nengel@10	2707 int *init;
nengel@10	2708 };
nengel@10	2709 static void smp_ol_init_ref_list_and_get_dpb_task_27(struct nanos_args_13_t *const args);
nengel@10	2710 struct nanos_args_14_t
nengel@9	2711 {
nengel@10	2712 H264Context *h;
nengel@10	2713 SuperMBContext *smbc;
nengel@10	2714 MBRecContext *d;
nengel@10	2715 SliceBufferEntry *sbe;
nengel@10	2716 SuperMBTask *lastsmb;
nengel@10	2717 int *release;
nengel@10	2718 };
nengel@10	2719 static void smp_ol_release_ref_list_task_29(struct nanos_args_14_t *const args);
nengel@10	2720 struct nanos_args_15_t
nengel@9	2721 {
nengel@10	2722 H264Context *h;
nengel@10	2723 OutputContext *oc;
nengel@10	2724 SliceBufferEntry *sbe;
nengel@10	2725 };
nengel@10	2726 static void smp_ol_output_task_31(struct nanos_args_15_t *const args);
nengel@10	2727 struct nanos_args_16_t
nengel@9	2728 {
nengel@10	2729 H264Context *h;
nengel@10	2730 ParserContext *pc;
nengel@10	2731 NalContext *nc;
nengel@10	2732 SliceBufferEntry *sbe;
nengel@10	2733 };
nengel@10	2734 static void smp_ol_parse_task_33(struct nanos_args_16_t *const args);
nengel@10	2735 struct nanos_args_17_t
nengel@9	2736 {
nengel@10	2737 H264Context *h;
nengel@10	2738 EntropyContext *ec;
nengel@10	2739 SliceBufferEntry *sbe;
nengel@10	2740 };
nengel@10	2741 static void smp_ol_decode_slice_entropy_task_35(struct nanos_args_17_t *const args);
nengel@10	2742 struct nanos_args_18_t
nengel@9	2743 {
nengel@10	2744 H264Context *h;
nengel@10	2745 MBRecContext *d;
nengel@10	2746 SliceBufferEntry *sbe;
nengel@10	2747 };
nengel@10	2748 static void smp_ol_decode_slice_mb_task_37(struct nanos_args_18_t *const args);
nengel@10	2749 struct nanos_args_19_t
nengel@9	2750 {
nengel@10	2751 H264Context *h;
nengel@10	2752 OutputContext *oc;
nengel@10	2753 SliceBufferEntry *sbe;
nengel@10	2754 };
nengel@10	2755 static void smp_ol_output_task_39(struct nanos_args_19_t *const args);
nengel@10	2756 extern nanos_err_t nanos_wg_wait_completion(void *wg, _Bool avoid_flush);
nengel@10	2757 void free_parse_context(ParserContext *pc);
nengel@10	2758 void free_nal_context(NalContext *nc);
nengel@10	2759 void free_output_context(OutputContext *oc);
nengel@10	2760 void free_sb_entry(SliceBufferEntry *sb);
nengel@10	2761 void free_entropy_context(EntropyContext *ec);
nengel@10	2762 void av_free(void *ptr);
nengel@10	2763 void free_mbrec_context(MBRecContext *d);
nengel@9	2764 int h264_decode_ompss(H264Context *h)
nengel@9	2765 {
nengel@10	2766 SliceBufferEntry *sbe;
nengel@10	2767 ParserContext *pc;
nengel@10	2768 NalContext *nc;
nengel@10	2769 MBRecContext *rc[2];
nengel@10	2770 OutputContext *oc;
nengel@10	2771 int init;
nengel@10	2772 SuperMBContext *smbc;
nengel@10	2773 int release;
nengel@10	2774 DecodedPicture *out;
nengel@10	2775 const int bufs = (*h).pipe_bufs;
nengel@10	2776 EntropyContext *ec[bufs];
nengel@10	2777 int frames = 0;
nengel@10	2778 sbe = av_mallocz(sizeof(SliceBufferEntry) * bufs);
nengel@10	2779 pc = get_parse_context((*h).ifile);
nengel@10	2780 nc = get_nal_context((h).width, (h).height);
nengel@10	2781 for (int i = 0; i < bufs; i++)
nengel@9	2782 {
nengel@10	2783 {
nengel@9	2784 ec[i] = get_entropy_context(h);
nengel@10	2785 }
nengel@9	2786 }
nengel@10	2787 for (int i = 0; i < 2; i++)
nengel@9	2788 {
nengel@10	2789 {
nengel@9	2790 rc[i] = get_mbrec_context(h);
nengel@10	2791 }
nengel@9	2792 }
nengel@10	2793 oc = get_output_context(h);
nengel@10	2794 av_start_timer();
nengel@10	2795 int k = 0;
nengel@10	2796 if ((h).static_3d && bufs < (h).num_frames)
nengel@9	2797 {
nengel@10	2798 {
nengel@9	2799 int num_pre_ed = 0;
nengel@10	2800 for (num_pre_ed = 0; num_pre_ed < bufs - 1 && !(*pc).final_frame; num_pre_ed++)
nengel@10	2801 {
nengel@9	2802 {
nengel@10	2803 nanos_err_t mcc_err_in_final_6;
nengel@10	2804 _Bool mcc_is_in_final_6;
nengel@10	2805 nanos_err_t mcc_err_in_final_7;
nengel@10	2806 _Bool mcc_is_in_final_7;
nengel@10	2807 mcc_err_in_final_6 = nanos_in_final(&mcc_is_in_final_6);
nengel@10	2808 {
nengel@10	2809 H264Context *mcc_arg_34 = h;
nengel@10	2810 ParserContext *mcc_arg_35 = pc;
nengel@10	2811 NalContext *mcc_arg_36 = nc;
nengel@10	2812 SliceBufferEntry *mcc_arg_37 = &sbe[k % bufs];
nengel@10	2813 if (mcc_is_in_final_6)
nengel@10	2814 {
nengel@10	2815 parse_task(h, pc, nc, &sbe[k % bufs]);
nengel@10	2816 }
nengel@10	2817 else
nengel@10	2818 {
nengel@9	2819 {
nengel@10	2820 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	2821 struct nanos_args_6_t *ol_args;
nengel@10	2822 nanos_err_t err;
nengel@10	2823 struct nanos_args_6_t imm_args;
nengel@10	2824 static nanos_smp_args_t smp_ol_parse_task_13_args = { .outline = (void ()(void ))(void ()(struct nanos_args_6_t ))&smp_ol_parse_task_13 };
nengel@10	2825 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_6_t), 0, 1, 0, "parse_task" }, { { &nanos_smp_factory, &smp_ol_parse_task_13_args } } };
nengel@10	2826 nanos_wd_dyn_props.tie_to = 0;
nengel@10	2827 nanos_wd_dyn_props.priority = 0;
nengel@10	2828 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	2829 ol_args = (struct nanos_args_6_t *)0;
nengel@10	2830 void nanos_wd_ = (void )0;
nengel@10	2831 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_6_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	2832 if (err != NANOS_OK)
nengel@9	2833 {
nengel@10	2834 nanos_handle_error(err);
nengel@10	2835 }
nengel@10	2836 /* Check pendant writes on subexpressions */
nengel@10	2837 /* End check pendant writes on subexpressions */
nengel@10	2838 if (nanos_wd_ != (void *)0)
nengel@10	2839 {
nengel@10	2840 {
nengel@10	2841 (*ol_args).h = mcc_arg_34;
nengel@10	2842 (*ol_args).pc = mcc_arg_35;
nengel@10	2843 (*ol_args).nc = mcc_arg_36;
nengel@10	2844 (*ol_args).sbe = mcc_arg_37;
nengel@10	2845 nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } };
nengel@10	2846 nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } };
nengel@10	2847 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2848 nanos_data_access_t dependences[3] = { { (void )mcc_arg_35, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_36, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_37, { 0, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	2849 ;
nengel@10	2850 err = nanos_submit(nanos_wd_, 3, dependences, (void *)0);
nengel@10	2851 if (err != NANOS_OK)
nengel@10	2852 {
nengel@10	2853 nanos_handle_error(err);
nengel@10	2854 }
nengel@10	2855 }
nengel@10	2856 }
nengel@10	2857 else
nengel@10	2858 {
nengel@10	2859 {
nengel@10	2860 imm_args.h = mcc_arg_34;
nengel@10	2861 imm_args.pc = mcc_arg_35;
nengel@10	2862 imm_args.nc = mcc_arg_36;
nengel@10	2863 imm_args.sbe = mcc_arg_37;
nengel@10	2864 nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } };
nengel@10	2865 nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } };
nengel@10	2866 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2867 nanos_data_access_t dependences[3] = { { (void )mcc_arg_35, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_36, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_37, { 0, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	2868 ;
nengel@10	2869 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_6_t), &imm_args, 3, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	2870 if (err != NANOS_OK)
nengel@10	2871 {
nengel@10	2872 nanos_handle_error(err);
nengel@10	2873 }
nengel@10	2874 }
nengel@10	2875 }
nengel@10	2876 }
nengel@10	2877 }
nengel@10	2878 }
nengel@10	2879 mcc_err_in_final_7 = nanos_in_final(&mcc_is_in_final_7);
nengel@10	2880 {
nengel@10	2881 H264Context *mcc_arg_38 = h;
nengel@10	2882 EntropyContext *mcc_arg_39 = ec[k % bufs];
nengel@10	2883 SliceBufferEntry *mcc_arg_40 = &sbe[k % bufs];
nengel@10	2884 if (mcc_is_in_final_7)
nengel@10	2885 {
nengel@10	2886 decode_slice_entropy_task(h, ec[k % bufs], &sbe[k % bufs]);
nengel@10	2887 }
nengel@10	2888 else
nengel@10	2889 {
nengel@9	2890 {
nengel@10	2891 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	2892 struct nanos_args_7_t *ol_args;
nengel@10	2893 nanos_err_t err;
nengel@10	2894 struct nanos_args_7_t imm_args;
nengel@10	2895 static nanos_smp_args_t smp_ol_decode_slice_entropy_task_15_args = { .outline = (void ()(void ))(void ()(struct nanos_args_7_t ))&smp_ol_decode_slice_entropy_task_15 };
nengel@10	2896 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_7_t), 0, 1, 0, "decode_slice_entropy_task" }, { { &nanos_smp_factory, &smp_ol_decode_slice_entropy_task_15_args } } };
nengel@10	2897 nanos_wd_dyn_props.tie_to = 0;
nengel@10	2898 nanos_wd_dyn_props.priority = 0;
nengel@10	2899 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	2900 ol_args = (struct nanos_args_7_t *)0;
nengel@10	2901 void nanos_wd_ = (void )0;
nengel@10	2902 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_7_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	2903 if (err != NANOS_OK)
nengel@10	2904 {
nengel@10	2905 nanos_handle_error(err);
nengel@10	2906 }
nengel@10	2907 /* Check pendant writes on subexpressions */
nengel@10	2908 /* End check pendant writes on subexpressions */
nengel@10	2909 if (nanos_wd_ != (void *)0)
nengel@10	2910 {
nengel@10	2911 {
nengel@10	2912 (*ol_args).h = mcc_arg_38;
nengel@10	2913 (*ol_args).ec = mcc_arg_39;
nengel@10	2914 (*ol_args).sbe = mcc_arg_40;
nengel@10	2915 nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } };
nengel@10	2916 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2917 nanos_data_access_t dependences[2] = { { (void )mcc_arg_39, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_40, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	2918 ;
nengel@10	2919 err = nanos_submit(nanos_wd_, 2, dependences, (void *)0);
nengel@10	2920 if (err != NANOS_OK)
nengel@10	2921 {
nengel@10	2922 nanos_handle_error(err);
nengel@10	2923 }
nengel@10	2924 }
nengel@10	2925 }
nengel@10	2926 else
nengel@10	2927 {
nengel@10	2928 {
nengel@10	2929 imm_args.h = mcc_arg_38;
nengel@10	2930 imm_args.ec = mcc_arg_39;
nengel@10	2931 imm_args.sbe = mcc_arg_40;
nengel@10	2932 nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } };
nengel@10	2933 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	2934 nanos_data_access_t dependences[2] = { { (void )mcc_arg_39, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_40, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	2935 ;
nengel@10	2936 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_7_t), &imm_args, 2, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	2937 if (err != NANOS_OK)
nengel@10	2938 {
nengel@10	2939 nanos_handle_error(err);
nengel@10	2940 }
nengel@10	2941 }
nengel@10	2942 }
nengel@9	2943 }
nengel@10	2944 }
nengel@10	2945 }
nengel@10	2946 {
nengel@10	2947 nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } };
nengel@10	2948 nanos_data_access_t dependences[1] = { { (void *)pc, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 } };
nengel@10	2949 ;
nengel@10	2950 nanos_err_t err = nanos_wait_on(1, dependences);
nengel@10	2951 if (err != NANOS_OK)
nengel@10	2952 {
nengel@10	2953 nanos_handle_error(err);
nengel@10	2954 }
nengel@10	2955 }
nengel@10	2956 k++;
nengel@10	2957 }
nengel@10	2958 }
nengel@10	2959 while ((!(pc).final_frame && frames++ < (h).num_frames) && !(*h).quit)
nengel@10	2960 {
nengel@10	2961 {
nengel@10	2962 nanos_err_t mcc_err_in_final_8;
nengel@10	2963 _Bool mcc_is_in_final_8;
nengel@10	2964 nanos_err_t mcc_err_in_final_9;
nengel@10	2965 _Bool mcc_is_in_final_9;
nengel@10	2966 nanos_err_t mcc_err_in_final_10;
nengel@10	2967 _Bool mcc_is_in_final_10;
nengel@10	2968 nanos_err_t mcc_err_in_final_11;
nengel@10	2969 _Bool mcc_is_in_final_11;
nengel@10	2970 nanos_err_t mcc_err_in_final_12;
nengel@10	2971 _Bool mcc_is_in_final_12;
nengel@10	2972 mcc_err_in_final_8 = nanos_in_final(&mcc_is_in_final_8);
nengel@10	2973 {
nengel@10	2974 H264Context *mcc_arg_41 = h;
nengel@10	2975 ParserContext *mcc_arg_42 = pc;
nengel@10	2976 NalContext *mcc_arg_43 = nc;
nengel@10	2977 SliceBufferEntry *mcc_arg_44 = &sbe[k % bufs];
nengel@10	2978 if (mcc_is_in_final_8)
nengel@10	2979 {
nengel@10	2980 parse_task(h, pc, nc, &sbe[k % bufs]);
nengel@10	2981 }
nengel@10	2982 else
nengel@10	2983 {
nengel@9	2984 {
nengel@10	2985 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	2986 struct nanos_args_8_t *ol_args;
nengel@10	2987 nanos_err_t err;
nengel@10	2988 struct nanos_args_8_t imm_args;
nengel@10	2989 static nanos_smp_args_t smp_ol_parse_task_17_args = { .outline = (void ()(void ))(void ()(struct nanos_args_8_t ))&smp_ol_parse_task_17 };
nengel@10	2990 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_8_t), 0, 1, 0, "parse_task" }, { { &nanos_smp_factory, &smp_ol_parse_task_17_args } } };
nengel@10	2991 nanos_wd_dyn_props.tie_to = 0;
nengel@10	2992 nanos_wd_dyn_props.priority = 0;
nengel@10	2993 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	2994 ol_args = (struct nanos_args_8_t *)0;
nengel@10	2995 void nanos_wd_ = (void )0;
nengel@10	2996 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_8_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	2997 if (err != NANOS_OK)
nengel@10	2998 {
nengel@10	2999 nanos_handle_error(err);
nengel@10	3000 }
nengel@10	3001 /* Check pendant writes on subexpressions */
nengel@10	3002 /* End check pendant writes on subexpressions */
nengel@10	3003 if (nanos_wd_ != (void *)0)
nengel@10	3004 {
nengel@10	3005 {
nengel@10	3006 (*ol_args).h = mcc_arg_41;
nengel@10	3007 (*ol_args).pc = mcc_arg_42;
nengel@10	3008 (*ol_args).nc = mcc_arg_43;
nengel@10	3009 (*ol_args).sbe = mcc_arg_44;
nengel@10	3010 nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } };
nengel@10	3011 nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } };
nengel@10	3012 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3013 nanos_data_access_t dependences[3] = { { (void )mcc_arg_42, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_43, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_44, { 0, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	3014 ;
nengel@10	3015 err = nanos_submit(nanos_wd_, 3, dependences, (void *)0);
nengel@10	3016 if (err != NANOS_OK)
nengel@10	3017 {
nengel@10	3018 nanos_handle_error(err);
nengel@10	3019 }
nengel@10	3020 }
nengel@10	3021 }
nengel@10	3022 else
nengel@10	3023 {
nengel@10	3024 {
nengel@10	3025 imm_args.h = mcc_arg_41;
nengel@10	3026 imm_args.pc = mcc_arg_42;
nengel@10	3027 imm_args.nc = mcc_arg_43;
nengel@10	3028 imm_args.sbe = mcc_arg_44;
nengel@10	3029 nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } };
nengel@10	3030 nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } };
nengel@10	3031 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3032 nanos_data_access_t dependences[3] = { { (void )mcc_arg_42, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_43, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_44, { 0, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	3033 ;
nengel@10	3034 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_8_t), &imm_args, 3, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3035 if (err != NANOS_OK)
nengel@10	3036 {
nengel@10	3037 nanos_handle_error(err);
nengel@10	3038 }
nengel@10	3039 }
nengel@10	3040 }
nengel@9	3041 }
nengel@10	3042 }
nengel@10	3043 }
nengel@10	3044 mcc_err_in_final_9 = nanos_in_final(&mcc_is_in_final_9);
nengel@10	3045 {
nengel@10	3046 H264Context *mcc_arg_45 = h;
nengel@10	3047 EntropyContext *mcc_arg_46 = ec[k % bufs];
nengel@10	3048 SliceBufferEntry *mcc_arg_47 = &sbe[k % bufs];
nengel@10	3049 if (mcc_is_in_final_9)
nengel@10	3050 {
nengel@10	3051 decode_slice_entropy_task(h, ec[k % bufs], &sbe[k % bufs]);
nengel@10	3052 }
nengel@10	3053 else
nengel@10	3054 {
nengel@10	3055 {
nengel@10	3056 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	3057 struct nanos_args_9_t *ol_args;
nengel@10	3058 nanos_err_t err;
nengel@10	3059 struct nanos_args_9_t imm_args;
nengel@10	3060 static nanos_smp_args_t smp_ol_decode_slice_entropy_task_19_args = { .outline = (void ()(void ))(void ()(struct nanos_args_9_t ))&smp_ol_decode_slice_entropy_task_19 };
nengel@10	3061 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_9_t), 0, 1, 0, "decode_slice_entropy_task" }, { { &nanos_smp_factory, &smp_ol_decode_slice_entropy_task_19_args } } };
nengel@10	3062 nanos_wd_dyn_props.tie_to = 0;
nengel@10	3063 nanos_wd_dyn_props.priority = 0;
nengel@10	3064 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	3065 ol_args = (struct nanos_args_9_t *)0;
nengel@10	3066 void nanos_wd_ = (void )0;
nengel@10	3067 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_9_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	3068 if (err != NANOS_OK)
nengel@10	3069 {
nengel@10	3070 nanos_handle_error(err);
nengel@10	3071 }
nengel@10	3072 /* Check pendant writes on subexpressions */
nengel@10	3073 /* End check pendant writes on subexpressions */
nengel@10	3074 if (nanos_wd_ != (void *)0)
nengel@10	3075 {
nengel@10	3076 {
nengel@10	3077 (*ol_args).h = mcc_arg_45;
nengel@10	3078 (*ol_args).ec = mcc_arg_46;
nengel@10	3079 (*ol_args).sbe = mcc_arg_47;
nengel@10	3080 nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } };
nengel@10	3081 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3082 nanos_data_access_t dependences[2] = { { (void )mcc_arg_46, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_47, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3083 ;
nengel@10	3084 err = nanos_submit(nanos_wd_, 2, dependences, (void *)0);
nengel@10	3085 if (err != NANOS_OK)
nengel@10	3086 {
nengel@10	3087 nanos_handle_error(err);
nengel@10	3088 }
nengel@10	3089 }
nengel@10	3090 }
nengel@10	3091 else
nengel@10	3092 {
nengel@10	3093 {
nengel@10	3094 imm_args.h = mcc_arg_45;
nengel@10	3095 imm_args.ec = mcc_arg_46;
nengel@10	3096 imm_args.sbe = mcc_arg_47;
nengel@10	3097 nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } };
nengel@10	3098 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3099 nanos_data_access_t dependences[2] = { { (void )mcc_arg_46, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_47, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3100 ;
nengel@10	3101 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_9_t), &imm_args, 2, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3102 if (err != NANOS_OK)
nengel@10	3103 {
nengel@10	3104 nanos_handle_error(err);
nengel@10	3105 }
nengel@10	3106 }
nengel@10	3107 }
nengel@10	3108 }
nengel@10	3109 }
nengel@10	3110 }
nengel@10	3111 k++;
nengel@10	3112 mcc_err_in_final_10 = nanos_in_final(&mcc_is_in_final_10);
nengel@10	3113 {
nengel@10	3114 H264Context *mcc_arg_48 = h;
nengel@10	3115 MBRecContext *mcc_arg_49 = rc[k % 2];
nengel@10	3116 SliceBufferEntry *mcc_arg_50 = &sbe[k % bufs];
nengel@10	3117 int *mcc_arg_51 = &init;
nengel@10	3118 if (mcc_is_in_final_10)
nengel@10	3119 {
nengel@10	3120 init_ref_list_and_get_dpb_task(h, rc[k % 2], &sbe[k % bufs], &init);
nengel@10	3121 }
nengel@10	3122 else
nengel@10	3123 {
nengel@10	3124 {
nengel@10	3125 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	3126 struct nanos_args_10_t *ol_args;
nengel@10	3127 nanos_err_t err;
nengel@10	3128 struct nanos_args_10_t imm_args;
nengel@10	3129 static nanos_smp_args_t smp_ol_init_ref_list_and_get_dpb_task_21_args = { .outline = (void ()(void ))(void ()(struct nanos_args_10_t ))&smp_ol_init_ref_list_and_get_dpb_task_21 };
nengel@10	3130 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_10_t), 0, 1, 0, "init_ref_list_and_get_dpb_task" }, { { &nanos_smp_factory, &smp_ol_init_ref_list_and_get_dpb_task_21_args } } };
nengel@10	3131 nanos_wd_dyn_props.tie_to = 0;
nengel@10	3132 nanos_wd_dyn_props.priority = 0;
nengel@10	3133 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	3134 ol_args = (struct nanos_args_10_t *)0;
nengel@10	3135 void nanos_wd_ = (void )0;
nengel@10	3136 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_10_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	3137 if (err != NANOS_OK)
nengel@10	3138 {
nengel@10	3139 nanos_handle_error(err);
nengel@10	3140 }
nengel@10	3141 /* Check pendant writes on subexpressions */
nengel@10	3142 /* End check pendant writes on subexpressions */
nengel@10	3143 if (nanos_wd_ != (void *)0)
nengel@10	3144 {
nengel@10	3145 {
nengel@10	3146 (*ol_args).h = mcc_arg_48;
nengel@10	3147 (*ol_args).d = mcc_arg_49;
nengel@10	3148 (*ol_args).sbe = mcc_arg_50;
nengel@10	3149 (*ol_args).init = mcc_arg_51;
nengel@10	3150 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	3151 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3152 nanos_region_dimension_t dimensions_2[1] = { { sizeof(int), 0, sizeof(int) } };
nengel@10	3153 nanos_data_access_t dependences[3] = { { (void )mcc_arg_49, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_50, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_51, { 1, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	3154 ;
nengel@10	3155 err = nanos_submit(nanos_wd_, 3, dependences, (void *)0);
nengel@10	3156 if (err != NANOS_OK)
nengel@10	3157 {
nengel@10	3158 nanos_handle_error(err);
nengel@10	3159 }
nengel@10	3160 }
nengel@10	3161 }
nengel@10	3162 else
nengel@10	3163 {
nengel@10	3164 {
nengel@10	3165 imm_args.h = mcc_arg_48;
nengel@10	3166 imm_args.d = mcc_arg_49;
nengel@10	3167 imm_args.sbe = mcc_arg_50;
nengel@10	3168 imm_args.init = mcc_arg_51;
nengel@10	3169 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	3170 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3171 nanos_region_dimension_t dimensions_2[1] = { { sizeof(int), 0, sizeof(int) } };
nengel@10	3172 nanos_data_access_t dependences[3] = { { (void )mcc_arg_49, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_50, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_51, { 1, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	3173 ;
nengel@10	3174 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_10_t), &imm_args, 3, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3175 if (err != NANOS_OK)
nengel@10	3176 {
nengel@10	3177 nanos_handle_error(err);
nengel@10	3178 }
nengel@10	3179 }
nengel@10	3180 }
nengel@10	3181 }
nengel@10	3182 }
nengel@10	3183 }
nengel@10	3184 smbc = acquire_smbc(h);
nengel@10	3185 SuperMBTask *lastsmb = add_decode_slice_3dwave_tasks(rc[k % 2], &sbe[k % bufs], smbc);
nengel@10	3186 mcc_err_in_final_11 = nanos_in_final(&mcc_is_in_final_11);
nengel@10	3187 {
nengel@10	3188 H264Context *mcc_arg_52 = h;
nengel@10	3189 SuperMBContext *mcc_arg_53 = smbc;
nengel@10	3190 MBRecContext *mcc_arg_54 = rc[k % 2];
nengel@10	3191 SliceBufferEntry *mcc_arg_55 = &sbe[k % bufs];
nengel@10	3192 SuperMBTask *mcc_arg_56 = lastsmb;
nengel@10	3193 int *mcc_arg_57 = &release;
nengel@10	3194 if (mcc_is_in_final_11)
nengel@10	3195 {
nengel@10	3196 release_ref_list_task(h, smbc, rc[k % 2], &sbe[k % bufs], lastsmb, &release);
nengel@10	3197 }
nengel@10	3198 else
nengel@10	3199 {
nengel@10	3200 {
nengel@10	3201 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	3202 struct nanos_args_11_t *ol_args;
nengel@10	3203 nanos_err_t err;
nengel@10	3204 struct nanos_args_11_t imm_args;
nengel@10	3205 static nanos_smp_args_t smp_ol_release_ref_list_task_23_args = { .outline = (void ()(void ))(void ()(struct nanos_args_11_t ))&smp_ol_release_ref_list_task_23 };
nengel@10	3206 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_11_t), 0, 1, 0, "release_ref_list_task" }, { { &nanos_smp_factory, &smp_ol_release_ref_list_task_23_args } } };
nengel@10	3207 nanos_wd_dyn_props.tie_to = 0;
nengel@10	3208 nanos_wd_dyn_props.priority = 0;
nengel@10	3209 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	3210 ol_args = (struct nanos_args_11_t *)0;
nengel@10	3211 void nanos_wd_ = (void )0;
nengel@10	3212 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_11_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	3213 if (err != NANOS_OK)
nengel@10	3214 {
nengel@10	3215 nanos_handle_error(err);
nengel@10	3216 }
nengel@10	3217 /* Check pendant writes on subexpressions */
nengel@10	3218 /* End check pendant writes on subexpressions */
nengel@10	3219 if (nanos_wd_ != (void *)0)
nengel@10	3220 {
nengel@10	3221 {
nengel@10	3222 (*ol_args).h = mcc_arg_52;
nengel@10	3223 (*ol_args).smbc = mcc_arg_53;
nengel@10	3224 (*ol_args).d = mcc_arg_54;
nengel@10	3225 (*ol_args).sbe = mcc_arg_55;
nengel@10	3226 (*ol_args).lastsmb = mcc_arg_56;
nengel@10	3227 (*ol_args).release = mcc_arg_57;
nengel@10	3228 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	3229 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3230 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	3231 nanos_region_dimension_t dimensions_3[1] = { { sizeof(int), 0, sizeof(int) } };
nengel@10	3232 nanos_data_access_t dependences[4] = { { (void )mcc_arg_54, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_55, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void )mcc_arg_56, { 1, 0, 0, 0, 0 }, 1, dimensions_2, 0 }, { (void )mcc_arg_57, { 1, 1, 0, 0, 0 }, 1, dimensions_3, 0 } };
nengel@10	3233 ;
nengel@10	3234 err = nanos_submit(nanos_wd_, 4, dependences, (void *)0);
nengel@10	3235 if (err != NANOS_OK)
nengel@10	3236 {
nengel@10	3237 nanos_handle_error(err);
nengel@10	3238 }
nengel@10	3239 }
nengel@10	3240 }
nengel@10	3241 else
nengel@10	3242 {
nengel@10	3243 {
nengel@10	3244 imm_args.h = mcc_arg_52;
nengel@10	3245 imm_args.smbc = mcc_arg_53;
nengel@10	3246 imm_args.d = mcc_arg_54;
nengel@10	3247 imm_args.sbe = mcc_arg_55;
nengel@10	3248 imm_args.lastsmb = mcc_arg_56;
nengel@10	3249 imm_args.release = mcc_arg_57;
nengel@10	3250 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	3251 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3252 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	3253 nanos_region_dimension_t dimensions_3[1] = { { sizeof(int), 0, sizeof(int) } };
nengel@10	3254 nanos_data_access_t dependences[4] = { { (void )mcc_arg_54, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_55, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void )mcc_arg_56, { 1, 0, 0, 0, 0 }, 1, dimensions_2, 0 }, { (void )mcc_arg_57, { 1, 1, 0, 0, 0 }, 1, dimensions_3, 0 } };
nengel@10	3255 ;
nengel@10	3256 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_11_t), &imm_args, 4, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3257 if (err != NANOS_OK)
nengel@10	3258 {
nengel@10	3259 nanos_handle_error(err);
nengel@10	3260 }
nengel@10	3261 }
nengel@10	3262 }
nengel@10	3263 }
nengel@10	3264 }
nengel@10	3265 }
nengel@10	3266 mcc_err_in_final_12 = nanos_in_final(&mcc_is_in_final_12);
nengel@10	3267 {
nengel@10	3268 H264Context *mcc_arg_58 = h;
nengel@10	3269 OutputContext *mcc_arg_59 = oc;
nengel@10	3270 SliceBufferEntry *mcc_arg_60 = &sbe[k % bufs];
nengel@10	3271 if (mcc_is_in_final_12)
nengel@10	3272 {
nengel@10	3273 output_task(h, oc, &sbe[k % bufs]);
nengel@10	3274 }
nengel@10	3275 else
nengel@10	3276 {
nengel@10	3277 {
nengel@10	3278 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	3279 struct nanos_args_12_t *ol_args;
nengel@10	3280 nanos_err_t err;
nengel@10	3281 struct nanos_args_12_t imm_args;
nengel@10	3282 static nanos_smp_args_t smp_ol_output_task_25_args = { .outline = (void ()(void ))(void ()(struct nanos_args_12_t ))&smp_ol_output_task_25 };
nengel@10	3283 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_12_t), 0, 1, 0, "output_task" }, { { &nanos_smp_factory, &smp_ol_output_task_25_args } } };
nengel@10	3284 nanos_wd_dyn_props.tie_to = 0;
nengel@10	3285 nanos_wd_dyn_props.priority = 0;
nengel@10	3286 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	3287 ol_args = (struct nanos_args_12_t *)0;
nengel@10	3288 void nanos_wd_ = (void )0;
nengel@10	3289 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_12_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	3290 if (err != NANOS_OK)
nengel@10	3291 {
nengel@10	3292 nanos_handle_error(err);
nengel@10	3293 }
nengel@10	3294 /* Check pendant writes on subexpressions */
nengel@10	3295 /* End check pendant writes on subexpressions */
nengel@10	3296 if (nanos_wd_ != (void *)0)
nengel@10	3297 {
nengel@10	3298 {
nengel@10	3299 (*ol_args).h = mcc_arg_58;
nengel@10	3300 (*ol_args).oc = mcc_arg_59;
nengel@10	3301 (*ol_args).sbe = mcc_arg_60;
nengel@10	3302 nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } };
nengel@10	3303 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3304 nanos_data_access_t dependences[2] = { { (void )mcc_arg_59, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_60, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3305 ;
nengel@10	3306 err = nanos_submit(nanos_wd_, 2, dependences, (void *)0);
nengel@10	3307 if (err != NANOS_OK)
nengel@10	3308 {
nengel@10	3309 nanos_handle_error(err);
nengel@10	3310 }
nengel@10	3311 }
nengel@10	3312 }
nengel@10	3313 else
nengel@10	3314 {
nengel@10	3315 {
nengel@10	3316 imm_args.h = mcc_arg_58;
nengel@10	3317 imm_args.oc = mcc_arg_59;
nengel@10	3318 imm_args.sbe = mcc_arg_60;
nengel@10	3319 nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } };
nengel@10	3320 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3321 nanos_data_access_t dependences[2] = { { (void )mcc_arg_59, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_60, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3322 ;
nengel@10	3323 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_12_t), &imm_args, 2, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3324 if (err != NANOS_OK)
nengel@10	3325 {
nengel@10	3326 nanos_handle_error(err);
nengel@10	3327 }
nengel@10	3328 }
nengel@10	3329 }
nengel@10	3330 }
nengel@10	3331 }
nengel@10	3332 }
nengel@10	3333 {
nengel@10	3334 nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } };
nengel@10	3335 nanos_data_access_t dependences[1] = { { (void *)pc, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 } };
nengel@9	3336 ;
nengel@10	3337 nanos_err_t err = nanos_wait_on(1, dependences);
nengel@10	3338 if (err != NANOS_OK)
nengel@10	3339 {
nengel@10	3340 nanos_handle_error(err);
nengel@10	3341 }
nengel@10	3342 }
nengel@9	3343 }
nengel@10	3344 }
nengel@10	3345 for (int i = 0; i < num_pre_ed; i++)
nengel@10	3346 {
nengel@9	3347 {
nengel@10	3348 nanos_err_t mcc_err_in_final_13;
nengel@10	3349 _Bool mcc_is_in_final_13;
nengel@10	3350 nanos_err_t mcc_err_in_final_14;
nengel@10	3351 _Bool mcc_is_in_final_14;
nengel@10	3352 nanos_err_t mcc_err_in_final_15;
nengel@10	3353 _Bool mcc_is_in_final_15;
nengel@10	3354 k++;
nengel@10	3355 mcc_err_in_final_13 = nanos_in_final(&mcc_is_in_final_13);
nengel@10	3356 {
nengel@10	3357 H264Context *mcc_arg_61 = h;
nengel@10	3358 MBRecContext *mcc_arg_62 = rc[k % 2];
nengel@10	3359 SliceBufferEntry *mcc_arg_63 = &sbe[k % bufs];
nengel@10	3360 int *mcc_arg_64 = &init;
nengel@10	3361 if (mcc_is_in_final_13)
nengel@10	3362 {
nengel@10	3363 init_ref_list_and_get_dpb_task(h, rc[k % 2], &sbe[k % bufs], &init);
nengel@10	3364 }
nengel@10	3365 else
nengel@10	3366 {
nengel@9	3367 {
nengel@10	3368 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	3369 struct nanos_args_13_t *ol_args;
nengel@10	3370 nanos_err_t err;
nengel@10	3371 struct nanos_args_13_t imm_args;
nengel@10	3372 static nanos_smp_args_t smp_ol_init_ref_list_and_get_dpb_task_27_args = { .outline = (void ()(void ))(void ()(struct nanos_args_13_t ))&smp_ol_init_ref_list_and_get_dpb_task_27 };
nengel@10	3373 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_13_t), 0, 1, 0, "init_ref_list_and_get_dpb_task" }, { { &nanos_smp_factory, &smp_ol_init_ref_list_and_get_dpb_task_27_args } } };
nengel@10	3374 nanos_wd_dyn_props.tie_to = 0;
nengel@10	3375 nanos_wd_dyn_props.priority = 0;
nengel@10	3376 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	3377 ol_args = (struct nanos_args_13_t *)0;
nengel@10	3378 void nanos_wd_ = (void )0;
nengel@10	3379 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_13_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	3380 if (err != NANOS_OK)
nengel@9	3381 {
nengel@10	3382 nanos_handle_error(err);
nengel@10	3383 }
nengel@10	3384 /* Check pendant writes on subexpressions */
nengel@10	3385 /* End check pendant writes on subexpressions */
nengel@10	3386 if (nanos_wd_ != (void *)0)
nengel@10	3387 {
nengel@10	3388 {
nengel@10	3389 (*ol_args).h = mcc_arg_61;
nengel@10	3390 (*ol_args).d = mcc_arg_62;
nengel@10	3391 (*ol_args).sbe = mcc_arg_63;
nengel@10	3392 (*ol_args).init = mcc_arg_64;
nengel@10	3393 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	3394 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3395 nanos_region_dimension_t dimensions_2[1] = { { sizeof(int), 0, sizeof(int) } };
nengel@10	3396 nanos_data_access_t dependences[3] = { { (void )mcc_arg_62, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_63, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_64, { 1, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	3397 ;
nengel@10	3398 err = nanos_submit(nanos_wd_, 3, dependences, (void *)0);
nengel@10	3399 if (err != NANOS_OK)
nengel@10	3400 {
nengel@10	3401 nanos_handle_error(err);
nengel@10	3402 }
nengel@10	3403 }
nengel@10	3404 }
nengel@10	3405 else
nengel@10	3406 {
nengel@10	3407 {
nengel@10	3408 imm_args.h = mcc_arg_61;
nengel@10	3409 imm_args.d = mcc_arg_62;
nengel@10	3410 imm_args.sbe = mcc_arg_63;
nengel@10	3411 imm_args.init = mcc_arg_64;
nengel@10	3412 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	3413 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3414 nanos_region_dimension_t dimensions_2[1] = { { sizeof(int), 0, sizeof(int) } };
nengel@10	3415 nanos_data_access_t dependences[3] = { { (void )mcc_arg_62, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_63, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_64, { 1, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	3416 ;
nengel@10	3417 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_13_t), &imm_args, 3, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3418 if (err != NANOS_OK)
nengel@10	3419 {
nengel@10	3420 nanos_handle_error(err);
nengel@10	3421 }
nengel@10	3422 }
nengel@10	3423 }
nengel@10	3424 }
nengel@10	3425 }
nengel@10	3426 }
nengel@10	3427 smbc = acquire_smbc(h);
nengel@10	3428 SuperMBTask *lastsmb = add_decode_slice_3dwave_tasks(rc[k % 2], &sbe[k % bufs], smbc);
nengel@10	3429 mcc_err_in_final_14 = nanos_in_final(&mcc_is_in_final_14);
nengel@10	3430 {
nengel@10	3431 H264Context *mcc_arg_65 = h;
nengel@10	3432 SuperMBContext *mcc_arg_66 = smbc;
nengel@10	3433 MBRecContext *mcc_arg_67 = rc[k % 2];
nengel@10	3434 SliceBufferEntry *mcc_arg_68 = &sbe[k % bufs];
nengel@10	3435 SuperMBTask *mcc_arg_69 = lastsmb;
nengel@10	3436 int *mcc_arg_70 = &release;
nengel@10	3437 if (mcc_is_in_final_14)
nengel@10	3438 {
nengel@10	3439 release_ref_list_task(h, smbc, rc[k % 2], &sbe[k % bufs], lastsmb, &release);
nengel@10	3440 }
nengel@10	3441 else
nengel@10	3442 {
nengel@9	3443 {
nengel@10	3444 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	3445 struct nanos_args_14_t *ol_args;
nengel@10	3446 nanos_err_t err;
nengel@10	3447 struct nanos_args_14_t imm_args;
nengel@10	3448 static nanos_smp_args_t smp_ol_release_ref_list_task_29_args = { .outline = (void ()(void ))(void ()(struct nanos_args_14_t ))&smp_ol_release_ref_list_task_29 };
nengel@10	3449 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_14_t), 0, 1, 0, "release_ref_list_task" }, { { &nanos_smp_factory, &smp_ol_release_ref_list_task_29_args } } };
nengel@10	3450 nanos_wd_dyn_props.tie_to = 0;
nengel@10	3451 nanos_wd_dyn_props.priority = 0;
nengel@10	3452 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	3453 ol_args = (struct nanos_args_14_t *)0;
nengel@10	3454 void nanos_wd_ = (void )0;
nengel@10	3455 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_14_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	3456 if (err != NANOS_OK)
nengel@10	3457 {
nengel@10	3458 nanos_handle_error(err);
nengel@10	3459 }
nengel@10	3460 /* Check pendant writes on subexpressions */
nengel@10	3461 /* End check pendant writes on subexpressions */
nengel@10	3462 if (nanos_wd_ != (void *)0)
nengel@10	3463 {
nengel@10	3464 {
nengel@10	3465 (*ol_args).h = mcc_arg_65;
nengel@10	3466 (*ol_args).smbc = mcc_arg_66;
nengel@10	3467 (*ol_args).d = mcc_arg_67;
nengel@10	3468 (*ol_args).sbe = mcc_arg_68;
nengel@10	3469 (*ol_args).lastsmb = mcc_arg_69;
nengel@10	3470 (*ol_args).release = mcc_arg_70;
nengel@10	3471 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	3472 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3473 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	3474 nanos_region_dimension_t dimensions_3[1] = { { sizeof(int), 0, sizeof(int) } };
nengel@10	3475 nanos_data_access_t dependences[4] = { { (void )mcc_arg_67, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_68, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void )mcc_arg_69, { 1, 0, 0, 0, 0 }, 1, dimensions_2, 0 }, { (void )mcc_arg_70, { 1, 1, 0, 0, 0 }, 1, dimensions_3, 0 } };
nengel@10	3476 ;
nengel@10	3477 err = nanos_submit(nanos_wd_, 4, dependences, (void *)0);
nengel@10	3478 if (err != NANOS_OK)
nengel@10	3479 {
nengel@10	3480 nanos_handle_error(err);
nengel@10	3481 }
nengel@10	3482 }
nengel@10	3483 }
nengel@10	3484 else
nengel@10	3485 {
nengel@10	3486 {
nengel@10	3487 imm_args.h = mcc_arg_65;
nengel@10	3488 imm_args.smbc = mcc_arg_66;
nengel@10	3489 imm_args.d = mcc_arg_67;
nengel@10	3490 imm_args.sbe = mcc_arg_68;
nengel@10	3491 imm_args.lastsmb = mcc_arg_69;
nengel@10	3492 imm_args.release = mcc_arg_70;
nengel@10	3493 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	3494 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3495 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } };
nengel@10	3496 nanos_region_dimension_t dimensions_3[1] = { { sizeof(int), 0, sizeof(int) } };
nengel@10	3497 nanos_data_access_t dependences[4] = { { (void )mcc_arg_67, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_68, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void )mcc_arg_69, { 1, 0, 0, 0, 0 }, 1, dimensions_2, 0 }, { (void )mcc_arg_70, { 1, 1, 0, 0, 0 }, 1, dimensions_3, 0 } };
nengel@10	3498 ;
nengel@10	3499 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_14_t), &imm_args, 4, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3500 if (err != NANOS_OK)
nengel@10	3501 {
nengel@10	3502 nanos_handle_error(err);
nengel@10	3503 }
nengel@10	3504 }
nengel@10	3505 }
nengel@9	3506 }
nengel@10	3507 }
nengel@10	3508 }
nengel@10	3509 mcc_err_in_final_15 = nanos_in_final(&mcc_is_in_final_15);
nengel@10	3510 {
nengel@10	3511 H264Context *mcc_arg_71 = h;
nengel@10	3512 OutputContext *mcc_arg_72 = oc;
nengel@10	3513 SliceBufferEntry *mcc_arg_73 = &sbe[k % bufs];
nengel@10	3514 if (mcc_is_in_final_15)
nengel@10	3515 {
nengel@10	3516 output_task(h, oc, &sbe[k % bufs]);
nengel@10	3517 }
nengel@10	3518 else
nengel@10	3519 {
nengel@9	3520 {
nengel@10	3521 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	3522 struct nanos_args_15_t *ol_args;
nengel@10	3523 nanos_err_t err;
nengel@10	3524 struct nanos_args_15_t imm_args;
nengel@10	3525 static nanos_smp_args_t smp_ol_output_task_31_args = { .outline = (void ()(void ))(void ()(struct nanos_args_15_t ))&smp_ol_output_task_31 };
nengel@10	3526 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_15_t), 0, 1, 0, "output_task" }, { { &nanos_smp_factory, &smp_ol_output_task_31_args } } };
nengel@10	3527 nanos_wd_dyn_props.tie_to = 0;
nengel@10	3528 nanos_wd_dyn_props.priority = 0;
nengel@10	3529 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	3530 ol_args = (struct nanos_args_15_t *)0;
nengel@10	3531 void nanos_wd_ = (void )0;
nengel@10	3532 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_15_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	3533 if (err != NANOS_OK)
nengel@10	3534 {
nengel@10	3535 nanos_handle_error(err);
nengel@10	3536 }
nengel@10	3537 /* Check pendant writes on subexpressions */
nengel@10	3538 /* End check pendant writes on subexpressions */
nengel@10	3539 if (nanos_wd_ != (void *)0)
nengel@10	3540 {
nengel@10	3541 {
nengel@10	3542 (*ol_args).h = mcc_arg_71;
nengel@10	3543 (*ol_args).oc = mcc_arg_72;
nengel@10	3544 (*ol_args).sbe = mcc_arg_73;
nengel@10	3545 nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } };
nengel@10	3546 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3547 nanos_data_access_t dependences[2] = { { (void )mcc_arg_72, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_73, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3548 ;
nengel@10	3549 err = nanos_submit(nanos_wd_, 2, dependences, (void *)0);
nengel@10	3550 if (err != NANOS_OK)
nengel@10	3551 {
nengel@10	3552 nanos_handle_error(err);
nengel@10	3553 }
nengel@10	3554 }
nengel@10	3555 }
nengel@10	3556 else
nengel@10	3557 {
nengel@10	3558 {
nengel@10	3559 imm_args.h = mcc_arg_71;
nengel@10	3560 imm_args.oc = mcc_arg_72;
nengel@10	3561 imm_args.sbe = mcc_arg_73;
nengel@10	3562 nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } };
nengel@10	3563 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3564 nanos_data_access_t dependences[2] = { { (void )mcc_arg_72, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_73, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3565 ;
nengel@10	3566 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_15_t), &imm_args, 2, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3567 if (err != NANOS_OK)
nengel@10	3568 {
nengel@10	3569 nanos_handle_error(err);
nengel@10	3570 }
nengel@10	3571 }
nengel@10	3572 }
nengel@9	3573 }
nengel@10	3574 }
nengel@10	3575 }
nengel@10	3576 }
nengel@10	3577 }
nengel@10	3578 }
nengel@10	3579 }
nengel@10	3580 else
nengel@10	3581 {
nengel@10	3582 {
nengel@10	3583 while ((!(pc).final_frame && frames++ < (h).num_frames) && !(*h).quit)
nengel@10	3584 {
nengel@10	3585 {
nengel@10	3586 nanos_err_t mcc_err_in_final_16;
nengel@10	3587 _Bool mcc_is_in_final_16;
nengel@10	3588 nanos_err_t mcc_err_in_final_17;
nengel@10	3589 _Bool mcc_is_in_final_17;
nengel@10	3590 nanos_err_t mcc_err_in_final_18;
nengel@10	3591 _Bool mcc_is_in_final_18;
nengel@10	3592 nanos_err_t mcc_err_in_final_19;
nengel@10	3593 _Bool mcc_is_in_final_19;
nengel@10	3594 mcc_err_in_final_16 = nanos_in_final(&mcc_is_in_final_16);
nengel@10	3595 {
nengel@10	3596 H264Context *mcc_arg_74 = h;
nengel@10	3597 ParserContext *mcc_arg_75 = pc;
nengel@10	3598 NalContext *mcc_arg_76 = nc;
nengel@10	3599 SliceBufferEntry *mcc_arg_77 = &sbe[k % bufs];
nengel@10	3600 if (mcc_is_in_final_16)
nengel@10	3601 {
nengel@10	3602 parse_task(h, pc, nc, &sbe[k % bufs]);
nengel@10	3603 }
nengel@10	3604 else
nengel@10	3605 {
nengel@10	3606 {
nengel@10	3607 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	3608 struct nanos_args_16_t *ol_args;
nengel@10	3609 nanos_err_t err;
nengel@10	3610 struct nanos_args_16_t imm_args;
nengel@10	3611 static nanos_smp_args_t smp_ol_parse_task_33_args = { .outline = (void ()(void ))(void ()(struct nanos_args_16_t ))&smp_ol_parse_task_33 };
nengel@10	3612 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_16_t), 0, 1, 0, "parse_task" }, { { &nanos_smp_factory, &smp_ol_parse_task_33_args } } };
nengel@10	3613 nanos_wd_dyn_props.tie_to = 0;
nengel@10	3614 nanos_wd_dyn_props.priority = 0;
nengel@10	3615 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	3616 ol_args = (struct nanos_args_16_t *)0;
nengel@10	3617 void nanos_wd_ = (void )0;
nengel@10	3618 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_16_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	3619 if (err != NANOS_OK)
nengel@10	3620 {
nengel@10	3621 nanos_handle_error(err);
nengel@10	3622 }
nengel@10	3623 /* Check pendant writes on subexpressions */
nengel@10	3624 /* End check pendant writes on subexpressions */
nengel@10	3625 if (nanos_wd_ != (void *)0)
nengel@10	3626 {
nengel@10	3627 {
nengel@10	3628 (*ol_args).h = mcc_arg_74;
nengel@10	3629 (*ol_args).pc = mcc_arg_75;
nengel@10	3630 (*ol_args).nc = mcc_arg_76;
nengel@10	3631 (*ol_args).sbe = mcc_arg_77;
nengel@10	3632 nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } };
nengel@10	3633 nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } };
nengel@10	3634 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3635 nanos_data_access_t dependences[3] = { { (void )mcc_arg_75, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_76, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_77, { 0, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	3636 ;
nengel@10	3637 err = nanos_submit(nanos_wd_, 3, dependences, (void *)0);
nengel@10	3638 if (err != NANOS_OK)
nengel@10	3639 {
nengel@10	3640 nanos_handle_error(err);
nengel@10	3641 }
nengel@10	3642 }
nengel@10	3643 }
nengel@10	3644 else
nengel@10	3645 {
nengel@10	3646 {
nengel@10	3647 imm_args.h = mcc_arg_74;
nengel@10	3648 imm_args.pc = mcc_arg_75;
nengel@10	3649 imm_args.nc = mcc_arg_76;
nengel@10	3650 imm_args.sbe = mcc_arg_77;
nengel@10	3651 nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } };
nengel@10	3652 nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } };
nengel@10	3653 nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3654 nanos_data_access_t dependences[3] = { { (void )mcc_arg_75, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_76, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 }, { (void *)mcc_arg_77, { 0, 1, 0, 0, 0 }, 1, dimensions_2, 0 } };
nengel@10	3655 ;
nengel@10	3656 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_16_t), &imm_args, 3, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3657 if (err != NANOS_OK)
nengel@10	3658 {
nengel@10	3659 nanos_handle_error(err);
nengel@10	3660 }
nengel@10	3661 }
nengel@10	3662 }
nengel@10	3663 }
nengel@10	3664 }
nengel@10	3665 }
nengel@10	3666 mcc_err_in_final_17 = nanos_in_final(&mcc_is_in_final_17);
nengel@10	3667 {
nengel@10	3668 H264Context *mcc_arg_78 = h;
nengel@10	3669 EntropyContext *mcc_arg_79 = ec[k % bufs];
nengel@10	3670 SliceBufferEntry *mcc_arg_80 = &sbe[k % bufs];
nengel@10	3671 if (mcc_is_in_final_17)
nengel@10	3672 {
nengel@10	3673 decode_slice_entropy_task(h, ec[k % bufs], &sbe[k % bufs]);
nengel@10	3674 }
nengel@10	3675 else
nengel@10	3676 {
nengel@10	3677 {
nengel@10	3678 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	3679 struct nanos_args_17_t *ol_args;
nengel@10	3680 nanos_err_t err;
nengel@10	3681 struct nanos_args_17_t imm_args;
nengel@10	3682 static nanos_smp_args_t smp_ol_decode_slice_entropy_task_35_args = { .outline = (void ()(void ))(void ()(struct nanos_args_17_t ))&smp_ol_decode_slice_entropy_task_35 };
nengel@10	3683 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_17_t), 0, 1, 0, "decode_slice_entropy_task" }, { { &nanos_smp_factory, &smp_ol_decode_slice_entropy_task_35_args } } };
nengel@10	3684 nanos_wd_dyn_props.tie_to = 0;
nengel@10	3685 nanos_wd_dyn_props.priority = 0;
nengel@10	3686 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	3687 ol_args = (struct nanos_args_17_t *)0;
nengel@10	3688 void nanos_wd_ = (void )0;
nengel@10	3689 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_17_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	3690 if (err != NANOS_OK)
nengel@10	3691 {
nengel@10	3692 nanos_handle_error(err);
nengel@10	3693 }
nengel@10	3694 /* Check pendant writes on subexpressions */
nengel@10	3695 /* End check pendant writes on subexpressions */
nengel@10	3696 if (nanos_wd_ != (void *)0)
nengel@10	3697 {
nengel@10	3698 {
nengel@10	3699 (*ol_args).h = mcc_arg_78;
nengel@10	3700 (*ol_args).ec = mcc_arg_79;
nengel@10	3701 (*ol_args).sbe = mcc_arg_80;
nengel@10	3702 nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } };
nengel@10	3703 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3704 nanos_data_access_t dependences[2] = { { (void )mcc_arg_79, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_80, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3705 ;
nengel@10	3706 err = nanos_submit(nanos_wd_, 2, dependences, (void *)0);
nengel@10	3707 if (err != NANOS_OK)
nengel@10	3708 {
nengel@10	3709 nanos_handle_error(err);
nengel@10	3710 }
nengel@10	3711 }
nengel@10	3712 }
nengel@10	3713 else
nengel@10	3714 {
nengel@10	3715 {
nengel@10	3716 imm_args.h = mcc_arg_78;
nengel@10	3717 imm_args.ec = mcc_arg_79;
nengel@10	3718 imm_args.sbe = mcc_arg_80;
nengel@10	3719 nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } };
nengel@10	3720 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3721 nanos_data_access_t dependences[2] = { { (void )mcc_arg_79, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_80, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3722 ;
nengel@10	3723 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_17_t), &imm_args, 2, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3724 if (err != NANOS_OK)
nengel@10	3725 {
nengel@10	3726 nanos_handle_error(err);
nengel@10	3727 }
nengel@10	3728 }
nengel@10	3729 }
nengel@10	3730 }
nengel@10	3731 }
nengel@10	3732 }
nengel@10	3733 mcc_err_in_final_18 = nanos_in_final(&mcc_is_in_final_18);
nengel@10	3734 {
nengel@10	3735 H264Context *mcc_arg_81 = h;
nengel@10	3736 MBRecContext *mcc_arg_82 = rc[0];
nengel@10	3737 SliceBufferEntry *mcc_arg_83 = &sbe[k % bufs];
nengel@10	3738 if (mcc_is_in_final_18)
nengel@10	3739 {
nengel@10	3740 decode_slice_mb_task(h, rc[0], &sbe[k % bufs]);
nengel@10	3741 }
nengel@10	3742 else
nengel@10	3743 {
nengel@10	3744 {
nengel@10	3745 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	3746 struct nanos_args_18_t *ol_args;
nengel@10	3747 nanos_err_t err;
nengel@10	3748 struct nanos_args_18_t imm_args;
nengel@10	3749 static nanos_smp_args_t smp_ol_decode_slice_mb_task_37_args = { .outline = (void ()(void ))(void ()(struct nanos_args_18_t ))&smp_ol_decode_slice_mb_task_37 };
nengel@10	3750 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_18_t), 0, 1, 0, "decode_slice_mb_task" }, { { &nanos_smp_factory, &smp_ol_decode_slice_mb_task_37_args } } };
nengel@10	3751 nanos_wd_dyn_props.tie_to = 0;
nengel@10	3752 nanos_wd_dyn_props.priority = 0;
nengel@10	3753 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	3754 ol_args = (struct nanos_args_18_t *)0;
nengel@10	3755 void nanos_wd_ = (void )0;
nengel@10	3756 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_18_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	3757 if (err != NANOS_OK)
nengel@10	3758 {
nengel@10	3759 nanos_handle_error(err);
nengel@10	3760 }
nengel@10	3761 /* Check pendant writes on subexpressions */
nengel@10	3762 /* End check pendant writes on subexpressions */
nengel@10	3763 if (nanos_wd_ != (void *)0)
nengel@10	3764 {
nengel@10	3765 {
nengel@10	3766 (*ol_args).h = mcc_arg_81;
nengel@10	3767 (*ol_args).d = mcc_arg_82;
nengel@10	3768 (*ol_args).sbe = mcc_arg_83;
nengel@10	3769 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	3770 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3771 nanos_data_access_t dependences[2] = { { (void )mcc_arg_82, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_83, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3772 ;
nengel@10	3773 err = nanos_submit(nanos_wd_, 2, dependences, (void *)0);
nengel@10	3774 if (err != NANOS_OK)
nengel@10	3775 {
nengel@10	3776 nanos_handle_error(err);
nengel@10	3777 }
nengel@10	3778 }
nengel@10	3779 }
nengel@10	3780 else
nengel@10	3781 {
nengel@10	3782 {
nengel@10	3783 imm_args.h = mcc_arg_81;
nengel@10	3784 imm_args.d = mcc_arg_82;
nengel@10	3785 imm_args.sbe = mcc_arg_83;
nengel@10	3786 nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } };
nengel@10	3787 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3788 nanos_data_access_t dependences[2] = { { (void )mcc_arg_82, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_83, { 1, 1, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3789 ;
nengel@10	3790 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_18_t), &imm_args, 2, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3791 if (err != NANOS_OK)
nengel@10	3792 {
nengel@10	3793 nanos_handle_error(err);
nengel@10	3794 }
nengel@10	3795 }
nengel@10	3796 }
nengel@10	3797 }
nengel@10	3798 }
nengel@10	3799 }
nengel@10	3800 mcc_err_in_final_19 = nanos_in_final(&mcc_is_in_final_19);
nengel@10	3801 {
nengel@10	3802 H264Context *mcc_arg_84 = h;
nengel@10	3803 OutputContext *mcc_arg_85 = oc;
nengel@10	3804 SliceBufferEntry *mcc_arg_86 = &sbe[k % bufs];
nengel@10	3805 if (mcc_is_in_final_19)
nengel@10	3806 {
nengel@10	3807 output_task(h, oc, &sbe[k % bufs]);
nengel@10	3808 }
nengel@10	3809 else
nengel@10	3810 {
nengel@10	3811 {
nengel@10	3812 nanos_wd_dyn_props_t nanos_wd_dyn_props;
nengel@10	3813 struct nanos_args_19_t *ol_args;
nengel@10	3814 nanos_err_t err;
nengel@10	3815 struct nanos_args_19_t imm_args;
nengel@10	3816 static nanos_smp_args_t smp_ol_output_task_39_args = { .outline = (void ()(void ))(void ()(struct nanos_args_19_t ))&smp_ol_output_task_39 };
nengel@10	3817 static struct nanos_const_wd_definition_1 nanos_wd_const_data = { { { 0, 1, 0, 0, 0, 0, 0, 0 }, __alignof__(struct nanos_args_19_t), 0, 1, 0, "output_task" }, { { &nanos_smp_factory, &smp_ol_output_task_39_args } } };
nengel@10	3818 nanos_wd_dyn_props.tie_to = 0;
nengel@10	3819 nanos_wd_dyn_props.priority = 0;
nengel@10	3820 nanos_wd_dyn_props.flags.is_final = 0;
nengel@10	3821 ol_args = (struct nanos_args_19_t *)0;
nengel@10	3822 void nanos_wd_ = (void )0;
nengel@10	3823 err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_19_t), (void )&ol_args, nanos_current_wd(), (nanos_copy_data_t )0, (nanos_region_dimension_internal_t **)0);
nengel@10	3824 if (err != NANOS_OK)
nengel@10	3825 {
nengel@10	3826 nanos_handle_error(err);
nengel@10	3827 }
nengel@10	3828 /* Check pendant writes on subexpressions */
nengel@10	3829 /* End check pendant writes on subexpressions */
nengel@10	3830 if (nanos_wd_ != (void *)0)
nengel@10	3831 {
nengel@10	3832 {
nengel@10	3833 (*ol_args).h = mcc_arg_84;
nengel@10	3834 (*ol_args).oc = mcc_arg_85;
nengel@10	3835 (*ol_args).sbe = mcc_arg_86;
nengel@10	3836 nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } };
nengel@10	3837 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3838 nanos_data_access_t dependences[2] = { { (void )mcc_arg_85, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_86, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3839 ;
nengel@10	3840 err = nanos_submit(nanos_wd_, 2, dependences, (void *)0);
nengel@10	3841 if (err != NANOS_OK)
nengel@10	3842 {
nengel@10	3843 nanos_handle_error(err);
nengel@10	3844 }
nengel@10	3845 }
nengel@10	3846 }
nengel@10	3847 else
nengel@10	3848 {
nengel@10	3849 {
nengel@10	3850 imm_args.h = mcc_arg_84;
nengel@10	3851 imm_args.oc = mcc_arg_85;
nengel@10	3852 imm_args.sbe = mcc_arg_86;
nengel@10	3853 nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } };
nengel@10	3854 nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } };
nengel@10	3855 nanos_data_access_t dependences[2] = { { (void )mcc_arg_85, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 }, { (void )mcc_arg_86, { 1, 0, 0, 0, 0 }, 1, dimensions_1, 0 } };
nengel@10	3856 ;
nengel@10	3857 err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_19_t), &imm_args, 2, dependences, (nanos_copy_data_t )0, (nanos_region_dimension_internal_t )0, (void ()(void , void *))0);
nengel@10	3858 if (err != NANOS_OK)
nengel@10	3859 {
nengel@10	3860 nanos_handle_error(err);
nengel@10	3861 }
nengel@10	3862 }
nengel@10	3863 }
nengel@10	3864 }
nengel@10	3865 }
nengel@10	3866 }
nengel@10	3867 {
nengel@10	3868 nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } };
nengel@10	3869 nanos_data_access_t dependences[1] = { { (void *)pc, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 } };
nengel@9	3870 ;
nengel@10	3871 nanos_err_t err = nanos_wait_on(1, dependences);
nengel@10	3872 if (err != NANOS_OK)
nengel@10	3873 {
nengel@10	3874 nanos_handle_error(err);
nengel@10	3875 }
nengel@10	3876 }
nengel@10	3877 k++;
nengel@9	3878 }
nengel@10	3879 }
nengel@10	3880 }
nengel@9	3881 }
nengel@10	3882 {
nengel@10	3883 nanos_err_t err;
nengel@10	3884 void *nanos_wd_ = nanos_current_wd();
nengel@10	3885 err = nanos_wg_wait_completion(nanos_wd_, 0);
nengel@10	3886 if (err != NANOS_OK)
nengel@10	3887 {
nengel@10	3888 nanos_handle_error(err);
nengel@10	3889 }
nengel@10	3890 }
nengel@10	3891 while ((out = output_frame(h, oc, (void )0, (h).ofile, (h).frame_width, (h).frame_height)))
nengel@9	3892 {
nengel@10	3893 ;
nengel@9	3894 }
nengel@10	3895 (h).num_frames = (oc).frame_number;
nengel@10	3896 free_parse_context(pc);
nengel@10	3897 free_nal_context(nc);
nengel@10	3898 free_output_context(oc);
nengel@10	3899 for (int i = 0; i < bufs; i++)
nengel@9	3900 {
nengel@10	3901 {
nengel@9	3902 free_sb_entry(&sbe[i]);
nengel@9	3903 free_entropy_context(ec[i]);
nengel@10	3904 }
nengel@9	3905 }
nengel@10	3906 av_free(sbe);
nengel@10	3907 for (int i = 0; i < 2; i++)
nengel@9	3908 {
nengel@10	3909 {
nengel@9	3910 free_mbrec_context(rc[i]);
nengel@10	3911 }
nengel@9	3912 }
nengel@10	3913 return 0;
nengel@9	3914 }
nengel@10	3915 static void smp_ol_decode_super_mb_task_1_unpacked(MBRecContext const d, SliceBufferEntry const sbe, SuperMBContext const smbc, SuperMBTask const ml, SuperMBTask const mur, SuperMBTask const m)
nengel@10	3916 {
nengel@10	3917 {
nengel@10	3918 decode_super_mb_task((d), (sbe), (smbc), (ml), (mur), (m));
nengel@10	3919 }
nengel@10	3920 }
nengel@10	3921 static void smp_ol_decode_super_mb_task_1(struct nanos_args_0_t *const args)
nengel@10	3922 {
nengel@10	3923 {
nengel@10	3924 smp_ol_decode_super_mb_task_1_unpacked(&((args).d), &((args).sbe), &((args).smbc), &((args).ml), &((args).mur), &((args).m));
nengel@10	3925 }
nengel@10	3926 }
nengel@10	3927 static void smp_ol_draw_edges_task_3_unpacked(MBRecContext const d, SliceBufferEntry const sbe, SuperMBContext const smbc, SuperMBTask const sm, int *const line)
nengel@10	3928 {
nengel@10	3929 {
nengel@10	3930 draw_edges_task((d), (sbe), (smbc), (sm), (*line));
nengel@10	3931 }
nengel@10	3932 }
nengel@10	3933 static void smp_ol_draw_edges_task_3(struct nanos_args_1_t *const args)
nengel@10	3934 {
nengel@10	3935 {
nengel@10	3936 smp_ol_draw_edges_task_3_unpacked(&((args).d), &((args).sbe), &((args).smbc), &((args).sm), &((*args).line));
nengel@10	3937 }
nengel@10	3938 }
nengel@10	3939 static void smp_ol_decode_3dwave_super_mb_task_5_unpacked(MBRecContext const d, SliceBufferEntry const sbe, SuperMBContext const smbc, SuperMBTask const ml, SuperMBTask const mur, SuperMBTask const mprev, SuperMBTask **const m)
nengel@10	3940 {
nengel@10	3941 {
nengel@10	3942 decode_3dwave_super_mb_task((d), (sbe), (smbc), (ml), (mur), (mprev), (*m));
nengel@10	3943 }
nengel@10	3944 }
nengel@10	3945 static void smp_ol_decode_3dwave_super_mb_task_5(struct nanos_args_2_t *const args)
nengel@10	3946 {
nengel@10	3947 {
nengel@10	3948 smp_ol_decode_3dwave_super_mb_task_5_unpacked(&((args).d), &((args).sbe), &((args).smbc), &((args).ml), &((args).mur), &((args).mprev), &((*args).m));
nengel@10	3949 }
nengel@10	3950 }
nengel@10	3951 static void smp_ol_draw_edges_task_7_unpacked(MBRecContext const d, SliceBufferEntry const sbe, SuperMBContext const smbc, SuperMBTask const sm, int *const line)
nengel@10	3952 {
nengel@10	3953 {
nengel@10	3954 draw_edges_task((d), (sbe), (smbc), (sm), (*line));
nengel@10	3955 }
nengel@10	3956 }
nengel@10	3957 static void smp_ol_draw_edges_task_7(struct nanos_args_3_t *const args)
nengel@10	3958 {
nengel@10	3959 {
nengel@10	3960 smp_ol_draw_edges_task_7_unpacked(&((args).d), &((args).sbe), &((args).smbc), &((args).sm), &((*args).line));
nengel@10	3961 }
nengel@10	3962 }
nengel@10	3963 static void smp_ol_decode_super_mb_task_9_unpacked(MBRecContext const d, SliceBufferEntry const sbe, SuperMBContext const smbc, SuperMBTask const ml, SuperMBTask const mur, SuperMBTask const m)
nengel@10	3964 {
nengel@10	3965 {
nengel@10	3966 decode_super_mb_task((d), (sbe), (smbc), (ml), (mur), (m));
nengel@10	3967 }
nengel@10	3968 }
nengel@10	3969 static void smp_ol_decode_super_mb_task_9(struct nanos_args_4_t *const args)
nengel@10	3970 {
nengel@10	3971 {
nengel@10	3972 smp_ol_decode_super_mb_task_9_unpacked(&((args).d), &((args).sbe), &((args).smbc), &((args).ml), &((args).mur), &((args).m));
nengel@10	3973 }
nengel@10	3974 }
nengel@10	3975 static void smp_ol_draw_edges_task_11_unpacked(MBRecContext const d, SliceBufferEntry const sbe, SuperMBContext const smbc, SuperMBTask const sm, int *const line)
nengel@10	3976 {
nengel@10	3977 {
nengel@10	3978 draw_edges_task((d), (sbe), (smbc), (sm), (*line));
nengel@10	3979 }
nengel@10	3980 }
nengel@10	3981 static void smp_ol_draw_edges_task_11(struct nanos_args_5_t *const args)
nengel@10	3982 {
nengel@10	3983 {
nengel@10	3984 smp_ol_draw_edges_task_11_unpacked(&((args).d), &((args).sbe), &((args).smbc), &((args).sm), &((*args).line));
nengel@10	3985 }
nengel@10	3986 }
nengel@10	3987 static void smp_ol_parse_task_13_unpacked(H264Context const h, ParserContext const pc, NalContext const nc, SliceBufferEntry const sbe)
nengel@10	3988 {
nengel@10	3989 {
nengel@10	3990 parse_task((h), (pc), (nc), (sbe));
nengel@10	3991 }
nengel@10	3992 }
nengel@10	3993 static void smp_ol_parse_task_13(struct nanos_args_6_t *const args)
nengel@10	3994 {
nengel@10	3995 {
nengel@10	3996 smp_ol_parse_task_13_unpacked(&((args).h), &((args).pc), &((args).nc), &((args).sbe));
nengel@10	3997 }
nengel@10	3998 }
nengel@10	3999 static void smp_ol_decode_slice_entropy_task_15_unpacked(H264Context const h, EntropyContext const ec, SliceBufferEntry **const sbe)
nengel@10	4000 {
nengel@10	4001 {
nengel@10	4002 decode_slice_entropy_task((h), (ec), (*sbe));
nengel@10	4003 }
nengel@10	4004 }
nengel@10	4005 static void smp_ol_decode_slice_entropy_task_15(struct nanos_args_7_t *const args)
nengel@10	4006 {
nengel@10	4007 {
nengel@10	4008 smp_ol_decode_slice_entropy_task_15_unpacked(&((args).h), &((args).ec), &((*args).sbe));
nengel@10	4009 }
nengel@10	4010 }
nengel@10	4011 static void smp_ol_parse_task_17_unpacked(H264Context const h, ParserContext const pc, NalContext const nc, SliceBufferEntry const sbe)
nengel@10	4012 {
nengel@10	4013 {
nengel@10	4014 parse_task((h), (pc), (nc), (sbe));
nengel@10	4015 }
nengel@10	4016 }
nengel@10	4017 static void smp_ol_parse_task_17(struct nanos_args_8_t *const args)
nengel@10	4018 {
nengel@10	4019 {
nengel@10	4020 smp_ol_parse_task_17_unpacked(&((args).h), &((args).pc), &((args).nc), &((args).sbe));
nengel@10	4021 }
nengel@10	4022 }
nengel@10	4023 static void smp_ol_decode_slice_entropy_task_19_unpacked(H264Context const h, EntropyContext const ec, SliceBufferEntry **const sbe)
nengel@10	4024 {
nengel@10	4025 {
nengel@10	4026 decode_slice_entropy_task((h), (ec), (*sbe));
nengel@10	4027 }
nengel@10	4028 }
nengel@10	4029 static void smp_ol_decode_slice_entropy_task_19(struct nanos_args_9_t *const args)
nengel@10	4030 {
nengel@10	4031 {
nengel@10	4032 smp_ol_decode_slice_entropy_task_19_unpacked(&((args).h), &((args).ec), &((*args).sbe));
nengel@10	4033 }
nengel@10	4034 }
nengel@10	4035 static void smp_ol_init_ref_list_and_get_dpb_task_21_unpacked(H264Context const h, MBRecContext const d, SliceBufferEntry const sbe, int const init)
nengel@10	4036 {
nengel@10	4037 {
nengel@10	4038 init_ref_list_and_get_dpb_task((h), (d), (sbe), (init));
nengel@10	4039 }
nengel@10	4040 }
nengel@10	4041 static void smp_ol_init_ref_list_and_get_dpb_task_21(struct nanos_args_10_t *const args)
nengel@10	4042 {
nengel@10	4043 {
nengel@10	4044 smp_ol_init_ref_list_and_get_dpb_task_21_unpacked(&((args).h), &((args).d), &((args).sbe), &((args).init));
nengel@10	4045 }
nengel@10	4046 }
nengel@10	4047 static void smp_ol_release_ref_list_task_23_unpacked(H264Context const h, SuperMBContext const smbc, MBRecContext const d, SliceBufferEntry const sbe, SuperMBTask const lastsmb, int const release)
nengel@10	4048 {
nengel@10	4049 {
nengel@10	4050 release_ref_list_task((h), (smbc), (d), (sbe), (lastsmb), (release));
nengel@10	4051 }
nengel@10	4052 }
nengel@10	4053 static void smp_ol_release_ref_list_task_23(struct nanos_args_11_t *const args)
nengel@10	4054 {
nengel@10	4055 {
nengel@10	4056 smp_ol_release_ref_list_task_23_unpacked(&((args).h), &((args).smbc), &((args).d), &((args).sbe), &((args).lastsmb), &((args).release));
nengel@10	4057 }
nengel@10	4058 }
nengel@10	4059 static void smp_ol_output_task_25_unpacked(H264Context const h, OutputContext const oc, SliceBufferEntry **const sbe)
nengel@10	4060 {
nengel@10	4061 {
nengel@10	4062 output_task((h), (oc), (*sbe));
nengel@10	4063 }
nengel@10	4064 }
nengel@10	4065 static void smp_ol_output_task_25(struct nanos_args_12_t *const args)
nengel@10	4066 {
nengel@10	4067 {
nengel@10	4068 smp_ol_output_task_25_unpacked(&((args).h), &((args).oc), &((*args).sbe));
nengel@10	4069 }
nengel@10	4070 }
nengel@10	4071 static void smp_ol_init_ref_list_and_get_dpb_task_27_unpacked(H264Context const h, MBRecContext const d, SliceBufferEntry const sbe, int const init)
nengel@10	4072 {
nengel@10	4073 {
nengel@10	4074 init_ref_list_and_get_dpb_task((h), (d), (sbe), (init));
nengel@10	4075 }
nengel@10	4076 }
nengel@10	4077 static void smp_ol_init_ref_list_and_get_dpb_task_27(struct nanos_args_13_t *const args)
nengel@10	4078 {
nengel@10	4079 {
nengel@10	4080 smp_ol_init_ref_list_and_get_dpb_task_27_unpacked(&((args).h), &((args).d), &((args).sbe), &((args).init));
nengel@10	4081 }
nengel@10	4082 }
nengel@10	4083 static void smp_ol_release_ref_list_task_29_unpacked(H264Context const h, SuperMBContext const smbc, MBRecContext const d, SliceBufferEntry const sbe, SuperMBTask const lastsmb, int const release)
nengel@10	4084 {
nengel@10	4085 {
nengel@10	4086 release_ref_list_task((h), (smbc), (d), (sbe), (lastsmb), (release));
nengel@10	4087 }
nengel@10	4088 }
nengel@10	4089 static void smp_ol_release_ref_list_task_29(struct nanos_args_14_t *const args)
nengel@10	4090 {
nengel@10	4091 {
nengel@10	4092 smp_ol_release_ref_list_task_29_unpacked(&((args).h), &((args).smbc), &((args).d), &((args).sbe), &((args).lastsmb), &((args).release));
nengel@10	4093 }
nengel@10	4094 }
nengel@10	4095 static void smp_ol_output_task_31_unpacked(H264Context const h, OutputContext const oc, SliceBufferEntry **const sbe)
nengel@10	4096 {
nengel@10	4097 {
nengel@10	4098 output_task((h), (oc), (*sbe));
nengel@10	4099 }
nengel@10	4100 }
nengel@10	4101 static void smp_ol_output_task_31(struct nanos_args_15_t *const args)
nengel@10	4102 {
nengel@10	4103 {
nengel@10	4104 smp_ol_output_task_31_unpacked(&((args).h), &((args).oc), &((*args).sbe));
nengel@10	4105 }
nengel@10	4106 }
nengel@10	4107 static void smp_ol_parse_task_33_unpacked(H264Context const h, ParserContext const pc, NalContext const nc, SliceBufferEntry const sbe)
nengel@10	4108 {
nengel@10	4109 {
nengel@10	4110 parse_task((h), (pc), (nc), (sbe));
nengel@10	4111 }
nengel@10	4112 }
nengel@10	4113 static void smp_ol_parse_task_33(struct nanos_args_16_t *const args)
nengel@10	4114 {
nengel@10	4115 {
nengel@10	4116 smp_ol_parse_task_33_unpacked(&((args).h), &((args).pc), &((args).nc), &((args).sbe));
nengel@10	4117 }
nengel@10	4118 }
nengel@10	4119 static void smp_ol_decode_slice_entropy_task_35_unpacked(H264Context const h, EntropyContext const ec, SliceBufferEntry **const sbe)
nengel@10	4120 {
nengel@10	4121 {
nengel@10	4122 decode_slice_entropy_task((h), (ec), (*sbe));
nengel@10	4123 }
nengel@10	4124 }
nengel@10	4125 static void smp_ol_decode_slice_entropy_task_35(struct nanos_args_17_t *const args)
nengel@10	4126 {
nengel@10	4127 {
nengel@10	4128 smp_ol_decode_slice_entropy_task_35_unpacked(&((args).h), &((args).ec), &((*args).sbe));
nengel@10	4129 }
nengel@10	4130 }
nengel@10	4131 static void smp_ol_decode_slice_mb_task_37_unpacked(H264Context const h, MBRecContext const d, SliceBufferEntry **const sbe)
nengel@10	4132 {
nengel@10	4133 {
nengel@10	4134 decode_slice_mb_task((h), (d), (*sbe));
nengel@10	4135 }
nengel@10	4136 }
nengel@10	4137 static void smp_ol_decode_slice_mb_task_37(struct nanos_args_18_t *const args)
nengel@10	4138 {
nengel@10	4139 {
nengel@10	4140 smp_ol_decode_slice_mb_task_37_unpacked(&((args).h), &((args).d), &((*args).sbe));
nengel@10	4141 }
nengel@10	4142 }
nengel@10	4143 static void smp_ol_output_task_39_unpacked(H264Context const h, OutputContext const oc, SliceBufferEntry **const sbe)
nengel@10	4144 {
nengel@10	4145 {
nengel@10	4146 output_task((h), (oc), (*sbe));
nengel@10	4147 }
nengel@10	4148 }
nengel@10	4149 static void smp_ol_output_task_39(struct nanos_args_19_t *const args)
nengel@10	4150 {
nengel@10	4151 {
nengel@10	4152 smp_ol_output_task_39_unpacked(&((args).h), &((args).oc), &((*args).sbe));
nengel@10	4153 }
nengel@10	4154 }
nengel@10	4155 typedef void nanos_init_func_t(void *);
nengel@10	4156 struct mcc_struct_anon_22
nengel@10	4157 {
nengel@10	4158 void (func)(void );
nengel@10	4159 void *data;
nengel@9	4160 };
nengel@10	4161 typedef struct mcc_struct_anon_22 nanos_init_desc_t;
nengel@10	4162 void nanos_omp_set_interface(void *);
nengel@10	4163 __attribute__((weak)) __attribute__((section("nanos_init"))) nanos_init_desc_t __section__nanos_init = { nanos_omp_set_interface, (void *)0 };

Mercurial > cgi-bin > hgwebdir.cgi > PR > Applications > VSs > VSs__H264__App

annotate libavcodec/sscc_h264_ompss.c @ 10:4d1f82230449

Mercurial > cgi-bin > hgwebdir.cgi > PR > Applications > VSs > VSsH264App