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