typedef unsigned int uint32_t; static __inline __attribute__((always_inline)) uint32_t pack16to32(int a, int b) { return (a & 65535) + (b << 16); } typedef unsigned short int uint16_t; static __inline __attribute__((always_inline)) uint16_t pack8to16(int a, int b) { return (a & 255) + (b << 8); } struct CABACContext; typedef struct CABACContext CABACContext; typedef unsigned char uint8_t; struct CABACContext { int low; int range; int outstanding_count; const uint8_t *bytestream_start; const uint8_t *bytestream; const uint8_t *bytestream_end; uint8_t cabac_state[460]; }; static void refill(CABACContext *c) { (*c).low += ((*c).bytestream[0] << 9) + ((*c).bytestream[1] << 1); (*c).low -= (1 << 16) - 1; (*c).bytestream += 16 / 8; } extern const uint8_t ff_h264_norm_shift[512]; static void refill2(CABACContext *c) { int x; int i; x = (*c).low ^ ((*c).low - 1); i = 7 - ff_h264_norm_shift[x >> (16 - 1)]; x = -((1 << 16) - 1); x += ((*c).bytestream[0] << 9) + ((*c).bytestream[1] << 1); (*c).low += x << i; (*c).bytestream += 16 / 8; } static __inline void renorm_cabac_decoder(CABACContext *c) { while ((*c).range < 256) { { (*c).range += (*c).range; (*c).low += (*c).low; if (!((*c).low & ((1 << 16) - 1))) { refill(c); } } } } static __inline void renorm_cabac_decoder_once(CABACContext *c) { int shift = (uint32_t)((*c).range - 256) >> 31; (*c).range <<= shift; (*c).low <<= shift; if (!((*c).low & ((1 << 16) - 1))) { refill(c); } } extern uint8_t ff_h264_lps_range[512]; extern uint8_t ff_h264_mlps_state[256]; static __inline __attribute__((always_inline)) int get_cabac_inline(CABACContext *c, uint8_t *const state) { __attribute__((unused)) int lps_mask; int bit; int s = *state; int RangeLPS = ff_h264_lps_range[2 * ((*c).range & 192) + s]; (*c).range -= RangeLPS; lps_mask = (((*c).range << (16 + 1)) - (*c).low) >> 31; (*c).low -= (*c).range << (16 + 1) & lps_mask; (*c).range += (RangeLPS - (*c).range) & lps_mask; s ^= lps_mask; *state = (ff_h264_mlps_state + 128)[s]; bit = s & 1; lps_mask = ff_h264_norm_shift[(*c).range]; (*c).range <<= lps_mask; (*c).low <<= lps_mask; if (!((*c).low & ((1 << 16) - 1))) { refill2(c); } return bit; } static __attribute__((noinline)) __attribute__((unused)) int get_cabac_noinline(CABACContext *c, uint8_t *const state) { return get_cabac_inline(c, state); } static __attribute__((unused)) int get_cabac(CABACContext *c, uint8_t *const state) { return get_cabac_inline(c, state); } static __attribute__((unused)) int get_cabac_bypass(CABACContext *c) { int range; (*c).low += (*c).low; if (!((*c).low & ((1 << 16) - 1))) { refill(c); } range = (*c).range << (16 + 1); if ((*c).low < range) { { return 0; } } else { { (*c).low -= range; return 1; } } } static __inline __attribute__((always_inline)) int get_cabac_bypass_sign(CABACContext *c, int val) { int range; int mask; (*c).low += (*c).low; if (!((*c).low & ((1 << 16) - 1))) { refill(c); } range = (*c).range << (16 + 1); (*c).low -= range; mask = (*c).low >> 31; range &= mask; (*c).low += range; return (val ^ mask) - mask; } static __attribute__((unused)) int get_cabac_terminate(CABACContext *c) { (*c).range -= 2; if ((*c).low < (*c).range << (16 + 1)) { { renorm_cabac_decoder_once(c); return 0; } } else { { return (*c).bytestream - (*c).bytestream_start; } } } static __inline __attribute__((always_inline)) __attribute__((const)) uint16_t bswap_16(uint16_t x) { __asm__ ("rorw $8, %0" : "+r"(x) : ); return x; } static __inline __attribute__((always_inline)) __attribute__((const)) uint32_t bswap_32(uint32_t x) { __asm__ ("bswap %0" : "+r"(x) : ); return x; } typedef unsigned long int uint64_t; static __inline __attribute__((const)) uint64_t bswap_64(uint64_t x) { __asm__ ("bswap %0" : "=r"(x) : "0"(x)); return x; } extern const uint8_t ff_log2_tab[256]; static __inline __attribute__((const)) int av_log2_c(unsigned int v) { int n = 0; if (v & 4294901760U) { { v >>= 16; n += 16; } } if (v & 65280) { { v >>= 8; n += 8; } } n += ff_log2_tab[v]; return n; } static __inline __attribute__((const)) int av_log2_16bit_c(unsigned int v) { int n = 0; if (v & 65280) { { v >>= 8; n += 8; } } n += ff_log2_tab[v]; return n; } static __inline __attribute__((const)) int av_clip(int a, int amin, int amax) { if (a < amin) { return amin; } else { if (a > amax) { return amax; } else { return a; } } } static __inline __attribute__((const)) uint8_t av_clip_uint8(int a) { if (a & ~255) { return -a >> 31; } else { return a; } } static __inline __attribute__((const)) uint16_t av_clip_uint16(int a) { if (a & ~65535) { return -a >> 31; } else { return a; } } typedef short int int16_t; static __inline __attribute__((const)) int16_t av_clip_int16(int a) { if ((a + 32768) & ~65535) { return a >> 31 ^ 32767; } else { return a; } } typedef int int32_t; typedef long int int64_t; static __inline __attribute__((const)) int32_t av_clipl_int32(int64_t a) { if ((a + 2147483648U) & ~4294967295LU) { return a >> 63 ^ 2147483647; } else { return a; } } static __inline __attribute__((const)) float av_clipf(float a, float amin, float amax) { if (a < amin) { return amin; } else { if (a > amax) { return amax; } else { return a; } } } static __inline __attribute__((const)) int av_ceil_log2(int x) { return av_log2_c((x - 1) << 1); } static __inline __attribute__((always_inline)) void AV_COPY64(void *d, const void *s) { __asm__ ("movq %1, %%mm0 \n\t""movq %%mm0, %0 \n\t" : "=m"(*((uint64_t *)d)) : "m"(*((const uint64_t *)s)) : "mm0"); } static __inline __attribute__((always_inline)) void AV_SWAP64(void *a, void *b) { __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"); } static __inline __attribute__((always_inline)) void AV_ZERO64(void *d) { __asm__ ("pxor %%mm0, %%mm0 \n\t""movq %%mm0, %0 \n\t" : "=m"(*((uint64_t *)d)) : : "mm0"); } static __inline __attribute__((always_inline)) void AV_COPY128(void *d, const void *s) { struct v; struct v { uint64_t v[2]; }; __asm__ ("movaps %1, %%xmm0 \n\t""movaps %%xmm0, %0 \n\t" : "=m"(*((struct v *)d)) : "m"(*((const struct v *)s)) : "xmm0"); } static __inline __attribute__((always_inline)) void AV_ZERO128(void *d) { struct v; struct v { uint64_t v[2]; }; __asm__ ("pxor %%xmm0, %%xmm0 \n\t""movdqa %%xmm0, %0 \n\t" : "=m"(*((struct v *)d)) : : "xmm0"); } static __inline uint32_t rnd_avg32(uint32_t a, uint32_t b) { return (a | b) - (((a ^ b) & ~(1 * 16843009LU)) >> 1); } static __inline uint32_t no_rnd_avg32(uint32_t a, uint32_t b) { return (a & b) + (((a ^ b) & ~(1 * 16843009LU)) >> 1); } static __inline void emms(void) { __asm__ volatile("emms;" : : : "memory"); } static __inline void copy_block2(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h) { int i; for (i = 0; i < h; i++) { { do { { ((uint8_t *)dst)[0] = ((const uint8_t *)src)[1] << 8 | ((const uint8_t *)src)[0]; ((uint8_t *)dst)[1] = (((const uint8_t *)src)[1] << 8 | ((const uint8_t *)src)[0]) >> 8; } } while (0); dst += dstStride; src += srcStride; } } } static __inline void copy_block4(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h) { int i; for (i = 0; i < h; i++) { { do { { ((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]; ((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; ((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; ((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; } } while (0); dst += dstStride; src += srcStride; } } } static __inline void copy_block8(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h) { int i; for (i = 0; i < h; i++) { { do { { ((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]; ((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; ((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; ((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; } } while (0); do { { ((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]; ((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; ((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; ((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; } } while (0); dst += dstStride; src += srcStride; } } } static __inline void copy_block9(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h) { int i; for (i = 0; i < h; i++) { { do { { ((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]; ((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; ((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; ((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; } } while (0); do { { ((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]; ((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; ((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; ((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; } } while (0); dst[8] = src[8]; dst += dstStride; src += srcStride; } } } static __inline void copy_block16(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h) { int i; for (i = 0; i < h; i++) { { do { { ((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]; ((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; ((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; ((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; } } while (0); do { { ((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]; ((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; ((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; ((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; } } while (0); do { { ((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]; ((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; ((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; ((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; } } while (0); do { { ((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]; ((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; ((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; ((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; } } while (0); dst += dstStride; src += srcStride; } } } static __inline void copy_block17(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h) { int i; for (i = 0; i < h; i++) { { do { { ((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]; ((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; ((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; ((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; } } while (0); do { { ((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]; ((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; ((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; ((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; } } while (0); do { { ((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]; ((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; ((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; ((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; } } while (0); do { { ((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]; ((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; ((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; ((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; } } while (0); dst[16] = src[16]; dst += dstStride; src += srcStride; } } } static __inline uint64_t read_time(void) { uint32_t a; uint32_t d; __asm__ volatile("rdtsc" : "=a"(a), "=d"(d) : ); return ((uint64_t)d << 32) + a; } typedef signed char int8_t; static __inline int32_t NEG_SSR32(int32_t a, int8_t s) { __asm__ ("sarl %1, %0\n\t" : "+r"(a) : "ic"((uint8_t) -s)); return a; } static __inline uint32_t NEG_USR32(uint32_t a, int8_t s) { __asm__ ("shrl %1, %0\n\t" : "+r"(a) : "ic"((uint8_t) -s)); return a; } static __inline __attribute__((always_inline)) int MULH(int a, int b) { return (int64_t)a * (int64_t)b >> 32; } static __inline __attribute__((always_inline)) unsigned int UMULH(unsigned int a, unsigned int b) { return (uint64_t)a * (uint64_t)b >> 32; } static __inline __attribute__((const)) int mid_pred(int a, int b, int c) { if (a > b) { { if (c > b) { { if (c > a) { b = a; } else { b = c; } } } } } else { { if (b > c) { { if (c > a) { b = c; } else { b = a; } } } } } return b; } static __inline __attribute__((const)) int sign_extend(int val, unsigned int bits) { return val << (8 * sizeof(int) - bits) >> (8 * sizeof(int) - bits); } static __inline __attribute__((const)) unsigned int zero_extend(unsigned int val, unsigned int bits) { return val << (8 * sizeof(int) - bits) >> (8 * sizeof(int) - bits); } struct GetBitContext; typedef struct GetBitContext GetBitContext; struct GetBitContext { uint8_t *rbsp; unsigned int rbsp_size; uint8_t *raw; const uint8_t *buffer; const uint8_t *buffer_end; unsigned int alloc_size; unsigned int buf_size; uint32_t *buffer_ptr; uint32_t cache0; uint32_t cache1; int bit_count; int size_in_bits; }; static __inline int get_bits_count(const GetBitContext *s) { return ((uint8_t *)(*s).buffer_ptr - (*s).buffer) * 8 - 32 + (*s).bit_count; } static __inline void skip_bits_long(GetBitContext *s, int n) { int re_bit_count = (*s).bit_count; uint32_t re_cache0 = (*s).cache0; uint32_t re_cache1 = (*s).cache1; uint32_t *re_buffer_ptr = (*s).buffer_ptr; re_bit_count += n; re_buffer_ptr += re_bit_count >> 5; re_bit_count &= 31; re_cache0 = bswap_32(re_buffer_ptr[ -1]) << re_bit_count; re_cache1 = 0; if (re_bit_count > 0) { { const uint32_t next = bswap_32(*re_buffer_ptr); re_cache0 |= NEG_USR32(next, re_bit_count); re_cache1 |= next << re_bit_count; re_buffer_ptr++; re_bit_count -= 32; } } (*s).bit_count = re_bit_count; (*s).cache0 = re_cache0; (*s).cache1 = re_cache1; (*s).buffer_ptr = re_buffer_ptr; } static __inline int get_xbits(GetBitContext *s, int n) { register int32_t cache; register int sign; int re_bit_count = (*s).bit_count; uint32_t re_cache0 = (*s).cache0; uint32_t re_cache1 = (*s).cache1; uint32_t *re_buffer_ptr = (*s).buffer_ptr; if (re_bit_count > 0) { { const uint32_t next = bswap_32(*re_buffer_ptr); re_cache0 |= NEG_USR32(next, re_bit_count); re_cache1 |= next << re_bit_count; re_buffer_ptr++; re_bit_count -= 32; } } cache = re_cache0; sign = ~cache >> 31; { __asm__ ("shldl %2, %1, %0 \n\t""shll %2, %1 \n\t" : "+r"(re_cache0), "+r"(re_cache1) : "Ic"((uint8_t)n)); re_bit_count += n; } (*s).bit_count = re_bit_count; (*s).cache0 = re_cache0; (*s).cache1 = re_cache1; (*s).buffer_ptr = re_buffer_ptr; return (NEG_USR32(sign ^ cache, n) ^ sign) - sign; } static __inline int get_sbits(GetBitContext *s, int n) { register int tmp; int re_bit_count = (*s).bit_count; uint32_t re_cache0 = (*s).cache0; uint32_t re_cache1 = (*s).cache1; uint32_t *re_buffer_ptr = (*s).buffer_ptr; if (re_bit_count > 0) { { const uint32_t next = bswap_32(*re_buffer_ptr); re_cache0 |= NEG_USR32(next, re_bit_count); re_cache1 |= next << re_bit_count; re_buffer_ptr++; re_bit_count -= 32; } } tmp = NEG_SSR32(re_cache0, n); { __asm__ ("shldl %2, %1, %0 \n\t""shll %2, %1 \n\t" : "+r"(re_cache0), "+r"(re_cache1) : "Ic"((uint8_t)n)); re_bit_count += n; } (*s).bit_count = re_bit_count; (*s).cache0 = re_cache0; (*s).cache1 = re_cache1; (*s).buffer_ptr = re_buffer_ptr; return tmp; } static __inline unsigned int get_bits(GetBitContext *s, int n) { register int tmp; int re_bit_count = (*s).bit_count; uint32_t re_cache0 = (*s).cache0; uint32_t re_cache1 = (*s).cache1; uint32_t *re_buffer_ptr = (*s).buffer_ptr; if (re_bit_count > 0) { { const uint32_t next = bswap_32(*re_buffer_ptr); re_cache0 |= NEG_USR32(next, re_bit_count); re_cache1 |= next << re_bit_count; re_buffer_ptr++; re_bit_count -= 32; } } tmp = NEG_USR32(re_cache0, n); { __asm__ ("shldl %2, %1, %0 \n\t""shll %2, %1 \n\t" : "+r"(re_cache0), "+r"(re_cache1) : "Ic"((uint8_t)n)); re_bit_count += n; } (*s).bit_count = re_bit_count; (*s).cache0 = re_cache0; (*s).cache1 = re_cache1; (*s).buffer_ptr = re_buffer_ptr; return tmp; } static __inline unsigned int show_bits(GetBitContext *s, int n) { register int tmp; int re_bit_count = (*s).bit_count; uint32_t re_cache0 = (*s).cache0; uint32_t re_cache1 = (*s).cache1; uint32_t *re_buffer_ptr = (*s).buffer_ptr; if (re_bit_count > 0) { { const uint32_t next = bswap_32(*re_buffer_ptr); re_cache0 |= NEG_USR32(next, re_bit_count); re_cache1 |= next << re_bit_count; re_buffer_ptr++; re_bit_count -= 32; } } tmp = NEG_USR32(re_cache0, n); return tmp; } static __inline void skip_bits(GetBitContext *s, int n) { int re_bit_count = (*s).bit_count; uint32_t re_cache0 = (*s).cache0; uint32_t re_cache1 = (*s).cache1; uint32_t *re_buffer_ptr = (*s).buffer_ptr; if (re_bit_count > 0) { { const uint32_t next = bswap_32(*re_buffer_ptr); re_cache0 |= NEG_USR32(next, re_bit_count); re_cache1 |= next << re_bit_count; re_buffer_ptr++; re_bit_count -= 32; } } { __asm__ ("shldl %2, %1, %0 \n\t""shll %2, %1 \n\t" : "+r"(re_cache0), "+r"(re_cache1) : "Ic"((uint8_t)n)); re_bit_count += n; } (*s).bit_count = re_bit_count; (*s).cache0 = re_cache0; (*s).cache1 = re_cache1; (*s).buffer_ptr = re_buffer_ptr; } static __inline unsigned int get_bits1(GetBitContext *s) { return get_bits(s, 1); } static __inline unsigned int show_bits1(GetBitContext *s) { return show_bits(s, 1); } static __inline void skip_bits1(GetBitContext *s) { skip_bits(s, 1); } static __inline unsigned int get_bits_long(GetBitContext *s, int n) { if (n <= 32) { return get_bits(s, n); } else { { int ret = get_bits(s, 16) << (n - 16); return ret | get_bits(s, n - 16); } } } static __inline int get_sbits_long(GetBitContext *s, int n) { return sign_extend(get_bits_long(s, n), n); } static __inline unsigned int show_bits_long(GetBitContext *s, int n) { if (n <= 32) { return show_bits(s, n); } else { { GetBitContext gb = *s; return get_bits_long(&gb, n); } } } void av_log(int level, const char *fmt, ...); static __inline int check_marker(GetBitContext *s, const char *msg) { int bit = get_bits1(s); if (!bit) { av_log(32, "Marker bit missing %s\n", msg); } return bit; } typedef long int __intptr_t; typedef __intptr_t intptr_t; static __inline void init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size) { int buffer_size = (bit_size + 7) >> 3; if (buffer_size < 0 || bit_size < 0) { { buffer_size = bit_size = 0; buffer = (void *)0; } } (*s).buffer = buffer; (*s).size_in_bits = bit_size; (*s).buffer_end = buffer + buffer_size; (*s).buffer_ptr = (uint32_t *)((intptr_t)buffer & ~3); (*s).bit_count = 32 + 8 * ((intptr_t)buffer & 3); skip_bits_long(s, 0); } static __inline void align_get_bits(GetBitContext *s) { int n = -get_bits_count(s) & 7; if (n) { skip_bits(s, n); } } static __inline int get_bits_left(GetBitContext *gb) { return (*gb).size_in_bits - get_bits_count(gb); } struct H264Slice; typedef struct H264Slice H264Slice; struct PPS { unsigned int sps_id; int cabac; int pic_order_present; int slice_group_count; int mb_slice_group_map_type; unsigned int ref_count[2]; int weighted_pred; int weighted_bipred_idc; int init_qp; int init_qs; int chroma_qp_index_offset[2]; int deblocking_filter_parameters_present; int constrained_intra_pred; int redundant_pic_cnt_present; int transform_8x8_mode; uint8_t scaling_matrix4[6][16]; uint8_t scaling_matrix8[2][64]; uint8_t chroma_qp_table[2][64]; int chroma_qp_diff; }; typedef struct PPS PPS; struct PictureInfo; typedef struct PictureInfo PictureInfo; struct DecodedPicture; typedef struct DecodedPicture DecodedPicture; struct H264Slice { PPS pps; PictureInfo *current_picture_info; DecodedPicture *curr_pic; int slice_num; int release_ref_cpn[66]; int release_cnt; int qp_thresh; int use_weight; int use_weight_chroma; int luma_log2_weight_denom; int chroma_log2_weight_denom; int16_t luma_weight[16][2][2]; int16_t chroma_weight[16][2][2][2]; int16_t implicit_weight[16][16][2]; int ref_list_cpn[2][16]; PictureInfo *ref_list[2][16]; DecodedPicture *dp_ref_list[2][16]; int ref_count[2]; int slice_type; int slice_type_nos; int slice_alpha_c0_offset; int slice_beta_offset; int direct_8x8_inference_flag; uint8_t list_count; uint32_t coded_pic_num; int poc; int key_frame; int mmco_reset; int ip_id; int transform_bypass; int direct_spatial_mv_pred; int map_col_to_list0[2][16]; int dist_scale_factor[16]; int cabac_init_idc; int nal_ref_idc; int nal_unit_type; int ref2frm[2][64]; int qscale; }; static __inline int get_chroma_qp(H264Slice *s, int t, int qscale) { return (*s).pps.chroma_qp_table[t][qscale]; } struct H264Context; typedef struct H264Context H264Context; struct ParserContext; typedef struct ParserContext ParserContext; struct NalContext; typedef struct NalContext NalContext; struct mcc_struct_anon_54; typedef struct mcc_struct_anon_54 SliceBufferEntry; struct H264Mb; typedef struct H264Mb H264Mb; struct mcc_struct_anon_54 { H264Slice slice; H264Mb *mbs; DecodedPicture *dp; GetBitContext gb; int lines_taken; int lines_total; int state; int initialized; }; void init_sb_entry(H264Context *h, SliceBufferEntry *sbe); struct __pthread_internal_list; struct __pthread_internal_list { struct __pthread_internal_list *__prev; struct __pthread_internal_list *__next; }; typedef struct __pthread_internal_list __pthread_list_t; struct __pthread_mutex_s { int __lock; unsigned int __count; int __owner; unsigned int __nusers; int __kind; int __spins; __pthread_list_t __list; }; union mcc_union_anon_26 { struct __pthread_mutex_s __data; char __size[40]; long int __align; }; typedef union mcc_union_anon_26 pthread_mutex_t; struct mcc_struct_anon_29 { int __lock; unsigned int __futex; __extension__ unsigned long long int __total_seq; __extension__ unsigned long long int __wakeup_seq; __extension__ unsigned long long int __woken_seq; void *__mutex; unsigned int __nwaiters; unsigned int __broadcast_seq; }; union mcc_union_anon_28 { struct mcc_struct_anon_29 __data; char __size[48]; __extension__ long long int __align; }; typedef union mcc_union_anon_28 pthread_cond_t; struct mcc_struct_anon_56 { pthread_mutex_t lock; pthread_cond_t cond; SliceBufferEntry **queue; int size; int cnt; int fi; int fo; }; typedef struct mcc_struct_anon_56 SliceBufferQueue; struct RingLineEntry; typedef struct RingLineEntry RingLineEntry; struct mcc_struct_anon_57 { pthread_mutex_t wslock; pthread_cond_t wscond; pthread_mutex_t swlock; pthread_cond_t swcond; RingLineEntry **queue; int size; int ready; int free; int fi; int fo; }; typedef struct mcc_struct_anon_57 RingLineQueue; union mcc_union_anon_25 { char __size[56]; long int __align; }; typedef union mcc_union_anon_25 pthread_attr_t; typedef unsigned long int pthread_t; struct SuperMBContext; typedef struct SuperMBContext SuperMBContext; typedef long int __time_t; struct timespec { __time_t tv_sec; long int tv_nsec; }; struct H264Context { SliceBufferQueue sb_q[6]; RingLineQueue rl_q; pthread_mutex_t lock[6]; pthread_cond_t cond[6]; pthread_mutex_t task_lock; pthread_cond_t task_cond; pthread_attr_t ed_rec_attr[80]; pthread_t ed_rec_thr[80]; int init_threads; pthread_mutex_t ilock; pthread_cond_t icond; const char *file_name; int profile; int start; int touch_start; int setaff; int touch_done; int rl_side_touch; int statmbd; pthread_mutex_t slock; pthread_cond_t scond; pthread_mutex_t tlock; pthread_cond_t tcond; pthread_mutex_t tdlock; pthread_cond_t tdcond; int ed_ppe_threads; int threads; int smt; int acdpb_cnt; int reldpb_cnt; int sb_size; SliceBufferEntry *sb; int free_sb_cnt; int slice_bufs; int max_dpb_cnt; DecodedPicture *dpb; int free_dpb_cnt; int ifile; int ofile; int frame_width; int frame_height; int num_frames; int width; int height; int mb_width; int mb_height; int mb_stride; int b4_stride; int b_stride; int smb_height; int smb_width; pthread_mutex_t smb_lock; pthread_cond_t sdl_cond; pthread_mutex_t sdl_lock; SuperMBContext *smbc; int wave_order; int static_3d; int pipe_bufs; uint8_t zigzag_scan[16]; uint8_t zigzag_scan8x8[64]; int verbose; int no_mbd; int display; int fullscreen; int quit; struct timespec start_time[4]; struct timespec end_time[4]; double last_time[4]; double total_time[4]; }; void av_read_frame_internal(ParserContext *pc, GetBitContext *gb); int decode_nal_units(NalContext *n, H264Slice *s, GetBitContext *gb); static void parse_task(H264Context *h, ParserContext *pc, NalContext *nc, SliceBufferEntry *sbe) { H264Slice *s; if (!(*sbe).initialized) { { init_sb_entry(h, sbe); (*sbe).lines_total = (*h).mb_height; } } av_read_frame_internal(pc, &(*sbe).gb); s = &(*sbe).slice; decode_nal_units(nc, s, &(*sbe).gb); } struct EntropyContext; typedef struct EntropyContext EntropyContext; struct EntropyContext { CABACContext c; H264Mb *m; int top_cbp; int left_cbp; int neighbor_transform_size; uint32_t top_type; uint32_t left_type; uint32_t topright_type; uint32_t topleft_type; int curr_qscale; int chroma_qp[2]; int last_qscale_diff; uint32_t dequant4_buffer[6][52][16]; uint32_t dequant8_buffer[2][52][64]; uint32_t (*dequant4_coeff[6])[16]; uint32_t (*dequant8_coeff[2])[64]; uint8_t (*non_zero_count_top)[8]; uint8_t (*non_zero_count)[8]; uint8_t (*non_zero_count_row[2])[8]; __attribute__((aligned(8))) uint8_t non_zero_count_left[8]; uint8_t (*mvd_top[2])[2]; uint8_t (*mvd[2])[2]; uint8_t (*mvd_table[2][2])[2]; uint8_t *direct_top; uint8_t *direct; uint8_t *direct_table[2]; uint8_t *chroma_pred_mode_top; uint8_t *chroma_pred_mode; uint8_t *chroma_pred_mode_table[2]; uint16_t *cbp_top; uint16_t *cbp; uint16_t *cbp_table[2]; int8_t *qscale_top; int8_t *qscale; int8_t *qscale_table[2]; int8_t *ref_index_top[2]; int8_t *ref_index[2]; int8_t *ref_index_table[2][2]; uint32_t *mb_type_top; uint32_t *mb_type; uint32_t *mb_type_table[2]; int b_stride; int mb_stride; int mb_width; int mb_height; uint8_t *zigzag_scan; uint8_t *zigzag_scan8x8; uint8_t direct_cache[40]; __attribute__((aligned(8))) int8_t intra4x4_pred_mode_cache[40]; __attribute__((aligned(16))) int16_t mv_cache[2][40][2]; __attribute__((aligned(8))) int8_t ref_cache[2][40]; __attribute__((aligned(8))) uint8_t non_zero_count_cache[48]; __attribute__((aligned(16))) uint8_t mvd_cache[2][40][2]; }; void init_dequant_tables(H264Slice *s, EntropyContext *ec); void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size); void ff_h264_init_cabac_states(EntropyContext *ec, H264Slice *s, CABACContext *c); int init_entropy_buf(EntropyContext *ec, H264Slice *s, int line); struct H264Mb { int16_t mb_x; int16_t mb_y; int32_t mb_type; uint16_t cbp; int8_t qscale_mb_xy; int8_t qscale_left_mb_xy; int8_t qscale_top_mb_xy; __attribute__((aligned(8))) uint16_t sub_mb_type[4]; __attribute__((aligned(8))) uint8_t non_zero_count[24]; __attribute__((aligned(16))) int16_t mb[384]; union { struct { __attribute__((aligned(8))) int8_t ref_index[2][4]; __attribute__((aligned(16))) int16_t mvd[2][16][2]; }; struct { __attribute__((aligned(8))) int8_t intra4x4_pred_mode[16]; int8_t chroma_pred_mode; int8_t intra16x16_pred_mode; }; }; __attribute__((aligned(8))) uint8_t top_border[32]; __attribute__((aligned(8))) uint8_t top_border_next[8]; __attribute__((aligned(8))) uint8_t left_border[35]; int8_t intra4x4_pred_mode_left[4]; }; int ff_h264_decode_mb_cabac(EntropyContext *ec, H264Slice *s, CABACContext *c); static void decode_slice_entropy_task(H264Context *h, EntropyContext *ec, SliceBufferEntry *sbe) { int j; int i; H264Slice *s = &(*sbe).slice; GetBitContext *gb = &(*sbe).gb; H264Mb *mbs = (*sbe).mbs; CABACContext *c = &(*ec).c; if (!(*s).pps.cabac) { { av_log(16, "Only cabac encoded streams are supported\n"); return ; } } init_dequant_tables(s, ec); (*ec).curr_qscale = (*s).qscale; (*ec).last_qscale_diff = 0; (*ec).chroma_qp[0] = get_chroma_qp((H264Slice *)s, 0, (*s).qscale); (*ec).chroma_qp[1] = get_chroma_qp((H264Slice *)s, 1, (*s).qscale); align_get_bits(gb); ff_init_cabac_decoder(c, (*gb).buffer + get_bits_count(gb) / 8, (get_bits_left(gb) + 7) / 8); ff_h264_init_cabac_states(ec, s, c); for (j = 0; j < (*ec).mb_height; j++) { { init_entropy_buf(ec, s, j); for (i = 0; i < (*ec).mb_width; i++) { { int ret; int eos; H264Mb *m = &mbs[i + j * (*ec).mb_width]; (*m).mb_x = i; (*m).mb_y = j; (*ec).m = m; ret = ff_h264_decode_mb_cabac(ec, s, c); eos = get_cabac_terminate(c); (void)eos; if (ret < 0 || (*c).bytestream > (*c).bytestream_end + 2) { { av_log(16, "error while decoding MB %d %d, bytestream (%td)\n", (*m).mb_x, (*m).mb_y, (*c).bytestream_end - (*c).bytestream); return ; } } } } } } } struct MBRecContext; typedef struct MBRecContext MBRecContext; struct SuperMBTask; typedef struct SuperMBTask SuperMBTask; struct SuperMBContext { int nsmb_width; int nsmb_height; int nsmb_3dheight; int smb_width; int smb_height; int refcount; int index; SuperMBTask *smbs[2]; }; struct MBRecState; typedef struct MBRecState MBRecState; void init_mbrec_context(MBRecContext *mrc, MBRecState *mrs, H264Slice *s, int line); struct MBRecState { int8_t *ref_index_top[2]; int8_t *ref_index[2]; int16_t (*motion_val_top[2])[2]; int16_t (*motion_val[2])[2]; uint32_t *mb_type_top; uint32_t *mb_type; int8_t *list1_ref_index[2]; int16_t (*list1_motion_val[2])[2]; uint32_t *list1_mb_type; int8_t *intra4x4_pred_mode_top; int8_t *intra4x4_pred_mode; int8_t *non_zero_count_top; int8_t *non_zero_count; unsigned int topleft_samples_available; unsigned int topright_samples_available; unsigned int top_samples_available; unsigned int left_samples_available; int top_type; int left_type; __attribute__((aligned(8))) int8_t intra4x4_pred_mode_cache[40]; __attribute__((aligned(16))) int16_t mv_cache[2][40][2]; __attribute__((aligned(8))) int8_t ref_cache[2][40]; __attribute__((aligned(8))) uint8_t non_zero_count_cache[48]; __attribute__((aligned(16))) uint8_t mvd_cache[2][40][2]; __attribute__((aligned(8))) int16_t bS[2][4][4]; uint8_t edges[2]; }; typedef short int DCTELEM; typedef void (*op_pixels_func)(uint8_t *, const uint8_t *, int, int); typedef void (*qpel_mc_func)(uint8_t *, uint8_t *, int); typedef void (*h264_chroma_mc_func)(uint8_t *, uint8_t *, int, int, int, int); struct DSPContext { void (*get_pixels)(DCTELEM *, const uint8_t *, int); void (*diff_pixels)(DCTELEM *, const uint8_t *, const uint8_t *, int); void (*put_pixels_clamped)(const DCTELEM *, uint8_t *, int); void (*put_signed_pixels_clamped)(const DCTELEM *, uint8_t *, int); void (*put_pixels_nonclamped)(const DCTELEM *, uint8_t *, int); void (*add_pixels_clamped)(const DCTELEM *, uint8_t *, int); void (*add_pixels8)(uint8_t *, DCTELEM *, int); void (*add_pixels4)(uint8_t *, DCTELEM *, int); void (*clear_block)(DCTELEM *); void (*clear_blocks)(DCTELEM *); void (*put_pixels_tab[4][4])(uint8_t *, const uint8_t *, int, int); void (*avg_pixels_tab[4][4])(uint8_t *, const uint8_t *, int, int); void (*put_no_rnd_pixels_tab[4][4])(uint8_t *, const uint8_t *, int, int); void (*avg_no_rnd_pixels_tab[4][4])(uint8_t *, const uint8_t *, int, int); void (*put_no_rnd_pixels_l2[2])(uint8_t *, const uint8_t *, const uint8_t *, int, int); void (*put_qpel_pixels_tab[2][16])(uint8_t *, uint8_t *, int); void (*avg_qpel_pixels_tab[2][16])(uint8_t *, uint8_t *, int); void (*put_no_rnd_qpel_pixels_tab[2][16])(uint8_t *, uint8_t *, int); void (*avg_no_rnd_qpel_pixels_tab[2][16])(uint8_t *, uint8_t *, int); void (*put_mspel_pixels_tab[8])(uint8_t *, uint8_t *, int); void (*put_h264_chroma_pixels_tab[3])(uint8_t *, uint8_t *, int, int, int, int); void (*avg_h264_chroma_pixels_tab[3])(uint8_t *, uint8_t *, int, int, int, int); void (*put_no_rnd_vc1_chroma_pixels_tab[3])(uint8_t *, uint8_t *, int, int, int, int); void (*avg_no_rnd_vc1_chroma_pixels_tab[3])(uint8_t *, uint8_t *, int, int, int, int); void (*put_h264_qpel_pixels_tab[4][16])(uint8_t *, uint8_t *, int); void (*avg_h264_qpel_pixels_tab[4][16])(uint8_t *, uint8_t *, int); void (*put_2tap_qpel_pixels_tab[4][16])(uint8_t *, uint8_t *, int); void (*avg_2tap_qpel_pixels_tab[4][16])(uint8_t *, uint8_t *, int); void (*fdct)(DCTELEM *); void (*fdct248)(DCTELEM *); void (*idct)(DCTELEM *); void (*idct_put)(uint8_t *, int, DCTELEM *); void (*idct_add)(uint8_t *, int, DCTELEM *); void (*draw_edges)(uint8_t *, int, int, int, int); void (*prefetch)(void *, int, int); }; typedef struct DSPContext DSPContext; typedef void (*h264_weight_func)(uint8_t *, int, int, int, int); typedef void (*h264_biweight_func)(uint8_t *, uint8_t *, int, int, int, int, int); struct H264DSPContext { void (*weight_h264_pixels_tab[10])(uint8_t *, int, int, int, int); void (*biweight_h264_pixels_tab[10])(uint8_t *, uint8_t *, int, int, int, int, int); void (*h264_v_loop_filter_luma)(uint8_t *, int, int, int, int8_t *); void (*h264_h_loop_filter_luma)(uint8_t *, int, int, int, int8_t *); void (*h264_v_loop_filter_luma_intra)(uint8_t *, int, int, int); void (*h264_h_loop_filter_luma_intra)(uint8_t *, int, int, int); void (*h264_v_loop_filter_chroma)(uint8_t *, int, int, int, int8_t *); void (*h264_h_loop_filter_chroma)(uint8_t *, int, int, int, int8_t *); void (*h264_v_loop_filter_chroma_intra)(uint8_t *, int, int, int); void (*h264_h_loop_filter_chroma_intra)(uint8_t *, int, int, int); 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); void (*h264_idct_add)(uint8_t *, DCTELEM *, int); void (*h264_idct8_add)(uint8_t *, DCTELEM *, int); void (*h264_idct_dc_add)(uint8_t *, DCTELEM *, int); void (*h264_idct8_dc_add)(uint8_t *, DCTELEM *, int); void (*h264_dct)(DCTELEM [4][4]); void (*h264_idct_add16)(uint8_t *, const int *, DCTELEM *, int, const uint8_t [48]); void (*h264_idct8_add4)(uint8_t *, const int *, DCTELEM *, int, const uint8_t [48]); void (*h264_idct_add8)(uint8_t **, const int *, DCTELEM *, int, const uint8_t [48]); void (*h264_idct_add16intra)(uint8_t *, const int *, DCTELEM *, int, const uint8_t [48]); void (*(*qpel_put)[16])(uint8_t *, uint8_t *, int); void (*(*qpel_avg)[16])(uint8_t *, uint8_t *, int); }; typedef struct H264DSPContext H264DSPContext; struct H264PredContext { void (*pred4x4[15])(uint8_t *, uint8_t *, int); void (*pred8x8l[12])(uint8_t *, int, int, int); void (*pred8x8[11])(uint8_t *, int); void (*pred16x16[7])(uint8_t *, int); void (*pred4x4_add[2])(uint8_t *, const DCTELEM *, int); void (*pred8x8l_add[2])(uint8_t *, const DCTELEM *, int); void (*pred8x8_add[3])(uint8_t *, const int *, const DCTELEM *, int); void (*pred16x16_add[3])(uint8_t *, const int *, const DCTELEM *, int); }; typedef struct H264PredContext H264PredContext; struct MBRecContext { DSPContext dsp; H264DSPContext hdsp; H264PredContext hpc; MBRecState *mrs; RingLineEntry *rle; uint8_t *scratchpad_y; uint8_t *scratchpad_cb; uint8_t *scratchpad_cr; int linesize; int uvlinesize; int mb_width; int mb_height; int mb_stride; int b_stride; int width; int height; int block_offset[24]; }; void h264_decode_mb_internal(MBRecContext *d, MBRecState *mrs, H264Slice *s, H264Mb *m); static void decode_super_mb_block(MBRecContext *d, H264Slice *s, SuperMBContext *smbc, H264Mb *mbs, int smb_x, int smb_y) { MBRecState mrs; for (int k = 0, i = smb_y; i < smb_y + (*smbc).smb_height; (i++, k++)) { { init_mbrec_context(d, &mrs, s, i); for (int j = smb_x - k; j < smb_x - k + (*smbc).smb_width; j++) { { if ((i < (*d).mb_height && j >= 0) && j < (*d).mb_width) { { h264_decode_mb_internal(d, &mrs, s, &mbs[i * (*d).mb_width + j]); } } } } } } } struct SuperMBTask { int smb_x; int smb_y; }; static void decode_super_mb_task(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, SuperMBTask *ml, SuperMBTask *mur, SuperMBTask *m) { H264Slice *s = &(*sbe).slice; H264Mb *mbs = (*sbe).mbs; decode_super_mb_block(d, s, smbc, mbs, (*m).smb_x, (*m).smb_y); } void draw_edges(MBRecContext *d, H264Slice *s, int line); static void draw_edges_task(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, SuperMBTask *sm, int line) { H264Slice *s = &(*sbe).slice; for (int i = line * (*smbc).smb_height; i < (line + 1) * (*smbc).smb_height && i < (*d).mb_height; i++) { draw_edges(d, s, i); } } SuperMBContext *acquire_smbc(H264Context *h); enum mcc_enum_anon_8 { NANOS_OK = 0, NANOS_UNKNOWN_ERR = 1, NANOS_UNIMPLEMENTED = 2, NANOS_ENOMEM = 3, NANOS_INVALID_PARAM = 4 }; typedef enum mcc_enum_anon_8 nanos_err_t; extern nanos_err_t nanos_in_final(_Bool *result); struct mcc_struct_anon_20 { void (*outline)(void *); }; typedef struct mcc_struct_anon_20 nanos_smp_args_t; struct nanos_args_0_t { MBRecContext *d; SliceBufferEntry *sbe; SuperMBContext *smbc; SuperMBTask *ml; SuperMBTask *mur; SuperMBTask *m; }; static void smp_ol_decode_super_mb_task_1(struct nanos_args_0_t *const args); struct mcc_struct_anon_16 { _Bool mandatory_creation:1; _Bool tied:1; _Bool clear_chunk:1; _Bool reserved0:1; _Bool reserved1:1; _Bool reserved2:1; _Bool reserved3:1; _Bool reserved4:1; }; typedef struct mcc_struct_anon_16 nanos_wd_props_t; typedef unsigned long int size_t; struct nanos_const_wd_definition_tag { nanos_wd_props_t props; size_t data_alignment; size_t num_copies; size_t num_devices; size_t num_dimensions; const char *description; }; typedef struct nanos_const_wd_definition_tag nanos_const_wd_definition_t; struct mcc_struct_anon_19 { void *(*factory)(void *); void *arg; }; typedef struct mcc_struct_anon_19 nanos_device_t; struct nanos_const_wd_definition_1 { nanos_const_wd_definition_t base; nanos_device_t devices[1]; }; extern void *nanos_smp_factory(void *args); struct mcc_struct_anon_17 { _Bool is_final:1; _Bool reserved1:1; _Bool reserved2:1; _Bool reserved3:1; _Bool reserved4:1; _Bool reserved5:1; _Bool reserved6:1; _Bool reserved7:1; }; typedef struct mcc_struct_anon_17 nanos_wd_dyn_flags_t; typedef void *nanos_thread_t; struct mcc_struct_anon_18 { nanos_wd_dyn_flags_t flags; void *tie_to; unsigned int priority; }; typedef struct mcc_struct_anon_18 nanos_wd_dyn_props_t; typedef void *nanos_wd_t; struct mcc_struct_anon_9; typedef struct mcc_struct_anon_9 nanos_copy_data_internal_t; typedef nanos_copy_data_internal_t nanos_copy_data_t; struct mcc_struct_anon_5; typedef struct mcc_struct_anon_5 nanos_region_dimension_internal_t; typedef void *nanos_wg_t; 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); extern void *nanos_current_wd(void); extern void nanos_handle_error(nanos_err_t err); struct mcc_struct_anon_5 { size_t size; size_t lower_bound; size_t accessed_length; }; typedef nanos_region_dimension_internal_t nanos_region_dimension_t; struct mcc_struct_anon_6 { _Bool input:1; _Bool output:1; _Bool can_rename:1; _Bool concurrent:1; _Bool commutative:1; }; typedef struct mcc_struct_anon_6 nanos_access_type_internal_t; typedef long int ptrdiff_t; struct mcc_struct_anon_7 { void *address; nanos_access_type_internal_t flags; short int dimension_count; const nanos_region_dimension_internal_t *dimensions; ptrdiff_t offset; }; typedef struct mcc_struct_anon_7 nanos_data_access_internal_t; typedef nanos_data_access_internal_t nanos_data_access_t; typedef void *nanos_team_t; extern nanos_err_t nanos_submit(void *wd, size_t num_data_accesses, nanos_data_access_t *data_accesses, void *team); typedef void (*nanos_translate_args_t)(void *, void *); 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 *)); struct nanos_args_1_t { MBRecContext *d; SliceBufferEntry *sbe; SuperMBContext *smbc; SuperMBTask *sm; int line; }; static void smp_ol_draw_edges_task_3(struct nanos_args_1_t *const args); extern nanos_err_t nanos_wait_on(size_t num_data_accesses, nanos_data_access_t *data_accesses); void release_smbc(H264Context *h, SuperMBContext *smbc); static void decode_mb_in_slice(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe) { int j; int i; SuperMBTask *sml; SuperMBTask *smur; SuperMBContext *smbc = acquire_smbc(h); int smb_height = (*smbc).nsmb_height; int smb_width = (*smbc).nsmb_width; SuperMBTask *smbs = (*smbc).smbs[0]; SuperMBTask *sm = (void *)0; for (j = 0; j < smb_height; j++) { { nanos_err_t mcc_err_in_final_1; _Bool mcc_is_in_final_1; for (i = 0; i < smb_width; i++) { { nanos_err_t mcc_err_in_final_0; _Bool mcc_is_in_final_0; sm = smbs + j * smb_width + i; sml = sm - (i > 0 ? 1 : 0); smur = sm + (i < smb_width - 1 && j > 0 ? -smb_width + 1 : 0); mcc_err_in_final_0 = nanos_in_final(&mcc_is_in_final_0); { MBRecContext *mcc_arg_0 = d; SliceBufferEntry *mcc_arg_1 = sbe; SuperMBContext *mcc_arg_2 = smbc; SuperMBTask *mcc_arg_3 = sml; SuperMBTask *mcc_arg_4 = smur; SuperMBTask *mcc_arg_5 = sm; if (mcc_is_in_final_0) { decode_super_mb_task(d, sbe, smbc, sml, smur, sm); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_0_t *ol_args; nanos_err_t err; struct nanos_args_0_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_0_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).d = mcc_arg_0; (*ol_args).sbe = mcc_arg_1; (*ol_args).smbc = mcc_arg_2; (*ol_args).ml = mcc_arg_3; (*ol_args).mur = mcc_arg_4; (*ol_args).m = mcc_arg_5; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 5, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.d = mcc_arg_0; imm_args.sbe = mcc_arg_1; imm_args.smbc = mcc_arg_2; imm_args.ml = mcc_arg_3; imm_args.mur = mcc_arg_4; imm_args.m = mcc_arg_5; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } } } mcc_err_in_final_1 = nanos_in_final(&mcc_is_in_final_1); { MBRecContext *mcc_arg_6 = d; SliceBufferEntry *mcc_arg_7 = sbe; SuperMBContext *mcc_arg_8 = smbc; SuperMBTask *mcc_arg_9 = sm; int mcc_arg_10 = j; if (mcc_is_in_final_1) { draw_edges_task(d, sbe, smbc, sm, j); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_1_t *ol_args; nanos_err_t err; struct nanos_args_1_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_1_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).d = mcc_arg_6; (*ol_args).sbe = mcc_arg_7; (*ol_args).smbc = mcc_arg_8; (*ol_args).sm = mcc_arg_9; (*ol_args).line = mcc_arg_10; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 3, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.d = mcc_arg_6; imm_args.sbe = mcc_arg_7; imm_args.smbc = mcc_arg_8; imm_args.sm = mcc_arg_9; imm_args.line = mcc_arg_10; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } } } { nanos_region_dimension_t dimensions_0[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_data_access_t dependences[1] = { { (void *)sm, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 } }; ; nanos_err_t err = nanos_wait_on(1, dependences); if (err != NANOS_OK) { nanos_handle_error(err); } } release_smbc(h, smbc); } struct DecodedPicture { int16_t (*motion_val[2])[2]; int16_t (*motion_val_base[2])[2]; int8_t *ref_index[2]; uint32_t *mb_type; uint32_t *mb_type_base; int8_t *intra4x4_pred_mode; int8_t *non_zero_count; uint8_t *data[3]; int linesize[3]; uint8_t *base[3]; int cpn; int poc; int reference; int key_frame; int mmco_reset; }; struct nanos_lock_t; typedef struct nanos_lock_t nanos_lock_t; extern nanos_err_t nanos_set_lock(nanos_lock_t *lock); enum mcc_enum_anon_7 { NANOS_LOCK_FREE = 0, NANOS_LOCK_BUSY = 1 }; typedef enum mcc_enum_anon_7 nanos_lock_state_t; struct nanos_lock_t { volatile nanos_lock_state_t state_; }; __attribute__((weak)) nanos_lock_t nanos_critical_lock_dpb = { NANOS_LOCK_FREE }; DecodedPicture *get_dpb_entry(H264Context *h, H264Slice *s); extern nanos_err_t nanos_unset_lock(nanos_lock_t *lock); void release_dpb_entry(H264Context *h, DecodedPicture *pic, int mode); static void decode_slice_mb_task(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe) { H264Slice *s = &(*sbe).slice; for (int i = 0; i < 2; i++) { { for (int j = 0; j < (*s).ref_count[i]; j++) { { int k; if ((*s).ref_list_cpn[i][j] == -1) { continue; } for (k = 0; k < (*h).max_dpb_cnt; k++) { { if ((*h).dpb[k].reference >= 2 && (*h).dpb[k].cpn == (*s).ref_list_cpn[i][j]) { { (*s).dp_ref_list[i][j] = &(*h).dpb[k]; break; } } } } } } } } { nanos_err_t err; err = nanos_set_lock(&nanos_critical_lock_dpb); if (err != NANOS_OK) { nanos_handle_error(err); } get_dpb_entry(h, s); err = nanos_unset_lock(&nanos_critical_lock_dpb); if (err != NANOS_OK) { nanos_handle_error(err); } } if (!(*h).no_mbd) { { decode_mb_in_slice(h, d, sbe); } } for (int i = 0; i < (*s).release_cnt; i++) { { for (int j = 0; j < (*h).max_dpb_cnt; j++) { { if ((*h).dpb[j].cpn == (*s).release_ref_cpn[i]) { { { nanos_err_t err; err = nanos_set_lock(&nanos_critical_lock_dpb); if (err != NANOS_OK) { nanos_handle_error(err); } release_dpb_entry(h, &(*h).dpb[j], 2); err = nanos_unset_lock(&nanos_critical_lock_dpb); if (err != NANOS_OK) { nanos_handle_error(err); } } break; } } } } } } (*s).release_cnt = 0; } static void decode_3dwave_super_mb_task(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc, SuperMBTask *ml, SuperMBTask *mur, SuperMBTask *mprev, SuperMBTask *m) { H264Slice *s = &(*sbe).slice; H264Mb *mbs = (*sbe).mbs; decode_super_mb_block(d, s, smbc, mbs, (*m).smb_x, (*m).smb_y); } static void init_ref_list_and_get_dpb_task(H264Context *h, MBRecContext *d, SliceBufferEntry *sbe, int *init) { H264Slice *s = &(*sbe).slice; for (int i = 0; i < 2; i++) { { for (int j = 0; j < (*s).ref_count[i]; j++) { { int k; if ((*s).ref_list_cpn[i][j] == -1) { continue; } for (k = 0; k < (*h).max_dpb_cnt; k++) { { if ((*h).dpb[k].reference >= 2 && (*h).dpb[k].cpn == (*s).ref_list_cpn[i][j]) { { (*s).dp_ref_list[i][j] = &(*h).dpb[k]; break; } } } } } } } } { nanos_err_t err; err = nanos_set_lock(&nanos_critical_lock_dpb); if (err != NANOS_OK) { nanos_handle_error(err); } get_dpb_entry(h, s); err = nanos_unset_lock(&nanos_critical_lock_dpb); if (err != NANOS_OK) { nanos_handle_error(err); } } } struct nanos_args_2_t { MBRecContext *d; SliceBufferEntry *sbe; SuperMBContext *smbc; SuperMBTask *ml; SuperMBTask *mur; SuperMBTask *mprev; SuperMBTask *m; }; static void smp_ol_decode_3dwave_super_mb_task_5(struct nanos_args_2_t *const args); struct nanos_args_3_t { MBRecContext *d; SliceBufferEntry *sbe; SuperMBContext *smbc; SuperMBTask *sm; int line; }; static void smp_ol_draw_edges_task_7(struct nanos_args_3_t *const args); struct nanos_args_4_t { MBRecContext *d; SliceBufferEntry *sbe; SuperMBContext *smbc; SuperMBTask *ml; SuperMBTask *mur; SuperMBTask *m; }; static void smp_ol_decode_super_mb_task_9(struct nanos_args_4_t *const args); struct nanos_args_5_t { MBRecContext *d; SliceBufferEntry *sbe; SuperMBContext *smbc; SuperMBTask *sm; int line; }; static void smp_ol_draw_edges_task_11(struct nanos_args_5_t *const args); static SuperMBTask *add_decode_slice_3dwave_tasks(MBRecContext *d, SliceBufferEntry *sbe, SuperMBContext *smbc) { int j; int i; SuperMBTask *sml; SuperMBTask *smur; SuperMBTask *smprev; int smb_3d_height = (*smbc).nsmb_3dheight; int smb_height = (*smbc).nsmb_height; int smb_width = (*smbc).nsmb_width; int smb_diff_prev = smb_height - smb_3d_height; SuperMBTask *sm = (void *)0; SuperMBTask *smbs = (*smbc).smbs[(*smbc).index++]; (*smbc).index %= 2; SuperMBTask *smbs_prev = (*smbc).smbs[(*smbc).index]; for (j = 0; j < smb_3d_height; j++) { { nanos_err_t mcc_err_in_final_3; _Bool mcc_is_in_final_3; for (i = 0; i < smb_width; i++) { { nanos_err_t mcc_err_in_final_2; _Bool mcc_is_in_final_2; sm = smbs + j * smb_width + i; sml = sm - (i > 0 ? 1 : 0); smur = sm + (i < smb_width - 1 && j > 0 ? -smb_width + 1 : 0); smprev = smbs_prev + (j + smb_diff_prev + 1) * smb_width - 1; mcc_err_in_final_2 = nanos_in_final(&mcc_is_in_final_2); { MBRecContext *mcc_arg_11 = d; SliceBufferEntry *mcc_arg_12 = sbe; SuperMBContext *mcc_arg_13 = smbc; SuperMBTask *mcc_arg_14 = sml; SuperMBTask *mcc_arg_15 = smur; SuperMBTask *mcc_arg_16 = smprev; SuperMBTask *mcc_arg_17 = sm; if (mcc_is_in_final_2) { decode_3dwave_super_mb_task(d, sbe, smbc, sml, smur, smprev, sm); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_2_t *ol_args; nanos_err_t err; struct nanos_args_2_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_2_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).d = mcc_arg_11; (*ol_args).sbe = mcc_arg_12; (*ol_args).smbc = mcc_arg_13; (*ol_args).ml = mcc_arg_14; (*ol_args).mur = mcc_arg_15; (*ol_args).mprev = mcc_arg_16; (*ol_args).m = mcc_arg_17; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_5[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 6, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.d = mcc_arg_11; imm_args.sbe = mcc_arg_12; imm_args.smbc = mcc_arg_13; imm_args.ml = mcc_arg_14; imm_args.mur = mcc_arg_15; imm_args.mprev = mcc_arg_16; imm_args.m = mcc_arg_17; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_5[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } } } mcc_err_in_final_3 = nanos_in_final(&mcc_is_in_final_3); { MBRecContext *mcc_arg_18 = d; SliceBufferEntry *mcc_arg_19 = sbe; SuperMBContext *mcc_arg_20 = smbc; SuperMBTask *mcc_arg_21 = sm; int mcc_arg_22 = j; if (mcc_is_in_final_3) { draw_edges_task(d, sbe, smbc, sm, j); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_3_t *ol_args; nanos_err_t err; struct nanos_args_3_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_3_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).d = mcc_arg_18; (*ol_args).sbe = mcc_arg_19; (*ol_args).smbc = mcc_arg_20; (*ol_args).sm = mcc_arg_21; (*ol_args).line = mcc_arg_22; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 3, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.d = mcc_arg_18; imm_args.sbe = mcc_arg_19; imm_args.smbc = mcc_arg_20; imm_args.sm = mcc_arg_21; imm_args.line = mcc_arg_22; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } } } for (; j < smb_height; j++) { { nanos_err_t mcc_err_in_final_5; _Bool mcc_is_in_final_5; for (i = 0; i < smb_width; i++) { { nanos_err_t mcc_err_in_final_4; _Bool mcc_is_in_final_4; sm = smbs + j * smb_width + i; sml = sm - (i > 0 ? 1 : 0); smur = sm + (i < smb_width - 1 && j > 0 ? -smb_width + 1 : 0); mcc_err_in_final_4 = nanos_in_final(&mcc_is_in_final_4); { MBRecContext *mcc_arg_23 = d; SliceBufferEntry *mcc_arg_24 = sbe; SuperMBContext *mcc_arg_25 = smbc; SuperMBTask *mcc_arg_26 = sml; SuperMBTask *mcc_arg_27 = smur; SuperMBTask *mcc_arg_28 = sm; if (mcc_is_in_final_4) { decode_super_mb_task(d, sbe, smbc, sml, smur, sm); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_4_t *ol_args; nanos_err_t err; struct nanos_args_4_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_4_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).d = mcc_arg_23; (*ol_args).sbe = mcc_arg_24; (*ol_args).smbc = mcc_arg_25; (*ol_args).ml = mcc_arg_26; (*ol_args).mur = mcc_arg_27; (*ol_args).m = mcc_arg_28; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 5, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.d = mcc_arg_23; imm_args.sbe = mcc_arg_24; imm_args.smbc = mcc_arg_25; imm_args.ml = mcc_arg_26; imm_args.mur = mcc_arg_27; imm_args.m = mcc_arg_28; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_3[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_4[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } } } mcc_err_in_final_5 = nanos_in_final(&mcc_is_in_final_5); { MBRecContext *mcc_arg_29 = d; SliceBufferEntry *mcc_arg_30 = sbe; SuperMBContext *mcc_arg_31 = smbc; SuperMBTask *mcc_arg_32 = sm; int mcc_arg_33 = j; if (mcc_is_in_final_5) { draw_edges_task(d, sbe, smbc, sm, j); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_5_t *ol_args; nanos_err_t err; struct nanos_args_5_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_5_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).d = mcc_arg_29; (*ol_args).sbe = mcc_arg_30; (*ol_args).smbc = mcc_arg_31; (*ol_args).sm = mcc_arg_32; (*ol_args).line = mcc_arg_33; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 3, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.d = mcc_arg_29; imm_args.sbe = mcc_arg_30; imm_args.smbc = mcc_arg_31; imm_args.sm = mcc_arg_32; imm_args.line = mcc_arg_33; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } } } return sm; } static void release_ref_list_task(H264Context *h, SuperMBContext *smbc, MBRecContext *d, SliceBufferEntry *sbe, SuperMBTask *lastsmb, int *release) { H264Slice *s = &(*sbe).slice; for (int i = 0; i < (*s).release_cnt; i++) { { for (int j = 0; j < (*h).max_dpb_cnt; j++) { { if ((*h).dpb[j].cpn == (*s).release_ref_cpn[i]) { { { nanos_err_t err; err = nanos_set_lock(&nanos_critical_lock_dpb); if (err != NANOS_OK) { nanos_handle_error(err); } release_dpb_entry(h, &(*h).dpb[j], 2); err = nanos_unset_lock(&nanos_critical_lock_dpb); if (err != NANOS_OK) { nanos_handle_error(err); } } break; } } } } } } (*s).release_cnt = 0; release_smbc(h, smbc); } struct OutputContext; typedef struct OutputContext OutputContext; DecodedPicture *output_frame(H264Context *h, OutputContext *oc, DecodedPicture *pic, int fd, int frame_width, int frame_height); static void output_task(H264Context *h, OutputContext *oc, SliceBufferEntry *sbe) { DecodedPicture *out = output_frame(h, oc, (*sbe).slice.curr_pic, (*h).ofile, (*h).frame_width, (*h).frame_height); if (out) { { { nanos_err_t err; err = nanos_set_lock(&nanos_critical_lock_dpb); if (err != NANOS_OK) { nanos_handle_error(err); } release_dpb_entry(h, out, 1); err = nanos_unset_lock(&nanos_critical_lock_dpb); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } void *av_mallocz(unsigned int size)__attribute__((__malloc__)); ParserContext *get_parse_context(int ifile); NalContext *get_nal_context(int width, int height); EntropyContext *get_entropy_context(H264Context *h); MBRecContext *get_mbrec_context(H264Context *h); OutputContext *get_output_context(H264Context *h); void av_start_timer(); struct ParserContext { int ifile; int ofile; int buffer_size; int eof_reached; uint8_t *data; int size; uint8_t *cur_ptr; int cur_len; int64_t frame_offset; int64_t cur_offset; int64_t next_frame_offset; int pict_type; int repeat_pict; int key_frame; int64_t pos; int64_t last_pos; int final_frame; uint8_t overread[5]; int overread_cnt; int index; int last_index; int frame_start_found; uint32_t state; }; struct nanos_args_6_t { H264Context *h; ParserContext *pc; NalContext *nc; SliceBufferEntry *sbe; }; static void smp_ol_parse_task_13(struct nanos_args_6_t *const args); struct SPS; typedef struct SPS SPS; enum AVColorPrimaries { AVCOL_PRI_BT709 = 1, AVCOL_PRI_UNSPECIFIED = 2, AVCOL_PRI_BT470M = 4, AVCOL_PRI_BT470BG = 5, AVCOL_PRI_SMPTE170M = 6, AVCOL_PRI_SMPTE240M = 7, AVCOL_PRI_FILM = 8, AVCOL_PRI_NB = 9 }; enum AVColorTransferCharacteristic { AVCOL_TRC_BT709 = 1, AVCOL_TRC_UNSPECIFIED = 2, AVCOL_TRC_GAMMA22 = 4, AVCOL_TRC_GAMMA28 = 5, AVCOL_TRC_NB = 6 }; enum AVColorSpace { AVCOL_SPC_RGB = 0, AVCOL_SPC_BT709 = 1, AVCOL_SPC_UNSPECIFIED = 2, AVCOL_SPC_FCC = 4, AVCOL_SPC_BT470BG = 5, AVCOL_SPC_SMPTE170M = 6, AVCOL_SPC_SMPTE240M = 7, AVCOL_SPC_NB = 8 }; struct SPS { int profile_idc; int level_idc; int chroma_format_idc; int transform_bypass; int log2_max_frame_num; int poc_type; int log2_max_poc_lsb; int delta_pic_order_always_zero_flag; int offset_for_non_ref_pic; int offset_for_top_to_bottom_field; int poc_cycle_length; int ref_frame_count; int gaps_in_frame_num_allowed_flag; int mb_width; int mb_height; int frame_mbs_only_flag; int mb_aff; int direct_8x8_inference_flag; int crop; unsigned int crop_left; unsigned int crop_right; unsigned int crop_top; unsigned int crop_bottom; int vui_parameters_present_flag; int num; int den; int video_signal_type_present_flag; int full_range; int colour_description_present_flag; enum AVColorPrimaries color_primaries; enum AVColorTransferCharacteristic color_trc; enum AVColorSpace colorspace; int timing_info_present_flag; uint32_t num_units_in_tick; uint32_t time_scale; int fixed_frame_rate_flag; short int offset_for_ref_frame[256]; int bitstream_restriction_flag; int num_reorder_frames; int scaling_matrix_present; uint8_t scaling_matrix4[6][16]; uint8_t scaling_matrix8[2][64]; int nal_hrd_parameters_present_flag; int vcl_hrd_parameters_present_flag; int pic_struct_present_flag; int time_offset_length; int cpb_cnt; int initial_cpb_removal_delay_length; int cpb_removal_delay_length; int dpb_output_delay_length; int bit_depth_luma; int bit_depth_chroma; int residual_color_transform_flag; }; struct PictureInfo { int ref_poc[2][16]; int ref_count[2]; int poc; int frame_num; int pic_id; int long_ref; int cpn; int slice_type_nos; int reference; }; enum mcc_enum_anon_20 { SEI_PIC_STRUCT_FRAME = 0, SEI_PIC_STRUCT_TOP_FIELD = 1, SEI_PIC_STRUCT_BOTTOM_FIELD = 2, SEI_PIC_STRUCT_TOP_BOTTOM = 3, SEI_PIC_STRUCT_BOTTOM_TOP = 4, SEI_PIC_STRUCT_TOP_BOTTOM_TOP = 5, SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6, SEI_PIC_STRUCT_FRAME_DOUBLING = 7, SEI_PIC_STRUCT_FRAME_TRIPLING = 8 }; typedef enum mcc_enum_anon_20 SEI_PicStructType; struct NalContext { SPS *sps_buffers[32]; PPS *pps_buffers[256]; SPS sps; PictureInfo picture[17]; PictureInfo *release_ref[66]; PictureInfo *short_ref[32]; PictureInfo *long_ref[32]; int long_ref_count; int short_ref_count; uint32_t coded_pic_num; int poc_lsb; int poc_msb; uint32_t poc_offset; int delta_poc; int frame_num; int prev_poc_msb; int prev_poc_lsb; int frame_num_offset; int prev_frame_num_offset; int prev_frame_num; int max_pic_num; int redundant_pic_count; int outputed_poc; int ip_id; int b4_stride; int mb_stride; int mb_width; int mb_height; int width; int height; int has_b_frames; SEI_PicStructType sei_pic_struct; int sei_ct_type; int sei_dpb_output_delay; int sei_cpb_removal_delay; int sei_recovery_frame_cnt; int sei_buffering_period_present; int initial_cpb_removal_delay[32]; }; struct nanos_args_7_t { H264Context *h; EntropyContext *ec; SliceBufferEntry *sbe; }; static void smp_ol_decode_slice_entropy_task_15(struct nanos_args_7_t *const args); struct nanos_args_8_t { H264Context *h; ParserContext *pc; NalContext *nc; SliceBufferEntry *sbe; }; static void smp_ol_parse_task_17(struct nanos_args_8_t *const args); struct nanos_args_9_t { H264Context *h; EntropyContext *ec; SliceBufferEntry *sbe; }; static void smp_ol_decode_slice_entropy_task_19(struct nanos_args_9_t *const args); struct nanos_args_10_t { H264Context *h; MBRecContext *d; SliceBufferEntry *sbe; int *init; }; static void smp_ol_init_ref_list_and_get_dpb_task_21(struct nanos_args_10_t *const args); struct nanos_args_11_t { H264Context *h; SuperMBContext *smbc; MBRecContext *d; SliceBufferEntry *sbe; SuperMBTask *lastsmb; int *release; }; static void smp_ol_release_ref_list_task_23(struct nanos_args_11_t *const args); struct nanos_args_12_t { H264Context *h; OutputContext *oc; SliceBufferEntry *sbe; }; static void smp_ol_output_task_25(struct nanos_args_12_t *const args); struct OutputContext { int bit_buffer_size; uint8_t *bit_buffer; uint64_t video_size; int frame_number; DecodedPicture *delayed_pic[33]; int dp_cnt; }; struct nanos_args_13_t { H264Context *h; MBRecContext *d; SliceBufferEntry *sbe; int *init; }; static void smp_ol_init_ref_list_and_get_dpb_task_27(struct nanos_args_13_t *const args); struct nanos_args_14_t { H264Context *h; SuperMBContext *smbc; MBRecContext *d; SliceBufferEntry *sbe; SuperMBTask *lastsmb; int *release; }; static void smp_ol_release_ref_list_task_29(struct nanos_args_14_t *const args); struct nanos_args_15_t { H264Context *h; OutputContext *oc; SliceBufferEntry *sbe; }; static void smp_ol_output_task_31(struct nanos_args_15_t *const args); struct nanos_args_16_t { H264Context *h; ParserContext *pc; NalContext *nc; SliceBufferEntry *sbe; }; static void smp_ol_parse_task_33(struct nanos_args_16_t *const args); struct nanos_args_17_t { H264Context *h; EntropyContext *ec; SliceBufferEntry *sbe; }; static void smp_ol_decode_slice_entropy_task_35(struct nanos_args_17_t *const args); struct nanos_args_18_t { H264Context *h; MBRecContext *d; SliceBufferEntry *sbe; }; static void smp_ol_decode_slice_mb_task_37(struct nanos_args_18_t *const args); struct nanos_args_19_t { H264Context *h; OutputContext *oc; SliceBufferEntry *sbe; }; static void smp_ol_output_task_39(struct nanos_args_19_t *const args); extern nanos_err_t nanos_wg_wait_completion(void *wg, _Bool avoid_flush); void free_parse_context(ParserContext *pc); void free_nal_context(NalContext *nc); void free_output_context(OutputContext *oc); void free_sb_entry(SliceBufferEntry *sb); void free_entropy_context(EntropyContext *ec); void av_free(void *ptr); void free_mbrec_context(MBRecContext *d); int h264_decode_ompss(H264Context *h) { SliceBufferEntry *sbe; ParserContext *pc; NalContext *nc; MBRecContext *rc[2]; OutputContext *oc; int init; SuperMBContext *smbc; int release; DecodedPicture *out; const int bufs = (*h).pipe_bufs; EntropyContext *ec[bufs]; int frames = 0; sbe = av_mallocz(sizeof(SliceBufferEntry) * bufs); pc = get_parse_context((*h).ifile); nc = get_nal_context((*h).width, (*h).height); for (int i = 0; i < bufs; i++) { { ec[i] = get_entropy_context(h); } } for (int i = 0; i < 2; i++) { { rc[i] = get_mbrec_context(h); } } oc = get_output_context(h); av_start_timer(); int k = 0; if ((*h).static_3d && bufs < (*h).num_frames) { { int num_pre_ed = 0; for (num_pre_ed = 0; num_pre_ed < bufs - 1 && !(*pc).final_frame; num_pre_ed++) { { nanos_err_t mcc_err_in_final_6; _Bool mcc_is_in_final_6; nanos_err_t mcc_err_in_final_7; _Bool mcc_is_in_final_7; mcc_err_in_final_6 = nanos_in_final(&mcc_is_in_final_6); { H264Context *mcc_arg_34 = h; ParserContext *mcc_arg_35 = pc; NalContext *mcc_arg_36 = nc; SliceBufferEntry *mcc_arg_37 = &sbe[k % bufs]; if (mcc_is_in_final_6) { parse_task(h, pc, nc, &sbe[k % bufs]); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_6_t *ol_args; nanos_err_t err; struct nanos_args_6_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_6_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_34; (*ol_args).pc = mcc_arg_35; (*ol_args).nc = mcc_arg_36; (*ol_args).sbe = mcc_arg_37; nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 3, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_34; imm_args.pc = mcc_arg_35; imm_args.nc = mcc_arg_36; imm_args.sbe = mcc_arg_37; nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } mcc_err_in_final_7 = nanos_in_final(&mcc_is_in_final_7); { H264Context *mcc_arg_38 = h; EntropyContext *mcc_arg_39 = ec[k % bufs]; SliceBufferEntry *mcc_arg_40 = &sbe[k % bufs]; if (mcc_is_in_final_7) { decode_slice_entropy_task(h, ec[k % bufs], &sbe[k % bufs]); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_7_t *ol_args; nanos_err_t err; struct nanos_args_7_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_7_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_38; (*ol_args).ec = mcc_arg_39; (*ol_args).sbe = mcc_arg_40; nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 2, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_38; imm_args.ec = mcc_arg_39; imm_args.sbe = mcc_arg_40; nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } { nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } }; nanos_data_access_t dependences[1] = { { (void *)pc, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 } }; ; nanos_err_t err = nanos_wait_on(1, dependences); if (err != NANOS_OK) { nanos_handle_error(err); } } k++; } } while ((!(*pc).final_frame && frames++ < (*h).num_frames) && !(*h).quit) { { nanos_err_t mcc_err_in_final_8; _Bool mcc_is_in_final_8; nanos_err_t mcc_err_in_final_9; _Bool mcc_is_in_final_9; nanos_err_t mcc_err_in_final_10; _Bool mcc_is_in_final_10; nanos_err_t mcc_err_in_final_11; _Bool mcc_is_in_final_11; nanos_err_t mcc_err_in_final_12; _Bool mcc_is_in_final_12; mcc_err_in_final_8 = nanos_in_final(&mcc_is_in_final_8); { H264Context *mcc_arg_41 = h; ParserContext *mcc_arg_42 = pc; NalContext *mcc_arg_43 = nc; SliceBufferEntry *mcc_arg_44 = &sbe[k % bufs]; if (mcc_is_in_final_8) { parse_task(h, pc, nc, &sbe[k % bufs]); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_8_t *ol_args; nanos_err_t err; struct nanos_args_8_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_8_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_41; (*ol_args).pc = mcc_arg_42; (*ol_args).nc = mcc_arg_43; (*ol_args).sbe = mcc_arg_44; nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 3, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_41; imm_args.pc = mcc_arg_42; imm_args.nc = mcc_arg_43; imm_args.sbe = mcc_arg_44; nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } mcc_err_in_final_9 = nanos_in_final(&mcc_is_in_final_9); { H264Context *mcc_arg_45 = h; EntropyContext *mcc_arg_46 = ec[k % bufs]; SliceBufferEntry *mcc_arg_47 = &sbe[k % bufs]; if (mcc_is_in_final_9) { decode_slice_entropy_task(h, ec[k % bufs], &sbe[k % bufs]); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_9_t *ol_args; nanos_err_t err; struct nanos_args_9_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_9_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_45; (*ol_args).ec = mcc_arg_46; (*ol_args).sbe = mcc_arg_47; nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 2, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_45; imm_args.ec = mcc_arg_46; imm_args.sbe = mcc_arg_47; nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } k++; mcc_err_in_final_10 = nanos_in_final(&mcc_is_in_final_10); { H264Context *mcc_arg_48 = h; MBRecContext *mcc_arg_49 = rc[k % 2]; SliceBufferEntry *mcc_arg_50 = &sbe[k % bufs]; int *mcc_arg_51 = &init; if (mcc_is_in_final_10) { init_ref_list_and_get_dpb_task(h, rc[k % 2], &sbe[k % bufs], &init); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_10_t *ol_args; nanos_err_t err; struct nanos_args_10_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_10_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_48; (*ol_args).d = mcc_arg_49; (*ol_args).sbe = mcc_arg_50; (*ol_args).init = mcc_arg_51; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(int), 0, sizeof(int) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 3, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_48; imm_args.d = mcc_arg_49; imm_args.sbe = mcc_arg_50; imm_args.init = mcc_arg_51; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(int), 0, sizeof(int) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } smbc = acquire_smbc(h); SuperMBTask *lastsmb = add_decode_slice_3dwave_tasks(rc[k % 2], &sbe[k % bufs], smbc); mcc_err_in_final_11 = nanos_in_final(&mcc_is_in_final_11); { H264Context *mcc_arg_52 = h; SuperMBContext *mcc_arg_53 = smbc; MBRecContext *mcc_arg_54 = rc[k % 2]; SliceBufferEntry *mcc_arg_55 = &sbe[k % bufs]; SuperMBTask *mcc_arg_56 = lastsmb; int *mcc_arg_57 = &release; if (mcc_is_in_final_11) { release_ref_list_task(h, smbc, rc[k % 2], &sbe[k % bufs], lastsmb, &release); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_11_t *ol_args; nanos_err_t err; struct nanos_args_11_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_11_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_52; (*ol_args).smbc = mcc_arg_53; (*ol_args).d = mcc_arg_54; (*ol_args).sbe = mcc_arg_55; (*ol_args).lastsmb = mcc_arg_56; (*ol_args).release = mcc_arg_57; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_3[1] = { { sizeof(int), 0, sizeof(int) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 4, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_52; imm_args.smbc = mcc_arg_53; imm_args.d = mcc_arg_54; imm_args.sbe = mcc_arg_55; imm_args.lastsmb = mcc_arg_56; imm_args.release = mcc_arg_57; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_3[1] = { { sizeof(int), 0, sizeof(int) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } mcc_err_in_final_12 = nanos_in_final(&mcc_is_in_final_12); { H264Context *mcc_arg_58 = h; OutputContext *mcc_arg_59 = oc; SliceBufferEntry *mcc_arg_60 = &sbe[k % bufs]; if (mcc_is_in_final_12) { output_task(h, oc, &sbe[k % bufs]); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_12_t *ol_args; nanos_err_t err; struct nanos_args_12_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_12_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_58; (*ol_args).oc = mcc_arg_59; (*ol_args).sbe = mcc_arg_60; nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 2, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_58; imm_args.oc = mcc_arg_59; imm_args.sbe = mcc_arg_60; nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } { nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } }; nanos_data_access_t dependences[1] = { { (void *)pc, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 } }; ; nanos_err_t err = nanos_wait_on(1, dependences); if (err != NANOS_OK) { nanos_handle_error(err); } } } } for (int i = 0; i < num_pre_ed; i++) { { nanos_err_t mcc_err_in_final_13; _Bool mcc_is_in_final_13; nanos_err_t mcc_err_in_final_14; _Bool mcc_is_in_final_14; nanos_err_t mcc_err_in_final_15; _Bool mcc_is_in_final_15; k++; mcc_err_in_final_13 = nanos_in_final(&mcc_is_in_final_13); { H264Context *mcc_arg_61 = h; MBRecContext *mcc_arg_62 = rc[k % 2]; SliceBufferEntry *mcc_arg_63 = &sbe[k % bufs]; int *mcc_arg_64 = &init; if (mcc_is_in_final_13) { init_ref_list_and_get_dpb_task(h, rc[k % 2], &sbe[k % bufs], &init); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_13_t *ol_args; nanos_err_t err; struct nanos_args_13_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_13_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_61; (*ol_args).d = mcc_arg_62; (*ol_args).sbe = mcc_arg_63; (*ol_args).init = mcc_arg_64; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(int), 0, sizeof(int) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 3, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_61; imm_args.d = mcc_arg_62; imm_args.sbe = mcc_arg_63; imm_args.init = mcc_arg_64; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(int), 0, sizeof(int) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } smbc = acquire_smbc(h); SuperMBTask *lastsmb = add_decode_slice_3dwave_tasks(rc[k % 2], &sbe[k % bufs], smbc); mcc_err_in_final_14 = nanos_in_final(&mcc_is_in_final_14); { H264Context *mcc_arg_65 = h; SuperMBContext *mcc_arg_66 = smbc; MBRecContext *mcc_arg_67 = rc[k % 2]; SliceBufferEntry *mcc_arg_68 = &sbe[k % bufs]; SuperMBTask *mcc_arg_69 = lastsmb; int *mcc_arg_70 = &release; if (mcc_is_in_final_14) { release_ref_list_task(h, smbc, rc[k % 2], &sbe[k % bufs], lastsmb, &release); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_14_t *ol_args; nanos_err_t err; struct nanos_args_14_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_14_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_65; (*ol_args).smbc = mcc_arg_66; (*ol_args).d = mcc_arg_67; (*ol_args).sbe = mcc_arg_68; (*ol_args).lastsmb = mcc_arg_69; (*ol_args).release = mcc_arg_70; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_3[1] = { { sizeof(int), 0, sizeof(int) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 4, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_65; imm_args.smbc = mcc_arg_66; imm_args.d = mcc_arg_67; imm_args.sbe = mcc_arg_68; imm_args.lastsmb = mcc_arg_69; imm_args.release = mcc_arg_70; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SuperMBTask), 0, sizeof(SuperMBTask) } }; nanos_region_dimension_t dimensions_3[1] = { { sizeof(int), 0, sizeof(int) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } mcc_err_in_final_15 = nanos_in_final(&mcc_is_in_final_15); { H264Context *mcc_arg_71 = h; OutputContext *mcc_arg_72 = oc; SliceBufferEntry *mcc_arg_73 = &sbe[k % bufs]; if (mcc_is_in_final_15) { output_task(h, oc, &sbe[k % bufs]); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_15_t *ol_args; nanos_err_t err; struct nanos_args_15_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_15_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_71; (*ol_args).oc = mcc_arg_72; (*ol_args).sbe = mcc_arg_73; nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 2, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_71; imm_args.oc = mcc_arg_72; imm_args.sbe = mcc_arg_73; nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } } } } } else { { while ((!(*pc).final_frame && frames++ < (*h).num_frames) && !(*h).quit) { { nanos_err_t mcc_err_in_final_16; _Bool mcc_is_in_final_16; nanos_err_t mcc_err_in_final_17; _Bool mcc_is_in_final_17; nanos_err_t mcc_err_in_final_18; _Bool mcc_is_in_final_18; nanos_err_t mcc_err_in_final_19; _Bool mcc_is_in_final_19; mcc_err_in_final_16 = nanos_in_final(&mcc_is_in_final_16); { H264Context *mcc_arg_74 = h; ParserContext *mcc_arg_75 = pc; NalContext *mcc_arg_76 = nc; SliceBufferEntry *mcc_arg_77 = &sbe[k % bufs]; if (mcc_is_in_final_16) { parse_task(h, pc, nc, &sbe[k % bufs]); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_16_t *ol_args; nanos_err_t err; struct nanos_args_16_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_16_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_74; (*ol_args).pc = mcc_arg_75; (*ol_args).nc = mcc_arg_76; (*ol_args).sbe = mcc_arg_77; nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 3, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_74; imm_args.pc = mcc_arg_75; imm_args.nc = mcc_arg_76; imm_args.sbe = mcc_arg_77; nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(NalContext), 0, sizeof(NalContext) } }; nanos_region_dimension_t dimensions_2[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } mcc_err_in_final_17 = nanos_in_final(&mcc_is_in_final_17); { H264Context *mcc_arg_78 = h; EntropyContext *mcc_arg_79 = ec[k % bufs]; SliceBufferEntry *mcc_arg_80 = &sbe[k % bufs]; if (mcc_is_in_final_17) { decode_slice_entropy_task(h, ec[k % bufs], &sbe[k % bufs]); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_17_t *ol_args; nanos_err_t err; struct nanos_args_17_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_17_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_78; (*ol_args).ec = mcc_arg_79; (*ol_args).sbe = mcc_arg_80; nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 2, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_78; imm_args.ec = mcc_arg_79; imm_args.sbe = mcc_arg_80; nanos_region_dimension_t dimensions_0[1] = { { sizeof(EntropyContext), 0, sizeof(EntropyContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } mcc_err_in_final_18 = nanos_in_final(&mcc_is_in_final_18); { H264Context *mcc_arg_81 = h; MBRecContext *mcc_arg_82 = rc[0]; SliceBufferEntry *mcc_arg_83 = &sbe[k % bufs]; if (mcc_is_in_final_18) { decode_slice_mb_task(h, rc[0], &sbe[k % bufs]); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_18_t *ol_args; nanos_err_t err; struct nanos_args_18_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_18_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_81; (*ol_args).d = mcc_arg_82; (*ol_args).sbe = mcc_arg_83; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 2, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_81; imm_args.d = mcc_arg_82; imm_args.sbe = mcc_arg_83; nanos_region_dimension_t dimensions_0[1] = { { sizeof(MBRecContext), 0, sizeof(MBRecContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } mcc_err_in_final_19 = nanos_in_final(&mcc_is_in_final_19); { H264Context *mcc_arg_84 = h; OutputContext *mcc_arg_85 = oc; SliceBufferEntry *mcc_arg_86 = &sbe[k % bufs]; if (mcc_is_in_final_19) { output_task(h, oc, &sbe[k % bufs]); } else { { nanos_wd_dyn_props_t nanos_wd_dyn_props; struct nanos_args_19_t *ol_args; nanos_err_t err; struct nanos_args_19_t imm_args; 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 }; 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 } } }; nanos_wd_dyn_props.tie_to = 0; nanos_wd_dyn_props.priority = 0; nanos_wd_dyn_props.flags.is_final = 0; ol_args = (struct nanos_args_19_t *)0; void *nanos_wd_ = (void *)0; 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); if (err != NANOS_OK) { nanos_handle_error(err); } /* Check pendant writes on subexpressions */ /* End check pendant writes on subexpressions */ if (nanos_wd_ != (void *)0) { { (*ol_args).h = mcc_arg_84; (*ol_args).oc = mcc_arg_85; (*ol_args).sbe = mcc_arg_86; nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; err = nanos_submit(nanos_wd_, 2, dependences, (void *)0); if (err != NANOS_OK) { nanos_handle_error(err); } } } else { { imm_args.h = mcc_arg_84; imm_args.oc = mcc_arg_85; imm_args.sbe = mcc_arg_86; nanos_region_dimension_t dimensions_0[1] = { { sizeof(OutputContext), 0, sizeof(OutputContext) } }; nanos_region_dimension_t dimensions_1[1] = { { sizeof(SliceBufferEntry), 0, sizeof(SliceBufferEntry) } }; 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 } }; ; 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); if (err != NANOS_OK) { nanos_handle_error(err); } } } } } } { nanos_region_dimension_t dimensions_0[1] = { { sizeof(ParserContext), 0, sizeof(ParserContext) } }; nanos_data_access_t dependences[1] = { { (void *)pc, { 1, 1, 0, 0, 0 }, 1, dimensions_0, 0 } }; ; nanos_err_t err = nanos_wait_on(1, dependences); if (err != NANOS_OK) { nanos_handle_error(err); } } k++; } } } } { nanos_err_t err; void *nanos_wd_ = nanos_current_wd(); err = nanos_wg_wait_completion(nanos_wd_, 0); if (err != NANOS_OK) { nanos_handle_error(err); } } while ((out = output_frame(h, oc, (void *)0, (*h).ofile, (*h).frame_width, (*h).frame_height))) { ; } (*h).num_frames = (*oc).frame_number; free_parse_context(pc); free_nal_context(nc); free_output_context(oc); for (int i = 0; i < bufs; i++) { { free_sb_entry(&sbe[i]); free_entropy_context(ec[i]); } } av_free(sbe); for (int i = 0; i < 2; i++) { { free_mbrec_context(rc[i]); } } return 0; } 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) { { decode_super_mb_task((*d), (*sbe), (*smbc), (*ml), (*mur), (*m)); } } static void smp_ol_decode_super_mb_task_1(struct nanos_args_0_t *const args) { { smp_ol_decode_super_mb_task_1_unpacked(&((*args).d), &((*args).sbe), &((*args).smbc), &((*args).ml), &((*args).mur), &((*args).m)); } } static void smp_ol_draw_edges_task_3_unpacked(MBRecContext **const d, SliceBufferEntry **const sbe, SuperMBContext **const smbc, SuperMBTask **const sm, int *const line) { { draw_edges_task((*d), (*sbe), (*smbc), (*sm), (*line)); } } static void smp_ol_draw_edges_task_3(struct nanos_args_1_t *const args) { { smp_ol_draw_edges_task_3_unpacked(&((*args).d), &((*args).sbe), &((*args).smbc), &((*args).sm), &((*args).line)); } } 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) { { decode_3dwave_super_mb_task((*d), (*sbe), (*smbc), (*ml), (*mur), (*mprev), (*m)); } } static void smp_ol_decode_3dwave_super_mb_task_5(struct nanos_args_2_t *const args) { { smp_ol_decode_3dwave_super_mb_task_5_unpacked(&((*args).d), &((*args).sbe), &((*args).smbc), &((*args).ml), &((*args).mur), &((*args).mprev), &((*args).m)); } } static void smp_ol_draw_edges_task_7_unpacked(MBRecContext **const d, SliceBufferEntry **const sbe, SuperMBContext **const smbc, SuperMBTask **const sm, int *const line) { { draw_edges_task((*d), (*sbe), (*smbc), (*sm), (*line)); } } static void smp_ol_draw_edges_task_7(struct nanos_args_3_t *const args) { { smp_ol_draw_edges_task_7_unpacked(&((*args).d), &((*args).sbe), &((*args).smbc), &((*args).sm), &((*args).line)); } } 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) { { decode_super_mb_task((*d), (*sbe), (*smbc), (*ml), (*mur), (*m)); } } static void smp_ol_decode_super_mb_task_9(struct nanos_args_4_t *const args) { { smp_ol_decode_super_mb_task_9_unpacked(&((*args).d), &((*args).sbe), &((*args).smbc), &((*args).ml), &((*args).mur), &((*args).m)); } } static void smp_ol_draw_edges_task_11_unpacked(MBRecContext **const d, SliceBufferEntry **const sbe, SuperMBContext **const smbc, SuperMBTask **const sm, int *const line) { { draw_edges_task((*d), (*sbe), (*smbc), (*sm), (*line)); } } static void smp_ol_draw_edges_task_11(struct nanos_args_5_t *const args) { { smp_ol_draw_edges_task_11_unpacked(&((*args).d), &((*args).sbe), &((*args).smbc), &((*args).sm), &((*args).line)); } } static void smp_ol_parse_task_13_unpacked(H264Context **const h, ParserContext **const pc, NalContext **const nc, SliceBufferEntry **const sbe) { { parse_task((*h), (*pc), (*nc), (*sbe)); } } static void smp_ol_parse_task_13(struct nanos_args_6_t *const args) { { smp_ol_parse_task_13_unpacked(&((*args).h), &((*args).pc), &((*args).nc), &((*args).sbe)); } } static void smp_ol_decode_slice_entropy_task_15_unpacked(H264Context **const h, EntropyContext **const ec, SliceBufferEntry **const sbe) { { decode_slice_entropy_task((*h), (*ec), (*sbe)); } } static void smp_ol_decode_slice_entropy_task_15(struct nanos_args_7_t *const args) { { smp_ol_decode_slice_entropy_task_15_unpacked(&((*args).h), &((*args).ec), &((*args).sbe)); } } static void smp_ol_parse_task_17_unpacked(H264Context **const h, ParserContext **const pc, NalContext **const nc, SliceBufferEntry **const sbe) { { parse_task((*h), (*pc), (*nc), (*sbe)); } } static void smp_ol_parse_task_17(struct nanos_args_8_t *const args) { { smp_ol_parse_task_17_unpacked(&((*args).h), &((*args).pc), &((*args).nc), &((*args).sbe)); } } static void smp_ol_decode_slice_entropy_task_19_unpacked(H264Context **const h, EntropyContext **const ec, SliceBufferEntry **const sbe) { { decode_slice_entropy_task((*h), (*ec), (*sbe)); } } static void smp_ol_decode_slice_entropy_task_19(struct nanos_args_9_t *const args) { { smp_ol_decode_slice_entropy_task_19_unpacked(&((*args).h), &((*args).ec), &((*args).sbe)); } } 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) { { init_ref_list_and_get_dpb_task((*h), (*d), (*sbe), (*init)); } } static void smp_ol_init_ref_list_and_get_dpb_task_21(struct nanos_args_10_t *const args) { { smp_ol_init_ref_list_and_get_dpb_task_21_unpacked(&((*args).h), &((*args).d), &((*args).sbe), &((*args).init)); } } 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) { { release_ref_list_task((*h), (*smbc), (*d), (*sbe), (*lastsmb), (*release)); } } static void smp_ol_release_ref_list_task_23(struct nanos_args_11_t *const args) { { smp_ol_release_ref_list_task_23_unpacked(&((*args).h), &((*args).smbc), &((*args).d), &((*args).sbe), &((*args).lastsmb), &((*args).release)); } } static void smp_ol_output_task_25_unpacked(H264Context **const h, OutputContext **const oc, SliceBufferEntry **const sbe) { { output_task((*h), (*oc), (*sbe)); } } static void smp_ol_output_task_25(struct nanos_args_12_t *const args) { { smp_ol_output_task_25_unpacked(&((*args).h), &((*args).oc), &((*args).sbe)); } } 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) { { init_ref_list_and_get_dpb_task((*h), (*d), (*sbe), (*init)); } } static void smp_ol_init_ref_list_and_get_dpb_task_27(struct nanos_args_13_t *const args) { { smp_ol_init_ref_list_and_get_dpb_task_27_unpacked(&((*args).h), &((*args).d), &((*args).sbe), &((*args).init)); } } 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) { { release_ref_list_task((*h), (*smbc), (*d), (*sbe), (*lastsmb), (*release)); } } static void smp_ol_release_ref_list_task_29(struct nanos_args_14_t *const args) { { smp_ol_release_ref_list_task_29_unpacked(&((*args).h), &((*args).smbc), &((*args).d), &((*args).sbe), &((*args).lastsmb), &((*args).release)); } } static void smp_ol_output_task_31_unpacked(H264Context **const h, OutputContext **const oc, SliceBufferEntry **const sbe) { { output_task((*h), (*oc), (*sbe)); } } static void smp_ol_output_task_31(struct nanos_args_15_t *const args) { { smp_ol_output_task_31_unpacked(&((*args).h), &((*args).oc), &((*args).sbe)); } } static void smp_ol_parse_task_33_unpacked(H264Context **const h, ParserContext **const pc, NalContext **const nc, SliceBufferEntry **const sbe) { { parse_task((*h), (*pc), (*nc), (*sbe)); } } static void smp_ol_parse_task_33(struct nanos_args_16_t *const args) { { smp_ol_parse_task_33_unpacked(&((*args).h), &((*args).pc), &((*args).nc), &((*args).sbe)); } } static void smp_ol_decode_slice_entropy_task_35_unpacked(H264Context **const h, EntropyContext **const ec, SliceBufferEntry **const sbe) { { decode_slice_entropy_task((*h), (*ec), (*sbe)); } } static void smp_ol_decode_slice_entropy_task_35(struct nanos_args_17_t *const args) { { smp_ol_decode_slice_entropy_task_35_unpacked(&((*args).h), &((*args).ec), &((*args).sbe)); } } static void smp_ol_decode_slice_mb_task_37_unpacked(H264Context **const h, MBRecContext **const d, SliceBufferEntry **const sbe) { { decode_slice_mb_task((*h), (*d), (*sbe)); } } static void smp_ol_decode_slice_mb_task_37(struct nanos_args_18_t *const args) { { smp_ol_decode_slice_mb_task_37_unpacked(&((*args).h), &((*args).d), &((*args).sbe)); } } static void smp_ol_output_task_39_unpacked(H264Context **const h, OutputContext **const oc, SliceBufferEntry **const sbe) { { output_task((*h), (*oc), (*sbe)); } } static void smp_ol_output_task_39(struct nanos_args_19_t *const args) { { smp_ol_output_task_39_unpacked(&((*args).h), &((*args).oc), &((*args).sbe)); } } typedef void nanos_init_func_t(void *); struct mcc_struct_anon_22 { void (*func)(void *); void *data; }; typedef struct mcc_struct_anon_22 nanos_init_desc_t; void nanos_omp_set_interface(void *); __attribute__((weak)) __attribute__((section("nanos_init"))) nanos_init_desc_t __section__nanos_init = { nanos_omp_set_interface, (void *)0 };