commit 69259af52c815d64657b5c38782f08681c57c6e6
parent 1af6a17bd21050902fb88e6b134a0fa9273c73b2
Author: Jack Mordaunt <jackmordaunt.dev@gmail.com>
Date: Wed, 26 Jan 2022 00:21:30 +0800
webp: upgrade deps
Bump libc to include bsearch and regenerate libwebp.
Signed-off-by: Jack Mordaunt <jackmordaunt.dev@gmail.com>
Diffstat:
| M | go.mod | | | 8 | ++++---- |
| M | go.sum | | | 9 | +++++++++ |
| M | libwebp.go | | | 14298 | +++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | main.go | | | 49 | ++----------------------------------------------- |
4 files changed, 7015 insertions(+), 7349 deletions(-)
diff --git a/go.mod b/go.mod
@@ -1,14 +1,14 @@
module git.sr.ht/~jackmordaunt/go-libwebp
-go 1.18
+go 1.17
-require modernc.org/libc v1.14.4
+require modernc.org/libc v1.14.5
require (
github.com/google/uuid v1.3.0 // indirect
- github.com/mattn/go-isatty v0.0.12 // indirect
+ github.com/mattn/go-isatty v0.0.14 // indirect
github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
- golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac // indirect
+ golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 // indirect
modernc.org/mathutil v1.4.1 // indirect; sindirect
modernc.org/memory v1.0.5 // indirect
)
diff --git a/go.sum b/go.sum
@@ -5,6 +5,8 @@ github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+
github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 h1:OdAsTTz6OkFY5QxjkYwrChwuRruF69c169dPK26NUlk=
github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
@@ -23,9 +25,12 @@ golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7w
golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201126233918-771906719818/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210902050250-f475640dd07b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac h1:oN6lz7iLW/YC7un8pq+9bOLyXrprv2+DKfkJY+2LJJw=
golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 h1:XfKQ4OlFl8okEOr5UvAqFRVj8pY/4yfcXrddB8qAbU0=
+golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -92,6 +97,7 @@ modernc.org/ccgo/v3 v3.12.92/go.mod h1:5yDdN7ti9KWPi5bRVWPl8UNhpEAtCjuEE7ayQnzzq
modernc.org/ccgo/v3 v3.13.1/go.mod h1:aBYVOUfIlcSnrsRVU8VRS35y2DIfpgkmVkYZ0tpIXi4=
modernc.org/ccgo/v3 v3.15.9/go.mod h1:md59wBwDT2LznX/OTCPoVS6KIsdRgY8xqQwBV+hkTH0=
modernc.org/ccgo/v3 v3.15.10/go.mod h1:wQKxoFn0ynxMuCLfFD09c8XPUCc8obfchoVR9Cn0fI8=
+modernc.org/ccgo/v3 v3.15.12/go.mod h1:VFePOWoCd8uDGRJpq/zfJ29D0EVzMSyID8LCMWYbX6I=
modernc.org/ccorpus v1.11.1/go.mod h1:2gEUTrWqdpH2pXsmTM1ZkjeSrUWDpjMu2T6m29L/ErQ=
modernc.org/httpfs v1.0.6/go.mod h1:7dosgurJGp0sPaRanU53W4xZYKh14wfzX420oZADeHM=
modernc.org/libc v1.9.8/go.mod h1:U1eq8YWr/Kc1RWCMFUWEdkTg8OTcfLw2kY8EDwl039w=
@@ -134,8 +140,11 @@ modernc.org/libc v1.11.101/go.mod h1:wLLYgEiY2D17NbBOEp+mIJJJBGSiy7fLL4ZrGGZ+8jI
modernc.org/libc v1.12.0/go.mod h1:2MH3DaF/gCU8i/UBiVE1VFRos4o523M7zipmwH8SIgQ=
modernc.org/libc v1.14.1/go.mod h1:npFeGWjmZTjFeWALQLrvklVmAxv4m80jnG3+xI8FdJk=
modernc.org/libc v1.14.2/go.mod h1:MX1GBLnRLNdvmK9azU9LCxZ5lMyhrbEMK8rG3X/Fe34=
+modernc.org/libc v1.14.3/go.mod h1:GPIvQVOVPizzlqyRX3l756/3ppsAgg1QgPxjr5Q4agQ=
modernc.org/libc v1.14.4 h1:Sw2GDhSQbQF75VKC6RSd5//QH2gj9TgBzjLNZTW6m00=
modernc.org/libc v1.14.4/go.mod h1:GPIvQVOVPizzlqyRX3l756/3ppsAgg1QgPxjr5Q4agQ=
+modernc.org/libc v1.14.5 h1:DAHvwGoVRDZs5iJXnX9RJrgXSsorupCWmJ2ac964Owk=
+modernc.org/libc v1.14.5/go.mod h1:2PJHINagVxO4QW/5OQdRrvMYo+bm5ClpUFfyXCYl9ak=
modernc.org/mathutil v1.1.1/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
modernc.org/mathutil v1.2.2/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
modernc.org/mathutil v1.4.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
diff --git a/libwebp.go b/libwebp.go
@@ -1,3 +1,5 @@
+// Code generated by 'ccgo -trace-translation-units cdb.json src/.libs/libwebp.a', DO NOT EDIT.
+
package main
import (
@@ -17,8 +19,6 @@ var _ unsafe.Pointer
var _ *libc.TLS
var _ types.Size_t
-//------------------------------------------------------------------------------
-
// Copyright 2011 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
@@ -28,20 +28,7 @@ var _ types.Size_t
// be found in the AUTHORS file in the root of the source tree.
// -----------------------------------------------------------------------------
//
-// Internal header: WebP decoding parameters and custom IO on buffer
-//
-// Author: somnath@google.com (Somnath Banerjee)
-
-// Copyright 2010 Google Inc. All Rights Reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the COPYING file in the root of the source
-// tree. An additional intellectual property rights grant can be found
-// in the file PATENTS. All contributing project authors may
-// be found in the AUTHORS file in the root of the source tree.
-// -----------------------------------------------------------------------------
-//
-// VP8 decoder: internal header.
+// WebP encoder: internal header.
//
// Author: Skal (pascal.massimino@gmail.com)
@@ -194,75 +181,6 @@ const ( /* dsp.h:696:1: */ // Filter types.
)
//------------------------------------------------------------------------------
-// Transform-related functions use din both encoding and decoding.
-
-// Macros used to create a batch predictor that iteratively uses a
-// one-pixel predictor.
-
-// The predictor is added to the output pixel (which
-// is therefore considered as a residual) to get the final prediction.
-
-// Copyright 2010 Google Inc. All Rights Reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the COPYING file in the root of the source
-// tree. An additional intellectual property rights grant can be found
-// in the file PATENTS. All contributing project authors may
-// be found in the AUTHORS file in the root of the source tree.
-// -----------------------------------------------------------------------------
-//
-// inline YUV<->RGB conversion function
-//
-// The exact naming is Y'CbCr, following the ITU-R BT.601 standard.
-// More information at: https://en.wikipedia.org/wiki/YCbCr
-// Y = 0.2569 * R + 0.5044 * G + 0.0979 * B + 16
-// U = -0.1483 * R - 0.2911 * G + 0.4394 * B + 128
-// V = 0.4394 * R - 0.3679 * G - 0.0715 * B + 128
-// We use 16bit fixed point operations for RGB->YUV conversion (YUV_FIX).
-//
-// For the Y'CbCr to RGB conversion, the BT.601 specification reads:
-// R = 1.164 * (Y-16) + 1.596 * (V-128)
-// G = 1.164 * (Y-16) - 0.813 * (V-128) - 0.391 * (U-128)
-// B = 1.164 * (Y-16) + 2.018 * (U-128)
-// where Y is in the [16,235] range, and U/V in the [16,240] range.
-//
-// The fixed-point implementation used here is:
-// R = (19077 . y + 26149 . v - 14234) >> 6
-// G = (19077 . y - 6419 . u - 13320 . v + 8708) >> 6
-// B = (19077 . y + 33050 . u - 17685) >> 6
-// where the '.' operator is the mulhi_epu16 variant:
-// a . b = ((a << 8) * b) >> 16
-// that preserves 8 bits of fractional precision before final descaling.
-
-// Author: Skal (pascal.massimino@gmail.com)
-
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the COPYING file in the root of the source
-// tree. An additional intellectual property rights grant can be found
-// in the file PATENTS. All contributing project authors may
-// be found in the AUTHORS file in the root of the source tree.
-// -----------------------------------------------------------------------------
-//
-// Speed-critical functions.
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-// Copyright 2010 Google Inc. All Rights Reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the COPYING file in the root of the source
-// tree. An additional intellectual property rights grant can be found
-// in the file PATENTS. All contributing project authors may
-// be found in the AUTHORS file in the root of the source tree.
-// -----------------------------------------------------------------------------
-//
-// Low-level API for VP8 decoder
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-//------------------------------------------------------------------------------
// YUV -> RGB conversion
const ( /* yuv.h:48:1: */
@@ -303,19 +221,6 @@ const ( /* backward_references_enc.h:32:1: */
//------------------------------------------------------------------------------
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the COPYING file in the root of the source
-// tree. An additional intellectual property rights grant can be found
-// in the file PATENTS. All contributing project authors may
-// be found in the AUTHORS file in the root of the source tree.
-// -----------------------------------------------------------------------------
-//
-// WebP encoder: main interface
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
//------------------------------------------------------------------------------
// Various defines and enums
@@ -334,169 +239,6 @@ const ( /* vp8i_enc.h:42:1: */ // Rate-distortion optimization levels
RD_OPT_TRELLIS_ALL = 3
)
-//------------------------------------------------------------------------------
-
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the COPYING file in the root of the source
-// tree. An additional intellectual property rights grant can be found
-// in the file PATENTS. All contributing project authors may
-// be found in the AUTHORS file in the root of the source tree.
-// -----------------------------------------------------------------------------
-//
-// Lossless encoder: internal header.
-//
-// Author: Vikas Arora (vikaas.arora@gmail.com)
-
-// src/webp/config.h. Generated from config.h.in by configure.
-// src/webp/config.h.in. Generated from configure.ac by autoheader.
-
-// Define if building universal (internal helper macro)
-// #undef AC_APPLE_UNIVERSAL_BUILD
-
-// Set to 1 if __builtin_bswap16 is available
-
-// Set to 1 if __builtin_bswap32 is available
-
-// Set to 1 if __builtin_bswap64 is available
-
-// Define to 1 if you have the <cpu-features.h> header file.
-// #undef HAVE_CPU_FEATURES_H
-
-// Define to 1 if you have the <dlfcn.h> header file.
-
-// Define to 1 if you have the <GLUT/glut.h> header file.
-// #undef HAVE_GLUT_GLUT_H
-
-// Define to 1 if you have the <GL/glut.h> header file.
-// #undef HAVE_GL_GLUT_H
-
-// Define to 1 if you have the <inttypes.h> header file.
-
-// Define to 1 if you have the <OpenGL/glut.h> header file.
-// #undef HAVE_OPENGL_GLUT_H
-
-// Have PTHREAD_PRIO_INHERIT.
-// #undef HAVE_PTHREAD_PRIO_INHERIT
-
-// Define to 1 if you have the <shlwapi.h> header file.
-// #undef HAVE_SHLWAPI_H
-
-// Define to 1 if you have the <stdint.h> header file.
-
-// Define to 1 if you have the <stdio.h> header file.
-
-// Define to 1 if you have the <stdlib.h> header file.
-
-// Define to 1 if you have the <strings.h> header file.
-
-// Define to 1 if you have the <string.h> header file.
-
-// Define to 1 if you have the <sys/stat.h> header file.
-
-// Define to 1 if you have the <sys/types.h> header file.
-
-// Define to 1 if you have the <unistd.h> header file.
-
-// Define to 1 if you have the <wincodec.h> header file.
-// #undef HAVE_WINCODEC_H
-
-// Define to 1 if you have the <windows.h> header file.
-// #undef HAVE_WINDOWS_H
-
-// Define to the sub-directory where libtool stores uninstalled libraries.
-
-// Name of package
-
-// Define to the address where bug reports for this package should be sent.
-
-// Define to the full name of this package.
-
-// Define to the full name and version of this package.
-
-// Define to the one symbol short name of this package.
-
-// Define to the home page for this package.
-
-// Define to the version of this package.
-
-// Define to necessary symbol if this constant uses a non-standard name on
-// your system.
-// #undef PTHREAD_CREATE_JOINABLE
-
-// Define to 1 if all of the C90 standard headers exist (not just the ones
-// required in a freestanding environment). This macro is provided for
-// backward compatibility; new code need not use it.
-
-// Version number of package
-
-// Set to 1 if GIF library is installed
-// #undef WEBP_HAVE_GIF
-
-// Set to 1 if OpenGL is supported
-// #undef WEBP_HAVE_GL
-
-// Set to 1 if JPEG library is installed
-// #undef WEBP_HAVE_JPEG
-
-// Set to 1 if NEON is supported
-// #undef WEBP_HAVE_NEON
-
-// Set to 1 if runtime detection of NEON is enabled
-// #undef WEBP_HAVE_NEON_RTCD
-
-// Set to 1 if PNG library is installed
-// #undef WEBP_HAVE_PNG
-
-// Set to 1 if SDL library is installed
-// #undef WEBP_HAVE_SDL
-
-// Set to 1 if SSE2 is supported
-// #undef WEBP_HAVE_SSE2
-
-// Set to 1 if SSE4.1 is supported
-// #undef WEBP_HAVE_SSE41
-
-// Set to 1 if TIFF library is installed
-// #undef WEBP_HAVE_TIFF
-
-// Enable near lossless encoding
-
-// Undefine this to disable thread support.
-// #undef WEBP_USE_THREAD
-
-// Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
-// significant byte first (like Motorola and SPARC, unlike Intel).
-// # undef WORDS_BIGENDIAN
-// Either WEBP_NEAR_LOSSLESS is defined as 0 in config.h when compiling to
-// disable near-lossless, or it is enabled by default.
-
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the COPYING file in the root of the source
-// tree. An additional intellectual property rights grant can be found
-// in the file PATENTS. All contributing project authors may
-// be found in the AUTHORS file in the root of the source tree.
-// -----------------------------------------------------------------------------
-//
-// Author: Jyrki Alakuijala (jyrki@google.com)
-//
-
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the COPYING file in the root of the source
-// tree. An additional intellectual property rights grant can be found
-// in the file PATENTS. All contributing project authors may
-// be found in the AUTHORS file in the root of the source tree.
-// -----------------------------------------------------------------------------
-//
-// Author: Jyrki Alakuijala (jyrki@google.com)
-//
-// Models the histograms of literal and distance codes.
-
// Copyright 2011 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
@@ -797,8 +539,6 @@ const ( /* encode.h:86:1: */
WEBP_HINT_LAST = 4
)
-//------------------------------------------------------------------------------
-
// Copyright 2012 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
@@ -2296,12 +2036,12 @@ type WebPRescaler = WebPRescaler1 /* rescaler_utils.h:30:29 */
// Return true if output is finished
func WebPRescalerOutputDone(tls *libc.TLS, rescaler uintptr) int32 { /* rescaler_utils.h:86:5: */
- return (libc.Bool32((*WebPRescaler)(unsafe.Pointer(rescaler)).dst_y >= (*WebPRescaler)(unsafe.Pointer(rescaler)).dst_height))
+ return libc.Bool32((*WebPRescaler)(unsafe.Pointer(rescaler)).dst_y >= (*WebPRescaler)(unsafe.Pointer(rescaler)).dst_height)
}
// Return true if there are pending output rows ready.
func WebPRescalerHasPendingOutput(tls *libc.TLS, rescaler uintptr) int32 { /* rescaler_utils.h:92:5: */
- return (libc.Bool32(!(WebPRescalerOutputDone(tls, rescaler) != 0) && ((*WebPRescaler)(unsafe.Pointer(rescaler)).y_accum <= 0)))
+ return libc.Bool32(!(WebPRescalerOutputDone(tls, rescaler) != 0) && (*WebPRescaler)(unsafe.Pointer(rescaler)).y_accum <= 0)
}
//------------------------------------------------------------------------------
@@ -2505,15 +2245,15 @@ type WEBP_CSP_MODE = uint32 /* decode.h:162:3 */
// Some useful macros:
func WebPIsPremultipliedMode(tls *libc.TLS, mode WEBP_CSP_MODE) int32 { /* decode.h:165:24: */
- return (libc.Bool32((((mode == MODE_rgbA) || (mode == MODE_bgrA)) || (mode == MODE_Argb)) || (mode == MODE_rgbA_4444)))
+ return libc.Bool32(mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb || mode == MODE_rgbA_4444)
}
func WebPIsAlphaMode(tls *libc.TLS, mode WEBP_CSP_MODE) int32 { /* decode.h:170:24: */
- return (libc.Bool32((((((mode == MODE_RGBA) || (mode == MODE_BGRA)) || (mode == MODE_ARGB)) || (mode == MODE_RGBA_4444)) || (mode == MODE_YUVA)) || (WebPIsPremultipliedMode(tls, mode) != 0)))
+ return libc.Bool32(mode == MODE_RGBA || mode == MODE_BGRA || mode == MODE_ARGB || mode == MODE_RGBA_4444 || mode == MODE_YUVA || WebPIsPremultipliedMode(tls, mode) != 0)
}
func WebPIsRGBMode(tls *libc.TLS, mode WEBP_CSP_MODE) int32 { /* decode.h:176:24: */
- return (libc.Bool32(mode < MODE_YUV))
+ return libc.Bool32(mode < MODE_YUV)
}
// Initialize the structure as empty. Must be called before any other use.
@@ -3393,14 +3133,14 @@ type VP8LBitReader = struct {
// Return the prefetched bits, so they can be looked up.
func VP8LPrefetchBits(tls *libc.TLS, br uintptr) uint32_t { /* bit_reader_utils.h:164:29: */
- return (uint32_t((*VP8LBitReader)(unsafe.Pointer(br)).val_ >> ((*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ & (64 - 1))))
+ return uint32_t((*VP8LBitReader)(unsafe.Pointer(br)).val_ >> ((*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ & (64 - 1)))
}
// Returns true if there was an attempt at reading bit past the end of
// the buffer. Doesn't set br->eos_ flag.
func VP8LIsEndOfStream(tls *libc.TLS, br uintptr) int32 { /* bit_reader_utils.h:170:24: */
- return (libc.Bool32(((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0) || (((*VP8LBitReader)(unsafe.Pointer(br)).pos_ == (*VP8LBitReader)(unsafe.Pointer(br)).len_) && ((*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ > 64))))
+ return libc.Bool32((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0 || (*VP8LBitReader)(unsafe.Pointer(br)).pos_ == (*VP8LBitReader)(unsafe.Pointer(br)).len_ && (*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ > 64)
}
// For jumping over a number of bits in the bit stream when accessed with
@@ -3514,7 +3254,7 @@ type VP8LColorCache = struct {
var kHashMul uint32_t = 0x1e35a7bd /* color_cache_utils.h:34:23 */
func VP8LHashPix(tls *libc.TLS, argb uint32_t, shift int32) int32 { /* color_cache_utils.h:37:5: */
- return (int32((argb * kHashMul) >> shift))
+ return int32(argb * kHashMul >> shift)
}
func VP8LColorCacheLookup(tls *libc.TLS, cc uintptr, key uint32_t) uint32_t { /* color_cache_utils.h:41:29: */
@@ -3821,11 +3561,11 @@ type VP8Random = struct {
func VP8RandomBits2(tls *libc.TLS, rg uintptr, num_bits int32, amp int32) int32 { /* random_utils.h:39:24: */
var diff int32
- diff = (int32(*(*uint32_t)(unsafe.Pointer((rg + 8 /* &.tab_ */) + uintptr((*VP8Random)(unsafe.Pointer(rg)).index1_)*4)) - *(*uint32_t)(unsafe.Pointer((rg + 8 /* &.tab_ */) + uintptr((*VP8Random)(unsafe.Pointer(rg)).index2_)*4))))
+ diff = int32(*(*uint32_t)(unsafe.Pointer(rg + 8 + uintptr((*VP8Random)(unsafe.Pointer(rg)).index1_)*4)) - *(*uint32_t)(unsafe.Pointer(rg + 8 + uintptr((*VP8Random)(unsafe.Pointer(rg)).index2_)*4)))
if diff < 0 {
- diff = libc.Int32FromUint32(uint32(diff) + (uint32(1) << 31))
+ diff = libc.Int32FromUint32(uint32(diff) + uint32(1)<<31)
}
- *(*uint32_t)(unsafe.Pointer((rg + 8 /* &.tab_ */) + uintptr((*VP8Random)(unsafe.Pointer(rg)).index1_)*4)) = uint32_t(diff)
+ *(*uint32_t)(unsafe.Pointer(rg + 8 + uintptr((*VP8Random)(unsafe.Pointer(rg)).index1_)*4)) = uint32_t(diff)
if libc.PreIncInt32(&(*VP8Random)(unsafe.Pointer(rg)).index1_, 1) == 55 {
(*VP8Random)(unsafe.Pointer(rg)).index1_ = 0
}
@@ -3833,9 +3573,9 @@ func VP8RandomBits2(tls *libc.TLS, rg uintptr, num_bits int32, amp int32) int32
(*VP8Random)(unsafe.Pointer(rg)).index2_ = 0
}
// sign-extend, 0-center
- diff = ((int32(uint32_t(diff) << 1)) >> (32 - num_bits))
- diff = ((diff * amp) >> 8) // restrict range
- diff = diff + (int32(1) << (num_bits - 1)) // shift back to 0.5-center
+ diff = int32(uint32_t(diff)<<1) >> (32 - num_bits)
+ diff = diff * amp >> 8 // restrict range
+ diff = diff + int32(1)<<(num_bits-1) // shift back to 0.5-center
return diff
}
@@ -4785,7 +4525,7 @@ type VP8TopSamples = struct {
// This is the maximum memory amount that libwebp will ever try to allocate.
func CheckSizeOverflow(tls *libc.TLS, size uint64_t) int32 { /* utils.h:45:24: */
- return (libc.Bool32(size == size))
+ return libc.Bool32(size == size)
}
//------------------------------------------------------------------------------
@@ -4817,7 +4557,7 @@ func WebPMemToUint32(tls *libc.TLS, ptr uintptr) uint32_t { /* utils.h:71:29: */
// var A uint32_t at bp, 4
- libc.Xmemcpy(tls, (bp) /* &A */, ptr, uint64(unsafe.Sizeof(uint32_t(0))))
+ libc.Xmemcpy(tls, bp, ptr, uint64(unsafe.Sizeof(uint32_t(0))))
return *(*uint32_t)(unsafe.Pointer(bp /* A */))
}
@@ -4826,7 +4566,7 @@ func WebPUint32ToMem(tls *libc.TLS, ptr uintptr, val uint32_t) { /* utils.h:76:2
defer tls.Free(4)
*(*uint32_t)(unsafe.Pointer(bp)) = val
- libc.Xmemcpy(tls, ptr, (bp) /* &val */, uint64(unsafe.Sizeof(uint32_t(0))))
+ libc.Xmemcpy(tls, ptr, bp, uint64(unsafe.Sizeof(uint32_t(0))))
}
//------------------------------------------------------------------------------
@@ -4834,39 +4574,39 @@ func WebPUint32ToMem(tls *libc.TLS, ptr uintptr, val uint32_t) { /* utils.h:76:2
// Read 16, 24 or 32 bits stored in little-endian order.
func GetLE16(tls *libc.TLS, data uintptr) int32 { /* utils.h:84:24: */
- return ((int32(*(*uint8_t)(unsafe.Pointer(data))) << 0) | (int32(*(*uint8_t)(unsafe.Pointer(data + 1))) << 8))
+ return int32(*(*uint8_t)(unsafe.Pointer(data)))<<0 | int32(*(*uint8_t)(unsafe.Pointer(data + 1)))<<8
}
func GetLE24(tls *libc.TLS, data uintptr) int32 { /* utils.h:88:24: */
- return (GetLE16(tls, data) | (int32(*(*uint8_t)(unsafe.Pointer(data + 2))) << 16))
+ return GetLE16(tls, data) | int32(*(*uint8_t)(unsafe.Pointer(data + 2)))<<16
}
func GetLE32(tls *libc.TLS, data uintptr) uint32_t { /* utils.h:92:29: */
- return (uint32_t(GetLE16(tls, data)) | (uint32_t(GetLE16(tls, (data+uintptr(2)))) << 16))
+ return uint32_t(GetLE16(tls, data)) | uint32_t(GetLE16(tls, data+uintptr(2)))<<16
}
// Store 16, 24 or 32 bits in little-endian order.
func PutLE16(tls *libc.TLS, data uintptr, val int32) { /* utils.h:97:25: */
- *(*uint8_t)(unsafe.Pointer(data)) = (uint8_t((val >> 0) & 0xff))
- *(*uint8_t)(unsafe.Pointer(data + 1)) = (uint8_t((val >> 8) & 0xff))
+ *(*uint8_t)(unsafe.Pointer(data)) = uint8_t(val >> 0 & 0xff)
+ *(*uint8_t)(unsafe.Pointer(data + 1)) = uint8_t(val >> 8 & 0xff)
}
func PutLE24(tls *libc.TLS, data uintptr, val int32) { /* utils.h:103:25: */
- PutLE16(tls, data, (val & 0xffff))
- *(*uint8_t)(unsafe.Pointer(data + 2)) = (uint8_t((val >> 16) & 0xff))
+ PutLE16(tls, data, val&0xffff)
+ *(*uint8_t)(unsafe.Pointer(data + 2)) = uint8_t(val >> 16 & 0xff)
}
func PutLE32(tls *libc.TLS, data uintptr, val uint32_t) { /* utils.h:109:25: */
- PutLE16(tls, data, (int32(val & uint32_t(0xffff))))
- PutLE16(tls, (data + uintptr(2)), (int32(val >> 16)))
+ PutLE16(tls, data, int32(val&uint32_t(0xffff)))
+ PutLE16(tls, data+uintptr(2), int32(val>>16))
}
// use GNU builtins where available.
// Returns (int)floor(log2(n)). n must be > 0.
func BitsLog2Floor(tls *libc.TLS, n uint32_t) int32 { /* utils.h:118:24: */
- return (31 ^ libc.X__builtin_clz(tls, n))
+ return 31 ^ libc.X__builtin_clz(tls, n)
}
//------------------------------------------------------------------------------
@@ -4935,9 +4675,9 @@ func ALPHNew(tls *libc.TLS) uintptr { /* alpha_dec.c:27:19: */
// Clears and deallocates an alpha decoder instance.
func ALPHDelete(tls *libc.TLS, dec uintptr) { /* alpha_dec.c:33:13: */
- if dec != (uintptr(0)) {
+ if dec != uintptr(0) {
VP8LDelete(tls, (*ALPHDecoder)(unsafe.Pointer(dec)).vp8l_dec_)
- (*ALPHDecoder)(unsafe.Pointer(dec)).vp8l_dec_ = (uintptr(0))
+ (*ALPHDecoder)(unsafe.Pointer(dec)).vp8l_dec_ = uintptr(0)
WebPSafeFree(tls, dec)
}
}
@@ -4951,10 +4691,10 @@ func ALPHDelete(tls *libc.TLS, dec uintptr) { /* alpha_dec.c:33:13: */
// compression method or filter, error in lossless header data etc).
func ALPHInit(tls *libc.TLS, dec uintptr, data uintptr, data_size size_t, src_io uintptr, output uintptr) int32 { /* alpha_dec.c:48:12: */
var ok int32 = 0
- var alpha_data uintptr = (data + uintptr(1))
- var alpha_data_size size_t = (data_size - uint64(1))
+ var alpha_data uintptr = data + uintptr(1)
+ var alpha_data_size size_t = data_size - uint64(1)
var rsrv int32
- var io uintptr = (dec + 32 /* &.io_ */)
+ var io uintptr = dec + 32
VP8FiltersInit(tls)
(*ALPHDecoder)(unsafe.Pointer(dec)).output_ = output
@@ -4965,17 +4705,17 @@ func ALPHInit(tls *libc.TLS, dec uintptr, data uintptr, data_size size_t, src_io
return 0
}
- (*ALPHDecoder)(unsafe.Pointer(dec)).method_ = ((int32(*(*uint8_t)(unsafe.Pointer(data))) >> 0) & 0x03)
- (*ALPHDecoder)(unsafe.Pointer(dec)).filter_ = (WEBP_FILTER_TYPE((int32(*(*uint8_t)(unsafe.Pointer(data))) >> 2) & 0x03))
- (*ALPHDecoder)(unsafe.Pointer(dec)).pre_processing_ = ((int32(*(*uint8_t)(unsafe.Pointer(data))) >> 4) & 0x03)
- rsrv = ((int32(*(*uint8_t)(unsafe.Pointer(data))) >> 6) & 0x03)
- if (((((*ALPHDecoder)(unsafe.Pointer(dec)).method_ < 0) || ((*ALPHDecoder)(unsafe.Pointer(dec)).method_ > 1)) || ((*ALPHDecoder)(unsafe.Pointer(dec)).filter_ >= WEBP_FILTER_LAST)) || ((*ALPHDecoder)(unsafe.Pointer(dec)).pre_processing_ > 1)) || (rsrv != 0) {
+ (*ALPHDecoder)(unsafe.Pointer(dec)).method_ = int32(*(*uint8_t)(unsafe.Pointer(data))) >> 0 & 0x03
+ (*ALPHDecoder)(unsafe.Pointer(dec)).filter_ = WEBP_FILTER_TYPE(int32(*(*uint8_t)(unsafe.Pointer(data))) >> 2 & 0x03)
+ (*ALPHDecoder)(unsafe.Pointer(dec)).pre_processing_ = int32(*(*uint8_t)(unsafe.Pointer(data))) >> 4 & 0x03
+ rsrv = int32(*(*uint8_t)(unsafe.Pointer(data))) >> 6 & 0x03
+ if (*ALPHDecoder)(unsafe.Pointer(dec)).method_ < 0 || (*ALPHDecoder)(unsafe.Pointer(dec)).method_ > 1 || (*ALPHDecoder)(unsafe.Pointer(dec)).filter_ >= WEBP_FILTER_LAST || (*ALPHDecoder)(unsafe.Pointer(dec)).pre_processing_ > 1 || rsrv != 0 {
return 0
}
// Copy the necessary parameters from src_io to io
VP8InitIo(tls, io)
- WebPInitCustomIo(tls, (uintptr(0)), io)
+ WebPInitCustomIo(tls, uintptr(0), io)
(*VP8Io)(unsafe.Pointer(io)).opaque = dec
(*VP8Io)(unsafe.Pointer(io)).width = (*VP8Io)(unsafe.Pointer(src_io)).width
(*VP8Io)(unsafe.Pointer(io)).height = (*VP8Io)(unsafe.Pointer(src_io)).height
@@ -4988,8 +4728,8 @@ func ALPHInit(tls *libc.TLS, dec uintptr, data uintptr, data_size size_t, src_io
// No need to copy the scaling parameters.
if (*ALPHDecoder)(unsafe.Pointer(dec)).method_ == 0 {
- var alpha_decoded_size size_t = (size_t((*ALPHDecoder)(unsafe.Pointer(dec)).width_ * (*ALPHDecoder)(unsafe.Pointer(dec)).height_))
- ok = (libc.Bool32(alpha_data_size >= alpha_decoded_size))
+ var alpha_decoded_size size_t = size_t((*ALPHDecoder)(unsafe.Pointer(dec)).width_ * (*ALPHDecoder)(unsafe.Pointer(dec)).height_)
+ ok = libc.Bool32(alpha_data_size >= alpha_decoded_size)
} else {
ok = VP8LDecodeAlphaHeader(tls, dec, alpha_data, alpha_data_size)
@@ -5009,8 +4749,8 @@ func ALPHDecode(tls *libc.TLS, dec uintptr, row int32, num_rows int32) int32 { /
if (*ALPHDecoder)(unsafe.Pointer(alph_dec)).method_ == 0 {
var y int32
var prev_line uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).alpha_prev_line_
- var deltas uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_ + uintptr(1)) + uintptr((row * width)))
- var dst uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_ + uintptr((row * width)))
+ var deltas uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_ + uintptr(1) + uintptr(row*width)
+ var dst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_ + uintptr(row*width)
if (*ALPHDecoder)(unsafe.Pointer(alph_dec)).filter_ != WEBP_FILTER_NONE {
@@ -5024,7 +4764,7 @@ func ALPHDecode(tls *libc.TLS, dec uintptr, row int32, num_rows int32) int32 { /
}
} else {
for y = 0; y < num_rows; y++ {
- libc.Xmemcpy(tls, dst, deltas, (uint64(width) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ libc.Xmemcpy(tls, dst, deltas, uint64(width)*uint64(unsafe.Sizeof(uint8_t(0))))
prev_line = dst
dst += uintptr(width)
deltas += uintptr(width)
@@ -5033,12 +4773,12 @@ func ALPHDecode(tls *libc.TLS, dec uintptr, row int32, num_rows int32) int32 { /
(*VP8Decoder)(unsafe.Pointer(dec)).alpha_prev_line_ = prev_line
} else { // alph_dec->method_ == ALPHA_LOSSLESS_COMPRESSION
- if !(VP8LDecodeAlphaImageStream(tls, alph_dec, (row+num_rows)) != 0) {
+ if !(VP8LDecodeAlphaImageStream(tls, alph_dec, row+num_rows) != 0) {
return 0
}
}
- if (row + num_rows) >= height {
+ if row+num_rows >= height {
(*VP8Decoder)(unsafe.Pointer(dec)).is_alpha_decoded_ = 1
}
return 1
@@ -5047,24 +4787,24 @@ func ALPHDecode(tls *libc.TLS, dec uintptr, row int32, num_rows int32) int32 { /
func AllocateAlphaPlane(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* alpha_dec.c:150:12: */
var stride int32 = (*VP8Io)(unsafe.Pointer(io)).width
var height int32 = (*VP8Io)(unsafe.Pointer(io)).crop_bottom
- var alpha_size uint64_t = (uint64_t(stride) * uint64_t(height))
+ var alpha_size uint64_t = uint64_t(stride) * uint64_t(height)
(*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_mem_ = WebPSafeMalloc(tls, alpha_size, uint64(unsafe.Sizeof(uint8_t(0))))
- if (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_mem_ == (uintptr(0)) {
+ if (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_mem_ == uintptr(0) {
return 0
}
(*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_ = (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_mem_
- (*VP8Decoder)(unsafe.Pointer(dec)).alpha_prev_line_ = (uintptr(0))
+ (*VP8Decoder)(unsafe.Pointer(dec)).alpha_prev_line_ = uintptr(0)
return 1
}
func WebPDeallocateAlphaMemory(tls *libc.TLS, dec uintptr) { /* alpha_dec.c:165:6: */
WebPSafeFree(tls, (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_mem_)
- (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_mem_ = (uintptr(0))
- (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_ = (uintptr(0))
+ (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_mem_ = uintptr(0)
+ (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_ = uintptr(0)
ALPHDelete(tls, (*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_)
- (*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_ = (uintptr(0))
+ (*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_ = uintptr(0)
}
//------------------------------------------------------------------------------
@@ -5077,34 +4817,34 @@ func VP8DecompressAlphaRows(tls *libc.TLS, dec uintptr, io uintptr, row int32, n
width = (*VP8Io)(unsafe.Pointer(io)).width
height = (*VP8Io)(unsafe.Pointer(io)).crop_bottom
- if !(((row < 0) || (num_rows <= 0)) || ((row + num_rows) > height)) {
+ if !(row < 0 || num_rows <= 0 || row+num_rows > height) {
goto __1
}
- return (uintptr(0))
+ return uintptr(0)
__1:
;
- if !(!((*VP8Decoder)(unsafe.Pointer(dec)).is_alpha_decoded_ != 0)) {
+ if !!((*VP8Decoder)(unsafe.Pointer(dec)).is_alpha_decoded_ != 0) {
goto __2
}
- if !((*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_ == (uintptr(0))) {
+ if !((*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_ == uintptr(0)) {
goto __3
} // Initialize decoder.
(*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_ = ALPHNew(tls)
- if !((*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_ == (uintptr(0))) {
+ if !((*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_ == uintptr(0)) {
goto __4
}
- return (uintptr(0))
+ return uintptr(0)
__4:
;
- if !(!(AllocateAlphaPlane(tls, dec, io) != 0)) {
+ if !!(AllocateAlphaPlane(tls, dec, io) != 0) {
goto __5
}
goto Error
__5:
;
- if !(!(ALPHInit(tls, (*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_, (*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_, (*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_size_,
- io, (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_) != 0)) {
+ if !!(ALPHInit(tls, (*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_, (*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_, (*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_size_,
+ io, (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_) != 0) {
goto __6
}
goto Error
@@ -5117,13 +4857,13 @@ __6:
(*VP8Decoder)(unsafe.Pointer(dec)).alpha_dithering_ = 0 // disable dithering
goto __8
__7:
- num_rows = (height - row) // decode everything in one pass
+ num_rows = height - row // decode everything in one pass
__8:
;
__3:
;
- if !(!(ALPHDecode(tls, dec, row, num_rows) != 0)) {
+ if !!(ALPHDecode(tls, dec, row, num_rows) != 0) {
goto __9
}
goto Error
@@ -5134,16 +4874,16 @@ __9:
goto __10
} // finished?
ALPHDelete(tls, (*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_)
- (*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_ = (uintptr(0))
+ (*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_ = uintptr(0)
if !((*VP8Decoder)(unsafe.Pointer(dec)).alpha_dithering_ > 0) {
goto __11
}
- alpha = (((*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_ + uintptr(((*VP8Io)(unsafe.Pointer(io)).crop_top * width))) +
- uintptr((*VP8Io)(unsafe.Pointer(io)).crop_left))
- if !(!(WebPDequantizeLevels(tls, alpha,
- ((*VP8Io)(unsafe.Pointer(io)).crop_right-(*VP8Io)(unsafe.Pointer(io)).crop_left),
- ((*VP8Io)(unsafe.Pointer(io)).crop_bottom-(*VP8Io)(unsafe.Pointer(io)).crop_top),
- width, (*VP8Decoder)(unsafe.Pointer(dec)).alpha_dithering_) != 0)) {
+ alpha = (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_ + uintptr((*VP8Io)(unsafe.Pointer(io)).crop_top*width) +
+ uintptr((*VP8Io)(unsafe.Pointer(io)).crop_left)
+ if !!(WebPDequantizeLevels(tls, alpha,
+ (*VP8Io)(unsafe.Pointer(io)).crop_right-(*VP8Io)(unsafe.Pointer(io)).crop_left,
+ (*VP8Io)(unsafe.Pointer(io)).crop_bottom-(*VP8Io)(unsafe.Pointer(io)).crop_top,
+ width, (*VP8Decoder)(unsafe.Pointer(dec)).alpha_dithering_) != 0) {
goto __12
}
goto Error
@@ -5157,11 +4897,11 @@ __2:
;
// Return a pointer to the current decoded row.
- return ((*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_ + uintptr((row * width)))
+ return (*VP8Decoder)(unsafe.Pointer(dec)).alpha_plane_ + uintptr(row*width)
Error:
WebPDeallocateAlphaMemory(tls, dec)
- return (uintptr(0))
+ return uintptr(0)
}
//------------------------------------------------------------------------------
@@ -5179,7 +4919,7 @@ var kModeBpp = [13]uint8_t{
// Convert to an integer to handle both the unsigned/signed enum cases
// without the need for casting to remove type limit warnings.
func IsValidColorspace(tls *libc.TLS, webp_csp_mode int32) int32 { /* buffer_dec.c:32:12: */
- return (libc.Bool32((webp_csp_mode >= MODE_RGB) && (webp_csp_mode < MODE_LAST)))
+ return libc.Bool32(webp_csp_mode >= MODE_RGB && webp_csp_mode < MODE_LAST)
}
// strictly speaking, the very last (or first, if flipped) row
@@ -5193,38 +4933,38 @@ func CheckDecBuffer(tls *libc.TLS, buffer uintptr) VP8StatusCode { /* buffer_dec
if !(IsValidColorspace(tls, int32(mode)) != 0) {
ok = 0
} else if !(WebPIsRGBMode(tls, mode) != 0) { // YUV checks
- var buf uintptr = (buffer + 16 /* &.u */) /* &.YUVA */
- var uv_width int32 = ((width + 1) / 2)
- var uv_height int32 = ((height + 1) / 2)
+ var buf uintptr = buffer + 16
+ var uv_width int32 = (width + 1) / 2
+ var uv_height int32 = (height + 1) / 2
var y_stride int32 = libc.Xabs(tls, (*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride)
var u_stride int32 = libc.Xabs(tls, (*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride)
var v_stride int32 = libc.Xabs(tls, (*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride)
var a_stride int32 = libc.Xabs(tls, (*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride)
- var y_size uint64_t = (((uint64_t(y_stride)) * (uint64_t((height) - 1))) + (uint64_t(width)))
- var u_size uint64_t = (((uint64_t(u_stride)) * (uint64_t((uv_height) - 1))) + (uint64_t(uv_width)))
- var v_size uint64_t = (((uint64_t(v_stride)) * (uint64_t((uv_height) - 1))) + (uint64_t(uv_width)))
- var a_size uint64_t = (((uint64_t(a_stride)) * (uint64_t((height) - 1))) + (uint64_t(width)))
- ok = ok & (libc.Bool32(y_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).y_size))
- ok = ok & (libc.Bool32(u_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).u_size))
- ok = ok & (libc.Bool32(v_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).v_size))
- ok = ok & (libc.Bool32(y_stride >= width))
- ok = ok & (libc.Bool32(u_stride >= uv_width))
- ok = ok & (libc.Bool32(v_stride >= uv_width))
- ok = ok & (libc.Bool32((*WebPYUVABuffer)(unsafe.Pointer(buf)).y != (uintptr(0))))
- ok = ok & (libc.Bool32((*WebPYUVABuffer)(unsafe.Pointer(buf)).u != (uintptr(0))))
- ok = ok & (libc.Bool32((*WebPYUVABuffer)(unsafe.Pointer(buf)).v != (uintptr(0))))
+ var y_size uint64_t = uint64_t(y_stride)*uint64_t(height-1) + uint64_t(width)
+ var u_size uint64_t = uint64_t(u_stride)*uint64_t(uv_height-1) + uint64_t(uv_width)
+ var v_size uint64_t = uint64_t(v_stride)*uint64_t(uv_height-1) + uint64_t(uv_width)
+ var a_size uint64_t = uint64_t(a_stride)*uint64_t(height-1) + uint64_t(width)
+ ok = ok & libc.Bool32(y_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).y_size)
+ ok = ok & libc.Bool32(u_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).u_size)
+ ok = ok & libc.Bool32(v_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).v_size)
+ ok = ok & libc.Bool32(y_stride >= width)
+ ok = ok & libc.Bool32(u_stride >= uv_width)
+ ok = ok & libc.Bool32(v_stride >= uv_width)
+ ok = ok & libc.Bool32((*WebPYUVABuffer)(unsafe.Pointer(buf)).y != uintptr(0))
+ ok = ok & libc.Bool32((*WebPYUVABuffer)(unsafe.Pointer(buf)).u != uintptr(0))
+ ok = ok & libc.Bool32((*WebPYUVABuffer)(unsafe.Pointer(buf)).v != uintptr(0))
if mode == MODE_YUVA {
- ok = ok & (libc.Bool32(a_stride >= width))
- ok = ok & (libc.Bool32(a_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).a_size))
- ok = ok & (libc.Bool32((*WebPYUVABuffer)(unsafe.Pointer(buf)).a != (uintptr(0))))
+ ok = ok & libc.Bool32(a_stride >= width)
+ ok = ok & libc.Bool32(a_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).a_size)
+ ok = ok & libc.Bool32((*WebPYUVABuffer)(unsafe.Pointer(buf)).a != uintptr(0))
}
} else { // RGB checks
- var buf uintptr = (buffer + 16 /* &.u */) /* &.RGBA */
+ var buf uintptr = buffer + 16
var stride int32 = libc.Xabs(tls, (*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)
- var size uint64_t = (((uint64_t(stride)) * (uint64_t((height) - 1))) + (uint64_t(width * int32(kModeBpp[mode]))))
- ok = ok & (libc.Bool32(size <= (*WebPRGBABuffer)(unsafe.Pointer(buf)).size))
- ok = ok & (libc.Bool32(stride >= (width * int32(kModeBpp[mode]))))
- ok = ok & (libc.Bool32((*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba != (uintptr(0))))
+ var size uint64_t = uint64_t(stride)*uint64_t(height-1) + uint64_t(width*int32(kModeBpp[mode]))
+ ok = ok & libc.Bool32(size <= (*WebPRGBABuffer)(unsafe.Pointer(buf)).size)
+ ok = ok & libc.Bool32(stride >= width*int32(kModeBpp[mode]))
+ ok = ok & libc.Bool32((*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba != uintptr(0))
}
if ok != 0 {
return VP8_STATUS_OK
@@ -5237,11 +4977,11 @@ func AllocateBuffer(tls *libc.TLS, buffer uintptr) VP8StatusCode { /* buffer_dec
var h int32 = (*WebPDecBuffer)(unsafe.Pointer(buffer)).height
var mode WEBP_CSP_MODE = (*WebPDecBuffer)(unsafe.Pointer(buffer)).colorspace
- if ((w <= 0) || (h <= 0)) || !(IsValidColorspace(tls, int32(mode)) != 0) {
+ if w <= 0 || h <= 0 || !(IsValidColorspace(tls, int32(mode)) != 0) {
return VP8_STATUS_INVALID_PARAM
}
- if ((*WebPDecBuffer)(unsafe.Pointer(buffer)).is_external_memory <= 0) && ((*WebPDecBuffer)(unsafe.Pointer(buffer)).private_memory == (uintptr(0))) {
+ if (*WebPDecBuffer)(unsafe.Pointer(buffer)).is_external_memory <= 0 && (*WebPDecBuffer)(unsafe.Pointer(buffer)).private_memory == uintptr(0) {
var output uintptr
var uv_stride int32 = 0
var a_stride int32 = 0
@@ -5253,45 +4993,45 @@ func AllocateBuffer(tls *libc.TLS, buffer uintptr) VP8StatusCode { /* buffer_dec
var stride int32
var size uint64_t
- if (uint64(uint64_t(w) * uint64_t(kModeBpp[mode]))) >= (uint64(1) << 31) {
+ if uint64(uint64_t(w)*uint64_t(kModeBpp[mode])) >= uint64(1)<<31 {
return VP8_STATUS_INVALID_PARAM
}
- stride = (w * int32(kModeBpp[mode]))
- size = (uint64_t(stride) * uint64_t(h))
+ stride = w * int32(kModeBpp[mode])
+ size = uint64_t(stride) * uint64_t(h)
if !(WebPIsRGBMode(tls, mode) != 0) {
- uv_stride = ((w + 1) / 2)
- uv_size = (uint64_t(uv_stride) * (uint64_t((h + 1) / 2)))
+ uv_stride = (w + 1) / 2
+ uv_size = uint64_t(uv_stride) * uint64_t((h+1)/2)
if mode == MODE_YUVA {
a_stride = w
- a_size = (uint64_t(a_stride) * uint64_t(h))
+ a_size = uint64_t(a_stride) * uint64_t(h)
}
}
- total_size = ((size + (uint64(2) * uv_size)) + a_size)
+ total_size = size + uint64(2)*uv_size + a_size
output = WebPSafeMalloc(tls, total_size, uint64(unsafe.Sizeof(uint8_t(0))))
- if output == (uintptr(0)) {
+ if output == uintptr(0) {
return VP8_STATUS_OUT_OF_MEMORY
}
(*WebPDecBuffer)(unsafe.Pointer(buffer)).private_memory = output
if !(WebPIsRGBMode(tls, mode) != 0) { // YUVA initialization
- var buf uintptr = (buffer + 16 /* &.u */) /* &.YUVA */
+ var buf uintptr = buffer + 16
(*WebPYUVABuffer)(unsafe.Pointer(buf)).y = output
(*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride = stride
(*WebPYUVABuffer)(unsafe.Pointer(buf)).y_size = size
- (*WebPYUVABuffer)(unsafe.Pointer(buf)).u = (output + uintptr(size))
+ (*WebPYUVABuffer)(unsafe.Pointer(buf)).u = output + uintptr(size)
(*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride = uv_stride
(*WebPYUVABuffer)(unsafe.Pointer(buf)).u_size = uv_size
- (*WebPYUVABuffer)(unsafe.Pointer(buf)).v = ((output + uintptr(size)) + uintptr(uv_size))
+ (*WebPYUVABuffer)(unsafe.Pointer(buf)).v = output + uintptr(size) + uintptr(uv_size)
(*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride = uv_stride
(*WebPYUVABuffer)(unsafe.Pointer(buf)).v_size = uv_size
if mode == MODE_YUVA {
- (*WebPYUVABuffer)(unsafe.Pointer(buf)).a = ((output + uintptr(size)) + uintptr((uint64(2) * uv_size)))
+ (*WebPYUVABuffer)(unsafe.Pointer(buf)).a = output + uintptr(size) + uintptr(uint64(2)*uv_size)
}
(*WebPYUVABuffer)(unsafe.Pointer(buf)).a_size = a_size
(*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride = a_stride
} else { // RGBA initialization
- var buf uintptr = (buffer + 16 /* &.u */) /* &.RGBA */
+ var buf uintptr = buffer + 16
(*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba = output
(*WebPRGBABuffer)(unsafe.Pointer(buf)).stride = stride
(*WebPRGBABuffer)(unsafe.Pointer(buf)).size = size
@@ -5301,24 +5041,24 @@ func AllocateBuffer(tls *libc.TLS, buffer uintptr) VP8StatusCode { /* buffer_dec
}
func WebPFlipBuffer(tls *libc.TLS, buffer uintptr) VP8StatusCode { /* buffer_dec.c:152:15: */
- if buffer == (uintptr(0)) {
+ if buffer == uintptr(0) {
return VP8_STATUS_INVALID_PARAM
}
if WebPIsRGBMode(tls, (*WebPDecBuffer)(unsafe.Pointer(buffer)).colorspace) != 0 {
- var buf uintptr = (buffer + 16 /* &.u */) /* &.RGBA */
- *(*uintptr)(unsafe.Pointer((buf /* &.rgba */))) += (uintptr((int64_t((*WebPDecBuffer)(unsafe.Pointer(buffer)).height - 1)) * int64_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)))
+ var buf uintptr = buffer + 16
+ *(*uintptr)(unsafe.Pointer(buf)) += uintptr(int64_t((*WebPDecBuffer)(unsafe.Pointer(buffer)).height-1) * int64_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))
(*WebPRGBABuffer)(unsafe.Pointer(buf)).stride = -(*WebPRGBABuffer)(unsafe.Pointer(buf)).stride
} else {
- var buf uintptr = (buffer + 16 /* &.u */) /* &.YUVA */
+ var buf uintptr = buffer + 16
var H int64_t = int64_t((*WebPDecBuffer)(unsafe.Pointer(buffer)).height)
- *(*uintptr)(unsafe.Pointer((buf /* &.y */))) += (uintptr((H - int64(1)) * int64_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride)))
+ *(*uintptr)(unsafe.Pointer(buf)) += uintptr((H - int64(1)) * int64_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride))
(*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride = -(*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride
- *(*uintptr)(unsafe.Pointer((buf + 8 /* &.u */))) += (uintptr(((H - int64(1)) >> 1) * int64_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride)))
+ *(*uintptr)(unsafe.Pointer(buf + 8)) += uintptr((H - int64(1)) >> 1 * int64_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride))
(*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride = -(*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride
- *(*uintptr)(unsafe.Pointer((buf + 16 /* &.v */))) += (uintptr(((H - int64(1)) >> 1) * int64_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride)))
+ *(*uintptr)(unsafe.Pointer(buf + 16)) += uintptr((H - int64(1)) >> 1 * int64_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride))
(*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride = -(*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride
- if (*WebPYUVABuffer)(unsafe.Pointer(buf)).a != (uintptr(0)) {
- *(*uintptr)(unsafe.Pointer((buf + 24 /* &.a */))) += (uintptr((H - int64(1)) * int64_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride)))
+ if (*WebPYUVABuffer)(unsafe.Pointer(buf)).a != uintptr(0) {
+ *(*uintptr)(unsafe.Pointer(buf + 24)) += uintptr((H - int64(1)) * int64_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride))
(*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride = -(*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride
}
}
@@ -5330,15 +5070,15 @@ func WebPAllocateDecBuffer(tls *libc.TLS, width int32, height int32, options uin
defer tls.Free(8)
var status VP8StatusCode
- if ((buffer == (uintptr(0))) || (width <= 0)) || (height <= 0) {
+ if buffer == uintptr(0) || width <= 0 || height <= 0 {
return VP8_STATUS_INVALID_PARAM
}
- if options != (uintptr(0)) { // First, apply options if there is any.
+ if options != uintptr(0) { // First, apply options if there is any.
if (*WebPDecoderOptions)(unsafe.Pointer(options)).use_cropping != 0 {
var cw int32 = (*WebPDecoderOptions)(unsafe.Pointer(options)).crop_width
var ch int32 = (*WebPDecoderOptions)(unsafe.Pointer(options)).crop_height
- var x int32 = ((*WebPDecoderOptions)(unsafe.Pointer(options)).crop_left & libc.CplInt32(1))
- var y int32 = ((*WebPDecoderOptions)(unsafe.Pointer(options)).crop_top & libc.CplInt32(1))
+ var x int32 = (*WebPDecoderOptions)(unsafe.Pointer(options)).crop_left & libc.CplInt32(1)
+ var y int32 = (*WebPDecoderOptions)(unsafe.Pointer(options)).crop_top & libc.CplInt32(1)
if !(WebPCheckCropDimensions(tls, width, height, x, y, cw, ch) != 0) {
return VP8_STATUS_INVALID_PARAM // out of frame boundary.
}
@@ -5350,7 +5090,7 @@ func WebPAllocateDecBuffer(tls *libc.TLS, width int32, height int32, options uin
*(*int32)(unsafe.Pointer(bp /* scaled_width */)) = (*WebPDecoderOptions)(unsafe.Pointer(options)).scaled_width
*(*int32)(unsafe.Pointer(bp + 4 /* scaled_height */)) = (*WebPDecoderOptions)(unsafe.Pointer(options)).scaled_height
if !(WebPRescalerGetScaledDimensions(tls,
- width, height, (bp) /* &scaled_width */, (bp+4) /* &scaled_height */) != 0) {
+ width, height, bp, bp+4) != 0) {
return VP8_STATUS_INVALID_PARAM
}
width = *(*int32)(unsafe.Pointer(bp /* scaled_width */))
@@ -5367,7 +5107,7 @@ func WebPAllocateDecBuffer(tls *libc.TLS, width int32, height int32, options uin
}
// Use the stride trick if vertical flip is needed.
- if (options != (uintptr(0))) && ((*WebPDecoderOptions)(unsafe.Pointer(options)).flip != 0) {
+ if options != uintptr(0) && (*WebPDecoderOptions)(unsafe.Pointer(options)).flip != 0 {
status = WebPFlipBuffer(tls, buffer)
}
return status
@@ -5377,10 +5117,10 @@ func WebPAllocateDecBuffer(tls *libc.TLS, width int32, height int32, options uin
// constructors / destructors
func WebPInitDecBufferInternal(tls *libc.TLS, buffer uintptr, version int32) int32 { /* buffer_dec.c:229:5: */
- if ((version) >> 8) != (int32((0x0209)) >> 8) {
+ if version>>8 != int32(0x0209)>>8 {
return 0 // version mismatch
}
- if buffer == (uintptr(0)) {
+ if buffer == uintptr(0) {
return 0
}
libc.Xmemset(tls, buffer, 0, uint64(unsafe.Sizeof(WebPDecBuffer{})))
@@ -5388,31 +5128,31 @@ func WebPInitDecBufferInternal(tls *libc.TLS, buffer uintptr, version int32) int
}
func WebPFreeDecBuffer(tls *libc.TLS, buffer uintptr) { /* buffer_dec.c:238:6: */
- if buffer != (uintptr(0)) {
+ if buffer != uintptr(0) {
if (*WebPDecBuffer)(unsafe.Pointer(buffer)).is_external_memory <= 0 {
WebPSafeFree(tls, (*WebPDecBuffer)(unsafe.Pointer(buffer)).private_memory)
}
- (*WebPDecBuffer)(unsafe.Pointer(buffer)).private_memory = (uintptr(0))
+ (*WebPDecBuffer)(unsafe.Pointer(buffer)).private_memory = uintptr(0)
}
}
func WebPCopyDecBuffer(tls *libc.TLS, src uintptr, dst uintptr) { /* buffer_dec.c:247:6: */
- if (src != (uintptr(0))) && (dst != (uintptr(0))) {
+ if src != uintptr(0) && dst != uintptr(0) {
*(*WebPDecBuffer)(unsafe.Pointer(dst)) = *(*WebPDecBuffer)(unsafe.Pointer(src))
- if (*WebPDecBuffer)(unsafe.Pointer(src)).private_memory != (uintptr(0)) {
+ if (*WebPDecBuffer)(unsafe.Pointer(src)).private_memory != uintptr(0) {
(*WebPDecBuffer)(unsafe.Pointer(dst)).is_external_memory = 1 // dst buffer doesn't own the memory.
- (*WebPDecBuffer)(unsafe.Pointer(dst)).private_memory = (uintptr(0))
+ (*WebPDecBuffer)(unsafe.Pointer(dst)).private_memory = uintptr(0)
}
}
}
// Copy and transfer ownership from src to dst (beware of parameter order!)
func WebPGrabDecBuffer(tls *libc.TLS, src uintptr, dst uintptr) { /* buffer_dec.c:259:6: */
- if (src != (uintptr(0))) && (dst != (uintptr(0))) {
+ if src != uintptr(0) && dst != uintptr(0) {
*(*WebPDecBuffer)(unsafe.Pointer(dst)) = *(*WebPDecBuffer)(unsafe.Pointer(src))
- if (*WebPDecBuffer)(unsafe.Pointer(src)).private_memory != (uintptr(0)) {
+ if (*WebPDecBuffer)(unsafe.Pointer(src)).private_memory != uintptr(0) {
(*WebPDecBuffer)(unsafe.Pointer(src)).is_external_memory = 1 // src relinquishes ownership
- (*WebPDecBuffer)(unsafe.Pointer(src)).private_memory = (uintptr(0))
+ (*WebPDecBuffer)(unsafe.Pointer(src)).private_memory = uintptr(0)
}
}
}
@@ -5425,20 +5165,20 @@ func WebPCopyDecBufferPixels(tls *libc.TLS, src_buf uintptr, dst_buf uintptr) VP
return VP8_STATUS_INVALID_PARAM
}
if WebPIsRGBMode(tls, (*WebPDecBuffer)(unsafe.Pointer(src_buf)).colorspace) != 0 {
- var src uintptr = (src_buf + 16 /* &.u */) /* &.RGBA */
- var dst uintptr = (dst_buf + 16 /* &.u */) /* &.RGBA */
+ var src uintptr = src_buf + 16
+ var dst uintptr = dst_buf + 16
WebPCopyPlane(tls, (*WebPRGBABuffer)(unsafe.Pointer(src)).rgba, (*WebPRGBABuffer)(unsafe.Pointer(src)).stride, (*WebPRGBABuffer)(unsafe.Pointer(dst)).rgba, (*WebPRGBABuffer)(unsafe.Pointer(dst)).stride,
- ((*WebPDecBuffer)(unsafe.Pointer(src_buf)).width * int32(kModeBpp[(*WebPDecBuffer)(unsafe.Pointer(src_buf)).colorspace])),
+ (*WebPDecBuffer)(unsafe.Pointer(src_buf)).width*int32(kModeBpp[(*WebPDecBuffer)(unsafe.Pointer(src_buf)).colorspace]),
(*WebPDecBuffer)(unsafe.Pointer(src_buf)).height)
} else {
- var src uintptr = (src_buf + 16 /* &.u */) /* &.YUVA */
- var dst uintptr = (dst_buf + 16 /* &.u */) /* &.YUVA */
+ var src uintptr = src_buf + 16
+ var dst uintptr = dst_buf + 16
WebPCopyPlane(tls, (*WebPYUVABuffer)(unsafe.Pointer(src)).y, (*WebPYUVABuffer)(unsafe.Pointer(src)).y_stride, (*WebPYUVABuffer)(unsafe.Pointer(dst)).y, (*WebPYUVABuffer)(unsafe.Pointer(dst)).y_stride,
(*WebPDecBuffer)(unsafe.Pointer(src_buf)).width, (*WebPDecBuffer)(unsafe.Pointer(src_buf)).height)
WebPCopyPlane(tls, (*WebPYUVABuffer)(unsafe.Pointer(src)).u, (*WebPYUVABuffer)(unsafe.Pointer(src)).u_stride, (*WebPYUVABuffer)(unsafe.Pointer(dst)).u, (*WebPYUVABuffer)(unsafe.Pointer(dst)).u_stride,
- (((*WebPDecBuffer)(unsafe.Pointer(src_buf)).width + 1) / 2), (((*WebPDecBuffer)(unsafe.Pointer(src_buf)).height + 1) / 2))
+ ((*WebPDecBuffer)(unsafe.Pointer(src_buf)).width+1)/2, ((*WebPDecBuffer)(unsafe.Pointer(src_buf)).height+1)/2)
WebPCopyPlane(tls, (*WebPYUVABuffer)(unsafe.Pointer(src)).v, (*WebPYUVABuffer)(unsafe.Pointer(src)).v_stride, (*WebPYUVABuffer)(unsafe.Pointer(dst)).v, (*WebPYUVABuffer)(unsafe.Pointer(dst)).v_stride,
- (((*WebPDecBuffer)(unsafe.Pointer(src_buf)).width + 1) / 2), (((*WebPDecBuffer)(unsafe.Pointer(src_buf)).height + 1) / 2))
+ ((*WebPDecBuffer)(unsafe.Pointer(src_buf)).width+1)/2, ((*WebPDecBuffer)(unsafe.Pointer(src_buf)).height+1)/2)
if WebPIsAlphaMode(tls, (*WebPDecBuffer)(unsafe.Pointer(src_buf)).colorspace) != 0 {
WebPCopyPlane(tls, (*WebPYUVABuffer)(unsafe.Pointer(src)).a, (*WebPYUVABuffer)(unsafe.Pointer(src)).a_stride, (*WebPYUVABuffer)(unsafe.Pointer(dst)).a, (*WebPYUVABuffer)(unsafe.Pointer(dst)).a_stride,
(*WebPDecBuffer)(unsafe.Pointer(src_buf)).width, (*WebPDecBuffer)(unsafe.Pointer(src_buf)).height)
@@ -5449,7 +5189,7 @@ func WebPCopyDecBufferPixels(tls *libc.TLS, src_buf uintptr, dst_buf uintptr) VP
func WebPAvoidSlowMemory(tls *libc.TLS, output uintptr, features uintptr) int32 { /* buffer_dec.c:302:5: */
- return (libc.Bool32((((*WebPDecBuffer)(unsafe.Pointer(output)).is_external_memory >= 2) && (WebPIsPremultipliedMode(tls, (*WebPDecBuffer)(unsafe.Pointer(output)).colorspace) != 0)) && ((features != (uintptr(0))) && ((*WebPBitstreamFeatures)(unsafe.Pointer(features)).has_alpha != 0))))
+ return libc.Bool32((*WebPDecBuffer)(unsafe.Pointer(output)).is_external_memory >= 2 && WebPIsPremultipliedMode(tls, (*WebPDecBuffer)(unsafe.Pointer(output)).colorspace) != 0 && (features != uintptr(0) && (*WebPBitstreamFeatures)(unsafe.Pointer(features)).has_alpha != 0))
}
//------------------------------------------------------------------------------
@@ -5460,10 +5200,10 @@ func WebPAvoidSlowMemory(tls *libc.TLS, output uintptr, features uintptr) int32
// Main reconstruction function.
var kScan = [16]uint16_t{
- (uint16_t(0 + (0 * 32))), (uint16_t(4 + (0 * 32))), (uint16_t(8 + (0 * 32))), (uint16_t(12 + (0 * 32))),
- (uint16_t(0 + (4 * 32))), (uint16_t(4 + (4 * 32))), (uint16_t(8 + (4 * 32))), (uint16_t(12 + (4 * 32))),
- (uint16_t(0 + (8 * 32))), (uint16_t(4 + (8 * 32))), (uint16_t(8 + (8 * 32))), (uint16_t(12 + (8 * 32))),
- (uint16_t(0 + (12 * 32))), (uint16_t(4 + (12 * 32))), (uint16_t(8 + (12 * 32))), (uint16_t(12 + (12 * 32))),
+ uint16_t(0 + 0*32), uint16_t(4 + 0*32), uint16_t(8 + 0*32), uint16_t(12 + 0*32),
+ uint16_t(0 + 4*32), uint16_t(4 + 4*32), uint16_t(8 + 4*32), uint16_t(12 + 4*32),
+ uint16_t(0 + 8*32), uint16_t(4 + 8*32), uint16_t(8 + 8*32), uint16_t(12 + 8*32),
+ uint16_t(0 + 12*32), uint16_t(4 + 12*32), uint16_t(8 + 12*32), uint16_t(12 + 12*32),
} /* frame_dec.c:21:23 */
func CheckMode(tls *libc.TLS, mb_x int32, mb_y int32, mode int32) int32 { /* frame_dec.c:28:12: */
@@ -5510,8 +5250,8 @@ func DoTransform(tls *libc.TLS, bits uint32_t, src uintptr, dst uintptr) { /* fr
}
func DoUVTransform(tls *libc.TLS, bits uint32_t, src uintptr, dst uintptr) { /* frame_dec.c:60:13: */
- if (bits & uint32_t(0xff)) != 0 { // any non-zero coeff at all?
- if (bits & uint32_t(0xaa)) != 0 { // any non-zero AC coefficient?
+ if bits&uint32_t(0xff) != 0 { // any non-zero coeff at all?
+ if bits&uint32_t(0xaa) != 0 { // any non-zero AC coefficient?
(*struct {
f func(*libc.TLS, uintptr, uintptr)
})(unsafe.Pointer(&struct{ uintptr }{VP8TransformUV})).f(tls, src, dst) // note we don't use the AC3 variant for U/V
@@ -5528,71 +5268,71 @@ func ReconstructRow(tls *libc.TLS, dec uintptr, ctx uintptr) { /* frame_dec.c:71
var mb_x int32
var mb_y int32 = (*VP8ThreadContext)(unsafe.Pointer(ctx)).mb_y_
var cache_id int32 = (*VP8ThreadContext)(unsafe.Pointer(ctx)).id_
- var y_dst uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).yuv_b_ + uintptr(((32 * 1) + 8)))
- var u_dst uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).yuv_b_ + uintptr(((((32 * 1) + 8) + (32 * 16)) + 32)))
- var v_dst uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).yuv_b_ + uintptr((((((32 * 1) + 8) + (32 * 16)) + 32) + 16)))
+ var y_dst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).yuv_b_ + uintptr(32*1+8)
+ var u_dst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).yuv_b_ + uintptr(32*1+8+32*16+32)
+ var v_dst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).yuv_b_ + uintptr(32*1+8+32*16+32+16)
// Initialize left-most block.
for j = 0; j < 16; j++ {
- *(*uint8_t)(unsafe.Pointer(y_dst + uintptr(((j * 32) - 1)))) = uint8_t(129)
+ *(*uint8_t)(unsafe.Pointer(y_dst + uintptr(j*32-1))) = uint8_t(129)
}
for j = 0; j < 8; j++ {
- *(*uint8_t)(unsafe.Pointer(u_dst + uintptr(((j * 32) - 1)))) = uint8_t(129)
- *(*uint8_t)(unsafe.Pointer(v_dst + uintptr(((j * 32) - 1)))) = uint8_t(129)
+ *(*uint8_t)(unsafe.Pointer(u_dst + uintptr(j*32-1))) = uint8_t(129)
+ *(*uint8_t)(unsafe.Pointer(v_dst + uintptr(j*32-1))) = uint8_t(129)
}
// Init top-left sample on left column too.
if mb_y > 0 {
- *(*uint8_t)(unsafe.Pointer(y_dst + libc.UintptrFromInt32((-1 - 32)))) = libc.AssignPtrUint8((u_dst + libc.UintptrFromInt32((-1 - 32))), libc.AssignPtrUint8((v_dst+libc.UintptrFromInt32((-1-32))), uint8_t(129)))
+ *(*uint8_t)(unsafe.Pointer(y_dst + libc.UintptrFromInt32(-1-32))) = libc.AssignPtrUint8(u_dst+libc.UintptrFromInt32(-1-32), libc.AssignPtrUint8(v_dst+libc.UintptrFromInt32(-1-32), uint8_t(129)))
} else {
// we only need to do this init once at block (0,0).
// Afterward, it remains valid for the whole topmost row.
- libc.Xmemset(tls, ((y_dst - uintptr(32)) - uintptr(1)), 127, (uint64((16 + 4) + 1)))
- libc.Xmemset(tls, ((u_dst - uintptr(32)) - uintptr(1)), 127, (uint64(8 + 1)))
- libc.Xmemset(tls, ((v_dst - uintptr(32)) - uintptr(1)), 127, (uint64(8 + 1)))
+ libc.Xmemset(tls, y_dst-uintptr(32)-uintptr(1), 127, uint64(16+4+1))
+ libc.Xmemset(tls, u_dst-uintptr(32)-uintptr(1), 127, uint64(8+1))
+ libc.Xmemset(tls, v_dst-uintptr(32)-uintptr(1), 127, uint64(8+1))
}
// Reconstruct one row.
for mb_x = 0; mb_x < (*VP8Decoder)(unsafe.Pointer(dec)).mb_w_; mb_x++ {
- var block uintptr = ((*VP8ThreadContext)(unsafe.Pointer(ctx)).mb_data_ + uintptr(mb_x)*800)
+ var block uintptr = (*VP8ThreadContext)(unsafe.Pointer(ctx)).mb_data_ + uintptr(mb_x)*800
// Rotate in the left samples from previously decoded block. We move four
// pixels at a time for alignment reason, and because of in-loop filter.
if mb_x > 0 {
for j = -1; j < 16; j++ {
- Copy32b(tls, (y_dst + uintptr(((j * 32) - 4))), (y_dst + uintptr(((j * 32) + 12))))
+ Copy32b(tls, y_dst+uintptr(j*32-4), y_dst+uintptr(j*32+12))
}
for j = -1; j < 8; j++ {
- Copy32b(tls, (u_dst + uintptr(((j * 32) - 4))), (u_dst + uintptr(((j * 32) + 4))))
- Copy32b(tls, (v_dst + uintptr(((j * 32) - 4))), (v_dst + uintptr(((j * 32) + 4))))
+ Copy32b(tls, u_dst+uintptr(j*32-4), u_dst+uintptr(j*32+4))
+ Copy32b(tls, v_dst+uintptr(j*32-4), v_dst+uintptr(j*32+4))
}
}
{
// bring top samples into the cache
- var top_yuv uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).yuv_t_ + uintptr(mb_x)*32)
+ var top_yuv uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).yuv_t_ + uintptr(mb_x)*32
var coeffs uintptr = block /* &.coeffs_ */
var bits uint32_t = (*VP8MBData)(unsafe.Pointer(block)).non_zero_y_
var n int32
if mb_y > 0 {
- libc.Xmemcpy(tls, (y_dst - uintptr(32)), (top_yuv) /* &.y */, uint64(16))
- libc.Xmemcpy(tls, (u_dst - uintptr(32)), ((top_yuv) + 16 /* &.u */), uint64(8))
- libc.Xmemcpy(tls, (v_dst - uintptr(32)), ((top_yuv) + 24 /* &.v */), uint64(8))
+ libc.Xmemcpy(tls, y_dst-uintptr(32), top_yuv, uint64(16))
+ libc.Xmemcpy(tls, u_dst-uintptr(32), top_yuv+16, uint64(8))
+ libc.Xmemcpy(tls, v_dst-uintptr(32), top_yuv+24, uint64(8))
}
// predict and add residuals
if (*VP8MBData)(unsafe.Pointer(block)).is_i4x4_ != 0 { // 4x4
- var top_right uintptr = ((y_dst - uintptr(32)) + uintptr(16))
+ var top_right uintptr = y_dst - uintptr(32) + uintptr(16)
if mb_y > 0 {
- if mb_x >= ((*VP8Decoder)(unsafe.Pointer(dec)).mb_w_ - 1) { // on rightmost border
- libc.Xmemset(tls, top_right, int32(*(*uint8_t)(unsafe.Pointer((top_yuv) /* &.y */ + 15))), uint64(unsafe.Sizeof(uint32_t(0))))
+ if mb_x >= (*VP8Decoder)(unsafe.Pointer(dec)).mb_w_-1 { // on rightmost border
+ libc.Xmemset(tls, top_right, int32(*(*uint8_t)(unsafe.Pointer(top_yuv + 15))), uint64(unsafe.Sizeof(uint32_t(0))))
} else {
- libc.Xmemcpy(tls, top_right, (top_yuv + 1*32) /* &.y */, uint64(unsafe.Sizeof(uint32_t(0))))
+ libc.Xmemcpy(tls, top_right, top_yuv+1*32, uint64(unsafe.Sizeof(uint32_t(0))))
}
}
// replicate the top-right pixels below
- *(*uint32_t)(unsafe.Pointer(top_right + 32*4)) = libc.AssignPtrUint32((top_right + 64*4), libc.AssignPtrUint32((top_right+96*4), *(*uint32_t)(unsafe.Pointer(top_right))))
+ *(*uint32_t)(unsafe.Pointer(top_right + 32*4)) = libc.AssignPtrUint32(top_right+64*4, libc.AssignPtrUint32(top_right+96*4, *(*uint32_t)(unsafe.Pointer(top_right))))
// predict and add residuals for all 4x4 blocks in turn.
n = 0
@@ -5601,9 +5341,9 @@ func ReconstructRow(tls *libc.TLS, dec uintptr, ctx uintptr) { /* frame_dec.c:71
goto __3
}
{
- var dst uintptr = (y_dst + uintptr(kScan[n]))
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{VP8PredLuma4[*(*uint8_t)(unsafe.Pointer((block + 769 /* &.imodes_ */) + uintptr(n)))]})).f(tls, dst)
- DoTransform(tls, bits, (coeffs + uintptr((n*16))*2), dst)
+ var dst uintptr = y_dst + uintptr(kScan[n])
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{VP8PredLuma4[*(*uint8_t)(unsafe.Pointer(block + 769 /* &.imodes_ */ + uintptr(n)))]})).f(tls, dst)
+ DoTransform(tls, bits, coeffs+uintptr(n*16)*2, dst)
}
goto __2
@@ -5614,7 +5354,7 @@ func ReconstructRow(tls *libc.TLS, dec uintptr, ctx uintptr) { /* frame_dec.c:71
goto __3
__3:
} else { // 16x16
- var pred_func int32 = CheckMode(tls, mb_x, mb_y, int32(*(*uint8_t)(unsafe.Pointer((block + 769 /* &.imodes_ */)))))
+ var pred_func int32 = CheckMode(tls, mb_x, mb_y, int32(*(*uint8_t)(unsafe.Pointer(block + 769))))
(*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{VP8PredLuma16[pred_func]})).f(tls, y_dst)
if bits != uint32_t(0) {
n = 0
@@ -5623,7 +5363,7 @@ func ReconstructRow(tls *libc.TLS, dec uintptr, ctx uintptr) { /* frame_dec.c:71
goto __6
}
{
- DoTransform(tls, bits, (coeffs + uintptr((n*16))*2), (y_dst + uintptr(kScan[n])))
+ DoTransform(tls, bits, coeffs+uintptr(n*16)*2, y_dst+uintptr(kScan[n]))
}
goto __5
@@ -5641,32 +5381,32 @@ func ReconstructRow(tls *libc.TLS, dec uintptr, ctx uintptr) { /* frame_dec.c:71
var pred_func int32 = CheckMode(tls, mb_x, mb_y, int32((*VP8MBData)(unsafe.Pointer(block)).uvmode_))
(*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{VP8PredChroma8[pred_func]})).f(tls, u_dst)
(*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{VP8PredChroma8[pred_func]})).f(tls, v_dst)
- DoUVTransform(tls, (bits_uv >> 0), (coeffs + uintptr((16*16))*2), u_dst)
- DoUVTransform(tls, (bits_uv >> 8), (coeffs + uintptr((20*16))*2), v_dst)
+ DoUVTransform(tls, bits_uv>>0, coeffs+uintptr(16*16)*2, u_dst)
+ DoUVTransform(tls, bits_uv>>8, coeffs+uintptr(20*16)*2, v_dst)
}
// stash away top samples for next block
- if mb_y < ((*VP8Decoder)(unsafe.Pointer(dec)).mb_h_ - 1) {
- libc.Xmemcpy(tls, (top_yuv) /* &.y */, (y_dst + uintptr((15 * 32))), uint64(16))
- libc.Xmemcpy(tls, ((top_yuv) + 16 /* &.u */), (u_dst + uintptr((7 * 32))), uint64(8))
- libc.Xmemcpy(tls, ((top_yuv) + 24 /* &.v */), (v_dst + uintptr((7 * 32))), uint64(8))
+ if mb_y < (*VP8Decoder)(unsafe.Pointer(dec)).mb_h_-1 {
+ libc.Xmemcpy(tls, top_yuv, y_dst+uintptr(15*32), uint64(16))
+ libc.Xmemcpy(tls, top_yuv+16, u_dst+uintptr(7*32), uint64(8))
+ libc.Xmemcpy(tls, top_yuv+24, v_dst+uintptr(7*32), uint64(8))
}
}
// Transfer reconstructed samples from yuv_b_ cache to final destination.
{
- var y_offset int32 = ((cache_id * 16) * (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_)
- var uv_offset int32 = ((cache_id * 8) * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_)
- var y_out uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ + uintptr((mb_x * 16))) + uintptr(y_offset))
- var u_out uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ + uintptr((mb_x * 8))) + uintptr(uv_offset))
- var v_out uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ + uintptr((mb_x * 8))) + uintptr(uv_offset))
+ var y_offset int32 = cache_id * 16 * (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_
+ var uv_offset int32 = cache_id * 8 * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_
+ var y_out uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ + uintptr(mb_x*16) + uintptr(y_offset)
+ var u_out uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ + uintptr(mb_x*8) + uintptr(uv_offset)
+ var v_out uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ + uintptr(mb_x*8) + uintptr(uv_offset)
for j = 0; j < 16; j++ {
- libc.Xmemcpy(tls, (y_out + uintptr((j * (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_))), (y_dst + uintptr((j * 32))), uint64(16))
+ libc.Xmemcpy(tls, y_out+uintptr(j*(*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_), y_dst+uintptr(j*32), uint64(16))
}
for j = 0; j < 8; j++ {
- libc.Xmemcpy(tls, (u_out + uintptr((j * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_))), (u_dst + uintptr((j * 32))), uint64(8))
- libc.Xmemcpy(tls, (v_out + uintptr((j * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_))), (v_dst + uintptr((j * 32))), uint64(8))
+ libc.Xmemcpy(tls, u_out+uintptr(j*(*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_), u_dst+uintptr(j*32), uint64(8))
+ libc.Xmemcpy(tls, v_out+uintptr(j*(*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_), v_dst+uintptr(j*32), uint64(8))
}
}
@@ -5684,11 +5424,11 @@ func ReconstructRow(tls *libc.TLS, dec uintptr, ctx uintptr) { /* frame_dec.c:71
var kFilterExtraRows = [3]uint8_t{uint8_t(0), uint8_t(2), uint8_t(8)} /* frame_dec.c:201:22 */
func DoFilter(tls *libc.TLS, dec uintptr, mb_x int32, mb_y int32) { /* frame_dec.c:203:13: */
- var ctx uintptr = (dec + 216 /* &.thread_ctx_ */)
+ var ctx uintptr = dec + 216
var cache_id int32 = (*VP8ThreadContext)(unsafe.Pointer(ctx)).id_
var y_bps int32 = (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_
- var f_info uintptr = ((*VP8ThreadContext)(unsafe.Pointer(ctx)).f_info_ + uintptr(mb_x)*4)
- var y_dst uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ + uintptr(((cache_id * 16) * y_bps))) + uintptr((mb_x * 16)))
+ var f_info uintptr = (*VP8ThreadContext)(unsafe.Pointer(ctx)).f_info_ + uintptr(mb_x)*4
+ var y_dst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ + uintptr(cache_id*16*y_bps) + uintptr(mb_x*16)
var ilevel int32 = int32((*VP8FInfo)(unsafe.Pointer(f_info)).f_ilevel_)
var limit int32 = int32((*VP8FInfo)(unsafe.Pointer(f_info)).f_limit_)
if limit == 0 {
@@ -5699,7 +5439,7 @@ func DoFilter(tls *libc.TLS, dec uintptr, mb_x int32, mb_y int32) { /* frame_dec
if mb_x > 0 {
(*struct {
f func(*libc.TLS, uintptr, int32, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SimpleHFilter16})).f(tls, y_dst, y_bps, (limit + 4))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SimpleHFilter16})).f(tls, y_dst, y_bps, limit+4)
}
if (*VP8FInfo)(unsafe.Pointer(f_info)).f_inner_ != 0 {
(*struct {
@@ -5709,7 +5449,7 @@ func DoFilter(tls *libc.TLS, dec uintptr, mb_x int32, mb_y int32) { /* frame_dec
if mb_y > 0 {
(*struct {
f func(*libc.TLS, uintptr, int32, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SimpleVFilter16})).f(tls, y_dst, y_bps, (limit + 4))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SimpleVFilter16})).f(tls, y_dst, y_bps, limit+4)
}
if (*VP8FInfo)(unsafe.Pointer(f_info)).f_inner_ != 0 {
(*struct {
@@ -5718,16 +5458,16 @@ func DoFilter(tls *libc.TLS, dec uintptr, mb_x int32, mb_y int32) { /* frame_dec
}
} else { // complex
var uv_bps int32 = (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_
- var u_dst uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ + uintptr(((cache_id * 8) * uv_bps))) + uintptr((mb_x * 8)))
- var v_dst uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ + uintptr(((cache_id * 8) * uv_bps))) + uintptr((mb_x * 8)))
+ var u_dst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ + uintptr(cache_id*8*uv_bps) + uintptr(mb_x*8)
+ var v_dst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ + uintptr(cache_id*8*uv_bps) + uintptr(mb_x*8)
var hev_thresh int32 = int32((*VP8FInfo)(unsafe.Pointer(f_info)).hev_thresh_)
if mb_x > 0 {
(*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8HFilter16})).f(tls, y_dst, y_bps, (limit + 4), ilevel, hev_thresh)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8HFilter16})).f(tls, y_dst, y_bps, limit+4, ilevel, hev_thresh)
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, int32, int32, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8HFilter8})).f(tls, u_dst, v_dst, uv_bps, (limit + 4), ilevel, hev_thresh)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8HFilter8})).f(tls, u_dst, v_dst, uv_bps, limit+4, ilevel, hev_thresh)
}
if (*VP8FInfo)(unsafe.Pointer(f_info)).f_inner_ != 0 {
(*struct {
@@ -5740,10 +5480,10 @@ func DoFilter(tls *libc.TLS, dec uintptr, mb_x int32, mb_y int32) { /* frame_dec
if mb_y > 0 {
(*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8VFilter16})).f(tls, y_dst, y_bps, (limit + 4), ilevel, hev_thresh)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8VFilter16})).f(tls, y_dst, y_bps, limit+4, ilevel, hev_thresh)
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, int32, int32, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8VFilter8})).f(tls, u_dst, v_dst, uv_bps, (limit + 4), ilevel, hev_thresh)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8VFilter8})).f(tls, u_dst, v_dst, uv_bps, limit+4, ilevel, hev_thresh)
}
if (*VP8FInfo)(unsafe.Pointer(f_info)).f_inner_ != 0 {
(*struct {
@@ -5772,26 +5512,26 @@ func FilterRow(tls *libc.TLS, dec uintptr) { /* frame_dec.c:253:13: */
func PrecomputeFilterStrengths(tls *libc.TLS, dec uintptr) { /* frame_dec.c:265:13: */
if (*VP8Decoder)(unsafe.Pointer(dec)).filter_type_ > 0 {
var s int32
- var hdr uintptr = (dec + 80 /* &.filter_hdr_ */)
+ var hdr uintptr = dec + 80
for s = 0; s < NUM_MB_SEGMENTS; s++ {
var i4x4 int32
// First, compute the initial level
var base_level int32
if (*VP8Decoder)(unsafe.Pointer(dec)).segment_hdr_.use_segment_ != 0 {
- base_level = int32(*(*int8_t)(unsafe.Pointer(((dec + 128 /* &.segment_hdr_ */) + 16 /* &.filter_strength_ */) + uintptr(s))))
+ base_level = int32(*(*int8_t)(unsafe.Pointer(dec + 128 + 16 + uintptr(s))))
if !((*VP8Decoder)(unsafe.Pointer(dec)).segment_hdr_.absolute_delta_ != 0) {
- base_level = base_level + ((*VP8FilterHeader)(unsafe.Pointer(hdr)).level_)
+ base_level = base_level + (*VP8FilterHeader)(unsafe.Pointer(hdr)).level_
}
} else {
base_level = (*VP8FilterHeader)(unsafe.Pointer(hdr)).level_
}
for i4x4 = 0; i4x4 <= 1; i4x4++ {
- var info uintptr = (((dec + 2924 /* &.fstrengths_ */) + uintptr(s)*8) + uintptr(i4x4)*4)
+ var info uintptr = dec + 2924 + uintptr(s)*8 + uintptr(i4x4)*4
var level int32 = base_level
if (*VP8FilterHeader)(unsafe.Pointer(hdr)).use_lf_delta_ != 0 {
- level = level + (*(*int32)(unsafe.Pointer((hdr + 16 /* &.ref_lf_delta_ */))))
+ level = level + *(*int32)(unsafe.Pointer(hdr + 16))
if i4x4 != 0 {
- level = level + (*(*int32)(unsafe.Pointer((hdr + 32 /* &.mode_lf_delta_ */))))
+ level = level + *(*int32)(unsafe.Pointer(hdr + 32))
}
}
if level < 0 {
@@ -5811,15 +5551,15 @@ func PrecomputeFilterStrengths(tls *libc.TLS, dec uintptr) { /* frame_dec.c:265:
} else {
ilevel >>= 1
}
- if ilevel > (9 - (*VP8FilterHeader)(unsafe.Pointer(hdr)).sharpness_) {
- ilevel = (9 - (*VP8FilterHeader)(unsafe.Pointer(hdr)).sharpness_)
+ if ilevel > 9-(*VP8FilterHeader)(unsafe.Pointer(hdr)).sharpness_ {
+ ilevel = 9 - (*VP8FilterHeader)(unsafe.Pointer(hdr)).sharpness_
}
}
if ilevel < 1 {
ilevel = 1
}
(*VP8FInfo)(unsafe.Pointer(info)).f_ilevel_ = uint8_t(ilevel)
- (*VP8FInfo)(unsafe.Pointer(info)).f_limit_ = (uint8_t((2 * level) + ilevel))
+ (*VP8FInfo)(unsafe.Pointer(info)).f_limit_ = uint8_t(2*level + ilevel)
(*VP8FInfo)(unsafe.Pointer(info)).hev_thresh_ = func() uint8 {
if level >= 40 {
return uint8(2)
@@ -5852,9 +5592,9 @@ var kQuantToDitherAmp = [12]uint8_t{
func VP8InitDithering(tls *libc.TLS, options uintptr, dec uintptr) { /* frame_dec.c:328:6: */
- if options != (uintptr(0)) {
+ if options != uintptr(0) {
var d int32 = (*WebPDecoderOptions)(unsafe.Pointer(options)).dithering_strength
- var max_amp int32 = ((int32(1) << 8) - 1)
+ var max_amp int32 = int32(1)<<8 - 1
var f int32
if d < 0 {
f = 0
@@ -5862,14 +5602,14 @@ func VP8InitDithering(tls *libc.TLS, options uintptr, dec uintptr) { /* frame_de
if d > 100 {
f = max_amp
} else {
- f = ((d * max_amp) / 100)
+ f = d * max_amp / 100
}
}
if f > 0 {
var s int32
var all_amp int32 = 0
for s = 0; s < NUM_MB_SEGMENTS; s++ {
- var dqm uintptr = ((dec + 1060 /* &.dqm_ */) + uintptr(s)*32)
+ var dqm uintptr = dec + 1060 + uintptr(s)*32
if (*VP8QuantMatrix)(unsafe.Pointer(dqm)).uv_quant_ < 12 {
var idx int32
if (*VP8QuantMatrix)(unsafe.Pointer(dqm)).uv_quant_ < 0 {
@@ -5877,12 +5617,12 @@ func VP8InitDithering(tls *libc.TLS, options uintptr, dec uintptr) { /* frame_de
} else {
idx = (*VP8QuantMatrix)(unsafe.Pointer(dqm)).uv_quant_
}
- (*VP8QuantMatrix)(unsafe.Pointer(dqm)).dither_ = ((f * int32(kQuantToDitherAmp[idx])) >> 3)
+ (*VP8QuantMatrix)(unsafe.Pointer(dqm)).dither_ = f * int32(kQuantToDitherAmp[idx]) >> 3
}
- all_amp = all_amp | ((*VP8QuantMatrix)(unsafe.Pointer(dqm)).dither_)
+ all_amp = all_amp | (*VP8QuantMatrix)(unsafe.Pointer(dqm)).dither_
}
if all_amp != 0 {
- VP8InitRandom(tls, (dec + 828 /* &.dithering_rg_ */), 1.0)
+ VP8InitRandom(tls, dec+828, 1.0)
(*VP8Decoder)(unsafe.Pointer(dec)).dither_ = 1
}
}
@@ -5904,27 +5644,27 @@ func Dither8x8(tls *libc.TLS, rg uintptr, dst uintptr, bps int32, amp int32) { /
// var dither [64]uint8_t at bp, 64
var i int32
- for i = 0; i < (8 * 8); i++ {
- *(*uint8_t)(unsafe.Pointer((bp) /* &dither[0] */ + uintptr(i))) = uint8_t(VP8RandomBits2(tls, rg, (7 + 1), amp))
+ for i = 0; i < 8*8; i++ {
+ *(*uint8_t)(unsafe.Pointer(bp + uintptr(i))) = uint8_t(VP8RandomBits2(tls, rg, 7+1, amp))
}
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8DitherCombine8x8})).f(tls, (bp) /* &dither[0] */, dst, bps)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8DitherCombine8x8})).f(tls, bp /* &dither[0] */, dst, bps)
}
func DitherRow(tls *libc.TLS, dec uintptr) { /* frame_dec.c:371:13: */
var mb_x int32
for mb_x = (*VP8Decoder)(unsafe.Pointer(dec)).tl_mb_x_; mb_x < (*VP8Decoder)(unsafe.Pointer(dec)).br_mb_x_; mb_x++ {
- var ctx uintptr = (dec + 216 /* &.thread_ctx_ */)
- var data uintptr = ((*VP8ThreadContext)(unsafe.Pointer(ctx)).mb_data_ + uintptr(mb_x)*800)
+ var ctx uintptr = dec + 216
+ var data uintptr = (*VP8ThreadContext)(unsafe.Pointer(ctx)).mb_data_ + uintptr(mb_x)*800
var cache_id int32 = (*VP8ThreadContext)(unsafe.Pointer(ctx)).id_
var uv_bps int32 = (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_
if int32((*VP8MBData)(unsafe.Pointer(data)).dither_) >= 4 {
- var u_dst uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ + uintptr(((cache_id * 8) * uv_bps))) + uintptr((mb_x * 8)))
- var v_dst uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ + uintptr(((cache_id * 8) * uv_bps))) + uintptr((mb_x * 8)))
- Dither8x8(tls, (dec + 828 /* &.dithering_rg_ */), u_dst, uv_bps, int32((*VP8MBData)(unsafe.Pointer(data)).dither_))
- Dither8x8(tls, (dec + 828 /* &.dithering_rg_ */), v_dst, uv_bps, int32((*VP8MBData)(unsafe.Pointer(data)).dither_))
+ var u_dst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ + uintptr(cache_id*8*uv_bps) + uintptr(mb_x*8)
+ var v_dst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ + uintptr(cache_id*8*uv_bps) + uintptr(mb_x*8)
+ Dither8x8(tls, dec+828, u_dst, uv_bps, int32((*VP8MBData)(unsafe.Pointer(data)).dither_))
+ Dither8x8(tls, dec+828, v_dst, uv_bps, int32((*VP8MBData)(unsafe.Pointer(data)).dither_))
}
}
}
@@ -5945,19 +5685,19 @@ func FinishRow(tls *libc.TLS, arg1 uintptr, arg2 uintptr) int32 { /* frame_dec.c
var dec uintptr = arg1
var io uintptr = arg2
var ok int32 = 1
- var ctx uintptr = (dec + 216 /* &.thread_ctx_ */)
+ var ctx uintptr = dec + 216
var cache_id int32 = (*VP8ThreadContext)(unsafe.Pointer(ctx)).id_
var extra_y_rows int32 = int32(kFilterExtraRows[(*VP8Decoder)(unsafe.Pointer(dec)).filter_type_])
- var ysize int32 = (extra_y_rows * (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_)
- var uvsize int32 = ((extra_y_rows / 2) * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_)
- var y_offset int32 = ((cache_id * 16) * (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_)
- var uv_offset int32 = ((cache_id * 8) * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_)
- var ydst uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ - uintptr(ysize)) + uintptr(y_offset))
- var udst uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ - uintptr(uvsize)) + uintptr(uv_offset))
- var vdst uintptr = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ - uintptr(uvsize)) + uintptr(uv_offset))
+ var ysize int32 = extra_y_rows * (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_
+ var uvsize int32 = extra_y_rows / 2 * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_
+ var y_offset int32 = cache_id * 16 * (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_
+ var uv_offset int32 = cache_id * 8 * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_
+ var ydst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ - uintptr(ysize) + uintptr(y_offset)
+ var udst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ - uintptr(uvsize) + uintptr(uv_offset)
+ var vdst uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ - uintptr(uvsize) + uintptr(uv_offset)
var mb_y int32 = (*VP8ThreadContext)(unsafe.Pointer(ctx)).mb_y_
- var is_first_row int32 = (libc.Bool32(mb_y == 0))
- var is_last_row int32 = (libc.Bool32(mb_y >= ((*VP8Decoder)(unsafe.Pointer(dec)).br_mb_y_ - 1)))
+ var is_first_row int32 = libc.Bool32(mb_y == 0)
+ var is_last_row int32 = libc.Bool32(mb_y >= (*VP8Decoder)(unsafe.Pointer(dec)).br_mb_y_-1)
if (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ == 2 {
ReconstructRow(tls, dec, ctx)
@@ -5971,67 +5711,67 @@ func FinishRow(tls *libc.TLS, arg1 uintptr, arg2 uintptr) int32 { /* frame_dec.c
DitherRow(tls, dec)
}
- if (*VP8Io)(unsafe.Pointer(io)).put != (uintptr(0)) {
- var y_start int32 = ((mb_y) * 16)
- var y_end int32 = ((mb_y + 1) * 16)
+ if (*VP8Io)(unsafe.Pointer(io)).put != uintptr(0) {
+ var y_start int32 = mb_y * 16
+ var y_end int32 = (mb_y + 1) * 16
if !(is_first_row != 0) {
- y_start = y_start - (extra_y_rows)
+ y_start = y_start - extra_y_rows
(*VP8Io)(unsafe.Pointer(io)).y = ydst
(*VP8Io)(unsafe.Pointer(io)).u = udst
(*VP8Io)(unsafe.Pointer(io)).v = vdst
} else {
- (*VP8Io)(unsafe.Pointer(io)).y = ((*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ + uintptr(y_offset))
- (*VP8Io)(unsafe.Pointer(io)).u = ((*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ + uintptr(uv_offset))
- (*VP8Io)(unsafe.Pointer(io)).v = ((*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ + uintptr(uv_offset))
+ (*VP8Io)(unsafe.Pointer(io)).y = (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ + uintptr(y_offset)
+ (*VP8Io)(unsafe.Pointer(io)).u = (*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ + uintptr(uv_offset)
+ (*VP8Io)(unsafe.Pointer(io)).v = (*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ + uintptr(uv_offset)
}
if !(is_last_row != 0) {
- y_end = y_end - (extra_y_rows)
+ y_end = y_end - extra_y_rows
}
if y_end > (*VP8Io)(unsafe.Pointer(io)).crop_bottom {
y_end = (*VP8Io)(unsafe.Pointer(io)).crop_bottom // make sure we don't overflow on last row.
}
// If dec->alpha_data_ is not NULL, we have some alpha plane present.
- (*VP8Io)(unsafe.Pointer(io)).a = (uintptr(0))
- if ((*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_ != (uintptr(0))) && (y_start < y_end) {
- (*VP8Io)(unsafe.Pointer(io)).a = VP8DecompressAlphaRows(tls, dec, io, y_start, (y_end - y_start))
- if (*VP8Io)(unsafe.Pointer(io)).a == (uintptr(0)) {
+ (*VP8Io)(unsafe.Pointer(io)).a = uintptr(0)
+ if (*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_ != uintptr(0) && y_start < y_end {
+ (*VP8Io)(unsafe.Pointer(io)).a = VP8DecompressAlphaRows(tls, dec, io, y_start, y_end-y_start)
+ if (*VP8Io)(unsafe.Pointer(io)).a == uintptr(0) {
return VP8SetError(tls, dec, VP8_STATUS_BITSTREAM_ERROR,
- (ts) /* "Could not decode..." */)
+ ts)
}
}
if y_start < (*VP8Io)(unsafe.Pointer(io)).crop_top {
- var delta_y int32 = ((*VP8Io)(unsafe.Pointer(io)).crop_top - y_start)
+ var delta_y int32 = (*VP8Io)(unsafe.Pointer(io)).crop_top - y_start
y_start = (*VP8Io)(unsafe.Pointer(io)).crop_top
- *(*uintptr)(unsafe.Pointer((io + 24 /* &.y */))) += (uintptr((*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_ * delta_y))
- *(*uintptr)(unsafe.Pointer((io + 32 /* &.u */))) += (uintptr((*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_ * (delta_y >> 1)))
- *(*uintptr)(unsafe.Pointer((io + 40 /* &.v */))) += (uintptr((*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_ * (delta_y >> 1)))
- if (*VP8Io)(unsafe.Pointer(io)).a != (uintptr(0)) {
- *(*uintptr)(unsafe.Pointer((io + 152 /* &.a */))) += (uintptr((*VP8Io)(unsafe.Pointer(io)).width * delta_y))
+ *(*uintptr)(unsafe.Pointer(io + 24)) += uintptr((*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_ * delta_y)
+ *(*uintptr)(unsafe.Pointer(io + 32)) += uintptr((*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_ * (delta_y >> 1))
+ *(*uintptr)(unsafe.Pointer(io + 40)) += uintptr((*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_ * (delta_y >> 1))
+ if (*VP8Io)(unsafe.Pointer(io)).a != uintptr(0) {
+ *(*uintptr)(unsafe.Pointer(io + 152)) += uintptr((*VP8Io)(unsafe.Pointer(io)).width * delta_y)
}
}
if y_start < y_end {
- *(*uintptr)(unsafe.Pointer((io + 24 /* &.y */))) += (uintptr((*VP8Io)(unsafe.Pointer(io)).crop_left))
- *(*uintptr)(unsafe.Pointer((io + 32 /* &.u */))) += (uintptr((*VP8Io)(unsafe.Pointer(io)).crop_left >> 1))
- *(*uintptr)(unsafe.Pointer((io + 40 /* &.v */))) += (uintptr((*VP8Io)(unsafe.Pointer(io)).crop_left >> 1))
- if (*VP8Io)(unsafe.Pointer(io)).a != (uintptr(0)) {
- *(*uintptr)(unsafe.Pointer((io + 152 /* &.a */))) += (uintptr((*VP8Io)(unsafe.Pointer(io)).crop_left))
- }
- (*VP8Io)(unsafe.Pointer(io)).mb_y = (y_start - (*VP8Io)(unsafe.Pointer(io)).crop_top)
- (*VP8Io)(unsafe.Pointer(io)).mb_w = ((*VP8Io)(unsafe.Pointer(io)).crop_right - (*VP8Io)(unsafe.Pointer(io)).crop_left)
- (*VP8Io)(unsafe.Pointer(io)).mb_h = (y_end - y_start)
+ *(*uintptr)(unsafe.Pointer(io + 24)) += uintptr((*VP8Io)(unsafe.Pointer(io)).crop_left)
+ *(*uintptr)(unsafe.Pointer(io + 32)) += uintptr((*VP8Io)(unsafe.Pointer(io)).crop_left >> 1)
+ *(*uintptr)(unsafe.Pointer(io + 40)) += uintptr((*VP8Io)(unsafe.Pointer(io)).crop_left >> 1)
+ if (*VP8Io)(unsafe.Pointer(io)).a != uintptr(0) {
+ *(*uintptr)(unsafe.Pointer(io + 152)) += uintptr((*VP8Io)(unsafe.Pointer(io)).crop_left)
+ }
+ (*VP8Io)(unsafe.Pointer(io)).mb_y = y_start - (*VP8Io)(unsafe.Pointer(io)).crop_top
+ (*VP8Io)(unsafe.Pointer(io)).mb_w = (*VP8Io)(unsafe.Pointer(io)).crop_right - (*VP8Io)(unsafe.Pointer(io)).crop_left
+ (*VP8Io)(unsafe.Pointer(io)).mb_h = y_end - y_start
ok = (*struct {
f func(*libc.TLS, uintptr) int32
})(unsafe.Pointer(&struct{ uintptr }{(*VP8Io)(unsafe.Pointer(io)).put})).f(tls, io)
}
}
// rotate top samples if needed
- if (cache_id + 1) == (*VP8Decoder)(unsafe.Pointer(dec)).num_caches_ {
+ if cache_id+1 == (*VP8Decoder)(unsafe.Pointer(dec)).num_caches_ {
if !(is_last_row != 0) {
- libc.Xmemcpy(tls, ((*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ - uintptr(ysize)), (ydst + uintptr((16 * (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_))), uint64(ysize))
- libc.Xmemcpy(tls, ((*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ - uintptr(uvsize)), (udst + uintptr((8 * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_))), uint64(uvsize))
- libc.Xmemcpy(tls, ((*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ - uintptr(uvsize)), (vdst + uintptr((8 * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_))), uint64(uvsize))
+ libc.Xmemcpy(tls, (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_-uintptr(ysize), ydst+uintptr(16*(*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_), uint64(ysize))
+ libc.Xmemcpy(tls, (*VP8Decoder)(unsafe.Pointer(dec)).cache_u_-uintptr(uvsize), udst+uintptr(8*(*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_), uint64(uvsize))
+ libc.Xmemcpy(tls, (*VP8Decoder)(unsafe.Pointer(dec)).cache_v_-uintptr(uvsize), vdst+uintptr(8*(*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_), uint64(uvsize))
}
}
@@ -6042,8 +5782,8 @@ func FinishRow(tls *libc.TLS, arg1 uintptr, arg2 uintptr) int32 { /* frame_dec.c
func VP8ProcessRow(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* frame_dec.c:501:5: */
var ok int32 = 1
- var ctx uintptr = (dec + 216 /* &.thread_ctx_ */)
- var filter_row int32 = (libc.Bool32((((*VP8Decoder)(unsafe.Pointer(dec)).filter_type_ > 0) && ((*VP8Decoder)(unsafe.Pointer(dec)).mb_y_ >= (*VP8Decoder)(unsafe.Pointer(dec)).tl_mb_y_)) && ((*VP8Decoder)(unsafe.Pointer(dec)).mb_y_ <= (*VP8Decoder)(unsafe.Pointer(dec)).br_mb_y_)))
+ var ctx uintptr = dec + 216
+ var filter_row int32 = libc.Bool32((*VP8Decoder)(unsafe.Pointer(dec)).filter_type_ > 0 && (*VP8Decoder)(unsafe.Pointer(dec)).mb_y_ >= (*VP8Decoder)(unsafe.Pointer(dec)).tl_mb_y_ && (*VP8Decoder)(unsafe.Pointer(dec)).mb_y_ <= (*VP8Decoder)(unsafe.Pointer(dec)).br_mb_y_)
if (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ == 0 {
// ctx->id_ and ctx->f_info_ are already set
(*VP8ThreadContext)(unsafe.Pointer(ctx)).mb_y_ = (*VP8Decoder)(unsafe.Pointer(dec)).mb_y_
@@ -6051,11 +5791,11 @@ func VP8ProcessRow(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* frame_dec.
ReconstructRow(tls, dec, ctx)
ok = FinishRow(tls, dec, io)
} else {
- var worker uintptr = (dec + 152 /* &.worker_ */)
+ var worker uintptr = dec + 152
// Finish previous job *before* updating context
- ok = ok & ((*struct {
+ ok = ok & (*struct {
f func(*libc.TLS, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Sync})).f(tls, worker))
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Sync})).f(tls, worker)
if ok != 0 { // spawn a new deblocking/output job
(*VP8ThreadContext)(unsafe.Pointer(ctx)).io_ = *(*VP8Io)(unsafe.Pointer(io))
@@ -6091,10 +5831,10 @@ func VP8ProcessRow(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* frame_dec.
func VP8EnterCritical(tls *libc.TLS, dec uintptr, io uintptr) VP8StatusCode { /* frame_dec.c:549:15: */
// Call setup() first. This may trigger additional decoding features on 'io'.
// Note: Afterward, we must call teardown() no matter what.
- if ((*VP8Io)(unsafe.Pointer(io)).setup != (uintptr(0))) && !((*struct {
+ if (*VP8Io)(unsafe.Pointer(io)).setup != uintptr(0) && !((*struct {
f func(*libc.TLS, uintptr) int32
})(unsafe.Pointer(&struct{ uintptr }{(*VP8Io)(unsafe.Pointer(io)).setup})).f(tls, io) != 0) {
- VP8SetError(tls, dec, VP8_STATUS_USER_ABORT, (ts + 29) /* "Frame setup fail..." */)
+ VP8SetError(tls, dec, VP8_STATUS_USER_ABORT, ts+29)
return (*VP8Decoder)(unsafe.Pointer(dec)).status_
}
@@ -6123,8 +5863,8 @@ func VP8EnterCritical(tls *libc.TLS, dec uintptr, io uintptr) VP8StatusCode { /*
// We include 'extra_pixels' on the other side of the boundary, since
// vertical or horizontal filtering of the previous macroblock can
// modify some abutting pixels.
- (*VP8Decoder)(unsafe.Pointer(dec)).tl_mb_x_ = (((*VP8Io)(unsafe.Pointer(io)).crop_left - extra_pixels) >> 4)
- (*VP8Decoder)(unsafe.Pointer(dec)).tl_mb_y_ = (((*VP8Io)(unsafe.Pointer(io)).crop_top - extra_pixels) >> 4)
+ (*VP8Decoder)(unsafe.Pointer(dec)).tl_mb_x_ = ((*VP8Io)(unsafe.Pointer(io)).crop_left - extra_pixels) >> 4
+ (*VP8Decoder)(unsafe.Pointer(dec)).tl_mb_y_ = ((*VP8Io)(unsafe.Pointer(io)).crop_top - extra_pixels) >> 4
if (*VP8Decoder)(unsafe.Pointer(dec)).tl_mb_x_ < 0 {
(*VP8Decoder)(unsafe.Pointer(dec)).tl_mb_x_ = 0
}
@@ -6133,8 +5873,8 @@ func VP8EnterCritical(tls *libc.TLS, dec uintptr, io uintptr) VP8StatusCode { /*
}
}
// We need some 'extra' pixels on the right/bottom.
- (*VP8Decoder)(unsafe.Pointer(dec)).br_mb_y_ = ((((*VP8Io)(unsafe.Pointer(io)).crop_bottom + 15) + extra_pixels) >> 4)
- (*VP8Decoder)(unsafe.Pointer(dec)).br_mb_x_ = ((((*VP8Io)(unsafe.Pointer(io)).crop_right + 15) + extra_pixels) >> 4)
+ (*VP8Decoder)(unsafe.Pointer(dec)).br_mb_y_ = ((*VP8Io)(unsafe.Pointer(io)).crop_bottom + 15 + extra_pixels) >> 4
+ (*VP8Decoder)(unsafe.Pointer(dec)).br_mb_x_ = ((*VP8Io)(unsafe.Pointer(io)).crop_right + 15 + extra_pixels) >> 4
if (*VP8Decoder)(unsafe.Pointer(dec)).br_mb_x_ > (*VP8Decoder)(unsafe.Pointer(dec)).mb_w_ {
(*VP8Decoder)(unsafe.Pointer(dec)).br_mb_x_ = (*VP8Decoder)(unsafe.Pointer(dec)).mb_w_
}
@@ -6152,10 +5892,10 @@ func VP8ExitCritical(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* frame_de
if (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ > 0 {
ok = (*struct {
f func(*libc.TLS, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Sync})).f(tls, (dec + 152 /* &.worker_ */))
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Sync})).f(tls, dec+152 /* &.worker_ */)
}
- if (*VP8Io)(unsafe.Pointer(io)).teardown != (uintptr(0)) {
+ if (*VP8Io)(unsafe.Pointer(io)).teardown != uintptr(0) {
(*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*VP8Io)(unsafe.Pointer(io)).teardown})).f(tls, io)
}
return ok
@@ -6189,15 +5929,15 @@ func VP8ExitCritical(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* frame_de
func InitThreadContext(tls *libc.TLS, dec uintptr) int32 { /* frame_dec.c:641:12: */
(*VP8Decoder)(unsafe.Pointer(dec)).cache_id_ = 0
if (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ > 0 {
- var worker uintptr = (dec + 152 /* &.worker_ */)
+ var worker uintptr = dec + 152
if !((*struct {
f func(*libc.TLS, uintptr) int32
})(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Reset})).f(tls, worker) != 0) {
return VP8SetError(tls, dec, VP8_STATUS_OUT_OF_MEMORY,
- (ts + 48) /* "thread initializ..." */)
+ ts+48)
}
(*WebPWorker)(unsafe.Pointer(worker)).data1 = dec
- (*WebPWorker)(unsafe.Pointer(worker)).data2 = ((dec + 216 /* &.thread_ctx_ */) + 32 /* &.io_ */)
+ (*WebPWorker)(unsafe.Pointer(worker)).data2 = dec + 216 + 32
(*WebPWorker)(unsafe.Pointer(worker)).hook = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) int32
}{FinishRow}))
@@ -6205,7 +5945,7 @@ func InitThreadContext(tls *libc.TLS, dec uintptr) int32 { /* frame_dec.c:641:12
if (*VP8Decoder)(unsafe.Pointer(dec)).filter_type_ > 0 {
return 3
}
- return (3 - 1)
+ return 3 - 1
}()
} else {
(*VP8Decoder)(unsafe.Pointer(dec)).num_caches_ = 1
@@ -6214,7 +5954,7 @@ func InitThreadContext(tls *libc.TLS, dec uintptr) int32 { /* frame_dec.c:641:12
}
func VP8GetThreadMethod(tls *libc.TLS, options uintptr, headers uintptr, width int32, height int32) int32 { /* frame_dec.c:660:5: */
- if (options == (uintptr(0))) || ((*WebPDecoderOptions)(unsafe.Pointer(options)).use_threads == 0) {
+ if options == uintptr(0) || (*WebPDecoderOptions)(unsafe.Pointer(options)).use_threads == 0 {
return 0
}
_ = headers
@@ -6231,41 +5971,41 @@ func AllocateMemory(tls *libc.TLS, dec uintptr) int32 { /* frame_dec.c:682:12: *
var num_caches int32 = (*VP8Decoder)(unsafe.Pointer(dec)).num_caches_
var mb_w int32 = (*VP8Decoder)(unsafe.Pointer(dec)).mb_w_
// Note: we use 'size_t' when there's no overflow risk, uint64_t otherwise.
- var intra_pred_mode_size size_t = ((uint64(4 * mb_w)) * uint64(unsafe.Sizeof(uint8_t(0))))
- var top_size size_t = (uint64(unsafe.Sizeof(VP8TopSamples{})) * uint64(mb_w))
- var mb_info_size size_t = ((uint64(mb_w + 1)) * uint64(unsafe.Sizeof(VP8MB{})))
+ var intra_pred_mode_size size_t = uint64(4*mb_w) * uint64(unsafe.Sizeof(uint8_t(0)))
+ var top_size size_t = uint64(unsafe.Sizeof(VP8TopSamples{})) * uint64(mb_w)
+ var mb_info_size size_t = uint64(mb_w+1) * uint64(unsafe.Sizeof(VP8MB{}))
var f_info_size size_t
if (*VP8Decoder)(unsafe.Pointer(dec)).filter_type_ > 0 {
- f_info_size = ((uint64(mb_w * (func() int32 {
+ f_info_size = uint64(mb_w*func() int32 {
if (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ > 0 {
return 2
}
return 1
- }()))) * uint64(unsafe.Sizeof(VP8FInfo{})))
+ }()) * uint64(unsafe.Sizeof(VP8FInfo{}))
} else {
f_info_size = uint64(0)
}
- var yuv_size size_t = ((uint64((32 * 17) + (32 * 9))) * uint64(unsafe.Sizeof(uint8_t(0))))
- var mb_data_size size_t = ((uint64((func() int32 {
+ var yuv_size size_t = uint64(32*17+32*9) * uint64(unsafe.Sizeof(uint8_t(0)))
+ var mb_data_size size_t = uint64(func() int32 {
if (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ == 2 {
return 2
}
return 1
- }()) * mb_w)) * uint64(unsafe.Sizeof(VP8MBData{})))
- var cache_height size_t = (size_t((((16 * num_caches) +
- int32(kFilterExtraRows[(*VP8Decoder)(unsafe.Pointer(dec)).filter_type_])) * 3) / 2))
- var cache_size size_t = (top_size * cache_height)
+ }()*mb_w) * uint64(unsafe.Sizeof(VP8MBData{}))
+ var cache_height size_t = size_t((16*num_caches +
+ int32(kFilterExtraRows[(*VP8Decoder)(unsafe.Pointer(dec)).filter_type_])) * 3 / 2)
+ var cache_size size_t = top_size * cache_height
// alpha_size is the only one that scales as width x height.
var alpha_size uint64_t
- if (*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_ != (uintptr(0)) {
- alpha_size = (uint64_t((*VP8Decoder)(unsafe.Pointer(dec)).pic_hdr_.width_) * uint64_t((*VP8Decoder)(unsafe.Pointer(dec)).pic_hdr_.height_))
+ if (*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_ != uintptr(0) {
+ alpha_size = uint64_t((*VP8Decoder)(unsafe.Pointer(dec)).pic_hdr_.width_) * uint64_t((*VP8Decoder)(unsafe.Pointer(dec)).pic_hdr_.height_)
} else {
alpha_size = 0
}
- var needed uint64_t = ((((((((intra_pred_mode_size +
- top_size) + mb_info_size) + f_info_size) +
- yuv_size) + mb_data_size) +
- cache_size) + alpha_size) + uint64(31))
+ var needed uint64_t = intra_pred_mode_size +
+ top_size + mb_info_size + f_info_size +
+ yuv_size + mb_data_size +
+ cache_size + alpha_size + uint64(31)
var mem uintptr
if !(CheckSizeOverflow(tls, needed) != 0) {
@@ -6275,9 +6015,9 @@ func AllocateMemory(tls *libc.TLS, dec uintptr) int32 { /* frame_dec.c:682:12: *
WebPSafeFree(tls, (*VP8Decoder)(unsafe.Pointer(dec)).mem_)
(*VP8Decoder)(unsafe.Pointer(dec)).mem_size_ = uint64(0)
(*VP8Decoder)(unsafe.Pointer(dec)).mem_ = WebPSafeMalloc(tls, needed, uint64(unsafe.Sizeof(uint8_t(0))))
- if (*VP8Decoder)(unsafe.Pointer(dec)).mem_ == (uintptr(0)) {
+ if (*VP8Decoder)(unsafe.Pointer(dec)).mem_ == uintptr(0) {
return VP8SetError(tls, dec, VP8_STATUS_OUT_OF_MEMORY,
- (ts + 78) /* "no memory during..." */)
+ ts+78)
}
// down-cast is ok, thanks to WebPSafeMalloc() above.
(*VP8Decoder)(unsafe.Pointer(dec)).mem_size_ = needed
@@ -6290,26 +6030,26 @@ func AllocateMemory(tls *libc.TLS, dec uintptr) int32 { /* frame_dec.c:682:12: *
(*VP8Decoder)(unsafe.Pointer(dec)).yuv_t_ = mem
mem += uintptr(top_size)
- (*VP8Decoder)(unsafe.Pointer(dec)).mb_info_ = ((mem) + uintptr(1)*2)
+ (*VP8Decoder)(unsafe.Pointer(dec)).mb_info_ = mem + uintptr(1)*2
mem += uintptr(mb_info_size)
(*VP8Decoder)(unsafe.Pointer(dec)).f_info_ = func() uintptr {
if f_info_size != 0 {
return mem
}
- return (uintptr(0))
+ return uintptr(0)
}()
mem += uintptr(f_info_size)
(*VP8Decoder)(unsafe.Pointer(dec)).thread_ctx_.id_ = 0
(*VP8Decoder)(unsafe.Pointer(dec)).thread_ctx_.f_info_ = (*VP8Decoder)(unsafe.Pointer(dec)).f_info_
- if ((*VP8Decoder)(unsafe.Pointer(dec)).filter_type_ > 0) && ((*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ > 0) {
+ if (*VP8Decoder)(unsafe.Pointer(dec)).filter_type_ > 0 && (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ > 0 {
// secondary cache line. The deblocking process need to make use of the
// filtering strength from previous macroblock row, while the new ones
// are being decoded in parallel. We'll just swap the pointers.
- *(*uintptr)(unsafe.Pointer(((dec + 216 /* &.thread_ctx_ */) + 16 /* &.f_info_ */))) += (uintptr(mb_w)) * 4
+ *(*uintptr)(unsafe.Pointer(dec + 216 + 16)) += uintptr(mb_w) * 4
}
- mem = (uintptr((uintptr_t((mem)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
+ mem = uintptr((uintptr_t(mem) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
(*VP8Decoder)(unsafe.Pointer(dec)).yuv_b_ = mem
mem += uintptr(yuv_size)
@@ -6317,21 +6057,21 @@ func AllocateMemory(tls *libc.TLS, dec uintptr) int32 { /* frame_dec.c:682:12: *
(*VP8Decoder)(unsafe.Pointer(dec)).mb_data_ = mem
(*VP8Decoder)(unsafe.Pointer(dec)).thread_ctx_.mb_data_ = mem
if (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ == 2 {
- *(*uintptr)(unsafe.Pointer(((dec + 216 /* &.thread_ctx_ */) + 24 /* &.mb_data_ */))) += (uintptr(mb_w)) * 800
+ *(*uintptr)(unsafe.Pointer(dec + 216 + 24)) += uintptr(mb_w) * 800
}
mem += uintptr(mb_data_size)
- (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_ = (16 * mb_w)
- (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_ = (8 * mb_w)
+ (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_ = 16 * mb_w
+ (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_ = 8 * mb_w
{
var extra_rows int32 = int32(kFilterExtraRows[(*VP8Decoder)(unsafe.Pointer(dec)).filter_type_])
- var extra_y int32 = (extra_rows * (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_)
- var extra_uv int32 = ((extra_rows / 2) * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_)
- (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ = (mem + uintptr(extra_y))
- (*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ +
- uintptr(((16 * num_caches) * (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_))) + uintptr(extra_uv))
- (*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ = (((*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ +
- uintptr(((8 * num_caches) * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_))) + uintptr(extra_uv))
+ var extra_y int32 = extra_rows * (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_
+ var extra_uv int32 = extra_rows / 2 * (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_
+ (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ = mem + uintptr(extra_y)
+ (*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ = (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_ +
+ uintptr(16*num_caches*(*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_) + uintptr(extra_uv)
+ (*VP8Decoder)(unsafe.Pointer(dec)).cache_v_ = (*VP8Decoder)(unsafe.Pointer(dec)).cache_u_ +
+ uintptr(8*num_caches*(*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_) + uintptr(extra_uv)
(*VP8Decoder)(unsafe.Pointer(dec)).cache_id_ = 0
}
@@ -6342,12 +6082,12 @@ func AllocateMemory(tls *libc.TLS, dec uintptr) int32 { /* frame_dec.c:682:12: *
if alpha_size != 0 {
return mem
}
- return (uintptr(0))
+ return uintptr(0)
}()
mem += uintptr(alpha_size)
// note: left/top-info is initialized once for all.
- libc.Xmemset(tls, ((*VP8Decoder)(unsafe.Pointer(dec)).mb_info_ - uintptr(1)*2), 0, mb_info_size)
+ libc.Xmemset(tls, (*VP8Decoder)(unsafe.Pointer(dec)).mb_info_-uintptr(1)*2, 0, mb_info_size)
VP8InitScanline(tls, dec) // initialize left too.
// initialize top
@@ -6364,7 +6104,7 @@ func InitIo(tls *libc.TLS, dec uintptr, io uintptr) { /* frame_dec.c:784:13: */
(*VP8Io)(unsafe.Pointer(io)).v = (*VP8Decoder)(unsafe.Pointer(dec)).cache_v_
(*VP8Io)(unsafe.Pointer(io)).y_stride = (*VP8Decoder)(unsafe.Pointer(dec)).cache_y_stride_
(*VP8Io)(unsafe.Pointer(io)).uv_stride = (*VP8Decoder)(unsafe.Pointer(dec)).cache_uv_stride_
- (*VP8Io)(unsafe.Pointer(io)).a = (uintptr(0))
+ (*VP8Io)(unsafe.Pointer(io)).a = uintptr(0)
}
func VP8InitFrame(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* frame_dec.c:795:5: */
@@ -6424,7 +6164,7 @@ type MBContext = struct {
// MemBuffer: incoming data handling
func MemDataSize(tls *libc.TLS, mem uintptr) size_t { /* idec_dec.c:91:27: */
- return ((*MemBuffer)(unsafe.Pointer(mem)).end_ - (*MemBuffer)(unsafe.Pointer(mem)).start_)
+ return (*MemBuffer)(unsafe.Pointer(mem)).end_ - (*MemBuffer)(unsafe.Pointer(mem)).start_
}
// Check if we need to preserve the compressed alpha data, as it may not have
@@ -6440,50 +6180,50 @@ func NeedCompressedAlpha(tls *libc.TLS, idec uintptr) int32 { /* idec_dec.c:97:1
} else {
var dec uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).dec_
// Must be true as idec->state_ != STATE_WEBP_HEADER.
- return (libc.Bool32(((*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_ != (uintptr(0))) && !((*VP8Decoder)(unsafe.Pointer(dec)).is_alpha_decoded_ != 0)))
+ return libc.Bool32((*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_ != uintptr(0) && !((*VP8Decoder)(unsafe.Pointer(dec)).is_alpha_decoded_ != 0))
}
return int32(0)
}
func DoRemap(tls *libc.TLS, idec uintptr, offset ptrdiff_t) { /* idec_dec.c:112:13: */
- var mem uintptr = (idec + 296 /* &.mem_ */)
- var new_base uintptr = ((*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_))
+ var mem uintptr = idec + 296
+ var new_base uintptr = (*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_)
// note: for VP8, setting up idec->io_ is only really needed at the beginning
// of the decoding, till partition #0 is complete.
(*WebPIDecoder)(unsafe.Pointer(idec)).io_.data = new_base
(*WebPIDecoder)(unsafe.Pointer(idec)).io_.data_size = MemDataSize(tls, mem)
- if (*WebPIDecoder)(unsafe.Pointer(idec)).dec_ != (uintptr(0)) {
+ if (*WebPIDecoder)(unsafe.Pointer(idec)).dec_ != uintptr(0) {
if !((*WebPIDecoder)(unsafe.Pointer(idec)).is_lossless_ != 0) {
var dec uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).dec_
var last_part uint32_t = (*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_
if offset != int64(0) {
var p uint32_t
for p = uint32_t(0); p <= last_part; p++ {
- VP8RemapBitReader(tls, ((dec + 440 /* &.parts_ */) + uintptr(p)*48), offset)
+ VP8RemapBitReader(tls, dec+440+uintptr(p)*48, offset)
}
// Remap partition #0 data pointer to new offset, but only in MAP
// mode (in APPEND mode, partition #0 is copied into a fixed memory).
if (*MemBuffer)(unsafe.Pointer(mem)).mode_ == MEM_MODE_MAP {
- VP8RemapBitReader(tls, (dec + 16 /* &.br_ */), offset)
+ VP8RemapBitReader(tls, dec+16, offset)
}
}
{
- var last_start uintptr = (*VP8BitReader)(unsafe.Pointer((dec + 440 /* &.parts_ */) + uintptr(last_part)*48)).buf_
- VP8BitReaderSetBuffer(tls, ((dec + 440 /* &.parts_ */) + uintptr(last_part)*48), last_start,
- (uint64(((int64((*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).end_))) - int64(last_start)) / 1)))
+ var last_start uintptr = (*VP8BitReader)(unsafe.Pointer(dec + 440 + uintptr(last_part)*48)).buf_
+ VP8BitReaderSetBuffer(tls, dec+440+uintptr(last_part)*48, last_start,
+ uint64((int64((*MemBuffer)(unsafe.Pointer(mem)).buf_+uintptr((*MemBuffer)(unsafe.Pointer(mem)).end_))-int64(last_start))/1))
}
if NeedCompressedAlpha(tls, idec) != 0 {
var alph_dec uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).alph_dec_
- *(*uintptr)(unsafe.Pointer((dec + 2968 /* &.alpha_data_ */))) += (uintptr(offset))
- if (alph_dec != (uintptr(0))) && ((*ALPHDecoder)(unsafe.Pointer(alph_dec)).vp8l_dec_ != (uintptr(0))) {
+ *(*uintptr)(unsafe.Pointer(dec + 2968)) += uintptr(offset)
+ if alph_dec != uintptr(0) && (*ALPHDecoder)(unsafe.Pointer(alph_dec)).vp8l_dec_ != uintptr(0) {
if (*ALPHDecoder)(unsafe.Pointer(alph_dec)).method_ == 1 {
var alph_vp8l_dec uintptr = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).vp8l_dec_
- VP8LBitReaderSetBuffer(tls, (alph_vp8l_dec + 40 /* &.br_ */),
- ((*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_ + uintptr(1)),
- ((*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_size_ - uint64(1)))
+ VP8LBitReaderSetBuffer(tls, alph_vp8l_dec+40,
+ (*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_+uintptr(1),
+ (*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_size_-uint64(1))
} else { // alph_dec->method_ == ALPHA_NO_COMPRESSION
// Nothing special to do in this case.
}
@@ -6491,7 +6231,7 @@ func DoRemap(tls *libc.TLS, idec uintptr, offset ptrdiff_t) { /* idec_dec.c:112:
}
} else { // Resize lossless bitreader
var dec uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).dec_
- VP8LBitReaderSetBuffer(tls, (dec + 40 /* &.br_ */), new_base, MemDataSize(tls, mem))
+ VP8LBitReaderSetBuffer(tls, dec+40, new_base, MemDataSize(tls, mem))
}
}
}
@@ -6500,13 +6240,13 @@ func DoRemap(tls *libc.TLS, idec uintptr, offset ptrdiff_t) { /* idec_dec.c:112:
// size if required and also updates VP8BitReader's if new memory is allocated.
func AppendToMemBuffer(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) int32 { /* idec_dec.c:164:12: */
var dec uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).dec_
- var mem uintptr = (idec + 296 /* &.mem_ */)
+ var mem uintptr = idec + 296
var need_compressed_alpha int32 = NeedCompressedAlpha(tls, idec)
var old_start uintptr
- if (*MemBuffer)(unsafe.Pointer(mem)).buf_ == (uintptr(0)) {
- old_start = (uintptr(0))
+ if (*MemBuffer)(unsafe.Pointer(mem)).buf_ == uintptr(0) {
+ old_start = uintptr(0)
} else {
- old_start = ((*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_))
+ old_start = (*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_)
}
var old_base uintptr
if need_compressed_alpha != 0 {
@@ -6515,22 +6255,22 @@ func AppendToMemBuffer(tls *libc.TLS, idec uintptr, data uintptr, data_size size
old_base = old_start
}
- if data_size > (uint64((libc.CplUint32(0) - uint32(8)) - uint32(1))) {
+ if data_size > uint64(libc.CplUint32(0)-uint32(8)-uint32(1)) {
// security safeguard: trying to allocate more than what the format
// allows for a chunk should be considered a smoke smell.
return 0
}
- if ((*MemBuffer)(unsafe.Pointer(mem)).end_ + data_size) > (*MemBuffer)(unsafe.Pointer(mem)).buf_size_ { // Need some free memory
- var new_mem_start size_t = (size_t((int64(old_start) - int64(old_base)) / 1))
- var current_size size_t = (MemDataSize(tls, mem) + new_mem_start)
- var new_size uint64_t = (current_size + data_size)
- var extra_size uint64_t = (((new_size + uint64(4096)) - uint64(1)) & libc.Uint64FromInt32(libc.CplInt32((4096 - 1))))
+ if (*MemBuffer)(unsafe.Pointer(mem)).end_+data_size > (*MemBuffer)(unsafe.Pointer(mem)).buf_size_ { // Need some free memory
+ var new_mem_start size_t = size_t((int64(old_start) - int64(old_base)) / 1)
+ var current_size size_t = MemDataSize(tls, mem) + new_mem_start
+ var new_size uint64_t = current_size + data_size
+ var extra_size uint64_t = (new_size + uint64(4096) - uint64(1)) & libc.Uint64FromInt32(libc.CplInt32(4096-1))
var new_buf uintptr = WebPSafeMalloc(tls, extra_size, uint64(unsafe.Sizeof(uint8_t(0))))
- if new_buf == (uintptr(0)) {
+ if new_buf == uintptr(0) {
return 0
}
- if old_base != (uintptr(0)) {
+ if old_base != uintptr(0) {
libc.Xmemcpy(tls, new_buf, old_base, current_size)
}
WebPSafeFree(tls, (*MemBuffer)(unsafe.Pointer(mem)).buf_)
@@ -6540,21 +6280,21 @@ func AppendToMemBuffer(tls *libc.TLS, idec uintptr, data uintptr, data_size size
(*MemBuffer)(unsafe.Pointer(mem)).end_ = current_size
}
- libc.Xmemcpy(tls, ((*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).end_)), data, data_size)
- *(*size_t)(unsafe.Pointer((mem + 16 /* &.end_ */))) += (data_size)
+ libc.Xmemcpy(tls, (*MemBuffer)(unsafe.Pointer(mem)).buf_+uintptr((*MemBuffer)(unsafe.Pointer(mem)).end_), data, data_size)
+ *(*size_t)(unsafe.Pointer(mem + 16)) += data_size
- DoRemap(tls, idec, (((int64((*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_))) - int64(old_start)) / 1))
+ DoRemap(tls, idec, (int64((*MemBuffer)(unsafe.Pointer(mem)).buf_+uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_))-int64(old_start))/1)
return 1
}
func RemapMemBuffer(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) int32 { /* idec_dec.c:206:12: */
- var mem uintptr = (idec + 296 /* &.mem_ */)
+ var mem uintptr = idec + 296
var old_buf uintptr = (*MemBuffer)(unsafe.Pointer(mem)).buf_
var old_start uintptr
- if old_buf == (uintptr(0)) {
- old_start = (uintptr(0))
+ if old_buf == uintptr(0) {
+ old_start = uintptr(0)
} else {
- old_start = (old_buf + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_))
+ old_start = old_buf + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_)
}
if data_size < (*MemBuffer)(unsafe.Pointer(mem)).buf_size_ {
@@ -6562,17 +6302,17 @@ func RemapMemBuffer(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t)
} // can't remap to a shorter buffer!
(*MemBuffer)(unsafe.Pointer(mem)).buf_ = data
- (*MemBuffer)(unsafe.Pointer(mem)).end_ = libc.AssignPtrUint64((mem + 24 /* &.buf_size_ */), data_size)
+ (*MemBuffer)(unsafe.Pointer(mem)).end_ = libc.AssignPtrUint64(mem+24, data_size)
- DoRemap(tls, idec, (((int64((*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_))) - int64(old_start)) / 1))
+ DoRemap(tls, idec, (int64((*MemBuffer)(unsafe.Pointer(mem)).buf_+uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_))-int64(old_start))/1)
return 1
}
func InitMemBuffer(tls *libc.TLS, mem uintptr) { /* idec_dec.c:224:13: */
(*MemBuffer)(unsafe.Pointer(mem)).mode_ = MEM_MODE_NONE
- (*MemBuffer)(unsafe.Pointer(mem)).buf_ = (uintptr(0))
+ (*MemBuffer)(unsafe.Pointer(mem)).buf_ = uintptr(0)
(*MemBuffer)(unsafe.Pointer(mem)).buf_size_ = uint64(0)
- (*MemBuffer)(unsafe.Pointer(mem)).part0_buf_ = (uintptr(0))
+ (*MemBuffer)(unsafe.Pointer(mem)).part0_buf_ = uintptr(0)
(*MemBuffer)(unsafe.Pointer(mem)).part0_size_ = uint64(0)
}
@@ -6600,17 +6340,17 @@ func FinishDecoding(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:2
var output uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).params_.output
(*WebPIDecoder)(unsafe.Pointer(idec)).state_ = STATE_DONE
- if (options != (uintptr(0))) && ((*WebPDecoderOptions)(unsafe.Pointer(options)).flip != 0) {
+ if options != uintptr(0) && (*WebPDecoderOptions)(unsafe.Pointer(options)).flip != 0 {
var status VP8StatusCode = WebPFlipBuffer(tls, output)
if status != VP8_STATUS_OK {
return status
}
}
- if (*WebPIDecoder)(unsafe.Pointer(idec)).final_output_ != (uintptr(0)) {
+ if (*WebPIDecoder)(unsafe.Pointer(idec)).final_output_ != uintptr(0) {
WebPCopyDecBufferPixels(tls, output, (*WebPIDecoder)(unsafe.Pointer(idec)).final_output_) // do the slow-copy
- WebPFreeDecBuffer(tls, (idec + 352 /* &.output_ */))
+ WebPFreeDecBuffer(tls, idec+352)
*(*WebPDecBuffer)(unsafe.Pointer(output)) = *(*WebPDecBuffer)(unsafe.Pointer((*WebPIDecoder)(unsafe.Pointer(idec)).final_output_))
- (*WebPIDecoder)(unsafe.Pointer(idec)).final_output_ = (uintptr(0))
+ (*WebPIDecoder)(unsafe.Pointer(idec)).final_output_ = uintptr(0)
}
return VP8_STATUS_OK
}
@@ -6635,18 +6375,18 @@ func RestoreContext(tls *libc.TLS, context uintptr, dec uintptr, token_br uintpt
func IDecError(tls *libc.TLS, idec uintptr, error VP8StatusCode) VP8StatusCode { /* idec_dec.c:288:22: */
if (*WebPIDecoder)(unsafe.Pointer(idec)).state_ == STATE_VP8_DATA {
// Synchronize the thread, clean-up and check for errors.
- VP8ExitCritical(tls, (*WebPIDecoder)(unsafe.Pointer(idec)).dec_, (idec + 136 /* &.io_ */))
+ VP8ExitCritical(tls, (*WebPIDecoder)(unsafe.Pointer(idec)).dec_, idec+136)
}
(*WebPIDecoder)(unsafe.Pointer(idec)).state_ = STATE_ERROR
return error
}
func ChangeState(tls *libc.TLS, idec uintptr, new_state DecState, consumed_bytes size_t) { /* idec_dec.c:297:13: */
- var mem uintptr = (idec + 296 /* &.mem_ */)
+ var mem uintptr = idec + 296
(*WebPIDecoder)(unsafe.Pointer(idec)).state_ = new_state
- *(*size_t)(unsafe.Pointer((mem + 8 /* &.start_ */))) += (consumed_bytes)
+ *(*size_t)(unsafe.Pointer(mem + 8)) += consumed_bytes
- (*WebPIDecoder)(unsafe.Pointer(idec)).io_.data = ((*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_))
+ (*WebPIDecoder)(unsafe.Pointer(idec)).io_.data = (*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_)
(*WebPIDecoder)(unsafe.Pointer(idec)).io_.data_size = MemDataSize(tls, mem)
}
@@ -6655,8 +6395,8 @@ func DecodeWebPHeaders(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.
bp := tls.Alloc(72)
defer tls.Free(72)
- var mem uintptr = (idec + 296 /* &.mem_ */)
- var data uintptr = ((*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_))
+ var mem uintptr = idec + 296
+ var data uintptr = (*MemBuffer)(unsafe.Pointer(mem)).buf_ + uintptr((*MemBuffer)(unsafe.Pointer(mem)).start_)
var curr_size size_t = MemDataSize(tls, mem)
var status VP8StatusCode
// var headers WebPHeaderStructure at bp, 72
@@ -6664,7 +6404,7 @@ func DecodeWebPHeaders(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.
(*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).data = data
(*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).data_size = curr_size
(*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).have_all_data = 0
- status = WebPParseHeaders(tls, (bp) /* &headers */)
+ status = WebPParseHeaders(tls, bp)
if status == VP8_STATUS_NOT_ENOUGH_DATA {
return VP8_STATUS_SUSPENDED // We haven't found a VP8 chunk yet.
} else if status != VP8_STATUS_OK {
@@ -6675,7 +6415,7 @@ func DecodeWebPHeaders(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.
(*WebPIDecoder)(unsafe.Pointer(idec)).is_lossless_ = (*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).is_lossless
if !((*WebPIDecoder)(unsafe.Pointer(idec)).is_lossless_ != 0) {
var dec uintptr = VP8New(tls)
- if dec == (uintptr(0)) {
+ if dec == uintptr(0) {
return VP8_STATUS_OUT_OF_MEMORY
}
(*WebPIDecoder)(unsafe.Pointer(idec)).dec_ = dec
@@ -6684,7 +6424,7 @@ func DecodeWebPHeaders(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.
ChangeState(tls, idec, STATE_VP8_HEADER, (*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).offset)
} else {
var dec uintptr = VP8LNew(tls)
- if dec == (uintptr(0)) {
+ if dec == uintptr(0) {
return VP8_STATUS_OUT_OF_MEMORY
}
(*WebPIDecoder)(unsafe.Pointer(idec)).dec_ = dec
@@ -6697,8 +6437,8 @@ func DecodeVP8FrameHeader(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_d
bp := tls.Alloc(8)
defer tls.Free(8)
- var data uintptr = ((*WebPIDecoder)(unsafe.Pointer(idec)).mem_.buf_ + uintptr((*WebPIDecoder)(unsafe.Pointer(idec)).mem_.start_))
- var curr_size size_t = MemDataSize(tls, (idec + 296 /* &.mem_ */))
+ var data uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).mem_.buf_ + uintptr((*WebPIDecoder)(unsafe.Pointer(idec)).mem_.start_)
+ var curr_size size_t = MemDataSize(tls, idec+296)
// var width int32 at bp, 4
// var height int32 at bp+4, 4
@@ -6709,12 +6449,12 @@ func DecodeVP8FrameHeader(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_d
// Not enough data bytes to extract VP8 Frame Header.
return VP8_STATUS_SUSPENDED
}
- if !(VP8GetInfo(tls, data, curr_size, (*WebPIDecoder)(unsafe.Pointer(idec)).chunk_size_, (bp) /* &width */, (bp+4) /* &height */) != 0) {
+ if !(VP8GetInfo(tls, data, curr_size, (*WebPIDecoder)(unsafe.Pointer(idec)).chunk_size_, bp, bp+4) != 0) {
return IDecError(tls, idec, VP8_STATUS_BITSTREAM_ERROR)
}
- bits = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(data))) | (int32(*(*uint8_t)(unsafe.Pointer(data + 1))) << 8)) | (int32(*(*uint8_t)(unsafe.Pointer(data + 2))) << 16)))
- (*WebPIDecoder)(unsafe.Pointer(idec)).mem_.part0_size_ = (size_t((bits >> 5) + uint32_t(10)))
+ bits = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(data))) | int32(*(*uint8_t)(unsafe.Pointer(data + 1)))<<8 | int32(*(*uint8_t)(unsafe.Pointer(data + 2)))<<16)
+ (*WebPIDecoder)(unsafe.Pointer(idec)).mem_.part0_size_ = size_t(bits>>5 + uint32_t(10))
(*WebPIDecoder)(unsafe.Pointer(idec)).io_.data = data
(*WebPIDecoder)(unsafe.Pointer(idec)).io_.data_size = curr_size
@@ -6725,9 +6465,9 @@ func DecodeVP8FrameHeader(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_d
// Partition #0
func CopyParts0Data(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:371:22: */
var dec uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).dec_
- var br uintptr = (dec + 16 /* &.br_ */)
- var part_size size_t = (size_t((int64((*VP8BitReader)(unsafe.Pointer(br)).buf_end_) - int64((*VP8BitReader)(unsafe.Pointer(br)).buf_)) / 1))
- var mem uintptr = (idec + 296 /* &.mem_ */)
+ var br uintptr = dec + 16
+ var part_size size_t = size_t((int64((*VP8BitReader)(unsafe.Pointer(br)).buf_end_) - int64((*VP8BitReader)(unsafe.Pointer(br)).buf_)) / 1)
+ var mem uintptr = idec + 296
// the following is a format limitation, no need for runtime check:
@@ -6737,7 +6477,7 @@ func CopyParts0Data(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:3
if (*MemBuffer)(unsafe.Pointer(mem)).mode_ == MEM_MODE_APPEND {
// We copy and grab ownership of the partition #0 data.
var part0_buf uintptr = WebPSafeMalloc(tls, 1, part_size)
- if part0_buf == (uintptr(0)) {
+ if part0_buf == uintptr(0) {
return VP8_STATUS_OUT_OF_MEMORY
}
libc.Xmemcpy(tls, part0_buf, (*VP8BitReader)(unsafe.Pointer(br)).buf_, part_size)
@@ -6746,24 +6486,24 @@ func CopyParts0Data(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:3
} else {
// Else: just keep pointers to the partition #0's data in dec_->br_.
}
- *(*size_t)(unsafe.Pointer((mem + 8 /* &.start_ */))) += (part_size)
+ *(*size_t)(unsafe.Pointer(mem + 8)) += part_size
return VP8_STATUS_OK
}
func DecodePartition0(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:399:22: */
var dec uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).dec_
- var io uintptr = (idec + 136 /* &.io_ */)
- var params uintptr = (idec + 8 /* &.params_ */)
+ var io uintptr = idec + 136
+ var params uintptr = idec + 8
var output uintptr = (*WebPDecParams)(unsafe.Pointer(params)).output
// Wait till we have enough data for the whole partition #0
- if MemDataSize(tls, (idec+296 /* &.mem_ */)) < (*WebPIDecoder)(unsafe.Pointer(idec)).mem_.part0_size_ {
+ if MemDataSize(tls, idec+296) < (*WebPIDecoder)(unsafe.Pointer(idec)).mem_.part0_size_ {
return VP8_STATUS_SUSPENDED
}
if !(VP8GetHeaders(tls, dec, io) != 0) {
var status VP8StatusCode = (*VP8Decoder)(unsafe.Pointer(dec)).status_
- if (status == VP8_STATUS_SUSPENDED) || (status == VP8_STATUS_NOT_ENOUGH_DATA) {
+ if status == VP8_STATUS_SUSPENDED || status == VP8_STATUS_NOT_ENOUGH_DATA {
// treating NOT_ENOUGH_DATA as SUSPENDED state
return VP8_STATUS_SUSPENDED
}
@@ -6777,7 +6517,7 @@ func DecodePartition0(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c
return IDecError(tls, idec, (*VP8Decoder)(unsafe.Pointer(dec)).status_)
}
// This change must be done before calling VP8InitFrame()
- (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ = VP8GetThreadMethod(tls, (*WebPDecParams)(unsafe.Pointer(params)).options, (uintptr(0)),
+ (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ = VP8GetThreadMethod(tls, (*WebPDecParams)(unsafe.Pointer(params)).options, uintptr(0),
(*VP8Io)(unsafe.Pointer(io)).width, (*VP8Io)(unsafe.Pointer(io)).height)
VP8InitDithering(tls, (*WebPDecParams)(unsafe.Pointer(params)).options, dec)
@@ -6807,7 +6547,7 @@ func DecodeRemaining(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:
defer tls.Free(56)
var dec uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).dec_
- var io uintptr = (idec + 136 /* &.io_ */)
+ var io uintptr = idec + 136
// Make sure partition #0 has been read before, to set dec to ready_.
if !((*VP8Decoder)(unsafe.Pointer(dec)).ready_ != 0) {
@@ -6815,7 +6555,7 @@ func DecodeRemaining(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:
}
for ; (*VP8Decoder)(unsafe.Pointer(dec)).mb_y_ < (*VP8Decoder)(unsafe.Pointer(dec)).mb_h_; (*VP8Decoder)(unsafe.Pointer(dec)).mb_y_++ {
if (*WebPIDecoder)(unsafe.Pointer(idec)).last_mb_y_ != (*VP8Decoder)(unsafe.Pointer(dec)).mb_y_ {
- if !(VP8ParseIntraModeRow(tls, (dec+16 /* &.br_ */), dec) != 0) {
+ if !(VP8ParseIntraModeRow(tls, dec+16, dec) != 0) {
// note: normally, error shouldn't occur since we already have the whole
// partition0 available here in DecodeRemaining(). Reaching EOF while
// reading intra modes really means a BITSTREAM_ERROR.
@@ -6824,29 +6564,29 @@ func DecodeRemaining(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:
(*WebPIDecoder)(unsafe.Pointer(idec)).last_mb_y_ = (*VP8Decoder)(unsafe.Pointer(dec)).mb_y_
}
for ; (*VP8Decoder)(unsafe.Pointer(dec)).mb_x_ < (*VP8Decoder)(unsafe.Pointer(dec)).mb_w_; (*VP8Decoder)(unsafe.Pointer(dec)).mb_x_++ {
- var token_br uintptr = ((dec + 440 /* &.parts_ */) + uintptr((uint32_t((*VP8Decoder)(unsafe.Pointer(dec)).mb_y_)&(*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_))*48)
+ var token_br uintptr = dec + 440 + uintptr(uint32_t((*VP8Decoder)(unsafe.Pointer(dec)).mb_y_)&(*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_)*48
// var context MBContext at bp, 56
- SaveContext(tls, dec, token_br, (bp) /* &context */)
+ SaveContext(tls, dec, token_br, bp)
if !(VP8DecodeMB(tls, dec, token_br) != 0) {
// We shouldn't fail when MAX_MB data was available
- if ((*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_ == uint32_t(0)) && (MemDataSize(tls, (idec+296 /* &.mem_ */)) > uint64(4096)) {
+ if (*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_ == uint32_t(0) && MemDataSize(tls, idec+296) > uint64(4096) {
return IDecError(tls, idec, VP8_STATUS_BITSTREAM_ERROR)
}
// Synchronize the threads.
if (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ > 0 {
if !((*struct {
f func(*libc.TLS, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Sync})).f(tls, (dec+152 /* &.worker_ */)) != 0) {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Sync})).f(tls, dec+152) != 0) {
return IDecError(tls, idec, VP8_STATUS_BITSTREAM_ERROR)
}
}
- RestoreContext(tls, (bp) /* &context */, dec, token_br)
+ RestoreContext(tls, bp, dec, token_br)
return VP8_STATUS_SUSPENDED
}
// Release buffer only if there is only one partition
if (*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_ == uint32_t(0) {
- (*WebPIDecoder)(unsafe.Pointer(idec)).mem_.start_ = (size_t((int64((*VP8BitReader)(unsafe.Pointer(token_br)).buf_) - int64((*WebPIDecoder)(unsafe.Pointer(idec)).mem_.buf_)) / 1))
+ (*WebPIDecoder)(unsafe.Pointer(idec)).mem_.start_ = size_t((int64((*VP8BitReader)(unsafe.Pointer(token_br)).buf_) - int64((*WebPIDecoder)(unsafe.Pointer(idec)).mem_.buf_)) / 1)
}
}
@@ -6867,27 +6607,27 @@ func DecodeRemaining(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:
}
func ErrorStatusLossless(tls *libc.TLS, idec uintptr, status VP8StatusCode) VP8StatusCode { /* idec_dec.c:512:22: */
- if (status == VP8_STATUS_SUSPENDED) || (status == VP8_STATUS_NOT_ENOUGH_DATA) {
+ if status == VP8_STATUS_SUSPENDED || status == VP8_STATUS_NOT_ENOUGH_DATA {
return VP8_STATUS_SUSPENDED
}
return IDecError(tls, idec, status)
}
func DecodeVP8LHeader(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:520:22: */
- var io uintptr = (idec + 136 /* &.io_ */)
+ var io uintptr = idec + 136
var dec uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).dec_
- var params uintptr = (idec + 8 /* &.params_ */)
+ var params uintptr = idec + 8
var output uintptr = (*WebPDecParams)(unsafe.Pointer(params)).output
- var curr_size size_t = MemDataSize(tls, (idec + 296 /* &.mem_ */))
+ var curr_size size_t = MemDataSize(tls, idec+296)
// Wait until there's enough data for decoding header.
- if curr_size < ((*WebPIDecoder)(unsafe.Pointer(idec)).chunk_size_ >> 3) {
+ if curr_size < (*WebPIDecoder)(unsafe.Pointer(idec)).chunk_size_>>3 {
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_SUSPENDED
return ErrorStatusLossless(tls, idec, (*VP8LDecoder)(unsafe.Pointer(dec)).status_)
}
if !(VP8LDecodeHeader(tls, dec, io) != 0) {
- if ((*VP8LDecoder)(unsafe.Pointer(dec)).status_ == VP8_STATUS_BITSTREAM_ERROR) && (curr_size < (*WebPIDecoder)(unsafe.Pointer(idec)).chunk_size_) {
+ if (*VP8LDecoder)(unsafe.Pointer(dec)).status_ == VP8_STATUS_BITSTREAM_ERROR && curr_size < (*WebPIDecoder)(unsafe.Pointer(idec)).chunk_size_ {
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_SUSPENDED
}
return ErrorStatusLossless(tls, idec, (*VP8LDecoder)(unsafe.Pointer(dec)).status_)
@@ -6905,10 +6645,10 @@ func DecodeVP8LHeader(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c
func DecodeVP8LData(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:552:22: */
var dec uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).dec_
- var curr_size size_t = MemDataSize(tls, (idec + 296 /* &.mem_ */))
+ var curr_size size_t = MemDataSize(tls, idec+296)
// Switch to incremental decoding if we don't have all the bytes available.
- (*VP8LDecoder)(unsafe.Pointer(dec)).incremental_ = (libc.Bool32(curr_size < (*WebPIDecoder)(unsafe.Pointer(idec)).chunk_size_))
+ (*VP8LDecoder)(unsafe.Pointer(dec)).incremental_ = libc.Bool32(curr_size < (*WebPIDecoder)(unsafe.Pointer(idec)).chunk_size_)
if !(VP8LDecodeImage(tls, dec) != 0) {
return ErrorStatusLossless(tls, idec, (*VP8LDecoder)(unsafe.Pointer(dec)).status_)
@@ -6927,7 +6667,7 @@ func IDecode(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:569:22:
if (*WebPIDecoder)(unsafe.Pointer(idec)).state_ == STATE_WEBP_HEADER {
status = DecodeWebPHeaders(tls, idec)
} else {
- if (*WebPIDecoder)(unsafe.Pointer(idec)).dec_ == (uintptr(0)) {
+ if (*WebPIDecoder)(unsafe.Pointer(idec)).dec_ == uintptr(0) {
return VP8_STATUS_SUSPENDED // can't continue if we have no decoder.
}
}
@@ -6939,7 +6679,7 @@ func IDecode(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:569:22:
}
if (*WebPIDecoder)(unsafe.Pointer(idec)).state_ == STATE_VP8_DATA {
var dec uintptr = (*WebPIDecoder)(unsafe.Pointer(idec)).dec_
- if dec == (uintptr(0)) {
+ if dec == uintptr(0) {
return VP8_STATUS_SUSPENDED // can't continue if we have no decoder.
}
status = DecodeRemaining(tls, idec)
@@ -6958,8 +6698,8 @@ func IDecode(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:569:22:
func NewDecoder(tls *libc.TLS, output_buffer uintptr, features uintptr) uintptr { /* idec_dec.c:604:20: */
var idec uintptr = WebPSafeCalloc(tls, 1, uint64(unsafe.Sizeof(WebPIDecoder{})))
- if idec == (uintptr(0)) {
- return (uintptr(0))
+ if idec == uintptr(0) {
+ return uintptr(0)
}
(*WebPIDecoder)(unsafe.Pointer(idec)).state_ = STATE_WEBP_HEADER
@@ -6967,22 +6707,22 @@ func NewDecoder(tls *libc.TLS, output_buffer uintptr, features uintptr) uintptr
(*WebPIDecoder)(unsafe.Pointer(idec)).last_mb_y_ = -1
- InitMemBuffer(tls, (idec + 296 /* &.mem_ */))
- WebPInitDecBuffer(tls, (idec + 352 /* &.output_ */))
- VP8InitIo(tls, (idec + 136 /* &.io_ */))
+ InitMemBuffer(tls, idec+296)
+ WebPInitDecBuffer(tls, idec+352)
+ VP8InitIo(tls, idec+136)
- WebPResetDecParams(tls, (idec + 8 /* &.params_ */))
- if (output_buffer == (uintptr(0))) || (WebPAvoidSlowMemory(tls, output_buffer, features) != 0) {
- (*WebPIDecoder)(unsafe.Pointer(idec)).params_.output = (idec + 352 /* &.output_ */)
+ WebPResetDecParams(tls, idec+8)
+ if output_buffer == uintptr(0) || WebPAvoidSlowMemory(tls, output_buffer, features) != 0 {
+ (*WebPIDecoder)(unsafe.Pointer(idec)).params_.output = idec + 352
(*WebPIDecoder)(unsafe.Pointer(idec)).final_output_ = output_buffer
- if output_buffer != (uintptr(0)) {
+ if output_buffer != uintptr(0) {
(*WebPDecBuffer)(unsafe.Pointer((*WebPIDecoder)(unsafe.Pointer(idec)).params_.output)).colorspace = (*WebPDecBuffer)(unsafe.Pointer(output_buffer)).colorspace
}
} else {
(*WebPIDecoder)(unsafe.Pointer(idec)).params_.output = output_buffer
- (*WebPIDecoder)(unsafe.Pointer(idec)).final_output_ = (uintptr(0))
+ (*WebPIDecoder)(unsafe.Pointer(idec)).final_output_ = uintptr(0)
}
- WebPInitCustomIo(tls, (idec + 8 /* &.params_ */), (idec + 136 /* &.io_ */)) // Plug the I/O functions.
+ WebPInitCustomIo(tls, idec+8, idec+136) // Plug the I/O functions.
return idec
}
@@ -6991,7 +6731,7 @@ func NewDecoder(tls *libc.TLS, output_buffer uintptr, features uintptr) uintptr
// Public functions
func WebPINewDecoder(tls *libc.TLS, output_buffer uintptr) uintptr { /* idec_dec.c:639:13: */
- return NewDecoder(tls, output_buffer, (uintptr(0)))
+ return NewDecoder(tls, output_buffer, uintptr(0))
}
func WebPIDecode(tls *libc.TLS, data uintptr, data_size size_t, config uintptr) uintptr { /* idec_dec.c:643:13: */
@@ -7002,53 +6742,53 @@ func WebPIDecode(tls *libc.TLS, data uintptr, data_size size_t, config uintptr)
// var tmp_features WebPBitstreamFeatures at bp, 40
var features uintptr
- if config == (uintptr(0)) {
- features = (bp) /* &tmp_features */
+ if config == uintptr(0) {
+ features = bp /* &tmp_features */
} else {
- features = (config /* &.input */)
+ features = config /* &.input */
}
- libc.Xmemset(tls, (bp) /* &tmp_features */, 0, uint64(unsafe.Sizeof(WebPBitstreamFeatures{})))
+ libc.Xmemset(tls, bp, 0, uint64(unsafe.Sizeof(WebPBitstreamFeatures{})))
// Parse the bitstream's features, if requested:
- if (data != (uintptr(0))) && (data_size > uint64(0)) {
+ if data != uintptr(0) && data_size > uint64(0) {
if WebPGetFeatures(tls, data, data_size, features) != VP8_STATUS_OK {
- return (uintptr(0))
+ return uintptr(0)
}
}
// Create an instance of the incremental decoder
- if config != (uintptr(0)) {
- idec = NewDecoder(tls, (config + 40 /* &.output */), features)
+ if config != uintptr(0) {
+ idec = NewDecoder(tls, config+40, features)
} else {
- idec = NewDecoder(tls, (uintptr(0)), features)
+ idec = NewDecoder(tls, uintptr(0), features)
}
- if idec == (uintptr(0)) {
- return (uintptr(0))
+ if idec == uintptr(0) {
+ return uintptr(0)
}
// Finish initialization
- if config != (uintptr(0)) {
- (*WebPIDecoder)(unsafe.Pointer(idec)).params_.options = (config + 160 /* &.options */)
+ if config != uintptr(0) {
+ (*WebPIDecoder)(unsafe.Pointer(idec)).params_.options = config + 160
}
return idec
}
func WebPIDelete(tls *libc.TLS, idec uintptr) { /* idec_dec.c:671:6: */
- if idec == (uintptr(0)) {
+ if idec == uintptr(0) {
return
}
- if (*WebPIDecoder)(unsafe.Pointer(idec)).dec_ != (uintptr(0)) {
+ if (*WebPIDecoder)(unsafe.Pointer(idec)).dec_ != uintptr(0) {
if !((*WebPIDecoder)(unsafe.Pointer(idec)).is_lossless_ != 0) {
if (*WebPIDecoder)(unsafe.Pointer(idec)).state_ == STATE_VP8_DATA {
// Synchronize the thread, clean-up and check for errors.
- VP8ExitCritical(tls, (*WebPIDecoder)(unsafe.Pointer(idec)).dec_, (idec + 136 /* &.io_ */))
+ VP8ExitCritical(tls, (*WebPIDecoder)(unsafe.Pointer(idec)).dec_, idec+136)
}
VP8Delete(tls, (*WebPIDecoder)(unsafe.Pointer(idec)).dec_)
} else {
VP8LDelete(tls, (*WebPIDecoder)(unsafe.Pointer(idec)).dec_)
}
}
- ClearMemBuffer(tls, (idec + 296 /* &.mem_ */))
- WebPFreeDecBuffer(tls, (idec + 352 /* &.output_ */))
+ ClearMemBuffer(tls, idec+296)
+ WebPFreeDecBuffer(tls, idec+352)
WebPSafeFree(tls, idec)
}
@@ -7057,7 +6797,7 @@ func WebPIDelete(tls *libc.TLS, idec uintptr) { /* idec_dec.c:671:6: */
func WebPINewRGB(tls *libc.TLS, csp WEBP_CSP_MODE, output_buffer uintptr, output_buffer_size size_t, output_stride int32) uintptr { /* idec_dec.c:692:13: */
var is_external_memory int32
- if output_buffer != (uintptr(0)) {
+ if output_buffer != uintptr(0) {
is_external_memory = 1
} else {
is_external_memory = 0
@@ -7065,31 +6805,31 @@ func WebPINewRGB(tls *libc.TLS, csp WEBP_CSP_MODE, output_buffer uintptr, output
var idec uintptr
if csp >= MODE_YUV {
- return (uintptr(0))
+ return uintptr(0)
}
if is_external_memory == 0 { // Overwrite parameters to sane values.
output_buffer_size = uint64(0)
output_stride = 0
} else { // A buffer was passed. Validate the other params.
- if (output_stride == 0) || (output_buffer_size == uint64(0)) {
- return (uintptr(0)) // invalid parameter.
+ if output_stride == 0 || output_buffer_size == uint64(0) {
+ return uintptr(0) // invalid parameter.
}
}
- idec = WebPINewDecoder(tls, (uintptr(0)))
- if idec == (uintptr(0)) {
- return (uintptr(0))
+ idec = WebPINewDecoder(tls, uintptr(0))
+ if idec == uintptr(0) {
+ return uintptr(0)
}
(*WebPIDecoder)(unsafe.Pointer(idec)).output_.colorspace = csp
(*WebPIDecoder)(unsafe.Pointer(idec)).output_.is_external_memory = is_external_memory
- (*WebPRGBABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).rgba = output_buffer
- (*WebPRGBABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).stride = output_stride
- (*WebPRGBABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).size = output_buffer_size
+ (*WebPRGBABuffer)(unsafe.Pointer(idec + 352 + 16)).rgba = output_buffer
+ (*WebPRGBABuffer)(unsafe.Pointer(idec + 352 + 16)).stride = output_stride
+ (*WebPRGBABuffer)(unsafe.Pointer(idec + 352 + 16)).size = output_buffer_size
return idec
}
func WebPINewYUVA(tls *libc.TLS, luma uintptr, luma_size size_t, luma_stride int32, u uintptr, u_size size_t, u_stride int32, v uintptr, v_size size_t, v_stride int32, a uintptr, a_size size_t, a_stride int32) uintptr { /* idec_dec.c:716:13: */
var is_external_memory int32
- if luma != (uintptr(0)) {
+ if luma != uintptr(0) {
is_external_memory = 1
} else {
is_external_memory = 0
@@ -7100,49 +6840,49 @@ func WebPINewYUVA(tls *libc.TLS, luma uintptr, luma_size size_t, luma_stride int
if is_external_memory == 0 { // Overwrite parameters to sane values.
luma_size = libc.AssignUint64(&u_size, libc.AssignUint64(&v_size, libc.AssignUint64(&a_size, uint64(0))))
luma_stride = libc.AssignInt32(&u_stride, libc.AssignInt32(&v_stride, libc.AssignInt32(&a_stride, 0)))
- u = libc.AssignUintptr(&v, libc.AssignUintptr(&a, (uintptr(0))))
+ u = libc.AssignUintptr(&v, libc.AssignUintptr(&a, uintptr(0)))
colorspace = MODE_YUVA
} else { // A luma buffer was passed. Validate the other parameters.
- if (u == (uintptr(0))) || (v == (uintptr(0))) {
- return (uintptr(0))
+ if u == uintptr(0) || v == uintptr(0) {
+ return uintptr(0)
}
- if ((luma_size == uint64(0)) || (u_size == uint64(0))) || (v_size == uint64(0)) {
- return (uintptr(0))
+ if luma_size == uint64(0) || u_size == uint64(0) || v_size == uint64(0) {
+ return uintptr(0)
}
- if ((luma_stride == 0) || (u_stride == 0)) || (v_stride == 0) {
- return (uintptr(0))
+ if luma_stride == 0 || u_stride == 0 || v_stride == 0 {
+ return uintptr(0)
}
- if a != (uintptr(0)) {
- if (a_size == uint64(0)) || (a_stride == 0) {
- return (uintptr(0))
+ if a != uintptr(0) {
+ if a_size == uint64(0) || a_stride == 0 {
+ return uintptr(0)
}
}
- if a == (uintptr(0)) {
+ if a == uintptr(0) {
colorspace = MODE_YUV
} else {
colorspace = MODE_YUVA
}
}
- idec = WebPINewDecoder(tls, (uintptr(0)))
- if idec == (uintptr(0)) {
- return (uintptr(0))
+ idec = WebPINewDecoder(tls, uintptr(0))
+ if idec == uintptr(0) {
+ return uintptr(0)
}
(*WebPIDecoder)(unsafe.Pointer(idec)).output_.colorspace = colorspace
(*WebPIDecoder)(unsafe.Pointer(idec)).output_.is_external_memory = is_external_memory
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).y = luma
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).y_stride = luma_stride
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).y_size = luma_size
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).u = u
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).u_stride = u_stride
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).u_size = u_size
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).v = v
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).v_stride = v_stride
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).v_size = v_size
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).a = a
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).a_stride = a_stride
- (*WebPYUVABuffer)(unsafe.Pointer(((idec + 352 /* &.output_ */) + 16 /* &.u */))).a_size = a_size
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).y = luma
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).y_stride = luma_stride
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).y_size = luma_size
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).u = u
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).u_stride = u_stride
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).u_size = u_size
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).v = v
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).v_stride = v_stride
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).v_size = v_size
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).a = a
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).a_stride = a_stride
+ (*WebPYUVABuffer)(unsafe.Pointer(idec + 352 + 16)).a_size = a_size
return idec
}
@@ -7150,7 +6890,7 @@ func WebPINewYUV(tls *libc.TLS, luma uintptr, luma_size size_t, luma_stride int3
return WebPINewYUVA(tls, luma, luma_size, luma_stride,
u, u_size, u_stride,
v, v_size, v_stride,
- (uintptr(0)), uint64(0), 0)
+ uintptr(0), uint64(0), 0)
}
//------------------------------------------------------------------------------
@@ -7168,7 +6908,7 @@ func IDecCheckStatus(tls *libc.TLS, idec uintptr) VP8StatusCode { /* idec_dec.c:
func WebPIAppend(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) VP8StatusCode { /* idec_dec.c:781:15: */
var status VP8StatusCode
- if (idec == (uintptr(0))) || (data == (uintptr(0))) {
+ if idec == uintptr(0) || data == uintptr(0) {
return VP8_STATUS_INVALID_PARAM
}
status = IDecCheckStatus(tls, idec)
@@ -7176,7 +6916,7 @@ func WebPIAppend(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) VP
return status
}
// Check mixed calls between RemapMemBuffer and AppendToMemBuffer.
- if !(CheckMemBufferMode(tls, (idec+296 /* &.mem_ */), MEM_MODE_APPEND) != 0) {
+ if !(CheckMemBufferMode(tls, idec+296, MEM_MODE_APPEND) != 0) {
return VP8_STATUS_INVALID_PARAM
}
// Append data to memory buffer
@@ -7188,7 +6928,7 @@ func WebPIAppend(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) VP
func WebPIUpdate(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) VP8StatusCode { /* idec_dec.c:802:15: */
var status VP8StatusCode
- if (idec == (uintptr(0))) || (data == (uintptr(0))) {
+ if idec == uintptr(0) || data == uintptr(0) {
return VP8_STATUS_INVALID_PARAM
}
status = IDecCheckStatus(tls, idec)
@@ -7196,7 +6936,7 @@ func WebPIUpdate(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) VP
return status
}
// Check mixed calls between RemapMemBuffer and AppendToMemBuffer.
- if !(CheckMemBufferMode(tls, (idec+296 /* &.mem_ */), MEM_MODE_MAP) != 0) {
+ if !(CheckMemBufferMode(tls, idec+296, MEM_MODE_MAP) != 0) {
return VP8_STATUS_INVALID_PARAM
}
// Make the memory buffer point to the new buffer
@@ -7209,38 +6949,38 @@ func WebPIUpdate(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) VP
//------------------------------------------------------------------------------
func GetOutputBuffer(tls *libc.TLS, idec uintptr) uintptr { /* idec_dec.c:825:27: */
- if (idec == (uintptr(0))) || ((*WebPIDecoder)(unsafe.Pointer(idec)).dec_ == (uintptr(0))) {
- return (uintptr(0))
+ if idec == uintptr(0) || (*WebPIDecoder)(unsafe.Pointer(idec)).dec_ == uintptr(0) {
+ return uintptr(0)
}
if (*WebPIDecoder)(unsafe.Pointer(idec)).state_ <= STATE_VP8_PARTS0 {
- return (uintptr(0))
+ return uintptr(0)
}
- if (*WebPIDecoder)(unsafe.Pointer(idec)).final_output_ != (uintptr(0)) {
- return (uintptr(0)) // not yet slow-copied
+ if (*WebPIDecoder)(unsafe.Pointer(idec)).final_output_ != uintptr(0) {
+ return uintptr(0) // not yet slow-copied
}
return (*WebPIDecoder)(unsafe.Pointer(idec)).params_.output
}
func WebPIDecodedArea(tls *libc.TLS, idec uintptr, left uintptr, top uintptr, width uintptr, height uintptr) uintptr { /* idec_dec.c:838:20: */
var src uintptr = GetOutputBuffer(tls, idec)
- if left != (uintptr(0)) {
+ if left != uintptr(0) {
*(*int32)(unsafe.Pointer(left)) = 0
}
- if top != (uintptr(0)) {
+ if top != uintptr(0) {
*(*int32)(unsafe.Pointer(top)) = 0
}
- if src != (uintptr(0)) {
- if width != (uintptr(0)) {
+ if src != uintptr(0) {
+ if width != uintptr(0) {
*(*int32)(unsafe.Pointer(width)) = (*WebPDecBuffer)(unsafe.Pointer(src)).width
}
- if height != (uintptr(0)) {
+ if height != uintptr(0) {
*(*int32)(unsafe.Pointer(height)) = (*WebPIDecoder)(unsafe.Pointer(idec)).params_.last_y
}
} else {
- if width != (uintptr(0)) {
+ if width != uintptr(0) {
*(*int32)(unsafe.Pointer(width)) = 0
}
- if height != (uintptr(0)) {
+ if height != uintptr(0) {
*(*int32)(unsafe.Pointer(height)) = 0
}
}
@@ -7249,71 +6989,71 @@ func WebPIDecodedArea(tls *libc.TLS, idec uintptr, left uintptr, top uintptr, wi
func WebPIDecGetRGB(tls *libc.TLS, idec uintptr, last_y uintptr, width uintptr, height uintptr, stride uintptr) uintptr { /* idec_dec.c:854:8: */
var src uintptr = GetOutputBuffer(tls, idec)
- if src == (uintptr(0)) {
- return (uintptr(0))
+ if src == uintptr(0) {
+ return uintptr(0)
}
if (*WebPDecBuffer)(unsafe.Pointer(src)).colorspace >= MODE_YUV {
- return (uintptr(0))
+ return uintptr(0)
}
- if last_y != (uintptr(0)) {
+ if last_y != uintptr(0) {
*(*int32)(unsafe.Pointer(last_y)) = (*WebPIDecoder)(unsafe.Pointer(idec)).params_.last_y
}
- if width != (uintptr(0)) {
+ if width != uintptr(0) {
*(*int32)(unsafe.Pointer(width)) = (*WebPDecBuffer)(unsafe.Pointer(src)).width
}
- if height != (uintptr(0)) {
+ if height != uintptr(0) {
*(*int32)(unsafe.Pointer(height)) = (*WebPDecBuffer)(unsafe.Pointer(src)).height
}
- if stride != (uintptr(0)) {
- *(*int32)(unsafe.Pointer(stride)) = (*WebPRGBABuffer)(unsafe.Pointer((src + 16 /* &.u */))).stride
+ if stride != uintptr(0) {
+ *(*int32)(unsafe.Pointer(stride)) = (*WebPRGBABuffer)(unsafe.Pointer(src + 16)).stride
}
- return (*WebPRGBABuffer)(unsafe.Pointer((src + 16 /* &.u */))).rgba
+ return (*WebPRGBABuffer)(unsafe.Pointer(src + 16)).rgba
}
func WebPIDecGetYUVA(tls *libc.TLS, idec uintptr, last_y uintptr, u uintptr, v uintptr, a uintptr, width uintptr, height uintptr, stride uintptr, uv_stride uintptr, a_stride uintptr) uintptr { /* idec_dec.c:870:8: */
var src uintptr = GetOutputBuffer(tls, idec)
- if src == (uintptr(0)) {
- return (uintptr(0))
+ if src == uintptr(0) {
+ return uintptr(0)
}
if (*WebPDecBuffer)(unsafe.Pointer(src)).colorspace < MODE_YUV {
- return (uintptr(0))
+ return uintptr(0)
}
- if last_y != (uintptr(0)) {
+ if last_y != uintptr(0) {
*(*int32)(unsafe.Pointer(last_y)) = (*WebPIDecoder)(unsafe.Pointer(idec)).params_.last_y
}
- if u != (uintptr(0)) {
- *(*uintptr)(unsafe.Pointer(u)) = (*WebPYUVABuffer)(unsafe.Pointer((src + 16 /* &.u */))).u
+ if u != uintptr(0) {
+ *(*uintptr)(unsafe.Pointer(u)) = (*WebPYUVABuffer)(unsafe.Pointer(src + 16)).u
}
- if v != (uintptr(0)) {
- *(*uintptr)(unsafe.Pointer(v)) = (*WebPYUVABuffer)(unsafe.Pointer((src + 16 /* &.u */))).v
+ if v != uintptr(0) {
+ *(*uintptr)(unsafe.Pointer(v)) = (*WebPYUVABuffer)(unsafe.Pointer(src + 16)).v
}
- if a != (uintptr(0)) {
- *(*uintptr)(unsafe.Pointer(a)) = (*WebPYUVABuffer)(unsafe.Pointer((src + 16 /* &.u */))).a
+ if a != uintptr(0) {
+ *(*uintptr)(unsafe.Pointer(a)) = (*WebPYUVABuffer)(unsafe.Pointer(src + 16)).a
}
- if width != (uintptr(0)) {
+ if width != uintptr(0) {
*(*int32)(unsafe.Pointer(width)) = (*WebPDecBuffer)(unsafe.Pointer(src)).width
}
- if height != (uintptr(0)) {
+ if height != uintptr(0) {
*(*int32)(unsafe.Pointer(height)) = (*WebPDecBuffer)(unsafe.Pointer(src)).height
}
- if stride != (uintptr(0)) {
- *(*int32)(unsafe.Pointer(stride)) = (*WebPYUVABuffer)(unsafe.Pointer((src + 16 /* &.u */))).y_stride
+ if stride != uintptr(0) {
+ *(*int32)(unsafe.Pointer(stride)) = (*WebPYUVABuffer)(unsafe.Pointer(src + 16)).y_stride
}
- if uv_stride != (uintptr(0)) {
- *(*int32)(unsafe.Pointer(uv_stride)) = (*WebPYUVABuffer)(unsafe.Pointer((src + 16 /* &.u */))).u_stride
+ if uv_stride != uintptr(0) {
+ *(*int32)(unsafe.Pointer(uv_stride)) = (*WebPYUVABuffer)(unsafe.Pointer(src + 16)).u_stride
}
- if a_stride != (uintptr(0)) {
- *(*int32)(unsafe.Pointer(a_stride)) = (*WebPYUVABuffer)(unsafe.Pointer((src + 16 /* &.u */))).a_stride
+ if a_stride != uintptr(0) {
+ *(*int32)(unsafe.Pointer(a_stride)) = (*WebPYUVABuffer)(unsafe.Pointer(src + 16)).a_stride
}
- return (*WebPYUVABuffer)(unsafe.Pointer((src + 16 /* &.u */))).y
+ return (*WebPYUVABuffer)(unsafe.Pointer(src + 16)).y
}
func WebPISetIOHooks(tls *libc.TLS, idec uintptr, put VP8IoPutHook, setup VP8IoSetupHook, teardown VP8IoTeardownHook, user_data uintptr) int32 { /* idec_dec.c:893:5: */
- if (idec == (uintptr(0))) || ((*WebPIDecoder)(unsafe.Pointer(idec)).state_ > STATE_WEBP_HEADER) {
+ if idec == uintptr(0) || (*WebPIDecoder)(unsafe.Pointer(idec)).state_ > STATE_WEBP_HEADER {
return 0
}
@@ -7329,12 +7069,12 @@ func WebPISetIOHooks(tls *libc.TLS, idec uintptr, put VP8IoPutHook, setup VP8IoS
// slower on x86 by ~7-8%, but bit-exact with the SSE2/NEON version
func MultHi(tls *libc.TLS, v int32, coeff int32) int32 { /* yuv.h:59:24: */ // _mm_mulhi_epu16 emulation
- return ((v * coeff) >> 8)
+ return v * coeff >> 8
}
func VP8Clip8(tls *libc.TLS, v int32) int32 { /* yuv.h:63:24: */
- if (v & libc.CplInt32(YUV_MASK2)) == 0 {
- return (v >> YUV_FIX2)
+ if v&libc.CplInt32(YUV_MASK2) == 0 {
+ return v >> YUV_FIX2
}
if v < 0 {
return 0
@@ -7343,15 +7083,15 @@ func VP8Clip8(tls *libc.TLS, v int32) int32 { /* yuv.h:63:24: */
}
func VP8YUVToR(tls *libc.TLS, y int32, v int32) int32 { /* yuv.h:67:24: */
- return VP8Clip8(tls, ((MultHi(tls, y, 19077) + MultHi(tls, v, 26149)) - 14234))
+ return VP8Clip8(tls, MultHi(tls, y, 19077)+MultHi(tls, v, 26149)-14234)
}
func VP8YUVToG(tls *libc.TLS, y int32, u int32, v int32) int32 { /* yuv.h:71:24: */
- return VP8Clip8(tls, (((MultHi(tls, y, 19077) - MultHi(tls, u, 6419)) - MultHi(tls, v, 13320)) + 8708))
+ return VP8Clip8(tls, MultHi(tls, y, 19077)-MultHi(tls, u, 6419)-MultHi(tls, v, 13320)+8708)
}
func VP8YUVToB(tls *libc.TLS, y int32, u int32) int32 { /* yuv.h:75:24: */
- return VP8Clip8(tls, ((MultHi(tls, y, 19077) + MultHi(tls, u, 33050)) - 17685))
+ return VP8Clip8(tls, MultHi(tls, y, 19077)+MultHi(tls, u, 33050)-17685)
}
func VP8YuvToRgb(tls *libc.TLS, y int32, u int32, v int32, rgb uintptr) { /* yuv.h:79:25: */
@@ -7370,8 +7110,8 @@ func VP8YuvToRgb565(tls *libc.TLS, y int32, u int32, v int32, rgb uintptr) { /*
var r int32 = VP8YUVToR(tls, y, v) // 5 usable bits
var g int32 = VP8YUVToG(tls, y, u, v) // 6 usable bits
var b int32 = VP8YUVToB(tls, y, u) // 5 usable bits
- var rg int32 = ((r & 0xf8) | (g >> 5))
- var gb int32 = (((g << 3) & 0xe0) | (b >> 3))
+ var rg int32 = r&0xf8 | g>>5
+ var gb int32 = g<<3&0xe0 | b>>3
*(*uint8_t)(unsafe.Pointer(rgb)) = uint8_t(rg)
*(*uint8_t)(unsafe.Pointer(rgb + 1)) = uint8_t(gb)
}
@@ -7380,8 +7120,8 @@ func VP8YuvToRgba4444(tls *libc.TLS, y int32, u int32, v int32, argb uintptr) {
var r int32 = VP8YUVToR(tls, y, v) // 4 usable bits
var g int32 = VP8YUVToG(tls, y, u, v) // 4 usable bits
var b int32 = VP8YUVToB(tls, y, u) // 4 usable bits
- var rg int32 = ((r & 0xf0) | (g >> 4))
- var ba int32 = ((b & 0xf0) | 0x0f) // overwrite the lower 4 bits
+ var rg int32 = r&0xf0 | g>>4
+ var ba int32 = b&0xf0 | 0x0f // overwrite the lower 4 bits
*(*uint8_t)(unsafe.Pointer(argb)) = uint8_t(rg)
*(*uint8_t)(unsafe.Pointer(argb + 1)) = uint8_t(ba)
}
@@ -7391,7 +7131,7 @@ func VP8YuvToRgba4444(tls *libc.TLS, y int32, u int32, v int32, argb uintptr) {
func VP8YuvToArgb(tls *libc.TLS, y uint8_t, u uint8_t, v uint8_t, argb uintptr) { /* yuv.h:128:25: */
*(*uint8_t)(unsafe.Pointer(argb)) = uint8_t(0xff)
- VP8YuvToRgb(tls, int32(y), int32(u), int32(v), (argb + uintptr(1)))
+ VP8YuvToRgb(tls, int32(y), int32(u), int32(v), argb+uintptr(1))
}
func VP8YuvToBgra(tls *libc.TLS, y uint8_t, u uint8_t, v uint8_t, bgra uintptr) { /* yuv.h:134:25: */
@@ -7415,8 +7155,8 @@ func VP8YuvToRgba(tls *libc.TLS, y uint8_t, u uint8_t, v uint8_t, rgba uintptr)
// Stub functions that can be called with various rounding values:
func VP8ClipUV(tls *libc.TLS, uv int32, rounding int32) int32 { /* yuv.h:186:24: */
- uv = (((uv + rounding) + (int32(128) << (YUV_FIX + 2))) >> (YUV_FIX + 2))
- if (uv & libc.CplInt32(0xff)) == 0 {
+ uv = (uv + rounding + int32(128)<<(YUV_FIX+2)) >> (YUV_FIX + 2)
+ if uv&libc.CplInt32(0xff) == 0 {
return uv
}
if uv < 0 {
@@ -7426,17 +7166,17 @@ func VP8ClipUV(tls *libc.TLS, uv int32, rounding int32) int32 { /* yuv.h:186:24:
}
func VP8RGBToY(tls *libc.TLS, r int32, g int32, b int32, rounding int32) int32 { /* yuv.h:191:24: */
- var luma int32 = (((16839 * r) + (33059 * g)) + (6420 * b))
- return (((luma + rounding) + (int32(16) << YUV_FIX)) >> YUV_FIX) // no need to clip
+ var luma int32 = 16839*r + 33059*g + 6420*b
+ return (luma + rounding + int32(16)<<YUV_FIX) >> YUV_FIX // no need to clip
}
func VP8RGBToU(tls *libc.TLS, r int32, g int32, b int32, rounding int32) int32 { /* yuv.h:196:24: */
- var u int32 = (((-9719 * r) - (19081 * g)) + (28800 * b))
+ var u int32 = -9719*r - 19081*g + 28800*b
return VP8ClipUV(tls, u, rounding)
}
func VP8RGBToV(tls *libc.TLS, r int32, g int32, b int32, rounding int32) int32 { /* yuv.h:201:24: */
- var v int32 = (((+28800 * r) - (24116 * g)) - (4684 * b))
+ var v int32 = +28800*r - 24116*g - 4684*b
return VP8ClipUV(tls, v, rounding)
}
@@ -7447,14 +7187,14 @@ func VP8RGBToV(tls *libc.TLS, r int32, g int32, b int32, rounding int32) int32 {
func EmitYUV(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:25:12: */
var output uintptr = (*WebPDecParams)(unsafe.Pointer(p)).output
- var buf uintptr = (output + 16 /* &.u */) /* &.YUVA */
- var y_dst uintptr = ((*WebPYUVABuffer)(unsafe.Pointer(buf)).y + uintptr((size_t((*VP8Io)(unsafe.Pointer(io)).mb_y) * size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride))))
- var u_dst uintptr = ((*WebPYUVABuffer)(unsafe.Pointer(buf)).u + uintptr(((size_t((*VP8Io)(unsafe.Pointer(io)).mb_y >> 1)) * size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride))))
- var v_dst uintptr = ((*WebPYUVABuffer)(unsafe.Pointer(buf)).v + uintptr(((size_t((*VP8Io)(unsafe.Pointer(io)).mb_y >> 1)) * size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride))))
+ var buf uintptr = output + 16
+ var y_dst uintptr = (*WebPYUVABuffer)(unsafe.Pointer(buf)).y + uintptr(size_t((*VP8Io)(unsafe.Pointer(io)).mb_y)*size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride))
+ var u_dst uintptr = (*WebPYUVABuffer)(unsafe.Pointer(buf)).u + uintptr(size_t((*VP8Io)(unsafe.Pointer(io)).mb_y>>1)*size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride))
+ var v_dst uintptr = (*WebPYUVABuffer)(unsafe.Pointer(buf)).v + uintptr(size_t((*VP8Io)(unsafe.Pointer(io)).mb_y>>1)*size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride))
var mb_w int32 = (*VP8Io)(unsafe.Pointer(io)).mb_w
var mb_h int32 = (*VP8Io)(unsafe.Pointer(io)).mb_h
- var uv_w int32 = ((mb_w + 1) / 2)
- var uv_h int32 = ((mb_h + 1) / 2)
+ var uv_w int32 = (mb_w + 1) / 2
+ var uv_h int32 = (mb_h + 1) / 2
WebPCopyPlane(tls, (*VP8Io)(unsafe.Pointer(io)).y, (*VP8Io)(unsafe.Pointer(io)).y_stride, y_dst, (*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride, mb_w, mb_h)
WebPCopyPlane(tls, (*VP8Io)(unsafe.Pointer(io)).u, (*VP8Io)(unsafe.Pointer(io)).uv_stride, u_dst, (*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride, uv_w, uv_h)
WebPCopyPlane(tls, (*VP8Io)(unsafe.Pointer(io)).v, (*VP8Io)(unsafe.Pointer(io)).uv_stride, v_dst, (*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride, uv_w, uv_h)
@@ -7464,8 +7204,8 @@ func EmitYUV(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:25:12: */
// Point-sampling U/V sampler.
func EmitSampledRGB(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:42:12: */
var output uintptr = (*WebPDecParams)(unsafe.Pointer(p)).output
- var buf uintptr = (output + 16 /* &.u */) /* &.RGBA */
- var dst uintptr = ((*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr((size_t((*VP8Io)(unsafe.Pointer(io)).mb_y) * size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))))
+ var buf uintptr = output + 16
+ var dst uintptr = (*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr(size_t((*VP8Io)(unsafe.Pointer(io)).mb_y)*size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))
WebPSamplerProcessPlane(tls, (*VP8Io)(unsafe.Pointer(io)).y, (*VP8Io)(unsafe.Pointer(io)).y_stride,
(*VP8Io)(unsafe.Pointer(io)).u, (*VP8Io)(unsafe.Pointer(io)).v, (*VP8Io)(unsafe.Pointer(io)).uv_stride,
dst, (*WebPRGBABuffer)(unsafe.Pointer(buf)).stride, (*VP8Io)(unsafe.Pointer(io)).mb_w, (*VP8Io)(unsafe.Pointer(io)).mb_h,
@@ -7477,9 +7217,9 @@ func EmitSampledRGB(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:42
// Fancy upsampling
func EmitFancyRGB(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:57:12: */
- var num_lines_out int32 = (*VP8Io)(unsafe.Pointer(io)).mb_h // a priori guess
- var buf uintptr = ((*WebPDecParams)(unsafe.Pointer(p)).output + 16 /* &.u */) /* &.RGBA */
- var dst uintptr = ((*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr((size_t((*VP8Io)(unsafe.Pointer(io)).mb_y) * size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))))
+ var num_lines_out int32 = (*VP8Io)(unsafe.Pointer(io)).mb_h // a priori guess
+ var buf uintptr = (*WebPDecParams)(unsafe.Pointer(p)).output + 16
+ var dst uintptr = (*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr(size_t((*VP8Io)(unsafe.Pointer(io)).mb_y)*size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))
var upsample WebPUpsampleLinePairFunc = WebPUpsamplers[(*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace]
var cur_y uintptr = (*VP8Io)(unsafe.Pointer(io)).y
var cur_u uintptr = (*VP8Io)(unsafe.Pointer(io)).u
@@ -7487,54 +7227,54 @@ func EmitFancyRGB(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:57:1
var top_u uintptr = (*WebPDecParams)(unsafe.Pointer(p)).tmp_u
var top_v uintptr = (*WebPDecParams)(unsafe.Pointer(p)).tmp_v
var y int32 = (*VP8Io)(unsafe.Pointer(io)).mb_y
- var y_end int32 = ((*VP8Io)(unsafe.Pointer(io)).mb_y + (*VP8Io)(unsafe.Pointer(io)).mb_h)
+ var y_end int32 = (*VP8Io)(unsafe.Pointer(io)).mb_y + (*VP8Io)(unsafe.Pointer(io)).mb_h
var mb_w int32 = (*VP8Io)(unsafe.Pointer(io)).mb_w
- var uv_w int32 = ((mb_w + 1) / 2)
+ var uv_w int32 = (mb_w + 1) / 2
if y == 0 {
// First line is special cased. We mirror the u/v samples at boundary.
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, cur_y, (uintptr(0)), cur_u, cur_v, cur_u, cur_v, dst, (uintptr(0)), mb_w)
+ })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, cur_y, uintptr(0), cur_u, cur_v, cur_u, cur_v, dst, uintptr(0), mb_w)
} else {
// We can finish the left-over line from previous call.
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32)
})(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, (*WebPDecParams)(unsafe.Pointer(p)).tmp_y, cur_y, top_u, top_v, cur_u, cur_v,
- (dst - uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)), dst, mb_w)
+ dst-uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride), dst, mb_w)
num_lines_out++
}
// Loop over each output pairs of row.
- for ; (y + 2) < y_end; y = y + (2) {
+ for ; y+2 < y_end; y = y + 2 {
top_u = cur_u
top_v = cur_v
cur_u += uintptr((*VP8Io)(unsafe.Pointer(io)).uv_stride)
cur_v += uintptr((*VP8Io)(unsafe.Pointer(io)).uv_stride)
- dst += (uintptr(2 * (*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))
- cur_y += (uintptr(2 * (*VP8Io)(unsafe.Pointer(io)).y_stride))
+ dst += uintptr(2 * (*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)
+ cur_y += uintptr(2 * (*VP8Io)(unsafe.Pointer(io)).y_stride)
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, (cur_y - uintptr((*VP8Io)(unsafe.Pointer(io)).y_stride)), cur_y,
+ })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, cur_y-uintptr((*VP8Io)(unsafe.Pointer(io)).y_stride), cur_y,
top_u, top_v, cur_u, cur_v,
- (dst - uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)), dst, mb_w)
+ dst-uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride), dst, mb_w)
}
// move to last row
cur_y += uintptr((*VP8Io)(unsafe.Pointer(io)).y_stride)
- if ((*VP8Io)(unsafe.Pointer(io)).crop_top + y_end) < (*VP8Io)(unsafe.Pointer(io)).crop_bottom {
+ if (*VP8Io)(unsafe.Pointer(io)).crop_top+y_end < (*VP8Io)(unsafe.Pointer(io)).crop_bottom {
// Save the unfinished samples for next call (as we're not done yet).
- libc.Xmemcpy(tls, (*WebPDecParams)(unsafe.Pointer(p)).tmp_y, cur_y, (uint64(mb_w) * uint64(unsafe.Sizeof(uint8_t(0)))))
- libc.Xmemcpy(tls, (*WebPDecParams)(unsafe.Pointer(p)).tmp_u, cur_u, (uint64(uv_w) * uint64(unsafe.Sizeof(uint8_t(0)))))
- libc.Xmemcpy(tls, (*WebPDecParams)(unsafe.Pointer(p)).tmp_v, cur_v, (uint64(uv_w) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ libc.Xmemcpy(tls, (*WebPDecParams)(unsafe.Pointer(p)).tmp_y, cur_y, uint64(mb_w)*uint64(unsafe.Sizeof(uint8_t(0))))
+ libc.Xmemcpy(tls, (*WebPDecParams)(unsafe.Pointer(p)).tmp_u, cur_u, uint64(uv_w)*uint64(unsafe.Sizeof(uint8_t(0))))
+ libc.Xmemcpy(tls, (*WebPDecParams)(unsafe.Pointer(p)).tmp_v, cur_v, uint64(uv_w)*uint64(unsafe.Sizeof(uint8_t(0))))
// The fancy upsampler leaves a row unfinished behind
// (except for the very last row)
num_lines_out--
} else {
// Process the very last row of even-sized picture
- if !((y_end & 1) != 0) {
+ if !(y_end&1 != 0) {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, cur_y, (uintptr(0)), cur_u, cur_v, cur_u, cur_v,
- (dst + uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)), (uintptr(0)), mb_w)
+ })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, cur_y, uintptr(0), cur_u, cur_v, cur_u, cur_v,
+ dst+uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride), uintptr(0), mb_w)
}
}
return num_lines_out
@@ -7545,27 +7285,27 @@ func EmitFancyRGB(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:57:1
func FillAlphaPlane(tls *libc.TLS, dst uintptr, w int32, h int32, stride int32) { /* io_dec.c:117:13: */
var j int32
for j = 0; j < h; j++ {
- libc.Xmemset(tls, dst, 0xff, (uint64(w) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ libc.Xmemset(tls, dst, 0xff, uint64(w)*uint64(unsafe.Sizeof(uint8_t(0))))
dst += uintptr(stride)
}
}
func EmitAlphaYUV(tls *libc.TLS, io uintptr, p uintptr, expected_num_lines_out int32) int32 { /* io_dec.c:125:12: */
var alpha uintptr = (*VP8Io)(unsafe.Pointer(io)).a
- var buf uintptr = ((*WebPDecParams)(unsafe.Pointer(p)).output + 16 /* &.u */) /* &.YUVA */
+ var buf uintptr = (*WebPDecParams)(unsafe.Pointer(p)).output + 16
var mb_w int32 = (*VP8Io)(unsafe.Pointer(io)).mb_w
var mb_h int32 = (*VP8Io)(unsafe.Pointer(io)).mb_h
- var dst uintptr = ((*WebPYUVABuffer)(unsafe.Pointer(buf)).a + uintptr((size_t((*VP8Io)(unsafe.Pointer(io)).mb_y) * size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride))))
+ var dst uintptr = (*WebPYUVABuffer)(unsafe.Pointer(buf)).a + uintptr(size_t((*VP8Io)(unsafe.Pointer(io)).mb_y)*size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride))
var j int32
_ = expected_num_lines_out
- if alpha != (uintptr(0)) {
+ if alpha != uintptr(0) {
for j = 0; j < mb_h; j++ {
- libc.Xmemcpy(tls, dst, alpha, (uint64(mb_w) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ libc.Xmemcpy(tls, dst, alpha, uint64(mb_w)*uint64(unsafe.Sizeof(uint8_t(0))))
alpha += uintptr((*VP8Io)(unsafe.Pointer(io)).width)
dst += uintptr((*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride)
}
- } else if (*WebPYUVABuffer)(unsafe.Pointer(buf)).a != (uintptr(0)) {
+ } else if (*WebPYUVABuffer)(unsafe.Pointer(buf)).a != uintptr(0) {
// the user requested alpha, but there is none, set it to opaque.
FillAlphaPlane(tls, dst, mb_w, mb_h, (*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride)
}
@@ -7587,11 +7327,11 @@ func GetAlphaSourceRow(tls *libc.TLS, io uintptr, alpha uintptr, num_rows uintpt
// Fortunately, *alpha data is persistent, so we can go back
// one row and finish alpha blending, now that the fancy upscaler
// completed the YUV->RGB interpolation.
- *(*uintptr)(unsafe.Pointer(alpha)) -= (uintptr((*VP8Io)(unsafe.Pointer(io)).width))
+ *(*uintptr)(unsafe.Pointer(alpha)) -= uintptr((*VP8Io)(unsafe.Pointer(io)).width)
}
- if (((*VP8Io)(unsafe.Pointer(io)).crop_top + (*VP8Io)(unsafe.Pointer(io)).mb_y) + (*VP8Io)(unsafe.Pointer(io)).mb_h) == (*VP8Io)(unsafe.Pointer(io)).crop_bottom {
+ if (*VP8Io)(unsafe.Pointer(io)).crop_top+(*VP8Io)(unsafe.Pointer(io)).mb_y+(*VP8Io)(unsafe.Pointer(io)).mb_h == (*VP8Io)(unsafe.Pointer(io)).crop_bottom {
// If it's the very last call, we process all the remaining rows!
- *(*int32)(unsafe.Pointer(num_rows)) = (((*VP8Io)(unsafe.Pointer(io)).crop_bottom - (*VP8Io)(unsafe.Pointer(io)).crop_top) - start_y)
+ *(*int32)(unsafe.Pointer(num_rows)) = (*VP8Io)(unsafe.Pointer(io)).crop_bottom - (*VP8Io)(unsafe.Pointer(io)).crop_top - start_y
}
}
return start_y
@@ -7602,21 +7342,21 @@ func EmitAlphaRGB(tls *libc.TLS, io uintptr, p uintptr, expected_num_lines_out i
defer tls.Free(12)
*(*uintptr)(unsafe.Pointer(bp /* alpha */)) = (*VP8Io)(unsafe.Pointer(io)).a
- if *(*uintptr)(unsafe.Pointer(bp /* alpha */)) != (uintptr(0)) {
+ if *(*uintptr)(unsafe.Pointer(bp)) != uintptr(0) {
var mb_w int32 = (*VP8Io)(unsafe.Pointer(io)).mb_w
var colorspace WEBP_CSP_MODE = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace
- var alpha_first int32 = (libc.Bool32((colorspace == MODE_ARGB) || (colorspace == MODE_Argb)))
- var buf uintptr = ((*WebPDecParams)(unsafe.Pointer(p)).output + 16 /* &.u */) /* &.RGBA */
+ var alpha_first int32 = libc.Bool32(colorspace == MODE_ARGB || colorspace == MODE_Argb)
+ var buf uintptr = (*WebPDecParams)(unsafe.Pointer(p)).output + 16
// var num_rows int32 at bp+8, 4
- var start_y size_t = size_t(GetAlphaSourceRow(tls, io, (bp) /* &alpha */, (bp + 8) /* &num_rows */))
- var base_rgba uintptr = ((*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr((start_y * size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))))
- var dst uintptr = (base_rgba + uintptr((func() int32 {
+ var start_y size_t = size_t(GetAlphaSourceRow(tls, io, bp, bp+8))
+ var base_rgba uintptr = (*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr(start_y*size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))
+ var dst uintptr = base_rgba + uintptr(func() int32 {
if alpha_first != 0 {
return 0
}
return 3
- }())))
+ }())
var has_alpha int32 = (*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32) int32
})(unsafe.Pointer(&struct{ uintptr }{WebPDispatchAlpha})).f(tls, *(*uintptr)(unsafe.Pointer(bp /* alpha */)), (*VP8Io)(unsafe.Pointer(io)).width, mb_w,
@@ -7624,7 +7364,7 @@ func EmitAlphaRGB(tls *libc.TLS, io uintptr, p uintptr, expected_num_lines_out i
_ = expected_num_lines_out
// has_alpha is true if there's non-trivial alpha to premultiply with.
- if (has_alpha != 0) && (WebPIsPremultipliedMode(tls, colorspace) != 0) {
+ if has_alpha != 0 && WebPIsPremultipliedMode(tls, colorspace) != 0 {
(*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, int32)
})(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply})).f(tls, base_rgba, alpha_first,
@@ -7639,31 +7379,31 @@ func EmitAlphaRGBA4444(tls *libc.TLS, io uintptr, p uintptr, expected_num_lines_
defer tls.Free(12)
*(*uintptr)(unsafe.Pointer(bp /* alpha */)) = (*VP8Io)(unsafe.Pointer(io)).a
- if *(*uintptr)(unsafe.Pointer(bp /* alpha */)) != (uintptr(0)) {
+ if *(*uintptr)(unsafe.Pointer(bp)) != uintptr(0) {
var mb_w int32 = (*VP8Io)(unsafe.Pointer(io)).mb_w
var colorspace WEBP_CSP_MODE = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace
- var buf uintptr = ((*WebPDecParams)(unsafe.Pointer(p)).output + 16 /* &.u */) /* &.RGBA */
+ var buf uintptr = (*WebPDecParams)(unsafe.Pointer(p)).output + 16
// var num_rows int32 at bp+8, 4
- var start_y size_t = size_t(GetAlphaSourceRow(tls, io, (bp) /* &alpha */, (bp + 8) /* &num_rows */))
- var base_rgba uintptr = ((*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr((start_y * size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))))
- var alpha_dst uintptr = (base_rgba + uintptr(1))
+ var start_y size_t = size_t(GetAlphaSourceRow(tls, io, bp, bp+8))
+ var base_rgba uintptr = (*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr(start_y*size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))
+ var alpha_dst uintptr = base_rgba + uintptr(1)
var alpha_mask uint32_t = uint32_t(0x0f)
var i int32
var j int32
for j = 0; j < *(*int32)(unsafe.Pointer(bp + 8 /* num_rows */)); j++ {
for i = 0; i < mb_w; i++ {
// Fill in the alpha value (converted to 4 bits).
- var alpha_value uint32_t = (uint32_t(int32(*(*uint8_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp /* alpha */)) + uintptr(i)))) >> 4))
- *(*uint8_t)(unsafe.Pointer(alpha_dst + uintptr((2 * i)))) = (uint8_t((uint32_t(int32(*(*uint8_t)(unsafe.Pointer(alpha_dst + uintptr((2 * i))))) & 0xf0)) | alpha_value))
- alpha_mask = alpha_mask & (alpha_value)
+ var alpha_value uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)))) >> 4)
+ *(*uint8_t)(unsafe.Pointer(alpha_dst + uintptr(2*i))) = uint8_t(uint32_t(int32(*(*uint8_t)(unsafe.Pointer(alpha_dst + uintptr(2*i))))&0xf0) | alpha_value)
+ alpha_mask = alpha_mask & alpha_value
}
*(*uintptr)(unsafe.Pointer(bp /* alpha */)) += uintptr((*VP8Io)(unsafe.Pointer(io)).width)
alpha_dst += uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)
}
_ = expected_num_lines_out
- if (alpha_mask != uint32_t(0x0f)) && (WebPIsPremultipliedMode(tls, colorspace) != 0) {
+ if alpha_mask != uint32_t(0x0f) && WebPIsPremultipliedMode(tls, colorspace) != 0 {
(*struct {
f func(*libc.TLS, uintptr, int32, int32, int32)
})(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply4444})).f(tls, base_rgba, mb_w, *(*int32)(unsafe.Pointer(bp + 8 /* num_rows */)), (*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)
@@ -7679,19 +7419,19 @@ func Rescale(tls *libc.TLS, src uintptr, src_stride int32, new_lines int32, wrk
var num_lines_out int32 = 0
for new_lines > 0 { // import new contributions of source rows.
var lines_in int32 = WebPRescalerImport(tls, wrk, new_lines, src, src_stride)
- src += (uintptr(lines_in * src_stride))
- new_lines = new_lines - (lines_in)
- num_lines_out = num_lines_out + (WebPRescalerExport(tls, wrk)) // emit output row(s)
+ src += uintptr(lines_in * src_stride)
+ new_lines = new_lines - lines_in
+ num_lines_out = num_lines_out + WebPRescalerExport(tls, wrk) // emit output row(s)
}
return num_lines_out
}
func EmitRescaledYUV(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:252:12: */
var mb_h int32 = (*VP8Io)(unsafe.Pointer(io)).mb_h
- var uv_mb_h int32 = ((mb_h + 1) >> 1)
+ var uv_mb_h int32 = (mb_h + 1) >> 1
var scaler uintptr = (*WebPDecParams)(unsafe.Pointer(p)).scaler_y
var num_lines_out int32 = 0
- if (WebPIsAlphaMode(tls, (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace) != 0) && ((*VP8Io)(unsafe.Pointer(io)).a != (uintptr(0))) {
+ if WebPIsAlphaMode(tls, (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace) != 0 && (*VP8Io)(unsafe.Pointer(io)).a != uintptr(0) {
// Before rescaling, we premultiply the luma directly into the io->y
// internal buffer. This is OK since these samples are not used for
// intra-prediction (the top samples are saved in cache_y_/u_/v_).
@@ -7706,17 +7446,17 @@ func EmitRescaledYUV(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:2
}
func EmitRescaledAlphaYUV(tls *libc.TLS, io uintptr, p uintptr, expected_num_lines_out int32) int32 { /* io_dec.c:271:12: */
- var buf uintptr = ((*WebPDecParams)(unsafe.Pointer(p)).output + 16 /* &.u */) /* &.YUVA */
- var dst_a uintptr = ((*WebPYUVABuffer)(unsafe.Pointer(buf)).a + uintptr((size_t((*WebPDecParams)(unsafe.Pointer(p)).last_y) * size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride))))
- if (*VP8Io)(unsafe.Pointer(io)).a != (uintptr(0)) {
- var dst_y uintptr = ((*WebPYUVABuffer)(unsafe.Pointer(buf)).y + uintptr((size_t((*WebPDecParams)(unsafe.Pointer(p)).last_y) * size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride))))
+ var buf uintptr = (*WebPDecParams)(unsafe.Pointer(p)).output + 16
+ var dst_a uintptr = (*WebPYUVABuffer)(unsafe.Pointer(buf)).a + uintptr(size_t((*WebPDecParams)(unsafe.Pointer(p)).last_y)*size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride))
+ if (*VP8Io)(unsafe.Pointer(io)).a != uintptr(0) {
+ var dst_y uintptr = (*WebPYUVABuffer)(unsafe.Pointer(buf)).y + uintptr(size_t((*WebPDecParams)(unsafe.Pointer(p)).last_y)*size_t((*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride))
var num_lines_out int32 = Rescale(tls, (*VP8Io)(unsafe.Pointer(io)).a, (*VP8Io)(unsafe.Pointer(io)).width, (*VP8Io)(unsafe.Pointer(io)).mb_h, (*WebPDecParams)(unsafe.Pointer(p)).scaler_a)
if num_lines_out > 0 { // unmultiply the Y
WebPMultRows(tls, dst_y, (*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride, dst_a, (*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride,
(*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).scaler_a)).dst_width, num_lines_out, 1)
}
- } else if (*WebPYUVABuffer)(unsafe.Pointer(buf)).a != (uintptr(0)) {
+ } else if (*WebPYUVABuffer)(unsafe.Pointer(buf)).a != uintptr(0) {
// the user requested alpha, but there is none, set it to opaque.
FillAlphaPlane(tls, dst_a, (*VP8Io)(unsafe.Pointer(io)).scaled_width, expected_num_lines_out,
@@ -7727,16 +7467,16 @@ func EmitRescaledAlphaYUV(tls *libc.TLS, io uintptr, p uintptr, expected_num_lin
func InitYUVRescaler(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:292:12: */
var has_alpha int32 = WebPIsAlphaMode(tls, (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace)
- var buf uintptr = ((*WebPDecParams)(unsafe.Pointer(p)).output + 16 /* &.u */) /* &.YUVA */
+ var buf uintptr = (*WebPDecParams)(unsafe.Pointer(p)).output + 16
var out_width int32 = (*VP8Io)(unsafe.Pointer(io)).scaled_width
var out_height int32 = (*VP8Io)(unsafe.Pointer(io)).scaled_height
- var uv_out_width int32 = ((out_width + 1) >> 1)
- var uv_out_height int32 = ((out_height + 1) >> 1)
- var uv_in_width int32 = (((*VP8Io)(unsafe.Pointer(io)).mb_w + 1) >> 1)
- var uv_in_height int32 = (((*VP8Io)(unsafe.Pointer(io)).mb_h + 1) >> 1)
+ var uv_out_width int32 = (out_width + 1) >> 1
+ var uv_out_height int32 = (out_height + 1) >> 1
+ var uv_in_width int32 = ((*VP8Io)(unsafe.Pointer(io)).mb_w + 1) >> 1
+ var uv_in_height int32 = ((*VP8Io)(unsafe.Pointer(io)).mb_h + 1) >> 1
// scratch memory for luma rescaler
- var work_size size_t = (uint64(2) * size_t(out_width))
- var uv_work_size size_t = (size_t(2 * uv_out_width)) // and for each u/v ones
+ var work_size size_t = uint64(2) * size_t(out_width)
+ var uv_work_size size_t = size_t(2 * uv_out_width) // and for each u/v ones
var total_size uint64_t
var rescaler_size size_t
var work uintptr
@@ -7748,40 +7488,40 @@ func InitYUVRescaler(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:2
num_rescalers = 3
}
- total_size = ((work_size + (uint64(2) * uv_work_size)) * uint64_t(unsafe.Sizeof(rescaler_t(0))))
+ total_size = (work_size + uint64(2)*uv_work_size) * uint64_t(unsafe.Sizeof(rescaler_t(0)))
if has_alpha != 0 {
- total_size = total_size + (work_size * uint64_t(unsafe.Sizeof(rescaler_t(0))))
+ total_size = total_size + work_size*uint64_t(unsafe.Sizeof(rescaler_t(0)))
}
- rescaler_size = ((uint64(num_rescalers) * uint64(unsafe.Sizeof(WebPRescaler{}))) + uint64(31))
- total_size = total_size + (rescaler_size)
+ rescaler_size = uint64(num_rescalers)*uint64(unsafe.Sizeof(WebPRescaler{})) + uint64(31)
+ total_size = total_size + rescaler_size
if !(CheckSizeOverflow(tls, total_size) != 0) {
return 0
}
(*WebPDecParams)(unsafe.Pointer(p)).memory = WebPSafeMalloc(tls, 1, total_size)
- if (*WebPDecParams)(unsafe.Pointer(p)).memory == (uintptr(0)) {
+ if (*WebPDecParams)(unsafe.Pointer(p)).memory == uintptr(0) {
return 0 // memory error
}
work = (*WebPDecParams)(unsafe.Pointer(p)).memory
- scalers = (uintptr((uintptr_t(((work + uintptr(total_size)) - uintptr(rescaler_size))) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
- (*WebPDecParams)(unsafe.Pointer(p)).scaler_y = (scalers)
- (*WebPDecParams)(unsafe.Pointer(p)).scaler_u = (scalers + 1*104)
- (*WebPDecParams)(unsafe.Pointer(p)).scaler_v = (scalers + 2*104)
+ scalers = uintptr((uintptr_t(work+uintptr(total_size)-uintptr(rescaler_size)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
+ (*WebPDecParams)(unsafe.Pointer(p)).scaler_y = scalers
+ (*WebPDecParams)(unsafe.Pointer(p)).scaler_u = scalers + 1*104
+ (*WebPDecParams)(unsafe.Pointer(p)).scaler_v = scalers + 2*104
(*WebPDecParams)(unsafe.Pointer(p)).scaler_a = func() uintptr {
if has_alpha != 0 {
- return (scalers + 3*104)
+ return scalers + 3*104
}
- return (uintptr(0))
+ return uintptr(0)
}()
- if (!(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_y, (*VP8Io)(unsafe.Pointer(io)).mb_w, (*VP8Io)(unsafe.Pointer(io)).mb_h,
+ if !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_y, (*VP8Io)(unsafe.Pointer(io)).mb_w, (*VP8Io)(unsafe.Pointer(io)).mb_h,
(*WebPYUVABuffer)(unsafe.Pointer(buf)).y, out_width, out_height, (*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride, 1,
work) != 0) || !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_u, uv_in_width, uv_in_height,
(*WebPYUVABuffer)(unsafe.Pointer(buf)).u, uv_out_width, uv_out_height, (*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride, 1,
- (work+uintptr(work_size)*4)) != 0)) || !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_v, uv_in_width, uv_in_height,
+ work+uintptr(work_size)*4) != 0) || !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_v, uv_in_width, uv_in_height,
(*WebPYUVABuffer)(unsafe.Pointer(buf)).v, uv_out_width, uv_out_height, (*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride, 1,
- ((work+uintptr(work_size)*4)+uintptr(uv_work_size)*4)) != 0) {
+ work+uintptr(work_size)*4+uintptr(uv_work_size)*4) != 0) {
return 0
}
(*WebPDecParams)(unsafe.Pointer(p)).emit = *(*uintptr)(unsafe.Pointer(&struct {
@@ -7791,7 +7531,7 @@ func InitYUVRescaler(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:2
if has_alpha != 0 {
if !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_a, (*VP8Io)(unsafe.Pointer(io)).mb_w, (*VP8Io)(unsafe.Pointer(io)).mb_h,
(*WebPYUVABuffer)(unsafe.Pointer(buf)).a, out_width, out_height, (*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride, 1,
- ((work+uintptr(work_size)*4)+uintptr((uint64(2)*uv_work_size))*4)) != 0) {
+ work+uintptr(work_size)*4+uintptr(uint64(2)*uv_work_size)*4) != 0) {
return 0
}
(*WebPDecParams)(unsafe.Pointer(p)).emit_alpha = *(*uintptr)(unsafe.Pointer(&struct {
@@ -7807,12 +7547,12 @@ func InitYUVRescaler(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:2
func ExportRGB(tls *libc.TLS, p uintptr, y_pos int32) int32 { /* io_dec.c:361:12: */
var convert WebPYUV444Converter = WebPYUV444Converters[(*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace]
- var buf uintptr = ((*WebPDecParams)(unsafe.Pointer(p)).output + 16 /* &.u */) /* &.RGBA */
- var dst uintptr = ((*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr((size_t(y_pos) * size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))))
+ var buf uintptr = (*WebPDecParams)(unsafe.Pointer(p)).output + 16
+ var dst uintptr = (*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr(size_t(y_pos)*size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))
var num_lines_out int32 = 0
// For RGB rescaling, because of the YUV420, current scan position
// U/V can be +1/-1 line from the Y one. Hence the double test.
- for (WebPRescalerHasPendingOutput(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_y) != 0) && (WebPRescalerHasPendingOutput(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_u) != 0) {
+ for WebPRescalerHasPendingOutput(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_y) != 0 && WebPRescalerHasPendingOutput(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_u) != 0 {
WebPRescalerExportRow(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_y)
WebPRescalerExportRow(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_u)
@@ -7829,57 +7569,57 @@ func ExportRGB(tls *libc.TLS, p uintptr, y_pos int32) int32 { /* io_dec.c:361:12
func EmitRescaledRGB(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:384:12: */
var mb_h int32 = (*VP8Io)(unsafe.Pointer(io)).mb_h
- var uv_mb_h int32 = ((mb_h + 1) >> 1)
+ var uv_mb_h int32 = (mb_h + 1) >> 1
var j int32 = 0
var uv_j int32 = 0
var num_lines_out int32 = 0
for j < mb_h {
- var y_lines_in int32 = WebPRescalerImport(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_y, (mb_h - j),
- ((*VP8Io)(unsafe.Pointer(io)).y + uintptr((size_t(j) * size_t((*VP8Io)(unsafe.Pointer(io)).y_stride)))), (*VP8Io)(unsafe.Pointer(io)).y_stride)
- j = j + (y_lines_in)
- if WebPRescaleNeededLines(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_u, (uv_mb_h-uv_j)) != 0 {
+ var y_lines_in int32 = WebPRescalerImport(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_y, mb_h-j,
+ (*VP8Io)(unsafe.Pointer(io)).y+uintptr(size_t(j)*size_t((*VP8Io)(unsafe.Pointer(io)).y_stride)), (*VP8Io)(unsafe.Pointer(io)).y_stride)
+ j = j + y_lines_in
+ if WebPRescaleNeededLines(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_u, uv_mb_h-uv_j) != 0 {
var u_lines_in int32 = WebPRescalerImport(tls,
- (*WebPDecParams)(unsafe.Pointer(p)).scaler_u, (uv_mb_h - uv_j), ((*VP8Io)(unsafe.Pointer(io)).u + uintptr((size_t(uv_j) * size_t((*VP8Io)(unsafe.Pointer(io)).uv_stride)))),
+ (*WebPDecParams)(unsafe.Pointer(p)).scaler_u, uv_mb_h-uv_j, (*VP8Io)(unsafe.Pointer(io)).u+uintptr(size_t(uv_j)*size_t((*VP8Io)(unsafe.Pointer(io)).uv_stride)),
(*VP8Io)(unsafe.Pointer(io)).uv_stride)
var v_lines_in int32 = WebPRescalerImport(tls,
- (*WebPDecParams)(unsafe.Pointer(p)).scaler_v, (uv_mb_h - uv_j), ((*VP8Io)(unsafe.Pointer(io)).v + uintptr((size_t(uv_j) * size_t((*VP8Io)(unsafe.Pointer(io)).uv_stride)))),
+ (*WebPDecParams)(unsafe.Pointer(p)).scaler_v, uv_mb_h-uv_j, (*VP8Io)(unsafe.Pointer(io)).v+uintptr(size_t(uv_j)*size_t((*VP8Io)(unsafe.Pointer(io)).uv_stride)),
(*VP8Io)(unsafe.Pointer(io)).uv_stride)
_ = v_lines_in
_ = v_lines_in // remove a gcc warning
- uv_j = uv_j + (u_lines_in)
+ uv_j = uv_j + u_lines_in
}
- num_lines_out = num_lines_out + (ExportRGB(tls, p, ((*WebPDecParams)(unsafe.Pointer(p)).last_y + num_lines_out)))
+ num_lines_out = num_lines_out + ExportRGB(tls, p, (*WebPDecParams)(unsafe.Pointer(p)).last_y+num_lines_out)
}
return num_lines_out
}
func ExportAlpha(tls *libc.TLS, p uintptr, y_pos int32, max_lines_out int32) int32 { /* io_dec.c:410:12: */
- var buf uintptr = ((*WebPDecParams)(unsafe.Pointer(p)).output + 16 /* &.u */) /* &.RGBA */
- var base_rgba uintptr = ((*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr((size_t(y_pos) * size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))))
+ var buf uintptr = (*WebPDecParams)(unsafe.Pointer(p)).output + 16
+ var base_rgba uintptr = (*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr(size_t(y_pos)*size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))
var colorspace WEBP_CSP_MODE = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace
- var alpha_first int32 = (libc.Bool32((colorspace == MODE_ARGB) || (colorspace == MODE_Argb)))
- var dst uintptr = (base_rgba + uintptr((func() int32 {
+ var alpha_first int32 = libc.Bool32(colorspace == MODE_ARGB || colorspace == MODE_Argb)
+ var dst uintptr = base_rgba + uintptr(func() int32 {
if alpha_first != 0 {
return 0
}
return 3
- }())))
+ }())
var num_lines_out int32 = 0
var is_premult_alpha int32 = WebPIsPremultipliedMode(tls, colorspace)
var non_opaque uint32_t = uint32_t(0)
var width int32 = (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).scaler_a)).dst_width
- for (WebPRescalerHasPendingOutput(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_a) != 0) && (num_lines_out < max_lines_out) {
+ for WebPRescalerHasPendingOutput(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_a) != 0 && num_lines_out < max_lines_out {
WebPRescalerExportRow(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_a)
- non_opaque = non_opaque | (uint32_t((*struct {
+ non_opaque = non_opaque | uint32_t((*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32) int32
- })(unsafe.Pointer(&struct{ uintptr }{WebPDispatchAlpha})).f(tls, (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).scaler_a)).dst, 0, width, 1, dst, 0)))
+ })(unsafe.Pointer(&struct{ uintptr }{WebPDispatchAlpha})).f(tls, (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).scaler_a)).dst, 0, width, 1, dst, 0))
dst += uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)
num_lines_out++
}
- if (is_premult_alpha != 0) && (non_opaque != 0) {
+ if is_premult_alpha != 0 && non_opaque != 0 {
(*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, int32)
})(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply})).f(tls, base_rgba, alpha_first,
@@ -7889,29 +7629,29 @@ func ExportAlpha(tls *libc.TLS, p uintptr, y_pos int32, max_lines_out int32) int
}
func ExportAlphaRGBA4444(tls *libc.TLS, p uintptr, y_pos int32, max_lines_out int32) int32 { /* io_dec.c:437:12: */
- var buf uintptr = ((*WebPDecParams)(unsafe.Pointer(p)).output + 16 /* &.u */) /* &.RGBA */
- var base_rgba uintptr = ((*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr((size_t(y_pos) * size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))))
- var alpha_dst uintptr = (base_rgba + uintptr(1))
+ var buf uintptr = (*WebPDecParams)(unsafe.Pointer(p)).output + 16
+ var base_rgba uintptr = (*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr(size_t(y_pos)*size_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))
+ var alpha_dst uintptr = base_rgba + uintptr(1)
var num_lines_out int32 = 0
var colorspace WEBP_CSP_MODE = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace
var width int32 = (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).scaler_a)).dst_width
var is_premult_alpha int32 = WebPIsPremultipliedMode(tls, colorspace)
var alpha_mask uint32_t = uint32_t(0x0f)
- for (WebPRescalerHasPendingOutput(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_a) != 0) && (num_lines_out < max_lines_out) {
+ for WebPRescalerHasPendingOutput(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_a) != 0 && num_lines_out < max_lines_out {
var i int32
WebPRescalerExportRow(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_a)
for i = 0; i < width; i++ {
// Fill in the alpha value (converted to 4 bits).
- var alpha_value uint32_t = (uint32_t(int32(*(*uint8_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).scaler_a)).dst + uintptr(i)))) >> 4))
- *(*uint8_t)(unsafe.Pointer(alpha_dst + uintptr((2 * i)))) = (uint8_t((uint32_t(int32(*(*uint8_t)(unsafe.Pointer(alpha_dst + uintptr((2 * i))))) & 0xf0)) | alpha_value))
- alpha_mask = alpha_mask & (alpha_value)
+ var alpha_value uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).scaler_a)).dst + uintptr(i)))) >> 4)
+ *(*uint8_t)(unsafe.Pointer(alpha_dst + uintptr(2*i))) = uint8_t(uint32_t(int32(*(*uint8_t)(unsafe.Pointer(alpha_dst + uintptr(2*i))))&0xf0) | alpha_value)
+ alpha_mask = alpha_mask & alpha_value
}
alpha_dst += uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)
num_lines_out++
}
- if (is_premult_alpha != 0) && (alpha_mask != uint32_t(0x0f)) {
+ if is_premult_alpha != 0 && alpha_mask != uint32_t(0x0f) {
(*struct {
f func(*libc.TLS, uintptr, int32, int32, int32)
})(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply4444})).f(tls, base_rgba, width, num_lines_out, (*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)
@@ -7920,17 +7660,17 @@ func ExportAlphaRGBA4444(tls *libc.TLS, p uintptr, y_pos int32, max_lines_out in
}
func EmitRescaledAlphaRGB(tls *libc.TLS, io uintptr, p uintptr, expected_num_out_lines int32) int32 { /* io_dec.c:472:12: */
- if (*VP8Io)(unsafe.Pointer(io)).a != (uintptr(0)) {
+ if (*VP8Io)(unsafe.Pointer(io)).a != uintptr(0) {
var scaler uintptr = (*WebPDecParams)(unsafe.Pointer(p)).scaler_a
var lines_left int32 = expected_num_out_lines
- var y_end int32 = ((*WebPDecParams)(unsafe.Pointer(p)).last_y + lines_left)
+ var y_end int32 = (*WebPDecParams)(unsafe.Pointer(p)).last_y + lines_left
for lines_left > 0 {
- var row_offset int64_t = (int64_t((*WebPRescaler)(unsafe.Pointer(scaler)).src_y) - int64_t((*VP8Io)(unsafe.Pointer(io)).mb_y))
- WebPRescalerImport(tls, scaler, (((*VP8Io)(unsafe.Pointer(io)).mb_h + (*VP8Io)(unsafe.Pointer(io)).mb_y) - (*WebPRescaler)(unsafe.Pointer(scaler)).src_y),
- ((*VP8Io)(unsafe.Pointer(io)).a + uintptr((row_offset * int64_t((*VP8Io)(unsafe.Pointer(io)).width)))), (*VP8Io)(unsafe.Pointer(io)).width)
- lines_left = lines_left - ((*struct {
+ var row_offset int64_t = int64_t((*WebPRescaler)(unsafe.Pointer(scaler)).src_y) - int64_t((*VP8Io)(unsafe.Pointer(io)).mb_y)
+ WebPRescalerImport(tls, scaler, (*VP8Io)(unsafe.Pointer(io)).mb_h+(*VP8Io)(unsafe.Pointer(io)).mb_y-(*WebPRescaler)(unsafe.Pointer(scaler)).src_y,
+ (*VP8Io)(unsafe.Pointer(io)).a+uintptr(row_offset*int64_t((*VP8Io)(unsafe.Pointer(io)).width)), (*VP8Io)(unsafe.Pointer(io)).width)
+ lines_left = lines_left - (*struct {
f func(*libc.TLS, uintptr, int32, int32) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPDecParams)(unsafe.Pointer(p)).emit_alpha_row})).f(tls, p, (y_end - lines_left), lines_left))
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPDecParams)(unsafe.Pointer(p)).emit_alpha_row})).f(tls, p, y_end-lines_left, lines_left)
}
}
return 0
@@ -7940,10 +7680,10 @@ func InitRGBRescaler(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:4
var has_alpha int32 = WebPIsAlphaMode(tls, (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace)
var out_width int32 = (*VP8Io)(unsafe.Pointer(io)).scaled_width
var out_height int32 = (*VP8Io)(unsafe.Pointer(io)).scaled_height
- var uv_in_width int32 = (((*VP8Io)(unsafe.Pointer(io)).mb_w + 1) >> 1)
- var uv_in_height int32 = (((*VP8Io)(unsafe.Pointer(io)).mb_h + 1) >> 1)
+ var uv_in_width int32 = ((*VP8Io)(unsafe.Pointer(io)).mb_w + 1) >> 1
+ var uv_in_height int32 = ((*VP8Io)(unsafe.Pointer(io)).mb_h + 1) >> 1
// scratch memory for one rescaler
- var work_size size_t = (uint64(2) * size_t(out_width))
+ var work_size size_t = uint64(2) * size_t(out_width)
var work uintptr // rescalers work area
var tmp uintptr // tmp storage for scaled YUV444 samples before RGB conversion
var tmp_size1 uint64_t
@@ -7958,40 +7698,40 @@ func InitRGBRescaler(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:4
num_rescalers = 3
}
- tmp_size1 = (uint64_t(num_rescalers) * work_size)
- tmp_size2 = (uint64_t(num_rescalers) * uint64_t(out_width))
- total_size = ((tmp_size1 * uint64_t(unsafe.Sizeof(rescaler_t(0)))) + (tmp_size2 * uint64_t(unsafe.Sizeof(uint8_t(0)))))
- rescaler_size = ((uint64(num_rescalers) * uint64(unsafe.Sizeof(WebPRescaler{}))) + uint64(31))
- total_size = total_size + (rescaler_size)
+ tmp_size1 = uint64_t(num_rescalers) * work_size
+ tmp_size2 = uint64_t(num_rescalers) * uint64_t(out_width)
+ total_size = tmp_size1*uint64_t(unsafe.Sizeof(rescaler_t(0))) + tmp_size2*uint64_t(unsafe.Sizeof(uint8_t(0)))
+ rescaler_size = uint64(num_rescalers)*uint64(unsafe.Sizeof(WebPRescaler{})) + uint64(31)
+ total_size = total_size + rescaler_size
if !(CheckSizeOverflow(tls, total_size) != 0) {
return 0
}
(*WebPDecParams)(unsafe.Pointer(p)).memory = WebPSafeMalloc(tls, 1, total_size)
- if (*WebPDecParams)(unsafe.Pointer(p)).memory == (uintptr(0)) {
+ if (*WebPDecParams)(unsafe.Pointer(p)).memory == uintptr(0) {
return 0 // memory error
}
work = (*WebPDecParams)(unsafe.Pointer(p)).memory
- tmp = (work + uintptr(tmp_size1)*4)
+ tmp = work + uintptr(tmp_size1)*4
- scalers = (uintptr((uintptr_t(((work + uintptr(total_size)) - uintptr(rescaler_size))) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
- (*WebPDecParams)(unsafe.Pointer(p)).scaler_y = (scalers)
- (*WebPDecParams)(unsafe.Pointer(p)).scaler_u = (scalers + 1*104)
- (*WebPDecParams)(unsafe.Pointer(p)).scaler_v = (scalers + 2*104)
+ scalers = uintptr((uintptr_t(work+uintptr(total_size)-uintptr(rescaler_size)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
+ (*WebPDecParams)(unsafe.Pointer(p)).scaler_y = scalers
+ (*WebPDecParams)(unsafe.Pointer(p)).scaler_u = scalers + 1*104
+ (*WebPDecParams)(unsafe.Pointer(p)).scaler_v = scalers + 2*104
(*WebPDecParams)(unsafe.Pointer(p)).scaler_a = func() uintptr {
if has_alpha != 0 {
- return (scalers + 3*104)
+ return scalers + 3*104
}
- return (uintptr(0))
+ return uintptr(0)
}()
- if (!(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_y, (*VP8Io)(unsafe.Pointer(io)).mb_w, (*VP8Io)(unsafe.Pointer(io)).mb_h,
- (tmp+uintptr((0*out_width))), out_width, out_height, 0, 1,
- (work+uintptr((uint64(0)*work_size))*4)) != 0) || !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_u, uv_in_width, uv_in_height,
- (tmp+uintptr((1*out_width))), out_width, out_height, 0, 1,
- (work+uintptr((uint64(1)*work_size))*4)) != 0)) || !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_v, uv_in_width, uv_in_height,
- (tmp+uintptr((2*out_width))), out_width, out_height, 0, 1,
- (work+uintptr((uint64(2)*work_size))*4)) != 0) {
+ if !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_y, (*VP8Io)(unsafe.Pointer(io)).mb_w, (*VP8Io)(unsafe.Pointer(io)).mb_h,
+ tmp+uintptr(0*out_width), out_width, out_height, 0, 1,
+ work+uintptr(uint64(0)*work_size)*4) != 0) || !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_u, uv_in_width, uv_in_height,
+ tmp+uintptr(1*out_width), out_width, out_height, 0, 1,
+ work+uintptr(uint64(1)*work_size)*4) != 0) || !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_v, uv_in_width, uv_in_height,
+ tmp+uintptr(2*out_width), out_width, out_height, 0, 1,
+ work+uintptr(uint64(2)*work_size)*4) != 0) {
return 0
}
(*WebPDecParams)(unsafe.Pointer(p)).emit = *(*uintptr)(unsafe.Pointer(&struct {
@@ -8001,14 +7741,14 @@ func InitRGBRescaler(tls *libc.TLS, io uintptr, p uintptr) int32 { /* io_dec.c:4
if has_alpha != 0 {
if !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).scaler_a, (*VP8Io)(unsafe.Pointer(io)).mb_w, (*VP8Io)(unsafe.Pointer(io)).mb_h,
- (tmp+uintptr((3*out_width))), out_width, out_height, 0, 1,
- (work+uintptr((uint64(3)*work_size))*4)) != 0) {
+ tmp+uintptr(3*out_width), out_width, out_height, 0, 1,
+ work+uintptr(uint64(3)*work_size)*4) != 0) {
return 0
}
(*WebPDecParams)(unsafe.Pointer(p)).emit_alpha = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32) int32
}{EmitRescaledAlphaRGB}))
- if ((*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace == MODE_RGBA_4444) || ((*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace == MODE_rgbA_4444) {
+ if (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace == MODE_RGBA_4444 || (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).output)).colorspace == MODE_rgbA_4444 {
(*WebPDecParams)(unsafe.Pointer(p)).emit_alpha_row = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, int32, int32) int32
}{ExportAlphaRGBA4444}))
@@ -8031,10 +7771,10 @@ func CustomSetup(tls *libc.TLS, io uintptr) int32 { /* io_dec.c:563:12: */
var is_rgb int32 = WebPIsRGBMode(tls, colorspace)
var is_alpha int32 = WebPIsAlphaMode(tls, colorspace)
- (*WebPDecParams)(unsafe.Pointer(p)).memory = (uintptr(0))
- (*WebPDecParams)(unsafe.Pointer(p)).emit = (uintptr(0))
- (*WebPDecParams)(unsafe.Pointer(p)).emit_alpha = (uintptr(0))
- (*WebPDecParams)(unsafe.Pointer(p)).emit_alpha_row = (uintptr(0))
+ (*WebPDecParams)(unsafe.Pointer(p)).memory = uintptr(0)
+ (*WebPDecParams)(unsafe.Pointer(p)).emit = uintptr(0)
+ (*WebPDecParams)(unsafe.Pointer(p)).emit_alpha = uintptr(0)
+ (*WebPDecParams)(unsafe.Pointer(p)).emit_alpha_row = uintptr(0)
if !(WebPIoInitFromOptions(tls, (*WebPDecParams)(unsafe.Pointer(p)).options, io, func() uint32 {
if is_alpha != 0 {
return MODE_YUV
@@ -8043,7 +7783,7 @@ func CustomSetup(tls *libc.TLS, io uintptr) int32 { /* io_dec.c:563:12: */
}()) != 0) {
return 0
}
- if (is_alpha != 0) && (WebPIsPremultipliedMode(tls, colorspace) != 0) {
+ if is_alpha != 0 && WebPIsPremultipliedMode(tls, colorspace) != 0 {
WebPInitUpsamplers(tls)
}
if (*VP8Io)(unsafe.Pointer(io)).use_scaling != 0 {
@@ -8063,14 +7803,14 @@ func CustomSetup(tls *libc.TLS, io uintptr) int32 { /* io_dec.c:563:12: */
f func(*libc.TLS, uintptr, uintptr) int32
}{EmitSampledRGB})) // default
if (*VP8Io)(unsafe.Pointer(io)).fancy_upsampling != 0 {
- var uv_width int32 = (((*VP8Io)(unsafe.Pointer(io)).mb_w + 1) >> 1)
- (*WebPDecParams)(unsafe.Pointer(p)).memory = WebPSafeMalloc(tls, 1, (size_t((*VP8Io)(unsafe.Pointer(io)).mb_w + (2 * uv_width))))
- if (*WebPDecParams)(unsafe.Pointer(p)).memory == (uintptr(0)) {
+ var uv_width int32 = ((*VP8Io)(unsafe.Pointer(io)).mb_w + 1) >> 1
+ (*WebPDecParams)(unsafe.Pointer(p)).memory = WebPSafeMalloc(tls, 1, size_t((*VP8Io)(unsafe.Pointer(io)).mb_w+2*uv_width))
+ if (*WebPDecParams)(unsafe.Pointer(p)).memory == uintptr(0) {
return 0 // memory error.
}
(*WebPDecParams)(unsafe.Pointer(p)).tmp_y = (*WebPDecParams)(unsafe.Pointer(p)).memory
- (*WebPDecParams)(unsafe.Pointer(p)).tmp_u = ((*WebPDecParams)(unsafe.Pointer(p)).tmp_y + uintptr((*VP8Io)(unsafe.Pointer(io)).mb_w))
- (*WebPDecParams)(unsafe.Pointer(p)).tmp_v = ((*WebPDecParams)(unsafe.Pointer(p)).tmp_u + uintptr(uv_width))
+ (*WebPDecParams)(unsafe.Pointer(p)).tmp_u = (*WebPDecParams)(unsafe.Pointer(p)).tmp_y + uintptr((*VP8Io)(unsafe.Pointer(io)).mb_w)
+ (*WebPDecParams)(unsafe.Pointer(p)).tmp_v = (*WebPDecParams)(unsafe.Pointer(p)).tmp_u + uintptr(uv_width)
(*WebPDecParams)(unsafe.Pointer(p)).emit = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) int32
}{EmitFancyRGB}))
@@ -8083,7 +7823,7 @@ func CustomSetup(tls *libc.TLS, io uintptr) int32 { /* io_dec.c:563:12: */
}
if is_alpha != 0 { // need transparency output
(*WebPDecParams)(unsafe.Pointer(p)).emit_alpha = func() uintptr {
- if (colorspace == MODE_RGBA_4444) || (colorspace == MODE_rgbA_4444) {
+ if colorspace == MODE_RGBA_4444 || colorspace == MODE_rgbA_4444 {
return *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32) int32
}{EmitAlphaRGBA4444}))
@@ -8116,18 +7856,18 @@ func CustomPut(tls *libc.TLS, io uintptr) int32 { /* io_dec.c:626:12: */
var mb_h int32 = (*VP8Io)(unsafe.Pointer(io)).mb_h
var num_lines_out int32
- if (mb_w <= 0) || (mb_h <= 0) {
+ if mb_w <= 0 || mb_h <= 0 {
return 0
}
num_lines_out = (*struct {
f func(*libc.TLS, uintptr, uintptr) int32
})(unsafe.Pointer(&struct{ uintptr }{(*WebPDecParams)(unsafe.Pointer(p)).emit})).f(tls, io, p)
- if (*WebPDecParams)(unsafe.Pointer(p)).emit_alpha != (uintptr(0)) {
+ if (*WebPDecParams)(unsafe.Pointer(p)).emit_alpha != uintptr(0) {
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32) int32
})(unsafe.Pointer(&struct{ uintptr }{(*WebPDecParams)(unsafe.Pointer(p)).emit_alpha})).f(tls, io, p, num_lines_out)
}
- *(*int32)(unsafe.Pointer((p + 32 /* &.last_y */))) += (num_lines_out)
+ *(*int32)(unsafe.Pointer(p + 32)) += num_lines_out
return 1
}
@@ -8136,7 +7876,7 @@ func CustomPut(tls *libc.TLS, io uintptr) int32 { /* io_dec.c:626:12: */
func CustomTeardown(tls *libc.TLS, io uintptr) { /* io_dec.c:646:13: */
var p uintptr = (*VP8Io)(unsafe.Pointer(io)).opaque
WebPSafeFree(tls, (*WebPDecParams)(unsafe.Pointer(p)).memory)
- (*WebPDecParams)(unsafe.Pointer(p)).memory = (uintptr(0))
+ (*WebPDecParams)(unsafe.Pointer(p)).memory = uintptr(0)
}
//------------------------------------------------------------------------------
@@ -8210,7 +7950,7 @@ var kAcTable = [128]uint16_t{
// Paragraph 9.6
func VP8ParseQuant(tls *libc.TLS, dec uintptr) { /* quant_dec.c:62:6: */
- var br uintptr = (dec + 16 /* &.br_ */)
+ var br uintptr = dec + 16
var base_q0 int32 = int32(VP8GetValue(tls, br, 7))
var dqy1_dc int32
if VP8GetValue(tls, br, 1) != 0 {
@@ -8243,42 +7983,42 @@ func VP8ParseQuant(tls *libc.TLS, dec uintptr) { /* quant_dec.c:62:6: */
dquv_ac = 0
}
- var hdr uintptr = (dec + 128 /* &.segment_hdr_ */)
+ var hdr uintptr = dec + 128
var i int32
for i = 0; i < NUM_MB_SEGMENTS; i++ {
var q int32
if (*VP8SegmentHeader)(unsafe.Pointer(hdr)).use_segment_ != 0 {
- q = int32(*(*int8_t)(unsafe.Pointer((hdr + 12 /* &.quantizer_ */) + uintptr(i))))
+ q = int32(*(*int8_t)(unsafe.Pointer(hdr + 12 + uintptr(i))))
if !((*VP8SegmentHeader)(unsafe.Pointer(hdr)).absolute_delta_ != 0) {
- q = q + (base_q0)
+ q = q + base_q0
}
} else {
if i > 0 {
- *(*VP8QuantMatrix)(unsafe.Pointer((dec + 1060 /* &.dqm_ */) + uintptr(i)*32)) = *(*VP8QuantMatrix)(unsafe.Pointer((dec + 1060 /* &.dqm_ */)))
+ *(*VP8QuantMatrix)(unsafe.Pointer(dec + 1060 + uintptr(i)*32)) = *(*VP8QuantMatrix)(unsafe.Pointer(dec + 1060))
continue
} else {
q = base_q0
}
}
{
- var m uintptr = ((dec + 1060 /* &.dqm_ */) + uintptr(i)*32)
- *(*int32)(unsafe.Pointer((m /* &.y1_mat_ */))) = int32(kDcTable[clip(tls, (q+dqy1_dc), 127)])
- *(*int32)(unsafe.Pointer((m /* &.y1_mat_ */) + 1*4)) = int32(kAcTable[clip(tls, (q+0), 127)])
+ var m uintptr = dec + 1060 + uintptr(i)*32
+ *(*int32)(unsafe.Pointer(m)) = int32(kDcTable[clip(tls, q+dqy1_dc, 127)])
+ *(*int32)(unsafe.Pointer(m + 1*4)) = int32(kAcTable[clip(tls, q+0, 127)])
- *(*int32)(unsafe.Pointer((m + 8 /* &.y2_mat_ */))) = (int32(kDcTable[clip(tls, (q+dqy2_dc), 127)]) * 2)
+ *(*int32)(unsafe.Pointer(m + 8)) = int32(kDcTable[clip(tls, q+dqy2_dc, 127)]) * 2
// For all x in [0..284], x*155/100 is bitwise equal to (x*101581) >> 16.
// The smallest precision for that is '(x*6349) >> 12' but 16 is a good
// word size.
- *(*int32)(unsafe.Pointer((m + 8 /* &.y2_mat_ */) + 1*4)) = ((int32(kAcTable[clip(tls, (q+dqy2_ac), 127)]) * 101581) >> 16)
- if *(*int32)(unsafe.Pointer((m + 8 /* &.y2_mat_ */) + 1*4)) < 8 {
- *(*int32)(unsafe.Pointer((m + 8 /* &.y2_mat_ */) + 1*4)) = 8
+ *(*int32)(unsafe.Pointer(m + 8 + 1*4)) = int32(kAcTable[clip(tls, q+dqy2_ac, 127)]) * 101581 >> 16
+ if *(*int32)(unsafe.Pointer(m + 8 + 1*4)) < 8 {
+ *(*int32)(unsafe.Pointer(m + 8 + 1*4)) = 8
}
- *(*int32)(unsafe.Pointer((m + 16 /* &.uv_mat_ */))) = int32(kDcTable[clip(tls, (q+dquv_dc), 117)])
- *(*int32)(unsafe.Pointer((m + 16 /* &.uv_mat_ */) + 1*4)) = int32(kAcTable[clip(tls, (q+dquv_ac), 127)])
+ *(*int32)(unsafe.Pointer(m + 16)) = int32(kDcTable[clip(tls, q+dquv_dc, 117)])
+ *(*int32)(unsafe.Pointer(m + 16 + 1*4)) = int32(kAcTable[clip(tls, q+dquv_ac, 127)])
- (*VP8QuantMatrix)(unsafe.Pointer(m)).uv_quant_ = (q + dquv_ac) // for dithering strength evaluation
+ (*VP8QuantMatrix)(unsafe.Pointer(m)).uv_quant_ = q + dquv_ac // for dithering strength evaluation
}
}
@@ -8315,12 +8055,12 @@ func VP8LoadNewBytes(tls *libc.TLS, br uintptr) { /* bit_reader_inl_utils.h:58:6
var bits bit_t
// var in_bits lbit_t at bp, 8
- libc.Xmemcpy(tls, (bp) /* &in_bits */, (*VP8BitReader)(unsafe.Pointer(br)).buf_, uint64(unsafe.Sizeof(lbit_t(0))))
- *(*uintptr)(unsafe.Pointer((br + 16 /* &.buf_ */))) += (uintptr(int32(56) >> 3))
+ libc.Xmemcpy(tls, bp, (*VP8BitReader)(unsafe.Pointer(br)).buf_, uint64(unsafe.Sizeof(lbit_t(0))))
+ *(*uintptr)(unsafe.Pointer(br + 16)) += uintptr(int32(56) >> 3)
bits = BSwap64(tls, *(*lbit_t)(unsafe.Pointer(bp /* in_bits */)))
- bits >>= (64 - 56)
- (*VP8BitReader)(unsafe.Pointer(br)).value_ = (bits | ((*VP8BitReader)(unsafe.Pointer(br)).value_ << 56))
- *(*int32)(unsafe.Pointer((br + 12 /* &.bits_ */))) += (56)
+ bits >>= 64 - 56
+ (*VP8BitReader)(unsafe.Pointer(br)).value_ = bits | (*VP8BitReader)(unsafe.Pointer(br)).value_<<56
+ *(*int32)(unsafe.Pointer(br + 12)) += 56
} else {
VP8LoadFinalBytes(tls, br) // no need to be inlined
}
@@ -8337,22 +8077,22 @@ func VP8GetBit(tls *libc.TLS, br uintptr, prob int32) int32 { /* bit_reader_inl_
}
{
var pos int32 = (*VP8BitReader)(unsafe.Pointer(br)).bits_
- var split range_t = ((range1 * range_t(prob)) >> 8)
- var value range_t = (range_t((*VP8BitReader)(unsafe.Pointer(br)).value_ >> pos))
- var bit int32 = (libc.Bool32(value > split))
+ var split range_t = range1 * range_t(prob) >> 8
+ var value range_t = range_t((*VP8BitReader)(unsafe.Pointer(br)).value_ >> pos)
+ var bit int32 = libc.Bool32(value > split)
if bit != 0 {
- range1 = range1 - (split)
- *(*bit_t)(unsafe.Pointer((br /* &.value_ */))) -= ((bit_t(split + range_t(1))) << pos)
+ range1 = range1 - split
+ *(*bit_t)(unsafe.Pointer(br)) -= bit_t(split+range_t(1)) << pos
} else {
- range1 = (split + range_t(1))
+ range1 = split + range_t(1)
}
{
- var shift int32 = (7 ^ BitsLog2Floor(tls, range1))
+ var shift int32 = 7 ^ BitsLog2Floor(tls, range1)
range1 <<= shift
- *(*int32)(unsafe.Pointer((br + 12 /* &.bits_ */))) -= (shift)
+ *(*int32)(unsafe.Pointer(br + 12)) -= shift
}
- (*VP8BitReader)(unsafe.Pointer(br)).range_ = (range1 - range_t(1))
+ (*VP8BitReader)(unsafe.Pointer(br)).range_ = range1 - range_t(1)
return bit
@@ -8367,15 +8107,15 @@ func VP8GetSigned(tls *libc.TLS, br uintptr, v int32) int32 { /* bit_reader_inl_
}
{
var pos int32 = (*VP8BitReader)(unsafe.Pointer(br)).bits_
- var split range_t = ((*VP8BitReader)(unsafe.Pointer(br)).range_ >> 1)
- var value range_t = (range_t((*VP8BitReader)(unsafe.Pointer(br)).value_ >> pos))
- var mask int32_t = ((int32_t(split - value)) >> 31) // -1 or 0
- *(*int32)(unsafe.Pointer((br + 12 /* &.bits_ */))) -= (1)
- *(*range_t)(unsafe.Pointer((br + 8 /* &.range_ */))) += (range_t(mask))
- *(*range_t)(unsafe.Pointer((br + 8 /* &.range_ */))) |= (range_t(1))
- *(*bit_t)(unsafe.Pointer((br /* &.value_ */))) -= ((bit_t((split + range_t(1)) & range_t(mask))) << pos)
+ var split range_t = (*VP8BitReader)(unsafe.Pointer(br)).range_ >> 1
+ var value range_t = range_t((*VP8BitReader)(unsafe.Pointer(br)).value_ >> pos)
+ var mask int32_t = int32_t(split-value) >> 31 // -1 or 0
+ *(*int32)(unsafe.Pointer(br + 12)) -= 1
+ *(*range_t)(unsafe.Pointer(br + 8)) += range_t(mask)
+ *(*range_t)(unsafe.Pointer(br + 8)) |= range_t(1)
+ *(*bit_t)(unsafe.Pointer(br)) -= bit_t((split+range_t(1))&range_t(mask)) << pos
- return ((v ^ mask) - mask)
+ return v ^ mask - mask
}
return int32(0)
@@ -8391,12 +8131,12 @@ func VP8GetBitAlt(tls *libc.TLS, br uintptr, prob int32) int32 { /* bit_reader_i
}
{
var pos int32 = (*VP8BitReader)(unsafe.Pointer(br)).bits_
- var split range_t = ((range1 * range_t(prob)) >> 8)
- var value range_t = (range_t((*VP8BitReader)(unsafe.Pointer(br)).value_ >> pos))
+ var split range_t = range1 * range_t(prob) >> 8
+ var value range_t = range_t((*VP8BitReader)(unsafe.Pointer(br)).value_ >> pos)
var bit int32 // Don't use 'const int bit = (value > split);", it's slower.
if value > split {
range1 = range1 - (split + range_t(1))
- *(*bit_t)(unsafe.Pointer((br /* &.value_ */))) -= ((bit_t(split + range_t(1))) << pos)
+ *(*bit_t)(unsafe.Pointer(br)) -= bit_t(split+range_t(1)) << pos
bit = 1
} else {
range1 = split
@@ -8405,7 +8145,7 @@ func VP8GetBitAlt(tls *libc.TLS, br uintptr, prob int32) int32 { /* bit_reader_i
if range1 <= range_t(0x7e) {
var shift int32 = int32(kVP8Log2Range[range1])
range1 = range_t(kVP8NewRange[range1])
- *(*int32)(unsafe.Pointer((br + 12 /* &.bits_ */))) -= (shift)
+ *(*int32)(unsafe.Pointer(br + 12)) -= shift
}
(*VP8BitReader)(unsafe.Pointer(br)).range_ = range1
@@ -8433,266 +8173,266 @@ var kYModesIntra4 = [18]int8_t{
// Default probabilities
// Paragraph 13.5
-var CoeffsProba0 = [4][8][3][11]uint8_t{[8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+var CoeffsProba0 = [4][8][3][11]uint8_t{{
+ {{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(253), uint8_t(136), uint8_t(254), uint8_t(255), uint8_t(228), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(189), uint8_t(129), uint8_t(242), uint8_t(255), uint8_t(227), uint8_t(213), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(106), uint8_t(126), uint8_t(227), uint8_t(252), uint8_t(214), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(253), uint8_t(136), uint8_t(254), uint8_t(255), uint8_t(228), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(189), uint8_t(129), uint8_t(242), uint8_t(255), uint8_t(227), uint8_t(213), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(106), uint8_t(126), uint8_t(227), uint8_t(252), uint8_t(214), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(98), uint8_t(248), uint8_t(255), uint8_t(236), uint8_t(226), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(181), uint8_t(133), uint8_t(238), uint8_t(254), uint8_t(221), uint8_t(234), uint8_t(255), uint8_t(154), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(78), uint8_t(134), uint8_t(202), uint8_t(247), uint8_t(198), uint8_t(180), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(98), uint8_t(248), uint8_t(255), uint8_t(236), uint8_t(226), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(181), uint8_t(133), uint8_t(238), uint8_t(254), uint8_t(221), uint8_t(234), uint8_t(255), uint8_t(154), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(78), uint8_t(134), uint8_t(202), uint8_t(247), uint8_t(198), uint8_t(180), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(185), uint8_t(249), uint8_t(255), uint8_t(243), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(184), uint8_t(150), uint8_t(247), uint8_t(255), uint8_t(236), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(77), uint8_t(110), uint8_t(216), uint8_t(255), uint8_t(236), uint8_t(230), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(185), uint8_t(249), uint8_t(255), uint8_t(243), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(184), uint8_t(150), uint8_t(247), uint8_t(255), uint8_t(236), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(77), uint8_t(110), uint8_t(216), uint8_t(255), uint8_t(236), uint8_t(230), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(101), uint8_t(251), uint8_t(255), uint8_t(241), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(170), uint8_t(139), uint8_t(241), uint8_t(252), uint8_t(236), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(37), uint8_t(116), uint8_t(196), uint8_t(243), uint8_t(228), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(101), uint8_t(251), uint8_t(255), uint8_t(241), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(170), uint8_t(139), uint8_t(241), uint8_t(252), uint8_t(236), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(37), uint8_t(116), uint8_t(196), uint8_t(243), uint8_t(228), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(204), uint8_t(254), uint8_t(255), uint8_t(245), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(207), uint8_t(160), uint8_t(250), uint8_t(255), uint8_t(238), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(102), uint8_t(103), uint8_t(231), uint8_t(255), uint8_t(211), uint8_t(171), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(204), uint8_t(254), uint8_t(255), uint8_t(245), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(207), uint8_t(160), uint8_t(250), uint8_t(255), uint8_t(238), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(102), uint8_t(103), uint8_t(231), uint8_t(255), uint8_t(211), uint8_t(171), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(152), uint8_t(252), uint8_t(255), uint8_t(240), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(177), uint8_t(135), uint8_t(243), uint8_t(255), uint8_t(234), uint8_t(225), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(80), uint8_t(129), uint8_t(211), uint8_t(255), uint8_t(194), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(152), uint8_t(252), uint8_t(255), uint8_t(240), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(177), uint8_t(135), uint8_t(243), uint8_t(255), uint8_t(234), uint8_t(225), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(80), uint8_t(129), uint8_t(211), uint8_t(255), uint8_t(194), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(246), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(246), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(198), uint8_t(35), uint8_t(237), uint8_t(223), uint8_t(193), uint8_t(187), uint8_t(162), uint8_t(160), uint8_t(145), uint8_t(155), uint8_t(62)},
- [11]uint8_t{uint8_t(131), uint8_t(45), uint8_t(198), uint8_t(221), uint8_t(172), uint8_t(176), uint8_t(220), uint8_t(157), uint8_t(252), uint8_t(221), uint8_t(1)},
- [11]uint8_t{uint8_t(68), uint8_t(47), uint8_t(146), uint8_t(208), uint8_t(149), uint8_t(167), uint8_t(221), uint8_t(162), uint8_t(255), uint8_t(223), uint8_t(128)},
+ {
+ {{uint8_t(198), uint8_t(35), uint8_t(237), uint8_t(223), uint8_t(193), uint8_t(187), uint8_t(162), uint8_t(160), uint8_t(145), uint8_t(155), uint8_t(62)},
+ {uint8_t(131), uint8_t(45), uint8_t(198), uint8_t(221), uint8_t(172), uint8_t(176), uint8_t(220), uint8_t(157), uint8_t(252), uint8_t(221), uint8_t(1)},
+ {uint8_t(68), uint8_t(47), uint8_t(146), uint8_t(208), uint8_t(149), uint8_t(167), uint8_t(221), uint8_t(162), uint8_t(255), uint8_t(223), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(149), uint8_t(241), uint8_t(255), uint8_t(221), uint8_t(224), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(184), uint8_t(141), uint8_t(234), uint8_t(253), uint8_t(222), uint8_t(220), uint8_t(255), uint8_t(199), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(81), uint8_t(99), uint8_t(181), uint8_t(242), uint8_t(176), uint8_t(190), uint8_t(249), uint8_t(202), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {{uint8_t(1), uint8_t(149), uint8_t(241), uint8_t(255), uint8_t(221), uint8_t(224), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(184), uint8_t(141), uint8_t(234), uint8_t(253), uint8_t(222), uint8_t(220), uint8_t(255), uint8_t(199), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(81), uint8_t(99), uint8_t(181), uint8_t(242), uint8_t(176), uint8_t(190), uint8_t(249), uint8_t(202), uint8_t(255), uint8_t(255), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(129), uint8_t(232), uint8_t(253), uint8_t(214), uint8_t(197), uint8_t(242), uint8_t(196), uint8_t(255), uint8_t(255), uint8_t(128)},
- [11]uint8_t{uint8_t(99), uint8_t(121), uint8_t(210), uint8_t(250), uint8_t(201), uint8_t(198), uint8_t(255), uint8_t(202), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(23), uint8_t(91), uint8_t(163), uint8_t(242), uint8_t(170), uint8_t(187), uint8_t(247), uint8_t(210), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {{uint8_t(1), uint8_t(129), uint8_t(232), uint8_t(253), uint8_t(214), uint8_t(197), uint8_t(242), uint8_t(196), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {uint8_t(99), uint8_t(121), uint8_t(210), uint8_t(250), uint8_t(201), uint8_t(198), uint8_t(255), uint8_t(202), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(23), uint8_t(91), uint8_t(163), uint8_t(242), uint8_t(170), uint8_t(187), uint8_t(247), uint8_t(210), uint8_t(255), uint8_t(255), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(200), uint8_t(246), uint8_t(255), uint8_t(234), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(109), uint8_t(178), uint8_t(241), uint8_t(255), uint8_t(231), uint8_t(245), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(44), uint8_t(130), uint8_t(201), uint8_t(253), uint8_t(205), uint8_t(192), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(200), uint8_t(246), uint8_t(255), uint8_t(234), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(109), uint8_t(178), uint8_t(241), uint8_t(255), uint8_t(231), uint8_t(245), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(44), uint8_t(130), uint8_t(201), uint8_t(253), uint8_t(205), uint8_t(192), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(132), uint8_t(239), uint8_t(251), uint8_t(219), uint8_t(209), uint8_t(255), uint8_t(165), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(94), uint8_t(136), uint8_t(225), uint8_t(251), uint8_t(218), uint8_t(190), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(22), uint8_t(100), uint8_t(174), uint8_t(245), uint8_t(186), uint8_t(161), uint8_t(255), uint8_t(199), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(132), uint8_t(239), uint8_t(251), uint8_t(219), uint8_t(209), uint8_t(255), uint8_t(165), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(94), uint8_t(136), uint8_t(225), uint8_t(251), uint8_t(218), uint8_t(190), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(22), uint8_t(100), uint8_t(174), uint8_t(245), uint8_t(186), uint8_t(161), uint8_t(255), uint8_t(199), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(182), uint8_t(249), uint8_t(255), uint8_t(232), uint8_t(235), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(124), uint8_t(143), uint8_t(241), uint8_t(255), uint8_t(227), uint8_t(234), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(35), uint8_t(77), uint8_t(181), uint8_t(251), uint8_t(193), uint8_t(211), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(182), uint8_t(249), uint8_t(255), uint8_t(232), uint8_t(235), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(124), uint8_t(143), uint8_t(241), uint8_t(255), uint8_t(227), uint8_t(234), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(35), uint8_t(77), uint8_t(181), uint8_t(251), uint8_t(193), uint8_t(211), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(157), uint8_t(247), uint8_t(255), uint8_t(236), uint8_t(231), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(121), uint8_t(141), uint8_t(235), uint8_t(255), uint8_t(225), uint8_t(227), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(45), uint8_t(99), uint8_t(188), uint8_t(251), uint8_t(195), uint8_t(217), uint8_t(255), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(157), uint8_t(247), uint8_t(255), uint8_t(236), uint8_t(231), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(121), uint8_t(141), uint8_t(235), uint8_t(255), uint8_t(225), uint8_t(227), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(45), uint8_t(99), uint8_t(188), uint8_t(251), uint8_t(195), uint8_t(217), uint8_t(255), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(1), uint8_t(251), uint8_t(255), uint8_t(213), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(203), uint8_t(1), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(137), uint8_t(1), uint8_t(177), uint8_t(255), uint8_t(224), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(1), uint8_t(251), uint8_t(255), uint8_t(213), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(203), uint8_t(1), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(137), uint8_t(1), uint8_t(177), uint8_t(255), uint8_t(224), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(253), uint8_t(9), uint8_t(248), uint8_t(251), uint8_t(207), uint8_t(208), uint8_t(255), uint8_t(192), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(175), uint8_t(13), uint8_t(224), uint8_t(243), uint8_t(193), uint8_t(185), uint8_t(249), uint8_t(198), uint8_t(255), uint8_t(255), uint8_t(128)},
- [11]uint8_t{uint8_t(73), uint8_t(17), uint8_t(171), uint8_t(221), uint8_t(161), uint8_t(179), uint8_t(236), uint8_t(167), uint8_t(255), uint8_t(234), uint8_t(128)},
+ {
+ {{uint8_t(253), uint8_t(9), uint8_t(248), uint8_t(251), uint8_t(207), uint8_t(208), uint8_t(255), uint8_t(192), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(175), uint8_t(13), uint8_t(224), uint8_t(243), uint8_t(193), uint8_t(185), uint8_t(249), uint8_t(198), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {uint8_t(73), uint8_t(17), uint8_t(171), uint8_t(221), uint8_t(161), uint8_t(179), uint8_t(236), uint8_t(167), uint8_t(255), uint8_t(234), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(95), uint8_t(247), uint8_t(253), uint8_t(212), uint8_t(183), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(239), uint8_t(90), uint8_t(244), uint8_t(250), uint8_t(211), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(155), uint8_t(77), uint8_t(195), uint8_t(248), uint8_t(188), uint8_t(195), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(95), uint8_t(247), uint8_t(253), uint8_t(212), uint8_t(183), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(239), uint8_t(90), uint8_t(244), uint8_t(250), uint8_t(211), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(155), uint8_t(77), uint8_t(195), uint8_t(248), uint8_t(188), uint8_t(195), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(24), uint8_t(239), uint8_t(251), uint8_t(218), uint8_t(219), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(201), uint8_t(51), uint8_t(219), uint8_t(255), uint8_t(196), uint8_t(186), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(69), uint8_t(46), uint8_t(190), uint8_t(239), uint8_t(201), uint8_t(218), uint8_t(255), uint8_t(228), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(24), uint8_t(239), uint8_t(251), uint8_t(218), uint8_t(219), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(201), uint8_t(51), uint8_t(219), uint8_t(255), uint8_t(196), uint8_t(186), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(69), uint8_t(46), uint8_t(190), uint8_t(239), uint8_t(201), uint8_t(218), uint8_t(255), uint8_t(228), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(191), uint8_t(251), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(223), uint8_t(165), uint8_t(249), uint8_t(255), uint8_t(213), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(141), uint8_t(124), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(191), uint8_t(251), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(223), uint8_t(165), uint8_t(249), uint8_t(255), uint8_t(213), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(141), uint8_t(124), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(16), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(190), uint8_t(36), uint8_t(230), uint8_t(255), uint8_t(236), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(149), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(16), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(190), uint8_t(36), uint8_t(230), uint8_t(255), uint8_t(236), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(149), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(226), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(247), uint8_t(192), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(240), uint8_t(128), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(226), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(247), uint8_t(192), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(240), uint8_t(128), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(134), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(213), uint8_t(62), uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(55), uint8_t(93), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(134), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(213), uint8_t(62), uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(55), uint8_t(93), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(202), uint8_t(24), uint8_t(213), uint8_t(235), uint8_t(186), uint8_t(191), uint8_t(220), uint8_t(160), uint8_t(240), uint8_t(175), uint8_t(255)},
- [11]uint8_t{uint8_t(126), uint8_t(38), uint8_t(182), uint8_t(232), uint8_t(169), uint8_t(184), uint8_t(228), uint8_t(174), uint8_t(255), uint8_t(187), uint8_t(128)},
- [11]uint8_t{uint8_t(61), uint8_t(46), uint8_t(138), uint8_t(219), uint8_t(151), uint8_t(178), uint8_t(240), uint8_t(170), uint8_t(255), uint8_t(216), uint8_t(128)},
+ {
+ {{uint8_t(202), uint8_t(24), uint8_t(213), uint8_t(235), uint8_t(186), uint8_t(191), uint8_t(220), uint8_t(160), uint8_t(240), uint8_t(175), uint8_t(255)},
+ {uint8_t(126), uint8_t(38), uint8_t(182), uint8_t(232), uint8_t(169), uint8_t(184), uint8_t(228), uint8_t(174), uint8_t(255), uint8_t(187), uint8_t(128)},
+ {uint8_t(61), uint8_t(46), uint8_t(138), uint8_t(219), uint8_t(151), uint8_t(178), uint8_t(240), uint8_t(170), uint8_t(255), uint8_t(216), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(112), uint8_t(230), uint8_t(250), uint8_t(199), uint8_t(191), uint8_t(247), uint8_t(159), uint8_t(255), uint8_t(255), uint8_t(128)},
- [11]uint8_t{uint8_t(166), uint8_t(109), uint8_t(228), uint8_t(252), uint8_t(211), uint8_t(215), uint8_t(255), uint8_t(174), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(39), uint8_t(77), uint8_t(162), uint8_t(232), uint8_t(172), uint8_t(180), uint8_t(245), uint8_t(178), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {{uint8_t(1), uint8_t(112), uint8_t(230), uint8_t(250), uint8_t(199), uint8_t(191), uint8_t(247), uint8_t(159), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {uint8_t(166), uint8_t(109), uint8_t(228), uint8_t(252), uint8_t(211), uint8_t(215), uint8_t(255), uint8_t(174), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(39), uint8_t(77), uint8_t(162), uint8_t(232), uint8_t(172), uint8_t(180), uint8_t(245), uint8_t(178), uint8_t(255), uint8_t(255), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(52), uint8_t(220), uint8_t(246), uint8_t(198), uint8_t(199), uint8_t(249), uint8_t(220), uint8_t(255), uint8_t(255), uint8_t(128)},
- [11]uint8_t{uint8_t(124), uint8_t(74), uint8_t(191), uint8_t(243), uint8_t(183), uint8_t(193), uint8_t(250), uint8_t(221), uint8_t(255), uint8_t(255), uint8_t(128)},
- [11]uint8_t{uint8_t(24), uint8_t(71), uint8_t(130), uint8_t(219), uint8_t(154), uint8_t(170), uint8_t(243), uint8_t(182), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {{uint8_t(1), uint8_t(52), uint8_t(220), uint8_t(246), uint8_t(198), uint8_t(199), uint8_t(249), uint8_t(220), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {uint8_t(124), uint8_t(74), uint8_t(191), uint8_t(243), uint8_t(183), uint8_t(193), uint8_t(250), uint8_t(221), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {uint8_t(24), uint8_t(71), uint8_t(130), uint8_t(219), uint8_t(154), uint8_t(170), uint8_t(243), uint8_t(182), uint8_t(255), uint8_t(255), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(182), uint8_t(225), uint8_t(249), uint8_t(219), uint8_t(240), uint8_t(255), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(149), uint8_t(150), uint8_t(226), uint8_t(252), uint8_t(216), uint8_t(205), uint8_t(255), uint8_t(171), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(28), uint8_t(108), uint8_t(170), uint8_t(242), uint8_t(183), uint8_t(194), uint8_t(254), uint8_t(223), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {{uint8_t(1), uint8_t(182), uint8_t(225), uint8_t(249), uint8_t(219), uint8_t(240), uint8_t(255), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(149), uint8_t(150), uint8_t(226), uint8_t(252), uint8_t(216), uint8_t(205), uint8_t(255), uint8_t(171), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(28), uint8_t(108), uint8_t(170), uint8_t(242), uint8_t(183), uint8_t(194), uint8_t(254), uint8_t(223), uint8_t(255), uint8_t(255), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(81), uint8_t(230), uint8_t(252), uint8_t(204), uint8_t(203), uint8_t(255), uint8_t(192), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(123), uint8_t(102), uint8_t(209), uint8_t(247), uint8_t(188), uint8_t(196), uint8_t(255), uint8_t(233), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(20), uint8_t(95), uint8_t(153), uint8_t(243), uint8_t(164), uint8_t(173), uint8_t(255), uint8_t(203), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(81), uint8_t(230), uint8_t(252), uint8_t(204), uint8_t(203), uint8_t(255), uint8_t(192), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(123), uint8_t(102), uint8_t(209), uint8_t(247), uint8_t(188), uint8_t(196), uint8_t(255), uint8_t(233), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(20), uint8_t(95), uint8_t(153), uint8_t(243), uint8_t(164), uint8_t(173), uint8_t(255), uint8_t(203), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(222), uint8_t(248), uint8_t(255), uint8_t(216), uint8_t(213), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(168), uint8_t(175), uint8_t(246), uint8_t(252), uint8_t(235), uint8_t(205), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(47), uint8_t(116), uint8_t(215), uint8_t(255), uint8_t(211), uint8_t(212), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(222), uint8_t(248), uint8_t(255), uint8_t(216), uint8_t(213), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(168), uint8_t(175), uint8_t(246), uint8_t(252), uint8_t(235), uint8_t(205), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(47), uint8_t(116), uint8_t(215), uint8_t(255), uint8_t(211), uint8_t(212), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(121), uint8_t(236), uint8_t(253), uint8_t(212), uint8_t(214), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(141), uint8_t(84), uint8_t(213), uint8_t(252), uint8_t(201), uint8_t(202), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(42), uint8_t(80), uint8_t(160), uint8_t(240), uint8_t(162), uint8_t(185), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(121), uint8_t(236), uint8_t(253), uint8_t(212), uint8_t(214), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(141), uint8_t(84), uint8_t(213), uint8_t(252), uint8_t(201), uint8_t(202), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(42), uint8_t(80), uint8_t(160), uint8_t(240), uint8_t(162), uint8_t(185), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(244), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(238), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(244), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(238), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
},
} /* tree_dec.c:45:3 */
// Paragraph 11.5
-var kBModesProba = [10][10][9]uint8_t{[10][9]uint8_t{
- [9]uint8_t{uint8_t(231), uint8_t(120), uint8_t(48), uint8_t(89), uint8_t(115), uint8_t(113), uint8_t(120), uint8_t(152), uint8_t(112)},
- [9]uint8_t{uint8_t(152), uint8_t(179), uint8_t(64), uint8_t(126), uint8_t(170), uint8_t(118), uint8_t(46), uint8_t(70), uint8_t(95)},
- [9]uint8_t{uint8_t(175), uint8_t(69), uint8_t(143), uint8_t(80), uint8_t(85), uint8_t(82), uint8_t(72), uint8_t(155), uint8_t(103)},
- [9]uint8_t{uint8_t(56), uint8_t(58), uint8_t(10), uint8_t(171), uint8_t(218), uint8_t(189), uint8_t(17), uint8_t(13), uint8_t(152)},
- [9]uint8_t{uint8_t(114), uint8_t(26), uint8_t(17), uint8_t(163), uint8_t(44), uint8_t(195), uint8_t(21), uint8_t(10), uint8_t(173)},
- [9]uint8_t{uint8_t(121), uint8_t(24), uint8_t(80), uint8_t(195), uint8_t(26), uint8_t(62), uint8_t(44), uint8_t(64), uint8_t(85)},
- [9]uint8_t{uint8_t(144), uint8_t(71), uint8_t(10), uint8_t(38), uint8_t(171), uint8_t(213), uint8_t(144), uint8_t(34), uint8_t(26)},
- [9]uint8_t{uint8_t(170), uint8_t(46), uint8_t(55), uint8_t(19), uint8_t(136), uint8_t(160), uint8_t(33), uint8_t(206), uint8_t(71)},
- [9]uint8_t{uint8_t(63), uint8_t(20), uint8_t(8), uint8_t(114), uint8_t(114), uint8_t(208), uint8_t(12), uint8_t(9), uint8_t(226)},
- [9]uint8_t{uint8_t(81), uint8_t(40), uint8_t(11), uint8_t(96), uint8_t(182), uint8_t(84), uint8_t(29), uint8_t(16), uint8_t(36)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(134), uint8_t(183), uint8_t(89), uint8_t(137), uint8_t(98), uint8_t(101), uint8_t(106), uint8_t(165), uint8_t(148)},
- [9]uint8_t{uint8_t(72), uint8_t(187), uint8_t(100), uint8_t(130), uint8_t(157), uint8_t(111), uint8_t(32), uint8_t(75), uint8_t(80)},
- [9]uint8_t{uint8_t(66), uint8_t(102), uint8_t(167), uint8_t(99), uint8_t(74), uint8_t(62), uint8_t(40), uint8_t(234), uint8_t(128)},
- [9]uint8_t{uint8_t(41), uint8_t(53), uint8_t(9), uint8_t(178), uint8_t(241), uint8_t(141), uint8_t(26), uint8_t(8), uint8_t(107)},
- [9]uint8_t{uint8_t(74), uint8_t(43), uint8_t(26), uint8_t(146), uint8_t(73), uint8_t(166), uint8_t(49), uint8_t(23), uint8_t(157)},
- [9]uint8_t{uint8_t(65), uint8_t(38), uint8_t(105), uint8_t(160), uint8_t(51), uint8_t(52), uint8_t(31), uint8_t(115), uint8_t(128)},
- [9]uint8_t{uint8_t(104), uint8_t(79), uint8_t(12), uint8_t(27), uint8_t(217), uint8_t(255), uint8_t(87), uint8_t(17), uint8_t(7)},
- [9]uint8_t{uint8_t(87), uint8_t(68), uint8_t(71), uint8_t(44), uint8_t(114), uint8_t(51), uint8_t(15), uint8_t(186), uint8_t(23)},
- [9]uint8_t{uint8_t(47), uint8_t(41), uint8_t(14), uint8_t(110), uint8_t(182), uint8_t(183), uint8_t(21), uint8_t(17), uint8_t(194)},
- [9]uint8_t{uint8_t(66), uint8_t(45), uint8_t(25), uint8_t(102), uint8_t(197), uint8_t(189), uint8_t(23), uint8_t(18), uint8_t(22)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(88), uint8_t(88), uint8_t(147), uint8_t(150), uint8_t(42), uint8_t(46), uint8_t(45), uint8_t(196), uint8_t(205)},
- [9]uint8_t{uint8_t(43), uint8_t(97), uint8_t(183), uint8_t(117), uint8_t(85), uint8_t(38), uint8_t(35), uint8_t(179), uint8_t(61)},
- [9]uint8_t{uint8_t(39), uint8_t(53), uint8_t(200), uint8_t(87), uint8_t(26), uint8_t(21), uint8_t(43), uint8_t(232), uint8_t(171)},
- [9]uint8_t{uint8_t(56), uint8_t(34), uint8_t(51), uint8_t(104), uint8_t(114), uint8_t(102), uint8_t(29), uint8_t(93), uint8_t(77)},
- [9]uint8_t{uint8_t(39), uint8_t(28), uint8_t(85), uint8_t(171), uint8_t(58), uint8_t(165), uint8_t(90), uint8_t(98), uint8_t(64)},
- [9]uint8_t{uint8_t(34), uint8_t(22), uint8_t(116), uint8_t(206), uint8_t(23), uint8_t(34), uint8_t(43), uint8_t(166), uint8_t(73)},
- [9]uint8_t{uint8_t(107), uint8_t(54), uint8_t(32), uint8_t(26), uint8_t(51), uint8_t(1), uint8_t(81), uint8_t(43), uint8_t(31)},
- [9]uint8_t{uint8_t(68), uint8_t(25), uint8_t(106), uint8_t(22), uint8_t(64), uint8_t(171), uint8_t(36), uint8_t(225), uint8_t(114)},
- [9]uint8_t{uint8_t(34), uint8_t(19), uint8_t(21), uint8_t(102), uint8_t(132), uint8_t(188), uint8_t(16), uint8_t(76), uint8_t(124)},
- [9]uint8_t{uint8_t(62), uint8_t(18), uint8_t(78), uint8_t(95), uint8_t(85), uint8_t(57), uint8_t(50), uint8_t(48), uint8_t(51)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(193), uint8_t(101), uint8_t(35), uint8_t(159), uint8_t(215), uint8_t(111), uint8_t(89), uint8_t(46), uint8_t(111)},
- [9]uint8_t{uint8_t(60), uint8_t(148), uint8_t(31), uint8_t(172), uint8_t(219), uint8_t(228), uint8_t(21), uint8_t(18), uint8_t(111)},
- [9]uint8_t{uint8_t(112), uint8_t(113), uint8_t(77), uint8_t(85), uint8_t(179), uint8_t(255), uint8_t(38), uint8_t(120), uint8_t(114)},
- [9]uint8_t{uint8_t(40), uint8_t(42), uint8_t(1), uint8_t(196), uint8_t(245), uint8_t(209), uint8_t(10), uint8_t(25), uint8_t(109)},
- [9]uint8_t{uint8_t(88), uint8_t(43), uint8_t(29), uint8_t(140), uint8_t(166), uint8_t(213), uint8_t(37), uint8_t(43), uint8_t(154)},
- [9]uint8_t{uint8_t(61), uint8_t(63), uint8_t(30), uint8_t(155), uint8_t(67), uint8_t(45), uint8_t(68), uint8_t(1), uint8_t(209)},
- [9]uint8_t{uint8_t(100), uint8_t(80), uint8_t(8), uint8_t(43), uint8_t(154), uint8_t(1), uint8_t(51), uint8_t(26), uint8_t(71)},
- [9]uint8_t{uint8_t(142), uint8_t(78), uint8_t(78), uint8_t(16), uint8_t(255), uint8_t(128), uint8_t(34), uint8_t(197), uint8_t(171)},
- [9]uint8_t{uint8_t(41), uint8_t(40), uint8_t(5), uint8_t(102), uint8_t(211), uint8_t(183), uint8_t(4), uint8_t(1), uint8_t(221)},
- [9]uint8_t{uint8_t(51), uint8_t(50), uint8_t(17), uint8_t(168), uint8_t(209), uint8_t(192), uint8_t(23), uint8_t(25), uint8_t(82)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(138), uint8_t(31), uint8_t(36), uint8_t(171), uint8_t(27), uint8_t(166), uint8_t(38), uint8_t(44), uint8_t(229)},
- [9]uint8_t{uint8_t(67), uint8_t(87), uint8_t(58), uint8_t(169), uint8_t(82), uint8_t(115), uint8_t(26), uint8_t(59), uint8_t(179)},
- [9]uint8_t{uint8_t(63), uint8_t(59), uint8_t(90), uint8_t(180), uint8_t(59), uint8_t(166), uint8_t(93), uint8_t(73), uint8_t(154)},
- [9]uint8_t{uint8_t(40), uint8_t(40), uint8_t(21), uint8_t(116), uint8_t(143), uint8_t(209), uint8_t(34), uint8_t(39), uint8_t(175)},
- [9]uint8_t{uint8_t(47), uint8_t(15), uint8_t(16), uint8_t(183), uint8_t(34), uint8_t(223), uint8_t(49), uint8_t(45), uint8_t(183)},
- [9]uint8_t{uint8_t(46), uint8_t(17), uint8_t(33), uint8_t(183), uint8_t(6), uint8_t(98), uint8_t(15), uint8_t(32), uint8_t(183)},
- [9]uint8_t{uint8_t(57), uint8_t(46), uint8_t(22), uint8_t(24), uint8_t(128), uint8_t(1), uint8_t(54), uint8_t(17), uint8_t(37)},
- [9]uint8_t{uint8_t(65), uint8_t(32), uint8_t(73), uint8_t(115), uint8_t(28), uint8_t(128), uint8_t(23), uint8_t(128), uint8_t(205)},
- [9]uint8_t{uint8_t(40), uint8_t(3), uint8_t(9), uint8_t(115), uint8_t(51), uint8_t(192), uint8_t(18), uint8_t(6), uint8_t(223)},
- [9]uint8_t{uint8_t(87), uint8_t(37), uint8_t(9), uint8_t(115), uint8_t(59), uint8_t(77), uint8_t(64), uint8_t(21), uint8_t(47)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(104), uint8_t(55), uint8_t(44), uint8_t(218), uint8_t(9), uint8_t(54), uint8_t(53), uint8_t(130), uint8_t(226)},
- [9]uint8_t{uint8_t(64), uint8_t(90), uint8_t(70), uint8_t(205), uint8_t(40), uint8_t(41), uint8_t(23), uint8_t(26), uint8_t(57)},
- [9]uint8_t{uint8_t(54), uint8_t(57), uint8_t(112), uint8_t(184), uint8_t(5), uint8_t(41), uint8_t(38), uint8_t(166), uint8_t(213)},
- [9]uint8_t{uint8_t(30), uint8_t(34), uint8_t(26), uint8_t(133), uint8_t(152), uint8_t(116), uint8_t(10), uint8_t(32), uint8_t(134)},
- [9]uint8_t{uint8_t(39), uint8_t(19), uint8_t(53), uint8_t(221), uint8_t(26), uint8_t(114), uint8_t(32), uint8_t(73), uint8_t(255)},
- [9]uint8_t{uint8_t(31), uint8_t(9), uint8_t(65), uint8_t(234), uint8_t(2), uint8_t(15), uint8_t(1), uint8_t(118), uint8_t(73)},
- [9]uint8_t{uint8_t(75), uint8_t(32), uint8_t(12), uint8_t(51), uint8_t(192), uint8_t(255), uint8_t(160), uint8_t(43), uint8_t(51)},
- [9]uint8_t{uint8_t(88), uint8_t(31), uint8_t(35), uint8_t(67), uint8_t(102), uint8_t(85), uint8_t(55), uint8_t(186), uint8_t(85)},
- [9]uint8_t{uint8_t(56), uint8_t(21), uint8_t(23), uint8_t(111), uint8_t(59), uint8_t(205), uint8_t(45), uint8_t(37), uint8_t(192)},
- [9]uint8_t{uint8_t(55), uint8_t(38), uint8_t(70), uint8_t(124), uint8_t(73), uint8_t(102), uint8_t(1), uint8_t(34), uint8_t(98)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(125), uint8_t(98), uint8_t(42), uint8_t(88), uint8_t(104), uint8_t(85), uint8_t(117), uint8_t(175), uint8_t(82)},
- [9]uint8_t{uint8_t(95), uint8_t(84), uint8_t(53), uint8_t(89), uint8_t(128), uint8_t(100), uint8_t(113), uint8_t(101), uint8_t(45)},
- [9]uint8_t{uint8_t(75), uint8_t(79), uint8_t(123), uint8_t(47), uint8_t(51), uint8_t(128), uint8_t(81), uint8_t(171), uint8_t(1)},
- [9]uint8_t{uint8_t(57), uint8_t(17), uint8_t(5), uint8_t(71), uint8_t(102), uint8_t(57), uint8_t(53), uint8_t(41), uint8_t(49)},
- [9]uint8_t{uint8_t(38), uint8_t(33), uint8_t(13), uint8_t(121), uint8_t(57), uint8_t(73), uint8_t(26), uint8_t(1), uint8_t(85)},
- [9]uint8_t{uint8_t(41), uint8_t(10), uint8_t(67), uint8_t(138), uint8_t(77), uint8_t(110), uint8_t(90), uint8_t(47), uint8_t(114)},
- [9]uint8_t{uint8_t(115), uint8_t(21), uint8_t(2), uint8_t(10), uint8_t(102), uint8_t(255), uint8_t(166), uint8_t(23), uint8_t(6)},
- [9]uint8_t{uint8_t(101), uint8_t(29), uint8_t(16), uint8_t(10), uint8_t(85), uint8_t(128), uint8_t(101), uint8_t(196), uint8_t(26)},
- [9]uint8_t{uint8_t(57), uint8_t(18), uint8_t(10), uint8_t(102), uint8_t(102), uint8_t(213), uint8_t(34), uint8_t(20), uint8_t(43)},
- [9]uint8_t{uint8_t(117), uint8_t(20), uint8_t(15), uint8_t(36), uint8_t(163), uint8_t(128), uint8_t(68), uint8_t(1), uint8_t(26)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(102), uint8_t(61), uint8_t(71), uint8_t(37), uint8_t(34), uint8_t(53), uint8_t(31), uint8_t(243), uint8_t(192)},
- [9]uint8_t{uint8_t(69), uint8_t(60), uint8_t(71), uint8_t(38), uint8_t(73), uint8_t(119), uint8_t(28), uint8_t(222), uint8_t(37)},
- [9]uint8_t{uint8_t(68), uint8_t(45), uint8_t(128), uint8_t(34), uint8_t(1), uint8_t(47), uint8_t(11), uint8_t(245), uint8_t(171)},
- [9]uint8_t{uint8_t(62), uint8_t(17), uint8_t(19), uint8_t(70), uint8_t(146), uint8_t(85), uint8_t(55), uint8_t(62), uint8_t(70)},
- [9]uint8_t{uint8_t(37), uint8_t(43), uint8_t(37), uint8_t(154), uint8_t(100), uint8_t(163), uint8_t(85), uint8_t(160), uint8_t(1)},
- [9]uint8_t{uint8_t(63), uint8_t(9), uint8_t(92), uint8_t(136), uint8_t(28), uint8_t(64), uint8_t(32), uint8_t(201), uint8_t(85)},
- [9]uint8_t{uint8_t(75), uint8_t(15), uint8_t(9), uint8_t(9), uint8_t(64), uint8_t(255), uint8_t(184), uint8_t(119), uint8_t(16)},
- [9]uint8_t{uint8_t(86), uint8_t(6), uint8_t(28), uint8_t(5), uint8_t(64), uint8_t(255), uint8_t(25), uint8_t(248), uint8_t(1)},
- [9]uint8_t{uint8_t(56), uint8_t(8), uint8_t(17), uint8_t(132), uint8_t(137), uint8_t(255), uint8_t(55), uint8_t(116), uint8_t(128)},
- [9]uint8_t{uint8_t(58), uint8_t(15), uint8_t(20), uint8_t(82), uint8_t(135), uint8_t(57), uint8_t(26), uint8_t(121), uint8_t(40)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(164), uint8_t(50), uint8_t(31), uint8_t(137), uint8_t(154), uint8_t(133), uint8_t(25), uint8_t(35), uint8_t(218)},
- [9]uint8_t{uint8_t(51), uint8_t(103), uint8_t(44), uint8_t(131), uint8_t(131), uint8_t(123), uint8_t(31), uint8_t(6), uint8_t(158)},
- [9]uint8_t{uint8_t(86), uint8_t(40), uint8_t(64), uint8_t(135), uint8_t(148), uint8_t(224), uint8_t(45), uint8_t(183), uint8_t(128)},
- [9]uint8_t{uint8_t(22), uint8_t(26), uint8_t(17), uint8_t(131), uint8_t(240), uint8_t(154), uint8_t(14), uint8_t(1), uint8_t(209)},
- [9]uint8_t{uint8_t(45), uint8_t(16), uint8_t(21), uint8_t(91), uint8_t(64), uint8_t(222), uint8_t(7), uint8_t(1), uint8_t(197)},
- [9]uint8_t{uint8_t(56), uint8_t(21), uint8_t(39), uint8_t(155), uint8_t(60), uint8_t(138), uint8_t(23), uint8_t(102), uint8_t(213)},
- [9]uint8_t{uint8_t(83), uint8_t(12), uint8_t(13), uint8_t(54), uint8_t(192), uint8_t(255), uint8_t(68), uint8_t(47), uint8_t(28)},
- [9]uint8_t{uint8_t(85), uint8_t(26), uint8_t(85), uint8_t(85), uint8_t(128), uint8_t(128), uint8_t(32), uint8_t(146), uint8_t(171)},
- [9]uint8_t{uint8_t(18), uint8_t(11), uint8_t(7), uint8_t(63), uint8_t(144), uint8_t(171), uint8_t(4), uint8_t(4), uint8_t(246)},
- [9]uint8_t{uint8_t(35), uint8_t(27), uint8_t(10), uint8_t(146), uint8_t(174), uint8_t(171), uint8_t(12), uint8_t(26), uint8_t(128)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(190), uint8_t(80), uint8_t(35), uint8_t(99), uint8_t(180), uint8_t(80), uint8_t(126), uint8_t(54), uint8_t(45)},
- [9]uint8_t{uint8_t(85), uint8_t(126), uint8_t(47), uint8_t(87), uint8_t(176), uint8_t(51), uint8_t(41), uint8_t(20), uint8_t(32)},
- [9]uint8_t{uint8_t(101), uint8_t(75), uint8_t(128), uint8_t(139), uint8_t(118), uint8_t(146), uint8_t(116), uint8_t(128), uint8_t(85)},
- [9]uint8_t{uint8_t(56), uint8_t(41), uint8_t(15), uint8_t(176), uint8_t(236), uint8_t(85), uint8_t(37), uint8_t(9), uint8_t(62)},
- [9]uint8_t{uint8_t(71), uint8_t(30), uint8_t(17), uint8_t(119), uint8_t(118), uint8_t(255), uint8_t(17), uint8_t(18), uint8_t(138)},
- [9]uint8_t{uint8_t(101), uint8_t(38), uint8_t(60), uint8_t(138), uint8_t(55), uint8_t(70), uint8_t(43), uint8_t(26), uint8_t(142)},
- [9]uint8_t{uint8_t(146), uint8_t(36), uint8_t(19), uint8_t(30), uint8_t(171), uint8_t(255), uint8_t(97), uint8_t(27), uint8_t(20)},
- [9]uint8_t{uint8_t(138), uint8_t(45), uint8_t(61), uint8_t(62), uint8_t(219), uint8_t(1), uint8_t(81), uint8_t(188), uint8_t(64)},
- [9]uint8_t{uint8_t(32), uint8_t(41), uint8_t(20), uint8_t(117), uint8_t(151), uint8_t(142), uint8_t(20), uint8_t(21), uint8_t(163)},
- [9]uint8_t{uint8_t(112), uint8_t(19), uint8_t(12), uint8_t(61), uint8_t(195), uint8_t(128), uint8_t(48), uint8_t(4), uint8_t(24)}}} /* tree_dec.c:181:22 */
+var kBModesProba = [10][10][9]uint8_t{{
+ {uint8_t(231), uint8_t(120), uint8_t(48), uint8_t(89), uint8_t(115), uint8_t(113), uint8_t(120), uint8_t(152), uint8_t(112)},
+ {uint8_t(152), uint8_t(179), uint8_t(64), uint8_t(126), uint8_t(170), uint8_t(118), uint8_t(46), uint8_t(70), uint8_t(95)},
+ {uint8_t(175), uint8_t(69), uint8_t(143), uint8_t(80), uint8_t(85), uint8_t(82), uint8_t(72), uint8_t(155), uint8_t(103)},
+ {uint8_t(56), uint8_t(58), uint8_t(10), uint8_t(171), uint8_t(218), uint8_t(189), uint8_t(17), uint8_t(13), uint8_t(152)},
+ {uint8_t(114), uint8_t(26), uint8_t(17), uint8_t(163), uint8_t(44), uint8_t(195), uint8_t(21), uint8_t(10), uint8_t(173)},
+ {uint8_t(121), uint8_t(24), uint8_t(80), uint8_t(195), uint8_t(26), uint8_t(62), uint8_t(44), uint8_t(64), uint8_t(85)},
+ {uint8_t(144), uint8_t(71), uint8_t(10), uint8_t(38), uint8_t(171), uint8_t(213), uint8_t(144), uint8_t(34), uint8_t(26)},
+ {uint8_t(170), uint8_t(46), uint8_t(55), uint8_t(19), uint8_t(136), uint8_t(160), uint8_t(33), uint8_t(206), uint8_t(71)},
+ {uint8_t(63), uint8_t(20), uint8_t(8), uint8_t(114), uint8_t(114), uint8_t(208), uint8_t(12), uint8_t(9), uint8_t(226)},
+ {uint8_t(81), uint8_t(40), uint8_t(11), uint8_t(96), uint8_t(182), uint8_t(84), uint8_t(29), uint8_t(16), uint8_t(36)}},
+ {{uint8_t(134), uint8_t(183), uint8_t(89), uint8_t(137), uint8_t(98), uint8_t(101), uint8_t(106), uint8_t(165), uint8_t(148)},
+ {uint8_t(72), uint8_t(187), uint8_t(100), uint8_t(130), uint8_t(157), uint8_t(111), uint8_t(32), uint8_t(75), uint8_t(80)},
+ {uint8_t(66), uint8_t(102), uint8_t(167), uint8_t(99), uint8_t(74), uint8_t(62), uint8_t(40), uint8_t(234), uint8_t(128)},
+ {uint8_t(41), uint8_t(53), uint8_t(9), uint8_t(178), uint8_t(241), uint8_t(141), uint8_t(26), uint8_t(8), uint8_t(107)},
+ {uint8_t(74), uint8_t(43), uint8_t(26), uint8_t(146), uint8_t(73), uint8_t(166), uint8_t(49), uint8_t(23), uint8_t(157)},
+ {uint8_t(65), uint8_t(38), uint8_t(105), uint8_t(160), uint8_t(51), uint8_t(52), uint8_t(31), uint8_t(115), uint8_t(128)},
+ {uint8_t(104), uint8_t(79), uint8_t(12), uint8_t(27), uint8_t(217), uint8_t(255), uint8_t(87), uint8_t(17), uint8_t(7)},
+ {uint8_t(87), uint8_t(68), uint8_t(71), uint8_t(44), uint8_t(114), uint8_t(51), uint8_t(15), uint8_t(186), uint8_t(23)},
+ {uint8_t(47), uint8_t(41), uint8_t(14), uint8_t(110), uint8_t(182), uint8_t(183), uint8_t(21), uint8_t(17), uint8_t(194)},
+ {uint8_t(66), uint8_t(45), uint8_t(25), uint8_t(102), uint8_t(197), uint8_t(189), uint8_t(23), uint8_t(18), uint8_t(22)}},
+ {{uint8_t(88), uint8_t(88), uint8_t(147), uint8_t(150), uint8_t(42), uint8_t(46), uint8_t(45), uint8_t(196), uint8_t(205)},
+ {uint8_t(43), uint8_t(97), uint8_t(183), uint8_t(117), uint8_t(85), uint8_t(38), uint8_t(35), uint8_t(179), uint8_t(61)},
+ {uint8_t(39), uint8_t(53), uint8_t(200), uint8_t(87), uint8_t(26), uint8_t(21), uint8_t(43), uint8_t(232), uint8_t(171)},
+ {uint8_t(56), uint8_t(34), uint8_t(51), uint8_t(104), uint8_t(114), uint8_t(102), uint8_t(29), uint8_t(93), uint8_t(77)},
+ {uint8_t(39), uint8_t(28), uint8_t(85), uint8_t(171), uint8_t(58), uint8_t(165), uint8_t(90), uint8_t(98), uint8_t(64)},
+ {uint8_t(34), uint8_t(22), uint8_t(116), uint8_t(206), uint8_t(23), uint8_t(34), uint8_t(43), uint8_t(166), uint8_t(73)},
+ {uint8_t(107), uint8_t(54), uint8_t(32), uint8_t(26), uint8_t(51), uint8_t(1), uint8_t(81), uint8_t(43), uint8_t(31)},
+ {uint8_t(68), uint8_t(25), uint8_t(106), uint8_t(22), uint8_t(64), uint8_t(171), uint8_t(36), uint8_t(225), uint8_t(114)},
+ {uint8_t(34), uint8_t(19), uint8_t(21), uint8_t(102), uint8_t(132), uint8_t(188), uint8_t(16), uint8_t(76), uint8_t(124)},
+ {uint8_t(62), uint8_t(18), uint8_t(78), uint8_t(95), uint8_t(85), uint8_t(57), uint8_t(50), uint8_t(48), uint8_t(51)}},
+ {{uint8_t(193), uint8_t(101), uint8_t(35), uint8_t(159), uint8_t(215), uint8_t(111), uint8_t(89), uint8_t(46), uint8_t(111)},
+ {uint8_t(60), uint8_t(148), uint8_t(31), uint8_t(172), uint8_t(219), uint8_t(228), uint8_t(21), uint8_t(18), uint8_t(111)},
+ {uint8_t(112), uint8_t(113), uint8_t(77), uint8_t(85), uint8_t(179), uint8_t(255), uint8_t(38), uint8_t(120), uint8_t(114)},
+ {uint8_t(40), uint8_t(42), uint8_t(1), uint8_t(196), uint8_t(245), uint8_t(209), uint8_t(10), uint8_t(25), uint8_t(109)},
+ {uint8_t(88), uint8_t(43), uint8_t(29), uint8_t(140), uint8_t(166), uint8_t(213), uint8_t(37), uint8_t(43), uint8_t(154)},
+ {uint8_t(61), uint8_t(63), uint8_t(30), uint8_t(155), uint8_t(67), uint8_t(45), uint8_t(68), uint8_t(1), uint8_t(209)},
+ {uint8_t(100), uint8_t(80), uint8_t(8), uint8_t(43), uint8_t(154), uint8_t(1), uint8_t(51), uint8_t(26), uint8_t(71)},
+ {uint8_t(142), uint8_t(78), uint8_t(78), uint8_t(16), uint8_t(255), uint8_t(128), uint8_t(34), uint8_t(197), uint8_t(171)},
+ {uint8_t(41), uint8_t(40), uint8_t(5), uint8_t(102), uint8_t(211), uint8_t(183), uint8_t(4), uint8_t(1), uint8_t(221)},
+ {uint8_t(51), uint8_t(50), uint8_t(17), uint8_t(168), uint8_t(209), uint8_t(192), uint8_t(23), uint8_t(25), uint8_t(82)}},
+ {{uint8_t(138), uint8_t(31), uint8_t(36), uint8_t(171), uint8_t(27), uint8_t(166), uint8_t(38), uint8_t(44), uint8_t(229)},
+ {uint8_t(67), uint8_t(87), uint8_t(58), uint8_t(169), uint8_t(82), uint8_t(115), uint8_t(26), uint8_t(59), uint8_t(179)},
+ {uint8_t(63), uint8_t(59), uint8_t(90), uint8_t(180), uint8_t(59), uint8_t(166), uint8_t(93), uint8_t(73), uint8_t(154)},
+ {uint8_t(40), uint8_t(40), uint8_t(21), uint8_t(116), uint8_t(143), uint8_t(209), uint8_t(34), uint8_t(39), uint8_t(175)},
+ {uint8_t(47), uint8_t(15), uint8_t(16), uint8_t(183), uint8_t(34), uint8_t(223), uint8_t(49), uint8_t(45), uint8_t(183)},
+ {uint8_t(46), uint8_t(17), uint8_t(33), uint8_t(183), uint8_t(6), uint8_t(98), uint8_t(15), uint8_t(32), uint8_t(183)},
+ {uint8_t(57), uint8_t(46), uint8_t(22), uint8_t(24), uint8_t(128), uint8_t(1), uint8_t(54), uint8_t(17), uint8_t(37)},
+ {uint8_t(65), uint8_t(32), uint8_t(73), uint8_t(115), uint8_t(28), uint8_t(128), uint8_t(23), uint8_t(128), uint8_t(205)},
+ {uint8_t(40), uint8_t(3), uint8_t(9), uint8_t(115), uint8_t(51), uint8_t(192), uint8_t(18), uint8_t(6), uint8_t(223)},
+ {uint8_t(87), uint8_t(37), uint8_t(9), uint8_t(115), uint8_t(59), uint8_t(77), uint8_t(64), uint8_t(21), uint8_t(47)}},
+ {{uint8_t(104), uint8_t(55), uint8_t(44), uint8_t(218), uint8_t(9), uint8_t(54), uint8_t(53), uint8_t(130), uint8_t(226)},
+ {uint8_t(64), uint8_t(90), uint8_t(70), uint8_t(205), uint8_t(40), uint8_t(41), uint8_t(23), uint8_t(26), uint8_t(57)},
+ {uint8_t(54), uint8_t(57), uint8_t(112), uint8_t(184), uint8_t(5), uint8_t(41), uint8_t(38), uint8_t(166), uint8_t(213)},
+ {uint8_t(30), uint8_t(34), uint8_t(26), uint8_t(133), uint8_t(152), uint8_t(116), uint8_t(10), uint8_t(32), uint8_t(134)},
+ {uint8_t(39), uint8_t(19), uint8_t(53), uint8_t(221), uint8_t(26), uint8_t(114), uint8_t(32), uint8_t(73), uint8_t(255)},
+ {uint8_t(31), uint8_t(9), uint8_t(65), uint8_t(234), uint8_t(2), uint8_t(15), uint8_t(1), uint8_t(118), uint8_t(73)},
+ {uint8_t(75), uint8_t(32), uint8_t(12), uint8_t(51), uint8_t(192), uint8_t(255), uint8_t(160), uint8_t(43), uint8_t(51)},
+ {uint8_t(88), uint8_t(31), uint8_t(35), uint8_t(67), uint8_t(102), uint8_t(85), uint8_t(55), uint8_t(186), uint8_t(85)},
+ {uint8_t(56), uint8_t(21), uint8_t(23), uint8_t(111), uint8_t(59), uint8_t(205), uint8_t(45), uint8_t(37), uint8_t(192)},
+ {uint8_t(55), uint8_t(38), uint8_t(70), uint8_t(124), uint8_t(73), uint8_t(102), uint8_t(1), uint8_t(34), uint8_t(98)}},
+ {{uint8_t(125), uint8_t(98), uint8_t(42), uint8_t(88), uint8_t(104), uint8_t(85), uint8_t(117), uint8_t(175), uint8_t(82)},
+ {uint8_t(95), uint8_t(84), uint8_t(53), uint8_t(89), uint8_t(128), uint8_t(100), uint8_t(113), uint8_t(101), uint8_t(45)},
+ {uint8_t(75), uint8_t(79), uint8_t(123), uint8_t(47), uint8_t(51), uint8_t(128), uint8_t(81), uint8_t(171), uint8_t(1)},
+ {uint8_t(57), uint8_t(17), uint8_t(5), uint8_t(71), uint8_t(102), uint8_t(57), uint8_t(53), uint8_t(41), uint8_t(49)},
+ {uint8_t(38), uint8_t(33), uint8_t(13), uint8_t(121), uint8_t(57), uint8_t(73), uint8_t(26), uint8_t(1), uint8_t(85)},
+ {uint8_t(41), uint8_t(10), uint8_t(67), uint8_t(138), uint8_t(77), uint8_t(110), uint8_t(90), uint8_t(47), uint8_t(114)},
+ {uint8_t(115), uint8_t(21), uint8_t(2), uint8_t(10), uint8_t(102), uint8_t(255), uint8_t(166), uint8_t(23), uint8_t(6)},
+ {uint8_t(101), uint8_t(29), uint8_t(16), uint8_t(10), uint8_t(85), uint8_t(128), uint8_t(101), uint8_t(196), uint8_t(26)},
+ {uint8_t(57), uint8_t(18), uint8_t(10), uint8_t(102), uint8_t(102), uint8_t(213), uint8_t(34), uint8_t(20), uint8_t(43)},
+ {uint8_t(117), uint8_t(20), uint8_t(15), uint8_t(36), uint8_t(163), uint8_t(128), uint8_t(68), uint8_t(1), uint8_t(26)}},
+ {{uint8_t(102), uint8_t(61), uint8_t(71), uint8_t(37), uint8_t(34), uint8_t(53), uint8_t(31), uint8_t(243), uint8_t(192)},
+ {uint8_t(69), uint8_t(60), uint8_t(71), uint8_t(38), uint8_t(73), uint8_t(119), uint8_t(28), uint8_t(222), uint8_t(37)},
+ {uint8_t(68), uint8_t(45), uint8_t(128), uint8_t(34), uint8_t(1), uint8_t(47), uint8_t(11), uint8_t(245), uint8_t(171)},
+ {uint8_t(62), uint8_t(17), uint8_t(19), uint8_t(70), uint8_t(146), uint8_t(85), uint8_t(55), uint8_t(62), uint8_t(70)},
+ {uint8_t(37), uint8_t(43), uint8_t(37), uint8_t(154), uint8_t(100), uint8_t(163), uint8_t(85), uint8_t(160), uint8_t(1)},
+ {uint8_t(63), uint8_t(9), uint8_t(92), uint8_t(136), uint8_t(28), uint8_t(64), uint8_t(32), uint8_t(201), uint8_t(85)},
+ {uint8_t(75), uint8_t(15), uint8_t(9), uint8_t(9), uint8_t(64), uint8_t(255), uint8_t(184), uint8_t(119), uint8_t(16)},
+ {uint8_t(86), uint8_t(6), uint8_t(28), uint8_t(5), uint8_t(64), uint8_t(255), uint8_t(25), uint8_t(248), uint8_t(1)},
+ {uint8_t(56), uint8_t(8), uint8_t(17), uint8_t(132), uint8_t(137), uint8_t(255), uint8_t(55), uint8_t(116), uint8_t(128)},
+ {uint8_t(58), uint8_t(15), uint8_t(20), uint8_t(82), uint8_t(135), uint8_t(57), uint8_t(26), uint8_t(121), uint8_t(40)}},
+ {{uint8_t(164), uint8_t(50), uint8_t(31), uint8_t(137), uint8_t(154), uint8_t(133), uint8_t(25), uint8_t(35), uint8_t(218)},
+ {uint8_t(51), uint8_t(103), uint8_t(44), uint8_t(131), uint8_t(131), uint8_t(123), uint8_t(31), uint8_t(6), uint8_t(158)},
+ {uint8_t(86), uint8_t(40), uint8_t(64), uint8_t(135), uint8_t(148), uint8_t(224), uint8_t(45), uint8_t(183), uint8_t(128)},
+ {uint8_t(22), uint8_t(26), uint8_t(17), uint8_t(131), uint8_t(240), uint8_t(154), uint8_t(14), uint8_t(1), uint8_t(209)},
+ {uint8_t(45), uint8_t(16), uint8_t(21), uint8_t(91), uint8_t(64), uint8_t(222), uint8_t(7), uint8_t(1), uint8_t(197)},
+ {uint8_t(56), uint8_t(21), uint8_t(39), uint8_t(155), uint8_t(60), uint8_t(138), uint8_t(23), uint8_t(102), uint8_t(213)},
+ {uint8_t(83), uint8_t(12), uint8_t(13), uint8_t(54), uint8_t(192), uint8_t(255), uint8_t(68), uint8_t(47), uint8_t(28)},
+ {uint8_t(85), uint8_t(26), uint8_t(85), uint8_t(85), uint8_t(128), uint8_t(128), uint8_t(32), uint8_t(146), uint8_t(171)},
+ {uint8_t(18), uint8_t(11), uint8_t(7), uint8_t(63), uint8_t(144), uint8_t(171), uint8_t(4), uint8_t(4), uint8_t(246)},
+ {uint8_t(35), uint8_t(27), uint8_t(10), uint8_t(146), uint8_t(174), uint8_t(171), uint8_t(12), uint8_t(26), uint8_t(128)}},
+ {{uint8_t(190), uint8_t(80), uint8_t(35), uint8_t(99), uint8_t(180), uint8_t(80), uint8_t(126), uint8_t(54), uint8_t(45)},
+ {uint8_t(85), uint8_t(126), uint8_t(47), uint8_t(87), uint8_t(176), uint8_t(51), uint8_t(41), uint8_t(20), uint8_t(32)},
+ {uint8_t(101), uint8_t(75), uint8_t(128), uint8_t(139), uint8_t(118), uint8_t(146), uint8_t(116), uint8_t(128), uint8_t(85)},
+ {uint8_t(56), uint8_t(41), uint8_t(15), uint8_t(176), uint8_t(236), uint8_t(85), uint8_t(37), uint8_t(9), uint8_t(62)},
+ {uint8_t(71), uint8_t(30), uint8_t(17), uint8_t(119), uint8_t(118), uint8_t(255), uint8_t(17), uint8_t(18), uint8_t(138)},
+ {uint8_t(101), uint8_t(38), uint8_t(60), uint8_t(138), uint8_t(55), uint8_t(70), uint8_t(43), uint8_t(26), uint8_t(142)},
+ {uint8_t(146), uint8_t(36), uint8_t(19), uint8_t(30), uint8_t(171), uint8_t(255), uint8_t(97), uint8_t(27), uint8_t(20)},
+ {uint8_t(138), uint8_t(45), uint8_t(61), uint8_t(62), uint8_t(219), uint8_t(1), uint8_t(81), uint8_t(188), uint8_t(64)},
+ {uint8_t(32), uint8_t(41), uint8_t(20), uint8_t(117), uint8_t(151), uint8_t(142), uint8_t(20), uint8_t(21), uint8_t(163)},
+ {uint8_t(112), uint8_t(19), uint8_t(12), uint8_t(61), uint8_t(195), uint8_t(128), uint8_t(48), uint8_t(4), uint8_t(24)}}} /* tree_dec.c:181:22 */
func VP8ResetProba(tls *libc.TLS, proba uintptr) { /* tree_dec.c:284:6: */
- libc.Xmemset(tls, (proba /* &.segments_ */), int32(255), uint64(unsafe.Sizeof([3]uint8_t{})))
+ libc.Xmemset(tls, proba, int32(255), uint64(unsafe.Sizeof([3]uint8_t{})))
// proba->bands_[][] is initialized later
}
func ParseIntraMode(tls *libc.TLS, br uintptr, dec uintptr, mb_x int32) { /* tree_dec.c:289:13: */
- var top uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).intra_t_ + uintptr((4 * mb_x)))
+ var top uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).intra_t_ + uintptr(4*mb_x)
var left uintptr = dec + 2816 /* &.intra_l_ */
- var block uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).mb_data_ + uintptr(mb_x)*800)
+ var block uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).mb_data_ + uintptr(mb_x)*800
// Note: we don't save segment map (yet), as we don't expect
// to decode more than 1 keyframe.
if (*VP8Decoder)(unsafe.Pointer(dec)).segment_hdr_.update_map_ != 0 {
// Hardcoded tree parsing
(*VP8MBData)(unsafe.Pointer(block)).segment_ = func() uint8 {
- if !(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer((dec + 1192 /* &.proba_ */) /* &.segments_ */)))) != 0) {
- return uint8(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer((dec + 1192 /* &.proba_ */) /* &.segments_ */ + 1)))))
+ if !(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(dec + 1192)))) != 0) {
+ return uint8(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(dec + 1192 + 1)))))
}
- return (uint8(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer((dec + 1192 /* &.proba_ */) /* &.segments_ */ + 2)))) + 2))
+ return uint8(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(dec + 1192 + 2)))) + 2)
}()
} else {
(*VP8MBData)(unsafe.Pointer(block)).segment_ = uint8_t(0) // default for intra
@@ -8706,23 +8446,23 @@ func ParseIntraMode(tls *libc.TLS, br uintptr, dec uintptr, mb_x int32) { /* tre
// Hardcoded 16x16 intra-mode decision tree.
var ymode int32
if VP8GetBit(tls, br, 156) != 0 {
- ymode = (func() int32 {
+ ymode = func() int32 {
if VP8GetBit(tls, br, 128) != 0 {
return TM_PRED
}
return H_PRED
- }())
+ }()
} else {
- ymode = (func() int32 {
+ ymode = func() int32 {
if VP8GetBit(tls, br, 163) != 0 {
return V_PRED
}
return DC_PRED
- }())
+ }()
}
- *(*uint8_t)(unsafe.Pointer((block + 769 /* &.imodes_ */))) = uint8_t(ymode)
- libc.Xmemset(tls, top, ymode, (uint64(4) * uint64(unsafe.Sizeof(uint8_t(0)))))
- libc.Xmemset(tls, left, ymode, (uint64(4) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ *(*uint8_t)(unsafe.Pointer(block + 769)) = uint8_t(ymode)
+ libc.Xmemset(tls, top, ymode, uint64(4)*uint64(unsafe.Sizeof(uint8_t(0))))
+ libc.Xmemset(tls, left, ymode, uint64(4)*uint64(unsafe.Sizeof(uint8_t(0))))
} else {
var modes uintptr = block + 769 /* &.imodes_ */
var y int32
@@ -8730,16 +8470,16 @@ func ParseIntraMode(tls *libc.TLS, br uintptr, dec uintptr, mb_x int32) { /* tre
var ymode int32 = int32(*(*uint8_t)(unsafe.Pointer(left + uintptr(y))))
var x int32
for x = 0; x < 4; x++ {
- var prob uintptr = ((uintptr(unsafe.Pointer(&kBModesProba)) + uintptr(*(*uint8_t)(unsafe.Pointer(top + uintptr(x))))*90) + uintptr(ymode)*9)
+ var prob uintptr = uintptr(unsafe.Pointer(&kBModesProba)) + uintptr(*(*uint8_t)(unsafe.Pointer(top + uintptr(x))))*90 + uintptr(ymode)*9
// Generic tree-parsing
var i int32 = int32(kYModesIntra4[VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(prob))))])
for i > 0 {
- i = int32(kYModesIntra4[((2 * i) + VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(prob + uintptr(i))))))])
+ i = int32(kYModesIntra4[2*i+VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(prob + uintptr(i)))))])
}
ymode = -i
*(*uint8_t)(unsafe.Pointer(top + uintptr(x))) = uint8_t(ymode)
}
- libc.Xmemcpy(tls, modes, top, (uint64(4) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ libc.Xmemcpy(tls, modes, top, uint64(4)*uint64(unsafe.Sizeof(uint8_t(0))))
modes += uintptr(4)
*(*uint8_t)(unsafe.Pointer(left + uintptr(y))) = uint8_t(ymode)
}
@@ -8774,140 +8514,140 @@ func VP8ParseIntraModeRow(tls *libc.TLS, br uintptr, dec uintptr) int32 { /* tre
//------------------------------------------------------------------------------
// Paragraph 13
-var CoeffsUpdateProba = [4][8][3][11]uint8_t{[8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+var CoeffsUpdateProba = [4][8][3][11]uint8_t{{
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(176), uint8_t(246), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(223), uint8_t(241), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(249), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(176), uint8_t(246), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(223), uint8_t(241), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(249), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(244), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(234), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(244), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(234), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(246), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(239), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(246), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(239), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(248), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(251), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(248), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(251), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(251), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(251), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(250), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(250), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(217), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(225), uint8_t(252), uint8_t(241), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(234), uint8_t(250), uint8_t(241), uint8_t(250), uint8_t(253), uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {
+ {{uint8_t(217), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(225), uint8_t(252), uint8_t(241), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(234), uint8_t(250), uint8_t(241), uint8_t(250), uint8_t(253), uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(223), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(238), uint8_t(253), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(223), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(238), uint8_t(253), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(248), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(249), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(248), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(249), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(247), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(247), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(186), uint8_t(251), uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(234), uint8_t(251), uint8_t(244), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(251), uint8_t(251), uint8_t(243), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {
+ {{uint8_t(186), uint8_t(251), uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(234), uint8_t(251), uint8_t(244), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(251), uint8_t(251), uint8_t(243), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(236), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(251), uint8_t(253), uint8_t(253), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(236), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(251), uint8_t(253), uint8_t(253), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(250), uint8_t(254), uint8_t(252), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(248), uint8_t(254), uint8_t(249), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {
+ {{uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(250), uint8_t(254), uint8_t(252), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(248), uint8_t(254), uint8_t(249), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(246), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(252), uint8_t(254), uint8_t(251), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(246), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(252), uint8_t(254), uint8_t(251), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(248), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(253), uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(248), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(253), uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(251), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(245), uint8_t(251), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(253), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(251), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(245), uint8_t(251), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(253), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(251), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(252), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(251), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(252), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(249), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(249), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
},
} /* tree_dec.c:372:5 */
@@ -8920,7 +8660,7 @@ var kBands = [17]uint8_t{
} /* tree_dec.c:509:22 */
func VP8ParseProba(tls *libc.TLS, br uintptr, dec uintptr) { /* tree_dec.c:514:6: */
- var proba uintptr = (dec + 1192 /* &.proba_ */)
+ var proba uintptr = dec + 1192
var t int32
var b int32
var c int32
@@ -8930,17 +8670,17 @@ func VP8ParseProba(tls *libc.TLS, br uintptr, dec uintptr) { /* tree_dec.c:514:6
for c = 0; c < NUM_CTX; c++ {
for p = 0; p < NUM_PROBAS; p++ {
var v int32
- if VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer((((uintptr(unsafe.Pointer(&CoeffsUpdateProba)) + uintptr(t)*264) + uintptr(b)*33) + uintptr(c)*11) + uintptr(p))))) != 0 {
+ if VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&CoeffsUpdateProba)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))))) != 0 {
v = int32(VP8GetValue(tls, br, 8))
} else {
- v = int32(*(*uint8_t)(unsafe.Pointer((((uintptr(unsafe.Pointer(&CoeffsProba0)) + uintptr(t)*264) + uintptr(b)*33) + uintptr(c)*11) + uintptr(p))))
+ v = int32(*(*uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&CoeffsProba0)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))))
}
- *(*uint8_t)(unsafe.Pointer(((((proba + 3 /* &.bands_ */) + uintptr(t)*264) + uintptr(b)*33) /* &.probas_ */ + uintptr(c)*11) + uintptr(p))) = uint8_t(v)
+ *(*uint8_t)(unsafe.Pointer(proba + 3 + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))) = uint8_t(v)
}
}
}
- for b = 0; b < (16 + 1); b++ {
- *(*uintptr)(unsafe.Pointer(((proba + 1064 /* &.bands_ptr_ */) + uintptr(t)*136) + uintptr(b)*8)) = (((proba + 3 /* &.bands_ */) + uintptr(t)*264) + uintptr(kBands[b])*33)
+ for b = 0; b < 16+1; b++ {
+ *(*uintptr)(unsafe.Pointer(proba + 1064 + uintptr(t)*136 + uintptr(b)*8)) = proba + 3 + uintptr(t)*264 + uintptr(kBands[b])*33
}
}
(*VP8Decoder)(unsafe.Pointer(dec)).use_skip_proba_ = int32(VP8GetValue(tls, br, 1))
@@ -8966,28 +8706,28 @@ func VP8ParseProba(tls *libc.TLS, br uintptr, dec uintptr) { /* tree_dec.c:514:6
//------------------------------------------------------------------------------
func WebPGetDecoderVersion(tls *libc.TLS) int32 { /* vp8_dec.c:25:5: */
- return (((int32(1) << 16) | (int32(2) << 8)) | 2)
+ return int32(1)<<16 | int32(2)<<8 | 2
}
//------------------------------------------------------------------------------
// Signature and pointer-to-function for GetCoeffs() variants below.
-type GetCoeffsFunc = uintptr /* vp8_dec.c:32:13 */
-var GetCoeffs GetCoeffsFunc = (uintptr(0)) /* vp8_dec.c:35:31 */
+type GetCoeffsFunc = uintptr /* vp8_dec.c:32:13 */
+var GetCoeffs GetCoeffsFunc = uintptr(0) /* vp8_dec.c:35:31 */
//------------------------------------------------------------------------------
// VP8Decoder
func SetOk(tls *libc.TLS, dec uintptr) { /* vp8_dec.c:42:13: */
(*VP8Decoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OK
- (*VP8Decoder)(unsafe.Pointer(dec)).error_msg_ = (ts + 117) /* "OK" */
+ (*VP8Decoder)(unsafe.Pointer(dec)).error_msg_ = ts + 117 /* "OK" */
}
func VP8InitIoInternal(tls *libc.TLS, io uintptr, version int32) int32 { /* vp8_dec.c:47:5: */
- if ((version) >> 8) != (int32((0x0209)) >> 8) {
+ if version>>8 != int32(0x0209)>>8 {
return 0 // mismatch error
}
- if io != (uintptr(0)) {
+ if io != uintptr(0) {
libc.Xmemset(tls, io, 0, uint64(unsafe.Sizeof(VP8Io{})))
}
return 1
@@ -8995,9 +8735,9 @@ func VP8InitIoInternal(tls *libc.TLS, io uintptr, version int32) int32 { /* vp8_
func VP8New(tls *libc.TLS) uintptr { /* vp8_dec.c:57:11: */
var dec uintptr = WebPSafeCalloc(tls, 1, uint64(unsafe.Sizeof(VP8Decoder{})))
- if dec != (uintptr(0)) {
+ if dec != uintptr(0) {
SetOk(tls, dec)
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Init})).f(tls, (dec + 152 /* &.worker_ */))
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Init})).f(tls, dec+152 /* &.worker_ */)
(*VP8Decoder)(unsafe.Pointer(dec)).ready_ = 0
(*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_ = uint32_t(0)
InitGetCoeffs(tls)
@@ -9013,17 +8753,17 @@ func VP8Status(tls *libc.TLS, dec uintptr) VP8StatusCode { /* vp8_dec.c:69:15: *
}
func VP8StatusMessage(tls *libc.TLS, dec uintptr) uintptr { /* vp8_dec.c:74:11: */
- if dec == (uintptr(0)) {
- return (ts + 120) /* "no object" */
+ if dec == uintptr(0) {
+ return ts + 120 /* "no object" */
}
if !(int32((*VP8Decoder)(unsafe.Pointer(dec)).error_msg_) != 0) {
- return (ts + 117) /* "OK" */
+ return ts + 117 /* "OK" */
}
return (*VP8Decoder)(unsafe.Pointer(dec)).error_msg_
}
func VP8Delete(tls *libc.TLS, dec uintptr) { /* vp8_dec.c:80:6: */
- if dec != (uintptr(0)) {
+ if dec != uintptr(0) {
VP8Clear(tls, dec)
WebPSafeFree(tls, dec)
}
@@ -9042,36 +8782,36 @@ func VP8SetError(tls *libc.TLS, dec uintptr, error VP8StatusCode, msg uintptr) i
//------------------------------------------------------------------------------
func VP8CheckSignature(tls *libc.TLS, data uintptr, data_size size_t) int32 { /* vp8_dec.c:100:5: */
- return (libc.Bool32((((data_size >= uint64(3)) && (int32(*(*uint8_t)(unsafe.Pointer(data))) == 0x9d)) && (int32(*(*uint8_t)(unsafe.Pointer(data + 1))) == 0x01)) && (int32(*(*uint8_t)(unsafe.Pointer(data + 2))) == 0x2a)))
+ return libc.Bool32(data_size >= uint64(3) && int32(*(*uint8_t)(unsafe.Pointer(data))) == 0x9d && int32(*(*uint8_t)(unsafe.Pointer(data + 1))) == 0x01 && int32(*(*uint8_t)(unsafe.Pointer(data + 2))) == 0x2a)
}
func VP8GetInfo(tls *libc.TLS, data uintptr, data_size size_t, chunk_size size_t, width uintptr, height uintptr) int32 { /* vp8_dec.c:105:5: */
- if (data == (uintptr(0))) || (data_size < uint64(10)) {
+ if data == uintptr(0) || data_size < uint64(10) {
return 0 // not enough data
}
// check signature
- if !(VP8CheckSignature(tls, (data+uintptr(3)), (data_size-uint64(3))) != 0) {
+ if !(VP8CheckSignature(tls, data+uintptr(3), data_size-uint64(3)) != 0) {
return 0 // Wrong signature.
} else {
- var bits uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(data))) | (int32(*(*uint8_t)(unsafe.Pointer(data + 1))) << 8)) | (int32(*(*uint8_t)(unsafe.Pointer(data + 2))) << 16)))
- var key_frame int32 = libc.BoolInt32(!((bits & uint32_t(1)) != 0))
- var w int32 = (((int32(*(*uint8_t)(unsafe.Pointer(data + 7))) << 8) | int32(*(*uint8_t)(unsafe.Pointer(data + 6)))) & 0x3fff)
- var h int32 = (((int32(*(*uint8_t)(unsafe.Pointer(data + 9))) << 8) | int32(*(*uint8_t)(unsafe.Pointer(data + 8)))) & 0x3fff)
+ var bits uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(data))) | int32(*(*uint8_t)(unsafe.Pointer(data + 1)))<<8 | int32(*(*uint8_t)(unsafe.Pointer(data + 2)))<<16)
+ var key_frame int32 = libc.BoolInt32(!(bits&uint32_t(1) != 0))
+ var w int32 = (int32(*(*uint8_t)(unsafe.Pointer(data + 7)))<<8 | int32(*(*uint8_t)(unsafe.Pointer(data + 6)))) & 0x3fff
+ var h int32 = (int32(*(*uint8_t)(unsafe.Pointer(data + 9)))<<8 | int32(*(*uint8_t)(unsafe.Pointer(data + 8)))) & 0x3fff
if !(key_frame != 0) { // Not a keyframe.
return 0
}
- if ((bits >> 1) & uint32_t(7)) > uint32_t(3) {
+ if bits>>1&uint32_t(7) > uint32_t(3) {
return 0 // unknown profile
}
- if !(((bits >> 4) & uint32_t(1)) != 0) {
+ if !(bits>>4&uint32_t(1) != 0) {
return 0 // first frame is invisible!
}
- if (size_t(bits >> 5)) >= chunk_size { // partition_length
+ if size_t(bits>>5) >= chunk_size { // partition_length
return 0 // inconsistent size information.
}
- if (w == 0) || (h == 0) {
+ if w == 0 || h == 0 {
return 0 // We don't support both width and height to be zero.
}
@@ -9095,8 +8835,8 @@ func ResetSegmentHeader(tls *libc.TLS, hdr uintptr) { /* vp8_dec.c:150:13: */
(*VP8SegmentHeader)(unsafe.Pointer(hdr)).use_segment_ = 0
(*VP8SegmentHeader)(unsafe.Pointer(hdr)).update_map_ = 0
(*VP8SegmentHeader)(unsafe.Pointer(hdr)).absolute_delta_ = 1
- libc.Xmemset(tls, (hdr + 12 /* &.quantizer_ */), 0, uint64(unsafe.Sizeof([4]int8_t{})))
- libc.Xmemset(tls, (hdr + 16 /* &.filter_strength_ */), 0, uint64(unsafe.Sizeof([4]int8_t{})))
+ libc.Xmemset(tls, hdr+12, 0, uint64(unsafe.Sizeof([4]int8_t{})))
+ libc.Xmemset(tls, hdr+16, 0, uint64(unsafe.Sizeof([4]int8_t{})))
}
// Paragraph 9.3
@@ -9109,7 +8849,7 @@ func ParseSegmentHeader(tls *libc.TLS, br uintptr, hdr uintptr, proba uintptr) i
var s int32
(*VP8SegmentHeader)(unsafe.Pointer(hdr)).absolute_delta_ = int32(VP8GetValue(tls, br, 1))
for s = 0; s < NUM_MB_SEGMENTS; s++ {
- *(*int8_t)(unsafe.Pointer((hdr + 12 /* &.quantizer_ */) + uintptr(s))) = func() int8 {
+ *(*int8_t)(unsafe.Pointer(hdr + 12 + uintptr(s))) = func() int8 {
if VP8GetValue(tls, br, 1) != 0 {
return int8(VP8GetSignedValue(tls, br, 7))
}
@@ -9117,7 +8857,7 @@ func ParseSegmentHeader(tls *libc.TLS, br uintptr, hdr uintptr, proba uintptr) i
}()
}
for s = 0; s < NUM_MB_SEGMENTS; s++ {
- *(*int8_t)(unsafe.Pointer((hdr + 16 /* &.filter_strength_ */) + uintptr(s))) = func() int8 {
+ *(*int8_t)(unsafe.Pointer(hdr + 16 + uintptr(s))) = func() int8 {
if VP8GetValue(tls, br, 1) != 0 {
return int8(VP8GetSignedValue(tls, br, 6))
}
@@ -9128,7 +8868,7 @@ func ParseSegmentHeader(tls *libc.TLS, br uintptr, hdr uintptr, proba uintptr) i
if (*VP8SegmentHeader)(unsafe.Pointer(hdr)).update_map_ != 0 {
var s int32
for s = 0; s < MB_FEATURE_TREE_PROBS; s++ {
- *(*uint8_t)(unsafe.Pointer((proba /* &.segments_ */) + uintptr(s))) = func() uint8 {
+ *(*uint8_t)(unsafe.Pointer(proba + uintptr(s))) = func() uint8 {
if VP8GetValue(tls, br, 1) != 0 {
return uint8(VP8GetValue(tls, br, 8))
}
@@ -9152,33 +8892,33 @@ func ParseSegmentHeader(tls *libc.TLS, br uintptr, hdr uintptr, proba uintptr) i
// is returned, and this is an unrecoverable error.
// If the partitions were positioned ok, VP8_STATUS_OK is returned.
func ParsePartitions(tls *libc.TLS, dec uintptr, buf uintptr, size size_t) VP8StatusCode { /* vp8_dec.c:201:22: */
- var br uintptr = (dec + 16 /* &.br_ */)
+ var br uintptr = dec + 16
var sz uintptr = buf
- var buf_end uintptr = (buf + uintptr(size))
+ var buf_end uintptr = buf + uintptr(size)
var part_start uintptr
var size_left size_t = size
var last_part size_t
var p size_t
- (*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_ = (uint32_t((int32(1) << VP8GetValue(tls, br, 2)) - 1))
+ (*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_ = uint32_t(int32(1)<<VP8GetValue(tls, br, 2) - 1)
last_part = size_t((*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_)
- if size < (uint64(3) * last_part) {
+ if size < uint64(3)*last_part {
// we can't even read the sizes with sz[]! That's a failure.
return VP8_STATUS_NOT_ENOUGH_DATA
}
- part_start = (buf + uintptr((last_part * uint64(3))))
- size_left = size_left - (last_part * uint64(3))
+ part_start = buf + uintptr(last_part*uint64(3))
+ size_left = size_left - last_part*uint64(3)
for p = uint64(0); p < last_part; p++ {
- var psize size_t = (size_t((int32(*(*uint8_t)(unsafe.Pointer(sz))) | (int32(*(*uint8_t)(unsafe.Pointer(sz + 1))) << 8)) | (int32(*(*uint8_t)(unsafe.Pointer(sz + 2))) << 16)))
+ var psize size_t = size_t(int32(*(*uint8_t)(unsafe.Pointer(sz))) | int32(*(*uint8_t)(unsafe.Pointer(sz + 1)))<<8 | int32(*(*uint8_t)(unsafe.Pointer(sz + 2)))<<16)
if psize > size_left {
psize = size_left
}
- VP8InitBitReader(tls, ((dec + 440 /* &.parts_ */) + uintptr(p)*48), part_start, psize)
+ VP8InitBitReader(tls, dec+440+uintptr(p)*48, part_start, psize)
part_start += uintptr(psize)
- size_left = size_left - (psize)
+ size_left = size_left - psize
sz += uintptr(3)
}
- VP8InitBitReader(tls, ((dec + 440 /* &.parts_ */) + uintptr(last_part)*48), part_start, size_left)
+ VP8InitBitReader(tls, dec+440+uintptr(last_part)*48, part_start, size_left)
if part_start < buf_end {
return VP8_STATUS_OK
}
@@ -9187,7 +8927,7 @@ func ParsePartitions(tls *libc.TLS, dec uintptr, buf uintptr, size size_t) VP8St
// Paragraph 9.4
func ParseFilterHeader(tls *libc.TLS, br uintptr, dec uintptr) int32 { /* vp8_dec.c:233:12: */
- var hdr uintptr = (dec + 80 /* &.filter_hdr_ */)
+ var hdr uintptr = dec + 80
(*VP8FilterHeader)(unsafe.Pointer(hdr)).simple_ = int32(VP8GetValue(tls, br, 1))
(*VP8FilterHeader)(unsafe.Pointer(hdr)).level_ = int32(VP8GetValue(tls, br, 6))
(*VP8FilterHeader)(unsafe.Pointer(hdr)).sharpness_ = int32(VP8GetValue(tls, br, 3))
@@ -9197,12 +8937,12 @@ func ParseFilterHeader(tls *libc.TLS, br uintptr, dec uintptr) int32 { /* vp8_de
var i int32
for i = 0; i < NUM_REF_LF_DELTAS; i++ {
if VP8GetValue(tls, br, 1) != 0 {
- *(*int32)(unsafe.Pointer((hdr + 16 /* &.ref_lf_delta_ */) + uintptr(i)*4)) = VP8GetSignedValue(tls, br, 6)
+ *(*int32)(unsafe.Pointer(hdr + 16 + uintptr(i)*4)) = VP8GetSignedValue(tls, br, 6)
}
}
for i = 0; i < NUM_MODE_LF_DELTAS; i++ {
if VP8GetValue(tls, br, 1) != 0 {
- *(*int32)(unsafe.Pointer((hdr + 32 /* &.mode_lf_delta_ */) + uintptr(i)*4)) = VP8GetSignedValue(tls, br, 6)
+ *(*int32)(unsafe.Pointer(hdr + 32 + uintptr(i)*4)) = VP8GetSignedValue(tls, br, 6)
}
}
}
@@ -9230,62 +8970,62 @@ func VP8GetHeaders(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* vp8_dec.c:
var br uintptr
var status VP8StatusCode
- if dec == (uintptr(0)) {
+ if dec == uintptr(0) {
return 0
}
SetOk(tls, dec)
- if io == (uintptr(0)) {
+ if io == uintptr(0) {
return VP8SetError(tls, dec, VP8_STATUS_INVALID_PARAM,
- (ts + 130) /* "null VP8Io passe..." */)
+ ts+130)
}
buf = (*VP8Io)(unsafe.Pointer(io)).data
buf_size = (*VP8Io)(unsafe.Pointer(io)).data_size
if buf_size < uint64(4) {
return VP8SetError(tls, dec, VP8_STATUS_NOT_ENOUGH_DATA,
- (ts + 167) /* "Truncated header..." */)
+ ts+167)
}
// Paragraph 9.1
{
- var bits uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(buf))) | (int32(*(*uint8_t)(unsafe.Pointer(buf + 1))) << 8)) | (int32(*(*uint8_t)(unsafe.Pointer(buf + 2))) << 16)))
- frm_hdr = (dec + 64 /* &.frm_hdr_ */)
- (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).key_frame_ = libc.BoolUint8(!((bits & uint32_t(1)) != 0))
- (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).profile_ = (uint8_t((bits >> 1) & uint32_t(7)))
- (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).show_ = (uint8_t((bits >> 4) & uint32_t(1)))
- (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).partition_length_ = (bits >> 5)
+ var bits uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(buf))) | int32(*(*uint8_t)(unsafe.Pointer(buf + 1)))<<8 | int32(*(*uint8_t)(unsafe.Pointer(buf + 2)))<<16)
+ frm_hdr = dec + 64
+ (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).key_frame_ = libc.BoolUint8(!(bits&uint32_t(1) != 0))
+ (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).profile_ = uint8_t(bits >> 1 & uint32_t(7))
+ (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).show_ = uint8_t(bits >> 4 & uint32_t(1))
+ (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).partition_length_ = bits >> 5
if int32((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).profile_) > 3 {
return VP8SetError(tls, dec, VP8_STATUS_BITSTREAM_ERROR,
- (ts + 185) /* "Incorrect keyfra..." */)
+ ts+185)
}
if !(int32((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).show_) != 0) {
return VP8SetError(tls, dec, VP8_STATUS_UNSUPPORTED_FEATURE,
- (ts + 216) /* "Frame not displa..." */)
+ ts+216)
}
buf += uintptr(3)
- buf_size = buf_size - (uint64(3))
+ buf_size = buf_size - uint64(3)
}
- pic_hdr = (dec + 72 /* &.pic_hdr_ */)
+ pic_hdr = dec + 72
if (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).key_frame_ != 0 {
// Paragraph 9.2
if buf_size < uint64(7) {
return VP8SetError(tls, dec, VP8_STATUS_NOT_ENOUGH_DATA,
- (ts + 239) /* "cannot parse pic..." */)
+ ts+239)
}
if !(VP8CheckSignature(tls, buf, buf_size) != 0) {
return VP8SetError(tls, dec, VP8_STATUS_BITSTREAM_ERROR,
- (ts + 267) /* "Bad code word" */)
+ ts+267)
}
- (*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).width_ = (uint16_t(((int32(*(*uint8_t)(unsafe.Pointer(buf + 4))) << 8) | int32(*(*uint8_t)(unsafe.Pointer(buf + 3)))) & 0x3fff))
- (*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).xscale_ = (uint8_t(int32(*(*uint8_t)(unsafe.Pointer(buf + 4))) >> 6)) // ratio: 1, 5/4 5/3 or 2
- (*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).height_ = (uint16_t(((int32(*(*uint8_t)(unsafe.Pointer(buf + 6))) << 8) | int32(*(*uint8_t)(unsafe.Pointer(buf + 5)))) & 0x3fff))
- (*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).yscale_ = (uint8_t(int32(*(*uint8_t)(unsafe.Pointer(buf + 6))) >> 6))
+ (*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).width_ = uint16_t((int32(*(*uint8_t)(unsafe.Pointer(buf + 4)))<<8 | int32(*(*uint8_t)(unsafe.Pointer(buf + 3)))) & 0x3fff)
+ (*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).xscale_ = uint8_t(int32(*(*uint8_t)(unsafe.Pointer(buf + 4))) >> 6) // ratio: 1, 5/4 5/3 or 2
+ (*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).height_ = uint16_t((int32(*(*uint8_t)(unsafe.Pointer(buf + 6)))<<8 | int32(*(*uint8_t)(unsafe.Pointer(buf + 5)))) & 0x3fff)
+ (*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).yscale_ = uint8_t(int32(*(*uint8_t)(unsafe.Pointer(buf + 6))) >> 6)
buf += uintptr(7)
- buf_size = buf_size - (uint64(7))
+ buf_size = buf_size - uint64(7)
- (*VP8Decoder)(unsafe.Pointer(dec)).mb_w_ = ((int32((*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).width_) + 15) >> 4)
- (*VP8Decoder)(unsafe.Pointer(dec)).mb_h_ = ((int32((*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).height_) + 15) >> 4)
+ (*VP8Decoder)(unsafe.Pointer(dec)).mb_w_ = (int32((*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).width_) + 15) >> 4
+ (*VP8Decoder)(unsafe.Pointer(dec)).mb_h_ = (int32((*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).height_) + 15) >> 4
// Setup default output area (can be later modified during io->setup())
(*VP8Io)(unsafe.Pointer(io)).width = int32((*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).width_)
@@ -9305,38 +9045,38 @@ func VP8GetHeaders(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* vp8_dec.c:
(*VP8Io)(unsafe.Pointer(io)).mb_w = (*VP8Io)(unsafe.Pointer(io)).width // for soundness
(*VP8Io)(unsafe.Pointer(io)).mb_h = (*VP8Io)(unsafe.Pointer(io)).height // ditto
- VP8ResetProba(tls, (dec + 1192 /* &.proba_ */))
- ResetSegmentHeader(tls, (dec + 128 /* &.segment_hdr_ */))
+ VP8ResetProba(tls, dec+1192)
+ ResetSegmentHeader(tls, dec+128)
}
// Check if we have all the partition #0 available, and initialize dec->br_
// to read this partition (and this partition only).
if size_t((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).partition_length_) > buf_size {
return VP8SetError(tls, dec, VP8_STATUS_NOT_ENOUGH_DATA,
- (ts + 281) /* "bad partition le..." */)
+ ts+281)
}
- br = (dec + 16 /* &.br_ */)
+ br = dec + 16
VP8InitBitReader(tls, br, buf, uint64((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).partition_length_))
buf += uintptr((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).partition_length_)
- buf_size = buf_size - (size_t((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).partition_length_))
+ buf_size = buf_size - size_t((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).partition_length_)
if (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).key_frame_ != 0 {
(*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).colorspace_ = uint8_t(VP8GetValue(tls, br, 1))
(*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).clamp_type_ = uint8_t(VP8GetValue(tls, br, 1))
}
- if !(ParseSegmentHeader(tls, br, (dec+128 /* &.segment_hdr_ */), (dec+1192 /* &.proba_ */)) != 0) {
+ if !(ParseSegmentHeader(tls, br, dec+128, dec+1192) != 0) {
return VP8SetError(tls, dec, VP8_STATUS_BITSTREAM_ERROR,
- (ts + 302) /* "cannot parse seg..." */)
+ ts+302)
}
// Filter specs
if !(ParseFilterHeader(tls, br, dec) != 0) {
return VP8SetError(tls, dec, VP8_STATUS_BITSTREAM_ERROR,
- (ts + 330) /* "cannot parse fil..." */)
+ ts+330)
}
status = ParsePartitions(tls, dec, buf, buf_size)
if status != VP8_STATUS_OK {
- return VP8SetError(tls, dec, status, (ts + 357) /* "cannot parse par..." */)
+ return VP8SetError(tls, dec, status, ts+357)
}
// quantizer change
@@ -9345,7 +9085,7 @@ func VP8GetHeaders(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* vp8_dec.c:
// Frame buffer marking
if !(int32((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).key_frame_) != 0) {
return VP8SetError(tls, dec, VP8_STATUS_UNSUPPORTED_FEATURE,
- (ts + 381) /* "Not a key frame." */)
+ ts+381)
}
VP8GetValue(tls, br, 1) // ignore the value of update_proba_
@@ -9376,26 +9116,26 @@ func GetLargeValue(tls *libc.TLS, br uintptr, p uintptr) int32 { /* vp8_dec.c:40
if !(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + 4)))) != 0) {
v = 2
} else {
- v = (3 + VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + 5)))))
+ v = 3 + VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + 5))))
}
} else {
if !(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + 6)))) != 0) {
if !(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + 7)))) != 0) {
- v = (5 + VP8GetBit(tls, br, 159))
+ v = 5 + VP8GetBit(tls, br, 159)
} else {
- v = (7 + (2 * VP8GetBit(tls, br, 165)))
- v = v + (VP8GetBit(tls, br, 145))
+ v = 7 + 2*VP8GetBit(tls, br, 165)
+ v = v + VP8GetBit(tls, br, 145)
}
} else {
var tab uintptr
var bit1 int32 = VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + 8))))
- var bit0 int32 = VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((9 + bit1))))))
- var cat int32 = ((2 * bit1) + bit0)
+ var bit0 int32 = VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(9+bit1)))))
+ var cat int32 = 2*bit1 + bit0
v = 0
for tab = kCat3456[cat]; *(*uint8_t)(unsafe.Pointer(tab)) != 0; tab++ {
v = v + (v + VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(tab)))))
}
- v = v + (3 + (int32(8) << cat))
+ v = v + (3 + int32(8)<<cat)
}
}
return v
@@ -9403,28 +9143,28 @@ func GetLargeValue(tls *libc.TLS, br uintptr, p uintptr) int32 { /* vp8_dec.c:40
// Returns the position of the last non-zero coeff plus one
func GetCoeffsFast(tls *libc.TLS, br uintptr, prob uintptr, ctx int32, dq uintptr, n int32, out uintptr) int32 { /* vp8_dec.c:439:12: */
- var p uintptr = (*(*uintptr)(unsafe.Pointer(prob + uintptr(n)*8)) /* &.probas_ */ + uintptr(ctx)*11)
+ var p uintptr = *(*uintptr)(unsafe.Pointer(prob + uintptr(n)*8)) + uintptr(ctx)*11
for ; n < 16; n++ {
if !(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p)))) != 0) {
return n // previous coeff was last non-zero coeff
}
for !(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + 1)))) != 0) { // sequence of zero coeffs
- p = (*(*uintptr)(unsafe.Pointer(prob + uintptr(libc.PreIncInt32(&n, 1))*8)) /* &.probas_ */)
+ p = *(*uintptr)(unsafe.Pointer(prob + uintptr(libc.PreIncInt32(&n, 1))*8))
if n == 16 {
return 16
}
}
{ // non zero coeff
- var p_ctx uintptr = (*(*uintptr)(unsafe.Pointer(prob + uintptr((n+1))*8)) /* &.probas_ */)
+ var p_ctx uintptr = *(*uintptr)(unsafe.Pointer(prob + uintptr(n+1)*8))
var v int32
if !(VP8GetBit(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + 2)))) != 0) {
v = 1
- p = (p_ctx + 1*11)
+ p = p_ctx + 1*11
} else {
v = GetLargeValue(tls, br, p)
- p = (p_ctx + 2*11)
+ p = p_ctx + 2*11
}
- *(*int16_t)(unsafe.Pointer(out + uintptr(kZigzag[n])*2)) = (int16_t(VP8GetSigned(tls, br, v) * *(*int32)(unsafe.Pointer(dq + uintptr((libc.Bool32(n > 0)))*4))))
+ *(*int16_t)(unsafe.Pointer(out + uintptr(kZigzag[n])*2)) = int16_t(VP8GetSigned(tls, br, v) * *(*int32)(unsafe.Pointer(dq + uintptr(libc.Bool32(n > 0))*4)))
}
}
@@ -9434,28 +9174,28 @@ func GetCoeffsFast(tls *libc.TLS, br uintptr, prob uintptr, ctx int32, dq uintpt
// This version of GetCoeffs() uses VP8GetBitAlt() which is an alternate version
// of VP8GetBitAlt() targeting specific platforms.
func GetCoeffsAlt(tls *libc.TLS, br uintptr, prob uintptr, ctx int32, dq uintptr, n int32, out uintptr) int32 { /* vp8_dec.c:469:12: */
- var p uintptr = (*(*uintptr)(unsafe.Pointer(prob + uintptr(n)*8)) /* &.probas_ */ + uintptr(ctx)*11)
+ var p uintptr = *(*uintptr)(unsafe.Pointer(prob + uintptr(n)*8)) + uintptr(ctx)*11
for ; n < 16; n++ {
if !(VP8GetBitAlt(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p)))) != 0) {
return n // previous coeff was last non-zero coeff
}
for !(VP8GetBitAlt(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + 1)))) != 0) { // sequence of zero coeffs
- p = (*(*uintptr)(unsafe.Pointer(prob + uintptr(libc.PreIncInt32(&n, 1))*8)) /* &.probas_ */)
+ p = *(*uintptr)(unsafe.Pointer(prob + uintptr(libc.PreIncInt32(&n, 1))*8))
if n == 16 {
return 16
}
}
{ // non zero coeff
- var p_ctx uintptr = (*(*uintptr)(unsafe.Pointer(prob + uintptr((n+1))*8)) /* &.probas_ */)
+ var p_ctx uintptr = *(*uintptr)(unsafe.Pointer(prob + uintptr(n+1)*8))
var v int32
if !(VP8GetBitAlt(tls, br, int32(*(*uint8_t)(unsafe.Pointer(p + 2)))) != 0) {
v = 1
- p = (p_ctx + 1*11)
+ p = p_ctx + 1*11
} else {
v = GetLargeValue(tls, br, p)
- p = (p_ctx + 2*11)
+ p = p_ctx + 2*11
}
- *(*int16_t)(unsafe.Pointer(out + uintptr(kZigzag[n])*2)) = (int16_t(VP8GetSigned(tls, br, v) * *(*int32)(unsafe.Pointer(dq + uintptr((libc.Bool32(n > 0)))*4))))
+ *(*int16_t)(unsafe.Pointer(out + uintptr(kZigzag[n])*2)) = int16_t(VP8GetSigned(tls, br, v) * *(*int32)(unsafe.Pointer(dq + uintptr(libc.Bool32(n > 0))*4)))
}
}
@@ -9463,7 +9203,7 @@ func GetCoeffsAlt(tls *libc.TLS, br uintptr, prob uintptr, ctx int32, dq uintptr
}
func InitGetCoeffs(tls *libc.TLS) { /* vp8_dec.c:497:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if InitGetCoeffs_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -9475,9 +9215,9 @@ func InitGetCoeffs(tls *libc.TLS) { /* vp8_dec.c:497:1: */
var InitGetCoeffs_body_last_cpuinfo_used VP8CPUInfo = 0 /* vp8_dec.c:497:1 */
func InitGetCoeffs_body(tls *libc.TLS) { /* vp8_dec.c:497:1: */
- if (VP8GetCPUInfo != (uintptr(0))) && ((*struct {
+ if VP8GetCPUInfo != uintptr(0) && (*struct {
f func(*libc.TLS, CPUFeature) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8GetCPUInfo})).f(tls, kSlowSSSE3) != 0) {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8GetCPUInfo})).f(tls, kSlowSSSE3) != 0 {
GetCoeffs = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr, int32, uintptr) int32
}{GetCoeffsAlt}))
@@ -9490,7 +9230,7 @@ func InitGetCoeffs_body(tls *libc.TLS) { /* vp8_dec.c:497:1: */
func NzCodeBits(tls *libc.TLS, nz_coeffs uint32_t, nz int32, dc_nz int32) uint32_t { /* vp8_dec.c:505:29: */
nz_coeffs <<= 2
- nz_coeffs = nz_coeffs | (func() uint32 {
+ nz_coeffs = nz_coeffs | func() uint32 {
if nz > 3 {
return uint32(3)
}
@@ -9500,7 +9240,7 @@ func NzCodeBits(tls *libc.TLS, nz_coeffs uint32_t, nz int32, dc_nz int32) uint32
}
return uint32(dc_nz)
}()
- }())
+ }()
return nz_coeffs
}
@@ -9508,12 +9248,12 @@ func ParseResiduals(tls *libc.TLS, dec uintptr, mb uintptr, token_br uintptr) in
bp := tls.Alloc(32)
defer tls.Free(32)
- var bands uintptr = ((dec + 1192 /* &.proba_ */) + 1064 /* &.bands_ptr_ */)
+ var bands uintptr = dec + 1192 + 1064
var ac_proba uintptr
- var block uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).mb_data_ + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).mb_x_)*800)
- var q uintptr = ((dec + 1060 /* &.dqm_ */) + uintptr((*VP8MBData)(unsafe.Pointer(block)).segment_)*32)
+ var block uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).mb_data_ + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).mb_x_)*800
+ var q uintptr = dec + 1060 + uintptr((*VP8MBData)(unsafe.Pointer(block)).segment_)*32
var dst uintptr = block /* &.coeffs_ */
- var left_mb uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).mb_info_ - uintptr(1)*2)
+ var left_mb uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).mb_info_ - uintptr(1)*2
var tnz uint8_t
var lnz uint8_t
var non_zero_y uint32_t = uint32_t(0)
@@ -9525,77 +9265,77 @@ func ParseResiduals(tls *libc.TLS, dec uintptr, mb uintptr, token_br uintptr) in
var out_l_nz uint32_t
var first int32
- libc.Xmemset(tls, dst, 0, (uint64(384) * uint64(unsafe.Sizeof(int16_t(0)))))
+ libc.Xmemset(tls, dst, 0, uint64(384)*uint64(unsafe.Sizeof(int16_t(0))))
if !(int32((*VP8MBData)(unsafe.Pointer(block)).is_i4x4_) != 0) { // parse DC
*(*[16]int16_t)(unsafe.Pointer(bp /* dc */)) = [16]int16_t{0: int16(0)}
- var ctx int32 = (int32((*VP8MB)(unsafe.Pointer(mb)).nz_dc_) + int32((*VP8MB)(unsafe.Pointer(left_mb)).nz_dc_))
+ var ctx int32 = int32((*VP8MB)(unsafe.Pointer(mb)).nz_dc_) + int32((*VP8MB)(unsafe.Pointer(left_mb)).nz_dc_)
var nz int32 = (*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr, int32, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{GetCoeffs})).f(tls, token_br, (bands + 1*136), ctx, (q + 8 /* &.y2_mat_ */), 0, (bp) /* &dc[0] */)
- (*VP8MB)(unsafe.Pointer(mb)).nz_dc_ = libc.AssignPtrUint8((left_mb + 1 /* &.nz_dc_ */), (uint8_t(libc.Bool32(nz > 0))))
+ })(unsafe.Pointer(&struct{ uintptr }{GetCoeffs})).f(tls, token_br, bands+1*136, ctx, q+8 /* &.y2_mat_ */, 0, bp /* &dc[0] */)
+ (*VP8MB)(unsafe.Pointer(mb)).nz_dc_ = libc.AssignPtrUint8(left_mb+1, uint8_t(libc.Bool32(nz > 0)))
if nz > 1 { // more than just the DC -> perform the full transform
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8TransformWHT})).f(tls, (bp) /* &dc[0] */, dst)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8TransformWHT})).f(tls, bp /* &dc[0] */, dst)
} else { // only DC is non-zero -> inlined simplified transform
var i int32
- var dc0 int32 = ((int32(*(*int16_t)(unsafe.Pointer((bp) /* &dc[0] */))) + 3) >> 3)
- for i = 0; i < (16 * 16); i = i + (16) {
+ var dc0 int32 = (int32(*(*int16_t)(unsafe.Pointer(bp))) + 3) >> 3
+ for i = 0; i < 16*16; i = i + 16 {
*(*int16_t)(unsafe.Pointer(dst + uintptr(i)*2)) = int16_t(dc0)
}
}
first = 1
- ac_proba = (bands)
+ ac_proba = bands
} else {
first = 0
- ac_proba = (bands + 3*136)
+ ac_proba = bands + 3*136
}
- tnz = (uint8_t(int32((*VP8MB)(unsafe.Pointer(mb)).nz_) & 0x0f))
- lnz = (uint8_t(int32((*VP8MB)(unsafe.Pointer(left_mb)).nz_) & 0x0f))
+ tnz = uint8_t(int32((*VP8MB)(unsafe.Pointer(mb)).nz_) & 0x0f)
+ lnz = uint8_t(int32((*VP8MB)(unsafe.Pointer(left_mb)).nz_) & 0x0f)
for y = 0; y < 4; y++ {
- var l int32 = (int32(lnz) & 1)
+ var l int32 = int32(lnz) & 1
var nz_coeffs uint32_t = uint32_t(0)
for x = 0; x < 4; x++ {
- var ctx int32 = (l + (int32(tnz) & 1))
+ var ctx int32 = l + int32(tnz)&1
var nz int32 = (*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr, int32, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{GetCoeffs})).f(tls, token_br, ac_proba, ctx, (q /* &.y1_mat_ */), first, dst)
- l = (libc.Bool32(nz > first))
- tnz = (uint8_t((int32(tnz) >> 1) | (l << 7)))
- nz_coeffs = NzCodeBits(tls, nz_coeffs, nz, (libc.Bool32(int32(*(*int16_t)(unsafe.Pointer(dst))) != 0)))
- dst += 2 * (uintptr(16))
+ })(unsafe.Pointer(&struct{ uintptr }{GetCoeffs})).f(tls, token_br, ac_proba, ctx, q /* &.y1_mat_ */, first, dst)
+ l = libc.Bool32(nz > first)
+ tnz = uint8_t(int32(tnz)>>1 | l<<7)
+ nz_coeffs = NzCodeBits(tls, nz_coeffs, nz, libc.Bool32(int32(*(*int16_t)(unsafe.Pointer(dst))) != 0))
+ dst += 2 * uintptr(16)
}
tnz >>= 4
- lnz = (uint8_t((int32(lnz) >> 1) | (l << 7)))
- non_zero_y = ((non_zero_y << 8) | nz_coeffs)
+ lnz = uint8_t(int32(lnz)>>1 | l<<7)
+ non_zero_y = non_zero_y<<8 | nz_coeffs
}
out_t_nz = uint32_t(tnz)
- out_l_nz = (uint32_t(int32(lnz) >> 4))
+ out_l_nz = uint32_t(int32(lnz) >> 4)
- for ch = 0; ch < 4; ch = ch + (2) {
+ for ch = 0; ch < 4; ch = ch + 2 {
var nz_coeffs uint32_t = uint32_t(0)
- tnz = (uint8_t(int32((*VP8MB)(unsafe.Pointer(mb)).nz_) >> (4 + ch)))
- lnz = (uint8_t(int32((*VP8MB)(unsafe.Pointer(left_mb)).nz_) >> (4 + ch)))
+ tnz = uint8_t(int32((*VP8MB)(unsafe.Pointer(mb)).nz_) >> (4 + ch))
+ lnz = uint8_t(int32((*VP8MB)(unsafe.Pointer(left_mb)).nz_) >> (4 + ch))
for y = 0; y < 2; y++ {
- var l int32 = (int32(lnz) & 1)
+ var l int32 = int32(lnz) & 1
for x = 0; x < 2; x++ {
- var ctx int32 = (l + (int32(tnz) & 1))
+ var ctx int32 = l + int32(tnz)&1
var nz int32 = (*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr, int32, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{GetCoeffs})).f(tls, token_br, (bands + 2*136), ctx, (q + 16 /* &.uv_mat_ */), 0, dst)
- l = (libc.Bool32(nz > 0))
- tnz = (uint8_t((int32(tnz) >> 1) | (l << 3)))
- nz_coeffs = NzCodeBits(tls, nz_coeffs, nz, (libc.Bool32(int32(*(*int16_t)(unsafe.Pointer(dst))) != 0)))
- dst += 2 * (uintptr(16))
+ })(unsafe.Pointer(&struct{ uintptr }{GetCoeffs})).f(tls, token_br, bands+2*136, ctx, q+16 /* &.uv_mat_ */, 0, dst)
+ l = libc.Bool32(nz > 0)
+ tnz = uint8_t(int32(tnz)>>1 | l<<3)
+ nz_coeffs = NzCodeBits(tls, nz_coeffs, nz, libc.Bool32(int32(*(*int16_t)(unsafe.Pointer(dst))) != 0))
+ dst += 2 * uintptr(16)
}
tnz >>= 2
- lnz = (uint8_t((int32(lnz) >> 1) | (l << 5)))
+ lnz = uint8_t(int32(lnz)>>1 | l<<5)
}
// Note: we don't really need the per-4x4 details for U/V blocks.
- non_zero_uv = non_zero_uv | (nz_coeffs << (4 * ch))
- out_t_nz = out_t_nz | (uint32_t((int32(tnz) << 4) << ch))
- out_l_nz = out_l_nz | (uint32_t((int32(lnz) & 0xf0) << ch))
+ non_zero_uv = non_zero_uv | nz_coeffs<<(4*ch)
+ out_t_nz = out_t_nz | uint32_t(int32(tnz)<<4<<ch)
+ out_l_nz = out_l_nz | uint32_t(int32(lnz)&0xf0<<ch)
}
(*VP8MB)(unsafe.Pointer(mb)).nz_ = uint8_t(out_t_nz)
(*VP8MB)(unsafe.Pointer(left_mb)).nz_ = uint8_t(out_l_nz)
@@ -9607,22 +9347,22 @@ func ParseResiduals(tls *libc.TLS, dec uintptr, mb uintptr, token_br uintptr) in
// than three non-zero coeffs (code < 2). This is to avoid dithering flat and
// empty blocks.
(*VP8MBData)(unsafe.Pointer(block)).dither_ = func() uint8 {
- if (non_zero_uv & uint32_t(0xaaaa)) != 0 {
+ if non_zero_uv&uint32_t(0xaaaa) != 0 {
return uint8(0)
}
return uint8((*VP8QuantMatrix)(unsafe.Pointer(q)).dither_)
}()
- return libc.BoolInt32(!((non_zero_y | non_zero_uv) != 0)) // will be used for further optimization
+ return libc.BoolInt32(!(non_zero_y|non_zero_uv != 0)) // will be used for further optimization
}
//------------------------------------------------------------------------------
// Main loop
func VP8DecodeMB(tls *libc.TLS, dec uintptr, token_br uintptr) int32 { /* vp8_dec.c:605:5: */
- var left uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).mb_info_ - uintptr(1)*2)
- var mb uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).mb_info_ + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).mb_x_)*2)
- var block uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).mb_data_ + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).mb_x_)*800)
+ var left uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).mb_info_ - uintptr(1)*2
+ var mb uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).mb_info_ + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).mb_x_)*2
+ var block uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).mb_data_ + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).mb_x_)*800
var skip int32
if (*VP8Decoder)(unsafe.Pointer(dec)).use_skip_proba_ != 0 {
skip = int32((*VP8MBData)(unsafe.Pointer(block)).skip_)
@@ -9633,9 +9373,9 @@ func VP8DecodeMB(tls *libc.TLS, dec uintptr, token_br uintptr) int32 { /* vp8_de
if !(skip != 0) {
skip = ParseResiduals(tls, dec, mb, token_br)
} else {
- (*VP8MB)(unsafe.Pointer(left)).nz_ = libc.AssignPtrUint8((mb /* &.nz_ */), uint8_t(0))
+ (*VP8MB)(unsafe.Pointer(left)).nz_ = libc.AssignPtrUint8(mb, uint8_t(0))
if !(int32((*VP8MBData)(unsafe.Pointer(block)).is_i4x4_) != 0) {
- (*VP8MB)(unsafe.Pointer(left)).nz_dc_ = libc.AssignPtrUint8((mb + 1 /* &.nz_dc_ */), uint8_t(0))
+ (*VP8MB)(unsafe.Pointer(left)).nz_dc_ = libc.AssignPtrUint8(mb+1, uint8_t(0))
}
(*VP8MBData)(unsafe.Pointer(block)).non_zero_y_ = uint32_t(0)
(*VP8MBData)(unsafe.Pointer(block)).non_zero_uv_ = uint32_t(0)
@@ -9643,47 +9383,47 @@ func VP8DecodeMB(tls *libc.TLS, dec uintptr, token_br uintptr) int32 { /* vp8_de
}
if (*VP8Decoder)(unsafe.Pointer(dec)).filter_type_ > 0 { // store filter info
- var finfo uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).f_info_ + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).mb_x_)*4)
- *(*VP8FInfo)(unsafe.Pointer(finfo)) = *(*VP8FInfo)(unsafe.Pointer(((dec + 2924 /* &.fstrengths_ */) + uintptr((*VP8MBData)(unsafe.Pointer(block)).segment_)*8) + uintptr((*VP8MBData)(unsafe.Pointer(block)).is_i4x4_)*4))
- *(*uint8_t)(unsafe.Pointer((finfo + 2 /* &.f_inner_ */))) |= uint8_t((libc.BoolInt32(!(skip != 0))))
+ var finfo uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).f_info_ + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).mb_x_)*4
+ *(*VP8FInfo)(unsafe.Pointer(finfo)) = *(*VP8FInfo)(unsafe.Pointer(dec + 2924 + uintptr((*VP8MBData)(unsafe.Pointer(block)).segment_)*8 + uintptr((*VP8MBData)(unsafe.Pointer(block)).is_i4x4_)*4))
+ *(*uint8_t)(unsafe.Pointer(finfo + 2)) |= uint8_t(libc.BoolInt32(!(skip != 0)))
}
return libc.BoolInt32(!((*VP8BitReader)(unsafe.Pointer(token_br)).eof_ != 0))
}
func VP8InitScanline(tls *libc.TLS, dec uintptr) { /* vp8_dec.c:632:6: */
- var left uintptr = ((*VP8Decoder)(unsafe.Pointer(dec)).mb_info_ - uintptr(1)*2)
+ var left uintptr = (*VP8Decoder)(unsafe.Pointer(dec)).mb_info_ - uintptr(1)*2
(*VP8MB)(unsafe.Pointer(left)).nz_ = uint8_t(0)
(*VP8MB)(unsafe.Pointer(left)).nz_dc_ = uint8_t(0)
- libc.Xmemset(tls, (dec + 2816 /* &.intra_l_ */), B_DC_PRED, uint64(unsafe.Sizeof([4]uint8_t{})))
+ libc.Xmemset(tls, dec+2816, B_DC_PRED, uint64(unsafe.Sizeof([4]uint8_t{})))
(*VP8Decoder)(unsafe.Pointer(dec)).mb_x_ = 0
}
func ParseFrame(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* vp8_dec.c:640:12: */
for (*VP8Decoder)(unsafe.Pointer(dec)).mb_y_ = 0; (*VP8Decoder)(unsafe.Pointer(dec)).mb_y_ < (*VP8Decoder)(unsafe.Pointer(dec)).br_mb_y_; (*VP8Decoder)(unsafe.Pointer(dec)).mb_y_++ {
// Parse bitstream for this row.
- var token_br uintptr = ((dec + 440 /* &.parts_ */) + uintptr((uint32_t((*VP8Decoder)(unsafe.Pointer(dec)).mb_y_)&(*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_))*48)
- if !(VP8ParseIntraModeRow(tls, (dec+16 /* &.br_ */), dec) != 0) {
+ var token_br uintptr = dec + 440 + uintptr(uint32_t((*VP8Decoder)(unsafe.Pointer(dec)).mb_y_)&(*VP8Decoder)(unsafe.Pointer(dec)).num_parts_minus_one_)*48
+ if !(VP8ParseIntraModeRow(tls, dec+16, dec) != 0) {
return VP8SetError(tls, dec, VP8_STATUS_NOT_ENOUGH_DATA,
- (ts + 398) /* "Premature end-of..." */)
+ ts+398)
}
for ; (*VP8Decoder)(unsafe.Pointer(dec)).mb_x_ < (*VP8Decoder)(unsafe.Pointer(dec)).mb_w_; (*VP8Decoder)(unsafe.Pointer(dec)).mb_x_++ {
if !(VP8DecodeMB(tls, dec, token_br) != 0) {
return VP8SetError(tls, dec, VP8_STATUS_NOT_ENOUGH_DATA,
- (ts + 439) /* "Premature end-of..." */)
+ ts+439)
}
}
VP8InitScanline(tls, dec) // Prepare for next scanline
// Reconstruct, filter and emit the row.
if !(VP8ProcessRow(tls, dec, io) != 0) {
- return VP8SetError(tls, dec, VP8_STATUS_USER_ABORT, (ts + 474) /* "Output aborted." */)
+ return VP8SetError(tls, dec, VP8_STATUS_USER_ABORT, ts+474)
}
}
if (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ > 0 {
if !((*struct {
f func(*libc.TLS, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Sync})).f(tls, (dec+152 /* &.worker_ */)) != 0) {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Sync})).f(tls, dec+152) != 0) {
return 0
}
}
@@ -9694,12 +9434,12 @@ func ParseFrame(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* vp8_dec.c:640
// Main entry point
func VP8Decode(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* vp8_dec.c:670:5: */
var ok int32 = 0
- if dec == (uintptr(0)) {
+ if dec == uintptr(0) {
return 0
}
- if io == (uintptr(0)) {
+ if io == uintptr(0) {
return VP8SetError(tls, dec, VP8_STATUS_INVALID_PARAM,
- (ts + 490) /* "NULL VP8Io param..." */)
+ ts+490)
}
if !((*VP8Decoder)(unsafe.Pointer(dec)).ready_ != 0) {
@@ -9709,7 +9449,7 @@ func VP8Decode(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* vp8_dec.c:670:
}
// Finish setting up the decoding parameter. Will call io->setup().
- ok = (libc.Bool32(VP8EnterCritical(tls, dec, io) == VP8_STATUS_OK))
+ ok = libc.Bool32(VP8EnterCritical(tls, dec, io) == VP8_STATUS_OK)
if ok != 0 { // good to go.
// Will allocate memory and prepare everything.
if ok != 0 {
@@ -9722,7 +9462,7 @@ func VP8Decode(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* vp8_dec.c:670:
}
// Exit.
- ok = ok & (VP8ExitCritical(tls, dec, io))
+ ok = ok & VP8ExitCritical(tls, dec, io)
}
if !(ok != 0) {
@@ -9735,15 +9475,15 @@ func VP8Decode(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* vp8_dec.c:670:
}
func VP8Clear(tls *libc.TLS, dec uintptr) { /* vp8_dec.c:709:6: */
- if dec == (uintptr(0)) {
+ if dec == uintptr(0) {
return
}
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).End})).f(tls, (dec + 152 /* &.worker_ */))
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).End})).f(tls, dec+152 /* &.worker_ */)
WebPDeallocateAlphaMemory(tls, dec)
WebPSafeFree(tls, (*VP8Decoder)(unsafe.Pointer(dec)).mem_)
- (*VP8Decoder)(unsafe.Pointer(dec)).mem_ = (uintptr(0))
+ (*VP8Decoder)(unsafe.Pointer(dec)).mem_ = uintptr(0)
(*VP8Decoder)(unsafe.Pointer(dec)).mem_size_ = uint64(0)
- libc.Xmemset(tls, (dec + 16 /* &.br_ */), 0, uint64(unsafe.Sizeof(VP8BitReader{})))
+ libc.Xmemset(tls, dec+16, 0, uint64(unsafe.Sizeof(VP8BitReader{})))
(*VP8Decoder)(unsafe.Pointer(dec)).ready_ = 0
}
@@ -10322,20 +10062,20 @@ func PixOrCopyCreateLiteral(tls *libc.TLS, argb uint32_t) PixOrCopy { /* backwar
}
func PixOrCopyIsLiteral(tls *libc.TLS, p uintptr) int32 { /* backward_references_enc.h:73:24: */
- return (libc.Bool32(int32((*PixOrCopy)(unsafe.Pointer(p)).mode) == kLiteral))
+ return libc.Bool32(int32((*PixOrCopy)(unsafe.Pointer(p)).mode) == kLiteral)
}
func PixOrCopyIsCacheIdx(tls *libc.TLS, p uintptr) int32 { /* backward_references_enc.h:77:24: */
- return (libc.Bool32(int32((*PixOrCopy)(unsafe.Pointer(p)).mode) == kCacheIdx))
+ return libc.Bool32(int32((*PixOrCopy)(unsafe.Pointer(p)).mode) == kCacheIdx)
}
func PixOrCopyIsCopy(tls *libc.TLS, p uintptr) int32 { /* backward_references_enc.h:81:24: */
- return (libc.Bool32(int32((*PixOrCopy)(unsafe.Pointer(p)).mode) == kCopy))
+ return libc.Bool32(int32((*PixOrCopy)(unsafe.Pointer(p)).mode) == kCopy)
}
func PixOrCopyLiteral(tls *libc.TLS, p uintptr, component int32) uint32_t { /* backward_references_enc.h:85:29: */
- return (((*PixOrCopy)(unsafe.Pointer(p)).argb_or_distance >> (component * 8)) & uint32_t(0xff))
+ return (*PixOrCopy)(unsafe.Pointer(p)).argb_or_distance >> (component * 8) & uint32_t(0xff)
}
func PixOrCopyLength(tls *libc.TLS, p uintptr) uint32_t { /* backward_references_enc.h:91:29: */
@@ -10377,11 +10117,11 @@ type VP8LHashChain = VP8LHashChain1 /* backward_references_enc.h:122:30 */
// release memory
func VP8LHashChainFindOffset(tls *libc.TLS, p uintptr, base_position int32) int32 { /* backward_references_enc.h:143:24: */
- return (int32(*(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ + uintptr(base_position)*4)) >> 12))
+ return int32(*(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ + uintptr(base_position)*4)) >> 12)
}
func VP8LHashChainFindLength(tls *libc.TLS, p uintptr, base_position int32) int32 { /* backward_references_enc.h:148:24: */
- return (int32(*(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ + uintptr(base_position)*4)) & ((uint32(1) << 12) - uint32(1))))
+ return int32(*(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ + uintptr(base_position)*4)) & (uint32(1)<<12 - uint32(1)))
}
func VP8LHashChainFindCopy(tls *libc.TLS, p uintptr, base_position int32, offset_ptr uintptr, length_ptr uintptr) { /* backward_references_enc.h:153:25: */
@@ -10423,7 +10163,7 @@ type VP8LRefsCursor = struct {
// Returns true if cursor is pointing at a valid position.
func VP8LRefsCursorOk(tls *libc.TLS, c uintptr) int32 { /* backward_references_enc.h:198:24: */
- return (libc.Bool32((*VP8LRefsCursor)(unsafe.Pointer(c)).cur_pos != (uintptr(0))))
+ return libc.Bool32((*VP8LRefsCursor)(unsafe.Pointer(c)).cur_pos != uintptr(0))
}
// Move to next position, or NULL. Should not be called if !VP8LRefsCursorOk().
@@ -10488,12 +10228,12 @@ type VP8LHistogramSet = struct {
} /* histogram_enc.h:56:3 */
func VP8LHistogramNumCodes(tls *libc.TLS, palette_code_bits int32) int32 { /* histogram_enc.h:103:24: */
- return ((256 + 24) + (func() int32 {
+ return 256 + 24 + func() int32 {
if palette_code_bits > 0 {
- return (int32(1) << palette_code_bits)
+ return int32(1) << palette_code_bits
}
return 0
- }()))
+ }()
}
//------------------------------------------------------------------------------
@@ -10617,7 +10357,7 @@ type VP8LBundleColorMapFunc = uintptr /* lossless.h:244:14 */
// color mapping related functions.
func VP8GetARGBIndex(tls *libc.TLS, idx uint32_t) uint32_t { /* lossless_common.h:31:29: */
- return ((idx >> 8) & uint32_t(0xff))
+ return idx >> 8 & uint32_t(0xff)
}
func VP8GetAlphaIndex(tls *libc.TLS, idx uint8_t) uint8_t { /* lossless_common.h:35:28: */
@@ -10629,7 +10369,7 @@ func VP8GetARGBValue(tls *libc.TLS, val uint32_t) uint32_t { /* lossless_common.
}
func VP8GetAlphaValue(tls *libc.TLS, val uint32_t) uint8_t { /* lossless_common.h:43:28: */
- return (uint8_t((val >> 8) & uint32_t(0xff)))
+ return uint8_t(val >> 8 & uint32_t(0xff))
}
//------------------------------------------------------------------------------
@@ -10637,7 +10377,7 @@ func VP8GetAlphaValue(tls *libc.TLS, val uint32_t) uint8_t { /* lossless_common.
// Computes sampled size of 'size' when sampling using 'sampling bits'.
func VP8LSubSampleSize(tls *libc.TLS, size uint32_t, sampling_bits uint32_t) uint32_t { /* lossless_common.h:51:29: */
- return (((size + (uint32_t(int32(1) << sampling_bits))) - uint32_t(1)) >> sampling_bits)
+ return (size + uint32_t(int32(1)<<sampling_bits) - uint32_t(1)) >> sampling_bits
}
// Converts near lossless quality into max number of bits shaved off.
@@ -10648,7 +10388,7 @@ func VP8LNearLosslessBits(tls *libc.TLS, near_lossless_quality int32) int32 { /*
// 40..59 -> 3
// 20..39 -> 4
// 0..19 -> 5
- return (5 - (near_lossless_quality / 20))
+ return 5 - near_lossless_quality/20
}
type VP8LFastLog2SlowFunc = uintptr /* lossless_common.h:80:15 */
@@ -10680,17 +10420,17 @@ func VP8LFastSLog2(tls *libc.TLS, v uint32_t) float32 { /* lossless_common.h:89:
// while the extra bits are stored just as normal bits.
func VP8LPrefixEncodeBitsNoLUT(tls *libc.TLS, distance int32, code uintptr, extra_bits uintptr) { /* lossless_common.h:99:25: */
var highest_bit int32 = BitsLog2Floor(tls, uint32(libc.PreDecInt32(&distance, 1)))
- var second_highest_bit int32 = ((distance >> (highest_bit - 1)) & 1)
- *(*int32)(unsafe.Pointer(extra_bits)) = (highest_bit - 1)
- *(*int32)(unsafe.Pointer(code)) = ((2 * highest_bit) + second_highest_bit)
+ var second_highest_bit int32 = distance >> (highest_bit - 1) & 1
+ *(*int32)(unsafe.Pointer(extra_bits)) = highest_bit - 1
+ *(*int32)(unsafe.Pointer(code)) = 2*highest_bit + second_highest_bit
}
func VP8LPrefixEncodeNoLUT(tls *libc.TLS, distance int32, code uintptr, extra_bits uintptr, extra_bits_value uintptr) { /* lossless_common.h:107:25: */
var highest_bit int32 = BitsLog2Floor(tls, uint32(libc.PreDecInt32(&distance, 1)))
- var second_highest_bit int32 = ((distance >> (highest_bit - 1)) & 1)
- *(*int32)(unsafe.Pointer(extra_bits)) = (highest_bit - 1)
- *(*int32)(unsafe.Pointer(extra_bits_value)) = (distance & ((int32(1) << *(*int32)(unsafe.Pointer(extra_bits))) - 1))
- *(*int32)(unsafe.Pointer(code)) = ((2 * highest_bit) + second_highest_bit)
+ var second_highest_bit int32 = distance >> (highest_bit - 1) & 1
+ *(*int32)(unsafe.Pointer(extra_bits)) = highest_bit - 1
+ *(*int32)(unsafe.Pointer(extra_bits_value)) = distance & (int32(1)<<*(*int32)(unsafe.Pointer(extra_bits)) - 1)
+ *(*int32)(unsafe.Pointer(code)) = 2*highest_bit + second_highest_bit
}
type VP8LPrefixCode = struct {
@@ -10721,16 +10461,16 @@ func VP8LPrefixEncode(tls *libc.TLS, distance int32, code uintptr, extra_bits ui
// Sum of each component, mod 256.
func VP8LAddPixels(tls *libc.TLS, a uint32_t, b uint32_t) uint32_t { /* lossless_common.h:152:10: */
- var alpha_and_green uint32_t = ((a & 0xff00ff00) + (b & 0xff00ff00))
- var red_and_blue uint32_t = ((a & 0x00ff00ff) + (b & 0x00ff00ff))
- return ((alpha_and_green & 0xff00ff00) | (red_and_blue & 0x00ff00ff))
+ var alpha_and_green uint32_t = a&0xff00ff00 + b&0xff00ff00
+ var red_and_blue uint32_t = a&0x00ff00ff + b&0x00ff00ff
+ return alpha_and_green&0xff00ff00 | red_and_blue&0x00ff00ff
}
// Difference of each component, mod 256.
func VP8LSubPixels(tls *libc.TLS, a uint32_t, b uint32_t) uint32_t { /* lossless_common.h:160:10: */
- var alpha_and_green uint32_t = ((0x00ff00ff + (a & 0xff00ff00)) - (b & 0xff00ff00))
- var red_and_blue uint32_t = ((0xff00ff00 + (a & 0x00ff00ff)) - (b & 0x00ff00ff))
- return ((alpha_and_green & 0xff00ff00) | (red_and_blue & 0x00ff00ff))
+ var alpha_and_green uint32_t = 0x00ff00ff + a&0xff00ff00 - b&0xff00ff00
+ var red_and_blue uint32_t = 0xff00ff00 + a&0x00ff00ff - b&0x00ff00ff
+ return alpha_and_green&0xff00ff00 | red_and_blue&0x00ff00ff
}
// Copyright 2012 Google Inc. All Rights Reserved.
@@ -10775,7 +10515,7 @@ var kCodeLengthRepeatOffsets = [3]uint8_t{uint8_t(3), uint8_t(3), uint8_t(11)} /
type HuffIndex = uint32 /* vp8l_dec.c:47:3 */
var kAlphabetSize = [5]uint16_t{
- (uint16_t(256 + 24)),
+ uint16_t(256 + 24),
uint16_t(256), uint16_t(256), uint16_t(256),
uint16_t(40),
} /* vp8l_dec.c:49:23 */
@@ -10812,32 +10552,32 @@ var kCodeToPlane = [120]uint8_t{
// All values computed for 8-bit first level lookup with Mark Adler's tool:
// https://github.com/madler/zlib/blob/v1.2.5/examples/enough.c
var kTableSize = [12]uint16_t{
- (uint16_t(((630 * 3) + 410) + 654)),
- (uint16_t(((630 * 3) + 410) + 656)),
- (uint16_t(((630 * 3) + 410) + 658)),
- (uint16_t(((630 * 3) + 410) + 662)),
- (uint16_t(((630 * 3) + 410) + 670)),
- (uint16_t(((630 * 3) + 410) + 686)),
- (uint16_t(((630 * 3) + 410) + 718)),
- (uint16_t(((630 * 3) + 410) + 782)),
- (uint16_t(((630 * 3) + 410) + 912)),
- (uint16_t(((630 * 3) + 410) + 1168)),
- (uint16_t(((630 * 3) + 410) + 1680)),
- (uint16_t(((630 * 3) + 410) + 2704)),
+ uint16_t(630*3 + 410 + 654),
+ uint16_t(630*3 + 410 + 656),
+ uint16_t(630*3 + 410 + 658),
+ uint16_t(630*3 + 410 + 662),
+ uint16_t(630*3 + 410 + 670),
+ uint16_t(630*3 + 410 + 686),
+ uint16_t(630*3 + 410 + 718),
+ uint16_t(630*3 + 410 + 782),
+ uint16_t(630*3 + 410 + 912),
+ uint16_t(630*3 + 410 + 1168),
+ uint16_t(630*3 + 410 + 1680),
+ uint16_t(630*3 + 410 + 2704),
} /* vp8l_dec.c:89:23 */
//------------------------------------------------------------------------------
func VP8LCheckSignature(tls *libc.TLS, data uintptr, size size_t) int32 { /* vp8l_dec.c:111:5: */
- return (libc.Bool32(((size >= uint64(5)) && (int32(*(*uint8_t)(unsafe.Pointer(data))) == 0x2f)) && ((int32(*(*uint8_t)(unsafe.Pointer(data + 4))) >> 5) == 0))) // version
+ return libc.Bool32(size >= uint64(5) && int32(*(*uint8_t)(unsafe.Pointer(data))) == 0x2f && int32(*(*uint8_t)(unsafe.Pointer(data + 4)))>>5 == 0) // version
}
func ReadImageInfo(tls *libc.TLS, br uintptr, width uintptr, height uintptr, has_alpha uintptr) int32 { /* vp8l_dec.c:117:12: */
if VP8LReadBits(tls, br, 8) != uint32_t(0x2f) {
return 0
}
- *(*int32)(unsafe.Pointer(width)) = (int32(VP8LReadBits(tls, br, 14) + uint32_t(1)))
- *(*int32)(unsafe.Pointer(height)) = (int32(VP8LReadBits(tls, br, 14) + uint32_t(1)))
+ *(*int32)(unsafe.Pointer(width)) = int32(VP8LReadBits(tls, br, 14) + uint32_t(1))
+ *(*int32)(unsafe.Pointer(height)) = int32(VP8LReadBits(tls, br, 14) + uint32_t(1))
*(*int32)(unsafe.Pointer(has_alpha)) = int32(VP8LReadBits(tls, br, 1))
if VP8LReadBits(tls, br, 3) != uint32_t(0) {
return 0
@@ -10849,7 +10589,7 @@ func VP8LGetInfo(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, h
bp := tls.Alloc(52)
defer tls.Free(52)
- if (data == (uintptr(0))) || (data_size < uint64(5)) {
+ if data == uintptr(0) || data_size < uint64(5) {
return 0 // not enough data
} else if !(VP8LCheckSignature(tls, data, data_size) != 0) {
return 0 // bad signature
@@ -10862,17 +10602,17 @@ func VP8LGetInfo(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, h
// var br VP8LBitReader at bp, 40
- VP8LInitBitReader(tls, (bp) /* &br */, data, data_size)
- if !(ReadImageInfo(tls, (bp) /* &br */, (bp+40) /* &w */, (bp+44) /* &h */, (bp+48) /* &a */) != 0) {
+ VP8LInitBitReader(tls, bp, data, data_size)
+ if !(ReadImageInfo(tls, bp, bp+40, bp+44, bp+48) != 0) {
return 0
}
- if width != (uintptr(0)) {
+ if width != uintptr(0) {
*(*int32)(unsafe.Pointer(width)) = *(*int32)(unsafe.Pointer(bp + 40 /* w */))
}
- if height != (uintptr(0)) {
+ if height != uintptr(0) {
*(*int32)(unsafe.Pointer(height)) = *(*int32)(unsafe.Pointer(bp + 44 /* h */))
}
- if has_alpha != (uintptr(0)) {
+ if has_alpha != uintptr(0) {
*(*int32)(unsafe.Pointer(has_alpha)) = *(*int32)(unsafe.Pointer(bp + 48 /* a */))
}
return 1
@@ -10886,11 +10626,11 @@ func GetCopyDistance(tls *libc.TLS, distance_symbol int32, br uintptr) int32 { /
var extra_bits int32
var offset int32
if distance_symbol < 4 {
- return (distance_symbol + 1)
+ return distance_symbol + 1
}
- extra_bits = ((distance_symbol - 2) >> 1)
- offset = ((2 + (distance_symbol & 1)) << extra_bits)
- return (int32((uint32_t(offset) + VP8LReadBits(tls, br, extra_bits)) + uint32_t(1)))
+ extra_bits = (distance_symbol - 2) >> 1
+ offset = (2 + distance_symbol&1) << extra_bits
+ return int32(uint32_t(offset) + VP8LReadBits(tls, br, extra_bits) + uint32_t(1))
}
func GetCopyLength(tls *libc.TLS, length_symbol int32, br uintptr) int32 { /* vp8l_dec.c:161:24: */
@@ -10900,12 +10640,12 @@ func GetCopyLength(tls *libc.TLS, length_symbol int32, br uintptr) int32 { /* vp
func PlaneCodeToDistance(tls *libc.TLS, xsize int32, plane_code int32) int32 { /* vp8l_dec.c:167:24: */
if plane_code > 120 {
- return (plane_code - 120)
+ return plane_code - 120
} else {
- var dist_code int32 = int32(kCodeToPlane[(plane_code - 1)])
- var yoffset int32 = (dist_code >> 4)
- var xoffset int32 = (8 - (dist_code & 0xf))
- var dist int32 = ((yoffset * xsize) + xoffset)
+ var dist_code int32 = int32(kCodeToPlane[plane_code-1])
+ var yoffset int32 = dist_code >> 4
+ var xoffset int32 = 8 - dist_code&0xf
+ var dist int32 = yoffset*xsize + xoffset
if dist >= 1 {
return dist
}
@@ -10921,29 +10661,29 @@ func PlaneCodeToDistance(tls *libc.TLS, xsize int32, plane_code int32) int32 { /
func ReadSymbol(tls *libc.TLS, table uintptr, br uintptr) int32 { /* vp8l_dec.c:183:24: */
var nbits int32
var val uint32_t = VP8LPrefetchBits(tls, br)
- table += 4 * (uintptr(val & (uint32_t((int32(1) << 8) - 1))))
- nbits = (int32((*HuffmanCode)(unsafe.Pointer(table)).bits) - 8)
+ table += 4 * uintptr(val&uint32_t(int32(1)<<8-1))
+ nbits = int32((*HuffmanCode)(unsafe.Pointer(table)).bits) - 8
if nbits > 0 {
- VP8LSetBitPos(tls, br, ((*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ + 8))
+ VP8LSetBitPos(tls, br, (*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_+8)
val = VP8LPrefetchBits(tls, br)
- table += 4 * (uintptr((*HuffmanCode)(unsafe.Pointer(table)).value))
- table += 4 * (uintptr(val & (uint32_t((int32(1) << nbits) - 1))))
+ table += 4 * uintptr((*HuffmanCode)(unsafe.Pointer(table)).value)
+ table += 4 * uintptr(val&uint32_t(int32(1)<<nbits-1))
}
- VP8LSetBitPos(tls, br, ((*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ + int32((*HuffmanCode)(unsafe.Pointer(table)).bits)))
+ VP8LSetBitPos(tls, br, (*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_+int32((*HuffmanCode)(unsafe.Pointer(table)).bits))
return int32((*HuffmanCode)(unsafe.Pointer(table)).value)
}
// Reads packed symbol depending on GREEN channel
func ReadPackedSymbols(tls *libc.TLS, group uintptr, br uintptr, dst uintptr) int32 { /* vp8l_dec.c:202:24: */
- var val uint32_t = (VP8LPrefetchBits(tls, br) & ((uint32(1) << 6) - uint32(1)))
- var code = *(*HuffmanCode32)(unsafe.Pointer((group + 56 /* &.packed_table */) + uintptr(val)*8))
+ var val uint32_t = VP8LPrefetchBits(tls, br) & (uint32(1)<<6 - uint32(1))
+ var code = *(*HuffmanCode32)(unsafe.Pointer(group + 56 + uintptr(val)*8))
if code.bits < 0x100 {
- VP8LSetBitPos(tls, br, ((*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ + code.bits))
+ VP8LSetBitPos(tls, br, (*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_+code.bits)
*(*uint32_t)(unsafe.Pointer(dst)) = code.value
return 0
} else {
- VP8LSetBitPos(tls, br, (((*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ + code.bits) - 0x100))
+ VP8LSetBitPos(tls, br, (*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_+code.bits-0x100)
return int32(code.value)
}
@@ -10951,29 +10691,29 @@ func ReadPackedSymbols(tls *libc.TLS, group uintptr, br uintptr, dst uintptr) in
}
func AccumulateHCode(tls *libc.TLS, hcode HuffmanCode, shift int32, huff uintptr) int32 { /* vp8l_dec.c:219:12: */
- *(*int32)(unsafe.Pointer((huff /* &.bits */))) += (int32(hcode.bits))
- *(*uint32_t)(unsafe.Pointer((huff + 4 /* &.value */))) |= (uint32_t(hcode.value) << shift)
+ *(*int32)(unsafe.Pointer(huff)) += int32(hcode.bits)
+ *(*uint32_t)(unsafe.Pointer(huff + 4)) |= uint32_t(hcode.value) << shift
return int32(hcode.bits)
}
func BuildPackedTable(tls *libc.TLS, htree_group uintptr) { /* vp8l_dec.c:227:13: */
var code uint32_t
- for code = uint32_t(0); code < (uint32(1) << 6); code++ {
+ for code = uint32_t(0); code < uint32(1)<<6; code++ {
var bits uint32_t = code
_ = bits
- var huff uintptr = ((htree_group + 56 /* &.packed_table */) + uintptr(bits)*8)
- var hcode = *(*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((htree_group /* &.htrees */))) + uintptr(bits)*4))
+ var huff uintptr = htree_group + 56 + uintptr(bits)*8
+ var hcode = *(*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htree_group)) + uintptr(bits)*4))
if int32(hcode.value) >= 256 {
- (*HuffmanCode32)(unsafe.Pointer(huff)).bits = (int32(hcode.bits) + 0x100)
+ (*HuffmanCode32)(unsafe.Pointer(huff)).bits = int32(hcode.bits) + 0x100
(*HuffmanCode32)(unsafe.Pointer(huff)).value = uint32_t(hcode.value)
} else {
(*HuffmanCode32)(unsafe.Pointer(huff)).bits = 0
(*HuffmanCode32)(unsafe.Pointer(huff)).value = uint32_t(0)
bits >>= AccumulateHCode(tls, hcode, 8, huff)
- bits >>= AccumulateHCode(tls, *(*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((htree_group /* &.htrees */) + 1*8)) + uintptr(bits)*4)), 16, huff)
- bits >>= AccumulateHCode(tls, *(*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((htree_group /* &.htrees */) + 2*8)) + uintptr(bits)*4)), 0, huff)
- bits >>= AccumulateHCode(tls, *(*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((htree_group /* &.htrees */) + 3*8)) + uintptr(bits)*4)), 24, huff)
+ bits >>= AccumulateHCode(tls, *(*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htree_group + 1*8)) + uintptr(bits)*4)), 16, huff)
+ bits >>= AccumulateHCode(tls, *(*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htree_group + 2*8)) + uintptr(bits)*4)), 0, huff)
+ bits >>= AccumulateHCode(tls, *(*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htree_group + 3*8)) + uintptr(bits)*4)), 24, huff)
_ = bits
}
}
@@ -11000,12 +10740,12 @@ func ReadHuffmanCodeLengths(tls *libc.TLS, dec uintptr, code_length_code_lengths
var p uintptr
var code_len int32
ok = 0
- br = (dec + 40 /* &.br_ */)
+ br = dec + 40
prev_code_len = 8
- if !(!(VP8LBuildHuffmanTable(tls, (bp) /* &table[0] */, 7,
+ if !!(VP8LBuildHuffmanTable(tls, bp, 7,
code_length_code_lengths,
- 19) != 0)) {
+ 19) != 0) {
goto __1
}
goto End
@@ -11015,8 +10755,8 @@ __1:
if !(VP8LReadBits(tls, br, 1) != 0) {
goto __2
} // use length
- length_nbits = (int32(uint32_t(2) + (uint32_t(2) * VP8LReadBits(tls, br, 3))))
- max_symbol = (int32(uint32_t(2) + VP8LReadBits(tls, br, length_nbits)))
+ length_nbits = int32(uint32_t(2) + uint32_t(2)*VP8LReadBits(tls, br, 3))
+ max_symbol = int32(uint32_t(2) + VP8LReadBits(tls, br, length_nbits))
if !(max_symbol > num_symbols) {
goto __4
}
@@ -11041,8 +10781,8 @@ __5:
__7:
;
VP8LFillBitWindow(tls, br)
- p = ((bp) /* &table */ + uintptr((VP8LPrefetchBits(tls, br)&(uint32_t((int32(1)<<7)-1))))*4)
- VP8LSetBitPos(tls, br, ((*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ + int32((*HuffmanCode)(unsafe.Pointer(p)).bits)))
+ p = bp + uintptr(VP8LPrefetchBits(tls, br)&uint32_t(int32(1)<<7-1))*4
+ VP8LSetBitPos(tls, br, (*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_+int32((*HuffmanCode)(unsafe.Pointer(p)).bits))
code_len = int32((*HuffmanCode)(unsafe.Pointer(p)).value)
if !(code_len < kCodeLengthLiterals) {
goto __8
@@ -11056,12 +10796,12 @@ __10:
;
goto __9
__8:
- use_prev = (libc.Bool32(code_len == kCodeLengthRepeatCode))
- slot = (code_len - kCodeLengthLiterals)
+ use_prev = libc.Bool32(code_len == kCodeLengthRepeatCode)
+ slot = code_len - kCodeLengthLiterals
extra_bits = int32(kCodeLengthExtraBits[slot])
repeat_offset = int32(kCodeLengthRepeatOffsets[slot])
- repeat = (int32(VP8LReadBits(tls, br, extra_bits) + uint32_t(repeat_offset)))
- if !((symbol + repeat) > num_symbols) {
+ repeat = int32(VP8LReadBits(tls, br, extra_bits) + uint32_t(repeat_offset))
+ if !(symbol+repeat > num_symbols) {
goto __11
}
goto End
@@ -11090,7 +10830,7 @@ __6:
ok = 1
End:
- if !(!(ok != 0)) {
+ if !!(ok != 0) {
goto __15
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_BITSTREAM_ERROR
@@ -11107,13 +10847,13 @@ func ReadHuffmanCode(tls *libc.TLS, alphabet_size int32, dec uintptr, code_lengt
var ok int32 = 0
var size int32 = 0
- var br uintptr = (dec + 40 /* &.br_ */)
+ var br uintptr = dec + 40
var simple_code int32 = int32(VP8LReadBits(tls, br, 1))
- libc.Xmemset(tls, code_lengths, 0, (uint64(alphabet_size) * uint64(unsafe.Sizeof(int32(0)))))
+ libc.Xmemset(tls, code_lengths, 0, uint64(alphabet_size)*uint64(unsafe.Sizeof(int32(0))))
if simple_code != 0 { // Read symbols, codes & code lengths directly.
- var num_symbols int32 = (int32(VP8LReadBits(tls, br, 1) + uint32_t(1)))
+ var num_symbols int32 = int32(VP8LReadBits(tls, br, 1) + uint32_t(1))
var first_symbol_len_code int32 = int32(VP8LReadBits(tls, br, 1))
// The first code is either 1 bit or 8 bit code.
var symbol int32 = int32(VP8LReadBits(tls, br, func() int32 {
@@ -11132,25 +10872,25 @@ func ReadHuffmanCode(tls *libc.TLS, alphabet_size int32, dec uintptr, code_lengt
} else { // Decode Huffman-coded code lengths.
var i int32
*(*[19]int32)(unsafe.Pointer(bp /* code_length_code_lengths */)) = [19]int32{0: 0}
- var num_codes int32 = (int32(VP8LReadBits(tls, br, 4) + uint32_t(4)))
+ var num_codes int32 = int32(VP8LReadBits(tls, br, 4) + uint32_t(4))
if num_codes > 19 {
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_BITSTREAM_ERROR
return 0
}
for i = 0; i < num_codes; i++ {
- *(*int32)(unsafe.Pointer((bp) /* &code_length_code_lengths[0] */ + uintptr(kCodeLengthCodeOrder[i])*4)) = int32(VP8LReadBits(tls, br, 3))
+ *(*int32)(unsafe.Pointer(bp + uintptr(kCodeLengthCodeOrder[i])*4)) = int32(VP8LReadBits(tls, br, 3))
}
- ok = ReadHuffmanCodeLengths(tls, dec, (bp) /* &code_length_code_lengths[0] */, alphabet_size,
+ ok = ReadHuffmanCodeLengths(tls, dec, bp, alphabet_size,
code_lengths)
}
- ok = (libc.Bool32((ok != 0) && !((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0)))
+ ok = libc.Bool32(ok != 0 && !((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0))
if ok != 0 {
size = VP8LBuildHuffmanTable(tls, table, 8,
code_lengths, alphabet_size)
}
- if !(ok != 0) || (size == 0) {
+ if !(ok != 0) || size == 0 {
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_BITSTREAM_ERROR
return 0
}
@@ -11200,30 +10940,30 @@ func ReadHuffmanCodes(tls *libc.TLS, dec uintptr, xsize int32, ysize int32, colo
var total_size int32
var is_trivial_literal int32
var max_bits int32
- br = (dec + 40 /* &.br_ */)
- hdr = (dec + 152 /* &.hdr_ */)
- *(*uintptr)(unsafe.Pointer(bp /* huffman_image */)) = (uintptr(0))
- htree_groups = (uintptr(0))
- huffman_tables = (uintptr(0))
- huffman_table = (uintptr(0))
+ br = dec + 40
+ hdr = dec + 152
+ *(*uintptr)(unsafe.Pointer(bp /* huffman_image */)) = uintptr(0)
+ htree_groups = uintptr(0)
+ huffman_tables = uintptr(0)
+ huffman_table = uintptr(0)
num_htree_groups = 1
num_htree_groups_max = 1
max_alphabet_size = 0
- code_lengths = (uintptr(0))
+ code_lengths = uintptr(0)
table_size = int32(kTableSize[color_cache_bits])
- mapping = (uintptr(0))
+ mapping = uintptr(0)
ok = 0
- if !((allow_recursion != 0) && (VP8LReadBits(tls, br, 1) != 0)) {
+ if !(allow_recursion != 0 && VP8LReadBits(tls, br, 1) != 0) {
goto __1
}
// use meta Huffman codes.
- huffman_precision = (int32(VP8LReadBits(tls, br, 3) + uint32_t(2)))
+ huffman_precision = int32(VP8LReadBits(tls, br, 3) + uint32_t(2))
huffman_xsize = int32(VP8LSubSampleSize(tls, uint32(xsize), uint32(huffman_precision)))
huffman_ysize = int32(VP8LSubSampleSize(tls, uint32(ysize), uint32(huffman_precision)))
- huffman_pixs = (huffman_xsize * huffman_ysize)
- if !(!(DecodeImageStream(tls, huffman_xsize, huffman_ysize, 0, dec,
- (bp) /* &huffman_image */) != 0)) {
+ huffman_pixs = huffman_xsize * huffman_ysize
+ if !!(DecodeImageStream(tls, huffman_xsize, huffman_ysize, 0, dec,
+ bp) != 0) {
goto __2
}
goto Error
@@ -11236,12 +10976,12 @@ __3:
goto __5
}
// The huffman data is stored in red and green bytes.
- group = (int32((*(*uint32_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp /* huffman_image */)) + uintptr(i)*4)) >> 8) & uint32_t(0xffff)))
+ group = int32(*(*uint32_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*4)) >> 8 & uint32_t(0xffff))
*(*uint32_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp /* huffman_image */)) + uintptr(i)*4)) = uint32_t(group)
if !(group >= num_htree_groups_max) {
goto __6
}
- num_htree_groups_max = (group + 1)
+ num_htree_groups_max = group + 1
__6:
;
goto __4
@@ -11257,13 +10997,13 @@ __5:
// The value of 1000 is totally arbitrary. We know that num_htree_groups_max
// is smaller than (1 << 16) and should be smaller than the number of pixels
// (though the format allows it to be bigger).
- if !((num_htree_groups_max > 1000) || (num_htree_groups_max > (xsize * ysize))) {
+ if !(num_htree_groups_max > 1000 || num_htree_groups_max > xsize*ysize) {
goto __7
}
// Create a mapping from the used indices to the minimal set of used
// values [0, num_htree_groups)
mapping = WebPSafeMalloc(tls, uint64(num_htree_groups_max), uint64(unsafe.Sizeof(int32(0))))
- if !(mapping == (uintptr(0))) {
+ if !(mapping == uintptr(0)) {
goto __9
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OUT_OF_MEMORY
@@ -11272,7 +11012,7 @@ __9:
;
// -1 means a value is unmapped, and therefore unused in the Huffman
// image.
- libc.Xmemset(tls, mapping, 0xff, (uint64(num_htree_groups_max) * uint64(unsafe.Sizeof(int32(0)))))
+ libc.Xmemset(tls, mapping, 0xff, uint64(num_htree_groups_max)*uint64(unsafe.Sizeof(int32(0))))
num_htree_groups = 0
i = 0
__10:
@@ -11280,7 +11020,7 @@ __10:
goto __12
}
// Get the current mapping for the group and remap the Huffman image.
- mapped_group = (mapping + uintptr(*(*uint32_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp /* huffman_image */)) + uintptr(i)*4)))*4)
+ mapped_group = mapping + uintptr(*(*uint32_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*4)))*4
if !(*(*int32)(unsafe.Pointer(mapped_group)) == -1) {
goto __13
}
@@ -11317,10 +11057,10 @@ __15:
goto __17
}
alphabet_size = int32(kAlphabetSize[j])
- if !((j == 0) && (color_cache_bits > 0)) {
+ if !(j == 0 && color_cache_bits > 0) {
goto __18
}
- alphabet_size = alphabet_size + (int32(1) << color_cache_bits)
+ alphabet_size = alphabet_size + int32(1)<<color_cache_bits
__18:
;
if !(max_alphabet_size < alphabet_size) {
@@ -11339,11 +11079,11 @@ __17:
code_lengths = WebPSafeCalloc(tls, uint64_t(max_alphabet_size),
uint64(unsafe.Sizeof(int32(0))))
- huffman_tables = WebPSafeMalloc(tls, (uint64(num_htree_groups * table_size)),
+ huffman_tables = WebPSafeMalloc(tls, uint64(num_htree_groups*table_size),
uint64(unsafe.Sizeof(HuffmanCode{})))
htree_groups = VP8LHtreeGroupsNew(tls, num_htree_groups)
- if !(((htree_groups == (uintptr(0))) || (code_lengths == (uintptr(0)))) || (huffman_tables == (uintptr(0)))) {
+ if !(htree_groups == uintptr(0) || code_lengths == uintptr(0) || huffman_tables == uintptr(0)) {
goto __20
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OUT_OF_MEMORY
@@ -11359,7 +11099,7 @@ __21:
}
// If the index "i" is unused in the Huffman image, just make sure the
// coefficients are valid but do not store them.
- if !((mapping != (uintptr(0))) && (*(*int32)(unsafe.Pointer(mapping + uintptr(i)*4)) == -1)) {
+ if !(mapping != uintptr(0) && *(*int32)(unsafe.Pointer(mapping + uintptr(i)*4)) == -1) {
goto __24
}
j = 0
@@ -11368,14 +11108,14 @@ __26:
goto __28
}
alphabet_size1 = int32(kAlphabetSize[j])
- if !((j == 0) && (color_cache_bits > 0)) {
+ if !(j == 0 && color_cache_bits > 0) {
goto __29
}
- alphabet_size1 = alphabet_size1 + (int32(1) << color_cache_bits)
+ alphabet_size1 = alphabet_size1 + int32(1)<<color_cache_bits
__29:
;
// Passing in NULL so that nothing gets filled.
- if !(!(ReadHuffmanCode(tls, alphabet_size1, dec, code_lengths, (uintptr(0))) != 0)) {
+ if !!(ReadHuffmanCode(tls, alphabet_size1, dec, code_lengths, uintptr(0)) != 0) {
goto __30
}
goto Error
@@ -11391,12 +11131,12 @@ __28:
goto __25
__24:
htree_group =
- (htree_groups + uintptr(func() int32 {
- if mapping == (uintptr(0)) {
+ htree_groups + uintptr(func() int32 {
+ if mapping == uintptr(0) {
return i
}
return *(*int32)(unsafe.Pointer(mapping + uintptr(i)*4))
- }())*568)
+ }())*568
htrees = htree_group /* &.htrees */
total_size = 0
is_trivial_literal = 1
@@ -11408,10 +11148,10 @@ __31:
}
alphabet_size2 = int32(kAlphabetSize[j])
*(*uintptr)(unsafe.Pointer(htrees + uintptr(j)*8)) = huffman_table
- if !((j == 0) && (color_cache_bits > 0)) {
+ if !(j == 0 && color_cache_bits > 0) {
goto __34
}
- alphabet_size2 = alphabet_size2 + (int32(1) << color_cache_bits)
+ alphabet_size2 = alphabet_size2 + int32(1)<<color_cache_bits
__34:
;
size = ReadHuffmanCode(tls, alphabet_size2, dec, code_lengths, huffman_table)
@@ -11421,14 +11161,14 @@ __34:
goto Error
__35:
;
- if !((is_trivial_literal != 0) && (int32(kLiteralMap[j]) == 1)) {
+ if !(is_trivial_literal != 0 && int32(kLiteralMap[j]) == 1) {
goto __36
}
- is_trivial_literal = (libc.Bool32(int32((*HuffmanCode)(unsafe.Pointer(huffman_table)).bits) == 0))
+ is_trivial_literal = libc.Bool32(int32((*HuffmanCode)(unsafe.Pointer(huffman_table)).bits) == 0)
__36:
;
- total_size = total_size + (int32((*HuffmanCode)(unsafe.Pointer(huffman_table)).bits))
- huffman_table += 4 * (uintptr(size))
+ total_size = total_size + int32((*HuffmanCode)(unsafe.Pointer(huffman_table)).bits)
+ huffman_table += 4 * uintptr(size)
if !(j <= ALPHA) {
goto __37
}
@@ -11451,7 +11191,7 @@ __39:
goto __40
__40:
;
- max_bits = max_bits + (local_max_bits)
+ max_bits = max_bits + local_max_bits
__37:
;
goto __32
@@ -11469,17 +11209,17 @@ __33:
red = int32((*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htrees + 1*8)))).value)
blue = int32((*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htrees + 2*8)))).value)
alpha = int32((*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htrees + 3*8)))).value)
- (*HTreeGroup)(unsafe.Pointer(htree_group)).literal_arb = (((uint32_t(alpha) << 24) | (uint32_t(red << 16))) | uint32_t(blue))
- if !((total_size == 0) && (int32((*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htrees)))).value) < 256)) {
+ (*HTreeGroup)(unsafe.Pointer(htree_group)).literal_arb = uint32_t(alpha)<<24 | uint32_t(red<<16) | uint32_t(blue)
+ if !(total_size == 0 && int32((*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htrees)))).value) < 256) {
goto __43
}
(*HTreeGroup)(unsafe.Pointer(htree_group)).is_trivial_code = 1
- *(*uint32_t)(unsafe.Pointer((htree_group + 44 /* &.literal_arb */))) |= (uint32_t(int32((*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htrees)))).value) << 8))
+ *(*uint32_t)(unsafe.Pointer(htree_group + 44)) |= uint32_t(int32((*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htrees)))).value) << 8)
__43:
;
__42:
;
- (*HTreeGroup)(unsafe.Pointer(htree_group)).use_packed_table = (libc.Bool32(!((*HTreeGroup)(unsafe.Pointer(htree_group)).is_trivial_code != 0) && (max_bits < 6)))
+ (*HTreeGroup)(unsafe.Pointer(htree_group)).use_packed_table = libc.Bool32(!((*HTreeGroup)(unsafe.Pointer(htree_group)).is_trivial_code != 0) && max_bits < 6)
if !((*HTreeGroup)(unsafe.Pointer(htree_group)).use_packed_table != 0) {
goto __44
}
@@ -11506,7 +11246,7 @@ __23:
Error:
WebPSafeFree(tls, code_lengths)
WebPSafeFree(tls, mapping)
- if !(!(ok != 0)) {
+ if !!(ok != 0) {
goto __45
}
WebPSafeFree(tls, *(*uintptr)(unsafe.Pointer(bp /* huffman_image */)))
@@ -11526,13 +11266,13 @@ func AllocateAndInitRescaler(tls *libc.TLS, dec uintptr, io uintptr) int32 { /*
var out_width int32 = (*VP8Io)(unsafe.Pointer(io)).scaled_width
var in_height int32 = (*VP8Io)(unsafe.Pointer(io)).mb_h
var out_height int32 = (*VP8Io)(unsafe.Pointer(io)).scaled_height
- var work_size uint64_t = ((uint64_t(2 * num_channels)) * uint64_t(out_width))
+ var work_size uint64_t = uint64_t(2*num_channels) * uint64_t(out_width)
var work uintptr // Rescaler work area.
var scaled_data_size uint64_t = uint64_t(out_width)
var scaled_data uintptr // Temporary storage for scaled BGRA data.
- var memory_size uint64_t = ((uint64(unsafe.Sizeof(WebPRescaler{})) + (work_size * uint64_t(unsafe.Sizeof(rescaler_t(0))))) + (scaled_data_size * uint64_t(unsafe.Sizeof(uint32_t(0)))))
+ var memory_size uint64_t = uint64(unsafe.Sizeof(WebPRescaler{})) + work_size*uint64_t(unsafe.Sizeof(rescaler_t(0))) + scaled_data_size*uint64_t(unsafe.Sizeof(uint32_t(0)))
var memory uintptr = WebPSafeMalloc(tls, memory_size, uint64(unsafe.Sizeof(uint8_t(0))))
- if memory == (uintptr(0)) {
+ if memory == uintptr(0) {
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OUT_OF_MEMORY
return 0
}
@@ -11542,7 +11282,7 @@ func AllocateAndInitRescaler(tls *libc.TLS, dec uintptr, io uintptr) int32 { /*
(*VP8LDecoder)(unsafe.Pointer(dec)).rescaler = memory
memory += uintptr(unsafe.Sizeof(WebPRescaler{}))
work = memory
- memory += (uintptr(work_size * uint64_t(unsafe.Sizeof(rescaler_t(0)))))
+ memory += uintptr(work_size * uint64_t(unsafe.Sizeof(rescaler_t(0))))
scaled_data = memory
if !(WebPRescalerInit(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).rescaler, in_width, in_height,
@@ -11580,9 +11320,9 @@ func EmitRescaledRowsRGBA(tls *libc.TLS, dec uintptr, in uintptr, in_stride int3
var num_lines_in int32 = 0
var num_lines_out int32 = 0
for num_lines_in < mb_h {
- var row_in uintptr = (in + uintptr((uint64_t(num_lines_in) * uint64_t(in_stride))))
- var row_out uintptr = (out + uintptr((uint64_t(num_lines_out) * uint64_t(out_stride))))
- var lines_left int32 = (mb_h - num_lines_in)
+ var row_in uintptr = in + uintptr(uint64_t(num_lines_in)*uint64_t(in_stride))
+ var row_out uintptr = out + uintptr(uint64_t(num_lines_out)*uint64_t(out_stride))
+ var lines_left int32 = mb_h - num_lines_in
var needed_lines int32 = WebPRescaleNeededLines(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).rescaler, lines_left)
var lines_imported int32
@@ -11590,8 +11330,8 @@ func EmitRescaledRowsRGBA(tls *libc.TLS, dec uintptr, in uintptr, in_stride int3
(*WebPRescaler)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).rescaler)).src_width, needed_lines, 0)
lines_imported = WebPRescalerImport(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).rescaler, lines_left, row_in, in_stride)
- num_lines_in = num_lines_in + (lines_imported)
- num_lines_out = num_lines_out + (Export(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).rescaler, colorspace, out_stride, row_out))
+ num_lines_in = num_lines_in + lines_imported
+ num_lines_out = num_lines_out + Export(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).rescaler, colorspace, out_stride, row_out)
}
return num_lines_out
}
@@ -11612,30 +11352,30 @@ func EmitRows(tls *libc.TLS, colorspace WEBP_CSP_MODE, row_in uintptr, in_stride
// Export to YUVA
func ConvertToYUVA(tls *libc.TLS, src uintptr, width int32, y_pos int32, output uintptr) { /* vp8l_dec.c:638:13: */
- var buf uintptr = (output + 16 /* &.u */) /* &.YUVA */
+ var buf uintptr = output + 16
// first, the luma plane
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{WebPConvertARGBToY})).f(tls, src, ((*WebPYUVABuffer)(unsafe.Pointer(buf)).y + uintptr((y_pos * (*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride))), width)
+ })(unsafe.Pointer(&struct{ uintptr }{WebPConvertARGBToY})).f(tls, src, (*WebPYUVABuffer)(unsafe.Pointer(buf)).y+uintptr(y_pos*(*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride), width)
// then U/V planes
{
- var u uintptr = ((*WebPYUVABuffer)(unsafe.Pointer(buf)).u + uintptr(((y_pos >> 1) * (*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride)))
- var v uintptr = ((*WebPYUVABuffer)(unsafe.Pointer(buf)).v + uintptr(((y_pos >> 1) * (*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride)))
+ var u uintptr = (*WebPYUVABuffer)(unsafe.Pointer(buf)).u + uintptr(y_pos>>1*(*WebPYUVABuffer)(unsafe.Pointer(buf)).u_stride)
+ var v uintptr = (*WebPYUVABuffer)(unsafe.Pointer(buf)).v + uintptr(y_pos>>1*(*WebPYUVABuffer)(unsafe.Pointer(buf)).v_stride)
// even lines: store values
// odd lines: average with previous values
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32, int32)
- })(unsafe.Pointer(&struct{ uintptr }{WebPConvertARGBToUV})).f(tls, src, u, v, width, libc.BoolInt32(!((y_pos & 1) != 0)))
+ })(unsafe.Pointer(&struct{ uintptr }{WebPConvertARGBToUV})).f(tls, src, u, v, width, libc.BoolInt32(!(y_pos&1 != 0)))
}
// Lastly, store alpha if needed.
- if (*WebPYUVABuffer)(unsafe.Pointer(buf)).a != (uintptr(0)) {
- var a uintptr = ((*WebPYUVABuffer)(unsafe.Pointer(buf)).a + uintptr((y_pos * (*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride)))
+ if (*WebPYUVABuffer)(unsafe.Pointer(buf)).a != uintptr(0) {
+ var a uintptr = (*WebPYUVABuffer)(unsafe.Pointer(buf)).a + uintptr(y_pos*(*WebPYUVABuffer)(unsafe.Pointer(buf)).a_stride)
(*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32) int32
- })(unsafe.Pointer(&struct{ uintptr }{WebPExtractAlpha})).f(tls, (src + uintptr(3)), 0, width, 1, a, 0)
+ })(unsafe.Pointer(&struct{ uintptr }{WebPExtractAlpha})).f(tls, src+uintptr(3), 0, width, 1, a, 0)
}
}
@@ -11660,15 +11400,15 @@ func EmitRescaledRowsYUVA(tls *libc.TLS, dec uintptr, in uintptr, in_stride int3
var num_lines_in int32 = 0
var y_pos int32 = (*VP8LDecoder)(unsafe.Pointer(dec)).last_out_row_
for num_lines_in < mb_h {
- var lines_left int32 = (mb_h - num_lines_in)
+ var lines_left int32 = mb_h - num_lines_in
var needed_lines int32 = WebPRescaleNeededLines(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).rescaler, lines_left)
var lines_imported int32
WebPMultARGBRows(tls, in, in_stride, (*WebPRescaler)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).rescaler)).src_width, needed_lines, 0)
lines_imported = WebPRescalerImport(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).rescaler, lines_left, in, in_stride)
- num_lines_in = num_lines_in + (lines_imported)
- in += (uintptr(needed_lines * in_stride))
- y_pos = y_pos + (ExportYUVA(tls, dec, y_pos))
+ num_lines_in = num_lines_in + lines_imported
+ in += uintptr(needed_lines * in_stride)
+ y_pos = y_pos + ExportYUVA(tls, dec, y_pos)
}
return y_pos
}
@@ -11697,19 +11437,19 @@ func SetCropWindow(tls *libc.TLS, io uintptr, y_start int32, y_end int32, in_dat
y_end = (*VP8Io)(unsafe.Pointer(io)).crop_bottom // make sure we don't overflow on last row.
}
if y_start < (*VP8Io)(unsafe.Pointer(io)).crop_top {
- var delta int32 = ((*VP8Io)(unsafe.Pointer(io)).crop_top - y_start)
+ var delta int32 = (*VP8Io)(unsafe.Pointer(io)).crop_top - y_start
y_start = (*VP8Io)(unsafe.Pointer(io)).crop_top
- *(*uintptr)(unsafe.Pointer(in_data)) += (uintptr(delta * pixel_stride))
+ *(*uintptr)(unsafe.Pointer(in_data)) += uintptr(delta * pixel_stride)
}
if y_start >= y_end {
return 0
} // Crop window is empty.
- *(*uintptr)(unsafe.Pointer(in_data)) += (uintptr(uint64((*VP8Io)(unsafe.Pointer(io)).crop_left) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ *(*uintptr)(unsafe.Pointer(in_data)) += uintptr(uint64((*VP8Io)(unsafe.Pointer(io)).crop_left) * uint64(unsafe.Sizeof(uint32_t(0))))
- (*VP8Io)(unsafe.Pointer(io)).mb_y = (y_start - (*VP8Io)(unsafe.Pointer(io)).crop_top)
- (*VP8Io)(unsafe.Pointer(io)).mb_w = ((*VP8Io)(unsafe.Pointer(io)).crop_right - (*VP8Io)(unsafe.Pointer(io)).crop_left)
- (*VP8Io)(unsafe.Pointer(io)).mb_h = (y_end - y_start)
+ (*VP8Io)(unsafe.Pointer(io)).mb_y = y_start - (*VP8Io)(unsafe.Pointer(io)).crop_top
+ (*VP8Io)(unsafe.Pointer(io)).mb_w = (*VP8Io)(unsafe.Pointer(io)).crop_right - (*VP8Io)(unsafe.Pointer(io)).crop_left
+ (*VP8Io)(unsafe.Pointer(io)).mb_h = y_end - y_start
return 1 // Non-empty crop window.
}
@@ -11719,14 +11459,14 @@ func GetMetaIndex(tls *libc.TLS, image uintptr, xsize int32, bits int32, x int32
if bits == 0 {
return 0
}
- return int32(*(*uint32_t)(unsafe.Pointer(image + uintptr(((xsize*(y>>bits))+(x>>bits)))*4)))
+ return int32(*(*uint32_t)(unsafe.Pointer(image + uintptr(xsize*(y>>bits)+x>>bits)*4)))
}
func GetHtreeGroupForPos(tls *libc.TLS, hdr uintptr, x int32, y int32) uintptr { /* vp8l_dec.c:748:30: */
var meta_index int32 = GetMetaIndex(tls, (*VP8LMetadata)(unsafe.Pointer(hdr)).huffman_image_, (*VP8LMetadata)(unsafe.Pointer(hdr)).huffman_xsize_,
(*VP8LMetadata)(unsafe.Pointer(hdr)).huffman_subsample_bits_, x, y)
- return ((*VP8LMetadata)(unsafe.Pointer(hdr)).htree_groups_ + uintptr(meta_index)*568)
+ return (*VP8LMetadata)(unsafe.Pointer(hdr)).htree_groups_ + uintptr(meta_index)*568
}
//------------------------------------------------------------------------------
@@ -11736,20 +11476,20 @@ type ProcessRowsFunc = uintptr /* vp8l_dec.c:759:14 */
func ApplyInverseTransforms(tls *libc.TLS, dec uintptr, start_row int32, num_rows int32, rows uintptr) { /* vp8l_dec.c:761:13: */
var n int32 = (*VP8LDecoder)(unsafe.Pointer(dec)).next_transform_
- var cache_pixs int32 = ((*VP8LDecoder)(unsafe.Pointer(dec)).width_ * num_rows)
- var end_row int32 = (start_row + num_rows)
+ var cache_pixs int32 = (*VP8LDecoder)(unsafe.Pointer(dec)).width_ * num_rows
+ var end_row int32 = start_row + num_rows
var rows_in uintptr = rows
var rows_out uintptr = (*VP8LDecoder)(unsafe.Pointer(dec)).argb_cache_
// Inverse transforms.
for libc.PostDecInt32(&n, 1) > 0 {
- var transform uintptr = ((dec + 248 /* &.transforms_ */) + uintptr(n)*24)
+ var transform uintptr = dec + 248 + uintptr(n)*24
VP8LInverseTransform(tls, transform, start_row, end_row, rows_in, rows_out)
rows_in = rows_out
}
if rows_in != rows_out {
// No transform called, hence just copy.
- libc.Xmemcpy(tls, rows_out, rows_in, (uint64(cache_pixs) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, rows_out, rows_in, uint64(cache_pixs)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
@@ -11759,8 +11499,8 @@ func ProcessRows(tls *libc.TLS, dec uintptr, row int32) { /* vp8l_dec.c:784:13:
bp := tls.Alloc(8)
defer tls.Free(8)
- var rows uintptr = ((*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ + uintptr(((*VP8LDecoder)(unsafe.Pointer(dec)).width_*(*VP8LDecoder)(unsafe.Pointer(dec)).last_row_))*4)
- var num_rows int32 = (row - (*VP8LDecoder)(unsafe.Pointer(dec)).last_row_)
+ var rows uintptr = (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).width_*(*VP8LDecoder)(unsafe.Pointer(dec)).last_row_)*4
+ var num_rows int32 = row - (*VP8LDecoder)(unsafe.Pointer(dec)).last_row_
// We can't process more than NUM_ARGB_CACHE_ROWS at a time (that's the size
// of argb_cache_), but we currently don't need more than that.
@@ -11768,15 +11508,15 @@ func ProcessRows(tls *libc.TLS, dec uintptr, row int32) { /* vp8l_dec.c:784:13:
if num_rows > 0 { // Emit output.
var io uintptr = (*VP8LDecoder)(unsafe.Pointer(dec)).io_
*(*uintptr)(unsafe.Pointer(bp /* rows_data */)) = (*VP8LDecoder)(unsafe.Pointer(dec)).argb_cache_
- var in_stride int32 = (int32(uint64((*VP8Io)(unsafe.Pointer(io)).width) * uint64(unsafe.Sizeof(uint32_t(0))))) // in unit of RGBA
+ var in_stride int32 = int32(uint64((*VP8Io)(unsafe.Pointer(io)).width) * uint64(unsafe.Sizeof(uint32_t(0)))) // in unit of RGBA
ApplyInverseTransforms(tls, dec, (*VP8LDecoder)(unsafe.Pointer(dec)).last_row_, num_rows, rows)
- if !(SetCropWindow(tls, io, (*VP8LDecoder)(unsafe.Pointer(dec)).last_row_, row, (bp) /* &rows_data */, in_stride) != 0) {
+ if !(SetCropWindow(tls, io, (*VP8LDecoder)(unsafe.Pointer(dec)).last_row_, row, bp, in_stride) != 0) {
// Nothing to output (this time).
} else {
var output uintptr = (*VP8LDecoder)(unsafe.Pointer(dec)).output_
if WebPIsRGBMode(tls, (*WebPDecBuffer)(unsafe.Pointer(output)).colorspace) != 0 { // convert to RGBA
- var buf uintptr = (output + 16 /* &.u */) /* &.RGBA */
- var rgba uintptr = ((*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr((int64_t((*VP8LDecoder)(unsafe.Pointer(dec)).last_out_row_) * int64_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))))
+ var buf uintptr = output + 16
+ var rgba uintptr = (*WebPRGBABuffer)(unsafe.Pointer(buf)).rgba + uintptr(int64_t((*VP8LDecoder)(unsafe.Pointer(dec)).last_out_row_)*int64_t((*WebPRGBABuffer)(unsafe.Pointer(buf)).stride))
var num_rows_out int32
if (*VP8Io)(unsafe.Pointer(io)).use_scaling != 0 {
num_rows_out = EmitRescaledRowsRGBA(tls, dec, *(*uintptr)(unsafe.Pointer(bp /* rows_data */)), in_stride, (*VP8Io)(unsafe.Pointer(io)).mb_h,
@@ -11786,7 +11526,7 @@ func ProcessRows(tls *libc.TLS, dec uintptr, row int32) { /* vp8l_dec.c:784:13:
(*VP8Io)(unsafe.Pointer(io)).mb_w, (*VP8Io)(unsafe.Pointer(io)).mb_h, rgba, (*WebPRGBABuffer)(unsafe.Pointer(buf)).stride)
}
// Update 'last_out_row_'.
- *(*int32)(unsafe.Pointer((dec + 148 /* &.last_out_row_ */))) += (num_rows_out)
+ *(*int32)(unsafe.Pointer(dec + 148)) += num_rows_out
} else { // convert to YUVA
(*VP8LDecoder)(unsafe.Pointer(dec)).last_out_row_ = func() int32 {
if (*VP8Io)(unsafe.Pointer(io)).use_scaling != 0 {
@@ -11814,7 +11554,7 @@ func Is8bOptimizable(tls *libc.TLS, hdr uintptr) int32 { /* vp8l_dec.c:831:12: *
// When the Huffman tree contains only one symbol, we can skip the
// call to ReadSymbol() for red/blue/alpha channels.
for i = 0; i < (*VP8LMetadata)(unsafe.Pointer(hdr)).num_htree_groups_; i++ {
- var htrees uintptr = ((*VP8LMetadata)(unsafe.Pointer(hdr)).htree_groups_ + uintptr(i)*568) /* &.htrees */
+ var htrees uintptr = (*VP8LMetadata)(unsafe.Pointer(hdr)).htree_groups_ + uintptr(i)*568
if int32((*HuffmanCode)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(htrees + 1*8)))).bits) > 0 {
return 0
}
@@ -11849,7 +11589,7 @@ func ExtractPalettedAlphaRows(tls *libc.TLS, dec uintptr, last_row int32) { /* v
// crop_top row, in order to have the correct spatial predictors.
var alph_dec uintptr = (*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).io_)).opaque
var top_row int32
- if ((*ALPHDecoder)(unsafe.Pointer(alph_dec)).filter_ == WEBP_FILTER_NONE) || ((*ALPHDecoder)(unsafe.Pointer(alph_dec)).filter_ == WEBP_FILTER_HORIZONTAL) {
+ if (*ALPHDecoder)(unsafe.Pointer(alph_dec)).filter_ == WEBP_FILTER_NONE || (*ALPHDecoder)(unsafe.Pointer(alph_dec)).filter_ == WEBP_FILTER_HORIZONTAL {
top_row = (*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).io_)).crop_top
} else {
top_row = (*VP8LDecoder)(unsafe.Pointer(dec)).last_row_
@@ -11864,15 +11604,15 @@ func ExtractPalettedAlphaRows(tls *libc.TLS, dec uintptr, last_row int32) { /* v
if last_row > first_row {
// Special method for paletted alpha data. We only process the cropped area.
var width int32 = (*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).io_)).width
- var out uintptr = ((*ALPHDecoder)(unsafe.Pointer(alph_dec)).output_ + uintptr((width * first_row)))
- var in uintptr = ((*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ + uintptr(((*VP8LDecoder)(unsafe.Pointer(dec)).width_ * first_row)))
- var transform uintptr = (dec + 248 /* &.transforms_ */)
+ var out uintptr = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).output_ + uintptr(width*first_row)
+ var in uintptr = (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).width_*first_row)
+ var transform uintptr = dec + 248
VP8LColorIndexInverseTransformAlpha(tls, transform, first_row, last_row,
in, out)
AlphaApplyFilter(tls, alph_dec, first_row, last_row, out, width)
}
- (*VP8LDecoder)(unsafe.Pointer(dec)).last_row_ = libc.AssignPtrInt32((dec + 148 /* &.last_out_row_ */), last_row)
+ (*VP8LDecoder)(unsafe.Pointer(dec)).last_row_ = libc.AssignPtrInt32(dec+148, last_row)
}
//------------------------------------------------------------------------------
@@ -11880,21 +11620,21 @@ func ExtractPalettedAlphaRows(tls *libc.TLS, dec uintptr, last_row int32) { /* v
// cyclic rotation of pattern word
func Rotate8b(tls *libc.TLS, V uint32_t) uint32_t { /* vp8l_dec.c:891:29: */
- return (((V & 0xff) << 24) | (V >> 8))
+ return V&0xff<<24 | V>>8
}
// copy 1, 2 or 4-bytes pattern
func CopySmallPattern8b(tls *libc.TLS, src uintptr, dst uintptr, length int32, pattern uint32_t) { /* vp8l_dec.c:900:25: */
var i int32
// align 'dst' to 4-bytes boundary. Adjust the pattern along the way.
- for (uintptr_t(dst) & uint64(3)) != 0 {
+ for uintptr_t(dst)&uint64(3) != 0 {
*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&src, 1)))
pattern = Rotate8b(tls, pattern)
length--
}
// Copy the pattern 4 bytes at a time.
- for i = 0; i < (length >> 2); i++ {
- *(*uint32_t)(unsafe.Pointer((dst) + uintptr(i)*4)) = pattern
+ for i = 0; i < length>>2; i++ {
+ *(*uint32_t)(unsafe.Pointer(dst + uintptr(i)*4)) = pattern
}
// Finish with left-overs. 'pattern' is still correctly positioned,
// so no Rotate8b() call is needed.
@@ -11911,7 +11651,7 @@ func CopyBlock8b(tls *libc.TLS, dst uintptr, dist int32, length int32) { /* vp8l
// var pattern uint32_t at bp, 4
var i int32
- src = (dst - uintptr(dist))
+ src = dst - uintptr(dist)
if !(length >= 8) {
goto __1
}
@@ -11929,14 +11669,14 @@ func CopyBlock8b(tls *libc.TLS, dst uintptr, dist int32, length int32) { /* vp8l
goto __2
__3:
*(*uint32_t)(unsafe.Pointer(bp /* pattern */)) = uint32_t(*(*uint8_t)(unsafe.Pointer(src)))
- *(*uint32_t)(unsafe.Pointer(bp /* pattern */)) = (0x01010101 * *(*uint32_t)(unsafe.Pointer(bp /* pattern */)))
+ *(*uint32_t)(unsafe.Pointer(bp /* pattern */)) = 0x01010101 * *(*uint32_t)(unsafe.Pointer(bp))
goto __2
__4:
- libc.Xmemcpy(tls, (bp) /* &pattern */, src, uint64(unsafe.Sizeof(uint16_t(0))))
- *(*uint32_t)(unsafe.Pointer(bp /* pattern */)) = (0x00010001 * *(*uint32_t)(unsafe.Pointer(bp /* pattern */)))
+ libc.Xmemcpy(tls, bp, src, uint64(unsafe.Sizeof(uint16_t(0))))
+ *(*uint32_t)(unsafe.Pointer(bp /* pattern */)) = 0x00010001 * *(*uint32_t)(unsafe.Pointer(bp))
goto __2
__5:
- libc.Xmemcpy(tls, (bp) /* &pattern */, src, uint64(unsafe.Sizeof(uint32_t(0))))
+ libc.Xmemcpy(tls, bp, src, uint64(unsafe.Sizeof(uint32_t(0))))
goto __2
__6:
goto Copy
@@ -11950,7 +11690,7 @@ Copy:
if !(dist >= length) {
goto __7
} // no overlap -> use memcpy()
- libc.Xmemcpy(tls, dst, src, (uint64(length) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ libc.Xmemcpy(tls, dst, src, uint64(length)*uint64(unsafe.Sizeof(uint8_t(0))))
goto __8
__7:
i = 0
@@ -11972,17 +11712,17 @@ __8:
// copy pattern of 1 or 2 uint32_t's
func CopySmallPattern32b(tls *libc.TLS, src uintptr, dst uintptr, length int32, pattern uint64_t) { /* vp8l_dec.c:969:25: */
var i int32
- if (uintptr_t(dst) & uint64(4)) != 0 { // Align 'dst' to 8-bytes boundary.
+ if uintptr_t(dst)&uint64(4) != 0 { // Align 'dst' to 8-bytes boundary.
*(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 4))) = *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&src, 4)))
- pattern = ((pattern >> 32) | (pattern << 32))
+ pattern = pattern>>32 | pattern<<32
length--
}
- for i = 0; i < (length >> 1); i++ {
- *(*uint64_t)(unsafe.Pointer((dst) + uintptr(i)*8)) = pattern // Copy the pattern 8 bytes at a time.
+ for i = 0; i < length>>1; i++ {
+ *(*uint64_t)(unsafe.Pointer(dst + uintptr(i)*8)) = pattern // Copy the pattern 8 bytes at a time.
}
- if (length & 1) != 0 { // Finish with left-over.
- *(*uint32_t)(unsafe.Pointer(dst + uintptr((i<<1))*4)) = *(*uint32_t)(unsafe.Pointer(src + uintptr((i<<1))*4))
+ if length&1 != 0 { // Finish with left-over.
+ *(*uint32_t)(unsafe.Pointer(dst + uintptr(i<<1)*4)) = *(*uint32_t)(unsafe.Pointer(src + uintptr(i<<1)*4))
}
}
@@ -11990,19 +11730,19 @@ func CopyBlock32b(tls *libc.TLS, dst uintptr, dist int32, length int32) { /* vp8
bp := tls.Alloc(8)
defer tls.Free(8)
- var src uintptr = (dst - uintptr(dist)*4)
- if ((dist <= 2) && (length >= 4)) && ((uintptr_t(dst) & uint64(3)) == uint64(0)) {
+ var src uintptr = dst - uintptr(dist)*4
+ if dist <= 2 && length >= 4 && uintptr_t(dst)&uint64(3) == uint64(0) {
// var pattern uint64_t at bp, 8
if dist == 1 {
*(*uint64_t)(unsafe.Pointer(bp /* pattern */)) = uint64_t(*(*uint32_t)(unsafe.Pointer(src)))
- *(*uint64_t)(unsafe.Pointer(bp /* pattern */)) |= (*(*uint64_t)(unsafe.Pointer(bp /* pattern */)) << 32)
+ *(*uint64_t)(unsafe.Pointer(bp /* pattern */)) |= *(*uint64_t)(unsafe.Pointer(bp)) << 32
} else {
- libc.Xmemcpy(tls, (bp) /* &pattern */, src, uint64(unsafe.Sizeof(uint64_t(0))))
+ libc.Xmemcpy(tls, bp, src, uint64(unsafe.Sizeof(uint64_t(0))))
}
CopySmallPattern32b(tls, src, dst, length, *(*uint64_t)(unsafe.Pointer(bp /* pattern */)))
} else if dist >= length { // no overlap
- libc.Xmemcpy(tls, dst, src, (uint64(length) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, dst, src, uint64(length)*uint64(unsafe.Sizeof(uint32_t(0))))
} else {
var i int32
for i = 0; i < length; i++ {
@@ -12032,27 +11772,27 @@ func DecodeAlphaData(tls *libc.TLS, dec uintptr, data uintptr, width int32, heig
var dist_symbol int32
var code int32
ok = 1
- row = ((*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ / width)
- col = ((*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ % width)
- br = (dec + 40 /* &.br_ */)
- hdr = (dec + 152 /* &.hdr_ */)
+ row = (*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ / width
+ col = (*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ % width
+ br = dec + 40
+ hdr = dec + 152
pos = (*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_
- end = (width * height)
- last = (width * last_row)
- len_code_limit = (256 + 24)
+ end = width * height
+ last = width * last_row
+ len_code_limit = 256 + 24
mask = (*VP8LMetadata)(unsafe.Pointer(hdr)).huffman_mask_
if pos < last {
htree_group = GetHtreeGroupForPos(tls, hdr, col, row)
} else {
- htree_group = (uintptr(0))
+ htree_group = uintptr(0)
}
__1:
- if !(!((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0) && (pos < last)) {
+ if !(!((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0) && pos < last) {
goto __2
}
// Only update when changing tile.
- if !((col & mask) == 0) {
+ if !(col&mask == 0) {
goto __3
}
htree_group = GetHtreeGroupForPos(tls, hdr, col, row)
@@ -12060,7 +11800,7 @@ __3:
;
VP8LFillBitWindow(tls, br)
- code = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer((htree_group /* &.htrees */))), br)
+ code = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer(htree_group)), br)
if !(code < 256) {
goto __4
} // Literal
@@ -12072,7 +11812,7 @@ __3:
}
col = 0
row++
- if !((row <= last_row) && ((row % 16) == 0)) {
+ if !(row <= last_row && row%16 == 0) {
goto __7
}
ExtractPalettedAlphaRows(tls, dec, row)
@@ -12085,31 +11825,31 @@ __4:
if !(code < len_code_limit) {
goto __8
}
- length_sym = (code - 256)
+ length_sym = code - 256
length = GetCopyLength(tls, length_sym, br)
- dist_symbol = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer((htree_group /* &.htrees */) + 4*8)), br)
+ dist_symbol = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer(htree_group + 4*8)), br)
VP8LFillBitWindow(tls, br)
dist_code = GetCopyDistance(tls, dist_symbol, br)
dist = PlaneCodeToDistance(tls, width, dist_code)
- if !((pos >= dist) && ((end - pos) >= length)) {
+ if !(pos >= dist && end-pos >= length) {
goto __10
}
- CopyBlock8b(tls, (data + uintptr(pos)), dist, length)
+ CopyBlock8b(tls, data+uintptr(pos), dist, length)
goto __11
__10:
ok = 0
goto End
__11:
;
- pos = pos + (length)
- col = col + (length)
+ pos = pos + length
+ col = col + length
__12:
if !(col >= width) {
goto __13
}
- col = col - (width)
+ col = col - width
row++
- if !((row <= last_row) && ((row % 16) == 0)) {
+ if !(row <= last_row && row%16 == 0) {
goto __14
}
ExtractPalettedAlphaRows(tls, dec, row)
@@ -12118,7 +11858,7 @@ __14:
goto __12
__13:
;
- if !((pos < last) && ((col & mask) != 0)) {
+ if !(pos < last && col&mask != 0) {
goto __15
}
htree_group = GetHtreeGroupForPos(tls, hdr, col, row)
@@ -12146,7 +11886,7 @@ __2:
End:
(*VP8LBitReader)(unsafe.Pointer(br)).eos_ = VP8LIsEndOfStream(tls, br)
- if !(!(ok != 0) || (((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0) && (pos < end))) {
+ if !(!(ok != 0) || (*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0 && pos < end) {
goto __16
}
ok = 0
@@ -12169,7 +11909,7 @@ func SaveState(tls *libc.TLS, dec uintptr, last_pixel int32) { /* vp8l_dec.c:109
(*VP8LDecoder)(unsafe.Pointer(dec)).saved_br_ = (*VP8LDecoder)(unsafe.Pointer(dec)).br_
(*VP8LDecoder)(unsafe.Pointer(dec)).saved_last_pixel_ = last_pixel
if (*VP8LDecoder)(unsafe.Pointer(dec)).hdr_.color_cache_size_ > 0 {
- VP8LColorCacheCopy(tls, ((dec + 152 /* &.hdr_ */) + 8 /* &.color_cache_ */), ((dec + 152 /* &.hdr_ */) + 24 /* &.saved_color_cache_ */))
+ VP8LColorCacheCopy(tls, dec+152+8, dec+152+24)
}
}
@@ -12179,7 +11919,7 @@ func RestoreState(tls *libc.TLS, dec uintptr) { /* vp8l_dec.c:1103:13: */
(*VP8LDecoder)(unsafe.Pointer(dec)).br_ = (*VP8LDecoder)(unsafe.Pointer(dec)).saved_br_
(*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ = (*VP8LDecoder)(unsafe.Pointer(dec)).saved_last_pixel_
if (*VP8LDecoder)(unsafe.Pointer(dec)).hdr_.color_cache_size_ > 0 {
- VP8LColorCacheCopy(tls, ((dec + 152 /* &.hdr_ */) + 24 /* &.saved_color_cache_ */), ((dec + 152 /* &.hdr_ */) + 8 /* &.color_cache_ */))
+ VP8LColorCacheCopy(tls, dec+152+24, dec+152+8)
}
}
@@ -12208,31 +11948,31 @@ func DecodeImageData(tls *libc.TLS, dec uintptr, data uintptr, width int32, heig
var dist_symbol int32 // Color cache
var key int32
var code int32
- row = ((*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ / width)
- col = ((*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ % width)
- br = (dec + 40 /* &.br_ */)
- hdr = (dec + 152 /* &.hdr_ */)
- src = (data + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_)*4)
+ row = (*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ / width
+ col = (*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ % width
+ br = dec + 40
+ hdr = dec + 152
+ src = data + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_)*4
last_cached = src
- src_end = (data + uintptr((width*height))*4)
- src_last = (data + uintptr((width*last_row))*4)
- len_code_limit = (256 + 24)
- color_cache_limit = (len_code_limit + (*VP8LMetadata)(unsafe.Pointer(hdr)).color_cache_size_)
+ src_end = data + uintptr(width*height)*4
+ src_last = data + uintptr(width*last_row)*4
+ len_code_limit = 256 + 24
+ color_cache_limit = len_code_limit + (*VP8LMetadata)(unsafe.Pointer(hdr)).color_cache_size_
if (*VP8LDecoder)(unsafe.Pointer(dec)).incremental_ != 0 {
next_sync_row = row
} else {
- next_sync_row = (int32(1) << 24)
+ next_sync_row = int32(1) << 24
}
if (*VP8LMetadata)(unsafe.Pointer(hdr)).color_cache_size_ > 0 {
- color_cache = (hdr + 8 /* &.color_cache_ */)
+ color_cache = hdr + 8
} else {
- color_cache = (uintptr(0))
+ color_cache = uintptr(0)
}
mask = (*VP8LMetadata)(unsafe.Pointer(hdr)).huffman_mask_
if src < src_last {
htree_group = GetHtreeGroupForPos(tls, hdr, col, row)
} else {
- htree_group = (uintptr(0))
+ htree_group = uintptr(0)
}
__1:
@@ -12242,14 +11982,14 @@ __1:
if !(row >= next_sync_row) {
goto __3
}
- SaveState(tls, dec, (int32((int64(src) - int64(data)) / 4)))
- next_sync_row = (row + 8)
+ SaveState(tls, dec, int32((int64(src)-int64(data))/4))
+ next_sync_row = row + 8
__3:
;
// Only update when changing tile. Note we could use this test:
// if "((((prev_col ^ col) | prev_row ^ row)) > mask)" -> tile changed
// but that's actually slower and needs storing the previous col/row.
- if !((col & mask) == 0) {
+ if !(col&mask == 0) {
goto __4
}
htree_group = GetHtreeGroupForPos(tls, hdr, col, row)
@@ -12282,7 +12022,7 @@ __9:
;
goto __7
__6:
- code = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer((htree_group /* &.htrees */))), br)
+ code = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer(htree_group)), br)
__7:
;
if !(VP8LIsEndOfStream(tls, br) != 0) {
@@ -12297,20 +12037,20 @@ __10:
if !((*HTreeGroup)(unsafe.Pointer(htree_group)).is_trivial_literal != 0) {
goto __13
}
- *(*uint32_t)(unsafe.Pointer(src)) = ((*HTreeGroup)(unsafe.Pointer(htree_group)).literal_arb | (uint32_t(code << 8)))
+ *(*uint32_t)(unsafe.Pointer(src)) = (*HTreeGroup)(unsafe.Pointer(htree_group)).literal_arb | uint32_t(code<<8)
goto __14
__13:
- red = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer((htree_group /* &.htrees */) + 1*8)), br)
+ red = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer(htree_group + 1*8)), br)
VP8LFillBitWindow(tls, br)
- blue = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer((htree_group /* &.htrees */) + 2*8)), br)
- alpha = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer((htree_group /* &.htrees */) + 3*8)), br)
+ blue = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer(htree_group + 2*8)), br)
+ alpha = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer(htree_group + 3*8)), br)
if !(VP8LIsEndOfStream(tls, br) != 0) {
goto __15
}
goto __2
__15:
;
- *(*uint32_t)(unsafe.Pointer(src)) = ((((uint32_t(alpha) << 24) | (uint32_t(red << 16))) | (uint32_t(code << 8))) | uint32_t(blue))
+ *(*uint32_t)(unsafe.Pointer(src)) = uint32_t(alpha)<<24 | uint32_t(red<<16) | uint32_t(code<<8) | uint32_t(blue)
__14:
;
AdvanceByOne:
@@ -12321,10 +12061,10 @@ AdvanceByOne:
}
col = 0
row++
- if !(process_func != (uintptr(0))) {
+ if !(process_func != uintptr(0)) {
goto __17
}
- if !((row <= last_row) && ((row % 16) == 0)) {
+ if !(row <= last_row && row%16 == 0) {
goto __18
}
(*struct {
@@ -12334,7 +12074,7 @@ __18:
;
__17:
;
- if !(color_cache != (uintptr(0))) {
+ if !(color_cache != uintptr(0)) {
goto __19
}
__20:
@@ -12354,9 +12094,9 @@ __11:
if !(code < len_code_limit) {
goto __22
}
- length_sym = (code - 256)
+ length_sym = code - 256
length = GetCopyLength(tls, length_sym, br)
- dist_symbol = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer((htree_group /* &.htrees */) + 4*8)), br)
+ dist_symbol = ReadSymbol(tls, *(*uintptr)(unsafe.Pointer(htree_group + 4*8)), br)
VP8LFillBitWindow(tls, br)
dist_code = GetCopyDistance(tls, dist_symbol, br)
dist = PlaneCodeToDistance(tls, width, dist_code)
@@ -12367,7 +12107,7 @@ __11:
goto __2
__24:
;
- if !((((int64(src) - int64(data)) / 4) < ptrdiff_t(dist)) || (((int64(src_end) - int64(src)) / 4) < ptrdiff_t(length))) {
+ if !((int64(src)-int64(data))/4 < ptrdiff_t(dist) || (int64(src_end)-int64(src))/4 < ptrdiff_t(length)) {
goto __25
}
goto Error
@@ -12376,18 +12116,18 @@ __25:
CopyBlock32b(tls, src, dist, length)
__26:
;
- src += 4 * (uintptr(length))
- col = col + (length)
+ src += 4 * uintptr(length)
+ col = col + length
__27:
if !(col >= width) {
goto __28
}
- col = col - (width)
+ col = col - width
row++
- if !(process_func != (uintptr(0))) {
+ if !(process_func != uintptr(0)) {
goto __29
}
- if !((row <= last_row) && ((row % 16) == 0)) {
+ if !(row <= last_row && row%16 == 0) {
goto __30
}
(*struct {
@@ -12403,13 +12143,13 @@ __28:
// Because of the check done above (before 'src' was incremented by
// 'length'), the following holds true.
- if !((col & mask) != 0) {
+ if !(col&mask != 0) {
goto __31
}
htree_group = GetHtreeGroupForPos(tls, hdr, col, row)
__31:
;
- if !(color_cache != (uintptr(0))) {
+ if !(color_cache != uintptr(0)) {
goto __32
}
__33:
@@ -12427,7 +12167,7 @@ __22:
if !(code < color_cache_limit) {
goto __35
} // Color cache
- key = (code - len_code_limit)
+ key = code - len_code_limit
__37:
if !(last_cached < src) {
@@ -12453,17 +12193,17 @@ __2:
;
(*VP8LBitReader)(unsafe.Pointer(br)).eos_ = VP8LIsEndOfStream(tls, br)
- if !((((*VP8LDecoder)(unsafe.Pointer(dec)).incremental_ != 0) && ((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0)) && (src < src_end)) {
+ if !((*VP8LDecoder)(unsafe.Pointer(dec)).incremental_ != 0 && (*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0 && src < src_end) {
goto __39
}
RestoreState(tls, dec)
goto __40
__39:
- if !(!((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0)) {
+ if !!((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0) {
goto __41
}
// Process the remaining rows corresponding to last row-block.
- if !(process_func != (uintptr(0))) {
+ if !(process_func != uintptr(0)) {
goto __43
}
(*struct {
@@ -12477,7 +12217,7 @@ __39:
__43:
;
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OK
- (*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ = (int32((int64(src) - int64(data)) / 4)) // end-of-scan marker
+ (*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ = int32((int64(src) - int64(data)) / 4) // end-of-scan marker
goto __42
__41:
// if not incremental, and we are past the end of buffer (eos_=1), then this
@@ -12499,27 +12239,27 @@ Error:
func ClearTransform(tls *libc.TLS, transform uintptr) { /* vp8l_dec.c:1264:13: */
WebPSafeFree(tls, (*VP8LTransform)(unsafe.Pointer(transform)).data_)
- (*VP8LTransform)(unsafe.Pointer(transform)).data_ = (uintptr(0))
+ (*VP8LTransform)(unsafe.Pointer(transform)).data_ = uintptr(0)
}
// For security reason, we need to remap the color map to span
// the total possible bundled values, and not just the num_colors.
func ExpandColorMap(tls *libc.TLS, num_colors int32, transform uintptr) int32 { /* vp8l_dec.c:1271:12: */
var i int32
- var final_num_colors int32 = (int32(1) << (int32(8) >> (*VP8LTransform)(unsafe.Pointer(transform)).bits_))
+ var final_num_colors int32 = int32(1) << (int32(8) >> (*VP8LTransform)(unsafe.Pointer(transform)).bits_)
var new_color_map uintptr = WebPSafeMalloc(tls, uint64_t(final_num_colors),
uint64(unsafe.Sizeof(uint32_t(0))))
- if new_color_map == (uintptr(0)) {
+ if new_color_map == uintptr(0) {
return 0
} else {
var data uintptr = (*VP8LTransform)(unsafe.Pointer(transform)).data_
var new_data uintptr = new_color_map
*(*uint32_t)(unsafe.Pointer(new_color_map)) = *(*uint32_t)(unsafe.Pointer((*VP8LTransform)(unsafe.Pointer(transform)).data_))
- for i = 4; i < (4 * num_colors); i++ {
+ for i = 4; i < 4*num_colors; i++ {
// Equivalent to AddPixelEq(), on a byte-basis.
- *(*uint8_t)(unsafe.Pointer(new_data + uintptr(i))) = (uint8_t((int32(*(*uint8_t)(unsafe.Pointer(data + uintptr(i)))) + int32(*(*uint8_t)(unsafe.Pointer(new_data + uintptr((i - 4)))))) & 0xff))
+ *(*uint8_t)(unsafe.Pointer(new_data + uintptr(i))) = uint8_t((int32(*(*uint8_t)(unsafe.Pointer(data + uintptr(i)))) + int32(*(*uint8_t)(unsafe.Pointer(new_data + uintptr(i-4))))) & 0xff)
}
- for ; i < (4 * final_num_colors); i++ {
+ for ; i < 4*final_num_colors; i++ {
*(*uint8_t)(unsafe.Pointer(new_data + uintptr(i))) = uint8_t(0) // black tail.
}
WebPSafeFree(tls, (*VP8LTransform)(unsafe.Pointer(transform)).data_)
@@ -12530,36 +12270,36 @@ func ExpandColorMap(tls *libc.TLS, num_colors int32, transform uintptr) int32 {
func ReadTransform(tls *libc.TLS, xsize uintptr, ysize uintptr, dec uintptr) int32 { /* vp8l_dec.c:1296:12: */
var ok int32 = 1
- var br uintptr = (dec + 40 /* &.br_ */)
- var transform uintptr = ((dec + 248 /* &.transforms_ */) + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).next_transform_)*24)
+ var br uintptr = dec + 40
+ var transform uintptr = dec + 248 + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).next_transform_)*24
var type1 VP8LImageTransformType = VP8LReadBits(tls, br, 2)
// Each transform type can only be present once in the stream.
- if ((*VP8LDecoder)(unsafe.Pointer(dec)).transforms_seen_ & (uint32(1) << type1)) != 0 {
+ if (*VP8LDecoder)(unsafe.Pointer(dec)).transforms_seen_&(uint32(1)<<type1) != 0 {
return 0 // Already there, let's not accept the second same transform.
}
- *(*uint32_t)(unsafe.Pointer((dec + 344 /* &.transforms_seen_ */))) |= (uint32(1) << type1)
+ *(*uint32_t)(unsafe.Pointer(dec + 344)) |= uint32(1) << type1
(*VP8LTransform)(unsafe.Pointer(transform)).type_ = type1
(*VP8LTransform)(unsafe.Pointer(transform)).xsize_ = *(*int32)(unsafe.Pointer(xsize))
(*VP8LTransform)(unsafe.Pointer(transform)).ysize_ = *(*int32)(unsafe.Pointer(ysize))
- (*VP8LTransform)(unsafe.Pointer(transform)).data_ = (uintptr(0))
+ (*VP8LTransform)(unsafe.Pointer(transform)).data_ = uintptr(0)
(*VP8LDecoder)(unsafe.Pointer(dec)).next_transform_++
switch type1 {
case PREDICTOR_TRANSFORM:
fallthrough
case CROSS_COLOR_TRANSFORM:
- (*VP8LTransform)(unsafe.Pointer(transform)).bits_ = (int32(VP8LReadBits(tls, br, 3) + uint32_t(2)))
+ (*VP8LTransform)(unsafe.Pointer(transform)).bits_ = int32(VP8LReadBits(tls, br, 3) + uint32_t(2))
ok = DecodeImageStream(tls, int32(VP8LSubSampleSize(tls, uint32((*VP8LTransform)(unsafe.Pointer(transform)).xsize_),
uint32((*VP8LTransform)(unsafe.Pointer(transform)).bits_))),
int32(VP8LSubSampleSize(tls, uint32((*VP8LTransform)(unsafe.Pointer(transform)).ysize_),
uint32((*VP8LTransform)(unsafe.Pointer(transform)).bits_))),
- 0, dec, (transform + 16 /* &.data_ */))
+ 0, dec, transform+16)
break
case COLOR_INDEXING_TRANSFORM:
{
- var num_colors int32 = (int32(VP8LReadBits(tls, br, 8) + uint32_t(1)))
+ var num_colors int32 = int32(VP8LReadBits(tls, br, 8) + uint32_t(1))
var bits int32
if num_colors > 16 {
bits = 0
@@ -12576,8 +12316,8 @@ func ReadTransform(tls *libc.TLS, xsize uintptr, ysize uintptr, dec uintptr) int
}
*(*int32)(unsafe.Pointer(xsize)) = int32(VP8LSubSampleSize(tls, uint32((*VP8LTransform)(unsafe.Pointer(transform)).xsize_), uint32(bits)))
(*VP8LTransform)(unsafe.Pointer(transform)).bits_ = bits
- ok = DecodeImageStream(tls, num_colors, 1, 0, dec, (transform + 16 /* &.data_ */))
- ok = (libc.Bool32((ok != 0) && (ExpandColorMap(tls, num_colors, transform) != 0)))
+ ok = DecodeImageStream(tls, num_colors, 1, 0, dec, transform+16)
+ ok = libc.Bool32(ok != 0 && ExpandColorMap(tls, num_colors, transform) != 0)
break
}
@@ -12604,8 +12344,8 @@ func ClearMetadata(tls *libc.TLS, hdr uintptr) { /* vp8l_dec.c:1357:13: */
WebPSafeFree(tls, (*VP8LMetadata)(unsafe.Pointer(hdr)).huffman_image_)
WebPSafeFree(tls, (*VP8LMetadata)(unsafe.Pointer(hdr)).huffman_tables_)
VP8LHtreeGroupsFree(tls, (*VP8LMetadata)(unsafe.Pointer(hdr)).htree_groups_)
- VP8LColorCacheClear(tls, (hdr + 8 /* &.color_cache_ */))
- VP8LColorCacheClear(tls, (hdr + 24 /* &.saved_color_cache_ */))
+ VP8LColorCacheClear(tls, hdr+8)
+ VP8LColorCacheClear(tls, hdr+24)
InitMetadata(tls, hdr)
}
@@ -12614,8 +12354,8 @@ func ClearMetadata(tls *libc.TLS, hdr uintptr) { /* vp8l_dec.c:1357:13: */
func VP8LNew(tls *libc.TLS) uintptr { /* vp8l_dec.c:1371:12: */
var dec uintptr = WebPSafeCalloc(tls, 1, uint64(unsafe.Sizeof(VP8LDecoder{})))
- if dec == (uintptr(0)) {
- return (uintptr(0))
+ if dec == uintptr(0) {
+ return uintptr(0)
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OK
(*VP8LDecoder)(unsafe.Pointer(dec)).state_ = READ_DIM
@@ -12627,34 +12367,34 @@ func VP8LNew(tls *libc.TLS) uintptr { /* vp8l_dec.c:1371:12: */
func VP8LClear(tls *libc.TLS, dec uintptr) { /* vp8l_dec.c:1382:6: */
var i int32
- if dec == (uintptr(0)) {
+ if dec == uintptr(0) {
return
}
- ClearMetadata(tls, (dec + 152 /* &.hdr_ */))
+ ClearMetadata(tls, dec+152)
WebPSafeFree(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_)
- (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ = (uintptr(0))
+ (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ = uintptr(0)
for i = 0; i < (*VP8LDecoder)(unsafe.Pointer(dec)).next_transform_; i++ {
- ClearTransform(tls, ((dec + 248 /* &.transforms_ */) + uintptr(i)*24))
+ ClearTransform(tls, dec+248+uintptr(i)*24)
}
(*VP8LDecoder)(unsafe.Pointer(dec)).next_transform_ = 0
(*VP8LDecoder)(unsafe.Pointer(dec)).transforms_seen_ = uint32_t(0)
WebPSafeFree(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).rescaler_memory)
- (*VP8LDecoder)(unsafe.Pointer(dec)).rescaler_memory = (uintptr(0))
+ (*VP8LDecoder)(unsafe.Pointer(dec)).rescaler_memory = uintptr(0)
- (*VP8LDecoder)(unsafe.Pointer(dec)).output_ = (uintptr(0)) // leave no trace behind
+ (*VP8LDecoder)(unsafe.Pointer(dec)).output_ = uintptr(0) // leave no trace behind
}
func VP8LDelete(tls *libc.TLS, dec uintptr) { /* vp8l_dec.c:1401:6: */
- if dec != (uintptr(0)) {
+ if dec != uintptr(0) {
VP8LClear(tls, dec)
WebPSafeFree(tls, dec)
}
}
func UpdateDecoder(tls *libc.TLS, dec uintptr, width int32, height int32) { /* vp8l_dec.c:1408:13: */
- var hdr uintptr = (dec + 152 /* &.hdr_ */)
+ var hdr uintptr = dec + 152
var num_bits int32 = (*VP8LMetadata)(unsafe.Pointer(hdr)).huffman_subsample_bits_
(*VP8LDecoder)(unsafe.Pointer(dec)).width_ = width
(*VP8LDecoder)(unsafe.Pointer(dec)).height_ = height
@@ -12664,7 +12404,7 @@ func UpdateDecoder(tls *libc.TLS, dec uintptr, width int32, height int32) { /* v
if num_bits == 0 {
return libc.CplInt32(0)
}
- return ((int32(1) << num_bits) - 1)
+ return int32(1)<<num_bits - 1
}()
}
@@ -12685,9 +12425,9 @@ func DecodeImageStream(tls *libc.TLS, xsize int32, ysize int32, is_level0 int32,
ok = 1
*(*int32)(unsafe.Pointer(bp /* transform_xsize */)) = xsize
*(*int32)(unsafe.Pointer(bp + 4 /* transform_ysize */)) = ysize
- br = (dec + 40 /* &.br_ */)
- hdr = (dec + 152 /* &.hdr_ */)
- data = (uintptr(0))
+ br = dec + 40
+ hdr = dec + 152
+ data = uintptr(0)
color_cache_bits = 0
// Read the transforms (may recurse).
@@ -12695,10 +12435,10 @@ func DecodeImageStream(tls *libc.TLS, xsize int32, ysize int32, is_level0 int32,
goto __1
}
__2:
- if !((ok != 0) && (VP8LReadBits(tls, br, 1) != 0)) {
+ if !(ok != 0 && VP8LReadBits(tls, br, 1) != 0) {
goto __3
}
- ok = ReadTransform(tls, (bp) /* &transform_xsize */, (bp + 4) /* &transform_ysize */, dec)
+ ok = ReadTransform(tls, bp, bp+4, dec)
goto __2
__3:
;
@@ -12706,12 +12446,12 @@ __1:
;
// Color cache
- if !((ok != 0) && (VP8LReadBits(tls, br, 1) != 0)) {
+ if !(ok != 0 && VP8LReadBits(tls, br, 1) != 0) {
goto __4
}
color_cache_bits = int32(VP8LReadBits(tls, br, 4))
- ok = (libc.Bool32((color_cache_bits >= 1) && (color_cache_bits <= 11)))
- if !(!(ok != 0)) {
+ ok = libc.Bool32(color_cache_bits >= 1 && color_cache_bits <= 11)
+ if !!(ok != 0) {
goto __5
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_BITSTREAM_ERROR
@@ -12722,9 +12462,9 @@ __4:
;
// Read the Huffman codes (may recurse).
- ok = (libc.Bool32((ok != 0) && (ReadHuffmanCodes(tls, dec, *(*int32)(unsafe.Pointer(bp /* transform_xsize */)), *(*int32)(unsafe.Pointer(bp + 4 /* transform_ysize */)),
- color_cache_bits, is_level0) != 0)))
- if !(!(ok != 0)) {
+ ok = libc.Bool32(ok != 0 && ReadHuffmanCodes(tls, dec, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)),
+ color_cache_bits, is_level0) != 0)
+ if !!(ok != 0) {
goto __6
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_BITSTREAM_ERROR
@@ -12736,8 +12476,8 @@ __6:
if !(color_cache_bits > 0) {
goto __7
}
- (*VP8LMetadata)(unsafe.Pointer(hdr)).color_cache_size_ = (int32(1) << color_cache_bits)
- if !(!(VP8LColorCacheInit(tls, (hdr+8 /* &.color_cache_ */), color_cache_bits) != 0)) {
+ (*VP8LMetadata)(unsafe.Pointer(hdr)).color_cache_size_ = int32(1) << color_cache_bits
+ if !!(VP8LColorCacheInit(tls, hdr+8, color_cache_bits) != 0) {
goto __9
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OUT_OF_MEMORY
@@ -12760,9 +12500,9 @@ __8:
__10:
;
- total_size = (uint64_t(*(*int32)(unsafe.Pointer(bp /* transform_xsize */))) * uint64_t(*(*int32)(unsafe.Pointer(bp + 4 /* transform_ysize */))))
+ total_size = uint64_t(*(*int32)(unsafe.Pointer(bp))) * uint64_t(*(*int32)(unsafe.Pointer(bp + 4)))
data = WebPSafeMalloc(tls, total_size, uint64(unsafe.Sizeof(uint32_t(0))))
- if !(data == (uintptr(0))) {
+ if !(data == uintptr(0)) {
goto __11
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OUT_OF_MEMORY
@@ -12773,18 +12513,18 @@ __11:
// Use the Huffman trees to decode the LZ77 encoded data.
ok = DecodeImageData(tls, dec, data, *(*int32)(unsafe.Pointer(bp /* transform_xsize */)), *(*int32)(unsafe.Pointer(bp + 4 /* transform_ysize */)),
- *(*int32)(unsafe.Pointer(bp + 4 /* transform_ysize */)), (uintptr(0)))
- ok = (libc.Bool32((ok != 0) && !((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0)))
+ *(*int32)(unsafe.Pointer(bp + 4 /* transform_ysize */)), uintptr(0))
+ ok = libc.Bool32(ok != 0 && !((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0))
End:
- if !(!(ok != 0)) {
+ if !!(ok != 0) {
goto __12
}
WebPSafeFree(tls, data)
ClearMetadata(tls, hdr)
goto __13
__12:
- if !(decoded_data != (uintptr(0))) {
+ if !(decoded_data != uintptr(0)) {
goto __14
}
*(*uintptr)(unsafe.Pointer(decoded_data)) = data
@@ -12797,7 +12537,7 @@ __14:
__15:
;
(*VP8LDecoder)(unsafe.Pointer(dec)).last_pixel_ = 0 // Reset for future DECODE_DATA_FUNC() calls.
- if !(!(is_level0 != 0)) {
+ if !!(is_level0 != 0) {
goto __16
}
ClearMetadata(tls, hdr)
@@ -12811,29 +12551,29 @@ __13:
//------------------------------------------------------------------------------
// Allocate internal buffers dec->pixels_ and dec->argb_cache_.
func AllocateInternalBuffers32b(tls *libc.TLS, dec uintptr, final_width int32) int32 { /* vp8l_dec.c:1509:12: */
- var num_pixels uint64_t = (uint64_t((*VP8LDecoder)(unsafe.Pointer(dec)).width_) * uint64_t((*VP8LDecoder)(unsafe.Pointer(dec)).height_))
+ var num_pixels uint64_t = uint64_t((*VP8LDecoder)(unsafe.Pointer(dec)).width_) * uint64_t((*VP8LDecoder)(unsafe.Pointer(dec)).height_)
// Scratch buffer corresponding to top-prediction row for transforming the
// first row in the row-blocks. Not needed for paletted alpha.
var cache_top_pixels uint64_t = uint64_t(uint16_t(final_width))
// Scratch buffer for temporary BGRA storage. Not needed for paletted alpha.
- var cache_pixels uint64_t = (uint64_t(final_width) * uint64(16))
- var total_num_pixels uint64_t = ((num_pixels + cache_top_pixels) + cache_pixels)
+ var cache_pixels uint64_t = uint64_t(final_width) * uint64(16)
+ var total_num_pixels uint64_t = num_pixels + cache_top_pixels + cache_pixels
(*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ = WebPSafeMalloc(tls, total_num_pixels, uint64(unsafe.Sizeof(uint32_t(0))))
- if (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ == (uintptr(0)) {
- (*VP8LDecoder)(unsafe.Pointer(dec)).argb_cache_ = (uintptr(0)) // for soundness
+ if (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ == uintptr(0) {
+ (*VP8LDecoder)(unsafe.Pointer(dec)).argb_cache_ = uintptr(0) // for soundness
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OUT_OF_MEMORY
return 0
}
- (*VP8LDecoder)(unsafe.Pointer(dec)).argb_cache_ = (((*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ + uintptr(num_pixels)*4) + uintptr(cache_top_pixels)*4)
+ (*VP8LDecoder)(unsafe.Pointer(dec)).argb_cache_ = (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ + uintptr(num_pixels)*4 + uintptr(cache_top_pixels)*4
return 1
}
func AllocateInternalBuffers8b(tls *libc.TLS, dec uintptr) int32 { /* vp8l_dec.c:1530:12: */
- var total_num_pixels uint64_t = (uint64_t((*VP8LDecoder)(unsafe.Pointer(dec)).width_) * uint64_t((*VP8LDecoder)(unsafe.Pointer(dec)).height_))
- (*VP8LDecoder)(unsafe.Pointer(dec)).argb_cache_ = (uintptr(0)) // for soundness
+ var total_num_pixels uint64_t = uint64_t((*VP8LDecoder)(unsafe.Pointer(dec)).width_) * uint64_t((*VP8LDecoder)(unsafe.Pointer(dec)).height_)
+ (*VP8LDecoder)(unsafe.Pointer(dec)).argb_cache_ = uintptr(0) // for soundness
(*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ = WebPSafeMalloc(tls, total_num_pixels, uint64(unsafe.Sizeof(uint8_t(0))))
- if (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ == (uintptr(0)) {
+ if (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ == uintptr(0) {
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OUT_OF_MEMORY
return 0
}
@@ -12845,8 +12585,8 @@ func AllocateInternalBuffers8b(tls *libc.TLS, dec uintptr) int32 { /* vp8l_dec.c
// Special row-processing that only stores the alpha data.
func ExtractAlphaRows(tls *libc.TLS, dec uintptr, last_row int32) { /* vp8l_dec.c:1544:13: */
var cur_row int32 = (*VP8LDecoder)(unsafe.Pointer(dec)).last_row_
- var num_rows int32 = (last_row - cur_row)
- var in uintptr = ((*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ + uintptr(((*VP8LDecoder)(unsafe.Pointer(dec)).width_*cur_row))*4)
+ var num_rows int32 = last_row - cur_row
+ var in uintptr = (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_ + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).width_*cur_row)*4
for num_rows > 0 {
var num_rows_to_process int32
@@ -12859,21 +12599,21 @@ func ExtractAlphaRows(tls *libc.TLS, dec uintptr, last_row int32) { /* vp8l_dec.
var alph_dec uintptr = (*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).io_)).opaque
var output uintptr = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).output_
var width int32 = (*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).io_)).width // the final width (!= dec->width_)
- var cache_pixs int32 = (width * num_rows_to_process)
- var dst uintptr = (output + uintptr((width * cur_row)))
+ var cache_pixs int32 = width * num_rows_to_process
+ var dst uintptr = output + uintptr(width*cur_row)
var src uintptr = (*VP8LDecoder)(unsafe.Pointer(dec)).argb_cache_
ApplyInverseTransforms(tls, dec, cur_row, num_rows_to_process, in)
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
})(unsafe.Pointer(&struct{ uintptr }{WebPExtractGreen})).f(tls, src, dst, cache_pixs)
AlphaApplyFilter(tls, alph_dec,
- cur_row, (cur_row + num_rows_to_process), dst, width)
- num_rows = num_rows - (num_rows_to_process)
- in += 4 * (uintptr(num_rows_to_process * (*VP8LDecoder)(unsafe.Pointer(dec)).width_))
- cur_row = cur_row + (num_rows_to_process)
+ cur_row, cur_row+num_rows_to_process, dst, width)
+ num_rows = num_rows - num_rows_to_process
+ in += 4 * uintptr(num_rows_to_process*(*VP8LDecoder)(unsafe.Pointer(dec)).width_)
+ cur_row = cur_row + num_rows_to_process
}
- (*VP8LDecoder)(unsafe.Pointer(dec)).last_row_ = libc.AssignPtrInt32((dec + 148 /* &.last_out_row_ */), last_row)
+ (*VP8LDecoder)(unsafe.Pointer(dec)).last_row_ = libc.AssignPtrInt32(dec+148, last_row)
}
func VP8LDecodeAlphaHeader(tls *libc.TLS, alph_dec uintptr, data uintptr, data_size size_t) int32 { /* vp8l_dec.c:1572:5: */
@@ -12882,7 +12622,7 @@ func VP8LDecodeAlphaHeader(tls *libc.TLS, alph_dec uintptr, data uintptr, data_s
ok = 0
dec = VP8LNew(tls)
- if !(dec == (uintptr(0))) {
+ if !(dec == uintptr(0)) {
goto __1
}
return 0
@@ -12891,15 +12631,15 @@ __1:
(*VP8LDecoder)(unsafe.Pointer(dec)).width_ = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).width_
(*VP8LDecoder)(unsafe.Pointer(dec)).height_ = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).height_
- (*VP8LDecoder)(unsafe.Pointer(dec)).io_ = (alph_dec + 32 /* &.io_ */)
+ (*VP8LDecoder)(unsafe.Pointer(dec)).io_ = alph_dec + 32
(*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).io_)).opaque = alph_dec
(*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).io_)).width = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).width_
(*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).io_)).height = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).height_
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OK
- VP8LInitBitReader(tls, (dec + 40 /* &.br_ */), data, data_size)
+ VP8LInitBitReader(tls, dec+40, data, data_size)
- if !(!(DecodeImageStream(tls, (*ALPHDecoder)(unsafe.Pointer(alph_dec)).width_, (*ALPHDecoder)(unsafe.Pointer(alph_dec)).height_, 1, dec, (uintptr(0))) != 0)) {
+ if !!(DecodeImageStream(tls, (*ALPHDecoder)(unsafe.Pointer(alph_dec)).width_, (*ALPHDecoder)(unsafe.Pointer(alph_dec)).height_, 1, dec, uintptr(0)) != 0) {
goto __2
}
goto Err
@@ -12909,7 +12649,7 @@ __2:
// Special case: if alpha data uses only the color indexing transform and
// doesn't use color cache (a frequent case), we will use DecodeAlphaData()
// method that only needs allocation of 1 byte per pixel (alpha channel).
- if !((((*VP8LDecoder)(unsafe.Pointer(dec)).next_transform_ == 1) && ((*VP8LTransform)(unsafe.Pointer((dec + 248 /* &.transforms_ */))).type_ == COLOR_INDEXING_TRANSFORM)) && (Is8bOptimizable(tls, (dec+152 /* &.hdr_ */)) != 0)) {
+ if !((*VP8LDecoder)(unsafe.Pointer(dec)).next_transform_ == 1 && (*VP8LTransform)(unsafe.Pointer(dec+248)).type_ == COLOR_INDEXING_TRANSFORM && Is8bOptimizable(tls, dec+152) != 0) {
goto __3
}
(*ALPHDecoder)(unsafe.Pointer(alph_dec)).use_8b_decode_ = 1
@@ -12922,7 +12662,7 @@ __3:
__4:
;
- if !(!(ok != 0)) {
+ if !!(ok != 0) {
goto __5
}
goto Err
@@ -12972,13 +12712,13 @@ func VP8LDecodeHeader(tls *libc.TLS, dec uintptr, io uintptr) int32 { /* vp8l_de
// var has_alpha int32 at bp+8, 4
- if !(dec == (uintptr(0))) {
+ if !(dec == uintptr(0)) {
goto __1
}
return 0
__1:
;
- if !(io == (uintptr(0))) {
+ if !(io == uintptr(0)) {
goto __2
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_INVALID_PARAM
@@ -12988,8 +12728,8 @@ __2:
(*VP8LDecoder)(unsafe.Pointer(dec)).io_ = io
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OK
- VP8LInitBitReader(tls, (dec + 40 /* &.br_ */), (*VP8Io)(unsafe.Pointer(io)).data, (*VP8Io)(unsafe.Pointer(io)).data_size)
- if !(!(ReadImageInfo(tls, (dec+40 /* &.br_ */), (bp) /* &width */, (bp+4) /* &height */, (bp+8) /* &has_alpha */) != 0)) {
+ VP8LInitBitReader(tls, dec+40, (*VP8Io)(unsafe.Pointer(io)).data, (*VP8Io)(unsafe.Pointer(io)).data_size)
+ if !!(ReadImageInfo(tls, dec+40, bp, bp+4, bp+8) != 0) {
goto __3
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_BITSTREAM_ERROR
@@ -13000,7 +12740,7 @@ __3:
(*VP8Io)(unsafe.Pointer(io)).width = *(*int32)(unsafe.Pointer(bp /* width */))
(*VP8Io)(unsafe.Pointer(io)).height = *(*int32)(unsafe.Pointer(bp + 4 /* height */))
- if !(!(DecodeImageStream(tls, *(*int32)(unsafe.Pointer(bp /* width */)), *(*int32)(unsafe.Pointer(bp + 4 /* height */)), 1, dec, (uintptr(0))) != 0)) {
+ if !!(DecodeImageStream(tls, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), 1, dec, uintptr(0)) != 0) {
goto __4
}
goto Error
@@ -13017,10 +12757,10 @@ Error:
func VP8LDecodeImage(tls *libc.TLS, dec uintptr) int32 { /* vp8l_dec.c:1670:5: */
var io uintptr
var params uintptr
- io = (uintptr(0))
- params = (uintptr(0))
+ io = uintptr(0)
+ params = uintptr(0)
- if !(dec == (uintptr(0))) {
+ if !(dec == uintptr(0)) {
goto __1
}
return 0
@@ -13037,7 +12777,7 @@ __1:
}
(*VP8LDecoder)(unsafe.Pointer(dec)).output_ = (*WebPDecParams)(unsafe.Pointer(params)).output
- if !(!(WebPIoInitFromOptions(tls, (*WebPDecParams)(unsafe.Pointer(params)).options, io, MODE_BGRA) != 0)) {
+ if !!(WebPIoInitFromOptions(tls, (*WebPDecParams)(unsafe.Pointer(params)).options, io, MODE_BGRA) != 0) {
goto __3
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_INVALID_PARAM
@@ -13045,20 +12785,20 @@ __1:
__3:
;
- if !(!(AllocateInternalBuffers32b(tls, dec, (*VP8Io)(unsafe.Pointer(io)).width) != 0)) {
+ if !!(AllocateInternalBuffers32b(tls, dec, (*VP8Io)(unsafe.Pointer(io)).width) != 0) {
goto __4
}
goto Err
__4:
;
- if !(((*VP8Io)(unsafe.Pointer(io)).use_scaling != 0) && !(AllocateAndInitRescaler(tls, dec, io) != 0)) {
+ if !((*VP8Io)(unsafe.Pointer(io)).use_scaling != 0 && !(AllocateAndInitRescaler(tls, dec, io) != 0)) {
goto __5
}
goto Err
__5:
;
- if !(((*VP8Io)(unsafe.Pointer(io)).use_scaling != 0) || (WebPIsPremultipliedMode(tls, (*WebPDecBuffer)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).output_)).colorspace) != 0)) {
+ if !((*VP8Io)(unsafe.Pointer(io)).use_scaling != 0 || WebPIsPremultipliedMode(tls, (*WebPDecBuffer)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).output_)).colorspace) != 0) {
goto __6
}
// need the alpha-multiply functions for premultiplied output or rescaling
@@ -13066,11 +12806,11 @@ __5:
__6:
;
- if !(!(WebPIsRGBMode(tls, (*WebPDecBuffer)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).output_)).colorspace) != 0)) {
+ if !!(WebPIsRGBMode(tls, (*WebPDecBuffer)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).output_)).colorspace) != 0) {
goto __7
}
WebPInitConvertARGBToYUV(tls)
- if !((*WebPYUVABuffer)(unsafe.Pointer(((*VP8LDecoder)(unsafe.Pointer(dec)).output_ + 16 /* &.u */))).a != (uintptr(0))) {
+ if !((*WebPYUVABuffer)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).output_+16)).a != uintptr(0)) {
goto __8
}
WebPInitAlphaProcessing(tls)
@@ -13081,11 +12821,11 @@ __7:
if !((*VP8LDecoder)(unsafe.Pointer(dec)).incremental_ != 0) {
goto __9
}
- if !(((*VP8LDecoder)(unsafe.Pointer(dec)).hdr_.color_cache_size_ > 0) && ((*VP8LDecoder)(unsafe.Pointer(dec)).hdr_.saved_color_cache_.colors_ == (uintptr(0)))) {
+ if !((*VP8LDecoder)(unsafe.Pointer(dec)).hdr_.color_cache_size_ > 0 && (*VP8LDecoder)(unsafe.Pointer(dec)).hdr_.saved_color_cache_.colors_ == uintptr(0)) {
goto __10
}
- if !(!(VP8LColorCacheInit(tls, ((dec+152 /* &.hdr_ */)+24 /* &.saved_color_cache_ */),
- (*VP8LDecoder)(unsafe.Pointer(dec)).hdr_.color_cache_.hash_bits_) != 0)) {
+ if !!(VP8LColorCacheInit(tls, dec+152+24,
+ (*VP8LDecoder)(unsafe.Pointer(dec)).hdr_.color_cache_.hash_bits_) != 0) {
goto __11
}
(*VP8LDecoder)(unsafe.Pointer(dec)).status_ = VP8_STATUS_OUT_OF_MEMORY
@@ -13101,10 +12841,10 @@ __2:
;
// Decode.
- if !(!(DecodeImageData(tls, dec, (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_, (*VP8LDecoder)(unsafe.Pointer(dec)).width_, (*VP8LDecoder)(unsafe.Pointer(dec)).height_,
+ if !!(DecodeImageData(tls, dec, (*VP8LDecoder)(unsafe.Pointer(dec)).pixels_, (*VP8LDecoder)(unsafe.Pointer(dec)).width_, (*VP8LDecoder)(unsafe.Pointer(dec)).height_,
(*VP8Io)(unsafe.Pointer(io)).crop_bottom, *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, int32)
- }{ProcessRows}))) != 0)) {
+ }{ProcessRows}))) != 0) {
goto __12
}
goto Err
@@ -13246,7 +12986,7 @@ type WebPMuxAnimBlend = uint32 /* mux_types.h:54:3 */
// Initializes the contents of the 'webp_data' object with default values.
func WebPDataInit(tls *libc.TLS, webp_data uintptr) { /* mux_types.h:65:25: */
- if webp_data != (uintptr(0)) {
+ if webp_data != uintptr(0) {
libc.Xmemset(tls, webp_data, 0, uint64(unsafe.Sizeof(WebPData{})))
}
}
@@ -13286,25 +13026,25 @@ func WebPDataInit(tls *libc.TLS, webp_data uintptr) { /* mux_types.h:65:25: */
func ParseRIFF(tls *libc.TLS, data uintptr, data_size uintptr, have_all_data int32, riff_size uintptr) VP8StatusCode { /* webp_dec.c:54:22: */
*(*size_t)(unsafe.Pointer(riff_size)) = uint64(0) // Default: no RIFF present.
- if (*(*size_t)(unsafe.Pointer(data_size)) >= uint64(12)) && !(libc.Xmemcmp(tls, *(*uintptr)(unsafe.Pointer(data)), (ts+527) /* "RIFF" */, uint64(4)) != 0) {
- if libc.Xmemcmp(tls, (*(*uintptr)(unsafe.Pointer(data))+uintptr(8)), (ts+532) /* "WEBP" */, uint64(4)) != 0 {
+ if *(*size_t)(unsafe.Pointer(data_size)) >= uint64(12) && !(libc.Xmemcmp(tls, *(*uintptr)(unsafe.Pointer(data)), ts+527, uint64(4)) != 0) {
+ if libc.Xmemcmp(tls, *(*uintptr)(unsafe.Pointer(data))+uintptr(8), ts+532, uint64(4)) != 0 {
return VP8_STATUS_BITSTREAM_ERROR // Wrong image file signature.
} else {
- var size uint32_t = GetLE32(tls, (*(*uintptr)(unsafe.Pointer(data)) + uintptr(4)))
+ var size uint32_t = GetLE32(tls, *(*uintptr)(unsafe.Pointer(data))+uintptr(4))
// Check that we have at least one chunk (i.e "WEBP" + "VP8?nnnn").
- if size < (uint32_t(4 + 8)) {
+ if size < uint32_t(4+8) {
return VP8_STATUS_BITSTREAM_ERROR
}
- if size > ((libc.CplUint32(0) - uint32(8)) - uint32(1)) {
+ if size > libc.CplUint32(0)-uint32(8)-uint32(1) {
return VP8_STATUS_BITSTREAM_ERROR
}
- if (have_all_data != 0) && (size_t(size) > (*(*size_t)(unsafe.Pointer(data_size)) - uint64(8))) {
+ if have_all_data != 0 && size_t(size) > *(*size_t)(unsafe.Pointer(data_size))-uint64(8) {
return VP8_STATUS_NOT_ENOUGH_DATA // Truncated bitstream.
}
// We have a RIFF container. Skip it.
*(*size_t)(unsafe.Pointer(riff_size)) = size_t(size)
- *(*uintptr)(unsafe.Pointer(data)) += (uintptr(12))
- *(*size_t)(unsafe.Pointer(data_size)) -= (uint64(12))
+ *(*uintptr)(unsafe.Pointer(data)) += uintptr(12)
+ *(*size_t)(unsafe.Pointer(data_size)) -= uint64(12)
}
}
return VP8_STATUS_OK
@@ -13318,7 +13058,7 @@ func ParseRIFF(tls *libc.TLS, data uintptr, data_size uintptr, have_all_data int
// *height_ptr and *flags_ptr are set to the corresponding values extracted
// from the VP8X chunk.
func ParseVP8X(tls *libc.TLS, data uintptr, data_size uintptr, found_vp8x uintptr, width_ptr uintptr, height_ptr uintptr, flags_ptr uintptr) VP8StatusCode { /* webp_dec.c:93:22: */
- var vp8x_size uint32_t = (uint32_t(8 + 10))
+ var vp8x_size uint32_t = uint32_t(8 + 10)
*(*int32)(unsafe.Pointer(found_vp8x)) = 0
@@ -13326,11 +13066,11 @@ func ParseVP8X(tls *libc.TLS, data uintptr, data_size uintptr, found_vp8x uintpt
return VP8_STATUS_NOT_ENOUGH_DATA // Insufficient data.
}
- if !(libc.Xmemcmp(tls, *(*uintptr)(unsafe.Pointer(data)), (ts+537) /* "VP8X" */, uint64(4)) != 0) {
+ if !(libc.Xmemcmp(tls, *(*uintptr)(unsafe.Pointer(data)), ts+537, uint64(4)) != 0) {
var width int32
var height int32
var flags uint32_t
- var chunk_size uint32_t = GetLE32(tls, (*(*uintptr)(unsafe.Pointer(data)) + uintptr(4)))
+ var chunk_size uint32_t = GetLE32(tls, *(*uintptr)(unsafe.Pointer(data))+uintptr(4))
if chunk_size != uint32_t(10) {
return VP8_STATUS_BITSTREAM_ERROR // Wrong chunk size.
}
@@ -13339,25 +13079,25 @@ func ParseVP8X(tls *libc.TLS, data uintptr, data_size uintptr, found_vp8x uintpt
if *(*size_t)(unsafe.Pointer(data_size)) < size_t(vp8x_size) {
return VP8_STATUS_NOT_ENOUGH_DATA // Insufficient data.
}
- flags = GetLE32(tls, (*(*uintptr)(unsafe.Pointer(data)) + uintptr(8)))
- width = (1 + GetLE24(tls, (*(*uintptr)(unsafe.Pointer(data))+uintptr(12))))
- height = (1 + GetLE24(tls, (*(*uintptr)(unsafe.Pointer(data))+uintptr(15))))
- if (uint64(uint64_t(width) * uint64_t(height))) >= (uint64(1) << 32) {
+ flags = GetLE32(tls, *(*uintptr)(unsafe.Pointer(data))+uintptr(8))
+ width = 1 + GetLE24(tls, *(*uintptr)(unsafe.Pointer(data))+uintptr(12))
+ height = 1 + GetLE24(tls, *(*uintptr)(unsafe.Pointer(data))+uintptr(15))
+ if uint64(uint64_t(width)*uint64_t(height)) >= uint64(1)<<32 {
return VP8_STATUS_BITSTREAM_ERROR // image is too large
}
- if flags_ptr != (uintptr(0)) {
+ if flags_ptr != uintptr(0) {
*(*uint32_t)(unsafe.Pointer(flags_ptr)) = flags
}
- if width_ptr != (uintptr(0)) {
+ if width_ptr != uintptr(0) {
*(*int32)(unsafe.Pointer(width_ptr)) = width
}
- if height_ptr != (uintptr(0)) {
+ if height_ptr != uintptr(0) {
*(*int32)(unsafe.Pointer(height_ptr)) = height
}
// Skip over VP8X header bytes.
- *(*uintptr)(unsafe.Pointer(data)) += (uintptr(vp8x_size))
- *(*size_t)(unsafe.Pointer(data_size)) -= (size_t(vp8x_size))
+ *(*uintptr)(unsafe.Pointer(data)) += uintptr(vp8x_size)
+ *(*size_t)(unsafe.Pointer(data_size)) -= size_t(vp8x_size)
*(*int32)(unsafe.Pointer(found_vp8x)) = 1
}
return VP8_STATUS_OK
@@ -13373,12 +13113,12 @@ func ParseVP8X(tls *libc.TLS, data uintptr, data_size uintptr, found_vp8x uintpt
func ParseOptionalChunks(tls *libc.TLS, data uintptr, data_size uintptr, riff_size size_t, alpha_data uintptr, alpha_size uintptr) VP8StatusCode { /* webp_dec.c:146:22: */
var buf uintptr
var buf_size size_t
- var total_size uint32_t = (uint32_t((4 + 8) + 10)) // data.
+ var total_size uint32_t = uint32_t(4 + 8 + 10) // data.
buf = *(*uintptr)(unsafe.Pointer(data))
buf_size = *(*size_t)(unsafe.Pointer(data_size))
- *(*uintptr)(unsafe.Pointer(alpha_data)) = (uintptr(0))
+ *(*uintptr)(unsafe.Pointer(alpha_data)) = uintptr(0)
*(*size_t)(unsafe.Pointer(alpha_size)) = uint64(0)
for 1 != 0 {
@@ -13392,16 +13132,16 @@ func ParseOptionalChunks(tls *libc.TLS, data uintptr, data_size uintptr, riff_si
return VP8_STATUS_NOT_ENOUGH_DATA
}
- chunk_size = GetLE32(tls, (buf + uintptr(4)))
- if chunk_size > ((libc.CplUint32(0) - uint32(8)) - uint32(1)) {
+ chunk_size = GetLE32(tls, buf+uintptr(4))
+ if chunk_size > libc.CplUint32(0)-uint32(8)-uint32(1) {
return VP8_STATUS_BITSTREAM_ERROR // Not a valid chunk size.
}
// For odd-sized chunk-payload, there's one byte padding at the end.
- disk_chunk_size = (((uint32_t(8) + chunk_size) + uint32_t(1)) & libc.Uint32FromInt32(libc.CplInt32(1)))
- total_size = total_size + (disk_chunk_size)
+ disk_chunk_size = (uint32_t(8) + chunk_size + uint32_t(1)) & libc.Uint32FromInt32(libc.CplInt32(1))
+ total_size = total_size + disk_chunk_size
// Check that total bytes skipped so far does not exceed riff_size.
- if (riff_size > uint64(0)) && (size_t(total_size) > riff_size) {
+ if riff_size > uint64(0) && size_t(total_size) > riff_size {
return VP8_STATUS_BITSTREAM_ERROR // Not a valid chunk size.
}
@@ -13409,7 +13149,7 @@ func ParseOptionalChunks(tls *libc.TLS, data uintptr, data_size uintptr, riff_si
// parsed all the optional chunks.
// Note: This check must occur before the check 'buf_size < disk_chunk_size'
// below to allow incomplete VP8/VP8L chunks.
- if !(libc.Xmemcmp(tls, buf, (ts+542) /* "VP8 " */, uint64(4)) != 0) || !(libc.Xmemcmp(tls, buf, (ts+547) /* "VP8L" */, uint64(4)) != 0) {
+ if !(libc.Xmemcmp(tls, buf, ts+542, uint64(4)) != 0) || !(libc.Xmemcmp(tls, buf, ts+547, uint64(4)) != 0) {
return VP8_STATUS_OK
}
@@ -13417,14 +13157,14 @@ func ParseOptionalChunks(tls *libc.TLS, data uintptr, data_size uintptr, riff_si
return VP8_STATUS_NOT_ENOUGH_DATA
}
- if !(libc.Xmemcmp(tls, buf, (ts+552) /* "ALPH" */, uint64(4)) != 0) { // A valid ALPH header.
- *(*uintptr)(unsafe.Pointer(alpha_data)) = (buf + uintptr(8))
+ if !(libc.Xmemcmp(tls, buf, ts+552, uint64(4)) != 0) { // A valid ALPH header.
+ *(*uintptr)(unsafe.Pointer(alpha_data)) = buf + uintptr(8)
*(*size_t)(unsafe.Pointer(alpha_size)) = size_t(chunk_size)
}
// We have a full and valid chunk; skip it.
buf += uintptr(disk_chunk_size)
- buf_size = buf_size - (size_t(disk_chunk_size))
+ buf_size = buf_size - size_t(disk_chunk_size)
}
return VP8StatusCode(0)
}
@@ -13439,28 +13179,28 @@ func ParseOptionalChunks(tls *libc.TLS, data uintptr, data_size uintptr, riff_si
// The flag '*is_lossless' is set to 1 in case of VP8L chunk / raw VP8L data.
func ParseVP8Header(tls *libc.TLS, data_ptr uintptr, data_size uintptr, have_all_data int32, riff_size size_t, chunk_size uintptr, is_lossless uintptr) VP8StatusCode { /* webp_dec.c:222:22: */
var data uintptr = *(*uintptr)(unsafe.Pointer(data_ptr))
- var is_vp8 int32 = libc.BoolInt32(!(libc.Xmemcmp(tls, data, (ts+542) /* "VP8 " */, uint64(4)) != 0))
- var is_vp8l int32 = libc.BoolInt32(!(libc.Xmemcmp(tls, data, (ts+547) /* "VP8L" */, uint64(4)) != 0))
- var minimal_size uint32_t = (uint32_t(4 + 8)) // "WEBP" + "VP8 nnnn" OR
+ var is_vp8 int32 = libc.BoolInt32(!(libc.Xmemcmp(tls, data, ts+542, uint64(4)) != 0))
+ var is_vp8l int32 = libc.BoolInt32(!(libc.Xmemcmp(tls, data, ts+547, uint64(4)) != 0))
+ var minimal_size uint32_t = uint32_t(4 + 8) // "WEBP" + "VP8 nnnn" OR
// "WEBP" + "VP8Lnnnn"
if *(*size_t)(unsafe.Pointer(data_size)) < uint64(8) {
return VP8_STATUS_NOT_ENOUGH_DATA // Insufficient data.
}
- if (is_vp8 != 0) || (is_vp8l != 0) {
+ if is_vp8 != 0 || is_vp8l != 0 {
// Bitstream contains VP8/VP8L header.
- var size uint32_t = GetLE32(tls, (data + uintptr(4)))
- if (riff_size >= size_t(minimal_size)) && (size_t(size) > (riff_size - size_t(minimal_size))) {
+ var size uint32_t = GetLE32(tls, data+uintptr(4))
+ if riff_size >= size_t(minimal_size) && size_t(size) > riff_size-size_t(minimal_size) {
return VP8_STATUS_BITSTREAM_ERROR // Inconsistent size information.
}
- if (have_all_data != 0) && (size_t(size) > (*(*size_t)(unsafe.Pointer(data_size)) - uint64(8))) {
+ if have_all_data != 0 && size_t(size) > *(*size_t)(unsafe.Pointer(data_size))-uint64(8) {
return VP8_STATUS_NOT_ENOUGH_DATA // Truncated bitstream.
}
// Skip over CHUNK_HEADER_SIZE bytes from VP8/VP8L Header.
*(*size_t)(unsafe.Pointer(chunk_size)) = size_t(size)
- *(*uintptr)(unsafe.Pointer(data_ptr)) += (uintptr(8))
- *(*size_t)(unsafe.Pointer(data_size)) -= (uint64(8))
+ *(*uintptr)(unsafe.Pointer(data_ptr)) += uintptr(8)
+ *(*size_t)(unsafe.Pointer(data_size)) -= uint64(8)
*(*int32)(unsafe.Pointer(is_lossless)) = is_vp8l
} else {
// Raw VP8/VP8L bitstream (no header).
@@ -13514,45 +13254,45 @@ func ParseHeadersInternal(tls *libc.TLS, data uintptr, data_size size_t, width u
found_riff = 0
*(*int32)(unsafe.Pointer(bp + 88 /* found_vp8x */)) = 0
animation_present = 0
- if headers != (uintptr(0)) {
+ if headers != uintptr(0) {
have_all_data = (*WebPHeaderStructure)(unsafe.Pointer(headers)).have_all_data
} else {
have_all_data = 0
}
- if !((*(*uintptr)(unsafe.Pointer(bp + 72 /* data */)) == (uintptr(0))) || (*(*size_t)(unsafe.Pointer(bp + 80 /* data_size */)) < uint64(12))) {
+ if !(*(*uintptr)(unsafe.Pointer(bp + 72)) == uintptr(0) || *(*size_t)(unsafe.Pointer(bp + 80)) < uint64(12)) {
goto __1
}
return VP8_STATUS_NOT_ENOUGH_DATA
__1:
;
- libc.Xmemset(tls, (bp) /* &hdrs */, 0, uint64(unsafe.Sizeof(WebPHeaderStructure{})))
+ libc.Xmemset(tls, bp, 0, uint64(unsafe.Sizeof(WebPHeaderStructure{})))
(*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).data = *(*uintptr)(unsafe.Pointer(bp + 72 /* data */))
(*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).data_size = *(*size_t)(unsafe.Pointer(bp + 80 /* data_size */))
// Skip over RIFF header.
- status = ParseRIFF(tls, (bp + 72) /* &data */, (bp + 80) /* &data_size */, have_all_data, ((bp) /* &hdrs */ + 56 /* &.riff_size */))
+ status = ParseRIFF(tls, bp+72, bp+80, have_all_data, bp+56)
if !(status != VP8_STATUS_OK) {
goto __2
}
return status // Wrong RIFF header / insufficient data.
__2:
;
- found_riff = (libc.Bool32((*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).riff_size > uint64(0)))
+ found_riff = libc.Bool32((*WebPHeaderStructure)(unsafe.Pointer(bp)).riff_size > uint64(0))
// Skip over VP8X.
*(*uint32_t)(unsafe.Pointer(bp + 100 /* flags */)) = uint32_t(0)
- status = ParseVP8X(tls, (bp + 72) /* &data */, (bp + 80) /* &data_size */, (bp + 88), /* &found_vp8x */
- (bp + 92) /* &canvas_width */, (bp + 96) /* &canvas_height */, (bp + 100) /* &flags */)
+ status = ParseVP8X(tls, bp+72, bp+80, bp+88,
+ bp+92, bp+96, bp+100)
if !(status != VP8_STATUS_OK) {
goto __3
}
return status // Wrong VP8X / insufficient data.
__3:
;
- animation_present = libc.BoolInt32(!(!((*(*uint32_t)(unsafe.Pointer(bp + 100 /* flags */)) & ANIMATION_FLAG) != 0)))
- if !(!(found_riff != 0) && (*(*int32)(unsafe.Pointer(bp + 88 /* found_vp8x */)) != 0)) {
+ animation_present = libc.BoolInt32(!!(*(*uint32_t)(unsafe.Pointer(bp + 100))&ANIMATION_FLAG != 0))
+ if !(!(found_riff != 0) && *(*int32)(unsafe.Pointer(bp + 88)) != 0) {
goto __4
}
// Note: This restriction may be removed in the future, if it becomes
@@ -13560,19 +13300,19 @@ __3:
return VP8_STATUS_BITSTREAM_ERROR
__4:
;
- if !(has_alpha != (uintptr(0))) {
+ if !(has_alpha != uintptr(0)) {
goto __5
}
- *(*int32)(unsafe.Pointer(has_alpha)) = libc.BoolInt32(!(!((*(*uint32_t)(unsafe.Pointer(bp + 100 /* flags */)) & ALPHA_FLAG) != 0)))
+ *(*int32)(unsafe.Pointer(has_alpha)) = libc.BoolInt32(!!(*(*uint32_t)(unsafe.Pointer(bp + 100))&ALPHA_FLAG != 0))
__5:
;
- if !(has_animation != (uintptr(0))) {
+ if !(has_animation != uintptr(0)) {
goto __6
}
*(*int32)(unsafe.Pointer(has_animation)) = animation_present
__6:
;
- if !(format != (uintptr(0))) {
+ if !(format != uintptr(0)) {
goto __7
}
*(*int32)(unsafe.Pointer(format)) = 0
@@ -13581,7 +13321,7 @@ __7:
*(*int32)(unsafe.Pointer(bp + 104 /* image_width */)) = *(*int32)(unsafe.Pointer(bp + 92 /* canvas_width */))
*(*int32)(unsafe.Pointer(bp + 108 /* image_height */)) = *(*int32)(unsafe.Pointer(bp + 96 /* canvas_height */))
- if !(((*(*int32)(unsafe.Pointer(bp + 88 /* found_vp8x */)) != 0) && (animation_present != 0)) && (headers == (uintptr(0)))) {
+ if !(*(*int32)(unsafe.Pointer(bp + 88)) != 0 && animation_present != 0 && headers == uintptr(0)) {
goto __8
}
status = VP8_STATUS_OK
@@ -13589,7 +13329,7 @@ __7:
__8:
;
- if !(*(*size_t)(unsafe.Pointer(bp + 80 /* data_size */)) < uint64(4)) {
+ if !(*(*size_t)(unsafe.Pointer(bp + 80)) < uint64(4)) {
goto __9
}
status = VP8_STATUS_NOT_ENOUGH_DATA
@@ -13598,11 +13338,11 @@ __9:
;
// Skip over optional chunks if data started with "RIFF + VP8X" or "ALPH".
- if !(((found_riff != 0) && (*(*int32)(unsafe.Pointer(bp + 88 /* found_vp8x */)) != 0)) || ((!(found_riff != 0) && !(*(*int32)(unsafe.Pointer(bp + 88 /* found_vp8x */)) != 0)) && !(libc.Xmemcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 72 /* data */)), (ts+552) /* "ALPH" */, uint64(4)) != 0))) {
+ if !(found_riff != 0 && *(*int32)(unsafe.Pointer(bp + 88)) != 0 || !(found_riff != 0) && !(*(*int32)(unsafe.Pointer(bp + 88)) != 0) && !(libc.Xmemcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 72)), ts+552, uint64(4)) != 0)) {
goto __10
}
- status = ParseOptionalChunks(tls, (bp + 72) /* &data */, (bp + 80) /* &data_size */, (*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).riff_size,
- ((bp) /* &hdrs */ + 32 /* &.alpha_data */), ((bp) /* &hdrs */ + 40 /* &.alpha_data_size */))
+ status = ParseOptionalChunks(tls, bp+72, bp+80, (*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).riff_size,
+ bp+32, bp+40)
if !(status != VP8_STATUS_OK) {
goto __11
}
@@ -13613,26 +13353,26 @@ __10:
;
// Skip over VP8/VP8L header.
- status = ParseVP8Header(tls, (bp + 72) /* &data */, (bp + 80) /* &data_size */, have_all_data, (*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).riff_size,
- ((bp) /* &hdrs */ + 48 /* &.compressed_size */), ((bp) /* &hdrs */ + 64 /* &.is_lossless */))
+ status = ParseVP8Header(tls, bp+72, bp+80, have_all_data, (*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).riff_size,
+ bp+48, bp+64)
if !(status != VP8_STATUS_OK) {
goto __12
}
goto ReturnWidthHeight // Wrong VP8/VP8L chunk-header / insufficient data.
__12:
;
- if !((*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).compressed_size > (uint64((libc.CplUint32(0) - uint32(8)) - uint32(1)))) {
+ if !((*WebPHeaderStructure)(unsafe.Pointer(bp)).compressed_size > uint64(libc.CplUint32(0)-uint32(8)-uint32(1))) {
goto __13
}
return VP8_STATUS_BITSTREAM_ERROR
__13:
;
- if !((format != (uintptr(0))) && !(animation_present != 0)) {
+ if !(format != uintptr(0) && !(animation_present != 0)) {
goto __14
}
*(*int32)(unsafe.Pointer(format)) = func() int32 {
- if (*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).is_lossless != 0 {
+ if (*WebPHeaderStructure)(unsafe.Pointer(bp)).is_lossless != 0 {
return 2
}
return 1
@@ -13640,10 +13380,10 @@ __13:
__14:
;
- if !(!((*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).is_lossless != 0)) {
+ if !!((*WebPHeaderStructure)(unsafe.Pointer(bp)).is_lossless != 0) {
goto __15
}
- if !(*(*size_t)(unsafe.Pointer(bp + 80 /* data_size */)) < uint64(10)) {
+ if !(*(*size_t)(unsafe.Pointer(bp + 80)) < uint64(10)) {
goto __17
}
status = VP8_STATUS_NOT_ENOUGH_DATA
@@ -13651,8 +13391,8 @@ __14:
__17:
;
// Validates raw VP8 data.
- if !(!(VP8GetInfo(tls, *(*uintptr)(unsafe.Pointer(bp + 72 /* data */)), *(*size_t)(unsafe.Pointer(bp + 80 /* data_size */)), uint64(uint32_t((*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).compressed_size)),
- (bp+104) /* &image_width */, (bp+108) /* &image_height */) != 0)) {
+ if !!(VP8GetInfo(tls, *(*uintptr)(unsafe.Pointer(bp + 72)), *(*size_t)(unsafe.Pointer(bp + 80)), uint64(uint32_t((*WebPHeaderStructure)(unsafe.Pointer(bp)).compressed_size)),
+ bp+104, bp+108) != 0) {
goto __18
}
return VP8_STATUS_BITSTREAM_ERROR
@@ -13660,7 +13400,7 @@ __18:
;
goto __16
__15:
- if !(*(*size_t)(unsafe.Pointer(bp + 80 /* data_size */)) < uint64(5)) {
+ if !(*(*size_t)(unsafe.Pointer(bp + 80)) < uint64(5)) {
goto __19
}
status = VP8_STATUS_NOT_ENOUGH_DATA
@@ -13668,7 +13408,7 @@ __15:
__19:
;
// Validates raw VP8L data.
- if !(!(VP8LGetInfo(tls, *(*uintptr)(unsafe.Pointer(bp + 72 /* data */)), *(*size_t)(unsafe.Pointer(bp + 80 /* data_size */)), (bp+104) /* &image_width */, (bp+108) /* &image_height */, has_alpha) != 0)) {
+ if !!(VP8LGetInfo(tls, *(*uintptr)(unsafe.Pointer(bp + 72)), *(*size_t)(unsafe.Pointer(bp + 80)), bp+104, bp+108, has_alpha) != 0) {
goto __20
}
return VP8_STATUS_BITSTREAM_ERROR
@@ -13677,10 +13417,10 @@ __20:
__16:
;
// Validates image size coherency.
- if !(*(*int32)(unsafe.Pointer(bp + 88 /* found_vp8x */)) != 0) {
+ if !(*(*int32)(unsafe.Pointer(bp + 88)) != 0) {
goto __21
}
- if !((*(*int32)(unsafe.Pointer(bp + 92 /* canvas_width */)) != *(*int32)(unsafe.Pointer(bp + 104 /* image_width */))) || (*(*int32)(unsafe.Pointer(bp + 96 /* canvas_height */)) != *(*int32)(unsafe.Pointer(bp + 108 /* image_height */)))) {
+ if !(*(*int32)(unsafe.Pointer(bp + 92)) != *(*int32)(unsafe.Pointer(bp + 104)) || *(*int32)(unsafe.Pointer(bp + 96)) != *(*int32)(unsafe.Pointer(bp + 108))) {
goto __22
}
return VP8_STATUS_BITSTREAM_ERROR
@@ -13688,33 +13428,33 @@ __22:
;
__21:
;
- if !(headers != (uintptr(0))) {
+ if !(headers != uintptr(0)) {
goto __23
}
*(*WebPHeaderStructure)(unsafe.Pointer(headers)) = *(*WebPHeaderStructure)(unsafe.Pointer(bp /* hdrs */))
- (*WebPHeaderStructure)(unsafe.Pointer(headers)).offset = (size_t((int64(*(*uintptr)(unsafe.Pointer(bp + 72 /* data */))) - int64((*WebPHeaderStructure)(unsafe.Pointer(headers)).data)) / 1))
+ (*WebPHeaderStructure)(unsafe.Pointer(headers)).offset = size_t((int64(*(*uintptr)(unsafe.Pointer(bp + 72))) - int64((*WebPHeaderStructure)(unsafe.Pointer(headers)).data)) / 1)
__23:
;
ReturnWidthHeight:
- if !((status == VP8_STATUS_OK) || (((status == VP8_STATUS_NOT_ENOUGH_DATA) && (*(*int32)(unsafe.Pointer(bp + 88 /* found_vp8x */)) != 0)) && (headers == (uintptr(0))))) {
+ if !(status == VP8_STATUS_OK || status == VP8_STATUS_NOT_ENOUGH_DATA && *(*int32)(unsafe.Pointer(bp + 88)) != 0 && headers == uintptr(0)) {
goto __24
}
- if !(has_alpha != (uintptr(0))) {
+ if !(has_alpha != uintptr(0)) {
goto __26
}
// If the data did not contain a VP8X/VP8L chunk the only definitive way
// to set this is by looking for alpha data (from an ALPH chunk).
- *(*int32)(unsafe.Pointer(has_alpha)) |= (libc.Bool32((*WebPHeaderStructure)(unsafe.Pointer(bp /* &hdrs */)).alpha_data != (uintptr(0))))
+ *(*int32)(unsafe.Pointer(has_alpha)) |= libc.Bool32((*WebPHeaderStructure)(unsafe.Pointer(bp)).alpha_data != uintptr(0))
__26:
;
- if !(width != (uintptr(0))) {
+ if !(width != uintptr(0)) {
goto __27
}
*(*int32)(unsafe.Pointer(width)) = *(*int32)(unsafe.Pointer(bp + 104 /* image_width */))
__27:
;
- if !(height != (uintptr(0))) {
+ if !(height != uintptr(0)) {
goto __28
}
*(*int32)(unsafe.Pointer(height)) = *(*int32)(unsafe.Pointer(bp + 108 /* image_height */))
@@ -13739,13 +13479,13 @@ func WebPParseHeaders(tls *libc.TLS, headers uintptr) VP8StatusCode { /* webp_de
// fill out headers, ignore width/height/has_alpha.
status = ParseHeadersInternal(tls, (*WebPHeaderStructure)(unsafe.Pointer(headers)).data, (*WebPHeaderStructure)(unsafe.Pointer(headers)).data_size,
- (uintptr(0)), (uintptr(0)), (uintptr(0)), (bp), /* &has_animation */
- (uintptr(0)), headers)
- if (status == VP8_STATUS_OK) || (status == VP8_STATUS_NOT_ENOUGH_DATA) {
+ uintptr(0), uintptr(0), uintptr(0), bp,
+ uintptr(0), headers)
+ if status == VP8_STATUS_OK || status == VP8_STATUS_NOT_ENOUGH_DATA {
// The WebPDemux API + libwebp can be used to decode individual
// uncomposited frames or the WebPAnimDecoder can be used to fully
// reconstruct them (see webp/demux.h).
- if *(*int32)(unsafe.Pointer(bp /* has_animation */)) != 0 {
+ if *(*int32)(unsafe.Pointer(bp)) != 0 {
status = VP8_STATUS_UNSUPPORTED_FEATURE
}
}
@@ -13756,7 +13496,7 @@ func WebPParseHeaders(tls *libc.TLS, headers uintptr) VP8StatusCode { /* webp_de
// WebPDecParams
func WebPResetDecParams(tls *libc.TLS, params uintptr) { /* webp_dec.c:437:6: */
- if params != (uintptr(0)) {
+ if params != uintptr(0) {
libc.Xmemset(tls, params, 0, uint64(unsafe.Sizeof(WebPDecParams{})))
}
}
@@ -13777,26 +13517,26 @@ func DecodeInto(tls *libc.TLS, data uintptr, data_size size_t, params uintptr) V
(*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).data = data
(*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).data_size = data_size
(*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).have_all_data = 1
- status = WebPParseHeaders(tls, (bp) /* &headers */) // Process Pre-VP8 chunks.
+ status = WebPParseHeaders(tls, bp) // Process Pre-VP8 chunks.
if status != VP8_STATUS_OK {
return status
}
- VP8InitIo(tls, (bp + 72) /* &io */)
- (*VP8Io)(unsafe.Pointer(bp + 72 /* &io */)).data = ((*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).data + uintptr((*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).offset))
- (*VP8Io)(unsafe.Pointer(bp + 72 /* &io */)).data_size = ((*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).data_size - (*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).offset)
- WebPInitCustomIo(tls, params, (bp + 72) /* &io */) // Plug the I/O functions.
+ VP8InitIo(tls, bp+72)
+ (*VP8Io)(unsafe.Pointer(bp + 72 /* &io */)).data = (*WebPHeaderStructure)(unsafe.Pointer(bp)).data + uintptr((*WebPHeaderStructure)(unsafe.Pointer(bp)).offset)
+ (*VP8Io)(unsafe.Pointer(bp + 72 /* &io */)).data_size = (*WebPHeaderStructure)(unsafe.Pointer(bp)).data_size - (*WebPHeaderStructure)(unsafe.Pointer(bp)).offset
+ WebPInitCustomIo(tls, params, bp+72) // Plug the I/O functions.
- if !((*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).is_lossless != 0) {
+ if !((*WebPHeaderStructure)(unsafe.Pointer(bp)).is_lossless != 0) {
var dec uintptr = VP8New(tls)
- if dec == (uintptr(0)) {
+ if dec == uintptr(0) {
return VP8_STATUS_OUT_OF_MEMORY
}
(*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_ = (*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).alpha_data
(*VP8Decoder)(unsafe.Pointer(dec)).alpha_data_size_ = (*WebPHeaderStructure)(unsafe.Pointer(bp /* &headers */)).alpha_data_size
// Decode bitstream header, update io->width/io->height.
- if !(VP8GetHeaders(tls, dec, (bp+72) /* &io */) != 0) {
+ if !(VP8GetHeaders(tls, dec, bp+72) != 0) {
status = (*VP8Decoder)(unsafe.Pointer(dec)).status_ // An error occurred. Grab error status.
} else {
// Allocate/check output buffers.
@@ -13804,10 +13544,10 @@ func DecodeInto(tls *libc.TLS, data uintptr, data_size size_t, params uintptr) V
(*WebPDecParams)(unsafe.Pointer(params)).output)
if status == VP8_STATUS_OK { // Decode
// This change must be done before calling VP8Decode()
- (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ = VP8GetThreadMethod(tls, (*WebPDecParams)(unsafe.Pointer(params)).options, (bp), /* &headers */
+ (*VP8Decoder)(unsafe.Pointer(dec)).mt_method_ = VP8GetThreadMethod(tls, (*WebPDecParams)(unsafe.Pointer(params)).options, bp,
(*VP8Io)(unsafe.Pointer(bp+72 /* &io */)).width, (*VP8Io)(unsafe.Pointer(bp+72 /* &io */)).height)
VP8InitDithering(tls, (*WebPDecParams)(unsafe.Pointer(params)).options, dec)
- if !(VP8Decode(tls, dec, (bp+72) /* &io */) != 0) {
+ if !(VP8Decode(tls, dec, bp+72) != 0) {
status = (*VP8Decoder)(unsafe.Pointer(dec)).status_
}
}
@@ -13815,10 +13555,10 @@ func DecodeInto(tls *libc.TLS, data uintptr, data_size size_t, params uintptr) V
VP8Delete(tls, dec)
} else {
var dec uintptr = VP8LNew(tls)
- if dec == (uintptr(0)) {
+ if dec == uintptr(0) {
return VP8_STATUS_OUT_OF_MEMORY
}
- if !(VP8LDecodeHeader(tls, dec, (bp+72) /* &io */) != 0) {
+ if !(VP8LDecodeHeader(tls, dec, bp+72) != 0) {
status = (*VP8LDecoder)(unsafe.Pointer(dec)).status_ // An error occurred. Grab error status.
} else {
// Allocate/check output buffers.
@@ -13836,7 +13576,7 @@ func DecodeInto(tls *libc.TLS, data uintptr, data_size size_t, params uintptr) V
if status != VP8_STATUS_OK {
WebPFreeDecBuffer(tls, (*WebPDecParams)(unsafe.Pointer(params)).output)
} else {
- if ((*WebPDecParams)(unsafe.Pointer(params)).options != (uintptr(0))) && ((*WebPDecoderOptions)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(params)).options)).flip != 0) {
+ if (*WebPDecParams)(unsafe.Pointer(params)).options != uintptr(0) && (*WebPDecoderOptions)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(params)).options)).flip != 0 {
// This restores the original stride values if options->flip was used
// during the call to WebPAllocateDecBuffer above.
status = WebPFlipBuffer(tls, (*WebPDecParams)(unsafe.Pointer(params)).output)
@@ -13854,19 +13594,19 @@ func DecodeIntoRGBABuffer(tls *libc.TLS, colorspace WEBP_CSP_MODE, data uintptr,
// var buf WebPDecBuffer at bp, 120
- if rgba == (uintptr(0)) {
- return (uintptr(0))
+ if rgba == uintptr(0) {
+ return uintptr(0)
}
- WebPInitDecBuffer(tls, (bp) /* &buf */)
- WebPResetDecParams(tls, (bp + 120) /* ¶ms */)
- (*WebPDecParams)(unsafe.Pointer(bp + 120 /* ¶ms */)).output = (bp) /* &buf */
+ WebPInitDecBuffer(tls, bp)
+ WebPResetDecParams(tls, bp+120)
+ (*WebPDecParams)(unsafe.Pointer(bp + 120 /* ¶ms */)).output = bp /* &buf */
(*WebPDecBuffer)(unsafe.Pointer(bp /* &buf */)).colorspace = colorspace
- (*WebPRGBABuffer)(unsafe.Pointer(((bp) /* &buf */ + 16 /* &.u */))).rgba = rgba
- (*WebPRGBABuffer)(unsafe.Pointer(((bp) /* &buf */ + 16 /* &.u */))).stride = stride
- (*WebPRGBABuffer)(unsafe.Pointer(((bp) /* &buf */ + 16 /* &.u */))).size = size
+ (*WebPRGBABuffer)(unsafe.Pointer(bp + 16)).rgba = rgba
+ (*WebPRGBABuffer)(unsafe.Pointer(bp + 16)).stride = stride
+ (*WebPRGBABuffer)(unsafe.Pointer(bp + 16)).size = size
(*WebPDecBuffer)(unsafe.Pointer(bp /* &buf */)).is_external_memory = 1
- if DecodeInto(tls, data, data_size, (bp+120) /* ¶ms */) != VP8_STATUS_OK {
- return (uintptr(0))
+ if DecodeInto(tls, data, data_size, bp+120) != VP8_STATUS_OK {
+ return uintptr(0)
}
return rgba
}
@@ -13899,25 +13639,25 @@ func WebPDecodeYUVInto(tls *libc.TLS, data uintptr, data_size size_t, luma uintp
// var output WebPDecBuffer at bp, 120
- if luma == (uintptr(0)) {
- return (uintptr(0))
+ if luma == uintptr(0) {
+ return uintptr(0)
}
- WebPInitDecBuffer(tls, (bp) /* &output */)
- WebPResetDecParams(tls, (bp + 120) /* ¶ms */)
- (*WebPDecParams)(unsafe.Pointer(bp + 120 /* ¶ms */)).output = (bp) /* &output */
+ WebPInitDecBuffer(tls, bp)
+ WebPResetDecParams(tls, bp+120)
+ (*WebPDecParams)(unsafe.Pointer(bp + 120 /* ¶ms */)).output = bp /* &output */
(*WebPDecBuffer)(unsafe.Pointer(bp /* &output */)).colorspace = MODE_YUV
- (*WebPYUVABuffer)(unsafe.Pointer(((bp) /* &output */ + 16 /* &.u */))).y = luma
- (*WebPYUVABuffer)(unsafe.Pointer(((bp) /* &output */ + 16 /* &.u */))).y_stride = luma_stride
- (*WebPYUVABuffer)(unsafe.Pointer(((bp) /* &output */ + 16 /* &.u */))).y_size = luma_size
- (*WebPYUVABuffer)(unsafe.Pointer(((bp) /* &output */ + 16 /* &.u */))).u = u
- (*WebPYUVABuffer)(unsafe.Pointer(((bp) /* &output */ + 16 /* &.u */))).u_stride = u_stride
- (*WebPYUVABuffer)(unsafe.Pointer(((bp) /* &output */ + 16 /* &.u */))).u_size = u_size
- (*WebPYUVABuffer)(unsafe.Pointer(((bp) /* &output */ + 16 /* &.u */))).v = v
- (*WebPYUVABuffer)(unsafe.Pointer(((bp) /* &output */ + 16 /* &.u */))).v_stride = v_stride
- (*WebPYUVABuffer)(unsafe.Pointer(((bp) /* &output */ + 16 /* &.u */))).v_size = v_size
+ (*WebPYUVABuffer)(unsafe.Pointer(bp + 16)).y = luma
+ (*WebPYUVABuffer)(unsafe.Pointer(bp + 16)).y_stride = luma_stride
+ (*WebPYUVABuffer)(unsafe.Pointer(bp + 16)).y_size = luma_size
+ (*WebPYUVABuffer)(unsafe.Pointer(bp + 16)).u = u
+ (*WebPYUVABuffer)(unsafe.Pointer(bp + 16)).u_stride = u_stride
+ (*WebPYUVABuffer)(unsafe.Pointer(bp + 16)).u_size = u_size
+ (*WebPYUVABuffer)(unsafe.Pointer(bp + 16)).v = v
+ (*WebPYUVABuffer)(unsafe.Pointer(bp + 16)).v_stride = v_stride
+ (*WebPYUVABuffer)(unsafe.Pointer(bp + 16)).v_size = v_size
(*WebPDecBuffer)(unsafe.Pointer(bp /* &output */)).is_external_memory = 1
- if DecodeInto(tls, data, data_size, (bp+120) /* ¶ms */) != VP8_STATUS_OK {
- return (uintptr(0))
+ if DecodeInto(tls, data, data_size, bp+120) != VP8_STATUS_OK {
+ return uintptr(0)
}
return luma
}
@@ -13932,54 +13672,54 @@ func Decode(tls *libc.TLS, mode WEBP_CSP_MODE, data uintptr, data_size size_t, w
// var output WebPDecBuffer at bp, 120
- WebPInitDecBuffer(tls, (bp) /* &output */)
- WebPResetDecParams(tls, (bp + 120) /* ¶ms */)
- (*WebPDecParams)(unsafe.Pointer(bp + 120 /* ¶ms */)).output = (bp) /* &output */
+ WebPInitDecBuffer(tls, bp)
+ WebPResetDecParams(tls, bp+120)
+ (*WebPDecParams)(unsafe.Pointer(bp + 120 /* ¶ms */)).output = bp /* &output */
(*WebPDecBuffer)(unsafe.Pointer(bp /* &output */)).colorspace = mode
// Retrieve (and report back) the required dimensions from bitstream.
- if !(WebPGetInfo(tls, data, data_size, ((bp) /* &output */ +4 /* &.width */), ((bp) /* &output */ +8 /* &.height */)) != 0) {
- return (uintptr(0))
+ if !(WebPGetInfo(tls, data, data_size, bp+4, bp+8) != 0) {
+ return uintptr(0)
}
- if width != (uintptr(0)) {
+ if width != uintptr(0) {
*(*int32)(unsafe.Pointer(width)) = (*WebPDecBuffer)(unsafe.Pointer(bp /* &output */)).width
}
- if height != (uintptr(0)) {
+ if height != uintptr(0) {
*(*int32)(unsafe.Pointer(height)) = (*WebPDecBuffer)(unsafe.Pointer(bp /* &output */)).height
}
// Decode
- if DecodeInto(tls, data, data_size, (bp+120) /* ¶ms */) != VP8_STATUS_OK {
- return (uintptr(0))
+ if DecodeInto(tls, data, data_size, bp+120) != VP8_STATUS_OK {
+ return uintptr(0)
}
- if keep_info != (uintptr(0)) { // keep track of the side-info
- WebPCopyDecBuffer(tls, (bp) /* &output */, keep_info)
+ if keep_info != uintptr(0) { // keep track of the side-info
+ WebPCopyDecBuffer(tls, bp, keep_info)
}
// return decoded samples (don't clear 'output'!)
if WebPIsRGBMode(tls, mode) != 0 {
- return (*WebPRGBABuffer)(unsafe.Pointer(((bp) /* &output */ + 16 /* &.u */))).rgba
+ return (*WebPRGBABuffer)(unsafe.Pointer(bp + 16)).rgba
}
- return (*WebPYUVABuffer)(unsafe.Pointer(((bp) /* &output */ + 16 /* &.u */))).y
+ return (*WebPYUVABuffer)(unsafe.Pointer(bp + 16)).y
}
func WebPDecodeRGB(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr) uintptr { /* webp_dec.c:633:8: */
- return Decode(tls, MODE_RGB, data, data_size, width, height, (uintptr(0)))
+ return Decode(tls, MODE_RGB, data, data_size, width, height, uintptr(0))
}
func WebPDecodeRGBA(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr) uintptr { /* webp_dec.c:638:8: */
- return Decode(tls, MODE_RGBA, data, data_size, width, height, (uintptr(0)))
+ return Decode(tls, MODE_RGBA, data, data_size, width, height, uintptr(0))
}
func WebPDecodeARGB(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr) uintptr { /* webp_dec.c:643:8: */
- return Decode(tls, MODE_ARGB, data, data_size, width, height, (uintptr(0)))
+ return Decode(tls, MODE_ARGB, data, data_size, width, height, uintptr(0))
}
func WebPDecodeBGR(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr) uintptr { /* webp_dec.c:648:8: */
- return Decode(tls, MODE_BGR, data, data_size, width, height, (uintptr(0)))
+ return Decode(tls, MODE_BGR, data, data_size, width, height, uintptr(0))
}
func WebPDecodeBGRA(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr) uintptr { /* webp_dec.c:653:8: */
- return Decode(tls, MODE_BGRA, data, data_size, width, height, (uintptr(0)))
+ return Decode(tls, MODE_BGRA, data, data_size, width, height, uintptr(0))
}
func WebPDecodeYUV(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr, u uintptr, v uintptr, stride uintptr, uv_stride uintptr) uintptr { /* webp_dec.c:658:8: */
@@ -13989,10 +13729,10 @@ func WebPDecodeYUV(tls *libc.TLS, data uintptr, data_size size_t, width uintptr,
// var output WebPDecBuffer at bp, 120
// only to preserve the side-infos
var out uintptr = Decode(tls, MODE_YUV, data, data_size,
- width, height, (bp) /* &output */)
+ width, height, bp)
- if out != (uintptr(0)) {
- var buf uintptr = ((bp) /* &output */ + 16 /* &.u */) /* &.YUVA */
+ if out != uintptr(0) {
+ var buf uintptr = bp + 16
*(*uintptr)(unsafe.Pointer(u)) = (*WebPYUVABuffer)(unsafe.Pointer(buf)).u
*(*uintptr)(unsafe.Pointer(v)) = (*WebPYUVABuffer)(unsafe.Pointer(buf)).v
*(*int32)(unsafe.Pointer(stride)) = (*WebPYUVABuffer)(unsafe.Pointer(buf)).y_stride
@@ -14008,16 +13748,16 @@ func DefaultFeatures(tls *libc.TLS, features uintptr) { /* webp_dec.c:676:13: */
}
func GetFeatures(tls *libc.TLS, data uintptr, data_size size_t, features uintptr) VP8StatusCode { /* webp_dec.c:681:22: */
- if (features == (uintptr(0))) || (data == (uintptr(0))) {
+ if features == uintptr(0) || data == uintptr(0) {
return VP8_STATUS_INVALID_PARAM
}
DefaultFeatures(tls, features)
// Only parse enough of the data to retrieve the features.
return ParseHeadersInternal(tls, data, data_size,
- (features /* &.width */), (features + 4 /* &.height */),
- (features + 8 /* &.has_alpha */), (features + 12 /* &.has_animation */),
- (features + 16 /* &.format */), (uintptr(0)))
+ features, features+4,
+ features+8, features+12,
+ features+16, uintptr(0))
}
//------------------------------------------------------------------------------
@@ -14029,14 +13769,14 @@ func WebPGetInfo(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, h
// var features WebPBitstreamFeatures at bp, 40
- if GetFeatures(tls, data, data_size, (bp) /* &features */) != VP8_STATUS_OK {
+ if GetFeatures(tls, data, data_size, bp) != VP8_STATUS_OK {
return 0
}
- if width != (uintptr(0)) {
+ if width != uintptr(0) {
*(*int32)(unsafe.Pointer(width)) = (*WebPBitstreamFeatures)(unsafe.Pointer(bp /* &features */)).width
}
- if height != (uintptr(0)) {
+ if height != uintptr(0) {
*(*int32)(unsafe.Pointer(height)) = (*WebPBitstreamFeatures)(unsafe.Pointer(bp /* &features */)).height
}
@@ -14047,23 +13787,23 @@ func WebPGetInfo(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, h
// Advance decoding API
func WebPInitDecoderConfigInternal(tls *libc.TLS, config uintptr, version int32) int32 { /* webp_dec.c:719:5: */
- if ((version) >> 8) != (int32((0x0209)) >> 8) {
+ if version>>8 != int32(0x0209)>>8 {
return 0 // version mismatch
}
- if config == (uintptr(0)) {
+ if config == uintptr(0) {
return 0
}
libc.Xmemset(tls, config, 0, uint64(unsafe.Sizeof(WebPDecoderConfig{})))
- DefaultFeatures(tls, (config /* &.input */))
- WebPInitDecBuffer(tls, (config + 40 /* &.output */))
+ DefaultFeatures(tls, config)
+ WebPInitDecBuffer(tls, config+40)
return 1
}
func WebPGetFeaturesInternal(tls *libc.TLS, data uintptr, data_size size_t, features uintptr, version int32) VP8StatusCode { /* webp_dec.c:733:15: */
- if ((version) >> 8) != (int32((0x0209)) >> 8) {
+ if version>>8 != int32(0x0209)>>8 {
return VP8_STATUS_INVALID_PARAM // version mismatch
}
- if features == (uintptr(0)) {
+ if features == uintptr(0) {
return VP8_STATUS_INVALID_PARAM
}
return GetFeatures(tls, data, data_size, features)
@@ -14077,11 +13817,11 @@ func WebPDecode(tls *libc.TLS, data uintptr, data_size size_t, config uintptr) V
var status VP8StatusCode
- if config == (uintptr(0)) {
+ if config == uintptr(0) {
return VP8_STATUS_INVALID_PARAM
}
- status = GetFeatures(tls, data, data_size, (config /* &.input */))
+ status = GetFeatures(tls, data, data_size, config)
if status != VP8_STATUS_OK {
if status == VP8_STATUS_NOT_ENOUGH_DATA {
return VP8_STATUS_BITSTREAM_ERROR // Not-enough-data treated as error.
@@ -14089,25 +13829,25 @@ func WebPDecode(tls *libc.TLS, data uintptr, data_size size_t, config uintptr) V
return status
}
- WebPResetDecParams(tls, (bp) /* ¶ms */)
- (*WebPDecParams)(unsafe.Pointer(bp /* ¶ms */)).options = (config + 160 /* &.options */)
- (*WebPDecParams)(unsafe.Pointer(bp /* ¶ms */)).output = (config + 40 /* &.output */)
- if WebPAvoidSlowMemory(tls, (*WebPDecParams)(unsafe.Pointer(bp /* ¶ms */)).output, (config /* &.input */)) != 0 {
+ WebPResetDecParams(tls, bp)
+ (*WebPDecParams)(unsafe.Pointer(bp /* ¶ms */)).options = config + 160
+ (*WebPDecParams)(unsafe.Pointer(bp /* ¶ms */)).output = config + 40
+ if WebPAvoidSlowMemory(tls, (*WebPDecParams)(unsafe.Pointer(bp)).output, config) != 0 {
// decoding to slow memory: use a temporary in-mem buffer to decode into.
// var in_mem_buffer WebPDecBuffer at bp+112, 120
- WebPInitDecBuffer(tls, (bp + 112) /* &in_mem_buffer */)
+ WebPInitDecBuffer(tls, bp+112)
(*WebPDecBuffer)(unsafe.Pointer(bp + 112 /* &in_mem_buffer */)).colorspace = (*WebPDecoderConfig)(unsafe.Pointer(config)).output.colorspace
(*WebPDecBuffer)(unsafe.Pointer(bp + 112 /* &in_mem_buffer */)).width = (*WebPDecoderConfig)(unsafe.Pointer(config)).input.width
(*WebPDecBuffer)(unsafe.Pointer(bp + 112 /* &in_mem_buffer */)).height = (*WebPDecoderConfig)(unsafe.Pointer(config)).input.height
- (*WebPDecParams)(unsafe.Pointer(bp /* ¶ms */)).output = (bp + 112) /* &in_mem_buffer */
- status = DecodeInto(tls, data, data_size, (bp) /* ¶ms */)
+ (*WebPDecParams)(unsafe.Pointer(bp /* ¶ms */)).output = bp + 112 /* &in_mem_buffer */
+ status = DecodeInto(tls, data, data_size, bp)
if status == VP8_STATUS_OK { // do the slow-copy
- status = WebPCopyDecBufferPixels(tls, (bp + 112) /* &in_mem_buffer */, (config + 40 /* &.output */))
+ status = WebPCopyDecBufferPixels(tls, bp+112, config+40)
}
- WebPFreeDecBuffer(tls, (bp + 112) /* &in_mem_buffer */)
+ WebPFreeDecBuffer(tls, bp+112)
} else {
- status = DecodeInto(tls, data, data_size, (bp) /* ¶ms */)
+ status = DecodeInto(tls, data, data_size, bp)
}
return status
@@ -14117,7 +13857,7 @@ func WebPDecode(tls *libc.TLS, data uintptr, data_size size_t, config uintptr) V
// Cropping and rescaling.
func WebPCheckCropDimensions(tls *libc.TLS, image_width int32, image_height int32, x int32, y int32, w int32, h int32) int32 { /* webp_dec.c:788:5: */
- return libc.BoolInt32(!((((((((((x < 0) || (y < 0)) || (w <= 0)) || (h <= 0)) || (x >= image_width)) || (w > image_width)) || (w > (image_width - x))) || (y >= image_height)) || (h > image_height)) || (h > (image_height - y))))
+ return libc.BoolInt32(!(x < 0 || y < 0 || w <= 0 || h <= 0 || x >= image_width || w > image_width || w > image_width-x || y >= image_height || h > image_height || h > image_height-y))
}
func WebPIoInitFromOptions(tls *libc.TLS, options uintptr, io uintptr, src_colorspace WEBP_CSP_MODE) int32 { /* webp_dec.c:795:5: */
@@ -14132,15 +13872,15 @@ func WebPIoInitFromOptions(tls *libc.TLS, options uintptr, io uintptr, src_color
var h int32 = H
// Cropping
- (*VP8Io)(unsafe.Pointer(io)).use_cropping = (libc.Bool32((options != (uintptr(0))) && ((*WebPDecoderOptions)(unsafe.Pointer(options)).use_cropping != 0)))
+ (*VP8Io)(unsafe.Pointer(io)).use_cropping = libc.Bool32(options != uintptr(0) && (*WebPDecoderOptions)(unsafe.Pointer(options)).use_cropping != 0)
if (*VP8Io)(unsafe.Pointer(io)).use_cropping != 0 {
w = (*WebPDecoderOptions)(unsafe.Pointer(options)).crop_width
h = (*WebPDecoderOptions)(unsafe.Pointer(options)).crop_height
x = (*WebPDecoderOptions)(unsafe.Pointer(options)).crop_left
y = (*WebPDecoderOptions)(unsafe.Pointer(options)).crop_top
if !(WebPIsRGBMode(tls, src_colorspace) != 0) { // only snap for YUV420
- x = x & (libc.CplInt32(1))
- y = y & (libc.CplInt32(1))
+ x = x & libc.CplInt32(1)
+ y = y & libc.CplInt32(1)
}
if !(WebPCheckCropDimensions(tls, W, H, x, y, w, h) != 0) {
return 0 // out of frame boundary error
@@ -14148,17 +13888,17 @@ func WebPIoInitFromOptions(tls *libc.TLS, options uintptr, io uintptr, src_color
}
(*VP8Io)(unsafe.Pointer(io)).crop_left = x
(*VP8Io)(unsafe.Pointer(io)).crop_top = y
- (*VP8Io)(unsafe.Pointer(io)).crop_right = (x + w)
- (*VP8Io)(unsafe.Pointer(io)).crop_bottom = (y + h)
+ (*VP8Io)(unsafe.Pointer(io)).crop_right = x + w
+ (*VP8Io)(unsafe.Pointer(io)).crop_bottom = y + h
(*VP8Io)(unsafe.Pointer(io)).mb_w = w
(*VP8Io)(unsafe.Pointer(io)).mb_h = h
// Scaling
- (*VP8Io)(unsafe.Pointer(io)).use_scaling = (libc.Bool32((options != (uintptr(0))) && ((*WebPDecoderOptions)(unsafe.Pointer(options)).use_scaling != 0)))
+ (*VP8Io)(unsafe.Pointer(io)).use_scaling = libc.Bool32(options != uintptr(0) && (*WebPDecoderOptions)(unsafe.Pointer(options)).use_scaling != 0)
if (*VP8Io)(unsafe.Pointer(io)).use_scaling != 0 {
*(*int32)(unsafe.Pointer(bp /* scaled_width */)) = (*WebPDecoderOptions)(unsafe.Pointer(options)).scaled_width
*(*int32)(unsafe.Pointer(bp + 4 /* scaled_height */)) = (*WebPDecoderOptions)(unsafe.Pointer(options)).scaled_height
- if !(WebPRescalerGetScaledDimensions(tls, w, h, (bp) /* &scaled_width */, (bp+4) /* &scaled_height */) != 0) {
+ if !(WebPRescalerGetScaledDimensions(tls, w, h, bp, bp+4) != 0) {
return 0
}
(*VP8Io)(unsafe.Pointer(io)).scaled_width = *(*int32)(unsafe.Pointer(bp /* scaled_width */))
@@ -14166,14 +13906,14 @@ func WebPIoInitFromOptions(tls *libc.TLS, options uintptr, io uintptr, src_color
}
// Filter
- (*VP8Io)(unsafe.Pointer(io)).bypass_filtering = (libc.Bool32((options != (uintptr(0))) && ((*WebPDecoderOptions)(unsafe.Pointer(options)).bypass_filtering != 0)))
+ (*VP8Io)(unsafe.Pointer(io)).bypass_filtering = libc.Bool32(options != uintptr(0) && (*WebPDecoderOptions)(unsafe.Pointer(options)).bypass_filtering != 0)
// Fancy upsampler
- (*VP8Io)(unsafe.Pointer(io)).fancy_upsampling = (libc.Bool32((options == (uintptr(0))) || (!((*WebPDecoderOptions)(unsafe.Pointer(options)).no_fancy_upsampling != 0))))
+ (*VP8Io)(unsafe.Pointer(io)).fancy_upsampling = libc.Bool32(options == uintptr(0) || !((*WebPDecoderOptions)(unsafe.Pointer(options)).no_fancy_upsampling != 0))
if (*VP8Io)(unsafe.Pointer(io)).use_scaling != 0 {
// disable filter (only for large downscaling ratio).
- *(*int32)(unsafe.Pointer((io + 112 /* &.bypass_filtering */))) |= (libc.Bool32(((*VP8Io)(unsafe.Pointer(io)).scaled_width < ((W * 3) / 4)) && ((*VP8Io)(unsafe.Pointer(io)).scaled_height < ((H * 3) / 4))))
+ *(*int32)(unsafe.Pointer(io + 112)) |= libc.Bool32((*VP8Io)(unsafe.Pointer(io)).scaled_width < W*3/4 && (*VP8Io)(unsafe.Pointer(io)).scaled_height < H*3/4)
(*VP8Io)(unsafe.Pointer(io)).fancy_upsampling = 0
}
return 1
@@ -14186,16 +13926,16 @@ func WebPIoInitFromOptions(tls *libc.TLS, options uintptr, io uintptr, src_color
// -----------------------------------------------------------------------------
func Mult(tls *libc.TLS, x uint8_t, mult uint32_t) uint32_t { /* alpha_processing.c:29:17: */
- var v uint32_t = (((uint32_t(x) * mult) + (uint32((uint32(1) << 24)) >> 1)) >> 24)
+ var v uint32_t = (uint32_t(x)*mult + uint32(uint32(1)<<24)>>1) >> 24
// <- 24bit precision is enough to ensure that.
return v
}
func GetScale(tls *libc.TLS, a uint32_t, inverse int32) uint32_t { /* alpha_processing.c:134:29: */
if inverse != 0 {
- return ((uint32(255) << 24) / a)
+ return uint32(255) << 24 / a
}
- return (a * ((uint32(1) << 24) / 255))
+ return a * (uint32(1) << 24 / 255)
}
func WebPMultARGBRow_C(tls *libc.TLS, ptr uintptr, width int32, inverse int32) { /* alpha_processing.c:140:6: */
@@ -14206,12 +13946,12 @@ func WebPMultARGBRow_C(tls *libc.TLS, ptr uintptr, width int32, inverse int32) {
if argb <= 0x00ffffff { // alpha == 0
*(*uint32_t)(unsafe.Pointer(ptr + uintptr(x)*4)) = uint32_t(0)
} else {
- var alpha uint32_t = ((argb >> 24) & uint32_t(0xff))
+ var alpha uint32_t = argb >> 24 & uint32_t(0xff)
var scale uint32_t = GetScale(tls, alpha, inverse)
- var out uint32_t = (argb & 0xff000000)
- out = out | (Mult(tls, (uint8(argb>>0)), scale) << 0)
- out = out | (Mult(tls, (uint8(argb>>8)), scale) << 8)
- out = out | (Mult(tls, (uint8(argb>>16)), scale) << 16)
+ var out uint32_t = argb & 0xff000000
+ out = out | Mult(tls, uint8(argb>>0), scale)<<0
+ out = out | Mult(tls, uint8(argb>>8), scale)<<8
+ out = out | Mult(tls, uint8(argb>>16), scale)<<16
*(*uint32_t)(unsafe.Pointer(ptr + uintptr(x)*4)) = out
}
}
@@ -14271,26 +14011,26 @@ func WebPMultRows(tls *libc.TLS, ptr uintptr, stride int32, alpha uintptr, alpha
func ApplyAlphaMultiply_C(tls *libc.TLS, rgba uintptr, alpha_first int32, w int32, h int32, stride int32) { /* alpha_processing.c:226:13: */
for libc.PostDecInt32(&h, 1) > 0 {
- var rgb uintptr = (rgba + uintptr((func() int32 {
+ var rgb uintptr = rgba + uintptr(func() int32 {
if alpha_first != 0 {
return 1
}
return 0
- }())))
- var alpha uintptr = (rgba + uintptr((func() int32 {
+ }())
+ var alpha uintptr = rgba + uintptr(func() int32 {
if alpha_first != 0 {
return 0
}
return 3
- }())))
+ }())
var i int32
for i = 0; i < w; i++ {
- var a uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(alpha + uintptr((4 * i)))))
+ var a uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(alpha + uintptr(4*i))))
if a != uint32_t(0xff) {
- var mult uint32_t = ((a) * 32897)
- *(*uint8_t)(unsafe.Pointer(rgb + uintptr(((4 * i) + 0)))) = (uint8_t(((uint32_t(*(*uint8_t)(unsafe.Pointer(rgb + uintptr(((4 * i) + 0)))))) * (mult)) >> 23))
- *(*uint8_t)(unsafe.Pointer(rgb + uintptr(((4 * i) + 1)))) = (uint8_t(((uint32_t(*(*uint8_t)(unsafe.Pointer(rgb + uintptr(((4 * i) + 1)))))) * (mult)) >> 23))
- *(*uint8_t)(unsafe.Pointer(rgb + uintptr(((4 * i) + 2)))) = (uint8_t(((uint32_t(*(*uint8_t)(unsafe.Pointer(rgb + uintptr(((4 * i) + 2)))))) * (mult)) >> 23))
+ var mult uint32_t = a * 32897
+ *(*uint8_t)(unsafe.Pointer(rgb + uintptr(4*i+0))) = uint8_t(uint32_t(*(*uint8_t)(unsafe.Pointer(rgb + uintptr(4*i+0)))) * mult >> 23)
+ *(*uint8_t)(unsafe.Pointer(rgb + uintptr(4*i+1))) = uint8_t(uint32_t(*(*uint8_t)(unsafe.Pointer(rgb + uintptr(4*i+1)))) * mult >> 23)
+ *(*uint8_t)(unsafe.Pointer(rgb + uintptr(4*i+2))) = uint8_t(uint32_t(*(*uint8_t)(unsafe.Pointer(rgb + uintptr(4*i+2)))) * mult >> 23)
}
}
rgba += uintptr(stride)
@@ -14300,30 +14040,30 @@ func ApplyAlphaMultiply_C(tls *libc.TLS, rgba uintptr, alpha_first int32, w int3
// rgbA4444
func dither_hi(tls *libc.TLS, x uint8_t) uint8_t { /* alpha_processing.c:252:28: */
- return (uint8_t((int32(x) & 0xf0) | (int32(x) >> 4)))
+ return uint8_t(int32(x)&0xf0 | int32(x)>>4)
}
func dither_lo(tls *libc.TLS, x uint8_t) uint8_t { /* alpha_processing.c:256:28: */
- return (uint8_t((int32(x) & 0x0f) | (int32(x) << 4)))
+ return uint8_t(int32(x)&0x0f | int32(x)<<4)
}
func multiply(tls *libc.TLS, x uint8_t, m uint32_t) uint8_t { /* alpha_processing.c:260:28: */
- return (uint8_t((uint32_t(x) * m) >> 16))
+ return uint8_t(uint32_t(x) * m >> 16)
}
func ApplyAlphaMultiply4444_C(tls *libc.TLS, rgba4444 uintptr, w int32, h int32, stride int32, rg_byte_pos int32) { /* alpha_processing.c:264:25: */
for libc.PostDecInt32(&h, 1) > 0 {
var i int32
for i = 0; i < w; i++ {
- var rg uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(rgba4444 + uintptr(((2 * i) + rg_byte_pos)))))
- var ba uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(rgba4444 + uintptr(((2 * i) + (rg_byte_pos ^ 1))))))
- var a uint8_t = (uint8_t(ba & uint32_t(0x0f)))
- var mult uint32_t = (uint32_t((int32(a)) * 0x1111))
+ var rg uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(rgba4444 + uintptr(2*i+rg_byte_pos))))
+ var ba uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(rgba4444 + uintptr(2*i+(rg_byte_pos^1)))))
+ var a uint8_t = uint8_t(ba & uint32_t(0x0f))
+ var mult uint32_t = uint32_t(int32(a) * 0x1111)
var r uint8_t = multiply(tls, dither_hi(tls, uint8(rg)), mult)
var g uint8_t = multiply(tls, dither_lo(tls, uint8(rg)), mult)
var b uint8_t = multiply(tls, dither_hi(tls, uint8(ba)), mult)
- *(*uint8_t)(unsafe.Pointer(rgba4444 + uintptr(((2 * i) + rg_byte_pos)))) = (uint8_t((int32(r) & 0xf0) | ((int32(g) >> 4) & 0x0f)))
- *(*uint8_t)(unsafe.Pointer(rgba4444 + uintptr(((2 * i) + (rg_byte_pos ^ 1))))) = (uint8_t((int32(b) & 0xf0) | int32(a)))
+ *(*uint8_t)(unsafe.Pointer(rgba4444 + uintptr(2*i+rg_byte_pos))) = uint8_t(int32(r)&0xf0 | int32(g)>>4&0x0f)
+ *(*uint8_t)(unsafe.Pointer(rgba4444 + uintptr(2*i+(rg_byte_pos^1)))) = uint8_t(int32(b)&0xf0 | int32(a))
}
rgba4444 += uintptr(stride)
}
@@ -14341,14 +14081,14 @@ func DispatchAlpha_C(tls *libc.TLS, alpha uintptr, alpha_stride int32, width int
for j = 0; j < height; j++ {
for i = 0; i < width; i++ {
var alpha_value uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(alpha + uintptr(i))))
- *(*uint8_t)(unsafe.Pointer(dst + uintptr((4 * i)))) = uint8_t(alpha_value)
- alpha_mask = alpha_mask & (alpha_value)
+ *(*uint8_t)(unsafe.Pointer(dst + uintptr(4*i))) = uint8_t(alpha_value)
+ alpha_mask = alpha_mask & alpha_value
}
alpha += uintptr(alpha_stride)
dst += uintptr(dst_stride)
}
- return (libc.Bool32(alpha_mask != uint32_t(0xff)))
+ return libc.Bool32(alpha_mask != uint32_t(0xff))
}
func DispatchAlphaToGreen_C(tls *libc.TLS, alpha uintptr, alpha_stride int32, width int32, height int32, dst uintptr, dst_stride int32) { /* alpha_processing.c:314:13: */
@@ -14356,10 +14096,10 @@ func DispatchAlphaToGreen_C(tls *libc.TLS, alpha uintptr, alpha_stride int32, wi
var j int32
for j = 0; j < height; j++ {
for i = 0; i < width; i++ {
- *(*uint32_t)(unsafe.Pointer(dst + uintptr(i)*4)) = (uint32_t(int32(*(*uint8_t)(unsafe.Pointer(alpha + uintptr(i)))) << 8)) // leave A/R/B channels zero'd.
+ *(*uint32_t)(unsafe.Pointer(dst + uintptr(i)*4)) = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(alpha + uintptr(i)))) << 8) // leave A/R/B channels zero'd.
}
alpha += uintptr(alpha_stride)
- dst += 4 * (uintptr(dst_stride))
+ dst += 4 * uintptr(dst_stride)
}
}
@@ -14370,20 +14110,20 @@ func ExtractAlpha_C(tls *libc.TLS, argb uintptr, argb_stride int32, width int32,
for j = 0; j < height; j++ {
for i = 0; i < width; i++ {
- var alpha_value uint8_t = *(*uint8_t)(unsafe.Pointer(argb + uintptr((4 * i))))
+ var alpha_value uint8_t = *(*uint8_t)(unsafe.Pointer(argb + uintptr(4*i)))
*(*uint8_t)(unsafe.Pointer(alpha + uintptr(i))) = alpha_value
- alpha_mask = uint8_t(int32(alpha_mask) & (int32(alpha_value)))
+ alpha_mask = uint8_t(int32(alpha_mask) & int32(alpha_value))
}
argb += uintptr(argb_stride)
alpha += uintptr(alpha_stride)
}
- return (libc.Bool32(int32(alpha_mask) == 0xff))
+ return libc.Bool32(int32(alpha_mask) == 0xff)
}
func ExtractGreen_C(tls *libc.TLS, argb uintptr, alpha uintptr, size int32) { /* alpha_processing.c:346:13: */
var i int32
for i = 0; i < size; i++ {
- *(*uint8_t)(unsafe.Pointer(alpha + uintptr(i))) = (uint8_t(*(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)) >> 8))
+ *(*uint8_t)(unsafe.Pointer(alpha + uintptr(i))) = uint8_t(*(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)) >> 8)
}
}
@@ -14400,7 +14140,7 @@ func HasAlpha8b_C(tls *libc.TLS, src uintptr, length int32) int32 { /* alpha_pro
func HasAlpha32b_C(tls *libc.TLS, src uintptr, length int32) int32 { /* alpha_processing.c:360:12: */
var x int32
- for x = 0; libc.PostDecInt32(&length, 1) > 0; x = x + (4) {
+ for x = 0; libc.PostDecInt32(&length, 1) > 0; x = x + 4 {
if int32(*(*uint8_t)(unsafe.Pointer(src + uintptr(x)))) != 0xff {
return 1
}
@@ -14411,7 +14151,7 @@ func HasAlpha32b_C(tls *libc.TLS, src uintptr, length int32) int32 { /* alpha_pr
func AlphaReplace_C(tls *libc.TLS, src uintptr, length int32, color uint32_t) { /* alpha_processing.c:366:13: */
var x int32
for x = 0; x < length; x++ {
- if (*(*uint32_t)(unsafe.Pointer(src + uintptr(x)*4)) >> 24) == uint32_t(0) {
+ if *(*uint32_t)(unsafe.Pointer(src + uintptr(x)*4))>>24 == uint32_t(0) {
*(*uint32_t)(unsafe.Pointer(src + uintptr(x)*4)) = color
}
}
@@ -14421,7 +14161,7 @@ func AlphaReplace_C(tls *libc.TLS, src uintptr, length int32, color uint32_t) {
// Simple channel manipulations.
func MakeARGB32(tls *libc.TLS, a int32, r int32, g int32, b int32) uint32_t { /* alpha_processing.c:374:29: */
- return ((((uint32_t(a) << 24) | (uint32_t(r << 16))) | (uint32_t(g << 8))) | uint32_t(b))
+ return uint32_t(a)<<24 | uint32_t(r<<16) | uint32_t(g<<8) | uint32_t(b)
}
func PackRGB_C(tls *libc.TLS, r uintptr, g uintptr, b uintptr, len int32, step int32, out uintptr) { /* alpha_processing.c:391:13: */
@@ -14429,7 +14169,7 @@ func PackRGB_C(tls *libc.TLS, r uintptr, g uintptr, b uintptr, len int32, step i
var offset int32 = 0
for i = 0; i < len; i++ {
*(*uint32_t)(unsafe.Pointer(out + uintptr(i)*4)) = MakeARGB32(tls, 0xff, int32(*(*uint8_t)(unsafe.Pointer(r + uintptr(offset)))), int32(*(*uint8_t)(unsafe.Pointer(g + uintptr(offset)))), int32(*(*uint8_t)(unsafe.Pointer(b + uintptr(offset)))))
- offset = offset + (step)
+ offset = offset + step
}
}
@@ -14446,7 +14186,7 @@ var WebPHasAlpha32b uintptr /* alpha_processing.c:422:5: */
var WebPAlphaReplace uintptr /* alpha_processing.c:423:6: */
func WebPInitAlphaProcessing(tls *libc.TLS) { /* alpha_processing.c:433:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if WebPInitAlphaProcessing_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -14498,7 +14238,7 @@ func WebPInitAlphaProcessing_body(tls *libc.TLS) { /* alpha_processing.c:433:1:
}{AlphaReplace_C}))
// If defined, use CPUInfo() to overwrite some pointers with faster versions.
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -14603,8 +14343,8 @@ type VP8BitWriter = VP8BitWriter1 /* bit_writer_utils.h:26:29 */
// return approximate write position (in bits)
func VP8BitWriterPos(tls *libc.TLS, bw uintptr) uint64_t { /* bit_writer_utils.h:56:29: */
- var nb_bits uint64_t = (uint64_t(8 + (*VP8BitWriter)(unsafe.Pointer(bw)).nb_bits_)) // bw->nb_bits_ is <= 0, note
- return ((((*VP8BitWriter)(unsafe.Pointer(bw)).pos_ + size_t((*VP8BitWriter)(unsafe.Pointer(bw)).run_)) * uint64(8)) + nb_bits)
+ var nb_bits uint64_t = uint64_t(8 + (*VP8BitWriter)(unsafe.Pointer(bw)).nb_bits_) // bw->nb_bits_ is <= 0, note
+ return ((*VP8BitWriter)(unsafe.Pointer(bw)).pos_+size_t((*VP8BitWriter)(unsafe.Pointer(bw)).run_))*uint64(8) + nb_bits
}
// Returns a pointer to the internal buffer.
@@ -14635,7 +14375,7 @@ type VP8LBitWriter = struct {
} /* bit_writer_utils.h:101:3 */
func VP8LBitWriterNumBytes(tls *libc.TLS, bw uintptr) size_t { /* bit_writer_utils.h:103:27: */
- return (size_t(((int64((*VP8LBitWriter)(unsafe.Pointer(bw)).cur_) - int64((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_)) / 1) + (int64(((*VP8LBitWriter)(unsafe.Pointer(bw)).used_ + 7) >> 3))))
+ return size_t((int64((*VP8LBitWriter)(unsafe.Pointer(bw)).cur_)-int64((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_))/1 + int64(((*VP8LBitWriter)(unsafe.Pointer(bw)).used_+7)>>3))
}
// This function writes bits into bytes in increasing addresses (little endian),
@@ -14649,8 +14389,8 @@ func VP8LPutBits(tls *libc.TLS, bw uintptr, bits uint32_t, n_bits int32) { /* bi
if (*VP8LBitWriter)(unsafe.Pointer(bw)).used_ >= 32 {
VP8LPutBitsFlushBits(tls, bw)
}
- *(*vp8l_atype_t)(unsafe.Pointer((bw /* &.bits_ */))) |= (vp8l_atype_t(bits) << (*VP8LBitWriter)(unsafe.Pointer(bw)).used_)
- *(*int32)(unsafe.Pointer((bw + 8 /* &.used_ */))) += (n_bits)
+ *(*vp8l_atype_t)(unsafe.Pointer(bw)) |= vp8l_atype_t(bits) << (*VP8LBitWriter)(unsafe.Pointer(bw)).used_
+ *(*int32)(unsafe.Pointer(bw + 8)) += n_bits
}
} else {
VP8LPutBitsInternal(tls, bw, bits, n_bits)
@@ -14673,7 +14413,7 @@ type score_t = int64_t /* vp8i_enc.h:107:17 */
// Fun fact: this is the _only_ line where we're actually being lossy and
// discarding bits.
func QUANTDIV(tls *libc.TLS, n uint32_t, iQ uint32_t, B uint32_t) int32 { /* vp8i_enc.h:116:24: */
- return (int32(((n * iQ) + B) >> 17))
+ return int32((n*iQ + B) >> 17)
}
// Uncomment the following to remove token-buffer code:
@@ -14906,7 +14646,7 @@ func VP8RecordStats(tls *libc.TLS, bit int32, stats uintptr) int32 { /* cost_enc
// An overflow is inbound. Note we handle this at 0xfffe0000u instead of
// 0xffff0000u to make sure p + 1u does not overflow.
if p >= 0xfffe0000 {
- p = (((p + 1) >> 1) & 0x7fff7fff) // -> divide the stats by 2.
+ p = (p + 1) >> 1 & 0x7fff7fff // -> divide the stats by 2.
}
// record bit count (lower 16 bits) and increment total count (upper 16 bits).
p = p + (0x00010000 + uint32(bit))
@@ -14919,17 +14659,17 @@ func VP8BitCost(tls *libc.TLS, bit int32, proba uint8_t) int32 { /* cost_enc.h:5
if !(bit != 0) {
return int32(VP8EntropyCost[proba])
}
- return int32(VP8EntropyCost[(255 - int32(proba))])
+ return int32(VP8EntropyCost[255-int32(proba)])
}
func VP8LevelCost(tls *libc.TLS, table uintptr, level int32) int32 { /* cost_enc.h:66:24: */
- return (int32(VP8LevelFixedCosts[level]) +
+ return int32(VP8LevelFixedCosts[level]) +
int32(*(*uint16_t)(unsafe.Pointer(table + uintptr(func() int32 {
if level > MAX_VARIABLE_LEVEL {
return MAX_VARIABLE_LEVEL
}
return level
- }())*2))))
+ }())*2)))
}
//------------------------------------------------------------------------------
@@ -15244,9 +14984,9 @@ var VP8EncBands = [17]uint8_t{
func GetResidualCost_C(tls *libc.TLS, ctx0 int32, res uintptr) int32 { /* cost.c:322:12: */
var n int32 = (*VP8Residual)(unsafe.Pointer(res)).first
// should be prob[VP8EncBands[n]], but it's equivalent for n=0 or 1
- var p0 int32 = int32(*(*uint8_t)(unsafe.Pointer((((*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(n)*33) + uintptr(ctx0)*11))))
+ var p0 int32 = int32(*(*uint8_t)(unsafe.Pointer((*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(n)*33 + uintptr(ctx0)*11)))
var costs CostArrayPtr = (*VP8Residual)(unsafe.Pointer(res)).costs
- var t uintptr = *(*uintptr)(unsafe.Pointer((costs + uintptr(n)*24) + uintptr(ctx0)*8))
+ var t uintptr = *(*uintptr)(unsafe.Pointer(costs + uintptr(n)*24 + uintptr(ctx0)*8))
// bit_cost(1, p0) is already incorporated in t[] tables, but only if ctx != 0
// (as required by the syntax). For ctx0 == 0, we need to add it here or it'll
// be missing during the loop.
@@ -15268,24 +15008,24 @@ func GetResidualCost_C(tls *libc.TLS, ctx0 int32, res uintptr) int32 { /* cost.c
} else {
ctx = v
}
- cost = cost + (VP8LevelCost(tls, t, v))
- t = *(*uintptr)(unsafe.Pointer((costs + uintptr((n+1))*24) + uintptr(ctx)*8))
+ cost = cost + VP8LevelCost(tls, t, v)
+ t = *(*uintptr)(unsafe.Pointer(costs + uintptr(n+1)*24 + uintptr(ctx)*8))
}
// Last coefficient is always non-zero
{
var v int32 = libc.Xabs(tls, int32(*(*int16_t)(unsafe.Pointer((*VP8Residual)(unsafe.Pointer(res)).coeffs + uintptr(n)*2))))
- cost = cost + (VP8LevelCost(tls, t, v))
+ cost = cost + VP8LevelCost(tls, t, v)
if n < 15 {
- var b int32 = int32(VP8EncBands[(n + 1)])
+ var b int32 = int32(VP8EncBands[n+1])
var ctx int32
if v == 1 {
ctx = 1
} else {
ctx = 2
}
- var last_p0 int32 = int32(*(*uint8_t)(unsafe.Pointer((((*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(b)*33) + uintptr(ctx)*11))))
- cost = cost + (VP8BitCost(tls, 0, uint8(last_p0)))
+ var last_p0 int32 = int32(*(*uint8_t)(unsafe.Pointer((*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(b)*33 + uintptr(ctx)*11)))
+ cost = cost + VP8BitCost(tls, 0, uint8(last_p0))
}
}
@@ -15312,7 +15052,7 @@ var VP8GetResidualCost VP8GetResidualCostFunc /* cost.c:374:24: */
var VP8SetResidualCoeffs VP8SetResidualCoeffsFunc /* cost.c:375:26: */
func VP8EncDspCostInit(tls *libc.TLS) { /* cost.c:382:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if VP8EncDspCostInit_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -15332,7 +15072,7 @@ func VP8EncDspCostInit_body(tls *libc.TLS) { /* cost.c:382:1: */
}{SetResidualCoeffs_C}))
// If defined, use CPUInfo() to overwrite some pointers with faster versions.
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -15354,16 +15094,16 @@ func xgetbv(tls *libc.TLS) uint64_t { /* cpu.c:74:29: */
var eax uint32_t
var edx uint32_t
panic(`cpu.c:78:3: assembler statements not supported`)
- return ((uint64_t(edx) << 32) | uint64_t(eax))
+ return uint64_t(edx)<<32 | uint64_t(eax)
}
// helper function for run-time detection of slow SSSE3 platforms
func CheckSlowModel(tls *libc.TLS, info int32) int32 { /* cpu.c:106:12: */
- var model uint32_t = (uint32_t(((info & 0xf0000) >> 12) | ((info >> 4) & 0xf)))
- var family uint32_t = (uint32_t((info >> 8) & 0xf))
+ var model uint32_t = uint32_t(info&0xf0000>>12 | info>>4&0xf)
+ var family uint32_t = uint32_t(info >> 8 & 0xf)
if family == uint32_t(0x06) {
var i size_t
- for i = uint64(0); i < (uint64(unsafe.Sizeof(kSlowModels)) / uint64(unsafe.Sizeof(uint8_t(0)))); i++ {
+ for i = uint64(0); i < uint64(unsafe.Sizeof(kSlowModels))/uint64(unsafe.Sizeof(uint8_t(0))); i++ {
if model == uint32_t(kSlowModels[i]) {
return 1
}
@@ -15387,45 +15127,45 @@ func x86CPUInfo(tls *libc.TLS, feature CPUFeature) int32 { /* cpu.c:125:12: */
var is_intel int32 = 0
// get the highest feature value cpuid supports
- GetCPUInfo(tls, (bp) /* &cpu_info[0] */, 0)
- max_cpuid_value = *(*int32)(unsafe.Pointer((bp) /* &cpu_info[0] */))
+ GetCPUInfo(tls, bp, 0)
+ max_cpuid_value = *(*int32)(unsafe.Pointer(bp))
if max_cpuid_value < 1 {
return 0
} else {
- var VENDOR_ID_INTEL_EBX int32 = 0x756e6547 // uneG
- var VENDOR_ID_INTEL_EDX int32 = 0x49656e69 // Ieni
- var VENDOR_ID_INTEL_ECX int32 = 0x6c65746e // letn
- is_intel = (libc.Bool32(((*(*int32)(unsafe.Pointer((bp) /* &cpu_info[0] */ + 1*4)) == VENDOR_ID_INTEL_EBX) && (*(*int32)(unsafe.Pointer((bp) /* &cpu_info[0] */ + 2*4)) == VENDOR_ID_INTEL_ECX)) && (*(*int32)(unsafe.Pointer((bp) /* &cpu_info[0] */ + 3*4)) == VENDOR_ID_INTEL_EDX))) // genuine Intel?
+ var VENDOR_ID_INTEL_EBX int32 = 0x756e6547 // uneG
+ var VENDOR_ID_INTEL_EDX int32 = 0x49656e69 // Ieni
+ var VENDOR_ID_INTEL_ECX int32 = 0x6c65746e // letn
+ is_intel = libc.Bool32(*(*int32)(unsafe.Pointer(bp + 1*4)) == VENDOR_ID_INTEL_EBX && *(*int32)(unsafe.Pointer(bp + 2*4)) == VENDOR_ID_INTEL_ECX && *(*int32)(unsafe.Pointer(bp + 3*4)) == VENDOR_ID_INTEL_EDX) // genuine Intel?
}
- GetCPUInfo(tls, (bp) /* &cpu_info[0] */, 1)
+ GetCPUInfo(tls, bp, 1)
if feature == kSSE2 {
- return libc.BoolInt32(!(!((*(*int32)(unsafe.Pointer((bp) /* &cpu_info[0] */ + 3*4)) & (int32(1) << 26)) != 0)))
+ return libc.BoolInt32(!!(*(*int32)(unsafe.Pointer(bp + 3*4))&(int32(1)<<26) != 0))
}
if feature == kSSE3 {
- return libc.BoolInt32(!(!((*(*int32)(unsafe.Pointer((bp) /* &cpu_info[0] */ + 2*4)) & (int32(1) << 0)) != 0)))
+ return libc.BoolInt32(!!(*(*int32)(unsafe.Pointer(bp + 2*4))&(int32(1)<<0) != 0))
}
if feature == kSlowSSSE3 {
- if (is_intel != 0) && ((*(*int32)(unsafe.Pointer((bp) /* &cpu_info[0] */ + 2*4)) & (int32(1) << 9)) != 0) { // SSSE3?
- return CheckSlowModel(tls, *(*int32)(unsafe.Pointer((bp) /* &cpu_info[0] */)))
+ if is_intel != 0 && *(*int32)(unsafe.Pointer(bp + 2*4))&(int32(1)<<9) != 0 { // SSSE3?
+ return CheckSlowModel(tls, *(*int32)(unsafe.Pointer(bp)))
}
return 0
}
if feature == kSSE4_1 {
- return libc.BoolInt32(!(!((*(*int32)(unsafe.Pointer((bp) /* &cpu_info[0] */ + 2*4)) & (int32(1) << 19)) != 0)))
+ return libc.BoolInt32(!!(*(*int32)(unsafe.Pointer(bp + 2*4))&(int32(1)<<19) != 0))
}
if feature == kAVX {
// bits 27 (OSXSAVE) & 28 (256-bit AVX)
- if (*(*int32)(unsafe.Pointer((bp) /* &cpu_info[0] */ + 2*4)) & 0x18000000) == 0x18000000 {
+ if *(*int32)(unsafe.Pointer(bp + 2*4))&0x18000000 == 0x18000000 {
// XMM state and YMM state enabled by the OS.
- return (libc.Bool32((xgetbv(tls) & uint64(0x6)) == uint64(0x6)))
+ return libc.Bool32(xgetbv(tls)&uint64(0x6) == uint64(0x6))
}
}
if feature == kAVX2 {
- if (x86CPUInfo(tls, kAVX) != 0) && (max_cpuid_value >= 7) {
- GetCPUInfo(tls, (bp) /* &cpu_info[0] */, 7)
- return libc.BoolInt32(!(!((*(*int32)(unsafe.Pointer((bp) /* &cpu_info[0] */ + 1*4)) & (int32(1) << 5)) != 0)))
+ if x86CPUInfo(tls, kAVX) != 0 && max_cpuid_value >= 7 {
+ GetCPUInfo(tls, bp, 7)
+ return libc.BoolInt32(!!(*(*int32)(unsafe.Pointer(bp + 1*4))&(int32(1)<<5) != 0))
}
}
return 0
@@ -15438,7 +15178,7 @@ var VP8GetCPUInfo VP8CPUInfo = 0 /* cpu.c:176:12 */
//------------------------------------------------------------------------------
func clip_8b(tls *libc.TLS, v int32) uint8_t { /* dec.c:22:28: */
- if !((v & libc.CplInt32(0xff)) != 0) {
+ if !(v&libc.CplInt32(0xff) != 0) {
return uint8(v)
}
if v < 0 {
@@ -15458,17 +15198,17 @@ func TransformOne_C(tls *libc.TLS, in uintptr, dst uintptr) { /* dec.c:44:13: */
var tmp uintptr
var i int32
- tmp = (bp) /* &C[0] */
+ tmp = bp /* &C[0] */
for i = 0; i < 4; i++ { // vertical pass
- var a int32 = (int32(*(*int16_t)(unsafe.Pointer(in))) + int32(*(*int16_t)(unsafe.Pointer(in + 8*2)))) // [-4096, 4094]
- var b int32 = (int32(*(*int16_t)(unsafe.Pointer(in))) - int32(*(*int16_t)(unsafe.Pointer(in + 8*2)))) // [-4095, 4095]
- var c int32 = ((((int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))) * 35468) >> 16) - ((((int32(*(*int16_t)(unsafe.Pointer(in + 12*2)))) * 20091) >> 16) + (int32(*(*int16_t)(unsafe.Pointer(in + 12*2)))))) // [-3783, 3783]
- var d int32 = (((((int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))) * 20091) >> 16) + (int32(*(*int16_t)(unsafe.Pointer(in + 4*2))))) + (((int32(*(*int16_t)(unsafe.Pointer(in + 12*2)))) * 35468) >> 16)) // [-3785, 3781]
- *(*int32)(unsafe.Pointer(tmp)) = (a + d) // [-7881, 7875]
- *(*int32)(unsafe.Pointer(tmp + 1*4)) = (b + c) // [-7878, 7878]
- *(*int32)(unsafe.Pointer(tmp + 2*4)) = (b - c) // [-7878, 7878]
- *(*int32)(unsafe.Pointer(tmp + 3*4)) = (a - d) // [-7877, 7879]
- tmp += 4 * (uintptr(4))
+ var a int32 = int32(*(*int16_t)(unsafe.Pointer(in))) + int32(*(*int16_t)(unsafe.Pointer(in + 8*2))) // [-4096, 4094]
+ var b int32 = int32(*(*int16_t)(unsafe.Pointer(in))) - int32(*(*int16_t)(unsafe.Pointer(in + 8*2))) // [-4095, 4095]
+ var c int32 = int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))*35468>>16 - (int32(*(*int16_t)(unsafe.Pointer(in + 12*2)))*20091>>16 + int32(*(*int16_t)(unsafe.Pointer(in + 12*2)))) // [-3783, 3783]
+ var d int32 = int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))*20091>>16 + int32(*(*int16_t)(unsafe.Pointer(in + 4*2))) + int32(*(*int16_t)(unsafe.Pointer(in + 12*2)))*35468>>16 // [-3785, 3781]
+ *(*int32)(unsafe.Pointer(tmp)) = a + d // [-7881, 7875]
+ *(*int32)(unsafe.Pointer(tmp + 1*4)) = b + c // [-7878, 7878]
+ *(*int32)(unsafe.Pointer(tmp + 2*4)) = b - c // [-7878, 7878]
+ *(*int32)(unsafe.Pointer(tmp + 3*4)) = a - d // [-7877, 7879]
+ tmp += 4 * uintptr(4)
in += 2
}
// Each pass is expanding the dynamic range by ~3.85 (upper bound).
@@ -15478,17 +15218,17 @@ func TransformOne_C(tls *libc.TLS, in uintptr, dst uintptr) { /* dec.c:44:13: */
// in the [0, 255] range.
// In the worst case scenario, the input to clip_8b() can be as large as
// [-60713, 60968].
- tmp = (bp) /* &C[0] */
+ tmp = bp /* &C[0] */
for i = 0; i < 4; i++ { // horizontal pass
- var dc int32 = (*(*int32)(unsafe.Pointer(tmp)) + 4)
- var a int32 = (dc + *(*int32)(unsafe.Pointer(tmp + 8*4)))
- var b int32 = (dc - *(*int32)(unsafe.Pointer(tmp + 8*4)))
- var c int32 = ((((*(*int32)(unsafe.Pointer(tmp + 4*4))) * 35468) >> 16) - ((((*(*int32)(unsafe.Pointer(tmp + 12*4))) * 20091) >> 16) + (*(*int32)(unsafe.Pointer(tmp + 12*4)))))
- var d int32 = (((((*(*int32)(unsafe.Pointer(tmp + 4*4))) * 20091) >> 16) + (*(*int32)(unsafe.Pointer(tmp + 4*4)))) + (((*(*int32)(unsafe.Pointer(tmp + 12*4))) * 35468) >> 16))
- *(*uint8_t)(unsafe.Pointer(dst)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst))) + ((a + d) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 1))) + ((b + c) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 2))) + ((b - c) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 3))) + ((a - d) >> 3)))
+ var dc int32 = *(*int32)(unsafe.Pointer(tmp)) + 4
+ var a int32 = dc + *(*int32)(unsafe.Pointer(tmp + 8*4))
+ var b int32 = dc - *(*int32)(unsafe.Pointer(tmp + 8*4))
+ var c int32 = *(*int32)(unsafe.Pointer(tmp + 4*4))*35468>>16 - (*(*int32)(unsafe.Pointer(tmp + 12*4))*20091>>16 + *(*int32)(unsafe.Pointer(tmp + 12*4)))
+ var d int32 = *(*int32)(unsafe.Pointer(tmp + 4*4))*20091>>16 + *(*int32)(unsafe.Pointer(tmp + 4*4)) + *(*int32)(unsafe.Pointer(tmp + 12*4))*35468>>16
+ *(*uint8_t)(unsafe.Pointer(dst)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst)))+(a+d)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 1)))+(b+c)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 2)))+(b-c)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 3)))+(a-d)>>3)
tmp += 4
dst += uintptr(32)
}
@@ -15496,64 +15236,64 @@ func TransformOne_C(tls *libc.TLS, in uintptr, dst uintptr) { /* dec.c:44:13: */
// Simplified transform when only in[0], in[1] and in[4] are non-zero
func TransformAC3_C(tls *libc.TLS, in uintptr, dst uintptr) { /* dec.c:84:13: */
- var a int32 = (int32(*(*int16_t)(unsafe.Pointer(in))) + 4)
- var c4 int32 = (((int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))) * 35468) >> 16)
- var d4 int32 = ((((int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))) * 20091) >> 16) + (int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))))
- var c1 int32 = (((int32(*(*int16_t)(unsafe.Pointer(in + 1*2)))) * 35468) >> 16)
- var d1 int32 = ((((int32(*(*int16_t)(unsafe.Pointer(in + 1*2)))) * 20091) >> 16) + (int32(*(*int16_t)(unsafe.Pointer(in + 1*2)))))
- for ok := true; ok; ok = (0 != 0) {
- var DC int32 = (a + d4)
- *(*uint8_t)(unsafe.Pointer(dst)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst))) + ((DC + (d1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 1))) + ((DC + (c1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 2))) + ((DC - (c1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 3))) + ((DC - (d1)) >> 3)))
- }
- for ok1 := true; ok1; ok1 = (0 != 0) {
- var DC int32 = (a + c4)
- *(*uint8_t)(unsafe.Pointer(dst + 32)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 32))) + ((DC + (d1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 33)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 33))) + ((DC + (c1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 34)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 34))) + ((DC - (c1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 35)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 35))) + ((DC - (d1)) >> 3)))
- }
- for ok2 := true; ok2; ok2 = (0 != 0) {
- var DC int32 = (a - c4)
- *(*uint8_t)(unsafe.Pointer(dst + 64)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 64))) + ((DC + (d1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 65)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 65))) + ((DC + (c1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 66)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 66))) + ((DC - (c1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 67)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 67))) + ((DC - (d1)) >> 3)))
- }
- for ok3 := true; ok3; ok3 = (0 != 0) {
- var DC int32 = (a - d4)
- *(*uint8_t)(unsafe.Pointer(dst + 96)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 96))) + ((DC + (d1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 97)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 97))) + ((DC + (c1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 98)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 98))) + ((DC - (c1)) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 99)) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + 99))) + ((DC - (d1)) >> 3)))
+ var a int32 = int32(*(*int16_t)(unsafe.Pointer(in))) + 4
+ var c4 int32 = int32(*(*int16_t)(unsafe.Pointer(in + 4*2))) * 35468 >> 16
+ var d4 int32 = int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))*20091>>16 + int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))
+ var c1 int32 = int32(*(*int16_t)(unsafe.Pointer(in + 1*2))) * 35468 >> 16
+ var d1 int32 = int32(*(*int16_t)(unsafe.Pointer(in + 1*2)))*20091>>16 + int32(*(*int16_t)(unsafe.Pointer(in + 1*2)))
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
+ var DC int32 = a + d4
+ *(*uint8_t)(unsafe.Pointer(dst)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst)))+(DC+d1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 1)))+(DC+c1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 2)))+(DC-c1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 3)))+(DC-d1)>>3)
+ }
+ for __ccgo1 := true; __ccgo1; __ccgo1 = 0 != 0 {
+ var DC int32 = a + c4
+ *(*uint8_t)(unsafe.Pointer(dst + 32)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 32)))+(DC+d1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 33)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 33)))+(DC+c1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 34)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 34)))+(DC-c1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 35)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 35)))+(DC-d1)>>3)
+ }
+ for __ccgo2 := true; __ccgo2; __ccgo2 = 0 != 0 {
+ var DC int32 = a - c4
+ *(*uint8_t)(unsafe.Pointer(dst + 64)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 64)))+(DC+d1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 65)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 65)))+(DC+c1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 66)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 66)))+(DC-c1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 67)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 67)))+(DC-d1)>>3)
+ }
+ for __ccgo3 := true; __ccgo3; __ccgo3 = 0 != 0 {
+ var DC int32 = a - d4
+ *(*uint8_t)(unsafe.Pointer(dst + 96)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 96)))+(DC+d1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 97)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 97)))+(DC+c1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 98)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 98)))+(DC-c1)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + 99)) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + 99)))+(DC-d1)>>3)
}
}
func TransformTwo_C(tls *libc.TLS, in uintptr, dst uintptr, do_two int32) { /* dec.c:99:13: */
TransformOne_C(tls, in, dst)
if do_two != 0 {
- TransformOne_C(tls, (in + uintptr(16)*2), (dst + uintptr(4)))
+ TransformOne_C(tls, in+uintptr(16)*2, dst+uintptr(4))
}
}
func TransformUV_C(tls *libc.TLS, in uintptr, dst uintptr) { /* dec.c:107:13: */
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8Transform})).f(tls, (in + uintptr((0*16))*2), dst, 1)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8Transform})).f(tls, in+uintptr(0*16)*2, dst, 1)
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8Transform})).f(tls, (in + uintptr((2*16))*2), (dst + uintptr((4 * 32))), 1)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8Transform})).f(tls, in+uintptr(2*16)*2, dst+uintptr(4*32), 1)
}
func TransformDC_C(tls *libc.TLS, in uintptr, dst uintptr) { /* dec.c:113:13: */
- var DC int32 = (int32(*(*int16_t)(unsafe.Pointer(in))) + 4)
+ var DC int32 = int32(*(*int16_t)(unsafe.Pointer(in))) + 4
var i int32
var j int32
for j = 0; j < 4; j++ {
for i = 0; i < 4; i++ {
- *(*uint8_t)(unsafe.Pointer(dst + uintptr(((i) + ((j) * 32))))) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(((i) + ((j) * 32)))))) + ((DC) >> 3)))
+ *(*uint8_t)(unsafe.Pointer(dst + uintptr(i+j*32))) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(i+j*32))))+DC>>3)
}
}
}
@@ -15562,22 +15302,22 @@ func TransformDCUV_C(tls *libc.TLS, in uintptr, dst uintptr) { /* dec.c:124:13:
if *(*int16_t)(unsafe.Pointer(in)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})).f(tls, (in + uintptr((0*16))*2), dst)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})).f(tls, in+uintptr(0*16)*2, dst)
}
if *(*int16_t)(unsafe.Pointer(in + 16*2)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})).f(tls, (in + uintptr((1*16))*2), (dst + uintptr(4)))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})).f(tls, in+uintptr(1*16)*2, dst+uintptr(4))
}
if *(*int16_t)(unsafe.Pointer(in + 32*2)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})).f(tls, (in + uintptr((2*16))*2), (dst + uintptr((4 * 32))))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})).f(tls, in+uintptr(2*16)*2, dst+uintptr(4*32))
}
if *(*int16_t)(unsafe.Pointer(in + 48*2)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})).f(tls, (in + uintptr((3*16))*2), ((dst + uintptr((4 * 32))) + uintptr(4)))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})).f(tls, in+uintptr(3*16)*2, dst+uintptr(4*32)+uintptr(4))
}
}
@@ -15592,26 +15332,26 @@ func TransformWHT_C(tls *libc.TLS, in uintptr, out uintptr) { /* dec.c:137:13: *
var i int32
for i = 0; i < 4; i++ {
- var a0 int32 = (int32(*(*int16_t)(unsafe.Pointer(in + uintptr((0+i))*2))) + int32(*(*int16_t)(unsafe.Pointer(in + uintptr((12+i))*2))))
- var a1 int32 = (int32(*(*int16_t)(unsafe.Pointer(in + uintptr((4+i))*2))) + int32(*(*int16_t)(unsafe.Pointer(in + uintptr((8+i))*2))))
- var a2 int32 = (int32(*(*int16_t)(unsafe.Pointer(in + uintptr((4+i))*2))) - int32(*(*int16_t)(unsafe.Pointer(in + uintptr((8+i))*2))))
- var a3 int32 = (int32(*(*int16_t)(unsafe.Pointer(in + uintptr((0+i))*2))) - int32(*(*int16_t)(unsafe.Pointer(in + uintptr((12+i))*2))))
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((0+i))*4)) = (a0 + a1)
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((8+i))*4)) = (a0 - a1)
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((4+i))*4)) = (a3 + a2)
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((12+i))*4)) = (a3 - a2)
+ var a0 int32 = int32(*(*int16_t)(unsafe.Pointer(in + uintptr(0+i)*2))) + int32(*(*int16_t)(unsafe.Pointer(in + uintptr(12+i)*2)))
+ var a1 int32 = int32(*(*int16_t)(unsafe.Pointer(in + uintptr(4+i)*2))) + int32(*(*int16_t)(unsafe.Pointer(in + uintptr(8+i)*2)))
+ var a2 int32 = int32(*(*int16_t)(unsafe.Pointer(in + uintptr(4+i)*2))) - int32(*(*int16_t)(unsafe.Pointer(in + uintptr(8+i)*2)))
+ var a3 int32 = int32(*(*int16_t)(unsafe.Pointer(in + uintptr(0+i)*2))) - int32(*(*int16_t)(unsafe.Pointer(in + uintptr(12+i)*2)))
+ *(*int32)(unsafe.Pointer(bp + uintptr(0+i)*4)) = a0 + a1
+ *(*int32)(unsafe.Pointer(bp + uintptr(8+i)*4)) = a0 - a1
+ *(*int32)(unsafe.Pointer(bp + uintptr(4+i)*4)) = a3 + a2
+ *(*int32)(unsafe.Pointer(bp + uintptr(12+i)*4)) = a3 - a2
}
for i = 0; i < 4; i++ {
- var dc int32 = (*(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((0+(i*4)))*4)) + 3) // w/ rounder
- var a0 int32 = (dc + *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((3+(i*4)))*4)))
- var a1 int32 = (*(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((1+(i*4)))*4)) + *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((2+(i*4)))*4)))
- var a2 int32 = (*(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((1+(i*4)))*4)) - *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((2+(i*4)))*4)))
- var a3 int32 = (dc - *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((3+(i*4)))*4)))
- *(*int16_t)(unsafe.Pointer(out)) = (int16_t((a0 + a1) >> 3))
- *(*int16_t)(unsafe.Pointer(out + 16*2)) = (int16_t((a3 + a2) >> 3))
- *(*int16_t)(unsafe.Pointer(out + 32*2)) = (int16_t((a0 - a1) >> 3))
- *(*int16_t)(unsafe.Pointer(out + 48*2)) = (int16_t((a3 - a2) >> 3))
- out += 2 * (uintptr(64))
+ var dc int32 = *(*int32)(unsafe.Pointer(bp + uintptr(0+i*4)*4)) + 3 // w/ rounder
+ var a0 int32 = dc + *(*int32)(unsafe.Pointer(bp + uintptr(3+i*4)*4))
+ var a1 int32 = *(*int32)(unsafe.Pointer(bp + uintptr(1+i*4)*4)) + *(*int32)(unsafe.Pointer(bp + uintptr(2+i*4)*4))
+ var a2 int32 = *(*int32)(unsafe.Pointer(bp + uintptr(1+i*4)*4)) - *(*int32)(unsafe.Pointer(bp + uintptr(2+i*4)*4))
+ var a3 int32 = dc - *(*int32)(unsafe.Pointer(bp + uintptr(3+i*4)*4))
+ *(*int16_t)(unsafe.Pointer(out)) = int16_t((a0 + a1) >> 3)
+ *(*int16_t)(unsafe.Pointer(out + 16*2)) = int16_t((a3 + a2) >> 3)
+ *(*int16_t)(unsafe.Pointer(out + 32*2)) = int16_t((a0 - a1) >> 3)
+ *(*int16_t)(unsafe.Pointer(out + 48*2)) = int16_t((a3 - a2) >> 3)
+ out += 2 * uintptr(64)
}
}
@@ -15621,11 +15361,11 @@ var VP8TransformWHT uintptr /* dec.c:165:6: */
// Intra predictions
func TrueMotion(tls *libc.TLS, dst uintptr, size int32) { /* dec.c:173:25: */
- var top uintptr = (dst - uintptr(32))
- var clip0 uintptr = (VP8kclip1 - uintptr(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-1)))))
+ var top uintptr = dst - uintptr(32)
+ var clip0 uintptr = VP8kclip1 - uintptr(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-1))))
var y int32
for y = 0; y < size; y++ {
- var clip uintptr = (clip0 + uintptr(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(-1)))))
+ var clip uintptr = clip0 + uintptr(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(-1))))
var x int32
for x = 0; x < size; x++ {
*(*uint8_t)(unsafe.Pointer(dst + uintptr(x))) = *(*uint8_t)(unsafe.Pointer(clip + uintptr(*(*uint8_t)(unsafe.Pointer(top + uintptr(x))))))
@@ -15652,7 +15392,7 @@ func TM16_C(tls *libc.TLS, dst uintptr) { /* dec.c:188:13: */
func VE16_C(tls *libc.TLS, dst uintptr) { /* dec.c:193:13: */ // vertical
var j int32
for j = 0; j < 16; j++ {
- libc.Xmemcpy(tls, (dst + uintptr((j * 32))), (dst - uintptr(32)), uint64(16))
+ libc.Xmemcpy(tls, dst+uintptr(j*32), dst-uintptr(32), uint64(16))
}
}
@@ -15667,7 +15407,7 @@ func HE16_C(tls *libc.TLS, dst uintptr) { /* dec.c:200:13: */ // horizontal
func Put16(tls *libc.TLS, v int32, dst uintptr) { /* dec.c:208:25: */
var j int32
for j = 0; j < 16; j++ {
- libc.Xmemset(tls, (dst + uintptr((j * 32))), v, uint64(16))
+ libc.Xmemset(tls, dst+uintptr(j*32), v, uint64(16))
}
}
@@ -15675,27 +15415,27 @@ func DC16_C(tls *libc.TLS, dst uintptr) { /* dec.c:215:13: */ // DC
var DC int32 = 16
var j int32
for j = 0; j < 16; j++ {
- DC = DC + (int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr((-1 + (j * 32)))))) + int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr((j - 32))))))
+ DC = DC + (int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(-1+j*32)))) + int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(j-32)))))
}
- Put16(tls, (DC >> 5), dst)
+ Put16(tls, DC>>5, dst)
}
func DC16NoTop_C(tls *libc.TLS, dst uintptr) { /* dec.c:224:13: */ // DC with top samples not available
var DC int32 = 8
var j int32
for j = 0; j < 16; j++ {
- DC = DC + (int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr((-1 + (j * 32)))))))
+ DC = DC + int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(-1+j*32))))
}
- Put16(tls, (DC >> 4), dst)
+ Put16(tls, DC>>4, dst)
}
func DC16NoLeft_C(tls *libc.TLS, dst uintptr) { /* dec.c:233:13: */ // DC with left samples not available
var DC int32 = 8
var i int32
for i = 0; i < 16; i++ {
- DC = DC + (int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr((i - 32))))))
+ DC = DC + int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(i-32))))
}
- Put16(tls, (DC >> 4), dst)
+ Put16(tls, DC>>4, dst)
}
func DC16NoTopLeft_C(tls *libc.TLS, dst uintptr) { /* dec.c:242:13: */ // DC with no top and left samples
@@ -15711,159 +15451,159 @@ func VE4_C(tls *libc.TLS, dst uintptr) { /* dec.c:256:13: */
bp := tls.Alloc(4)
defer tls.Free(4)
// vertical
- var top uintptr = (dst - uintptr(32))
+ var top uintptr = dst - uintptr(32)
*(*[4]uint8_t)(unsafe.Pointer(bp /* vals */)) = [4]uint8_t{
- (uint8_t(((((int32(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-1))))) + (2 * (int32(*(*uint8_t)(unsafe.Pointer(top)))))) + (int32(*(*uint8_t)(unsafe.Pointer(top + 1))))) + 2) >> 2)),
- (uint8_t(((((int32(*(*uint8_t)(unsafe.Pointer(top)))) + (2 * (int32(*(*uint8_t)(unsafe.Pointer(top + 1)))))) + (int32(*(*uint8_t)(unsafe.Pointer(top + 2))))) + 2) >> 2)),
- (uint8_t(((((int32(*(*uint8_t)(unsafe.Pointer(top + 1)))) + (2 * (int32(*(*uint8_t)(unsafe.Pointer(top + 2)))))) + (int32(*(*uint8_t)(unsafe.Pointer(top + 3))))) + 2) >> 2)),
- (uint8_t(((((int32(*(*uint8_t)(unsafe.Pointer(top + 2)))) + (2 * (int32(*(*uint8_t)(unsafe.Pointer(top + 3)))))) + (int32(*(*uint8_t)(unsafe.Pointer(top + 4))))) + 2) >> 2)),
+ uint8_t((int32(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-1)))) + 2*int32(*(*uint8_t)(unsafe.Pointer(top))) + int32(*(*uint8_t)(unsafe.Pointer(top + 1))) + 2) >> 2),
+ uint8_t((int32(*(*uint8_t)(unsafe.Pointer(top))) + 2*int32(*(*uint8_t)(unsafe.Pointer(top + 1))) + int32(*(*uint8_t)(unsafe.Pointer(top + 2))) + 2) >> 2),
+ uint8_t((int32(*(*uint8_t)(unsafe.Pointer(top + 1))) + 2*int32(*(*uint8_t)(unsafe.Pointer(top + 2))) + int32(*(*uint8_t)(unsafe.Pointer(top + 3))) + 2) >> 2),
+ uint8_t((int32(*(*uint8_t)(unsafe.Pointer(top + 2))) + 2*int32(*(*uint8_t)(unsafe.Pointer(top + 3))) + int32(*(*uint8_t)(unsafe.Pointer(top + 4))) + 2) >> 2),
}
var i int32
for i = 0; i < 4; i++ {
- libc.Xmemcpy(tls, (dst + uintptr((i * 32))), (bp) /* &vals[0] */, uint64(unsafe.Sizeof([4]uint8_t{})))
+ libc.Xmemcpy(tls, dst+uintptr(i*32), bp, uint64(unsafe.Sizeof([4]uint8_t{})))
}
}
func HE4_C(tls *libc.TLS, dst uintptr) { /* dec.c:271:13: */ // horizontal
- var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((-1 - 32)))))
+ var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(-1-32))))
var B int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(-1))))
var C int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 31)))
var D int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 63)))
var E int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 95)))
- WebPUint32ToMem(tls, (dst + uintptr((0 * 32))), (0x01010101 * (uint32((uint8_t(((((A) + (2 * (B))) + (C)) + 2) >> 2))))))
- WebPUint32ToMem(tls, (dst + uintptr((1 * 32))), (0x01010101 * (uint32((uint8_t(((((B) + (2 * (C))) + (D)) + 2) >> 2))))))
- WebPUint32ToMem(tls, (dst + uintptr((2 * 32))), (0x01010101 * (uint32((uint8_t(((((C) + (2 * (D))) + (E)) + 2) >> 2))))))
- WebPUint32ToMem(tls, (dst + uintptr((3 * 32))), (0x01010101 * (uint32((uint8_t(((((D) + (2 * (E))) + (E)) + 2) >> 2))))))
+ WebPUint32ToMem(tls, dst+uintptr(0*32), 0x01010101*uint32(uint8_t((A+2*B+C+2)>>2)))
+ WebPUint32ToMem(tls, dst+uintptr(1*32), 0x01010101*uint32(uint8_t((B+2*C+D+2)>>2)))
+ WebPUint32ToMem(tls, dst+uintptr(2*32), 0x01010101*uint32(uint8_t((C+2*D+E+2)>>2)))
+ WebPUint32ToMem(tls, dst+uintptr(3*32), 0x01010101*uint32(uint8_t((D+2*E+E+2)>>2)))
}
func DC4_C(tls *libc.TLS, dst uintptr) { /* dec.c:284:13: */ // DC
var dc uint32_t = uint32_t(4)
var i int32
for i = 0; i < 4; i++ {
- dc = dc + (uint32_t(int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr((i - 32))))) + int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr((-1 + (i * 32))))))))
+ dc = dc + uint32_t(int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(i-32))))+int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(-1+i*32)))))
}
dc >>= 3
for i = 0; i < 4; i++ {
- libc.Xmemset(tls, (dst + uintptr((i * 32))), int32(dc), uint64(4))
+ libc.Xmemset(tls, dst+uintptr(i*32), int32(dc), uint64(4))
}
}
func RD4_C(tls *libc.TLS, dst uintptr) { /* dec.c:292:13: */ // Down-right
- var I int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((-1 + (0 * 32))))))
+ var I int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(-1+0*32))))
var J int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 31)))
var K int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 63)))
var L int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 95)))
- var X int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((-1 - 32)))))
- var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((0 - 32)))))
- var B int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((1 - 32)))))
- var C int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((2 - 32)))))
- var D int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((3 - 32)))))
- *(*uint8_t)(unsafe.Pointer(dst + 96)) = (uint8_t(((((J) + (2 * (K))) + (L)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 97)) = libc.AssignPtrUint8((dst + 64), (uint8_t(((((I) + (2 * (J))) + (K)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 98)) = libc.AssignPtrUint8((dst + 65), libc.AssignPtrUint8((dst+32), (uint8_t(((((X)+(2*(I)))+(J))+2)>>2))))
- *(*uint8_t)(unsafe.Pointer(dst + 99)) = libc.AssignPtrUint8((dst + 66), libc.AssignPtrUint8((dst+33), libc.AssignPtrUint8((dst), (uint8_t(((((A)+(2*(X)))+(I))+2)>>2)))))
- *(*uint8_t)(unsafe.Pointer(dst + 67)) = libc.AssignPtrUint8((dst + 34), libc.AssignPtrUint8((dst+1), (uint8_t(((((B)+(2*(A)))+(X))+2)>>2))))
- *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8((dst + 2), (uint8_t(((((C) + (2 * (B))) + (A)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = (uint8_t(((((D) + (2 * (C))) + (B)) + 2) >> 2))
+ var X int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(-1-32))))
+ var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(0-32))))
+ var B int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(1-32))))
+ var C int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(2-32))))
+ var D int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(3-32))))
+ *(*uint8_t)(unsafe.Pointer(dst + 96)) = uint8_t((J + 2*K + L + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 97)) = libc.AssignPtrUint8(dst+64, uint8_t((I+2*J+K+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 98)) = libc.AssignPtrUint8(dst+65, libc.AssignPtrUint8(dst+32, uint8_t((X+2*I+J+2)>>2)))
+ *(*uint8_t)(unsafe.Pointer(dst + 99)) = libc.AssignPtrUint8(dst+66, libc.AssignPtrUint8(dst+33, libc.AssignPtrUint8(dst, uint8_t((A+2*X+I+2)>>2))))
+ *(*uint8_t)(unsafe.Pointer(dst + 67)) = libc.AssignPtrUint8(dst+34, libc.AssignPtrUint8(dst+1, uint8_t((B+2*A+X+2)>>2)))
+ *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8(dst+2, uint8_t((C+2*B+A+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = uint8_t((D + 2*C + B + 2) >> 2)
}
func LD4_C(tls *libc.TLS, dst uintptr) { /* dec.c:311:13: */ // Down-Left
- var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((0 - 32)))))
- var B int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((1 - 32)))))
- var C int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((2 - 32)))))
- var D int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((3 - 32)))))
- var E int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((4 - 32)))))
- var F int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((5 - 32)))))
- var G int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((6 - 32)))))
- var H int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((7 - 32)))))
- *(*uint8_t)(unsafe.Pointer(dst)) = (uint8_t(((((A) + (2 * (B))) + (C)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8((dst + 32), (uint8_t(((((B) + (2 * (C))) + (D)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8((dst + 33), libc.AssignPtrUint8((dst+64), (uint8_t(((((C)+(2*(D)))+(E))+2)>>2))))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8((dst + 34), libc.AssignPtrUint8((dst+65), libc.AssignPtrUint8((dst+96), (uint8_t(((((D)+(2*(E)))+(F))+2)>>2)))))
- *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8((dst + 66), libc.AssignPtrUint8((dst+97), (uint8_t(((((E)+(2*(F)))+(G))+2)>>2))))
- *(*uint8_t)(unsafe.Pointer(dst + 67)) = libc.AssignPtrUint8((dst + 98), (uint8_t(((((F) + (2 * (G))) + (H)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 99)) = (uint8_t(((((G) + (2 * (H))) + (H)) + 2) >> 2))
+ var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(0-32))))
+ var B int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(1-32))))
+ var C int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(2-32))))
+ var D int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(3-32))))
+ var E int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(4-32))))
+ var F int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(5-32))))
+ var G int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(6-32))))
+ var H int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(7-32))))
+ *(*uint8_t)(unsafe.Pointer(dst)) = uint8_t((A + 2*B + C + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8(dst+32, uint8_t((B+2*C+D+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8(dst+33, libc.AssignPtrUint8(dst+64, uint8_t((C+2*D+E+2)>>2)))
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8(dst+34, libc.AssignPtrUint8(dst+65, libc.AssignPtrUint8(dst+96, uint8_t((D+2*E+F+2)>>2))))
+ *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8(dst+66, libc.AssignPtrUint8(dst+97, uint8_t((E+2*F+G+2)>>2)))
+ *(*uint8_t)(unsafe.Pointer(dst + 67)) = libc.AssignPtrUint8(dst+98, uint8_t((F+2*G+H+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 99)) = uint8_t((G + 2*H + H + 2) >> 2)
}
func VR4_C(tls *libc.TLS, dst uintptr) { /* dec.c:330:13: */ // Vertical-Right
- var I int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((-1 + (0 * 32))))))
+ var I int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(-1+0*32))))
var J int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 31)))
var K int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 63)))
- var X int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((-1 - 32)))))
- var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((0 - 32)))))
- var B int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((1 - 32)))))
- var C int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((2 - 32)))))
- var D int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((3 - 32)))))
- *(*uint8_t)(unsafe.Pointer(dst)) = libc.AssignPtrUint8((dst + 65), (uint8_t((((X) + (A)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8((dst + 66), (uint8_t((((A) + (B)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8((dst + 67), (uint8_t((((B) + (C)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = (uint8_t((((C) + (D)) + 1) >> 1))
-
- *(*uint8_t)(unsafe.Pointer(dst + 96)) = (uint8_t(((((K) + (2 * (J))) + (I)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 64)) = (uint8_t(((((J) + (2 * (I))) + (X)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 32)) = libc.AssignPtrUint8((dst + 97), (uint8_t(((((I) + (2 * (X))) + (A)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8((dst + 98), (uint8_t(((((X) + (2 * (A))) + (B)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8((dst + 99), (uint8_t(((((A) + (2 * (B))) + (C)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 35)) = (uint8_t(((((B) + (2 * (C))) + (D)) + 2) >> 2))
+ var X int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(-1-32))))
+ var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(0-32))))
+ var B int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(1-32))))
+ var C int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(2-32))))
+ var D int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(3-32))))
+ *(*uint8_t)(unsafe.Pointer(dst)) = libc.AssignPtrUint8(dst+65, uint8_t((X+A+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8(dst+66, uint8_t((A+B+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8(dst+67, uint8_t((B+C+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = uint8_t((C + D + 1) >> 1)
+
+ *(*uint8_t)(unsafe.Pointer(dst + 96)) = uint8_t((K + 2*J + I + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 64)) = uint8_t((J + 2*I + X + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 32)) = libc.AssignPtrUint8(dst+97, uint8_t((I+2*X+A+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8(dst+98, uint8_t((X+2*A+B+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8(dst+99, uint8_t((A+2*B+C+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 35)) = uint8_t((B + 2*C + D + 2) >> 2)
}
func VL4_C(tls *libc.TLS, dst uintptr) { /* dec.c:352:13: */ // Vertical-Left
- var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((0 - 32)))))
- var B int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((1 - 32)))))
- var C int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((2 - 32)))))
- var D int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((3 - 32)))))
- var E int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((4 - 32)))))
- var F int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((5 - 32)))))
- var G int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((6 - 32)))))
- var H int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((7 - 32)))))
- *(*uint8_t)(unsafe.Pointer(dst)) = (uint8_t((((A) + (B)) + 1) >> 1))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8((dst + 64), (uint8_t((((B) + (C)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8((dst + 65), (uint8_t((((C) + (D)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8((dst + 66), (uint8_t((((D) + (E)) + 1) >> 1)))
-
- *(*uint8_t)(unsafe.Pointer(dst + 32)) = (uint8_t(((((A) + (2 * (B))) + (C)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8((dst + 96), (uint8_t(((((B) + (2 * (C))) + (D)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8((dst + 97), (uint8_t(((((C) + (2 * (D))) + (E)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8((dst + 98), (uint8_t(((((D) + (2 * (E))) + (F)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 67)) = (uint8_t(((((E) + (2 * (F))) + (G)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 99)) = (uint8_t(((((F) + (2 * (G))) + (H)) + 2) >> 2))
+ var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(0-32))))
+ var B int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(1-32))))
+ var C int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(2-32))))
+ var D int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(3-32))))
+ var E int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(4-32))))
+ var F int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(5-32))))
+ var G int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(6-32))))
+ var H int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(7-32))))
+ *(*uint8_t)(unsafe.Pointer(dst)) = uint8_t((A + B + 1) >> 1)
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8(dst+64, uint8_t((B+C+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8(dst+65, uint8_t((C+D+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8(dst+66, uint8_t((D+E+1)>>1))
+
+ *(*uint8_t)(unsafe.Pointer(dst + 32)) = uint8_t((A + 2*B + C + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8(dst+96, uint8_t((B+2*C+D+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8(dst+97, uint8_t((C+2*D+E+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8(dst+98, uint8_t((D+2*E+F+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 67)) = uint8_t((E + 2*F + G + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 99)) = uint8_t((F + 2*G + H + 2) >> 2)
}
func HU4_C(tls *libc.TLS, dst uintptr) { /* dec.c:374:13: */ // Horizontal-Up
- var I int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((-1 + (0 * 32))))))
+ var I int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(-1+0*32))))
var J int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 31)))
var K int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 63)))
var L int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 95)))
- *(*uint8_t)(unsafe.Pointer(dst)) = (uint8_t((((I) + (J)) + 1) >> 1))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8((dst + 32), (uint8_t((((J) + (K)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8((dst + 64), (uint8_t((((K) + (L)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = (uint8_t(((((I) + (2 * (J))) + (K)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8((dst + 33), (uint8_t(((((J) + (2 * (K))) + (L)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8((dst + 65), (uint8_t(((((K) + (2 * (L))) + (L)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 67)) = libc.AssignPtrUint8((dst + 66), libc.AssignPtrUint8((dst+96), libc.AssignPtrUint8((dst+97), libc.AssignPtrUint8((dst+98), libc.AssignPtrUint8((dst+99), uint8_t(L))))))
+ *(*uint8_t)(unsafe.Pointer(dst)) = uint8_t((I + J + 1) >> 1)
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8(dst+32, uint8_t((J+K+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8(dst+64, uint8_t((K+L+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = uint8_t((I + 2*J + K + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8(dst+33, uint8_t((J+2*K+L+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8(dst+65, uint8_t((K+2*L+L+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 67)) = libc.AssignPtrUint8(dst+66, libc.AssignPtrUint8(dst+96, libc.AssignPtrUint8(dst+97, libc.AssignPtrUint8(dst+98, libc.AssignPtrUint8(dst+99, uint8_t(L))))))
}
func HD4_C(tls *libc.TLS, dst uintptr) { /* dec.c:389:13: */ // Horizontal-Down
- var I int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((-1 + (0 * 32))))))
+ var I int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(-1+0*32))))
var J int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 31)))
var K int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 63)))
var L int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + 95)))
- var X int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((-1 - 32)))))
- var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((0 - 32)))))
- var B int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((1 - 32)))))
- var C int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32((2 - 32)))))
+ var X int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(-1-32))))
+ var A int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(0-32))))
+ var B int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(1-32))))
+ var C int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + libc.UintptrFromInt32(2-32))))
- *(*uint8_t)(unsafe.Pointer(dst)) = libc.AssignPtrUint8((dst + 34), (uint8_t((((I) + (X)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 32)) = libc.AssignPtrUint8((dst + 66), (uint8_t((((J) + (I)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 64)) = libc.AssignPtrUint8((dst + 98), (uint8_t((((K) + (J)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 96)) = (uint8_t((((L) + (K)) + 1) >> 1))
+ *(*uint8_t)(unsafe.Pointer(dst)) = libc.AssignPtrUint8(dst+34, uint8_t((I+X+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 32)) = libc.AssignPtrUint8(dst+66, uint8_t((J+I+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 64)) = libc.AssignPtrUint8(dst+98, uint8_t((K+J+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 96)) = uint8_t((L + K + 1) >> 1)
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = (uint8_t(((((A) + (2 * (B))) + (C)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = (uint8_t(((((X) + (2 * (A))) + (B)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8((dst + 35), (uint8_t(((((I) + (2 * (X))) + (A)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8((dst + 67), (uint8_t(((((J) + (2 * (I))) + (X)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 65)) = libc.AssignPtrUint8((dst + 99), (uint8_t(((((K) + (2 * (J))) + (I)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 97)) = (uint8_t(((((L) + (2 * (K))) + (J)) + 2) >> 2))
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = uint8_t((A + 2*B + C + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = uint8_t((X + 2*A + B + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8(dst+35, uint8_t((I+2*X+A+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8(dst+67, uint8_t((J+2*I+X+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 65)) = libc.AssignPtrUint8(dst+99, uint8_t((K+2*J+I+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 97)) = uint8_t((L + 2*K + J + 2) >> 2)
}
var VP8PredLuma4 [10]VP8PredFunc /* dec.c:416:13: */
@@ -15874,7 +15614,7 @@ var VP8PredLuma4 [10]VP8PredFunc /* dec.c:416:13: */
func VE8uv_C(tls *libc.TLS, dst uintptr) { /* dec.c:422:13: */ // vertical
var j int32
for j = 0; j < 8; j++ {
- libc.Xmemcpy(tls, (dst + uintptr((j * 32))), (dst - uintptr(32)), uint64(8))
+ libc.Xmemcpy(tls, dst+uintptr(j*32), dst-uintptr(32), uint64(8))
}
}
@@ -15890,7 +15630,7 @@ func HE8uv_C(tls *libc.TLS, dst uintptr) { /* dec.c:429:13: */ // horizontal
func Put8x8uv(tls *libc.TLS, value uint8_t, dst uintptr) { /* dec.c:438:25: */
var j int32
for j = 0; j < 8; j++ {
- libc.Xmemset(tls, (dst + uintptr((j * 32))), int32(value), uint64(8))
+ libc.Xmemset(tls, dst+uintptr(j*32), int32(value), uint64(8))
}
}
@@ -15898,27 +15638,27 @@ func DC8uv_C(tls *libc.TLS, dst uintptr) { /* dec.c:445:13: */ // DC
var dc0 int32 = 8
var i int32
for i = 0; i < 8; i++ {
- dc0 = dc0 + (int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr((i - 32))))) + int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr((-1 + (i * 32)))))))
+ dc0 = dc0 + (int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(i-32)))) + int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(-1+i*32)))))
}
- Put8x8uv(tls, (uint8(dc0 >> 4)), dst)
+ Put8x8uv(tls, uint8(dc0>>4), dst)
}
func DC8uvNoLeft_C(tls *libc.TLS, dst uintptr) { /* dec.c:454:13: */ // DC with no left samples
var dc0 int32 = 4
var i int32
for i = 0; i < 8; i++ {
- dc0 = dc0 + (int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr((i - 32))))))
+ dc0 = dc0 + int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(i-32))))
}
- Put8x8uv(tls, (uint8(dc0 >> 3)), dst)
+ Put8x8uv(tls, uint8(dc0>>3), dst)
}
func DC8uvNoTop_C(tls *libc.TLS, dst uintptr) { /* dec.c:463:13: */ // DC with no top samples
var dc0 int32 = 4
var i int32
for i = 0; i < 8; i++ {
- dc0 = dc0 + (int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr((-1 + (i * 32)))))))
+ dc0 = dc0 + int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(-1+i*32))))
}
- Put8x8uv(tls, (uint8(dc0 >> 3)), dst)
+ Put8x8uv(tls, uint8(dc0>>3), dst)
}
func DC8uvNoTopLeft_C(tls *libc.TLS, dst uintptr) { /* dec.c:472:13: */ // DC with nothing
@@ -15932,83 +15672,83 @@ var VP8PredChroma8 [7]VP8PredFunc /* dec.c:477:13: */
// 4 pixels in, 2 pixels out
func DoFilter2_C(tls *libc.TLS, p uintptr, step int32) { /* dec.c:484:25: */
- var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((-2 * step)))))
+ var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-2*step))))
var p0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-step))))
var q0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p)))
var q1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(step))))
- var a int32 = ((3 * (q0 - p0)) + int32(*(*int8_t)(unsafe.Pointer(VP8ksclip1 + uintptr((p1 - q1)))))) // in [-893,892]
- var a1 int32 = int32(*(*int8_t)(unsafe.Pointer(VP8ksclip2 + uintptr(((a + 4) >> 3))))) // in [-16,15]
- var a2 int32 = int32(*(*int8_t)(unsafe.Pointer(VP8ksclip2 + uintptr(((a + 3) >> 3)))))
- *(*uint8_t)(unsafe.Pointer(p + uintptr(-step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((p0 + a2))))
- *(*uint8_t)(unsafe.Pointer(p)) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((q0 - a1))))
+ var a int32 = 3*(q0-p0) + int32(*(*int8_t)(unsafe.Pointer(VP8ksclip1 + uintptr(p1-q1)))) // in [-893,892]
+ var a1 int32 = int32(*(*int8_t)(unsafe.Pointer(VP8ksclip2 + uintptr((a+4)>>3)))) // in [-16,15]
+ var a2 int32 = int32(*(*int8_t)(unsafe.Pointer(VP8ksclip2 + uintptr((a+3)>>3))))
+ *(*uint8_t)(unsafe.Pointer(p + uintptr(-step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(p0+a2)))
+ *(*uint8_t)(unsafe.Pointer(p)) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(q0-a1)))
}
// 4 pixels in, 4 pixels out
func DoFilter4_C(tls *libc.TLS, p uintptr, step int32) { /* dec.c:494:25: */
- var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((-2 * step)))))
+ var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-2*step))))
var p0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-step))))
var q0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p)))
var q1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(step))))
- var a int32 = (3 * (q0 - p0))
- var a1 int32 = int32(*(*int8_t)(unsafe.Pointer(VP8ksclip2 + uintptr(((a + 4) >> 3)))))
- var a2 int32 = int32(*(*int8_t)(unsafe.Pointer(VP8ksclip2 + uintptr(((a + 3) >> 3)))))
- var a3 int32 = ((a1 + 1) >> 1)
- *(*uint8_t)(unsafe.Pointer(p + uintptr((-2 * step)))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((p1 + a3))))
- *(*uint8_t)(unsafe.Pointer(p + uintptr(-step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((p0 + a2))))
- *(*uint8_t)(unsafe.Pointer(p)) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((q0 - a1))))
- *(*uint8_t)(unsafe.Pointer(p + uintptr(step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((q1 - a3))))
+ var a int32 = 3 * (q0 - p0)
+ var a1 int32 = int32(*(*int8_t)(unsafe.Pointer(VP8ksclip2 + uintptr((a+4)>>3))))
+ var a2 int32 = int32(*(*int8_t)(unsafe.Pointer(VP8ksclip2 + uintptr((a+3)>>3))))
+ var a3 int32 = (a1 + 1) >> 1
+ *(*uint8_t)(unsafe.Pointer(p + uintptr(-2*step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(p1+a3)))
+ *(*uint8_t)(unsafe.Pointer(p + uintptr(-step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(p0+a2)))
+ *(*uint8_t)(unsafe.Pointer(p)) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(q0-a1)))
+ *(*uint8_t)(unsafe.Pointer(p + uintptr(step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(q1-a3)))
}
// 6 pixels in, 6 pixels out
func DoFilter6_C(tls *libc.TLS, p uintptr, step int32) { /* dec.c:507:25: */
- var p2 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((-3 * step)))))
- var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((-2 * step)))))
+ var p2 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-3*step))))
+ var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-2*step))))
var p0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-step))))
var q0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p)))
var q1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(step))))
- var q2 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((2 * step)))))
- var a int32 = int32(*(*int8_t)(unsafe.Pointer(VP8ksclip1 + uintptr(((3 * (q0 - p0)) + int32(*(*int8_t)(unsafe.Pointer(VP8ksclip1 + uintptr((p1 - q1))))))))))
+ var q2 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(2*step))))
+ var a int32 = int32(*(*int8_t)(unsafe.Pointer(VP8ksclip1 + uintptr(3*(q0-p0)+int32(*(*int8_t)(unsafe.Pointer(VP8ksclip1 + uintptr(p1-q1))))))))
// a is in [-128,127], a1 in [-27,27], a2 in [-18,18] and a3 in [-9,9]
- var a1 int32 = (((27 * a) + 63) >> 7) // eq. to ((3 * a + 7) * 9) >> 7
- var a2 int32 = (((18 * a) + 63) >> 7) // eq. to ((2 * a + 7) * 9) >> 7
- var a3 int32 = (((9 * a) + 63) >> 7) // eq. to ((1 * a + 7) * 9) >> 7
- *(*uint8_t)(unsafe.Pointer(p + uintptr((-3 * step)))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((p2 + a3))))
- *(*uint8_t)(unsafe.Pointer(p + uintptr((-2 * step)))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((p1 + a2))))
- *(*uint8_t)(unsafe.Pointer(p + uintptr(-step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((p0 + a1))))
- *(*uint8_t)(unsafe.Pointer(p)) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((q0 - a1))))
- *(*uint8_t)(unsafe.Pointer(p + uintptr(step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((q1 - a2))))
- *(*uint8_t)(unsafe.Pointer(p + uintptr((2 * step)))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr((q2 - a3))))
+ var a1 int32 = (27*a + 63) >> 7 // eq. to ((3 * a + 7) * 9) >> 7
+ var a2 int32 = (18*a + 63) >> 7 // eq. to ((2 * a + 7) * 9) >> 7
+ var a3 int32 = (9*a + 63) >> 7 // eq. to ((1 * a + 7) * 9) >> 7
+ *(*uint8_t)(unsafe.Pointer(p + uintptr(-3*step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(p2+a3)))
+ *(*uint8_t)(unsafe.Pointer(p + uintptr(-2*step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(p1+a2)))
+ *(*uint8_t)(unsafe.Pointer(p + uintptr(-step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(p0+a1)))
+ *(*uint8_t)(unsafe.Pointer(p)) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(q0-a1)))
+ *(*uint8_t)(unsafe.Pointer(p + uintptr(step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(q1-a2)))
+ *(*uint8_t)(unsafe.Pointer(p + uintptr(2*step))) = *(*uint8_t)(unsafe.Pointer(VP8kclip1 + uintptr(q2-a3)))
}
func Hev(tls *libc.TLS, p uintptr, step int32, thresh int32) int32 { /* dec.c:523:24: */
- var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((-2 * step)))))
+ var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-2*step))))
var p0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-step))))
var q0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p)))
var q1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(step))))
- return (libc.Bool32((int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((p1 - p0))))) > thresh) || (int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((q1 - q0))))) > thresh)))
+ return libc.Bool32(int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(p1-p0)))) > thresh || int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(q1-q0)))) > thresh)
}
func NeedsFilter_C(tls *libc.TLS, p uintptr, step int32, t int32) int32 { /* dec.c:530:24: */
- var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((-2 * step)))))
+ var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-2*step))))
var p0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-step))))
var q0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p)))
var q1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(step))))
- return (libc.Bool32(((4 * int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((p0 - q0)))))) + int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((p1 - q1)))))) <= t))
+ return libc.Bool32(4*int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(p0-q0))))+int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(p1-q1)))) <= t)
}
func NeedsFilter2_C(tls *libc.TLS, p uintptr, step int32, t int32, it int32) int32 { /* dec.c:537:24: */
- var p3 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((-4 * step)))))
- var p2 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((-3 * step)))))
- var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((-2 * step)))))
+ var p3 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-4*step))))
+ var p2 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-3*step))))
+ var p1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-2*step))))
var p0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(-step))))
var q0 int32 = int32(*(*uint8_t)(unsafe.Pointer(p)))
var q1 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(step))))
- var q2 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((2 * step)))))
- var q3 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((3 * step)))))
- if ((4 * int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((p0 - q0)))))) + int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((p1 - q1)))))) > t {
+ var q2 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(2*step))))
+ var q3 int32 = int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(3*step))))
+ if 4*int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(p0-q0))))+int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(p1-q1)))) > t {
return 0
}
- return (libc.Bool32((((((int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((p3 - p2))))) <= it) && (int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((p2 - p1))))) <= it)) && (int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((p1 - p0))))) <= it)) && (int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((q3 - q2))))) <= it)) && (int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((q2 - q1))))) <= it)) && (int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr((q1 - q0))))) <= it)))
+ return libc.Bool32(int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(p3-p2)))) <= it && int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(p2-p1)))) <= it && int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(p1-p0)))) <= it && int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(q3-q2)))) <= it && int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(q2-q1)))) <= it && int32(*(*uint8_t)(unsafe.Pointer(VP8kabs0 + uintptr(q1-q0)))) <= it)
}
//------------------------------------------------------------------------------
@@ -16016,20 +15756,20 @@ func NeedsFilter2_C(tls *libc.TLS, p uintptr, step int32, t int32, it int32) int
func SimpleVFilter16_C(tls *libc.TLS, p uintptr, stride int32, thresh int32) { /* dec.c:553:13: */
var i int32
- var thresh2 int32 = ((2 * thresh) + 1)
+ var thresh2 int32 = 2*thresh + 1
for i = 0; i < 16; i++ {
- if NeedsFilter_C(tls, (p+uintptr(i)), stride, thresh2) != 0 {
- DoFilter2_C(tls, (p + uintptr(i)), stride)
+ if NeedsFilter_C(tls, p+uintptr(i), stride, thresh2) != 0 {
+ DoFilter2_C(tls, p+uintptr(i), stride)
}
}
}
func SimpleHFilter16_C(tls *libc.TLS, p uintptr, stride int32, thresh int32) { /* dec.c:563:13: */
var i int32
- var thresh2 int32 = ((2 * thresh) + 1)
+ var thresh2 int32 = 2*thresh + 1
for i = 0; i < 16; i++ {
- if NeedsFilter_C(tls, (p+uintptr((i*stride))), 1, thresh2) != 0 {
- DoFilter2_C(tls, (p + uintptr((i * stride))), 1)
+ if NeedsFilter_C(tls, p+uintptr(i*stride), 1, thresh2) != 0 {
+ DoFilter2_C(tls, p+uintptr(i*stride), 1)
}
}
}
@@ -16037,7 +15777,7 @@ func SimpleHFilter16_C(tls *libc.TLS, p uintptr, stride int32, thresh int32) { /
func SimpleVFilter16i_C(tls *libc.TLS, p uintptr, stride int32, thresh int32) { /* dec.c:573:13: */
var k int32
for k = 3; k > 0; k-- {
- p += (uintptr(4 * stride))
+ p += uintptr(4 * stride)
SimpleVFilter16_C(tls, p, stride, thresh)
}
}
@@ -16054,7 +15794,7 @@ func SimpleHFilter16i_C(tls *libc.TLS, p uintptr, stride int32, thresh int32) {
// Complex In-loop filtering (Paragraph 15.3)
func FilterLoop26_C(tls *libc.TLS, p uintptr, hstride int32, vstride int32, size int32, thresh int32, ithresh int32, hev_thresh int32) { /* dec.c:594:25: */
- var thresh2 int32 = ((2 * thresh) + 1)
+ var thresh2 int32 = 2*thresh + 1
for libc.PostDecInt32(&size, 1) > 0 {
if NeedsFilter2_C(tls, p, hstride, thresh2, ithresh) != 0 {
if Hev(tls, p, hstride, hev_thresh) != 0 {
@@ -16068,7 +15808,7 @@ func FilterLoop26_C(tls *libc.TLS, p uintptr, hstride int32, vstride int32, size
}
func FilterLoop24_C(tls *libc.TLS, p uintptr, hstride int32, vstride int32, size int32, thresh int32, ithresh int32, hev_thresh int32) { /* dec.c:611:25: */
- var thresh2 int32 = ((2 * thresh) + 1)
+ var thresh2 int32 = 2*thresh + 1
for libc.PostDecInt32(&size, 1) > 0 {
if NeedsFilter2_C(tls, p, hstride, thresh2, ithresh) != 0 {
if Hev(tls, p, hstride, hev_thresh) != 0 {
@@ -16094,7 +15834,7 @@ func HFilter16_C(tls *libc.TLS, p uintptr, stride int32, thresh int32, ithresh i
func VFilter16i_C(tls *libc.TLS, p uintptr, stride int32, thresh int32, ithresh int32, hev_thresh int32) { /* dec.c:642:13: */
var k int32
for k = 3; k > 0; k-- {
- p += (uintptr(4 * stride))
+ p += uintptr(4 * stride)
FilterLoop24_C(tls, p, stride, 1, 16, thresh, ithresh, hev_thresh)
}
}
@@ -16119,13 +15859,13 @@ func HFilter8_C(tls *libc.TLS, u uintptr, v uintptr, stride int32, thresh int32,
}
func VFilter8i_C(tls *libc.TLS, u uintptr, v uintptr, stride int32, thresh int32, ithresh int32, hev_thresh int32) { /* dec.c:681:13: */
- FilterLoop24_C(tls, (u + uintptr((4 * stride))), stride, 1, 8, thresh, ithresh, hev_thresh)
- FilterLoop24_C(tls, (v + uintptr((4 * stride))), stride, 1, 8, thresh, ithresh, hev_thresh)
+ FilterLoop24_C(tls, u+uintptr(4*stride), stride, 1, 8, thresh, ithresh, hev_thresh)
+ FilterLoop24_C(tls, v+uintptr(4*stride), stride, 1, 8, thresh, ithresh, hev_thresh)
}
func HFilter8i_C(tls *libc.TLS, u uintptr, v uintptr, stride int32, thresh int32, ithresh int32, hev_thresh int32) { /* dec.c:689:13: */
- FilterLoop24_C(tls, (u + uintptr(4)), 1, stride, 8, thresh, ithresh, hev_thresh)
- FilterLoop24_C(tls, (v + uintptr(4)), 1, stride, 8, thresh, ithresh, hev_thresh)
+ FilterLoop24_C(tls, u+uintptr(4), 1, stride, 8, thresh, ithresh, hev_thresh)
+ FilterLoop24_C(tls, v+uintptr(4), 1, stride, 8, thresh, ithresh, hev_thresh)
}
//------------------------------------------------------------------------------
@@ -16135,9 +15875,9 @@ func DitherCombine8x8_C(tls *libc.TLS, dither uintptr, dst uintptr, dst_stride i
var j int32
for j = 0; j < 8; j++ {
for i = 0; i < 8; i++ {
- var delta0 int32 = (int32(*(*uint8_t)(unsafe.Pointer(dither + uintptr(i)))) - (int32(1) << 7))
- var delta1 int32 = ((delta0 + (int32(1) << (4 - 1))) >> 4)
- *(*uint8_t)(unsafe.Pointer(dst + uintptr(i))) = clip_8b(tls, (int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(i)))) + delta1))
+ var delta0 int32 = int32(*(*uint8_t)(unsafe.Pointer(dither + uintptr(i)))) - int32(1)<<7
+ var delta1 int32 = (delta0 + int32(1)<<(4-1)) >> 4
+ *(*uint8_t)(unsafe.Pointer(dst + uintptr(i))) = clip_8b(tls, int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(i))))+delta1)
}
dst += uintptr(dst_stride)
dither += uintptr(8)
@@ -16168,7 +15908,7 @@ var VP8SimpleHFilter16i VP8SimpleFilterFunc /* dec.c:732:21: */
var VP8DitherCombine8x8 uintptr /* dec.c:734:6: */
func VP8DspInit(tls *libc.TLS) { /* dec.c:744:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if VP8DspInit_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -16272,7 +16012,7 @@ func VP8DspInit_body(tls *libc.TLS) { /* dec.c:744:1: */
}{DitherCombine8x8_C}))
// If defined, use CPUInfo() to overwrite some pointers with faster versions.
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -16598,7 +16338,7 @@ func VP8InitClipTables(tls *libc.TLS) { /* dec_clip_tables.c:350:32: */
//------------------------------------------------------------------------------
func clip_8b1(tls *libc.TLS, v int32) uint8_t { /* enc.c:20:28: */
- if !((v & libc.CplInt32(0xff)) != 0) {
+ if !(v&libc.CplInt32(0xff) != 0) {
return uint8(v)
}
if v < 0 {
@@ -16619,14 +16359,14 @@ func clip_max(tls *libc.TLS, v int32, max int32) int32 { /* enc.c:25:24: */
// the higher, the "easier" the macroblock is to compress.
var VP8DspScan = [24]int32{
- // Luma
- (0 + (0 * 32)), (4 + (0 * 32)), (8 + (0 * 32)), (12 + (0 * 32)),
- (0 + (4 * 32)), (4 + (4 * 32)), (8 + (4 * 32)), (12 + (4 * 32)),
- (0 + (8 * 32)), (4 + (8 * 32)), (8 + (8 * 32)), (12 + (8 * 32)),
- (0 + (12 * 32)), (4 + (12 * 32)), (8 + (12 * 32)), (12 + (12 * 32)),
-
- (0 + (0 * 32)), (4 + (0 * 32)), (0 + (4 * 32)), (4 + (4 * 32)), // U
- (8 + (0 * 32)), (12 + (0 * 32)), (8 + (4 * 32)), (12 + (4 * 32)), // V
+
+ 0 + 0*32, 4 + 0*32, 8 + 0*32, 12 + 0*32,
+ 0 + 4*32, 4 + 4*32, 8 + 4*32, 12 + 4*32,
+ 0 + 8*32, 4 + 8*32, 8 + 8*32, 12 + 8*32,
+ 0 + 12*32, 4 + 12*32, 8 + 12*32, 12 + 12*32,
+
+ 0 + 0*32, 4 + 0*32, 0 + 4*32, 4 + 4*32,
+ 8 + 0*32, 12 + 0*32, 8 + 4*32, 12 + 4*32,
} /* enc.c:34:11 */
// general-purpose util function
@@ -16659,16 +16399,16 @@ func CollectHistogram_C(tls *libc.TLS, ref uintptr, pred uintptr, start_block in
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8FTransform})).f(tls, (ref + uintptr(VP8DspScan[j])), (pred + uintptr(VP8DspScan[j])), (bp) /* &out[0] */)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8FTransform})).f(tls, ref+uintptr(VP8DspScan[j]), pred+uintptr(VP8DspScan[j]), bp /* &out[0] */)
// Convert coefficients to bin.
for k = 0; k < 16; k++ {
- var v int32 = (libc.Xabs(tls, int32(*(*int16_t)(unsafe.Pointer((bp) /* &out[0] */ + uintptr(k)*2)))) >> 3)
+ var v int32 = libc.Xabs(tls, int32(*(*int16_t)(unsafe.Pointer(bp + uintptr(k)*2)))) >> 3
var clipped_value int32 = clip_max(tls, v, 31)
- *(*int32)(unsafe.Pointer((bp + 32) /* &distribution[0] */ + uintptr(clipped_value)*4))++
+ *(*int32)(unsafe.Pointer(bp + 32 + uintptr(clipped_value)*4))++
}
}
- VP8SetHistogramData(tls, (bp + 32) /* &distribution[0] */, histo)
+ VP8SetHistogramData(tls, bp+32, histo)
}
//------------------------------------------------------------------------------
@@ -16683,8 +16423,8 @@ var tables_ok int32 = 0 /* enc.c:91:21 */
func InitTables(tls *libc.TLS) { /* enc.c:93:39: */
if !(libc.AtomicLoadInt32(&tables_ok) != 0) {
var i int32
- for i = -255; i <= (255 + 255); i++ {
- clip11[(255 + i)] = clip_8b1(tls, i)
+ for i = -255; i <= 255+255; i++ {
+ clip11[255+i] = clip_8b1(tls, i)
}
libc.AtomicStoreInt32(&tables_ok, int32(1))
}
@@ -16693,8 +16433,8 @@ func InitTables(tls *libc.TLS) { /* enc.c:93:39: */
//------------------------------------------------------------------------------
// Transforms (Paragraph 14.4)
-var kC1 int32 = (20091 + (int32(1) << 16)) /* enc.c:112:18 */
-var kC2 int32 = 35468 /* enc.c:113:18 */
+var kC1 int32 = 20091 + int32(1)<<16 /* enc.c:112:18 */
+var kC2 int32 = 35468 /* enc.c:113:18 */
func ITransformOne(tls *libc.TLS, ref uintptr, in uintptr, dst uintptr) { /* enc.c:116:25: */
bp := tls.Alloc(64)
@@ -16704,31 +16444,31 @@ func ITransformOne(tls *libc.TLS, ref uintptr, in uintptr, dst uintptr) { /* enc
var tmp uintptr
var i int32
- tmp = (bp) /* &C[0] */
+ tmp = bp /* &C[0] */
for i = 0; i < 4; i++ { // vertical pass
- var a int32 = (int32(*(*int16_t)(unsafe.Pointer(in))) + int32(*(*int16_t)(unsafe.Pointer(in + 8*2))))
- var b int32 = (int32(*(*int16_t)(unsafe.Pointer(in))) - int32(*(*int16_t)(unsafe.Pointer(in + 8*2))))
- var c int32 = ((((int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))) * (kC2)) >> 16) - (((int32(*(*int16_t)(unsafe.Pointer(in + 12*2)))) * (kC1)) >> 16))
- var d int32 = ((((int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))) * (kC1)) >> 16) + (((int32(*(*int16_t)(unsafe.Pointer(in + 12*2)))) * (kC2)) >> 16))
- *(*int32)(unsafe.Pointer(tmp)) = (a + d)
- *(*int32)(unsafe.Pointer(tmp + 1*4)) = (b + c)
- *(*int32)(unsafe.Pointer(tmp + 2*4)) = (b - c)
- *(*int32)(unsafe.Pointer(tmp + 3*4)) = (a - d)
- tmp += 4 * (uintptr(4))
+ var a int32 = int32(*(*int16_t)(unsafe.Pointer(in))) + int32(*(*int16_t)(unsafe.Pointer(in + 8*2)))
+ var b int32 = int32(*(*int16_t)(unsafe.Pointer(in))) - int32(*(*int16_t)(unsafe.Pointer(in + 8*2)))
+ var c int32 = int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))*kC2>>16 - int32(*(*int16_t)(unsafe.Pointer(in + 12*2)))*kC1>>16
+ var d int32 = int32(*(*int16_t)(unsafe.Pointer(in + 4*2)))*kC1>>16 + int32(*(*int16_t)(unsafe.Pointer(in + 12*2)))*kC2>>16
+ *(*int32)(unsafe.Pointer(tmp)) = a + d
+ *(*int32)(unsafe.Pointer(tmp + 1*4)) = b + c
+ *(*int32)(unsafe.Pointer(tmp + 2*4)) = b - c
+ *(*int32)(unsafe.Pointer(tmp + 3*4)) = a - d
+ tmp += 4 * uintptr(4)
in += 2
}
- tmp = (bp) /* &C[0] */
+ tmp = bp /* &C[0] */
for i = 0; i < 4; i++ { // horizontal pass
- var dc int32 = (*(*int32)(unsafe.Pointer(tmp)) + 4)
- var a int32 = (dc + *(*int32)(unsafe.Pointer(tmp + 8*4)))
- var b int32 = (dc - *(*int32)(unsafe.Pointer(tmp + 8*4)))
- var c int32 = ((((*(*int32)(unsafe.Pointer(tmp + 4*4))) * (kC2)) >> 16) - (((*(*int32)(unsafe.Pointer(tmp + 12*4))) * (kC1)) >> 16))
- var d int32 = ((((*(*int32)(unsafe.Pointer(tmp + 4*4))) * (kC1)) >> 16) + (((*(*int32)(unsafe.Pointer(tmp + 12*4))) * (kC2)) >> 16))
- *(*uint8_t)(unsafe.Pointer(dst + uintptr(((0) + ((i) * 32))))) = clip_8b1(tls, (int32(*(*uint8_t)(unsafe.Pointer(ref + uintptr(((0) + ((i) * 32)))))) + ((a + d) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + uintptr(((1) + ((i) * 32))))) = clip_8b1(tls, (int32(*(*uint8_t)(unsafe.Pointer(ref + uintptr(((1) + ((i) * 32)))))) + ((b + c) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + uintptr(((2) + ((i) * 32))))) = clip_8b1(tls, (int32(*(*uint8_t)(unsafe.Pointer(ref + uintptr(((2) + ((i) * 32)))))) + ((b - c) >> 3)))
- *(*uint8_t)(unsafe.Pointer(dst + uintptr(((3) + ((i) * 32))))) = clip_8b1(tls, (int32(*(*uint8_t)(unsafe.Pointer(ref + uintptr(((3) + ((i) * 32)))))) + ((a - d) >> 3)))
+ var dc int32 = *(*int32)(unsafe.Pointer(tmp)) + 4
+ var a int32 = dc + *(*int32)(unsafe.Pointer(tmp + 8*4))
+ var b int32 = dc - *(*int32)(unsafe.Pointer(tmp + 8*4))
+ var c int32 = *(*int32)(unsafe.Pointer(tmp + 4*4))*kC2>>16 - *(*int32)(unsafe.Pointer(tmp + 12*4))*kC1>>16
+ var d int32 = *(*int32)(unsafe.Pointer(tmp + 4*4))*kC1>>16 + *(*int32)(unsafe.Pointer(tmp + 12*4))*kC2>>16
+ *(*uint8_t)(unsafe.Pointer(dst + uintptr(0+i*32))) = clip_8b1(tls, int32(*(*uint8_t)(unsafe.Pointer(ref + uintptr(0+i*32))))+(a+d)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + uintptr(1+i*32))) = clip_8b1(tls, int32(*(*uint8_t)(unsafe.Pointer(ref + uintptr(1+i*32))))+(b+c)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + uintptr(2+i*32))) = clip_8b1(tls, int32(*(*uint8_t)(unsafe.Pointer(ref + uintptr(2+i*32))))+(b-c)>>3)
+ *(*uint8_t)(unsafe.Pointer(dst + uintptr(3+i*32))) = clip_8b1(tls, int32(*(*uint8_t)(unsafe.Pointer(ref + uintptr(3+i*32))))+(a-d)>>3)
tmp += 4
}
}
@@ -16736,7 +16476,7 @@ func ITransformOne(tls *libc.TLS, ref uintptr, in uintptr, dst uintptr) { /* enc
func ITransform_C(tls *libc.TLS, ref uintptr, in uintptr, dst uintptr, do_two int32) { /* enc.c:149:13: */
ITransformOne(tls, ref, in, dst)
if do_two != 0 {
- ITransformOne(tls, (ref + uintptr(4)), (in + uintptr(16)*2), (dst + uintptr(4)))
+ ITransformOne(tls, ref+uintptr(4), in+uintptr(16)*2, dst+uintptr(4))
}
}
@@ -16753,18 +16493,18 @@ __1:
goto __3
}
{
- var d0 int32 = (int32(*(*uint8_t)(unsafe.Pointer(src))) - int32(*(*uint8_t)(unsafe.Pointer(ref)))) // 9bit dynamic range ([-255,255])
- var d1 int32 = (int32(*(*uint8_t)(unsafe.Pointer(src + 1))) - int32(*(*uint8_t)(unsafe.Pointer(ref + 1))))
- var d2 int32 = (int32(*(*uint8_t)(unsafe.Pointer(src + 2))) - int32(*(*uint8_t)(unsafe.Pointer(ref + 2))))
- var d3 int32 = (int32(*(*uint8_t)(unsafe.Pointer(src + 3))) - int32(*(*uint8_t)(unsafe.Pointer(ref + 3))))
- var a0 int32 = (d0 + d3) // 10b [-510,510]
- var a1 int32 = (d1 + d2)
- var a2 int32 = (d1 - d2)
- var a3 int32 = (d0 - d3)
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((0+(i*4)))*4)) = ((a0 + a1) * 8) // 14b [-8160,8160]
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((1+(i*4)))*4)) = ((((a2 * 2217) + (a3 * 5352)) + 1812) >> 9) // [-7536,7542]
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((2+(i*4)))*4)) = ((a0 - a1) * 8)
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((3+(i*4)))*4)) = ((((a3 * 2217) - (a2 * 5352)) + 937) >> 9)
+ var d0 int32 = int32(*(*uint8_t)(unsafe.Pointer(src))) - int32(*(*uint8_t)(unsafe.Pointer(ref))) // 9bit dynamic range ([-255,255])
+ var d1 int32 = int32(*(*uint8_t)(unsafe.Pointer(src + 1))) - int32(*(*uint8_t)(unsafe.Pointer(ref + 1)))
+ var d2 int32 = int32(*(*uint8_t)(unsafe.Pointer(src + 2))) - int32(*(*uint8_t)(unsafe.Pointer(ref + 2)))
+ var d3 int32 = int32(*(*uint8_t)(unsafe.Pointer(src + 3))) - int32(*(*uint8_t)(unsafe.Pointer(ref + 3)))
+ var a0 int32 = d0 + d3 // 10b [-510,510]
+ var a1 int32 = d1 + d2
+ var a2 int32 = d1 - d2
+ var a3 int32 = d0 - d3
+ *(*int32)(unsafe.Pointer(bp + uintptr(0+i*4)*4)) = (a0 + a1) * 8 // 14b [-8160,8160]
+ *(*int32)(unsafe.Pointer(bp + uintptr(1+i*4)*4)) = (a2*2217 + a3*5352 + 1812) >> 9 // [-7536,7542]
+ *(*int32)(unsafe.Pointer(bp + uintptr(2+i*4)*4)) = (a0 - a1) * 8
+ *(*int32)(unsafe.Pointer(bp + uintptr(3+i*4)*4)) = (a3*2217 - a2*5352 + 937) >> 9
}
goto __2
@@ -16777,14 +16517,14 @@ __2:
__3:
;
for i = 0; i < 4; i++ {
- var a0 int32 = (*(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((0+i))*4)) + *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((12+i))*4))) // 15b
- var a1 int32 = (*(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((4+i))*4)) + *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((8+i))*4)))
- var a2 int32 = (*(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((4+i))*4)) - *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((8+i))*4)))
- var a3 int32 = (*(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((0+i))*4)) - *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((12+i))*4)))
- *(*int16_t)(unsafe.Pointer(out + uintptr((0+i))*2)) = (int16_t(((a0 + a1) + 7) >> 4)) // 12b
- *(*int16_t)(unsafe.Pointer(out + uintptr((4+i))*2)) = (int16_t(((((a2 * 2217) + (a3 * 5352)) + 12000) >> 16) + (libc.Bool32(a3 != 0))))
- *(*int16_t)(unsafe.Pointer(out + uintptr((8+i))*2)) = (int16_t(((a0 - a1) + 7) >> 4))
- *(*int16_t)(unsafe.Pointer(out + uintptr((12+i))*2)) = (int16_t((((a3 * 2217) - (a2 * 5352)) + 51000) >> 16))
+ var a0 int32 = *(*int32)(unsafe.Pointer(bp + uintptr(0+i)*4)) + *(*int32)(unsafe.Pointer(bp + uintptr(12+i)*4)) // 15b
+ var a1 int32 = *(*int32)(unsafe.Pointer(bp + uintptr(4+i)*4)) + *(*int32)(unsafe.Pointer(bp + uintptr(8+i)*4))
+ var a2 int32 = *(*int32)(unsafe.Pointer(bp + uintptr(4+i)*4)) - *(*int32)(unsafe.Pointer(bp + uintptr(8+i)*4))
+ var a3 int32 = *(*int32)(unsafe.Pointer(bp + uintptr(0+i)*4)) - *(*int32)(unsafe.Pointer(bp + uintptr(12+i)*4))
+ *(*int16_t)(unsafe.Pointer(out + uintptr(0+i)*2)) = int16_t((a0 + a1 + 7) >> 4) // 12b
+ *(*int16_t)(unsafe.Pointer(out + uintptr(4+i)*2)) = int16_t((a2*2217+a3*5352+12000)>>16 + libc.Bool32(a3 != 0))
+ *(*int16_t)(unsafe.Pointer(out + uintptr(8+i)*2)) = int16_t((a0 - a1 + 7) >> 4)
+ *(*int16_t)(unsafe.Pointer(out + uintptr(12+i)*2)) = int16_t((a3*2217 - a2*5352 + 51000) >> 16)
}
}
@@ -16794,7 +16534,7 @@ func FTransform2_C(tls *libc.TLS, src uintptr, ref uintptr, out uintptr) { /* en
})(unsafe.Pointer(&struct{ uintptr }{VP8FTransform})).f(tls, src, ref, out)
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8FTransform})).f(tls, (src + uintptr(4)), (ref + uintptr(4)), (out + uintptr(16)*2))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8FTransform})).f(tls, src+uintptr(4), ref+uintptr(4), out+uintptr(16)*2)
}
func FTransformWHT_C(tls *libc.TLS, in uintptr, out uintptr) { /* enc.c:194:13: */
@@ -16811,37 +16551,37 @@ __1:
goto __3
}
{
- var a0 int32 = (int32(*(*int16_t)(unsafe.Pointer(in))) + int32(*(*int16_t)(unsafe.Pointer(in + 32*2)))) // 13b
- var a1 int32 = (int32(*(*int16_t)(unsafe.Pointer(in + 16*2))) + int32(*(*int16_t)(unsafe.Pointer(in + 48*2))))
- var a2 int32 = (int32(*(*int16_t)(unsafe.Pointer(in + 16*2))) - int32(*(*int16_t)(unsafe.Pointer(in + 48*2))))
- var a3 int32 = (int32(*(*int16_t)(unsafe.Pointer(in))) - int32(*(*int16_t)(unsafe.Pointer(in + 32*2))))
- *(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((0+(i*4)))*4)) = (a0 + a1) // 14b
- *(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((1+(i*4)))*4)) = (a3 + a2)
- *(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((2+(i*4)))*4)) = (a3 - a2)
- *(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((3+(i*4)))*4)) = (a0 - a1)
+ var a0 int32 = int32(*(*int16_t)(unsafe.Pointer(in))) + int32(*(*int16_t)(unsafe.Pointer(in + 32*2))) // 13b
+ var a1 int32 = int32(*(*int16_t)(unsafe.Pointer(in + 16*2))) + int32(*(*int16_t)(unsafe.Pointer(in + 48*2)))
+ var a2 int32 = int32(*(*int16_t)(unsafe.Pointer(in + 16*2))) - int32(*(*int16_t)(unsafe.Pointer(in + 48*2)))
+ var a3 int32 = int32(*(*int16_t)(unsafe.Pointer(in))) - int32(*(*int16_t)(unsafe.Pointer(in + 32*2)))
+ *(*int32_t)(unsafe.Pointer(bp + uintptr(0+i*4)*4)) = a0 + a1 // 14b
+ *(*int32_t)(unsafe.Pointer(bp + uintptr(1+i*4)*4)) = a3 + a2
+ *(*int32_t)(unsafe.Pointer(bp + uintptr(2+i*4)*4)) = a3 - a2
+ *(*int32_t)(unsafe.Pointer(bp + uintptr(3+i*4)*4)) = a0 - a1
}
goto __2
__2:
i++
- in += 2 * (uintptr(64))
+ in += 2 * uintptr(64)
goto __1
goto __3
__3:
;
for i = 0; i < 4; i++ {
- var a0 int32 = (*(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((0+i))*4)) + *(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((8+i))*4))) // 15b
- var a1 int32 = (*(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((4+i))*4)) + *(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((12+i))*4)))
- var a2 int32 = (*(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((4+i))*4)) - *(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((12+i))*4)))
- var a3 int32 = (*(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((0+i))*4)) - *(*int32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((8+i))*4)))
- var b0 int32 = (a0 + a1) // 16b
- var b1 int32 = (a3 + a2)
- var b2 int32 = (a3 - a2)
- var b3 int32 = (a0 - a1)
- *(*int16_t)(unsafe.Pointer(out + uintptr((0+i))*2)) = (int16_t(b0 >> 1)) // 15b
- *(*int16_t)(unsafe.Pointer(out + uintptr((4+i))*2)) = (int16_t(b1 >> 1))
- *(*int16_t)(unsafe.Pointer(out + uintptr((8+i))*2)) = (int16_t(b2 >> 1))
- *(*int16_t)(unsafe.Pointer(out + uintptr((12+i))*2)) = (int16_t(b3 >> 1))
+ var a0 int32 = *(*int32_t)(unsafe.Pointer(bp + uintptr(0+i)*4)) + *(*int32_t)(unsafe.Pointer(bp + uintptr(8+i)*4)) // 15b
+ var a1 int32 = *(*int32_t)(unsafe.Pointer(bp + uintptr(4+i)*4)) + *(*int32_t)(unsafe.Pointer(bp + uintptr(12+i)*4))
+ var a2 int32 = *(*int32_t)(unsafe.Pointer(bp + uintptr(4+i)*4)) - *(*int32_t)(unsafe.Pointer(bp + uintptr(12+i)*4))
+ var a3 int32 = *(*int32_t)(unsafe.Pointer(bp + uintptr(0+i)*4)) - *(*int32_t)(unsafe.Pointer(bp + uintptr(8+i)*4))
+ var b0 int32 = a0 + a1 // 16b
+ var b1 int32 = a3 + a2
+ var b2 int32 = a3 - a2
+ var b3 int32 = a0 - a1
+ *(*int16_t)(unsafe.Pointer(out + uintptr(0+i)*2)) = int16_t(b0 >> 1) // 15b
+ *(*int16_t)(unsafe.Pointer(out + uintptr(4+i)*2)) = int16_t(b1 >> 1)
+ *(*int16_t)(unsafe.Pointer(out + uintptr(8+i)*2)) = int16_t(b2 >> 1)
+ *(*int16_t)(unsafe.Pointer(out + uintptr(12+i)*2)) = int16_t(b3 >> 1)
}
}
@@ -16851,15 +16591,15 @@ __3:
func Fill(tls *libc.TLS, dst uintptr, value int32, size int32) { /* enc.c:231:25: */
var j int32
for j = 0; j < size; j++ {
- libc.Xmemset(tls, (dst + uintptr((j * 32))), value, uint64(size))
+ libc.Xmemset(tls, dst+uintptr(j*32), value, uint64(size))
}
}
func VerticalPred(tls *libc.TLS, dst uintptr, top uintptr, size int32) { /* enc.c:238:25: */
var j int32
- if top != (uintptr(0)) {
+ if top != uintptr(0) {
for j = 0; j < size; j++ {
- libc.Xmemcpy(tls, (dst + uintptr((j * 32))), top, uint64(size))
+ libc.Xmemcpy(tls, dst+uintptr(j*32), top, uint64(size))
}
} else {
Fill(tls, dst, 127, size)
@@ -16867,10 +16607,10 @@ func VerticalPred(tls *libc.TLS, dst uintptr, top uintptr, size int32) { /* enc.
}
func HorizontalPred(tls *libc.TLS, dst uintptr, left uintptr, size int32) { /* enc.c:248:25: */
- if left != (uintptr(0)) {
+ if left != uintptr(0) {
var j int32
for j = 0; j < size; j++ {
- libc.Xmemset(tls, (dst + uintptr((j * 32))), int32(*(*uint8_t)(unsafe.Pointer(left + uintptr(j)))), uint64(size))
+ libc.Xmemset(tls, dst+uintptr(j*32), int32(*(*uint8_t)(unsafe.Pointer(left + uintptr(j)))), uint64(size))
}
} else {
Fill(tls, dst, 129, size)
@@ -16879,11 +16619,11 @@ func HorizontalPred(tls *libc.TLS, dst uintptr, left uintptr, size int32) { /* e
func TrueMotion1(tls *libc.TLS, dst uintptr, left uintptr, top uintptr, size int32) { /* enc.c:260:25: */
var y int32
- if left != (uintptr(0)) {
- if top != (uintptr(0)) {
- var clip uintptr = ((uintptr(unsafe.Pointer(&clip11)) + uintptr(255)) - uintptr(*(*uint8_t)(unsafe.Pointer(left + libc.UintptrFromInt32(-1)))))
+ if left != uintptr(0) {
+ if top != uintptr(0) {
+ var clip uintptr = uintptr(unsafe.Pointer(&clip11)) + uintptr(255) - uintptr(*(*uint8_t)(unsafe.Pointer(left + libc.UintptrFromInt32(-1))))
for y = 0; y < size; y++ {
- var clip_table uintptr = (clip + uintptr(*(*uint8_t)(unsafe.Pointer(left + uintptr(y)))))
+ var clip_table uintptr = clip + uintptr(*(*uint8_t)(unsafe.Pointer(left + uintptr(y))))
var x int32
for x = 0; x < size; x++ {
*(*uint8_t)(unsafe.Pointer(dst + uintptr(x))) = *(*uint8_t)(unsafe.Pointer(clip_table + uintptr(*(*uint8_t)(unsafe.Pointer(top + uintptr(x))))))
@@ -16898,7 +16638,7 @@ func TrueMotion1(tls *libc.TLS, dst uintptr, left uintptr, top uintptr, size int
// is equivalent to VE prediction where you just copy the top samples.
// Note that if top samples are not available, the default value is
// then 129, and not 127 as in the VerticalPred case.
- if top != (uintptr(0)) {
+ if top != uintptr(0) {
VerticalPred(tls, dst, top, size)
} else {
Fill(tls, dst, 129, size)
@@ -16909,24 +16649,24 @@ func TrueMotion1(tls *libc.TLS, dst uintptr, left uintptr, top uintptr, size int
func DCMode(tls *libc.TLS, dst uintptr, left uintptr, top uintptr, size int32, round int32, shift int32) { /* enc.c:290:25: */
var DC int32 = 0
var j int32
- if top != (uintptr(0)) {
+ if top != uintptr(0) {
for j = 0; j < size; j++ {
- DC = DC + (int32(*(*uint8_t)(unsafe.Pointer(top + uintptr(j)))))
+ DC = DC + int32(*(*uint8_t)(unsafe.Pointer(top + uintptr(j))))
}
- if left != (uintptr(0)) { // top and left present
+ if left != uintptr(0) { // top and left present
for j = 0; j < size; j++ {
- DC = DC + (int32(*(*uint8_t)(unsafe.Pointer(left + uintptr(j)))))
+ DC = DC + int32(*(*uint8_t)(unsafe.Pointer(left + uintptr(j))))
}
} else { // top, but no left
- DC = DC + (DC)
+ DC = DC + DC
}
- DC = ((DC + round) >> shift)
- } else if left != (uintptr(0)) { // left but no top
+ DC = (DC + round) >> shift
+ } else if left != uintptr(0) { // left but no top
for j = 0; j < size; j++ {
- DC = DC + (int32(*(*uint8_t)(unsafe.Pointer(left + uintptr(j)))))
+ DC = DC + int32(*(*uint8_t)(unsafe.Pointer(left + uintptr(j))))
}
- DC = DC + (DC)
- DC = ((DC + round) >> shift)
+ DC = DC + DC
+ DC = (DC + round) >> shift
} else { // no top, no left, nothing.
DC = 0x80
}
@@ -16938,32 +16678,32 @@ func DCMode(tls *libc.TLS, dst uintptr, left uintptr, top uintptr, size int32, r
func IntraChromaPreds_C(tls *libc.TLS, dst uintptr, left uintptr, top uintptr) { /* enc.c:316:13: */
// U block
- DCMode(tls, (uintptr(((2 * 16) * 32)) + dst), left, top, 8, 8, 4)
- VerticalPred(tls, (uintptr((((2 * 16) * 32) + (8 * 32))) + dst), top, 8)
- HorizontalPred(tls, (uintptr(((((2 * 16) * 32) + (8 * 32)) + (1 * 16))) + dst), left, 8)
- TrueMotion1(tls, (uintptr((((2 * 16) * 32) + (1 * 16))) + dst), left, top, 8)
+ DCMode(tls, uintptr(2*16*32)+dst, left, top, 8, 8, 4)
+ VerticalPred(tls, uintptr(2*16*32+8*32)+dst, top, 8)
+ HorizontalPred(tls, uintptr(2*16*32+8*32+1*16)+dst, left, 8)
+ TrueMotion1(tls, uintptr(2*16*32+1*16)+dst, left, top, 8)
// V block
dst += uintptr(8)
- if top != (uintptr(0)) {
+ if top != uintptr(0) {
top += uintptr(8)
}
- if left != (uintptr(0)) {
+ if left != uintptr(0) {
left += uintptr(16)
}
- DCMode(tls, (uintptr(((2 * 16) * 32)) + dst), left, top, 8, 8, 4)
- VerticalPred(tls, (uintptr((((2 * 16) * 32) + (8 * 32))) + dst), top, 8)
- HorizontalPred(tls, (uintptr(((((2 * 16) * 32) + (8 * 32)) + (1 * 16))) + dst), left, 8)
- TrueMotion1(tls, (uintptr((((2 * 16) * 32) + (1 * 16))) + dst), left, top, 8)
+ DCMode(tls, uintptr(2*16*32)+dst, left, top, 8, 8, 4)
+ VerticalPred(tls, uintptr(2*16*32+8*32)+dst, top, 8)
+ HorizontalPred(tls, uintptr(2*16*32+8*32+1*16)+dst, left, 8)
+ TrueMotion1(tls, uintptr(2*16*32+1*16)+dst, left, top, 8)
}
//------------------------------------------------------------------------------
// luma 16x16 prediction (paragraph 12.3)
func Intra16Preds_C(tls *libc.TLS, dst uintptr, left uintptr, top uintptr) { /* enc.c:336:13: */
- DCMode(tls, (uintptr(((0 * 16) * 32)) + dst), left, top, 16, 16, 5)
- VerticalPred(tls, (uintptr(((1 * 16) * 32)) + dst), top, 16)
- HorizontalPred(tls, (uintptr((((1 * 16) * 32) + 16)) + dst), left, 16)
- TrueMotion1(tls, (uintptr((((0 * 16) * 32) + 16)) + dst), left, top, 16)
+ DCMode(tls, uintptr(0*16*32)+dst, left, top, 16, 16, 5)
+ VerticalPred(tls, uintptr(1*16*32)+dst, top, 16)
+ HorizontalPred(tls, uintptr(1*16*32+16)+dst, left, 16)
+ TrueMotion1(tls, uintptr(0*16*32+16)+dst, left, top, 16)
}
//------------------------------------------------------------------------------
@@ -16974,14 +16714,14 @@ func VE4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:351:13: */
defer tls.Free(4)
// vertical
*(*[4]uint8_t)(unsafe.Pointer(bp /* vals */)) = [4]uint8_t{
- (uint8_t(((((int32(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-1))))) + (2 * (int32(*(*uint8_t)(unsafe.Pointer(top)))))) + (int32(*(*uint8_t)(unsafe.Pointer(top + 1))))) + 2) >> 2)),
- (uint8_t(((((int32(*(*uint8_t)(unsafe.Pointer(top)))) + (2 * (int32(*(*uint8_t)(unsafe.Pointer(top + 1)))))) + (int32(*(*uint8_t)(unsafe.Pointer(top + 2))))) + 2) >> 2)),
- (uint8_t(((((int32(*(*uint8_t)(unsafe.Pointer(top + 1)))) + (2 * (int32(*(*uint8_t)(unsafe.Pointer(top + 2)))))) + (int32(*(*uint8_t)(unsafe.Pointer(top + 3))))) + 2) >> 2)),
- (uint8_t(((((int32(*(*uint8_t)(unsafe.Pointer(top + 2)))) + (2 * (int32(*(*uint8_t)(unsafe.Pointer(top + 3)))))) + (int32(*(*uint8_t)(unsafe.Pointer(top + 4))))) + 2) >> 2)),
+ uint8_t((int32(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-1)))) + 2*int32(*(*uint8_t)(unsafe.Pointer(top))) + int32(*(*uint8_t)(unsafe.Pointer(top + 1))) + 2) >> 2),
+ uint8_t((int32(*(*uint8_t)(unsafe.Pointer(top))) + 2*int32(*(*uint8_t)(unsafe.Pointer(top + 1))) + int32(*(*uint8_t)(unsafe.Pointer(top + 2))) + 2) >> 2),
+ uint8_t((int32(*(*uint8_t)(unsafe.Pointer(top + 1))) + 2*int32(*(*uint8_t)(unsafe.Pointer(top + 2))) + int32(*(*uint8_t)(unsafe.Pointer(top + 3))) + 2) >> 2),
+ uint8_t((int32(*(*uint8_t)(unsafe.Pointer(top + 2))) + 2*int32(*(*uint8_t)(unsafe.Pointer(top + 3))) + int32(*(*uint8_t)(unsafe.Pointer(top + 4))) + 2) >> 2),
}
var i int32
for i = 0; i < 4; i++ {
- libc.Xmemcpy(tls, (dst + uintptr((i * 32))), (bp) /* &vals[0] */, uint64(4))
+ libc.Xmemcpy(tls, dst+uintptr(i*32), bp, uint64(4))
}
}
@@ -16991,19 +16731,19 @@ func HE4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:364:13: */ // horiz
var J int32 = int32(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-3))))
var K int32 = int32(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-4))))
var L int32 = int32(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-5))))
- WebPUint32ToMem(tls, (dst + uintptr((0 * 32))), (0x01010101 * (uint32((uint8_t(((((X) + (2 * (I))) + (J)) + 2) >> 2))))))
- WebPUint32ToMem(tls, (dst + uintptr((1 * 32))), (0x01010101 * (uint32((uint8_t(((((I) + (2 * (J))) + (K)) + 2) >> 2))))))
- WebPUint32ToMem(tls, (dst + uintptr((2 * 32))), (0x01010101 * (uint32((uint8_t(((((J) + (2 * (K))) + (L)) + 2) >> 2))))))
- WebPUint32ToMem(tls, (dst + uintptr((3 * 32))), (0x01010101 * (uint32((uint8_t(((((K) + (2 * (L))) + (L)) + 2) >> 2))))))
+ WebPUint32ToMem(tls, dst+uintptr(0*32), 0x01010101*uint32(uint8_t((X+2*I+J+2)>>2)))
+ WebPUint32ToMem(tls, dst+uintptr(1*32), 0x01010101*uint32(uint8_t((I+2*J+K+2)>>2)))
+ WebPUint32ToMem(tls, dst+uintptr(2*32), 0x01010101*uint32(uint8_t((J+2*K+L+2)>>2)))
+ WebPUint32ToMem(tls, dst+uintptr(3*32), 0x01010101*uint32(uint8_t((K+2*L+L+2)>>2)))
}
func DC4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:376:13: */
var dc uint32_t = uint32_t(4)
var i int32
for i = 0; i < 4; i++ {
- dc = dc + (uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top + uintptr(i)))) + int32(*(*uint8_t)(unsafe.Pointer(top + uintptr((-5 + i)))))))
+ dc = dc + uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top + uintptr(i))))+int32(*(*uint8_t)(unsafe.Pointer(top + uintptr(-5+i)))))
}
- Fill(tls, dst, (int32(dc >> 3)), 4)
+ Fill(tls, dst, int32(dc>>3), 4)
}
func RD4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:383:13: */
@@ -17016,13 +16756,13 @@ func RD4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:383:13: */
var B int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 1)))
var C int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 2)))
var D int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 3)))
- *(*uint8_t)(unsafe.Pointer(dst + 96)) = (uint8_t(((((J) + (2 * (K))) + (L)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 64)) = libc.AssignPtrUint8((dst + 97), (uint8_t(((((I) + (2 * (J))) + (K)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 32)) = libc.AssignPtrUint8((dst + 65), libc.AssignPtrUint8((dst+98), (uint8_t(((((X)+(2*(I)))+(J))+2)>>2))))
- *(*uint8_t)(unsafe.Pointer(dst)) = libc.AssignPtrUint8((dst + 33), libc.AssignPtrUint8((dst+66), libc.AssignPtrUint8((dst+99), (uint8_t(((((A)+(2*(X)))+(I))+2)>>2)))))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8((dst + 34), libc.AssignPtrUint8((dst+67), (uint8_t(((((B)+(2*(A)))+(X))+2)>>2))))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8((dst + 35), (uint8_t(((((C) + (2 * (B))) + (A)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = (uint8_t(((((D) + (2 * (C))) + (B)) + 2) >> 2))
+ *(*uint8_t)(unsafe.Pointer(dst + 96)) = uint8_t((J + 2*K + L + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 64)) = libc.AssignPtrUint8(dst+97, uint8_t((I+2*J+K+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 32)) = libc.AssignPtrUint8(dst+65, libc.AssignPtrUint8(dst+98, uint8_t((X+2*I+J+2)>>2)))
+ *(*uint8_t)(unsafe.Pointer(dst)) = libc.AssignPtrUint8(dst+33, libc.AssignPtrUint8(dst+66, libc.AssignPtrUint8(dst+99, uint8_t((A+2*X+I+2)>>2))))
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8(dst+34, libc.AssignPtrUint8(dst+67, uint8_t((B+2*A+X+2)>>2)))
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8(dst+35, uint8_t((C+2*B+A+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = uint8_t((D + 2*C + B + 2) >> 2)
}
func LD4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:402:13: */
@@ -17034,13 +16774,13 @@ func LD4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:402:13: */
var F int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 5)))
var G int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 6)))
var H int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 7)))
- *(*uint8_t)(unsafe.Pointer(dst)) = (uint8_t(((((A) + (2 * (B))) + (C)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8((dst + 32), (uint8_t(((((B) + (2 * (C))) + (D)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8((dst + 33), libc.AssignPtrUint8((dst+64), (uint8_t(((((C)+(2*(D)))+(E))+2)>>2))))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8((dst + 34), libc.AssignPtrUint8((dst+65), libc.AssignPtrUint8((dst+96), (uint8_t(((((D)+(2*(E)))+(F))+2)>>2)))))
- *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8((dst + 66), libc.AssignPtrUint8((dst+97), (uint8_t(((((E)+(2*(F)))+(G))+2)>>2))))
- *(*uint8_t)(unsafe.Pointer(dst + 67)) = libc.AssignPtrUint8((dst + 98), (uint8_t(((((F) + (2 * (G))) + (H)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 99)) = (uint8_t(((((G) + (2 * (H))) + (H)) + 2) >> 2))
+ *(*uint8_t)(unsafe.Pointer(dst)) = uint8_t((A + 2*B + C + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8(dst+32, uint8_t((B+2*C+D+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8(dst+33, libc.AssignPtrUint8(dst+64, uint8_t((C+2*D+E+2)>>2)))
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8(dst+34, libc.AssignPtrUint8(dst+65, libc.AssignPtrUint8(dst+96, uint8_t((D+2*E+F+2)>>2))))
+ *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8(dst+66, libc.AssignPtrUint8(dst+97, uint8_t((E+2*F+G+2)>>2)))
+ *(*uint8_t)(unsafe.Pointer(dst + 67)) = libc.AssignPtrUint8(dst+98, uint8_t((F+2*G+H+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 99)) = uint8_t((G + 2*H + H + 2) >> 2)
}
func VR4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:420:13: */
@@ -17052,17 +16792,17 @@ func VR4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:420:13: */
var B int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 1)))
var C int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 2)))
var D int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 3)))
- *(*uint8_t)(unsafe.Pointer(dst)) = libc.AssignPtrUint8((dst + 65), (uint8_t((((X) + (A)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8((dst + 66), (uint8_t((((A) + (B)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8((dst + 67), (uint8_t((((B) + (C)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = (uint8_t((((C) + (D)) + 1) >> 1))
+ *(*uint8_t)(unsafe.Pointer(dst)) = libc.AssignPtrUint8(dst+65, uint8_t((X+A+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8(dst+66, uint8_t((A+B+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8(dst+67, uint8_t((B+C+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = uint8_t((C + D + 1) >> 1)
- *(*uint8_t)(unsafe.Pointer(dst + 96)) = (uint8_t(((((K) + (2 * (J))) + (I)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 64)) = (uint8_t(((((J) + (2 * (I))) + (X)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 32)) = libc.AssignPtrUint8((dst + 97), (uint8_t(((((I) + (2 * (X))) + (A)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8((dst + 98), (uint8_t(((((X) + (2 * (A))) + (B)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8((dst + 99), (uint8_t(((((A) + (2 * (B))) + (C)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 35)) = (uint8_t(((((B) + (2 * (C))) + (D)) + 2) >> 2))
+ *(*uint8_t)(unsafe.Pointer(dst + 96)) = uint8_t((K + 2*J + I + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 64)) = uint8_t((J + 2*I + X + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 32)) = libc.AssignPtrUint8(dst+97, uint8_t((I+2*X+A+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8(dst+98, uint8_t((X+2*A+B+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8(dst+99, uint8_t((A+2*B+C+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 35)) = uint8_t((B + 2*C + D + 2) >> 2)
}
func VL4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:442:13: */
@@ -17074,17 +16814,17 @@ func VL4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:442:13: */
var F int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 5)))
var G int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 6)))
var H int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 7)))
- *(*uint8_t)(unsafe.Pointer(dst)) = (uint8_t((((A) + (B)) + 1) >> 1))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8((dst + 64), (uint8_t((((B) + (C)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8((dst + 65), (uint8_t((((C) + (D)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8((dst + 66), (uint8_t((((D) + (E)) + 1) >> 1)))
+ *(*uint8_t)(unsafe.Pointer(dst)) = uint8_t((A + B + 1) >> 1)
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8(dst+64, uint8_t((B+C+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8(dst+65, uint8_t((C+D+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8(dst+66, uint8_t((D+E+1)>>1))
- *(*uint8_t)(unsafe.Pointer(dst + 32)) = (uint8_t(((((A) + (2 * (B))) + (C)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8((dst + 96), (uint8_t(((((B) + (2 * (C))) + (D)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8((dst + 97), (uint8_t(((((C) + (2 * (D))) + (E)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8((dst + 98), (uint8_t(((((D) + (2 * (E))) + (F)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 67)) = (uint8_t(((((E) + (2 * (F))) + (G)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 99)) = (uint8_t(((((F) + (2 * (G))) + (H)) + 2) >> 2))
+ *(*uint8_t)(unsafe.Pointer(dst + 32)) = uint8_t((A + 2*B + C + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8(dst+96, uint8_t((B+2*C+D+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8(dst+97, uint8_t((C+2*D+E+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8(dst+98, uint8_t((D+2*E+F+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 67)) = uint8_t((E + 2*F + G + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 99)) = uint8_t((F + 2*G + H + 2) >> 2)
}
func HU4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:464:13: */
@@ -17092,13 +16832,13 @@ func HU4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:464:13: */
var J int32 = int32(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-3))))
var K int32 = int32(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-4))))
var L int32 = int32(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-5))))
- *(*uint8_t)(unsafe.Pointer(dst)) = (uint8_t((((I) + (J)) + 1) >> 1))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8((dst + 32), (uint8_t((((J) + (K)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8((dst + 64), (uint8_t((((K) + (L)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = (uint8_t(((((I) + (2 * (J))) + (K)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8((dst + 33), (uint8_t(((((J) + (2 * (K))) + (L)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8((dst + 65), (uint8_t(((((K) + (2 * (L))) + (L)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 67)) = libc.AssignPtrUint8((dst + 66), libc.AssignPtrUint8((dst+96), libc.AssignPtrUint8((dst+97), libc.AssignPtrUint8((dst+98), libc.AssignPtrUint8((dst+99), uint8_t(L))))))
+ *(*uint8_t)(unsafe.Pointer(dst)) = uint8_t((I + J + 1) >> 1)
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = libc.AssignPtrUint8(dst+32, uint8_t((J+K+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 34)) = libc.AssignPtrUint8(dst+64, uint8_t((K+L+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = uint8_t((I + 2*J + K + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = libc.AssignPtrUint8(dst+33, uint8_t((J+2*K+L+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 35)) = libc.AssignPtrUint8(dst+65, uint8_t((K+2*L+L+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 67)) = libc.AssignPtrUint8(dst+66, libc.AssignPtrUint8(dst+96, libc.AssignPtrUint8(dst+97, libc.AssignPtrUint8(dst+98, libc.AssignPtrUint8(dst+99, uint8_t(L))))))
}
func HD4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:479:13: */
@@ -17111,25 +16851,25 @@ func HD4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:479:13: */
var B int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 1)))
var C int32 = int32(*(*uint8_t)(unsafe.Pointer(top + 2)))
- *(*uint8_t)(unsafe.Pointer(dst)) = libc.AssignPtrUint8((dst + 34), (uint8_t((((I) + (X)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 32)) = libc.AssignPtrUint8((dst + 66), (uint8_t((((J) + (I)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 64)) = libc.AssignPtrUint8((dst + 98), (uint8_t((((K) + (J)) + 1) >> 1)))
- *(*uint8_t)(unsafe.Pointer(dst + 96)) = (uint8_t((((L) + (K)) + 1) >> 1))
+ *(*uint8_t)(unsafe.Pointer(dst)) = libc.AssignPtrUint8(dst+34, uint8_t((I+X+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 32)) = libc.AssignPtrUint8(dst+66, uint8_t((J+I+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 64)) = libc.AssignPtrUint8(dst+98, uint8_t((K+J+1)>>1))
+ *(*uint8_t)(unsafe.Pointer(dst + 96)) = uint8_t((L + K + 1) >> 1)
- *(*uint8_t)(unsafe.Pointer(dst + 3)) = (uint8_t(((((A) + (2 * (B))) + (C)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 2)) = (uint8_t(((((X) + (2 * (A))) + (B)) + 2) >> 2))
- *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8((dst + 35), (uint8_t(((((I) + (2 * (X))) + (A)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8((dst + 67), (uint8_t(((((J) + (2 * (I))) + (X)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 65)) = libc.AssignPtrUint8((dst + 99), (uint8_t(((((K) + (2 * (J))) + (I)) + 2) >> 2)))
- *(*uint8_t)(unsafe.Pointer(dst + 97)) = (uint8_t(((((L) + (2 * (K))) + (J)) + 2) >> 2))
+ *(*uint8_t)(unsafe.Pointer(dst + 3)) = uint8_t((A + 2*B + C + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 2)) = uint8_t((X + 2*A + B + 2) >> 2)
+ *(*uint8_t)(unsafe.Pointer(dst + 1)) = libc.AssignPtrUint8(dst+35, uint8_t((I+2*X+A+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 33)) = libc.AssignPtrUint8(dst+67, uint8_t((J+2*I+X+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 65)) = libc.AssignPtrUint8(dst+99, uint8_t((K+2*J+I+2)>>2))
+ *(*uint8_t)(unsafe.Pointer(dst + 97)) = uint8_t((L + 2*K + J + 2) >> 2)
}
func TM4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:502:13: */
var x int32
var y int32
- var clip uintptr = ((uintptr(unsafe.Pointer(&clip11)) + uintptr(255)) - uintptr(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-1)))))
+ var clip uintptr = uintptr(unsafe.Pointer(&clip11)) + uintptr(255) - uintptr(*(*uint8_t)(unsafe.Pointer(top + libc.UintptrFromInt32(-1))))
for y = 0; y < 4; y++ {
- var clip_table uintptr = (clip + uintptr(*(*uint8_t)(unsafe.Pointer(top + uintptr((-2 - y))))))
+ var clip_table uintptr = clip + uintptr(*(*uint8_t)(unsafe.Pointer(top + uintptr(-2-y))))
for x = 0; x < 4; x++ {
*(*uint8_t)(unsafe.Pointer(dst + uintptr(x))) = *(*uint8_t)(unsafe.Pointer(clip_table + uintptr(*(*uint8_t)(unsafe.Pointer(top + uintptr(x))))))
}
@@ -17140,16 +16880,16 @@ func TM4(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:502:13: */
// Left samples are top[-5 .. -2], top_left is top[-1], top are
// located at top[0..3], and top right is top[4..7]
func Intra4Preds_C(tls *libc.TLS, dst uintptr, top uintptr) { /* enc.c:520:13: */
- DC4(tls, (uintptr((((3 * 16) * 32) + 0)) + dst), top)
- TM4(tls, (uintptr(((((3 * 16) * 32) + 0) + 4)) + dst), top)
- VE4(tls, (uintptr(((((3 * 16) * 32) + 0) + 8)) + dst), top)
- HE4(tls, (uintptr(((((3 * 16) * 32) + 0) + 12)) + dst), top)
- RD4(tls, (uintptr(((((3 * 16) * 32) + 0) + 16)) + dst), top)
- VR4(tls, (uintptr(((((3 * 16) * 32) + 0) + 20)) + dst), top)
- LD4(tls, (uintptr(((((3 * 16) * 32) + 0) + 24)) + dst), top)
- VL4(tls, (uintptr(((((3 * 16) * 32) + 0) + 28)) + dst), top)
- HD4(tls, (uintptr((((3 * 16) * 32) + (4 * 32))) + dst), top)
- HU4(tls, (uintptr(((((3 * 16) * 32) + (4 * 32)) + 4)) + dst), top)
+ DC4(tls, uintptr(3*16*32+0)+dst, top)
+ TM4(tls, uintptr(3*16*32+0+4)+dst, top)
+ VE4(tls, uintptr(3*16*32+0+8)+dst, top)
+ HE4(tls, uintptr(3*16*32+0+12)+dst, top)
+ RD4(tls, uintptr(3*16*32+0+16)+dst, top)
+ VR4(tls, uintptr(3*16*32+0+20)+dst, top)
+ LD4(tls, uintptr(3*16*32+0+24)+dst, top)
+ VL4(tls, uintptr(3*16*32+0+28)+dst, top)
+ HD4(tls, uintptr(3*16*32+4*32)+dst, top)
+ HU4(tls, uintptr(3*16*32+4*32+4)+dst, top)
}
//------------------------------------------------------------------------------
@@ -17161,8 +16901,8 @@ func GetSSE(tls *libc.TLS, a uintptr, b uintptr, w int32, h int32) int32 { /* en
var x int32
for y = 0; y < h; y++ {
for x = 0; x < w; x++ {
- var diff int32 = (int32(*(*uint8_t)(unsafe.Pointer(a + uintptr(x)))) - int32(*(*uint8_t)(unsafe.Pointer(b + uintptr(x)))))
- count = count + (diff * diff)
+ var diff int32 = int32(*(*uint8_t)(unsafe.Pointer(a + uintptr(x)))) - int32(*(*uint8_t)(unsafe.Pointer(b + uintptr(x))))
+ count = count + diff*diff
}
a += uintptr(32)
b += uintptr(32)
@@ -17194,7 +16934,7 @@ func Mean16x4_C(tls *libc.TLS, ref uintptr, dc uintptr) { /* enc.c:566:13: */
var avg uint32_t = uint32_t(0)
for y = 0; y < 4; y++ {
for x = 0; x < 4; x++ {
- avg = avg + (uint32_t(*(*uint8_t)(unsafe.Pointer(ref + uintptr((x + (y * 32)))))))
+ avg = avg + uint32_t(*(*uint8_t)(unsafe.Pointer(ref + uintptr(x+y*32))))
}
}
*(*uint32_t)(unsafe.Pointer(dc + uintptr(k)*4)) = avg
@@ -17226,14 +16966,14 @@ __1:
goto __3
}
{
- var a0 int32 = (int32(*(*uint8_t)(unsafe.Pointer(in))) + int32(*(*uint8_t)(unsafe.Pointer(in + 2))))
- var a1 int32 = (int32(*(*uint8_t)(unsafe.Pointer(in + 1))) + int32(*(*uint8_t)(unsafe.Pointer(in + 3))))
- var a2 int32 = (int32(*(*uint8_t)(unsafe.Pointer(in + 1))) - int32(*(*uint8_t)(unsafe.Pointer(in + 3))))
- var a3 int32 = (int32(*(*uint8_t)(unsafe.Pointer(in))) - int32(*(*uint8_t)(unsafe.Pointer(in + 2))))
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((0+(i*4)))*4)) = (a0 + a1)
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((1+(i*4)))*4)) = (a3 + a2)
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((2+(i*4)))*4)) = (a3 - a2)
- *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((3+(i*4)))*4)) = (a0 - a1)
+ var a0 int32 = int32(*(*uint8_t)(unsafe.Pointer(in))) + int32(*(*uint8_t)(unsafe.Pointer(in + 2)))
+ var a1 int32 = int32(*(*uint8_t)(unsafe.Pointer(in + 1))) + int32(*(*uint8_t)(unsafe.Pointer(in + 3)))
+ var a2 int32 = int32(*(*uint8_t)(unsafe.Pointer(in + 1))) - int32(*(*uint8_t)(unsafe.Pointer(in + 3)))
+ var a3 int32 = int32(*(*uint8_t)(unsafe.Pointer(in))) - int32(*(*uint8_t)(unsafe.Pointer(in + 2)))
+ *(*int32)(unsafe.Pointer(bp + uintptr(0+i*4)*4)) = a0 + a1
+ *(*int32)(unsafe.Pointer(bp + uintptr(1+i*4)*4)) = a3 + a2
+ *(*int32)(unsafe.Pointer(bp + uintptr(2+i*4)*4)) = a3 - a2
+ *(*int32)(unsafe.Pointer(bp + uintptr(3+i*4)*4)) = a0 - a1
}
goto __2
@@ -17251,19 +16991,19 @@ __4:
goto __6
}
{
- var a0 int32 = (*(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((0+i))*4)) + *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((8+i))*4)))
- var a1 int32 = (*(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((4+i))*4)) + *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((12+i))*4)))
- var a2 int32 = (*(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((4+i))*4)) - *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((12+i))*4)))
- var a3 int32 = (*(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((0+i))*4)) - *(*int32)(unsafe.Pointer((bp) /* &tmp[0] */ + uintptr((8+i))*4)))
- var b0 int32 = (a0 + a1)
- var b1 int32 = (a3 + a2)
- var b2 int32 = (a3 - a2)
- var b3 int32 = (a0 - a1)
+ var a0 int32 = *(*int32)(unsafe.Pointer(bp + uintptr(0+i)*4)) + *(*int32)(unsafe.Pointer(bp + uintptr(8+i)*4))
+ var a1 int32 = *(*int32)(unsafe.Pointer(bp + uintptr(4+i)*4)) + *(*int32)(unsafe.Pointer(bp + uintptr(12+i)*4))
+ var a2 int32 = *(*int32)(unsafe.Pointer(bp + uintptr(4+i)*4)) - *(*int32)(unsafe.Pointer(bp + uintptr(12+i)*4))
+ var a3 int32 = *(*int32)(unsafe.Pointer(bp + uintptr(0+i)*4)) - *(*int32)(unsafe.Pointer(bp + uintptr(8+i)*4))
+ var b0 int32 = a0 + a1
+ var b1 int32 = a3 + a2
+ var b2 int32 = a3 - a2
+ var b3 int32 = a0 - a1
- sum = sum + (int32(*(*uint16_t)(unsafe.Pointer(w))) * libc.Xabs(tls, b0))
- sum = sum + (int32(*(*uint16_t)(unsafe.Pointer(w + 4*2))) * libc.Xabs(tls, b1))
- sum = sum + (int32(*(*uint16_t)(unsafe.Pointer(w + 8*2))) * libc.Xabs(tls, b2))
- sum = sum + (int32(*(*uint16_t)(unsafe.Pointer(w + 12*2))) * libc.Xabs(tls, b3))
+ sum = sum + int32(*(*uint16_t)(unsafe.Pointer(w)))*libc.Xabs(tls, b0)
+ sum = sum + int32(*(*uint16_t)(unsafe.Pointer(w + 4*2)))*libc.Xabs(tls, b1)
+ sum = sum + int32(*(*uint16_t)(unsafe.Pointer(w + 8*2)))*libc.Xabs(tls, b2)
+ sum = sum + int32(*(*uint16_t)(unsafe.Pointer(w + 12*2)))*libc.Xabs(tls, b3)
}
goto __5
@@ -17280,16 +17020,16 @@ __6:
func Disto4x4_C(tls *libc.TLS, a uintptr, b uintptr, w uintptr) int32 { /* enc.c:624:12: */
var sum1 int32 = TTransform(tls, a, w)
var sum2 int32 = TTransform(tls, b, w)
- return (libc.Xabs(tls, (sum2-sum1)) >> 5)
+ return libc.Xabs(tls, sum2-sum1) >> 5
}
func Disto16x16_C(tls *libc.TLS, a uintptr, b uintptr, w uintptr) int32 { /* enc.c:631:12: */
var D int32 = 0
var x int32
var y int32
- for y = 0; y < (16 * 32); y = y + (4 * 32) {
- for x = 0; x < 16; x = x + (4) {
- D = D + (Disto4x4_C(tls, ((a + uintptr(x)) + uintptr(y)), ((b + uintptr(x)) + uintptr(y)), w))
+ for y = 0; y < 16*32; y = y + 4*32 {
+ for x = 0; x < 16; x = x + 4 {
+ D = D + Disto4x4_C(tls, a+uintptr(x)+uintptr(y), b+uintptr(x)+uintptr(y), w)
}
}
return D
@@ -17309,17 +17049,17 @@ func QuantizeBlock_C(tls *libc.TLS, in uintptr, out uintptr, mtx uintptr) int32
var n int32
for n = 0; n < 16; n++ {
var j int32 = int32(kZigzag1[n])
- var sign int32 = (libc.Bool32(int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2))) < 0))
- var coeff uint32_t = (uint32_t((func() int32 {
+ var sign int32 = libc.Bool32(int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2))) < 0)
+ var coeff uint32_t = uint32_t(func() int32 {
if sign != 0 {
return -int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2)))
}
return int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2)))
- }()) + int32(*(*uint16_t)(unsafe.Pointer((mtx + 192 /* &.sharpen_ */) + uintptr(j)*2)))))
- if coeff > *(*uint32_t)(unsafe.Pointer((mtx + 128 /* &.zthresh_ */) + uintptr(j)*4)) {
- var Q uint32_t = uint32_t(*(*uint16_t)(unsafe.Pointer((mtx /* &.q_ */) + uintptr(j)*2)))
- var iQ uint32_t = uint32_t(*(*uint16_t)(unsafe.Pointer((mtx + 32 /* &.iq_ */) + uintptr(j)*2)))
- var B uint32_t = *(*uint32_t)(unsafe.Pointer((mtx + 64 /* &.bias_ */) + uintptr(j)*4))
+ }() + int32(*(*uint16_t)(unsafe.Pointer(mtx + 192 + uintptr(j)*2))))
+ if coeff > *(*uint32_t)(unsafe.Pointer(mtx + 128 + uintptr(j)*4)) {
+ var Q uint32_t = uint32_t(*(*uint16_t)(unsafe.Pointer(mtx + uintptr(j)*2)))
+ var iQ uint32_t = uint32_t(*(*uint16_t)(unsafe.Pointer(mtx + 32 + uintptr(j)*2)))
+ var B uint32_t = *(*uint32_t)(unsafe.Pointer(mtx + 64 + uintptr(j)*4))
var level int32 = QUANTDIV(tls, coeff, iQ, B)
if level > MAX_LEVEL {
level = MAX_LEVEL
@@ -17327,7 +17067,7 @@ func QuantizeBlock_C(tls *libc.TLS, in uintptr, out uintptr, mtx uintptr) int32
if sign != 0 {
level = -level
}
- *(*int16_t)(unsafe.Pointer(in + uintptr(j)*2)) = (int16_t(level * int32(Q)))
+ *(*int16_t)(unsafe.Pointer(in + uintptr(j)*2)) = int16_t(level * int32(Q))
*(*int16_t)(unsafe.Pointer(out + uintptr(n)*2)) = int16_t(level)
if level != 0 {
last = n
@@ -17337,17 +17077,17 @@ func QuantizeBlock_C(tls *libc.TLS, in uintptr, out uintptr, mtx uintptr) int32
*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2)) = int16(0)
}
}
- return (libc.Bool32(last >= 0))
+ return libc.Bool32(last >= 0)
}
func Quantize2Blocks_C(tls *libc.TLS, in uintptr, out uintptr, mtx uintptr) int32 { /* enc.c:680:12: */
var nz int32
- nz = ((*struct {
+ nz = (*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlock})).f(tls, (in+uintptr((0*16))*2), (out+uintptr((0*16))*2), mtx) << 0)
- nz = nz | ((*struct {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlock})).f(tls, in+uintptr(0*16)*2, out+uintptr(0*16)*2, mtx) << 0
+ nz = nz | (*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlock})).f(tls, (in+uintptr((1*16))*2), (out+uintptr((1*16))*2), mtx) << 1)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlock})).f(tls, in+uintptr(1*16)*2, out+uintptr(1*16)*2, mtx)<<1
return nz
}
@@ -17398,7 +17138,7 @@ var VP8Copy4x4 VP8BlockCopy /* enc.c:732:14: */
var VP8Copy16x8 VP8BlockCopy /* enc.c:733:14: */
func VP8EncDspInit(tls *libc.TLS) { /* enc.c:742:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if VP8EncDspInit_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -17478,7 +17218,7 @@ func VP8EncDspInit_body(tls *libc.TLS) { /* enc.c:742:1: */
}{Copy16x8_C}))
// If defined, use CPUInfo() to overwrite some pointers with faster versions.
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -17490,11 +17230,11 @@ func PredictLine_C(tls *libc.TLS, src uintptr, pred uintptr, dst uintptr, length
var i int32
if inverse != 0 {
for i = 0; i < length; i++ {
- *(*uint8_t)(unsafe.Pointer(dst + uintptr(i))) = (uint8_t(int32(*(*uint8_t)(unsafe.Pointer(src + uintptr(i)))) + int32(*(*uint8_t)(unsafe.Pointer(pred + uintptr(i))))))
+ *(*uint8_t)(unsafe.Pointer(dst + uintptr(i))) = uint8_t(int32(*(*uint8_t)(unsafe.Pointer(src + uintptr(i)))) + int32(*(*uint8_t)(unsafe.Pointer(pred + uintptr(i)))))
}
} else {
for i = 0; i < length; i++ {
- *(*uint8_t)(unsafe.Pointer(dst + uintptr(i))) = (uint8_t(int32(*(*uint8_t)(unsafe.Pointer(src + uintptr(i)))) - int32(*(*uint8_t)(unsafe.Pointer(pred + uintptr(i))))))
+ *(*uint8_t)(unsafe.Pointer(dst + uintptr(i))) = uint8_t(int32(*(*uint8_t)(unsafe.Pointer(src + uintptr(i)))) - int32(*(*uint8_t)(unsafe.Pointer(pred + uintptr(i)))))
}
}
}
@@ -17504,8 +17244,8 @@ func PredictLine_C(tls *libc.TLS, src uintptr, pred uintptr, dst uintptr, length
func DoHorizontalFilter_C(tls *libc.TLS, in uintptr, width int32, height int32, stride int32, row int32, num_rows int32, inverse int32, out uintptr) { /* filters.c:45:25: */
var preds uintptr
- var start_offset size_t = (size_t(row * stride))
- var last_row int32 = (row + num_rows)
+ var start_offset size_t = size_t(row * stride)
+ var last_row int32 = row + num_rows
_ = height
in += uintptr(start_offset)
@@ -17519,7 +17259,7 @@ func DoHorizontalFilter_C(tls *libc.TLS, in uintptr, width int32, height int32,
if row == 0 {
// Leftmost pixel is the same as input for topmost scanline.
*(*uint8_t)(unsafe.Pointer(out)) = *(*uint8_t)(unsafe.Pointer(in))
- PredictLine_C(tls, (in + uintptr(1)), preds, (out + uintptr(1)), (width - 1), inverse)
+ PredictLine_C(tls, in+uintptr(1), preds, out+uintptr(1), width-1, inverse)
row = 1
preds += uintptr(stride)
in += uintptr(stride)
@@ -17529,8 +17269,8 @@ func DoHorizontalFilter_C(tls *libc.TLS, in uintptr, width int32, height int32,
// Filter line-by-line.
for row < last_row {
// Leftmost pixel is predicted from above.
- PredictLine_C(tls, in, (preds - uintptr(stride)), out, 1, inverse)
- PredictLine_C(tls, (in + uintptr(1)), preds, (out + uintptr(1)), (width - 1), inverse)
+ PredictLine_C(tls, in, preds-uintptr(stride), out, 1, inverse)
+ PredictLine_C(tls, in+uintptr(1), preds, out+uintptr(1), width-1, inverse)
row++
preds += uintptr(stride)
in += uintptr(stride)
@@ -17543,8 +17283,8 @@ func DoHorizontalFilter_C(tls *libc.TLS, in uintptr, width int32, height int32,
func DoVerticalFilter_C(tls *libc.TLS, in uintptr, width int32, height int32, stride int32, row int32, num_rows int32, inverse int32, out uintptr) { /* filters.c:82:25: */
var preds uintptr
- var start_offset size_t = (size_t(row * stride))
- var last_row int32 = (row + num_rows)
+ var start_offset size_t = size_t(row * stride)
+ var last_row int32 = row + num_rows
_ = height
in += uintptr(start_offset)
@@ -17559,7 +17299,7 @@ func DoVerticalFilter_C(tls *libc.TLS, in uintptr, width int32, height int32, st
// Very first top-left pixel is copied.
*(*uint8_t)(unsafe.Pointer(out)) = *(*uint8_t)(unsafe.Pointer(in))
// Rest of top scan-line is left-predicted.
- PredictLine_C(tls, (in + uintptr(1)), preds, (out + uintptr(1)), (width - 1), inverse)
+ PredictLine_C(tls, in+uintptr(1), preds, out+uintptr(1), width-1, inverse)
row = 1
in += uintptr(stride)
out += uintptr(stride)
@@ -17582,8 +17322,8 @@ func DoVerticalFilter_C(tls *libc.TLS, in uintptr, width int32, height int32, st
// Gradient filter.
func GradientPredictor_C(tls *libc.TLS, a uint8_t, b uint8_t, c uint8_t) int32 { /* filters.c:121:24: */
- var g int32 = ((int32(a) + int32(b)) - int32(c))
- if (g & libc.CplInt32(0xff)) == 0 {
+ var g int32 = int32(a) + int32(b) - int32(c)
+ if g&libc.CplInt32(0xff) == 0 {
return g
}
if g < 0 {
@@ -17594,8 +17334,8 @@ func GradientPredictor_C(tls *libc.TLS, a uint8_t, b uint8_t, c uint8_t) int32 {
func DoGradientFilter_C(tls *libc.TLS, in uintptr, width int32, height int32, stride int32, row int32, num_rows int32, inverse int32, out uintptr) { /* filters.c:127:25: */
var preds uintptr
- var start_offset size_t = (size_t(row * stride))
- var last_row int32 = (row + num_rows)
+ var start_offset size_t = size_t(row * stride)
+ var last_row int32 = row + num_rows
_ = height
in += uintptr(start_offset)
@@ -17609,7 +17349,7 @@ func DoGradientFilter_C(tls *libc.TLS, in uintptr, width int32, height int32, st
// left prediction for top scan-line
if row == 0 {
*(*uint8_t)(unsafe.Pointer(out)) = *(*uint8_t)(unsafe.Pointer(in))
- PredictLine_C(tls, (in + uintptr(1)), preds, (out + uintptr(1)), (width - 1), inverse)
+ PredictLine_C(tls, in+uintptr(1), preds, out+uintptr(1), width-1, inverse)
row = 1
preds += uintptr(stride)
in += uintptr(stride)
@@ -17620,17 +17360,17 @@ func DoGradientFilter_C(tls *libc.TLS, in uintptr, width int32, height int32, st
for row < last_row {
var w int32
// leftmost pixel: predict from above.
- PredictLine_C(tls, in, (preds - uintptr(stride)), out, 1, inverse)
+ PredictLine_C(tls, in, preds-uintptr(stride), out, 1, inverse)
for w = 1; w < width; w++ {
- var pred int32 = GradientPredictor_C(tls, *(*uint8_t)(unsafe.Pointer(preds + uintptr((w - 1)))),
- *(*uint8_t)(unsafe.Pointer(preds + uintptr((w - stride)))),
- *(*uint8_t)(unsafe.Pointer(preds + uintptr(((w - stride) - 1)))))
- *(*uint8_t)(unsafe.Pointer(out + uintptr(w))) = (uint8_t(int32(*(*uint8_t)(unsafe.Pointer(in + uintptr(w)))) + (func() int32 {
+ var pred int32 = GradientPredictor_C(tls, *(*uint8_t)(unsafe.Pointer(preds + uintptr(w-1))),
+ *(*uint8_t)(unsafe.Pointer(preds + uintptr(w-stride))),
+ *(*uint8_t)(unsafe.Pointer(preds + uintptr(w-stride-1))))
+ *(*uint8_t)(unsafe.Pointer(out + uintptr(w))) = uint8_t(int32(*(*uint8_t)(unsafe.Pointer(in + uintptr(w)))) + func() int32 {
if inverse != 0 {
return pred
}
return -pred
- }())))
+ }())
}
row++
preds += uintptr(stride)
@@ -17658,32 +17398,32 @@ func GradientFilter_C(tls *libc.TLS, data uintptr, width int32, height int32, st
func HorizontalUnfilter_C(tls *libc.TLS, prev uintptr, in uintptr, out uintptr, width int32) { /* filters.c:192:13: */
var pred uint8_t
- if prev == (uintptr(0)) {
+ if prev == uintptr(0) {
pred = uint8(0)
} else {
pred = *(*uint8_t)(unsafe.Pointer(prev))
}
var i int32
for i = 0; i < width; i++ {
- *(*uint8_t)(unsafe.Pointer(out + uintptr(i))) = (uint8_t(int32(pred) + int32(*(*uint8_t)(unsafe.Pointer(in + uintptr(i))))))
+ *(*uint8_t)(unsafe.Pointer(out + uintptr(i))) = uint8_t(int32(pred) + int32(*(*uint8_t)(unsafe.Pointer(in + uintptr(i)))))
pred = *(*uint8_t)(unsafe.Pointer(out + uintptr(i)))
}
}
func VerticalUnfilter_C(tls *libc.TLS, prev uintptr, in uintptr, out uintptr, width int32) { /* filters.c:203:13: */
- if prev == (uintptr(0)) {
- HorizontalUnfilter_C(tls, (uintptr(0)), in, out, width)
+ if prev == uintptr(0) {
+ HorizontalUnfilter_C(tls, uintptr(0), in, out, width)
} else {
var i int32
for i = 0; i < width; i++ {
- *(*uint8_t)(unsafe.Pointer(out + uintptr(i))) = (uint8_t(int32(*(*uint8_t)(unsafe.Pointer(prev + uintptr(i)))) + int32(*(*uint8_t)(unsafe.Pointer(in + uintptr(i))))))
+ *(*uint8_t)(unsafe.Pointer(out + uintptr(i))) = uint8_t(int32(*(*uint8_t)(unsafe.Pointer(prev + uintptr(i)))) + int32(*(*uint8_t)(unsafe.Pointer(in + uintptr(i)))))
}
}
}
func GradientUnfilter_C(tls *libc.TLS, prev uintptr, in uintptr, out uintptr, width int32) { /* filters.c:214:13: */
- if prev == (uintptr(0)) {
- HorizontalUnfilter_C(tls, (uintptr(0)), in, out, width)
+ if prev == uintptr(0) {
+ HorizontalUnfilter_C(tls, uintptr(0), in, out, width)
} else {
var top uint8_t = *(*uint8_t)(unsafe.Pointer(prev))
var top_left uint8_t = top
@@ -17691,7 +17431,7 @@ func GradientUnfilter_C(tls *libc.TLS, prev uintptr, in uintptr, out uintptr, wi
var i int32
for i = 0; i < width; i++ {
top = *(*uint8_t)(unsafe.Pointer(prev + uintptr(i))) // need to read this first, in case prev==out
- left = (uint8_t(int32(*(*uint8_t)(unsafe.Pointer(in + uintptr(i)))) + GradientPredictor_C(tls, left, top, top_left)))
+ left = uint8_t(int32(*(*uint8_t)(unsafe.Pointer(in + uintptr(i)))) + GradientPredictor_C(tls, left, top, top_left))
top_left = top
*(*uint8_t)(unsafe.Pointer(out + uintptr(i))) = left
}
@@ -17705,7 +17445,7 @@ var WebPFilters [4]WebPFilterFunc /* filters.c:233:16: */
var WebPUnfilters [4]WebPUnfilterFunc /* filters.c:234:18: */
func VP8FiltersInit(tls *libc.TLS) { /* filters.c:241:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if VP8FiltersInit_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -17717,7 +17457,7 @@ func VP8FiltersInit(tls *libc.TLS) { /* filters.c:241:1: */
var VP8FiltersInit_body_last_cpuinfo_used VP8CPUInfo = 0 /* filters.c:241:1 */
func VP8FiltersInit_body(tls *libc.TLS) { /* filters.c:241:1: */
- WebPUnfilters[WEBP_FILTER_NONE] = (uintptr(0))
+ WebPUnfilters[WEBP_FILTER_NONE] = uintptr(0)
WebPUnfilters[WEBP_FILTER_HORIZONTAL] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
}{HorizontalUnfilter_C}))
@@ -17728,7 +17468,7 @@ func VP8FiltersInit_body(tls *libc.TLS) { /* filters.c:241:1: */
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
}{GradientUnfilter_C}))
- WebPFilters[WEBP_FILTER_NONE] = (uintptr(0))
+ WebPFilters[WEBP_FILTER_NONE] = uintptr(0)
WebPFilters[WEBP_FILTER_HORIZONTAL] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, int32, int32, int32, uintptr)
}{HorizontalFilter_C}))
@@ -17739,7 +17479,7 @@ func VP8FiltersInit_body(tls *libc.TLS) { /* filters.c:241:1: */
f func(*libc.TLS, uintptr, int32, int32, int32, uintptr)
}{GradientFilter_C}))
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -18164,7 +17904,7 @@ type double_t = float64 /* math.h:150:16 */
// Image transforms.
func Average2(tls *libc.TLS, a0 uint32_t, a1 uint32_t) uint32_t { /* lossless.c:29:29: */
- return ((((a0 ^ a1) & 0xfefefefe) >> 1) + (a0 & a1))
+ return (a0^a1)&0xfefefefe>>1 + a0&a1
}
func Average3(tls *libc.TLS, a0 uint32_t, a1 uint32_t, a2 uint32_t) uint32_t { /* lossless.c:33:29: */
@@ -18181,49 +17921,49 @@ func Clip255(tls *libc.TLS, a uint32_t) uint32_t { /* lossless.c:42:29: */
}
// return 0, when a is a negative integer.
// return 255, when a is positive.
- return (^a >> 24)
+ return ^a >> 24
}
func AddSubtractComponentFull(tls *libc.TLS, a int32, b int32, c int32) int32 { /* lossless.c:51:24: */
- return int32(Clip255(tls, (uint32((a + b) - c))))
+ return int32(Clip255(tls, uint32(a+b-c)))
}
func ClampedAddSubtractFull(tls *libc.TLS, c0 uint32_t, c1 uint32_t, c2 uint32_t) uint32_t { /* lossless.c:55:29: */
- var a int32 = AddSubtractComponentFull(tls, (int32(c0 >> 24)), (int32(c1 >> 24)), (int32(c2 >> 24)))
- var r int32 = AddSubtractComponentFull(tls, (int32((c0 >> 16) & uint32_t(0xff))),
- (int32((c1 >> 16) & uint32_t(0xff))),
- (int32((c2 >> 16) & uint32_t(0xff))))
- var g int32 = AddSubtractComponentFull(tls, (int32((c0 >> 8) & uint32_t(0xff))),
- (int32((c1 >> 8) & uint32_t(0xff))),
- (int32((c2 >> 8) & uint32_t(0xff))))
- var b int32 = AddSubtractComponentFull(tls, (int32(c0 & uint32_t(0xff))), (int32(c1 & uint32_t(0xff))), (int32(c2 & uint32_t(0xff))))
- return ((((uint32_t(a) << 24) | (uint32_t(r << 16))) | (uint32_t(g << 8))) | uint32_t(b))
+ var a int32 = AddSubtractComponentFull(tls, int32(c0>>24), int32(c1>>24), int32(c2>>24))
+ var r int32 = AddSubtractComponentFull(tls, int32(c0>>16&uint32_t(0xff)),
+ int32(c1>>16&uint32_t(0xff)),
+ int32(c2>>16&uint32_t(0xff)))
+ var g int32 = AddSubtractComponentFull(tls, int32(c0>>8&uint32_t(0xff)),
+ int32(c1>>8&uint32_t(0xff)),
+ int32(c2>>8&uint32_t(0xff)))
+ var b int32 = AddSubtractComponentFull(tls, int32(c0&uint32_t(0xff)), int32(c1&uint32_t(0xff)), int32(c2&uint32_t(0xff)))
+ return uint32_t(a)<<24 | uint32_t(r<<16) | uint32_t(g<<8) | uint32_t(b)
}
func AddSubtractComponentHalf(tls *libc.TLS, a int32, b int32) int32 { /* lossless.c:68:24: */
- return int32(Clip255(tls, (uint32(a + ((a - b) / 2)))))
+ return int32(Clip255(tls, uint32(a+(a-b)/2)))
}
func ClampedAddSubtractHalf(tls *libc.TLS, c0 uint32_t, c1 uint32_t, c2 uint32_t) uint32_t { /* lossless.c:72:29: */
var ave uint32_t = Average2(tls, c0, c1)
- var a int32 = AddSubtractComponentHalf(tls, (int32(ave >> 24)), (int32(c2 >> 24)))
- var r int32 = AddSubtractComponentHalf(tls, (int32((ave >> 16) & uint32_t(0xff))), (int32((c2 >> 16) & uint32_t(0xff))))
- var g int32 = AddSubtractComponentHalf(tls, (int32((ave >> 8) & uint32_t(0xff))), (int32((c2 >> 8) & uint32_t(0xff))))
- var b int32 = AddSubtractComponentHalf(tls, (int32((ave >> 0) & uint32_t(0xff))), (int32((c2 >> 0) & uint32_t(0xff))))
- return ((((uint32_t(a) << 24) | (uint32_t(r << 16))) | (uint32_t(g << 8))) | uint32_t(b))
+ var a int32 = AddSubtractComponentHalf(tls, int32(ave>>24), int32(c2>>24))
+ var r int32 = AddSubtractComponentHalf(tls, int32(ave>>16&uint32_t(0xff)), int32(c2>>16&uint32_t(0xff)))
+ var g int32 = AddSubtractComponentHalf(tls, int32(ave>>8&uint32_t(0xff)), int32(c2>>8&uint32_t(0xff)))
+ var b int32 = AddSubtractComponentHalf(tls, int32(ave>>0&uint32_t(0xff)), int32(c2>>0&uint32_t(0xff)))
+ return uint32_t(a)<<24 | uint32_t(r<<16) | uint32_t(g<<8) | uint32_t(b)
}
// gcc <= 4.9 on ARM generates incorrect code in Select() when Sub3() is
// inlined.
func Sub3(tls *libc.TLS, a int32, b int32, c int32) int32 { /* lossless.c:90:25: */
- var pb int32 = (b - c)
- var pa int32 = (a - c)
- return (libc.Xabs(tls, pb) - libc.Xabs(tls, pa))
+ var pb int32 = b - c
+ var pa int32 = a - c
+ return libc.Xabs(tls, pb) - libc.Xabs(tls, pa)
}
func Select(tls *libc.TLS, a uint32_t, b uint32_t, c uint32_t) uint32_t { /* lossless.c:98:29: */
- var pa_minus_pb int32 = (((Sub3(tls, (int32(a>>24)), (int32(b>>24)), (int32(c>>24))) + Sub3(tls, (int32((a>>16)&uint32_t(0xff))), (int32((b>>16)&uint32_t(0xff))), (int32((c>>16)&uint32_t(0xff))))) + Sub3(tls, (int32((a>>8)&uint32_t(0xff))), (int32((b>>8)&uint32_t(0xff))), (int32((c>>8)&uint32_t(0xff))))) + Sub3(tls, (int32((a)&uint32_t(0xff))), (int32((b)&uint32_t(0xff))), (int32((c)&uint32_t(0xff)))))
+ var pa_minus_pb int32 = Sub3(tls, int32(a>>24), int32(b>>24), int32(c>>24)) + Sub3(tls, int32(a>>16&uint32_t(0xff)), int32(b>>16&uint32_t(0xff)), int32(c>>16&uint32_t(0xff))) + Sub3(tls, int32(a>>8&uint32_t(0xff)), int32(b>>8&uint32_t(0xff)), int32(c>>8&uint32_t(0xff))) + Sub3(tls, int32(a&uint32_t(0xff)), int32(b&uint32_t(0xff)), int32(c&uint32_t(0xff)))
if pa_minus_pb <= 0 {
return a
}
@@ -18326,7 +18066,7 @@ func PredictorAdd1_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorAdd2_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:199:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor2_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor2_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18334,7 +18074,7 @@ func PredictorAdd2_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorAdd3_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:200:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor3_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor3_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18342,7 +18082,7 @@ func PredictorAdd3_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorAdd4_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:201:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor4_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor4_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18350,7 +18090,7 @@ func PredictorAdd4_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorAdd5_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:202:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor5_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor5_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18358,7 +18098,7 @@ func PredictorAdd5_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorAdd6_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:203:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor6_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor6_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18366,7 +18106,7 @@ func PredictorAdd6_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorAdd7_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:204:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor7_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor7_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18374,7 +18114,7 @@ func PredictorAdd7_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorAdd8_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:205:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor8_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor8_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18382,7 +18122,7 @@ func PredictorAdd8_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorAdd9_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:206:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor9_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor9_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18390,7 +18130,7 @@ func PredictorAdd9_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorAdd10_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:207:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor10_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor10_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18398,7 +18138,7 @@ func PredictorAdd10_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32
func PredictorAdd11_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:208:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor11_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor11_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18406,7 +18146,7 @@ func PredictorAdd11_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32
func PredictorAdd12_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:209:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor12_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor12_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18414,7 +18154,7 @@ func PredictorAdd12_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32
func PredictorAdd13_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless.c:210:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor13_C(tls, (out + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor13_C(tls, out+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LAddPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -18425,42 +18165,42 @@ func PredictorAdd13_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32
func PredictorInverseTransform_C(tls *libc.TLS, transform uintptr, y_start int32, y_end int32, in uintptr, out uintptr) { /* lossless.c:215:13: */
var width int32 = (*VP8LTransform)(unsafe.Pointer(transform)).xsize_
if y_start == 0 { // First Row follows the L (mode=1) mode.
- PredictorAdd0_C(tls, in, (uintptr(0)), 1, out)
- PredictorAdd1_C(tls, (in + uintptr(1)*4), (uintptr(0)), (width - 1), (out + uintptr(1)*4))
- in += 4 * (uintptr(width))
- out += 4 * (uintptr(width))
+ PredictorAdd0_C(tls, in, uintptr(0), 1, out)
+ PredictorAdd1_C(tls, in+uintptr(1)*4, uintptr(0), width-1, out+uintptr(1)*4)
+ in += 4 * uintptr(width)
+ out += 4 * uintptr(width)
y_start++
}
{
var y int32 = y_start
- var tile_width int32 = (int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).bits_)
- var mask int32 = (tile_width - 1)
+ var tile_width int32 = int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).bits_
+ var mask int32 = tile_width - 1
var tiles_per_row int32 = int32(VP8LSubSampleSize(tls, uint32(width), uint32((*VP8LTransform)(unsafe.Pointer(transform)).bits_)))
- var pred_mode_base uintptr = ((*VP8LTransform)(unsafe.Pointer(transform)).data_ + uintptr(((y>>(*VP8LTransform)(unsafe.Pointer(transform)).bits_)*tiles_per_row))*4)
+ var pred_mode_base uintptr = (*VP8LTransform)(unsafe.Pointer(transform)).data_ + uintptr(y>>(*VP8LTransform)(unsafe.Pointer(transform)).bits_*tiles_per_row)*4
for y < y_end {
var pred_mode_src uintptr = pred_mode_base
var x int32 = 1
// First pixel follows the T (mode=2) mode.
- PredictorAdd2_C(tls, in, (out - uintptr(width)*4), 1, out)
+ PredictorAdd2_C(tls, in, out-uintptr(width)*4, 1, out)
// .. the rest:
for x < width {
- var pred_func VP8LPredictorAddSubFunc = VP8LPredictorsAdd[(((*(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&pred_mode_src, 4)))) >> 8) & uint32_t(0xf))]
- var x_end int32 = ((x & ^mask) + tile_width)
+ var pred_func VP8LPredictorAddSubFunc = VP8LPredictorsAdd[*(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&pred_mode_src, 4)))>>8&uint32_t(0xf)]
+ var x_end int32 = x & ^mask + tile_width
if x_end > width {
x_end = width
}
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{pred_func})).f(tls, (in + uintptr(x)*4), ((out + uintptr(x)*4) - uintptr(width)*4), (x_end - x), (out + uintptr(x)*4))
+ })(unsafe.Pointer(&struct{ uintptr }{pred_func})).f(tls, in+uintptr(x)*4, out+uintptr(x)*4-uintptr(width)*4, x_end-x, out+uintptr(x)*4)
x = x_end
}
- in += 4 * (uintptr(width))
- out += 4 * (uintptr(width))
+ in += 4 * uintptr(width)
+ out += 4 * uintptr(width)
y++
- if (y & mask) == 0 { // Use the same mask, since tiles are squares.
- pred_mode_base += 4 * (uintptr(tiles_per_row))
+ if y&mask == 0 { // Use the same mask, since tiles are squares.
+ pred_mode_base += 4 * uintptr(tiles_per_row)
}
}
@@ -18473,38 +18213,38 @@ func VP8LAddGreenToBlueAndRed_C(tls *libc.TLS, src uintptr, num_pixels int32, ds
var i int32
for i = 0; i < num_pixels; i++ {
var argb uint32_t = *(*uint32_t)(unsafe.Pointer(src + uintptr(i)*4))
- var green uint32_t = ((argb >> 8) & uint32_t(0xff))
- var red_blue uint32_t = (argb & 0x00ff00ff)
- red_blue = red_blue + ((green << 16) | green)
- red_blue = red_blue & (0x00ff00ff)
- *(*uint32_t)(unsafe.Pointer(dst + uintptr(i)*4)) = ((argb & 0xff00ff00) | red_blue)
+ var green uint32_t = argb >> 8 & uint32_t(0xff)
+ var red_blue uint32_t = argb & 0x00ff00ff
+ red_blue = red_blue + (green<<16 | green)
+ red_blue = red_blue & 0x00ff00ff
+ *(*uint32_t)(unsafe.Pointer(dst + uintptr(i)*4)) = argb&0xff00ff00 | red_blue
}
}
func ColorTransformDelta(tls *libc.TLS, color_pred int8_t, color int8_t) int32 { /* lossless.c:274:24: */
- return ((int32(color_pred) * int32(color)) >> 5)
+ return int32(color_pred) * int32(color) >> 5
}
func ColorCodeToMultipliers(tls *libc.TLS, color_code uint32_t, m uintptr) { /* lossless.c:279:25: */
- (*VP8LMultipliers)(unsafe.Pointer(m)).green_to_red_ = (uint8_t((color_code >> 0) & uint32_t(0xff)))
- (*VP8LMultipliers)(unsafe.Pointer(m)).green_to_blue_ = (uint8_t((color_code >> 8) & uint32_t(0xff)))
- (*VP8LMultipliers)(unsafe.Pointer(m)).red_to_blue_ = (uint8_t((color_code >> 16) & uint32_t(0xff)))
+ (*VP8LMultipliers)(unsafe.Pointer(m)).green_to_red_ = uint8_t(color_code >> 0 & uint32_t(0xff))
+ (*VP8LMultipliers)(unsafe.Pointer(m)).green_to_blue_ = uint8_t(color_code >> 8 & uint32_t(0xff))
+ (*VP8LMultipliers)(unsafe.Pointer(m)).red_to_blue_ = uint8_t(color_code >> 16 & uint32_t(0xff))
}
func VP8LTransformColorInverse_C(tls *libc.TLS, m uintptr, src uintptr, num_pixels int32, dst uintptr) { /* lossless.c:286:6: */
var i int32
for i = 0; i < num_pixels; i++ {
var argb uint32_t = *(*uint32_t)(unsafe.Pointer(src + uintptr(i)*4))
- var green int8_t = (int8_t(argb >> 8))
- var red uint32_t = (argb >> 16)
- var new_red int32 = (int32(red & uint32_t(0xff)))
- var new_blue int32 = (int32(argb & uint32_t(0xff)))
- new_red = new_red + (ColorTransformDelta(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_red_), green))
- new_red = new_red & (0xff)
- new_blue = new_blue + (ColorTransformDelta(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_blue_), green))
- new_blue = new_blue + (ColorTransformDelta(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).red_to_blue_), int8_t(new_red)))
- new_blue = new_blue & (0xff)
- *(*uint32_t)(unsafe.Pointer(dst + uintptr(i)*4)) = (((argb & 0xff00ff00) | (uint32_t(new_red << 16))) | (uint32_t(new_blue)))
+ var green int8_t = int8_t(argb >> 8)
+ var red uint32_t = argb >> 16
+ var new_red int32 = int32(red & uint32_t(0xff))
+ var new_blue int32 = int32(argb & uint32_t(0xff))
+ new_red = new_red + ColorTransformDelta(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_red_), green)
+ new_red = new_red & 0xff
+ new_blue = new_blue + ColorTransformDelta(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_blue_), green)
+ new_blue = new_blue + ColorTransformDelta(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).red_to_blue_), int8_t(new_red))
+ new_blue = new_blue & 0xff
+ *(*uint32_t)(unsafe.Pointer(dst + uintptr(i)*4)) = argb&0xff00ff00 | uint32_t(new_red<<16) | uint32_t(new_blue)
}
}
@@ -18514,38 +18254,38 @@ func ColorSpaceInverseTransform_C(tls *libc.TLS, transform uintptr, y_start int3
defer tls.Free(3)
var width int32 = (*VP8LTransform)(unsafe.Pointer(transform)).xsize_
- var tile_width int32 = (int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).bits_)
- var mask int32 = (tile_width - 1)
- var safe_width int32 = (width & ^mask)
- var remaining_width int32 = (width - safe_width)
+ var tile_width int32 = int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).bits_
+ var mask int32 = tile_width - 1
+ var safe_width int32 = width & ^mask
+ var remaining_width int32 = width - safe_width
var tiles_per_row int32 = int32(VP8LSubSampleSize(tls, uint32(width), uint32((*VP8LTransform)(unsafe.Pointer(transform)).bits_)))
var y int32 = y_start
- var pred_row uintptr = ((*VP8LTransform)(unsafe.Pointer(transform)).data_ + uintptr(((y>>(*VP8LTransform)(unsafe.Pointer(transform)).bits_)*tiles_per_row))*4)
+ var pred_row uintptr = (*VP8LTransform)(unsafe.Pointer(transform)).data_ + uintptr(y>>(*VP8LTransform)(unsafe.Pointer(transform)).bits_*tiles_per_row)*4
for y < y_end {
var pred uintptr = pred_row
*(*VP8LMultipliers)(unsafe.Pointer(bp /* m */)) = VP8LMultipliers{}
- var src_safe_end uintptr = (src + uintptr(safe_width)*4)
- var src_end uintptr = (src + uintptr(width)*4)
+ var src_safe_end uintptr = src + uintptr(safe_width)*4
+ var src_end uintptr = src + uintptr(width)*4
for src < src_safe_end {
- ColorCodeToMultipliers(tls, *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&pred, 4))), (bp) /* &m */)
+ ColorCodeToMultipliers(tls, *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&pred, 4))), bp)
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LTransformColorInverse})).f(tls, (bp) /* &m */, src, tile_width, dst)
- src += 4 * (uintptr(tile_width))
- dst += 4 * (uintptr(tile_width))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LTransformColorInverse})).f(tls, bp /* &m */, src, tile_width, dst)
+ src += 4 * uintptr(tile_width)
+ dst += 4 * uintptr(tile_width)
}
if src < src_end { // Left-overs using C-version.
- ColorCodeToMultipliers(tls, *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&pred, 4))), (bp) /* &m */)
+ ColorCodeToMultipliers(tls, *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&pred, 4))), bp)
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LTransformColorInverse})).f(tls, (bp) /* &m */, src, remaining_width, dst)
- src += 4 * (uintptr(remaining_width))
- dst += 4 * (uintptr(remaining_width))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LTransformColorInverse})).f(tls, bp /* &m */, src, remaining_width, dst)
+ src += 4 * uintptr(remaining_width)
+ dst += 4 * uintptr(remaining_width)
}
y++
- if (y & mask) == 0 {
- pred_row += 4 * (uintptr(tiles_per_row))
+ if y&mask == 0 {
+ pred_row += 4 * uintptr(tiles_per_row)
}
}
}
@@ -18565,21 +18305,21 @@ func MapARGB_C(tls *libc.TLS, src uintptr, color_map uintptr, dst uintptr, y_sta
func ColorIndexInverseTransform_C(tls *libc.TLS, transform uintptr, y_start int32, y_end int32, src uintptr, dst uintptr) { /* lossless.c:384:1: */
var y int32
- var bits_per_pixel int32 = (int32(8) >> (*VP8LTransform)(unsafe.Pointer(transform)).bits_)
+ var bits_per_pixel int32 = int32(8) >> (*VP8LTransform)(unsafe.Pointer(transform)).bits_
var width int32 = (*VP8LTransform)(unsafe.Pointer(transform)).xsize_
var color_map uintptr = (*VP8LTransform)(unsafe.Pointer(transform)).data_
if bits_per_pixel < 8 {
- var pixels_per_byte int32 = (int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).bits_)
- var count_mask int32 = (pixels_per_byte - 1)
- var bit_mask uint32_t = (uint32_t((int32(1) << bits_per_pixel) - 1))
+ var pixels_per_byte int32 = int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).bits_
+ var count_mask int32 = pixels_per_byte - 1
+ var bit_mask uint32_t = uint32_t(int32(1)<<bits_per_pixel - 1)
for y = y_start; y < y_end; y++ {
var packed_pixels uint32_t = uint32_t(0)
var x int32
for x = 0; x < width; x++ { /* We need to load fresh 'packed_pixels' once every */ /* 'pixels_per_byte' increments of x. Fortunately, pixels_per_byte */ /* is a power of 2, so can just use a mask for that, instead of */ /* decrementing a counter. */
- if (x & count_mask) == 0 {
+ if x&count_mask == 0 {
packed_pixels = VP8GetARGBIndex(tls, *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&src, 4))))
}
- *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 4))) = VP8GetARGBValue(tls, *(*uint32_t)(unsafe.Pointer(color_map + uintptr((packed_pixels&bit_mask))*4)))
+ *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 4))) = VP8GetARGBValue(tls, *(*uint32_t)(unsafe.Pointer(color_map + uintptr(packed_pixels&bit_mask)*4)))
packed_pixels >>= bits_per_pixel
}
}
@@ -18602,21 +18342,21 @@ func MapAlpha_C(tls *libc.TLS, src uintptr, color_map uintptr, dst uintptr, y_st
func VP8LColorIndexInverseTransformAlpha(tls *libc.TLS, transform uintptr, y_start int32, y_end int32, src uintptr, dst uintptr) { /* lossless.c:386:1: */
var y int32
- var bits_per_pixel int32 = (int32(8) >> (*VP8LTransform)(unsafe.Pointer(transform)).bits_)
+ var bits_per_pixel int32 = int32(8) >> (*VP8LTransform)(unsafe.Pointer(transform)).bits_
var width int32 = (*VP8LTransform)(unsafe.Pointer(transform)).xsize_
var color_map uintptr = (*VP8LTransform)(unsafe.Pointer(transform)).data_
if bits_per_pixel < 8 {
- var pixels_per_byte int32 = (int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).bits_)
- var count_mask int32 = (pixels_per_byte - 1)
- var bit_mask uint32_t = (uint32_t((int32(1) << bits_per_pixel) - 1))
+ var pixels_per_byte int32 = int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).bits_
+ var count_mask int32 = pixels_per_byte - 1
+ var bit_mask uint32_t = uint32_t(int32(1)<<bits_per_pixel - 1)
for y = y_start; y < y_end; y++ {
var packed_pixels uint32_t = uint32_t(0)
var x int32
for x = 0; x < width; x++ { /* We need to load fresh 'packed_pixels' once every */ /* 'pixels_per_byte' increments of x. Fortunately, pixels_per_byte */ /* is a power of 2, so can just use a mask for that, instead of */ /* decrementing a counter. */
- if (x & count_mask) == 0 {
+ if x&count_mask == 0 {
packed_pixels = uint32_t(VP8GetAlphaIndex(tls, *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&src, 1)))))
}
- *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = VP8GetAlphaValue(tls, *(*uint32_t)(unsafe.Pointer(color_map + uintptr((packed_pixels&bit_mask))*4)))
+ *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = VP8GetAlphaValue(tls, *(*uint32_t)(unsafe.Pointer(color_map + uintptr(packed_pixels&bit_mask)*4)))
packed_pixels >>= bits_per_pixel
}
}
@@ -18634,31 +18374,31 @@ func VP8LInverseTransform(tls *libc.TLS, transform uintptr, row_start int32, row
case SUBTRACT_GREEN:
(*struct {
f func(*libc.TLS, uintptr, int32, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LAddGreenToBlueAndRed})).f(tls, in, ((row_end - row_start) * width), out)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LAddGreenToBlueAndRed})).f(tls, in, (row_end-row_start)*width, out)
break
case PREDICTOR_TRANSFORM:
PredictorInverseTransform_C(tls, transform, row_start, row_end, in, out)
if row_end != (*VP8LTransform)(unsafe.Pointer(transform)).ysize_ {
// The last predicted row in this iteration will be the top-pred row
// for the first row in next iteration.
- libc.Xmemcpy(tls, (out - uintptr(width)*4), (out + uintptr((((row_end-row_start)-1)*width))*4),
- (uint64(width) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, out-uintptr(width)*4, out+uintptr((row_end-row_start-1)*width)*4,
+ uint64(width)*uint64(unsafe.Sizeof(uint32_t(0))))
}
break
case CROSS_COLOR_TRANSFORM:
ColorSpaceInverseTransform_C(tls, transform, row_start, row_end, in, out)
break
case COLOR_INDEXING_TRANSFORM:
- if (in == out) && ((*VP8LTransform)(unsafe.Pointer(transform)).bits_ > 0) {
+ if in == out && (*VP8LTransform)(unsafe.Pointer(transform)).bits_ > 0 {
// Move packed pixels to the end of unpacked region, so that unpacking
// can occur seamlessly.
// Also, note that this is the only transform that applies on
// the effective width of VP8LSubSampleSize(xsize_, bits_). All other
// transforms work on effective width of xsize_.
- var out_stride int32 = ((row_end - row_start) * width)
- var in_stride int32 = (int32((uint32_t(row_end - row_start)) * VP8LSubSampleSize(tls, uint32((*VP8LTransform)(unsafe.Pointer(transform)).xsize_), uint32((*VP8LTransform)(unsafe.Pointer(transform)).bits_))))
- var src uintptr = ((out + uintptr(out_stride)*4) - uintptr(in_stride)*4)
- libc.Xmemmove(tls, src, out, (uint64(in_stride) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ var out_stride int32 = (row_end - row_start) * width
+ var in_stride int32 = int32(uint32_t(row_end-row_start) * VP8LSubSampleSize(tls, uint32((*VP8LTransform)(unsafe.Pointer(transform)).xsize_), uint32((*VP8LTransform)(unsafe.Pointer(transform)).bits_)))
+ var src uintptr = out + uintptr(out_stride)*4 - uintptr(in_stride)*4
+ libc.Xmemmove(tls, src, out, uint64(in_stride)*uint64(unsafe.Sizeof(uint32_t(0))))
ColorIndexInverseTransform_C(tls, transform, row_start, row_end, src, out)
} else {
ColorIndexInverseTransform_C(tls, transform, row_start, row_end, in, out)
@@ -18671,7 +18411,7 @@ func VP8LInverseTransform(tls *libc.TLS, transform uintptr, row_start int32, row
// Color space conversion.
func is_big_endian(tls *libc.TLS) int32 { /* lossless.c:436:12: */
- return (libc.Bool32(int32(*(*uint8_t)(unsafe.Pointer((uintptr(unsafe.Pointer(&tmp)) /* &.b */)))) != 1))
+ return libc.Bool32(int32(*(*uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&tmp))))) != 1)
}
var tmp = func() (r struct{ w uint16_t }) {
@@ -18680,68 +18420,68 @@ var tmp = func() (r struct{ w uint16_t }) {
}() /* lossless.c:440:5 */
func VP8LConvertBGRAToRGB_C(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr) { /* lossless.c:444:6: */
- var src_end uintptr = (src + uintptr(num_pixels)*4)
+ var src_end uintptr = src + uintptr(num_pixels)*4
for src < src_end {
var argb uint32_t = *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&src, 4)))
- *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = (uint8_t((argb >> 16) & uint32_t(0xff)))
- *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = (uint8_t((argb >> 8) & uint32_t(0xff)))
- *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = (uint8_t((argb >> 0) & uint32_t(0xff)))
+ *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = uint8_t(argb >> 16 & uint32_t(0xff))
+ *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = uint8_t(argb >> 8 & uint32_t(0xff))
+ *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = uint8_t(argb >> 0 & uint32_t(0xff))
}
}
func VP8LConvertBGRAToRGBA_C(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr) { /* lossless.c:455:6: */
- var src_end uintptr = (src + uintptr(num_pixels)*4)
+ var src_end uintptr = src + uintptr(num_pixels)*4
for src < src_end {
var argb uint32_t = *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&src, 4)))
- *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = (uint8_t((argb >> 16) & uint32_t(0xff)))
- *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = (uint8_t((argb >> 8) & uint32_t(0xff)))
- *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = (uint8_t((argb >> 0) & uint32_t(0xff)))
- *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = (uint8_t((argb >> 24) & uint32_t(0xff)))
+ *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = uint8_t(argb >> 16 & uint32_t(0xff))
+ *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = uint8_t(argb >> 8 & uint32_t(0xff))
+ *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = uint8_t(argb >> 0 & uint32_t(0xff))
+ *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = uint8_t(argb >> 24 & uint32_t(0xff))
}
}
func VP8LConvertBGRAToRGBA4444_C(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr) { /* lossless.c:467:6: */
- var src_end uintptr = (src + uintptr(num_pixels)*4)
+ var src_end uintptr = src + uintptr(num_pixels)*4
for src < src_end {
var argb uint32_t = *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&src, 4)))
- var rg uint8_t = (uint8_t(((argb >> 16) & uint32_t(0xf0)) | ((argb >> 12) & uint32_t(0xf))))
- var ba uint8_t = (uint8_t(((argb >> 0) & uint32_t(0xf0)) | ((argb >> 28) & uint32_t(0xf))))
+ var rg uint8_t = uint8_t(argb>>16&uint32_t(0xf0) | argb>>12&uint32_t(0xf))
+ var ba uint8_t = uint8_t(argb>>0&uint32_t(0xf0) | argb>>28&uint32_t(0xf))
*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = rg
*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = ba
}
}
func VP8LConvertBGRAToRGB565_C(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr) { /* lossless.c:484:6: */
- var src_end uintptr = (src + uintptr(num_pixels)*4)
+ var src_end uintptr = src + uintptr(num_pixels)*4
for src < src_end {
var argb uint32_t = *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&src, 4)))
- var rg uint8_t = (uint8_t(((argb >> 16) & uint32_t(0xf8)) | ((argb >> 13) & uint32_t(0x7))))
- var gb uint8_t = (uint8_t(((argb >> 5) & uint32_t(0xe0)) | ((argb >> 3) & uint32_t(0x1f))))
+ var rg uint8_t = uint8_t(argb>>16&uint32_t(0xf8) | argb>>13&uint32_t(0x7))
+ var gb uint8_t = uint8_t(argb>>5&uint32_t(0xe0) | argb>>3&uint32_t(0x1f))
*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = rg
*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = gb
}
}
func VP8LConvertBGRAToBGR_C(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr) { /* lossless.c:501:6: */
- var src_end uintptr = (src + uintptr(num_pixels)*4)
+ var src_end uintptr = src + uintptr(num_pixels)*4
for src < src_end {
var argb uint32_t = *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&src, 4)))
- *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = (uint8_t((argb >> 0) & uint32_t(0xff)))
- *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = (uint8_t((argb >> 8) & uint32_t(0xff)))
- *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = (uint8_t((argb >> 16) & uint32_t(0xff)))
+ *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = uint8_t(argb >> 0 & uint32_t(0xff))
+ *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = uint8_t(argb >> 8 & uint32_t(0xff))
+ *(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&dst, 1))) = uint8_t(argb >> 16 & uint32_t(0xff))
}
}
func CopyOrSwap(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr, swap_on_big_endian int32) { /* lossless.c:512:13: */
if is_big_endian(tls) == swap_on_big_endian {
- var src_end uintptr = (src + uintptr(num_pixels)*4)
+ var src_end uintptr = src + uintptr(num_pixels)*4
for src < src_end {
var argb uint32_t = *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&src, 4)))
WebPUint32ToMem(tls, dst, BSwap32(tls, argb))
dst += uintptr(unsafe.Sizeof(argb))
}
} else {
- libc.Xmemcpy(tls, dst, src, (uint64(num_pixels) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, dst, src, uint64(num_pixels)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
@@ -18832,7 +18572,7 @@ var VP8LMapColor32b VP8LMapARGBFunc /* lossless.c:588:17: */
var VP8LMapColor8b VP8LMapAlphaFunc /* lossless.c:589:18: */
func VP8LDspInit(tls *libc.TLS) { /* lossless.c:616:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if VP8LDspInit_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -18844,153 +18584,153 @@ func VP8LDspInit(tls *libc.TLS) { /* lossless.c:616:1: */
var VP8LDspInit_body_last_cpuinfo_used VP8CPUInfo = 0 /* lossless.c:616:1 */
func VP8LDspInit_body(tls *libc.TLS) { /* lossless.c:616:1: */
- for ok := true; ok; ok = (0 != 0) {
- (VP8LPredictors)[0] = *(*uintptr)(unsafe.Pointer(&struct {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
+ VP8LPredictors[0] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor0_C}))
- (VP8LPredictors)[1] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[1] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor1_C}))
- (VP8LPredictors)[2] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[2] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor2_C}))
- (VP8LPredictors)[3] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[3] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor3_C}))
- (VP8LPredictors)[4] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[4] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor4_C}))
- (VP8LPredictors)[5] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[5] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor5_C}))
- (VP8LPredictors)[6] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[6] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor6_C}))
- (VP8LPredictors)[7] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[7] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor7_C}))
- (VP8LPredictors)[8] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[8] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor8_C}))
- (VP8LPredictors)[9] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[9] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor9_C}))
- (VP8LPredictors)[10] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[10] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor10_C}))
- (VP8LPredictors)[11] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[11] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor11_C}))
- (VP8LPredictors)[12] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[12] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor12_C}))
- (VP8LPredictors)[13] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[13] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor13_C}))
- (VP8LPredictors)[14] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[14] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor0_C})) /* <- padding security sentinels*/
- (VP8LPredictors)[15] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictors[15] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
}{VP8LPredictor0_C}))
}
- for ok1 := true; ok1; ok1 = (0 != 0) {
- (VP8LPredictorsAdd)[0] = *(*uintptr)(unsafe.Pointer(&struct {
+ for __ccgo1 := true; __ccgo1; __ccgo1 = 0 != 0 {
+ VP8LPredictorsAdd[0] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd0_C}))
- (VP8LPredictorsAdd)[1] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[1] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd1_C}))
- (VP8LPredictorsAdd)[2] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[2] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd2_C}))
- (VP8LPredictorsAdd)[3] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[3] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd3_C}))
- (VP8LPredictorsAdd)[4] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[4] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd4_C}))
- (VP8LPredictorsAdd)[5] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[5] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd5_C}))
- (VP8LPredictorsAdd)[6] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[6] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd6_C}))
- (VP8LPredictorsAdd)[7] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[7] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd7_C}))
- (VP8LPredictorsAdd)[8] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[8] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd8_C}))
- (VP8LPredictorsAdd)[9] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[9] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd9_C}))
- (VP8LPredictorsAdd)[10] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[10] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd10_C}))
- (VP8LPredictorsAdd)[11] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[11] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd11_C}))
- (VP8LPredictorsAdd)[12] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[12] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd12_C}))
- (VP8LPredictorsAdd)[13] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[13] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd13_C}))
- (VP8LPredictorsAdd)[14] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[14] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd0_C})) /* <- padding security sentinels*/
- (VP8LPredictorsAdd)[15] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd[15] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd0_C}))
}
- for ok2 := true; ok2; ok2 = (0 != 0) {
- (VP8LPredictorsAdd_C)[0] = *(*uintptr)(unsafe.Pointer(&struct {
+ for __ccgo2 := true; __ccgo2; __ccgo2 = 0 != 0 {
+ VP8LPredictorsAdd_C[0] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd0_C}))
- (VP8LPredictorsAdd_C)[1] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[1] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd1_C}))
- (VP8LPredictorsAdd_C)[2] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[2] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd2_C}))
- (VP8LPredictorsAdd_C)[3] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[3] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd3_C}))
- (VP8LPredictorsAdd_C)[4] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[4] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd4_C}))
- (VP8LPredictorsAdd_C)[5] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[5] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd5_C}))
- (VP8LPredictorsAdd_C)[6] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[6] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd6_C}))
- (VP8LPredictorsAdd_C)[7] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[7] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd7_C}))
- (VP8LPredictorsAdd_C)[8] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[8] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd8_C}))
- (VP8LPredictorsAdd_C)[9] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[9] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd9_C}))
- (VP8LPredictorsAdd_C)[10] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[10] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd10_C}))
- (VP8LPredictorsAdd_C)[11] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[11] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd11_C}))
- (VP8LPredictorsAdd_C)[12] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[12] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd12_C}))
- (VP8LPredictorsAdd_C)[13] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[13] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd13_C}))
- (VP8LPredictorsAdd_C)[14] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[14] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd0_C})) /* <- padding security sentinels*/
- (VP8LPredictorsAdd_C)[15] = *(*uintptr)(unsafe.Pointer(&struct {
+ VP8LPredictorsAdd_C[15] = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
}{PredictorAdd0_C}))
}
@@ -19028,7 +18768,7 @@ func VP8LDspInit_body(tls *libc.TLS) { /* lossless.c:616:1: */
}{MapAlpha_C}))
// If defined, use CPUInfo() to overwrite some pointers with faster versions.
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -19235,70 +18975,70 @@ var kSLog2Table = [256]float32{
} /* lossless_enc.c:159:13 */
var kPrefixEncodeCode = [512]VP8LPrefixCode{
- VP8LPrefixCode{}, VP8LPrefixCode{}, VP8LPrefixCode{code_: int8(1)}, VP8LPrefixCode{code_: int8(2)}, VP8LPrefixCode{code_: int8(3)}, VP8LPrefixCode{code_: int8(4), extra_bits_: int8(1)}, VP8LPrefixCode{code_: int8(4), extra_bits_: int8(1)}, VP8LPrefixCode{code_: int8(5), extra_bits_: int8(1)},
- VP8LPrefixCode{code_: int8(5), extra_bits_: int8(1)}, VP8LPrefixCode{code_: int8(6), extra_bits_: int8(2)}, VP8LPrefixCode{code_: int8(6), extra_bits_: int8(2)}, VP8LPrefixCode{code_: int8(6), extra_bits_: int8(2)}, VP8LPrefixCode{code_: int8(6), extra_bits_: int8(2)}, VP8LPrefixCode{code_: int8(7), extra_bits_: int8(2)}, VP8LPrefixCode{code_: int8(7), extra_bits_: int8(2)}, VP8LPrefixCode{code_: int8(7), extra_bits_: int8(2)},
- VP8LPrefixCode{code_: int8(7), extra_bits_: int8(2)}, VP8LPrefixCode{code_: int8(8), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(8), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(8), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(8), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(8), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(8), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(8), extra_bits_: int8(3)},
- VP8LPrefixCode{code_: int8(8), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(9), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(9), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(9), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(9), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(9), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(9), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(9), extra_bits_: int8(3)},
- VP8LPrefixCode{code_: int8(9), extra_bits_: int8(3)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)},
- VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)},
- VP8LPrefixCode{code_: int8(10), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)},
- VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)},
- VP8LPrefixCode{code_: int8(11), extra_bits_: int8(4)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)},
- VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)},
- VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)},
- VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)},
- VP8LPrefixCode{code_: int8(12), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)},
- VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)},
- VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)},
- VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)},
- VP8LPrefixCode{code_: int8(13), extra_bits_: int8(5)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(14), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)},
- VP8LPrefixCode{code_: int8(15), extra_bits_: int8(6)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(16), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
- VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)}, VP8LPrefixCode{code_: int8(17), extra_bits_: int8(7)},
+ {}, {}, {code_: int8(1)}, {code_: int8(2)}, {code_: int8(3)}, {code_: int8(4), extra_bits_: int8(1)}, {code_: int8(4), extra_bits_: int8(1)}, {code_: int8(5), extra_bits_: int8(1)},
+ {code_: int8(5), extra_bits_: int8(1)}, {code_: int8(6), extra_bits_: int8(2)}, {code_: int8(6), extra_bits_: int8(2)}, {code_: int8(6), extra_bits_: int8(2)}, {code_: int8(6), extra_bits_: int8(2)}, {code_: int8(7), extra_bits_: int8(2)}, {code_: int8(7), extra_bits_: int8(2)}, {code_: int8(7), extra_bits_: int8(2)},
+ {code_: int8(7), extra_bits_: int8(2)}, {code_: int8(8), extra_bits_: int8(3)}, {code_: int8(8), extra_bits_: int8(3)}, {code_: int8(8), extra_bits_: int8(3)}, {code_: int8(8), extra_bits_: int8(3)}, {code_: int8(8), extra_bits_: int8(3)}, {code_: int8(8), extra_bits_: int8(3)}, {code_: int8(8), extra_bits_: int8(3)},
+ {code_: int8(8), extra_bits_: int8(3)}, {code_: int8(9), extra_bits_: int8(3)}, {code_: int8(9), extra_bits_: int8(3)}, {code_: int8(9), extra_bits_: int8(3)}, {code_: int8(9), extra_bits_: int8(3)}, {code_: int8(9), extra_bits_: int8(3)}, {code_: int8(9), extra_bits_: int8(3)}, {code_: int8(9), extra_bits_: int8(3)},
+ {code_: int8(9), extra_bits_: int8(3)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)},
+ {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(10), extra_bits_: int8(4)},
+ {code_: int8(10), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)},
+ {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(11), extra_bits_: int8(4)},
+ {code_: int8(11), extra_bits_: int8(4)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)},
+ {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)},
+ {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)},
+ {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(12), extra_bits_: int8(5)},
+ {code_: int8(12), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)},
+ {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)},
+ {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)},
+ {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(13), extra_bits_: int8(5)},
+ {code_: int8(13), extra_bits_: int8(5)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)},
+ {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)},
+ {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)},
+ {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)},
+ {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)},
+ {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)},
+ {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)},
+ {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(14), extra_bits_: int8(6)},
+ {code_: int8(14), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)},
+ {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)},
+ {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)},
+ {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)},
+ {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)},
+ {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)},
+ {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)},
+ {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(15), extra_bits_: int8(6)},
+ {code_: int8(15), extra_bits_: int8(6)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(16), extra_bits_: int8(7)},
+ {code_: int8(16), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
+ {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)}, {code_: int8(17), extra_bits_: int8(7)},
} /* lossless_enc.c:226:22 */
var kPrefixEncodeExtraBitsValue = [512]uint8_t{
@@ -19341,8 +19081,8 @@ func FastSLog2Slow_C(tls *libc.TLS, v uint32_t) float32 { /* lossless_enc.c:329:
if v < uint32_t(65536) {
// use clz if available
- var log_cnt int32 = (BitsLog2Floor(tls, v) - 7)
- var y uint32_t = (uint32_t(int32(1) << log_cnt))
+ var log_cnt int32 = BitsLog2Floor(tls, v) - 7
+ var y uint32_t = uint32_t(int32(1) << log_cnt)
var correction int32 = 0
var v_f float32 = float32(v)
var orig_v uint32_t = v
@@ -19353,10 +19093,10 @@ func FastSLog2Slow_C(tls *libc.TLS, v uint32_t) float32 { /* lossless_enc.c:329:
// The correction factor: log(1 + d) ~ d; for very small d values, so
// log2(1 + (v % y) / v) ~ LOG_2_RECIPROCAL * (v % y)/v
// LOG_2_RECIPROCAL ~ 23/16
- correction = (int32((uint32_t(23) * (orig_v & (y - uint32_t(1)))) >> 4))
- return ((v_f * (kLog2Table[v] + float32(log_cnt))) + float32(correction))
+ correction = int32(uint32_t(23) * (orig_v & (y - uint32_t(1))) >> 4)
+ return v_f*(kLog2Table[v]+float32(log_cnt)) + float32(correction)
} else {
- return (float32((1.44269504088896338700465094007086 * float64(v)) * libc.Xlog(tls, float64(v))))
+ return float32(1.44269504088896338700465094007086 * float64(v) * libc.Xlog(tls, float64(v)))
}
return float32(0)
}
@@ -19365,21 +19105,21 @@ func FastLog2Slow_C(tls *libc.TLS, v uint32_t) float32 { /* lossless_enc.c:365:1
if v < uint32_t(65536) {
// use clz if available
- var log_cnt int32 = (BitsLog2Floor(tls, v) - 7)
- var y uint32_t = (uint32_t(int32(1) << log_cnt))
+ var log_cnt int32 = BitsLog2Floor(tls, v) - 7
+ var y uint32_t = uint32_t(int32(1) << log_cnt)
var orig_v uint32_t = v
var log_2 float64
v >>= log_cnt
- log_2 = (float64(kLog2Table[v] + float32(log_cnt)))
+ log_2 = float64(kLog2Table[v] + float32(log_cnt))
if orig_v >= uint32_t(4096) {
// Since the division is still expensive, add this correction factor only
// for large values of 'v'.
- var correction int32 = (int32((uint32_t(23) * (orig_v & (y - uint32_t(1)))) >> 4))
- log_2 = log_2 + (float64(correction) / float64(orig_v))
+ var correction int32 = int32(uint32_t(23) * (orig_v & (y - uint32_t(1))) >> 4)
+ log_2 = log_2 + float64(correction)/float64(orig_v)
}
return float32(log_2)
} else {
- return (float32(1.44269504088896338700465094007086 * libc.Xlog(tls, float64(v))))
+ return float32(1.44269504088896338700465094007086 * libc.Xlog(tls, float64(v)))
}
return float32(0)
}
@@ -19396,17 +19136,17 @@ func CombinedShannonEntropy_C(tls *libc.TLS, X uintptr, Y uintptr) float32 { /*
for i = 0; i < 256; i++ {
var x int32 = *(*int32)(unsafe.Pointer(X + uintptr(i)*4))
if x != 0 {
- var xy int32 = (x + *(*int32)(unsafe.Pointer(Y + uintptr(i)*4)))
- sumX = sumX + (x)
- retval = retval - (float64(VP8LFastSLog2(tls, uint32(x))))
- sumXY = sumXY + (xy)
- retval = retval - (float64(VP8LFastSLog2(tls, uint32(xy))))
+ var xy int32 = x + *(*int32)(unsafe.Pointer(Y + uintptr(i)*4))
+ sumX = sumX + x
+ retval = retval - float64(VP8LFastSLog2(tls, uint32(x)))
+ sumXY = sumXY + xy
+ retval = retval - float64(VP8LFastSLog2(tls, uint32(xy)))
} else if *(*int32)(unsafe.Pointer(Y + uintptr(i)*4)) != 0 {
- sumXY = sumXY + (*(*int32)(unsafe.Pointer(Y + uintptr(i)*4)))
- retval = retval - (float64(VP8LFastSLog2(tls, uint32(*(*int32)(unsafe.Pointer(Y + uintptr(i)*4))))))
+ sumXY = sumXY + *(*int32)(unsafe.Pointer(Y + uintptr(i)*4))
+ retval = retval - float64(VP8LFastSLog2(tls, uint32(*(*int32)(unsafe.Pointer(Y + uintptr(i)*4)))))
}
}
- retval = retval + (float64(VP8LFastSLog2(tls, uint32(sumX)) + VP8LFastSLog2(tls, uint32(sumXY))))
+ retval = retval + float64(VP8LFastSLog2(tls, uint32(sumX))+VP8LFastSLog2(tls, uint32(sumXY)))
return float32(retval)
}
@@ -19415,7 +19155,7 @@ func VP8LBitEntropyInit(tls *libc.TLS, entropy uintptr) { /* lossless_enc.c:424:
(*VP8LBitEntropy)(unsafe.Pointer(entropy)).sum = uint32_t(0)
(*VP8LBitEntropy)(unsafe.Pointer(entropy)).nonzeros = 0
(*VP8LBitEntropy)(unsafe.Pointer(entropy)).max_val = uint32_t(0)
- (*VP8LBitEntropy)(unsafe.Pointer(entropy)).nonzero_code = (0xffffffff)
+ (*VP8LBitEntropy)(unsafe.Pointer(entropy)).nonzero_code = 0xffffffff
}
func VP8LBitsEntropyUnrefined(tls *libc.TLS, array uintptr, n int32, entropy uintptr) { /* lossless_enc.c:432:6: */
@@ -19425,35 +19165,35 @@ func VP8LBitsEntropyUnrefined(tls *libc.TLS, array uintptr, n int32, entropy uin
for i = 0; i < n; i++ {
if *(*uint32_t)(unsafe.Pointer(array + uintptr(i)*4)) != uint32_t(0) {
- *(*uint32_t)(unsafe.Pointer((entropy + 8 /* &.sum */))) += (*(*uint32_t)(unsafe.Pointer(array + uintptr(i)*4)))
+ *(*uint32_t)(unsafe.Pointer(entropy + 8)) += *(*uint32_t)(unsafe.Pointer(array + uintptr(i)*4))
(*VP8LBitEntropy)(unsafe.Pointer(entropy)).nonzero_code = uint32_t(i)
(*VP8LBitEntropy)(unsafe.Pointer(entropy)).nonzeros++
- *(*float64)(unsafe.Pointer((entropy /* &.entropy */))) -= (float64(VP8LFastSLog2(tls, *(*uint32_t)(unsafe.Pointer(array + uintptr(i)*4)))))
+ *(*float64)(unsafe.Pointer(entropy)) -= float64(VP8LFastSLog2(tls, *(*uint32_t)(unsafe.Pointer(array + uintptr(i)*4))))
if (*VP8LBitEntropy)(unsafe.Pointer(entropy)).max_val < *(*uint32_t)(unsafe.Pointer(array + uintptr(i)*4)) {
(*VP8LBitEntropy)(unsafe.Pointer(entropy)).max_val = *(*uint32_t)(unsafe.Pointer(array + uintptr(i)*4))
}
}
}
- *(*float64)(unsafe.Pointer((entropy /* &.entropy */))) += (float64(VP8LFastSLog2(tls, (*VP8LBitEntropy)(unsafe.Pointer(entropy)).sum)))
+ *(*float64)(unsafe.Pointer(entropy)) += float64(VP8LFastSLog2(tls, (*VP8LBitEntropy)(unsafe.Pointer(entropy)).sum))
}
func GetEntropyUnrefinedHelper(tls *libc.TLS, val uint32_t, i int32, val_prev uintptr, i_prev uintptr, bit_entropy uintptr, stats uintptr) { /* lossless_enc.c:452:25: */
- var streak int32 = (i - *(*int32)(unsafe.Pointer(i_prev)))
+ var streak int32 = i - *(*int32)(unsafe.Pointer(i_prev))
// Gather info for the bit entropy.
if *(*uint32_t)(unsafe.Pointer(val_prev)) != uint32_t(0) {
- *(*uint32_t)(unsafe.Pointer((bit_entropy + 8 /* &.sum */))) += ((*(*uint32_t)(unsafe.Pointer(val_prev))) * uint32_t(streak))
- *(*int32)(unsafe.Pointer((bit_entropy + 12 /* &.nonzeros */))) += (streak)
+ *(*uint32_t)(unsafe.Pointer(bit_entropy + 8)) += *(*uint32_t)(unsafe.Pointer(val_prev)) * uint32_t(streak)
+ *(*int32)(unsafe.Pointer(bit_entropy + 12)) += streak
(*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).nonzero_code = uint32_t(*(*int32)(unsafe.Pointer(i_prev)))
- *(*float64)(unsafe.Pointer((bit_entropy /* &.entropy */))) -= (float64(VP8LFastSLog2(tls, *(*uint32_t)(unsafe.Pointer(val_prev))) * float32(streak)))
+ *(*float64)(unsafe.Pointer(bit_entropy)) -= float64(VP8LFastSLog2(tls, *(*uint32_t)(unsafe.Pointer(val_prev))) * float32(streak))
if (*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).max_val < *(*uint32_t)(unsafe.Pointer(val_prev)) {
(*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).max_val = *(*uint32_t)(unsafe.Pointer(val_prev))
}
}
// Gather info for the Huffman cost.
- *(*int32)(unsafe.Pointer(((stats /* &.counts */) + uintptr((libc.Bool32(*(*uint32_t)(unsafe.Pointer(val_prev)) != uint32_t(0))))*4))) += (libc.Bool32(streak > 3))
- *(*int32)(unsafe.Pointer((((stats + 8 /* &.streaks */) + uintptr((libc.Bool32(*(*uint32_t)(unsafe.Pointer(val_prev)) != uint32_t(0))))*8) + uintptr((libc.Bool32(streak > 3)))*4))) += (streak)
+ *(*int32)(unsafe.Pointer(stats + uintptr(libc.Bool32(*(*uint32_t)(unsafe.Pointer(val_prev)) != uint32_t(0)))*4)) += libc.Bool32(streak > 3)
+ *(*int32)(unsafe.Pointer(stats + 8 + uintptr(libc.Bool32(*(*uint32_t)(unsafe.Pointer(val_prev)) != uint32_t(0)))*8 + uintptr(libc.Bool32(streak > 3))*4)) += streak
*(*uint32_t)(unsafe.Pointer(val_prev)) = val
*(*int32)(unsafe.Pointer(i_prev)) = i
@@ -19472,13 +19212,13 @@ func GetEntropyUnrefined_C(tls *libc.TLS, X uintptr, length int32, bit_entropy u
for i = 1; i < length; i++ {
var x uint32_t = *(*uint32_t)(unsafe.Pointer(X + uintptr(i)*4))
- if x != *(*uint32_t)(unsafe.Pointer(bp /* x_prev */)) {
- GetEntropyUnrefinedHelper(tls, x, i, (bp) /* &x_prev */, (bp + 4) /* &i_prev */, bit_entropy, stats)
+ if x != *(*uint32_t)(unsafe.Pointer(bp)) {
+ GetEntropyUnrefinedHelper(tls, x, i, bp, bp+4, bit_entropy, stats)
}
}
- GetEntropyUnrefinedHelper(tls, uint32(0), i, (bp) /* &x_prev */, (bp + 4) /* &i_prev */, bit_entropy, stats)
+ GetEntropyUnrefinedHelper(tls, uint32(0), i, bp, bp+4, bit_entropy, stats)
- *(*float64)(unsafe.Pointer((bit_entropy /* &.entropy */))) += (float64(VP8LFastSLog2(tls, (*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).sum)))
+ *(*float64)(unsafe.Pointer(bit_entropy)) += float64(VP8LFastSLog2(tls, (*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).sum))
}
func GetCombinedEntropyUnrefined_C(tls *libc.TLS, X uintptr, Y uintptr, length int32, bit_entropy uintptr, stats uintptr) { /* lossless_enc.c:497:13: */
@@ -19487,20 +19227,20 @@ func GetCombinedEntropyUnrefined_C(tls *libc.TLS, X uintptr, Y uintptr, length i
var i int32 = 1
*(*int32)(unsafe.Pointer(bp + 4 /* i_prev */)) = 0
- *(*uint32_t)(unsafe.Pointer(bp /* xy_prev */)) = (*(*uint32_t)(unsafe.Pointer(X)) + *(*uint32_t)(unsafe.Pointer(Y)))
+ *(*uint32_t)(unsafe.Pointer(bp /* xy_prev */)) = *(*uint32_t)(unsafe.Pointer(X)) + *(*uint32_t)(unsafe.Pointer(Y))
libc.Xmemset(tls, stats, 0, uint64(unsafe.Sizeof(VP8LStreaks{})))
VP8LBitEntropyInit(tls, bit_entropy)
for i = 1; i < length; i++ {
- var xy uint32_t = (*(*uint32_t)(unsafe.Pointer(X + uintptr(i)*4)) + *(*uint32_t)(unsafe.Pointer(Y + uintptr(i)*4)))
- if xy != *(*uint32_t)(unsafe.Pointer(bp /* xy_prev */)) {
- GetEntropyUnrefinedHelper(tls, xy, i, (bp) /* &xy_prev */, (bp + 4) /* &i_prev */, bit_entropy, stats)
+ var xy uint32_t = *(*uint32_t)(unsafe.Pointer(X + uintptr(i)*4)) + *(*uint32_t)(unsafe.Pointer(Y + uintptr(i)*4))
+ if xy != *(*uint32_t)(unsafe.Pointer(bp)) {
+ GetEntropyUnrefinedHelper(tls, xy, i, bp, bp+4, bit_entropy, stats)
}
}
- GetEntropyUnrefinedHelper(tls, uint32(0), i, (bp) /* &xy_prev */, (bp + 4) /* &i_prev */, bit_entropy, stats)
+ GetEntropyUnrefinedHelper(tls, uint32(0), i, bp, bp+4, bit_entropy, stats)
- *(*float64)(unsafe.Pointer((bit_entropy /* &.entropy */))) += (float64(VP8LFastSLog2(tls, (*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).sum)))
+ *(*float64)(unsafe.Pointer(bit_entropy)) += float64(VP8LFastSLog2(tls, (*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).sum))
}
//------------------------------------------------------------------------------
@@ -19509,52 +19249,52 @@ func VP8LSubtractGreenFromBlueAndRed_C(tls *libc.TLS, argb_data uintptr, num_pix
var i int32
for i = 0; i < num_pixels; i++ {
var argb int32 = int32(*(*uint32_t)(unsafe.Pointer(argb_data + uintptr(i)*4)))
- var green int32 = ((argb >> 8) & 0xff)
- var new_r uint32_t = (uint32_t((((argb >> 16) & 0xff) - green) & 0xff))
- var new_b uint32_t = (uint32_t((((argb >> 0) & 0xff) - green) & 0xff))
- *(*uint32_t)(unsafe.Pointer(argb_data + uintptr(i)*4)) = (((uint32(argb) & 0xff00ff00) | (new_r << 16)) | new_b)
+ var green int32 = argb >> 8 & 0xff
+ var new_r uint32_t = uint32_t((argb>>16&0xff - green) & 0xff)
+ var new_b uint32_t = uint32_t((argb>>0&0xff - green) & 0xff)
+ *(*uint32_t)(unsafe.Pointer(argb_data + uintptr(i)*4)) = uint32(argb)&0xff00ff00 | new_r<<16 | new_b
}
}
func ColorTransformDelta1(tls *libc.TLS, color_pred int8_t, color int8_t) int32 { /* lossless_enc.c:533:24: */
- return ((int32(color_pred) * int32(color)) >> 5)
+ return int32(color_pred) * int32(color) >> 5
}
func U32ToS8(tls *libc.TLS, v uint32_t) int8_t { /* lossless_enc.c:537:27: */
- return (int8_t(v & uint32_t(0xff)))
+ return int8_t(v & uint32_t(0xff))
}
func VP8LTransformColor_C(tls *libc.TLS, m uintptr, data uintptr, num_pixels int32) { /* lossless_enc.c:541:6: */
var i int32
for i = 0; i < num_pixels; i++ {
var argb uint32_t = *(*uint32_t)(unsafe.Pointer(data + uintptr(i)*4))
- var green int8_t = U32ToS8(tls, (argb >> 8))
- var red int8_t = U32ToS8(tls, (argb >> 16))
- var new_red int32 = (int32(red) & 0xff)
- var new_blue int32 = (int32(argb & uint32_t(0xff)))
- new_red = new_red - (ColorTransformDelta1(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_red_), green))
- new_red = new_red & (0xff)
- new_blue = new_blue - (ColorTransformDelta1(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_blue_), green))
- new_blue = new_blue - (ColorTransformDelta1(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).red_to_blue_), red))
- new_blue = new_blue & (0xff)
- *(*uint32_t)(unsafe.Pointer(data + uintptr(i)*4)) = (((argb & 0xff00ff00) | (uint32_t(new_red << 16))) | (uint32_t(new_blue)))
+ var green int8_t = U32ToS8(tls, argb>>8)
+ var red int8_t = U32ToS8(tls, argb>>16)
+ var new_red int32 = int32(red) & 0xff
+ var new_blue int32 = int32(argb & uint32_t(0xff))
+ new_red = new_red - ColorTransformDelta1(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_red_), green)
+ new_red = new_red & 0xff
+ new_blue = new_blue - ColorTransformDelta1(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_blue_), green)
+ new_blue = new_blue - ColorTransformDelta1(tls, int8((*VP8LMultipliers)(unsafe.Pointer(m)).red_to_blue_), red)
+ new_blue = new_blue & 0xff
+ *(*uint32_t)(unsafe.Pointer(data + uintptr(i)*4)) = argb&0xff00ff00 | uint32_t(new_red<<16) | uint32_t(new_blue)
}
}
func TransformColorRed(tls *libc.TLS, green_to_red uint8_t, argb uint32_t) uint8_t { /* lossless_enc.c:559:28: */
- var green int8_t = U32ToS8(tls, (argb >> 8))
- var new_red int32 = (int32(argb >> 16))
- new_red = new_red - (ColorTransformDelta1(tls, int8(green_to_red), green))
- return (uint8_t(new_red & 0xff))
+ var green int8_t = U32ToS8(tls, argb>>8)
+ var new_red int32 = int32(argb >> 16)
+ new_red = new_red - ColorTransformDelta1(tls, int8(green_to_red), green)
+ return uint8_t(new_red & 0xff)
}
func TransformColorBlue(tls *libc.TLS, green_to_blue uint8_t, red_to_blue uint8_t, argb uint32_t) uint8_t { /* lossless_enc.c:567:28: */
- var green int8_t = U32ToS8(tls, (argb >> 8))
- var red int8_t = U32ToS8(tls, (argb >> 16))
- var new_blue uint8_t = (uint8_t(argb & uint32_t(0xff)))
- new_blue = uint8_t(int32(new_blue) - (ColorTransformDelta1(tls, int8(green_to_blue), green)))
- new_blue = uint8_t(int32(new_blue) - (ColorTransformDelta1(tls, int8(red_to_blue), red)))
- return (uint8_t(int32(new_blue) & 0xff))
+ var green int8_t = U32ToS8(tls, argb>>8)
+ var red int8_t = U32ToS8(tls, argb>>16)
+ var new_blue uint8_t = uint8_t(argb & uint32_t(0xff))
+ new_blue = uint8_t(int32(new_blue) - ColorTransformDelta1(tls, int8(green_to_blue), green))
+ new_blue = uint8_t(int32(new_blue) - ColorTransformDelta1(tls, int8(red_to_blue), red))
+ return uint8_t(int32(new_blue) & 0xff)
}
func VP8LCollectColorRedTransforms_C(tls *libc.TLS, argb uintptr, stride int32, tile_width int32, tile_height int32, green_to_red int32, histo uintptr) { /* lossless_enc.c:578:6: */
@@ -19563,7 +19303,7 @@ func VP8LCollectColorRedTransforms_C(tls *libc.TLS, argb uintptr, stride int32,
for x = 0; x < tile_width; x++ {
*(*int32)(unsafe.Pointer(histo + uintptr(TransformColorRed(tls, uint8_t(green_to_red), *(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4))))*4))++
}
- argb += 4 * (uintptr(stride))
+ argb += 4 * uintptr(stride)
}
}
@@ -19574,7 +19314,7 @@ func VP8LCollectColorBlueTransforms_C(tls *libc.TLS, argb uintptr, stride int32,
*(*int32)(unsafe.Pointer(histo + uintptr(TransformColorBlue(tls, uint8_t(green_to_blue), uint8_t(red_to_blue),
*(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4))))*4))++
}
- argb += 4 * (uintptr(stride))
+ argb += 4 * uintptr(stride)
}
}
@@ -19583,7 +19323,7 @@ func VP8LCollectColorBlueTransforms_C(tls *libc.TLS, argb uintptr, stride int32,
func VectorMismatch_C(tls *libc.TLS, array1 uintptr, array2 uintptr, length int32) int32 { /* lossless_enc.c:606:12: */
var match_len int32 = 0
- for (match_len < length) && (*(*uint32_t)(unsafe.Pointer(array1 + uintptr(match_len)*4)) == *(*uint32_t)(unsafe.Pointer(array2 + uintptr(match_len)*4))) {
+ for match_len < length && *(*uint32_t)(unsafe.Pointer(array1 + uintptr(match_len)*4)) == *(*uint32_t)(unsafe.Pointer(array2 + uintptr(match_len)*4)) {
match_len++
}
return match_len
@@ -19593,20 +19333,20 @@ func VectorMismatch_C(tls *libc.TLS, array1 uintptr, array2 uintptr, length int3
func VP8LBundleColorMap_C(tls *libc.TLS, row uintptr, width int32, xbits int32, dst uintptr) { /* lossless_enc.c:617:6: */
var x int32
if xbits > 0 {
- var bit_depth int32 = (int32(1) << (3 - xbits))
- var mask int32 = ((int32(1) << xbits) - 1)
+ var bit_depth int32 = int32(1) << (3 - xbits)
+ var mask int32 = int32(1)<<xbits - 1
var code uint32_t = 0xff000000
for x = 0; x < width; x++ {
- var xsub int32 = (x & mask)
+ var xsub int32 = x & mask
if xsub == 0 {
code = 0xff000000
}
- code = code | (uint32_t(int32(*(*uint8_t)(unsafe.Pointer(row + uintptr(x)))) << (8 + (bit_depth * xsub))))
- *(*uint32_t)(unsafe.Pointer(dst + uintptr((x>>xbits))*4)) = code
+ code = code | uint32_t(int32(*(*uint8_t)(unsafe.Pointer(row + uintptr(x))))<<(8+bit_depth*xsub))
+ *(*uint32_t)(unsafe.Pointer(dst + uintptr(x>>xbits)*4)) = code
}
} else {
for x = 0; x < width; x++ {
- *(*uint32_t)(unsafe.Pointer(dst + uintptr(x)*4)) = (0xff000000 | (uint32(int32(*(*uint8_t)(unsafe.Pointer(row + uintptr(x)))) << 8)))
+ *(*uint32_t)(unsafe.Pointer(dst + uintptr(x)*4)) = 0xff000000 | uint32(int32(*(*uint8_t)(unsafe.Pointer(row + uintptr(x))))<<8)
}
}
}
@@ -19616,8 +19356,8 @@ func VP8LBundleColorMap_C(tls *libc.TLS, row uintptr, width int32, xbits int32,
func ExtraCost_C(tls *libc.TLS, population uintptr, length int32) float64 { /* lossless_enc.c:639:15: */
var i int32
var cost float64 = 0.
- for i = 2; i < (length - 2); i++ {
- cost = cost + (float64((uint32_t(i >> 1)) * *(*uint32_t)(unsafe.Pointer(population + uintptr((i+2))*4))))
+ for i = 2; i < length-2; i++ {
+ cost = cost + float64(uint32_t(i>>1)**(*uint32_t)(unsafe.Pointer(population + uintptr(i+2)*4)))
}
return cost
}
@@ -19625,9 +19365,9 @@ func ExtraCost_C(tls *libc.TLS, population uintptr, length int32) float64 { /* l
func ExtraCostCombined_C(tls *libc.TLS, X uintptr, Y uintptr, length int32) float64 { /* lossless_enc.c:646:15: */
var i int32
var cost float64 = 0.
- for i = 2; i < (length - 2); i++ {
- var xy int32 = (int32(*(*uint32_t)(unsafe.Pointer(X + uintptr((i+2))*4)) + *(*uint32_t)(unsafe.Pointer(Y + uintptr((i+2))*4))))
- cost = cost + (float64((i >> 1) * xy))
+ for i = 2; i < length-2; i++ {
+ var xy int32 = int32(*(*uint32_t)(unsafe.Pointer(X + uintptr(i+2)*4)) + *(*uint32_t)(unsafe.Pointer(Y + uintptr(i+2)*4)))
+ cost = cost + float64(i>>1*xy)
}
return cost
}
@@ -19637,14 +19377,14 @@ func ExtraCostCombined_C(tls *libc.TLS, X uintptr, Y uintptr, length int32) floa
func AddVector_C(tls *libc.TLS, a uintptr, b uintptr, out uintptr, size int32) { /* lossless_enc.c:659:13: */
var i int32
for i = 0; i < size; i++ {
- *(*uint32_t)(unsafe.Pointer(out + uintptr(i)*4)) = (*(*uint32_t)(unsafe.Pointer(a + uintptr(i)*4)) + *(*uint32_t)(unsafe.Pointer(b + uintptr(i)*4)))
+ *(*uint32_t)(unsafe.Pointer(out + uintptr(i)*4)) = *(*uint32_t)(unsafe.Pointer(a + uintptr(i)*4)) + *(*uint32_t)(unsafe.Pointer(b + uintptr(i)*4))
}
}
func AddVectorEq_C(tls *libc.TLS, a uintptr, out uintptr, size int32) { /* lossless_enc.c:665:13: */
var i int32
for i = 0; i < size; i++ {
- *(*uint32_t)(unsafe.Pointer((out + uintptr(i)*4))) += (*(*uint32_t)(unsafe.Pointer(a + uintptr(i)*4)))
+ *(*uint32_t)(unsafe.Pointer(out + uintptr(i)*4)) += *(*uint32_t)(unsafe.Pointer(a + uintptr(i)*4))
}
}
@@ -19653,142 +19393,142 @@ func VP8LHistogramAdd(tls *libc.TLS, a uintptr, b uintptr, out uintptr) { /* los
var literal_size int32 = VP8LHistogramNumCodes(tls, (*VP8LHistogram)(unsafe.Pointer(a)).palette_code_bits_)
if b != out {
- for ok := true; ok; ok = (0 != 0) {
- if *(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */))) != 0 {
- if *(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */))) != 0 {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
+ if *(*uint8_t)(unsafe.Pointer(a + 3280)) != 0 {
+ if *(*uint8_t)(unsafe.Pointer(b + 3280)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVector})).f(tls, (*VP8LHistogram)(unsafe.Pointer(a)).literal_, (*VP8LHistogram)(unsafe.Pointer(b)).literal_, (*VP8LHistogram)(unsafe.Pointer(out)).literal_, (literal_size))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVector})).f(tls, (*VP8LHistogram)(unsafe.Pointer(a)).literal_, (*VP8LHistogram)(unsafe.Pointer(b)).literal_, (*VP8LHistogram)(unsafe.Pointer(out)).literal_, literal_size)
} else {
- libc.Xmemcpy(tls, ((*VP8LHistogram)(unsafe.Pointer(out)).literal_), ((*VP8LHistogram)(unsafe.Pointer(a)).literal_), ((uint64(literal_size)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, (*VP8LHistogram)(unsafe.Pointer(out)).literal_, (*VP8LHistogram)(unsafe.Pointer(a)).literal_, uint64(literal_size)*uint64(unsafe.Sizeof(uint32_t(0))))
}
- } else if *(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */))) != 0 {
- libc.Xmemcpy(tls, ((*VP8LHistogram)(unsafe.Pointer(out)).literal_), ((*VP8LHistogram)(unsafe.Pointer(b)).literal_), ((uint64(literal_size)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ } else if *(*uint8_t)(unsafe.Pointer(b + 3280)) != 0 {
+ libc.Xmemcpy(tls, (*VP8LHistogram)(unsafe.Pointer(out)).literal_, (*VP8LHistogram)(unsafe.Pointer(b)).literal_, uint64(literal_size)*uint64(unsafe.Sizeof(uint32_t(0))))
} else {
- libc.Xmemset(tls, ((*VP8LHistogram)(unsafe.Pointer(out)).literal_), 0, ((uint64(literal_size)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemset(tls, (*VP8LHistogram)(unsafe.Pointer(out)).literal_, 0, uint64(literal_size)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
- for ok1 := true; ok1; ok1 = (0 != 0) {
- if *(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 1)) != 0 {
- if *(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 1)) != 0 {
+ for __ccgo1 := true; __ccgo1; __ccgo1 = 0 != 0 {
+ if *(*uint8_t)(unsafe.Pointer(a + 3280 + 1)) != 0 {
+ if *(*uint8_t)(unsafe.Pointer(b + 3280 + 1)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVector})).f(tls, (a + 8 /* &.red_ */), (b + 8 /* &.red_ */), (out + 8 /* &.red_ */), (256))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVector})).f(tls, a+8 /* &.red_ */, b+8 /* &.red_ */, out+8 /* &.red_ */, 256)
} else {
- libc.Xmemcpy(tls, (out + 8 /* &.red_ */), (a + 8 /* &.red_ */), ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, out+8 /* &.red_ */, a+8 /* &.red_ */, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
}
- } else if *(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 1)) != 0 {
- libc.Xmemcpy(tls, (out + 8 /* &.red_ */), (b + 8 /* &.red_ */), ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ } else if *(*uint8_t)(unsafe.Pointer(b + 3280 /* &.is_used_ */ + 1)) != 0 {
+ libc.Xmemcpy(tls, out+8 /* &.red_ */, b+8 /* &.red_ */, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
} else {
- libc.Xmemset(tls, (out + 8 /* &.red_ */), 0, ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemset(tls, out+8 /* &.red_ */, 0, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
- for ok2 := true; ok2; ok2 = (0 != 0) {
- if *(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 2)) != 0 {
- if *(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 2)) != 0 {
+ for __ccgo2 := true; __ccgo2; __ccgo2 = 0 != 0 {
+ if *(*uint8_t)(unsafe.Pointer(a + 3280 + 2)) != 0 {
+ if *(*uint8_t)(unsafe.Pointer(b + 3280 + 2)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVector})).f(tls, (a + 1032 /* &.blue_ */), (b + 1032 /* &.blue_ */), (out + 1032 /* &.blue_ */), (256))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVector})).f(tls, a+1032 /* &.blue_ */, b+1032 /* &.blue_ */, out+1032 /* &.blue_ */, 256)
} else {
- libc.Xmemcpy(tls, (out + 1032 /* &.blue_ */), (a + 1032 /* &.blue_ */), ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, out+1032 /* &.blue_ */, a+1032 /* &.blue_ */, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
}
- } else if *(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 2)) != 0 {
- libc.Xmemcpy(tls, (out + 1032 /* &.blue_ */), (b + 1032 /* &.blue_ */), ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ } else if *(*uint8_t)(unsafe.Pointer(b + 3280 /* &.is_used_ */ + 2)) != 0 {
+ libc.Xmemcpy(tls, out+1032 /* &.blue_ */, b+1032 /* &.blue_ */, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
} else {
- libc.Xmemset(tls, (out + 1032 /* &.blue_ */), 0, ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemset(tls, out+1032 /* &.blue_ */, 0, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
- for ok3 := true; ok3; ok3 = (0 != 0) {
- if *(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 3)) != 0 {
- if *(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 3)) != 0 {
+ for __ccgo3 := true; __ccgo3; __ccgo3 = 0 != 0 {
+ if *(*uint8_t)(unsafe.Pointer(a + 3280 + 3)) != 0 {
+ if *(*uint8_t)(unsafe.Pointer(b + 3280 + 3)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVector})).f(tls, (a + 2056 /* &.alpha_ */), (b + 2056 /* &.alpha_ */), (out + 2056 /* &.alpha_ */), (256))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVector})).f(tls, a+2056 /* &.alpha_ */, b+2056 /* &.alpha_ */, out+2056 /* &.alpha_ */, 256)
} else {
- libc.Xmemcpy(tls, (out + 2056 /* &.alpha_ */), (a + 2056 /* &.alpha_ */), ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, out+2056 /* &.alpha_ */, a+2056 /* &.alpha_ */, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
}
- } else if *(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 3)) != 0 {
- libc.Xmemcpy(tls, (out + 2056 /* &.alpha_ */), (b + 2056 /* &.alpha_ */), ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ } else if *(*uint8_t)(unsafe.Pointer(b + 3280 /* &.is_used_ */ + 3)) != 0 {
+ libc.Xmemcpy(tls, out+2056 /* &.alpha_ */, b+2056 /* &.alpha_ */, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
} else {
- libc.Xmemset(tls, (out + 2056 /* &.alpha_ */), 0, ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemset(tls, out+2056 /* &.alpha_ */, 0, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
- for ok4 := true; ok4; ok4 = (0 != 0) {
- if *(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 4)) != 0 {
- if *(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 4)) != 0 {
+ for __ccgo4 := true; __ccgo4; __ccgo4 = 0 != 0 {
+ if *(*uint8_t)(unsafe.Pointer(a + 3280 + 4)) != 0 {
+ if *(*uint8_t)(unsafe.Pointer(b + 3280 + 4)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVector})).f(tls, (a + 3080 /* &.distance_ */), (b + 3080 /* &.distance_ */), (out + 3080 /* &.distance_ */), (40))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVector})).f(tls, a+3080 /* &.distance_ */, b+3080 /* &.distance_ */, out+3080 /* &.distance_ */, 40)
} else {
- libc.Xmemcpy(tls, (out + 3080 /* &.distance_ */), (a + 3080 /* &.distance_ */), ((uint64(40)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, out+3080 /* &.distance_ */, a+3080 /* &.distance_ */, uint64(40)*uint64(unsafe.Sizeof(uint32_t(0))))
}
- } else if *(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 4)) != 0 {
- libc.Xmemcpy(tls, (out + 3080 /* &.distance_ */), (b + 3080 /* &.distance_ */), ((uint64(40)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ } else if *(*uint8_t)(unsafe.Pointer(b + 3280 /* &.is_used_ */ + 4)) != 0 {
+ libc.Xmemcpy(tls, out+3080 /* &.distance_ */, b+3080 /* &.distance_ */, uint64(40)*uint64(unsafe.Sizeof(uint32_t(0))))
} else {
- libc.Xmemset(tls, (out + 3080 /* &.distance_ */), 0, ((uint64(40)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemset(tls, out+3080 /* &.distance_ */, 0, uint64(40)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
for i = 0; i < 5; i++ {
- *(*uint8_t)(unsafe.Pointer((out + 3280 /* &.is_used_ */) + uintptr(i))) = (uint8_t(int32(*(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + uintptr(i)))) | int32(*(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + uintptr(i))))))
+ *(*uint8_t)(unsafe.Pointer(out + 3280 + uintptr(i))) = uint8_t(int32(*(*uint8_t)(unsafe.Pointer(a + 3280 + uintptr(i)))) | int32(*(*uint8_t)(unsafe.Pointer(b + 3280 + uintptr(i)))))
}
} else {
- for ok5 := true; ok5; ok5 = (0 != 0) {
- if *(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */))) != 0 {
- if *(*uint8_t)(unsafe.Pointer((out + 3280 /* &.is_used_ */))) != 0 {
+ for __ccgo5 := true; __ccgo5; __ccgo5 = 0 != 0 {
+ if *(*uint8_t)(unsafe.Pointer(a + 3280)) != 0 {
+ if *(*uint8_t)(unsafe.Pointer(out + 3280)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})).f(tls, (*VP8LHistogram)(unsafe.Pointer(a)).literal_, (*VP8LHistogram)(unsafe.Pointer(out)).literal_, (literal_size))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})).f(tls, (*VP8LHistogram)(unsafe.Pointer(a)).literal_, (*VP8LHistogram)(unsafe.Pointer(out)).literal_, literal_size)
} else {
- libc.Xmemcpy(tls, ((*VP8LHistogram)(unsafe.Pointer(out)).literal_), ((*VP8LHistogram)(unsafe.Pointer(a)).literal_), ((uint64(literal_size)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, (*VP8LHistogram)(unsafe.Pointer(out)).literal_, (*VP8LHistogram)(unsafe.Pointer(a)).literal_, uint64(literal_size)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
}
- for ok6 := true; ok6; ok6 = (0 != 0) {
- if *(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 1)) != 0 {
- if *(*uint8_t)(unsafe.Pointer((out + 3280 /* &.is_used_ */) + 1)) != 0 {
+ for __ccgo6 := true; __ccgo6; __ccgo6 = 0 != 0 {
+ if *(*uint8_t)(unsafe.Pointer(a + 3280 + 1)) != 0 {
+ if *(*uint8_t)(unsafe.Pointer(out + 3280 + 1)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})).f(tls, (a + 8 /* &.red_ */), (out + 8 /* &.red_ */), (256))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})).f(tls, a+8 /* &.red_ */, out+8 /* &.red_ */, 256)
} else {
- libc.Xmemcpy(tls, (out + 8 /* &.red_ */), (a + 8 /* &.red_ */), ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, out+8 /* &.red_ */, a+8 /* &.red_ */, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
}
- for ok7 := true; ok7; ok7 = (0 != 0) {
- if *(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 2)) != 0 {
- if *(*uint8_t)(unsafe.Pointer((out + 3280 /* &.is_used_ */) + 2)) != 0 {
+ for __ccgo7 := true; __ccgo7; __ccgo7 = 0 != 0 {
+ if *(*uint8_t)(unsafe.Pointer(a + 3280 + 2)) != 0 {
+ if *(*uint8_t)(unsafe.Pointer(out + 3280 + 2)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})).f(tls, (a + 1032 /* &.blue_ */), (out + 1032 /* &.blue_ */), (256))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})).f(tls, a+1032 /* &.blue_ */, out+1032 /* &.blue_ */, 256)
} else {
- libc.Xmemcpy(tls, (out + 1032 /* &.blue_ */), (a + 1032 /* &.blue_ */), ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, out+1032 /* &.blue_ */, a+1032 /* &.blue_ */, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
}
- for ok8 := true; ok8; ok8 = (0 != 0) {
- if *(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 3)) != 0 {
- if *(*uint8_t)(unsafe.Pointer((out + 3280 /* &.is_used_ */) + 3)) != 0 {
+ for __ccgo8 := true; __ccgo8; __ccgo8 = 0 != 0 {
+ if *(*uint8_t)(unsafe.Pointer(a + 3280 + 3)) != 0 {
+ if *(*uint8_t)(unsafe.Pointer(out + 3280 + 3)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})).f(tls, (a + 2056 /* &.alpha_ */), (out + 2056 /* &.alpha_ */), (256))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})).f(tls, a+2056 /* &.alpha_ */, out+2056 /* &.alpha_ */, 256)
} else {
- libc.Xmemcpy(tls, (out + 2056 /* &.alpha_ */), (a + 2056 /* &.alpha_ */), ((uint64(256)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, out+2056 /* &.alpha_ */, a+2056 /* &.alpha_ */, uint64(256)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
}
- for ok9 := true; ok9; ok9 = (0 != 0) {
- if *(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 4)) != 0 {
- if *(*uint8_t)(unsafe.Pointer((out + 3280 /* &.is_used_ */) + 4)) != 0 {
+ for __ccgo9 := true; __ccgo9; __ccgo9 = 0 != 0 {
+ if *(*uint8_t)(unsafe.Pointer(a + 3280 + 4)) != 0 {
+ if *(*uint8_t)(unsafe.Pointer(out + 3280 + 4)) != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})).f(tls, (a + 3080 /* &.distance_ */), (out + 3080 /* &.distance_ */), (40))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})).f(tls, a+3080 /* &.distance_ */, out+3080 /* &.distance_ */, 40)
} else {
- libc.Xmemcpy(tls, (out + 3080 /* &.distance_ */), (a + 3080 /* &.distance_ */), ((uint64(40)) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, out+3080 /* &.distance_ */, a+3080 /* &.distance_ */, uint64(40)*uint64(unsafe.Sizeof(uint32_t(0))))
}
}
}
for i = 0; i < 5; i++ {
- *(*uint8_t)(unsafe.Pointer(((out + 3280 /* &.is_used_ */) + uintptr(i)))) |= uint8_t((int32(*(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + uintptr(i))))))
+ *(*uint8_t)(unsafe.Pointer(out + 3280 + uintptr(i))) |= uint8_t(int32(*(*uint8_t)(unsafe.Pointer(a + 3280 + uintptr(i)))))
}
}
}
@@ -19807,7 +19547,7 @@ func PredictorSub0_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorSub1_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:731:13: */
var i int32
for i = 0; i < num_pixels; i++ {
- *(*uint32_t)(unsafe.Pointer(out + uintptr(i)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(i)*4)), *(*uint32_t)(unsafe.Pointer(in + uintptr((i-1))*4)))
+ *(*uint32_t)(unsafe.Pointer(out + uintptr(i)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(i)*4)), *(*uint32_t)(unsafe.Pointer(in + uintptr(i-1)*4)))
}
_ = upper
}
@@ -19818,7 +19558,7 @@ func PredictorSub1_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorSub2_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:753:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor2_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor2_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19826,7 +19566,7 @@ func PredictorSub2_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorSub3_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:754:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor3_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor3_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19834,7 +19574,7 @@ func PredictorSub3_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorSub4_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:755:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor4_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor4_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19842,7 +19582,7 @@ func PredictorSub4_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorSub5_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:756:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor5_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor5_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19850,7 +19590,7 @@ func PredictorSub5_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorSub6_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:757:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor6_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor6_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19858,7 +19598,7 @@ func PredictorSub6_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorSub7_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:758:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor7_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor7_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19866,7 +19606,7 @@ func PredictorSub7_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorSub8_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:759:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor8_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor8_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19874,7 +19614,7 @@ func PredictorSub8_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorSub9_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:760:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor9_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor9_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19882,7 +19622,7 @@ func PredictorSub9_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32,
func PredictorSub10_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:761:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor10_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor10_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19890,7 +19630,7 @@ func PredictorSub10_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32
func PredictorSub11_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:762:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor11_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor11_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19898,7 +19638,7 @@ func PredictorSub11_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32
func PredictorSub12_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:763:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor12_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor12_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19906,7 +19646,7 @@ func PredictorSub12_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32
func PredictorSub13_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) { /* lossless_enc.c:764:1: */
var x int32
for x = 0; x < num_pixels; x++ {
- var pred uint32_t = VP8LPredictor13_C(tls, (in + uintptr((x-1))*4), (upper + uintptr(x)*4))
+ var pred uint32_t = VP8LPredictor13_C(tls, in+uintptr(x-1)*4, upper+uintptr(x)*4)
*(*uint32_t)(unsafe.Pointer(out + uintptr(x)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(in + uintptr(x)*4)), pred)
}
}
@@ -19940,7 +19680,7 @@ var VP8LPredictorsSub [16]VP8LPredictorAddSubFunc /* lossless_enc.c:791:25: */
var VP8LPredictorsSub_C [16]VP8LPredictorAddSubFunc /* lossless_enc.c:792:25: */
func VP8LEncDspInit(tls *libc.TLS) { /* lossless_enc.c:801:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if VP8LEncDspInit_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -20106,7 +19846,7 @@ func VP8LEncDspInit_body(tls *libc.TLS) { /* lossless_enc.c:801:1: */
}{PredictorSub0_C}))
// If defined, use CPUInfo() to overwrite some pointers with faster versions.
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -20123,7 +19863,7 @@ func VP8LEncDspInit_body(tls *libc.TLS) { /* lossless_enc.c:801:1: */
func WebPRescalerImportRowExpand_C(tls *libc.TLS, wrk uintptr, src uintptr) { /* rescaler.c:29:6: */
var x_stride int32 = (*WebPRescaler)(unsafe.Pointer(wrk)).num_channels
- var x_out_max int32 = ((*WebPRescaler)(unsafe.Pointer(wrk)).dst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).num_channels)
+ var x_out_max int32 = (*WebPRescaler)(unsafe.Pointer(wrk)).dst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).num_channels
var channel int32
for channel = 0; channel < x_stride; channel++ {
@@ -20134,24 +19874,24 @@ func WebPRescalerImportRowExpand_C(tls *libc.TLS, wrk uintptr, src uintptr) { /*
var left rescaler_t = rescaler_t(*(*uint8_t)(unsafe.Pointer(src + uintptr(x_in))))
var right rescaler_t
if (*WebPRescaler)(unsafe.Pointer(wrk)).src_width > 1 {
- right = rescaler_t(*(*uint8_t)(unsafe.Pointer(src + uintptr((x_in + x_stride)))))
+ right = rescaler_t(*(*uint8_t)(unsafe.Pointer(src + uintptr(x_in+x_stride))))
} else {
right = left
}
- x_in = x_in + (x_stride)
+ x_in = x_in + x_stride
for 1 != 0 {
- *(*rescaler_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer(wrk)).frow + uintptr(x_out)*4)) = ((right * rescaler_t((*WebPRescaler)(unsafe.Pointer(wrk)).x_add)) + ((left - right) * rescaler_t(accum)))
- x_out = x_out + (x_stride)
+ *(*rescaler_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer(wrk)).frow + uintptr(x_out)*4)) = right*rescaler_t((*WebPRescaler)(unsafe.Pointer(wrk)).x_add) + (left-right)*rescaler_t(accum)
+ x_out = x_out + x_stride
if x_out >= x_out_max {
break
}
- accum = accum - ((*WebPRescaler)(unsafe.Pointer(wrk)).x_sub)
+ accum = accum - (*WebPRescaler)(unsafe.Pointer(wrk)).x_sub
if accum < 0 {
left = right
- x_in = x_in + (x_stride)
+ x_in = x_in + x_stride
right = rescaler_t(*(*uint8_t)(unsafe.Pointer(src + uintptr(x_in))))
- accum = accum + ((*WebPRescaler)(unsafe.Pointer(wrk)).x_add)
+ accum = accum + (*WebPRescaler)(unsafe.Pointer(wrk)).x_add
}
}
@@ -20160,7 +19900,7 @@ func WebPRescalerImportRowExpand_C(tls *libc.TLS, wrk uintptr, src uintptr) { /*
func WebPRescalerImportRowShrink_C(tls *libc.TLS, wrk uintptr, src uintptr) { /* rescaler.c:62:6: */
var x_stride int32 = (*WebPRescaler)(unsafe.Pointer(wrk)).num_channels
- var x_out_max int32 = ((*WebPRescaler)(unsafe.Pointer(wrk)).dst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).num_channels)
+ var x_out_max int32 = (*WebPRescaler)(unsafe.Pointer(wrk)).dst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).num_channels
var channel int32
for channel = 0; channel < x_stride; channel++ {
@@ -20170,22 +19910,22 @@ func WebPRescalerImportRowShrink_C(tls *libc.TLS, wrk uintptr, src uintptr) { /*
var accum int32 = 0
for x_out < x_out_max {
var base uint32_t = uint32_t(0)
- accum = accum + ((*WebPRescaler)(unsafe.Pointer(wrk)).x_add)
+ accum = accum + (*WebPRescaler)(unsafe.Pointer(wrk)).x_add
for accum > 0 {
- accum = accum - ((*WebPRescaler)(unsafe.Pointer(wrk)).x_sub)
+ accum = accum - (*WebPRescaler)(unsafe.Pointer(wrk)).x_sub
base = uint32_t(*(*uint8_t)(unsafe.Pointer(src + uintptr(x_in))))
- sum = sum + (base)
- x_in = x_in + (x_stride)
+ sum = sum + base
+ x_in = x_in + x_stride
}
{ // Emit next horizontal pixel.
- var frac rescaler_t = (base * (uint32_t(-accum)))
- *(*rescaler_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer(wrk)).frow + uintptr(x_out)*4)) = ((sum * uint32_t((*WebPRescaler)(unsafe.Pointer(wrk)).x_sub)) - frac)
+ var frac rescaler_t = base * uint32_t(-accum)
+ *(*rescaler_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer(wrk)).frow + uintptr(x_out)*4)) = sum*uint32_t((*WebPRescaler)(unsafe.Pointer(wrk)).x_sub) - frac
// fresh fractional start for next pixel
- sum = uint32_t((int32(((uint64((uint64_t(frac)) * (uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).fx_scale)))) + (uint64((uint64(1) << 32)) >> 1)) >> 32)))
+ sum = uint32_t(int32((uint64(uint64_t(frac)*uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).fx_scale)) + uint64(uint64(1)<<32)>>1) >> 32))
}
- x_out = x_out + (x_stride)
+ x_out = x_out + x_stride
}
}
@@ -20198,13 +19938,13 @@ func WebPRescalerExportRowExpand_C(tls *libc.TLS, wrk uintptr) { /* rescaler.c:9
var x_out int32
var dst uintptr = (*WebPRescaler)(unsafe.Pointer(wrk)).dst
var irow uintptr = (*WebPRescaler)(unsafe.Pointer(wrk)).irow
- var x_out_max int32 = ((*WebPRescaler)(unsafe.Pointer(wrk)).dst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).num_channels)
+ var x_out_max int32 = (*WebPRescaler)(unsafe.Pointer(wrk)).dst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).num_channels
var frow uintptr = (*WebPRescaler)(unsafe.Pointer(wrk)).frow
if (*WebPRescaler)(unsafe.Pointer(wrk)).y_accum == 0 {
for x_out = 0; x_out < x_out_max; x_out++ {
var J uint32_t = *(*rescaler_t)(unsafe.Pointer(frow + uintptr(x_out)*4))
- var v int32 = (int32(((uint64((uint64_t(J)) * (uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).fy_scale)))) + (uint64((uint64(1) << 32)) >> 1)) >> 32))
+ var v int32 = int32((uint64(uint64_t(J)*uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).fy_scale)) + uint64(uint64(1)<<32)>>1) >> 32)
*(*uint8_t)(unsafe.Pointer(dst + uintptr(x_out))) = func() uint8 {
if v > 255 {
return uint8(255)
@@ -20213,13 +19953,13 @@ func WebPRescalerExportRowExpand_C(tls *libc.TLS, wrk uintptr) { /* rescaler.c:9
}()
}
} else {
- var B uint32_t = (uint32_t(((uint64_t(-(*WebPRescaler)(unsafe.Pointer(wrk)).y_accum)) << 32) / (uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).y_sub))))
- var A uint32_t = (uint32_t((uint64(1) << 32) - uint64(B)))
+ var B uint32_t = uint32_t(uint64_t(-(*WebPRescaler)(unsafe.Pointer(wrk)).y_accum) << 32 / uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).y_sub))
+ var A uint32_t = uint32_t(uint64(1)<<32 - uint64(B))
for x_out = 0; x_out < x_out_max; x_out++ {
- var I uint64_t = ((uint64_t(A) * uint64_t(*(*rescaler_t)(unsafe.Pointer(frow + uintptr(x_out)*4)))) +
- (uint64_t(B) * uint64_t(*(*rescaler_t)(unsafe.Pointer(irow + uintptr(x_out)*4)))))
- var J uint32_t = (uint32_t((uint64(I) + (uint64((uint64(1) << 32)) >> 1)) >> 32))
- var v int32 = (int32(((uint64((uint64_t(J)) * (uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).fy_scale)))) + (uint64((uint64(1) << 32)) >> 1)) >> 32))
+ var I uint64_t = uint64_t(A)*uint64_t(*(*rescaler_t)(unsafe.Pointer(frow + uintptr(x_out)*4))) +
+ uint64_t(B)*uint64_t(*(*rescaler_t)(unsafe.Pointer(irow + uintptr(x_out)*4)))
+ var J uint32_t = uint32_t((uint64(I) + uint64(uint64(1)<<32)>>1) >> 32)
+ var v int32 = int32((uint64(uint64_t(J)*uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).fy_scale)) + uint64(uint64(1)<<32)>>1) >> 32)
*(*uint8_t)(unsafe.Pointer(dst + uintptr(x_out))) = func() uint8 {
if v > 255 {
return uint8(255)
@@ -20234,14 +19974,14 @@ func WebPRescalerExportRowShrink_C(tls *libc.TLS, wrk uintptr) { /* rescaler.c:1
var x_out int32
var dst uintptr = (*WebPRescaler)(unsafe.Pointer(wrk)).dst
var irow uintptr = (*WebPRescaler)(unsafe.Pointer(wrk)).irow
- var x_out_max int32 = ((*WebPRescaler)(unsafe.Pointer(wrk)).dst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).num_channels)
+ var x_out_max int32 = (*WebPRescaler)(unsafe.Pointer(wrk)).dst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).num_channels
var frow uintptr = (*WebPRescaler)(unsafe.Pointer(wrk)).frow
- var yscale uint32_t = ((*WebPRescaler)(unsafe.Pointer(wrk)).fy_scale * (uint32_t(-(*WebPRescaler)(unsafe.Pointer(wrk)).y_accum)))
+ var yscale uint32_t = (*WebPRescaler)(unsafe.Pointer(wrk)).fy_scale * uint32_t(-(*WebPRescaler)(unsafe.Pointer(wrk)).y_accum)
if yscale != 0 {
for x_out = 0; x_out < x_out_max; x_out++ {
- var frac uint32_t = (uint32_t(((uint64_t(*(*rescaler_t)(unsafe.Pointer(frow + uintptr(x_out)*4)))) * (uint64_t(yscale))) >> 32))
- var v int32 = (int32(((uint64((uint64_t(*(*rescaler_t)(unsafe.Pointer(irow + uintptr(x_out)*4)) - frac)) * (uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).fxy_scale)))) + (uint64((uint64(1) << 32)) >> 1)) >> 32))
+ var frac uint32_t = uint32_t(uint64_t(*(*rescaler_t)(unsafe.Pointer(frow + uintptr(x_out)*4))) * uint64_t(yscale) >> 32)
+ var v int32 = int32((uint64(uint64_t(*(*rescaler_t)(unsafe.Pointer(irow + uintptr(x_out)*4))-frac)*uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).fxy_scale)) + uint64(uint64(1)<<32)>>1) >> 32)
*(*uint8_t)(unsafe.Pointer(dst + uintptr(x_out))) = func() uint8 {
if v > 255 {
return uint8(255)
@@ -20252,7 +19992,7 @@ func WebPRescalerExportRowShrink_C(tls *libc.TLS, wrk uintptr) { /* rescaler.c:1
}
} else {
for x_out = 0; x_out < x_out_max; x_out++ {
- var v int32 = (int32(((uint64((uint64_t(*(*rescaler_t)(unsafe.Pointer(irow + uintptr(x_out)*4)))) * (uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).fxy_scale)))) + (uint64((uint64(1) << 32)) >> 1)) >> 32))
+ var v int32 = int32((uint64(uint64_t(*(*rescaler_t)(unsafe.Pointer(irow + uintptr(x_out)*4)))*uint64_t((*WebPRescaler)(unsafe.Pointer(wrk)).fxy_scale)) + uint64(uint64(1)<<32)>>1) >> 32)
*(*uint8_t)(unsafe.Pointer(dst + uintptr(x_out))) = func() uint8 {
if v > 255 {
return uint8(255)
@@ -20290,13 +20030,13 @@ func WebPRescalerExportRow(tls *libc.TLS, wrk uintptr) { /* rescaler.c:170:6: */
} else { // special case
var i int32
- for i = 0; i < ((*WebPRescaler)(unsafe.Pointer(wrk)).num_channels * (*WebPRescaler)(unsafe.Pointer(wrk)).dst_width); i++ {
+ for i = 0; i < (*WebPRescaler)(unsafe.Pointer(wrk)).num_channels*(*WebPRescaler)(unsafe.Pointer(wrk)).dst_width; i++ {
*(*uint8_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer(wrk)).dst + uintptr(i))) = uint8_t(*(*rescaler_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer(wrk)).irow + uintptr(i)*4)))
*(*rescaler_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer(wrk)).irow + uintptr(i)*4)) = rescaler_t(0)
}
}
- *(*int32)(unsafe.Pointer((wrk + 24 /* &.y_accum */))) += ((*WebPRescaler)(unsafe.Pointer(wrk)).y_add)
- *(*uintptr)(unsafe.Pointer((wrk + 72 /* &.dst */))) += (uintptr((*WebPRescaler)(unsafe.Pointer(wrk)).dst_stride))
+ *(*int32)(unsafe.Pointer(wrk + 24)) += (*WebPRescaler)(unsafe.Pointer(wrk)).y_add
+ *(*uintptr)(unsafe.Pointer(wrk + 72)) += uintptr((*WebPRescaler)(unsafe.Pointer(wrk)).dst_stride)
(*WebPRescaler)(unsafe.Pointer(wrk)).dst_y++
}
}
@@ -20310,7 +20050,7 @@ var WebPRescalerExportRowExpand WebPRescalerExportRowFunc /* rescaler.c:197:27:
var WebPRescalerExportRowShrink WebPRescalerExportRowFunc /* rescaler.c:198:27: */
func WebPRescalerDspInit(tls *libc.TLS) { /* rescaler.c:206:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if WebPRescalerDspInit_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -20332,7 +20072,7 @@ func WebPRescalerDspInit_body(tls *libc.TLS) { /* rescaler.c:206:1: */
f func(*libc.TLS, uintptr, uintptr)
}{WebPRescalerImportRowShrink_C}))
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -20343,34 +20083,34 @@ func WebPRescalerDspInit_body(tls *libc.TLS) { /* rescaler.c:206:1: */
// hat-shaped filter. Sum of coefficients is equal to 16.
var kWeight = [7]uint32_t{
uint32_t(1), uint32_t(2), uint32_t(3), uint32_t(4), uint32_t(3), uint32_t(2), uint32_t(1),
-} /* ssim.c:25:23 */
-var kWeightSum uint32_t = (uint32_t(16 * 16)) /* ssim.c:28:23 */
+} /* ssim.c:25:23 */
+var kWeightSum uint32_t = uint32_t(16 * 16) /* ssim.c:28:23 */
// sum{kWeight}^2
func SSIMCalculation(tls *libc.TLS, stats uintptr, N uint32_t) float64 { /* ssim.c:30:27: */
- var w2 uint32_t = (N * N)
- var C1 uint32_t = (uint32_t(20) * w2)
- var C2 uint32_t = (uint32_t(60) * w2)
- var C3 uint32_t = ((uint32_t(8 * 8)) * w2) // 'dark' limit ~= 6
- var xmxm uint64_t = (uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).xm) * uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).xm))
- var ymym uint64_t = (uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).ym) * uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).ym))
- if (xmxm + ymym) >= uint64_t(C3) {
- var xmym int64_t = (int64_t((*VP8DistoStats)(unsafe.Pointer(stats)).xm) * int64_t((*VP8DistoStats)(unsafe.Pointer(stats)).ym))
- var sxy int64_t = ((int64_t((*VP8DistoStats)(unsafe.Pointer(stats)).xym) * int64_t(N)) - xmym) // can be negative
- var sxx uint64_t = ((uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).xxm) * uint64_t(N)) - xmxm)
- var syy uint64_t = ((uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).yym) * uint64_t(N)) - ymym)
+ var w2 uint32_t = N * N
+ var C1 uint32_t = uint32_t(20) * w2
+ var C2 uint32_t = uint32_t(60) * w2
+ var C3 uint32_t = uint32_t(8*8) * w2 // 'dark' limit ~= 6
+ var xmxm uint64_t = uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).xm) * uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).xm)
+ var ymym uint64_t = uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).ym) * uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).ym)
+ if xmxm+ymym >= uint64_t(C3) {
+ var xmym int64_t = int64_t((*VP8DistoStats)(unsafe.Pointer(stats)).xm) * int64_t((*VP8DistoStats)(unsafe.Pointer(stats)).ym)
+ var sxy int64_t = int64_t((*VP8DistoStats)(unsafe.Pointer(stats)).xym)*int64_t(N) - xmym // can be negative
+ var sxx uint64_t = uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).xxm)*uint64_t(N) - xmxm
+ var syy uint64_t = uint64_t((*VP8DistoStats)(unsafe.Pointer(stats)).yym)*uint64_t(N) - ymym
// we descale by 8 to prevent overflow during the fnum/fden multiply.
- var num_S uint64_t = (((uint64(2) * (func() uint64 {
+ var num_S uint64_t = (uint64(2)*func() uint64 {
if sxy < int64(0) {
return uint64(0)
}
return uint64(sxy)
- }())) + uint64_t(C2)) >> 8)
- var den_S uint64_t = (((sxx + syy) + uint64_t(C2)) >> 8)
- var fnum uint64_t = ((uint64_t((int64(2) * xmym) + int64_t(C1))) * num_S)
- var fden uint64_t = (((xmxm + ymym) + uint64_t(C1)) * den_S)
- var r float64 = (float64(fnum) / float64(fden))
+ }() + uint64_t(C2)) >> 8
+ var den_S uint64_t = (sxx + syy + uint64_t(C2)) >> 8
+ var fnum uint64_t = uint64_t(int64(2)*xmym+int64_t(C1)) * num_S
+ var fden uint64_t = (xmxm + ymym + uint64_t(C1)) * den_S
+ var r float64 = float64(fnum) / float64(fden)
return r
}
@@ -20391,33 +20131,33 @@ func SSIMGetClipped_C(tls *libc.TLS, src1 uintptr, stride1 int32, src2 uintptr,
*(*VP8DistoStats)(unsafe.Pointer(bp /* stats */)) = VP8DistoStats{}
var ymin int32
- if (yo - 3) < 0 {
+ if yo-3 < 0 {
ymin = 0
} else {
- ymin = (yo - 3)
+ ymin = yo - 3
}
var ymax int32
- if (yo + 3) > (H - 1) {
- ymax = (H - 1)
+ if yo+3 > H-1 {
+ ymax = H - 1
} else {
- ymax = (yo + 3)
+ ymax = yo + 3
}
var xmin int32
- if (xo - 3) < 0 {
+ if xo-3 < 0 {
xmin = 0
} else {
- xmin = (xo - 3)
+ xmin = xo - 3
}
var xmax int32
- if (xo + 3) > (W - 1) {
- xmax = (W - 1)
+ if xo+3 > W-1 {
+ xmax = W - 1
} else {
- xmax = (xo + 3)
+ xmax = xo + 3
}
var x int32
var y int32
- src1 += (uintptr(ymin * stride1))
- src2 += (uintptr(ymin * stride2))
+ src1 += uintptr(ymin * stride1)
+ src2 += uintptr(ymin * stride2)
y = ymin
__1:
if !(y <= ymax) {
@@ -20425,16 +20165,16 @@ __1:
}
{
for x = xmin; x <= xmax; x++ {
- var w uint32_t = (kWeight[((3+x)-xo)] *
- kWeight[((3+y)-yo)])
+ var w uint32_t = kWeight[3+x-xo] *
+ kWeight[3+y-yo]
var s1 uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(src1 + uintptr(x))))
var s2 uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(src2 + uintptr(x))))
- *(*uint32_t)(unsafe.Pointer((bp) /* &stats */ /* &.w */)) += (w)
- *(*uint32_t)(unsafe.Pointer(((bp) /* &stats */ + 4 /* &.xm */))) += (w * s1)
- *(*uint32_t)(unsafe.Pointer(((bp) /* &stats */ + 8 /* &.ym */))) += (w * s2)
- *(*uint32_t)(unsafe.Pointer(((bp) /* &stats */ + 12 /* &.xxm */))) += ((w * s1) * s1)
- *(*uint32_t)(unsafe.Pointer(((bp) /* &stats */ + 16 /* &.xym */))) += ((w * s1) * s2)
- *(*uint32_t)(unsafe.Pointer(((bp) /* &stats */ + 20 /* &.yym */))) += ((w * s2) * s2)
+ *(*uint32_t)(unsafe.Pointer(bp)) += w
+ *(*uint32_t)(unsafe.Pointer(bp + 4)) += w * s1
+ *(*uint32_t)(unsafe.Pointer(bp + 8)) += w * s2
+ *(*uint32_t)(unsafe.Pointer(bp + 12)) += w * s1 * s1
+ *(*uint32_t)(unsafe.Pointer(bp + 16)) += w * s1 * s2
+ *(*uint32_t)(unsafe.Pointer(bp + 20)) += w * s2 * s2
}
}
@@ -20447,7 +20187,7 @@ __2:
goto __3
__3:
;
- return VP8SSIMFromStatsClipped(tls, (bp) /* &stats */)
+ return VP8SSIMFromStatsClipped(tls, bp)
}
func SSIMGet_C(tls *libc.TLS, src1 uintptr, stride1 int32, src2 uintptr, stride2 int32) float64 { /* ssim.c:93:15: */
@@ -20459,19 +20199,19 @@ func SSIMGet_C(tls *libc.TLS, src1 uintptr, stride1 int32, src2 uintptr, stride2
var y int32
y = 0
__1:
- if !(y <= (2 * 3)) {
+ if !(y <= 2*3) {
goto __3
}
{
- for x = 0; x <= (2 * 3); x++ {
- var w uint32_t = (kWeight[x] * kWeight[y])
+ for x = 0; x <= 2*3; x++ {
+ var w uint32_t = kWeight[x] * kWeight[y]
var s1 uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(src1 + uintptr(x))))
var s2 uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(src2 + uintptr(x))))
- *(*uint32_t)(unsafe.Pointer(((bp) /* &stats */ + 4 /* &.xm */))) += (w * s1)
- *(*uint32_t)(unsafe.Pointer(((bp) /* &stats */ + 8 /* &.ym */))) += (w * s2)
- *(*uint32_t)(unsafe.Pointer(((bp) /* &stats */ + 12 /* &.xxm */))) += ((w * s1) * s1)
- *(*uint32_t)(unsafe.Pointer(((bp) /* &stats */ + 16 /* &.xym */))) += ((w * s1) * s2)
- *(*uint32_t)(unsafe.Pointer(((bp) /* &stats */ + 20 /* &.yym */))) += ((w * s2) * s2)
+ *(*uint32_t)(unsafe.Pointer(bp + 4)) += w * s1
+ *(*uint32_t)(unsafe.Pointer(bp + 8)) += w * s2
+ *(*uint32_t)(unsafe.Pointer(bp + 12)) += w * s1 * s1
+ *(*uint32_t)(unsafe.Pointer(bp + 16)) += w * s1 * s2
+ *(*uint32_t)(unsafe.Pointer(bp + 20)) += w * s2 * s2
}
}
@@ -20484,7 +20224,7 @@ __2:
goto __3
__3:
;
- return VP8SSIMFromStats(tls, (bp) /* &stats */)
+ return VP8SSIMFromStats(tls, bp)
}
//------------------------------------------------------------------------------
@@ -20494,8 +20234,8 @@ func AccumulateSSE_C(tls *libc.TLS, src1 uintptr, src2 uintptr, len int32) uint3
var sse2 uint32_t = uint32_t(0)
// to ensure that accumulation fits within uint32_t
for i = 0; i < len; i++ {
- var diff int32_t = (int32(*(*uint8_t)(unsafe.Pointer(src1 + uintptr(i)))) - int32(*(*uint8_t)(unsafe.Pointer(src2 + uintptr(i)))))
- sse2 = sse2 + (uint32_t(diff * diff))
+ var diff int32_t = int32(*(*uint8_t)(unsafe.Pointer(src1 + uintptr(i)))) - int32(*(*uint8_t)(unsafe.Pointer(src2 + uintptr(i))))
+ sse2 = sse2 + uint32_t(diff*diff)
}
return sse2
}
@@ -20507,7 +20247,7 @@ var VP8SSIMGetClipped VP8SSIMGetClippedFunc /* ssim.c:134:23: */
var VP8AccumulateSSE VP8AccumulateSSEFunc /* ssim.c:137:22: */
func VP8SSIMDspInit(tls *libc.TLS) { /* ssim.c:142:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if VP8SSIMDspInit_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -20530,7 +20270,7 @@ func VP8SSIMDspInit_body(tls *libc.TLS) { /* ssim.c:142:1: */
f func(*libc.TLS, uintptr, uintptr, int32) uint32_t
}{AccumulateSSE_C}))
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -20599,322 +20339,322 @@ var WebPUpsamplers [13]WebPUpsampleLinePairFunc /* upsampling.c:25:26: */
// All variants implemented.
func UpsampleRgbaLinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len int32) { /* upsampling.c:97:1: */
var x int32
- var last_pixel_pair int32 = ((len - 1) >> 1)
- var tl_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v)))) << 16))) /* top-left sample */
- var l_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v)))) << 16))) /* left-sample */
+ var last_pixel_pair int32 = (len - 1) >> 1
+ var tl_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u))) | int32(*(*uint8_t)(unsafe.Pointer(top_v)))<<16) /* top-left sample */
+ var l_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v)))<<16) /* left-sample */
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(top_y)), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), top_dst)
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(top_y)), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), top_dst)
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(bottom_y)), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), bottom_dst)
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(bottom_y)), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), bottom_dst)
}
for x = 1; x <= last_pixel_pair; x++ {
- var t_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))) << 16))) /* top sample */
- var uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))) << 16))) /* sample */ /* precompute invariant values associated with first and second diagonals*/
- var avg uint32_t = ((((tl_uv + t_uv) + l_uv) + uv) + 0x00080008)
- var diag_12 uint32_t = ((avg + (uint32_t(2) * (t_uv + l_uv))) >> 3)
- var diag_03 uint32_t = ((avg + (uint32_t(2) * (tl_uv + uv))) >> 3)
+ var t_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))<<16) /* top sample */
+ var uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))<<16) /* sample */ /* precompute invariant values associated with first and second diagonals*/
+ var avg uint32_t = tl_uv + t_uv + l_uv + uv + 0x00080008
+ var diag_12 uint32_t = (avg + uint32_t(2)*(t_uv+l_uv)) >> 3
+ var diag_03 uint32_t = (avg + uint32_t(2)*(tl_uv+uv)) >> 3
{
- var uv0 uint32_t = ((diag_12 + tl_uv) >> 1)
- var uv1 uint32_t = ((diag_03 + t_uv) >> 1)
- VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (top_dst + uintptr((((2 * x) - 1) * (4)))))
- VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 0)))), (uint8(uv1 & uint32_t(0xff))), (uint8(uv1 >> 16)), (top_dst + uintptr((((2 * x) - 0) * (4)))))
+ var uv0 uint32_t = (diag_12 + tl_uv) >> 1
+ var uv1 uint32_t = (diag_03 + t_uv) >> 1
+ VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), top_dst+uintptr((2*x-1)*4))
+ VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-0))), uint8(uv1&uint32_t(0xff)), uint8(uv1>>16), top_dst+uintptr((2*x-0)*4))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((diag_03 + l_uv) >> 1)
- var uv1 uint32_t = ((diag_12 + uv) >> 1)
- VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (bottom_dst + uintptr((((2 * x) - 1) * (4)))))
- VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) + 0)))), (uint8(uv1 & uint32_t(0xff))), (uint8(uv1 >> 16)), (bottom_dst + uintptr((((2 * x) + 0) * (4)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (diag_03 + l_uv) >> 1
+ var uv1 uint32_t = (diag_12 + uv) >> 1
+ VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), bottom_dst+uintptr((2*x-1)*4))
+ VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x+0))), uint8(uv1&uint32_t(0xff)), uint8(uv1>>16), bottom_dst+uintptr((2*x+0)*4))
}
tl_uv = t_uv
l_uv = uv
}
- if !((len & 1) != 0) {
+ if !(len&1 != 0) {
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr((len - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (top_dst + uintptr(((len - 1) * (4)))))
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(len-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), top_dst+uintptr((len-1)*4))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr((len - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (bottom_dst + uintptr(((len - 1) * (4)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(len-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), bottom_dst+uintptr((len-1)*4))
}
}
}
func UpsampleBgraLinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len int32) { /* upsampling.c:98:1: */
var x int32
- var last_pixel_pair int32 = ((len - 1) >> 1)
- var tl_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v)))) << 16))) /* top-left sample */
- var l_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v)))) << 16))) /* left-sample */
+ var last_pixel_pair int32 = (len - 1) >> 1
+ var tl_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u))) | int32(*(*uint8_t)(unsafe.Pointer(top_v)))<<16) /* top-left sample */
+ var l_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v)))<<16) /* left-sample */
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(top_y)), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), top_dst)
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(top_y)), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), top_dst)
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(bottom_y)), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), bottom_dst)
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(bottom_y)), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), bottom_dst)
}
for x = 1; x <= last_pixel_pair; x++ {
- var t_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))) << 16))) /* top sample */
- var uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))) << 16))) /* sample */ /* precompute invariant values associated with first and second diagonals*/
- var avg uint32_t = ((((tl_uv + t_uv) + l_uv) + uv) + 0x00080008)
- var diag_12 uint32_t = ((avg + (uint32_t(2) * (t_uv + l_uv))) >> 3)
- var diag_03 uint32_t = ((avg + (uint32_t(2) * (tl_uv + uv))) >> 3)
+ var t_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))<<16) /* top sample */
+ var uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))<<16) /* sample */ /* precompute invariant values associated with first and second diagonals*/
+ var avg uint32_t = tl_uv + t_uv + l_uv + uv + 0x00080008
+ var diag_12 uint32_t = (avg + uint32_t(2)*(t_uv+l_uv)) >> 3
+ var diag_03 uint32_t = (avg + uint32_t(2)*(tl_uv+uv)) >> 3
{
- var uv0 uint32_t = ((diag_12 + tl_uv) >> 1)
- var uv1 uint32_t = ((diag_03 + t_uv) >> 1)
- VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (top_dst + uintptr((((2 * x) - 1) * (4)))))
- VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 0)))), (uint8(uv1 & uint32_t(0xff))), (uint8(uv1 >> 16)), (top_dst + uintptr((((2 * x) - 0) * (4)))))
+ var uv0 uint32_t = (diag_12 + tl_uv) >> 1
+ var uv1 uint32_t = (diag_03 + t_uv) >> 1
+ VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), top_dst+uintptr((2*x-1)*4))
+ VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-0))), uint8(uv1&uint32_t(0xff)), uint8(uv1>>16), top_dst+uintptr((2*x-0)*4))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((diag_03 + l_uv) >> 1)
- var uv1 uint32_t = ((diag_12 + uv) >> 1)
- VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (bottom_dst + uintptr((((2 * x) - 1) * (4)))))
- VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) + 0)))), (uint8(uv1 & uint32_t(0xff))), (uint8(uv1 >> 16)), (bottom_dst + uintptr((((2 * x) + 0) * (4)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (diag_03 + l_uv) >> 1
+ var uv1 uint32_t = (diag_12 + uv) >> 1
+ VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), bottom_dst+uintptr((2*x-1)*4))
+ VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x+0))), uint8(uv1&uint32_t(0xff)), uint8(uv1>>16), bottom_dst+uintptr((2*x+0)*4))
}
tl_uv = t_uv
l_uv = uv
}
- if !((len & 1) != 0) {
+ if !(len&1 != 0) {
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr((len - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (top_dst + uintptr(((len - 1) * (4)))))
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(len-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), top_dst+uintptr((len-1)*4))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr((len - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (bottom_dst + uintptr(((len - 1) * (4)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(len-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), bottom_dst+uintptr((len-1)*4))
}
}
}
func UpsampleArgbLinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len int32) { /* upsampling.c:100:1: */
var x int32
- var last_pixel_pair int32 = ((len - 1) >> 1)
- var tl_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v)))) << 16))) /* top-left sample */
- var l_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v)))) << 16))) /* left-sample */
+ var last_pixel_pair int32 = (len - 1) >> 1
+ var tl_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u))) | int32(*(*uint8_t)(unsafe.Pointer(top_v)))<<16) /* top-left sample */
+ var l_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v)))<<16) /* left-sample */
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(top_y)), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), top_dst)
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(top_y)), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), top_dst)
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(bottom_y)), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), bottom_dst)
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(bottom_y)), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), bottom_dst)
}
for x = 1; x <= last_pixel_pair; x++ {
- var t_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))) << 16))) /* top sample */
- var uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))) << 16))) /* sample */ /* precompute invariant values associated with first and second diagonals*/
- var avg uint32_t = ((((tl_uv + t_uv) + l_uv) + uv) + 0x00080008)
- var diag_12 uint32_t = ((avg + (uint32_t(2) * (t_uv + l_uv))) >> 3)
- var diag_03 uint32_t = ((avg + (uint32_t(2) * (tl_uv + uv))) >> 3)
+ var t_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))<<16) /* top sample */
+ var uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))<<16) /* sample */ /* precompute invariant values associated with first and second diagonals*/
+ var avg uint32_t = tl_uv + t_uv + l_uv + uv + 0x00080008
+ var diag_12 uint32_t = (avg + uint32_t(2)*(t_uv+l_uv)) >> 3
+ var diag_03 uint32_t = (avg + uint32_t(2)*(tl_uv+uv)) >> 3
{
- var uv0 uint32_t = ((diag_12 + tl_uv) >> 1)
- var uv1 uint32_t = ((diag_03 + t_uv) >> 1)
- VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (top_dst + uintptr((((2 * x) - 1) * (4)))))
- VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 0)))), (uint8(uv1 & uint32_t(0xff))), (uint8(uv1 >> 16)), (top_dst + uintptr((((2 * x) - 0) * (4)))))
+ var uv0 uint32_t = (diag_12 + tl_uv) >> 1
+ var uv1 uint32_t = (diag_03 + t_uv) >> 1
+ VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), top_dst+uintptr((2*x-1)*4))
+ VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-0))), uint8(uv1&uint32_t(0xff)), uint8(uv1>>16), top_dst+uintptr((2*x-0)*4))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((diag_03 + l_uv) >> 1)
- var uv1 uint32_t = ((diag_12 + uv) >> 1)
- VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (bottom_dst + uintptr((((2 * x) - 1) * (4)))))
- VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) + 0)))), (uint8(uv1 & uint32_t(0xff))), (uint8(uv1 >> 16)), (bottom_dst + uintptr((((2 * x) + 0) * (4)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (diag_03 + l_uv) >> 1
+ var uv1 uint32_t = (diag_12 + uv) >> 1
+ VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), bottom_dst+uintptr((2*x-1)*4))
+ VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x+0))), uint8(uv1&uint32_t(0xff)), uint8(uv1>>16), bottom_dst+uintptr((2*x+0)*4))
}
tl_uv = t_uv
l_uv = uv
}
- if !((len & 1) != 0) {
+ if !(len&1 != 0) {
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr((len - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (top_dst + uintptr(((len - 1) * (4)))))
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(top_y + uintptr(len-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), top_dst+uintptr((len-1)*4))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr((len - 1)))), (uint8(uv0 & uint32_t(0xff))), (uint8(uv0 >> 16)), (bottom_dst + uintptr(((len - 1) * (4)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(len-1))), uint8(uv0&uint32_t(0xff)), uint8(uv0>>16), bottom_dst+uintptr((len-1)*4))
}
}
}
func UpsampleRgbLinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len int32) { /* upsampling.c:101:1: */
var x int32
- var last_pixel_pair int32 = ((len - 1) >> 1)
- var tl_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v)))) << 16))) /* top-left sample */
- var l_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v)))) << 16))) /* left-sample */
+ var last_pixel_pair int32 = (len - 1) >> 1
+ var tl_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u))) | int32(*(*uint8_t)(unsafe.Pointer(top_v)))<<16) /* top-left sample */
+ var l_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v)))<<16) /* left-sample */
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), top_dst)
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst)
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), bottom_dst)
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst)
}
for x = 1; x <= last_pixel_pair; x++ {
- var t_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))) << 16))) /* top sample */
- var uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))) << 16))) /* sample */ /* precompute invariant values associated with first and second diagonals*/
- var avg uint32_t = ((((tl_uv + t_uv) + l_uv) + uv) + 0x00080008)
- var diag_12 uint32_t = ((avg + (uint32_t(2) * (t_uv + l_uv))) >> 3)
- var diag_03 uint32_t = ((avg + (uint32_t(2) * (tl_uv + uv))) >> 3)
+ var t_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))<<16) /* top sample */
+ var uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))<<16) /* sample */ /* precompute invariant values associated with first and second diagonals*/
+ var avg uint32_t = tl_uv + t_uv + l_uv + uv + 0x00080008
+ var diag_12 uint32_t = (avg + uint32_t(2)*(t_uv+l_uv)) >> 3
+ var diag_03 uint32_t = (avg + uint32_t(2)*(tl_uv+uv)) >> 3
{
- var uv0 uint32_t = ((diag_12 + tl_uv) >> 1)
- var uv1 uint32_t = ((diag_03 + t_uv) >> 1)
- VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (top_dst + uintptr((((2 * x) - 1) * (3)))))
- VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 0))))), (int32(uv1 & uint32_t(0xff))), (int32(uv1 >> 16)), (top_dst + uintptr((((2 * x) - 0) * (3)))))
+ var uv0 uint32_t = (diag_12 + tl_uv) >> 1
+ var uv1 uint32_t = (diag_03 + t_uv) >> 1
+ VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst+uintptr((2*x-1)*3))
+ VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-0)))), int32(uv1&uint32_t(0xff)), int32(uv1>>16), top_dst+uintptr((2*x-0)*3))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((diag_03 + l_uv) >> 1)
- var uv1 uint32_t = ((diag_12 + uv) >> 1)
- VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (bottom_dst + uintptr((((2 * x) - 1) * (3)))))
- VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) + 0))))), (int32(uv1 & uint32_t(0xff))), (int32(uv1 >> 16)), (bottom_dst + uintptr((((2 * x) + 0) * (3)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (diag_03 + l_uv) >> 1
+ var uv1 uint32_t = (diag_12 + uv) >> 1
+ VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst+uintptr((2*x-1)*3))
+ VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x+0)))), int32(uv1&uint32_t(0xff)), int32(uv1>>16), bottom_dst+uintptr((2*x+0)*3))
}
tl_uv = t_uv
l_uv = uv
}
- if !((len & 1) != 0) {
+ if !(len&1 != 0) {
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr((len - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (top_dst + uintptr(((len - 1) * (3)))))
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(len-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst+uintptr((len-1)*3))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr((len - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (bottom_dst + uintptr(((len - 1) * (3)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(len-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst+uintptr((len-1)*3))
}
}
}
func UpsampleBgrLinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len int32) { /* upsampling.c:102:1: */
var x int32
- var last_pixel_pair int32 = ((len - 1) >> 1)
- var tl_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v)))) << 16))) /* top-left sample */
- var l_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v)))) << 16))) /* left-sample */
+ var last_pixel_pair int32 = (len - 1) >> 1
+ var tl_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u))) | int32(*(*uint8_t)(unsafe.Pointer(top_v)))<<16) /* top-left sample */
+ var l_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v)))<<16) /* left-sample */
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), top_dst)
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst)
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), bottom_dst)
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst)
}
for x = 1; x <= last_pixel_pair; x++ {
- var t_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))) << 16))) /* top sample */
- var uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))) << 16))) /* sample */ /* precompute invariant values associated with first and second diagonals*/
- var avg uint32_t = ((((tl_uv + t_uv) + l_uv) + uv) + 0x00080008)
- var diag_12 uint32_t = ((avg + (uint32_t(2) * (t_uv + l_uv))) >> 3)
- var diag_03 uint32_t = ((avg + (uint32_t(2) * (tl_uv + uv))) >> 3)
+ var t_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))<<16) /* top sample */
+ var uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))<<16) /* sample */ /* precompute invariant values associated with first and second diagonals*/
+ var avg uint32_t = tl_uv + t_uv + l_uv + uv + 0x00080008
+ var diag_12 uint32_t = (avg + uint32_t(2)*(t_uv+l_uv)) >> 3
+ var diag_03 uint32_t = (avg + uint32_t(2)*(tl_uv+uv)) >> 3
{
- var uv0 uint32_t = ((diag_12 + tl_uv) >> 1)
- var uv1 uint32_t = ((diag_03 + t_uv) >> 1)
- VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (top_dst + uintptr((((2 * x) - 1) * (3)))))
- VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 0))))), (int32(uv1 & uint32_t(0xff))), (int32(uv1 >> 16)), (top_dst + uintptr((((2 * x) - 0) * (3)))))
+ var uv0 uint32_t = (diag_12 + tl_uv) >> 1
+ var uv1 uint32_t = (diag_03 + t_uv) >> 1
+ VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst+uintptr((2*x-1)*3))
+ VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-0)))), int32(uv1&uint32_t(0xff)), int32(uv1>>16), top_dst+uintptr((2*x-0)*3))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((diag_03 + l_uv) >> 1)
- var uv1 uint32_t = ((diag_12 + uv) >> 1)
- VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (bottom_dst + uintptr((((2 * x) - 1) * (3)))))
- VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) + 0))))), (int32(uv1 & uint32_t(0xff))), (int32(uv1 >> 16)), (bottom_dst + uintptr((((2 * x) + 0) * (3)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (diag_03 + l_uv) >> 1
+ var uv1 uint32_t = (diag_12 + uv) >> 1
+ VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst+uintptr((2*x-1)*3))
+ VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x+0)))), int32(uv1&uint32_t(0xff)), int32(uv1>>16), bottom_dst+uintptr((2*x+0)*3))
}
tl_uv = t_uv
l_uv = uv
}
- if !((len & 1) != 0) {
+ if !(len&1 != 0) {
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr((len - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (top_dst + uintptr(((len - 1) * (3)))))
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(len-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst+uintptr((len-1)*3))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr((len - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (bottom_dst + uintptr(((len - 1) * (3)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(len-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst+uintptr((len-1)*3))
}
}
}
func UpsampleRgba4444LinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len int32) { /* upsampling.c:103:1: */
var x int32
- var last_pixel_pair int32 = ((len - 1) >> 1)
- var tl_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v)))) << 16))) /* top-left sample */
- var l_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v)))) << 16))) /* left-sample */
+ var last_pixel_pair int32 = (len - 1) >> 1
+ var tl_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u))) | int32(*(*uint8_t)(unsafe.Pointer(top_v)))<<16) /* top-left sample */
+ var l_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v)))<<16) /* left-sample */
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), top_dst)
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst)
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), bottom_dst)
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst)
}
for x = 1; x <= last_pixel_pair; x++ {
- var t_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))) << 16))) /* top sample */
- var uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))) << 16))) /* sample */ /* precompute invariant values associated with first and second diagonals*/
- var avg uint32_t = ((((tl_uv + t_uv) + l_uv) + uv) + 0x00080008)
- var diag_12 uint32_t = ((avg + (uint32_t(2) * (t_uv + l_uv))) >> 3)
- var diag_03 uint32_t = ((avg + (uint32_t(2) * (tl_uv + uv))) >> 3)
+ var t_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))<<16) /* top sample */
+ var uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))<<16) /* sample */ /* precompute invariant values associated with first and second diagonals*/
+ var avg uint32_t = tl_uv + t_uv + l_uv + uv + 0x00080008
+ var diag_12 uint32_t = (avg + uint32_t(2)*(t_uv+l_uv)) >> 3
+ var diag_03 uint32_t = (avg + uint32_t(2)*(tl_uv+uv)) >> 3
{
- var uv0 uint32_t = ((diag_12 + tl_uv) >> 1)
- var uv1 uint32_t = ((diag_03 + t_uv) >> 1)
- VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (top_dst + uintptr((((2 * x) - 1) * (2)))))
- VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 0))))), (int32(uv1 & uint32_t(0xff))), (int32(uv1 >> 16)), (top_dst + uintptr((((2 * x) - 0) * (2)))))
+ var uv0 uint32_t = (diag_12 + tl_uv) >> 1
+ var uv1 uint32_t = (diag_03 + t_uv) >> 1
+ VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst+uintptr((2*x-1)*2))
+ VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-0)))), int32(uv1&uint32_t(0xff)), int32(uv1>>16), top_dst+uintptr((2*x-0)*2))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((diag_03 + l_uv) >> 1)
- var uv1 uint32_t = ((diag_12 + uv) >> 1)
- VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (bottom_dst + uintptr((((2 * x) - 1) * (2)))))
- VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) + 0))))), (int32(uv1 & uint32_t(0xff))), (int32(uv1 >> 16)), (bottom_dst + uintptr((((2 * x) + 0) * (2)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (diag_03 + l_uv) >> 1
+ var uv1 uint32_t = (diag_12 + uv) >> 1
+ VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst+uintptr((2*x-1)*2))
+ VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x+0)))), int32(uv1&uint32_t(0xff)), int32(uv1>>16), bottom_dst+uintptr((2*x+0)*2))
}
tl_uv = t_uv
l_uv = uv
}
- if !((len & 1) != 0) {
+ if !(len&1 != 0) {
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr((len - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (top_dst + uintptr(((len - 1) * (2)))))
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(len-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst+uintptr((len-1)*2))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr((len - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (bottom_dst + uintptr(((len - 1) * (2)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(len-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst+uintptr((len-1)*2))
}
}
}
func UpsampleRgb565LinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len int32) { /* upsampling.c:104:1: */
var x int32
- var last_pixel_pair int32 = ((len - 1) >> 1)
- var tl_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v)))) << 16))) /* top-left sample */
- var l_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u)))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v)))) << 16))) /* left-sample */
+ var last_pixel_pair int32 = (len - 1) >> 1
+ var tl_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u))) | int32(*(*uint8_t)(unsafe.Pointer(top_v)))<<16) /* top-left sample */
+ var l_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v)))<<16) /* left-sample */
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), top_dst)
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst)
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), bottom_dst)
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst)
}
for x = 1; x <= last_pixel_pair; x++ {
- var t_uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))) << 16))) /* top sample */
- var uv uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x))))) | ((int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))) << 16))) /* sample */ /* precompute invariant values associated with first and second diagonals*/
- var avg uint32_t = ((((tl_uv + t_uv) + l_uv) + uv) + 0x00080008)
- var diag_12 uint32_t = ((avg + (uint32_t(2) * (t_uv + l_uv))) >> 3)
- var diag_03 uint32_t = ((avg + (uint32_t(2) * (tl_uv + uv))) >> 3)
+ var t_uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(top_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(top_v + uintptr(x))))<<16) /* top sample */
+ var uv uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(cur_u + uintptr(x)))) | int32(*(*uint8_t)(unsafe.Pointer(cur_v + uintptr(x))))<<16) /* sample */ /* precompute invariant values associated with first and second diagonals*/
+ var avg uint32_t = tl_uv + t_uv + l_uv + uv + 0x00080008
+ var diag_12 uint32_t = (avg + uint32_t(2)*(t_uv+l_uv)) >> 3
+ var diag_03 uint32_t = (avg + uint32_t(2)*(tl_uv+uv)) >> 3
{
- var uv0 uint32_t = ((diag_12 + tl_uv) >> 1)
- var uv1 uint32_t = ((diag_03 + t_uv) >> 1)
- VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (top_dst + uintptr((((2 * x) - 1) * (2)))))
- VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(((2 * x) - 0))))), (int32(uv1 & uint32_t(0xff))), (int32(uv1 >> 16)), (top_dst + uintptr((((2 * x) - 0) * (2)))))
+ var uv0 uint32_t = (diag_12 + tl_uv) >> 1
+ var uv1 uint32_t = (diag_03 + t_uv) >> 1
+ VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst+uintptr((2*x-1)*2))
+ VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(2*x-0)))), int32(uv1&uint32_t(0xff)), int32(uv1>>16), top_dst+uintptr((2*x-0)*2))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((diag_03 + l_uv) >> 1)
- var uv1 uint32_t = ((diag_12 + uv) >> 1)
- VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (bottom_dst + uintptr((((2 * x) - 1) * (2)))))
- VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(((2 * x) + 0))))), (int32(uv1 & uint32_t(0xff))), (int32(uv1 >> 16)), (bottom_dst + uintptr((((2 * x) + 0) * (2)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (diag_03 + l_uv) >> 1
+ var uv1 uint32_t = (diag_12 + uv) >> 1
+ VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst+uintptr((2*x-1)*2))
+ VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(2*x+0)))), int32(uv1&uint32_t(0xff)), int32(uv1>>16), bottom_dst+uintptr((2*x+0)*2))
}
tl_uv = t_uv
l_uv = uv
}
- if !((len & 1) != 0) {
+ if !(len&1 != 0) {
{
- var uv0 uint32_t = ((((uint32_t(3) * tl_uv) + l_uv) + 0x00020002) >> 2)
- VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr((len - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (top_dst + uintptr(((len - 1) * (2)))))
+ var uv0 uint32_t = (uint32_t(3)*tl_uv + l_uv + 0x00020002) >> 2
+ VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(top_y + uintptr(len-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), top_dst+uintptr((len-1)*2))
}
- if bottom_y != (uintptr(0)) {
- var uv0 uint32_t = ((((uint32_t(3) * l_uv) + tl_uv) + 0x00020002) >> 2)
- VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr((len - 1))))), (int32(uv0 & uint32_t(0xff))), (int32(uv0 >> 16)), (bottom_dst + uintptr(((len - 1) * (2)))))
+ if bottom_y != uintptr(0) {
+ var uv0 uint32_t = (uint32_t(3)*l_uv + tl_uv + 0x00020002) >> 2
+ VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(bottom_y + uintptr(len-1)))), int32(uv0&uint32_t(0xff)), int32(uv0>>16), bottom_dst+uintptr((len-1)*2))
}
}
}
@@ -20934,56 +20674,56 @@ func WebPGetLinePairConverter(tls *libc.TLS, alpha_is_last int32) WebPUpsampleLi
func WebPYuv444ToRgba_C(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* upsampling.c:189:1: */
var i int32
for i = 0; i < len; i++ {
- VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(y + uintptr(i))), *(*uint8_t)(unsafe.Pointer(u + uintptr(i))), *(*uint8_t)(unsafe.Pointer(v + uintptr(i))), (dst + uintptr((i * (4)))))
+ VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(y + uintptr(i))), *(*uint8_t)(unsafe.Pointer(u + uintptr(i))), *(*uint8_t)(unsafe.Pointer(v + uintptr(i))), dst+uintptr(i*4))
}
}
func WebPYuv444ToBgra_C(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* upsampling.c:190:1: */
var i int32
for i = 0; i < len; i++ {
- VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(y + uintptr(i))), *(*uint8_t)(unsafe.Pointer(u + uintptr(i))), *(*uint8_t)(unsafe.Pointer(v + uintptr(i))), (dst + uintptr((i * (4)))))
+ VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(y + uintptr(i))), *(*uint8_t)(unsafe.Pointer(u + uintptr(i))), *(*uint8_t)(unsafe.Pointer(v + uintptr(i))), dst+uintptr(i*4))
}
}
func WebPYuv444ToRgb_C(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* upsampling.c:192:1: */
var i int32
for i = 0; i < len; i++ {
- VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(y + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))), (dst + uintptr((i * (3)))))
+ VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(y + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))), dst+uintptr(i*3))
}
}
func WebPYuv444ToBgr_C(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* upsampling.c:193:1: */
var i int32
for i = 0; i < len; i++ {
- VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(y + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))), (dst + uintptr((i * (3)))))
+ VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(y + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))), dst+uintptr(i*3))
}
}
func WebPYuv444ToArgb_C(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* upsampling.c:194:1: */
var i int32
for i = 0; i < len; i++ {
- VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(y + uintptr(i))), *(*uint8_t)(unsafe.Pointer(u + uintptr(i))), *(*uint8_t)(unsafe.Pointer(v + uintptr(i))), (dst + uintptr((i * (4)))))
+ VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(y + uintptr(i))), *(*uint8_t)(unsafe.Pointer(u + uintptr(i))), *(*uint8_t)(unsafe.Pointer(v + uintptr(i))), dst+uintptr(i*4))
}
}
func WebPYuv444ToRgba4444_C(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* upsampling.c:195:1: */
var i int32
for i = 0; i < len; i++ {
- VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(y + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))), (dst + uintptr((i * (2)))))
+ VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(y + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))), dst+uintptr(i*2))
}
}
func WebPYuv444ToRgb565_C(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* upsampling.c:196:1: */
var i int32
for i = 0; i < len; i++ {
- VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(y + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))), (dst + uintptr((i * (2)))))
+ VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(y + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))), int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))), dst+uintptr(i*2))
}
}
var WebPYUV444Converters [13]WebPYUV444Converter /* upsampling.c:216:21: */
func WebPInitYUV444Converters(tls *libc.TLS) { /* upsampling.c:222:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if WebPInitYUV444Converters_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -21029,12 +20769,12 @@ func WebPInitYUV444Converters_body(tls *libc.TLS) { /* upsampling.c:222:1: */
f func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, int32)
}{WebPYuv444ToRgba4444_C}))
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
func WebPInitUpsamplers(tls *libc.TLS) { /* upsampling.c:263:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if WebPInitUpsamplers_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -21081,7 +20821,7 @@ func WebPInitUpsamplers_body(tls *libc.TLS) { /* upsampling.c:263:1: */
}{UpsampleRgba4444LinePair_C}))
// If defined, use CPUInfo() to overwrite some pointers with faster versions.
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -21131,106 +20871,106 @@ func WebPInitUpsamplers_body(tls *libc.TLS) { /* upsampling.c:263:1: */
// All variants implemented.
func YuvToRgbRow(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* yuv.c:41:1: */
- var end uintptr = (dst + uintptr(((len & libc.CplInt32(1)) * (3))))
+ var end uintptr = dst + uintptr(len&libc.CplInt32(1)*3)
for dst != end {
VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(y))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst)
- VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(y + 1))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), (dst + uintptr((3))))
+ VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(y + 1))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst+uintptr(3))
y += uintptr(2)
u++
v++
- dst += (uintptr(2 * (3)))
+ dst += uintptr(2 * 3)
}
- if (len & 1) != 0 {
+ if len&1 != 0 {
VP8YuvToRgb(tls, int32(*(*uint8_t)(unsafe.Pointer(y))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst)
}
}
func YuvToBgrRow(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* yuv.c:42:1: */
- var end uintptr = (dst + uintptr(((len & libc.CplInt32(1)) * (3))))
+ var end uintptr = dst + uintptr(len&libc.CplInt32(1)*3)
for dst != end {
VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(y))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst)
- VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(y + 1))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), (dst + uintptr((3))))
+ VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(y + 1))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst+uintptr(3))
y += uintptr(2)
u++
v++
- dst += (uintptr(2 * (3)))
+ dst += uintptr(2 * 3)
}
- if (len & 1) != 0 {
+ if len&1 != 0 {
VP8YuvToBgr(tls, int32(*(*uint8_t)(unsafe.Pointer(y))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst)
}
}
func YuvToRgbaRow(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* yuv.c:43:1: */
- var end uintptr = (dst + uintptr(((len & libc.CplInt32(1)) * (4))))
+ var end uintptr = dst + uintptr(len&libc.CplInt32(1)*4)
for dst != end {
VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(y)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), dst)
- VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(y + 1)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), (dst + uintptr((4))))
+ VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(y + 1)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), dst+uintptr(4))
y += uintptr(2)
u++
v++
- dst += (uintptr(2 * (4)))
+ dst += uintptr(2 * 4)
}
- if (len & 1) != 0 {
+ if len&1 != 0 {
VP8YuvToRgba(tls, *(*uint8_t)(unsafe.Pointer(y)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), dst)
}
}
func YuvToBgraRow(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* yuv.c:44:1: */
- var end uintptr = (dst + uintptr(((len & libc.CplInt32(1)) * (4))))
+ var end uintptr = dst + uintptr(len&libc.CplInt32(1)*4)
for dst != end {
VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(y)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), dst)
- VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(y + 1)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), (dst + uintptr((4))))
+ VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(y + 1)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), dst+uintptr(4))
y += uintptr(2)
u++
v++
- dst += (uintptr(2 * (4)))
+ dst += uintptr(2 * 4)
}
- if (len & 1) != 0 {
+ if len&1 != 0 {
VP8YuvToBgra(tls, *(*uint8_t)(unsafe.Pointer(y)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), dst)
}
}
func YuvToArgbRow(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* yuv.c:45:1: */
- var end uintptr = (dst + uintptr(((len & libc.CplInt32(1)) * (4))))
+ var end uintptr = dst + uintptr(len&libc.CplInt32(1)*4)
for dst != end {
VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(y)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), dst)
- VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(y + 1)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), (dst + uintptr((4))))
+ VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(y + 1)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), dst+uintptr(4))
y += uintptr(2)
u++
v++
- dst += (uintptr(2 * (4)))
+ dst += uintptr(2 * 4)
}
- if (len & 1) != 0 {
+ if len&1 != 0 {
VP8YuvToArgb(tls, *(*uint8_t)(unsafe.Pointer(y)), *(*uint8_t)(unsafe.Pointer(u)), *(*uint8_t)(unsafe.Pointer(v)), dst)
}
}
func YuvToRgba4444Row(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* yuv.c:46:1: */
- var end uintptr = (dst + uintptr(((len & libc.CplInt32(1)) * (2))))
+ var end uintptr = dst + uintptr(len&libc.CplInt32(1)*2)
for dst != end {
VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(y))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst)
- VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(y + 1))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), (dst + uintptr((2))))
+ VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(y + 1))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst+uintptr(2))
y += uintptr(2)
u++
v++
- dst += (uintptr(2 * (2)))
+ dst += uintptr(2 * 2)
}
- if (len & 1) != 0 {
+ if len&1 != 0 {
VP8YuvToRgba4444(tls, int32(*(*uint8_t)(unsafe.Pointer(y))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst)
}
}
func YuvToRgb565Row(tls *libc.TLS, y uintptr, u uintptr, v uintptr, dst uintptr, len int32) { /* yuv.c:47:1: */
- var end uintptr = (dst + uintptr(((len & libc.CplInt32(1)) * (2))))
+ var end uintptr = dst + uintptr(len&libc.CplInt32(1)*2)
for dst != end {
VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(y))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst)
- VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(y + 1))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), (dst + uintptr((2))))
+ VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(y + 1))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst+uintptr(2))
y += uintptr(2)
u++
v++
- dst += (uintptr(2 * (2)))
+ dst += uintptr(2 * 2)
}
- if (len & 1) != 0 {
+ if len&1 != 0 {
VP8YuvToRgb565(tls, int32(*(*uint8_t)(unsafe.Pointer(y))), int32(*(*uint8_t)(unsafe.Pointer(u))), int32(*(*uint8_t)(unsafe.Pointer(v))), dst)
}
}
@@ -21243,7 +20983,7 @@ func WebPSamplerProcessPlane(tls *libc.TLS, y uintptr, y_stride int32, u uintptr
f func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, int32)
})(unsafe.Pointer(&struct{ uintptr }{func1})).f(tls, y, u, v, dst, width)
y += uintptr(y_stride)
- if (j & 1) != 0 {
+ if j&1 != 0 {
u += uintptr(uv_stride)
v += uintptr(uv_stride)
}
@@ -21257,7 +20997,7 @@ func WebPSamplerProcessPlane(tls *libc.TLS, y uintptr, y_stride int32, u uintptr
var WebPSamplers [13]WebPSamplerRowFunc /* yuv.c:71:20: */
func WebPInitSamplers(tls *libc.TLS) { /* yuv.c:78:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if WebPInitSamplers_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -21304,7 +21044,7 @@ func WebPInitSamplers_body(tls *libc.TLS) { /* yuv.c:78:1: */
}{YuvToRgba4444Row}))
// If defined, use CPUInfo() to overwrite some pointers with faster versions.
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -21315,47 +21055,47 @@ func ConvertARGBToY_C(tls *libc.TLS, argb uintptr, y uintptr, width int32) { /*
var i int32
for i = 0; i < width; i++ {
var p uint32_t = *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4))
- *(*uint8_t)(unsafe.Pointer(y + uintptr(i))) = uint8_t(VP8RGBToY(tls, (int32((p >> 16) & uint32_t(0xff))), (int32((p >> 8) & uint32_t(0xff))), (int32((p >> 0) & uint32_t(0xff))),
+ *(*uint8_t)(unsafe.Pointer(y + uintptr(i))) = uint8_t(VP8RGBToY(tls, int32(p>>16&uint32_t(0xff)), int32(p>>8&uint32_t(0xff)), int32(p>>0&uint32_t(0xff)),
YUV_HALF))
}
}
func WebPConvertARGBToUV_C(tls *libc.TLS, argb uintptr, u uintptr, v uintptr, src_width int32, do_store int32) { /* yuv.c:128:6: */
// No rounding. Last pixel is dealt with separately.
- var uv_width int32 = (src_width >> 1)
+ var uv_width int32 = src_width >> 1
var i int32
for i = 0; i < uv_width; i++ {
- var v0 uint32_t = *(*uint32_t)(unsafe.Pointer(argb + uintptr(((2*i)+0))*4))
- var v1 uint32_t = *(*uint32_t)(unsafe.Pointer(argb + uintptr(((2*i)+1))*4))
+ var v0 uint32_t = *(*uint32_t)(unsafe.Pointer(argb + uintptr(2*i+0)*4))
+ var v1 uint32_t = *(*uint32_t)(unsafe.Pointer(argb + uintptr(2*i+1)*4))
// VP8RGBToU/V expects four accumulated pixels. Hence we need to
// scale r/g/b value by a factor 2. We just shift v0/v1 one bit less.
- var r int32 = (int32(((v0 >> 15) & uint32_t(0x1fe)) + ((v1 >> 15) & uint32_t(0x1fe))))
- var g int32 = (int32(((v0 >> 7) & uint32_t(0x1fe)) + ((v1 >> 7) & uint32_t(0x1fe))))
- var b int32 = (int32(((v0 << 1) & uint32_t(0x1fe)) + ((v1 << 1) & uint32_t(0x1fe))))
- var tmp_u int32 = VP8RGBToU(tls, r, g, b, (int32(YUV_HALF) << 2))
- var tmp_v int32 = VP8RGBToV(tls, r, g, b, (int32(YUV_HALF) << 2))
+ var r int32 = int32(v0>>15&uint32_t(0x1fe) + v1>>15&uint32_t(0x1fe))
+ var g int32 = int32(v0>>7&uint32_t(0x1fe) + v1>>7&uint32_t(0x1fe))
+ var b int32 = int32(v0<<1&uint32_t(0x1fe) + v1<<1&uint32_t(0x1fe))
+ var tmp_u int32 = VP8RGBToU(tls, r, g, b, int32(YUV_HALF)<<2)
+ var tmp_v int32 = VP8RGBToV(tls, r, g, b, int32(YUV_HALF)<<2)
if do_store != 0 {
*(*uint8_t)(unsafe.Pointer(u + uintptr(i))) = uint8_t(tmp_u)
*(*uint8_t)(unsafe.Pointer(v + uintptr(i))) = uint8_t(tmp_v)
} else {
// Approximated average-of-four. But it's an acceptable diff.
- *(*uint8_t)(unsafe.Pointer(u + uintptr(i))) = (uint8_t(((int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))) + tmp_u) + 1) >> 1))
- *(*uint8_t)(unsafe.Pointer(v + uintptr(i))) = (uint8_t(((int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))) + tmp_v) + 1) >> 1))
+ *(*uint8_t)(unsafe.Pointer(u + uintptr(i))) = uint8_t((int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))) + tmp_u + 1) >> 1)
+ *(*uint8_t)(unsafe.Pointer(v + uintptr(i))) = uint8_t((int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))) + tmp_v + 1) >> 1)
}
}
- if (src_width & 1) != 0 { // last pixel
- var v0 uint32_t = *(*uint32_t)(unsafe.Pointer(argb + uintptr(((2*i)+0))*4))
- var r int32 = (int32((v0 >> 14) & uint32_t(0x3fc)))
- var g int32 = (int32((v0 >> 6) & uint32_t(0x3fc)))
- var b int32 = (int32((v0 << 2) & uint32_t(0x3fc)))
- var tmp_u int32 = VP8RGBToU(tls, r, g, b, (int32(YUV_HALF) << 2))
- var tmp_v int32 = VP8RGBToV(tls, r, g, b, (int32(YUV_HALF) << 2))
+ if src_width&1 != 0 { // last pixel
+ var v0 uint32_t = *(*uint32_t)(unsafe.Pointer(argb + uintptr(2*i+0)*4))
+ var r int32 = int32(v0 >> 14 & uint32_t(0x3fc))
+ var g int32 = int32(v0 >> 6 & uint32_t(0x3fc))
+ var b int32 = int32(v0 << 2 & uint32_t(0x3fc))
+ var tmp_u int32 = VP8RGBToU(tls, r, g, b, int32(YUV_HALF)<<2)
+ var tmp_v int32 = VP8RGBToV(tls, r, g, b, int32(YUV_HALF)<<2)
if do_store != 0 {
*(*uint8_t)(unsafe.Pointer(u + uintptr(i))) = uint8_t(tmp_u)
*(*uint8_t)(unsafe.Pointer(v + uintptr(i))) = uint8_t(tmp_v)
} else {
- *(*uint8_t)(unsafe.Pointer(u + uintptr(i))) = (uint8_t(((int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))) + tmp_u) + 1) >> 1))
- *(*uint8_t)(unsafe.Pointer(v + uintptr(i))) = (uint8_t(((int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))) + tmp_v) + 1) >> 1))
+ *(*uint8_t)(unsafe.Pointer(u + uintptr(i))) = uint8_t((int32(*(*uint8_t)(unsafe.Pointer(u + uintptr(i)))) + tmp_u + 1) >> 1)
+ *(*uint8_t)(unsafe.Pointer(v + uintptr(i))) = uint8_t((int32(*(*uint8_t)(unsafe.Pointer(v + uintptr(i)))) + tmp_v + 1) >> 1)
}
}
}
@@ -21413,14 +21153,14 @@ __1:
var r int32 = int32(*(*uint16_t)(unsafe.Pointer(rgb)))
var g int32 = int32(*(*uint16_t)(unsafe.Pointer(rgb + 1*2)))
var b int32 = int32(*(*uint16_t)(unsafe.Pointer(rgb + 2*2)))
- *(*uint8_t)(unsafe.Pointer(u + uintptr(i))) = uint8_t(VP8RGBToU(tls, r, g, b, (int32(YUV_HALF) << 2)))
- *(*uint8_t)(unsafe.Pointer(v + uintptr(i))) = uint8_t(VP8RGBToV(tls, r, g, b, (int32(YUV_HALF) << 2)))
+ *(*uint8_t)(unsafe.Pointer(u + uintptr(i))) = uint8_t(VP8RGBToU(tls, r, g, b, int32(YUV_HALF)<<2))
+ *(*uint8_t)(unsafe.Pointer(v + uintptr(i))) = uint8_t(VP8RGBToV(tls, r, g, b, int32(YUV_HALF)<<2))
}
goto __2
__2:
- i = i + (1)
- rgb += 2 * (uintptr(4))
+ i = i + 1
+ rgb += 2 * uintptr(4)
goto __1
goto __3
__3:
@@ -21432,8 +21172,8 @@ func clip_y(tls *libc.TLS, v int32) uint16_t { /* yuv.c:199:17: */
if v < 0 {
return uint16(0)
}
- if v > ((int32(1) << 10) - 1) {
- return (uint16((int32(1) << 10) - 1))
+ if v > int32(1)<<10-1 {
+ return uint16(int32(1)<<10 - 1)
}
return uint16_t(v)
}
@@ -21442,10 +21182,10 @@ func SharpYUVUpdateY_C(tls *libc.TLS, ref uintptr, src uintptr, dst uintptr, len
var diff uint64_t = uint64(0)
var i int32
for i = 0; i < len; i++ {
- var diff_y int32 = (int32(*(*uint16_t)(unsafe.Pointer(ref + uintptr(i)*2))) - int32(*(*uint16_t)(unsafe.Pointer(src + uintptr(i)*2))))
- var new_y int32 = (int32(*(*uint16_t)(unsafe.Pointer(dst + uintptr(i)*2))) + diff_y)
+ var diff_y int32 = int32(*(*uint16_t)(unsafe.Pointer(ref + uintptr(i)*2))) - int32(*(*uint16_t)(unsafe.Pointer(src + uintptr(i)*2)))
+ var new_y int32 = int32(*(*uint16_t)(unsafe.Pointer(dst + uintptr(i)*2))) + diff_y
*(*uint16_t)(unsafe.Pointer(dst + uintptr(i)*2)) = clip_y(tls, new_y)
- diff = diff + (uint64_t(libc.Xabs(tls, diff_y)))
+ diff = diff + uint64_t(libc.Xabs(tls, diff_y))
}
return diff
}
@@ -21453,8 +21193,8 @@ func SharpYUVUpdateY_C(tls *libc.TLS, ref uintptr, src uintptr, dst uintptr, len
func SharpYUVUpdateRGB_C(tls *libc.TLS, ref uintptr, src uintptr, dst uintptr, len int32) { /* yuv.c:216:13: */
var i int32
for i = 0; i < len; i++ {
- var diff_uv int32 = (int32(*(*int16_t)(unsafe.Pointer(ref + uintptr(i)*2))) - int32(*(*int16_t)(unsafe.Pointer(src + uintptr(i)*2))))
- *(*int16_t)(unsafe.Pointer((dst + uintptr(i)*2))) += int16_t((diff_uv))
+ var diff_uv int32 = int32(*(*int16_t)(unsafe.Pointer(ref + uintptr(i)*2))) - int32(*(*int16_t)(unsafe.Pointer(src + uintptr(i)*2)))
+ *(*int16_t)(unsafe.Pointer(dst + uintptr(i)*2)) += int16_t(diff_uv)
}
}
@@ -21466,10 +21206,10 @@ __1:
goto __3
}
{
- var v0 int32 = ((((((int32(*(*int16_t)(unsafe.Pointer(A))) * 9) + (int32(*(*int16_t)(unsafe.Pointer(A + 1*2))) * 3)) + (int32(*(*int16_t)(unsafe.Pointer(B))) * 3)) + int32(*(*int16_t)(unsafe.Pointer(B + 1*2)))) + 8) >> 4)
- var v1 int32 = ((((((int32(*(*int16_t)(unsafe.Pointer(A + 1*2))) * 9) + (int32(*(*int16_t)(unsafe.Pointer(A))) * 3)) + (int32(*(*int16_t)(unsafe.Pointer(B + 1*2))) * 3)) + int32(*(*int16_t)(unsafe.Pointer(B)))) + 8) >> 4)
- *(*uint16_t)(unsafe.Pointer(out + uintptr(((2*i)+0))*2)) = clip_y(tls, (int32(*(*uint16_t)(unsafe.Pointer(best_y + uintptr(((2*i)+0))*2))) + v0))
- *(*uint16_t)(unsafe.Pointer(out + uintptr(((2*i)+1))*2)) = clip_y(tls, (int32(*(*uint16_t)(unsafe.Pointer(best_y + uintptr(((2*i)+1))*2))) + v1))
+ var v0 int32 = (int32(*(*int16_t)(unsafe.Pointer(A)))*9 + int32(*(*int16_t)(unsafe.Pointer(A + 1*2)))*3 + int32(*(*int16_t)(unsafe.Pointer(B)))*3 + int32(*(*int16_t)(unsafe.Pointer(B + 1*2))) + 8) >> 4
+ var v1 int32 = (int32(*(*int16_t)(unsafe.Pointer(A + 1*2)))*9 + int32(*(*int16_t)(unsafe.Pointer(A)))*3 + int32(*(*int16_t)(unsafe.Pointer(B + 1*2)))*3 + int32(*(*int16_t)(unsafe.Pointer(B))) + 8) >> 4
+ *(*uint16_t)(unsafe.Pointer(out + uintptr(2*i+0)*2)) = clip_y(tls, int32(*(*uint16_t)(unsafe.Pointer(best_y + uintptr(2*i+0)*2)))+v0)
+ *(*uint16_t)(unsafe.Pointer(out + uintptr(2*i+1)*2)) = clip_y(tls, int32(*(*uint16_t)(unsafe.Pointer(best_y + uintptr(2*i+1)*2)))+v1)
}
goto __2
@@ -21496,7 +21236,7 @@ var WebPSharpYUVUpdateRGB uintptr /* yuv.c:252:6: */
var WebPSharpYUVFilterRow uintptr /* yuv.c:254:6: */
func WebPInitConvertARGBToYUV(tls *libc.TLS) { /* yuv.c:263:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if WebPInitConvertARGBToYUV_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -21536,7 +21276,7 @@ func WebPInitConvertARGBToYUV_body(tls *libc.TLS) { /* yuv.c:263:1: */
f func(*libc.TLS, uintptr, uintptr, int32, uintptr, uintptr)
}{SharpYUVFilterRow_C}))
- if VP8GetCPUInfo != (uintptr(0)) {
+ if VP8GetCPUInfo != uintptr(0) {
}
}
@@ -21795,12 +21535,12 @@ func EncodeLossless(tls *libc.TLS, data uintptr, width int32, height int32, effo
// var picture WebPPicture at bp, 256
- WebPPictureInit(tls, (bp) /* &picture */)
+ WebPPictureInit(tls, bp)
(*WebPPicture)(unsafe.Pointer(bp /* &picture */)).width = width
(*WebPPicture)(unsafe.Pointer(bp /* &picture */)).height = height
(*WebPPicture)(unsafe.Pointer(bp /* &picture */)).use_argb = 1
(*WebPPicture)(unsafe.Pointer(bp /* &picture */)).stats = stats
- if !(WebPPictureAlloc(tls, (bp) /* &picture */) != 0) {
+ if !(WebPPictureAlloc(tls, bp) != 0) {
return 0
}
@@ -21810,7 +21550,7 @@ func EncodeLossless(tls *libc.TLS, data uintptr, width int32, height int32, effo
})(unsafe.Pointer(&struct{ uintptr }{WebPDispatchAlphaToGreen})).f(tls, data, width, (*WebPPicture)(unsafe.Pointer(bp /* &picture */)).width, (*WebPPicture)(unsafe.Pointer(bp /* &picture */)).height,
(*WebPPicture)(unsafe.Pointer(bp /* &picture */)).argb, (*WebPPicture)(unsafe.Pointer(bp /* &picture */)).argb_stride)
- WebPConfigInit(tls, (bp + 256) /* &config */)
+ WebPConfigInit(tls, bp+256)
(*WebPConfig)(unsafe.Pointer(bp + 256 /* &config */)).lossless = 1
// Enable exact, or it would alter RGB values of transparent alpha, which is
// normally OK but not here since we are not encoding the input image but an
@@ -21824,19 +21564,19 @@ func EncodeLossless(tls *libc.TLS, data uintptr, width int32, height int32, effo
// If the alpha quality is set to 100 and the method to 6, allow for a high
// lossless quality to trigger the cruncher.
(*WebPConfig)(unsafe.Pointer(bp + 256 /* &config */)).quality = func() float32 {
- if (use_quality_100 != 0) && (effort_level == 6) {
+ if use_quality_100 != 0 && effort_level == 6 {
return float32(100)
}
- return (8. * float32(effort_level))
+ return 8. * float32(effort_level)
}()
// TODO(urvang): Temporary fix to avoid generating images that trigger
// a decoder bug related to alpha with color cache.
// See: https://code.google.com/p/webp/issues/detail?id=239
// Need to re-enable this later.
- ok = (libc.Bool32(VP8LEncodeStream(tls, (bp+256) /* &config */, (bp) /* &picture */, bw, 0) == VP8_ENC_OK))
- WebPPictureFree(tls, (bp) /* &picture */)
- ok = (libc.Bool32((ok != 0) && !((*VP8LBitWriter)(unsafe.Pointer(bw)).error_ != 0)))
+ ok = libc.Bool32(VP8LEncodeStream(tls, bp+256, bp, bw, 0) == VP8_ENC_OK)
+ WebPPictureFree(tls, bp)
+ ok = libc.Bool32(ok != 0 && !((*VP8LBitWriter)(unsafe.Pointer(bw)).error_ != 0))
if !(ok != 0) {
VP8LBitWriterWipeOut(tls, bw)
return 0
@@ -21864,15 +21604,15 @@ func EncodeAlphaInternal(tls *libc.TLS, data uintptr, width int32, height int32,
var filter_func WebPFilterFunc
// var header uint8_t at bp+48, 1
- var data_size size_t = (size_t(width * height))
- var output uintptr = (uintptr(0))
+ var data_size size_t = size_t(width * height)
+ var output uintptr = uintptr(0)
var output_size size_t = uint64(0)
// var tmp_bw VP8LBitWriter at bp, 48
// as per spec
filter_func = WebPFilters[filter]
- if filter_func != (uintptr(0)) {
+ if filter_func != uintptr(0) {
(*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, uintptr)
})(unsafe.Pointer(&struct{ uintptr }{filter_func})).f(tls, data, width, height, width, tmp_alpha)
@@ -21882,19 +21622,19 @@ func EncodeAlphaInternal(tls *libc.TLS, data uintptr, width int32, height int32,
}
if method != 0 {
- ok = VP8LBitWriterInit(tls, (bp) /* &tmp_bw */, (data_size >> 3))
- ok = (libc.Bool32((ok != 0) && (EncodeLossless(tls, alpha_src, width, height, effort_level,
- libc.BoolInt32(!(reduce_levels != 0)), (bp) /* &tmp_bw */, (result+56 /* &.stats */)) != 0)))
+ ok = VP8LBitWriterInit(tls, bp, data_size>>3)
+ ok = libc.Bool32(ok != 0 && EncodeLossless(tls, alpha_src, width, height, effort_level,
+ libc.BoolInt32(!(reduce_levels != 0)), bp, result+56) != 0)
if ok != 0 {
- output = VP8LBitWriterFinish(tls, (bp) /* &tmp_bw */)
- output_size = VP8LBitWriterNumBytes(tls, (bp) /* &tmp_bw */)
+ output = VP8LBitWriterFinish(tls, bp)
+ output_size = VP8LBitWriterNumBytes(tls, bp)
if output_size > data_size {
// compressed size is larger than source! Revert to uncompressed mode.
method = 0
- VP8LBitWriterWipeOut(tls, (bp) /* &tmp_bw */)
+ VP8LBitWriterWipeOut(tls, bp)
}
} else {
- VP8LBitWriterWipeOut(tls, (bp) /* &tmp_bw */)
+ VP8LBitWriterWipeOut(tls, bp)
return 0
}
}
@@ -21906,20 +21646,20 @@ func EncodeAlphaInternal(tls *libc.TLS, data uintptr, width int32, height int32,
}
// Emit final result.
- *(*uint8_t)(unsafe.Pointer(bp + 48 /* header */)) = (uint8_t(method | (filter << 2)))
+ *(*uint8_t)(unsafe.Pointer(bp + 48 /* header */)) = uint8_t(method | filter<<2)
if reduce_levels != 0 {
- *(*uint8_t)(unsafe.Pointer(bp + 48 /* header */)) |= uint8_t((int32(1) << 4))
+ *(*uint8_t)(unsafe.Pointer(bp + 48 /* header */)) |= uint8_t(int32(1) << 4)
}
- VP8BitWriterInit(tls, (result + 8 /* &.bw */), (uint64(1) + output_size))
- ok = (libc.Bool32((ok != 0) && (VP8BitWriterAppend(tls, (result+8 /* &.bw */), (bp+48) /* &header */, uint64(1)) != 0)))
- ok = (libc.Bool32((ok != 0) && (VP8BitWriterAppend(tls, (result+8 /* &.bw */), output, output_size) != 0)))
+ VP8BitWriterInit(tls, result+8, uint64(1)+output_size)
+ ok = libc.Bool32(ok != 0 && VP8BitWriterAppend(tls, result+8, bp+48, uint64(1)) != 0)
+ ok = libc.Bool32(ok != 0 && VP8BitWriterAppend(tls, result+8, output, output_size) != 0)
if method != 0 {
- VP8LBitWriterWipeOut(tls, (bp) /* &tmp_bw */)
+ VP8LBitWriterWipeOut(tls, bp)
}
- ok = (libc.Bool32((ok != 0) && !((*FilterTrial)(unsafe.Pointer(result)).bw.error_ != 0)))
- (*FilterTrial)(unsafe.Pointer(result)).score = VP8BitWriterSize(tls, (result + 8 /* &.bw */))
+ ok = libc.Bool32(ok != 0 && !((*FilterTrial)(unsafe.Pointer(result)).bw.error_ != 0))
+ (*FilterTrial)(unsafe.Pointer(result)).score = VP8BitWriterSize(tls, result+8)
return ok
}
@@ -21935,13 +21675,13 @@ func GetNumColors(tls *libc.TLS, data uintptr, width int32, height int32, stride
for j = 0; j < height; j++ {
var i int32
- var p uintptr = (data + uintptr((j * stride)))
+ var p uintptr = data + uintptr(j*stride)
for i = 0; i < width; i++ {
- *(*uint8_t)(unsafe.Pointer((bp) /* &color[0] */ + uintptr(*(*uint8_t)(unsafe.Pointer(p + uintptr(i)))))) = uint8_t(1)
+ *(*uint8_t)(unsafe.Pointer(bp + uintptr(*(*uint8_t)(unsafe.Pointer(p + uintptr(i)))))) = uint8_t(1)
}
}
for j = 0; j < 256; j++ {
- if int32(*(*uint8_t)(unsafe.Pointer((bp) /* &color[0] */ + uintptr(j)))) > 0 {
+ if int32(*(*uint8_t)(unsafe.Pointer(bp + uintptr(j)))) > 0 {
colors++
}
}
@@ -21953,7 +21693,7 @@ func GetFilterMap(tls *libc.TLS, alpha uintptr, width int32, height int32, filte
var bit_map uint32_t = 0
if filter == WEBP_FILTER_FAST {
// Quick estimate of the best candidate.
- var try_filter_none int32 = (libc.Bool32(effort_level > 3))
+ var try_filter_none int32 = libc.Bool32(effort_level > 3)
var kMinColorsForFilterNone int32 = 16
var kMaxColorsForFilterNone int32 = 192
var num_colors int32 = GetNumColors(tls, alpha, width, height, width)
@@ -21963,23 +21703,23 @@ func GetFilterMap(tls *libc.TLS, alpha uintptr, width int32, height int32, filte
} else {
filter = int32(WebPEstimateBestFilter(tls, alpha, width, height, width))
}
- bit_map = bit_map | (uint32_t(int32(1) << filter))
+ bit_map = bit_map | uint32_t(int32(1)<<filter)
// For large number of colors, try FILTER_NONE in addition to the best
// filter as well.
- if (try_filter_none != 0) || (num_colors > kMaxColorsForFilterNone) {
- bit_map = bit_map | (uint32_t(int32(1) << WEBP_FILTER_NONE))
+ if try_filter_none != 0 || num_colors > kMaxColorsForFilterNone {
+ bit_map = bit_map | uint32_t(int32(1)<<WEBP_FILTER_NONE)
}
} else if filter == WEBP_FILTER_NONE {
- bit_map = (uint32_t(int32(1) << WEBP_FILTER_NONE))
+ bit_map = uint32_t(int32(1) << WEBP_FILTER_NONE)
} else { // WEBP_FILTER_BEST -> try all
- bit_map = (uint32_t((int32(1) << WEBP_FILTER_LAST) - 1))
+ bit_map = uint32_t(int32(1)<<WEBP_FILTER_LAST - 1)
}
return bit_map
}
func InitFilterTrial(tls *libc.TLS, score uintptr) { /* alpha_enc.c:229:13: */
(*FilterTrial)(unsafe.Pointer(score)).score = uint64(libc.CplUint32(0))
- VP8BitWriterInit(tls, (score + 8 /* &.bw */), uint64(0))
+ VP8BitWriterInit(tls, score+8, uint64(0))
}
func ApplyFiltersAndEncode(tls *libc.TLS, alpha uintptr, width int32, height int32, data_size size_t, method int32, filter int32, reduce_levels int32, effort_level int32, output uintptr, output_size uintptr, stats uintptr) int32 { /* alpha_enc.c:234:12: */
@@ -21990,31 +21730,31 @@ func ApplyFiltersAndEncode(tls *libc.TLS, alpha uintptr, width int32, height int
// var best FilterTrial at bp, 248
var try_map uint32_t = GetFilterMap(tls, alpha, width, height, filter, effort_level)
- InitFilterTrial(tls, (bp) /* &best */)
+ InitFilterTrial(tls, bp)
- if try_map != (uint32_t(int32(1) << WEBP_FILTER_NONE)) {
+ if try_map != uint32_t(int32(1)<<WEBP_FILTER_NONE) {
var filtered_alpha uintptr = WebPSafeMalloc(tls, 1, data_size)
- if filtered_alpha == (uintptr(0)) {
+ if filtered_alpha == uintptr(0) {
return 0
}
filter = WEBP_FILTER_NONE
__1:
- if !((ok != 0) && (try_map != 0)) {
+ if !(ok != 0 && try_map != 0) {
goto __3
}
{
- if (try_map & uint32_t(1)) != 0 {
+ if try_map&uint32_t(1) != 0 {
// var trial FilterTrial at bp+248, 248
ok = EncodeAlphaInternal(tls, alpha, width, height, method, filter,
reduce_levels, effort_level, filtered_alpha,
- (bp + 248) /* &trial */)
- if (ok != 0) && ((*FilterTrial)(unsafe.Pointer(bp+248 /* &trial */)).score < (*FilterTrial)(unsafe.Pointer(bp /* &best */)).score) {
- VP8BitWriterWipeOut(tls, ((bp) /* &best */ + 8 /* &.bw */))
+ bp+248)
+ if ok != 0 && (*FilterTrial)(unsafe.Pointer(bp+248)).score < (*FilterTrial)(unsafe.Pointer(bp)).score {
+ VP8BitWriterWipeOut(tls, bp+8)
*(*FilterTrial)(unsafe.Pointer(bp /* best */)) = *(*FilterTrial)(unsafe.Pointer(bp + 248 /* trial */))
} else {
- VP8BitWriterWipeOut(tls, ((bp + 248) /* &trial */ + 8 /* &.bw */))
+ VP8BitWriterWipeOut(tls, bp+248+8)
}
}
@@ -22030,10 +21770,10 @@ func ApplyFiltersAndEncode(tls *libc.TLS, alpha uintptr, width int32, height int
WebPSafeFree(tls, filtered_alpha)
} else {
ok = EncodeAlphaInternal(tls, alpha, width, height, method, WEBP_FILTER_NONE,
- reduce_levels, effort_level, (uintptr(0)), (bp) /* &best */)
+ reduce_levels, effort_level, uintptr(0), bp)
}
if ok != 0 {
- if stats != (uintptr(0)) {
+ if stats != uintptr(0) {
(*WebPAuxStats)(unsafe.Pointer(stats)).lossless_features = (*FilterTrial)(unsafe.Pointer(bp /* &best */)).stats.lossless_features
(*WebPAuxStats)(unsafe.Pointer(stats)).histogram_bits = (*FilterTrial)(unsafe.Pointer(bp /* &best */)).stats.histogram_bits
(*WebPAuxStats)(unsafe.Pointer(stats)).transform_bits = (*FilterTrial)(unsafe.Pointer(bp /* &best */)).stats.transform_bits
@@ -22043,10 +21783,10 @@ func ApplyFiltersAndEncode(tls *libc.TLS, alpha uintptr, width int32, height int
(*WebPAuxStats)(unsafe.Pointer(stats)).lossless_hdr_size = (*FilterTrial)(unsafe.Pointer(bp /* &best */)).stats.lossless_hdr_size
(*WebPAuxStats)(unsafe.Pointer(stats)).lossless_data_size = (*FilterTrial)(unsafe.Pointer(bp /* &best */)).stats.lossless_data_size
}
- *(*size_t)(unsafe.Pointer(output_size)) = VP8BitWriterSize(tls, ((bp) /* &best */ + 8 /* &.bw */))
- *(*uintptr)(unsafe.Pointer(output)) = VP8BitWriterBuf(tls, ((bp) /* &best */ + 8 /* &.bw */))
+ *(*size_t)(unsafe.Pointer(output_size)) = VP8BitWriterSize(tls, bp+8)
+ *(*uintptr)(unsafe.Pointer(output)) = VP8BitWriterBuf(tls, bp+8)
} else {
- VP8BitWriterWipeOut(tls, ((bp) /* &best */ + 8 /* &.bw */))
+ VP8BitWriterWipeOut(tls, bp+8)
}
return ok
}
@@ -22059,20 +21799,20 @@ func EncodeAlpha(tls *libc.TLS, enc uintptr, quality int32, method int32, filter
var width int32 = (*WebPPicture)(unsafe.Pointer(pic)).width
var height int32 = (*WebPPicture)(unsafe.Pointer(pic)).height
- var quant_alpha uintptr = (uintptr(0))
- var data_size size_t = (size_t(width * height))
+ var quant_alpha uintptr = uintptr(0)
+ var data_size size_t = size_t(width * height)
*(*uint64_t)(unsafe.Pointer(bp /* sse */)) = uint64(0)
var ok int32 = 1
- var reduce_levels int32 = (libc.Bool32(quality < 100))
+ var reduce_levels int32 = libc.Bool32(quality < 100)
// quick correctness checks
// as per spec
- if (quality < 0) || (quality > 100) {
+ if quality < 0 || quality > 100 {
return 0
}
- if (method < 0) || (method > 1) {
+ if method < 0 || method > 1 {
return 0
}
@@ -22082,7 +21822,7 @@ func EncodeAlpha(tls *libc.TLS, enc uintptr, quality int32, method int32, filter
}
quant_alpha = WebPSafeMalloc(tls, 1, data_size)
- if quant_alpha == (uintptr(0)) {
+ if quant_alpha == uintptr(0) {
return 0
}
@@ -22095,11 +21835,11 @@ func EncodeAlpha(tls *libc.TLS, enc uintptr, quality int32, method int32, filter
// and Quality:]70, 100] -> Levels:]16, 256].
var alpha_levels int32
if quality <= 70 {
- alpha_levels = (2 + (quality / 5))
+ alpha_levels = 2 + quality/5
} else {
- alpha_levels = (16 + ((quality - 70) * 8))
+ alpha_levels = 16 + (quality-70)*8
}
- ok = QuantizeLevels(tls, quant_alpha, width, height, alpha_levels, (bp) /* &sse */)
+ ok = QuantizeLevels(tls, quant_alpha, width, height, alpha_levels, bp)
}
if ok != 0 {
@@ -22107,9 +21847,9 @@ func EncodeAlpha(tls *libc.TLS, enc uintptr, quality int32, method int32, filter
ok = ApplyFiltersAndEncode(tls, quant_alpha, width, height, data_size, method,
filter, reduce_levels, effort_level, output,
output_size, (*WebPPicture)(unsafe.Pointer(pic)).stats)
- if (*WebPPicture)(unsafe.Pointer(pic)).stats != (uintptr(0)) { // need stats?
- *(*int32)(unsafe.Pointer(((*WebPPicture)(unsafe.Pointer(pic)).stats /* &.coded_size */))) += (int32(*(*size_t)(unsafe.Pointer(output_size))))
- *(*uint64_t)(unsafe.Pointer((enc + 23512 /* &.sse_ */) + 3*8)) = *(*uint64_t)(unsafe.Pointer(bp /* sse */))
+ if (*WebPPicture)(unsafe.Pointer(pic)).stats != uintptr(0) { // need stats?
+ *(*int32)(unsafe.Pointer((*WebPPicture)(unsafe.Pointer(pic)).stats)) += int32(*(*size_t)(unsafe.Pointer(output_size)))
+ *(*uint64_t)(unsafe.Pointer(enc + 23512 + 3*8)) = *(*uint64_t)(unsafe.Pointer(bp /* sse */))
}
}
@@ -22126,7 +21866,7 @@ func CompressAlphaJob(tls *libc.TLS, arg1 uintptr, unused uintptr) int32 { /* al
var enc uintptr = arg1
var config uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).config_
- *(*uintptr)(unsafe.Pointer(bp /* alpha_data */)) = (uintptr(0))
+ *(*uintptr)(unsafe.Pointer(bp /* alpha_data */)) = uintptr(0)
*(*size_t)(unsafe.Pointer(bp + 8 /* alpha_size */)) = uint64(0)
var effort_level int32 = (*WebPConfig)(unsafe.Pointer(config)).method // maps to [0..6]
var filter WEBP_FILTER_TYPE
@@ -22140,10 +21880,10 @@ func CompressAlphaJob(tls *libc.TLS, arg1 uintptr, unused uintptr) int32 { /* al
}
}
if !(EncodeAlpha(tls, enc, (*WebPConfig)(unsafe.Pointer(config)).alpha_quality, (*WebPConfig)(unsafe.Pointer(config)).alpha_compression,
- int32(filter), effort_level, (bp) /* &alpha_data */, (bp+8) /* &alpha_size */) != 0) {
+ int32(filter), effort_level, bp, bp+8) != 0) {
return 0
}
- if *(*size_t)(unsafe.Pointer(bp + 8 /* alpha_size */)) != size_t(uint32_t(*(*size_t)(unsafe.Pointer(bp + 8 /* alpha_size */)))) { // Soundness check.
+ if *(*size_t)(unsafe.Pointer(bp + 8)) != size_t(uint32_t(*(*size_t)(unsafe.Pointer(bp + 8)))) { // Soundness check.
WebPSafeFree(tls, *(*uintptr)(unsafe.Pointer(bp /* alpha_data */)))
return 0
}
@@ -22156,13 +21896,13 @@ func CompressAlphaJob(tls *libc.TLS, arg1 uintptr, unused uintptr) int32 { /* al
func VP8EncInitAlpha(tls *libc.TLS, enc uintptr) { /* alpha_enc.c:388:6: */
WebPInitAlphaProcessing(tls)
(*VP8Encoder)(unsafe.Pointer(enc)).has_alpha_ = WebPPictureHasTransparency(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_)
- (*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_ = (uintptr(0))
+ (*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_ = uintptr(0)
(*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_size_ = uint32_t(0)
if (*VP8Encoder)(unsafe.Pointer(enc)).thread_level_ > 0 {
- var worker uintptr = (enc + 560 /* &.alpha_worker_ */)
+ var worker uintptr = enc + 560
(*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Init})).f(tls, worker)
(*WebPWorker)(unsafe.Pointer(worker)).data1 = enc
- (*WebPWorker)(unsafe.Pointer(worker)).data2 = (uintptr(0))
+ (*WebPWorker)(unsafe.Pointer(worker)).data2 = uintptr(0)
(*WebPWorker)(unsafe.Pointer(worker)).hook = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) int32
}{CompressAlphaJob}))
@@ -22172,7 +21912,7 @@ func VP8EncInitAlpha(tls *libc.TLS, enc uintptr) { /* alpha_enc.c:388:6: */
func VP8EncStartAlpha(tls *libc.TLS, enc uintptr) int32 { /* alpha_enc.c:402:5: */
if (*VP8Encoder)(unsafe.Pointer(enc)).has_alpha_ != 0 {
if (*VP8Encoder)(unsafe.Pointer(enc)).thread_level_ > 0 {
- var worker uintptr = (enc + 560 /* &.alpha_worker_ */)
+ var worker uintptr = enc + 560
// Makes sure worker is good to go.
if !((*struct {
f func(*libc.TLS, uintptr) int32
@@ -22182,7 +21922,7 @@ func VP8EncStartAlpha(tls *libc.TLS, enc uintptr) int32 { /* alpha_enc.c:402:5:
(*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Launch})).f(tls, worker)
return 1
} else {
- return CompressAlphaJob(tls, enc, (uintptr(0))) // just do the job right away
+ return CompressAlphaJob(tls, enc, uintptr(0)) // just do the job right away
}
}
return 1
@@ -22191,7 +21931,7 @@ func VP8EncStartAlpha(tls *libc.TLS, enc uintptr) int32 { /* alpha_enc.c:402:5:
func VP8EncFinishAlpha(tls *libc.TLS, enc uintptr) int32 { /* alpha_enc.c:419:5: */
if (*VP8Encoder)(unsafe.Pointer(enc)).has_alpha_ != 0 {
if (*VP8Encoder)(unsafe.Pointer(enc)).thread_level_ > 0 {
- var worker uintptr = (enc + 560 /* &.alpha_worker_ */)
+ var worker uintptr = enc + 560
if !((*struct {
f func(*libc.TLS, uintptr) int32
})(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Sync})).f(tls, worker) != 0) {
@@ -22199,13 +21939,13 @@ func VP8EncFinishAlpha(tls *libc.TLS, enc uintptr) int32 { /* alpha_enc.c:419:5:
} // error
}
}
- return WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, ((*VP8Encoder)(unsafe.Pointer(enc)).percent_ + 20), (enc + 536 /* &.percent_ */))
+ return WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, (*VP8Encoder)(unsafe.Pointer(enc)).percent_+20, enc+536)
}
func VP8EncDeleteAlpha(tls *libc.TLS, enc uintptr) int32 { /* alpha_enc.c:429:5: */
var ok int32 = 1
if (*VP8Encoder)(unsafe.Pointer(enc)).thread_level_ > 0 {
- var worker uintptr = (enc + 560 /* &.alpha_worker_ */)
+ var worker uintptr = enc + 560
// finish anything left in flight
ok = (*struct {
f func(*libc.TLS, uintptr) int32
@@ -22214,7 +21954,7 @@ func VP8EncDeleteAlpha(tls *libc.TLS, enc uintptr) int32 { /* alpha_enc.c:429:5:
(*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).End})).f(tls, worker)
}
WebPSafeFree(tls, (*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_)
- (*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_ = (uintptr(0))
+ (*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_ = uintptr(0)
(*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_size_ = uint32_t(0)
(*VP8Encoder)(unsafe.Pointer(enc)).has_alpha_ = 0
return ok
@@ -22250,39 +21990,39 @@ func SmoothSegmentMap(tls *libc.TLS, enc uintptr) { /* analysis_enc.c:28:13: */
var w int32 = (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_
var h int32 = (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_
var majority_cnt_3_x_3_grid int32 = 5
- var tmp uintptr = WebPSafeMalloc(tls, (uint64(w * h)), uint64(unsafe.Sizeof(uint8_t(0))))
+ var tmp uintptr = WebPSafeMalloc(tls, uint64(w*h), uint64(unsafe.Sizeof(uint8_t(0))))
// no overflow, as per spec
- if tmp == (uintptr(0)) {
+ if tmp == uintptr(0) {
return
}
- for y = 1; y < (h - 1); y++ {
- for x = 1; x < (w - 1); x++ {
+ for y = 1; y < h-1; y++ {
+ for x = 1; x < w-1; x++ {
*(*[4]int32)(unsafe.Pointer(bp /* cnt */)) = [4]int32{0: 0}
- var mb uintptr = ((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr((x+(w*y)))*4)
- var majority_seg int32 = (int32(*(*uint8)(unsafe.Pointer(mb /* &.segment_ */)) & 0x60 >> 5))
+ var mb uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(x+w*y)*4
+ var majority_seg int32 = int32(*(*uint8)(unsafe.Pointer(mb)) & 0x60 >> 5)
// Check the 8 neighbouring segment values.
- *(*int32)(unsafe.Pointer((bp) /* &cnt[0] */ + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((mb + uintptr((-w-1))*4) /* &.segment_ */))&0x60>>5))))*4))++ // top-left
- *(*int32)(unsafe.Pointer((bp) /* &cnt[0] */ + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((mb + uintptr((-w+0))*4) /* &.segment_ */))&0x60>>5))))*4))++ // top
- *(*int32)(unsafe.Pointer((bp) /* &cnt[0] */ + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((mb + uintptr((-w+1))*4) /* &.segment_ */))&0x60>>5))))*4))++ // top-right
- *(*int32)(unsafe.Pointer((bp) /* &cnt[0] */ + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((mb + libc.UintptrFromInt32(-1)*4) /* &.segment_ */))&0x60>>5))))*4))++ // left
- *(*int32)(unsafe.Pointer((bp) /* &cnt[0] */ + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((mb + 1*4) /* &.segment_ */))&0x60>>5))))*4))++ // right
- *(*int32)(unsafe.Pointer((bp) /* &cnt[0] */ + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((mb + uintptr((w-1))*4) /* &.segment_ */))&0x60>>5))))*4))++ // bottom-left
- *(*int32)(unsafe.Pointer((bp) /* &cnt[0] */ + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((mb + uintptr((w+0))*4) /* &.segment_ */))&0x60>>5))))*4))++ // bottom
- *(*int32)(unsafe.Pointer((bp) /* &cnt[0] */ + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((mb + uintptr((w+1))*4) /* &.segment_ */))&0x60>>5))))*4))++ // bottom-right
+ *(*int32)(unsafe.Pointer(bp + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer(mb + uintptr(-w-1)*4))&0x60>>5)))*4))++ // top-left
+ *(*int32)(unsafe.Pointer(bp + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer(mb + uintptr(-w+0)*4))&0x60>>5)))*4))++ // top
+ *(*int32)(unsafe.Pointer(bp + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer(mb + uintptr(-w+1)*4))&0x60>>5)))*4))++ // top-right
+ *(*int32)(unsafe.Pointer(bp + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer(mb + libc.UintptrFromInt32(-1)*4))&0x60>>5)))*4))++ // left
+ *(*int32)(unsafe.Pointer(bp + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer(mb + 1*4))&0x60>>5)))*4))++ // right
+ *(*int32)(unsafe.Pointer(bp + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer(mb + uintptr(w-1)*4))&0x60>>5)))*4))++ // bottom-left
+ *(*int32)(unsafe.Pointer(bp + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer(mb + uintptr(w+0)*4))&0x60>>5)))*4))++ // bottom
+ *(*int32)(unsafe.Pointer(bp + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer(mb + uintptr(w+1)*4))&0x60>>5)))*4))++ // bottom-right
for n = 0; n < NUM_MB_SEGMENTS; n++ {
- if *(*int32)(unsafe.Pointer((bp) /* &cnt[0] */ + uintptr(n)*4)) >= majority_cnt_3_x_3_grid {
+ if *(*int32)(unsafe.Pointer(bp + uintptr(n)*4)) >= majority_cnt_3_x_3_grid {
majority_seg = n
break
}
}
- *(*uint8_t)(unsafe.Pointer(tmp + uintptr((x + (y * w))))) = uint8_t(majority_seg)
+ *(*uint8_t)(unsafe.Pointer(tmp + uintptr(x+y*w))) = uint8_t(majority_seg)
}
}
- for y = 1; y < (h - 1); y++ {
- for x = 1; x < (w - 1); x++ {
- var mb uintptr = ((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr((x+(w*y)))*4)
- libc.SetBitFieldPtr8Uint32((mb /* &.segment_ */), uint32(*(*uint8_t)(unsafe.Pointer(tmp + uintptr((x + (y * w)))))), 5, 0x60)
+ for y = 1; y < h-1; y++ {
+ for x = 1; x < w-1; x++ {
+ var mb uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(x+w*y)*4
+ libc.SetBitFieldPtr8Uint32(mb, uint32(*(*uint8_t)(unsafe.Pointer(tmp + uintptr(x+y*w)))), 5, 0x60)
}
}
WebPSafeFree(tls, tmp)
@@ -22318,14 +22058,14 @@ func SetSegmentAlphas(tls *libc.TLS, enc uintptr, centers uintptr, mid int32) {
}
}
if max == min {
- max = (min + 1)
+ max = min + 1
}
for n = 0; n < nb; n++ {
- var alpha int32 = ((255 * (*(*int32)(unsafe.Pointer(centers + uintptr(n)*4)) - mid)) / (max - min))
- var beta int32 = ((255 * (*(*int32)(unsafe.Pointer(centers + uintptr(n)*4)) - min)) / (max - min))
- (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(n)*744)).alpha_ = clip2(tls, alpha, -127, 127)
- (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(n)*744)).beta_ = clip2(tls, beta, 0, 255)
+ var alpha int32 = 255 * (*(*int32)(unsafe.Pointer(centers + uintptr(n)*4)) - mid) / (max - min)
+ var beta int32 = 255 * (*(*int32)(unsafe.Pointer(centers + uintptr(n)*4)) - min) / (max - min)
+ (*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(n)*744)).alpha_ = clip2(tls, alpha, -127, 127)
+ (*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(n)*744)).beta_ = clip2(tls, beta, 0, 255)
}
}
@@ -22334,7 +22074,7 @@ func SetSegmentAlphas(tls *libc.TLS, enc uintptr, centers uintptr, mid int32) {
// the higher, the "easier" the macroblock is to compress.
func FinalAlphaValue(tls *libc.TLS, alpha int32) int32 { /* analysis_enc.c:108:12: */
- alpha = (255 - alpha)
+ alpha = 255 - alpha
return clip2(tls, alpha, 0, 255)
}
@@ -22346,7 +22086,7 @@ func GetAlpha(tls *libc.TLS, histo uintptr) int32 { /* analysis_enc.c:113:12: */
var last_non_zero int32 = (*VP8Histogram)(unsafe.Pointer(histo)).last_non_zero
var alpha int32
if max_value > 1 {
- alpha = (((2 * 255) * last_non_zero) / max_value)
+ alpha = 2 * 255 * last_non_zero / max_value
} else {
alpha = 0
}
@@ -22391,13 +22131,13 @@ func AssignSegments(tls *libc.TLS, enc uintptr, alphas uintptr) { /* analysis_en
// var dist_accum [4]int32 at bp+32, 16
// bracket the input
- for n = 0; (n <= 255) && (*(*int32)(unsafe.Pointer(alphas + uintptr(n)*4)) == 0); n++ {
+ for n = 0; n <= 255 && *(*int32)(unsafe.Pointer(alphas + uintptr(n)*4)) == 0; n++ {
}
min_a = n
- for n = 255; (n > min_a) && (*(*int32)(unsafe.Pointer(alphas + uintptr(n)*4)) == 0); n-- {
+ for n = 255; n > min_a && *(*int32)(unsafe.Pointer(alphas + uintptr(n)*4)) == 0; n-- {
}
max_a = n
- range_a = (max_a - min_a)
+ range_a = max_a - min_a
// Spread initial centers evenly
k = 0
@@ -22408,13 +22148,13 @@ __1:
}
{
- *(*int32)(unsafe.Pointer((bp) /* ¢ers[0] */ + uintptr(k)*4)) = (min_a + ((n * range_a) / (2 * nb)))
+ *(*int32)(unsafe.Pointer(bp + uintptr(k)*4)) = min_a + n*range_a/(2*nb)
}
goto __2
__2:
k++
- n = n + (2)
+ n = n + 2
goto __1
goto __3
__3:
@@ -22425,20 +22165,20 @@ __3:
var displaced int32
// Reset stats
for n = 0; n < nb; n++ {
- *(*int32)(unsafe.Pointer((bp + 16) /* &accum[0] */ + uintptr(n)*4)) = 0
- *(*int32)(unsafe.Pointer((bp + 32) /* &dist_accum[0] */ + uintptr(n)*4)) = 0
+ *(*int32)(unsafe.Pointer(bp + 16 + uintptr(n)*4)) = 0
+ *(*int32)(unsafe.Pointer(bp + 32 + uintptr(n)*4)) = 0
}
// Assign nearest center for each 'a'
n = 0 // track the nearest center for current 'a'
for a = min_a; a <= max_a; a++ {
if *(*int32)(unsafe.Pointer(alphas + uintptr(a)*4)) != 0 {
- for ((n + 1) < nb) && (libc.Xabs(tls, (a-*(*int32)(unsafe.Pointer((bp) /* ¢ers[0] */ + uintptr((n+1))*4)))) < libc.Xabs(tls, (a-*(*int32)(unsafe.Pointer((bp) /* ¢ers[0] */ + uintptr(n)*4))))) {
+ for n+1 < nb && libc.Xabs(tls, a-*(*int32)(unsafe.Pointer(bp + uintptr(n+1)*4))) < libc.Xabs(tls, a-*(*int32)(unsafe.Pointer(bp + uintptr(n)*4))) {
n++
}
- *(*int32)(unsafe.Pointer((bp + 48) /* &map1[0] */ + uintptr(a)*4)) = n
+ *(*int32)(unsafe.Pointer(bp + 48 + uintptr(a)*4)) = n
// accumulate contribution into best centroid
- *(*int32)(unsafe.Pointer(((bp + 32) /* &dist_accum */ + uintptr(n)*4))) += (a * *(*int32)(unsafe.Pointer(alphas + uintptr(a)*4)))
- *(*int32)(unsafe.Pointer(((bp + 16) /* &accum */ + uintptr(n)*4))) += (*(*int32)(unsafe.Pointer(alphas + uintptr(a)*4)))
+ *(*int32)(unsafe.Pointer(bp + 32 + uintptr(n)*4)) += a * *(*int32)(unsafe.Pointer(alphas + uintptr(a)*4))
+ *(*int32)(unsafe.Pointer(bp + 16 + uintptr(n)*4)) += *(*int32)(unsafe.Pointer(alphas + uintptr(a)*4))
}
}
// All point are classified. Move the centroids to the
@@ -22447,36 +22187,36 @@ __3:
weighted_average = 0
total_weight = 0
for n = 0; n < nb; n++ {
- if *(*int32)(unsafe.Pointer((bp + 16) /* &accum[0] */ + uintptr(n)*4)) != 0 {
- var new_center int32 = ((*(*int32)(unsafe.Pointer((bp + 32) /* &dist_accum[0] */ + uintptr(n)*4)) + (*(*int32)(unsafe.Pointer((bp + 16) /* &accum[0] */ + uintptr(n)*4)) / 2)) / *(*int32)(unsafe.Pointer((bp + 16) /* &accum[0] */ + uintptr(n)*4)))
- displaced = displaced + (libc.Xabs(tls, (*(*int32)(unsafe.Pointer((bp) /* ¢ers[0] */ + uintptr(n)*4)) - new_center)))
- *(*int32)(unsafe.Pointer((bp) /* ¢ers[0] */ + uintptr(n)*4)) = new_center
- weighted_average = weighted_average + (new_center * *(*int32)(unsafe.Pointer((bp + 16) /* &accum[0] */ + uintptr(n)*4)))
- total_weight = total_weight + (*(*int32)(unsafe.Pointer((bp + 16) /* &accum[0] */ + uintptr(n)*4)))
+ if *(*int32)(unsafe.Pointer(bp + 16 + uintptr(n)*4)) != 0 {
+ var new_center int32 = (*(*int32)(unsafe.Pointer(bp + 32 + uintptr(n)*4)) + *(*int32)(unsafe.Pointer(bp + 16 + uintptr(n)*4))/2) / *(*int32)(unsafe.Pointer(bp + 16 + uintptr(n)*4))
+ displaced = displaced + libc.Xabs(tls, *(*int32)(unsafe.Pointer(bp + uintptr(n)*4))-new_center)
+ *(*int32)(unsafe.Pointer(bp + uintptr(n)*4)) = new_center
+ weighted_average = weighted_average + new_center**(*int32)(unsafe.Pointer(bp + 16 + uintptr(n)*4))
+ total_weight = total_weight + *(*int32)(unsafe.Pointer(bp + 16 + uintptr(n)*4))
}
}
- weighted_average = ((weighted_average + (total_weight / 2)) / total_weight)
+ weighted_average = (weighted_average + total_weight/2) / total_weight
if displaced < 5 {
break
} // no need to keep on looping...
}
// Map each original value to the closest centroid
- for n = 0; n < ((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_); n++ {
- var mb uintptr = ((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(n)*4)
+ for n = 0; n < (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_*(*VP8Encoder)(unsafe.Pointer(enc)).mb_h_; n++ {
+ var mb uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(n)*4
var alpha int32 = int32((*VP8MBInfo)(unsafe.Pointer(mb)).alpha_)
- libc.SetBitFieldPtr8Uint32((mb /* &.segment_ */), uint32(*(*int32)(unsafe.Pointer((bp + 48) /* &map1[0] */ + uintptr(alpha)*4))), 5, 0x60)
- (*VP8MBInfo)(unsafe.Pointer(mb)).alpha_ = uint8_t(*(*int32)(unsafe.Pointer((bp) /* ¢ers[0] */ + uintptr(*(*int32)(unsafe.Pointer((bp + 48) /* &map1[0] */ + uintptr(alpha)*4)))*4))) // for the record.
+ libc.SetBitFieldPtr8Uint32(mb, uint32(*(*int32)(unsafe.Pointer(bp + 48 + uintptr(alpha)*4))), 5, 0x60)
+ (*VP8MBInfo)(unsafe.Pointer(mb)).alpha_ = uint8_t(*(*int32)(unsafe.Pointer(bp + uintptr(*(*int32)(unsafe.Pointer(bp + 48 + uintptr(alpha)*4)))*4))) // for the record.
}
if nb > 1 {
- var smooth int32 = ((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).preprocessing & 1)
+ var smooth int32 = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).preprocessing & 1
if smooth != 0 {
SmoothSegmentMap(tls, enc)
}
}
- SetSegmentAlphas(tls, enc, (bp) /* ¢ers[0] */, weighted_average) // pick some alphas.
+ SetSegmentAlphas(tls, enc, bp, weighted_average) // pick some alphas.
}
//------------------------------------------------------------------------------
@@ -22494,7 +22234,7 @@ func MBAnalyzeBestIntra16Mode(tls *libc.TLS, it uintptr) int32 { /* analysis_enc
var max_mode int32 = 2
var mode int32
- var best_alpha int32 = (-1)
+ var best_alpha int32 = -1
var best_mode int32 = 0
VP8MakeLuma16Preds(tls, it)
@@ -22503,14 +22243,14 @@ func MBAnalyzeBestIntra16Mode(tls *libc.TLS, it uintptr) int32 { /* analysis_enc
var alpha int32
- InitHistogram(tls, (bp) /* &histo */)
+ InitHistogram(tls, bp)
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, int32, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8CollectHistogram})).f(tls, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((0))),
- ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8I16ModeOffsets[mode])),
- 0, 16, (bp) /* &histo */)
- alpha = GetAlpha(tls, (bp) /* &histo */)
- if (alpha) > (best_alpha) {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8CollectHistogram})).f(tls, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_+uintptr(0),
+ (*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_+uintptr(VP8I16ModeOffsets[mode]),
+ 0, 16, bp)
+ alpha = GetAlpha(tls, bp)
+ if alpha > best_alpha {
best_alpha = alpha
best_mode = mode
}
@@ -22526,29 +22266,29 @@ func FastMBAnalyze(tls *libc.TLS, it uintptr) int32 { /* analysis_enc.c:255:12:
// Empirical cut-off value, should be around 16 (~=block size). We use the
// [8-17] range and favor intra4 at high quality, intra16 for low quality.
var q int32 = libc.Int32FromFloat32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).enc_)).config_)).quality)
- var kThreshold uint32_t = (uint32_t(8 + (((17 - 8) * q) / 100)))
+ var kThreshold uint32_t = uint32_t(8 + (17-8)*q/100)
var k int32
// var dc [16]uint32_t at bp, 64
var m uint32_t
var m2 uint32_t
- for k = 0; k < 16; k = k + (4) {
+ for k = 0; k < 16; k = k + 4 {
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8Mean16x4})).f(tls, (((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((0))) + uintptr((k * 32))), ((bp) /* &dc */ + uintptr(k)*4))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8Mean16x4})).f(tls, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_+uintptr(0)+uintptr(k*32), bp /* &dc */ +uintptr(k)*4)
}
m = uint32_t(0)
m2 = uint32_t(0)
k = 0
for ; k < 16; k++ {
- m = m + (*(*uint32_t)(unsafe.Pointer((bp) /* &dc[0] */ + uintptr(k)*4)))
- m2 = m2 + (*(*uint32_t)(unsafe.Pointer((bp) /* &dc[0] */ + uintptr(k)*4)) * *(*uint32_t)(unsafe.Pointer((bp) /* &dc[0] */ + uintptr(k)*4)))
+ m = m + *(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4))
+ m2 = m2 + *(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4))**(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4))
}
- if (kThreshold * m2) < (m * m) {
+ if kThreshold*m2 < m*m {
VP8SetIntra16Mode(tls, it, 0) // DC16
} else {
*(*[16]uint8_t)(unsafe.Pointer(bp + 64 /* modes */)) = [16]uint8_t{0: uint8_t(0)} // DC4
- VP8SetIntra4Mode(tls, it, (bp + 64) /* &modes[0] */)
+ VP8SetIntra4Mode(tls, it, bp+64 /* &modes[0] */)
}
return 0
}
@@ -22557,7 +22297,7 @@ func MBAnalyzeBestUVMode(tls *libc.TLS, it uintptr) int32 { /* analysis_enc.c:27
bp := tls.Alloc(8)
defer tls.Free(8)
- var best_alpha int32 = (-1)
+ var best_alpha int32 = -1
var smallest_alpha int32 = 0
var best_mode int32 = 0
var max_mode int32 = 2
@@ -22568,18 +22308,18 @@ func MBAnalyzeBestUVMode(tls *libc.TLS, it uintptr) int32 { /* analysis_enc.c:27
// var histo VP8Histogram at bp, 8
var alpha int32
- InitHistogram(tls, (bp) /* &histo */)
+ InitHistogram(tls, bp)
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, int32, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8CollectHistogram})).f(tls, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((16))),
- ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8UVModeOffsets[mode])),
- 16, ((16 + 4) + 4), (bp) /* &histo */)
- alpha = GetAlpha(tls, (bp) /* &histo */)
- if (alpha) > (best_alpha) {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8CollectHistogram})).f(tls, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_+uintptr(16),
+ (*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_+uintptr(VP8UVModeOffsets[mode]),
+ 16, 16+4+4, bp)
+ alpha = GetAlpha(tls, bp)
+ if alpha > best_alpha {
best_alpha = alpha
}
// The best prediction mode tends to be the one with the smallest alpha.
- if (mode == 0) || (alpha < smallest_alpha) {
+ if mode == 0 || alpha < smallest_alpha {
smallest_alpha = alpha
best_mode = mode
}
@@ -22605,21 +22345,21 @@ func MBAnalyze(tls *libc.TLS, it uintptr, alphas uintptr, alpha uintptr, uv_alph
best_uv_alpha = MBAnalyzeBestUVMode(tls, it)
// Final susceptibility mix
- best_alpha = ((((3 * best_alpha) + best_uv_alpha) + 2) >> 2)
+ best_alpha = (3*best_alpha + best_uv_alpha + 2) >> 2
best_alpha = FinalAlphaValue(tls, best_alpha)
*(*int32)(unsafe.Pointer(alphas + uintptr(best_alpha)*4))++
(*VP8MBInfo)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_)).alpha_ = uint8_t(best_alpha) // for later remapping.
// Accumulate for later complexity analysis.
- *(*int32)(unsafe.Pointer(alpha)) += (best_alpha) // mixed susceptibility (not just luma)
- *(*int32)(unsafe.Pointer(uv_alpha)) += (best_uv_alpha)
+ *(*int32)(unsafe.Pointer(alpha)) += best_alpha // mixed susceptibility (not just luma)
+ *(*int32)(unsafe.Pointer(uv_alpha)) += best_uv_alpha
}
func DefaultMBInfo(tls *libc.TLS, mb uintptr) { /* analysis_enc.c:335:13: */
- libc.SetBitFieldPtr8Uint32((mb /* &.type_ */), uint32(1), 0, 0x3) // I16x16
- libc.SetBitFieldPtr8Uint32((mb /* &.uv_mode_ */), uint32(0), 2, 0xc)
- libc.SetBitFieldPtr8Uint32((mb /* &.skip_ */), uint32(0), 4, 0x10) // not skipped
- libc.SetBitFieldPtr8Uint32((mb /* &.segment_ */), uint32(0), 5, 0x60) // default segment
+ libc.SetBitFieldPtr8Uint32(mb, uint32(1), 0, 0x3) // I16x16
+ libc.SetBitFieldPtr8Uint32(mb, uint32(0), 2, 0xc)
+ libc.SetBitFieldPtr8Uint32(mb, uint32(0), 4, 0x10) // not skipped
+ libc.SetBitFieldPtr8Uint32(mb, uint32(0), 5, 0x60) // default segment
(*VP8MBInfo)(unsafe.Pointer(mb)).alpha_ = uint8_t(0)
}
@@ -22635,16 +22375,16 @@ func DefaultMBInfo(tls *libc.TLS, mb uintptr) { /* analysis_enc.c:335:13: */
func ResetAllMBInfo(tls *libc.TLS, enc uintptr) { /* analysis_enc.c:353:13: */
var n int32
- for n = 0; n < ((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_); n++ {
- DefaultMBInfo(tls, ((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(n)*4))
+ for n = 0; n < (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_*(*VP8Encoder)(unsafe.Pointer(enc)).mb_h_; n++ {
+ DefaultMBInfo(tls, (*VP8Encoder)(unsafe.Pointer(enc)).mb_info_+uintptr(n)*4)
}
// Default susceptibilities.
- (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */))).alpha_ = 0
- (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */))).beta_ = 0
+ (*VP8SegmentInfo)(unsafe.Pointer(enc + 608)).alpha_ = 0
+ (*VP8SegmentInfo)(unsafe.Pointer(enc + 608)).beta_ = 0
// Note: we can't compute this alpha_ / uv_alpha_ -> set to default value.
(*VP8Encoder)(unsafe.Pointer(enc)).alpha_ = 0
(*VP8Encoder)(unsafe.Pointer(enc)).uv_alpha_ = 0
- WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, ((*VP8Encoder)(unsafe.Pointer(enc)).percent_ + 20), (enc + 536 /* &.percent_ */))
+ WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, (*VP8Encoder)(unsafe.Pointer(enc)).percent_+20, enc+536)
}
// struct used to collect job result
@@ -22660,17 +22400,20 @@ type SegmentJob = struct {
// main work call
func DoSegmentsJob(tls *libc.TLS, arg1 uintptr, arg2 uintptr) int32 { /* analysis_enc.c:377:12: */
+ bp := tls.Alloc(63)
+ defer tls.Free(63)
+
var job uintptr = arg1
var it uintptr = arg2
var ok int32 = 1
if !(VP8IteratorIsDone(tls, it) != 0) {
- var tmp [63]uint8_t
+ // var tmp [63]uint8_t at bp, 63
- var scratch uintptr = (uintptr((uintptr_t(libc.Uint64FromUint8(tmp[0])) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
- for ok := int32(1); ok != 1; ok = VP8IteratorNext(tls, it) {
+ var scratch uintptr = uintptr((uintptr_t(bp) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
+ for __ccgo := true; __ccgo; __ccgo = ok != 0 && VP8IteratorNext(tls, it) != 0 {
// Let's pretend we have perfect lossless reconstruction.
VP8IteratorImport(tls, it, scratch)
- MBAnalyze(tls, it, (job + 48 /* &.alphas */), (job + 1072 /* &.alpha */), (job + 1076 /* &.uv_alpha */))
+ MBAnalyze(tls, it, job+48, job+1072, job+1076)
ok = VP8IteratorProgress(tls, it, (*SegmentJob)(unsafe.Pointer(job)).delta_progress)
}
}
@@ -22680,24 +22423,24 @@ func DoSegmentsJob(tls *libc.TLS, arg1 uintptr, arg2 uintptr) int32 { /* analysi
func MergeJobs(tls *libc.TLS, src uintptr, dst uintptr) { /* analysis_enc.c:394:13: */
var i int32
for i = 0; i <= 255; i++ {
- *(*int32)(unsafe.Pointer(((dst + 48 /* &.alphas */) + uintptr(i)*4))) += (*(*int32)(unsafe.Pointer((src + 48 /* &.alphas */) + uintptr(i)*4)))
+ *(*int32)(unsafe.Pointer(dst + 48 + uintptr(i)*4)) += *(*int32)(unsafe.Pointer(src + 48 + uintptr(i)*4))
}
- *(*int32)(unsafe.Pointer((dst + 1072 /* &.alpha */))) += ((*SegmentJob)(unsafe.Pointer(src)).alpha)
- *(*int32)(unsafe.Pointer((dst + 1076 /* &.uv_alpha */))) += ((*SegmentJob)(unsafe.Pointer(src)).uv_alpha)
+ *(*int32)(unsafe.Pointer(dst + 1072)) += (*SegmentJob)(unsafe.Pointer(src)).alpha
+ *(*int32)(unsafe.Pointer(dst + 1076)) += (*SegmentJob)(unsafe.Pointer(src)).uv_alpha
}
// initialize the job struct with some tasks to perform
func InitSegmentJob(tls *libc.TLS, enc uintptr, job uintptr, start_row int32, end_row int32) { /* analysis_enc.c:402:13: */
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Init})).f(tls, (job /* &.worker */))
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).Init})).f(tls, job /* &.worker */)
(*SegmentJob)(unsafe.Pointer(job)).worker.data1 = job
- (*SegmentJob)(unsafe.Pointer(job)).worker.data2 = (job + 1080 /* &.it */)
+ (*SegmentJob)(unsafe.Pointer(job)).worker.data2 = job + 1080
(*SegmentJob)(unsafe.Pointer(job)).worker.hook = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) int32
}{DoSegmentsJob}))
- VP8IteratorInit(tls, enc, (job + 1080 /* &.it */))
- VP8IteratorSetRow(tls, (job + 1080 /* &.it */), start_row)
- VP8IteratorSetCountDown(tls, (job + 1080 /* &.it */), ((end_row - start_row) * (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_))
- libc.Xmemset(tls, (job + 48 /* &.alphas */), 0, uint64(unsafe.Sizeof([256]int32{})))
+ VP8IteratorInit(tls, enc, job+1080)
+ VP8IteratorSetRow(tls, job+1080, start_row)
+ VP8IteratorSetCountDown(tls, job+1080, (end_row-start_row)*(*VP8Encoder)(unsafe.Pointer(enc)).mb_w_)
+ libc.Xmemset(tls, job+48, 0, uint64(unsafe.Sizeof([256]int32{})))
(*SegmentJob)(unsafe.Pointer(job)).alpha = 0
(*SegmentJob)(unsafe.Pointer(job)).uv_alpha = 0
// only one of both jobs can record the progress, since we don't
@@ -22716,12 +22459,12 @@ func VP8EncAnalyze(tls *libc.TLS, enc uintptr) int32 { /* analysis_enc.c:420:5:
defer tls.Free(9872)
var ok int32 = 1
- var do_segments int32 = (libc.Bool32((((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).emulate_jpeg_size != 0) || ((*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.num_segments_ > 1)) || ((*VP8Encoder)(unsafe.Pointer(enc)).method_ <= 1))) // for method 0 - 1, we need preds_[] to be filled.
+ var do_segments int32 = libc.Bool32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).emulate_jpeg_size != 0 || (*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.num_segments_ > 1 || (*VP8Encoder)(unsafe.Pointer(enc)).method_ <= 1) // for method 0 - 1, we need preds_[] to be filled.
if do_segments != 0 {
var last_row int32 = (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_
// We give a little more than a half work to the main thread.
- var split_row int32 = (((9 * last_row) + 15) >> 4)
- var total_mb int32 = (last_row * (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_)
+ var split_row int32 = (9*last_row + 15) >> 4
+ var total_mb int32 = last_row * (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_
var do_mt int32 = 0
var worker_interface uintptr = WebPGetWorkerInterface(tls)
// var main_job SegmentJob at bp, 4936
@@ -22731,41 +22474,41 @@ func VP8EncAnalyze(tls *libc.TLS, enc uintptr) int32 { /* analysis_enc.c:420:5:
// Note the use of '&' instead of '&&' because we must call the functions
// no matter what.
- InitSegmentJob(tls, enc, (bp) /* &main_job */, 0, split_row)
- InitSegmentJob(tls, enc, (bp + 4936) /* &side_job */, split_row, last_row)
+ InitSegmentJob(tls, enc, bp, 0, split_row)
+ InitSegmentJob(tls, enc, bp+4936, split_row, last_row)
// we don't need to call Reset() on main_job.worker, since we're calling
// WebPWorkerExecute() on it
- ok = ok & ((*struct {
+ ok = ok & (*struct {
f func(*libc.TLS, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Reset})).f(tls, (bp + 4936) /* &side_job */ /* &.worker */))
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Reset})).f(tls, bp+4936)
// launch the two jobs in parallel
if ok != 0 {
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Launch})).f(tls, (bp + 4936) /* &side_job */ /* &.worker */)
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Execute})).f(tls, (bp) /* &main_job */ /* &.worker */)
- ok = ok & ((*struct {
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Launch})).f(tls, bp+4936 /* &side_job */ /* &.worker */)
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Execute})).f(tls, bp /* &main_job */ /* &.worker */)
+ ok = ok & (*struct {
f func(*libc.TLS, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Sync})).f(tls, (bp + 4936) /* &side_job */ /* &.worker */))
- ok = ok & ((*struct {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Sync})).f(tls, bp+4936)
+ ok = ok & (*struct {
f func(*libc.TLS, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Sync})).f(tls, (bp) /* &main_job */ /* &.worker */))
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Sync})).f(tls, bp)
}
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).End})).f(tls, (bp + 4936) /* &side_job */ /* &.worker */)
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).End})).f(tls, bp+4936 /* &side_job */ /* &.worker */)
if ok != 0 {
- MergeJobs(tls, (bp + 4936) /* &side_job */, (bp) /* &main_job */)
+ MergeJobs(tls, bp+4936, bp)
} // merge results together
} else {
// Even for single-thread case, we use the generic Worker tools.
- InitSegmentJob(tls, enc, (bp) /* &main_job */, 0, last_row)
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Execute})).f(tls, (bp) /* &main_job */ /* &.worker */)
- ok = ok & ((*struct {
+ InitSegmentJob(tls, enc, bp, 0, last_row)
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Execute})).f(tls, bp /* &main_job */ /* &.worker */)
+ ok = ok & (*struct {
f func(*libc.TLS, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Sync})).f(tls, (bp) /* &main_job */ /* &.worker */))
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Sync})).f(tls, bp)
}
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).End})).f(tls, (bp) /* &main_job */ /* &.worker */)
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).End})).f(tls, bp /* &main_job */ /* &.worker */)
if ok != 0 {
- (*VP8Encoder)(unsafe.Pointer(enc)).alpha_ = ((*SegmentJob)(unsafe.Pointer(bp /* &main_job */)).alpha / total_mb)
- (*VP8Encoder)(unsafe.Pointer(enc)).uv_alpha_ = ((*SegmentJob)(unsafe.Pointer(bp /* &main_job */)).uv_alpha / total_mb)
- AssignSegments(tls, enc, ((bp) /* &main_job */ + 48 /* &.alphas */))
+ (*VP8Encoder)(unsafe.Pointer(enc)).alpha_ = (*SegmentJob)(unsafe.Pointer(bp)).alpha / total_mb
+ (*VP8Encoder)(unsafe.Pointer(enc)).uv_alpha_ = (*SegmentJob)(unsafe.Pointer(bp)).uv_alpha / total_mb
+ AssignSegments(tls, enc, bp+48)
}
} else { // Use only one default segment.
ResetAllMBInfo(tls, enc)
@@ -22786,17 +22529,17 @@ func ConvertPopulationCountTableToBitEstimates(tls *libc.TLS, num_symbols int32,
var nonzeros int32 = 0
var i int32
for i = 0; i < num_symbols; i++ {
- sum = sum + (*(*uint32_t)(unsafe.Pointer(population_counts + uintptr(i)*4)))
+ sum = sum + *(*uint32_t)(unsafe.Pointer(population_counts + uintptr(i)*4))
if *(*uint32_t)(unsafe.Pointer(population_counts + uintptr(i)*4)) > uint32_t(0) {
nonzeros++
}
}
if nonzeros <= 1 {
- libc.Xmemset(tls, output, 0, (uint64(num_symbols) * uint64(unsafe.Sizeof(float64(0)))))
+ libc.Xmemset(tls, output, 0, uint64(num_symbols)*uint64(unsafe.Sizeof(float64(0))))
} else {
var logsum float64 = float64(VP8LFastLog2(tls, sum))
for i = 0; i < num_symbols; i++ {
- *(*float64)(unsafe.Pointer(output + uintptr(i)*8)) = (logsum - float64(VP8LFastLog2(tls, *(*uint32_t)(unsafe.Pointer(population_counts + uintptr(i)*4)))))
+ *(*float64)(unsafe.Pointer(output + uintptr(i)*8)) = logsum - float64(VP8LFastLog2(tls, *(*uint32_t)(unsafe.Pointer(population_counts + uintptr(i)*4))))
}
}
}
@@ -22812,7 +22555,7 @@ func CostModelBuild(tls *libc.TLS, m uintptr, xsize int32, cache_bits int32, ref
ok = 0
*(*VP8LRefsCursor)(unsafe.Pointer(bp /* c */)) = VP8LRefsCursorInit(tls, refs)
histo = VP8LAllocateHistogram(tls, cache_bits)
- if !(histo == (uintptr(0))) {
+ if !(histo == uintptr(0)) {
goto __1
}
goto Error
@@ -22823,14 +22566,14 @@ __1:
// distance to plane code.
VP8LHistogramInit(tls, histo, cache_bits /*init_arrays=*/, 1)
__2:
- if !(VP8LRefsCursorOk(tls, (bp) /* &c */) != 0) {
+ if !(VP8LRefsCursorOk(tls, bp) != 0) {
goto __3
}
VP8LHistogramAddSinglePixOrCopy(tls, histo, (*VP8LRefsCursor)(unsafe.Pointer(bp /* &c */)).cur_pos, *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, int32, int32) int32
}{VP8LDistanceToPlaneCode})),
xsize)
- VP8LRefsCursorNext(tls, (bp) /* &c */)
+ VP8LRefsCursorNext(tls, bp)
goto __2
__3:
;
@@ -22839,13 +22582,13 @@ __3:
VP8LHistogramNumCodes(tls, (*VP8LHistogram)(unsafe.Pointer(histo)).palette_code_bits_),
(*VP8LHistogram)(unsafe.Pointer(histo)).literal_, (*CostModel)(unsafe.Pointer(m)).literal_)
ConvertPopulationCountTableToBitEstimates(tls,
- 256, (histo + 8 /* &.red_ */), (m + 2048 /* &.red_ */))
+ 256, histo+8, m+2048)
ConvertPopulationCountTableToBitEstimates(tls,
- 256, (histo + 1032 /* &.blue_ */), (m + 4096 /* &.blue_ */))
+ 256, histo+1032, m+4096)
ConvertPopulationCountTableToBitEstimates(tls,
- 256, (histo + 2056 /* &.alpha_ */), (m /* &.alpha_ */))
+ 256, histo+2056, m)
ConvertPopulationCountTableToBitEstimates(tls,
- 40, (histo + 3080 /* &.distance_ */), (m + 6144 /* &.distance_ */))
+ 40, histo+3080, m+6144)
ok = 1
Error:
@@ -22854,11 +22597,11 @@ Error:
}
func GetLiteralCost(tls *libc.TLS, m uintptr, v uint32_t) float64 { /* backward_references_cost_enc.c:95:27: */
- return (((*(*float64)(unsafe.Pointer((m /* &.alpha_ */) + uintptr((v>>24))*8)) + *(*float64)(unsafe.Pointer((m + 2048 /* &.red_ */) + uintptr(((v>>16)&uint32_t(0xff)))*8))) + *(*float64)(unsafe.Pointer((*CostModel)(unsafe.Pointer(m)).literal_ + uintptr(((v>>8)&uint32_t(0xff)))*8))) + *(*float64)(unsafe.Pointer((m + 4096 /* &.blue_ */) + uintptr((v&uint32_t(0xff)))*8)))
+ return *(*float64)(unsafe.Pointer(m + uintptr(v>>24)*8)) + *(*float64)(unsafe.Pointer(m + 2048 + uintptr(v>>16&uint32_t(0xff))*8)) + *(*float64)(unsafe.Pointer((*CostModel)(unsafe.Pointer(m)).literal_ + uintptr(v>>8&uint32_t(0xff))*8)) + *(*float64)(unsafe.Pointer(m + 4096 + uintptr(v&uint32_t(0xff))*8))
}
func GetCacheCost(tls *libc.TLS, m uintptr, idx uint32_t) float64 { /* backward_references_cost_enc.c:102:27: */
- var literal_idx int32 = (int32((uint32_t(256 + 24)) + idx))
+ var literal_idx int32 = int32(uint32_t(256+24) + idx)
return *(*float64)(unsafe.Pointer((*CostModel)(unsafe.Pointer(m)).literal_ + uintptr(literal_idx)*8))
}
@@ -22870,8 +22613,8 @@ func GetLengthCost(tls *libc.TLS, m uintptr, length uint32_t) float64 { /* backw
// var extra_bits int32 at bp+4, 4
- VP8LPrefixEncodeBits(tls, int32(length), (bp) /* &code */, (bp + 4) /* &extra_bits */)
- return (*(*float64)(unsafe.Pointer((*CostModel)(unsafe.Pointer(m)).literal_ + uintptr((256+*(*int32)(unsafe.Pointer(bp /* code */))))*8)) + float64(*(*int32)(unsafe.Pointer(bp + 4 /* extra_bits */))))
+ VP8LPrefixEncodeBits(tls, int32(length), bp, bp+4)
+ return *(*float64)(unsafe.Pointer((*CostModel)(unsafe.Pointer(m)).literal_ + uintptr(256+*(*int32)(unsafe.Pointer(bp)))*8)) + float64(*(*int32)(unsafe.Pointer(bp + 4)))
}
func GetDistanceCost(tls *libc.TLS, m uintptr, distance uint32_t) float64 { /* backward_references_cost_enc.c:114:27: */
@@ -22882,8 +22625,8 @@ func GetDistanceCost(tls *libc.TLS, m uintptr, distance uint32_t) float64 { /* b
// var extra_bits int32 at bp+4, 4
- VP8LPrefixEncodeBits(tls, int32(distance), (bp) /* &code */, (bp + 4) /* &extra_bits */)
- return (*(*float64)(unsafe.Pointer((m + 6144 /* &.distance_ */) + uintptr(*(*int32)(unsafe.Pointer(bp /* code */)))*8)) + float64(*(*int32)(unsafe.Pointer(bp + 4 /* extra_bits */))))
+ VP8LPrefixEncodeBits(tls, int32(distance), bp, bp+4)
+ return *(*float64)(unsafe.Pointer(m + 6144 + uintptr(*(*int32)(unsafe.Pointer(bp)))*8)) + float64(*(*int32)(unsafe.Pointer(bp + 4)))
}
func AddSingleLiteralWithCostModel(tls *libc.TLS, argb uintptr, hashers uintptr, cost_model uintptr, idx int32, use_color_cache int32, prev_cost float32, cost uintptr, dist_array uintptr) { /* backward_references_cost_enc.c:121:25: */
@@ -22898,13 +22641,13 @@ func AddSingleLiteralWithCostModel(tls *libc.TLS, argb uintptr, hashers uintptr,
if ix >= 0 {
// use_color_cache is true and hashers contains color
var mul0 float64 = 0.68
- cost_val = cost_val + (GetCacheCost(tls, cost_model, uint32(ix)) * mul0)
+ cost_val = cost_val + GetCacheCost(tls, cost_model, uint32(ix))*mul0
} else {
var mul1 float64 = 0.82
if use_color_cache != 0 {
VP8LColorCacheInsert(tls, hashers, color)
}
- cost_val = cost_val + (GetLiteralCost(tls, cost_model, color) * mul1)
+ cost_val = cost_val + GetLiteralCost(tls, cost_model, color)*mul1
}
if float64(*(*float32)(unsafe.Pointer(cost + uintptr(idx)*4))) > cost_val {
*(*float32)(unsafe.Pointer(cost + uintptr(idx)*4)) = float32(cost_val)
@@ -22992,19 +22735,19 @@ func CostIntervalAddToFreeList(tls *libc.TLS, manager uintptr, interval uintptr)
}
func CostIntervalIsInFreeList(tls *libc.TLS, manager uintptr, interval uintptr) int32 { /* backward_references_cost_enc.c:208:12: */
- return (libc.Bool32((interval >= (manager + 32808 /* &.intervals_ */)) && (interval <= ((manager + 32808 /* &.intervals_ */) + 9*32))))
+ return libc.Bool32(interval >= manager+32808 && interval <= manager+32808+9*32)
}
func CostManagerInitFreeList(tls *libc.TLS, manager uintptr) { /* backward_references_cost_enc.c:214:13: */
var i int32
- (*CostManager)(unsafe.Pointer(manager)).free_intervals_ = (uintptr(0))
+ (*CostManager)(unsafe.Pointer(manager)).free_intervals_ = uintptr(0)
for i = 0; i < 10; i++ {
- CostIntervalAddToFreeList(tls, manager, ((manager + 32808 /* &.intervals_ */) + uintptr(i)*32))
+ CostIntervalAddToFreeList(tls, manager, manager+32808+uintptr(i)*32)
}
}
func DeleteIntervalList(tls *libc.TLS, manager uintptr, interval uintptr) { /* backward_references_cost_enc.c:222:13: */
- for interval != (uintptr(0)) {
+ for interval != uintptr(0) {
var next uintptr = (*CostInterval)(unsafe.Pointer(interval)).next_
if !(CostIntervalIsInFreeList(tls, manager, interval) != 0) {
WebPSafeFree(tls, interval)
@@ -23014,7 +22757,7 @@ func DeleteIntervalList(tls *libc.TLS, manager uintptr, interval uintptr) { /* b
}
func CostManagerClear(tls *libc.TLS, manager uintptr) { /* backward_references_cost_enc.c:233:13: */
- if manager == (uintptr(0)) {
+ if manager == uintptr(0) {
return
}
@@ -23023,9 +22766,9 @@ func CostManagerClear(tls *libc.TLS, manager uintptr) { /* backward_references_c
// Clear the interval lists.
DeleteIntervalList(tls, manager, (*CostManager)(unsafe.Pointer(manager)).head_)
- (*CostManager)(unsafe.Pointer(manager)).head_ = (uintptr(0))
+ (*CostManager)(unsafe.Pointer(manager)).head_ = uintptr(0)
DeleteIntervalList(tls, manager, (*CostManager)(unsafe.Pointer(manager)).recycled_intervals_)
- (*CostManager)(unsafe.Pointer(manager)).recycled_intervals_ = (uintptr(0))
+ (*CostManager)(unsafe.Pointer(manager)).recycled_intervals_ = uintptr(0)
// Reset pointers, count_ and cache_intervals_size_.
libc.Xmemset(tls, manager, 0, uint64(unsafe.Sizeof(CostManager{})))
@@ -23035,27 +22778,27 @@ func CostManagerClear(tls *libc.TLS, manager uintptr) { /* backward_references_c
func CostManagerInit(tls *libc.TLS, manager uintptr, dist_array uintptr, pix_count int32, cost_model uintptr) int32 { /* backward_references_cost_enc.c:250:12: */
var i int32
var cost_cache_size int32
- if pix_count > ((int32(1) << 12) - 1) {
- cost_cache_size = ((int32(1) << 12) - 1)
+ if pix_count > int32(1)<<12-1 {
+ cost_cache_size = int32(1)<<12 - 1
} else {
cost_cache_size = pix_count
}
- (*CostManager)(unsafe.Pointer(manager)).costs_ = (uintptr(0))
- (*CostManager)(unsafe.Pointer(manager)).cache_intervals_ = (uintptr(0))
- (*CostManager)(unsafe.Pointer(manager)).head_ = (uintptr(0))
- (*CostManager)(unsafe.Pointer(manager)).recycled_intervals_ = (uintptr(0))
+ (*CostManager)(unsafe.Pointer(manager)).costs_ = uintptr(0)
+ (*CostManager)(unsafe.Pointer(manager)).cache_intervals_ = uintptr(0)
+ (*CostManager)(unsafe.Pointer(manager)).head_ = uintptr(0)
+ (*CostManager)(unsafe.Pointer(manager)).recycled_intervals_ = uintptr(0)
(*CostManager)(unsafe.Pointer(manager)).count_ = 0
(*CostManager)(unsafe.Pointer(manager)).dist_array_ = dist_array
CostManagerInitFreeList(tls, manager)
// Fill in the cost_cache_.
(*CostManager)(unsafe.Pointer(manager)).cache_intervals_size_ = uint64(1)
- *(*float64)(unsafe.Pointer((manager + 32 /* &.cost_cache_ */))) = GetLengthCost(tls, cost_model, uint32(0))
+ *(*float64)(unsafe.Pointer(manager + 32)) = GetLengthCost(tls, cost_model, uint32(0))
for i = 1; i < cost_cache_size; i++ {
- *(*float64)(unsafe.Pointer((manager + 32 /* &.cost_cache_ */) + uintptr(i)*8)) = GetLengthCost(tls, cost_model, uint32(i))
+ *(*float64)(unsafe.Pointer(manager + 32 + uintptr(i)*8)) = GetLengthCost(tls, cost_model, uint32(i))
// Get the number of bound intervals.
- if *(*float64)(unsafe.Pointer((manager + 32 /* &.cost_cache_ */) + uintptr(i)*8)) != *(*float64)(unsafe.Pointer((manager + 32 /* &.cost_cache_ */) + uintptr((i-1))*8)) {
+ if *(*float64)(unsafe.Pointer(manager + 32 + uintptr(i)*8)) != *(*float64)(unsafe.Pointer(manager + 32 + uintptr(i-1)*8)) {
(*CostManager)(unsafe.Pointer(manager)).cache_intervals_size_++
}
}
@@ -23067,7 +22810,7 @@ func CostManagerInit(tls *libc.TLS, manager uintptr, dist_array uintptr, pix_cou
(*CostManager)(unsafe.Pointer(manager)).cache_intervals_ = WebPSafeMalloc(tls,
(*CostManager)(unsafe.Pointer(manager)).cache_intervals_size_, uint64(unsafe.Sizeof(CostCacheInterval{})))
- if (*CostManager)(unsafe.Pointer(manager)).cache_intervals_ == (uintptr(0)) {
+ if (*CostManager)(unsafe.Pointer(manager)).cache_intervals_ == uintptr(0) {
CostManagerClear(tls, manager)
return 0
}
@@ -23080,22 +22823,22 @@ func CostManagerInit(tls *libc.TLS, manager uintptr, dist_array uintptr, pix_cou
// difference is found, a new interval is created and bounded.
(*CostCacheInterval)(unsafe.Pointer(cur)).start_ = 0
(*CostCacheInterval)(unsafe.Pointer(cur)).end_ = 1
- (*CostCacheInterval)(unsafe.Pointer(cur)).cost_ = *(*float64)(unsafe.Pointer((manager + 32 /* &.cost_cache_ */)))
+ (*CostCacheInterval)(unsafe.Pointer(cur)).cost_ = *(*float64)(unsafe.Pointer(manager + 32))
for i = 1; i < cost_cache_size; i++ {
- var cost_val float64 = *(*float64)(unsafe.Pointer((manager + 32 /* &.cost_cache_ */) + uintptr(i)*8))
+ var cost_val float64 = *(*float64)(unsafe.Pointer(manager + 32 + uintptr(i)*8))
if cost_val != (*CostCacheInterval)(unsafe.Pointer(cur)).cost_ {
cur += 16
// Initialize an interval.
(*CostCacheInterval)(unsafe.Pointer(cur)).start_ = i
(*CostCacheInterval)(unsafe.Pointer(cur)).cost_ = cost_val
}
- (*CostCacheInterval)(unsafe.Pointer(cur)).end_ = (i + 1)
+ (*CostCacheInterval)(unsafe.Pointer(cur)).end_ = i + 1
}
}
(*CostManager)(unsafe.Pointer(manager)).costs_ = WebPSafeMalloc(tls, uint64(pix_count), uint64(unsafe.Sizeof(float32(0))))
- if (*CostManager)(unsafe.Pointer(manager)).costs_ == (uintptr(0)) {
+ if (*CostManager)(unsafe.Pointer(manager)).costs_ == uintptr(0) {
CostManagerClear(tls, manager)
return 0
}
@@ -23110,11 +22853,11 @@ func CostManagerInit(tls *libc.TLS, manager uintptr, dist_array uintptr, pix_cou
// Given the cost and the position that define an interval, update the cost at
// pixel 'i' if it is smaller than the previously computed value.
func UpdateCost(tls *libc.TLS, manager uintptr, i int32, position int32, cost float32) { /* backward_references_cost_enc.c:321:25: */
- var k int32 = (i - position)
+ var k int32 = i - position
if *(*float32)(unsafe.Pointer((*CostManager)(unsafe.Pointer(manager)).costs_ + uintptr(i)*4)) > cost {
*(*float32)(unsafe.Pointer((*CostManager)(unsafe.Pointer(manager)).costs_ + uintptr(i)*4)) = cost
- *(*uint16_t)(unsafe.Pointer((*CostManager)(unsafe.Pointer(manager)).dist_array_ + uintptr(i)*2)) = (uint16_t(k + 1))
+ *(*uint16_t)(unsafe.Pointer((*CostManager)(unsafe.Pointer(manager)).dist_array_ + uintptr(i)*2)) = uint16_t(k + 1)
}
}
@@ -23129,20 +22872,20 @@ func UpdateCostPerInterval(tls *libc.TLS, manager uintptr, start int32, end int3
// Given two intervals, make 'prev' be the previous one of 'next' in 'manager'.
func ConnectIntervals(tls *libc.TLS, manager uintptr, prev uintptr, next uintptr) { /* backward_references_cost_enc.c:342:25: */
- if prev != (uintptr(0)) {
+ if prev != uintptr(0) {
(*CostInterval)(unsafe.Pointer(prev)).next_ = next
} else {
(*CostManager)(unsafe.Pointer(manager)).head_ = next
}
- if next != (uintptr(0)) {
+ if next != uintptr(0) {
(*CostInterval)(unsafe.Pointer(next)).previous_ = prev
}
}
// Pop an interval in the manager.
func PopInterval(tls *libc.TLS, manager uintptr, interval uintptr) { /* backward_references_cost_enc.c:355:25: */
- if interval == (uintptr(0)) {
+ if interval == uintptr(0) {
return
}
@@ -23164,7 +22907,7 @@ func PopInterval(tls *libc.TLS, manager uintptr, interval uintptr) { /* backward
func UpdateCostAtIndex(tls *libc.TLS, manager uintptr, i int32, do_clean_intervals int32) { /* backward_references_cost_enc.c:374:25: */
var current uintptr = (*CostManager)(unsafe.Pointer(manager)).head_
- for (current != (uintptr(0))) && ((*CostInterval)(unsafe.Pointer(current)).start_ <= i) {
+ for current != uintptr(0) && (*CostInterval)(unsafe.Pointer(current)).start_ <= i {
var next uintptr = (*CostInterval)(unsafe.Pointer(current)).next_
if (*CostInterval)(unsafe.Pointer(current)).end_ <= i {
if do_clean_intervals != 0 {
@@ -23183,17 +22926,17 @@ func UpdateCostAtIndex(tls *libc.TLS, manager uintptr, i int32, do_clean_interva
// of intervals using the start_ ordering and the previous interval as a hint.
func PositionOrphanInterval(tls *libc.TLS, manager uintptr, current uintptr, previous uintptr) { /* backward_references_cost_enc.c:395:25: */
- if previous == (uintptr(0)) {
+ if previous == uintptr(0) {
previous = (*CostManager)(unsafe.Pointer(manager)).head_
}
- for (previous != (uintptr(0))) && ((*CostInterval)(unsafe.Pointer(current)).start_ < (*CostInterval)(unsafe.Pointer(previous)).start_) {
+ for previous != uintptr(0) && (*CostInterval)(unsafe.Pointer(current)).start_ < (*CostInterval)(unsafe.Pointer(previous)).start_ {
previous = (*CostInterval)(unsafe.Pointer(previous)).previous_
}
- for ((previous != (uintptr(0))) && ((*CostInterval)(unsafe.Pointer(previous)).next_ != (uintptr(0)))) && ((*CostInterval)(unsafe.Pointer((*CostInterval)(unsafe.Pointer(previous)).next_)).start_ < (*CostInterval)(unsafe.Pointer(current)).start_) {
+ for previous != uintptr(0) && (*CostInterval)(unsafe.Pointer(previous)).next_ != uintptr(0) && (*CostInterval)(unsafe.Pointer((*CostInterval)(unsafe.Pointer(previous)).next_)).start_ < (*CostInterval)(unsafe.Pointer(current)).start_ {
previous = (*CostInterval)(unsafe.Pointer(previous)).next_
}
- if previous != (uintptr(0)) {
+ if previous != uintptr(0) {
ConnectIntervals(tls, manager, current, (*CostInterval)(unsafe.Pointer(previous)).next_)
} else {
ConnectIntervals(tls, manager, current, (*CostManager)(unsafe.Pointer(manager)).head_)
@@ -23214,15 +22957,15 @@ func InsertInterval(tls *libc.TLS, manager uintptr, interval_in uintptr, cost fl
UpdateCostPerInterval(tls, manager, start, end, position, cost)
return
}
- if (*CostManager)(unsafe.Pointer(manager)).free_intervals_ != (uintptr(0)) {
+ if (*CostManager)(unsafe.Pointer(manager)).free_intervals_ != uintptr(0) {
interval_new = (*CostManager)(unsafe.Pointer(manager)).free_intervals_
(*CostManager)(unsafe.Pointer(manager)).free_intervals_ = (*CostInterval)(unsafe.Pointer(interval_new)).next_
- } else if (*CostManager)(unsafe.Pointer(manager)).recycled_intervals_ != (uintptr(0)) {
+ } else if (*CostManager)(unsafe.Pointer(manager)).recycled_intervals_ != uintptr(0) {
interval_new = (*CostManager)(unsafe.Pointer(manager)).recycled_intervals_
(*CostManager)(unsafe.Pointer(manager)).recycled_intervals_ = (*CostInterval)(unsafe.Pointer(interval_new)).next_
} else { // malloc for good
interval_new = WebPSafeMalloc(tls, uint64(1), uint64(unsafe.Sizeof(CostInterval{})))
- if interval_new == (uintptr(0)) {
+ if interval_new == uintptr(0) {
// Write down the interval if we cannot create it.
UpdateCostPerInterval(tls, manager, start, end, position, cost)
return
@@ -23253,32 +22996,32 @@ func PushInterval(tls *libc.TLS, manager uintptr, distance_cost float64, positio
if len < kSkipDistance {
var j int32
- for j = position; j < (position + len); j++ {
- var k int32 = (j - position)
+ for j = position; j < position+len; j++ {
+ var k int32 = j - position
var cost_tmp float32
- cost_tmp = (float32(distance_cost + *(*float64)(unsafe.Pointer((manager + 32 /* &.cost_cache_ */) + uintptr(k)*8))))
+ cost_tmp = float32(distance_cost + *(*float64)(unsafe.Pointer(manager + 32 + uintptr(k)*8)))
if *(*float32)(unsafe.Pointer((*CostManager)(unsafe.Pointer(manager)).costs_ + uintptr(j)*4)) > cost_tmp {
*(*float32)(unsafe.Pointer((*CostManager)(unsafe.Pointer(manager)).costs_ + uintptr(j)*4)) = cost_tmp
- *(*uint16_t)(unsafe.Pointer((*CostManager)(unsafe.Pointer(manager)).dist_array_ + uintptr(j)*2)) = (uint16_t(k + 1))
+ *(*uint16_t)(unsafe.Pointer((*CostManager)(unsafe.Pointer(manager)).dist_array_ + uintptr(j)*2)) = uint16_t(k + 1)
}
}
return
}
- for i = uint64(0); (i < (*CostManager)(unsafe.Pointer(manager)).cache_intervals_size_) && ((*CostCacheInterval)(unsafe.Pointer(cost_cache_intervals+uintptr(i)*16)).start_ < len); i++ {
+ for i = uint64(0); i < (*CostManager)(unsafe.Pointer(manager)).cache_intervals_size_ && (*CostCacheInterval)(unsafe.Pointer(cost_cache_intervals+uintptr(i)*16)).start_ < len; i++ {
// Define the intersection of the ith interval with the new one.
- var start int32 = (position + (*CostCacheInterval)(unsafe.Pointer(cost_cache_intervals+uintptr(i)*16)).start_)
- var end int32 = (position + (func() int32 {
+ var start int32 = position + (*CostCacheInterval)(unsafe.Pointer(cost_cache_intervals+uintptr(i)*16)).start_
+ var end int32 = position + func() int32 {
if (*CostCacheInterval)(unsafe.Pointer(cost_cache_intervals+uintptr(i)*16)).end_ > len {
return len
}
return (*CostCacheInterval)(unsafe.Pointer(cost_cache_intervals + uintptr(i)*16)).end_
- }()))
- var cost float32 = (float32(distance_cost + (*CostCacheInterval)(unsafe.Pointer(cost_cache_intervals+uintptr(i)*16)).cost_))
+ }()
+ var cost float32 = float32(distance_cost + (*CostCacheInterval)(unsafe.Pointer(cost_cache_intervals+uintptr(i)*16)).cost_)
- for ; (interval != (uintptr(0))) && ((*CostInterval)(unsafe.Pointer(interval)).start_ < end); interval = interval_next {
+ for ; interval != uintptr(0) && (*CostInterval)(unsafe.Pointer(interval)).start_ < end; interval = interval_next {
interval_next = (*CostInterval)(unsafe.Pointer(interval)).next_
// Make sure we have some overlap
@@ -23387,16 +23130,16 @@ func BackwardReferencesHashChainDistanceOnly(tls *libc.TLS, xsize int32, ysize i
// var len int32 at bp+20, 4
ok = 0
cc_init = 0
- pix_count = (xsize * ysize)
- use_color_cache = (libc.Bool32(cache_bits > 0))
+ pix_count = xsize * ysize
+ use_color_cache = libc.Bool32(cache_bits > 0)
literal_array_size =
- (uint64(unsafe.Sizeof(float64(0))) * (uint64((256 + 24) + (func() int32 {
+ uint64(unsafe.Sizeof(float64(0))) * uint64(256+24+func() int32 {
if cache_bits > 0 {
- return (int32(1) << cache_bits)
+ return int32(1) << cache_bits
}
return 0
- }()))))
- cost_model_size = (uint64(unsafe.Sizeof(CostModel{})) + literal_array_size)
+ }())
+ cost_model_size = uint64(unsafe.Sizeof(CostModel{})) + literal_array_size
cost_model =
WebPSafeCalloc(tls, 1, cost_model_size)
cost_manager =
@@ -23407,19 +23150,19 @@ func BackwardReferencesHashChainDistanceOnly(tls *libc.TLS, xsize int32, ysize i
first_offset_is_constant = -1
reach = 0
- if !((cost_model == (uintptr(0))) || (cost_manager == (uintptr(0)))) {
+ if !(cost_model == uintptr(0) || cost_manager == uintptr(0)) {
goto __1
}
goto Error
__1:
;
- (*CostModel)(unsafe.Pointer(cost_model)).literal_ = (cost_model + uintptr(1)*6472)
+ (*CostModel)(unsafe.Pointer(cost_model)).literal_ = cost_model + uintptr(1)*6472
if !(use_color_cache != 0) {
goto __2
}
- cc_init = VP8LColorCacheInit(tls, (bp) /* &hashers */, cache_bits)
- if !(!(cc_init != 0)) {
+ cc_init = VP8LColorCacheInit(tls, bp, cache_bits)
+ if !!(cc_init != 0) {
goto __3
}
goto Error
@@ -23428,14 +23171,14 @@ __3:
__2:
;
- if !(!(CostModelBuild(tls, cost_model, xsize, cache_bits, refs) != 0)) {
+ if !!(CostModelBuild(tls, cost_model, xsize, cache_bits, refs) != 0) {
goto __4
}
goto Error
__4:
;
- if !(!(CostManagerInit(tls, cost_manager, dist_array, pix_count, cost_model) != 0)) {
+ if !!(CostManagerInit(tls, cost_manager, dist_array, pix_count, cost_model) != 0) {
goto __5
}
goto Error
@@ -23446,7 +23189,7 @@ __5:
// non-processed locations from this point.
*(*uint16_t)(unsafe.Pointer(dist_array)) = uint16_t(0)
// Add first pixel as literal.
- AddSingleLiteralWithCostModel(tls, argb, (bp) /* &hashers */, cost_model, 0, use_color_cache,
+ AddSingleLiteralWithCostModel(tls, argb, bp, cost_model, 0, use_color_cache,
0., (*CostManager)(unsafe.Pointer(cost_manager)).costs_, dist_array)
i = 1
@@ -23454,25 +23197,25 @@ __6:
if !(i < pix_count) {
goto __8
}
- prev_cost = *(*float32)(unsafe.Pointer((*CostManager)(unsafe.Pointer(cost_manager)).costs_ + uintptr((i-1))*4))
- VP8LHashChainFindCopy(tls, hash_chain, i, (bp + 16) /* &offset */, (bp + 20) /* &len */)
+ prev_cost = *(*float32)(unsafe.Pointer((*CostManager)(unsafe.Pointer(cost_manager)).costs_ + uintptr(i-1)*4))
+ VP8LHashChainFindCopy(tls, hash_chain, i, bp+16, bp+20)
// Try adding the pixel as a literal.
- AddSingleLiteralWithCostModel(tls, argb, (bp) /* &hashers */, cost_model, i,
+ AddSingleLiteralWithCostModel(tls, argb, bp, cost_model, i,
use_color_cache, prev_cost,
(*CostManager)(unsafe.Pointer(cost_manager)).costs_, dist_array)
// If we are dealing with a non-literal.
- if !(*(*int32)(unsafe.Pointer(bp + 20 /* len */)) >= 2) {
+ if !(*(*int32)(unsafe.Pointer(bp + 20)) >= 2) {
goto __9
}
- if !(*(*int32)(unsafe.Pointer(bp + 16 /* offset */)) != offset_prev) {
+ if !(*(*int32)(unsafe.Pointer(bp + 16)) != offset_prev) {
goto __10
}
code = VP8LDistanceToPlaneCode(tls, xsize, *(*int32)(unsafe.Pointer(bp + 16 /* offset */)))
offset_cost = GetDistanceCost(tls, cost_model, uint32(code))
first_offset_is_constant = 1
- PushInterval(tls, cost_manager, (float64(prev_cost) + offset_cost), i, *(*int32)(unsafe.Pointer(bp + 20 /* len */)))
+ PushInterval(tls, cost_manager, float64(prev_cost)+offset_cost, i, *(*int32)(unsafe.Pointer(bp + 20 /* len */)))
goto __11
__10:
;
@@ -23485,12 +23228,12 @@ __10:
if !(first_offset_is_constant != 0) {
goto __12
}
- reach = (((i - 1) + len_prev) - 1)
+ reach = i - 1 + len_prev - 1
first_offset_is_constant = 0
__12:
;
- if !(((i + *(*int32)(unsafe.Pointer(bp + 20 /* len */))) - 1) > reach) {
+ if !(i+*(*int32)(unsafe.Pointer(bp + 20))-1 > reach) {
goto __13
}
*(*int32)(unsafe.Pointer(bp + 28 /* len_j */)) = 0
@@ -23502,11 +23245,11 @@ __14:
if !(j <= reach) {
goto __16
}
- VP8LHashChainFindCopy(tls, hash_chain, (j + 1), (bp + 24) /* &offset_j */, (bp + 28) /* &len_j */)
- if !(*(*int32)(unsafe.Pointer(bp + 24 /* offset_j */)) != *(*int32)(unsafe.Pointer(bp + 16 /* offset */))) {
+ VP8LHashChainFindCopy(tls, hash_chain, j+1, bp+24, bp+28)
+ if !(*(*int32)(unsafe.Pointer(bp + 24)) != *(*int32)(unsafe.Pointer(bp + 16))) {
goto __17
}
- VP8LHashChainFindCopy(tls, hash_chain, j, (bp + 24) /* &offset_j */, (bp + 28) /* &len_j */)
+ VP8LHashChainFindCopy(tls, hash_chain, j, bp+24, bp+28)
goto __16
__17:
;
@@ -23518,12 +23261,12 @@ __15:
__16:
;
// Update the cost at j - 1 and j.
- UpdateCostAtIndex(tls, cost_manager, (j - 1), 0)
+ UpdateCostAtIndex(tls, cost_manager, j-1, 0)
UpdateCostAtIndex(tls, cost_manager, j, 0)
- PushInterval(tls, cost_manager, (float64(*(*float32)(unsafe.Pointer((*CostManager)(unsafe.Pointer(cost_manager)).costs_ + uintptr((j-1))*4))) + offset_cost),
+ PushInterval(tls, cost_manager, float64(*(*float32)(unsafe.Pointer((*CostManager)(unsafe.Pointer(cost_manager)).costs_ + uintptr(j-1)*4)))+offset_cost,
j, *(*int32)(unsafe.Pointer(bp + 28 /* len_j */)))
- reach = ((j + *(*int32)(unsafe.Pointer(bp + 28 /* len_j */))) - 1)
+ reach = j + *(*int32)(unsafe.Pointer(bp + 28)) - 1
__13:
;
__11:
@@ -23547,7 +23290,7 @@ Error:
if !(cc_init != 0) {
goto __18
}
- VP8LColorCacheClear(tls, (bp) /* &hashers */)
+ VP8LColorCacheClear(tls, bp)
__18:
;
CostManagerClear(tls, cost_manager)
@@ -23560,16 +23303,16 @@ __18:
// a pointer to this part of the array. Example:
// dist_array = [1x2xx3x2] => packed [1x2x1232], chosen_path = [1232]
func TraceBackwards(tls *libc.TLS, dist_array uintptr, dist_array_size int32, chosen_path uintptr, chosen_path_size uintptr) { /* backward_references_cost_enc.c:689:13: */
- var path uintptr = (dist_array + uintptr(dist_array_size)*2)
- var cur uintptr = ((dist_array + uintptr(dist_array_size)*2) - uintptr(1)*2)
+ var path uintptr = dist_array + uintptr(dist_array_size)*2
+ var cur uintptr = dist_array + uintptr(dist_array_size)*2 - uintptr(1)*2
for cur >= dist_array {
var k int32 = int32(*(*uint16_t)(unsafe.Pointer(cur)))
path -= 2
*(*uint16_t)(unsafe.Pointer(path)) = uint16_t(k)
- cur -= 2 * (uintptr(k))
+ cur -= 2 * uintptr(k)
}
*(*uintptr)(unsafe.Pointer(chosen_path)) = path
- *(*int32)(unsafe.Pointer(chosen_path_size)) = (int32(((int64(dist_array + uintptr(dist_array_size)*2)) - int64(path)) / 2))
+ *(*int32)(unsafe.Pointer(chosen_path_size)) = int32((int64(dist_array+uintptr(dist_array_size)*2) - int64(path)) / 2)
}
func BackwardReferencesHashChainFollowChosenPath(tls *libc.TLS, argb uintptr, cache_bits int32, chosen_path uintptr, chosen_path_size int32, hash_chain uintptr, refs uintptr) int32 { /* backward_references_cost_enc.c:705:12: */
@@ -23588,7 +23331,7 @@ func BackwardReferencesHashChainFollowChosenPath(tls *libc.TLS, argb uintptr, ca
var v PixOrCopy
var idx int32
var len int32
- use_color_cache = (libc.Bool32(cache_bits > 0))
+ use_color_cache = libc.Bool32(cache_bits > 0)
i = 0
ok = 0
cc_init = 0
@@ -23596,8 +23339,8 @@ func BackwardReferencesHashChainFollowChosenPath(tls *libc.TLS, argb uintptr, ca
if !(use_color_cache != 0) {
goto __1
}
- cc_init = VP8LColorCacheInit(tls, (bp) /* &hashers */, cache_bits)
- if !(!(cc_init != 0)) {
+ cc_init = VP8LColorCacheInit(tls, bp, cache_bits)
+ if !!(cc_init != 0) {
goto __2
}
goto Error
@@ -23626,7 +23369,7 @@ __9:
if !(k < len) {
goto __11
}
- VP8LColorCacheInsert(tls, (bp) /* &hashers */, *(*uint32_t)(unsafe.Pointer(argb + uintptr((i+k))*4)))
+ VP8LColorCacheInsert(tls, bp, *(*uint32_t)(unsafe.Pointer(argb + uintptr(i+k)*4)))
goto __10
__10:
k++
@@ -23636,11 +23379,11 @@ __11:
;
__8:
;
- i = i + (len)
+ i = i + len
goto __7
__6:
if use_color_cache != 0 {
- idx = VP8LColorCacheContains(tls, (bp) /* &hashers */, *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)))
+ idx = VP8LColorCacheContains(tls, bp, *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)))
} else {
idx = -1
}
@@ -23655,7 +23398,7 @@ __12:
if !(use_color_cache != 0) {
goto __14
}
- VP8LColorCacheInsert(tls, (bp) /* &hashers */, *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)))
+ VP8LColorCacheInsert(tls, bp, *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)))
__14:
;
v = PixOrCopyCreateLiteral(tls, *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)))
@@ -23677,7 +23420,7 @@ Error:
if !(cc_init != 0) {
goto __15
}
- VP8LColorCacheClear(tls, (bp) /* &hashers */)
+ VP8LColorCacheClear(tls, bp)
__15:
;
return ok
@@ -23695,30 +23438,30 @@ func VP8LBackwardReferencesTraceBackwards(tls *libc.TLS, xsize int32, ysize int3
var dist_array uintptr
ok = 0
- dist_array_size = (xsize * ysize)
- *(*uintptr)(unsafe.Pointer(bp /* chosen_path */)) = (uintptr(0))
+ dist_array_size = xsize * ysize
+ *(*uintptr)(unsafe.Pointer(bp /* chosen_path */)) = uintptr(0)
*(*int32)(unsafe.Pointer(bp + 8 /* chosen_path_size */)) = 0
dist_array =
WebPSafeMalloc(tls, uint64(dist_array_size), uint64(unsafe.Sizeof(uint16_t(0))))
- if !(dist_array == (uintptr(0))) {
+ if !(dist_array == uintptr(0)) {
goto __1
}
goto Error
__1:
;
- if !(!(BackwardReferencesHashChainDistanceOnly(tls,
- xsize, ysize, argb, cache_bits, hash_chain, refs_src, dist_array) != 0)) {
+ if !!(BackwardReferencesHashChainDistanceOnly(tls,
+ xsize, ysize, argb, cache_bits, hash_chain, refs_src, dist_array) != 0) {
goto __2
}
goto Error
__2:
;
- TraceBackwards(tls, dist_array, dist_array_size, (bp) /* &chosen_path */, (bp + 8) /* &chosen_path_size */)
- if !(!(BackwardReferencesHashChainFollowChosenPath(tls,
- argb, cache_bits, *(*uintptr)(unsafe.Pointer(bp /* chosen_path */)), *(*int32)(unsafe.Pointer(bp + 8 /* chosen_path_size */)), hash_chain,
- refs_dst) != 0)) {
+ TraceBackwards(tls, dist_array, dist_array_size, bp, bp+8)
+ if !!(BackwardReferencesHashChainFollowChosenPath(tls,
+ argb, cache_bits, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), hash_chain,
+ refs_dst) != 0) {
goto __3
}
goto Error
@@ -23772,14 +23515,14 @@ var plane_to_code_lut = [128]uint8_t{
} /* backward_references_enc.c:38:22 */
func VP8LDistanceToPlaneCode(tls *libc.TLS, xsize int32, dist int32) int32 { /* backward_references_enc.c:50:5: */
- var yoffset int32 = (dist / xsize)
- var xoffset int32 = (dist - (yoffset * xsize))
- if (xoffset <= 8) && (yoffset < 8) {
- return (int32(plane_to_code_lut[(((yoffset*16)+8)-xoffset)]) + 1)
- } else if (xoffset > (xsize - 8)) && (yoffset < 7) {
- return (int32(plane_to_code_lut[((((yoffset+1)*16)+8)+(xsize-xoffset))]) + 1)
+ var yoffset int32 = dist / xsize
+ var xoffset int32 = dist - yoffset*xsize
+ if xoffset <= 8 && yoffset < 8 {
+ return int32(plane_to_code_lut[yoffset*16+8-xoffset]) + 1
+ } else if xoffset > xsize-8 && yoffset < 7 {
+ return int32(plane_to_code_lut[(yoffset+1)*16+8+(xsize-xoffset)]) + 1
}
- return (dist + 120)
+ return dist + 120
}
// Returns the exact index where array1 and array2 are different. For an index
@@ -23801,19 +23544,19 @@ func FindMatchLength(tls *libc.TLS, array1 uintptr, array2 uintptr, best_len_mat
func VP8LClearBackwardRefs(tls *libc.TLS, refs uintptr) { /* backward_references_enc.c:86:6: */
- if (*VP8LBackwardRefs)(unsafe.Pointer(refs)).tail_ != (uintptr(0)) {
+ if (*VP8LBackwardRefs)(unsafe.Pointer(refs)).tail_ != uintptr(0) {
*(*uintptr)(unsafe.Pointer((*VP8LBackwardRefs)(unsafe.Pointer(refs)).tail_)) = (*VP8LBackwardRefs)(unsafe.Pointer(refs)).free_blocks_ // recycle all blocks at once
}
(*VP8LBackwardRefs)(unsafe.Pointer(refs)).free_blocks_ = (*VP8LBackwardRefs)(unsafe.Pointer(refs)).refs_
- (*VP8LBackwardRefs)(unsafe.Pointer(refs)).tail_ = (refs + 8 /* &.refs_ */)
- (*VP8LBackwardRefs)(unsafe.Pointer(refs)).last_block_ = (uintptr(0))
- (*VP8LBackwardRefs)(unsafe.Pointer(refs)).refs_ = (uintptr(0))
+ (*VP8LBackwardRefs)(unsafe.Pointer(refs)).tail_ = refs + 8
+ (*VP8LBackwardRefs)(unsafe.Pointer(refs)).last_block_ = uintptr(0)
+ (*VP8LBackwardRefs)(unsafe.Pointer(refs)).refs_ = uintptr(0)
}
func VP8LBackwardRefsClear(tls *libc.TLS, refs uintptr) { /* backward_references_enc.c:97:6: */
VP8LClearBackwardRefs(tls, refs)
- for (*VP8LBackwardRefs)(unsafe.Pointer(refs)).free_blocks_ != (uintptr(0)) {
+ for (*VP8LBackwardRefs)(unsafe.Pointer(refs)).free_blocks_ != uintptr(0) {
var next uintptr = (*PixOrCopyBlock)(unsafe.Pointer((*VP8LBackwardRefs)(unsafe.Pointer(refs)).free_blocks_)).next_
WebPSafeFree(tls, (*VP8LBackwardRefs)(unsafe.Pointer(refs)).free_blocks_)
(*VP8LBackwardRefs)(unsafe.Pointer(refs)).free_blocks_ = next
@@ -23822,23 +23565,23 @@ func VP8LBackwardRefsClear(tls *libc.TLS, refs uintptr) { /* backward_references
// Swaps the content of two VP8LBackwardRefs.
func BackwardRefsSwap(tls *libc.TLS, refs1 uintptr, refs2 uintptr) { /* backward_references_enc.c:108:13: */
- var point_to_refs1 int32 = (libc.Bool32(((*VP8LBackwardRefs)(unsafe.Pointer(refs1)).tail_ != (uintptr(0))) && ((*VP8LBackwardRefs)(unsafe.Pointer(refs1)).tail_ == (refs1 + 8 /* &.refs_ */))))
- var point_to_refs2 int32 = (libc.Bool32(((*VP8LBackwardRefs)(unsafe.Pointer(refs2)).tail_ != (uintptr(0))) && ((*VP8LBackwardRefs)(unsafe.Pointer(refs2)).tail_ == (refs2 + 8 /* &.refs_ */))))
+ var point_to_refs1 int32 = libc.Bool32((*VP8LBackwardRefs)(unsafe.Pointer(refs1)).tail_ != uintptr(0) && (*VP8LBackwardRefs)(unsafe.Pointer(refs1)).tail_ == refs1+8)
+ var point_to_refs2 int32 = libc.Bool32((*VP8LBackwardRefs)(unsafe.Pointer(refs2)).tail_ != uintptr(0) && (*VP8LBackwardRefs)(unsafe.Pointer(refs2)).tail_ == refs2+8)
var tmp = *(*VP8LBackwardRefs)(unsafe.Pointer(refs1))
*(*VP8LBackwardRefs)(unsafe.Pointer(refs1)) = *(*VP8LBackwardRefs)(unsafe.Pointer(refs2))
*(*VP8LBackwardRefs)(unsafe.Pointer(refs2)) = tmp
if point_to_refs2 != 0 {
- (*VP8LBackwardRefs)(unsafe.Pointer(refs1)).tail_ = (refs1 + 8 /* &.refs_ */)
+ (*VP8LBackwardRefs)(unsafe.Pointer(refs1)).tail_ = refs1 + 8
}
if point_to_refs1 != 0 {
- (*VP8LBackwardRefs)(unsafe.Pointer(refs2)).tail_ = (refs2 + 8 /* &.refs_ */)
+ (*VP8LBackwardRefs)(unsafe.Pointer(refs2)).tail_ = refs2 + 8
}
}
func VP8LBackwardRefsInit(tls *libc.TLS, refs uintptr, block_size int32) { /* backward_references_enc.c:121:6: */
libc.Xmemset(tls, refs, 0, uint64(unsafe.Sizeof(VP8LBackwardRefs{})))
- (*VP8LBackwardRefs)(unsafe.Pointer(refs)).tail_ = (refs + 8 /* &.refs_ */)
+ (*VP8LBackwardRefs)(unsafe.Pointer(refs)).tail_ = refs + 8
(*VP8LBackwardRefs)(unsafe.Pointer(refs)).block_size_ = func() int32 {
if block_size < 256 {
return 256
@@ -23850,12 +23593,12 @@ func VP8LBackwardRefsInit(tls *libc.TLS, refs uintptr, block_size int32) { /* ba
func VP8LRefsCursorInit(tls *libc.TLS, refs uintptr) VP8LRefsCursor { /* backward_references_enc.c:129:16: */
var c VP8LRefsCursor
c.cur_block_ = (*VP8LBackwardRefs)(unsafe.Pointer(refs)).refs_
- if (*VP8LBackwardRefs)(unsafe.Pointer(refs)).refs_ != (uintptr(0)) {
+ if (*VP8LBackwardRefs)(unsafe.Pointer(refs)).refs_ != uintptr(0) {
c.cur_pos = (*PixOrCopyBlock)(unsafe.Pointer(c.cur_block_)).start_
- c.last_pos_ = (c.cur_pos + uintptr((*PixOrCopyBlock)(unsafe.Pointer(c.cur_block_)).size_)*8)
+ c.last_pos_ = c.cur_pos + uintptr((*PixOrCopyBlock)(unsafe.Pointer(c.cur_block_)).size_)*8
} else {
- c.cur_pos = (uintptr(0))
- c.last_pos_ = (uintptr(0))
+ c.cur_pos = uintptr(0)
+ c.last_pos_ = uintptr(0)
}
return c
}
@@ -23863,16 +23606,16 @@ func VP8LRefsCursorInit(tls *libc.TLS, refs uintptr) VP8LRefsCursor { /* backwar
func VP8LRefsCursorNextBlock(tls *libc.TLS, c uintptr) { /* backward_references_enc.c:142:6: */
var b uintptr = (*PixOrCopyBlock)(unsafe.Pointer((*VP8LRefsCursor)(unsafe.Pointer(c)).cur_block_)).next_
(*VP8LRefsCursor)(unsafe.Pointer(c)).cur_pos = func() uintptr {
- if b == (uintptr(0)) {
- return (uintptr(0))
+ if b == uintptr(0) {
+ return uintptr(0)
}
return (*PixOrCopyBlock)(unsafe.Pointer(b)).start_
}()
(*VP8LRefsCursor)(unsafe.Pointer(c)).last_pos_ = func() uintptr {
- if b == (uintptr(0)) {
- return (uintptr(0))
+ if b == uintptr(0) {
+ return uintptr(0)
}
- return ((*PixOrCopyBlock)(unsafe.Pointer(b)).start_ + uintptr((*PixOrCopyBlock)(unsafe.Pointer(b)).size_)*8)
+ return (*PixOrCopyBlock)(unsafe.Pointer(b)).start_ + uintptr((*PixOrCopyBlock)(unsafe.Pointer(b)).size_)*8
}()
(*VP8LRefsCursor)(unsafe.Pointer(c)).cur_block_ = b
}
@@ -23880,21 +23623,21 @@ func VP8LRefsCursorNextBlock(tls *libc.TLS, c uintptr) { /* backward_references_
// Create a new block, either from the free list or allocated
func BackwardRefsNewBlock(tls *libc.TLS, refs uintptr) uintptr { /* backward_references_enc.c:150:22: */
var b uintptr = (*VP8LBackwardRefs)(unsafe.Pointer(refs)).free_blocks_
- if b == (uintptr(0)) { // allocate new memory chunk
- var total_size size_t = (uint64(unsafe.Sizeof(PixOrCopyBlock{})) + (uint64((*VP8LBackwardRefs)(unsafe.Pointer(refs)).block_size_) * uint64(unsafe.Sizeof(PixOrCopy{}))))
+ if b == uintptr(0) { // allocate new memory chunk
+ var total_size size_t = uint64(unsafe.Sizeof(PixOrCopyBlock{})) + uint64((*VP8LBackwardRefs)(unsafe.Pointer(refs)).block_size_)*uint64(unsafe.Sizeof(PixOrCopy{}))
b = WebPSafeMalloc(tls, 1, total_size)
- if b == (uintptr(0)) {
- *(*int32)(unsafe.Pointer((refs + 4 /* &.error_ */))) |= (1)
- return (uintptr(0))
+ if b == uintptr(0) {
+ *(*int32)(unsafe.Pointer(refs + 4)) |= 1
+ return uintptr(0)
}
- (*PixOrCopyBlock)(unsafe.Pointer(b)).start_ = (b + uintptr(uint64(unsafe.Sizeof(PixOrCopyBlock{})))) // not always aligned
+ (*PixOrCopyBlock)(unsafe.Pointer(b)).start_ = b + uintptr(uint64(unsafe.Sizeof(PixOrCopyBlock{}))) // not always aligned
} else { // recycle from free-list
(*VP8LBackwardRefs)(unsafe.Pointer(refs)).free_blocks_ = (*PixOrCopyBlock)(unsafe.Pointer(b)).next_
}
*(*uintptr)(unsafe.Pointer((*VP8LBackwardRefs)(unsafe.Pointer(refs)).tail_)) = b
- (*VP8LBackwardRefs)(unsafe.Pointer(refs)).tail_ = (b /* &.next_ */)
+ (*VP8LBackwardRefs)(unsafe.Pointer(refs)).tail_ = b
(*VP8LBackwardRefs)(unsafe.Pointer(refs)).last_block_ = b
- (*PixOrCopyBlock)(unsafe.Pointer(b)).next_ = (uintptr(0))
+ (*PixOrCopyBlock)(unsafe.Pointer(b)).next_ = uintptr(0)
(*PixOrCopyBlock)(unsafe.Pointer(b)).size_ = 0
return b
}
@@ -23903,13 +23646,13 @@ func BackwardRefsNewBlock(tls *libc.TLS, refs uintptr) uintptr { /* backward_ref
func BackwardRefsClone(tls *libc.TLS, from uintptr, to uintptr) int32 { /* backward_references_enc.c:173:12: */
var block_from uintptr = (*VP8LBackwardRefs)(unsafe.Pointer(from)).refs_
VP8LClearBackwardRefs(tls, to)
- for block_from != (uintptr(0)) {
+ for block_from != uintptr(0) {
var block_to uintptr = BackwardRefsNewBlock(tls, to)
- if block_to == (uintptr(0)) {
+ if block_to == uintptr(0) {
return 0
}
libc.Xmemcpy(tls, (*PixOrCopyBlock)(unsafe.Pointer(block_to)).start_, (*PixOrCopyBlock)(unsafe.Pointer(block_from)).start_,
- (uint64((*PixOrCopyBlock)(unsafe.Pointer(block_from)).size_) * uint64(unsafe.Sizeof(PixOrCopy{}))))
+ uint64((*PixOrCopyBlock)(unsafe.Pointer(block_from)).size_)*uint64(unsafe.Sizeof(PixOrCopy{})))
(*PixOrCopyBlock)(unsafe.Pointer(block_to)).size_ = (*PixOrCopyBlock)(unsafe.Pointer(block_from)).size_
block_from = (*PixOrCopyBlock)(unsafe.Pointer(block_from)).next_
}
@@ -23918,9 +23661,9 @@ func BackwardRefsClone(tls *libc.TLS, from uintptr, to uintptr) int32 { /* backw
func VP8LBackwardRefsCursorAdd(tls *libc.TLS, refs uintptr, v PixOrCopy) { /* backward_references_enc.c:190:6: */
var b uintptr = (*VP8LBackwardRefs)(unsafe.Pointer(refs)).last_block_
- if (b == (uintptr(0))) || ((*PixOrCopyBlock)(unsafe.Pointer(b)).size_ == (*VP8LBackwardRefs)(unsafe.Pointer(refs)).block_size_) {
+ if b == uintptr(0) || (*PixOrCopyBlock)(unsafe.Pointer(b)).size_ == (*VP8LBackwardRefs)(unsafe.Pointer(refs)).block_size_ {
b = BackwardRefsNewBlock(tls, refs)
- if b == (uintptr(0)) {
+ if b == uintptr(0) {
return
} // refs->error_ is set
}
@@ -23933,7 +23676,7 @@ func VP8LBackwardRefsCursorAdd(tls *libc.TLS, refs uintptr, v PixOrCopy) { /* ba
func VP8LHashChainInit(tls *libc.TLS, p uintptr, size int32) int32 { /* backward_references_enc.c:203:5: */
(*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ = WebPSafeMalloc(tls, uint64(size), uint64(unsafe.Sizeof(uint32_t(0))))
- if (*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ == (uintptr(0)) {
+ if (*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ == uintptr(0) {
return 0
}
(*VP8LHashChain)(unsafe.Pointer(p)).size_ = size
@@ -23946,7 +23689,7 @@ func VP8LHashChainClear(tls *libc.TLS, p uintptr) { /* backward_references_enc.c
WebPSafeFree(tls, (*VP8LHashChain)(unsafe.Pointer(p)).offset_length_)
(*VP8LHashChain)(unsafe.Pointer(p)).size_ = 0
- (*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ = (uintptr(0))
+ (*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ = uintptr(0)
}
// -----------------------------------------------------------------------------
@@ -23956,52 +23699,52 @@ var kHashMultiplierLo uint32_t = 0x5bd1e996 /* backward_references_enc.c:226:23
func GetPixPairHash64(tls *libc.TLS, argb uintptr) uint32_t { /* backward_references_enc.c:229:10: */
var key uint32_t
- key = (*(*uint32_t)(unsafe.Pointer(argb + 1*4)) * kHashMultiplierHi)
- key = key + (*(*uint32_t)(unsafe.Pointer(argb)) * kHashMultiplierLo)
- key = (key >> (32 - 18))
+ key = *(*uint32_t)(unsafe.Pointer(argb + 1*4)) * kHashMultiplierHi
+ key = key + *(*uint32_t)(unsafe.Pointer(argb))*kHashMultiplierLo
+ key = key >> (32 - 18)
return key
}
// Returns the maximum number of hash chain lookups to do for a
// given compression quality. Return value in range [8, 86].
func GetMaxItersForQuality(tls *libc.TLS, quality int32) int32 { /* backward_references_enc.c:239:12: */
- return (8 + ((quality * quality) / 128))
+ return 8 + quality*quality/128
}
func GetWindowSizeForHashChain(tls *libc.TLS, quality int32, xsize int32) int32 { /* backward_references_enc.c:243:12: */
var max_window_size int32
if quality > 75 {
- max_window_size = ((int32(1) << 20) - 120)
+ max_window_size = int32(1)<<20 - 120
} else {
if quality > 50 {
- max_window_size = (xsize << 8)
+ max_window_size = xsize << 8
} else {
if quality > 25 {
- max_window_size = (xsize << 6)
+ max_window_size = xsize << 6
} else {
- max_window_size = (xsize << 4)
+ max_window_size = xsize << 4
}
}
}
- if max_window_size > ((int32(1) << 20) - 120) {
- return ((int32(1) << 20) - 120)
+ if max_window_size > int32(1)<<20-120 {
+ return int32(1)<<20 - 120
}
return max_window_size
}
func MaxFindCopyLength(tls *libc.TLS, len int32) int32 { /* backward_references_enc.c:252:24: */
- if len < ((int32(1) << 12) - 1) {
+ if len < int32(1)<<12-1 {
return len
}
- return ((int32(1) << 12) - 1)
+ return int32(1)<<12 - 1
}
func VP8LHashChainFill(tls *libc.TLS, p uintptr, quality int32, argb uintptr, xsize int32, ysize int32, low_effort int32) int32 { /* backward_references_enc.c:256:5: */
bp := tls.Alloc(8)
defer tls.Free(8)
- var size int32 = (xsize * ysize)
+ var size int32 = xsize * ysize
var iter_max int32 = GetMaxItersForQuality(tls, quality)
var window_size uint32_t = uint32_t(GetWindowSizeForHashChain(tls, quality, xsize))
var pos int32
@@ -24012,64 +23755,64 @@ func VP8LHashChainFill(tls *libc.TLS, p uintptr, quality int32, argb uintptr, xs
var chain uintptr = (*VP8LHashChain)(unsafe.Pointer(p)).offset_length_
if size <= 2 {
- *(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_)) = libc.AssignPtrUint32(((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ + uintptr((size-1))*4), uint32_t(0))
+ *(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_)) = libc.AssignPtrUint32((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_+uintptr(size-1)*4, uint32_t(0))
return 1
}
- hash_to_first_index = WebPSafeMalloc(tls, (uint64(int32(1) << 18)), uint64(unsafe.Sizeof(int32_t(0))))
- if hash_to_first_index == (uintptr(0)) {
+ hash_to_first_index = WebPSafeMalloc(tls, uint64(int32(1)<<18), uint64(unsafe.Sizeof(int32_t(0))))
+ if hash_to_first_index == uintptr(0) {
return 0
}
// Set the int32_t array to -1.
- libc.Xmemset(tls, hash_to_first_index, 0xff, ((uint64(int32(1) << 18)) * uint64(unsafe.Sizeof(int32_t(0)))))
+ libc.Xmemset(tls, hash_to_first_index, 0xff, uint64(int32(1)<<18)*uint64(unsafe.Sizeof(int32_t(0))))
// Fill the chain linking pixels with the same hash.
- argb_comp = (libc.Bool32(*(*uint32_t)(unsafe.Pointer(argb)) == *(*uint32_t)(unsafe.Pointer(argb + 1*4))))
- for pos = 0; pos < (size - 2); {
+ argb_comp = libc.Bool32(*(*uint32_t)(unsafe.Pointer(argb)) == *(*uint32_t)(unsafe.Pointer(argb + 1*4)))
+ for pos = 0; pos < size-2; {
var hash_code uint32_t
- var argb_comp_next int32 = (libc.Bool32(*(*uint32_t)(unsafe.Pointer(argb + uintptr((pos+1))*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr((pos+2))*4))))
- if (argb_comp != 0) && (argb_comp_next != 0) {
+ var argb_comp_next int32 = libc.Bool32(*(*uint32_t)(unsafe.Pointer(argb + uintptr(pos+1)*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr(pos+2)*4)))
+ if argb_comp != 0 && argb_comp_next != 0 {
// Consecutive pixels with the same color will share the same hash.
// We therefore use a different hash: the color and its repetition
// length.
// var tmp [2]uint32_t at bp, 8
var len uint32_t = uint32_t(1)
- *(*uint32_t)(unsafe.Pointer((bp) /* &tmp[0] */)) = *(*uint32_t)(unsafe.Pointer(argb + uintptr(pos)*4))
+ *(*uint32_t)(unsafe.Pointer(bp)) = *(*uint32_t)(unsafe.Pointer(argb + uintptr(pos)*4))
// Figure out how far the pixels are the same.
// The last pixel has a different 64 bit hash, as its next pixel does
// not have the same color, so we just need to get to the last pixel equal
// to its follower.
- for (((pos + int32(len)) + 2) < size) && (*(*uint32_t)(unsafe.Pointer(argb + uintptr(((uint32_t(pos)+len)+uint32_t(2)))*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr(pos)*4))) {
+ for pos+int32(len)+2 < size && *(*uint32_t)(unsafe.Pointer(argb + uintptr(uint32_t(pos)+len+uint32_t(2))*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr(pos)*4)) {
len++
}
- if len > (uint32_t((int32(1) << 12) - 1)) {
+ if len > uint32_t(int32(1)<<12-1) {
// Skip the pixels that match for distance=1 and length>MAX_LENGTH
// because they are linked to their predecessor and we automatically
// check that in the main for loop below. Skipping means setting no
// predecessor in the chain, hence -1.
- libc.Xmemset(tls, (chain + uintptr(pos)*4), 0xff, ((uint64(len - (uint32_t((int32(1) << 12) - 1)))) * uint64(unsafe.Sizeof(int32_t(0)))))
- pos = int32(uint32_t(pos) + (len - (uint32_t((int32(1) << 12) - 1))))
- len = (uint32_t((int32(1) << 12) - 1))
+ libc.Xmemset(tls, chain+uintptr(pos)*4, 0xff, uint64(len-uint32_t(int32(1)<<12-1))*uint64(unsafe.Sizeof(int32_t(0))))
+ pos = int32(uint32_t(pos) + (len - uint32_t(int32(1)<<12-1)))
+ len = uint32_t(int32(1)<<12 - 1)
}
// Process the rest of the hash chain.
for len != 0 {
- *(*uint32_t)(unsafe.Pointer((bp) /* &tmp[0] */ + 1*4)) = libc.PostDecUint32(&len, 1)
- hash_code = GetPixPairHash64(tls, (bp) /* &tmp[0] */)
+ *(*uint32_t)(unsafe.Pointer(bp + 1*4)) = libc.PostDecUint32(&len, 1)
+ hash_code = GetPixPairHash64(tls, bp)
*(*int32_t)(unsafe.Pointer(chain + uintptr(pos)*4)) = *(*int32_t)(unsafe.Pointer(hash_to_first_index + uintptr(hash_code)*4))
*(*int32_t)(unsafe.Pointer(hash_to_first_index + uintptr(hash_code)*4)) = libc.PostIncInt32(&pos, 1)
}
argb_comp = 0
} else {
// Just move one pixel forward.
- hash_code = GetPixPairHash64(tls, (argb + uintptr(pos)*4))
+ hash_code = GetPixPairHash64(tls, argb+uintptr(pos)*4)
*(*int32_t)(unsafe.Pointer(chain + uintptr(pos)*4)) = *(*int32_t)(unsafe.Pointer(hash_to_first_index + uintptr(hash_code)*4))
*(*int32_t)(unsafe.Pointer(hash_to_first_index + uintptr(hash_code)*4)) = libc.PostIncInt32(&pos, 1)
argb_comp = argb_comp_next
}
}
// Process the penultimate pixel.
- *(*int32_t)(unsafe.Pointer(chain + uintptr(pos)*4)) = *(*int32_t)(unsafe.Pointer(hash_to_first_index + uintptr(GetPixPairHash64(tls, (argb+uintptr(pos)*4)))*4))
+ *(*int32_t)(unsafe.Pointer(chain + uintptr(pos)*4)) = *(*int32_t)(unsafe.Pointer(hash_to_first_index + uintptr(GetPixPairHash64(tls, argb+uintptr(pos)*4))*4))
WebPSafeFree(tls, hash_to_first_index)
@@ -24078,17 +23821,17 @@ func VP8LHashChainFill(tls *libc.TLS, p uintptr, quality int32, argb uintptr, xs
// (hence a best length of 0) and the left-most pixel nothing to the left
// (hence an offset of 0).
- *(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_)) = libc.AssignPtrUint32(((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ + uintptr((size-1))*4), uint32_t(0))
- for base_position = (uint32_t(size - 2)); base_position > uint32_t(0); {
- var max_len int32 = MaxFindCopyLength(tls, (int32((uint32_t(size - 1)) - base_position)))
- var argb_start uintptr = (argb + uintptr(base_position)*4)
+ *(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_)) = libc.AssignPtrUint32((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_+uintptr(size-1)*4, uint32_t(0))
+ for base_position = uint32_t(size - 2); base_position > uint32_t(0); {
+ var max_len int32 = MaxFindCopyLength(tls, int32(uint32_t(size-1)-base_position))
+ var argb_start uintptr = argb + uintptr(base_position)*4
var iter int32 = iter_max
var best_length int32 = 0
var best_distance uint32_t = uint32_t(0)
var best_argb uint32_t
var min_pos int32
if base_position > window_size {
- min_pos = (int32(base_position - window_size))
+ min_pos = int32(base_position - window_size)
} else {
min_pos = 0
}
@@ -24105,7 +23848,7 @@ func VP8LHashChainFill(tls *libc.TLS, p uintptr, quality int32, argb uintptr, xs
var curr_length int32
// Heuristic: use the comparison with the above line as an initialization.
if base_position >= uint32_t(xsize) {
- curr_length = FindMatchLength(tls, (argb_start - uintptr(xsize)*4), argb_start,
+ curr_length = FindMatchLength(tls, argb_start-uintptr(xsize)*4, argb_start,
best_length, max_len)
if curr_length > best_length {
best_length = curr_length
@@ -24114,32 +23857,32 @@ func VP8LHashChainFill(tls *libc.TLS, p uintptr, quality int32, argb uintptr, xs
iter--
}
// Heuristic: compare to the previous pixel.
- curr_length = FindMatchLength(tls, (argb_start - uintptr(1)*4), argb_start, best_length, max_len)
+ curr_length = FindMatchLength(tls, argb_start-uintptr(1)*4, argb_start, best_length, max_len)
if curr_length > best_length {
best_length = curr_length
best_distance = uint32_t(1)
}
iter--
// Skip the for loop if we already have the maximum.
- if best_length == ((int32(1) << 12) - 1) {
- pos = (min_pos - 1)
+ if best_length == int32(1)<<12-1 {
+ pos = min_pos - 1
}
}
best_argb = *(*uint32_t)(unsafe.Pointer(argb_start + uintptr(best_length)*4))
- for ; (pos >= min_pos) && (libc.PreDecInt32(&iter, 1) != 0); pos = *(*int32_t)(unsafe.Pointer(chain + uintptr(pos)*4)) {
+ for ; pos >= min_pos && libc.PreDecInt32(&iter, 1) != 0; pos = *(*int32_t)(unsafe.Pointer(chain + uintptr(pos)*4)) {
var curr_length int32
- if *(*uint32_t)(unsafe.Pointer(argb + uintptr((pos+best_length))*4)) != best_argb {
+ if *(*uint32_t)(unsafe.Pointer(argb + uintptr(pos+best_length)*4)) != best_argb {
continue
}
curr_length = (*struct {
f func(*libc.TLS, uintptr, uintptr, int32) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8LVectorMismatch})).f(tls, (argb + uintptr(pos)*4), argb_start, max_len)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LVectorMismatch})).f(tls, argb+uintptr(pos)*4, argb_start, max_len)
if best_length < curr_length {
best_length = curr_length
- best_distance = (base_position - uint32_t(pos))
+ best_distance = base_position - uint32_t(pos)
best_argb = *(*uint32_t)(unsafe.Pointer(argb_start + uintptr(best_length)*4))
// Stop if we have reached a good enough length.
if best_length >= length_max {
@@ -24152,24 +23895,24 @@ func VP8LHashChainFill(tls *libc.TLS, p uintptr, quality int32, argb uintptr, xs
max_base_position = base_position
for 1 != 0 {
- *(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ + uintptr(base_position)*4)) = ((best_distance << 12) | uint32_t(best_length))
+ *(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(p)).offset_length_ + uintptr(base_position)*4)) = best_distance<<12 | uint32_t(best_length)
base_position--
// Stop if we don't have a match or if we are out of bounds.
- if (best_distance == uint32_t(0)) || (base_position == uint32_t(0)) {
+ if best_distance == uint32_t(0) || base_position == uint32_t(0) {
break
}
// Stop if we cannot extend the matching intervals to the left.
- if (base_position < best_distance) || (*(*uint32_t)(unsafe.Pointer(argb + uintptr((base_position-best_distance))*4)) != *(*uint32_t)(unsafe.Pointer(argb + uintptr(base_position)*4))) {
+ if base_position < best_distance || *(*uint32_t)(unsafe.Pointer(argb + uintptr(base_position-best_distance)*4)) != *(*uint32_t)(unsafe.Pointer(argb + uintptr(base_position)*4)) {
break
}
// Stop if we are matching at its limit because there could be a closer
// matching interval with the same maximum length. Then again, if the
// matching interval is as close as possible (best_distance == 1), we will
// never find anything better so let's continue.
- if ((best_length == ((int32(1) << 12) - 1)) && (best_distance != uint32_t(1))) && ((base_position + (uint32_t((int32(1) << 12) - 1))) < max_base_position) {
+ if best_length == int32(1)<<12-1 && best_distance != uint32_t(1) && base_position+uint32_t(int32(1)<<12-1) < max_base_position {
break
}
- if best_length < ((int32(1) << 12) - 1) {
+ if best_length < int32(1)<<12-1 {
best_length++
max_base_position = base_position
}
@@ -24198,49 +23941,49 @@ func BackwardReferencesRle(tls *libc.TLS, xsize int32, ysize int32, argb uintptr
bp := tls.Alloc(16)
defer tls.Free(16)
- var pix_count int32 = (xsize * ysize)
+ var pix_count int32 = xsize * ysize
var i int32
var k int32
- var use_color_cache int32 = (libc.Bool32(cache_bits > 0))
+ var use_color_cache int32 = libc.Bool32(cache_bits > 0)
// var hashers VP8LColorCache at bp, 16
- if (use_color_cache != 0) && !(VP8LColorCacheInit(tls, (bp) /* &hashers */, cache_bits) != 0) {
+ if use_color_cache != 0 && !(VP8LColorCacheInit(tls, bp, cache_bits) != 0) {
return 0
}
VP8LClearBackwardRefs(tls, refs)
// Add first pixel as literal.
- AddSingleLiteral(tls, *(*uint32_t)(unsafe.Pointer(argb)), use_color_cache, (bp) /* &hashers */, refs)
+ AddSingleLiteral(tls, *(*uint32_t)(unsafe.Pointer(argb)), use_color_cache, bp, refs)
i = 1
for i < pix_count {
- var max_len int32 = MaxFindCopyLength(tls, (pix_count - i))
- var rle_len int32 = FindMatchLength(tls, (argb + uintptr(i)*4), ((argb + uintptr(i)*4) - uintptr(1)*4), 0, max_len)
+ var max_len int32 = MaxFindCopyLength(tls, pix_count-i)
+ var rle_len int32 = FindMatchLength(tls, argb+uintptr(i)*4, argb+uintptr(i)*4-uintptr(1)*4, 0, max_len)
var prev_row_len int32
if i < xsize {
prev_row_len = 0
} else {
- prev_row_len = FindMatchLength(tls, (argb + uintptr(i)*4), ((argb + uintptr(i)*4) - uintptr(xsize)*4), 0, max_len)
+ prev_row_len = FindMatchLength(tls, argb+uintptr(i)*4, argb+uintptr(i)*4-uintptr(xsize)*4, 0, max_len)
}
- if (rle_len >= prev_row_len) && (rle_len >= 4) {
+ if rle_len >= prev_row_len && rle_len >= 4 {
VP8LBackwardRefsCursorAdd(tls, refs, PixOrCopyCreateCopy(tls, uint32(1), uint16(rle_len)))
// We don't need to update the color cache here since it is always the
// same pixel being copied, and that does not change the color cache
// state.
- i = i + (rle_len)
+ i = i + rle_len
} else if prev_row_len >= 4 {
VP8LBackwardRefsCursorAdd(tls, refs, PixOrCopyCreateCopy(tls, uint32(xsize), uint16(prev_row_len)))
if use_color_cache != 0 {
for k = 0; k < prev_row_len; k++ {
- VP8LColorCacheInsert(tls, (bp) /* &hashers */, *(*uint32_t)(unsafe.Pointer(argb + uintptr((i+k))*4)))
+ VP8LColorCacheInsert(tls, bp, *(*uint32_t)(unsafe.Pointer(argb + uintptr(i+k)*4)))
}
}
- i = i + (prev_row_len)
+ i = i + prev_row_len
} else {
- AddSingleLiteral(tls, *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)), use_color_cache, (bp) /* &hashers */, refs)
+ AddSingleLiteral(tls, *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)), use_color_cache, bp, refs)
i++
}
}
if use_color_cache != 0 {
- VP8LColorCacheClear(tls, (bp) /* &hashers */)
+ VP8LColorCacheClear(tls, bp)
}
return libc.BoolInt32(!((*VP8LBackwardRefs)(unsafe.Pointer(refs)).error_ != 0))
}
@@ -24271,14 +24014,14 @@ func BackwardReferencesLz77(tls *libc.TLS, xsize int32, ysize int32, argb uintpt
i_last_check = -1
ok = 0
cc_init = 0
- use_color_cache = (libc.Bool32(cache_bits > 0))
- pix_count = (xsize * ysize)
+ use_color_cache = libc.Bool32(cache_bits > 0)
+ pix_count = xsize * ysize
if !(use_color_cache != 0) {
goto __1
}
- cc_init = VP8LColorCacheInit(tls, (bp) /* &hashers */, cache_bits)
- if !(!(cc_init != 0)) {
+ cc_init = VP8LColorCacheInit(tls, bp, cache_bits)
+ if !!(cc_init != 0) {
goto __2
}
goto Error
@@ -24295,16 +24038,16 @@ __3:
// Alternative#1: Code the pixels starting at 'i' using backward reference.
*(*int32)(unsafe.Pointer(bp + 16 /* offset */)) = 0
*(*int32)(unsafe.Pointer(bp + 20 /* len */)) = 0
- VP8LHashChainFindCopy(tls, hash_chain, i, (bp + 16) /* &offset */, (bp + 20) /* &len */)
- if !(*(*int32)(unsafe.Pointer(bp + 20 /* len */)) >= 4) {
+ VP8LHashChainFindCopy(tls, hash_chain, i, bp+16, bp+20)
+ if !(*(*int32)(unsafe.Pointer(bp + 20)) >= 4) {
goto __6
}
len_ini = *(*int32)(unsafe.Pointer(bp + 20 /* len */))
max_reach = 0
- if (i + len_ini) >= pix_count {
- j_max = (pix_count - 1)
+ if i+len_ini >= pix_count {
+ j_max = pix_count - 1
} else {
- j_max = (i + len_ini)
+ j_max = i + len_ini
}
// Only start from what we have not checked already.
if i > i_last_check {
@@ -24318,23 +24061,23 @@ __3:
// [i,i+len) + [i+len, length of best match at i+len)
// while we check if we can use:
// [i,j) (where j<=i+len) + [j, length of best match at j)
- j = (i_last_check + 1)
+ j = i_last_check + 1
__8:
if !(j <= j_max) {
goto __10
}
len_j = VP8LHashChainFindLength(tls, hash_chain, j)
reach =
- (j + (func() int32 {
+ j + func() int32 {
if len_j >= 4 {
return len_j
}
return 1
- }())) // 1 for single literal.
+ }() // 1 for single literal.
if !(reach > max_reach) {
goto __11
}
- *(*int32)(unsafe.Pointer(bp + 20 /* len */)) = (j - i)
+ *(*int32)(unsafe.Pointer(bp + 20 /* len */)) = j - i
max_reach = reach
if !(max_reach >= pix_count) {
goto __12
@@ -24358,10 +24101,10 @@ __7:
;
// Go with literal or backward reference.
- if !(*(*int32)(unsafe.Pointer(bp + 20 /* len */)) == 1) {
+ if !(*(*int32)(unsafe.Pointer(bp + 20)) == 1) {
goto __13
}
- AddSingleLiteral(tls, *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)), use_color_cache, (bp) /* &hashers */, refs)
+ AddSingleLiteral(tls, *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)), use_color_cache, bp, refs)
goto __14
__13:
VP8LBackwardRefsCursorAdd(tls, refs, PixOrCopyCreateCopy(tls, uint32(*(*int32)(unsafe.Pointer(bp + 16 /* offset */))), uint16(*(*int32)(unsafe.Pointer(bp + 20 /* len */)))))
@@ -24370,10 +24113,10 @@ __13:
}
j = i
__16:
- if !(j < (i + *(*int32)(unsafe.Pointer(bp + 20 /* len */)))) {
+ if !(j < i+*(*int32)(unsafe.Pointer(bp + 20))) {
goto __18
}
- VP8LColorCacheInsert(tls, (bp) /* &hashers */, *(*uint32_t)(unsafe.Pointer(argb + uintptr(j)*4)))
+ VP8LColorCacheInsert(tls, bp, *(*uint32_t)(unsafe.Pointer(argb + uintptr(j)*4)))
goto __17
__17:
j++
@@ -24385,7 +24128,7 @@ __15:
;
__14:
;
- i = i + (*(*int32)(unsafe.Pointer(bp + 20 /* len */)))
+ i = i + *(*int32)(unsafe.Pointer(bp + 20))
goto __4
__4:
;
@@ -24399,7 +24142,7 @@ Error:
if !(cc_init != 0) {
goto __19
}
- VP8LColorCacheClear(tls, (bp) /* &hashers */)
+ VP8LColorCacheClear(tls, bp)
__19:
;
return ok
@@ -24413,31 +24156,31 @@ func BackwardReferencesLz77Box(tls *libc.TLS, xsize int32, ysize int32, argb uin
defer tls.Free(256)
var i int32
- var pix_count int32 = (xsize * ysize)
+ var pix_count int32 = xsize * ysize
var counts uintptr
*(*[32]int32)(unsafe.Pointer(bp /* window_offsets */)) = [32]int32{0: 0}
*(*[32]int32)(unsafe.Pointer(bp + 128 /* window_offsets_new */)) = [32]int32{0: 0}
var window_offsets_size int32 = 0
var window_offsets_new_size int32 = 0
- var counts_ini uintptr = WebPSafeMalloc(tls, (uint64(xsize * ysize)), uint64(unsafe.Sizeof(uint16_t(0))))
+ var counts_ini uintptr = WebPSafeMalloc(tls, uint64(xsize*ysize), uint64(unsafe.Sizeof(uint16_t(0))))
var best_offset_prev int32 = -1
var best_length_prev int32 = -1
- if counts_ini == (uintptr(0)) {
+ if counts_ini == uintptr(0) {
return 0
}
// counts[i] counts how many times a pixel is repeated starting at position i.
- i = (pix_count - 2)
- counts = (counts_ini + uintptr(i)*2)
+ i = pix_count - 2
+ counts = counts_ini + uintptr(i)*2
*(*uint16_t)(unsafe.Pointer(counts + 1*2)) = uint16_t(1)
__1:
if !(i >= 0) {
goto __3
}
{
- if *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr((i+1))*4)) {
+ if *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr(i+1)*4)) {
// Max out the counts to MAX_LENGTH.
- *(*uint16_t)(unsafe.Pointer(counts)) = (uint16_t(int32(*(*uint16_t)(unsafe.Pointer(counts + 1*2))) + (libc.Bool32(int32(*(*uint16_t)(unsafe.Pointer(counts + 1*2))) != ((int32(1) << 12) - 1)))))
+ *(*uint16_t)(unsafe.Pointer(counts)) = uint16_t(int32(*(*uint16_t)(unsafe.Pointer(counts + 1*2))) + libc.Bool32(int32(*(*uint16_t)(unsafe.Pointer(counts + 1*2))) != int32(1)<<12-1))
} else {
*(*uint16_t)(unsafe.Pointer(counts)) = uint16_t(1)
}
@@ -24459,36 +24202,36 @@ __3:
var y int32
for y = 0; y <= 6; y++ {
for x = -6; x <= 6; x++ {
- var offset int32 = ((y * xsize) + x)
+ var offset int32 = y*xsize + x
var plane_code int32
// Ignore offsets that bring us after the pixel.
if offset <= 0 {
continue
}
- plane_code = (VP8LDistanceToPlaneCode(tls, xsize, offset) - 1)
+ plane_code = VP8LDistanceToPlaneCode(tls, xsize, offset) - 1
if plane_code >= 32 {
continue
}
- *(*int32)(unsafe.Pointer((bp) /* &window_offsets[0] */ + uintptr(plane_code)*4)) = offset
+ *(*int32)(unsafe.Pointer(bp + uintptr(plane_code)*4)) = offset
}
}
// For narrow images, not all plane codes are reached, so remove those.
for i = 0; i < 32; i++ {
- if *(*int32)(unsafe.Pointer((bp) /* &window_offsets[0] */ + uintptr(i)*4)) == 0 {
+ if *(*int32)(unsafe.Pointer(bp + uintptr(i)*4)) == 0 {
continue
}
- *(*int32)(unsafe.Pointer((bp) /* &window_offsets[0] */ + uintptr(libc.PostIncInt32(&window_offsets_size, 1))*4)) = *(*int32)(unsafe.Pointer((bp) /* &window_offsets[0] */ + uintptr(i)*4))
+ *(*int32)(unsafe.Pointer(bp + uintptr(libc.PostIncInt32(&window_offsets_size, 1))*4)) = *(*int32)(unsafe.Pointer(bp + uintptr(i)*4))
}
// Given a pixel P, find the offsets that reach pixels unreachable from P-1
// with any of the offsets in window_offsets[].
for i = 0; i < window_offsets_size; i++ {
var j int32
var is_reachable int32 = 0
- for j = 0; (j < window_offsets_size) && !(is_reachable != 0); j++ {
- is_reachable = is_reachable | (libc.Bool32(*(*int32)(unsafe.Pointer((bp) /* &window_offsets[0] */ + uintptr(i)*4)) == (*(*int32)(unsafe.Pointer((bp) /* &window_offsets[0] */ + uintptr(j)*4)) + 1)))
+ for j = 0; j < window_offsets_size && !(is_reachable != 0); j++ {
+ is_reachable = is_reachable | libc.Bool32(*(*int32)(unsafe.Pointer(bp + uintptr(i)*4)) == *(*int32)(unsafe.Pointer(bp + uintptr(j)*4))+1)
}
if !(is_reachable != 0) {
- *(*int32)(unsafe.Pointer((bp + 128) /* &window_offsets_new[0] */ + uintptr(window_offsets_new_size)*4)) = *(*int32)(unsafe.Pointer((bp) /* &window_offsets[0] */ + uintptr(i)*4))
+ *(*int32)(unsafe.Pointer(bp + 128 + uintptr(window_offsets_new_size)*4)) = *(*int32)(unsafe.Pointer(bp + uintptr(i)*4))
window_offsets_new_size++
}
}
@@ -24502,12 +24245,12 @@ __3:
var best_offset int32
var do_compute int32 = 1
- if best_length >= ((int32(1) << 12) - 1) {
+ if best_length >= int32(1)<<12-1 {
// Do not recompute the best match if we already have a maximal one in the
// window.
best_offset = VP8LHashChainFindOffset(tls, hash_chain_best, i)
for ind = 0; ind < window_offsets_size; ind++ {
- if best_offset == *(*int32)(unsafe.Pointer((bp) /* &window_offsets[0] */ + uintptr(ind)*4)) {
+ if best_offset == *(*int32)(unsafe.Pointer(bp + uintptr(ind)*4)) {
do_compute = 0
break
}
@@ -24517,7 +24260,7 @@ __3:
// Figure out if we should use the offset/length from the previous pixel
// as an initial guess and therefore only inspect the offsets in
// window_offsets_new[].
- var use_prev int32 = (libc.Bool32((best_length_prev > 1) && (best_length_prev < ((int32(1) << 12) - 1))))
+ var use_prev int32 = libc.Bool32(best_length_prev > 1 && best_length_prev < int32(1)<<12-1)
var num_ind int32
if use_prev != 0 {
num_ind = window_offsets_new_size
@@ -24525,7 +24268,7 @@ __3:
num_ind = window_offsets_size
}
if use_prev != 0 {
- best_length = (best_length_prev - 1)
+ best_length = best_length_prev - 1
} else {
best_length = 0
}
@@ -24540,40 +24283,40 @@ __3:
var j int32 = i
var j_offset int32
if use_prev != 0 {
- j_offset = (i - *(*int32)(unsafe.Pointer((bp + 128) /* &window_offsets_new[0] */ + uintptr(ind)*4)))
+ j_offset = i - *(*int32)(unsafe.Pointer(bp + 128 + uintptr(ind)*4))
} else {
- j_offset = (i - *(*int32)(unsafe.Pointer((bp) /* &window_offsets[0] */ + uintptr(ind)*4)))
+ j_offset = i - *(*int32)(unsafe.Pointer(bp + uintptr(ind)*4))
}
- if (j_offset < 0) || (*(*uint32_t)(unsafe.Pointer(argb + uintptr(j_offset)*4)) != *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4))) {
+ if j_offset < 0 || *(*uint32_t)(unsafe.Pointer(argb + uintptr(j_offset)*4)) != *(*uint32_t)(unsafe.Pointer(argb + uintptr(i)*4)) {
continue
}
// The longest match is the sum of how many times each pixel is
// repeated.
- for ok := true; ok; ok = (((curr_length <= ((int32(1) << 12) - 1)) && (j < pix_count)) && (*(*uint32_t)(unsafe.Pointer(argb + uintptr(j_offset)*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr(j)*4)))) {
+ for __ccgo := true; __ccgo; __ccgo = curr_length <= int32(1)<<12-1 && j < pix_count && *(*uint32_t)(unsafe.Pointer(argb + uintptr(j_offset)*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr(j)*4)) {
var counts_j_offset int32 = int32(*(*uint16_t)(unsafe.Pointer(counts_ini + uintptr(j_offset)*2)))
var counts_j int32 = int32(*(*uint16_t)(unsafe.Pointer(counts_ini + uintptr(j)*2)))
if counts_j_offset != counts_j {
- curr_length = curr_length + (func() int32 {
+ curr_length = curr_length + func() int32 {
if counts_j_offset < counts_j {
return counts_j_offset
}
return counts_j
- }())
+ }()
break
}
// The same color is repeated counts_pos times at j_offset and j.
- curr_length = curr_length + (counts_j_offset)
- j_offset = j_offset + (counts_j_offset)
- j = j + (counts_j_offset)
+ curr_length = curr_length + counts_j_offset
+ j_offset = j_offset + counts_j_offset
+ j = j + counts_j_offset
}
if best_length < curr_length {
if use_prev != 0 {
- best_offset = *(*int32)(unsafe.Pointer((bp + 128) /* &window_offsets_new[0] */ + uintptr(ind)*4))
+ best_offset = *(*int32)(unsafe.Pointer(bp + 128 + uintptr(ind)*4))
} else {
- best_offset = *(*int32)(unsafe.Pointer((bp) /* &window_offsets[0] */ + uintptr(ind)*4))
+ best_offset = *(*int32)(unsafe.Pointer(bp + uintptr(ind)*4))
}
- if curr_length >= ((int32(1) << 12) - 1) {
- best_length = ((int32(1) << 12) - 1)
+ if curr_length >= int32(1)<<12-1 {
+ best_length = int32(1)<<12 - 1
break
} else {
best_length = curr_length
@@ -24587,7 +24330,7 @@ __3:
best_offset_prev = 0
best_length_prev = 0
} else {
- *(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(hash_chain)).offset_length_ + uintptr(i)*4)) = ((uint32_t(best_offset << 12)) | uint32_t(best_length))
+ *(*uint32_t)(unsafe.Pointer((*VP8LHashChain)(unsafe.Pointer(hash_chain)).offset_length_ + uintptr(i)*4)) = uint32_t(best_offset<<12) | uint32_t(best_length)
best_offset_prev = best_offset
best_length_prev = best_length
}
@@ -24606,13 +24349,13 @@ func BackwardReferences2DLocality(tls *libc.TLS, xsize int32, refs uintptr) { /*
defer tls.Free(24)
*(*VP8LRefsCursor)(unsafe.Pointer(bp /* c */)) = VP8LRefsCursorInit(tls, refs)
- for VP8LRefsCursorOk(tls, (bp) /* &c */) != 0 {
- if PixOrCopyIsCopy(tls, (*VP8LRefsCursor)(unsafe.Pointer(bp /* &c */)).cur_pos) != 0 {
+ for VP8LRefsCursorOk(tls, bp) != 0 {
+ if PixOrCopyIsCopy(tls, (*VP8LRefsCursor)(unsafe.Pointer(bp)).cur_pos) != 0 {
var dist int32 = int32((*PixOrCopy)(unsafe.Pointer((*VP8LRefsCursor)(unsafe.Pointer(bp /* &c */)).cur_pos)).argb_or_distance)
var transformed_dist int32 = VP8LDistanceToPlaneCode(tls, xsize, dist)
(*PixOrCopy)(unsafe.Pointer((*VP8LRefsCursor)(unsafe.Pointer(bp /* &c */)).cur_pos)).argb_or_distance = uint32_t(transformed_dist)
}
- VP8LRefsCursorNext(tls, (bp) /* &c */)
+ VP8LRefsCursorNext(tls, bp)
}
}
@@ -24666,10 +24409,10 @@ func CalculateBestCacheSize(tls *libc.TLS, argb uintptr, quality int32, refs uin
} else {
cache_bits_max = *(*int32)(unsafe.Pointer(best_cache_bits))
}
- entropy_min = (1e30)
+ entropy_min = 1e30
*(*[11]int32)(unsafe.Pointer(bp + 88 /* cc_init */)) = [11]int32{0: 0}
*(*VP8LRefsCursor)(unsafe.Pointer(bp + 312 /* c */)) = VP8LRefsCursorInit(tls, refs)
- *(*[11]uintptr)(unsafe.Pointer(bp /* histos */)) = [11]uintptr{0: (uintptr(0))}
+ *(*[11]uintptr)(unsafe.Pointer(bp /* histos */)) = [11]uintptr{0: uintptr(0)}
ok = 0
if !(cache_bits_max == 0) {
@@ -24687,22 +24430,22 @@ __2:
if !(i <= cache_bits_max) {
goto __4
}
- *(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */ + uintptr(i)*8)) = VP8LAllocateHistogram(tls, i)
- if !(*(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */ + uintptr(i)*8)) == (uintptr(0))) {
+ *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)) = VP8LAllocateHistogram(tls, i)
+ if !(*(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)) == uintptr(0)) {
goto __5
}
goto Error
__5:
;
- VP8LHistogramInit(tls, *(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */ + uintptr(i)*8)), i /*init_arrays=*/, 1)
+ VP8LHistogramInit(tls, *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)), i /*init_arrays=*/, 1)
if !(i == 0) {
goto __6
}
goto __3
__6:
;
- *(*int32)(unsafe.Pointer((bp + 88) /* &cc_init[0] */ + uintptr(i)*4)) = VP8LColorCacheInit(tls, ((bp + 136) /* &hashers */ + uintptr(i)*16), i)
- if !(!(*(*int32)(unsafe.Pointer((bp + 88) /* &cc_init[0] */ + uintptr(i)*4)) != 0)) {
+ *(*int32)(unsafe.Pointer(bp + 88 + uintptr(i)*4)) = VP8LColorCacheInit(tls, bp+136+uintptr(i)*16, i)
+ if !!(*(*int32)(unsafe.Pointer(bp + 88 + uintptr(i)*4)) != 0) {
goto __7
}
goto Error
@@ -24720,7 +24463,7 @@ __4:
// brute-force way as the function (entropy w.r.t cache_bits) can be
// anything in practice.
__8:
- if !(VP8LRefsCursorOk(tls, (bp+312) /* &c */) != 0) {
+ if !(VP8LRefsCursorOk(tls, bp+312) != 0) {
goto __9
}
v = (*VP8LRefsCursor)(unsafe.Pointer(bp + 312 /* &c */)).cur_pos
@@ -24728,34 +24471,34 @@ __8:
goto __10
}
pix = *(*uint32_t)(unsafe.Pointer(libc.PostIncUintptr(&argb, 4)))
- a = ((pix >> 24) & uint32_t(0xff))
- r = ((pix >> 16) & uint32_t(0xff))
- g = ((pix >> 8) & uint32_t(0xff))
- b = ((pix >> 0) & uint32_t(0xff))
+ a = pix >> 24 & uint32_t(0xff)
+ r = pix >> 16 & uint32_t(0xff)
+ g = pix >> 8 & uint32_t(0xff)
+ b = pix >> 0 & uint32_t(0xff)
// The keys of the caches can be derived from the longest one.
- key = VP8LHashPix(tls, pix, (32 - cache_bits_max))
+ key = VP8LHashPix(tls, pix, 32-cache_bits_max)
// Do not use the color cache for cache_bits = 0.
- *(*uint32_t)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */)) + 1032 /* &.blue_ */) + uintptr(b)*4))++
- *(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */)))).literal_ + uintptr(g)*4))++
- *(*uint32_t)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */)) + 8 /* &.red_ */) + uintptr(r)*4))++
- *(*uint32_t)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */)) + 2056 /* &.alpha_ */) + uintptr(a)*4))++
+ *(*uint32_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1032 + uintptr(b)*4))++
+ *(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).literal_ + uintptr(g)*4))++
+ *(*uint32_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + uintptr(r)*4))++
+ *(*uint32_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2056 + uintptr(a)*4))++
// Deal with cache_bits > 0.
i = cache_bits_max
__12:
if !(i >= 1) {
goto __14
}
- if !(VP8LColorCacheLookup(tls, ((bp+136) /* &hashers */ +uintptr(i)*16), uint32(key)) == pix) {
+ if !(VP8LColorCacheLookup(tls, bp+136+uintptr(i)*16, uint32(key)) == pix) {
goto __15
}
- *(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */ + uintptr(i)*8)))).literal_ + uintptr(((256+24)+key))*4))++
+ *(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)))).literal_ + uintptr(256+24+key)*4))++
goto __16
__15:
- VP8LColorCacheSet(tls, ((bp + 136) /* &hashers */ + uintptr(i)*16), uint32(key), pix)
- *(*uint32_t)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */ + uintptr(i)*8)) + 1032 /* &.blue_ */) + uintptr(b)*4))++
- *(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */ + uintptr(i)*8)))).literal_ + uintptr(g)*4))++
- *(*uint32_t)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */ + uintptr(i)*8)) + 8 /* &.red_ */) + uintptr(r)*4))++
- *(*uint32_t)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */ + uintptr(i)*8)) + 2056 /* &.alpha_ */) + uintptr(a)*4))++
+ VP8LColorCacheSet(tls, bp+136+uintptr(i)*16, uint32(key), pix)
+ *(*uint32_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)) + 1032 + uintptr(b)*4))++
+ *(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)))).literal_ + uintptr(g)*4))++
+ *(*uint32_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)) + 8 + uintptr(r)*4))++
+ *(*uint32_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)) + 2056 + uintptr(a)*4))++
__16:
;
goto __13
@@ -24774,14 +24517,14 @@ __10:
// histogram contributions, we can ignore them, except for the length
// prefix that is part of the literal_ histogram.
len = int32(PixOrCopyLength(tls, v))
- argb_prev = (*(*uint32_t)(unsafe.Pointer(argb)) ^ 0xffffffff)
- VP8LPrefixEncode(tls, len, (bp + 336) /* &code */, (bp + 340) /* &extra_bits */, (bp + 344) /* &extra_bits_value */)
+ argb_prev = *(*uint32_t)(unsafe.Pointer(argb)) ^ 0xffffffff
+ VP8LPrefixEncode(tls, len, bp+336, bp+340, bp+344)
i = 0
__17:
if !(i <= cache_bits_max) {
goto __19
}
- *(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */ + uintptr(i)*8)))).literal_ + uintptr((256+*(*int32)(unsafe.Pointer(bp + 336 /* code */))))*4))++
+ *(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)))).literal_ + uintptr(256+*(*int32)(unsafe.Pointer(bp + 336)))*4))++
goto __18
__18:
i++
@@ -24795,13 +24538,13 @@ __20:
goto __23
}
// Efficiency: insert only if the color changes.
- key1 = VP8LHashPix(tls, *(*uint32_t)(unsafe.Pointer(argb)), (32 - cache_bits_max))
+ key1 = VP8LHashPix(tls, *(*uint32_t)(unsafe.Pointer(argb)), 32-cache_bits_max)
i = cache_bits_max
__24:
if !(i >= 1) {
goto __26
}
- *(*uint32_t)(unsafe.Pointer((*VP8LColorCache)(unsafe.Pointer((bp+136) /* &hashers */ +uintptr(i)*16)).colors_ + uintptr(key1)*4)) = *(*uint32_t)(unsafe.Pointer(argb))
+ *(*uint32_t)(unsafe.Pointer((*VP8LColorCache)(unsafe.Pointer(bp+136+uintptr(i)*16)).colors_ + uintptr(key1)*4)) = *(*uint32_t)(unsafe.Pointer(argb))
goto __25
__25:
i--
@@ -24824,7 +24567,7 @@ __22:
;
__11:
;
- VP8LRefsCursorNext(tls, (bp + 312) /* &c */)
+ VP8LRefsCursorNext(tls, bp+312)
goto __8
__9:
;
@@ -24834,8 +24577,8 @@ __27:
if !(i <= cache_bits_max) {
goto __29
}
- entropy = VP8LHistogramEstimateBits(tls, *(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */ + uintptr(i)*8)))
- if !((i == 0) || (entropy < entropy_min)) {
+ entropy = VP8LHistogramEstimateBits(tls, *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)))
+ if !(i == 0 || entropy < entropy_min) {
goto __30
}
entropy_min = entropy
@@ -24856,13 +24599,13 @@ __31:
if !(i <= cache_bits_max) {
goto __33
}
- if !(*(*int32)(unsafe.Pointer((bp + 88) /* &cc_init[0] */ + uintptr(i)*4)) != 0) {
+ if !(*(*int32)(unsafe.Pointer(bp + 88 + uintptr(i)*4)) != 0) {
goto __34
}
- VP8LColorCacheClear(tls, ((bp + 136) /* &hashers */ + uintptr(i)*16))
+ VP8LColorCacheClear(tls, bp+136+uintptr(i)*16)
__34:
;
- VP8LFreeHistogram(tls, *(*uintptr)(unsafe.Pointer((bp) /* &histos[0] */ + uintptr(i)*8)))
+ VP8LFreeHistogram(tls, *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)))
goto __32
__32:
i++
@@ -24882,20 +24625,20 @@ func BackwardRefsWithLocalCache(tls *libc.TLS, argb uintptr, cache_bits int32, r
// var hashers VP8LColorCache at bp, 16
*(*VP8LRefsCursor)(unsafe.Pointer(bp + 16 /* c */)) = VP8LRefsCursorInit(tls, refs)
- if !(VP8LColorCacheInit(tls, (bp) /* &hashers */, cache_bits) != 0) {
+ if !(VP8LColorCacheInit(tls, bp, cache_bits) != 0) {
return 0
}
- for VP8LRefsCursorOk(tls, (bp+16) /* &c */) != 0 {
+ for VP8LRefsCursorOk(tls, bp+16) != 0 {
var v uintptr = (*VP8LRefsCursor)(unsafe.Pointer(bp + 16 /* &c */)).cur_pos
if PixOrCopyIsLiteral(tls, v) != 0 {
var argb_literal uint32_t = (*PixOrCopy)(unsafe.Pointer(v)).argb_or_distance
- var ix int32 = VP8LColorCacheContains(tls, (bp) /* &hashers */, argb_literal)
+ var ix int32 = VP8LColorCacheContains(tls, bp, argb_literal)
if ix >= 0 {
// hashers contains argb_literal
*(*PixOrCopy)(unsafe.Pointer(v)) = PixOrCopyCreateCacheIdx(tls, ix)
} else {
- VP8LColorCacheInsert(tls, (bp) /* &hashers */, argb_literal)
+ VP8LColorCacheInsert(tls, bp, argb_literal)
}
pixel_index++
} else {
@@ -24903,19 +24646,19 @@ func BackwardRefsWithLocalCache(tls *libc.TLS, argb uintptr, cache_bits int32, r
var k int32
for k = 0; k < int32((*PixOrCopy)(unsafe.Pointer(v)).len); k++ {
- VP8LColorCacheInsert(tls, (bp) /* &hashers */, *(*uint32_t)(unsafe.Pointer(argb + uintptr(libc.PostIncInt32(&pixel_index, 1))*4)))
+ VP8LColorCacheInsert(tls, bp, *(*uint32_t)(unsafe.Pointer(argb + uintptr(libc.PostIncInt32(&pixel_index, 1))*4)))
}
}
- VP8LRefsCursorNext(tls, (bp + 16) /* &c */)
+ VP8LRefsCursorNext(tls, bp+16)
}
- VP8LColorCacheClear(tls, (bp) /* &hashers */)
+ VP8LColorCacheClear(tls, bp)
return 1
}
func GetBackwardReferencesLowEffort(tls *libc.TLS, width int32, height int32, argb uintptr, cache_bits uintptr, hash_chain uintptr, refs_lz77 uintptr) uintptr { /* backward_references_enc.c:866:24: */
*(*int32)(unsafe.Pointer(cache_bits)) = 0
if !(BackwardReferencesLz77(tls, width, height, argb, 0, hash_chain, refs_lz77) != 0) {
- return (uintptr(0))
+ return uintptr(0)
}
BackwardReferences2DLocality(tls, width, refs_lz77)
return refs_lz77
@@ -24944,20 +24687,20 @@ func GetBackwardReferences(tls *libc.TLS, width int32, height int32, argb uintpt
var bit_cost_trace float64
var hash_chain_tmp uintptr
var cache_bits1 int32
- histo = (uintptr(0))
+ histo = uintptr(0)
*(*[2]int32)(unsafe.Pointer(bp + 40 /* lz77_types_best */)) = [2]int32{0, 0}
- *(*[2]float64)(unsafe.Pointer(bp + 24 /* bit_costs_best */)) = [2]float64{(1.79769313486231570814527423731704357e+308), (1.79769313486231570814527423731704357e+308)}
- refs_tmp = (refs + uintptr(func() int32 {
+ *(*[2]float64)(unsafe.Pointer(bp + 24 /* bit_costs_best */)) = [2]float64{1.79769313486231570814527423731704357e+308, 1.79769313486231570814527423731704357e+308}
+ refs_tmp = refs + uintptr(func() int32 {
if do_no_cache != 0 {
return 2
}
return 1
- }())*40)
+ }())*40
status = 0
- libc.Xmemset(tls, (bp) /* &hash_chain_box */, 0, uint64(unsafe.Sizeof(VP8LHashChain{})))
+ libc.Xmemset(tls, bp, 0, uint64(unsafe.Sizeof(VP8LHashChain{})))
histo = VP8LAllocateHistogram(tls, 10)
- if !(histo == (uintptr(0))) {
+ if !(histo == uintptr(0)) {
goto __1
}
goto Error
@@ -24971,7 +24714,7 @@ __2:
}
res = 0
bit_cost = 0.
- if !((lz77_types_to_try & lz77_type) == 0) {
+ if !(lz77_types_to_try&lz77_type == 0) {
goto __5
}
goto __3
@@ -24998,20 +24741,20 @@ __8:
refs_tmp)
goto __6
__9:
- if !(!(VP8LHashChainInit(tls, (bp) /* &hash_chain_box */, (width*height)) != 0)) {
+ if !!(VP8LHashChainInit(tls, bp, width*height) != 0) {
goto __11
}
goto Error
__11:
;
res = BackwardReferencesLz77Box(tls, width, height, argb, 0, hash_chain,
- (bp) /* &hash_chain_box */, refs_tmp)
+ bp, refs_tmp)
goto __6
__10:
;
__6:
;
- if !(!(res != 0)) {
+ if !!(res != 0) {
goto __12
}
goto Error
@@ -25030,7 +24773,7 @@ __13:
*(*int32)(unsafe.Pointer(bp + 16 /* cache_bits */)) = cache_bits_max
}
- if !((i == 1) && !(do_no_cache != 0)) {
+ if !(i == 1 && !(do_no_cache != 0)) {
goto __16
}
goto __14
@@ -25041,16 +24784,16 @@ __16:
goto __17
}
// Try with a color cache.
- if !(!(CalculateBestCacheSize(tls, argb, quality, refs_tmp, (bp+16) /* &cache_bits */) != 0)) {
+ if !!(CalculateBestCacheSize(tls, argb, quality, refs_tmp, bp+16) != 0) {
goto __18
}
goto Error
__18:
;
- if !(*(*int32)(unsafe.Pointer(bp + 16 /* cache_bits */)) > 0) {
+ if !(*(*int32)(unsafe.Pointer(bp + 16)) > 0) {
goto __19
}
- if !(!(BackwardRefsWithLocalCache(tls, argb, *(*int32)(unsafe.Pointer(bp + 16 /* cache_bits */)), refs_tmp) != 0)) {
+ if !!(BackwardRefsWithLocalCache(tls, argb, *(*int32)(unsafe.Pointer(bp + 16)), refs_tmp) != 0) {
goto __20
}
goto Error
@@ -25061,7 +24804,7 @@ __19:
__17:
;
- if !(((i == 0) && (do_no_cache != 0)) && (*(*int32)(unsafe.Pointer(bp + 16 /* cache_bits */)) == 0)) {
+ if !(i == 0 && do_no_cache != 0 && *(*int32)(unsafe.Pointer(bp + 16)) == 0) {
goto __21
}
// No need to re-compute bit_cost as it was computed at i == 1.
@@ -25072,7 +24815,7 @@ __21:
__22:
;
- if !(bit_cost < *(*float64)(unsafe.Pointer((bp + 24) /* &bit_costs_best[0] */ + uintptr(i)*8))) {
+ if !(bit_cost < *(*float64)(unsafe.Pointer(bp + 24 + uintptr(i)*8))) {
goto __23
}
if !(i == 1) {
@@ -25080,7 +24823,7 @@ __22:
}
// Do not swap as the full cache analysis would have the wrong
// VP8LBackwardRefs to start with.
- if !(!(BackwardRefsClone(tls, refs_tmp, (refs+1*40)) != 0)) {
+ if !!(BackwardRefsClone(tls, refs_tmp, refs+1*40) != 0) {
goto __26
}
goto Error
@@ -25088,11 +24831,11 @@ __26:
;
goto __25
__24:
- BackwardRefsSwap(tls, refs_tmp, (refs))
+ BackwardRefsSwap(tls, refs_tmp, refs)
__25:
;
- *(*float64)(unsafe.Pointer((bp + 24) /* &bit_costs_best[0] */ + uintptr(i)*8)) = bit_cost
- *(*int32)(unsafe.Pointer((bp + 40) /* &lz77_types_best[0] */ + uintptr(i)*4)) = lz77_type
+ *(*float64)(unsafe.Pointer(bp + 24 + uintptr(i)*8)) = bit_cost
+ *(*int32)(unsafe.Pointer(bp + 40 + uintptr(i)*4)) = lz77_type
if !(i == 0) {
goto __27
}
@@ -25110,7 +24853,7 @@ __15:
;
goto __3
__3:
- lz77_types_to_try = lz77_types_to_try & (^lz77_type)
+ lz77_types_to_try = lz77_types_to_try & ^lz77_type
lz77_type <<= 1
goto __2
goto __4
@@ -25124,19 +24867,19 @@ __28:
if !(i >= 0) {
goto __30
}
- if !((i == 1) && !(do_no_cache != 0)) {
+ if !(i == 1 && !(do_no_cache != 0)) {
goto __31
}
goto __29
__31:
;
- if !(((*(*int32)(unsafe.Pointer((bp + 40) /* &lz77_types_best[0] */ + uintptr(i)*4)) == kLZ77Standard) || (*(*int32)(unsafe.Pointer((bp + 40) /* &lz77_types_best[0] */ + uintptr(i)*4)) == kLZ77Box)) && (quality >= 25)) {
+ if !((*(*int32)(unsafe.Pointer(bp + 40 + uintptr(i)*4)) == kLZ77Standard || *(*int32)(unsafe.Pointer(bp + 40 + uintptr(i)*4)) == kLZ77Box) && quality >= 25) {
goto __32
}
- if *(*int32)(unsafe.Pointer((bp + 40) /* &lz77_types_best[0] */ + uintptr(i)*4)) == kLZ77Standard {
+ if *(*int32)(unsafe.Pointer(bp + 40 + uintptr(i)*4)) == kLZ77Standard {
hash_chain_tmp = hash_chain
} else {
- hash_chain_tmp = (bp) /* &hash_chain_box */
+ hash_chain_tmp = bp /* &hash_chain_box */
}
if i == 1 {
cache_bits1 = 0
@@ -25144,16 +24887,16 @@ __31:
cache_bits1 = *(*int32)(unsafe.Pointer(cache_bits_best))
}
if !(VP8LBackwardReferencesTraceBackwards(tls, width, height, argb, cache_bits1,
- hash_chain_tmp, (refs+uintptr(i)*40),
+ hash_chain_tmp, refs+uintptr(i)*40,
refs_tmp) != 0) {
goto __33
}
VP8LHistogramCreate(tls, histo, refs_tmp, cache_bits1)
bit_cost_trace = VP8LHistogramEstimateBits(tls, histo)
- if !(bit_cost_trace < *(*float64)(unsafe.Pointer((bp + 24) /* &bit_costs_best[0] */ + uintptr(i)*8))) {
+ if !(bit_cost_trace < *(*float64)(unsafe.Pointer(bp + 24 + uintptr(i)*8))) {
goto __34
}
- BackwardRefsSwap(tls, refs_tmp, (refs + uintptr(i)*40))
+ BackwardRefsSwap(tls, refs_tmp, refs+uintptr(i)*40)
__34:
;
__33:
@@ -25161,14 +24904,14 @@ __33:
__32:
;
- BackwardReferences2DLocality(tls, width, (refs + uintptr(i)*40))
+ BackwardReferences2DLocality(tls, width, refs+uintptr(i)*40)
- if !(((i == 1) && (*(*int32)(unsafe.Pointer((bp + 40) /* &lz77_types_best[0] */)) == *(*int32)(unsafe.Pointer((bp + 40) /* &lz77_types_best[0] */ + 1*4)))) && (*(*int32)(unsafe.Pointer(cache_bits_best)) == 0)) {
+ if !(i == 1 && *(*int32)(unsafe.Pointer(bp + 40)) == *(*int32)(unsafe.Pointer(bp + 40 + 1*4)) && *(*int32)(unsafe.Pointer(cache_bits_best)) == 0) {
goto __35
}
// If the best cache size is 0 and we have the same best LZ77, just copy
// the data over and stop here.
- if !(!(BackwardRefsClone(tls, (refs+1*40), (refs)) != 0)) {
+ if !!(BackwardRefsClone(tls, refs+1*40, refs) != 0) {
goto __36
}
goto Error
@@ -25187,7 +24930,7 @@ __30:
status = 1
Error:
- VP8LHashChainClear(tls, (bp) /* &hash_chain_box */)
+ VP8LHashChainClear(tls, bp)
VP8LFreeHistogram(tls, histo)
return status
}
@@ -25198,11 +24941,11 @@ func VP8LGetBackwardReferences(tls *libc.TLS, width int32, height int32, argb ui
*(*int32)(unsafe.Pointer(cache_bits_best)) = cache_bits_max
refs_best = GetBackwardReferencesLowEffort(tls,
width, height, argb, cache_bits_best, hash_chain, refs)
- if refs_best == (uintptr(0)) {
+ if refs_best == uintptr(0) {
return VP8_ENC_ERROR_OUT_OF_MEMORY
}
// Set it in first position.
- BackwardRefsSwap(tls, refs_best, (refs))
+ BackwardRefsSwap(tls, refs_best, refs)
} else {
if !(GetBackwardReferences(tls, width, height, argb, quality, lz77_types_to_try,
cache_bits_max, do_no_cache, hash_chain, refs,
@@ -25220,10 +24963,10 @@ func VP8LGetBackwardReferences(tls *libc.TLS, width int32, height int32, argb ui
//------------------------------------------------------------------------------
func WebPConfigInitInternal(tls *libc.TLS, config uintptr, preset WebPPreset, quality float32, version int32) int32 { /* config_enc.c:24:5: */
- if ((version) >> 8) != (int32((0x020f)) >> 8) {
+ if version>>8 != int32(0x020f)>>8 {
return 0 // caller/system version mismatch!
}
- if config == (uintptr(0)) {
+ if config == uintptr(0) {
return 0
}
@@ -25263,13 +25006,13 @@ func WebPConfigInitInternal(tls *libc.TLS, config uintptr, preset WebPPreset, qu
(*WebPConfig)(unsafe.Pointer(config)).sns_strength = 80
(*WebPConfig)(unsafe.Pointer(config)).filter_sharpness = 4
(*WebPConfig)(unsafe.Pointer(config)).filter_strength = 35
- *(*int32)(unsafe.Pointer((config + 68 /* &.preprocessing */))) &= (libc.CplInt32(2)) // no dithering
+ *(*int32)(unsafe.Pointer(config + 68)) &= libc.CplInt32(2) // no dithering
break
case WEBP_PRESET_PHOTO:
(*WebPConfig)(unsafe.Pointer(config)).sns_strength = 80
(*WebPConfig)(unsafe.Pointer(config)).filter_sharpness = 3
(*WebPConfig)(unsafe.Pointer(config)).filter_strength = 30
- *(*int32)(unsafe.Pointer((config + 68 /* &.preprocessing */))) |= (2)
+ *(*int32)(unsafe.Pointer(config + 68)) |= 2
break
case WEBP_PRESET_DRAWING:
(*WebPConfig)(unsafe.Pointer(config)).sns_strength = 25
@@ -25278,13 +25021,13 @@ func WebPConfigInitInternal(tls *libc.TLS, config uintptr, preset WebPPreset, qu
break
case WEBP_PRESET_ICON:
(*WebPConfig)(unsafe.Pointer(config)).sns_strength = 0
- (*WebPConfig)(unsafe.Pointer(config)).filter_strength = 0 // disable filtering to retain sharpness
- *(*int32)(unsafe.Pointer((config + 68 /* &.preprocessing */))) &= (libc.CplInt32(2)) // no dithering
+ (*WebPConfig)(unsafe.Pointer(config)).filter_strength = 0 // disable filtering to retain sharpness
+ *(*int32)(unsafe.Pointer(config + 68)) &= libc.CplInt32(2) // no dithering
break
case WEBP_PRESET_TEXT:
(*WebPConfig)(unsafe.Pointer(config)).sns_strength = 0
- (*WebPConfig)(unsafe.Pointer(config)).filter_strength = 0 // disable filtering to retain sharpness
- *(*int32)(unsafe.Pointer((config + 68 /* &.preprocessing */))) &= (libc.CplInt32(2)) // no dithering
+ (*WebPConfig)(unsafe.Pointer(config)).filter_strength = 0 // disable filtering to retain sharpness
+ *(*int32)(unsafe.Pointer(config + 68)) &= libc.CplInt32(2) // no dithering
(*WebPConfig)(unsafe.Pointer(config)).segments = 2
break
case WEBP_PRESET_DEFAULT:
@@ -25296,10 +25039,10 @@ func WebPConfigInitInternal(tls *libc.TLS, config uintptr, preset WebPPreset, qu
}
func WebPValidateConfig(tls *libc.TLS, config uintptr) int32 { /* config_enc.c:98:5: */
- if config == (uintptr(0)) {
+ if config == uintptr(0) {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).quality < float32(0)) || ((*WebPConfig)(unsafe.Pointer(config)).quality > float32(100)) {
+ if (*WebPConfig)(unsafe.Pointer(config)).quality < float32(0) || (*WebPConfig)(unsafe.Pointer(config)).quality > float32(100) {
return 0
}
if (*WebPConfig)(unsafe.Pointer(config)).target_size < 0 {
@@ -25308,43 +25051,43 @@ func WebPValidateConfig(tls *libc.TLS, config uintptr) int32 { /* config_enc.c:9
if (*WebPConfig)(unsafe.Pointer(config)).target_PSNR < float32(0) {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).method < 0) || ((*WebPConfig)(unsafe.Pointer(config)).method > 6) {
+ if (*WebPConfig)(unsafe.Pointer(config)).method < 0 || (*WebPConfig)(unsafe.Pointer(config)).method > 6 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).segments < 1) || ((*WebPConfig)(unsafe.Pointer(config)).segments > 4) {
+ if (*WebPConfig)(unsafe.Pointer(config)).segments < 1 || (*WebPConfig)(unsafe.Pointer(config)).segments > 4 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).sns_strength < 0) || ((*WebPConfig)(unsafe.Pointer(config)).sns_strength > 100) {
+ if (*WebPConfig)(unsafe.Pointer(config)).sns_strength < 0 || (*WebPConfig)(unsafe.Pointer(config)).sns_strength > 100 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).filter_strength < 0) || ((*WebPConfig)(unsafe.Pointer(config)).filter_strength > 100) {
+ if (*WebPConfig)(unsafe.Pointer(config)).filter_strength < 0 || (*WebPConfig)(unsafe.Pointer(config)).filter_strength > 100 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).filter_sharpness < 0) || ((*WebPConfig)(unsafe.Pointer(config)).filter_sharpness > 7) {
+ if (*WebPConfig)(unsafe.Pointer(config)).filter_sharpness < 0 || (*WebPConfig)(unsafe.Pointer(config)).filter_sharpness > 7 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).filter_type < 0) || ((*WebPConfig)(unsafe.Pointer(config)).filter_type > 1) {
+ if (*WebPConfig)(unsafe.Pointer(config)).filter_type < 0 || (*WebPConfig)(unsafe.Pointer(config)).filter_type > 1 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).autofilter < 0) || ((*WebPConfig)(unsafe.Pointer(config)).autofilter > 1) {
+ if (*WebPConfig)(unsafe.Pointer(config)).autofilter < 0 || (*WebPConfig)(unsafe.Pointer(config)).autofilter > 1 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).pass < 1) || ((*WebPConfig)(unsafe.Pointer(config)).pass > 10) {
+ if (*WebPConfig)(unsafe.Pointer(config)).pass < 1 || (*WebPConfig)(unsafe.Pointer(config)).pass > 10 {
return 0
}
- if (((*WebPConfig)(unsafe.Pointer(config)).qmin < 0) || ((*WebPConfig)(unsafe.Pointer(config)).qmax > 100)) || ((*WebPConfig)(unsafe.Pointer(config)).qmin > (*WebPConfig)(unsafe.Pointer(config)).qmax) {
+ if (*WebPConfig)(unsafe.Pointer(config)).qmin < 0 || (*WebPConfig)(unsafe.Pointer(config)).qmax > 100 || (*WebPConfig)(unsafe.Pointer(config)).qmin > (*WebPConfig)(unsafe.Pointer(config)).qmax {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).show_compressed < 0) || ((*WebPConfig)(unsafe.Pointer(config)).show_compressed > 1) {
+ if (*WebPConfig)(unsafe.Pointer(config)).show_compressed < 0 || (*WebPConfig)(unsafe.Pointer(config)).show_compressed > 1 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).preprocessing < 0) || ((*WebPConfig)(unsafe.Pointer(config)).preprocessing > 7) {
+ if (*WebPConfig)(unsafe.Pointer(config)).preprocessing < 0 || (*WebPConfig)(unsafe.Pointer(config)).preprocessing > 7 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).partitions < 0) || ((*WebPConfig)(unsafe.Pointer(config)).partitions > 3) {
+ if (*WebPConfig)(unsafe.Pointer(config)).partitions < 0 || (*WebPConfig)(unsafe.Pointer(config)).partitions > 3 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).partition_limit < 0) || ((*WebPConfig)(unsafe.Pointer(config)).partition_limit > 100) {
+ if (*WebPConfig)(unsafe.Pointer(config)).partition_limit < 0 || (*WebPConfig)(unsafe.Pointer(config)).partition_limit > 100 {
return 0
}
if (*WebPConfig)(unsafe.Pointer(config)).alpha_compression < 0 {
@@ -25353,34 +25096,34 @@ func WebPValidateConfig(tls *libc.TLS, config uintptr) int32 { /* config_enc.c:9
if (*WebPConfig)(unsafe.Pointer(config)).alpha_filtering < 0 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).alpha_quality < 0) || ((*WebPConfig)(unsafe.Pointer(config)).alpha_quality > 100) {
+ if (*WebPConfig)(unsafe.Pointer(config)).alpha_quality < 0 || (*WebPConfig)(unsafe.Pointer(config)).alpha_quality > 100 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).lossless < 0) || ((*WebPConfig)(unsafe.Pointer(config)).lossless > 1) {
+ if (*WebPConfig)(unsafe.Pointer(config)).lossless < 0 || (*WebPConfig)(unsafe.Pointer(config)).lossless > 1 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).near_lossless < 0) || ((*WebPConfig)(unsafe.Pointer(config)).near_lossless > 100) {
+ if (*WebPConfig)(unsafe.Pointer(config)).near_lossless < 0 || (*WebPConfig)(unsafe.Pointer(config)).near_lossless > 100 {
return 0
}
if (*WebPConfig)(unsafe.Pointer(config)).image_hint >= WEBP_HINT_LAST {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).emulate_jpeg_size < 0) || ((*WebPConfig)(unsafe.Pointer(config)).emulate_jpeg_size > 1) {
+ if (*WebPConfig)(unsafe.Pointer(config)).emulate_jpeg_size < 0 || (*WebPConfig)(unsafe.Pointer(config)).emulate_jpeg_size > 1 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).thread_level < 0) || ((*WebPConfig)(unsafe.Pointer(config)).thread_level > 1) {
+ if (*WebPConfig)(unsafe.Pointer(config)).thread_level < 0 || (*WebPConfig)(unsafe.Pointer(config)).thread_level > 1 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).low_memory < 0) || ((*WebPConfig)(unsafe.Pointer(config)).low_memory > 1) {
+ if (*WebPConfig)(unsafe.Pointer(config)).low_memory < 0 || (*WebPConfig)(unsafe.Pointer(config)).low_memory > 1 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).exact < 0) || ((*WebPConfig)(unsafe.Pointer(config)).exact > 1) {
+ if (*WebPConfig)(unsafe.Pointer(config)).exact < 0 || (*WebPConfig)(unsafe.Pointer(config)).exact > 1 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).use_delta_palette < 0) || ((*WebPConfig)(unsafe.Pointer(config)).use_delta_palette > 1) {
+ if (*WebPConfig)(unsafe.Pointer(config)).use_delta_palette < 0 || (*WebPConfig)(unsafe.Pointer(config)).use_delta_palette > 1 {
return 0
}
- if ((*WebPConfig)(unsafe.Pointer(config)).use_sharp_yuv < 0) || ((*WebPConfig)(unsafe.Pointer(config)).use_sharp_yuv > 1) {
+ if (*WebPConfig)(unsafe.Pointer(config)).use_sharp_yuv < 0 || (*WebPConfig)(unsafe.Pointer(config)).use_sharp_yuv > 1 {
return 0
}
@@ -25394,42 +25137,12 @@ var kLosslessPresets = [10]struct {
method_ uint8_t
quality_ uint8_t
}{
- struct {
- method_ uint8_t
- quality_ uint8_t
- }{}, struct {
- method_ uint8_t
- quality_ uint8_t
- }{method_: uint8_t(1), quality_: uint8_t(20)}, struct {
- method_ uint8_t
- quality_ uint8_t
- }{method_: uint8_t(2), quality_: uint8_t(25)}, struct {
- method_ uint8_t
- quality_ uint8_t
- }{method_: uint8_t(3), quality_: uint8_t(30)}, struct {
- method_ uint8_t
- quality_ uint8_t
- }{method_: uint8_t(3), quality_: uint8_t(50)},
- struct {
- method_ uint8_t
- quality_ uint8_t
- }{method_: uint8_t(4), quality_: uint8_t(50)}, struct {
- method_ uint8_t
- quality_ uint8_t
- }{method_: uint8_t(4), quality_: uint8_t(75)}, struct {
- method_ uint8_t
- quality_ uint8_t
- }{method_: uint8_t(4), quality_: uint8_t(90)}, struct {
- method_ uint8_t
- quality_ uint8_t
- }{method_: uint8_t(5), quality_: uint8_t(90)}, struct {
- method_ uint8_t
- quality_ uint8_t
- }{method_: uint8_t(6), quality_: uint8_t(100)},
+ {}, {method_: uint8_t(1), quality_: uint8_t(20)}, {method_: uint8_t(2), quality_: uint8_t(25)}, {method_: uint8_t(3), quality_: uint8_t(30)}, {method_: uint8_t(3), quality_: uint8_t(50)},
+ {method_: uint8_t(4), quality_: uint8_t(50)}, {method_: uint8_t(4), quality_: uint8_t(75)}, {method_: uint8_t(4), quality_: uint8_t(90)}, {method_: uint8_t(5), quality_: uint8_t(90)}, {method_: uint8_t(6), quality_: uint8_t(100)},
} /* config_enc.c:144:3 */
func WebPConfigLosslessPreset(tls *libc.TLS, config uintptr, level int32) int32 { /* config_enc.c:149:5: */
- if ((config == (uintptr(0))) || (level < 0)) || (level > 9) {
+ if config == uintptr(0) || level < 0 || level > 9 {
return 0
}
(*WebPConfig)(unsafe.Pointer(config)).lossless = 1
@@ -25449,33 +25162,33 @@ func WebPConfigLosslessPreset(tls *libc.TLS, config uintptr, level int32) int32
// use for coding it (in [][0]) as well as the bit value to use for each
// context (in [][1]).
var VP8LevelCodes = [67][2]uint16_t{
- [2]uint16_t{uint16_t(0x001), uint16_t(0x000)}, [2]uint16_t{uint16_t(0x007), uint16_t(0x001)}, [2]uint16_t{uint16_t(0x00f), uint16_t(0x005)},
- [2]uint16_t{uint16_t(0x00f), uint16_t(0x00d)}, [2]uint16_t{uint16_t(0x033), uint16_t(0x003)}, [2]uint16_t{uint16_t(0x033), uint16_t(0x003)}, [2]uint16_t{uint16_t(0x033), uint16_t(0x023)},
- [2]uint16_t{uint16_t(0x033), uint16_t(0x023)}, [2]uint16_t{uint16_t(0x033), uint16_t(0x023)}, [2]uint16_t{uint16_t(0x033), uint16_t(0x023)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x013)},
- [2]uint16_t{uint16_t(0x0d3), uint16_t(0x013)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x013)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x013)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x013)},
- [2]uint16_t{uint16_t(0x0d3), uint16_t(0x013)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x013)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x013)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)},
- [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)},
- [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)},
- [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)},
- [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x0d3), uint16_t(0x093)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)},
- [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)},
- [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)},
- [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)},
- [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)},
- [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)},
- [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)},
- [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)},
- [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x053)}, [2]uint16_t{uint16_t(0x153), uint16_t(0x153)},
+ {uint16_t(0x001), uint16_t(0x000)}, {uint16_t(0x007), uint16_t(0x001)}, {uint16_t(0x00f), uint16_t(0x005)},
+ {uint16_t(0x00f), uint16_t(0x00d)}, {uint16_t(0x033), uint16_t(0x003)}, {uint16_t(0x033), uint16_t(0x003)}, {uint16_t(0x033), uint16_t(0x023)},
+ {uint16_t(0x033), uint16_t(0x023)}, {uint16_t(0x033), uint16_t(0x023)}, {uint16_t(0x033), uint16_t(0x023)}, {uint16_t(0x0d3), uint16_t(0x013)},
+ {uint16_t(0x0d3), uint16_t(0x013)}, {uint16_t(0x0d3), uint16_t(0x013)}, {uint16_t(0x0d3), uint16_t(0x013)}, {uint16_t(0x0d3), uint16_t(0x013)},
+ {uint16_t(0x0d3), uint16_t(0x013)}, {uint16_t(0x0d3), uint16_t(0x013)}, {uint16_t(0x0d3), uint16_t(0x013)}, {uint16_t(0x0d3), uint16_t(0x093)},
+ {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x0d3), uint16_t(0x093)},
+ {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x0d3), uint16_t(0x093)},
+ {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x0d3), uint16_t(0x093)},
+ {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x0d3), uint16_t(0x093)}, {uint16_t(0x153), uint16_t(0x053)},
+ {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)},
+ {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)},
+ {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)},
+ {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)},
+ {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)},
+ {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)},
+ {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)},
+ {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x053)}, {uint16_t(0x153), uint16_t(0x153)},
} /* cost_enc.c:22:16 */
func VariableLevelCost(tls *libc.TLS, level int32, probas uintptr) int32 { /* cost_enc.c:42:12: */
- var pattern int32 = int32(*(*uint16_t)(unsafe.Pointer((uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr((level-1))*4))))
- var bits int32 = int32(*(*uint16_t)(unsafe.Pointer((uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr((level-1))*4) + 1*2)))
+ var pattern int32 = int32(*(*uint16_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr(level-1)*4)))
+ var bits int32 = int32(*(*uint16_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr(level-1)*4 + 1*2)))
var cost int32 = 0
var i int32
for i = 2; pattern != 0; i++ {
- if (pattern & 1) != 0 {
- cost = cost + (VP8BitCost(tls, (bits & 1), *(*uint8_t)(unsafe.Pointer(probas + uintptr(i)))))
+ if pattern&1 != 0 {
+ cost = cost + VP8BitCost(tls, bits&1, *(*uint8_t)(unsafe.Pointer(probas + uintptr(i))))
}
bits >>= 1
pattern >>= 1
@@ -25499,19 +25212,19 @@ func VP8CalculateLevelCosts(tls *libc.TLS, proba uintptr) { /* cost_enc.c:60:6:
var n int32
for band = 0; band < NUM_BANDS; band++ {
for ctx = 0; ctx < NUM_CTX; ctx++ {
- var p uintptr = (((proba + 4 /* &.coeffs_ */ + uintptr(ctype)*264) + uintptr(band)*33) + uintptr(ctx)*11)
- var table uintptr = (((proba + 5284 /* &.level_cost_ */ + uintptr(ctype)*3264) + uintptr(band)*408) + uintptr(ctx)*136)
+ var p uintptr = proba + 4 + uintptr(ctype)*264 + uintptr(band)*33 + uintptr(ctx)*11
+ var table uintptr = proba + 5284 + uintptr(ctype)*3264 + uintptr(band)*408 + uintptr(ctx)*136
var cost0 int32
if ctx > 0 {
cost0 = VP8BitCost(tls, 1, *(*uint8_t)(unsafe.Pointer(p)))
} else {
cost0 = 0
}
- var cost_base int32 = (VP8BitCost(tls, 1, *(*uint8_t)(unsafe.Pointer(p + 1))) + cost0)
+ var cost_base int32 = VP8BitCost(tls, 1, *(*uint8_t)(unsafe.Pointer(p + 1))) + cost0
var v int32
- *(*uint16_t)(unsafe.Pointer(table)) = (uint16_t(VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(p + 1))) + cost0))
+ *(*uint16_t)(unsafe.Pointer(table)) = uint16_t(VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(p + 1))) + cost0)
for v = 1; v <= MAX_VARIABLE_LEVEL; v++ {
- *(*uint16_t)(unsafe.Pointer(table + uintptr(v)*2)) = (uint16_t(cost_base + VariableLevelCost(tls, v, p)))
+ *(*uint16_t)(unsafe.Pointer(table + uintptr(v)*2)) = uint16_t(cost_base + VariableLevelCost(tls, v, p))
}
// Starting at level 67 and up, the variable part of the cost is
// actually constant.
@@ -25519,7 +25232,7 @@ func VP8CalculateLevelCosts(tls *libc.TLS, proba uintptr) { /* cost_enc.c:60:6:
}
for n = 0; n < 16; n++ { // replicate bands. We don't need to sentinel.
for ctx = 0; ctx < NUM_CTX; ctx++ {
- *(*uintptr)(unsafe.Pointer((((proba + 18344 /* &.remapped_costs_ */) + uintptr(ctype)*384) + uintptr(n)*24) + uintptr(ctx)*8)) = (((proba + 5284 /* &.level_cost_ */ + uintptr(ctype)*3264) + uintptr(VP8EncBands[n])*408) + uintptr(ctx)*136)
+ *(*uintptr)(unsafe.Pointer(proba + 18344 + uintptr(ctype)*384 + uintptr(n)*24 + uintptr(ctx)*8)) = proba + 5284 + uintptr(ctype)*3264 + uintptr(VP8EncBands[n])*408 + uintptr(ctx)*136
}
}
}
@@ -25534,116 +25247,116 @@ func VP8CalculateLevelCosts(tls *libc.TLS, proba uintptr) { /* cost_enc.c:60:6:
var VP8FixedCostsUV = [4]uint16_t{uint16_t(302), uint16_t(984), uint16_t(439), uint16_t(642)} /* cost_enc.c:97:16 */
// note: these values include the fixed VP8BitCost(1, 145) mode selection cost.
var VP8FixedCostsI16 = [4]uint16_t{uint16_t(663), uint16_t(919), uint16_t(872), uint16_t(919)} /* cost_enc.c:99:16 */
-var VP8FixedCostsI4 = [10][10][10]uint16_t{[10][10]uint16_t{
- [10]uint16_t{uint16_t(40), uint16_t(1151), uint16_t(1723), uint16_t(1874), uint16_t(2103), uint16_t(2019), uint16_t(1628), uint16_t(1777), uint16_t(2226), uint16_t(2137)},
- [10]uint16_t{uint16_t(192), uint16_t(469), uint16_t(1296), uint16_t(1308), uint16_t(1849), uint16_t(1794), uint16_t(1781), uint16_t(1703), uint16_t(1713), uint16_t(1522)},
- [10]uint16_t{uint16_t(142), uint16_t(910), uint16_t(762), uint16_t(1684), uint16_t(1849), uint16_t(1576), uint16_t(1460), uint16_t(1305), uint16_t(1801), uint16_t(1657)},
- [10]uint16_t{uint16_t(559), uint16_t(641), uint16_t(1370), uint16_t(421), uint16_t(1182), uint16_t(1569), uint16_t(1612), uint16_t(1725), uint16_t(863), uint16_t(1007)},
- [10]uint16_t{uint16_t(299), uint16_t(1059), uint16_t(1256), uint16_t(1108), uint16_t(636), uint16_t(1068), uint16_t(1581), uint16_t(1883), uint16_t(869), uint16_t(1142)},
- [10]uint16_t{uint16_t(277), uint16_t(1111), uint16_t(707), uint16_t(1362), uint16_t(1089), uint16_t(672), uint16_t(1603), uint16_t(1541), uint16_t(1545), uint16_t(1291)},
- [10]uint16_t{uint16_t(214), uint16_t(781), uint16_t(1609), uint16_t(1303), uint16_t(1632), uint16_t(2229), uint16_t(726), uint16_t(1560), uint16_t(1713), uint16_t(918)},
- [10]uint16_t{uint16_t(152), uint16_t(1037), uint16_t(1046), uint16_t(1759), uint16_t(1983), uint16_t(2174), uint16_t(1358), uint16_t(742), uint16_t(1740), uint16_t(1390)},
- [10]uint16_t{uint16_t(512), uint16_t(1046), uint16_t(1420), uint16_t(753), uint16_t(752), uint16_t(1297), uint16_t(1486), uint16_t(1613), uint16_t(460), uint16_t(1207)},
- [10]uint16_t{uint16_t(424), uint16_t(827), uint16_t(1362), uint16_t(719), uint16_t(1462), uint16_t(1202), uint16_t(1199), uint16_t(1476), uint16_t(1199), uint16_t(538)}},
- [10][10]uint16_t{[10]uint16_t{uint16_t(240), uint16_t(402), uint16_t(1134), uint16_t(1491), uint16_t(1659), uint16_t(1505), uint16_t(1517), uint16_t(1555), uint16_t(1979), uint16_t(2099)},
- [10]uint16_t{uint16_t(467), uint16_t(242), uint16_t(960), uint16_t(1232), uint16_t(1714), uint16_t(1620), uint16_t(1834), uint16_t(1570), uint16_t(1676), uint16_t(1391)},
- [10]uint16_t{uint16_t(500), uint16_t(455), uint16_t(463), uint16_t(1507), uint16_t(1699), uint16_t(1282), uint16_t(1564), uint16_t(982), uint16_t(2114), uint16_t(2114)},
- [10]uint16_t{uint16_t(672), uint16_t(643), uint16_t(1372), uint16_t(331), uint16_t(1589), uint16_t(1667), uint16_t(1453), uint16_t(1938), uint16_t(996), uint16_t(876)},
- [10]uint16_t{uint16_t(458), uint16_t(783), uint16_t(1037), uint16_t(911), uint16_t(738), uint16_t(968), uint16_t(1165), uint16_t(1518), uint16_t(859), uint16_t(1033)},
- [10]uint16_t{uint16_t(504), uint16_t(815), uint16_t(504), uint16_t(1139), uint16_t(1219), uint16_t(719), uint16_t(1506), uint16_t(1085), uint16_t(1268), uint16_t(1268)},
- [10]uint16_t{uint16_t(333), uint16_t(630), uint16_t(1445), uint16_t(1239), uint16_t(1883), uint16_t(3672), uint16_t(799), uint16_t(1548), uint16_t(1865), uint16_t(598)},
- [10]uint16_t{uint16_t(399), uint16_t(644), uint16_t(746), uint16_t(1342), uint16_t(1856), uint16_t(1350), uint16_t(1493), uint16_t(613), uint16_t(1855), uint16_t(1015)},
- [10]uint16_t{uint16_t(622), uint16_t(749), uint16_t(1205), uint16_t(608), uint16_t(1066), uint16_t(1408), uint16_t(1290), uint16_t(1406), uint16_t(546), uint16_t(971)},
- [10]uint16_t{uint16_t(500), uint16_t(753), uint16_t(1041), uint16_t(668), uint16_t(1230), uint16_t(1617), uint16_t(1297), uint16_t(1425), uint16_t(1383), uint16_t(523)}},
- [10][10]uint16_t{[10]uint16_t{uint16_t(394), uint16_t(553), uint16_t(523), uint16_t(1502), uint16_t(1536), uint16_t(981), uint16_t(1608), uint16_t(1142), uint16_t(1666), uint16_t(2181)},
- [10]uint16_t{uint16_t(655), uint16_t(430), uint16_t(375), uint16_t(1411), uint16_t(1861), uint16_t(1220), uint16_t(1677), uint16_t(1135), uint16_t(1978), uint16_t(1553)},
- [10]uint16_t{uint16_t(690), uint16_t(640), uint16_t(245), uint16_t(1954), uint16_t(2070), uint16_t(1194), uint16_t(1528), uint16_t(982), uint16_t(1972), uint16_t(2232)},
- [10]uint16_t{uint16_t(559), uint16_t(834), uint16_t(741), uint16_t(867), uint16_t(1131), uint16_t(980), uint16_t(1225), uint16_t(852), uint16_t(1092), uint16_t(784)},
- [10]uint16_t{uint16_t(690), uint16_t(875), uint16_t(516), uint16_t(959), uint16_t(673), uint16_t(894), uint16_t(1056), uint16_t(1190), uint16_t(1528), uint16_t(1126)},
- [10]uint16_t{uint16_t(740), uint16_t(951), uint16_t(384), uint16_t(1277), uint16_t(1177), uint16_t(492), uint16_t(1579), uint16_t(1155), uint16_t(1846), uint16_t(1513)},
- [10]uint16_t{uint16_t(323), uint16_t(775), uint16_t(1062), uint16_t(1776), uint16_t(3062), uint16_t(1274), uint16_t(813), uint16_t(1188), uint16_t(1372), uint16_t(655)},
- [10]uint16_t{uint16_t(488), uint16_t(971), uint16_t(484), uint16_t(1767), uint16_t(1515), uint16_t(1775), uint16_t(1115), uint16_t(503), uint16_t(1539), uint16_t(1461)},
- [10]uint16_t{uint16_t(740), uint16_t(1006), uint16_t(998), uint16_t(709), uint16_t(851), uint16_t(1230), uint16_t(1337), uint16_t(788), uint16_t(741), uint16_t(721)},
- [10]uint16_t{uint16_t(522), uint16_t(1073), uint16_t(573), uint16_t(1045), uint16_t(1346), uint16_t(887), uint16_t(1046), uint16_t(1146), uint16_t(1203), uint16_t(697)}},
- [10][10]uint16_t{[10]uint16_t{uint16_t(105), uint16_t(864), uint16_t(1442), uint16_t(1009), uint16_t(1934), uint16_t(1840), uint16_t(1519), uint16_t(1920), uint16_t(1673), uint16_t(1579)},
- [10]uint16_t{uint16_t(534), uint16_t(305), uint16_t(1193), uint16_t(683), uint16_t(1388), uint16_t(2164), uint16_t(1802), uint16_t(1894), uint16_t(1264), uint16_t(1170)},
- [10]uint16_t{uint16_t(305), uint16_t(518), uint16_t(877), uint16_t(1108), uint16_t(1426), uint16_t(3215), uint16_t(1425), uint16_t(1064), uint16_t(1320), uint16_t(1242)},
- [10]uint16_t{uint16_t(683), uint16_t(732), uint16_t(1927), uint16_t(257), uint16_t(1493), uint16_t(2048), uint16_t(1858), uint16_t(1552), uint16_t(1055), uint16_t(947)},
- [10]uint16_t{uint16_t(394), uint16_t(814), uint16_t(1024), uint16_t(660), uint16_t(959), uint16_t(1556), uint16_t(1282), uint16_t(1289), uint16_t(893), uint16_t(1047)},
- [10]uint16_t{uint16_t(528), uint16_t(615), uint16_t(996), uint16_t(940), uint16_t(1201), uint16_t(635), uint16_t(1094), uint16_t(2515), uint16_t(803), uint16_t(1358)},
- [10]uint16_t{uint16_t(347), uint16_t(614), uint16_t(1609), uint16_t(1187), uint16_t(3133), uint16_t(1345), uint16_t(1007), uint16_t(1339), uint16_t(1017), uint16_t(667)},
- [10]uint16_t{uint16_t(218), uint16_t(740), uint16_t(878), uint16_t(1605), uint16_t(3650), uint16_t(3650), uint16_t(1345), uint16_t(758), uint16_t(1357), uint16_t(1617)},
- [10]uint16_t{uint16_t(672), uint16_t(750), uint16_t(1541), uint16_t(558), uint16_t(1257), uint16_t(1599), uint16_t(1870), uint16_t(2135), uint16_t(402), uint16_t(1087)},
- [10]uint16_t{uint16_t(592), uint16_t(684), uint16_t(1161), uint16_t(430), uint16_t(1092), uint16_t(1497), uint16_t(1475), uint16_t(1489), uint16_t(1095), uint16_t(822)}},
- [10][10]uint16_t{[10]uint16_t{uint16_t(228), uint16_t(1056), uint16_t(1059), uint16_t(1368), uint16_t(752), uint16_t(982), uint16_t(1512), uint16_t(1518), uint16_t(987), uint16_t(1782)},
- [10]uint16_t{uint16_t(494), uint16_t(514), uint16_t(818), uint16_t(942), uint16_t(965), uint16_t(892), uint16_t(1610), uint16_t(1356), uint16_t(1048), uint16_t(1363)},
- [10]uint16_t{uint16_t(512), uint16_t(648), uint16_t(591), uint16_t(1042), uint16_t(761), uint16_t(991), uint16_t(1196), uint16_t(1454), uint16_t(1309), uint16_t(1463)},
- [10]uint16_t{uint16_t(683), uint16_t(749), uint16_t(1043), uint16_t(676), uint16_t(841), uint16_t(1396), uint16_t(1133), uint16_t(1138), uint16_t(654), uint16_t(939)},
- [10]uint16_t{uint16_t(622), uint16_t(1101), uint16_t(1126), uint16_t(994), uint16_t(361), uint16_t(1077), uint16_t(1203), uint16_t(1318), uint16_t(877), uint16_t(1219)},
- [10]uint16_t{uint16_t(631), uint16_t(1068), uint16_t(857), uint16_t(1650), uint16_t(651), uint16_t(477), uint16_t(1650), uint16_t(1419), uint16_t(828), uint16_t(1170)},
- [10]uint16_t{uint16_t(555), uint16_t(727), uint16_t(1068), uint16_t(1335), uint16_t(3127), uint16_t(1339), uint16_t(820), uint16_t(1331), uint16_t(1077), uint16_t(429)},
- [10]uint16_t{uint16_t(504), uint16_t(879), uint16_t(624), uint16_t(1398), uint16_t(889), uint16_t(889), uint16_t(1392), uint16_t(808), uint16_t(891), uint16_t(1406)},
- [10]uint16_t{uint16_t(683), uint16_t(1602), uint16_t(1289), uint16_t(977), uint16_t(578), uint16_t(983), uint16_t(1280), uint16_t(1708), uint16_t(406), uint16_t(1122)},
- [10]uint16_t{uint16_t(399), uint16_t(865), uint16_t(1433), uint16_t(1070), uint16_t(1072), uint16_t(764), uint16_t(968), uint16_t(1477), uint16_t(1223), uint16_t(678)}},
- [10][10]uint16_t{[10]uint16_t{uint16_t(333), uint16_t(760), uint16_t(935), uint16_t(1638), uint16_t(1010), uint16_t(529), uint16_t(1646), uint16_t(1410), uint16_t(1472), uint16_t(2219)},
- [10]uint16_t{uint16_t(512), uint16_t(494), uint16_t(750), uint16_t(1160), uint16_t(1215), uint16_t(610), uint16_t(1870), uint16_t(1868), uint16_t(1628), uint16_t(1169)},
- [10]uint16_t{uint16_t(572), uint16_t(646), uint16_t(492), uint16_t(1934), uint16_t(1208), uint16_t(603), uint16_t(1580), uint16_t(1099), uint16_t(1398), uint16_t(1995)},
- [10]uint16_t{uint16_t(786), uint16_t(789), uint16_t(942), uint16_t(581), uint16_t(1018), uint16_t(951), uint16_t(1599), uint16_t(1207), uint16_t(731), uint16_t(768)},
- [10]uint16_t{uint16_t(690), uint16_t(1015), uint16_t(672), uint16_t(1078), uint16_t(582), uint16_t(504), uint16_t(1693), uint16_t(1438), uint16_t(1108), uint16_t(2897)},
- [10]uint16_t{uint16_t(768), uint16_t(1267), uint16_t(571), uint16_t(2005), uint16_t(1243), uint16_t(244), uint16_t(2881), uint16_t(1380), uint16_t(1786), uint16_t(1453)},
- [10]uint16_t{uint16_t(452), uint16_t(899), uint16_t(1293), uint16_t(903), uint16_t(1311), uint16_t(3100), uint16_t(465), uint16_t(1311), uint16_t(1319), uint16_t(813)},
- [10]uint16_t{uint16_t(394), uint16_t(927), uint16_t(942), uint16_t(1103), uint16_t(1358), uint16_t(1104), uint16_t(946), uint16_t(593), uint16_t(1363), uint16_t(1109)},
- [10]uint16_t{uint16_t(559), uint16_t(1005), uint16_t(1007), uint16_t(1016), uint16_t(658), uint16_t(1173), uint16_t(1021), uint16_t(1164), uint16_t(623), uint16_t(1028)},
- [10]uint16_t{uint16_t(564), uint16_t(796), uint16_t(632), uint16_t(1005), uint16_t(1014), uint16_t(863), uint16_t(2316), uint16_t(1268), uint16_t(938), uint16_t(764)}},
- [10][10]uint16_t{[10]uint16_t{uint16_t(266), uint16_t(606), uint16_t(1098), uint16_t(1228), uint16_t(1497), uint16_t(1243), uint16_t(948), uint16_t(1030), uint16_t(1734), uint16_t(1461)},
- [10]uint16_t{uint16_t(366), uint16_t(585), uint16_t(901), uint16_t(1060), uint16_t(1407), uint16_t(1247), uint16_t(876), uint16_t(1134), uint16_t(1620), uint16_t(1054)},
- [10]uint16_t{uint16_t(452), uint16_t(565), uint16_t(542), uint16_t(1729), uint16_t(1479), uint16_t(1479), uint16_t(1016), uint16_t(886), uint16_t(2938), uint16_t(1150)},
- [10]uint16_t{uint16_t(555), uint16_t(1088), uint16_t(1533), uint16_t(950), uint16_t(1354), uint16_t(895), uint16_t(834), uint16_t(1019), uint16_t(1021), uint16_t(496)},
- [10]uint16_t{uint16_t(704), uint16_t(815), uint16_t(1193), uint16_t(971), uint16_t(973), uint16_t(640), uint16_t(1217), uint16_t(2214), uint16_t(832), uint16_t(578)},
- [10]uint16_t{uint16_t(672), uint16_t(1245), uint16_t(579), uint16_t(871), uint16_t(875), uint16_t(774), uint16_t(872), uint16_t(1273), uint16_t(1027), uint16_t(949)},
- [10]uint16_t{uint16_t(296), uint16_t(1134), uint16_t(2050), uint16_t(1784), uint16_t(1636), uint16_t(3425), uint16_t(442), uint16_t(1550), uint16_t(2076), uint16_t(722)},
- [10]uint16_t{uint16_t(342), uint16_t(982), uint16_t(1259), uint16_t(1846), uint16_t(1848), uint16_t(1848), uint16_t(622), uint16_t(568), uint16_t(1847), uint16_t(1052)},
- [10]uint16_t{uint16_t(555), uint16_t(1064), uint16_t(1304), uint16_t(828), uint16_t(746), uint16_t(1343), uint16_t(1075), uint16_t(1329), uint16_t(1078), uint16_t(494)},
- [10]uint16_t{uint16_t(288), uint16_t(1167), uint16_t(1285), uint16_t(1174), uint16_t(1639), uint16_t(1639), uint16_t(833), uint16_t(2254), uint16_t(1304), uint16_t(509)}},
- [10][10]uint16_t{[10]uint16_t{uint16_t(342), uint16_t(719), uint16_t(767), uint16_t(1866), uint16_t(1757), uint16_t(1270), uint16_t(1246), uint16_t(550), uint16_t(1746), uint16_t(2151)},
- [10]uint16_t{uint16_t(483), uint16_t(653), uint16_t(694), uint16_t(1509), uint16_t(1459), uint16_t(1410), uint16_t(1218), uint16_t(507), uint16_t(1914), uint16_t(1266)},
- [10]uint16_t{uint16_t(488), uint16_t(757), uint16_t(447), uint16_t(2979), uint16_t(1813), uint16_t(1268), uint16_t(1654), uint16_t(539), uint16_t(1849), uint16_t(2109)},
- [10]uint16_t{uint16_t(522), uint16_t(1097), uint16_t(1085), uint16_t(851), uint16_t(1365), uint16_t(1111), uint16_t(851), uint16_t(901), uint16_t(961), uint16_t(605)},
- [10]uint16_t{uint16_t(709), uint16_t(716), uint16_t(841), uint16_t(728), uint16_t(736), uint16_t(945), uint16_t(941), uint16_t(862), uint16_t(2845), uint16_t(1057)},
- [10]uint16_t{uint16_t(512), uint16_t(1323), uint16_t(500), uint16_t(1336), uint16_t(1083), uint16_t(681), uint16_t(1342), uint16_t(717), uint16_t(1604), uint16_t(1350)},
- [10]uint16_t{uint16_t(452), uint16_t(1155), uint16_t(1372), uint16_t(1900), uint16_t(1501), uint16_t(3290), uint16_t(311), uint16_t(944), uint16_t(1919), uint16_t(922)},
- [10]uint16_t{uint16_t(403), uint16_t(1520), uint16_t(977), uint16_t(2132), uint16_t(1733), uint16_t(3522), uint16_t(1076), uint16_t(276), uint16_t(3335), uint16_t(1547)},
- [10]uint16_t{uint16_t(559), uint16_t(1374), uint16_t(1101), uint16_t(615), uint16_t(673), uint16_t(2462), uint16_t(974), uint16_t(795), uint16_t(984), uint16_t(984)},
- [10]uint16_t{uint16_t(547), uint16_t(1122), uint16_t(1062), uint16_t(812), uint16_t(1410), uint16_t(951), uint16_t(1140), uint16_t(622), uint16_t(1268), uint16_t(651)}},
- [10][10]uint16_t{[10]uint16_t{uint16_t(165), uint16_t(982), uint16_t(1235), uint16_t(938), uint16_t(1334), uint16_t(1366), uint16_t(1659), uint16_t(1578), uint16_t(964), uint16_t(1612)},
- [10]uint16_t{uint16_t(592), uint16_t(422), uint16_t(925), uint16_t(847), uint16_t(1139), uint16_t(1112), uint16_t(1387), uint16_t(2036), uint16_t(861), uint16_t(1041)},
- [10]uint16_t{uint16_t(403), uint16_t(837), uint16_t(732), uint16_t(770), uint16_t(941), uint16_t(1658), uint16_t(1250), uint16_t(809), uint16_t(1407), uint16_t(1407)},
- [10]uint16_t{uint16_t(896), uint16_t(874), uint16_t(1071), uint16_t(381), uint16_t(1568), uint16_t(1722), uint16_t(1437), uint16_t(2192), uint16_t(480), uint16_t(1035)},
- [10]uint16_t{uint16_t(640), uint16_t(1098), uint16_t(1012), uint16_t(1032), uint16_t(684), uint16_t(1382), uint16_t(1581), uint16_t(2106), uint16_t(416), uint16_t(865)},
- [10]uint16_t{uint16_t(559), uint16_t(1005), uint16_t(819), uint16_t(914), uint16_t(710), uint16_t(770), uint16_t(1418), uint16_t(920), uint16_t(838), uint16_t(1435)},
- [10]uint16_t{uint16_t(415), uint16_t(1258), uint16_t(1245), uint16_t(870), uint16_t(1278), uint16_t(3067), uint16_t(770), uint16_t(1021), uint16_t(1287), uint16_t(522)},
- [10]uint16_t{uint16_t(406), uint16_t(990), uint16_t(601), uint16_t(1009), uint16_t(1265), uint16_t(1265), uint16_t(1267), uint16_t(759), uint16_t(1017), uint16_t(1277)},
- [10]uint16_t{uint16_t(968), uint16_t(1182), uint16_t(1329), uint16_t(788), uint16_t(1032), uint16_t(1292), uint16_t(1705), uint16_t(1714), uint16_t(203), uint16_t(1403)},
- [10]uint16_t{uint16_t(732), uint16_t(877), uint16_t(1279), uint16_t(471), uint16_t(901), uint16_t(1161), uint16_t(1545), uint16_t(1294), uint16_t(755), uint16_t(755)}},
- [10][10]uint16_t{[10]uint16_t{uint16_t(111), uint16_t(931), uint16_t(1378), uint16_t(1185), uint16_t(1933), uint16_t(1648), uint16_t(1148), uint16_t(1714), uint16_t(1873), uint16_t(1307)},
- [10]uint16_t{uint16_t(406), uint16_t(414), uint16_t(1030), uint16_t(1023), uint16_t(1910), uint16_t(1404), uint16_t(1313), uint16_t(1647), uint16_t(1509), uint16_t(793)},
- [10]uint16_t{uint16_t(342), uint16_t(640), uint16_t(575), uint16_t(1088), uint16_t(1241), uint16_t(1349), uint16_t(1161), uint16_t(1350), uint16_t(1756), uint16_t(1502)},
- [10]uint16_t{uint16_t(559), uint16_t(766), uint16_t(1185), uint16_t(357), uint16_t(1682), uint16_t(1428), uint16_t(1329), uint16_t(1897), uint16_t(1219), uint16_t(802)},
- [10]uint16_t{uint16_t(473), uint16_t(909), uint16_t(1164), uint16_t(771), uint16_t(719), uint16_t(2508), uint16_t(1427), uint16_t(1432), uint16_t(722), uint16_t(782)},
- [10]uint16_t{uint16_t(342), uint16_t(892), uint16_t(785), uint16_t(1145), uint16_t(1150), uint16_t(794), uint16_t(1296), uint16_t(1550), uint16_t(973), uint16_t(1057)},
- [10]uint16_t{uint16_t(208), uint16_t(1036), uint16_t(1326), uint16_t(1343), uint16_t(1606), uint16_t(3395), uint16_t(815), uint16_t(1455), uint16_t(1618), uint16_t(712)},
- [10]uint16_t{uint16_t(228), uint16_t(928), uint16_t(890), uint16_t(1046), uint16_t(3499), uint16_t(1711), uint16_t(994), uint16_t(829), uint16_t(1720), uint16_t(1318)},
- [10]uint16_t{uint16_t(768), uint16_t(724), uint16_t(1058), uint16_t(636), uint16_t(991), uint16_t(1075), uint16_t(1319), uint16_t(1324), uint16_t(616), uint16_t(825)},
- [10]uint16_t{uint16_t(305), uint16_t(1167), uint16_t(1358), uint16_t(899), uint16_t(1587), uint16_t(1587), uint16_t(987), uint16_t(1988), uint16_t(1332), uint16_t(501)}}} /* cost_enc.c:100:16 */
+var VP8FixedCostsI4 = [10][10][10]uint16_t{{
+ {uint16_t(40), uint16_t(1151), uint16_t(1723), uint16_t(1874), uint16_t(2103), uint16_t(2019), uint16_t(1628), uint16_t(1777), uint16_t(2226), uint16_t(2137)},
+ {uint16_t(192), uint16_t(469), uint16_t(1296), uint16_t(1308), uint16_t(1849), uint16_t(1794), uint16_t(1781), uint16_t(1703), uint16_t(1713), uint16_t(1522)},
+ {uint16_t(142), uint16_t(910), uint16_t(762), uint16_t(1684), uint16_t(1849), uint16_t(1576), uint16_t(1460), uint16_t(1305), uint16_t(1801), uint16_t(1657)},
+ {uint16_t(559), uint16_t(641), uint16_t(1370), uint16_t(421), uint16_t(1182), uint16_t(1569), uint16_t(1612), uint16_t(1725), uint16_t(863), uint16_t(1007)},
+ {uint16_t(299), uint16_t(1059), uint16_t(1256), uint16_t(1108), uint16_t(636), uint16_t(1068), uint16_t(1581), uint16_t(1883), uint16_t(869), uint16_t(1142)},
+ {uint16_t(277), uint16_t(1111), uint16_t(707), uint16_t(1362), uint16_t(1089), uint16_t(672), uint16_t(1603), uint16_t(1541), uint16_t(1545), uint16_t(1291)},
+ {uint16_t(214), uint16_t(781), uint16_t(1609), uint16_t(1303), uint16_t(1632), uint16_t(2229), uint16_t(726), uint16_t(1560), uint16_t(1713), uint16_t(918)},
+ {uint16_t(152), uint16_t(1037), uint16_t(1046), uint16_t(1759), uint16_t(1983), uint16_t(2174), uint16_t(1358), uint16_t(742), uint16_t(1740), uint16_t(1390)},
+ {uint16_t(512), uint16_t(1046), uint16_t(1420), uint16_t(753), uint16_t(752), uint16_t(1297), uint16_t(1486), uint16_t(1613), uint16_t(460), uint16_t(1207)},
+ {uint16_t(424), uint16_t(827), uint16_t(1362), uint16_t(719), uint16_t(1462), uint16_t(1202), uint16_t(1199), uint16_t(1476), uint16_t(1199), uint16_t(538)}},
+ {{uint16_t(240), uint16_t(402), uint16_t(1134), uint16_t(1491), uint16_t(1659), uint16_t(1505), uint16_t(1517), uint16_t(1555), uint16_t(1979), uint16_t(2099)},
+ {uint16_t(467), uint16_t(242), uint16_t(960), uint16_t(1232), uint16_t(1714), uint16_t(1620), uint16_t(1834), uint16_t(1570), uint16_t(1676), uint16_t(1391)},
+ {uint16_t(500), uint16_t(455), uint16_t(463), uint16_t(1507), uint16_t(1699), uint16_t(1282), uint16_t(1564), uint16_t(982), uint16_t(2114), uint16_t(2114)},
+ {uint16_t(672), uint16_t(643), uint16_t(1372), uint16_t(331), uint16_t(1589), uint16_t(1667), uint16_t(1453), uint16_t(1938), uint16_t(996), uint16_t(876)},
+ {uint16_t(458), uint16_t(783), uint16_t(1037), uint16_t(911), uint16_t(738), uint16_t(968), uint16_t(1165), uint16_t(1518), uint16_t(859), uint16_t(1033)},
+ {uint16_t(504), uint16_t(815), uint16_t(504), uint16_t(1139), uint16_t(1219), uint16_t(719), uint16_t(1506), uint16_t(1085), uint16_t(1268), uint16_t(1268)},
+ {uint16_t(333), uint16_t(630), uint16_t(1445), uint16_t(1239), uint16_t(1883), uint16_t(3672), uint16_t(799), uint16_t(1548), uint16_t(1865), uint16_t(598)},
+ {uint16_t(399), uint16_t(644), uint16_t(746), uint16_t(1342), uint16_t(1856), uint16_t(1350), uint16_t(1493), uint16_t(613), uint16_t(1855), uint16_t(1015)},
+ {uint16_t(622), uint16_t(749), uint16_t(1205), uint16_t(608), uint16_t(1066), uint16_t(1408), uint16_t(1290), uint16_t(1406), uint16_t(546), uint16_t(971)},
+ {uint16_t(500), uint16_t(753), uint16_t(1041), uint16_t(668), uint16_t(1230), uint16_t(1617), uint16_t(1297), uint16_t(1425), uint16_t(1383), uint16_t(523)}},
+ {{uint16_t(394), uint16_t(553), uint16_t(523), uint16_t(1502), uint16_t(1536), uint16_t(981), uint16_t(1608), uint16_t(1142), uint16_t(1666), uint16_t(2181)},
+ {uint16_t(655), uint16_t(430), uint16_t(375), uint16_t(1411), uint16_t(1861), uint16_t(1220), uint16_t(1677), uint16_t(1135), uint16_t(1978), uint16_t(1553)},
+ {uint16_t(690), uint16_t(640), uint16_t(245), uint16_t(1954), uint16_t(2070), uint16_t(1194), uint16_t(1528), uint16_t(982), uint16_t(1972), uint16_t(2232)},
+ {uint16_t(559), uint16_t(834), uint16_t(741), uint16_t(867), uint16_t(1131), uint16_t(980), uint16_t(1225), uint16_t(852), uint16_t(1092), uint16_t(784)},
+ {uint16_t(690), uint16_t(875), uint16_t(516), uint16_t(959), uint16_t(673), uint16_t(894), uint16_t(1056), uint16_t(1190), uint16_t(1528), uint16_t(1126)},
+ {uint16_t(740), uint16_t(951), uint16_t(384), uint16_t(1277), uint16_t(1177), uint16_t(492), uint16_t(1579), uint16_t(1155), uint16_t(1846), uint16_t(1513)},
+ {uint16_t(323), uint16_t(775), uint16_t(1062), uint16_t(1776), uint16_t(3062), uint16_t(1274), uint16_t(813), uint16_t(1188), uint16_t(1372), uint16_t(655)},
+ {uint16_t(488), uint16_t(971), uint16_t(484), uint16_t(1767), uint16_t(1515), uint16_t(1775), uint16_t(1115), uint16_t(503), uint16_t(1539), uint16_t(1461)},
+ {uint16_t(740), uint16_t(1006), uint16_t(998), uint16_t(709), uint16_t(851), uint16_t(1230), uint16_t(1337), uint16_t(788), uint16_t(741), uint16_t(721)},
+ {uint16_t(522), uint16_t(1073), uint16_t(573), uint16_t(1045), uint16_t(1346), uint16_t(887), uint16_t(1046), uint16_t(1146), uint16_t(1203), uint16_t(697)}},
+ {{uint16_t(105), uint16_t(864), uint16_t(1442), uint16_t(1009), uint16_t(1934), uint16_t(1840), uint16_t(1519), uint16_t(1920), uint16_t(1673), uint16_t(1579)},
+ {uint16_t(534), uint16_t(305), uint16_t(1193), uint16_t(683), uint16_t(1388), uint16_t(2164), uint16_t(1802), uint16_t(1894), uint16_t(1264), uint16_t(1170)},
+ {uint16_t(305), uint16_t(518), uint16_t(877), uint16_t(1108), uint16_t(1426), uint16_t(3215), uint16_t(1425), uint16_t(1064), uint16_t(1320), uint16_t(1242)},
+ {uint16_t(683), uint16_t(732), uint16_t(1927), uint16_t(257), uint16_t(1493), uint16_t(2048), uint16_t(1858), uint16_t(1552), uint16_t(1055), uint16_t(947)},
+ {uint16_t(394), uint16_t(814), uint16_t(1024), uint16_t(660), uint16_t(959), uint16_t(1556), uint16_t(1282), uint16_t(1289), uint16_t(893), uint16_t(1047)},
+ {uint16_t(528), uint16_t(615), uint16_t(996), uint16_t(940), uint16_t(1201), uint16_t(635), uint16_t(1094), uint16_t(2515), uint16_t(803), uint16_t(1358)},
+ {uint16_t(347), uint16_t(614), uint16_t(1609), uint16_t(1187), uint16_t(3133), uint16_t(1345), uint16_t(1007), uint16_t(1339), uint16_t(1017), uint16_t(667)},
+ {uint16_t(218), uint16_t(740), uint16_t(878), uint16_t(1605), uint16_t(3650), uint16_t(3650), uint16_t(1345), uint16_t(758), uint16_t(1357), uint16_t(1617)},
+ {uint16_t(672), uint16_t(750), uint16_t(1541), uint16_t(558), uint16_t(1257), uint16_t(1599), uint16_t(1870), uint16_t(2135), uint16_t(402), uint16_t(1087)},
+ {uint16_t(592), uint16_t(684), uint16_t(1161), uint16_t(430), uint16_t(1092), uint16_t(1497), uint16_t(1475), uint16_t(1489), uint16_t(1095), uint16_t(822)}},
+ {{uint16_t(228), uint16_t(1056), uint16_t(1059), uint16_t(1368), uint16_t(752), uint16_t(982), uint16_t(1512), uint16_t(1518), uint16_t(987), uint16_t(1782)},
+ {uint16_t(494), uint16_t(514), uint16_t(818), uint16_t(942), uint16_t(965), uint16_t(892), uint16_t(1610), uint16_t(1356), uint16_t(1048), uint16_t(1363)},
+ {uint16_t(512), uint16_t(648), uint16_t(591), uint16_t(1042), uint16_t(761), uint16_t(991), uint16_t(1196), uint16_t(1454), uint16_t(1309), uint16_t(1463)},
+ {uint16_t(683), uint16_t(749), uint16_t(1043), uint16_t(676), uint16_t(841), uint16_t(1396), uint16_t(1133), uint16_t(1138), uint16_t(654), uint16_t(939)},
+ {uint16_t(622), uint16_t(1101), uint16_t(1126), uint16_t(994), uint16_t(361), uint16_t(1077), uint16_t(1203), uint16_t(1318), uint16_t(877), uint16_t(1219)},
+ {uint16_t(631), uint16_t(1068), uint16_t(857), uint16_t(1650), uint16_t(651), uint16_t(477), uint16_t(1650), uint16_t(1419), uint16_t(828), uint16_t(1170)},
+ {uint16_t(555), uint16_t(727), uint16_t(1068), uint16_t(1335), uint16_t(3127), uint16_t(1339), uint16_t(820), uint16_t(1331), uint16_t(1077), uint16_t(429)},
+ {uint16_t(504), uint16_t(879), uint16_t(624), uint16_t(1398), uint16_t(889), uint16_t(889), uint16_t(1392), uint16_t(808), uint16_t(891), uint16_t(1406)},
+ {uint16_t(683), uint16_t(1602), uint16_t(1289), uint16_t(977), uint16_t(578), uint16_t(983), uint16_t(1280), uint16_t(1708), uint16_t(406), uint16_t(1122)},
+ {uint16_t(399), uint16_t(865), uint16_t(1433), uint16_t(1070), uint16_t(1072), uint16_t(764), uint16_t(968), uint16_t(1477), uint16_t(1223), uint16_t(678)}},
+ {{uint16_t(333), uint16_t(760), uint16_t(935), uint16_t(1638), uint16_t(1010), uint16_t(529), uint16_t(1646), uint16_t(1410), uint16_t(1472), uint16_t(2219)},
+ {uint16_t(512), uint16_t(494), uint16_t(750), uint16_t(1160), uint16_t(1215), uint16_t(610), uint16_t(1870), uint16_t(1868), uint16_t(1628), uint16_t(1169)},
+ {uint16_t(572), uint16_t(646), uint16_t(492), uint16_t(1934), uint16_t(1208), uint16_t(603), uint16_t(1580), uint16_t(1099), uint16_t(1398), uint16_t(1995)},
+ {uint16_t(786), uint16_t(789), uint16_t(942), uint16_t(581), uint16_t(1018), uint16_t(951), uint16_t(1599), uint16_t(1207), uint16_t(731), uint16_t(768)},
+ {uint16_t(690), uint16_t(1015), uint16_t(672), uint16_t(1078), uint16_t(582), uint16_t(504), uint16_t(1693), uint16_t(1438), uint16_t(1108), uint16_t(2897)},
+ {uint16_t(768), uint16_t(1267), uint16_t(571), uint16_t(2005), uint16_t(1243), uint16_t(244), uint16_t(2881), uint16_t(1380), uint16_t(1786), uint16_t(1453)},
+ {uint16_t(452), uint16_t(899), uint16_t(1293), uint16_t(903), uint16_t(1311), uint16_t(3100), uint16_t(465), uint16_t(1311), uint16_t(1319), uint16_t(813)},
+ {uint16_t(394), uint16_t(927), uint16_t(942), uint16_t(1103), uint16_t(1358), uint16_t(1104), uint16_t(946), uint16_t(593), uint16_t(1363), uint16_t(1109)},
+ {uint16_t(559), uint16_t(1005), uint16_t(1007), uint16_t(1016), uint16_t(658), uint16_t(1173), uint16_t(1021), uint16_t(1164), uint16_t(623), uint16_t(1028)},
+ {uint16_t(564), uint16_t(796), uint16_t(632), uint16_t(1005), uint16_t(1014), uint16_t(863), uint16_t(2316), uint16_t(1268), uint16_t(938), uint16_t(764)}},
+ {{uint16_t(266), uint16_t(606), uint16_t(1098), uint16_t(1228), uint16_t(1497), uint16_t(1243), uint16_t(948), uint16_t(1030), uint16_t(1734), uint16_t(1461)},
+ {uint16_t(366), uint16_t(585), uint16_t(901), uint16_t(1060), uint16_t(1407), uint16_t(1247), uint16_t(876), uint16_t(1134), uint16_t(1620), uint16_t(1054)},
+ {uint16_t(452), uint16_t(565), uint16_t(542), uint16_t(1729), uint16_t(1479), uint16_t(1479), uint16_t(1016), uint16_t(886), uint16_t(2938), uint16_t(1150)},
+ {uint16_t(555), uint16_t(1088), uint16_t(1533), uint16_t(950), uint16_t(1354), uint16_t(895), uint16_t(834), uint16_t(1019), uint16_t(1021), uint16_t(496)},
+ {uint16_t(704), uint16_t(815), uint16_t(1193), uint16_t(971), uint16_t(973), uint16_t(640), uint16_t(1217), uint16_t(2214), uint16_t(832), uint16_t(578)},
+ {uint16_t(672), uint16_t(1245), uint16_t(579), uint16_t(871), uint16_t(875), uint16_t(774), uint16_t(872), uint16_t(1273), uint16_t(1027), uint16_t(949)},
+ {uint16_t(296), uint16_t(1134), uint16_t(2050), uint16_t(1784), uint16_t(1636), uint16_t(3425), uint16_t(442), uint16_t(1550), uint16_t(2076), uint16_t(722)},
+ {uint16_t(342), uint16_t(982), uint16_t(1259), uint16_t(1846), uint16_t(1848), uint16_t(1848), uint16_t(622), uint16_t(568), uint16_t(1847), uint16_t(1052)},
+ {uint16_t(555), uint16_t(1064), uint16_t(1304), uint16_t(828), uint16_t(746), uint16_t(1343), uint16_t(1075), uint16_t(1329), uint16_t(1078), uint16_t(494)},
+ {uint16_t(288), uint16_t(1167), uint16_t(1285), uint16_t(1174), uint16_t(1639), uint16_t(1639), uint16_t(833), uint16_t(2254), uint16_t(1304), uint16_t(509)}},
+ {{uint16_t(342), uint16_t(719), uint16_t(767), uint16_t(1866), uint16_t(1757), uint16_t(1270), uint16_t(1246), uint16_t(550), uint16_t(1746), uint16_t(2151)},
+ {uint16_t(483), uint16_t(653), uint16_t(694), uint16_t(1509), uint16_t(1459), uint16_t(1410), uint16_t(1218), uint16_t(507), uint16_t(1914), uint16_t(1266)},
+ {uint16_t(488), uint16_t(757), uint16_t(447), uint16_t(2979), uint16_t(1813), uint16_t(1268), uint16_t(1654), uint16_t(539), uint16_t(1849), uint16_t(2109)},
+ {uint16_t(522), uint16_t(1097), uint16_t(1085), uint16_t(851), uint16_t(1365), uint16_t(1111), uint16_t(851), uint16_t(901), uint16_t(961), uint16_t(605)},
+ {uint16_t(709), uint16_t(716), uint16_t(841), uint16_t(728), uint16_t(736), uint16_t(945), uint16_t(941), uint16_t(862), uint16_t(2845), uint16_t(1057)},
+ {uint16_t(512), uint16_t(1323), uint16_t(500), uint16_t(1336), uint16_t(1083), uint16_t(681), uint16_t(1342), uint16_t(717), uint16_t(1604), uint16_t(1350)},
+ {uint16_t(452), uint16_t(1155), uint16_t(1372), uint16_t(1900), uint16_t(1501), uint16_t(3290), uint16_t(311), uint16_t(944), uint16_t(1919), uint16_t(922)},
+ {uint16_t(403), uint16_t(1520), uint16_t(977), uint16_t(2132), uint16_t(1733), uint16_t(3522), uint16_t(1076), uint16_t(276), uint16_t(3335), uint16_t(1547)},
+ {uint16_t(559), uint16_t(1374), uint16_t(1101), uint16_t(615), uint16_t(673), uint16_t(2462), uint16_t(974), uint16_t(795), uint16_t(984), uint16_t(984)},
+ {uint16_t(547), uint16_t(1122), uint16_t(1062), uint16_t(812), uint16_t(1410), uint16_t(951), uint16_t(1140), uint16_t(622), uint16_t(1268), uint16_t(651)}},
+ {{uint16_t(165), uint16_t(982), uint16_t(1235), uint16_t(938), uint16_t(1334), uint16_t(1366), uint16_t(1659), uint16_t(1578), uint16_t(964), uint16_t(1612)},
+ {uint16_t(592), uint16_t(422), uint16_t(925), uint16_t(847), uint16_t(1139), uint16_t(1112), uint16_t(1387), uint16_t(2036), uint16_t(861), uint16_t(1041)},
+ {uint16_t(403), uint16_t(837), uint16_t(732), uint16_t(770), uint16_t(941), uint16_t(1658), uint16_t(1250), uint16_t(809), uint16_t(1407), uint16_t(1407)},
+ {uint16_t(896), uint16_t(874), uint16_t(1071), uint16_t(381), uint16_t(1568), uint16_t(1722), uint16_t(1437), uint16_t(2192), uint16_t(480), uint16_t(1035)},
+ {uint16_t(640), uint16_t(1098), uint16_t(1012), uint16_t(1032), uint16_t(684), uint16_t(1382), uint16_t(1581), uint16_t(2106), uint16_t(416), uint16_t(865)},
+ {uint16_t(559), uint16_t(1005), uint16_t(819), uint16_t(914), uint16_t(710), uint16_t(770), uint16_t(1418), uint16_t(920), uint16_t(838), uint16_t(1435)},
+ {uint16_t(415), uint16_t(1258), uint16_t(1245), uint16_t(870), uint16_t(1278), uint16_t(3067), uint16_t(770), uint16_t(1021), uint16_t(1287), uint16_t(522)},
+ {uint16_t(406), uint16_t(990), uint16_t(601), uint16_t(1009), uint16_t(1265), uint16_t(1265), uint16_t(1267), uint16_t(759), uint16_t(1017), uint16_t(1277)},
+ {uint16_t(968), uint16_t(1182), uint16_t(1329), uint16_t(788), uint16_t(1032), uint16_t(1292), uint16_t(1705), uint16_t(1714), uint16_t(203), uint16_t(1403)},
+ {uint16_t(732), uint16_t(877), uint16_t(1279), uint16_t(471), uint16_t(901), uint16_t(1161), uint16_t(1545), uint16_t(1294), uint16_t(755), uint16_t(755)}},
+ {{uint16_t(111), uint16_t(931), uint16_t(1378), uint16_t(1185), uint16_t(1933), uint16_t(1648), uint16_t(1148), uint16_t(1714), uint16_t(1873), uint16_t(1307)},
+ {uint16_t(406), uint16_t(414), uint16_t(1030), uint16_t(1023), uint16_t(1910), uint16_t(1404), uint16_t(1313), uint16_t(1647), uint16_t(1509), uint16_t(793)},
+ {uint16_t(342), uint16_t(640), uint16_t(575), uint16_t(1088), uint16_t(1241), uint16_t(1349), uint16_t(1161), uint16_t(1350), uint16_t(1756), uint16_t(1502)},
+ {uint16_t(559), uint16_t(766), uint16_t(1185), uint16_t(357), uint16_t(1682), uint16_t(1428), uint16_t(1329), uint16_t(1897), uint16_t(1219), uint16_t(802)},
+ {uint16_t(473), uint16_t(909), uint16_t(1164), uint16_t(771), uint16_t(719), uint16_t(2508), uint16_t(1427), uint16_t(1432), uint16_t(722), uint16_t(782)},
+ {uint16_t(342), uint16_t(892), uint16_t(785), uint16_t(1145), uint16_t(1150), uint16_t(794), uint16_t(1296), uint16_t(1550), uint16_t(973), uint16_t(1057)},
+ {uint16_t(208), uint16_t(1036), uint16_t(1326), uint16_t(1343), uint16_t(1606), uint16_t(3395), uint16_t(815), uint16_t(1455), uint16_t(1618), uint16_t(712)},
+ {uint16_t(228), uint16_t(928), uint16_t(890), uint16_t(1046), uint16_t(3499), uint16_t(1711), uint16_t(994), uint16_t(829), uint16_t(1720), uint16_t(1318)},
+ {uint16_t(768), uint16_t(724), uint16_t(1058), uint16_t(636), uint16_t(991), uint16_t(1075), uint16_t(1319), uint16_t(1324), uint16_t(616), uint16_t(825)},
+ {uint16_t(305), uint16_t(1167), uint16_t(1358), uint16_t(899), uint16_t(1587), uint16_t(1587), uint16_t(987), uint16_t(1988), uint16_t(1332), uint16_t(501)}}} /* cost_enc.c:100:16 */
//------------------------------------------------------------------------------
// helper functions for residuals struct VP8Residual.
func VP8InitResidual(tls *libc.TLS, first int32, coeff_type int32, enc uintptr, res uintptr) { /* cost_enc.c:206:6: */
(*VP8Residual)(unsafe.Pointer(res)).coeff_type = coeff_type
- (*VP8Residual)(unsafe.Pointer(res)).prob = (((enc + 3616 /* &.proba_ */) + 4 /* &.coeffs_ */) + uintptr(coeff_type)*264)
- (*VP8Residual)(unsafe.Pointer(res)).stats = (((enc + 3616 /* &.proba_ */) + 1060 /* &.stats_ */) + uintptr(coeff_type)*1056)
- (*VP8Residual)(unsafe.Pointer(res)).costs = (((enc + 3616 /* &.proba_ */) + 18344 /* &.remapped_costs_ */) + uintptr(coeff_type)*384)
+ (*VP8Residual)(unsafe.Pointer(res)).prob = enc + 3616 + 4 + uintptr(coeff_type)*264
+ (*VP8Residual)(unsafe.Pointer(res)).stats = enc + 3616 + 1060 + uintptr(coeff_type)*1056
+ (*VP8Residual)(unsafe.Pointer(res)).costs = enc + 3616 + 18344 + uintptr(coeff_type)*384
(*VP8Residual)(unsafe.Pointer(res)).first = first
}
@@ -25654,22 +25367,22 @@ func VP8GetCostLuma4(tls *libc.TLS, it uintptr, levels uintptr) int32 { /* cost_
bp := tls.Alloc(48)
defer tls.Free(48)
- var x int32 = ((*VP8EncIterator)(unsafe.Pointer(it)).i4_ & 3)
- var y int32 = ((*VP8EncIterator)(unsafe.Pointer(it)).i4_ >> 2)
+ var x int32 = (*VP8EncIterator)(unsafe.Pointer(it)).i4_ & 3
+ var y int32 = (*VP8EncIterator)(unsafe.Pointer(it)).i4_ >> 2
// var res VP8Residual at bp, 48
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
var R int32 = 0
var ctx int32
- VP8InitResidual(tls, 0, 3, enc, (bp) /* &res */)
- ctx = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(y)*4)))
+ VP8InitResidual(tls, 0, 3, enc, bp)
+ ctx = *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(y)*4))
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, levels, (bp) /* &res */)
- R = R + ((*struct {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, levels, bp /* &res */)
+ R = R + (*struct {
f func(*libc.TLS, int32, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})).f(tls, ctx, (bp) /* &res */))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})).f(tls, ctx, bp)
return R
}
@@ -25687,26 +25400,26 @@ func VP8GetCostLuma16(tls *libc.TLS, it uintptr, rd uintptr) int32 { /* cost_enc
VP8IteratorNzToBytes(tls, it) // re-import the non-zero context
// DC
- VP8InitResidual(tls, 0, 1, enc, (bp) /* &res */)
+ VP8InitResidual(tls, 0, 1, enc, bp)
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, (rd + 40 /* &.y_dc_levels */), (bp) /* &res */)
- R = R + ((*struct {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+40 /* &.y_dc_levels */, bp /* &res */)
+ R = R + (*struct {
f func(*libc.TLS, int32, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})).f(tls, (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + 8*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + 8*4))), (bp) /* &res */))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})).f(tls, *(*int32)(unsafe.Pointer(it + 132 + 8*4))+*(*int32)(unsafe.Pointer(it + 168 + 8*4)), bp)
// AC
- VP8InitResidual(tls, 1, 0, enc, (bp) /* &res */)
+ VP8InitResidual(tls, 1, 0, enc, bp)
for y = 0; y < 4; y++ {
for x = 0; x < 4; x++ {
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(y)*4)))
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(y)*4))
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, ((rd + 72 /* &.y_ac_levels */) + uintptr((x+(y*4)))*32), (bp) /* &res */)
- R = R + ((*struct {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+72 /* &.y_ac_levels */ +uintptr(x+y*4)*32, bp /* &res */)
+ R = R + (*struct {
f func(*libc.TLS, int32, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})).f(tls, ctx, (bp) /* &res */))
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + uintptr(y)*4), (libc.Bool32((*VP8Residual)(unsafe.Pointer(bp /* &res */)).last >= 0)))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})).f(tls, ctx, bp)
+ *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) = libc.AssignPtrInt32(it+168+uintptr(y)*4, libc.Bool32((*VP8Residual)(unsafe.Pointer(bp)).last >= 0))
}
}
return R
@@ -25726,18 +25439,18 @@ func VP8GetCostUV(tls *libc.TLS, it uintptr, rd uintptr) int32 { /* cost_enc.c:2
VP8IteratorNzToBytes(tls, it) // re-import the non-zero context
- VP8InitResidual(tls, 0, 2, enc, (bp) /* &res */)
- for ch = 0; ch <= 2; ch = ch + (2) {
+ VP8InitResidual(tls, 0, 2, enc, bp)
+ for ch = 0; ch <= 2; ch = ch + 2 {
for y = 0; y < 2; y++ {
for x = 0; x < 2; x++ {
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(((4+ch)+x))*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(((4+ch)+y))*4)))
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + uintptr(4+ch+x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(4+ch+y)*4))
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, ((rd + 584 /* &.uv_levels */) + uintptr((((ch*2)+x)+(y*2)))*32), (bp) /* &res */)
- R = R + ((*struct {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+584 /* &.uv_levels */ +uintptr(ch*2+x+y*2)*32, bp /* &res */)
+ R = R + (*struct {
f func(*libc.TLS, int32, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})).f(tls, ctx, (bp) /* &res */))
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(((4+ch)+x))*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + uintptr(((4+ch)+y))*4), (libc.Bool32((*VP8Residual)(unsafe.Pointer(bp /* &res */)).last >= 0)))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})).f(tls, ctx, bp)
+ *(*int32)(unsafe.Pointer(it + 132 + uintptr(4+ch+x)*4)) = libc.AssignPtrInt32(it+168+uintptr(4+ch+y)*4, libc.Bool32((*VP8Residual)(unsafe.Pointer(bp)).last >= 0))
}
}
}
@@ -25754,21 +25467,21 @@ func VP8GetCostUV(tls *libc.TLS, it uintptr, rd uintptr) int32 { /* cost_enc.c:2
func VP8RecordCoeffs(tls *libc.TLS, ctx int32, res uintptr) int32 { /* cost_enc.c:289:5: */
var n int32 = (*VP8Residual)(unsafe.Pointer(res)).first
// should be stats[VP8EncBands[n]], but it's equivalent for n=0 or 1
- var s uintptr = (((*VP8Residual)(unsafe.Pointer(res)).stats + uintptr(n)*132) + uintptr(ctx)*44)
+ var s uintptr = (*VP8Residual)(unsafe.Pointer(res)).stats + uintptr(n)*132 + uintptr(ctx)*44
if (*VP8Residual)(unsafe.Pointer(res)).last < 0 {
- VP8RecordStats(tls, 0, (s + uintptr(0)*4))
+ VP8RecordStats(tls, 0, s+uintptr(0)*4)
return 0
}
for n <= (*VP8Residual)(unsafe.Pointer(res)).last {
var v int32
- VP8RecordStats(tls, 1, (s + uintptr(0)*4)) // order of record doesn't matter
- for (libc.AssignInt32(&v, int32(*(*int16_t)(unsafe.Pointer((*VP8Residual)(unsafe.Pointer(res)).coeffs + uintptr(libc.PostIncInt32(&n, 1))*2))))) == 0 {
- VP8RecordStats(tls, 0, (s + uintptr(1)*4))
- s = ((*VP8Residual)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132)
- }
- VP8RecordStats(tls, 1, (s + uintptr(1)*4))
- if !(VP8RecordStats(tls, (libc.Bool32(2 < (uint32(v+1)))), (s+uintptr(2)*4)) != 0) { // v = -1 or 1
- s = (((*VP8Residual)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132) + 1*44)
+ VP8RecordStats(tls, 1, s+uintptr(0)*4) // order of record doesn't matter
+ for libc.AssignInt32(&v, int32(*(*int16_t)(unsafe.Pointer((*VP8Residual)(unsafe.Pointer(res)).coeffs + uintptr(libc.PostIncInt32(&n, 1))*2)))) == 0 {
+ VP8RecordStats(tls, 0, s+uintptr(1)*4)
+ s = (*VP8Residual)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132
+ }
+ VP8RecordStats(tls, 1, s+uintptr(1)*4)
+ if !(VP8RecordStats(tls, libc.Bool32(2 < uint32(v+1)), s+uintptr(2)*4) != 0) { // v = -1 or 1
+ s = (*VP8Residual)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132 + 1*44
} else {
v = libc.Xabs(tls, v)
if v > MAX_VARIABLE_LEVEL {
@@ -25776,22 +25489,22 @@ func VP8RecordCoeffs(tls *libc.TLS, ctx int32, res uintptr) int32 { /* cost_enc.
}
{
- var bits int32 = int32(*(*uint16_t)(unsafe.Pointer((uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr((v-1))*4) + 1*2)))
- var pattern int32 = int32(*(*uint16_t)(unsafe.Pointer((uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr((v-1))*4))))
+ var bits int32 = int32(*(*uint16_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr(v-1)*4 + 1*2)))
+ var pattern int32 = int32(*(*uint16_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr(v-1)*4)))
var i int32
- for i = 0; (libc.AssignShrInt32(&pattern, int(1))) != 0; i++ {
- var mask int32 = (int32(2) << i)
- if (pattern & 1) != 0 {
- VP8RecordStats(tls, libc.BoolInt32(!(!((bits & mask) != 0))), ((s + uintptr(3)*4) + uintptr(i)*4))
+ for i = 0; libc.AssignShrInt32(&pattern, int(1)) != 0; i++ {
+ var mask int32 = int32(2) << i
+ if pattern&1 != 0 {
+ VP8RecordStats(tls, libc.BoolInt32(!!(bits&mask != 0)), s+uintptr(3)*4+uintptr(i)*4)
}
}
}
- s = (((*VP8Residual)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132) + 2*44)
+ s = (*VP8Residual)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132 + 2*44
}
}
if n < 16 {
- VP8RecordStats(tls, 0, (s + uintptr(0)*4))
+ VP8RecordStats(tls, 0, s+uintptr(0)*4)
}
return 1
}
@@ -25819,35 +25532,35 @@ func VP8RecordCoeffs(tls *libc.TLS, ctx int32, res uintptr) int32 { /* cost_enc.
// over all possible filtering strength / thresh until needs_filter() returns
// true.
var kLevelsFromDelta = [8][64]uint8_t{
- [64]uint8_t{uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(3), uint8_t(4), uint8_t(5), uint8_t(6), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(10), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(14), uint8_t(15),
+ {uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(3), uint8_t(4), uint8_t(5), uint8_t(6), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(10), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(14), uint8_t(15),
uint8_t(16), uint8_t(17), uint8_t(18), uint8_t(19), uint8_t(20), uint8_t(21), uint8_t(22), uint8_t(23), uint8_t(24), uint8_t(25), uint8_t(26), uint8_t(27), uint8_t(28), uint8_t(29), uint8_t(30), uint8_t(31),
uint8_t(32), uint8_t(33), uint8_t(34), uint8_t(35), uint8_t(36), uint8_t(37), uint8_t(38), uint8_t(39), uint8_t(40), uint8_t(41), uint8_t(42), uint8_t(43), uint8_t(44), uint8_t(45), uint8_t(46), uint8_t(47),
uint8_t(48), uint8_t(49), uint8_t(50), uint8_t(51), uint8_t(52), uint8_t(53), uint8_t(54), uint8_t(55), uint8_t(56), uint8_t(57), uint8_t(58), uint8_t(59), uint8_t(60), uint8_t(61), uint8_t(62), uint8_t(63)},
- [64]uint8_t{uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(3), uint8_t(5), uint8_t(6), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(14), uint8_t(15), uint8_t(17), uint8_t(18),
+ {uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(3), uint8_t(5), uint8_t(6), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(14), uint8_t(15), uint8_t(17), uint8_t(18),
uint8_t(20), uint8_t(21), uint8_t(23), uint8_t(24), uint8_t(26), uint8_t(27), uint8_t(29), uint8_t(30), uint8_t(32), uint8_t(33), uint8_t(35), uint8_t(36), uint8_t(38), uint8_t(39), uint8_t(41), uint8_t(42),
uint8_t(44), uint8_t(45), uint8_t(47), uint8_t(48), uint8_t(50), uint8_t(51), uint8_t(53), uint8_t(54), uint8_t(56), uint8_t(57), uint8_t(59), uint8_t(60), uint8_t(62), uint8_t(63), uint8_t(63), uint8_t(63),
uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63)},
- [64]uint8_t{uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(3), uint8_t(5), uint8_t(6), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(14), uint8_t(16), uint8_t(17), uint8_t(19),
+ {uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(3), uint8_t(5), uint8_t(6), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(14), uint8_t(16), uint8_t(17), uint8_t(19),
uint8_t(20), uint8_t(22), uint8_t(23), uint8_t(25), uint8_t(26), uint8_t(28), uint8_t(29), uint8_t(31), uint8_t(32), uint8_t(34), uint8_t(35), uint8_t(37), uint8_t(38), uint8_t(40), uint8_t(41), uint8_t(43),
uint8_t(44), uint8_t(46), uint8_t(47), uint8_t(49), uint8_t(50), uint8_t(52), uint8_t(53), uint8_t(55), uint8_t(56), uint8_t(58), uint8_t(59), uint8_t(61), uint8_t(62), uint8_t(63), uint8_t(63), uint8_t(63),
uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63)},
- [64]uint8_t{uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(3), uint8_t(5), uint8_t(6), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(15), uint8_t(16), uint8_t(18), uint8_t(19),
+ {uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(3), uint8_t(5), uint8_t(6), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(15), uint8_t(16), uint8_t(18), uint8_t(19),
uint8_t(21), uint8_t(22), uint8_t(24), uint8_t(25), uint8_t(27), uint8_t(28), uint8_t(30), uint8_t(31), uint8_t(33), uint8_t(34), uint8_t(36), uint8_t(37), uint8_t(39), uint8_t(40), uint8_t(42), uint8_t(43),
uint8_t(45), uint8_t(46), uint8_t(48), uint8_t(49), uint8_t(51), uint8_t(52), uint8_t(54), uint8_t(55), uint8_t(57), uint8_t(58), uint8_t(60), uint8_t(61), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63),
uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63)},
- [64]uint8_t{uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(3), uint8_t(5), uint8_t(6), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(14), uint8_t(15), uint8_t(17), uint8_t(18), uint8_t(20),
+ {uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(3), uint8_t(5), uint8_t(6), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(14), uint8_t(15), uint8_t(17), uint8_t(18), uint8_t(20),
uint8_t(21), uint8_t(23), uint8_t(24), uint8_t(26), uint8_t(27), uint8_t(29), uint8_t(30), uint8_t(32), uint8_t(33), uint8_t(35), uint8_t(36), uint8_t(38), uint8_t(39), uint8_t(41), uint8_t(42), uint8_t(44),
uint8_t(45), uint8_t(47), uint8_t(48), uint8_t(50), uint8_t(51), uint8_t(53), uint8_t(54), uint8_t(56), uint8_t(57), uint8_t(59), uint8_t(60), uint8_t(62), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63),
uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63)},
- [64]uint8_t{uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(4), uint8_t(5), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(15), uint8_t(16), uint8_t(17), uint8_t(19), uint8_t(20),
+ {uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(4), uint8_t(5), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(15), uint8_t(16), uint8_t(17), uint8_t(19), uint8_t(20),
uint8_t(22), uint8_t(23), uint8_t(25), uint8_t(26), uint8_t(28), uint8_t(29), uint8_t(31), uint8_t(32), uint8_t(34), uint8_t(35), uint8_t(37), uint8_t(38), uint8_t(40), uint8_t(41), uint8_t(43), uint8_t(44),
uint8_t(46), uint8_t(47), uint8_t(49), uint8_t(50), uint8_t(52), uint8_t(53), uint8_t(55), uint8_t(56), uint8_t(58), uint8_t(59), uint8_t(61), uint8_t(62), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63),
uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63)},
- [64]uint8_t{uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(4), uint8_t(5), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(15), uint8_t(16), uint8_t(18), uint8_t(19), uint8_t(21),
+ {uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(4), uint8_t(5), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(13), uint8_t(15), uint8_t(16), uint8_t(18), uint8_t(19), uint8_t(21),
uint8_t(22), uint8_t(24), uint8_t(25), uint8_t(27), uint8_t(28), uint8_t(30), uint8_t(31), uint8_t(33), uint8_t(34), uint8_t(36), uint8_t(37), uint8_t(39), uint8_t(40), uint8_t(42), uint8_t(43), uint8_t(45),
uint8_t(46), uint8_t(48), uint8_t(49), uint8_t(51), uint8_t(52), uint8_t(54), uint8_t(55), uint8_t(57), uint8_t(58), uint8_t(60), uint8_t(61), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63),
uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63)},
- [64]uint8_t{uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(4), uint8_t(5), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(14), uint8_t(15), uint8_t(17), uint8_t(18), uint8_t(20), uint8_t(21),
+ {uint8_t(0), uint8_t(1), uint8_t(2), uint8_t(4), uint8_t(5), uint8_t(7), uint8_t(8), uint8_t(9), uint8_t(11), uint8_t(12), uint8_t(14), uint8_t(15), uint8_t(17), uint8_t(18), uint8_t(20), uint8_t(21),
uint8_t(23), uint8_t(24), uint8_t(26), uint8_t(27), uint8_t(29), uint8_t(30), uint8_t(32), uint8_t(33), uint8_t(35), uint8_t(36), uint8_t(38), uint8_t(39), uint8_t(41), uint8_t(42), uint8_t(44), uint8_t(45),
uint8_t(47), uint8_t(48), uint8_t(50), uint8_t(51), uint8_t(53), uint8_t(54), uint8_t(56), uint8_t(57), uint8_t(59), uint8_t(60), uint8_t(62), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63),
uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63), uint8_t(63)},
@@ -25858,10 +25571,10 @@ func VP8FilterStrengthFromDelta(tls *libc.TLS, sharpness int32, delta int32) int
if delta < 64 {
pos = delta
} else {
- pos = (64 - 1)
+ pos = 64 - 1
}
- return int32(*(*uint8_t)(unsafe.Pointer((uintptr(unsafe.Pointer(&kLevelsFromDelta)) + uintptr(sharpness)*64) + uintptr(pos))))
+ return int32(*(*uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&kLevelsFromDelta)) + uintptr(sharpness)*64 + uintptr(pos))))
}
//------------------------------------------------------------------------------
@@ -25874,8 +25587,8 @@ func GetILevel(tls *libc.TLS, sharpness int32, level int32) int32 { /* filter_en
} else {
level >>= 1
}
- if level > (9 - sharpness) {
- level = (9 - sharpness)
+ if level > 9-sharpness {
+ level = 9 - sharpness
}
}
if level < 1 {
@@ -25887,14 +25600,14 @@ func GetILevel(tls *libc.TLS, sharpness int32, level int32) int32 { /* filter_en
func DoFilter1(tls *libc.TLS, it uintptr, level int32) { /* filter_enc.c:85:13: */
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
var ilevel int32 = GetILevel(tls, (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).filter_sharpness, level)
- var limit int32 = ((2 * level) + ilevel)
+ var limit int32 = 2*level + ilevel
- var y_dst uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr((0)))
- var u_dst uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr((16)))
- var v_dst uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr((16 + 8)))
+ var y_dst uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr(0)
+ var u_dst uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr(16)
+ var v_dst uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr(16+8)
// copy current block to yuv_out2_
- libc.Xmemcpy(tls, y_dst, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_, ((uint64(32 * 16)) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ libc.Xmemcpy(tls, y_dst, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_, uint64(32*16)*uint64(unsafe.Sizeof(uint8_t(0))))
if (*VP8Encoder)(unsafe.Pointer(enc)).filter_hdr_.simple_ == 1 { // simple
(*struct {
@@ -25938,24 +25651,24 @@ func GetMBSSIM(tls *libc.TLS, yuv1 uintptr, yuv2 uintptr) float64 { /* filter_en
var sum float64 = 0.
// compute SSIM in a 10 x 10 window
- for y = 3; y < (16 - 3); y++ {
- for x = 3; x < (16 - 3); x++ {
- sum = sum + ((*struct {
+ for y = 3; y < 16-3; y++ {
+ for x = 3; x < 16-3; x++ {
+ sum = sum + (*struct {
f func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, (yuv1 + uintptr((0))), 32, (yuv2 + uintptr((0))), 32,
- x, y, 16, 16))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, yuv1+uintptr(0), 32, yuv2+uintptr(0), 32,
+ x, y, 16, 16)
}
}
for x = 1; x < 7; x++ {
for y = 1; y < 7; y++ {
- sum = sum + ((*struct {
+ sum = sum + (*struct {
f func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, (yuv1 + uintptr((16))), 32, (yuv2 + uintptr((16))), 32,
- x, y, 8, 8))
- sum = sum + ((*struct {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, yuv1+uintptr(16), 32, yuv2+uintptr(16), 32,
+ x, y, 8, 8)
+ sum = sum + (*struct {
f func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, (yuv1 + uintptr((16 + 8))), 32, (yuv2 + uintptr((16 + 8))), 32,
- x, y, 8, 8))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, yuv1+uintptr(16+8), 32, yuv2+uintptr(16+8), 32,
+ x, y, 8, 8)
}
}
return sum
@@ -25966,12 +25679,12 @@ func GetMBSSIM(tls *libc.TLS, yuv1 uintptr, yuv2 uintptr) float64 { /* filter_en
// loop filter strength
func VP8InitFilter(tls *libc.TLS, it uintptr) { /* filter_enc.c:140:6: */
- if (*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ != (uintptr(0)) {
+ if (*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ != uintptr(0) {
var s int32
var i int32
for s = 0; s < NUM_MB_SEGMENTS; s++ {
for i = 0; i < MAX_LF_LEVELS; i++ {
- *(*float64)(unsafe.Pointer(((*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ + uintptr(s)*512) + uintptr(i)*8)) = float64(0)
+ *(*float64)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ + uintptr(s)*512 + uintptr(i)*8)) = float64(0)
}
}
VP8SSIMDspInit(tls)
@@ -25981,20 +25694,20 @@ func VP8InitFilter(tls *libc.TLS, it uintptr) { /* filter_enc.c:140:6: */
func VP8StoreFilterStats(tls *libc.TLS, it uintptr) { /* filter_enc.c:156:6: */
var d int32
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
- var s int32 = (int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.segment_ */)) & 0x60 >> 5))
- var level0 int32 = (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(s)*744)).fstrength_
+ var s int32 = int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_)) & 0x60 >> 5)
+ var level0 int32 = (*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(s)*744)).fstrength_
// explore +/-quant range of values around level0
- var delta_min int32 = -(*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(s)*744)).quant_
- var delta_max int32 = (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(s)*744)).quant_
+ var delta_min int32 = -(*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(s)*744)).quant_
+ var delta_max int32 = (*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(s)*744)).quant_
var step_size int32
- if (delta_max - delta_min) >= 4 {
+ if delta_max-delta_min >= 4 {
step_size = 4
} else {
step_size = 1
}
- if (*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ == (uintptr(0)) {
+ if (*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ == uintptr(0) {
return
}
@@ -26004,40 +25717,40 @@ func VP8StoreFilterStats(tls *libc.TLS, it uintptr) { /* filter_enc.c:156:6: */
// the left and top macro blocks. That will be hard to restore
// 2. Macro Blocks on the bottom and right are not yet compressed. So we
// cannot apply filter on the right and bottom macro block edges.
- if ((int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.type_ */)) & 0x3 >> 0)) == 1) && ((uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.skip_ */)) & 0x10 >> 4))) != 0) {
+ if int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x3>>0) == 1 && uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x10>>4)) != 0 {
return
}
// Always try filter level zero
- *(*float64)(unsafe.Pointer(((*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ + uintptr(s)*512))) += (GetMBSSIM(tls, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_))
+ *(*float64)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ + uintptr(s)*512)) += GetMBSSIM(tls, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_)
- for d = delta_min; d <= delta_max; d = d + (step_size) {
- var level int32 = (level0 + d)
- if (level <= 0) || (level >= MAX_LF_LEVELS) {
+ for d = delta_min; d <= delta_max; d = d + step_size {
+ var level int32 = level0 + d
+ if level <= 0 || level >= MAX_LF_LEVELS {
continue
}
DoFilter1(tls, it, level)
- *(*float64)(unsafe.Pointer((((*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ + uintptr(s)*512) + uintptr(level)*8))) += (GetMBSSIM(tls, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_))
+ *(*float64)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ + uintptr(s)*512 + uintptr(level)*8)) += GetMBSSIM(tls, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_)
}
}
func VP8AdjustFilterStrength(tls *libc.TLS, it uintptr) { /* filter_enc.c:194:6: */
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
- if (*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ != (uintptr(0)) {
+ if (*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ != uintptr(0) {
var s int32
for s = 0; s < NUM_MB_SEGMENTS; s++ {
var i int32
var best_level int32 = 0
// Improvement over filter level 0 should be at least 1e-5 (relatively)
- var best_v float64 = (1.00001 * *(*float64)(unsafe.Pointer(((*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ + uintptr(s)*512))))
+ var best_v float64 = 1.00001 * *(*float64)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ + uintptr(s)*512))
for i = 1; i < MAX_LF_LEVELS; i++ {
- var v float64 = *(*float64)(unsafe.Pointer(((*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ + uintptr(s)*512) + uintptr(i)*8))
+ var v float64 = *(*float64)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ + uintptr(s)*512 + uintptr(i)*8))
if v > best_v {
best_v = v
best_level = i
}
}
- (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(s)*744)).fstrength_ = best_level
+ (*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(s)*744)).fstrength_ = best_level
}
return
}
@@ -26045,9 +25758,9 @@ func VP8AdjustFilterStrength(tls *libc.TLS, it uintptr) { /* filter_enc.c:194:6:
var max_level int32 = 0
var s int32
for s = 0; s < NUM_MB_SEGMENTS; s++ {
- var dqm uintptr = ((enc + 608 /* &.dqm_ */) + uintptr(s)*744)
+ var dqm uintptr = enc + 608 + uintptr(s)*744
// this '>> 3' accounts for some inverse WHT scaling
- var delta int32 = (((*VP8SegmentInfo)(unsafe.Pointer(dqm)).max_edge_ * int32(*(*uint16_t)(unsafe.Pointer((dqm + 224 /* &.y2_ */) /* &.q_ */ + 1*2)))) >> 3)
+ var delta int32 = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).max_edge_ * int32(*(*uint16_t)(unsafe.Pointer(dqm + 224 + 1*2))) >> 3
var level int32 = VP8FilterStrengthFromDelta(tls, (*VP8Encoder)(unsafe.Pointer(enc)).filter_hdr_.sharpness_, delta)
if level > (*VP8SegmentInfo)(unsafe.Pointer(dqm)).fstrength_ {
(*VP8SegmentInfo)(unsafe.Pointer(dqm)).fstrength_ = level
@@ -26100,14 +25813,14 @@ type PassStats = struct {
func InitPassStats(tls *libc.TLS, enc uintptr, s uintptr) int32 { /* frame_enc.c:48:12: */
var target_size uint64_t = uint64_t((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).target_size)
- var do_size_search int32 = (libc.Bool32(target_size != uint64(0)))
+ var do_size_search int32 = libc.Bool32(target_size != uint64(0))
var target_PSNR float32 = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).target_PSNR
(*PassStats)(unsafe.Pointer(s)).is_first = 1
(*PassStats)(unsafe.Pointer(s)).dq = 10.
- (*PassStats)(unsafe.Pointer(s)).qmin = (1. * float32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).qmin))
- (*PassStats)(unsafe.Pointer(s)).qmax = (1. * float32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).qmax))
- (*PassStats)(unsafe.Pointer(s)).q = libc.AssignPtrFloat32((s + 12 /* &.last_q */), Clamp(tls, (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).quality, (*PassStats)(unsafe.Pointer(s)).qmin, (*PassStats)(unsafe.Pointer(s)).qmax))
+ (*PassStats)(unsafe.Pointer(s)).qmin = 1. * float32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).qmin)
+ (*PassStats)(unsafe.Pointer(s)).qmax = 1. * float32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).qmax)
+ (*PassStats)(unsafe.Pointer(s)).q = libc.AssignPtrFloat32(s+12, Clamp(tls, (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).quality, (*PassStats)(unsafe.Pointer(s)).qmin, (*PassStats)(unsafe.Pointer(s)).qmax))
(*PassStats)(unsafe.Pointer(s)).target = func() float64 {
if do_size_search != 0 {
return float64(target_size)
@@ -26119,7 +25832,7 @@ func InitPassStats(tls *libc.TLS, enc uintptr, s uintptr) int32 { /* frame_enc.c
return 40.
}()
}() // default, just in case
- (*PassStats)(unsafe.Pointer(s)).value = libc.AssignPtrFloat64((s + 32 /* &.last_value */), 0.)
+ (*PassStats)(unsafe.Pointer(s)).value = libc.AssignPtrFloat64(s+32, 0.)
(*PassStats)(unsafe.Pointer(s)).do_size_search = do_size_search
return do_size_search
}
@@ -26134,8 +25847,8 @@ func ComputeNextQ(tls *libc.TLS, s uintptr) float32 { /* frame_enc.c:66:14: */
}
(*PassStats)(unsafe.Pointer(s)).is_first = 0
} else if (*PassStats)(unsafe.Pointer(s)).value != (*PassStats)(unsafe.Pointer(s)).last_value {
- var slope float64 = (((*PassStats)(unsafe.Pointer(s)).target - (*PassStats)(unsafe.Pointer(s)).value) / ((*PassStats)(unsafe.Pointer(s)).last_value - (*PassStats)(unsafe.Pointer(s)).value))
- dq = (float32(slope * (float64((*PassStats)(unsafe.Pointer(s)).last_q - (*PassStats)(unsafe.Pointer(s)).q))))
+ var slope float64 = ((*PassStats)(unsafe.Pointer(s)).target - (*PassStats)(unsafe.Pointer(s)).value) / ((*PassStats)(unsafe.Pointer(s)).last_value - (*PassStats)(unsafe.Pointer(s)).value)
+ dq = float32(slope * float64((*PassStats)(unsafe.Pointer(s)).last_q-(*PassStats)(unsafe.Pointer(s)).q))
} else {
dq = 0. // we're done?!
}
@@ -26143,7 +25856,7 @@ func ComputeNextQ(tls *libc.TLS, s uintptr) float32 { /* frame_enc.c:66:14: */
(*PassStats)(unsafe.Pointer(s)).dq = Clamp(tls, dq, -30., 30.)
(*PassStats)(unsafe.Pointer(s)).last_q = (*PassStats)(unsafe.Pointer(s)).q
(*PassStats)(unsafe.Pointer(s)).last_value = (*PassStats)(unsafe.Pointer(s)).value
- (*PassStats)(unsafe.Pointer(s)).q = Clamp(tls, ((*PassStats)(unsafe.Pointer(s)).q + (*PassStats)(unsafe.Pointer(s)).dq), (*PassStats)(unsafe.Pointer(s)).qmin, (*PassStats)(unsafe.Pointer(s)).qmax)
+ (*PassStats)(unsafe.Pointer(s)).q = Clamp(tls, (*PassStats)(unsafe.Pointer(s)).q+(*PassStats)(unsafe.Pointer(s)).dq, (*PassStats)(unsafe.Pointer(s)).qmin, (*PassStats)(unsafe.Pointer(s)).qmax)
return (*PassStats)(unsafe.Pointer(s)).q
}
@@ -26159,7 +25872,7 @@ var VP8Cat6 = [11]uint8_t{uint8_t(254), uint8_t(254), uint8_t(243), uint8_t(230)
// Reset the statistics about: number of skips, token proba, level cost,...
func ResetStats(tls *libc.TLS, enc uintptr) { /* frame_enc.c:97:13: */
- var proba uintptr = (enc + 3616 /* &.proba_ */)
+ var proba uintptr = enc + 3616
VP8CalculateLevelCosts(tls, proba)
(*VP8EncProba)(unsafe.Pointer(proba)).nb_skip_ = 0
}
@@ -26168,27 +25881,27 @@ func ResetStats(tls *libc.TLS, enc uintptr) { /* frame_enc.c:97:13: */
// Skip decision probability
func CalcSkipProba(tls *libc.TLS, nb uint64_t, total uint64_t) int32 { /* frame_enc.c:108:12: */
- return (func() int32 {
+ return func() int32 {
if total != 0 {
- return (int32(((total - nb) * uint64(255)) / total))
+ return int32((total - nb) * uint64(255) / total)
}
return 255
- }())
+ }()
}
// Returns the bit-cost for coding the skip probability.
func FinalizeSkipProba(tls *libc.TLS, enc uintptr) int32 { /* frame_enc.c:113:12: */
- var proba uintptr = (enc + 3616 /* &.proba_ */)
- var nb_mbs int32 = ((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_)
+ var proba uintptr = enc + 3616
+ var nb_mbs int32 = (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_
var nb_events int32 = (*VP8EncProba)(unsafe.Pointer(proba)).nb_skip_
var size int32
(*VP8EncProba)(unsafe.Pointer(proba)).skip_proba_ = uint8_t(CalcSkipProba(tls, uint64(nb_events), uint64(nb_mbs)))
- (*VP8EncProba)(unsafe.Pointer(proba)).use_skip_proba_ = (libc.Bool32(int32((*VP8EncProba)(unsafe.Pointer(proba)).skip_proba_) < 250))
+ (*VP8EncProba)(unsafe.Pointer(proba)).use_skip_proba_ = libc.Bool32(int32((*VP8EncProba)(unsafe.Pointer(proba)).skip_proba_) < 250)
size = 256 // 'use_skip_proba' bit
if (*VP8EncProba)(unsafe.Pointer(proba)).use_skip_proba_ != 0 {
- size = size + ((nb_events * VP8BitCost(tls, 1, (*VP8EncProba)(unsafe.Pointer(proba)).skip_proba_)) +
- ((nb_mbs - nb_events) * VP8BitCost(tls, 0, (*VP8EncProba)(unsafe.Pointer(proba)).skip_proba_)))
- size = size + (8 * 256) // cost of signaling the skip_proba_ itself.
+ size = size + (nb_events*VP8BitCost(tls, 1, (*VP8EncProba)(unsafe.Pointer(proba)).skip_proba_) +
+ (nb_mbs-nb_events)*VP8BitCost(tls, 0, (*VP8EncProba)(unsafe.Pointer(proba)).skip_proba_))
+ size = size + 8*256 // cost of signaling the skip_proba_ itself.
}
return size
}
@@ -26198,19 +25911,19 @@ func FinalizeSkipProba(tls *libc.TLS, enc uintptr) int32 { /* frame_enc.c:113:12
func CalcTokenProba(tls *libc.TLS, nb int32, total int32) int32 { /* frame_enc.c:131:12: */
if nb != 0 {
- return (255 - ((nb * 255) / total))
+ return 255 - nb*255/total
}
return 255
}
// Cost of coding 'nb' 1's and 'total-nb' 0's using 'proba' probability.
func BranchCost(tls *libc.TLS, nb int32, total int32, proba int32) int32 { /* frame_enc.c:137:12: */
- return ((nb * VP8BitCost(tls, 1, uint8(proba))) + ((total - nb) * VP8BitCost(tls, 0, uint8(proba))))
+ return nb*VP8BitCost(tls, 1, uint8(proba)) + (total-nb)*VP8BitCost(tls, 0, uint8(proba))
}
func ResetTokenStats(tls *libc.TLS, enc uintptr) { /* frame_enc.c:141:13: */
- var proba uintptr = (enc + 3616 /* &.proba_ */)
- libc.Xmemset(tls, (proba + 1060 /* &.stats_ */), 0, uint64(unsafe.Sizeof([4][8]StatsArray{})))
+ var proba uintptr = enc + 3616
+ libc.Xmemset(tls, proba+1060, 0, uint64(unsafe.Sizeof([4][8]StatsArray{})))
}
func FinalizeTokenProbas(tls *libc.TLS, proba uintptr) int32 { /* frame_enc.c:146:12: */
@@ -26224,25 +25937,25 @@ func FinalizeTokenProbas(tls *libc.TLS, proba uintptr) int32 { /* frame_enc.c:14
for b = 0; b < NUM_BANDS; b++ {
for c = 0; c < NUM_CTX; c++ {
for p = 0; p < NUM_PROBAS; p++ {
- var stats proba_t = *(*proba_t)(unsafe.Pointer(((((proba + 1060 /* &.stats_ */) + uintptr(t)*1056) + uintptr(b)*132) + uintptr(c)*44) + uintptr(p)*4))
- var nb int32 = (int32((stats >> 0) & proba_t(0xffff)))
- var total int32 = (int32((stats >> 16) & proba_t(0xffff)))
- var update_proba int32 = int32(*(*uint8_t)(unsafe.Pointer((((uintptr(unsafe.Pointer(&VP8CoeffsUpdateProba)) + uintptr(t)*264) + uintptr(b)*33) + uintptr(c)*11) + uintptr(p))))
- var old_p int32 = int32(*(*uint8_t)(unsafe.Pointer((((uintptr(unsafe.Pointer(&VP8CoeffsProba0)) + uintptr(t)*264) + uintptr(b)*33) + uintptr(c)*11) + uintptr(p))))
+ var stats proba_t = *(*proba_t)(unsafe.Pointer(proba + 1060 + uintptr(t)*1056 + uintptr(b)*132 + uintptr(c)*44 + uintptr(p)*4))
+ var nb int32 = int32(stats >> 0 & proba_t(0xffff))
+ var total int32 = int32(stats >> 16 & proba_t(0xffff))
+ var update_proba int32 = int32(*(*uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8CoeffsUpdateProba)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))))
+ var old_p int32 = int32(*(*uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8CoeffsProba0)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))))
var new_p int32 = CalcTokenProba(tls, nb, total)
- var old_cost int32 = (BranchCost(tls, nb, total, old_p) +
- VP8BitCost(tls, 0, uint8(update_proba)))
- var new_cost int32 = ((BranchCost(tls, nb, total, new_p) +
- VP8BitCost(tls, 1, uint8(update_proba))) +
- (8 * 256))
- var use_new_p int32 = (libc.Bool32(old_cost > new_cost))
- size = size + (VP8BitCost(tls, use_new_p, uint8(update_proba)))
+ var old_cost int32 = BranchCost(tls, nb, total, old_p) +
+ VP8BitCost(tls, 0, uint8(update_proba))
+ var new_cost int32 = BranchCost(tls, nb, total, new_p) +
+ VP8BitCost(tls, 1, uint8(update_proba)) +
+ 8*256
+ var use_new_p int32 = libc.Bool32(old_cost > new_cost)
+ size = size + VP8BitCost(tls, use_new_p, uint8(update_proba))
if use_new_p != 0 { // only use proba that seem meaningful enough.
- *(*uint8_t)(unsafe.Pointer(((((proba + 4 /* &.coeffs_ */) + uintptr(t)*264) + uintptr(b)*33) + uintptr(c)*11) + uintptr(p))) = uint8_t(new_p)
- has_changed = has_changed | (libc.Bool32(new_p != old_p))
- size = size + (8 * 256)
+ *(*uint8_t)(unsafe.Pointer(proba + 4 + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))) = uint8_t(new_p)
+ has_changed = has_changed | libc.Bool32(new_p != old_p)
+ size = size + 8*256
} else {
- *(*uint8_t)(unsafe.Pointer(((((proba + 4 /* &.coeffs_ */) + uintptr(t)*264) + uintptr(b)*33) + uintptr(c)*11) + uintptr(p))) = uint8_t(old_p)
+ *(*uint8_t)(unsafe.Pointer(proba + 4 + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))) = uint8_t(old_p)
}
}
}
@@ -26256,17 +25969,17 @@ func FinalizeTokenProbas(tls *libc.TLS, proba uintptr) int32 { /* frame_enc.c:14
// Finalize Segment probability based on the coding tree
func GetProba(tls *libc.TLS, a int32, b int32) int32 { /* frame_enc.c:185:12: */
- var total int32 = (a + b)
+ var total int32 = a + b
if total == 0 {
return 255
}
- return (((255 * a) + (total / 2)) / total) // rounded proba
+ return (255*a + total/2) / total // rounded proba
}
func ResetSegments(tls *libc.TLS, enc uintptr) { /* frame_enc.c:191:13: */
var n int32
- for n = 0; n < ((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_); n++ {
- libc.SetBitFieldPtr8Uint32(((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(n)*4) /* &.segment_ */, uint32(0), 5, 0x60)
+ for n = 0; n < (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_*(*VP8Encoder)(unsafe.Pointer(enc)).mb_h_; n++ {
+ libc.SetBitFieldPtr8Uint32((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_+uintptr(n)*4, uint32(0), 5, 0x60)
}
}
@@ -26277,26 +25990,26 @@ func SetSegmentProbas(tls *libc.TLS, enc uintptr) { /* frame_enc.c:198:13: */
*(*[4]int32)(unsafe.Pointer(bp /* p */)) = [4]int32{0: 0}
var n int32
- for n = 0; n < ((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_); n++ {
- var mb uintptr = ((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(n)*4)
- *(*int32)(unsafe.Pointer((bp) /* &p[0] */ + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer(mb /* &.segment_ */))&0x60>>5))))*4))++
+ for n = 0; n < (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_*(*VP8Encoder)(unsafe.Pointer(enc)).mb_h_; n++ {
+ var mb uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(n)*4
+ *(*int32)(unsafe.Pointer(bp + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer(mb))&0x60>>5)))*4))++
}
- if (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats != (uintptr(0)) {
+ if (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats != uintptr(0) {
for n = 0; n < NUM_MB_SEGMENTS; n++ {
- *(*int32)(unsafe.Pointer(((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats + 92 /* &.segment_size */) + uintptr(n)*4)) = *(*int32)(unsafe.Pointer((bp) /* &p[0] */ + uintptr(n)*4))
+ *(*int32)(unsafe.Pointer((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats + 92 + uintptr(n)*4)) = *(*int32)(unsafe.Pointer(bp + uintptr(n)*4))
}
}
if (*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.num_segments_ > 1 {
- var probas uintptr = (enc + 3616 /* &.proba_ */) /* &.segments_ */
- *(*uint8_t)(unsafe.Pointer(probas)) = uint8_t(GetProba(tls, (*(*int32)(unsafe.Pointer((bp) /* &p[0] */)) + *(*int32)(unsafe.Pointer((bp) /* &p[0] */ + 1*4))), (*(*int32)(unsafe.Pointer((bp) /* &p[0] */ + 2*4)) + *(*int32)(unsafe.Pointer((bp) /* &p[0] */ + 3*4)))))
- *(*uint8_t)(unsafe.Pointer(probas + 1)) = uint8_t(GetProba(tls, *(*int32)(unsafe.Pointer((bp) /* &p[0] */)), *(*int32)(unsafe.Pointer((bp) /* &p[0] */ + 1*4))))
- *(*uint8_t)(unsafe.Pointer(probas + 2)) = uint8_t(GetProba(tls, *(*int32)(unsafe.Pointer((bp) /* &p[0] */ + 2*4)), *(*int32)(unsafe.Pointer((bp) /* &p[0] */ + 3*4))))
+ var probas uintptr = enc + 3616
+ *(*uint8_t)(unsafe.Pointer(probas)) = uint8_t(GetProba(tls, *(*int32)(unsafe.Pointer(bp))+*(*int32)(unsafe.Pointer(bp + 1*4)), *(*int32)(unsafe.Pointer(bp + 2*4))+*(*int32)(unsafe.Pointer(bp + 3*4))))
+ *(*uint8_t)(unsafe.Pointer(probas + 1)) = uint8_t(GetProba(tls, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 1*4))))
+ *(*uint8_t)(unsafe.Pointer(probas + 2)) = uint8_t(GetProba(tls, *(*int32)(unsafe.Pointer(bp + 2*4)), *(*int32)(unsafe.Pointer(bp + 3*4))))
- (*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.update_map_ = (libc.Bool32(((int32(*(*uint8_t)(unsafe.Pointer(probas))) != 255) || (int32(*(*uint8_t)(unsafe.Pointer(probas + 1))) != 255)) || (int32(*(*uint8_t)(unsafe.Pointer(probas + 2))) != 255)))
+ (*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.update_map_ = libc.Bool32(int32(*(*uint8_t)(unsafe.Pointer(probas))) != 255 || int32(*(*uint8_t)(unsafe.Pointer(probas + 1))) != 255 || int32(*(*uint8_t)(unsafe.Pointer(probas + 2))) != 255)
if !((*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.update_map_ != 0) {
ResetSegments(tls, enc)
}
- (*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.size_ = ((((*(*int32)(unsafe.Pointer((bp) /* &p[0] */)) * (VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(probas))) + VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(probas + 1))))) + (*(*int32)(unsafe.Pointer((bp) /* &p[0] */ + 1*4)) * (VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(probas))) + VP8BitCost(tls, 1, *(*uint8_t)(unsafe.Pointer(probas + 1)))))) + (*(*int32)(unsafe.Pointer((bp) /* &p[0] */ + 2*4)) * (VP8BitCost(tls, 1, *(*uint8_t)(unsafe.Pointer(probas))) + VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(probas + 2)))))) + (*(*int32)(unsafe.Pointer((bp) /* &p[0] */ + 3*4)) * (VP8BitCost(tls, 1, *(*uint8_t)(unsafe.Pointer(probas))) + VP8BitCost(tls, 1, *(*uint8_t)(unsafe.Pointer(probas + 2))))))
+ (*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.size_ = *(*int32)(unsafe.Pointer(bp))*(VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(probas)))+VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(probas + 1)))) + *(*int32)(unsafe.Pointer(bp + 1*4))*(VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(probas)))+VP8BitCost(tls, 1, *(*uint8_t)(unsafe.Pointer(probas + 1)))) + *(*int32)(unsafe.Pointer(bp + 2*4))*(VP8BitCost(tls, 1, *(*uint8_t)(unsafe.Pointer(probas)))+VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(probas + 2)))) + *(*int32)(unsafe.Pointer(bp + 3*4))*(VP8BitCost(tls, 1, *(*uint8_t)(unsafe.Pointer(probas)))+VP8BitCost(tls, 1, *(*uint8_t)(unsafe.Pointer(probas + 2))))
} else {
(*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.update_map_ = 0
(*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.size_ = 0
@@ -26309,75 +26022,75 @@ func SetSegmentProbas(tls *libc.TLS, enc uintptr) { /* frame_enc.c:198:13: */
func PutCoeffs(tls *libc.TLS, bw uintptr, ctx int32, res uintptr) int32 { /* frame_enc.c:236:12: */
var n int32 = (*VP8Residual)(unsafe.Pointer(res)).first
// should be prob[VP8EncBands[n]], but it's equivalent for n=0 or 1
- var p uintptr = (((*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(n)*33) + uintptr(ctx)*11)
- if !(VP8PutBit(tls, bw, (libc.Bool32((*VP8Residual)(unsafe.Pointer(res)).last >= 0)), int32(*(*uint8_t)(unsafe.Pointer(p)))) != 0) {
+ var p uintptr = (*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(n)*33 + uintptr(ctx)*11
+ if !(VP8PutBit(tls, bw, libc.Bool32((*VP8Residual)(unsafe.Pointer(res)).last >= 0), int32(*(*uint8_t)(unsafe.Pointer(p)))) != 0) {
return 0
}
for n < 16 {
var c int32 = int32(*(*int16_t)(unsafe.Pointer((*VP8Residual)(unsafe.Pointer(res)).coeffs + uintptr(libc.PostIncInt32(&n, 1))*2)))
- var sign int32 = (libc.Bool32(c < 0))
+ var sign int32 = libc.Bool32(c < 0)
var v int32
if sign != 0 {
v = -c
} else {
v = c
}
- if !(VP8PutBit(tls, bw, (libc.Bool32(v != 0)), int32(*(*uint8_t)(unsafe.Pointer(p + 1)))) != 0) {
- p = ((*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(VP8EncBands[n])*33)
+ if !(VP8PutBit(tls, bw, libc.Bool32(v != 0), int32(*(*uint8_t)(unsafe.Pointer(p + 1)))) != 0) {
+ p = (*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(VP8EncBands[n])*33
continue
}
- if !(VP8PutBit(tls, bw, (libc.Bool32(v > 1)), int32(*(*uint8_t)(unsafe.Pointer(p + 2)))) != 0) {
- p = (((*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(VP8EncBands[n])*33) + 1*11)
+ if !(VP8PutBit(tls, bw, libc.Bool32(v > 1), int32(*(*uint8_t)(unsafe.Pointer(p + 2)))) != 0) {
+ p = (*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(VP8EncBands[n])*33 + 1*11
} else {
- if !(VP8PutBit(tls, bw, (libc.Bool32(v > 4)), int32(*(*uint8_t)(unsafe.Pointer(p + 3)))) != 0) {
- if VP8PutBit(tls, bw, (libc.Bool32(v != 2)), int32(*(*uint8_t)(unsafe.Pointer(p + 4)))) != 0 {
- VP8PutBit(tls, bw, (libc.Bool32(v == 4)), int32(*(*uint8_t)(unsafe.Pointer(p + 5))))
+ if !(VP8PutBit(tls, bw, libc.Bool32(v > 4), int32(*(*uint8_t)(unsafe.Pointer(p + 3)))) != 0) {
+ if VP8PutBit(tls, bw, libc.Bool32(v != 2), int32(*(*uint8_t)(unsafe.Pointer(p + 4)))) != 0 {
+ VP8PutBit(tls, bw, libc.Bool32(v == 4), int32(*(*uint8_t)(unsafe.Pointer(p + 5))))
}
- } else if !(VP8PutBit(tls, bw, (libc.Bool32(v > 10)), int32(*(*uint8_t)(unsafe.Pointer(p + 6)))) != 0) {
- if !(VP8PutBit(tls, bw, (libc.Bool32(v > 6)), int32(*(*uint8_t)(unsafe.Pointer(p + 7)))) != 0) {
- VP8PutBit(tls, bw, (libc.Bool32(v == 6)), 159)
+ } else if !(VP8PutBit(tls, bw, libc.Bool32(v > 10), int32(*(*uint8_t)(unsafe.Pointer(p + 6)))) != 0) {
+ if !(VP8PutBit(tls, bw, libc.Bool32(v > 6), int32(*(*uint8_t)(unsafe.Pointer(p + 7)))) != 0) {
+ VP8PutBit(tls, bw, libc.Bool32(v == 6), 159)
} else {
- VP8PutBit(tls, bw, (libc.Bool32(v >= 9)), 165)
- VP8PutBit(tls, bw, libc.BoolInt32(!((v & 1) != 0)), 145)
+ VP8PutBit(tls, bw, libc.Bool32(v >= 9), 165)
+ VP8PutBit(tls, bw, libc.BoolInt32(!(v&1 != 0)), 145)
}
} else {
var mask int32
var tab uintptr
- if v < (3 + (int32(8) << 1)) { // VP8Cat3 (3b)
+ if v < 3+int32(8)<<1 { // VP8Cat3 (3b)
VP8PutBit(tls, bw, 0, int32(*(*uint8_t)(unsafe.Pointer(p + 8))))
VP8PutBit(tls, bw, 0, int32(*(*uint8_t)(unsafe.Pointer(p + 9))))
- v = v - (3 + (int32(8) << 0))
- mask = (int32(1) << 2)
+ v = v - (3 + int32(8)<<0)
+ mask = int32(1) << 2
tab = uintptr(unsafe.Pointer(&VP8Cat3))
- } else if v < (3 + (int32(8) << 2)) { // VP8Cat4 (4b)
+ } else if v < 3+int32(8)<<2 { // VP8Cat4 (4b)
VP8PutBit(tls, bw, 0, int32(*(*uint8_t)(unsafe.Pointer(p + 8))))
VP8PutBit(tls, bw, 1, int32(*(*uint8_t)(unsafe.Pointer(p + 9))))
- v = v - (3 + (int32(8) << 1))
- mask = (int32(1) << 3)
+ v = v - (3 + int32(8)<<1)
+ mask = int32(1) << 3
tab = uintptr(unsafe.Pointer(&VP8Cat4))
- } else if v < (3 + (int32(8) << 3)) { // VP8Cat5 (5b)
+ } else if v < 3+int32(8)<<3 { // VP8Cat5 (5b)
VP8PutBit(tls, bw, 1, int32(*(*uint8_t)(unsafe.Pointer(p + 8))))
VP8PutBit(tls, bw, 0, int32(*(*uint8_t)(unsafe.Pointer(p + 10))))
- v = v - (3 + (int32(8) << 2))
- mask = (int32(1) << 4)
+ v = v - (3 + int32(8)<<2)
+ mask = int32(1) << 4
tab = uintptr(unsafe.Pointer(&VP8Cat5))
} else { // VP8Cat6 (11b)
VP8PutBit(tls, bw, 1, int32(*(*uint8_t)(unsafe.Pointer(p + 8))))
VP8PutBit(tls, bw, 1, int32(*(*uint8_t)(unsafe.Pointer(p + 10))))
- v = v - (3 + (int32(8) << 3))
- mask = (int32(1) << 10)
+ v = v - (3 + int32(8)<<3)
+ mask = int32(1) << 10
tab = uintptr(unsafe.Pointer(&VP8Cat6))
}
for mask != 0 {
- VP8PutBit(tls, bw, libc.BoolInt32(!(!((v & mask) != 0))), int32(*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&tab, 1)))))
+ VP8PutBit(tls, bw, libc.BoolInt32(!!(v&mask != 0)), int32(*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&tab, 1)))))
mask >>= 1
}
}
- p = (((*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(VP8EncBands[n])*33) + 2*11)
+ p = (*VP8Residual)(unsafe.Pointer(res)).prob + uintptr(VP8EncBands[n])*33 + 2*11
}
VP8PutBitUniform(tls, bw, sign)
- if (n == 16) || !(VP8PutBit(tls, bw, (libc.Bool32(n <= (*VP8Residual)(unsafe.Pointer(res)).last)), int32(*(*uint8_t)(unsafe.Pointer(p)))) != 0) {
+ if n == 16 || !(VP8PutBit(tls, bw, libc.Bool32(n <= (*VP8Residual)(unsafe.Pointer(res)).last), int32(*(*uint8_t)(unsafe.Pointer(p)))) != 0) {
return 1 // EOB
}
}
@@ -26396,54 +26109,54 @@ func CodeResiduals(tls *libc.TLS, bw uintptr, it uintptr, rd uintptr) { /* frame
var pos1 uint64_t
var pos2 uint64_t
var pos3 uint64_t
- var i16 int32 = (libc.Bool32((int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.type_ */)) & 0x3 >> 0)) == 1))
- var segment int32 = (int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.segment_ */)) & 0x60 >> 5))
+ var i16 int32 = libc.Bool32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x3>>0) == 1)
+ var segment int32 = int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_)) & 0x60 >> 5)
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
VP8IteratorNzToBytes(tls, it)
pos1 = VP8BitWriterPos(tls, bw)
if i16 != 0 {
- VP8InitResidual(tls, 0, 1, enc, (bp) /* &res */)
+ VP8InitResidual(tls, 0, 1, enc, bp)
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, (rd + 40 /* &.y_dc_levels */), (bp) /* &res */)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + 8*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + 8*4), PutCoeffs(tls, bw, (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + 8*4))+*(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + 8*4))), (bp) /* &res */))
- VP8InitResidual(tls, 1, 0, enc, (bp) /* &res */)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+40 /* &.y_dc_levels */, bp /* &res */)
+ *(*int32)(unsafe.Pointer(it + 132 + 8*4)) = libc.AssignPtrInt32(it+168+8*4, PutCoeffs(tls, bw, *(*int32)(unsafe.Pointer(it + 132 + 8*4))+*(*int32)(unsafe.Pointer(it + 168 + 8*4)), bp))
+ VP8InitResidual(tls, 1, 0, enc, bp)
} else {
- VP8InitResidual(tls, 0, 3, enc, (bp) /* &res */)
+ VP8InitResidual(tls, 0, 3, enc, bp)
}
// luma-AC
for y = 0; y < 4; y++ {
for x = 0; x < 4; x++ {
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(y)*4)))
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(y)*4))
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, ((rd + 72 /* &.y_ac_levels */) + uintptr((x+(y*4)))*32), (bp) /* &res */)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + uintptr(y)*4), PutCoeffs(tls, bw, ctx, (bp) /* &res */))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+72 /* &.y_ac_levels */ +uintptr(x+y*4)*32, bp /* &res */)
+ *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) = libc.AssignPtrInt32(it+168+uintptr(y)*4, PutCoeffs(tls, bw, ctx, bp /* &res */))
}
}
pos2 = VP8BitWriterPos(tls, bw)
// U/V
- VP8InitResidual(tls, 0, 2, enc, (bp) /* &res */)
- for ch = 0; ch <= 2; ch = ch + (2) {
+ VP8InitResidual(tls, 0, 2, enc, bp)
+ for ch = 0; ch <= 2; ch = ch + 2 {
for y = 0; y < 2; y++ {
for x = 0; x < 2; x++ {
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(((4+ch)+x))*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(((4+ch)+y))*4)))
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + uintptr(4+ch+x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(4+ch+y)*4))
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, ((rd + 584 /* &.uv_levels */) + uintptr((((ch*2)+x)+(y*2)))*32), (bp) /* &res */)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(((4+ch)+x))*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + uintptr(((4+ch)+y))*4), PutCoeffs(tls, bw, ctx, (bp) /* &res */))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+584 /* &.uv_levels */ +uintptr(ch*2+x+y*2)*32, bp /* &res */)
+ *(*int32)(unsafe.Pointer(it + 132 + uintptr(4+ch+x)*4)) = libc.AssignPtrInt32(it+168+uintptr(4+ch+y)*4, PutCoeffs(tls, bw, ctx, bp /* &res */))
}
}
}
pos3 = VP8BitWriterPos(tls, bw)
- (*VP8EncIterator)(unsafe.Pointer(it)).luma_bits_ = (pos2 - pos1)
- (*VP8EncIterator)(unsafe.Pointer(it)).uv_bits_ = (pos3 - pos2)
- *(*uint64_t)(unsafe.Pointer((((it + 208 /* &.bit_count_ */) + uintptr(segment)*24) + uintptr(i16)*8))) += ((*VP8EncIterator)(unsafe.Pointer(it)).luma_bits_)
- *(*uint64_t)(unsafe.Pointer((((it + 208 /* &.bit_count_ */) + uintptr(segment)*24) + 2*8))) += ((*VP8EncIterator)(unsafe.Pointer(it)).uv_bits_)
+ (*VP8EncIterator)(unsafe.Pointer(it)).luma_bits_ = pos2 - pos1
+ (*VP8EncIterator)(unsafe.Pointer(it)).uv_bits_ = pos3 - pos2
+ *(*uint64_t)(unsafe.Pointer(it + 208 + uintptr(segment)*24 + uintptr(i16)*8)) += (*VP8EncIterator)(unsafe.Pointer(it)).luma_bits_
+ *(*uint64_t)(unsafe.Pointer(it + 208 + uintptr(segment)*24 + 2*8)) += (*VP8EncIterator)(unsafe.Pointer(it)).uv_bits_
VP8IteratorBytesToNz(tls, it)
}
@@ -26462,38 +26175,38 @@ func RecordResiduals(tls *libc.TLS, it uintptr, rd uintptr) { /* frame_enc.c:363
VP8IteratorNzToBytes(tls, it)
- if (int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.type_ */)) & 0x3 >> 0)) == 1 { // i16x16
- VP8InitResidual(tls, 0, 1, enc, (bp) /* &res */)
+ if int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x3>>0) == 1 { // i16x16
+ VP8InitResidual(tls, 0, 1, enc, bp)
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, (rd + 40 /* &.y_dc_levels */), (bp) /* &res */)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + 8*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + 8*4), VP8RecordCoeffs(tls, (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + 8*4))+*(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + 8*4))), (bp) /* &res */))
- VP8InitResidual(tls, 1, 0, enc, (bp) /* &res */)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+40 /* &.y_dc_levels */, bp /* &res */)
+ *(*int32)(unsafe.Pointer(it + 132 + 8*4)) = libc.AssignPtrInt32(it+168+8*4, VP8RecordCoeffs(tls, *(*int32)(unsafe.Pointer(it + 132 + 8*4))+*(*int32)(unsafe.Pointer(it + 168 + 8*4)), bp))
+ VP8InitResidual(tls, 1, 0, enc, bp)
} else {
- VP8InitResidual(tls, 0, 3, enc, (bp) /* &res */)
+ VP8InitResidual(tls, 0, 3, enc, bp)
}
// luma-AC
for y = 0; y < 4; y++ {
for x = 0; x < 4; x++ {
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(y)*4)))
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(y)*4))
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, ((rd + 72 /* &.y_ac_levels */) + uintptr((x+(y*4)))*32), (bp) /* &res */)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + uintptr(y)*4), VP8RecordCoeffs(tls, ctx, (bp) /* &res */))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+72 /* &.y_ac_levels */ +uintptr(x+y*4)*32, bp /* &res */)
+ *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) = libc.AssignPtrInt32(it+168+uintptr(y)*4, VP8RecordCoeffs(tls, ctx, bp /* &res */))
}
}
// U/V
- VP8InitResidual(tls, 0, 2, enc, (bp) /* &res */)
- for ch = 0; ch <= 2; ch = ch + (2) {
+ VP8InitResidual(tls, 0, 2, enc, bp)
+ for ch = 0; ch <= 2; ch = ch + 2 {
for y = 0; y < 2; y++ {
for x = 0; x < 2; x++ {
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(((4+ch)+x))*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(((4+ch)+y))*4)))
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + uintptr(4+ch+x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(4+ch+y)*4))
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, ((rd + 584 /* &.uv_levels */) + uintptr((((ch*2)+x)+(y*2)))*32), (bp) /* &res */)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(((4+ch)+x))*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + uintptr(((4+ch)+y))*4), VP8RecordCoeffs(tls, ctx, (bp) /* &res */))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+584 /* &.uv_levels */ +uintptr(ch*2+x+y*2)*32, bp /* &res */)
+ *(*int32)(unsafe.Pointer(it + 132 + uintptr(4+ch+x)*4)) = libc.AssignPtrInt32(it+168+uintptr(4+ch+y)*4, VP8RecordCoeffs(tls, ctx, bp /* &res */))
}
}
}
@@ -26516,39 +26229,39 @@ func RecordTokens(tls *libc.TLS, it uintptr, rd uintptr, tokens uintptr) int32 {
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
VP8IteratorNzToBytes(tls, it)
- if (int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.type_ */)) & 0x3 >> 0)) == 1 { // i16x16
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + 8*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + 8*4)))
- VP8InitResidual(tls, 0, 1, enc, (bp) /* &res */)
+ if int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x3>>0) == 1 { // i16x16
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + 8*4)) + *(*int32)(unsafe.Pointer(it + 168 + 8*4))
+ VP8InitResidual(tls, 0, 1, enc, bp)
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, (rd + 40 /* &.y_dc_levels */), (bp) /* &res */)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + 8*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + 8*4), VP8RecordCoeffTokens(tls, ctx, (bp) /* &res */, tokens))
- VP8InitResidual(tls, 1, 0, enc, (bp) /* &res */)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+40 /* &.y_dc_levels */, bp /* &res */)
+ *(*int32)(unsafe.Pointer(it + 132 + 8*4)) = libc.AssignPtrInt32(it+168+8*4, VP8RecordCoeffTokens(tls, ctx, bp, tokens))
+ VP8InitResidual(tls, 1, 0, enc, bp)
} else {
- VP8InitResidual(tls, 0, 3, enc, (bp) /* &res */)
+ VP8InitResidual(tls, 0, 3, enc, bp)
}
// luma-AC
for y = 0; y < 4; y++ {
for x = 0; x < 4; x++ {
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(y)*4)))
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(y)*4))
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, ((rd + 72 /* &.y_ac_levels */) + uintptr((x+(y*4)))*32), (bp) /* &res */)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + uintptr(y)*4), VP8RecordCoeffTokens(tls, ctx, (bp) /* &res */, tokens))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+72 /* &.y_ac_levels */ +uintptr(x+y*4)*32, bp /* &res */)
+ *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) = libc.AssignPtrInt32(it+168+uintptr(y)*4, VP8RecordCoeffTokens(tls, ctx, bp, tokens))
}
}
// U/V
- VP8InitResidual(tls, 0, 2, enc, (bp) /* &res */)
- for ch = 0; ch <= 2; ch = ch + (2) {
+ VP8InitResidual(tls, 0, 2, enc, bp)
+ for ch = 0; ch <= 2; ch = ch + 2 {
for y = 0; y < 2; y++ {
for x = 0; x < 2; x++ {
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(((4+ch)+x))*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(((4+ch)+y))*4)))
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + uintptr(4+ch+x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(4+ch+y)*4))
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, ((rd + 584 /* &.uv_levels */) + uintptr((((ch*2)+x)+(y*2)))*32), (bp) /* &res */)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(((4+ch)+x))*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + uintptr(((4+ch)+y))*4), VP8RecordCoeffTokens(tls, ctx, (bp) /* &res */, tokens))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})).f(tls, rd+584 /* &.uv_levels */ +uintptr(ch*2+x+y*2)*32, bp /* &res */)
+ *(*int32)(unsafe.Pointer(it + 132 + uintptr(4+ch+x)*4)) = libc.AssignPtrInt32(it+168+uintptr(4+ch+y)*4, VP8RecordCoeffTokens(tls, ctx, bp, tokens))
}
}
}
@@ -26560,9 +26273,9 @@ func RecordTokens(tls *libc.TLS, it uintptr, rd uintptr, tokens uintptr) int32 {
// ExtraInfo map / Debug function
func ResetSSE(tls *libc.TLS, enc uintptr) { /* frame_enc.c:472:13: */
- *(*uint64_t)(unsafe.Pointer((enc + 23512 /* &.sse_ */))) = uint64(0)
- *(*uint64_t)(unsafe.Pointer((enc + 23512 /* &.sse_ */) + 1*8)) = uint64(0)
- *(*uint64_t)(unsafe.Pointer((enc + 23512 /* &.sse_ */) + 2*8)) = uint64(0)
+ *(*uint64_t)(unsafe.Pointer(enc + 23512)) = uint64(0)
+ *(*uint64_t)(unsafe.Pointer(enc + 23512 + 1*8)) = uint64(0)
+ *(*uint64_t)(unsafe.Pointer(enc + 23512 + 2*8)) = uint64(0)
// Note: enc->sse_[3] is managed by alpha.c
(*VP8Encoder)(unsafe.Pointer(enc)).sse_count_ = uint64(0)
}
@@ -26572,16 +26285,16 @@ func StoreSSE(tls *libc.TLS, it uintptr) { /* frame_enc.c:480:13: */
var in uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_
var out uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_
// Note: not totally accurate at boundary. And doesn't include in-loop filter.
- *(*uint64_t)(unsafe.Pointer((enc + 23512 /* &.sse_ */))) += (uint64_t((*struct {
+ *(*uint64_t)(unsafe.Pointer(enc + 23512)) += uint64_t((*struct {
f func(*libc.TLS, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x16})).f(tls, (in + uintptr((0))), (out + uintptr((0))))))
- *(*uint64_t)(unsafe.Pointer(((enc + 23512 /* &.sse_ */) + 1*8))) += (uint64_t((*struct {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x16})).f(tls, in+uintptr(0), out+uintptr(0)))
+ *(*uint64_t)(unsafe.Pointer(enc + 23512 + 1*8)) += uint64_t((*struct {
f func(*libc.TLS, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSE8x8})).f(tls, (in + uintptr((16))), (out + uintptr((16))))))
- *(*uint64_t)(unsafe.Pointer(((enc + 23512 /* &.sse_ */) + 2*8))) += (uint64_t((*struct {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSE8x8})).f(tls, in+uintptr(16), out+uintptr(16)))
+ *(*uint64_t)(unsafe.Pointer(enc + 23512 + 2*8)) += uint64_t((*struct {
f func(*libc.TLS, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSE8x8})).f(tls, (in + uintptr((16 + 8))), (out + uintptr((16 + 8))))))
- *(*uint64_t)(unsafe.Pointer((enc + 23544 /* &.sse_count_ */))) += (uint64(16 * 16))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSE8x8})).f(tls, in+uintptr(16+8), out+uintptr(16+8)))
+ *(*uint64_t)(unsafe.Pointer(enc + 23544)) += uint64(16 * 16)
}
func StoreSideInfo(tls *libc.TLS, it uintptr) { /* frame_enc.c:491:13: */
@@ -26589,31 +26302,31 @@ func StoreSideInfo(tls *libc.TLS, it uintptr) { /* frame_enc.c:491:13: */
var mb uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).mb_
var pic uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).pic_
- if (*WebPPicture)(unsafe.Pointer(pic)).stats != (uintptr(0)) {
+ if (*WebPPicture)(unsafe.Pointer(pic)).stats != uintptr(0) {
StoreSSE(tls, it)
- *(*int32)(unsafe.Pointer((enc + 23604 /* &.block_count_ */))) += (libc.Bool32((int32(*(*uint8)(unsafe.Pointer(mb /* &.type_ */)) & 0x3 >> 0)) == 0))
- *(*int32)(unsafe.Pointer(((enc + 23604 /* &.block_count_ */) + 1*4))) += (libc.Bool32((int32(*(*uint8)(unsafe.Pointer(mb /* &.type_ */)) & 0x3 >> 0)) == 1))
- *(*int32)(unsafe.Pointer(((enc + 23604 /* &.block_count_ */) + 2*4))) += (libc.Bool32((int32(*(*uint8)(unsafe.Pointer(mb /* &.skip_ */)) & 0x10 >> 4)) != 0))
+ *(*int32)(unsafe.Pointer(enc + 23604)) += libc.Bool32(int32(*(*uint8)(unsafe.Pointer(mb))&0x3>>0) == 0)
+ *(*int32)(unsafe.Pointer(enc + 23604 + 1*4)) += libc.Bool32(int32(*(*uint8)(unsafe.Pointer(mb))&0x3>>0) == 1)
+ *(*int32)(unsafe.Pointer(enc + 23604 + 2*4)) += libc.Bool32(int32(*(*uint8)(unsafe.Pointer(mb))&0x10>>4) != 0)
}
- if (*WebPPicture)(unsafe.Pointer(pic)).extra_info != (uintptr(0)) {
- var info uintptr = ((*WebPPicture)(unsafe.Pointer(pic)).extra_info + uintptr(((*VP8EncIterator)(unsafe.Pointer(it)).x_ + ((*VP8EncIterator)(unsafe.Pointer(it)).y_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_))))
+ if (*WebPPicture)(unsafe.Pointer(pic)).extra_info != uintptr(0) {
+ var info uintptr = (*WebPPicture)(unsafe.Pointer(pic)).extra_info + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).x_+(*VP8EncIterator)(unsafe.Pointer(it)).y_*(*VP8Encoder)(unsafe.Pointer(enc)).mb_w_)
switch (*WebPPicture)(unsafe.Pointer(pic)).extra_info_type {
case 1:
- *(*uint8_t)(unsafe.Pointer(info)) = (uint8_t(int32(*(*uint8)(unsafe.Pointer(mb /* &.type_ */)) & 0x3 >> 0)))
+ *(*uint8_t)(unsafe.Pointer(info)) = uint8_t(int32(*(*uint8)(unsafe.Pointer(mb)) & 0x3 >> 0))
break
fallthrough
case 2:
- *(*uint8_t)(unsafe.Pointer(info)) = (uint8_t(int32(*(*uint8)(unsafe.Pointer(mb /* &.segment_ */)) & 0x60 >> 5)))
+ *(*uint8_t)(unsafe.Pointer(info)) = uint8_t(int32(*(*uint8)(unsafe.Pointer(mb)) & 0x60 >> 5))
break
fallthrough
case 3:
- *(*uint8_t)(unsafe.Pointer(info)) = uint8_t((*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer(mb /* &.segment_ */))&0x60>>5))))*744)).quant_)
+ *(*uint8_t)(unsafe.Pointer(info)) = uint8_t((*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer(mb))&0x60>>5)))*744)).quant_)
break
fallthrough
case 4:
*(*uint8_t)(unsafe.Pointer(info)) = func() uint8 {
- if (int32(*(*uint8)(unsafe.Pointer(mb /* &.type_ */)) & 0x3 >> 0)) == 1 {
+ if int32(*(*uint8)(unsafe.Pointer(mb))&0x3>>0) == 1 {
return *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).preds_))
}
return uint8(0xff)
@@ -26621,12 +26334,12 @@ func StoreSideInfo(tls *libc.TLS, it uintptr) { /* frame_enc.c:491:13: */
break
fallthrough
case 5:
- *(*uint8_t)(unsafe.Pointer(info)) = (uint8_t(int32(*(*uint8)(unsafe.Pointer(mb /* &.uv_mode_ */)) & 0xc >> 2)))
+ *(*uint8_t)(unsafe.Pointer(info)) = uint8_t(int32(*(*uint8)(unsafe.Pointer(mb)) & 0xc >> 2))
break
fallthrough
case 6:
{
- var b int32 = (int32((((*VP8EncIterator)(unsafe.Pointer(it)).luma_bits_ + (*VP8EncIterator)(unsafe.Pointer(it)).uv_bits_) + uint64(7)) >> 3))
+ var b int32 = int32(((*VP8EncIterator)(unsafe.Pointer(it)).luma_bits_ + (*VP8EncIterator)(unsafe.Pointer(it)).uv_bits_ + uint64(7)) >> 3)
*(*uint8_t)(unsafe.Pointer(info)) = func() uint8 {
if b > 255 {
return uint8(255)
@@ -26651,15 +26364,15 @@ func StoreSideInfo(tls *libc.TLS, it uintptr) { /* frame_enc.c:491:13: */
func ResetSideInfo(tls *libc.TLS, it uintptr) { /* frame_enc.c:526:13: */
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
var pic uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).pic_
- if (*WebPPicture)(unsafe.Pointer(pic)).stats != (uintptr(0)) {
- libc.Xmemset(tls, (enc + 23604 /* &.block_count_ */), 0, uint64(unsafe.Sizeof([3]int32{})))
+ if (*WebPPicture)(unsafe.Pointer(pic)).stats != uintptr(0) {
+ libc.Xmemset(tls, enc+23604, 0, uint64(unsafe.Sizeof([3]int32{})))
}
ResetSSE(tls, enc)
}
func GetPSNR(tls *libc.TLS, mse uint64_t, size uint64_t) float64 { /* frame_enc.c:554:15: */
- if (mse > uint64(0)) && (size > uint64(0)) {
- return (10. * libc.Xlog10(tls, (((float64(255.)*255.)*float64(size))/float64(mse))))
+ if mse > uint64(0) && size > uint64(0) {
+ return 10. * libc.Xlog10(tls, float64(255.)*255.*float64(size)/float64(mse))
}
return float64(99)
}
@@ -26689,33 +26402,33 @@ func OneStatPass(tls *libc.TLS, enc uintptr, rd_opt VP8RDLevel, nb_mbs int32, pe
var size uint64_t = uint64(0)
var size_p0 uint64_t = uint64(0)
var distortion uint64_t = uint64(0)
- var pixel_count uint64_t = (uint64_t(nb_mbs * 384))
+ var pixel_count uint64_t = uint64_t(nb_mbs * 384)
- VP8IteratorInit(tls, enc, (bp) /* &it */)
+ VP8IteratorInit(tls, enc, bp)
SetLoopParams(tls, enc, (*PassStats)(unsafe.Pointer(s)).q)
- for ok := true; ok; ok = ((VP8IteratorNext(tls, (bp) /* &it */) != 0) && (libc.PreDecInt32(&nb_mbs, 1) > 0)) {
+ for __ccgo := true; __ccgo; __ccgo = VP8IteratorNext(tls, bp) != 0 && libc.PreDecInt32(&nb_mbs, 1) > 0 {
// var info VP8ModeScore at bp+3848, 880
- VP8IteratorImport(tls, (bp) /* &it */, (uintptr(0)))
- if VP8Decimate(tls, (bp) /* &it */, (bp+3848) /* &info */, rd_opt) != 0 {
+ VP8IteratorImport(tls, bp, uintptr(0))
+ if VP8Decimate(tls, bp, bp+3848, rd_opt) != 0 {
// Just record the number of skips and act like skip_proba is not used.
(*VP8Encoder)(unsafe.Pointer(enc)).proba_.nb_skip_++
}
- RecordResiduals(tls, (bp) /* &it */, (bp + 3848) /* &info */)
- size = size + (uint64_t((*VP8ModeScore)(unsafe.Pointer(bp+3848 /* &info */)).R + (*VP8ModeScore)(unsafe.Pointer(bp+3848 /* &info */)).H))
- size_p0 = size_p0 + (uint64_t((*VP8ModeScore)(unsafe.Pointer(bp + 3848 /* &info */)).H))
- distortion = distortion + (uint64_t((*VP8ModeScore)(unsafe.Pointer(bp + 3848 /* &info */)).D))
- if (percent_delta != 0) && !(VP8IteratorProgress(tls, (bp) /* &it */, percent_delta) != 0) {
+ RecordResiduals(tls, bp, bp+3848)
+ size = size + uint64_t((*VP8ModeScore)(unsafe.Pointer(bp+3848)).R+(*VP8ModeScore)(unsafe.Pointer(bp+3848)).H)
+ size_p0 = size_p0 + uint64_t((*VP8ModeScore)(unsafe.Pointer(bp+3848)).H)
+ distortion = distortion + uint64_t((*VP8ModeScore)(unsafe.Pointer(bp+3848)).D)
+ if percent_delta != 0 && !(VP8IteratorProgress(tls, bp, percent_delta) != 0) {
return uint64(0)
}
- VP8IteratorSaveBoundary(tls, (bp) /* &it */)
+ VP8IteratorSaveBoundary(tls, bp)
}
- size_p0 = size_p0 + (uint64_t((*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.size_))
+ size_p0 = size_p0 + uint64_t((*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.size_)
if (*PassStats)(unsafe.Pointer(s)).do_size_search != 0 {
- size = size + (uint64_t(FinalizeSkipProba(tls, enc)))
- size = size + (uint64_t(FinalizeTokenProbas(tls, (enc + 3616 /* &.proba_ */))))
- size = ((((size + size_p0) + uint64(1024)) >> 11) + (uint64((12 + 8) + 10)))
+ size = size + uint64_t(FinalizeSkipProba(tls, enc))
+ size = size + uint64_t(FinalizeTokenProbas(tls, enc+3616))
+ size = (size+size_p0+uint64(1024))>>11 + uint64(12+8+10)
(*PassStats)(unsafe.Pointer(s)).value = float64(size)
} else {
(*PassStats)(unsafe.Pointer(s)).value = GetPSNR(tls, distortion, pixel_count)
@@ -26729,34 +26442,34 @@ func StatLoop(tls *libc.TLS, enc uintptr) int32 { /* frame_enc.c:614:12: */
var method int32 = (*VP8Encoder)(unsafe.Pointer(enc)).method_
var do_search int32 = (*VP8Encoder)(unsafe.Pointer(enc)).do_search_
- var fast_probe int32 = (libc.Bool32(((method == 0) || (method == 3)) && !(do_search != 0)))
+ var fast_probe int32 = libc.Bool32((method == 0 || method == 3) && !(do_search != 0))
var num_pass_left int32 = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).pass
var task_percent int32 = 20
- var percent_per_pass int32 = ((task_percent + (num_pass_left / 2)) / num_pass_left)
- var final_percent int32 = ((*VP8Encoder)(unsafe.Pointer(enc)).percent_ + task_percent)
+ var percent_per_pass int32 = (task_percent + num_pass_left/2) / num_pass_left
+ var final_percent int32 = (*VP8Encoder)(unsafe.Pointer(enc)).percent_ + task_percent
var rd_opt VP8RDLevel
- if (method >= 3) || (do_search != 0) {
+ if method >= 3 || do_search != 0 {
rd_opt = RD_OPT_BASIC
} else {
rd_opt = RD_OPT_NONE
}
- var nb_mbs int32 = ((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_)
+ var nb_mbs int32 = (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_
// var stats PassStats at bp, 56
- InitPassStats(tls, enc, (bp) /* &stats */)
+ InitPassStats(tls, enc, bp)
ResetTokenStats(tls, enc)
// Fast mode: quick analysis pass over few mbs. Better than nothing.
if fast_probe != 0 {
if method == 3 { // we need more stats for method 3 to be reliable.
if nb_mbs > 200 {
- nb_mbs = (nb_mbs >> 1)
+ nb_mbs = nb_mbs >> 1
} else {
nb_mbs = 100
}
} else {
if nb_mbs > 200 {
- nb_mbs = (nb_mbs >> 2)
+ nb_mbs = nb_mbs >> 2
} else {
nb_mbs = 50
}
@@ -26764,34 +26477,34 @@ func StatLoop(tls *libc.TLS, enc uintptr) int32 { /* frame_enc.c:614:12: */
}
for libc.PostDecInt32(&num_pass_left, 1) > 0 {
- var is_last_pass int32 = (libc.Bool32(((libc.Xfabs(tls, float64((*PassStats)(unsafe.Pointer(bp /* &stats */)).dq)) <= 0.4) || (num_pass_left == 0)) || ((*VP8Encoder)(unsafe.Pointer(enc)).max_i4_header_bits_ == 0)))
- var size_p0 uint64_t = OneStatPass(tls, enc, rd_opt, nb_mbs, percent_per_pass, (bp) /* &stats */)
+ var is_last_pass int32 = libc.Bool32(libc.Xfabs(tls, float64((*PassStats)(unsafe.Pointer(bp)).dq)) <= 0.4 || num_pass_left == 0 || (*VP8Encoder)(unsafe.Pointer(enc)).max_i4_header_bits_ == 0)
+ var size_p0 uint64_t = OneStatPass(tls, enc, rd_opt, nb_mbs, percent_per_pass, bp)
if size_p0 == uint64(0) {
return 0
}
- if ((*VP8Encoder)(unsafe.Pointer(enc)).max_i4_header_bits_ > 0) && (uint64(size_p0) > (uint64(((uint64(int32(1) << 19)) - 2048)) << 11)) {
+ if (*VP8Encoder)(unsafe.Pointer(enc)).max_i4_header_bits_ > 0 && uint64(size_p0) > uint64(uint64(int32(1)<<19)-2048)<<11 {
num_pass_left++
- libc.AssignShrPtrInt32((enc + 23624 /* &.max_i4_header_bits_ */), int(1)) // strengthen header bit limitation...
- continue // ...and start over
+ libc.AssignShrPtrInt32(enc+23624, int(1)) // strengthen header bit limitation...
+ continue // ...and start over
}
if is_last_pass != 0 {
break
}
// If no target size: just do several pass without changing 'q'
if do_search != 0 {
- ComputeNextQ(tls, (bp) /* &stats */)
- if libc.Xfabs(tls, float64((*PassStats)(unsafe.Pointer(bp /* &stats */)).dq)) <= 0.4 {
+ ComputeNextQ(tls, bp)
+ if libc.Xfabs(tls, float64((*PassStats)(unsafe.Pointer(bp)).dq)) <= 0.4 {
break
}
}
}
- if !(do_search != 0) || !((*PassStats)(unsafe.Pointer(bp /* &stats */)).do_size_search != 0) {
+ if !(do_search != 0) || !((*PassStats)(unsafe.Pointer(bp)).do_size_search != 0) {
// Need to finalize probas now, since it wasn't done during the search.
FinalizeSkipProba(tls, enc)
- FinalizeTokenProbas(tls, (enc + 3616 /* &.proba_ */))
+ FinalizeTokenProbas(tls, enc+3616)
}
- VP8CalculateLevelCosts(tls, (enc + 3616 /* &.proba_ */)) // finalize costs
- return WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, final_percent, (enc + 536 /* &.percent_ */))
+ VP8CalculateLevelCosts(tls, enc+3616) // finalize costs
+ return WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, final_percent, enc+536 /* &.percent_ */)
}
//------------------------------------------------------------------------------
@@ -26803,11 +26516,11 @@ var kAverageBytesPerMB = [8]uint8_t{uint8_t(50), uint8_t(24), uint8_t(16), uint8
func PreLoopInitialize(tls *libc.TLS, enc uintptr) int32 { /* frame_enc.c:680:12: */
var p int32
var ok int32 = 1
- var average_bytes_per_MB int32 = int32(kAverageBytesPerMB[((*VP8Encoder)(unsafe.Pointer(enc)).base_quant_ >> 4)])
- var bytes_per_parts int32 = ((((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_) * average_bytes_per_MB) / (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_)
+ var average_bytes_per_MB int32 = int32(kAverageBytesPerMB[(*VP8Encoder)(unsafe.Pointer(enc)).base_quant_>>4])
+ var bytes_per_parts int32 = (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_ * average_bytes_per_MB / (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_
// Initialize the bit-writers
- for p = 0; (ok != 0) && (p < (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_); p++ {
- ok = VP8BitWriterInit(tls, ((enc + 112 /* &.parts_ */) + uintptr(p)*48), uint64(bytes_per_parts))
+ for p = 0; ok != 0 && p < (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_; p++ {
+ ok = VP8BitWriterInit(tls, enc+112+uintptr(p)*48, uint64(bytes_per_parts))
}
if !(ok != 0) {
VP8EncFreeBitWriters(tls, enc) // malloc error occurred
@@ -26821,18 +26534,18 @@ func PostLoopFinalize(tls *libc.TLS, it uintptr, ok int32) int32 { /* frame_enc.
if ok != 0 { // Finalize the partitions, check for extra errors.
var p int32
for p = 0; p < (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_; p++ {
- VP8BitWriterFinish(tls, ((enc + 112 /* &.parts_ */) + uintptr(p)*48))
- ok = ok & (libc.BoolInt32(!((*VP8BitWriter)(unsafe.Pointer((enc+112 /* &.parts_ */)+uintptr(p)*48)).error_ != 0)))
+ VP8BitWriterFinish(tls, enc+112+uintptr(p)*48)
+ ok = ok & libc.BoolInt32(!((*VP8BitWriter)(unsafe.Pointer(enc+112+uintptr(p)*48)).error_ != 0))
}
}
if ok != 0 { // All good. Finish up.
- if (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats != (uintptr(0)) { // finalize byte counters...
+ if (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats != uintptr(0) { // finalize byte counters...
var i int32
var s int32
for i = 0; i <= 2; i++ {
for s = 0; s < NUM_MB_SEGMENTS; s++ {
- *(*int32)(unsafe.Pointer(((enc + 23556 /* &.residual_bytes_ */) + uintptr(i)*16) + uintptr(s)*4)) = (int32((*(*uint64_t)(unsafe.Pointer(((it + 208 /* &.bit_count_ */) + uintptr(s)*24) + uintptr(i)*8)) + uint64(7)) >> 3))
+ *(*int32)(unsafe.Pointer(enc + 23556 + uintptr(i)*16 + uintptr(s)*4)) = int32((*(*uint64_t)(unsafe.Pointer(it + 208 + uintptr(s)*24 + uintptr(i)*8)) + uint64(7)) >> 3)
}
}
}
@@ -26848,11 +26561,11 @@ func PostLoopFinalize(tls *libc.TLS, it uintptr, ok int32) int32 { /* frame_enc.
// VP8EncLoop(): does the final bitstream coding.
func ResetAfterSkip(tls *libc.TLS, it uintptr) { /* frame_enc.c:729:13: */
- if (int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.type_ */)) & 0x3 >> 0)) == 1 {
+ if int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x3>>0) == 1 {
*(*uint32_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).nz_)) = uint32_t(0) // reset all predictors
- *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + 8*4)) = 0
+ *(*int32)(unsafe.Pointer(it + 168 + 8*4)) = 0
} else {
- *(*uint32_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).nz_)) &= (uint32_t(int32(1) << 24)) // preserve the dc_nz bit
+ *(*uint32_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).nz_)) &= uint32_t(int32(1) << 24) // preserve the dc_nz bit
}
}
@@ -26869,30 +26582,30 @@ func VP8EncLoop(tls *libc.TLS, enc uintptr) int32 { /* frame_enc.c:738:5: */
StatLoop(tls, enc) // stats-collection loop
- VP8IteratorInit(tls, enc, (bp) /* &it */)
- VP8InitFilter(tls, (bp) /* &it */)
- for ok := int32(1); ok == 1; ok = VP8IteratorNext(tls, (bp) /* &it */) {
+ VP8IteratorInit(tls, enc, bp)
+ VP8InitFilter(tls, bp)
+ for __ccgo := true; __ccgo; __ccgo = ok != 0 && VP8IteratorNext(tls, bp) != 0 {
// var info VP8ModeScore at bp+3848, 880
var dont_use_skip int32 = libc.BoolInt32(!((*VP8Encoder)(unsafe.Pointer(enc)).proba_.use_skip_proba_ != 0))
var rd_opt VP8RDLevel = (*VP8Encoder)(unsafe.Pointer(enc)).rd_opt_level_
- VP8IteratorImport(tls, (bp) /* &it */, (uintptr(0)))
+ VP8IteratorImport(tls, bp, uintptr(0))
// Warning! order is important: first call VP8Decimate() and
// *then* decide how to code the skip decision if there's one.
- if !(VP8Decimate(tls, (bp) /* &it */, (bp+3848) /* &info */, rd_opt) != 0) || (dont_use_skip != 0) {
- CodeResiduals(tls, (*VP8EncIterator)(unsafe.Pointer(bp /* &it */)).bw_, (bp) /* &it */, (bp + 3848) /* &info */)
+ if !(VP8Decimate(tls, bp, bp+3848, rd_opt) != 0) || dont_use_skip != 0 {
+ CodeResiduals(tls, (*VP8EncIterator)(unsafe.Pointer(bp /* &it */)).bw_, bp, bp+3848)
} else { // reset predictors after a skip
- ResetAfterSkip(tls, (bp) /* &it */)
+ ResetAfterSkip(tls, bp)
}
- StoreSideInfo(tls, (bp) /* &it */)
- VP8StoreFilterStats(tls, (bp) /* &it */)
- VP8IteratorExport(tls, (bp) /* &it */)
- ok = VP8IteratorProgress(tls, (bp) /* &it */, 20)
- VP8IteratorSaveBoundary(tls, (bp) /* &it */)
+ StoreSideInfo(tls, bp)
+ VP8StoreFilterStats(tls, bp)
+ VP8IteratorExport(tls, bp)
+ ok = VP8IteratorProgress(tls, bp, 20)
+ VP8IteratorSaveBoundary(tls, bp)
}
- return PostLoopFinalize(tls, (bp) /* &it */, ok)
+ return PostLoopFinalize(tls, bp, ok)
}
//------------------------------------------------------------------------------
@@ -26903,20 +26616,20 @@ func VP8EncTokenLoop(tls *libc.TLS, enc uintptr) int32 { /* frame_enc.c:777:5: *
defer tls.Free(4784)
// Roughly refresh the proba eight times per pass
- var max_count int32 = (((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_) >> 3)
+ var max_count int32 = (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_ >> 3
var num_pass_left int32 = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).pass
var remaining_progress int32 = 40 // percents
var do_search int32 = (*VP8Encoder)(unsafe.Pointer(enc)).do_search_
// var it VP8EncIterator at bp+56, 3848
- var proba uintptr = (enc + 3616 /* &.proba_ */)
+ var proba uintptr = enc + 3616
var rd_opt VP8RDLevel = (*VP8Encoder)(unsafe.Pointer(enc)).rd_opt_level_
- var pixel_count uint64_t = (uint64_t(((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_) * 384))
+ var pixel_count uint64_t = uint64_t((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_ * 384)
// var stats PassStats at bp, 56
var ok int32
- InitPassStats(tls, enc, (bp) /* &stats */)
+ InitPassStats(tls, enc, bp)
ok = PreLoopInitialize(tls, enc)
if !(ok != 0) {
return 0
@@ -26928,67 +26641,67 @@ func VP8EncTokenLoop(tls *libc.TLS, enc uintptr) int32 { /* frame_enc.c:777:5: *
// otherwise, token-buffer won't be useful
- for (ok != 0) && (libc.PostDecInt32(&num_pass_left, 1) > 0) {
- var is_last_pass int32 = (libc.Bool32(((libc.Xfabs(tls, float64((*PassStats)(unsafe.Pointer(bp /* &stats */)).dq)) <= 0.4) || (num_pass_left == 0)) || ((*VP8Encoder)(unsafe.Pointer(enc)).max_i4_header_bits_ == 0)))
+ for ok != 0 && libc.PostDecInt32(&num_pass_left, 1) > 0 {
+ var is_last_pass int32 = libc.Bool32(libc.Xfabs(tls, float64((*PassStats)(unsafe.Pointer(bp)).dq)) <= 0.4 || num_pass_left == 0 || (*VP8Encoder)(unsafe.Pointer(enc)).max_i4_header_bits_ == 0)
var size_p0 uint64_t = uint64(0)
var distortion uint64_t = uint64(0)
var cnt int32 = max_count
// The final number of passes is not trivial to know in advance.
- var pass_progress int32 = (remaining_progress / (2 + num_pass_left))
- remaining_progress = remaining_progress - (pass_progress)
- VP8IteratorInit(tls, enc, (bp + 56) /* &it */)
+ var pass_progress int32 = remaining_progress / (2 + num_pass_left)
+ remaining_progress = remaining_progress - pass_progress
+ VP8IteratorInit(tls, enc, bp+56)
SetLoopParams(tls, enc, (*PassStats)(unsafe.Pointer(bp /* &stats */)).q)
if is_last_pass != 0 {
ResetTokenStats(tls, enc)
- VP8InitFilter(tls, (bp + 56) /* &it */) // don't collect stats until last pass (too costly)
+ VP8InitFilter(tls, bp+56) // don't collect stats until last pass (too costly)
}
- VP8TBufferClear(tls, (enc + 496 /* &.tokens_ */))
- for ok := int32(1); ok == 1; ok = VP8IteratorNext(tls, (bp + 56) /* &it */) {
+ VP8TBufferClear(tls, enc+496)
+ for __ccgo := true; __ccgo; __ccgo = ok != 0 && VP8IteratorNext(tls, bp+56) != 0 {
// var info VP8ModeScore at bp+3904, 880
- VP8IteratorImport(tls, (bp + 56) /* &it */, (uintptr(0)))
+ VP8IteratorImport(tls, bp+56, uintptr(0))
if libc.PreDecInt32(&cnt, 1) < 0 {
FinalizeTokenProbas(tls, proba)
VP8CalculateLevelCosts(tls, proba) // refresh cost tables for rd-opt
cnt = max_count
}
- VP8Decimate(tls, (bp + 56) /* &it */, (bp + 3904) /* &info */, rd_opt)
- ok = RecordTokens(tls, (bp + 56) /* &it */, (bp + 3904) /* &info */, (enc + 496 /* &.tokens_ */))
+ VP8Decimate(tls, bp+56, bp+3904, rd_opt)
+ ok = RecordTokens(tls, bp+56, bp+3904, enc+496)
if !(ok != 0) {
WebPEncodingSetError(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, VP8_ENC_ERROR_OUT_OF_MEMORY)
break
}
- size_p0 = size_p0 + (uint64_t((*VP8ModeScore)(unsafe.Pointer(bp + 3904 /* &info */)).H))
- distortion = distortion + (uint64_t((*VP8ModeScore)(unsafe.Pointer(bp + 3904 /* &info */)).D))
+ size_p0 = size_p0 + uint64_t((*VP8ModeScore)(unsafe.Pointer(bp+3904)).H)
+ distortion = distortion + uint64_t((*VP8ModeScore)(unsafe.Pointer(bp+3904)).D)
if is_last_pass != 0 {
- StoreSideInfo(tls, (bp + 56) /* &it */)
- VP8StoreFilterStats(tls, (bp + 56) /* &it */)
- VP8IteratorExport(tls, (bp + 56) /* &it */)
- ok = VP8IteratorProgress(tls, (bp + 56) /* &it */, pass_progress)
+ StoreSideInfo(tls, bp+56)
+ VP8StoreFilterStats(tls, bp+56)
+ VP8IteratorExport(tls, bp+56)
+ ok = VP8IteratorProgress(tls, bp+56, pass_progress)
}
- VP8IteratorSaveBoundary(tls, (bp + 56) /* &it */)
+ VP8IteratorSaveBoundary(tls, bp+56)
}
if !(ok != 0) {
break
}
- size_p0 = size_p0 + (uint64_t((*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.size_))
- if (*PassStats)(unsafe.Pointer(bp /* &stats */)).do_size_search != 0 {
- var size uint64_t = uint64_t(FinalizeTokenProbas(tls, (enc + 3616 /* &.proba_ */)))
- size = size + (VP8EstimateTokenSize(tls, (enc + 496 /* &.tokens_ */),
- proba+4 /* &.coeffs_ */))
- size = (((size + size_p0) + uint64(1024)) >> 11) // -> size in bytes
- size = size + (uint64((12 + 8) + 10))
+ size_p0 = size_p0 + uint64_t((*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.size_)
+ if (*PassStats)(unsafe.Pointer(bp)).do_size_search != 0 {
+ var size uint64_t = uint64_t(FinalizeTokenProbas(tls, enc+3616))
+ size = size + VP8EstimateTokenSize(tls, enc+496,
+ proba+4)
+ size = (size + size_p0 + uint64(1024)) >> 11 // -> size in bytes
+ size = size + uint64(12+8+10)
(*PassStats)(unsafe.Pointer(bp /* &stats */)).value = float64(size)
} else { // compute and store PSNR
(*PassStats)(unsafe.Pointer(bp /* &stats */)).value = GetPSNR(tls, distortion, pixel_count)
}
- if ((*VP8Encoder)(unsafe.Pointer(enc)).max_i4_header_bits_ > 0) && (uint64(size_p0) > (uint64(((uint64(int32(1) << 19)) - 2048)) << 11)) {
+ if (*VP8Encoder)(unsafe.Pointer(enc)).max_i4_header_bits_ > 0 && uint64(size_p0) > uint64(uint64(int32(1)<<19)-2048)<<11 {
num_pass_left++
- libc.AssignShrPtrInt32((enc + 23624 /* &.max_i4_header_bits_ */), int(1)) // strengthen header bit limitation...
+ libc.AssignShrPtrInt32(enc+23624, int(1)) // strengthen header bit limitation...
if is_last_pass != 0 {
- ResetSideInfo(tls, (bp + 56) /* &it */)
+ ResetSideInfo(tls, bp+56)
}
continue // ...and start over
}
@@ -26996,19 +26709,19 @@ func VP8EncTokenLoop(tls *libc.TLS, enc uintptr) int32 { /* frame_enc.c:777:5: *
break // done
}
if do_search != 0 {
- ComputeNextQ(tls, (bp) /* &stats */) // Adjust q
+ ComputeNextQ(tls, bp) // Adjust q
}
}
if ok != 0 {
- if !((*PassStats)(unsafe.Pointer(bp /* &stats */)).do_size_search != 0) {
- FinalizeTokenProbas(tls, (enc + 3616 /* &.proba_ */))
+ if !((*PassStats)(unsafe.Pointer(bp)).do_size_search != 0) {
+ FinalizeTokenProbas(tls, enc+3616)
}
- ok = VP8EmitTokens(tls, (enc + 496 /* &.tokens_ */), ((enc + 112 /* &.parts_ */) + uintptr(0)*48),
+ ok = VP8EmitTokens(tls, enc+496, enc+112+uintptr(0)*48,
proba+4 /* &.coeffs_ */, 1)
}
- ok = (libc.Bool32((ok != 0) && (WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, ((*VP8Encoder)(unsafe.Pointer(enc)).percent_+remaining_progress),
- (enc+536 /* &.percent_ */)) != 0)))
- return PostLoopFinalize(tls, (bp + 56) /* &it */, ok)
+ ok = libc.Bool32(ok != 0 && WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, (*VP8Encoder)(unsafe.Pointer(enc)).percent_+remaining_progress,
+ enc+536) != 0)
+ return PostLoopFinalize(tls, bp+56, ok)
}
//------------------------------------------------------------------------------
@@ -27065,12 +26778,12 @@ func HistogramCopy(tls *libc.TLS, src uintptr, dst uintptr) { /* histogram_enc.c
libc.Xmemcpy(tls, dst, src, uint64(histo_size))
(*VP8LHistogram)(unsafe.Pointer(dst)).literal_ = dst_literal
- libc.Xmemcpy(tls, (*VP8LHistogram)(unsafe.Pointer(dst)).literal_, (*VP8LHistogram)(unsafe.Pointer(src)).literal_, (uint64(literal_size) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, (*VP8LHistogram)(unsafe.Pointer(dst)).literal_, (*VP8LHistogram)(unsafe.Pointer(src)).literal_, uint64(literal_size)*uint64(unsafe.Sizeof(uint32_t(0))))
}
func VP8LGetHistogramSize(tls *libc.TLS, cache_bits int32) int32 { /* histogram_enc.c:62:5: */
var literal_size int32 = VP8LHistogramNumCodes(tls, cache_bits)
- var total_size size_t = (uint64(unsafe.Sizeof(VP8LHistogram{})) + (uint64(unsafe.Sizeof(int32(0))) * uint64(literal_size)))
+ var total_size size_t = uint64(unsafe.Sizeof(VP8LHistogram{})) + uint64(unsafe.Sizeof(int32(0)))*uint64(literal_size)
return int32(total_size)
}
@@ -27088,9 +26801,9 @@ func VP8LHistogramStoreRefs(tls *libc.TLS, refs uintptr, histo uintptr) { /* his
defer tls.Free(24)
*(*VP8LRefsCursor)(unsafe.Pointer(bp /* c */)) = VP8LRefsCursorInit(tls, refs)
- for VP8LRefsCursorOk(tls, (bp) /* &c */) != 0 {
- VP8LHistogramAddSinglePixOrCopy(tls, histo, (*VP8LRefsCursor)(unsafe.Pointer(bp /* &c */)).cur_pos, (uintptr(0)), 0)
- VP8LRefsCursorNext(tls, (bp) /* &c */)
+ for VP8LRefsCursorOk(tls, bp) != 0 {
+ VP8LHistogramAddSinglePixOrCopy(tls, histo, (*VP8LRefsCursor)(unsafe.Pointer(bp /* &c */)).cur_pos, uintptr(0), 0)
+ VP8LRefsCursorNext(tls, bp)
}
}
@@ -27112,20 +26825,20 @@ func VP8LHistogramInit(tls *libc.TLS, p uintptr, palette_code_bits int32, init_a
(*VP8LHistogram)(unsafe.Pointer(p)).literal_cost_ = 0.
(*VP8LHistogram)(unsafe.Pointer(p)).red_cost_ = 0.
(*VP8LHistogram)(unsafe.Pointer(p)).blue_cost_ = 0.
- libc.Xmemset(tls, (p + 3280 /* &.is_used_ */), 0, uint64(unsafe.Sizeof([5]uint8_t{})))
+ libc.Xmemset(tls, p+3280, 0, uint64(unsafe.Sizeof([5]uint8_t{})))
}
}
func VP8LAllocateHistogram(tls *libc.TLS, cache_bits int32) uintptr { /* histogram_enc.c:111:14: */
- var histo uintptr = (uintptr(0))
+ var histo uintptr = uintptr(0)
var total_size int32 = VP8LGetHistogramSize(tls, cache_bits)
var memory uintptr = WebPSafeMalloc(tls, uint64(total_size), uint64(unsafe.Sizeof(uint8_t(0))))
- if memory == (uintptr(0)) {
- return (uintptr(0))
+ if memory == uintptr(0) {
+ return uintptr(0)
}
histo = memory
// literal_ won't necessary be aligned.
- (*VP8LHistogram)(unsafe.Pointer(histo)).literal_ = (memory + uintptr(uint64(unsafe.Sizeof(VP8LHistogram{}))))
+ (*VP8LHistogram)(unsafe.Pointer(histo)).literal_ = memory + uintptr(uint64(unsafe.Sizeof(VP8LHistogram{})))
VP8LHistogramInit(tls, histo, cache_bits /*init_arrays=*/, 0)
return histo
}
@@ -27134,13 +26847,13 @@ func VP8LAllocateHistogram(tls *libc.TLS, cache_bits int32) uintptr { /* histogr
func HistogramSetResetPointers(tls *libc.TLS, set uintptr, cache_bits int32) { /* histogram_enc.c:124:13: */
var i int32
var histo_size int32 = VP8LGetHistogramSize(tls, cache_bits)
- var memory uintptr = ((*VP8LHistogramSet)(unsafe.Pointer(set)).histograms)
- memory += (uintptr(uint64((*VP8LHistogramSet)(unsafe.Pointer(set)).max_size) * uint64(unsafe.Sizeof(uintptr(0)))))
+ var memory uintptr = (*VP8LHistogramSet)(unsafe.Pointer(set)).histograms
+ memory += uintptr(uint64((*VP8LHistogramSet)(unsafe.Pointer(set)).max_size) * uint64(unsafe.Sizeof(uintptr(0))))
for i = 0; i < (*VP8LHistogramSet)(unsafe.Pointer(set)).max_size; i++ {
- memory = (uintptr((uintptr_t((memory)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
+ memory = uintptr((uintptr_t(memory) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
*(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(set)).histograms + uintptr(i)*8)) = memory
// literal_ won't necessary be aligned.
- (*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(set)).histograms + uintptr(i)*8)))).literal_ = (memory + uintptr(uint64(unsafe.Sizeof(VP8LHistogram{}))))
+ (*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(set)).histograms + uintptr(i)*8)))).literal_ = memory + uintptr(uint64(unsafe.Sizeof(VP8LHistogram{})))
memory += uintptr(histo_size)
}
}
@@ -27148,7 +26861,7 @@ func HistogramSetResetPointers(tls *libc.TLS, set uintptr, cache_bits int32) { /
// Returns the total size of the VP8LHistogramSet.
func HistogramSetTotalSize(tls *libc.TLS, size int32, cache_bits int32) size_t { /* histogram_enc.c:140:15: */
var histo_size int32 = VP8LGetHistogramSize(tls, cache_bits)
- return (uint64(unsafe.Sizeof(VP8LHistogramSet{})) + (uint64(size) * ((uint64(unsafe.Sizeof(uintptr(0))) + uint64(histo_size)) + uint64(31))))
+ return uint64(unsafe.Sizeof(VP8LHistogramSet{})) + uint64(size)*(uint64(unsafe.Sizeof(uintptr(0)))+uint64(histo_size)+uint64(31))
}
func VP8LAllocateHistogramSet(tls *libc.TLS, size int32, cache_bits int32) uintptr { /* histogram_enc.c:146:17: */
@@ -27156,8 +26869,8 @@ func VP8LAllocateHistogramSet(tls *libc.TLS, size int32, cache_bits int32) uintp
var set uintptr
var total_size size_t = HistogramSetTotalSize(tls, size, cache_bits)
var memory uintptr = WebPSafeMalloc(tls, total_size, uint64(unsafe.Sizeof(uint8_t(0))))
- if memory == (uintptr(0)) {
- return (uintptr(0))
+ if memory == uintptr(0) {
+ return uintptr(0)
}
set = memory
@@ -27193,11 +26906,11 @@ func VP8LHistogramSetClear(tls *libc.TLS, set uintptr) { /* histogram_enc.c:165:
// Removes the histogram 'i' from 'set' by setting it to NULL.
func HistogramSetRemoveHistogram(tls *libc.TLS, set uintptr, i int32, num_used uintptr) { /* histogram_enc.c:184:13: */
- *(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(set)).histograms + uintptr(i)*8)) = (uintptr(0))
+ *(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(set)).histograms + uintptr(i)*8)) = uintptr(0)
*(*int32)(unsafe.Pointer(num_used))--
// If we remove the last valid one, shrink until the next valid one.
- if i == ((*VP8LHistogramSet)(unsafe.Pointer(set)).size - 1) {
- for ((*VP8LHistogramSet)(unsafe.Pointer(set)).size >= 1) && (*(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(set)).histograms + uintptr(((*VP8LHistogramSet)(unsafe.Pointer(set)).size-1))*8)) == (uintptr(0))) {
+ if i == (*VP8LHistogramSet)(unsafe.Pointer(set)).size-1 {
+ for (*VP8LHistogramSet)(unsafe.Pointer(set)).size >= 1 && *(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(set)).histograms + uintptr((*VP8LHistogramSet)(unsafe.Pointer(set)).size-1)*8)) == uintptr(0) {
(*VP8LHistogramSet)(unsafe.Pointer(set)).size--
}
}
@@ -27210,12 +26923,12 @@ func VP8LHistogramAddSinglePixOrCopy(tls *libc.TLS, histo uintptr, v uintptr, di
defer tls.Free(8)
if PixOrCopyIsLiteral(tls, v) != 0 {
- *(*uint32_t)(unsafe.Pointer((histo + 2056 /* &.alpha_ */) + uintptr(PixOrCopyLiteral(tls, v, 3))*4))++
- *(*uint32_t)(unsafe.Pointer((histo + 8 /* &.red_ */) + uintptr(PixOrCopyLiteral(tls, v, 2))*4))++
+ *(*uint32_t)(unsafe.Pointer(histo + 2056 + uintptr(PixOrCopyLiteral(tls, v, 3))*4))++
+ *(*uint32_t)(unsafe.Pointer(histo + 8 + uintptr(PixOrCopyLiteral(tls, v, 2))*4))++
*(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(histo)).literal_ + uintptr(PixOrCopyLiteral(tls, v, 1))*4))++
- *(*uint32_t)(unsafe.Pointer((histo + 1032 /* &.blue_ */) + uintptr(PixOrCopyLiteral(tls, v, 0))*4))++
+ *(*uint32_t)(unsafe.Pointer(histo + 1032 + uintptr(PixOrCopyLiteral(tls, v, 0))*4))++
} else if PixOrCopyIsCacheIdx(tls, v) != 0 {
- var literal_ix int32 = (int32((uint32_t(256 + 24)) + PixOrCopyCacheIdx(tls, v)))
+ var literal_ix int32 = int32(uint32_t(256+24) + PixOrCopyCacheIdx(tls, v))
*(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(histo)).literal_ + uintptr(literal_ix)*4))++
} else {
@@ -27223,18 +26936,18 @@ func VP8LHistogramAddSinglePixOrCopy(tls *libc.TLS, histo uintptr, v uintptr, di
// var extra_bits int32 at bp+4, 4
- VP8LPrefixEncodeBits(tls, int32(PixOrCopyLength(tls, v)), (bp) /* &code */, (bp + 4) /* &extra_bits */)
- *(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(histo)).literal_ + uintptr((256+*(*int32)(unsafe.Pointer(bp /* code */))))*4))++
- if distance_modifier == (uintptr(0)) {
- VP8LPrefixEncodeBits(tls, int32(PixOrCopyDistance(tls, v)), (bp) /* &code */, (bp + 4) /* &extra_bits */)
+ VP8LPrefixEncodeBits(tls, int32(PixOrCopyLength(tls, v)), bp, bp+4)
+ *(*uint32_t)(unsafe.Pointer((*VP8LHistogram)(unsafe.Pointer(histo)).literal_ + uintptr(256+*(*int32)(unsafe.Pointer(bp)))*4))++
+ if distance_modifier == uintptr(0) {
+ VP8LPrefixEncodeBits(tls, int32(PixOrCopyDistance(tls, v)), bp, bp+4)
} else {
VP8LPrefixEncodeBits(tls,
(*struct {
f func(*libc.TLS, int32, int32) int32
})(unsafe.Pointer(&struct{ uintptr }{distance_modifier})).f(tls, distance_modifier_arg0, int32(PixOrCopyDistance(tls, v))),
- (bp) /* &code */, (bp + 4) /* &extra_bits */)
+ bp, bp+4 /* &extra_bits */)
}
- *(*uint32_t)(unsafe.Pointer((histo + 3080 /* &.distance_ */) + uintptr(*(*int32)(unsafe.Pointer(bp /* code */)))*4))++
+ *(*uint32_t)(unsafe.Pointer(histo + 3080 + uintptr(*(*int32)(unsafe.Pointer(bp /* code */)))*4))++
}
}
@@ -27251,7 +26964,7 @@ func BitsEntropyRefine(tls *libc.TLS, entropy uintptr) float64 { /* histogram_en
// Let's mix in a bit of entropy to favor good clustering when
// distributions of these are combined.
if (*VP8LBitEntropy)(unsafe.Pointer(entropy)).nonzeros == 2 {
- return ((0.99 * float64((*VP8LBitEntropy)(unsafe.Pointer(entropy)).sum)) + (0.01 * (*VP8LBitEntropy)(unsafe.Pointer(entropy)).entropy))
+ return 0.99*float64((*VP8LBitEntropy)(unsafe.Pointer(entropy)).sum) + 0.01*(*VP8LBitEntropy)(unsafe.Pointer(entropy)).entropy
}
// No matter what the entropy says, we cannot be better than min_limit
// with Huffman coding. I am mixing a bit of entropy into the
@@ -27267,8 +26980,8 @@ func BitsEntropyRefine(tls *libc.TLS, entropy uintptr) float64 { /* histogram_en
}
{
- var min_limit float64 = (float64((uint32_t(2) * (*VP8LBitEntropy)(unsafe.Pointer(entropy)).sum) - (*VP8LBitEntropy)(unsafe.Pointer(entropy)).max_val))
- min_limit = ((mix * min_limit) + ((1.0 - mix) * (*VP8LBitEntropy)(unsafe.Pointer(entropy)).entropy))
+ var min_limit float64 = float64(uint32_t(2)*(*VP8LBitEntropy)(unsafe.Pointer(entropy)).sum - (*VP8LBitEntropy)(unsafe.Pointer(entropy)).max_val)
+ min_limit = mix*min_limit + (1.0-mix)*(*VP8LBitEntropy)(unsafe.Pointer(entropy)).entropy
if (*VP8LBitEntropy)(unsafe.Pointer(entropy)).entropy < min_limit {
return min_limit
}
@@ -27284,17 +26997,17 @@ func VP8LBitsEntropy(tls *libc.TLS, array uintptr, n int32) float64 { /* histogr
// var entropy VP8LBitEntropy at bp, 24
- VP8LBitsEntropyUnrefined(tls, array, n, (bp) /* &entropy */)
+ VP8LBitsEntropyUnrefined(tls, array, n, bp)
- return BitsEntropyRefine(tls, (bp) /* &entropy */)
+ return BitsEntropyRefine(tls, bp)
}
func InitialHuffmanCost(tls *libc.TLS) float64 { /* histogram_enc.c:270:15: */
- return (float64(kHuffmanCodeOfHuffmanCodeSize) - kSmallBias)
+ return float64(kHuffmanCodeOfHuffmanCodeSize) - kSmallBias
}
-var kHuffmanCodeOfHuffmanCodeSize int32 = (19 * 3) /* histogram_enc.c:273:20 */
-var kSmallBias float64 = 9.1 /* histogram_enc.c:274:23 */
+var kHuffmanCodeOfHuffmanCodeSize int32 = 19 * 3 /* histogram_enc.c:273:20 */
+var kSmallBias float64 = 9.1 /* histogram_enc.c:274:23 */
// Finalize the Huffman cost based on streak numbers and length type (<3 or >=3)
func FinalHuffmanCost(tls *libc.TLS, stats uintptr) float64 { /* histogram_enc.c:279:15: */
@@ -27303,15 +27016,15 @@ func FinalHuffmanCost(tls *libc.TLS, stats uintptr) float64 { /* histogram_enc.c
var retval float64 = InitialHuffmanCost(tls)
// Second coefficient: Many zeros in the histogram are covered efficiently
// by a run-length encode. Originally 2/8.
- retval = retval + ((float64(*(*int32)(unsafe.Pointer((stats /* &.counts */)))) * 1.5625) + (0.234375 * float64(*(*int32)(unsafe.Pointer((stats + 8 /* &.streaks */) + 1*4)))))
+ retval = retval + (float64(*(*int32)(unsafe.Pointer(stats)))*1.5625 + 0.234375*float64(*(*int32)(unsafe.Pointer(stats + 8 + 1*4))))
// Second coefficient: Constant values are encoded less efficiently, but still
// RLE'ed. Originally 6/8.
- retval = retval + ((float64(*(*int32)(unsafe.Pointer((stats /* &.counts */) + 1*4))) * 2.578125) + (0.703125 * float64(*(*int32)(unsafe.Pointer(((stats + 8 /* &.streaks */) + 1*8) + 1*4)))))
+ retval = retval + (float64(*(*int32)(unsafe.Pointer(stats + 1*4)))*2.578125 + 0.703125*float64(*(*int32)(unsafe.Pointer(stats + 8 + 1*8 + 1*4))))
// 0s are usually encoded more efficiently than non-0s.
// Originally 15/8.
- retval = retval + (1.796875 * float64(*(*int32)(unsafe.Pointer((stats + 8 /* &.streaks */)))))
+ retval = retval + 1.796875*float64(*(*int32)(unsafe.Pointer(stats + 8)))
// Originally 26/8.
- retval = retval + (3.28125 * float64(*(*int32)(unsafe.Pointer(((stats + 8 /* &.streaks */) + 1*8)))))
+ retval = retval + 3.28125*float64(*(*int32)(unsafe.Pointer(stats + 8 + 1*8)))
return retval
}
@@ -27327,19 +27040,19 @@ func PopulationCost(tls *libc.TLS, population uintptr, length int32, trivial_sym
(*struct {
f func(*libc.TLS, uintptr, int32, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LGetEntropyUnrefined})).f(tls, population, length, (bp) /* &bit_entropy */, (bp + 24) /* &stats */)
- if trivial_sym != (uintptr(0)) {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LGetEntropyUnrefined})).f(tls, population, length, bp /* &bit_entropy */, bp+24 /* &stats */)
+ if trivial_sym != uintptr(0) {
*(*uint32_t)(unsafe.Pointer(trivial_sym)) = func() uint32 {
- if (*VP8LBitEntropy)(unsafe.Pointer(bp /* &bit_entropy */)).nonzeros == 1 {
+ if (*VP8LBitEntropy)(unsafe.Pointer(bp)).nonzeros == 1 {
return (*VP8LBitEntropy)(unsafe.Pointer(bp /* &bit_entropy */)).nonzero_code
}
- return (0xffffffff)
+ return 0xffffffff
}()
}
// The histogram is used if there is at least one non-zero streak.
- *(*uint8_t)(unsafe.Pointer(is_used)) = (uint8_t(libc.Bool32((*(*int32)(unsafe.Pointer((((bp + 24) /* &stats */ + 8 /* &.streaks */) + 1*8))) != 0) || (*(*int32)(unsafe.Pointer((((bp + 24) /* &stats */ + 8 /* &.streaks */) + 1*8) + 1*4)) != 0))))
+ *(*uint8_t)(unsafe.Pointer(is_used)) = uint8_t(libc.Bool32(*(*int32)(unsafe.Pointer(bp + 24 + 8 + 1*8)) != 0 || *(*int32)(unsafe.Pointer(bp + 24 + 8 + 1*8 + 1*4)) != 0))
- return (BitsEntropyRefine(tls, (bp) /* &bit_entropy */) + FinalHuffmanCost(tls, (bp+24) /* &stats */))
+ return BitsEntropyRefine(tls, bp) + FinalHuffmanCost(tls, bp+24)
}
// trivial_at_end is 1 if the two histograms only have one element that is
@@ -27355,13 +27068,13 @@ func GetCombinedEntropy(tls *libc.TLS, X uintptr, Y uintptr, length int32, is_X_
// pixel into 0xff000000 | (pixel << 8) in VP8LBundleColorMap.
// BitsEntropyRefine is 0 for histograms with only one non-zero value.
// Only FinalHuffmanCost needs to be evaluated.
- libc.Xmemset(tls, (bp) /* &stats */, 0, uint64(unsafe.Sizeof(VP8LStreaks{})))
+ libc.Xmemset(tls, bp, 0, uint64(unsafe.Sizeof(VP8LStreaks{})))
// Deal with the non-zero value at index 0 or length-1.
- *(*int32)(unsafe.Pointer((((bp) /* &stats */ + 8 /* &.streaks */) + 1*8))) = 1
+ *(*int32)(unsafe.Pointer(bp + 8 + 1*8)) = 1
// Deal with the following/previous zero streak.
- *(*int32)(unsafe.Pointer((bp) /* &stats */ /* &.counts */)) = 1
- *(*int32)(unsafe.Pointer(((bp) /* &stats */ + 8 /* &.streaks */) + 1*4)) = (length - 1)
- return FinalHuffmanCost(tls, (bp) /* &stats */)
+ *(*int32)(unsafe.Pointer(bp)) = 1
+ *(*int32)(unsafe.Pointer(bp + 8 + 1*4)) = length - 1
+ return FinalHuffmanCost(tls, bp)
} else {
// var bit_entropy VP8LBitEntropy at bp+24, 24
@@ -27369,44 +27082,44 @@ func GetCombinedEntropy(tls *libc.TLS, X uintptr, Y uintptr, length int32, is_X_
if is_Y_used != 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LGetCombinedEntropyUnrefined})).f(tls, X, Y, length, (bp + 24) /* &bit_entropy */, (bp) /* &stats */)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LGetCombinedEntropyUnrefined})).f(tls, X, Y, length, bp+24 /* &bit_entropy */, bp /* &stats */)
} else {
(*struct {
f func(*libc.TLS, uintptr, int32, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LGetEntropyUnrefined})).f(tls, X, length, (bp + 24) /* &bit_entropy */, (bp) /* &stats */)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LGetEntropyUnrefined})).f(tls, X, length, bp+24 /* &bit_entropy */, bp /* &stats */)
}
} else {
if is_Y_used != 0 {
(*struct {
f func(*libc.TLS, uintptr, int32, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LGetEntropyUnrefined})).f(tls, Y, length, (bp + 24) /* &bit_entropy */, (bp) /* &stats */)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LGetEntropyUnrefined})).f(tls, Y, length, bp+24 /* &bit_entropy */, bp /* &stats */)
} else {
- libc.Xmemset(tls, (bp) /* &stats */, 0, uint64(unsafe.Sizeof(VP8LStreaks{})))
- *(*int32)(unsafe.Pointer((bp) /* &stats */ /* &.counts */)) = 1
- *(*int32)(unsafe.Pointer(((bp) /* &stats */ + 8 /* &.streaks */) + uintptr((libc.Bool32(length > 3)))*4)) = length
- VP8LBitEntropyInit(tls, (bp + 24) /* &bit_entropy */)
+ libc.Xmemset(tls, bp, 0, uint64(unsafe.Sizeof(VP8LStreaks{})))
+ *(*int32)(unsafe.Pointer(bp)) = 1
+ *(*int32)(unsafe.Pointer(bp + 8 + uintptr(libc.Bool32(length > 3))*4)) = length
+ VP8LBitEntropyInit(tls, bp+24)
}
}
- return (BitsEntropyRefine(tls, (bp+24) /* &bit_entropy */) + FinalHuffmanCost(tls, (bp) /* &stats */))
+ return BitsEntropyRefine(tls, bp+24) + FinalHuffmanCost(tls, bp)
}
return float64(0)
}
// Estimates the Entropy + Huffman + other block overhead size cost.
func VP8LHistogramEstimateBits(tls *libc.TLS, p uintptr) float64 { /* histogram_enc.c:359:8: */
- return ((((((PopulationCost(tls, (*VP8LHistogram)(unsafe.Pointer(p)).literal_, VP8LHistogramNumCodes(tls, (*VP8LHistogram)(unsafe.Pointer(p)).palette_code_bits_),
- (uintptr(0)), (p+3280 /* &.is_used_ */)) +
- PopulationCost(tls, (p+8 /* &.red_ */), 256, (uintptr(0)), ((p+3280 /* &.is_used_ */)+1))) +
- PopulationCost(tls, (p+1032 /* &.blue_ */), 256, (uintptr(0)), ((p+3280 /* &.is_used_ */)+2))) +
- PopulationCost(tls, (p+2056 /* &.alpha_ */), 256, (uintptr(0)), ((p+3280 /* &.is_used_ */)+3))) +
- PopulationCost(tls, (p+3080 /* &.distance_ */), 40, (uintptr(0)), ((p+3280 /* &.is_used_ */)+4))) +
+ return PopulationCost(tls, (*VP8LHistogram)(unsafe.Pointer(p)).literal_, VP8LHistogramNumCodes(tls, (*VP8LHistogram)(unsafe.Pointer(p)).palette_code_bits_),
+ uintptr(0), p+3280) +
+ PopulationCost(tls, p+8, 256, uintptr(0), p+3280+1) +
+ PopulationCost(tls, p+1032, 256, uintptr(0), p+3280+2) +
+ PopulationCost(tls, p+2056, 256, uintptr(0), p+3280+3) +
+ PopulationCost(tls, p+3080, 40, uintptr(0), p+3280+4) +
(*struct {
f func(*libc.TLS, uintptr, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCost})).f(tls, ((*VP8LHistogram)(unsafe.Pointer(p)).literal_+uintptr(256)*4), 24)) +
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCost})).f(tls, (*VP8LHistogram)(unsafe.Pointer(p)).literal_+uintptr(256)*4, 24) +
(*struct {
f func(*libc.TLS, uintptr, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCost})).f(tls, (p+3080 /* &.distance_ */), 40))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCost})).f(tls, p+3080, 40)
}
// -----------------------------------------------------------------------------
@@ -27416,51 +27129,51 @@ func GetCombinedHistogramEntropy(tls *libc.TLS, a uintptr, b uintptr, cost_thres
var palette_code_bits int32 = (*VP8LHistogram)(unsafe.Pointer(a)).palette_code_bits_
var trivial_at_end int32 = 0
- *(*float64)(unsafe.Pointer(cost)) += (GetCombinedEntropy(tls, (*VP8LHistogram)(unsafe.Pointer(a)).literal_, (*VP8LHistogram)(unsafe.Pointer(b)).literal_,
+ *(*float64)(unsafe.Pointer(cost)) += GetCombinedEntropy(tls, (*VP8LHistogram)(unsafe.Pointer(a)).literal_, (*VP8LHistogram)(unsafe.Pointer(b)).literal_,
VP8LHistogramNumCodes(tls, palette_code_bits),
- int32(*(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */)))), int32(*(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */)))), 0))
- *(*float64)(unsafe.Pointer(cost)) += ((*struct {
+ int32(*(*uint8_t)(unsafe.Pointer(a + 3280))), int32(*(*uint8_t)(unsafe.Pointer(b + 3280))), 0)
+ *(*float64)(unsafe.Pointer(cost)) += (*struct {
f func(*libc.TLS, uintptr, uintptr, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCostCombined})).f(tls, ((*VP8LHistogram)(unsafe.Pointer(a)).literal_ + uintptr(256)*4),
- ((*VP8LHistogram)(unsafe.Pointer(b)).literal_ + uintptr(256)*4),
- 24))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCostCombined})).f(tls, (*VP8LHistogram)(unsafe.Pointer(a)).literal_+uintptr(256)*4,
+ (*VP8LHistogram)(unsafe.Pointer(b)).literal_+uintptr(256)*4,
+ 24)
if *(*float64)(unsafe.Pointer(cost)) > cost_threshold {
return 0
}
- if ((*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_ != (0xffffffff)) && ((*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_ == (*VP8LHistogram)(unsafe.Pointer(b)).trivial_symbol_) {
+ if (*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_ != 0xffffffff && (*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_ == (*VP8LHistogram)(unsafe.Pointer(b)).trivial_symbol_ {
// A, R and B are all 0 or 0xff.
- var color_a uint32_t = (((*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_ >> 24) & uint32_t(0xff))
- var color_r uint32_t = (((*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_ >> 16) & uint32_t(0xff))
- var color_b uint32_t = (((*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_ >> 0) & uint32_t(0xff))
- if (((color_a == uint32_t(0)) || (color_a == uint32_t(0xff))) && ((color_r == uint32_t(0)) || (color_r == uint32_t(0xff)))) && ((color_b == uint32_t(0)) || (color_b == uint32_t(0xff))) {
+ var color_a uint32_t = (*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_ >> 24 & uint32_t(0xff)
+ var color_r uint32_t = (*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_ >> 16 & uint32_t(0xff)
+ var color_b uint32_t = (*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_ >> 0 & uint32_t(0xff)
+ if (color_a == uint32_t(0) || color_a == uint32_t(0xff)) && (color_r == uint32_t(0) || color_r == uint32_t(0xff)) && (color_b == uint32_t(0) || color_b == uint32_t(0xff)) {
trivial_at_end = 1
}
}
- *(*float64)(unsafe.Pointer(cost)) += (GetCombinedEntropy(tls, (a + 8 /* &.red_ */), (b + 8 /* &.red_ */), 256, int32(*(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 1))),
- int32(*(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 1))), trivial_at_end))
+ *(*float64)(unsafe.Pointer(cost)) += GetCombinedEntropy(tls, a+8, b+8, 256, int32(*(*uint8_t)(unsafe.Pointer(a + 3280 + 1))),
+ int32(*(*uint8_t)(unsafe.Pointer(b + 3280 + 1))), trivial_at_end)
if *(*float64)(unsafe.Pointer(cost)) > cost_threshold {
return 0
}
- *(*float64)(unsafe.Pointer(cost)) += (GetCombinedEntropy(tls, (a + 1032 /* &.blue_ */), (b + 1032 /* &.blue_ */), 256, int32(*(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 2))),
- int32(*(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 2))), trivial_at_end))
+ *(*float64)(unsafe.Pointer(cost)) += GetCombinedEntropy(tls, a+1032, b+1032, 256, int32(*(*uint8_t)(unsafe.Pointer(a + 3280 + 2))),
+ int32(*(*uint8_t)(unsafe.Pointer(b + 3280 + 2))), trivial_at_end)
if *(*float64)(unsafe.Pointer(cost)) > cost_threshold {
return 0
}
- *(*float64)(unsafe.Pointer(cost)) += (GetCombinedEntropy(tls, (a + 2056 /* &.alpha_ */), (b + 2056 /* &.alpha_ */), 256,
- int32(*(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 3))), int32(*(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 3))), trivial_at_end))
+ *(*float64)(unsafe.Pointer(cost)) += GetCombinedEntropy(tls, a+2056, b+2056, 256,
+ int32(*(*uint8_t)(unsafe.Pointer(a + 3280 + 3))), int32(*(*uint8_t)(unsafe.Pointer(b + 3280 + 3))), trivial_at_end)
if *(*float64)(unsafe.Pointer(cost)) > cost_threshold {
return 0
}
- *(*float64)(unsafe.Pointer(cost)) += (GetCombinedEntropy(tls, (a + 3080 /* &.distance_ */), (b + 3080 /* &.distance_ */), 40,
- int32(*(*uint8_t)(unsafe.Pointer((a + 3280 /* &.is_used_ */) + 4))), int32(*(*uint8_t)(unsafe.Pointer((b + 3280 /* &.is_used_ */) + 4))), 0))
- *(*float64)(unsafe.Pointer(cost)) += ((*struct {
+ *(*float64)(unsafe.Pointer(cost)) += GetCombinedEntropy(tls, a+3080, b+3080, 40,
+ int32(*(*uint8_t)(unsafe.Pointer(a + 3280 + 4))), int32(*(*uint8_t)(unsafe.Pointer(b + 3280 + 4))), 0)
+ *(*float64)(unsafe.Pointer(cost)) += (*struct {
f func(*libc.TLS, uintptr, uintptr, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCostCombined})).f(tls, (a + 3080 /* &.distance_ */), (b + 3080 /* &.distance_ */), 40))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCostCombined})).f(tls, a+3080, b+3080, 40)
if *(*float64)(unsafe.Pointer(cost)) > cost_threshold {
return 0
}
@@ -27474,7 +27187,7 @@ func HistogramAdd(tls *libc.TLS, a uintptr, b uintptr, out uintptr) { /* histogr
if (*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_ == (*VP8LHistogram)(unsafe.Pointer(b)).trivial_symbol_ {
return (*VP8LHistogram)(unsafe.Pointer(a)).trivial_symbol_
}
- return (0xffffffff)
+ return 0xffffffff
}()
}
@@ -27489,16 +27202,16 @@ func HistogramAddEval(tls *libc.TLS, a uintptr, b uintptr, out uintptr, cost_thr
defer tls.Free(8)
*(*float64)(unsafe.Pointer(bp /* cost */)) = float64(0)
- var sum_cost float64 = ((*VP8LHistogram)(unsafe.Pointer(a)).bit_cost_ + (*VP8LHistogram)(unsafe.Pointer(b)).bit_cost_)
- cost_threshold = cost_threshold + (sum_cost)
+ var sum_cost float64 = (*VP8LHistogram)(unsafe.Pointer(a)).bit_cost_ + (*VP8LHistogram)(unsafe.Pointer(b)).bit_cost_
+ cost_threshold = cost_threshold + sum_cost
- if GetCombinedHistogramEntropy(tls, a, b, cost_threshold, (bp) /* &cost */) != 0 {
+ if GetCombinedHistogramEntropy(tls, a, b, cost_threshold, bp) != 0 {
HistogramAdd(tls, a, b, out)
(*VP8LHistogram)(unsafe.Pointer(out)).bit_cost_ = *(*float64)(unsafe.Pointer(bp /* cost */))
(*VP8LHistogram)(unsafe.Pointer(out)).palette_code_bits_ = (*VP8LHistogram)(unsafe.Pointer(a)).palette_code_bits_
}
- return (*(*float64)(unsafe.Pointer(bp /* cost */)) - sum_cost)
+ return *(*float64)(unsafe.Pointer(bp)) - sum_cost
}
// Same as HistogramAddEval(), except that the resulting histogram
@@ -27511,7 +27224,7 @@ func HistogramAddThresh(tls *libc.TLS, a uintptr, b uintptr, cost_threshold floa
// var cost float64 at bp, 8
*(*float64)(unsafe.Pointer(bp /* cost */)) = -(*VP8LHistogram)(unsafe.Pointer(a)).bit_cost_
- GetCombinedHistogramEntropy(tls, a, b, cost_threshold, (bp) /* &cost */)
+ GetCombinedHistogramEntropy(tls, a, b, cost_threshold, bp)
return *(*float64)(unsafe.Pointer(bp /* cost */))
}
@@ -27570,30 +27283,30 @@ func UpdateHistogramCost(tls *libc.TLS, h uintptr) { /* histogram_enc.c:506:13:
// var blue_sym uint32_t at bp+8, 4
- var alpha_cost float64 = PopulationCost(tls, (h + 2056 /* &.alpha_ */), 256, (bp), /* &alpha_sym */
- ((h + 3280 /* &.is_used_ */) + 3))
- var distance_cost float64 = (PopulationCost(tls, (h+3080 /* &.distance_ */), 40, (uintptr(0)), ((h+3280 /* &.is_used_ */)+4)) + (*struct {
+ var alpha_cost float64 = PopulationCost(tls, h+2056, 256, bp,
+ h+3280+3)
+ var distance_cost float64 = PopulationCost(tls, h+3080, 40, uintptr(0), h+3280+4) + (*struct {
f func(*libc.TLS, uintptr, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCost})).f(tls, (h+3080 /* &.distance_ */), 40))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCost})).f(tls, h+3080, 40)
var num_codes int32 = VP8LHistogramNumCodes(tls, (*VP8LHistogram)(unsafe.Pointer(h)).palette_code_bits_)
- (*VP8LHistogram)(unsafe.Pointer(h)).literal_cost_ = (PopulationCost(tls, (*VP8LHistogram)(unsafe.Pointer(h)).literal_, num_codes, (uintptr(0)), (h+3280 /* &.is_used_ */)) + (*struct {
+ (*VP8LHistogram)(unsafe.Pointer(h)).literal_cost_ = PopulationCost(tls, (*VP8LHistogram)(unsafe.Pointer(h)).literal_, num_codes, uintptr(0), h+3280) + (*struct {
f func(*libc.TLS, uintptr, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCost})).f(tls, ((*VP8LHistogram)(unsafe.Pointer(h)).literal_+uintptr(256)*4), 24))
- (*VP8LHistogram)(unsafe.Pointer(h)).red_cost_ = PopulationCost(tls, (h + 8 /* &.red_ */), 256, (bp + 4) /* &red_sym */, ((h + 3280 /* &.is_used_ */) + 1))
- (*VP8LHistogram)(unsafe.Pointer(h)).blue_cost_ = PopulationCost(tls, (h + 1032 /* &.blue_ */), 256, (bp + 8) /* &blue_sym */, ((h + 3280 /* &.is_used_ */) + 2))
- (*VP8LHistogram)(unsafe.Pointer(h)).bit_cost_ = (((((*VP8LHistogram)(unsafe.Pointer(h)).literal_cost_ + (*VP8LHistogram)(unsafe.Pointer(h)).red_cost_) + (*VP8LHistogram)(unsafe.Pointer(h)).blue_cost_) + alpha_cost) + distance_cost)
- if ((*(*uint32_t)(unsafe.Pointer(bp /* alpha_sym */)) | *(*uint32_t)(unsafe.Pointer(bp + 4 /* red_sym */))) | *(*uint32_t)(unsafe.Pointer(bp + 8 /* blue_sym */))) == (0xffffffff) {
- (*VP8LHistogram)(unsafe.Pointer(h)).trivial_symbol_ = (0xffffffff)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCost})).f(tls, (*VP8LHistogram)(unsafe.Pointer(h)).literal_+uintptr(256)*4, 24)
+ (*VP8LHistogram)(unsafe.Pointer(h)).red_cost_ = PopulationCost(tls, h+8, 256, bp+4, h+3280+1)
+ (*VP8LHistogram)(unsafe.Pointer(h)).blue_cost_ = PopulationCost(tls, h+1032, 256, bp+8, h+3280+2)
+ (*VP8LHistogram)(unsafe.Pointer(h)).bit_cost_ = (*VP8LHistogram)(unsafe.Pointer(h)).literal_cost_ + (*VP8LHistogram)(unsafe.Pointer(h)).red_cost_ + (*VP8LHistogram)(unsafe.Pointer(h)).blue_cost_ + alpha_cost + distance_cost
+ if *(*uint32_t)(unsafe.Pointer(bp))|*(*uint32_t)(unsafe.Pointer(bp + 4))|*(*uint32_t)(unsafe.Pointer(bp + 8)) == 0xffffffff {
+ (*VP8LHistogram)(unsafe.Pointer(h)).trivial_symbol_ = 0xffffffff
} else {
- (*VP8LHistogram)(unsafe.Pointer(h)).trivial_symbol_ = (((*(*uint32_t)(unsafe.Pointer(bp /* alpha_sym */)) << 24) | (*(*uint32_t)(unsafe.Pointer(bp + 4 /* red_sym */)) << 16)) | (*(*uint32_t)(unsafe.Pointer(bp + 8 /* blue_sym */)) << 0))
+ (*VP8LHistogram)(unsafe.Pointer(h)).trivial_symbol_ = *(*uint32_t)(unsafe.Pointer(bp))<<24 | *(*uint32_t)(unsafe.Pointer(bp + 4))<<16 | *(*uint32_t)(unsafe.Pointer(bp + 8))<<0
}
}
func GetBinIdForEntropy(tls *libc.TLS, min float64, max float64, val float64) int32 { /* histogram_enc.c:532:12: */
- var range1 float64 = (max - min)
+ var range1 float64 = max - min
if range1 > 0. {
- var delta float64 = (val - min)
- return (libc.Int32FromFloat64(((float64(float64(4)) - 1e-6) * delta) / range1))
+ var delta float64 = val - min
+ return libc.Int32FromFloat64((float64(float64(4)) - 1e-6) * delta / range1)
} else {
return 0
}
@@ -27605,10 +27318,10 @@ func GetHistoBinIndex(tls *libc.TLS, h uintptr, c uintptr, low_effort int32) int
(*VP8LHistogram)(unsafe.Pointer(h)).literal_cost_)
if !(low_effort != 0) {
- bin_id = ((bin_id * 4) +
- GetBinIdForEntropy(tls, (*DominantCostRange)(unsafe.Pointer(c)).red_min_, (*DominantCostRange)(unsafe.Pointer(c)).red_max_, (*VP8LHistogram)(unsafe.Pointer(h)).red_cost_))
- bin_id = ((bin_id * 4) +
- GetBinIdForEntropy(tls, (*DominantCostRange)(unsafe.Pointer(c)).blue_min_, (*DominantCostRange)(unsafe.Pointer(c)).blue_max_, (*VP8LHistogram)(unsafe.Pointer(h)).blue_cost_))
+ bin_id = bin_id*4 +
+ GetBinIdForEntropy(tls, (*DominantCostRange)(unsafe.Pointer(c)).red_min_, (*DominantCostRange)(unsafe.Pointer(c)).red_max_, (*VP8LHistogram)(unsafe.Pointer(h)).red_cost_)
+ bin_id = bin_id*4 +
+ GetBinIdForEntropy(tls, (*DominantCostRange)(unsafe.Pointer(c)).blue_min_, (*DominantCostRange)(unsafe.Pointer(c)).blue_max_, (*VP8LHistogram)(unsafe.Pointer(h)).blue_cost_)
}
return bin_id
@@ -27626,21 +27339,21 @@ func HistogramBuild(tls *libc.TLS, xsize int32, histo_bits int32, backward_refs
*(*VP8LRefsCursor)(unsafe.Pointer(bp /* c */)) = VP8LRefsCursorInit(tls, backward_refs)
VP8LHistogramSetClear(tls, image_histo)
- for VP8LRefsCursorOk(tls, (bp) /* &c */) != 0 {
+ for VP8LRefsCursorOk(tls, bp) != 0 {
var v uintptr = (*VP8LRefsCursor)(unsafe.Pointer(bp /* &c */)).cur_pos
- var ix int32 = (((y >> histo_bits) * histo_xsize) + (x >> histo_bits))
- VP8LHistogramAddSinglePixOrCopy(tls, *(*uintptr)(unsafe.Pointer(histograms + uintptr(ix)*8)), v, (uintptr(0)), 0)
- x = int32(uint32_t(x) + (PixOrCopyLength(tls, v)))
+ var ix int32 = y>>histo_bits*histo_xsize + x>>histo_bits
+ VP8LHistogramAddSinglePixOrCopy(tls, *(*uintptr)(unsafe.Pointer(histograms + uintptr(ix)*8)), v, uintptr(0), 0)
+ x = int32(uint32_t(x) + PixOrCopyLength(tls, v))
for x >= xsize {
- x = x - (xsize)
+ x = x - xsize
y++
}
- VP8LRefsCursorNext(tls, (bp) /* &c */)
+ VP8LRefsCursorNext(tls, bp)
}
}
// Copies the histograms and computes its bit_cost.
-var kInvalidHistogramSymbol uint16_t = libc.Uint16((libc.Uint16FromInt32(-1))) /* histogram_enc.c:581:23 */
+var kInvalidHistogramSymbol uint16_t = libc.Uint16(libc.Uint16FromInt32(-1)) /* histogram_enc.c:581:23 */
func HistogramCopyAndAnalyze(tls *libc.TLS, orig_histo uintptr, image_histo uintptr, num_used uintptr, histogram_symbols uintptr) { /* histogram_enc.c:582:13: */
bp := tls.Alloc(4)
@@ -27660,14 +27373,14 @@ func HistogramCopyAndAnalyze(tls *libc.TLS, orig_histo uintptr, image_histo uint
// Skip the histogram if it is completely empty, which can happen for tiles
// with no information (when they are skipped because of LZ77).
- if (((!(int32(*(*uint8_t)(unsafe.Pointer((histo + 3280 /* &.is_used_ */)))) != 0) && !(int32(*(*uint8_t)(unsafe.Pointer((histo + 3280 /* &.is_used_ */) + 1))) != 0)) && !(int32(*(*uint8_t)(unsafe.Pointer((histo + 3280 /* &.is_used_ */) + 2))) != 0)) &&
- !(int32(*(*uint8_t)(unsafe.Pointer((histo + 3280 /* &.is_used_ */) + 3))) != 0)) && !(int32(*(*uint8_t)(unsafe.Pointer((histo + 3280 /* &.is_used_ */) + 4))) != 0) {
+ if !(int32(*(*uint8_t)(unsafe.Pointer(histo + 3280))) != 0) && !(int32(*(*uint8_t)(unsafe.Pointer(histo + 3280 + 1))) != 0) && !(int32(*(*uint8_t)(unsafe.Pointer(histo + 3280 + 2))) != 0) &&
+ !(int32(*(*uint8_t)(unsafe.Pointer(histo + 3280 + 3))) != 0) && !(int32(*(*uint8_t)(unsafe.Pointer(histo + 3280 + 4))) != 0) {
// The first histogram is always used. If an histogram is empty, we set
// its id to be the same as the previous one: this will improve
// compressibility for later LZ77.
HistogramSetRemoveHistogram(tls, image_histo, i, num_used)
- HistogramSetRemoveHistogram(tls, orig_histo, i, (bp) /* &num_used_orig */)
+ HistogramSetRemoveHistogram(tls, orig_histo, i, bp)
*(*uint16_t)(unsafe.Pointer(histogram_symbols + uintptr(i)*2)) = kInvalidHistogramSymbol
} else {
// Copy histograms from orig_histo[] to image_histo[].
@@ -27689,14 +27402,14 @@ func HistogramAnalyzeEntropyBin(tls *libc.TLS, image_histo uintptr, bin_map uint
var histo_size int32 = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).size
// var cost_range DominantCostRange at bp, 48
- DominantCostRangeInit(tls, (bp) /* &cost_range */)
+ DominantCostRangeInit(tls, bp)
// Analyze the dominant (literal, red and blue) entropy costs.
for i = 0; i < histo_size; i++ {
- if *(*uintptr)(unsafe.Pointer(histograms + uintptr(i)*8)) == (uintptr(0)) {
+ if *(*uintptr)(unsafe.Pointer(histograms + uintptr(i)*8)) == uintptr(0) {
continue
}
- UpdateDominantCostRange(tls, *(*uintptr)(unsafe.Pointer(histograms + uintptr(i)*8)), (bp) /* &cost_range */)
+ UpdateDominantCostRange(tls, *(*uintptr)(unsafe.Pointer(histograms + uintptr(i)*8)), bp)
}
// bin-hash histograms on three of the dominant (literal, red and blue)
@@ -27704,10 +27417,10 @@ func HistogramAnalyzeEntropyBin(tls *libc.TLS, image_histo uintptr, bin_map uint
for i = 0; i < histo_size; i++ {
// bin_map[i] is not set to a special value as its use will later be guarded
// by another (histograms[i] == NULL).
- if *(*uintptr)(unsafe.Pointer(histograms + uintptr(i)*8)) == (uintptr(0)) {
+ if *(*uintptr)(unsafe.Pointer(histograms + uintptr(i)*8)) == uintptr(0) {
continue
}
- *(*uint16_t)(unsafe.Pointer(bin_map + uintptr(i)*2)) = uint16_t(GetHistoBinIndex(tls, *(*uintptr)(unsafe.Pointer(histograms + uintptr(i)*8)), (bp) /* &cost_range */, low_effort))
+ *(*uint16_t)(unsafe.Pointer(bin_map + uintptr(i)*2)) = uint16_t(GetHistoBinIndex(tls, *(*uintptr)(unsafe.Pointer(histograms + uintptr(i)*8)), bp, low_effort))
}
}
@@ -27726,11 +27439,11 @@ func HistogramCombineEntropyBin(tls *libc.TLS, image_histo uintptr, num_used uin
(*struct {
first int16_t
num_combine_failures uint16_t
- })(unsafe.Pointer((bp) /* &bin_info */ + uintptr(idx)*4)).first = int16(-1)
+ })(unsafe.Pointer(bp + uintptr(idx)*4)).first = int16(-1)
(*struct {
first int16_t
num_combine_failures uint16_t
- })(unsafe.Pointer((bp) /* &bin_info */ + uintptr(idx)*4)).num_combine_failures = uint16_t(0)
+ })(unsafe.Pointer(bp + uintptr(idx)*4)).num_combine_failures = uint16_t(0)
}
// By default, a cluster matches itself.
@@ -27740,19 +27453,19 @@ func HistogramCombineEntropyBin(tls *libc.TLS, image_histo uintptr, num_used uin
for idx = 0; idx < (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).size; idx++ {
var bin_id int32
var first int32
- if *(*uintptr)(unsafe.Pointer(histograms + uintptr(idx)*8)) == (uintptr(0)) {
+ if *(*uintptr)(unsafe.Pointer(histograms + uintptr(idx)*8)) == uintptr(0) {
continue
}
bin_id = int32(*(*uint16_t)(unsafe.Pointer(bin_map + uintptr(idx)*2)))
first = int32((*struct {
first int16_t
num_combine_failures uint16_t
- })(unsafe.Pointer((bp) /* &bin_info */ + uintptr(bin_id)*4)).first)
+ })(unsafe.Pointer(bp + uintptr(bin_id)*4)).first)
if first == -1 {
(*struct {
first int16_t
num_combine_failures uint16_t
- })(unsafe.Pointer((bp) /* &bin_info */ + uintptr(bin_id)*4)).first = int16_t(idx)
+ })(unsafe.Pointer(bp + uintptr(bin_id)*4)).first = int16_t(idx)
} else if low_effort != 0 {
HistogramAdd(tls, *(*uintptr)(unsafe.Pointer(histograms + uintptr(idx)*8)), *(*uintptr)(unsafe.Pointer(histograms + uintptr(first)*8)), *(*uintptr)(unsafe.Pointer(histograms + uintptr(first)*8)))
HistogramSetRemoveHistogram(tls, image_histo, idx, num_used)
@@ -27760,7 +27473,7 @@ func HistogramCombineEntropyBin(tls *libc.TLS, image_histo uintptr, num_used uin
} else {
// try to merge #idx into #first (both share the same bin_id)
var bit_cost float64 = (*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(histograms + uintptr(idx)*8)))).bit_cost_
- var bit_cost_thresh float64 = (-bit_cost * combine_cost_factor)
+ var bit_cost_thresh float64 = -bit_cost * combine_cost_factor
var curr_cost_diff float64 = HistogramAddEval(tls, *(*uintptr)(unsafe.Pointer(histograms + uintptr(first)*8)), *(*uintptr)(unsafe.Pointer(histograms + uintptr(idx)*8)),
*(*uintptr)(unsafe.Pointer(bp + 256 /* cur_combo */)), bit_cost_thresh)
if curr_cost_diff < bit_cost_thresh {
@@ -27769,21 +27482,21 @@ func HistogramCombineEntropyBin(tls *libc.TLS, image_histo uintptr, num_used uin
// For some images, 'try_combine' turns out to be false for a lot of
// histogram pairs. In that case, we fallback to combining
// histograms as usual to avoid increasing the header size.
- var try_combine int32 = (libc.Bool32(((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 256 /* cur_combo */)))).trivial_symbol_ != (0xffffffff)) || (((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(histograms + uintptr(idx)*8)))).trivial_symbol_ == (0xffffffff)) && ((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(histograms + uintptr(first)*8)))).trivial_symbol_ == (0xffffffff)))))
+ var try_combine int32 = libc.Bool32((*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 256)))).trivial_symbol_ != 0xffffffff || (*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(histograms + uintptr(idx)*8)))).trivial_symbol_ == 0xffffffff && (*VP8LHistogram)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(histograms + uintptr(first)*8)))).trivial_symbol_ == 0xffffffff)
var max_combine_failures int32 = 32
- if (try_combine != 0) || (int32((*struct {
+ if try_combine != 0 || int32((*struct {
first int16_t
num_combine_failures uint16_t
- })(unsafe.Pointer((bp) /* &bin_info */ +uintptr(bin_id)*4)).num_combine_failures) >= max_combine_failures) {
+ })(unsafe.Pointer(bp+uintptr(bin_id)*4)).num_combine_failures) >= max_combine_failures {
// move the (better) merged histogram to its final slot
- HistogramSwap(tls, (bp + 256) /* &cur_combo */, (histograms + uintptr(first)*8))
+ HistogramSwap(tls, bp+256, histograms+uintptr(first)*8)
HistogramSetRemoveHistogram(tls, image_histo, idx, num_used)
*(*uint16_t)(unsafe.Pointer(cluster_mappings + uintptr(*(*uint16_t)(unsafe.Pointer(clusters + uintptr(idx)*2)))*2)) = *(*uint16_t)(unsafe.Pointer(clusters + uintptr(first)*2))
} else {
(*struct {
first int16_t
num_combine_failures uint16_t
- })(unsafe.Pointer((bp) /* &bin_info */ +uintptr(bin_id)*4)).num_combine_failures++
+ })(unsafe.Pointer(bp+uintptr(bin_id)*4)).num_combine_failures++
}
}
}
@@ -27791,7 +27504,7 @@ func HistogramCombineEntropyBin(tls *libc.TLS, image_histo uintptr, num_used uin
if low_effort != 0 {
// for low_effort case, update the final cost when everything is merged
for idx = 0; idx < (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).size; idx++ {
- if *(*uintptr)(unsafe.Pointer(histograms + uintptr(idx)*8)) == (uintptr(0)) {
+ if *(*uintptr)(unsafe.Pointer(histograms + uintptr(idx)*8)) == uintptr(0) {
continue
}
UpdateHistogramCost(tls, *(*uintptr)(unsafe.Pointer(histograms + uintptr(idx)*8)))
@@ -27802,7 +27515,7 @@ func HistogramCombineEntropyBin(tls *libc.TLS, image_histo uintptr, num_used uin
// Implement a Lehmer random number generator with a multiplicative constant of
// 48271 and a modulo constant of 2^31 - 1.
func MyRand(tls *libc.TLS, seed uintptr) uint32_t { /* histogram_enc.c:721:17: */
- *(*uint32_t)(unsafe.Pointer(seed)) = (uint32_t(((uint64_t(*(*uint32_t)(unsafe.Pointer(seed)))) * uint64(48271)) % uint64(2147483647)))
+ *(*uint32_t)(unsafe.Pointer(seed)) = uint32_t(uint64_t(*(*uint32_t)(unsafe.Pointer(seed))) * uint64(48271) % uint64(2147483647))
return *(*uint32_t)(unsafe.Pointer(seed))
}
@@ -27830,8 +27543,8 @@ func HistoQueueInit(tls *libc.TLS, histo_queue uintptr, max_size int32) int32 {
// We allocate max_size + 1 because the last element at index "size" is
// used as temporary data (and it could be up to max_size).
(*HistoQueue)(unsafe.Pointer(histo_queue)).queue = WebPSafeMalloc(tls,
- (uint64((*HistoQueue)(unsafe.Pointer(histo_queue)).max_size + 1)), uint64(unsafe.Sizeof(HistogramPair{})))
- return (libc.Bool32((*HistoQueue)(unsafe.Pointer(histo_queue)).queue != (uintptr(0))))
+ uint64((*HistoQueue)(unsafe.Pointer(histo_queue)).max_size+1), uint64(unsafe.Sizeof(HistogramPair{})))
+ return libc.Bool32((*HistoQueue)(unsafe.Pointer(histo_queue)).queue != uintptr(0))
}
func HistoQueueClear(tls *libc.TLS, histo_queue uintptr) { /* histogram_enc.c:754:13: */
@@ -27845,7 +27558,7 @@ func HistoQueueClear(tls *libc.TLS, histo_queue uintptr) { /* histogram_enc.c:75
// and shrinking the queue.
func HistoQueuePopPair(tls *libc.TLS, histo_queue uintptr, pair uintptr) { /* histogram_enc.c:763:13: */
- *(*HistogramPair)(unsafe.Pointer(pair)) = *(*HistogramPair)(unsafe.Pointer((*HistoQueue)(unsafe.Pointer(histo_queue)).queue + uintptr(((*HistoQueue)(unsafe.Pointer(histo_queue)).size-1))*24))
+ *(*HistogramPair)(unsafe.Pointer(pair)) = *(*HistogramPair)(unsafe.Pointer((*HistoQueue)(unsafe.Pointer(histo_queue)).queue + uintptr((*HistoQueue)(unsafe.Pointer(histo_queue)).size-1)*24))
(*HistoQueue)(unsafe.Pointer(histo_queue)).size--
}
@@ -27863,10 +27576,10 @@ func HistoQueueUpdateHead(tls *libc.TLS, histo_queue uintptr, pair uintptr) { /*
// Update the cost diff and combo of a pair of histograms. This needs to be
// called when the the histograms have been merged with a third one.
func HistoQueueUpdatePair(tls *libc.TLS, h1 uintptr, h2 uintptr, threshold float64, pair uintptr) { /* histogram_enc.c:789:13: */
- var sum_cost float64 = ((*VP8LHistogram)(unsafe.Pointer(h1)).bit_cost_ + (*VP8LHistogram)(unsafe.Pointer(h2)).bit_cost_)
+ var sum_cost float64 = (*VP8LHistogram)(unsafe.Pointer(h1)).bit_cost_ + (*VP8LHistogram)(unsafe.Pointer(h2)).bit_cost_
(*HistogramPair)(unsafe.Pointer(pair)).cost_combo = 0.
- GetCombinedHistogramEntropy(tls, h1, h2, (sum_cost + threshold), (pair + 16 /* &.cost_combo */))
- (*HistogramPair)(unsafe.Pointer(pair)).cost_diff = ((*HistogramPair)(unsafe.Pointer(pair)).cost_combo - sum_cost)
+ GetCombinedHistogramEntropy(tls, h1, h2, sum_cost+threshold, pair+16)
+ (*HistogramPair)(unsafe.Pointer(pair)).cost_diff = (*HistogramPair)(unsafe.Pointer(pair)).cost_combo - sum_cost
}
// Create a pair from indices "idx1" and "idx2" provided its cost
@@ -27895,15 +27608,15 @@ func HistoQueuePush(tls *libc.TLS, histo_queue uintptr, histograms uintptr, idx1
h1 = *(*uintptr)(unsafe.Pointer(histograms + uintptr(idx1)*8))
h2 = *(*uintptr)(unsafe.Pointer(histograms + uintptr(idx2)*8))
- HistoQueueUpdatePair(tls, h1, h2, threshold, (bp) /* &pair */)
+ HistoQueueUpdatePair(tls, h1, h2, threshold, bp)
// Do not even consider the pair if it does not improve the entropy.
- if (*HistogramPair)(unsafe.Pointer(bp /* &pair */)).cost_diff >= threshold {
+ if (*HistogramPair)(unsafe.Pointer(bp)).cost_diff >= threshold {
return 0.
}
*(*HistogramPair)(unsafe.Pointer((*HistoQueue)(unsafe.Pointer(histo_queue)).queue + uintptr(libc.PostIncInt32(&(*HistoQueue)(unsafe.Pointer(histo_queue)).size, 1))*24)) = *(*HistogramPair)(unsafe.Pointer(bp /* pair */))
- HistoQueueUpdateHead(tls, histo_queue, ((*HistoQueue)(unsafe.Pointer(histo_queue)).queue + uintptr(((*HistoQueue)(unsafe.Pointer(histo_queue)).size-1))*24))
+ HistoQueueUpdateHead(tls, histo_queue, (*HistoQueue)(unsafe.Pointer(histo_queue)).queue+uintptr((*HistoQueue)(unsafe.Pointer(histo_queue)).size-1)*24)
return (*HistogramPair)(unsafe.Pointer(bp /* &pair */)).cost_diff
}
@@ -27938,7 +27651,7 @@ func HistogramCombineGreedy(tls *libc.TLS, image_histo uintptr, num_used uintptr
// - image_histo_size - 1 in the last for loop at the first iteration of
// the while loop, image_histo_size - 2 at the second iteration ...
// therefore image_histo_size*(image_histo_size-1)/2 overall too
- if !(!(HistoQueueInit(tls, (bp) /* &histo_queue */, (image_histo_size*image_histo_size)) != 0)) {
+ if !!(HistoQueueInit(tls, bp, image_histo_size*image_histo_size) != 0) {
goto __1
}
goto End
@@ -27950,25 +27663,25 @@ __2:
if !(i < image_histo_size) {
goto __4
}
- if !(*(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms + uintptr(i)*8)) == (uintptr(0))) {
+ if !(*(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms + uintptr(i)*8)) == uintptr(0)) {
goto __5
}
goto __3
__5:
;
- j = (i + 1)
+ j = i + 1
__6:
if !(j < image_histo_size) {
goto __8
}
// Initialize queue.
- if !(*(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms + uintptr(j)*8)) == (uintptr(0))) {
+ if !(*(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms + uintptr(j)*8)) == uintptr(0)) {
goto __9
}
goto __7
__9:
;
- HistoQueuePush(tls, (bp) /* &histo_queue */, histograms, i, j, 0.)
+ HistoQueuePush(tls, bp, histograms, i, j, 0.)
goto __7
__7:
j++
@@ -27985,7 +27698,7 @@ __4:
;
__10:
- if !((*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).size > 0) {
+ if !((*HistoQueue)(unsafe.Pointer(bp)).size > 0) {
goto __11
}
idx1 = (*HistogramPair)(unsafe.Pointer((*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).queue)).idx1
@@ -27999,17 +27712,17 @@ __10:
// Remove pairs intersecting the just combined best pair.
i = 0
__12:
- if !(i < (*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).size) {
+ if !(i < (*HistoQueue)(unsafe.Pointer(bp)).size) {
goto __14
}
- p = ((*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).queue + uintptr(i)*24)
- if !(((((*HistogramPair)(unsafe.Pointer(p)).idx1 == idx1) || ((*HistogramPair)(unsafe.Pointer(p)).idx2 == idx1)) || ((*HistogramPair)(unsafe.Pointer(p)).idx1 == idx2)) || ((*HistogramPair)(unsafe.Pointer(p)).idx2 == idx2)) {
+ p = (*HistoQueue)(unsafe.Pointer(bp)).queue + uintptr(i)*24
+ if !((*HistogramPair)(unsafe.Pointer(p)).idx1 == idx1 || (*HistogramPair)(unsafe.Pointer(p)).idx2 == idx1 || (*HistogramPair)(unsafe.Pointer(p)).idx1 == idx2 || (*HistogramPair)(unsafe.Pointer(p)).idx2 == idx2) {
goto __15
}
- HistoQueuePopPair(tls, (bp) /* &histo_queue */, p)
+ HistoQueuePopPair(tls, bp, p)
goto __16
__15:
- HistoQueueUpdateHead(tls, (bp) /* &histo_queue */, p)
+ HistoQueueUpdateHead(tls, bp, p)
i++
__16:
;
@@ -28027,13 +27740,13 @@ __17:
if !(i < (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).size) {
goto __19
}
- if !((i == idx1) || (*(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms + uintptr(i)*8)) == (uintptr(0)))) {
+ if !(i == idx1 || *(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms + uintptr(i)*8)) == uintptr(0)) {
goto __20
}
goto __18
__20:
;
- HistoQueuePush(tls, (bp) /* &histo_queue */, (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms, idx1, i, 0.)
+ HistoQueuePush(tls, bp, (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms, idx1, i, 0.)
goto __18
__18:
i++
@@ -28048,7 +27761,7 @@ __11:
ok = 1
End:
- HistoQueueClear(tls, (bp) /* &histo_queue */)
+ HistoQueueClear(tls, bp)
return ok
}
@@ -28057,7 +27770,7 @@ End:
// afterwards, 0 otherwise.
func PairComparison(tls *libc.TLS, idx1 uintptr, idx2 uintptr) int32 { /* histogram_enc.c:904:12: */
// To be used with bsearch: <0 when *idx1<*idx2, >0 if >, 0 when ==.
- return (*(*int32)(unsafe.Pointer(idx1)) - *(*int32)(unsafe.Pointer(idx2)))
+ return *(*int32)(unsafe.Pointer(idx1)) - *(*int32)(unsafe.Pointer(idx2))
}
func HistogramCombineStochastic(tls *libc.TLS, image_histo uintptr, num_used uintptr, min_cluster_size int32, do_greedy uintptr) int32 { /* histogram_enc.c:908:12: */
@@ -28104,7 +27817,7 @@ func HistogramCombineStochastic(tls *libc.TLS, image_histo uintptr, num_used uin
*(*uint32_t)(unsafe.Pointer(bp + 16 /* seed */)) = uint32_t(1)
tries_with_no_success = 0
outer_iters = *(*int32)(unsafe.Pointer(num_used))
- num_tries_no_success = (outer_iters / 2)
+ num_tries_no_success = outer_iters / 2
histograms = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms
kHistoQueueSize = 9
ok = 0
@@ -28118,13 +27831,13 @@ __1:
;
mappings = WebPSafeMalloc(tls, uint64(*(*int32)(unsafe.Pointer(num_used))), uint64(unsafe.Sizeof(int32(0))))
- if !(mappings == (uintptr(0))) {
+ if !(mappings == uintptr(0)) {
goto __2
}
return 0
__2:
;
- if !(!(HistoQueueInit(tls, (bp) /* &histo_queue */, kHistoQueueSize) != 0)) {
+ if !!(HistoQueueInit(tls, bp, kHistoQueueSize) != 0) {
goto __3
}
goto End
@@ -28137,7 +27850,7 @@ __4:
if !(iter < (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).size) {
goto __6
}
- if !(*(*uintptr)(unsafe.Pointer(histograms + uintptr(iter)*8)) == (uintptr(0))) {
+ if !(*(*uintptr)(unsafe.Pointer(histograms + uintptr(iter)*8)) == uintptr(0)) {
goto __7
}
goto __5
@@ -28155,31 +27868,31 @@ __6:
// Collapse similar histograms in 'image_histo'.
iter = 0
__8:
- if !(((iter < outer_iters) && (*(*int32)(unsafe.Pointer(num_used)) >= min_cluster_size)) && (libc.PreIncInt32(&tries_with_no_success, 1) < num_tries_no_success)) {
+ if !(iter < outer_iters && *(*int32)(unsafe.Pointer(num_used)) >= min_cluster_size && libc.PreIncInt32(&tries_with_no_success, 1) < num_tries_no_success) {
goto __10
}
- if (*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).size == 0 {
+ if (*HistoQueue)(unsafe.Pointer(bp)).size == 0 {
best_cost = 0.
} else {
best_cost = (*HistogramPair)(unsafe.Pointer((*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).queue)).cost_diff
}
best_idx1 = -1
*(*int32)(unsafe.Pointer(bp + 20 /* best_idx2 */)) = 1
- rand_range = (uint32_t((*(*int32)(unsafe.Pointer(num_used)) - 1) * (*(*int32)(unsafe.Pointer(num_used)))))
+ rand_range = uint32_t((*(*int32)(unsafe.Pointer(num_used)) - 1) * *(*int32)(unsafe.Pointer(num_used)))
// (*num_used) / 2 was chosen empirically. Less means faster but worse
// compression.
- num_tries = ((*(*int32)(unsafe.Pointer(num_used))) / 2)
+ num_tries = *(*int32)(unsafe.Pointer(num_used)) / 2
// Pick random samples.
j = 0
__11:
- if !((*(*int32)(unsafe.Pointer(num_used)) >= 2) && (j < num_tries)) {
+ if !(*(*int32)(unsafe.Pointer(num_used)) >= 2 && j < num_tries) {
goto __13
}
// Choose two different histograms at random and try to combine them.
- tmp = (MyRand(tls, (bp+16) /* &seed */) % rand_range)
- idx1 = (tmp / (uint32_t(*(*int32)(unsafe.Pointer(num_used)) - 1)))
- idx2 = (tmp % (uint32_t(*(*int32)(unsafe.Pointer(num_used)) - 1)))
+ tmp = MyRand(tls, bp+16) % rand_range
+ idx1 = tmp / uint32_t(*(*int32)(unsafe.Pointer(num_used))-1)
+ idx2 = tmp % uint32_t(*(*int32)(unsafe.Pointer(num_used))-1)
if !(idx2 >= idx1) {
goto __14
}
@@ -28190,13 +27903,13 @@ __14:
idx2 = uint32_t(*(*int32)(unsafe.Pointer(mappings + uintptr(idx2)*4)))
// Calculate cost reduction on combination.
- curr_cost = HistoQueuePush(tls, (bp) /* &histo_queue */, histograms, int32(idx1), int32(idx2), best_cost)
+ curr_cost = HistoQueuePush(tls, bp, histograms, int32(idx1), int32(idx2), best_cost)
if !(curr_cost < float64(0)) {
goto __15
} // found a better pair?
best_cost = curr_cost
// Empty the queue if we reached full capacity.
- if !((*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).size == (*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).max_size) {
+ if !((*HistoQueue)(unsafe.Pointer(bp)).size == (*HistoQueue)(unsafe.Pointer(bp)).max_size) {
goto __16
}
goto __13
@@ -28211,7 +27924,7 @@ __12:
goto __13
__13:
;
- if !((*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).size == 0) {
+ if !((*HistoQueue)(unsafe.Pointer(bp)).size == 0) {
goto __17
}
goto __9
@@ -28223,23 +27936,12 @@ __17:
*(*int32)(unsafe.Pointer(bp + 20 /* best_idx2 */)) = (*HistogramPair)(unsafe.Pointer((*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).queue)).idx2
// Pop best_idx2 from mappings.
- mapping_index = bsearch(
- tls,
- (bp + 20), /* &best_idx2 */
- mappings,
- uint64(*(*int32)(unsafe.Pointer(num_used))),
- uint64(unsafe.Sizeof(int32(0))),
- // Function pointers are generated by taking a pointer to
- // a struct who's first field is that function.
- *(*uintptr)(unsafe.Pointer(
- &struct {
- f func(*libc.TLS, uintptr, uintptr) int32
- }{
- PairComparison,
- },
- )))
+ mapping_index = libc.Xbsearch(tls, bp+20, mappings, uint64(*(*int32)(unsafe.Pointer(num_used))),
+ uint64(unsafe.Sizeof(int32(0))), *(*uintptr)(unsafe.Pointer(&struct {
+ f func(*libc.TLS, uintptr, uintptr) int32
+ }{PairComparison})))
- libc.Xmemmove(tls, mapping_index, (mapping_index + uintptr(1)*4), (uint64(unsafe.Sizeof(int32(0))) * (uint64(((int64(*(*int32)(unsafe.Pointer(num_used)))) - ((int64(mapping_index) - int64(mappings)) / 4)) - int64(1)))))
+ libc.Xmemmove(tls, mapping_index, mapping_index+uintptr(1)*4, uint64(unsafe.Sizeof(int32(0)))*uint64(int64(*(*int32)(unsafe.Pointer(num_used)))-(int64(mapping_index)-int64(mappings))/4-int64(1)))
// Merge the histograms and remove best_idx2 from the queue.
HistogramAdd(tls, *(*uintptr)(unsafe.Pointer(histograms + uintptr(*(*int32)(unsafe.Pointer(bp + 20 /* best_idx2 */)))*8)), *(*uintptr)(unsafe.Pointer(histograms + uintptr(best_idx1)*8)),
*(*uintptr)(unsafe.Pointer(histograms + uintptr(best_idx1)*8)))
@@ -28249,19 +27951,19 @@ __17:
// best_idx2 or image_histo_size.
j = 0
__18:
- if !(j < (*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).size) {
+ if !(j < (*HistoQueue)(unsafe.Pointer(bp)).size) {
goto __20
}
- p = ((*HistoQueue)(unsafe.Pointer(bp /* &histo_queue */)).queue + uintptr(j)*24)
- is_idx1_best = (libc.Bool32(((*HistogramPair)(unsafe.Pointer(p)).idx1 == best_idx1) || ((*HistogramPair)(unsafe.Pointer(p)).idx1 == *(*int32)(unsafe.Pointer(bp + 20 /* best_idx2 */)))))
- is_idx2_best = (libc.Bool32(((*HistogramPair)(unsafe.Pointer(p)).idx2 == best_idx1) || ((*HistogramPair)(unsafe.Pointer(p)).idx2 == *(*int32)(unsafe.Pointer(bp + 20 /* best_idx2 */)))))
+ p = (*HistoQueue)(unsafe.Pointer(bp)).queue + uintptr(j)*24
+ is_idx1_best = libc.Bool32((*HistogramPair)(unsafe.Pointer(p)).idx1 == best_idx1 || (*HistogramPair)(unsafe.Pointer(p)).idx1 == *(*int32)(unsafe.Pointer(bp + 20)))
+ is_idx2_best = libc.Bool32((*HistogramPair)(unsafe.Pointer(p)).idx2 == best_idx1 || (*HistogramPair)(unsafe.Pointer(p)).idx2 == *(*int32)(unsafe.Pointer(bp + 20)))
do_eval = 0
// The front pair could have been duplicated by a random pick so
// check for it all the time nevertheless.
- if !((is_idx1_best != 0) && (is_idx2_best != 0)) {
+ if !(is_idx1_best != 0 && is_idx2_best != 0) {
goto __21
}
- HistoQueuePopPair(tls, (bp) /* &histo_queue */, p)
+ HistoQueuePopPair(tls, bp, p)
goto __19
__21:
;
@@ -28300,13 +28002,13 @@ __25:
if !((*HistogramPair)(unsafe.Pointer(p)).cost_diff >= 0.) {
goto __27
}
- HistoQueuePopPair(tls, (bp) /* &histo_queue */, p)
+ HistoQueuePopPair(tls, bp, p)
goto __19
__27:
;
__26:
;
- HistoQueueUpdateHead(tls, (bp) /* &histo_queue */, p)
+ HistoQueueUpdateHead(tls, bp, p)
j++
goto __19
__19:
@@ -28323,11 +28025,11 @@ __9:
goto __10
__10:
;
- *(*int32)(unsafe.Pointer(do_greedy)) = (libc.Bool32(*(*int32)(unsafe.Pointer(num_used)) <= min_cluster_size))
+ *(*int32)(unsafe.Pointer(do_greedy)) = libc.Bool32(*(*int32)(unsafe.Pointer(num_used)) <= min_cluster_size)
ok = 1
End:
- HistoQueueClear(tls, (bp) /* &histo_queue */)
+ HistoQueueClear(tls, bp)
WebPSafeFree(tls, mappings)
return ok
}
@@ -28349,15 +28051,15 @@ func HistogramRemap(tls *libc.TLS, in uintptr, out uintptr, symbols uintptr) { /
var best_out int32 = 0
var best_bits float64 = 1.e38
var k int32
- if *(*uintptr)(unsafe.Pointer(in_histo + uintptr(i)*8)) == (uintptr(0)) {
+ if *(*uintptr)(unsafe.Pointer(in_histo + uintptr(i)*8)) == uintptr(0) {
// Arbitrarily set to the previous value if unused to help future LZ77.
- *(*uint16_t)(unsafe.Pointer(symbols + uintptr(i)*2)) = *(*uint16_t)(unsafe.Pointer(symbols + uintptr((i-1))*2))
+ *(*uint16_t)(unsafe.Pointer(symbols + uintptr(i)*2)) = *(*uint16_t)(unsafe.Pointer(symbols + uintptr(i-1)*2))
continue
}
for k = 0; k < out_size; k++ {
var cur_bits float64
cur_bits = HistogramAddThresh(tls, *(*uintptr)(unsafe.Pointer(out_histo + uintptr(k)*8)), *(*uintptr)(unsafe.Pointer(in_histo + uintptr(i)*8)), best_bits)
- if (k == 0) || (cur_bits < best_bits) {
+ if k == 0 || cur_bits < best_bits {
best_bits = cur_bits
best_out = k
}
@@ -28377,7 +28079,7 @@ func HistogramRemap(tls *libc.TLS, in uintptr, out uintptr, symbols uintptr) { /
for i = 0; i < in_size; i++ {
var idx int32
- if *(*uintptr)(unsafe.Pointer(in_histo + uintptr(i)*8)) == (uintptr(0)) {
+ if *(*uintptr)(unsafe.Pointer(in_histo + uintptr(i)*8)) == uintptr(0) {
continue
}
idx = int32(*(*uint16_t)(unsafe.Pointer(symbols + uintptr(i)*2)))
@@ -28389,16 +28091,16 @@ func GetCombineCostFactor(tls *libc.TLS, histo_size int32, quality int32) float6
var combine_cost_factor float64 = 0.16
if quality < 90 {
if histo_size > 256 {
- combine_cost_factor = combine_cost_factor / (2.)
+ combine_cost_factor = combine_cost_factor / 2.
}
if histo_size > 512 {
- combine_cost_factor = combine_cost_factor / (2.)
+ combine_cost_factor = combine_cost_factor / 2.
}
if histo_size > 1024 {
- combine_cost_factor = combine_cost_factor / (2.)
+ combine_cost_factor = combine_cost_factor / 2.
}
if quality <= 50 {
- combine_cost_factor = combine_cost_factor / (2.)
+ combine_cost_factor = combine_cost_factor / 2.
}
}
return combine_cost_factor
@@ -28430,7 +28132,7 @@ func OptimizeHistogramSymbols(tls *libc.TLS, set uintptr, cluster_mappings uintp
// Create a mapping from a cluster id to its minimal version.
cluster_max = 0
libc.Xmemset(tls, cluster_mappings_tmp, 0,
- (uint64((*VP8LHistogramSet)(unsafe.Pointer(set)).max_size) * uint64(unsafe.Sizeof(uint16_t(0)))))
+ uint64((*VP8LHistogramSet)(unsafe.Pointer(set)).max_size)*uint64(unsafe.Sizeof(uint16_t(0))))
// Re-map the ids.
for i = 0; i < (*VP8LHistogramSet)(unsafe.Pointer(set)).max_size; i++ {
@@ -28440,7 +28142,7 @@ func OptimizeHistogramSymbols(tls *libc.TLS, set uintptr, cluster_mappings uintp
}
cluster = int32(*(*uint16_t)(unsafe.Pointer(cluster_mappings + uintptr(*(*uint16_t)(unsafe.Pointer(symbols + uintptr(i)*2)))*2)))
- if (cluster > 0) && (int32(*(*uint16_t)(unsafe.Pointer(cluster_mappings_tmp + uintptr(cluster)*2))) == 0) {
+ if cluster > 0 && int32(*(*uint16_t)(unsafe.Pointer(cluster_mappings_tmp + uintptr(cluster)*2))) == 0 {
cluster_max++
*(*uint16_t)(unsafe.Pointer(cluster_mappings_tmp + uintptr(cluster)*2)) = uint16_t(cluster_max)
}
@@ -28467,7 +28169,7 @@ func RemoveEmptyHistograms(tls *libc.TLS, image_histo uintptr) { /* histogram_en
i = 0
size = uint32_t(0)
for ; i < (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).size; i++ {
- if *(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms + uintptr(i)*8)) == (uintptr(0)) {
+ if *(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms + uintptr(i)*8)) == uintptr(0) {
continue
}
*(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms + uintptr(libc.PostIncUint32(&size, 1))*8)) = *(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).histograms + uintptr(i)*8))
@@ -28511,19 +28213,19 @@ func VP8LGetHistoImageSymbols(tls *libc.TLS, xsize int32, ysize int32, refs uint
} else {
histo_ysize = 1
}
- image_histo_raw_size = (histo_xsize * histo_ysize)
+ image_histo_raw_size = histo_xsize * histo_ysize
orig_histo =
VP8LAllocateHistogramSet(tls, image_histo_raw_size, cache_bits)
if low_effort != 0 {
entropy_combine_num_bins = 4
} else {
- entropy_combine_num_bins = ((4 * 4) * 4)
+ entropy_combine_num_bins = 4 * 4 * 4
}
map_tmp =
- WebPSafeMalloc(tls, (uint64(2 * image_histo_raw_size)), uint64(unsafe.Sizeof(map_tmp)))
- cluster_mappings = (map_tmp + uintptr(image_histo_raw_size)*2)
+ WebPSafeMalloc(tls, uint64(2*image_histo_raw_size), uint64(unsafe.Sizeof(map_tmp)))
+ cluster_mappings = map_tmp + uintptr(image_histo_raw_size)*2
*(*int32)(unsafe.Pointer(bp /* num_used */)) = image_histo_raw_size
- if !((orig_histo == (uintptr(0))) || (map_tmp == (uintptr(0)))) {
+ if !(orig_histo == uintptr(0) || map_tmp == uintptr(0)) {
goto __1
}
goto Error
@@ -28534,10 +28236,10 @@ __1:
HistogramBuild(tls, xsize, histogram_bits, refs, orig_histo)
// Copies the histograms and computes its bit_cost.
// histogram_symbols is optimized
- HistogramCopyAndAnalyze(tls, orig_histo, image_histo, (bp), /* &num_used */
+ HistogramCopyAndAnalyze(tls, orig_histo, image_histo, bp,
histogram_symbols)
- entropy_combine = (libc.Bool32((*(*int32)(unsafe.Pointer(bp /* num_used */)) > (entropy_combine_num_bins * 2)) && (quality < 100)))
+ entropy_combine = libc.Bool32(*(*int32)(unsafe.Pointer(bp)) > entropy_combine_num_bins*2 && quality < 100)
if !(entropy_combine != 0) {
goto __2
@@ -28549,7 +28251,7 @@ __1:
HistogramAnalyzeEntropyBin(tls, image_histo, bin_map, low_effort)
// Collapse histograms with similar entropy.
- HistogramCombineEntropyBin(tls, image_histo, (bp) /* &num_used */, histogram_symbols,
+ HistogramCombineEntropyBin(tls, image_histo, bp, histogram_symbols,
cluster_mappings, tmp_histo, bin_map,
entropy_combine_num_bins, combine_cost_factor,
low_effort)
@@ -28563,21 +28265,21 @@ __2:
if !(!(low_effort != 0) || !(entropy_combine != 0)) {
goto __3
}
- x = (float32(quality) / 100.)
+ x = float32(quality) / 100.
// cubic ramp between 1 and MAX_HISTO_GREEDY:
- threshold_size = (libc.Int32FromFloat32(float32(1) + (((x * x) * x) * (float32(100 - 1)))))
- if !(!(HistogramCombineStochastic(tls, image_histo, (bp) /* &num_used */, threshold_size,
- (bp+4) /* &do_greedy */) != 0)) {
+ threshold_size = libc.Int32FromFloat32(float32(1) + x*x*x*float32(100-1))
+ if !!(HistogramCombineStochastic(tls, image_histo, bp, threshold_size,
+ bp+4) != 0) {
goto __4
}
goto Error
__4:
;
- if !(*(*int32)(unsafe.Pointer(bp + 4 /* do_greedy */)) != 0) {
+ if !(*(*int32)(unsafe.Pointer(bp + 4)) != 0) {
goto __5
}
RemoveEmptyHistograms(tls, image_histo)
- if !(!(HistogramCombineGreedy(tls, image_histo, (bp) /* &num_used */) != 0)) {
+ if !!(HistogramCombineGreedy(tls, image_histo, bp) != 0) {
goto __6
}
goto Error
@@ -28607,7 +28309,7 @@ Error:
//------------------------------------------------------------------------------
func InitLeft(tls *libc.TLS, it uintptr) { /* iterator_enc.c:22:13: */
- *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + libc.UintptrFromInt32(-1))) = libc.AssignPtrUint8(((*VP8EncIterator)(unsafe.Pointer(it)).u_left_ + libc.UintptrFromInt32(-1)), libc.AssignPtrUint8(((*VP8EncIterator)(unsafe.Pointer(it)).v_left_+libc.UintptrFromInt32(-1)), func() uint8 {
+ *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + libc.UintptrFromInt32(-1))) = libc.AssignPtrUint8((*VP8EncIterator)(unsafe.Pointer(it)).u_left_+libc.UintptrFromInt32(-1), libc.AssignPtrUint8((*VP8EncIterator)(unsafe.Pointer(it)).v_left_+libc.UintptrFromInt32(-1), func() uint8 {
if (*VP8EncIterator)(unsafe.Pointer(it)).y_ > 0 {
return uint8(129)
}
@@ -28616,19 +28318,19 @@ func InitLeft(tls *libc.TLS, it uintptr) { /* iterator_enc.c:22:13: */
libc.Xmemset(tls, (*VP8EncIterator)(unsafe.Pointer(it)).y_left_, 129, uint64(16))
libc.Xmemset(tls, (*VP8EncIterator)(unsafe.Pointer(it)).u_left_, 129, uint64(8))
libc.Xmemset(tls, (*VP8EncIterator)(unsafe.Pointer(it)).v_left_, 129, uint64(8))
- *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + 8*4)) = 0
- if (*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ != (uintptr(0)) {
- libc.Xmemset(tls, (it + 344 /* &.left_derr_ */), 0, uint64(unsafe.Sizeof(DError{})))
+ *(*int32)(unsafe.Pointer(it + 168 + 8*4)) = 0
+ if (*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ != uintptr(0) {
+ libc.Xmemset(tls, it+344, 0, uint64(unsafe.Sizeof(DError{})))
}
}
func InitTop(tls *libc.TLS, it uintptr) { /* iterator_enc.c:34:13: */
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
- var top_size size_t = (size_t((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * 16))
- libc.Xmemset(tls, (*VP8Encoder)(unsafe.Pointer(enc)).y_top_, 127, (uint64(2) * top_size))
- libc.Xmemset(tls, (*VP8Encoder)(unsafe.Pointer(enc)).nz_, 0, (uint64((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_) * uint64(unsafe.Sizeof(uint32_t(0)))))
- if (*VP8Encoder)(unsafe.Pointer(enc)).top_derr_ != (uintptr(0)) {
- libc.Xmemset(tls, (*VP8Encoder)(unsafe.Pointer(enc)).top_derr_, 0, (uint64((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_) * uint64(unsafe.Sizeof(DError{}))))
+ var top_size size_t = size_t((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * 16)
+ libc.Xmemset(tls, (*VP8Encoder)(unsafe.Pointer(enc)).y_top_, 127, uint64(2)*top_size)
+ libc.Xmemset(tls, (*VP8Encoder)(unsafe.Pointer(enc)).nz_, 0, uint64((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_)*uint64(unsafe.Sizeof(uint32_t(0))))
+ if (*VP8Encoder)(unsafe.Pointer(enc)).top_derr_ != uintptr(0) {
+ libc.Xmemset(tls, (*VP8Encoder)(unsafe.Pointer(enc)).top_derr_, 0, uint64((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_)*uint64(unsafe.Sizeof(DError{})))
}
}
@@ -28636,10 +28338,10 @@ func VP8IteratorSetRow(tls *libc.TLS, it uintptr, y int32) { /* iterator_enc.c:4
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
(*VP8EncIterator)(unsafe.Pointer(it)).x_ = 0
(*VP8EncIterator)(unsafe.Pointer(it)).y_ = y
- (*VP8EncIterator)(unsafe.Pointer(it)).bw_ = ((enc + 112 /* &.parts_ */) + uintptr((y&((*VP8Encoder)(unsafe.Pointer(enc)).num_parts_-1)))*48)
- (*VP8EncIterator)(unsafe.Pointer(it)).preds_ = ((*VP8Encoder)(unsafe.Pointer(enc)).preds_ + uintptr(((y * 4) * (*VP8Encoder)(unsafe.Pointer(enc)).preds_w_)))
+ (*VP8EncIterator)(unsafe.Pointer(it)).bw_ = enc + 112 + uintptr(y&((*VP8Encoder)(unsafe.Pointer(enc)).num_parts_-1))*48
+ (*VP8EncIterator)(unsafe.Pointer(it)).preds_ = (*VP8Encoder)(unsafe.Pointer(enc)).preds_ + uintptr(y*4*(*VP8Encoder)(unsafe.Pointer(enc)).preds_w_)
(*VP8EncIterator)(unsafe.Pointer(it)).nz_ = (*VP8Encoder)(unsafe.Pointer(enc)).nz_
- (*VP8EncIterator)(unsafe.Pointer(it)).mb_ = ((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr((y*(*VP8Encoder)(unsafe.Pointer(enc)).mb_w_))*4)
+ (*VP8EncIterator)(unsafe.Pointer(it)).mb_ = (*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(y*(*VP8Encoder)(unsafe.Pointer(enc)).mb_w_)*4
(*VP8EncIterator)(unsafe.Pointer(it)).y_top_ = (*VP8Encoder)(unsafe.Pointer(enc)).y_top_
(*VP8EncIterator)(unsafe.Pointer(it)).uv_top_ = (*VP8Encoder)(unsafe.Pointer(enc)).uv_top_
InitLeft(tls, it)
@@ -28648,46 +28350,46 @@ func VP8IteratorSetRow(tls *libc.TLS, it uintptr, y int32) { /* iterator_enc.c:4
func VP8IteratorReset(tls *libc.TLS, it uintptr) { /* iterator_enc.c:57:6: */
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
VP8IteratorSetRow(tls, it, 0)
- VP8IteratorSetCountDown(tls, it, ((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_)) // default
+ VP8IteratorSetCountDown(tls, it, (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_*(*VP8Encoder)(unsafe.Pointer(enc)).mb_h_) // default
InitTop(tls, it)
- libc.Xmemset(tls, (it + 208 /* &.bit_count_ */), 0, uint64(unsafe.Sizeof([4][3]uint64_t{})))
+ libc.Xmemset(tls, it+208, 0, uint64(unsafe.Sizeof([4][3]uint64_t{})))
(*VP8EncIterator)(unsafe.Pointer(it)).do_trellis_ = 0
}
func VP8IteratorSetCountDown(tls *libc.TLS, it uintptr, count_down int32) { /* iterator_enc.c:66:6: */
- (*VP8EncIterator)(unsafe.Pointer(it)).count_down_ = libc.AssignPtrInt32((it + 336 /* &.count_down0_ */), count_down)
+ (*VP8EncIterator)(unsafe.Pointer(it)).count_down_ = libc.AssignPtrInt32(it+336, count_down)
}
func VP8IteratorIsDone(tls *libc.TLS, it uintptr) int32 { /* iterator_enc.c:70:5: */
- return (libc.Bool32((*VP8EncIterator)(unsafe.Pointer(it)).count_down_ <= 0))
+ return libc.Bool32((*VP8EncIterator)(unsafe.Pointer(it)).count_down_ <= 0)
}
func VP8IteratorInit(tls *libc.TLS, enc uintptr, it uintptr) { /* iterator_enc.c:74:6: */
(*VP8EncIterator)(unsafe.Pointer(it)).enc_ = enc
- (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ = (uintptr(((uint64(it + 488 /* &.yuv_mem_ */)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
- (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((32 * 16)))
- (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((32 * 16)))
- (*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr((32 * 16)))
+ (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ = uintptr((uint64(it+488) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
+ (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr(32*16)
+ (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr(32*16)
+ (*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr(32*16)
(*VP8EncIterator)(unsafe.Pointer(it)).lf_stats_ = (*VP8Encoder)(unsafe.Pointer(enc)).lf_stats_
(*VP8EncIterator)(unsafe.Pointer(it)).percent0_ = (*VP8Encoder)(unsafe.Pointer(enc)).percent_
- (*VP8EncIterator)(unsafe.Pointer(it)).y_left_ = (uintptr((uintptr_t(((it + 400 /* &.yuv_left_mem_ */) + uintptr(1))) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
- (*VP8EncIterator)(unsafe.Pointer(it)).u_left_ = (((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + uintptr(16)) + uintptr(16))
- (*VP8EncIterator)(unsafe.Pointer(it)).v_left_ = ((*VP8EncIterator)(unsafe.Pointer(it)).u_left_ + uintptr(16))
+ (*VP8EncIterator)(unsafe.Pointer(it)).y_left_ = uintptr((uintptr_t(it+400+uintptr(1)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
+ (*VP8EncIterator)(unsafe.Pointer(it)).u_left_ = (*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + uintptr(16) + uintptr(16)
+ (*VP8EncIterator)(unsafe.Pointer(it)).v_left_ = (*VP8EncIterator)(unsafe.Pointer(it)).u_left_ + uintptr(16)
(*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ = (*VP8Encoder)(unsafe.Pointer(enc)).top_derr_
VP8IteratorReset(tls, it)
}
func VP8IteratorProgress(tls *libc.TLS, it uintptr, delta int32) int32 { /* iterator_enc.c:89:5: */
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
- if (delta != 0) && ((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).progress_hook != (uintptr(0))) {
- var done int32 = ((*VP8EncIterator)(unsafe.Pointer(it)).count_down0_ - (*VP8EncIterator)(unsafe.Pointer(it)).count_down_)
+ if delta != 0 && (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).progress_hook != uintptr(0) {
+ var done int32 = (*VP8EncIterator)(unsafe.Pointer(it)).count_down0_ - (*VP8EncIterator)(unsafe.Pointer(it)).count_down_
var percent int32
if (*VP8EncIterator)(unsafe.Pointer(it)).count_down0_ <= 0 {
percent = (*VP8EncIterator)(unsafe.Pointer(it)).percent0_
} else {
- percent = ((*VP8EncIterator)(unsafe.Pointer(it)).percent0_ + ((delta * done) / (*VP8EncIterator)(unsafe.Pointer(it)).count_down0_))
+ percent = (*VP8EncIterator)(unsafe.Pointer(it)).percent0_ + delta*done/(*VP8EncIterator)(unsafe.Pointer(it)).count_down0_
}
- return WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, percent, (enc + 536 /* &.percent_ */))
+ return WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, percent, enc+536)
}
return 1
}
@@ -28708,13 +28410,13 @@ func ImportBlock(tls *libc.TLS, src uintptr, src_stride int32, dst uintptr, w in
for i = 0; i < h; i++ {
libc.Xmemcpy(tls, dst, src, uint64(w))
if w < size {
- libc.Xmemset(tls, (dst + uintptr(w)), int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr((w - 1))))), (uint64(size - w)))
+ libc.Xmemset(tls, dst+uintptr(w), int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(w-1)))), uint64(size-w))
}
dst += uintptr(32)
src += uintptr(src_stride)
}
for i = h; i < size; i++ {
- libc.Xmemcpy(tls, dst, (dst - uintptr(32)), uint64(size))
+ libc.Xmemcpy(tls, dst, dst-uintptr(32), uint64(size))
dst += uintptr(32)
}
}
@@ -28736,7 +28438,7 @@ __2:
__3:
;
for ; i < total_len; i++ {
- *(*uint8_t)(unsafe.Pointer(dst + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(dst + uintptr((len - 1))))
+ *(*uint8_t)(unsafe.Pointer(dst + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(dst + uintptr(len-1)))
}
}
@@ -28745,19 +28447,19 @@ func VP8IteratorImport(tls *libc.TLS, it uintptr, tmp_32 uintptr) { /* iterator_
var x int32 = (*VP8EncIterator)(unsafe.Pointer(it)).x_
var y int32 = (*VP8EncIterator)(unsafe.Pointer(it)).y_
var pic uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).pic_
- var ysrc uintptr = ((*WebPPicture)(unsafe.Pointer(pic)).y + uintptr((((y * (*WebPPicture)(unsafe.Pointer(pic)).y_stride) + x) * 16)))
- var usrc uintptr = ((*WebPPicture)(unsafe.Pointer(pic)).u + uintptr((((y * (*WebPPicture)(unsafe.Pointer(pic)).uv_stride) + x) * 8)))
- var vsrc uintptr = ((*WebPPicture)(unsafe.Pointer(pic)).v + uintptr((((y * (*WebPPicture)(unsafe.Pointer(pic)).uv_stride) + x) * 8)))
- var w int32 = MinSize(tls, ((*WebPPicture)(unsafe.Pointer(pic)).width - (x * 16)), 16)
- var h int32 = MinSize(tls, ((*WebPPicture)(unsafe.Pointer(pic)).height - (y * 16)), 16)
- var uv_w int32 = ((w + 1) >> 1)
- var uv_h int32 = ((h + 1) >> 1)
-
- ImportBlock(tls, ysrc, (*WebPPicture)(unsafe.Pointer(pic)).y_stride, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((0))), w, h, 16)
- ImportBlock(tls, usrc, (*WebPPicture)(unsafe.Pointer(pic)).uv_stride, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((16))), uv_w, uv_h, 8)
- ImportBlock(tls, vsrc, (*WebPPicture)(unsafe.Pointer(pic)).uv_stride, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((16 + 8))), uv_w, uv_h, 8)
-
- if tmp_32 == (uintptr(0)) {
+ var ysrc uintptr = (*WebPPicture)(unsafe.Pointer(pic)).y + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).y_stride+x)*16)
+ var usrc uintptr = (*WebPPicture)(unsafe.Pointer(pic)).u + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).uv_stride+x)*8)
+ var vsrc uintptr = (*WebPPicture)(unsafe.Pointer(pic)).v + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).uv_stride+x)*8)
+ var w int32 = MinSize(tls, (*WebPPicture)(unsafe.Pointer(pic)).width-x*16, 16)
+ var h int32 = MinSize(tls, (*WebPPicture)(unsafe.Pointer(pic)).height-y*16, 16)
+ var uv_w int32 = (w + 1) >> 1
+ var uv_h int32 = (h + 1) >> 1
+
+ ImportBlock(tls, ysrc, (*WebPPicture)(unsafe.Pointer(pic)).y_stride, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_+uintptr(0), w, h, 16)
+ ImportBlock(tls, usrc, (*WebPPicture)(unsafe.Pointer(pic)).uv_stride, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_+uintptr(16), uv_w, uv_h, 8)
+ ImportBlock(tls, vsrc, (*WebPPicture)(unsafe.Pointer(pic)).uv_stride, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_+uintptr(16+8), uv_w, uv_h, 8)
+
+ if tmp_32 == uintptr(0) {
return
}
@@ -28766,25 +28468,25 @@ func VP8IteratorImport(tls *libc.TLS, it uintptr, tmp_32 uintptr) { /* iterator_
InitLeft(tls, it)
} else {
if y == 0 {
- *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + libc.UintptrFromInt32(-1))) = libc.AssignPtrUint8(((*VP8EncIterator)(unsafe.Pointer(it)).u_left_ + libc.UintptrFromInt32(-1)), libc.AssignPtrUint8(((*VP8EncIterator)(unsafe.Pointer(it)).v_left_+libc.UintptrFromInt32(-1)), uint8_t(127)))
+ *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + libc.UintptrFromInt32(-1))) = libc.AssignPtrUint8((*VP8EncIterator)(unsafe.Pointer(it)).u_left_+libc.UintptrFromInt32(-1), libc.AssignPtrUint8((*VP8EncIterator)(unsafe.Pointer(it)).v_left_+libc.UintptrFromInt32(-1), uint8_t(127)))
} else {
- *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + libc.UintptrFromInt32(-1))) = *(*uint8_t)(unsafe.Pointer(ysrc + uintptr((-1 - (*WebPPicture)(unsafe.Pointer(pic)).y_stride))))
- *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).u_left_ + libc.UintptrFromInt32(-1))) = *(*uint8_t)(unsafe.Pointer(usrc + uintptr((-1 - (*WebPPicture)(unsafe.Pointer(pic)).uv_stride))))
- *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).v_left_ + libc.UintptrFromInt32(-1))) = *(*uint8_t)(unsafe.Pointer(vsrc + uintptr((-1 - (*WebPPicture)(unsafe.Pointer(pic)).uv_stride))))
+ *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + libc.UintptrFromInt32(-1))) = *(*uint8_t)(unsafe.Pointer(ysrc + uintptr(-1-(*WebPPicture)(unsafe.Pointer(pic)).y_stride)))
+ *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).u_left_ + libc.UintptrFromInt32(-1))) = *(*uint8_t)(unsafe.Pointer(usrc + uintptr(-1-(*WebPPicture)(unsafe.Pointer(pic)).uv_stride)))
+ *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).v_left_ + libc.UintptrFromInt32(-1))) = *(*uint8_t)(unsafe.Pointer(vsrc + uintptr(-1-(*WebPPicture)(unsafe.Pointer(pic)).uv_stride)))
}
- ImportLine(tls, (ysrc - uintptr(1)), (*WebPPicture)(unsafe.Pointer(pic)).y_stride, (*VP8EncIterator)(unsafe.Pointer(it)).y_left_, h, 16)
- ImportLine(tls, (usrc - uintptr(1)), (*WebPPicture)(unsafe.Pointer(pic)).uv_stride, (*VP8EncIterator)(unsafe.Pointer(it)).u_left_, uv_h, 8)
- ImportLine(tls, (vsrc - uintptr(1)), (*WebPPicture)(unsafe.Pointer(pic)).uv_stride, (*VP8EncIterator)(unsafe.Pointer(it)).v_left_, uv_h, 8)
+ ImportLine(tls, ysrc-uintptr(1), (*WebPPicture)(unsafe.Pointer(pic)).y_stride, (*VP8EncIterator)(unsafe.Pointer(it)).y_left_, h, 16)
+ ImportLine(tls, usrc-uintptr(1), (*WebPPicture)(unsafe.Pointer(pic)).uv_stride, (*VP8EncIterator)(unsafe.Pointer(it)).u_left_, uv_h, 8)
+ ImportLine(tls, vsrc-uintptr(1), (*WebPPicture)(unsafe.Pointer(pic)).uv_stride, (*VP8EncIterator)(unsafe.Pointer(it)).v_left_, uv_h, 8)
}
- (*VP8EncIterator)(unsafe.Pointer(it)).y_top_ = (tmp_32 + uintptr(0))
- (*VP8EncIterator)(unsafe.Pointer(it)).uv_top_ = (tmp_32 + uintptr(16))
+ (*VP8EncIterator)(unsafe.Pointer(it)).y_top_ = tmp_32 + uintptr(0)
+ (*VP8EncIterator)(unsafe.Pointer(it)).uv_top_ = tmp_32 + uintptr(16)
if y == 0 {
- libc.Xmemset(tls, tmp_32, 127, (uint64(32) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ libc.Xmemset(tls, tmp_32, 127, uint64(32)*uint64(unsafe.Sizeof(uint8_t(0))))
} else {
- ImportLine(tls, (ysrc - uintptr((*WebPPicture)(unsafe.Pointer(pic)).y_stride)), 1, tmp_32, w, 16)
- ImportLine(tls, (usrc - uintptr((*WebPPicture)(unsafe.Pointer(pic)).uv_stride)), 1, (tmp_32 + uintptr(16)), uv_w, 8)
- ImportLine(tls, (vsrc - uintptr((*WebPPicture)(unsafe.Pointer(pic)).uv_stride)), 1, ((tmp_32 + uintptr(16)) + uintptr(8)), uv_w, 8)
+ ImportLine(tls, ysrc-uintptr((*WebPPicture)(unsafe.Pointer(pic)).y_stride), 1, tmp_32, w, 16)
+ ImportLine(tls, usrc-uintptr((*WebPPicture)(unsafe.Pointer(pic)).uv_stride), 1, tmp_32+uintptr(16), uv_w, 8)
+ ImportLine(tls, vsrc-uintptr((*WebPPicture)(unsafe.Pointer(pic)).uv_stride), 1, tmp_32+uintptr(16)+uintptr(8), uv_w, 8)
}
}
@@ -28804,15 +28506,15 @@ func VP8IteratorExport(tls *libc.TLS, it uintptr) { /* iterator_enc.c:188:6: */
if (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).show_compressed != 0 {
var x int32 = (*VP8EncIterator)(unsafe.Pointer(it)).x_
var y int32 = (*VP8EncIterator)(unsafe.Pointer(it)).y_
- var ysrc uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((0)))
- var usrc uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((16)))
- var vsrc uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((16 + 8)))
+ var ysrc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr(0)
+ var usrc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr(16)
+ var vsrc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr(16+8)
var pic uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).pic_
- var ydst uintptr = ((*WebPPicture)(unsafe.Pointer(pic)).y + uintptr((((y * (*WebPPicture)(unsafe.Pointer(pic)).y_stride) + x) * 16)))
- var udst uintptr = ((*WebPPicture)(unsafe.Pointer(pic)).u + uintptr((((y * (*WebPPicture)(unsafe.Pointer(pic)).uv_stride) + x) * 8)))
- var vdst uintptr = ((*WebPPicture)(unsafe.Pointer(pic)).v + uintptr((((y * (*WebPPicture)(unsafe.Pointer(pic)).uv_stride) + x) * 8)))
- var w int32 = ((*WebPPicture)(unsafe.Pointer(pic)).width - (x * 16))
- var h int32 = ((*WebPPicture)(unsafe.Pointer(pic)).height - (y * 16))
+ var ydst uintptr = (*WebPPicture)(unsafe.Pointer(pic)).y + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).y_stride+x)*16)
+ var udst uintptr = (*WebPPicture)(unsafe.Pointer(pic)).u + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).uv_stride+x)*8)
+ var vdst uintptr = (*WebPPicture)(unsafe.Pointer(pic)).v + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).uv_stride+x)*8)
+ var w int32 = (*WebPPicture)(unsafe.Pointer(pic)).width - x*16
+ var h int32 = (*WebPPicture)(unsafe.Pointer(pic)).height - y*16
if w > 16 {
w = 16
@@ -28825,8 +28527,8 @@ func VP8IteratorExport(tls *libc.TLS, it uintptr) { /* iterator_enc.c:188:6: */
ExportBlock(tls, ysrc, ydst, (*WebPPicture)(unsafe.Pointer(pic)).y_stride, w, h)
{ // U/V planes
- var uv_w int32 = ((w + 1) >> 1)
- var uv_h int32 = ((h + 1) >> 1)
+ var uv_w int32 = (w + 1) >> 1
+ var uv_h int32 = (h + 1) >> 1
ExportBlock(tls, usrc, udst, (*WebPPicture)(unsafe.Pointer(pic)).uv_stride, uv_w, uv_h)
ExportBlock(tls, vsrc, vdst, (*WebPPicture)(unsafe.Pointer(pic)).uv_stride, uv_w, uv_h)
@@ -28857,30 +28559,30 @@ func VP8IteratorNzToBytes(tls *libc.TLS, it uintptr) { /* iterator_enc.c:234:6:
var left_nz uintptr = it + 168 /* &.left_nz_ */
// Top-Y
- *(*int32)(unsafe.Pointer(top_nz)) = (libc.BoolInt32(!(!(((tnz) & (int32(1) << (12))) != 0))))
- *(*int32)(unsafe.Pointer(top_nz + 1*4)) = (libc.BoolInt32(!(!(((tnz) & (int32(1) << (13))) != 0))))
- *(*int32)(unsafe.Pointer(top_nz + 2*4)) = (libc.BoolInt32(!(!(((tnz) & (int32(1) << (14))) != 0))))
- *(*int32)(unsafe.Pointer(top_nz + 3*4)) = (libc.BoolInt32(!(!(((tnz) & (int32(1) << (15))) != 0))))
+ *(*int32)(unsafe.Pointer(top_nz)) = libc.BoolInt32(!!(tnz&(int32(1)<<12) != 0))
+ *(*int32)(unsafe.Pointer(top_nz + 1*4)) = libc.BoolInt32(!!(tnz&(int32(1)<<13) != 0))
+ *(*int32)(unsafe.Pointer(top_nz + 2*4)) = libc.BoolInt32(!!(tnz&(int32(1)<<14) != 0))
+ *(*int32)(unsafe.Pointer(top_nz + 3*4)) = libc.BoolInt32(!!(tnz&(int32(1)<<15) != 0))
// Top-U
- *(*int32)(unsafe.Pointer(top_nz + 4*4)) = (libc.BoolInt32(!(!(((tnz) & (int32(1) << (18))) != 0))))
- *(*int32)(unsafe.Pointer(top_nz + 5*4)) = (libc.BoolInt32(!(!(((tnz) & (int32(1) << (19))) != 0))))
+ *(*int32)(unsafe.Pointer(top_nz + 4*4)) = libc.BoolInt32(!!(tnz&(int32(1)<<18) != 0))
+ *(*int32)(unsafe.Pointer(top_nz + 5*4)) = libc.BoolInt32(!!(tnz&(int32(1)<<19) != 0))
// Top-V
- *(*int32)(unsafe.Pointer(top_nz + 6*4)) = (libc.BoolInt32(!(!(((tnz) & (int32(1) << (22))) != 0))))
- *(*int32)(unsafe.Pointer(top_nz + 7*4)) = (libc.BoolInt32(!(!(((tnz) & (int32(1) << (23))) != 0))))
+ *(*int32)(unsafe.Pointer(top_nz + 6*4)) = libc.BoolInt32(!!(tnz&(int32(1)<<22) != 0))
+ *(*int32)(unsafe.Pointer(top_nz + 7*4)) = libc.BoolInt32(!!(tnz&(int32(1)<<23) != 0))
// DC
- *(*int32)(unsafe.Pointer(top_nz + 8*4)) = (libc.BoolInt32(!(!(((tnz) & (int32(1) << (24))) != 0))))
+ *(*int32)(unsafe.Pointer(top_nz + 8*4)) = libc.BoolInt32(!!(tnz&(int32(1)<<24) != 0))
// left-Y
- *(*int32)(unsafe.Pointer(left_nz)) = (libc.BoolInt32(!(!(((lnz) & (int32(1) << (3))) != 0))))
- *(*int32)(unsafe.Pointer(left_nz + 1*4)) = (libc.BoolInt32(!(!(((lnz) & (int32(1) << (7))) != 0))))
- *(*int32)(unsafe.Pointer(left_nz + 2*4)) = (libc.BoolInt32(!(!(((lnz) & (int32(1) << (11))) != 0))))
- *(*int32)(unsafe.Pointer(left_nz + 3*4)) = (libc.BoolInt32(!(!(((lnz) & (int32(1) << (15))) != 0))))
+ *(*int32)(unsafe.Pointer(left_nz)) = libc.BoolInt32(!!(lnz&(int32(1)<<3) != 0))
+ *(*int32)(unsafe.Pointer(left_nz + 1*4)) = libc.BoolInt32(!!(lnz&(int32(1)<<7) != 0))
+ *(*int32)(unsafe.Pointer(left_nz + 2*4)) = libc.BoolInt32(!!(lnz&(int32(1)<<11) != 0))
+ *(*int32)(unsafe.Pointer(left_nz + 3*4)) = libc.BoolInt32(!!(lnz&(int32(1)<<15) != 0))
// left-U
- *(*int32)(unsafe.Pointer(left_nz + 4*4)) = (libc.BoolInt32(!(!(((lnz) & (int32(1) << (17))) != 0))))
- *(*int32)(unsafe.Pointer(left_nz + 5*4)) = (libc.BoolInt32(!(!(((lnz) & (int32(1) << (19))) != 0))))
+ *(*int32)(unsafe.Pointer(left_nz + 4*4)) = libc.BoolInt32(!!(lnz&(int32(1)<<17) != 0))
+ *(*int32)(unsafe.Pointer(left_nz + 5*4)) = libc.BoolInt32(!!(lnz&(int32(1)<<19) != 0))
// left-V
- *(*int32)(unsafe.Pointer(left_nz + 6*4)) = (libc.BoolInt32(!(!(((lnz) & (int32(1) << (21))) != 0))))
- *(*int32)(unsafe.Pointer(left_nz + 7*4)) = (libc.BoolInt32(!(!(((lnz) & (int32(1) << (23))) != 0))))
+ *(*int32)(unsafe.Pointer(left_nz + 6*4)) = libc.BoolInt32(!!(lnz&(int32(1)<<21) != 0))
+ *(*int32)(unsafe.Pointer(left_nz + 7*4)) = libc.BoolInt32(!!(lnz&(int32(1)<<23) != 0))
// left-DC is special, iterated separately
}
@@ -28889,15 +28591,15 @@ func VP8IteratorBytesToNz(tls *libc.TLS, it uintptr) { /* iterator_enc.c:267:6:
var top_nz uintptr = it + 132 /* &.top_nz_ */
var left_nz uintptr = it + 168 /* &.left_nz_ */
// top
- nz = nz | (uint32_t((*(*int32)(unsafe.Pointer(top_nz)) << 12) | (*(*int32)(unsafe.Pointer(top_nz + 1*4)) << 13)))
- nz = nz | (uint32_t((*(*int32)(unsafe.Pointer(top_nz + 2*4)) << 14) | (*(*int32)(unsafe.Pointer(top_nz + 3*4)) << 15)))
- nz = nz | (uint32_t((*(*int32)(unsafe.Pointer(top_nz + 4*4)) << 18) | (*(*int32)(unsafe.Pointer(top_nz + 5*4)) << 19)))
- nz = nz | (uint32_t((*(*int32)(unsafe.Pointer(top_nz + 6*4)) << 22) | (*(*int32)(unsafe.Pointer(top_nz + 7*4)) << 23)))
- nz = nz | (uint32_t(*(*int32)(unsafe.Pointer(top_nz + 8*4)) << 24)) // we propagate the _top_ bit, esp. for intra4
+ nz = nz | uint32_t(*(*int32)(unsafe.Pointer(top_nz))<<12|*(*int32)(unsafe.Pointer(top_nz + 1*4))<<13)
+ nz = nz | uint32_t(*(*int32)(unsafe.Pointer(top_nz + 2*4))<<14|*(*int32)(unsafe.Pointer(top_nz + 3*4))<<15)
+ nz = nz | uint32_t(*(*int32)(unsafe.Pointer(top_nz + 4*4))<<18|*(*int32)(unsafe.Pointer(top_nz + 5*4))<<19)
+ nz = nz | uint32_t(*(*int32)(unsafe.Pointer(top_nz + 6*4))<<22|*(*int32)(unsafe.Pointer(top_nz + 7*4))<<23)
+ nz = nz | uint32_t(*(*int32)(unsafe.Pointer(top_nz + 8*4))<<24) // we propagate the _top_ bit, esp. for intra4
// left
- nz = nz | (uint32_t((*(*int32)(unsafe.Pointer(left_nz)) << 3) | (*(*int32)(unsafe.Pointer(left_nz + 1*4)) << 7)))
- nz = nz | (uint32_t(*(*int32)(unsafe.Pointer(left_nz + 2*4)) << 11))
- nz = nz | (uint32_t((*(*int32)(unsafe.Pointer(left_nz + 4*4)) << 17) | (*(*int32)(unsafe.Pointer(left_nz + 6*4)) << 21)))
+ nz = nz | uint32_t(*(*int32)(unsafe.Pointer(left_nz))<<3|*(*int32)(unsafe.Pointer(left_nz + 1*4))<<7)
+ nz = nz | uint32_t(*(*int32)(unsafe.Pointer(left_nz + 2*4))<<11)
+ nz = nz | uint32_t(*(*int32)(unsafe.Pointer(left_nz + 4*4))<<17|*(*int32)(unsafe.Pointer(left_nz + 6*4))<<21)
*(*uint32_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).nz_)) = nz
}
@@ -28909,25 +28611,25 @@ func VP8IteratorSaveBoundary(tls *libc.TLS, it uintptr) { /* iterator_enc.c:290:
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
var x int32 = (*VP8EncIterator)(unsafe.Pointer(it)).x_
var y int32 = (*VP8EncIterator)(unsafe.Pointer(it)).y_
- var ysrc uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((0)))
- var uvsrc uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((16)))
- if x < ((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ - 1) { // left
+ var ysrc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr(0)
+ var uvsrc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr(16)
+ if x < (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_-1 { // left
var i int32
for i = 0; i < 16; i++ {
- *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(ysrc + uintptr((15 + (i * 32)))))
+ *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(ysrc + uintptr(15+i*32)))
}
for i = 0; i < 8; i++ {
- *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).u_left_ + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(uvsrc + uintptr((7 + (i * 32)))))
- *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).v_left_ + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(uvsrc + uintptr((15 + (i * 32)))))
+ *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).u_left_ + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(uvsrc + uintptr(7+i*32)))
+ *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).v_left_ + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(uvsrc + uintptr(15+i*32)))
}
// top-left (before 'top'!)
*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + libc.UintptrFromInt32(-1))) = *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_top_ + 15))
*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).u_left_ + libc.UintptrFromInt32(-1))) = *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).uv_top_ + 7))
*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).v_left_ + libc.UintptrFromInt32(-1))) = *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).uv_top_ + 15))
}
- if y < ((*VP8Encoder)(unsafe.Pointer(enc)).mb_h_ - 1) { // top
- libc.Xmemcpy(tls, (*VP8EncIterator)(unsafe.Pointer(it)).y_top_, (ysrc + uintptr((15 * 32))), uint64(16))
- libc.Xmemcpy(tls, (*VP8EncIterator)(unsafe.Pointer(it)).uv_top_, (uvsrc + uintptr((7 * 32))), (uint64(8 + 8)))
+ if y < (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_-1 { // top
+ libc.Xmemcpy(tls, (*VP8EncIterator)(unsafe.Pointer(it)).y_top_, ysrc+uintptr(15*32), uint64(16))
+ libc.Xmemcpy(tls, (*VP8EncIterator)(unsafe.Pointer(it)).uv_top_, uvsrc+uintptr(7*32), uint64(8+8))
}
}
@@ -28935,13 +28637,13 @@ func VP8IteratorNext(tls *libc.TLS, it uintptr) int32 { /* iterator_enc.c:315:5:
if libc.PreIncInt32(&(*VP8EncIterator)(unsafe.Pointer(it)).x_, 1) == (*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).enc_)).mb_w_ {
VP8IteratorSetRow(tls, it, libc.PreIncInt32(&(*VP8EncIterator)(unsafe.Pointer(it)).y_, 1))
} else {
- *(*uintptr)(unsafe.Pointer((it + 64 /* &.preds_ */))) += (uintptr(4))
- *(*uintptr)(unsafe.Pointer((it + 48 /* &.mb_ */))) += (uintptr(1)) * 4
- *(*uintptr)(unsafe.Pointer((it + 72 /* &.nz_ */))) += (uintptr(1)) * 4
- *(*uintptr)(unsafe.Pointer((it + 384 /* &.y_top_ */))) += (uintptr(16))
- *(*uintptr)(unsafe.Pointer((it + 392 /* &.uv_top_ */))) += (uintptr(16))
+ *(*uintptr)(unsafe.Pointer(it + 64)) += uintptr(4)
+ *(*uintptr)(unsafe.Pointer(it + 48)) += uintptr(1) * 4
+ *(*uintptr)(unsafe.Pointer(it + 72)) += uintptr(1) * 4
+ *(*uintptr)(unsafe.Pointer(it + 384)) += uintptr(16)
+ *(*uintptr)(unsafe.Pointer(it + 392)) += uintptr(16)
}
- return (libc.Bool32(0 < libc.PreDecInt32(&(*VP8EncIterator)(unsafe.Pointer(it)).count_down_, 1)))
+ return libc.Bool32(0 < libc.PreDecInt32(&(*VP8EncIterator)(unsafe.Pointer(it)).count_down_, 1))
}
//------------------------------------------------------------------------------
@@ -28954,30 +28656,30 @@ func VP8SetIntra16Mode(tls *libc.TLS, it uintptr, mode int32) { /* iterator_enc.
libc.Xmemset(tls, preds, mode, uint64(4))
preds += uintptr((*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).enc_)).preds_w_)
}
- libc.SetBitFieldPtr8Uint32(((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.type_ */), uint32(1), 0, 0x3)
+ libc.SetBitFieldPtr8Uint32((*VP8EncIterator)(unsafe.Pointer(it)).mb_, uint32(1), 0, 0x3)
}
func VP8SetIntra4Mode(tls *libc.TLS, it uintptr, modes uintptr) { /* iterator_enc.c:341:6: */
var preds uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).preds_
var y int32
for y = 4; y > 0; y-- {
- libc.Xmemcpy(tls, preds, modes, (uint64(4) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ libc.Xmemcpy(tls, preds, modes, uint64(4)*uint64(unsafe.Sizeof(uint8_t(0))))
preds += uintptr((*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).enc_)).preds_w_)
modes += uintptr(4)
}
- libc.SetBitFieldPtr8Uint32(((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.type_ */), uint32(0), 0, 0x3)
+ libc.SetBitFieldPtr8Uint32((*VP8EncIterator)(unsafe.Pointer(it)).mb_, uint32(0), 0, 0x3)
}
func VP8SetIntraUVMode(tls *libc.TLS, it uintptr, mode int32) { /* iterator_enc.c:352:6: */
- libc.SetBitFieldPtr8Uint32(((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.uv_mode_ */), uint32(mode), 2, 0xc)
+ libc.SetBitFieldPtr8Uint32((*VP8EncIterator)(unsafe.Pointer(it)).mb_, uint32(mode), 2, 0xc)
}
func VP8SetSkip(tls *libc.TLS, it uintptr, skip int32) { /* iterator_enc.c:356:6: */
- libc.SetBitFieldPtr8Uint32(((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.skip_ */), uint32(skip), 4, 0x10)
+ libc.SetBitFieldPtr8Uint32((*VP8EncIterator)(unsafe.Pointer(it)).mb_, uint32(skip), 4, 0x10)
}
func VP8SetSegment(tls *libc.TLS, it uintptr, segment int32) { /* iterator_enc.c:360:6: */
- libc.SetBitFieldPtr8Uint32(((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.segment_ */), uint32(segment), 5, 0x60)
+ libc.SetBitFieldPtr8Uint32((*VP8EncIterator)(unsafe.Pointer(it)).mb_, uint32(segment), 5, 0x60)
}
//------------------------------------------------------------------------------
@@ -29024,44 +28726,44 @@ func VP8IteratorStartI4(tls *libc.TLS, it uintptr) { /* iterator_enc.c:403:6: */
var i int32
(*VP8EncIterator)(unsafe.Pointer(it)).i4_ = 0 // first 4x4 sub-block
- (*VP8EncIterator)(unsafe.Pointer(it)).i4_top_ = ((it + 80 /* &.i4_boundary_ */) + uintptr(VP8TopLeftI4[0]))
+ (*VP8EncIterator)(unsafe.Pointer(it)).i4_top_ = it + 80 + uintptr(VP8TopLeftI4[0])
// Import the boundary samples
for i = 0; i < 17; i++ { // left
- *(*uint8_t)(unsafe.Pointer((it + 80 /* &.i4_boundary_ */) + uintptr(i))) = *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + uintptr((15 - i))))
+ *(*uint8_t)(unsafe.Pointer(it + 80 + uintptr(i))) = *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_left_ + uintptr(15-i)))
}
for i = 0; i < 16; i++ { // top
- *(*uint8_t)(unsafe.Pointer((it + 80 /* &.i4_boundary_ */) + uintptr((17 + i)))) = *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_top_ + uintptr(i)))
+ *(*uint8_t)(unsafe.Pointer(it + 80 + uintptr(17+i))) = *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_top_ + uintptr(i)))
}
// top-right samples have a special case on the far right of the picture
- if (*VP8EncIterator)(unsafe.Pointer(it)).x_ < ((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ - 1) {
- for i = 16; i < (16 + 4); i++ {
- *(*uint8_t)(unsafe.Pointer((it + 80 /* &.i4_boundary_ */) + uintptr((17 + i)))) = *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_top_ + uintptr(i)))
+ if (*VP8EncIterator)(unsafe.Pointer(it)).x_ < (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_-1 {
+ for i = 16; i < 16+4; i++ {
+ *(*uint8_t)(unsafe.Pointer(it + 80 + uintptr(17+i))) = *(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).y_top_ + uintptr(i)))
}
} else { // else, replicate the last valid pixel four times
- for i = 16; i < (16 + 4); i++ {
- *(*uint8_t)(unsafe.Pointer((it + 80 /* &.i4_boundary_ */) + uintptr((17 + i)))) = *(*uint8_t)(unsafe.Pointer((it + 80 /* &.i4_boundary_ */) + 32))
+ for i = 16; i < 16+4; i++ {
+ *(*uint8_t)(unsafe.Pointer(it + 80 + uintptr(17+i))) = *(*uint8_t)(unsafe.Pointer(it + 80 + 32))
}
}
VP8IteratorNzToBytes(tls, it) // import the non-zero context
}
func VP8IteratorRotateI4(tls *libc.TLS, it uintptr, yuv_out uintptr) int32 { /* iterator_enc.c:430:5: */
- var blk uintptr = (yuv_out + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_]))
+ var blk uintptr = yuv_out + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_])
var top uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).i4_top_
var i int32
// Update the cache with 7 fresh samples
for i = 0; i <= 3; i++ {
- *(*uint8_t)(unsafe.Pointer(top + uintptr((-4 + i)))) = *(*uint8_t)(unsafe.Pointer(blk + uintptr((i + (3 * 32))))) // store future top samples
+ *(*uint8_t)(unsafe.Pointer(top + uintptr(-4+i))) = *(*uint8_t)(unsafe.Pointer(blk + uintptr(i+3*32))) // store future top samples
}
- if ((*VP8EncIterator)(unsafe.Pointer(it)).i4_ & 3) != 3 { // if not on the right sub-blocks #3, #7, #11, #15
+ if (*VP8EncIterator)(unsafe.Pointer(it)).i4_&3 != 3 { // if not on the right sub-blocks #3, #7, #11, #15
for i = 0; i <= 2; i++ { // store future left samples
- *(*uint8_t)(unsafe.Pointer(top + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(blk + uintptr((3 + ((2 - i) * 32)))))
+ *(*uint8_t)(unsafe.Pointer(top + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(blk + uintptr(3+(2-i)*32)))
}
} else { // else replicate top-right samples, as says the specs.
for i = 0; i <= 3; i++ {
- *(*uint8_t)(unsafe.Pointer(top + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(top + uintptr((i + 4))))
+ *(*uint8_t)(unsafe.Pointer(top + uintptr(i))) = *(*uint8_t)(unsafe.Pointer(top + uintptr(i+4)))
}
}
// move pointers to next sub-block
@@ -29070,7 +28772,7 @@ func VP8IteratorRotateI4(tls *libc.TLS, it uintptr, yuv_out uintptr) int32 { /*
return 0
}
- (*VP8EncIterator)(unsafe.Pointer(it)).i4_top_ = ((it + 80 /* &.i4_boundary_ */) + uintptr(VP8TopLeftI4[(*VP8EncIterator)(unsafe.Pointer(it)).i4_]))
+ (*VP8EncIterator)(unsafe.Pointer(it)).i4_top_ = it + 80 + uintptr(VP8TopLeftI4[(*VP8EncIterator)(unsafe.Pointer(it)).i4_])
return 1
}
@@ -29081,18 +28783,18 @@ func VP8IteratorRotateI4(tls *libc.TLS, it uintptr, yuv_out uintptr) int32 { /*
// Quantizes the value up or down to a multiple of 1<<bits (or to 255),
// choosing the closer one, resolving ties using bankers' rounding.
func FindClosestDiscretized(tls *libc.TLS, a uint32_t, bits int32) uint32_t { /* near_lossless_enc.c:31:17: */
- var mask uint32_t = ((uint32(1) << bits) - uint32(1))
- var biased uint32_t = ((a + (mask >> 1)) + ((a >> bits) & uint32_t(1)))
+ var mask uint32_t = uint32(1)<<bits - uint32(1)
+ var biased uint32_t = a + mask>>1 + a>>bits&uint32_t(1)
if biased > uint32_t(0xff) {
return uint32_t(0xff)
}
- return (biased & ^mask)
+ return biased & ^mask
}
// Applies FindClosestDiscretized to all channels of pixel.
func ClosestDiscretizedArgb(tls *libc.TLS, a uint32_t, bits int32) uint32_t { /* near_lossless_enc.c:40:17: */
- return ((((FindClosestDiscretized(tls, (a>>24), bits) << 24) | (FindClosestDiscretized(tls, ((a>>16)&uint32_t(0xff)), bits) << 16)) | (FindClosestDiscretized(tls, ((a>>8)&uint32_t(0xff)), bits) << 8)) | (FindClosestDiscretized(tls, (a & uint32_t(0xff)), bits)))
+ return FindClosestDiscretized(tls, a>>24, bits)<<24 | FindClosestDiscretized(tls, a>>16&uint32_t(0xff), bits)<<16 | FindClosestDiscretized(tls, a>>8&uint32_t(0xff), bits)<<8 | FindClosestDiscretized(tls, a&uint32_t(0xff), bits)
}
// Checks if distance between corresponding channel values of pixels a and b
@@ -29100,8 +28802,8 @@ func ClosestDiscretizedArgb(tls *libc.TLS, a uint32_t, bits int32) uint32_t { /*
func IsNear(tls *libc.TLS, a uint32_t, b uint32_t, limit int32) int32 { /* near_lossless_enc.c:50:12: */
var k int32
for k = 0; k < 4; k++ {
- var delta int32 = ((int32((a >> (k * 8)) & uint32_t(0xff))) - (int32((b >> (k * 8)) & uint32_t(0xff))))
- if (delta >= limit) || (delta <= -limit) {
+ var delta int32 = int32(a>>(k*8)&uint32_t(0xff)) - int32(b>>(k*8)&uint32_t(0xff))
+ if delta >= limit || delta <= -limit {
return 0
}
}
@@ -29110,19 +28812,19 @@ func IsNear(tls *libc.TLS, a uint32_t, b uint32_t, limit int32) int32 { /* near_
func IsSmooth(tls *libc.TLS, prev_row uintptr, curr_row uintptr, next_row uintptr, ix int32, limit int32) int32 { /* near_lossless_enc.c:62:12: */
// Check that all pixels in 4-connected neighborhood are smooth.
- return (libc.Bool32((((IsNear(tls, *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(ix)*4)), *(*uint32_t)(unsafe.Pointer(curr_row + uintptr((ix-1))*4)), limit) != 0) && (IsNear(tls, *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(ix)*4)), *(*uint32_t)(unsafe.Pointer(curr_row + uintptr((ix+1))*4)), limit) != 0)) && (IsNear(tls, *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(ix)*4)), *(*uint32_t)(unsafe.Pointer(prev_row + uintptr(ix)*4)), limit) != 0)) && (IsNear(tls, *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(ix)*4)), *(*uint32_t)(unsafe.Pointer(next_row + uintptr(ix)*4)), limit) != 0)))
+ return libc.Bool32(IsNear(tls, *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(ix)*4)), *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(ix-1)*4)), limit) != 0 && IsNear(tls, *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(ix)*4)), *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(ix+1)*4)), limit) != 0 && IsNear(tls, *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(ix)*4)), *(*uint32_t)(unsafe.Pointer(prev_row + uintptr(ix)*4)), limit) != 0 && IsNear(tls, *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(ix)*4)), *(*uint32_t)(unsafe.Pointer(next_row + uintptr(ix)*4)), limit) != 0)
}
// Adjusts pixel values of image with given maximum error.
func NearLossless(tls *libc.TLS, xsize int32, ysize int32, argb_src uintptr, stride int32, limit_bits int32, copy_buffer uintptr, argb_dst uintptr) { /* near_lossless_enc.c:74:13: */
var x int32
var y int32
- var limit int32 = (int32(1) << limit_bits)
+ var limit int32 = int32(1) << limit_bits
var prev_row uintptr = copy_buffer
- var curr_row uintptr = (prev_row + uintptr(xsize)*4)
- var next_row uintptr = (curr_row + uintptr(xsize)*4)
- libc.Xmemcpy(tls, curr_row, argb_src, (uint64(xsize) * uint64(unsafe.Sizeof(uint32_t(0)))))
- libc.Xmemcpy(tls, next_row, (argb_src + uintptr(stride)*4), (uint64(xsize) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ var curr_row uintptr = prev_row + uintptr(xsize)*4
+ var next_row uintptr = curr_row + uintptr(xsize)*4
+ libc.Xmemcpy(tls, curr_row, argb_src, uint64(xsize)*uint64(unsafe.Sizeof(uint32_t(0))))
+ libc.Xmemcpy(tls, next_row, argb_src+uintptr(stride)*4, uint64(xsize)*uint64(unsafe.Sizeof(uint32_t(0))))
y = 0
__1:
@@ -29130,13 +28832,13 @@ __1:
goto __3
}
{
- if (y == 0) || (y == (ysize - 1)) {
- libc.Xmemcpy(tls, argb_dst, argb_src, (uint64(xsize) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ if y == 0 || y == ysize-1 {
+ libc.Xmemcpy(tls, argb_dst, argb_src, uint64(xsize)*uint64(unsafe.Sizeof(uint32_t(0))))
} else {
- libc.Xmemcpy(tls, next_row, (argb_src + uintptr(stride)*4), (uint64(xsize) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, next_row, argb_src+uintptr(stride)*4, uint64(xsize)*uint64(unsafe.Sizeof(uint32_t(0))))
*(*uint32_t)(unsafe.Pointer(argb_dst)) = *(*uint32_t)(unsafe.Pointer(argb_src))
- *(*uint32_t)(unsafe.Pointer(argb_dst + uintptr((xsize-1))*4)) = *(*uint32_t)(unsafe.Pointer(argb_src + uintptr((xsize-1))*4))
- for x = 1; x < (xsize - 1); x++ {
+ *(*uint32_t)(unsafe.Pointer(argb_dst + uintptr(xsize-1)*4)) = *(*uint32_t)(unsafe.Pointer(argb_src + uintptr(xsize-1)*4))
+ for x = 1; x < xsize-1; x++ {
if IsSmooth(tls, prev_row, curr_row, next_row, x, limit) != 0 {
*(*uint32_t)(unsafe.Pointer(argb_dst + uintptr(x)*4)) = *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(x)*4))
} else {
@@ -29157,8 +28859,8 @@ __1:
goto __2
__2:
y++
- argb_src += 4 * (uintptr(stride))
- argb_dst += 4 * (uintptr(xsize))
+ argb_src += 4 * uintptr(stride)
+ argb_dst += 4 * uintptr(xsize)
goto __1
goto __3
__3:
@@ -29169,17 +28871,17 @@ func VP8ApplyNearLossless(tls *libc.TLS, picture uintptr, quality int32, argb_ds
var xsize int32 = (*WebPPicture)(unsafe.Pointer(picture)).width
var ysize int32 = (*WebPPicture)(unsafe.Pointer(picture)).height
var stride int32 = (*WebPPicture)(unsafe.Pointer(picture)).argb_stride
- var copy_buffer uintptr = WebPSafeMalloc(tls, (uint64(xsize * 3)), uint64(unsafe.Sizeof(uint32_t(0))))
+ var copy_buffer uintptr = WebPSafeMalloc(tls, uint64(xsize*3), uint64(unsafe.Sizeof(uint32_t(0))))
var limit_bits int32 = VP8LNearLosslessBits(tls, quality)
- if copy_buffer == (uintptr(0)) {
+ if copy_buffer == uintptr(0) {
return 0
}
// For small icon images, don't attempt to apply near-lossless compression.
- if ((xsize < 64) && (ysize < 64)) || (ysize < 3) {
+ if xsize < 64 && ysize < 64 || ysize < 3 {
for i = 0; i < ysize; i++ {
- libc.Xmemcpy(tls, (argb_dst + uintptr((i*xsize))*4), ((*WebPPicture)(unsafe.Pointer(picture)).argb + uintptr((i*(*WebPPicture)(unsafe.Pointer(picture)).argb_stride))*4),
- (uint64(xsize) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, argb_dst+uintptr(i*xsize)*4, (*WebPPicture)(unsafe.Pointer(picture)).argb+uintptr(i*(*WebPPicture)(unsafe.Pointer(picture)).argb_stride)*4,
+ uint64(xsize)*uint64(unsafe.Sizeof(uint32_t(0))))
}
WebPSafeFree(tls, copy_buffer)
return 1
@@ -29187,7 +28889,7 @@ func VP8ApplyNearLossless(tls *libc.TLS, picture uintptr, quality int32, argb_ds
NearLossless(tls, xsize, ysize, (*WebPPicture)(unsafe.Pointer(picture)).argb, stride, limit_bits, copy_buffer,
argb_dst)
- for i = (limit_bits - 1); i != 0; i-- {
+ for i = limit_bits - 1; i != 0; i-- {
NearLossless(tls, xsize, ysize, argb_dst, xsize, i, copy_buffer, argb_dst)
}
WebPSafeFree(tls, copy_buffer)
@@ -29205,7 +28907,7 @@ func VP8ApplyNearLossless(tls *libc.TLS, picture uintptr, quality int32, argb_ds
// Returns true if alpha[] has non-0xff values.
func CheckNonOpaque(tls *libc.TLS, alpha uintptr, width int32, height int32, x_step int32, y_step int32) int32 { /* picture_csp_enc.c:45:12: */
- if alpha == (uintptr(0)) {
+ if alpha == uintptr(0) {
return 0
}
WebPInitAlphaProcessing(tls)
@@ -29231,14 +28933,14 @@ func CheckNonOpaque(tls *libc.TLS, alpha uintptr, width int32, height int32, x_s
// Checking for the presence of non-opaque alpha.
func WebPPictureHasTransparency(tls *libc.TLS, picture uintptr) int32 { /* picture_csp_enc.c:62:5: */
- if picture == (uintptr(0)) {
+ if picture == uintptr(0) {
return 0
}
if (*WebPPicture)(unsafe.Pointer(picture)).use_argb != 0 {
- var alpha_offset int32 = (3 - (0))
- return CheckNonOpaque(tls, ((*WebPPicture)(unsafe.Pointer(picture)).argb + uintptr(alpha_offset)),
+ var alpha_offset int32 = 3 - 0
+ return CheckNonOpaque(tls, (*WebPPicture)(unsafe.Pointer(picture)).argb+uintptr(alpha_offset),
(*WebPPicture)(unsafe.Pointer(picture)).width, (*WebPPicture)(unsafe.Pointer(picture)).height,
- 4, (int32(uint64((*WebPPicture)(unsafe.Pointer(picture)).argb_stride) * uint64(unsafe.Sizeof(uint32_t(0))))))
+ 4, int32(uint64((*WebPPicture)(unsafe.Pointer(picture)).argb_stride)*uint64(unsafe.Sizeof(uint32_t(0)))))
}
return CheckNonOpaque(tls, (*WebPPicture)(unsafe.Pointer(picture)).a, (*WebPPicture)(unsafe.Pointer(picture)).width, (*WebPPicture)(unsafe.Pointer(picture)).height,
1, (*WebPPicture)(unsafe.Pointer(picture)).a_stride)
@@ -29254,7 +28956,7 @@ var kGammaToLinearTab [256]uint16_t /* picture_csp_enc.c:89:17: */
var kGammaTablesOk int32 = 0 /* picture_csp_enc.c:90:21 */
func InitGammaTables(tls *libc.TLS) { /* picture_csp_enc.c:93:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if InitGammaTables_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -29268,13 +28970,13 @@ var InitGammaTables_body_last_cpuinfo_used VP8CPUInfo = 0 /* picture_csp_enc.c:9
func InitGammaTables_body(tls *libc.TLS) { /* picture_csp_enc.c:93:1: */
if !(libc.AtomicLoadInt32(&kGammaTablesOk) != 0) {
var v int32
- var scale float64 = (float64((float64(int32(1) << 7))) / (float64((int32(1) << 12) - 1)))
- var norm float64 = (float64(1.) / 255.)
+ var scale float64 = float64(float64(int32(1)<<7)) / float64(int32(1)<<12-1)
+ var norm float64 = float64(1.) / 255.
for v = 0; v <= 255; v++ {
- kGammaToLinearTab[v] = (libc.Uint16FromFloat64((libc.Xpow(tls, (norm*float64(v)), 0.80) * (float64((int32(1) << 12) - 1))) + .5))
+ kGammaToLinearTab[v] = libc.Uint16FromFloat64(libc.Xpow(tls, norm*float64(v), 0.80)*float64(int32(1)<<12-1) + .5)
}
- for v = 0; v <= (int32(1) << (12 - 7)); v++ {
- kLinearToGammaTab[v] = (libc.Int32FromFloat64((255. * libc.Xpow(tls, (scale*float64(v)), (float64(1.)/0.80))) + .5))
+ for v = 0; v <= int32(1)<<(12-7); v++ {
+ kLinearToGammaTab[v] = libc.Int32FromFloat64(255.*libc.Xpow(tls, scale*float64(v), float64(1.)/0.80) + .5)
}
libc.AtomicStoreInt32(&kGammaTablesOk, int32(1))
}
@@ -29285,11 +28987,11 @@ func GammaToLinear(tls *libc.TLS, v uint8_t) uint32_t { /* picture_csp_enc.c:109
}
func Interpolate(tls *libc.TLS, v int32) int32 { /* picture_csp_enc.c:113:24: */
- var tab_pos int32 = (v >> (7 + 2)) // integer part
- var x int32 = (v & ((int32((int32(1) << 7)) << 2) - 1)) // fractional part
+ var tab_pos int32 = v >> (7 + 2) // integer part
+ var x int32 = v & (int32(int32(1)<<7)<<2 - 1) // fractional part
var v0 int32 = kLinearToGammaTab[tab_pos]
- var v1 int32 = kLinearToGammaTab[(tab_pos + 1)]
- var y int32 = ((v1 * x) + (v0 * ((int32((int32(1) << 7)) << 2) - x))) // interpolate
+ var v1 int32 = kLinearToGammaTab[tab_pos+1]
+ var y int32 = v1*x + v0*(int32(int32(1)<<7)<<2-x) // interpolate
return y
}
@@ -29297,32 +28999,32 @@ func Interpolate(tls *libc.TLS, v int32) int32 { /* picture_csp_enc.c:113:24: */
// Convert a linear value 'v' to YUV_FIX+2 fixed-point precision
// U/V value, suitable for RGBToU/V calls.
func LinearToGamma(tls *libc.TLS, base_value uint32_t, shift int32) int32 { /* picture_csp_enc.c:125:24: */
- var y int32 = Interpolate(tls, (int32(base_value << shift))) // final uplifted value
- return ((y + (int32((int32(1) << 7)) >> 1)) >> 7) // descale
+ var y int32 = Interpolate(tls, int32(base_value<<shift)) // final uplifted value
+ return (y + int32(int32(1)<<7)>>1) >> 7 // descale
}
//------------------------------------------------------------------------------
// RGB -> YUV conversion
func RGBToY(tls *libc.TLS, r int32, g int32, b int32, rg uintptr) int32 { /* picture_csp_enc.c:143:12: */
- if rg == (uintptr(0)) {
+ if rg == uintptr(0) {
return VP8RGBToY(tls, r, g, b, YUV_HALF)
}
return VP8RGBToY(tls, r, g, b, VP8RandomBits(tls, rg, YUV_FIX))
}
func RGBToU(tls *libc.TLS, r int32, g int32, b int32, rg uintptr) int32 { /* picture_csp_enc.c:148:12: */
- if rg == (uintptr(0)) {
- return VP8RGBToU(tls, r, g, b, (int32(YUV_HALF) << 2))
+ if rg == uintptr(0) {
+ return VP8RGBToU(tls, r, g, b, int32(YUV_HALF)<<2)
}
- return VP8RGBToU(tls, r, g, b, VP8RandomBits(tls, rg, (YUV_FIX+2)))
+ return VP8RGBToU(tls, r, g, b, VP8RandomBits(tls, rg, YUV_FIX+2))
}
func RGBToV(tls *libc.TLS, r int32, g int32, b int32, rg uintptr) int32 { /* picture_csp_enc.c:153:12: */
- if rg == (uintptr(0)) {
- return VP8RGBToV(tls, r, g, b, (int32(YUV_HALF) << 2))
+ if rg == uintptr(0) {
+ return VP8RGBToV(tls, r, g, b, int32(YUV_HALF)<<2)
}
- return VP8RGBToV(tls, r, g, b, VP8RandomBits(tls, rg, (YUV_FIX+2)))
+ return VP8RGBToV(tls, r, g, b, VP8RandomBits(tls, rg, YUV_FIX+2))
}
//------------------------------------------------------------------------------
@@ -29343,7 +29045,7 @@ var kGammaToLinearTabS [1024]uint32_t /* picture_csp_enc.c:181:17: */ // size sc
var kGammaTablesSOk int32 = 0 /* picture_csp_enc.c:182:21 */
func InitGammaTablesS(tls *libc.TLS) { /* picture_csp_enc.c:185:1: */
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
if InitGammaTablesS_body_last_cpuinfo_used == VP8GetCPUInfo {
break
}
@@ -29358,35 +29060,35 @@ func InitGammaTablesS_body(tls *libc.TLS) { /* picture_csp_enc.c:185:1: */
// we use uint32_t intermediate values
if !(libc.AtomicLoadInt32(&kGammaTablesSOk) != 0) {
var v int32
- var norm float64 = (float64(1.) / (float64((int32(256) << 2) - 1)))
- var scale float64 = (float64(1.) / (float64(int32(1) << (12 - 7))))
+ var norm float64 = float64(1.) / float64(int32(256)<<2-1)
+ var scale float64 = float64(1.) / float64(int32(1)<<(12-7))
var a float64 = 0.09929682680944
var thresh float64 = 0.018053968510807
- var final_scale float64 = (float64(int32(1) << 14))
- for v = 0; v <= ((int32(256) << 2) - 1); v++ {
- var g float64 = (norm * float64(v))
+ var final_scale float64 = float64(int32(1) << 14)
+ for v = 0; v <= int32(256)<<2-1; v++ {
+ var g float64 = norm * float64(v)
var value float64
- if g <= (thresh * 4.5) {
- value = (g / 4.5)
+ if g <= thresh*4.5 {
+ value = g / 4.5
} else {
- var a_rec float64 = (1. / (1. + a))
- value = libc.Xpow(tls, (a_rec * (g + a)), (float64(1.) / 0.45))
+ var a_rec float64 = 1. / (1. + a)
+ value = libc.Xpow(tls, a_rec*(g+a), float64(1.)/0.45)
}
- kGammaToLinearTabS[v] = (libc.Uint32FromFloat64((value * final_scale) + .5))
+ kGammaToLinearTabS[v] = libc.Uint32FromFloat64(value*final_scale + .5)
}
- for v = 0; v <= (int32(1) << (12 - 7)); v++ {
- var g float64 = (scale * float64(v))
+ for v = 0; v <= int32(1)<<(12-7); v++ {
+ var g float64 = scale * float64(v)
var value float64
if g <= thresh {
- value = (4.5 * g)
+ value = 4.5 * g
} else {
- value = (((1. + a) * libc.Xpow(tls, g, (float64(1.)/(float64(1.)/0.45)))) - a)
+ value = (1.+a)*libc.Xpow(tls, g, float64(1.)/(float64(1.)/0.45)) - a
}
// we already incorporate the 1/2 rounding constant here
- kLinearToGammaTabS[v] = ((libc.Uint32FromFloat64((float64((int32(256) << 2) - 1)) * value)) + (uint32_t(int32((int32(1) << 14)) >> 1)))
+ kLinearToGammaTabS[v] = libc.Uint32FromFloat64(float64(int32(256)<<2-1)*value) + uint32_t(int32(int32(1)<<14)>>1)
}
// to prevent small rounding errors to cause read-overflow:
- kLinearToGammaTabS[((int32(1) << (12 - 7)) + 1)] = kLinearToGammaTabS[(int32(1) << (12 - 7))]
+ kLinearToGammaTabS[int32(1)<<(12-7)+1] = kLinearToGammaTabS[int32(1)<<(12-7)]
libc.AtomicStoreInt32(&kGammaTablesSOk, int32(1))
}
}
@@ -29398,23 +29100,23 @@ func GammaToLinearS(tls *libc.TLS, v int32) uint32_t { /* picture_csp_enc.c:224:
func LinearToGammaS(tls *libc.TLS, value uint32_t) uint32_t { /* picture_csp_enc.c:228:29: */
// 'value' is in GAMMA_TO_LINEAR_BITS fractional precision
- var v uint32_t = (value * (uint32_t(int32(1) << (12 - 7))))
- var tab_pos uint32_t = (v >> 14)
+ var v uint32_t = value * uint32_t(int32(1)<<(12-7))
+ var tab_pos uint32_t = v >> 14
// fractional part, in GAMMA_TO_LINEAR_BITS fixed-point precision
- var x uint32_t = (v - (tab_pos << 14)) // fractional part
+ var x uint32_t = v - tab_pos<<14 // fractional part
// v0 / v1 are in GAMMA_TO_LINEAR_BITS fixed-point precision (range [0..1])
- var v0 uint32_t = kLinearToGammaTabS[(tab_pos + uint32_t(0))]
- var v1 uint32_t = kLinearToGammaTabS[(tab_pos + uint32_t(1))]
+ var v0 uint32_t = kLinearToGammaTabS[tab_pos+uint32_t(0)]
+ var v1 uint32_t = kLinearToGammaTabS[tab_pos+uint32_t(1)]
// Final interpolation. Note that rounding is already included.
- var v2 uint32_t = ((v1 - v0) * x) // note: v1 >= v0.
- var result uint32_t = (v0 + (v2 >> 14))
+ var v2 uint32_t = (v1 - v0) * x // note: v1 >= v0.
+ var result uint32_t = v0 + v2>>14
return result
}
//------------------------------------------------------------------------------
func clip_8b2(tls *libc.TLS, v fixed_t) uint8_t { /* picture_csp_enc.c:257:16: */
- if !((int32(v) & libc.CplInt32(0xff)) != 0) {
+ if !(int32(v)&libc.CplInt32(0xff) != 0) {
return uint8_t(v)
}
if int32(v) < 0 {
@@ -29424,20 +29126,20 @@ func clip_8b2(tls *libc.TLS, v fixed_t) uint8_t { /* picture_csp_enc.c:257:16: *
}
func clip_y1(tls *libc.TLS, y int32) fixed_y_t { /* picture_csp_enc.c:261:18: */
- if !((y & libc.CplInt32(((int32(256) << 2) - 1))) != 0) {
+ if !(y&libc.CplInt32(int32(256)<<2-1) != 0) {
return fixed_y_t(y)
}
if y < 0 {
return uint16(0)
}
- return (uint16((int32(256) << 2) - 1))
+ return uint16(int32(256)<<2 - 1)
}
//------------------------------------------------------------------------------
func RGBToGray(tls *libc.TLS, r int32, g int32, b int32) int32 { /* picture_csp_enc.c:267:12: */
- var luma int32 = ((((13933 * r) + (46871 * g)) + (4732 * b)) + YUV_HALF)
- return (luma >> YUV_FIX)
+ var luma int32 = 13933*r + 46871*g + 4732*b + YUV_HALF
+ return luma >> YUV_FIX
}
func ScaleDown(tls *libc.TLS, a int32, b int32, c int32, d int32) uint32_t { /* picture_csp_enc.c:272:17: */
@@ -29445,15 +29147,15 @@ func ScaleDown(tls *libc.TLS, a int32, b int32, c int32, d int32) uint32_t { /*
var B uint32_t = GammaToLinearS(tls, b)
var C uint32_t = GammaToLinearS(tls, c)
var D uint32_t = GammaToLinearS(tls, d)
- return LinearToGammaS(tls, (((((A + B) + C) + D) + uint32_t(2)) >> 2))
+ return LinearToGammaS(tls, (A+B+C+D+uint32_t(2))>>2)
}
func UpdateW(tls *libc.TLS, src uintptr, dst uintptr, w int32) { /* picture_csp_enc.c:280:25: */
var i int32
for i = 0; i < w; i++ {
- var R uint32_t = GammaToLinearS(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src + uintptr(((0*w)+i))*2))))
- var G uint32_t = GammaToLinearS(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src + uintptr(((1*w)+i))*2))))
- var B uint32_t = GammaToLinearS(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src + uintptr(((2*w)+i))*2))))
+ var R uint32_t = GammaToLinearS(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src + uintptr(0*w+i)*2))))
+ var G uint32_t = GammaToLinearS(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src + uintptr(1*w+i)*2))))
+ var B uint32_t = GammaToLinearS(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src + uintptr(2*w+i)*2))))
var Y uint32_t = uint32_t(RGBToGray(tls, int32(R), int32(G), int32(B)))
*(*fixed_y_t)(unsafe.Pointer(dst + uintptr(i)*2)) = fixed_y_t(LinearToGammaS(tls, Y))
}
@@ -29462,61 +29164,61 @@ func UpdateW(tls *libc.TLS, src uintptr, dst uintptr, w int32) { /* picture_csp_
func UpdateChroma(tls *libc.TLS, src1 uintptr, src2 uintptr, dst uintptr, uv_w int32) { /* picture_csp_enc.c:291:13: */
var i int32
for i = 0; i < uv_w; i++ {
- var r int32 = int32(ScaleDown(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(((0*uv_w)+0))*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(((0*uv_w)+1))*2))),
- int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(((0*uv_w)+0))*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(((0*uv_w)+1))*2)))))
- var g int32 = int32(ScaleDown(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(((2*uv_w)+0))*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(((2*uv_w)+1))*2))),
- int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(((2*uv_w)+0))*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(((2*uv_w)+1))*2)))))
- var b int32 = int32(ScaleDown(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(((4*uv_w)+0))*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(((4*uv_w)+1))*2))),
- int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(((4*uv_w)+0))*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(((4*uv_w)+1))*2)))))
+ var r int32 = int32(ScaleDown(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(0*uv_w+0)*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(0*uv_w+1)*2))),
+ int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(0*uv_w+0)*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(0*uv_w+1)*2)))))
+ var g int32 = int32(ScaleDown(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(2*uv_w+0)*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(2*uv_w+1)*2))),
+ int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(2*uv_w+0)*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(2*uv_w+1)*2)))))
+ var b int32 = int32(ScaleDown(tls, int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(4*uv_w+0)*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src1 + uintptr(4*uv_w+1)*2))),
+ int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(4*uv_w+0)*2))), int32(*(*fixed_y_t)(unsafe.Pointer(src2 + uintptr(4*uv_w+1)*2)))))
var W int32 = RGBToGray(tls, r, g, b)
- *(*fixed_t)(unsafe.Pointer(dst + uintptr((0*uv_w))*2)) = (fixed_t(r - W))
- *(*fixed_t)(unsafe.Pointer(dst + uintptr((1*uv_w))*2)) = (fixed_t(g - W))
- *(*fixed_t)(unsafe.Pointer(dst + uintptr((2*uv_w))*2)) = (fixed_t(b - W))
- dst += 2 * (uintptr(1))
- src1 += 2 * (uintptr(2))
- src2 += 2 * (uintptr(2))
+ *(*fixed_t)(unsafe.Pointer(dst + uintptr(0*uv_w)*2)) = fixed_t(r - W)
+ *(*fixed_t)(unsafe.Pointer(dst + uintptr(1*uv_w)*2)) = fixed_t(g - W)
+ *(*fixed_t)(unsafe.Pointer(dst + uintptr(2*uv_w)*2)) = fixed_t(b - W)
+ dst += 2 * uintptr(1)
+ src1 += 2 * uintptr(2)
+ src2 += 2 * uintptr(2)
}
}
func StoreGray(tls *libc.TLS, rgb uintptr, y uintptr, w int32) { /* picture_csp_enc.c:311:13: */
var i int32
for i = 0; i < w; i++ {
- *(*fixed_y_t)(unsafe.Pointer(y + uintptr(i)*2)) = fixed_y_t(RGBToGray(tls, int32(*(*fixed_y_t)(unsafe.Pointer(rgb + uintptr(((0*w)+i))*2))), int32(*(*fixed_y_t)(unsafe.Pointer(rgb + uintptr(((1*w)+i))*2))), int32(*(*fixed_y_t)(unsafe.Pointer(rgb + uintptr(((2*w)+i))*2)))))
+ *(*fixed_y_t)(unsafe.Pointer(y + uintptr(i)*2)) = fixed_y_t(RGBToGray(tls, int32(*(*fixed_y_t)(unsafe.Pointer(rgb + uintptr(0*w+i)*2))), int32(*(*fixed_y_t)(unsafe.Pointer(rgb + uintptr(1*w+i)*2))), int32(*(*fixed_y_t)(unsafe.Pointer(rgb + uintptr(2*w+i)*2)))))
}
}
//------------------------------------------------------------------------------
func Filter2(tls *libc.TLS, A int32, B int32, W0 int32) fixed_y_t { /* picture_csp_enc.c:320:30: */
- var v0 int32 = ((((A * 3) + B) + 2) >> 2)
- return clip_y1(tls, (v0 + W0))
+ var v0 int32 = (A*3 + B + 2) >> 2
+ return clip_y1(tls, v0+W0)
}
//------------------------------------------------------------------------------
func UpLift(tls *libc.TLS, a uint8_t) fixed_y_t { /* picture_csp_enc.c:327:30: */ // 8bit -> SFIX
- return (fixed_y_t((int32(fixed_y_t(a)) << 2) | (int32((int32(1) << 2)) >> 1)))
+ return fixed_y_t(int32(fixed_y_t(a))<<2 | int32(int32(1)<<2)>>1)
}
func ImportOneRow(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintptr, step int32, pic_width int32, dst uintptr) { /* picture_csp_enc.c:331:13: */
var i int32
- var w int32 = ((pic_width + 1) & libc.CplInt32(1))
+ var w int32 = (pic_width + 1) & libc.CplInt32(1)
for i = 0; i < pic_width; i++ {
- var off int32 = (i * step)
- *(*fixed_y_t)(unsafe.Pointer(dst + uintptr((i+(0*w)))*2)) = UpLift(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(off))))
- *(*fixed_y_t)(unsafe.Pointer(dst + uintptr((i+(1*w)))*2)) = UpLift(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(off))))
- *(*fixed_y_t)(unsafe.Pointer(dst + uintptr((i+(2*w)))*2)) = UpLift(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(off))))
+ var off int32 = i * step
+ *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(i+0*w)*2)) = UpLift(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(off))))
+ *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(i+1*w)*2)) = UpLift(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(off))))
+ *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(i+2*w)*2)) = UpLift(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(off))))
}
- if (pic_width & 1) != 0 { // replicate rightmost pixel
- *(*fixed_y_t)(unsafe.Pointer(dst + uintptr((pic_width+(0*w)))*2)) = *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(((pic_width+(0*w))-1))*2))
- *(*fixed_y_t)(unsafe.Pointer(dst + uintptr((pic_width+(1*w)))*2)) = *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(((pic_width+(1*w))-1))*2))
- *(*fixed_y_t)(unsafe.Pointer(dst + uintptr((pic_width+(2*w)))*2)) = *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(((pic_width+(2*w))-1))*2))
+ if pic_width&1 != 0 { // replicate rightmost pixel
+ *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(pic_width+0*w)*2)) = *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(pic_width+0*w-1)*2))
+ *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(pic_width+1*w)*2)) = *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(pic_width+1*w-1)*2))
+ *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(pic_width+2*w)*2)) = *(*fixed_y_t)(unsafe.Pointer(dst + uintptr(pic_width+2*w-1)*2))
}
}
func InterpolateTwoRows(tls *libc.TLS, best_y uintptr, prev_uv uintptr, cur_uv uintptr, next_uv uintptr, w int32, out1 uintptr, out2 uintptr) { /* picture_csp_enc.c:352:13: */
- var uv_w int32 = (w >> 1)
- var len int32 = ((w - 1) >> 1) // length to filter
+ var uv_w int32 = w >> 1
+ var len int32 = (w - 1) >> 1 // length to filter
var k int32 = 3
for libc.PostDecInt32(&k, 1) > 0 { // process each R/G/B segments in turn
// special boundary case for i==0
@@ -29525,39 +29227,39 @@ func InterpolateTwoRows(tls *libc.TLS, best_y uintptr, prev_uv uintptr, cur_uv u
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{WebPSharpYUVFilterRow})).f(tls, cur_uv, prev_uv, len, ((best_y + uintptr(0)*2) + uintptr(1)*2), (out1 + uintptr(1)*2))
+ })(unsafe.Pointer(&struct{ uintptr }{WebPSharpYUVFilterRow})).f(tls, cur_uv, prev_uv, len, best_y+uintptr(0)*2+uintptr(1)*2, out1+uintptr(1)*2)
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{WebPSharpYUVFilterRow})).f(tls, cur_uv, next_uv, len, ((best_y + uintptr(w)*2) + uintptr(1)*2), (out2 + uintptr(1)*2))
+ })(unsafe.Pointer(&struct{ uintptr }{WebPSharpYUVFilterRow})).f(tls, cur_uv, next_uv, len, best_y+uintptr(w)*2+uintptr(1)*2, out2+uintptr(1)*2)
// special boundary case for i == w - 1 when w is even
- if !((w & 1) != 0) {
- *(*fixed_y_t)(unsafe.Pointer(out1 + uintptr((w-1))*2)) = Filter2(tls, int32(*(*fixed_t)(unsafe.Pointer(cur_uv + uintptr((uv_w-1))*2))), int32(*(*fixed_t)(unsafe.Pointer(prev_uv + uintptr((uv_w-1))*2))),
- int32(*(*fixed_y_t)(unsafe.Pointer(best_y + uintptr(((w-1)+0))*2))))
- *(*fixed_y_t)(unsafe.Pointer(out2 + uintptr((w-1))*2)) = Filter2(tls, int32(*(*fixed_t)(unsafe.Pointer(cur_uv + uintptr((uv_w-1))*2))), int32(*(*fixed_t)(unsafe.Pointer(next_uv + uintptr((uv_w-1))*2))),
- int32(*(*fixed_y_t)(unsafe.Pointer(best_y + uintptr(((w-1)+w))*2))))
+ if !(w&1 != 0) {
+ *(*fixed_y_t)(unsafe.Pointer(out1 + uintptr(w-1)*2)) = Filter2(tls, int32(*(*fixed_t)(unsafe.Pointer(cur_uv + uintptr(uv_w-1)*2))), int32(*(*fixed_t)(unsafe.Pointer(prev_uv + uintptr(uv_w-1)*2))),
+ int32(*(*fixed_y_t)(unsafe.Pointer(best_y + uintptr(w-1+0)*2))))
+ *(*fixed_y_t)(unsafe.Pointer(out2 + uintptr(w-1)*2)) = Filter2(tls, int32(*(*fixed_t)(unsafe.Pointer(cur_uv + uintptr(uv_w-1)*2))), int32(*(*fixed_t)(unsafe.Pointer(next_uv + uintptr(uv_w-1)*2))),
+ int32(*(*fixed_y_t)(unsafe.Pointer(best_y + uintptr(w-1+w)*2))))
}
- out1 += 2 * (uintptr(w))
- out2 += 2 * (uintptr(w))
- prev_uv += 2 * (uintptr(uv_w))
- cur_uv += 2 * (uintptr(uv_w))
- next_uv += 2 * (uintptr(uv_w))
+ out1 += 2 * uintptr(w)
+ out2 += 2 * uintptr(w)
+ prev_uv += 2 * uintptr(uv_w)
+ cur_uv += 2 * uintptr(uv_w)
+ next_uv += 2 * uintptr(uv_w)
}
}
func ConvertRGBToY(tls *libc.TLS, r int32, g int32, b int32) uint8_t { /* picture_csp_enc.c:385:28: */
- var luma int32 = ((((16839 * r) + (33059 * g)) + (6420 * b)) + (int32(1) << ((YUV_FIX + 2) - 1)))
- return clip_8b2(tls, (int16(16 + (luma >> (YUV_FIX + 2)))))
+ var luma int32 = 16839*r + 33059*g + 6420*b + int32(1)<<(YUV_FIX+2-1)
+ return clip_8b2(tls, int16(16+luma>>(YUV_FIX+2)))
}
func ConvertRGBToU(tls *libc.TLS, r int32, g int32, b int32) uint8_t { /* picture_csp_enc.c:390:28: */
- var u int32 = ((((-9719 * r) - (19081 * g)) + (28800 * b)) + (int32(1) << ((YUV_FIX + 2) - 1)))
- return clip_8b2(tls, (int16(128 + (u >> (YUV_FIX + 2)))))
+ var u int32 = -9719*r - 19081*g + 28800*b + int32(1)<<(YUV_FIX+2-1)
+ return clip_8b2(tls, int16(128+u>>(YUV_FIX+2)))
}
func ConvertRGBToV(tls *libc.TLS, r int32, g int32, b int32) uint8_t { /* picture_csp_enc.c:395:28: */
- var v int32 = ((((+28800 * r) - (24116 * g)) - (4684 * b)) + (int32(1) << ((YUV_FIX + 2) - 1)))
- return clip_8b2(tls, (int16(128 + (v >> (YUV_FIX + 2)))))
+ var v int32 = +28800*r - 24116*g - 4684*b + int32(1)<<(YUV_FIX+2-1)
+ return clip_8b2(tls, int16(128+v>>(YUV_FIX+2)))
}
func ConvertWRGBToYUV(tls *libc.TLS, best_y uintptr, best_uv uintptr, picture uintptr) int32 { /* picture_csp_enc.c:400:12: */
@@ -29567,23 +29269,23 @@ func ConvertWRGBToYUV(tls *libc.TLS, best_y uintptr, best_uv uintptr, picture ui
var dst_u uintptr = (*WebPPicture)(unsafe.Pointer(picture)).u
var dst_v uintptr = (*WebPPicture)(unsafe.Pointer(picture)).v
var best_uv_base uintptr = best_uv
- var w int32 = (((*WebPPicture)(unsafe.Pointer(picture)).width + 1) & libc.CplInt32(1))
- var h int32 = (((*WebPPicture)(unsafe.Pointer(picture)).height + 1) & libc.CplInt32(1))
- var uv_w int32 = (w >> 1)
- var uv_h int32 = (h >> 1)
+ var w int32 = ((*WebPPicture)(unsafe.Pointer(picture)).width + 1) & libc.CplInt32(1)
+ var h int32 = ((*WebPPicture)(unsafe.Pointer(picture)).height + 1) & libc.CplInt32(1)
+ var uv_w int32 = w >> 1
+ var uv_h int32 = h >> 1
best_uv = best_uv_base
j = 0
for ; j < (*WebPPicture)(unsafe.Pointer(picture)).height; j++ {
for i = 0; i < (*WebPPicture)(unsafe.Pointer(picture)).width; i++ {
- var off int32 = (i >> 1)
+ var off int32 = i >> 1
var W int32 = int32(*(*fixed_y_t)(unsafe.Pointer(best_y + uintptr(i)*2)))
- var r int32 = (int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr((off+(0*uv_w)))*2))) + W)
- var g int32 = (int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr((off+(1*uv_w)))*2))) + W)
- var b int32 = (int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr((off+(2*uv_w)))*2))) + W)
+ var r int32 = int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr(off+0*uv_w)*2))) + W
+ var g int32 = int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr(off+1*uv_w)*2))) + W
+ var b int32 = int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr(off+2*uv_w)*2))) + W
*(*uint8_t)(unsafe.Pointer(dst_y + uintptr(i))) = ConvertRGBToY(tls, r, g, b)
}
- best_y += 2 * (uintptr(w))
- best_uv += 2 * (uintptr(((j & 1) * 3) * uv_w))
+ best_y += 2 * uintptr(w)
+ best_uv += 2 * uintptr(j&1*3*uv_w)
dst_y += uintptr((*WebPPicture)(unsafe.Pointer(picture)).y_stride)
}
best_uv = best_uv_base
@@ -29591,13 +29293,13 @@ func ConvertWRGBToYUV(tls *libc.TLS, best_y uintptr, best_uv uintptr, picture ui
for ; j < uv_h; j++ {
for i = 0; i < uv_w; i++ {
var off int32 = i
- var r int32 = int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr((off+(0*uv_w)))*2)))
- var g int32 = int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr((off+(1*uv_w)))*2)))
- var b int32 = int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr((off+(2*uv_w)))*2)))
+ var r int32 = int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr(off+0*uv_w)*2)))
+ var g int32 = int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr(off+1*uv_w)*2)))
+ var b int32 = int32(*(*fixed_t)(unsafe.Pointer(best_uv + uintptr(off+2*uv_w)*2)))
*(*uint8_t)(unsafe.Pointer(dst_u + uintptr(i))) = ConvertRGBToU(tls, r, g, b)
*(*uint8_t)(unsafe.Pointer(dst_v + uintptr(i))) = ConvertRGBToV(tls, r, g, b)
}
- best_uv += 2 * (uintptr(3 * uv_w))
+ best_uv += 2 * uintptr(3*uv_w)
dst_u += uintptr((*WebPPicture)(unsafe.Pointer(picture)).uv_stride)
dst_v += uintptr((*WebPPicture)(unsafe.Pointer(picture)).uv_stride)
}
@@ -29641,25 +29343,25 @@ func PreprocessARGB(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintptr,
var cur_uv uintptr
var prev_uv uintptr
var diff_y_sum uint64_t
- w = (((*WebPPicture)(unsafe.Pointer(picture)).width + 1) & libc.CplInt32(1))
- h = (((*WebPPicture)(unsafe.Pointer(picture)).height + 1) & libc.CplInt32(1))
- uv_w = (w >> 1)
- uv_h = (h >> 1)
+ w = ((*WebPPicture)(unsafe.Pointer(picture)).width + 1) & libc.CplInt32(1)
+ h = ((*WebPPicture)(unsafe.Pointer(picture)).height + 1) & libc.CplInt32(1)
+ uv_w = w >> 1
+ uv_h = h >> 1
prev_diff_y_sum = libc.Uint64FromInt32(libc.CplInt32(0))
- tmp_buffer = (WebPSafeMalloc(tls, (uint64((w * 3) * (2))), uint64(unsafe.Sizeof(fixed_y_t(0)))))
- best_y_base = (WebPSafeMalloc(tls, (uint64((w) * (h))), uint64(unsafe.Sizeof(fixed_y_t(0)))))
- target_y_base = (WebPSafeMalloc(tls, (uint64((w) * (h))), uint64(unsafe.Sizeof(fixed_y_t(0)))))
- best_rgb_y = (WebPSafeMalloc(tls, (uint64((w) * (2))), uint64(unsafe.Sizeof(fixed_y_t(0)))))
- best_uv_base = (WebPSafeMalloc(tls, (uint64((uv_w * 3) * (uv_h))), uint64(unsafe.Sizeof(fixed_t(0)))))
- target_uv_base = (WebPSafeMalloc(tls, (uint64((uv_w * 3) * (uv_h))), uint64(unsafe.Sizeof(fixed_t(0)))))
- best_rgb_uv = (WebPSafeMalloc(tls, (uint64((uv_w * 3) * (1))), uint64(unsafe.Sizeof(fixed_t(0)))))
+ tmp_buffer = WebPSafeMalloc(tls, uint64(w*3*2), uint64(unsafe.Sizeof(fixed_y_t(0))))
+ best_y_base = WebPSafeMalloc(tls, uint64(w*h), uint64(unsafe.Sizeof(fixed_y_t(0))))
+ target_y_base = WebPSafeMalloc(tls, uint64(w*h), uint64(unsafe.Sizeof(fixed_y_t(0))))
+ best_rgb_y = WebPSafeMalloc(tls, uint64(w*2), uint64(unsafe.Sizeof(fixed_y_t(0))))
+ best_uv_base = WebPSafeMalloc(tls, uint64(uv_w*3*uv_h), uint64(unsafe.Sizeof(fixed_t(0))))
+ target_uv_base = WebPSafeMalloc(tls, uint64(uv_w*3*uv_h), uint64(unsafe.Sizeof(fixed_t(0))))
+ best_rgb_uv = WebPSafeMalloc(tls, uint64(uv_w*3*1), uint64(unsafe.Sizeof(fixed_t(0))))
best_y = best_y_base
target_y = target_y_base
best_uv = best_uv_base
target_uv = target_uv_base
- diff_y_threshold = (libc.Uint64FromFloat64((3.0 * float64(w)) * float64(h)))
+ diff_y_threshold = libc.Uint64FromFloat64(3.0 * float64(w) * float64(h))
- if !(((((((best_y_base == (uintptr(0))) || (best_uv_base == (uintptr(0)))) || (target_y_base == (uintptr(0)))) || (target_uv_base == (uintptr(0)))) || (best_rgb_y == (uintptr(0)))) || (best_rgb_uv == (uintptr(0)))) || (tmp_buffer == (uintptr(0)))) {
+ if !(best_y_base == uintptr(0) || best_uv_base == uintptr(0) || target_y_base == uintptr(0) || target_uv_base == uintptr(0) || best_rgb_y == uintptr(0) || best_rgb_uv == uintptr(0) || tmp_buffer == uintptr(0)) {
goto __1
}
ok = WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_OUT_OF_MEMORY)
@@ -29675,39 +29377,39 @@ __2:
if !(j < (*WebPPicture)(unsafe.Pointer(picture)).height) {
goto __4
}
- is_last_row = (libc.Bool32(j == ((*WebPPicture)(unsafe.Pointer(picture)).height - 1)))
- src1 = (tmp_buffer + uintptr((0*w))*2)
- src2 = (tmp_buffer + uintptr((3*w))*2)
+ is_last_row = libc.Bool32(j == (*WebPPicture)(unsafe.Pointer(picture)).height-1)
+ src1 = tmp_buffer + uintptr(0*w)*2
+ src2 = tmp_buffer + uintptr(3*w)*2
// prepare two rows of input
ImportOneRow(tls, r_ptr, g_ptr, b_ptr, step, (*WebPPicture)(unsafe.Pointer(picture)).width, src1)
- if !(!(is_last_row != 0)) {
+ if !!(is_last_row != 0) {
goto __5
}
- ImportOneRow(tls, (r_ptr + uintptr(rgb_stride)), (g_ptr + uintptr(rgb_stride)), (b_ptr + uintptr(rgb_stride)),
+ ImportOneRow(tls, r_ptr+uintptr(rgb_stride), g_ptr+uintptr(rgb_stride), b_ptr+uintptr(rgb_stride),
step, (*WebPPicture)(unsafe.Pointer(picture)).width, src2)
goto __6
__5:
- libc.Xmemcpy(tls, src2, src1, ((uint64(3 * w)) * uint64(unsafe.Sizeof(fixed_y_t(0)))))
+ libc.Xmemcpy(tls, src2, src1, uint64(3*w)*uint64(unsafe.Sizeof(fixed_y_t(0))))
__6:
;
- StoreGray(tls, src1, (best_y + uintptr(0)*2), w)
- StoreGray(tls, src2, (best_y + uintptr(w)*2), w)
+ StoreGray(tls, src1, best_y+uintptr(0)*2, w)
+ StoreGray(tls, src2, best_y+uintptr(w)*2, w)
UpdateW(tls, src1, target_y, w)
- UpdateW(tls, src2, (target_y + uintptr(w)*2), w)
+ UpdateW(tls, src2, target_y+uintptr(w)*2, w)
UpdateChroma(tls, src1, src2, target_uv, uv_w)
- libc.Xmemcpy(tls, best_uv, target_uv, ((uint64(3 * uv_w)) * uint64(unsafe.Sizeof(fixed_t(0)))))
- best_y += 2 * (uintptr(2 * w))
- best_uv += 2 * (uintptr(3 * uv_w))
- target_y += 2 * (uintptr(2 * w))
- target_uv += 2 * (uintptr(3 * uv_w))
- r_ptr += (uintptr(2 * rgb_stride))
- g_ptr += (uintptr(2 * rgb_stride))
- b_ptr += (uintptr(2 * rgb_stride))
+ libc.Xmemcpy(tls, best_uv, target_uv, uint64(3*uv_w)*uint64(unsafe.Sizeof(fixed_t(0))))
+ best_y += 2 * uintptr(2*w)
+ best_uv += 2 * uintptr(3*uv_w)
+ target_y += 2 * uintptr(2*w)
+ target_uv += 2 * uintptr(3*uv_w)
+ r_ptr += uintptr(2 * rgb_stride)
+ g_ptr += uintptr(2 * rgb_stride)
+ b_ptr += uintptr(2 * rgb_stride)
goto __3
__3:
- j = j + (2)
+ j = j + 2
goto __2
goto __4
__4:
@@ -29732,38 +29434,38 @@ __10:
if !(j < h) {
goto __12
}
- src11 = (tmp_buffer + uintptr((0*w))*2)
- src21 = (tmp_buffer + uintptr((3*w))*2)
+ src11 = tmp_buffer + uintptr(0*w)*2
+ src21 = tmp_buffer + uintptr(3*w)*2
- next_uv = (cur_uv + uintptr((func() int32 {
- if j < (h - 2) {
- return (3 * uv_w)
+ next_uv = cur_uv + uintptr(func() int32 {
+ if j < h-2 {
+ return 3 * uv_w
}
return 0
- }()))*2)
+ }())*2
InterpolateTwoRows(tls, best_y, prev_uv, cur_uv, next_uv, w, src11, src21)
prev_uv = cur_uv
cur_uv = next_uv
- UpdateW(tls, src11, (best_rgb_y + uintptr((0*w))*2), w)
- UpdateW(tls, src21, (best_rgb_y + uintptr((1*w))*2), w)
+ UpdateW(tls, src11, best_rgb_y+uintptr(0*w)*2, w)
+ UpdateW(tls, src21, best_rgb_y+uintptr(1*w)*2, w)
UpdateChroma(tls, src11, src21, best_rgb_uv, uv_w)
// update two rows of Y and one row of RGB
- diff_y_sum = diff_y_sum + ((*struct {
+ diff_y_sum = diff_y_sum + (*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32) uint64_t
- })(unsafe.Pointer(&struct{ uintptr }{WebPSharpYUVUpdateY})).f(tls, target_y, best_rgb_y, best_y, (2 * w)))
+ })(unsafe.Pointer(&struct{ uintptr }{WebPSharpYUVUpdateY})).f(tls, target_y, best_rgb_y, best_y, 2*w)
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{WebPSharpYUVUpdateRGB})).f(tls, target_uv, best_rgb_uv, best_uv, (3 * uv_w))
+ })(unsafe.Pointer(&struct{ uintptr }{WebPSharpYUVUpdateRGB})).f(tls, target_uv, best_rgb_uv, best_uv, 3*uv_w)
- best_y += 2 * (uintptr(2 * w))
- best_uv += 2 * (uintptr(3 * uv_w))
- target_y += 2 * (uintptr(2 * w))
- target_uv += 2 * (uintptr(3 * uv_w))
+ best_y += 2 * uintptr(2*w)
+ best_uv += 2 * uintptr(3*uv_w)
+ target_y += 2 * uintptr(2*w)
+ target_uv += 2 * uintptr(3*uv_w)
goto __11
__11:
- j = j + (2)
+ j = j + 2
goto __10
goto __12
__12:
@@ -29955,9 +29657,9 @@ var kInvAlpha = [1021]uint32_t{
// so we incorporate this factor 4 inside the DIVIDE_BY_ALPHA macro directly.
func LinearToGammaWeighted(tls *libc.TLS, src uintptr, a_ptr uintptr, total_a uint32_t, step int32, rgb_stride int32) int32 { /* picture_csp_enc.c:738:24: */
- var sum uint32_t = ((((uint32_t(*(*uint8_t)(unsafe.Pointer(a_ptr))) * GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(src)))) + (uint32_t(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(step)))) * GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(src + uintptr(step)))))) + (uint32_t(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(rgb_stride)))) * GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(src + uintptr(rgb_stride)))))) + (uint32_t(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr((rgb_stride + step))))) * GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(src + uintptr((rgb_stride + step)))))))
+ var sum uint32_t = uint32_t(*(*uint8_t)(unsafe.Pointer(a_ptr)))*GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(src))) + uint32_t(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(step))))*GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(src + uintptr(step)))) + uint32_t(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(rgb_stride))))*GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(src + uintptr(rgb_stride)))) + uint32_t(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(rgb_stride+step))))*GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(src + uintptr(rgb_stride+step))))
- return LinearToGamma(tls, (((sum) * kInvAlpha[(total_a)]) >> (kAlphaFix - 2)), 0)
+ return LinearToGamma(tls, sum*kInvAlpha[total_a]>>(kAlphaFix-2), 0)
}
func ConvertRowToY(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintptr, step int32, dst_y uintptr, width int32, rg uintptr) { /* picture_csp_enc.c:754:25: */
@@ -29975,8 +29677,8 @@ __1:
}
goto __2
__2:
- i = i + (1)
- j = j + (step)
+ i = i + 1
+ j = j + step
goto __1
goto __3
__3:
@@ -29989,22 +29691,22 @@ func AccumulateRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintptr,
i = 0
j = 0
__1:
- if !(i < (width >> 1)) {
+ if !(i < width>>1) {
goto __3
}
{
- var a uint32_t = (uint32_t((int32(*(*uint8_t)(unsafe.Pointer((a_ptr + uintptr(j))))) + int32(*(*uint8_t)(unsafe.Pointer((a_ptr + uintptr(j)) + uintptr(rgb_stride))))) + (int32(*(*uint8_t)(unsafe.Pointer(((a_ptr + uintptr(j)) + uintptr(4))))) + int32(*(*uint8_t)(unsafe.Pointer(((a_ptr + uintptr(j)) + uintptr(4)) + uintptr(rgb_stride)))))))
+ var a uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(j)))) + int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(j) + uintptr(rgb_stride)))) + (int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(j) + uintptr(4)))) + int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(j) + uintptr(4) + uintptr(rgb_stride))))))
var r int32
var g int32
var b int32
- if (a == (uint32_t(4 * 0xff))) || (a == uint32_t(0)) {
- r = LinearToGamma(tls, (((GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j)) + 4)))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j)) + uintptr(rgb_stride))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j)) + uintptr((rgb_stride + (4))))))), 0)
- g = LinearToGamma(tls, (((GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j)) + 4)))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j)) + uintptr(rgb_stride))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j)) + uintptr((rgb_stride + (4))))))), 0)
- b = LinearToGamma(tls, (((GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j)) + 4)))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j)) + uintptr(rgb_stride))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j)) + uintptr((rgb_stride + (4))))))), 0)
+ if a == uint32_t(4*0xff) || a == uint32_t(0) {
+ r = LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j) + 4)))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j) + uintptr(rgb_stride+4)))), 0)
+ g = LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j) + 4)))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j) + uintptr(rgb_stride+4)))), 0)
+ b = LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j) + 4)))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j) + uintptr(rgb_stride+4)))), 0)
} else {
- r = LinearToGammaWeighted(tls, (r_ptr + uintptr(j)), (a_ptr + uintptr(j)), a, 4, rgb_stride)
- g = LinearToGammaWeighted(tls, (g_ptr + uintptr(j)), (a_ptr + uintptr(j)), a, 4, rgb_stride)
- b = LinearToGammaWeighted(tls, (b_ptr + uintptr(j)), (a_ptr + uintptr(j)), a, 4, rgb_stride)
+ r = LinearToGammaWeighted(tls, r_ptr+uintptr(j), a_ptr+uintptr(j), a, 4, rgb_stride)
+ g = LinearToGammaWeighted(tls, g_ptr+uintptr(j), a_ptr+uintptr(j), a, 4, rgb_stride)
+ b = LinearToGammaWeighted(tls, b_ptr+uintptr(j), a_ptr+uintptr(j), a, 4, rgb_stride)
}
*(*uint16_t)(unsafe.Pointer(dst)) = uint16_t(r)
*(*uint16_t)(unsafe.Pointer(dst + 1*2)) = uint16_t(g)
@@ -30014,26 +29716,26 @@ __1:
}
goto __2
__2:
- i = i + (1)
- j = j + (2 * 4)
- dst += 2 * (uintptr(4))
+ i = i + 1
+ j = j + 2*4
+ dst += 2 * uintptr(4)
goto __1
goto __3
__3:
;
- if (width & 1) != 0 {
- var a uint32_t = (2 * (uint32(int32(*(*uint8_t)(unsafe.Pointer((a_ptr + uintptr(j))))) + int32(*(*uint8_t)(unsafe.Pointer((a_ptr + uintptr(j)) + uintptr(rgb_stride)))))))
+ if width&1 != 0 {
+ var a uint32_t = 2 * uint32(int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(j))))+int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(j) + uintptr(rgb_stride)))))
var r int32
var g int32
var b int32
- if (a == (uint32_t(4 * 0xff))) || (a == uint32_t(0)) {
- r = LinearToGamma(tls, (GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j)) + uintptr(rgb_stride))))), 1)
- g = LinearToGamma(tls, (GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j)) + uintptr(rgb_stride))))), 1)
- b = LinearToGamma(tls, (GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j)) + uintptr(rgb_stride))))), 1)
+ if a == uint32_t(4*0xff) || a == uint32_t(0) {
+ r = LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j) + uintptr(rgb_stride)))), 1)
+ g = LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j) + uintptr(rgb_stride)))), 1)
+ b = LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j) + uintptr(rgb_stride)))), 1)
} else {
- r = LinearToGammaWeighted(tls, (r_ptr + uintptr(j)), (a_ptr + uintptr(j)), a, 0, rgb_stride)
- g = LinearToGammaWeighted(tls, (g_ptr + uintptr(j)), (a_ptr + uintptr(j)), a, 0, rgb_stride)
- b = LinearToGammaWeighted(tls, (b_ptr + uintptr(j)), (a_ptr + uintptr(j)), a, 0, rgb_stride)
+ r = LinearToGammaWeighted(tls, r_ptr+uintptr(j), a_ptr+uintptr(j), a, 0, rgb_stride)
+ g = LinearToGammaWeighted(tls, g_ptr+uintptr(j), a_ptr+uintptr(j), a, 0, rgb_stride)
+ b = LinearToGammaWeighted(tls, b_ptr+uintptr(j), a_ptr+uintptr(j), a, 0, rgb_stride)
}
*(*uint16_t)(unsafe.Pointer(dst)) = uint16_t(r)
*(*uint16_t)(unsafe.Pointer(dst + 1*2)) = uint16_t(g)
@@ -30048,28 +29750,28 @@ func AccumulateRGB(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintptr, s
i = 0
j = 0
__1:
- if !(i < (width >> 1)) {
+ if !(i < width>>1) {
goto __3
}
{
- *(*uint16_t)(unsafe.Pointer(dst)) = uint16_t(LinearToGamma(tls, (((GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j)) + uintptr((step)))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j)) + uintptr(rgb_stride))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j)) + uintptr((rgb_stride + (step))))))), 0))
- *(*uint16_t)(unsafe.Pointer(dst + 1*2)) = uint16_t(LinearToGamma(tls, (((GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j)) + uintptr((step)))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j)) + uintptr(rgb_stride))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j)) + uintptr((rgb_stride + (step))))))), 0))
- *(*uint16_t)(unsafe.Pointer(dst + 2*2)) = uint16_t(LinearToGamma(tls, (((GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j)) + uintptr((step)))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j)) + uintptr(rgb_stride))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j)) + uintptr((rgb_stride + (step))))))), 0))
+ *(*uint16_t)(unsafe.Pointer(dst)) = uint16_t(LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j) + uintptr(step))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j) + uintptr(rgb_stride+step)))), 0))
+ *(*uint16_t)(unsafe.Pointer(dst + 1*2)) = uint16_t(LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j) + uintptr(step))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j) + uintptr(rgb_stride+step)))), 0))
+ *(*uint16_t)(unsafe.Pointer(dst + 2*2)) = uint16_t(LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j) + uintptr(step))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j) + uintptr(rgb_stride+step)))), 0))
}
goto __2
__2:
- i = i + (1)
- j = j + (2 * step)
- dst += 2 * (uintptr(4))
+ i = i + 1
+ j = j + 2*step
+ dst += 2 * uintptr(4)
goto __1
goto __3
__3:
;
- if (width & 1) != 0 {
- *(*uint16_t)(unsafe.Pointer(dst)) = uint16_t(LinearToGamma(tls, (GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((r_ptr + uintptr(j)) + uintptr(rgb_stride))))), 1))
- *(*uint16_t)(unsafe.Pointer(dst + 1*2)) = uint16_t(LinearToGamma(tls, (GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((g_ptr + uintptr(j)) + uintptr(rgb_stride))))), 1))
- *(*uint16_t)(unsafe.Pointer(dst + 2*2)) = uint16_t(LinearToGamma(tls, (GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j))))) + GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer((b_ptr + uintptr(j)) + uintptr(rgb_stride))))), 1))
+ if width&1 != 0 {
+ *(*uint16_t)(unsafe.Pointer(dst)) = uint16_t(LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(r_ptr + uintptr(j) + uintptr(rgb_stride)))), 1))
+ *(*uint16_t)(unsafe.Pointer(dst + 1*2)) = uint16_t(LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(g_ptr + uintptr(j) + uintptr(rgb_stride)))), 1))
+ *(*uint16_t)(unsafe.Pointer(dst + 2*2)) = uint16_t(LinearToGamma(tls, GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j))))+GammaToLinear(tls, *(*uint8_t)(unsafe.Pointer(b_ptr + uintptr(j) + uintptr(rgb_stride)))), 1))
}
}
@@ -30090,8 +29792,8 @@ __1:
}
goto __2
__2:
- i = i + (1)
- rgb += 2 * (uintptr(4))
+ i = i + 1
+ rgb += 2 * uintptr(4)
goto __1
goto __3
__3:
@@ -30105,7 +29807,7 @@ func ImportYUVAFromRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintp
var width int32 = (*WebPPicture)(unsafe.Pointer(picture)).width
var height int32 = (*WebPPicture)(unsafe.Pointer(picture)).height
var has_alpha int32 = CheckNonOpaque(tls, a_ptr, width, height, step, rgb_stride)
- var is_rgb int32 = (libc.Bool32(r_ptr < b_ptr)) // otherwise it's bgr
+ var is_rgb int32 = libc.Bool32(r_ptr < b_ptr) // otherwise it's bgr
(*WebPPicture)(unsafe.Pointer(picture)).colorspace = func() uint32 {
if has_alpha != 0 {
@@ -30116,7 +29818,7 @@ func ImportYUVAFromRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintp
(*WebPPicture)(unsafe.Pointer(picture)).use_argb = 0
// disable smart conversion if source is too small (overkill).
- if (width < kMinDimensionIterativeConversion) || (height < kMinDimensionIterativeConversion) {
+ if width < kMinDimensionIterativeConversion || height < kMinDimensionIterativeConversion {
use_iterative_conversion = 0
}
@@ -30139,31 +29841,31 @@ func ImportYUVAFromRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintp
(*WebPPicture)(unsafe.Pointer(picture)).a, (*WebPPicture)(unsafe.Pointer(picture)).a_stride)
}
} else {
- var uv_width int32 = ((width + 1) >> 1)
- var use_dsp int32 = (libc.Bool32(step == 3)) // use special function in this case
+ var uv_width int32 = (width + 1) >> 1
+ var use_dsp int32 = libc.Bool32(step == 3) // use special function in this case
// temporary storage for accumulated R/G/B values during conversion to U/V
- var tmp_rgb uintptr = WebPSafeMalloc(tls, (uint64(4 * uv_width)), uint64(unsafe.Sizeof(uint16_t(0))))
+ var tmp_rgb uintptr = WebPSafeMalloc(tls, uint64(4*uv_width), uint64(unsafe.Sizeof(uint16_t(0))))
var dst_y uintptr = (*WebPPicture)(unsafe.Pointer(picture)).y
var dst_u uintptr = (*WebPPicture)(unsafe.Pointer(picture)).u
var dst_v uintptr = (*WebPPicture)(unsafe.Pointer(picture)).v
var dst_a uintptr = (*WebPPicture)(unsafe.Pointer(picture)).a
// var base_rg VP8Random at bp, 232
- var rg uintptr = (uintptr(0))
+ var rg uintptr = uintptr(0)
if float64(dithering) > 0. {
- VP8InitRandom(tls, (bp) /* &base_rg */, dithering)
- rg = (bp) /* &base_rg */
+ VP8InitRandom(tls, bp, dithering)
+ rg = bp /* &base_rg */
use_dsp = 0 // can't use dsp in this case
}
WebPInitConvertARGBToYUV(tls)
InitGammaTables(tls)
- if tmp_rgb == (uintptr(0)) {
+ if tmp_rgb == uintptr(0) {
return 0
} // malloc error
// Downsample Y/U/V planes, two rows at a time
- for y = 0; y < (height >> 1); y++ {
+ for y = 0; y < height>>1; y++ {
var rows_have_alpha int32 = has_alpha
if use_dsp != 0 {
if is_rgb != 0 {
@@ -30172,31 +29874,31 @@ func ImportYUVAFromRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintp
})(unsafe.Pointer(&struct{ uintptr }{WebPConvertRGB24ToY})).f(tls, r_ptr, dst_y, width)
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{WebPConvertRGB24ToY})).f(tls, (r_ptr + uintptr(rgb_stride)),
- (dst_y + uintptr((*WebPPicture)(unsafe.Pointer(picture)).y_stride)), width)
+ })(unsafe.Pointer(&struct{ uintptr }{WebPConvertRGB24ToY})).f(tls, r_ptr+uintptr(rgb_stride),
+ dst_y+uintptr((*WebPPicture)(unsafe.Pointer(picture)).y_stride), width)
} else {
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
})(unsafe.Pointer(&struct{ uintptr }{WebPConvertBGR24ToY})).f(tls, b_ptr, dst_y, width)
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{WebPConvertBGR24ToY})).f(tls, (b_ptr + uintptr(rgb_stride)),
- (dst_y + uintptr((*WebPPicture)(unsafe.Pointer(picture)).y_stride)), width)
+ })(unsafe.Pointer(&struct{ uintptr }{WebPConvertBGR24ToY})).f(tls, b_ptr+uintptr(rgb_stride),
+ dst_y+uintptr((*WebPPicture)(unsafe.Pointer(picture)).y_stride), width)
}
} else {
ConvertRowToY(tls, r_ptr, g_ptr, b_ptr, step, dst_y, width, rg)
- ConvertRowToY(tls, (r_ptr + uintptr(rgb_stride)),
- (g_ptr + uintptr(rgb_stride)),
- (b_ptr + uintptr(rgb_stride)), step,
- (dst_y + uintptr((*WebPPicture)(unsafe.Pointer(picture)).y_stride)), width, rg)
+ ConvertRowToY(tls, r_ptr+uintptr(rgb_stride),
+ g_ptr+uintptr(rgb_stride),
+ b_ptr+uintptr(rgb_stride), step,
+ dst_y+uintptr((*WebPPicture)(unsafe.Pointer(picture)).y_stride), width, rg)
}
- dst_y += (uintptr(2 * (*WebPPicture)(unsafe.Pointer(picture)).y_stride))
+ dst_y += uintptr(2 * (*WebPPicture)(unsafe.Pointer(picture)).y_stride)
if has_alpha != 0 {
- rows_have_alpha = rows_have_alpha & (libc.BoolInt32(!((*struct {
+ rows_have_alpha = rows_have_alpha & libc.BoolInt32(!((*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32) int32
})(unsafe.Pointer(&struct{ uintptr }{WebPExtractAlpha})).f(tls, a_ptr, rgb_stride, width, 2,
- dst_a, (*WebPPicture)(unsafe.Pointer(picture)).a_stride) != 0)))
- dst_a += (uintptr(2 * (*WebPPicture)(unsafe.Pointer(picture)).a_stride))
+ dst_a, (*WebPPicture)(unsafe.Pointer(picture)).a_stride) != 0))
+ dst_a += uintptr(2 * (*WebPPicture)(unsafe.Pointer(picture)).a_stride)
}
// Collect averaged R/G/B(/A)
if !(rows_have_alpha != 0) {
@@ -30205,7 +29907,7 @@ func ImportYUVAFromRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintp
AccumulateRGBA(tls, r_ptr, g_ptr, b_ptr, a_ptr, rgb_stride, tmp_rgb, width)
}
// Convert to U/V
- if rg == (uintptr(0)) {
+ if rg == uintptr(0) {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
})(unsafe.Pointer(&struct{ uintptr }{WebPConvertRGBA32ToUV})).f(tls, tmp_rgb, dst_u, dst_v, uv_width)
@@ -30214,14 +29916,14 @@ func ImportYUVAFromRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintp
}
dst_u += uintptr((*WebPPicture)(unsafe.Pointer(picture)).uv_stride)
dst_v += uintptr((*WebPPicture)(unsafe.Pointer(picture)).uv_stride)
- r_ptr += (uintptr(2 * rgb_stride))
- b_ptr += (uintptr(2 * rgb_stride))
- g_ptr += (uintptr(2 * rgb_stride))
+ r_ptr += uintptr(2 * rgb_stride)
+ b_ptr += uintptr(2 * rgb_stride)
+ g_ptr += uintptr(2 * rgb_stride)
if has_alpha != 0 {
- a_ptr += (uintptr(2 * rgb_stride))
+ a_ptr += uintptr(2 * rgb_stride)
}
}
- if (height & 1) != 0 { // extra last row
+ if height&1 != 0 { // extra last row
var row_has_alpha int32 = has_alpha
if use_dsp != 0 {
if r_ptr < b_ptr {
@@ -30237,9 +29939,9 @@ func ImportYUVAFromRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintp
ConvertRowToY(tls, r_ptr, g_ptr, b_ptr, step, dst_y, width, rg)
}
if row_has_alpha != 0 {
- row_has_alpha = row_has_alpha & (libc.BoolInt32(!((*struct {
+ row_has_alpha = row_has_alpha & libc.BoolInt32(!((*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32) int32
- })(unsafe.Pointer(&struct{ uintptr }{WebPExtractAlpha})).f(tls, a_ptr, 0, width, 1, dst_a, 0) != 0)))
+ })(unsafe.Pointer(&struct{ uintptr }{WebPExtractAlpha})).f(tls, a_ptr, 0, width, 1, dst_a, 0) != 0))
}
// Collect averaged R/G/B(/A)
if !(row_has_alpha != 0) {
@@ -30250,7 +29952,7 @@ func ImportYUVAFromRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintp
AccumulateRGBA(tls, r_ptr, g_ptr, b_ptr, a_ptr /* rgb_stride = */, 0,
tmp_rgb, width)
}
- if rg == (uintptr(0)) {
+ if rg == uintptr(0) {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
})(unsafe.Pointer(&struct{ uintptr }{WebPConvertRGBA32ToUV})).f(tls, tmp_rgb, dst_u, dst_v, uv_width)
@@ -30267,22 +29969,22 @@ func ImportYUVAFromRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintp
// call for ARGB->YUVA conversion
func PictureARGBToYUVA(tls *libc.TLS, picture uintptr, colorspace WebPEncCSP, dithering float32, use_iterative_conversion int32) int32 { /* picture_csp_enc.c:995:12: */
- if picture == (uintptr(0)) {
+ if picture == uintptr(0) {
return 0
}
- if (*WebPPicture)(unsafe.Pointer(picture)).argb == (uintptr(0)) {
+ if (*WebPPicture)(unsafe.Pointer(picture)).argb == uintptr(0) {
return WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_NULL_PARAMETER)
- } else if (colorspace & WEBP_CSP_UV_MASK) != WEBP_YUV420 {
+ } else if colorspace&WEBP_CSP_UV_MASK != WEBP_YUV420 {
return WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_INVALID_CONFIGURATION)
} else {
var argb uintptr = (*WebPPicture)(unsafe.Pointer(picture)).argb
- var a uintptr = (argb + uintptr((3 - (0))))
- var r uintptr = (argb + uintptr((3 - (1))))
- var g uintptr = (argb + uintptr((3 - (2))))
- var b uintptr = (argb + uintptr((3 - (3))))
+ var a uintptr = argb + uintptr(3-0)
+ var r uintptr = argb + uintptr(3-1)
+ var g uintptr = argb + uintptr(3-2)
+ var b uintptr = argb + uintptr(3-3)
(*WebPPicture)(unsafe.Pointer(picture)).colorspace = WEBP_YUV420
- return ImportYUVAFromRGBA(tls, r, g, b, a, 4, (4 * (*WebPPicture)(unsafe.Pointer(picture)).argb_stride),
+ return ImportYUVAFromRGBA(tls, r, g, b, a, 4, 4*(*WebPPicture)(unsafe.Pointer(picture)).argb_stride,
dithering, use_iterative_conversion, picture)
}
return int32(0)
@@ -30309,16 +30011,16 @@ func WebPPictureSmartARGBToYUVA(tls *libc.TLS, picture uintptr) int32 { /* pictu
// call for YUVA -> ARGB conversion
func WebPPictureYUVAToARGB(tls *libc.TLS, picture uintptr) int32 { /* picture_csp_enc.c:1035:5: */
- if picture == (uintptr(0)) {
+ if picture == uintptr(0) {
return 0
}
- if (((*WebPPicture)(unsafe.Pointer(picture)).y == (uintptr(0))) || ((*WebPPicture)(unsafe.Pointer(picture)).u == (uintptr(0)))) || ((*WebPPicture)(unsafe.Pointer(picture)).v == (uintptr(0))) {
+ if (*WebPPicture)(unsafe.Pointer(picture)).y == uintptr(0) || (*WebPPicture)(unsafe.Pointer(picture)).u == uintptr(0) || (*WebPPicture)(unsafe.Pointer(picture)).v == uintptr(0) {
return WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_NULL_PARAMETER)
}
- if (((*WebPPicture)(unsafe.Pointer(picture)).colorspace & WEBP_CSP_ALPHA_BIT) != 0) && ((*WebPPicture)(unsafe.Pointer(picture)).a == (uintptr(0))) {
+ if (*WebPPicture)(unsafe.Pointer(picture)).colorspace&WEBP_CSP_ALPHA_BIT != 0 && (*WebPPicture)(unsafe.Pointer(picture)).a == uintptr(0) {
return WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_NULL_PARAMETER)
}
- if ((*WebPPicture)(unsafe.Pointer(picture)).colorspace & WEBP_CSP_UV_MASK) != WEBP_YUV420 {
+ if (*WebPPicture)(unsafe.Pointer(picture)).colorspace&WEBP_CSP_UV_MASK != WEBP_YUV420 {
return WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_INVALID_CONFIGURATION)
}
// Allocate a new argb buffer (discarding the previous one).
@@ -30332,46 +30034,46 @@ func WebPPictureYUVAToARGB(tls *libc.TLS, picture uintptr) int32 { /* picture_cs
var y int32
var width int32 = (*WebPPicture)(unsafe.Pointer(picture)).width
var height int32 = (*WebPPicture)(unsafe.Pointer(picture)).height
- var argb_stride int32 = (4 * (*WebPPicture)(unsafe.Pointer(picture)).argb_stride)
+ var argb_stride int32 = 4 * (*WebPPicture)(unsafe.Pointer(picture)).argb_stride
var dst uintptr = (*WebPPicture)(unsafe.Pointer(picture)).argb
var cur_u uintptr = (*WebPPicture)(unsafe.Pointer(picture)).u
var cur_v uintptr = (*WebPPicture)(unsafe.Pointer(picture)).v
var cur_y uintptr = (*WebPPicture)(unsafe.Pointer(picture)).y
- var upsample WebPUpsampleLinePairFunc = WebPGetLinePairConverter(tls, (libc.Bool32((3 - (0)) > 0)))
+ var upsample WebPUpsampleLinePairFunc = WebPGetLinePairConverter(tls, libc.Bool32(3-0 > 0))
// First row, with replicated top samples.
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, cur_y, (uintptr(0)), cur_u, cur_v, cur_u, cur_v, dst, (uintptr(0)), width)
+ })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, cur_y, uintptr(0), cur_u, cur_v, cur_u, cur_v, dst, uintptr(0), width)
cur_y += uintptr((*WebPPicture)(unsafe.Pointer(picture)).y_stride)
dst += uintptr(argb_stride)
// Center rows.
- for y = 1; (y + 1) < height; y = y + (2) {
+ for y = 1; y+1 < height; y = y + 2 {
var top_u uintptr = cur_u
var top_v uintptr = cur_v
cur_u += uintptr((*WebPPicture)(unsafe.Pointer(picture)).uv_stride)
cur_v += uintptr((*WebPPicture)(unsafe.Pointer(picture)).uv_stride)
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, cur_y, (cur_y + uintptr((*WebPPicture)(unsafe.Pointer(picture)).y_stride)), top_u, top_v, cur_u, cur_v,
- dst, (dst + uintptr(argb_stride)), width)
- cur_y += (uintptr(2 * (*WebPPicture)(unsafe.Pointer(picture)).y_stride))
- dst += (uintptr(2 * argb_stride))
+ })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, cur_y, cur_y+uintptr((*WebPPicture)(unsafe.Pointer(picture)).y_stride), top_u, top_v, cur_u, cur_v,
+ dst, dst+uintptr(argb_stride), width)
+ cur_y += uintptr(2 * (*WebPPicture)(unsafe.Pointer(picture)).y_stride)
+ dst += uintptr(2 * argb_stride)
}
// Last row (if needed), with replicated bottom samples.
- if (height > 1) && !((height & 1) != 0) {
+ if height > 1 && !(height&1 != 0) {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, cur_y, (uintptr(0)), cur_u, cur_v, cur_u, cur_v, dst, (uintptr(0)), width)
+ })(unsafe.Pointer(&struct{ uintptr }{upsample})).f(tls, cur_y, uintptr(0), cur_u, cur_v, cur_u, cur_v, dst, uintptr(0), width)
}
// Insert alpha values if needed, in replacement for the default 0xff ones.
- if ((*WebPPicture)(unsafe.Pointer(picture)).colorspace & WEBP_CSP_ALPHA_BIT) != 0 {
+ if (*WebPPicture)(unsafe.Pointer(picture)).colorspace&WEBP_CSP_ALPHA_BIT != 0 {
for y = 0; y < height; y++ {
- var argb_dst uintptr = ((*WebPPicture)(unsafe.Pointer(picture)).argb + uintptr((y*(*WebPPicture)(unsafe.Pointer(picture)).argb_stride))*4)
- var src uintptr = ((*WebPPicture)(unsafe.Pointer(picture)).a + uintptr((y * (*WebPPicture)(unsafe.Pointer(picture)).a_stride)))
+ var argb_dst uintptr = (*WebPPicture)(unsafe.Pointer(picture)).argb + uintptr(y*(*WebPPicture)(unsafe.Pointer(picture)).argb_stride)*4
+ var src uintptr = (*WebPPicture)(unsafe.Pointer(picture)).a + uintptr(y*(*WebPPicture)(unsafe.Pointer(picture)).a_stride)
var x int32
for x = 0; x < width; x++ {
- *(*uint32_t)(unsafe.Pointer(argb_dst + uintptr(x)*4)) = ((*(*uint32_t)(unsafe.Pointer(argb_dst + uintptr(x)*4)) & 0x00ffffff) | (uint32_t(*(*uint8_t)(unsafe.Pointer(src + uintptr(x)))) << 24))
+ *(*uint32_t)(unsafe.Pointer(argb_dst + uintptr(x)*4)) = *(*uint32_t)(unsafe.Pointer(argb_dst + uintptr(x)*4))&0x00ffffff | uint32_t(*(*uint8_t)(unsafe.Pointer(src + uintptr(x))))<<24
}
}
}
@@ -30386,28 +30088,28 @@ func WebPPictureYUVAToARGB(tls *libc.TLS, picture uintptr) int32 { /* picture_cs
func Import(tls *libc.TLS, picture uintptr, rgb uintptr, rgb_stride int32, step int32, swap_rb int32, import_alpha int32) int32 { /* picture_csp_enc.c:1098:12: */
var y int32
// swap_rb -> b,g,r,a , !swap_rb -> r,g,b,a
- var r_ptr uintptr = (rgb + uintptr((func() int32 {
+ var r_ptr uintptr = rgb + uintptr(func() int32 {
if swap_rb != 0 {
return 2
}
return 0
- }())))
- var g_ptr uintptr = (rgb + uintptr(1))
- var b_ptr uintptr = (rgb + uintptr((func() int32 {
+ }())
+ var g_ptr uintptr = rgb + uintptr(1)
+ var b_ptr uintptr = rgb + uintptr(func() int32 {
if swap_rb != 0 {
return 0
}
return 2
- }())))
+ }())
var width int32 = (*WebPPicture)(unsafe.Pointer(picture)).width
var height int32 = (*WebPPicture)(unsafe.Pointer(picture)).height
if !((*WebPPicture)(unsafe.Pointer(picture)).use_argb != 0) {
var a_ptr uintptr
if import_alpha != 0 {
- a_ptr = (rgb + uintptr(3))
+ a_ptr = rgb + uintptr(3)
} else {
- a_ptr = (uintptr(0))
+ a_ptr = uintptr(0)
}
return ImportYUVAFromRGBA(tls, r_ptr, g_ptr, b_ptr, a_ptr, step, rgb_stride,
0., 0, picture)
@@ -30422,13 +30124,13 @@ func Import(tls *libc.TLS, picture uintptr, rgb uintptr, rgb_stride int32, step
if import_alpha != 0 {
// dst[] byte order is {a,r,g,b} for big-endian, {b,g,r,a} for little endian
var dst uintptr = (*WebPPicture)(unsafe.Pointer(picture)).argb
- var do_copy int32 = (libc.Bool32(((3 - (0)) == 3) && (swap_rb != 0)))
+ var do_copy int32 = libc.Bool32(3-0 == 3 && swap_rb != 0)
if do_copy != 0 {
for y = 0; y < height; y++ {
- libc.Xmemcpy(tls, dst, rgb, (uint64(width * 4)))
+ libc.Xmemcpy(tls, dst, rgb, uint64(width*4))
rgb += uintptr(rgb_stride)
- dst += 4 * (uintptr((*WebPPicture)(unsafe.Pointer(picture)).argb_stride))
+ dst += 4 * uintptr((*WebPPicture)(unsafe.Pointer(picture)).argb_stride)
}
} else {
for y = 0; y < height; y++ {
@@ -30437,7 +30139,7 @@ func Import(tls *libc.TLS, picture uintptr, rgb uintptr, rgb_stride int32, step
f func(*libc.TLS, uintptr, int32, uintptr)
})(unsafe.Pointer(&struct{ uintptr }{VP8LConvertBGRAToRGBA})).f(tls, rgb, width, dst)
rgb += uintptr(rgb_stride)
- dst += 4 * (uintptr((*WebPPicture)(unsafe.Pointer(picture)).argb_stride))
+ dst += 4 * uintptr((*WebPPicture)(unsafe.Pointer(picture)).argb_stride)
}
}
} else {
@@ -30450,7 +30152,7 @@ func Import(tls *libc.TLS, picture uintptr, rgb uintptr, rgb_stride int32, step
r_ptr += uintptr(rgb_stride)
g_ptr += uintptr(rgb_stride)
b_ptr += uintptr(rgb_stride)
- dst += 4 * (uintptr((*WebPPicture)(unsafe.Pointer(picture)).argb_stride))
+ dst += 4 * uintptr((*WebPPicture)(unsafe.Pointer(picture)).argb_stride)
}
}
return 1
@@ -30459,42 +30161,42 @@ func Import(tls *libc.TLS, picture uintptr, rgb uintptr, rgb_stride int32, step
// Public API
func WebPPictureImportBGR(tls *libc.TLS, picture uintptr, rgb uintptr, rgb_stride int32) int32 { /* picture_csp_enc.c:1165:5: */
- if (picture != (uintptr(0))) && (rgb != (uintptr(0))) {
+ if picture != uintptr(0) && rgb != uintptr(0) {
return Import(tls, picture, rgb, rgb_stride, 3, 1, 0)
}
return 0
}
func WebPPictureImportBGRA(tls *libc.TLS, picture uintptr, rgba uintptr, rgba_stride int32) int32 { /* picture_csp_enc.c:1172:5: */
- if (picture != (uintptr(0))) && (rgba != (uintptr(0))) {
+ if picture != uintptr(0) && rgba != uintptr(0) {
return Import(tls, picture, rgba, rgba_stride, 4, 1, 1)
}
return 0
}
func WebPPictureImportBGRX(tls *libc.TLS, picture uintptr, rgba uintptr, rgba_stride int32) int32 { /* picture_csp_enc.c:1180:5: */
- if (picture != (uintptr(0))) && (rgba != (uintptr(0))) {
+ if picture != uintptr(0) && rgba != uintptr(0) {
return Import(tls, picture, rgba, rgba_stride, 4, 1, 0)
}
return 0
}
func WebPPictureImportRGB(tls *libc.TLS, picture uintptr, rgb uintptr, rgb_stride int32) int32 { /* picture_csp_enc.c:1189:5: */
- if (picture != (uintptr(0))) && (rgb != (uintptr(0))) {
+ if picture != uintptr(0) && rgb != uintptr(0) {
return Import(tls, picture, rgb, rgb_stride, 3, 0, 0)
}
return 0
}
func WebPPictureImportRGBA(tls *libc.TLS, picture uintptr, rgba uintptr, rgba_stride int32) int32 { /* picture_csp_enc.c:1196:5: */
- if (picture != (uintptr(0))) && (rgba != (uintptr(0))) {
+ if picture != uintptr(0) && rgba != uintptr(0) {
return Import(tls, picture, rgba, rgba_stride, 4, 0, 1)
}
return 0
}
func WebPPictureImportRGBX(tls *libc.TLS, picture uintptr, rgba uintptr, rgba_stride int32) int32 { /* picture_csp_enc.c:1203:5: */
- if (picture != (uintptr(0))) && (rgba != (uintptr(0))) {
+ if picture != uintptr(0) && rgba != uintptr(0) {
return Import(tls, picture, rgba, rgba_stride, 4, 0, 0)
}
return 0
@@ -30544,10 +30246,10 @@ func DummyWriter(tls *libc.TLS, data uintptr, data_size size_t, picture uintptr)
}
func WebPPictureInitInternal(tls *libc.TLS, picture uintptr, version int32) int32 { /* picture_enc.c:34:5: */
- if ((version) >> 8) != (int32((0x020f)) >> 8) {
+ if version>>8 != int32(0x020f)>>8 {
return 0 // caller/system version mismatch!
}
- if picture != (uintptr(0)) {
+ if picture != uintptr(0) {
libc.Xmemset(tls, picture, 0, uint64(unsafe.Sizeof(WebPPicture{})))
(*WebPPicture)(unsafe.Pointer(picture)).writer = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
@@ -30560,15 +30262,15 @@ func WebPPictureInitInternal(tls *libc.TLS, picture uintptr, version int32) int3
//------------------------------------------------------------------------------
func WebPPictureResetBufferARGB(tls *libc.TLS, picture uintptr) { /* picture_enc.c:48:13: */
- (*WebPPicture)(unsafe.Pointer(picture)).memory_argb_ = (uintptr(0))
- (*WebPPicture)(unsafe.Pointer(picture)).argb = (uintptr(0))
+ (*WebPPicture)(unsafe.Pointer(picture)).memory_argb_ = uintptr(0)
+ (*WebPPicture)(unsafe.Pointer(picture)).argb = uintptr(0)
(*WebPPicture)(unsafe.Pointer(picture)).argb_stride = 0
}
func WebPPictureResetBufferYUVA(tls *libc.TLS, picture uintptr) { /* picture_enc.c:54:13: */
- (*WebPPicture)(unsafe.Pointer(picture)).memory_ = (uintptr(0))
- (*WebPPicture)(unsafe.Pointer(picture)).y = libc.AssignPtrUintptr((picture + 24 /* &.u */), libc.AssignPtrUintptr((picture+32 /* &.v */), libc.AssignPtrUintptr((picture+48 /* &.a */), (uintptr(0)))))
- (*WebPPicture)(unsafe.Pointer(picture)).y_stride = libc.AssignPtrInt32((picture + 44 /* &.uv_stride */), 0)
+ (*WebPPicture)(unsafe.Pointer(picture)).memory_ = uintptr(0)
+ (*WebPPicture)(unsafe.Pointer(picture)).y = libc.AssignPtrUintptr(picture+24, libc.AssignPtrUintptr(picture+32, libc.AssignPtrUintptr(picture+48, uintptr(0))))
+ (*WebPPicture)(unsafe.Pointer(picture)).y_stride = libc.AssignPtrInt32(picture+44, 0)
(*WebPPicture)(unsafe.Pointer(picture)).a_stride = 0
}
@@ -30579,31 +30281,31 @@ func WebPPictureResetBuffers(tls *libc.TLS, picture uintptr) { /* picture_enc.c:
func WebPPictureAllocARGB(tls *libc.TLS, picture uintptr, width int32, height int32) int32 { /* picture_enc.c:66:5: */
var memory uintptr
- var argb_size uint64_t = (uint64_t(width) * uint64_t(height))
+ var argb_size uint64_t = uint64_t(width) * uint64_t(height)
WebPSafeFree(tls, (*WebPPicture)(unsafe.Pointer(picture)).memory_argb_)
WebPPictureResetBufferARGB(tls, picture)
- if (width <= 0) || (height <= 0) {
+ if width <= 0 || height <= 0 {
return WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_BAD_DIMENSION)
}
// allocate a new buffer.
- memory = WebPSafeMalloc(tls, (argb_size + uint64(31)), uint64(unsafe.Sizeof(uint32_t(0))))
- if memory == (uintptr(0)) {
+ memory = WebPSafeMalloc(tls, argb_size+uint64(31), uint64(unsafe.Sizeof(uint32_t(0))))
+ if memory == uintptr(0) {
return WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_OUT_OF_MEMORY)
}
(*WebPPicture)(unsafe.Pointer(picture)).memory_argb_ = memory
- (*WebPPicture)(unsafe.Pointer(picture)).argb = (uintptr((uintptr_t((memory)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
+ (*WebPPicture)(unsafe.Pointer(picture)).argb = uintptr((uintptr_t(memory) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
(*WebPPicture)(unsafe.Pointer(picture)).argb_stride = width
return 1
}
func WebPPictureAllocYUVA(tls *libc.TLS, picture uintptr, width int32, height int32) int32 { /* picture_enc.c:89:5: */
- var uv_csp WebPEncCSP = (WebPEncCSP(int32((*WebPPicture)(unsafe.Pointer(picture)).colorspace) & WEBP_CSP_UV_MASK))
- var has_alpha int32 = (int32((*WebPPicture)(unsafe.Pointer(picture)).colorspace) & WEBP_CSP_ALPHA_BIT)
+ var uv_csp WebPEncCSP = WebPEncCSP(int32((*WebPPicture)(unsafe.Pointer(picture)).colorspace) & WEBP_CSP_UV_MASK)
+ var has_alpha int32 = int32((*WebPPicture)(unsafe.Pointer(picture)).colorspace) & WEBP_CSP_ALPHA_BIT
var y_stride int32 = width
- var uv_width int32 = (int32((int64_t(width) + int64(1)) >> 1))
- var uv_height int32 = (int32((int64_t(height) + int64(1)) >> 1))
+ var uv_width int32 = int32((int64_t(width) + int64(1)) >> 1)
+ var uv_height int32 = int32((int64_t(height) + int64(1)) >> 1)
var uv_stride int32 = uv_width
var a_width int32
var a_stride int32
@@ -30628,19 +30330,19 @@ func WebPPictureAllocYUVA(tls *libc.TLS, picture uintptr, width int32, height in
a_width = 0
}
a_stride = a_width
- y_size = (uint64_t(y_stride) * uint64_t(height))
- uv_size = (uint64_t(uv_stride) * uint64_t(uv_height))
- a_size = (uint64_t(a_stride) * uint64_t(height))
+ y_size = uint64_t(y_stride) * uint64_t(height)
+ uv_size = uint64_t(uv_stride) * uint64_t(uv_height)
+ a_size = uint64_t(a_stride) * uint64_t(height)
- total_size = ((y_size + a_size) + (uint64(2) * uv_size))
+ total_size = y_size + a_size + uint64(2)*uv_size
// Security and validation checks
- if (((width <= 0) || (height <= 0)) || (uv_width <= 0)) || (uv_height <= 0) { // u/v param error
+ if width <= 0 || height <= 0 || uv_width <= 0 || uv_height <= 0 { // u/v param error
return WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_BAD_DIMENSION)
}
// allocate a new buffer.
mem = WebPSafeMalloc(tls, total_size, uint64(unsafe.Sizeof(uint8_t(0))))
- if mem == (uintptr(0)) {
+ if mem == uintptr(0) {
return WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_OUT_OF_MEMORY)
}
@@ -30668,7 +30370,7 @@ func WebPPictureAllocYUVA(tls *libc.TLS, picture uintptr, width int32, height in
}
func WebPPictureAlloc(tls *libc.TLS, picture uintptr) int32 { /* picture_enc.c:153:5: */
- if picture != (uintptr(0)) {
+ if picture != uintptr(0) {
var width int32 = (*WebPPicture)(unsafe.Pointer(picture)).width
var height int32 = (*WebPPicture)(unsafe.Pointer(picture)).height
@@ -30684,7 +30386,7 @@ func WebPPictureAlloc(tls *libc.TLS, picture uintptr) int32 { /* picture_enc.c:1
}
func WebPPictureFree(tls *libc.TLS, picture uintptr) { /* picture_enc.c:169:6: */
- if picture != (uintptr(0)) {
+ if picture != uintptr(0) {
WebPSafeFree(tls, (*WebPPicture)(unsafe.Pointer(picture)).memory_)
WebPSafeFree(tls, (*WebPPicture)(unsafe.Pointer(picture)).memory_argb_)
WebPPictureResetBuffers(tls, picture)
@@ -30695,7 +30397,7 @@ func WebPPictureFree(tls *libc.TLS, picture uintptr) { /* picture_enc.c:169:6: *
// WebPMemoryWriter: Write-to-memory
func WebPMemoryWriterInit(tls *libc.TLS, writer uintptr) { /* picture_enc.c:180:6: */
- (*WebPMemoryWriter)(unsafe.Pointer(writer)).mem = (uintptr(0))
+ (*WebPMemoryWriter)(unsafe.Pointer(writer)).mem = uintptr(0)
(*WebPMemoryWriter)(unsafe.Pointer(writer)).size = uint64(0)
(*WebPMemoryWriter)(unsafe.Pointer(writer)).max_size = uint64(0)
}
@@ -30703,13 +30405,13 @@ func WebPMemoryWriterInit(tls *libc.TLS, writer uintptr) { /* picture_enc.c:180:
func WebPMemoryWrite(tls *libc.TLS, data uintptr, data_size size_t, picture uintptr) int32 { /* picture_enc.c:186:5: */
var w uintptr = (*WebPPicture)(unsafe.Pointer(picture)).custom_ptr
var next_size uint64_t
- if w == (uintptr(0)) {
+ if w == uintptr(0) {
return 1
}
- next_size = ((*WebPMemoryWriter)(unsafe.Pointer(w)).size + data_size)
+ next_size = (*WebPMemoryWriter)(unsafe.Pointer(w)).size + data_size
if next_size > (*WebPMemoryWriter)(unsafe.Pointer(w)).max_size {
var new_mem uintptr
- var next_max_size uint64_t = (uint64_t(2 * uint64((*WebPMemoryWriter)(unsafe.Pointer(w)).max_size)))
+ var next_max_size uint64_t = uint64_t(2 * uint64((*WebPMemoryWriter)(unsafe.Pointer(w)).max_size))
if next_max_size < next_size {
next_max_size = next_size
}
@@ -30717,7 +30419,7 @@ func WebPMemoryWrite(tls *libc.TLS, data uintptr, data_size size_t, picture uint
next_max_size = 8192
}
new_mem = WebPSafeMalloc(tls, next_max_size, uint64(1))
- if new_mem == (uintptr(0)) {
+ if new_mem == uintptr(0) {
return 0
}
if (*WebPMemoryWriter)(unsafe.Pointer(w)).size > uint64(0) {
@@ -30729,16 +30431,16 @@ func WebPMemoryWrite(tls *libc.TLS, data uintptr, data_size size_t, picture uint
(*WebPMemoryWriter)(unsafe.Pointer(w)).max_size = next_max_size
}
if data_size > uint64(0) {
- libc.Xmemcpy(tls, ((*WebPMemoryWriter)(unsafe.Pointer(w)).mem + uintptr((*WebPMemoryWriter)(unsafe.Pointer(w)).size)), data, data_size)
- *(*size_t)(unsafe.Pointer((w + 8 /* &.size */))) += (data_size)
+ libc.Xmemcpy(tls, (*WebPMemoryWriter)(unsafe.Pointer(w)).mem+uintptr((*WebPMemoryWriter)(unsafe.Pointer(w)).size), data, data_size)
+ *(*size_t)(unsafe.Pointer(w + 8)) += data_size
}
return 1
}
func WebPMemoryWriterClear(tls *libc.TLS, writer uintptr) { /* picture_enc.c:218:6: */
- if writer != (uintptr(0)) {
+ if writer != uintptr(0) {
WebPSafeFree(tls, (*WebPMemoryWriter)(unsafe.Pointer(writer)).mem)
- (*WebPMemoryWriter)(unsafe.Pointer(writer)).mem = (uintptr(0))
+ (*WebPMemoryWriter)(unsafe.Pointer(writer)).mem = uintptr(0)
(*WebPMemoryWriter)(unsafe.Pointer(writer)).size = uint64(0)
(*WebPMemoryWriter)(unsafe.Pointer(writer)).max_size = uint64(0)
}
@@ -30761,31 +30463,31 @@ func Encode(tls *libc.TLS, rgba uintptr, width int32, height int32, stride int32
var ok int32
- if output == (uintptr(0)) {
+ if output == uintptr(0) {
return uint64(0)
}
- if !(WebPConfigPreset(tls, (bp) /* &config */, WEBP_PRESET_DEFAULT, quality_factor) != 0) || !(WebPPictureInit(tls, (bp+120) /* &pic */) != 0) {
+ if !(WebPConfigPreset(tls, bp, WEBP_PRESET_DEFAULT, quality_factor) != 0) || !(WebPPictureInit(tls, bp+120) != 0) {
return uint64(0) // shouldn't happen, except if system installation is broken
}
- (*WebPConfig)(unsafe.Pointer(bp /* &config */)).lossless = libc.BoolInt32(!(!(lossless != 0)))
- (*WebPPicture)(unsafe.Pointer(bp + 120 /* &pic */)).use_argb = libc.BoolInt32(!(!(lossless != 0)))
+ (*WebPConfig)(unsafe.Pointer(bp /* &config */)).lossless = libc.BoolInt32(!!(lossless != 0))
+ (*WebPPicture)(unsafe.Pointer(bp + 120 /* &pic */)).use_argb = libc.BoolInt32(!!(lossless != 0))
(*WebPPicture)(unsafe.Pointer(bp + 120 /* &pic */)).width = width
(*WebPPicture)(unsafe.Pointer(bp + 120 /* &pic */)).height = height
(*WebPPicture)(unsafe.Pointer(bp + 120 /* &pic */)).writer = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
}{WebPMemoryWrite}))
- (*WebPPicture)(unsafe.Pointer(bp + 120 /* &pic */)).custom_ptr = (bp + 376) /* &wrt */
- WebPMemoryWriterInit(tls, (bp + 376) /* &wrt */)
+ (*WebPPicture)(unsafe.Pointer(bp + 120 /* &pic */)).custom_ptr = bp + 376 /* &wrt */
+ WebPMemoryWriterInit(tls, bp+376 /* &wrt */)
- ok = (libc.Bool32(((*struct {
+ ok = libc.Bool32((*struct {
f func(*libc.TLS, uintptr, uintptr, int32) int32
- })(unsafe.Pointer(&struct{ uintptr }{import1})).f(tls, (bp+120) /* &pic */, rgba, stride) != 0) && (WebPEncode(tls, (bp) /* &config */, (bp+120) /* &pic */) != 0)))
- WebPPictureFree(tls, (bp + 120) /* &pic */)
+ })(unsafe.Pointer(&struct{ uintptr }{import1})).f(tls, bp+120, rgba, stride) != 0 && WebPEncode(tls, bp, bp+120) != 0)
+ WebPPictureFree(tls, bp+120)
if !(ok != 0) {
- WebPMemoryWriterClear(tls, (bp + 376) /* &wrt */)
- *(*uintptr)(unsafe.Pointer(output)) = (uintptr(0))
+ WebPMemoryWriterClear(tls, bp+376)
+ *(*uintptr)(unsafe.Pointer(output)) = uintptr(0)
return uint64(0)
}
*(*uintptr)(unsafe.Pointer(output)) = (*WebPMemoryWriter)(unsafe.Pointer(bp + 376 /* &wrt */)).mem
@@ -30872,45 +30574,45 @@ func AccumulateLSIM(tls *libc.TLS, src uintptr, src_stride int32, ref uintptr, r
var total_sse float64 = 0.
for y = 0; y < h; y++ {
var y_0 int32
- if (y - 2) < 0 {
+ if y-2 < 0 {
y_0 = 0
} else {
- y_0 = (y - 2)
+ y_0 = y - 2
}
var y_1 int32
- if ((y + 2) + 1) >= h {
+ if y+2+1 >= h {
y_1 = h
} else {
- y_1 = ((y + 2) + 1)
+ y_1 = y + 2 + 1
}
for x = 0; x < w; x++ {
var x_0 int32
- if (x - 2) < 0 {
+ if x-2 < 0 {
x_0 = 0
} else {
- x_0 = (x - 2)
+ x_0 = x - 2
}
var x_1 int32
- if ((x + 2) + 1) >= w {
+ if x+2+1 >= w {
x_1 = w
} else {
- x_1 = ((x + 2) + 1)
+ x_1 = x + 2 + 1
}
- var best_sse float64 = (float64(255.) * 255.)
- var value float64 = float64(*(*uint8_t)(unsafe.Pointer(ref + uintptr(((y * ref_stride) + x)))))
+ var best_sse float64 = float64(255.) * 255.
+ var value float64 = float64(*(*uint8_t)(unsafe.Pointer(ref + uintptr(y*ref_stride+x))))
var i int32
var j int32
for j = y_0; j < y_1; j++ {
- var s uintptr = (src + uintptr((j * src_stride)))
+ var s uintptr = src + uintptr(j*src_stride)
for i = x_0; i < x_1; i++ {
- var diff float64 = (float64(*(*uint8_t)(unsafe.Pointer(s + uintptr(i)))) - value)
- var sse float64 = (diff * diff)
+ var diff float64 = float64(*(*uint8_t)(unsafe.Pointer(s + uintptr(i)))) - value
+ var sse float64 = diff * diff
if sse < best_sse {
best_sse = sse
}
}
}
- total_sse = total_sse + (best_sse)
+ total_sse = total_sse + best_sse
}
}
return total_sse
@@ -30920,9 +30622,9 @@ func AccumulateSSE(tls *libc.TLS, src uintptr, src_stride int32, ref uintptr, re
var y int32
var total_sse float64 = 0.
for y = 0; y < h; y++ {
- total_sse = total_sse + (float64((*struct {
+ total_sse = total_sse + float64((*struct {
f func(*libc.TLS, uintptr, uintptr, int32) uint32_t
- })(unsafe.Pointer(&struct{ uintptr }{VP8AccumulateSSE})).f(tls, src, ref, w)))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8AccumulateSSE})).f(tls, src, ref, w))
src += uintptr(src_stride)
ref += uintptr(ref_stride)
}
@@ -30938,48 +30640,48 @@ func AccumulateSSIM(tls *libc.TLS, src uintptr, src_stride int32, ref uintptr, r
} else {
w0 = 3
}
- var w1 int32 = ((w - 3) - 1)
+ var w1 int32 = w - 3 - 1
var h0 int32
if h < 3 {
h0 = h
} else {
h0 = 3
}
- var h1 int32 = ((h - 3) - 1)
+ var h1 int32 = h - 3 - 1
var x int32
var y int32
var sum float64 = 0.
for y = 0; y < h0; y++ {
for x = 0; x < w; x++ {
- sum = sum + ((*struct {
+ sum = sum + (*struct {
f func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, src, src_stride, ref, ref_stride, x, y, w, h))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, src, src_stride, ref, ref_stride, x, y, w, h)
}
}
for ; y < h1; y++ {
for x = 0; x < w0; x++ {
- sum = sum + ((*struct {
+ sum = sum + (*struct {
f func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, src, src_stride, ref, ref_stride, x, y, w, h))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, src, src_stride, ref, ref_stride, x, y, w, h)
}
for ; x < w1; x++ {
- var off1 int32 = ((x - 3) + ((y - 3) * src_stride))
- var off2 int32 = ((x - 3) + ((y - 3) * ref_stride))
- sum = sum + ((*struct {
+ var off1 int32 = x - 3 + (y-3)*src_stride
+ var off2 int32 = x - 3 + (y-3)*ref_stride
+ sum = sum + (*struct {
f func(*libc.TLS, uintptr, int32, uintptr, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGet})).f(tls, (src + uintptr(off1)), src_stride, (ref + uintptr(off2)), ref_stride))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGet})).f(tls, src+uintptr(off1), src_stride, ref+uintptr(off2), ref_stride)
}
for ; x < w; x++ {
- sum = sum + ((*struct {
+ sum = sum + (*struct {
f func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, src, src_stride, ref, ref_stride, x, y, w, h))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, src, src_stride, ref, ref_stride, x, y, w, h)
}
}
for ; y < h; y++ {
for x = 0; x < w; x++ {
- sum = sum + ((*struct {
+ sum = sum + (*struct {
f func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, src, src_stride, ref, ref_stride, x, y, w, h))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})).f(tls, src, src_stride, ref, ref_stride, x, y, w, h)
}
}
return sum
@@ -30992,26 +30694,26 @@ func AccumulateSSIM(tls *libc.TLS, src uintptr, src_stride int32, ref uintptr, r
var kMinDistortion_dB float64 = 99. /* picture_psnr_enc.c:120:21 */
func GetPSNR1(tls *libc.TLS, v float64, size float64) float64 { /* picture_psnr_enc.c:122:15: */
- if (v > 0.) && (size > 0.) {
- return (-4.3429448 * libc.Xlog(tls, (v/((size*float64(255))*255.))))
+ if v > 0. && size > 0. {
+ return -4.3429448 * libc.Xlog(tls, v/(size*float64(255)*255.))
}
return kMinDistortion_dB
}
func GetLogSSIM(tls *libc.TLS, v float64, size float64) float64 { /* picture_psnr_enc.c:127:15: */
if size > 0. {
- v = (v / size)
+ v = v / size
} else {
v = 1.
}
if v < 1. {
- return (-10.0 * libc.Xlog10(tls, (1.-v)))
+ return -10.0 * libc.Xlog10(tls, 1.-v)
}
return kMinDistortion_dB
}
func WebPPlaneDistortion(tls *libc.TLS, src uintptr, src_stride size_t, ref uintptr, ref_stride size_t, width int32, height int32, x_step size_t, type1 int32, distortion uintptr, result uintptr) int32 { /* picture_psnr_enc.c:132:5: */
- var allocated uintptr = (uintptr(0))
+ var allocated uintptr = uintptr(0)
var metric AccumulateFunc
if type1 == 0 {
metric = *(*uintptr)(unsafe.Pointer(&struct {
@@ -31028,7 +30730,7 @@ func WebPPlaneDistortion(tls *libc.TLS, src uintptr, src_stride size_t, ref uint
}{AccumulateLSIM}))
}
}
- if (((((src == (uintptr(0))) || (ref == (uintptr(0)))) || (src_stride < (x_step * size_t(width)))) || (ref_stride < (x_step * size_t(width)))) || (result == (uintptr(0)))) || (distortion == (uintptr(0))) {
+ if src == uintptr(0) || ref == uintptr(0) || src_stride < x_step*size_t(width) || ref_stride < x_step*size_t(width) || result == uintptr(0) || distortion == uintptr(0) {
return 0
}
@@ -31038,16 +30740,16 @@ func WebPPlaneDistortion(tls *libc.TLS, src uintptr, src_stride size_t, ref uint
var y int32
var tmp1 uintptr
var tmp2 uintptr
- allocated = WebPSafeMalloc(tls, (uint64((2 * uint64(width)) * uint64(height))), uint64(unsafe.Sizeof(uint8_t(0))))
- if allocated == (uintptr(0)) {
+ allocated = WebPSafeMalloc(tls, uint64(2*uint64(width)*uint64(height)), uint64(unsafe.Sizeof(uint8_t(0))))
+ if allocated == uintptr(0) {
return 0
}
tmp1 = allocated
- tmp2 = (tmp1 + uintptr((size_t(width) * size_t(height))))
+ tmp2 = tmp1 + uintptr(size_t(width)*size_t(height))
for y = 0; y < height; y++ {
for x = 0; x < width; x++ {
- *(*uint8_t)(unsafe.Pointer(tmp1 + uintptr((x + (y * width))))) = *(*uint8_t)(unsafe.Pointer(src + uintptr(((size_t(x) * x_step) + (size_t(y) * src_stride)))))
- *(*uint8_t)(unsafe.Pointer(tmp2 + uintptr((x + (y * width))))) = *(*uint8_t)(unsafe.Pointer(ref + uintptr(((size_t(x) * x_step) + (size_t(y) * ref_stride)))))
+ *(*uint8_t)(unsafe.Pointer(tmp1 + uintptr(x+y*width))) = *(*uint8_t)(unsafe.Pointer(src + uintptr(size_t(x)*x_step+size_t(y)*src_stride)))
+ *(*uint8_t)(unsafe.Pointer(tmp2 + uintptr(x+y*width))) = *(*uint8_t)(unsafe.Pointer(ref + uintptr(size_t(x)*x_step+size_t(y)*ref_stride)))
}
}
src = tmp1
@@ -31060,9 +30762,9 @@ func WebPPlaneDistortion(tls *libc.TLS, src uintptr, src_stride size_t, ref uint
*(*float32)(unsafe.Pointer(result)) = func() float32 {
if type1 == 1 {
- return float32(GetLogSSIM(tls, float64(*(*float32)(unsafe.Pointer(distortion))), (float64(width) * float64(height))))
+ return float32(GetLogSSIM(tls, float64(*(*float32)(unsafe.Pointer(distortion))), float64(width)*float64(height)))
}
- return float32(GetPSNR1(tls, float64(*(*float32)(unsafe.Pointer(distortion))), (float64(width) * float64(height))))
+ return float32(GetPSNR1(tls, float64(*(*float32)(unsafe.Pointer(distortion))), float64(width)*float64(height)))
}()
return 1
}
@@ -31090,7 +30792,7 @@ func WebPPictureDistortion(tls *libc.TLS, src uintptr, ref uintptr, type1 int32,
ok = 0
total_size = 0.
total_distortion = 0.
- if !(((((src == (uintptr(0))) || (ref == (uintptr(0)))) || ((*WebPPicture)(unsafe.Pointer(src)).width != (*WebPPicture)(unsafe.Pointer(ref)).width)) || ((*WebPPicture)(unsafe.Pointer(src)).height != (*WebPPicture)(unsafe.Pointer(ref)).height)) || (results == (uintptr(0)))) {
+ if !(src == uintptr(0) || ref == uintptr(0) || (*WebPPicture)(unsafe.Pointer(src)).width != (*WebPPicture)(unsafe.Pointer(ref)).width || (*WebPPicture)(unsafe.Pointer(src)).height != (*WebPPicture)(unsafe.Pointer(ref)).height || results == uintptr(0)) {
goto __1
}
return 0
@@ -31098,7 +30800,7 @@ __1:
;
VP8SSIMDspInit(tls)
- if !(!(WebPPictureInit(tls, (bp) /* &p0 */) != 0) || !(WebPPictureInit(tls, (bp+256) /* &p1 */) != 0)) {
+ if !(!(WebPPictureInit(tls, bp) != 0) || !(WebPPictureInit(tls, bp+256) != 0)) {
goto __2
}
return 0
@@ -31106,13 +30808,13 @@ __2:
;
w = (*WebPPicture)(unsafe.Pointer(src)).width
h = (*WebPPicture)(unsafe.Pointer(src)).height
- if !(!(WebPPictureView(tls, src, 0, 0, w, h, (bp) /* &p0 */) != 0)) {
+ if !!(WebPPictureView(tls, src, 0, 0, w, h, bp) != 0) {
goto __3
}
goto Error
__3:
;
- if !(!(WebPPictureView(tls, ref, 0, 0, w, h, (bp+256) /* &p1 */) != 0)) {
+ if !!(WebPPictureView(tls, ref, 0, 0, w, h, bp+256) != 0) {
goto __4
}
goto Error
@@ -31120,13 +30822,13 @@ __4:
;
// We always measure distortion in ARGB space.
- if !(((*WebPPicture)(unsafe.Pointer(bp /* &p0 */)).use_argb == 0) && !(WebPPictureYUVAToARGB(tls, (bp) /* &p0 */) != 0)) {
+ if !((*WebPPicture)(unsafe.Pointer(bp)).use_argb == 0 && !(WebPPictureYUVAToARGB(tls, bp) != 0)) {
goto __5
}
goto Error
__5:
;
- if !(((*WebPPicture)(unsafe.Pointer(bp+256 /* &p1 */)).use_argb == 0) && !(WebPPictureYUVAToARGB(tls, (bp+256) /* &p1 */) != 0)) {
+ if !((*WebPPicture)(unsafe.Pointer(bp+256)).use_argb == 0 && !(WebPPictureYUVAToARGB(tls, bp+256) != 0)) {
goto __6
}
goto Error
@@ -31137,20 +30839,20 @@ __7:
if !(c < 4) {
goto __9
}
- stride0 = (uint64(4) * size_t((*WebPPicture)(unsafe.Pointer(bp /* &p0 */)).argb_stride))
- stride1 = (uint64(4) * size_t((*WebPPicture)(unsafe.Pointer(bp+256 /* &p1 */)).argb_stride))
+ stride0 = uint64(4) * size_t((*WebPPicture)(unsafe.Pointer(bp)).argb_stride)
+ stride1 = uint64(4) * size_t((*WebPPicture)(unsafe.Pointer(bp+256)).argb_stride)
// results are reported as BGRA
- offset = (c ^ 0)
- if !(!(WebPPlaneDistortion(tls, ((*WebPPicture)(unsafe.Pointer(bp /* &p0 */)).argb+uintptr(offset)), stride0,
- ((*WebPPicture)(unsafe.Pointer(bp+256 /* &p1 */)).argb+uintptr(offset)), stride1,
- w, h, uint64(4), type1, (bp+512) /* &distortion */, (results+uintptr(c)*4)) != 0)) {
+ offset = c ^ 0
+ if !!(WebPPlaneDistortion(tls, (*WebPPicture)(unsafe.Pointer(bp)).argb+uintptr(offset), stride0,
+ (*WebPPicture)(unsafe.Pointer(bp+256)).argb+uintptr(offset), stride1,
+ w, h, uint64(4), type1, bp+512, results+uintptr(c)*4) != 0) {
goto __10
}
goto Error
__10:
;
- total_distortion = total_distortion + (float64(*(*float32)(unsafe.Pointer(bp + 512 /* distortion */))))
- total_size = total_size + (float64(w * h))
+ total_distortion = total_distortion + float64(*(*float32)(unsafe.Pointer(bp + 512)))
+ total_size = total_size + float64(w*h)
goto __8
__8:
c++
@@ -31168,8 +30870,8 @@ __9:
ok = 1
Error:
- WebPPictureFree(tls, (bp) /* &p0 */)
- WebPPictureFree(tls, (bp + 256) /* &p1 */)
+ WebPPictureFree(tls, bp)
+ WebPPictureFree(tls, bp+256)
return ok
}
@@ -31202,31 +30904,31 @@ func PictureGrabSpecs(tls *libc.TLS, src uintptr, dst uintptr) { /* picture_resc
// Adjust top-left corner to chroma sample position.
func SnapTopLeftPosition(tls *libc.TLS, pic uintptr, left uintptr, top uintptr) { /* picture_rescale_enc.c:39:13: */
if !((*WebPPicture)(unsafe.Pointer(pic)).use_argb != 0) {
- *(*int32)(unsafe.Pointer(left)) &= (libc.CplInt32(1))
- *(*int32)(unsafe.Pointer(top)) &= (libc.CplInt32(1))
+ *(*int32)(unsafe.Pointer(left)) &= libc.CplInt32(1)
+ *(*int32)(unsafe.Pointer(top)) &= libc.CplInt32(1)
}
}
// Adjust top-left corner and verify that the sub-rectangle is valid.
func AdjustAndCheckRectangle(tls *libc.TLS, pic uintptr, left uintptr, top uintptr, width int32, height int32) int32 { /* picture_rescale_enc.c:48:12: */
SnapTopLeftPosition(tls, pic, left, top)
- if ((*(*int32)(unsafe.Pointer(left))) < 0) || ((*(*int32)(unsafe.Pointer(top))) < 0) {
+ if *(*int32)(unsafe.Pointer(left)) < 0 || *(*int32)(unsafe.Pointer(top)) < 0 {
return 0
}
- if (width <= 0) || (height <= 0) {
+ if width <= 0 || height <= 0 {
return 0
}
- if ((*(*int32)(unsafe.Pointer(left))) + width) > (*WebPPicture)(unsafe.Pointer(pic)).width {
+ if *(*int32)(unsafe.Pointer(left))+width > (*WebPPicture)(unsafe.Pointer(pic)).width {
return 0
}
- if ((*(*int32)(unsafe.Pointer(top))) + height) > (*WebPPicture)(unsafe.Pointer(pic)).height {
+ if *(*int32)(unsafe.Pointer(top))+height > (*WebPPicture)(unsafe.Pointer(pic)).height {
return 0
}
return 1
}
func WebPPictureCopy(tls *libc.TLS, src uintptr, dst uintptr) int32 { /* picture_rescale_enc.c:59:5: */
- if (src == (uintptr(0))) || (dst == (uintptr(0))) {
+ if src == uintptr(0) || dst == uintptr(0) {
return 0
}
if src == dst {
@@ -31242,29 +30944,29 @@ func WebPPictureCopy(tls *libc.TLS, src uintptr, dst uintptr) int32 { /* picture
WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).y, (*WebPPicture)(unsafe.Pointer(src)).y_stride,
(*WebPPicture)(unsafe.Pointer(dst)).y, (*WebPPicture)(unsafe.Pointer(dst)).y_stride, (*WebPPicture)(unsafe.Pointer(dst)).width, (*WebPPicture)(unsafe.Pointer(dst)).height)
WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).u, (*WebPPicture)(unsafe.Pointer(src)).uv_stride, (*WebPPicture)(unsafe.Pointer(dst)).u, (*WebPPicture)(unsafe.Pointer(dst)).uv_stride,
- ((((*WebPPicture)(unsafe.Pointer(dst)).width) + 1) >> 1), ((((*WebPPicture)(unsafe.Pointer(dst)).height) + 1) >> 1))
+ ((*WebPPicture)(unsafe.Pointer(dst)).width+1)>>1, ((*WebPPicture)(unsafe.Pointer(dst)).height+1)>>1)
WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).v, (*WebPPicture)(unsafe.Pointer(src)).uv_stride, (*WebPPicture)(unsafe.Pointer(dst)).v, (*WebPPicture)(unsafe.Pointer(dst)).uv_stride,
- ((((*WebPPicture)(unsafe.Pointer(dst)).width) + 1) >> 1), ((((*WebPPicture)(unsafe.Pointer(dst)).height) + 1) >> 1))
- if (*WebPPicture)(unsafe.Pointer(dst)).a != (uintptr(0)) {
+ ((*WebPPicture)(unsafe.Pointer(dst)).width+1)>>1, ((*WebPPicture)(unsafe.Pointer(dst)).height+1)>>1)
+ if (*WebPPicture)(unsafe.Pointer(dst)).a != uintptr(0) {
WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).a, (*WebPPicture)(unsafe.Pointer(src)).a_stride,
(*WebPPicture)(unsafe.Pointer(dst)).a, (*WebPPicture)(unsafe.Pointer(dst)).a_stride, (*WebPPicture)(unsafe.Pointer(dst)).width, (*WebPPicture)(unsafe.Pointer(dst)).height)
}
} else {
- WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).argb, (4 * (*WebPPicture)(unsafe.Pointer(src)).argb_stride),
- (*WebPPicture)(unsafe.Pointer(dst)).argb, (4 * (*WebPPicture)(unsafe.Pointer(dst)).argb_stride),
- (4 * (*WebPPicture)(unsafe.Pointer(dst)).width), (*WebPPicture)(unsafe.Pointer(dst)).height)
+ WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).argb, 4*(*WebPPicture)(unsafe.Pointer(src)).argb_stride,
+ (*WebPPicture)(unsafe.Pointer(dst)).argb, 4*(*WebPPicture)(unsafe.Pointer(dst)).argb_stride,
+ 4*(*WebPPicture)(unsafe.Pointer(dst)).width, (*WebPPicture)(unsafe.Pointer(dst)).height)
}
return 1
}
func WebPPictureIsView(tls *libc.TLS, picture uintptr) int32 { /* picture_rescale_enc.c:85:5: */
- if picture == (uintptr(0)) {
+ if picture == uintptr(0) {
return 0
}
if (*WebPPicture)(unsafe.Pointer(picture)).use_argb != 0 {
- return (libc.Bool32((*WebPPicture)(unsafe.Pointer(picture)).memory_argb_ == (uintptr(0))))
+ return libc.Bool32((*WebPPicture)(unsafe.Pointer(picture)).memory_argb_ == uintptr(0))
}
- return (libc.Bool32((*WebPPicture)(unsafe.Pointer(picture)).memory_ == (uintptr(0))))
+ return libc.Bool32((*WebPPicture)(unsafe.Pointer(picture)).memory_ == uintptr(0))
}
func WebPPictureView(tls *libc.TLS, src uintptr, left int32, top int32, width int32, height int32, dst uintptr) int32 { /* picture_rescale_enc.c:93:5: */
@@ -31273,12 +30975,12 @@ func WebPPictureView(tls *libc.TLS, src uintptr, left int32, top int32, width in
*(*int32)(unsafe.Pointer(bp)) = left
*(*int32)(unsafe.Pointer(bp + 4)) = top
- if (src == (uintptr(0))) || (dst == (uintptr(0))) {
+ if src == uintptr(0) || dst == uintptr(0) {
return 0
}
// verify rectangle position.
- if !(AdjustAndCheckRectangle(tls, src, (bp) /* &left */, (bp+4) /* &top */, width, height) != 0) {
+ if !(AdjustAndCheckRectangle(tls, src, bp, bp+4, width, height) != 0) {
return 0
}
@@ -31288,17 +30990,17 @@ func WebPPictureView(tls *libc.TLS, src uintptr, left int32, top int32, width in
(*WebPPicture)(unsafe.Pointer(dst)).width = width
(*WebPPicture)(unsafe.Pointer(dst)).height = height
if !((*WebPPicture)(unsafe.Pointer(src)).use_argb != 0) {
- (*WebPPicture)(unsafe.Pointer(dst)).y = (((*WebPPicture)(unsafe.Pointer(src)).y + uintptr((*(*int32)(unsafe.Pointer(bp + 4 /* top */)) * (*WebPPicture)(unsafe.Pointer(src)).y_stride))) + uintptr(*(*int32)(unsafe.Pointer(bp /* left */))))
- (*WebPPicture)(unsafe.Pointer(dst)).u = (((*WebPPicture)(unsafe.Pointer(src)).u + uintptr(((*(*int32)(unsafe.Pointer(bp + 4 /* top */)) >> 1) * (*WebPPicture)(unsafe.Pointer(src)).uv_stride))) + uintptr((*(*int32)(unsafe.Pointer(bp /* left */)) >> 1)))
- (*WebPPicture)(unsafe.Pointer(dst)).v = (((*WebPPicture)(unsafe.Pointer(src)).v + uintptr(((*(*int32)(unsafe.Pointer(bp + 4 /* top */)) >> 1) * (*WebPPicture)(unsafe.Pointer(src)).uv_stride))) + uintptr((*(*int32)(unsafe.Pointer(bp /* left */)) >> 1)))
+ (*WebPPicture)(unsafe.Pointer(dst)).y = (*WebPPicture)(unsafe.Pointer(src)).y + uintptr(*(*int32)(unsafe.Pointer(bp + 4))*(*WebPPicture)(unsafe.Pointer(src)).y_stride) + uintptr(*(*int32)(unsafe.Pointer(bp)))
+ (*WebPPicture)(unsafe.Pointer(dst)).u = (*WebPPicture)(unsafe.Pointer(src)).u + uintptr(*(*int32)(unsafe.Pointer(bp + 4))>>1*(*WebPPicture)(unsafe.Pointer(src)).uv_stride) + uintptr(*(*int32)(unsafe.Pointer(bp))>>1)
+ (*WebPPicture)(unsafe.Pointer(dst)).v = (*WebPPicture)(unsafe.Pointer(src)).v + uintptr(*(*int32)(unsafe.Pointer(bp + 4))>>1*(*WebPPicture)(unsafe.Pointer(src)).uv_stride) + uintptr(*(*int32)(unsafe.Pointer(bp))>>1)
(*WebPPicture)(unsafe.Pointer(dst)).y_stride = (*WebPPicture)(unsafe.Pointer(src)).y_stride
(*WebPPicture)(unsafe.Pointer(dst)).uv_stride = (*WebPPicture)(unsafe.Pointer(src)).uv_stride
- if (*WebPPicture)(unsafe.Pointer(src)).a != (uintptr(0)) {
- (*WebPPicture)(unsafe.Pointer(dst)).a = (((*WebPPicture)(unsafe.Pointer(src)).a + uintptr((*(*int32)(unsafe.Pointer(bp + 4 /* top */)) * (*WebPPicture)(unsafe.Pointer(src)).a_stride))) + uintptr(*(*int32)(unsafe.Pointer(bp /* left */))))
+ if (*WebPPicture)(unsafe.Pointer(src)).a != uintptr(0) {
+ (*WebPPicture)(unsafe.Pointer(dst)).a = (*WebPPicture)(unsafe.Pointer(src)).a + uintptr(*(*int32)(unsafe.Pointer(bp + 4))*(*WebPPicture)(unsafe.Pointer(src)).a_stride) + uintptr(*(*int32)(unsafe.Pointer(bp)))
(*WebPPicture)(unsafe.Pointer(dst)).a_stride = (*WebPPicture)(unsafe.Pointer(src)).a_stride
}
} else {
- (*WebPPicture)(unsafe.Pointer(dst)).argb = (((*WebPPicture)(unsafe.Pointer(src)).argb + uintptr((*(*int32)(unsafe.Pointer(bp + 4 /* top */))*(*WebPPicture)(unsafe.Pointer(src)).argb_stride))*4) + uintptr(*(*int32)(unsafe.Pointer(bp /* left */)))*4)
+ (*WebPPicture)(unsafe.Pointer(dst)).argb = (*WebPPicture)(unsafe.Pointer(src)).argb + uintptr(*(*int32)(unsafe.Pointer(bp + 4))*(*WebPPicture)(unsafe.Pointer(src)).argb_stride)*4 + uintptr(*(*int32)(unsafe.Pointer(bp)))*4
(*WebPPicture)(unsafe.Pointer(dst)).argb_stride = (*WebPPicture)(unsafe.Pointer(src)).argb_stride
}
return 1
@@ -31315,39 +31017,39 @@ func WebPPictureCrop(tls *libc.TLS, pic uintptr, left int32, top int32, width in
// var tmp WebPPicture at bp+8, 256
- if pic == (uintptr(0)) {
+ if pic == uintptr(0) {
return 0
}
- if !(AdjustAndCheckRectangle(tls, pic, (bp) /* &left */, (bp+4) /* &top */, width, height) != 0) {
+ if !(AdjustAndCheckRectangle(tls, pic, bp, bp+4, width, height) != 0) {
return 0
}
- PictureGrabSpecs(tls, pic, (bp + 8) /* &tmp */)
+ PictureGrabSpecs(tls, pic, bp+8)
(*WebPPicture)(unsafe.Pointer(bp + 8 /* &tmp */)).width = width
(*WebPPicture)(unsafe.Pointer(bp + 8 /* &tmp */)).height = height
- if !(WebPPictureAlloc(tls, (bp+8) /* &tmp */) != 0) {
+ if !(WebPPictureAlloc(tls, bp+8) != 0) {
return 0
}
if !((*WebPPicture)(unsafe.Pointer(pic)).use_argb != 0) {
- var y_offset int32 = ((*(*int32)(unsafe.Pointer(bp + 4 /* top */)) * (*WebPPicture)(unsafe.Pointer(pic)).y_stride) + *(*int32)(unsafe.Pointer(bp /* left */)))
- var uv_offset int32 = (((*(*int32)(unsafe.Pointer(bp + 4 /* top */)) / 2) * (*WebPPicture)(unsafe.Pointer(pic)).uv_stride) + (*(*int32)(unsafe.Pointer(bp /* left */)) / 2))
- WebPCopyPlane(tls, ((*WebPPicture)(unsafe.Pointer(pic)).y + uintptr(y_offset)), (*WebPPicture)(unsafe.Pointer(pic)).y_stride,
+ var y_offset int32 = *(*int32)(unsafe.Pointer(bp + 4))*(*WebPPicture)(unsafe.Pointer(pic)).y_stride + *(*int32)(unsafe.Pointer(bp))
+ var uv_offset int32 = *(*int32)(unsafe.Pointer(bp + 4))/2*(*WebPPicture)(unsafe.Pointer(pic)).uv_stride + *(*int32)(unsafe.Pointer(bp))/2
+ WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).y+uintptr(y_offset), (*WebPPicture)(unsafe.Pointer(pic)).y_stride,
(*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).y, (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).y_stride, width, height)
- WebPCopyPlane(tls, ((*WebPPicture)(unsafe.Pointer(pic)).u + uintptr(uv_offset)), (*WebPPicture)(unsafe.Pointer(pic)).uv_stride,
- (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).u, (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).uv_stride, (((width) + 1) >> 1), (((height) + 1) >> 1))
- WebPCopyPlane(tls, ((*WebPPicture)(unsafe.Pointer(pic)).v + uintptr(uv_offset)), (*WebPPicture)(unsafe.Pointer(pic)).uv_stride,
- (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).v, (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).uv_stride, (((width) + 1) >> 1), (((height) + 1) >> 1))
-
- if (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).a != (uintptr(0)) {
- var a_offset int32 = ((*(*int32)(unsafe.Pointer(bp + 4 /* top */)) * (*WebPPicture)(unsafe.Pointer(pic)).a_stride) + *(*int32)(unsafe.Pointer(bp /* left */)))
- WebPCopyPlane(tls, ((*WebPPicture)(unsafe.Pointer(pic)).a + uintptr(a_offset)), (*WebPPicture)(unsafe.Pointer(pic)).a_stride,
+ WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).u+uintptr(uv_offset), (*WebPPicture)(unsafe.Pointer(pic)).uv_stride,
+ (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).u, (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).uv_stride, (width+1)>>1, (height+1)>>1)
+ WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).v+uintptr(uv_offset), (*WebPPicture)(unsafe.Pointer(pic)).uv_stride,
+ (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).v, (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).uv_stride, (width+1)>>1, (height+1)>>1)
+
+ if (*WebPPicture)(unsafe.Pointer(bp+8)).a != uintptr(0) {
+ var a_offset int32 = *(*int32)(unsafe.Pointer(bp + 4))*(*WebPPicture)(unsafe.Pointer(pic)).a_stride + *(*int32)(unsafe.Pointer(bp))
+ WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).a+uintptr(a_offset), (*WebPPicture)(unsafe.Pointer(pic)).a_stride,
(*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).a, (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).a_stride, width, height)
}
} else {
- var src uintptr = (((*WebPPicture)(unsafe.Pointer(pic)).argb + uintptr((*(*int32)(unsafe.Pointer(bp + 4 /* top */))*(*WebPPicture)(unsafe.Pointer(pic)).argb_stride))*4) + uintptr(*(*int32)(unsafe.Pointer(bp /* left */)))*4)
- WebPCopyPlane(tls, src, ((*WebPPicture)(unsafe.Pointer(pic)).argb_stride * 4), (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).argb,
- ((*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).argb_stride * 4), (width * 4), height)
+ var src uintptr = (*WebPPicture)(unsafe.Pointer(pic)).argb + uintptr(*(*int32)(unsafe.Pointer(bp + 4))*(*WebPPicture)(unsafe.Pointer(pic)).argb_stride)*4 + uintptr(*(*int32)(unsafe.Pointer(bp)))*4
+ WebPCopyPlane(tls, src, (*WebPPicture)(unsafe.Pointer(pic)).argb_stride*4, (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).argb,
+ (*WebPPicture)(unsafe.Pointer(bp+8)).argb_stride*4, width*4, height)
}
WebPPictureFree(tls, pic)
*(*WebPPicture)(unsafe.Pointer(pic)) = *(*WebPPicture)(unsafe.Pointer(bp + 8 /* tmp */))
@@ -31364,27 +31066,27 @@ func RescalePlane(tls *libc.TLS, src uintptr, src_width int32, src_height int32,
// var rescaler WebPRescaler at bp, 104
var y int32 = 0
- if !(WebPRescalerInit(tls, (bp) /* &rescaler */, src_width, src_height,
+ if !(WebPRescalerInit(tls, bp, src_width, src_height,
dst, dst_width, dst_height, dst_stride,
num_channels, work) != 0) {
return 0
}
for y < src_height {
- y = y + (WebPRescalerImport(tls, (bp) /* &rescaler */, (src_height - y),
- (src + uintptr((y * src_stride))), src_stride))
- WebPRescalerExport(tls, (bp) /* &rescaler */)
+ y = y + WebPRescalerImport(tls, bp, src_height-y,
+ src+uintptr(y*src_stride), src_stride)
+ WebPRescalerExport(tls, bp)
}
return 1
}
func AlphaMultiplyARGB(tls *libc.TLS, pic uintptr, inverse int32) { /* picture_rescale_enc.c:188:13: */
- WebPMultARGBRows(tls, (*WebPPicture)(unsafe.Pointer(pic)).argb, (int32(uint64((*WebPPicture)(unsafe.Pointer(pic)).argb_stride) * uint64(unsafe.Sizeof(uint32_t(0))))),
+ WebPMultARGBRows(tls, (*WebPPicture)(unsafe.Pointer(pic)).argb, int32(uint64((*WebPPicture)(unsafe.Pointer(pic)).argb_stride)*uint64(unsafe.Sizeof(uint32_t(0)))),
(*WebPPicture)(unsafe.Pointer(pic)).width, (*WebPPicture)(unsafe.Pointer(pic)).height, inverse)
}
func AlphaMultiplyY(tls *libc.TLS, pic uintptr, inverse int32) { /* picture_rescale_enc.c:194:13: */
- if (*WebPPicture)(unsafe.Pointer(pic)).a != (uintptr(0)) {
+ if (*WebPPicture)(unsafe.Pointer(pic)).a != uintptr(0) {
WebPMultRows(tls, (*WebPPicture)(unsafe.Pointer(pic)).y, (*WebPPicture)(unsafe.Pointer(pic)).y_stride, (*WebPPicture)(unsafe.Pointer(pic)).a, (*WebPPicture)(unsafe.Pointer(pic)).a_stride,
(*WebPPicture)(unsafe.Pointer(pic)).width, (*WebPPicture)(unsafe.Pointer(pic)).height, inverse)
}
@@ -31402,34 +31104,34 @@ func WebPPictureRescale(tls *libc.TLS, pic uintptr, width int32, height int32) i
var prev_height int32
var work uintptr
- if pic == (uintptr(0)) {
+ if pic == uintptr(0) {
return 0
}
prev_width = (*WebPPicture)(unsafe.Pointer(pic)).width
prev_height = (*WebPPicture)(unsafe.Pointer(pic)).height
if !(WebPRescalerGetScaledDimensions(tls,
- prev_width, prev_height, (bp) /* &width */, (bp+4) /* &height */) != 0) {
+ prev_width, prev_height, bp, bp+4) != 0) {
return 0
}
- PictureGrabSpecs(tls, pic, (bp + 8) /* &tmp */)
+ PictureGrabSpecs(tls, pic, bp+8)
(*WebPPicture)(unsafe.Pointer(bp + 8 /* &tmp */)).width = *(*int32)(unsafe.Pointer(bp /* width */))
(*WebPPicture)(unsafe.Pointer(bp + 8 /* &tmp */)).height = *(*int32)(unsafe.Pointer(bp + 4 /* height */))
- if !(WebPPictureAlloc(tls, (bp+8) /* &tmp */) != 0) {
+ if !(WebPPictureAlloc(tls, bp+8) != 0) {
return 0
}
if !((*WebPPicture)(unsafe.Pointer(pic)).use_argb != 0) {
- work = WebPSafeMalloc(tls, (uint64(2 * uint64(*(*int32)(unsafe.Pointer(bp /* width */))))), uint64(unsafe.Sizeof(rescaler_t(0))))
- if work == (uintptr(0)) {
- WebPPictureFree(tls, (bp + 8) /* &tmp */)
+ work = WebPSafeMalloc(tls, uint64(2*uint64(*(*int32)(unsafe.Pointer(bp)))), uint64(unsafe.Sizeof(rescaler_t(0))))
+ if work == uintptr(0) {
+ WebPPictureFree(tls, bp+8)
return 0
}
// If present, we need to rescale alpha first (for AlphaMultiplyY).
- if (*WebPPicture)(unsafe.Pointer(pic)).a != (uintptr(0)) {
+ if (*WebPPicture)(unsafe.Pointer(pic)).a != uintptr(0) {
WebPInitAlphaProcessing(tls)
if !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).a, prev_width, prev_height, (*WebPPicture)(unsafe.Pointer(pic)).a_stride,
- (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).a, *(*int32)(unsafe.Pointer(bp /* width */)), *(*int32)(unsafe.Pointer(bp + 4 /* height */)), (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).a_stride, work, 1) != 0) {
+ (*WebPPicture)(unsafe.Pointer(bp+8)).a, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), (*WebPPicture)(unsafe.Pointer(bp+8)).a_stride, work, 1) != 0) {
return 0
}
}
@@ -31437,21 +31139,21 @@ func WebPPictureRescale(tls *libc.TLS, pic uintptr, width int32, height int32) i
// We take transparency into account on the luma plane only. That's not
// totally exact blending, but still is a good approximation.
AlphaMultiplyY(tls, pic, 0)
- if (!(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).y, prev_width, prev_height, (*WebPPicture)(unsafe.Pointer(pic)).y_stride,
- (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).y, *(*int32)(unsafe.Pointer(bp /* width */)), *(*int32)(unsafe.Pointer(bp + 4 /* height */)), (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).y_stride, work, 1) != 0) || !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).u,
- (((prev_width)+1)>>1), (((prev_height)+1)>>1), (*WebPPicture)(unsafe.Pointer(pic)).uv_stride,
- (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).u,
- (((*(*int32)(unsafe.Pointer(bp /* width */)))+1)>>1), (((*(*int32)(unsafe.Pointer(bp + 4 /* height */)))+1)>>1), (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).uv_stride, work, 1) != 0)) || !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).v,
- (((prev_width)+1)>>1), (((prev_height)+1)>>1), (*WebPPicture)(unsafe.Pointer(pic)).uv_stride,
- (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).v,
- (((*(*int32)(unsafe.Pointer(bp /* width */)))+1)>>1), (((*(*int32)(unsafe.Pointer(bp + 4 /* height */)))+1)>>1), (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).uv_stride, work, 1) != 0) {
+ if !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).y, prev_width, prev_height, (*WebPPicture)(unsafe.Pointer(pic)).y_stride,
+ (*WebPPicture)(unsafe.Pointer(bp+8)).y, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), (*WebPPicture)(unsafe.Pointer(bp+8)).y_stride, work, 1) != 0) || !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).u,
+ (prev_width+1)>>1, (prev_height+1)>>1, (*WebPPicture)(unsafe.Pointer(pic)).uv_stride,
+ (*WebPPicture)(unsafe.Pointer(bp+8)).u,
+ (*(*int32)(unsafe.Pointer(bp))+1)>>1, (*(*int32)(unsafe.Pointer(bp + 4))+1)>>1, (*WebPPicture)(unsafe.Pointer(bp+8)).uv_stride, work, 1) != 0) || !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).v,
+ (prev_width+1)>>1, (prev_height+1)>>1, (*WebPPicture)(unsafe.Pointer(pic)).uv_stride,
+ (*WebPPicture)(unsafe.Pointer(bp+8)).v,
+ (*(*int32)(unsafe.Pointer(bp))+1)>>1, (*(*int32)(unsafe.Pointer(bp + 4))+1)>>1, (*WebPPicture)(unsafe.Pointer(bp+8)).uv_stride, work, 1) != 0) {
return 0
}
- AlphaMultiplyY(tls, (bp + 8) /* &tmp */, 1)
+ AlphaMultiplyY(tls, bp+8, 1)
} else {
- work = WebPSafeMalloc(tls, (uint64((2 * uint64(*(*int32)(unsafe.Pointer(bp /* width */)))) * uint64(4))), uint64(unsafe.Sizeof(rescaler_t(0))))
- if work == (uintptr(0)) {
- WebPPictureFree(tls, (bp + 8) /* &tmp */)
+ work = WebPSafeMalloc(tls, uint64(2*uint64(*(*int32)(unsafe.Pointer(bp)))*uint64(4)), uint64(unsafe.Sizeof(rescaler_t(0))))
+ if work == uintptr(0) {
+ WebPPictureFree(tls, bp+8)
return 0
}
// In order to correctly interpolate colors, we need to apply the alpha
@@ -31460,12 +31162,12 @@ func WebPPictureRescale(tls *libc.TLS, pic uintptr, width int32, height int32) i
WebPInitAlphaProcessing(tls)
AlphaMultiplyARGB(tls, pic, 0)
if !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).argb, prev_width, prev_height,
- ((*WebPPicture)(unsafe.Pointer(pic)).argb_stride*4),
- (*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).argb, *(*int32)(unsafe.Pointer(bp /* width */)), *(*int32)(unsafe.Pointer(bp + 4 /* height */)),
- ((*WebPPicture)(unsafe.Pointer(bp+8 /* &tmp */)).argb_stride*4), work, 4) != 0) {
+ (*WebPPicture)(unsafe.Pointer(pic)).argb_stride*4,
+ (*WebPPicture)(unsafe.Pointer(bp+8)).argb, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)),
+ (*WebPPicture)(unsafe.Pointer(bp+8)).argb_stride*4, work, 4) != 0) {
return 0
}
- AlphaMultiplyARGB(tls, (bp + 8) /* &tmp */, 1)
+ AlphaMultiplyARGB(tls, bp+8, 1)
}
WebPPictureFree(tls, pic)
WebPSafeFree(tls, work)
@@ -31481,11 +31183,11 @@ func IsTransparentARGBArea(tls *libc.TLS, ptr uintptr, stride int32, size int32)
var x int32
for y = 0; y < size; y++ {
for x = 0; x < size; x++ {
- if (*(*uint32_t)(unsafe.Pointer(ptr + uintptr(x)*4)) & 0xff000000) != 0 {
+ if *(*uint32_t)(unsafe.Pointer(ptr + uintptr(x)*4))&0xff000000 != 0 {
return 0
}
}
- ptr += 4 * (uintptr(stride))
+ ptr += 4 * uintptr(stride)
}
return 1
}
@@ -31505,7 +31207,7 @@ func FlattenARGB(tls *libc.TLS, ptr uintptr, v uint32_t, stride int32, size int3
for x = 0; x < size; x++ {
*(*uint32_t)(unsafe.Pointer(ptr + uintptr(x)*4)) = v
}
- ptr += 4 * (uintptr(stride))
+ ptr += 4 * uintptr(stride)
}
}
@@ -31522,14 +31224,14 @@ func SmoothenBlock(tls *libc.TLS, a_ptr uintptr, a_stride int32, y_ptr uintptr,
for x = 0; x < width; x++ {
if int32(*(*uint8_t)(unsafe.Pointer(alpha_ptr + uintptr(x)))) != 0 {
count++
- sum = sum + (int32(*(*uint8_t)(unsafe.Pointer(luma_ptr + uintptr(x)))))
+ sum = sum + int32(*(*uint8_t)(unsafe.Pointer(luma_ptr + uintptr(x))))
}
}
alpha_ptr += uintptr(a_stride)
luma_ptr += uintptr(y_stride)
}
- if (count > 0) && (count < (width * height)) {
- var avg_u8 uint8_t = (uint8_t(sum / count))
+ if count > 0 && count < width*height {
+ var avg_u8 uint8_t = uint8_t(sum / count)
alpha_ptr = a_ptr
luma_ptr = y_ptr
for y = 0; y < height; y++ {
@@ -31542,20 +31244,20 @@ func SmoothenBlock(tls *libc.TLS, a_ptr uintptr, a_stride int32, y_ptr uintptr,
luma_ptr += uintptr(y_stride)
}
}
- return (libc.Bool32(count == 0))
+ return libc.Bool32(count == 0)
}
func WebPReplaceTransparentPixels(tls *libc.TLS, pic uintptr, color uint32_t) { /* picture_tools_enc.c:86:6: */
- if (pic != (uintptr(0))) && ((*WebPPicture)(unsafe.Pointer(pic)).use_argb != 0) {
+ if pic != uintptr(0) && (*WebPPicture)(unsafe.Pointer(pic)).use_argb != 0 {
var y int32 = (*WebPPicture)(unsafe.Pointer(pic)).height
var argb uintptr = (*WebPPicture)(unsafe.Pointer(pic)).argb
- color = color & (0xffffff) // force alpha=0
+ color = color & 0xffffff // force alpha=0
WebPInitAlphaProcessing(tls)
for libc.PostDecInt32(&y, 1) > 0 {
(*struct {
f func(*libc.TLS, uintptr, int32, uint32_t)
})(unsafe.Pointer(&struct{ uintptr }{WebPAlphaReplace})).f(tls, argb, (*WebPPicture)(unsafe.Pointer(pic)).width, color)
- argb += 4 * (uintptr((*WebPPicture)(unsafe.Pointer(pic)).argb_stride))
+ argb += 4 * uintptr((*WebPPicture)(unsafe.Pointer(pic)).argb_stride)
}
}
}
@@ -31568,11 +31270,11 @@ func WebPCleanupTransparentArea(tls *libc.TLS, pic uintptr) { /* picture_tools_e
var y int32
var w int32
var h int32
- if pic == (uintptr(0)) {
+ if pic == uintptr(0) {
return
}
- w = ((*WebPPicture)(unsafe.Pointer(pic)).width / 8)
- h = ((*WebPPicture)(unsafe.Pointer(pic)).height / 8)
+ w = (*WebPPicture)(unsafe.Pointer(pic)).width / 8
+ h = (*WebPPicture)(unsafe.Pointer(pic)).height / 8
// note: we ignore the left-overs on right/bottom, except for SmoothenBlock().
if (*WebPPicture)(unsafe.Pointer(pic)).use_argb != 0 {
@@ -31580,13 +31282,13 @@ func WebPCleanupTransparentArea(tls *libc.TLS, pic uintptr) { /* picture_tools_e
for y = 0; y < h; y++ {
var need_reset int32 = 1
for x = 0; x < w; x++ {
- var off int32 = (((y * (*WebPPicture)(unsafe.Pointer(pic)).argb_stride) + x) * 8)
- if IsTransparentARGBArea(tls, ((*WebPPicture)(unsafe.Pointer(pic)).argb+uintptr(off)*4), (*WebPPicture)(unsafe.Pointer(pic)).argb_stride, 8) != 0 {
+ var off int32 = (y*(*WebPPicture)(unsafe.Pointer(pic)).argb_stride + x) * 8
+ if IsTransparentARGBArea(tls, (*WebPPicture)(unsafe.Pointer(pic)).argb+uintptr(off)*4, (*WebPPicture)(unsafe.Pointer(pic)).argb_stride, 8) != 0 {
if need_reset != 0 {
argb_value = *(*uint32_t)(unsafe.Pointer((*WebPPicture)(unsafe.Pointer(pic)).argb + uintptr(off)*4))
need_reset = 0
}
- FlattenARGB(tls, ((*WebPPicture)(unsafe.Pointer(pic)).argb + uintptr(off)*4), argb_value, (*WebPPicture)(unsafe.Pointer(pic)).argb_stride, 8)
+ FlattenARGB(tls, (*WebPPicture)(unsafe.Pointer(pic)).argb+uintptr(off)*4, argb_value, (*WebPPicture)(unsafe.Pointer(pic)).argb_stride, 8)
} else {
need_reset = 1
}
@@ -31603,45 +31305,45 @@ func WebPCleanupTransparentArea(tls *libc.TLS, pic uintptr) { /* picture_tools_e
var v_ptr uintptr = (*WebPPicture)(unsafe.Pointer(pic)).v
var a_ptr uintptr = (*WebPPicture)(unsafe.Pointer(pic)).a
*(*[3]int32)(unsafe.Pointer(bp /* values */)) = [3]int32{0: 0}
- if (((a_ptr == (uintptr(0))) || (y_ptr == (uintptr(0)))) || (u_ptr == (uintptr(0)))) || (v_ptr == (uintptr(0))) {
+ if a_ptr == uintptr(0) || y_ptr == uintptr(0) || u_ptr == uintptr(0) || v_ptr == uintptr(0) {
return
}
- for y = 0; (y + 8) <= height; y = y + (8) {
+ for y = 0; y+8 <= height; y = y + 8 {
var need_reset int32 = 1
- for x = 0; (x + 8) <= width; x = x + (8) {
- if SmoothenBlock(tls, (a_ptr+uintptr(x)), a_stride, (y_ptr+uintptr(x)), y_stride,
+ for x = 0; x+8 <= width; x = x + 8 {
+ if SmoothenBlock(tls, a_ptr+uintptr(x), a_stride, y_ptr+uintptr(x), y_stride,
8, 8) != 0 {
if need_reset != 0 {
- *(*int32)(unsafe.Pointer((bp) /* &values[0] */)) = int32(*(*uint8_t)(unsafe.Pointer(y_ptr + uintptr(x))))
- *(*int32)(unsafe.Pointer((bp) /* &values[0] */ + 1*4)) = int32(*(*uint8_t)(unsafe.Pointer(u_ptr + uintptr((x >> 1)))))
- *(*int32)(unsafe.Pointer((bp) /* &values[0] */ + 2*4)) = int32(*(*uint8_t)(unsafe.Pointer(v_ptr + uintptr((x >> 1)))))
+ *(*int32)(unsafe.Pointer(bp)) = int32(*(*uint8_t)(unsafe.Pointer(y_ptr + uintptr(x))))
+ *(*int32)(unsafe.Pointer(bp + 1*4)) = int32(*(*uint8_t)(unsafe.Pointer(u_ptr + uintptr(x>>1))))
+ *(*int32)(unsafe.Pointer(bp + 2*4)) = int32(*(*uint8_t)(unsafe.Pointer(v_ptr + uintptr(x>>1))))
need_reset = 0
}
- Flatten(tls, (y_ptr + uintptr(x)), *(*int32)(unsafe.Pointer((bp) /* &values[0] */)), y_stride, 8)
- Flatten(tls, (u_ptr + uintptr((x >> 1))), *(*int32)(unsafe.Pointer((bp) /* &values[0] */ + 1*4)), uv_stride, (8 / 2))
- Flatten(tls, (v_ptr + uintptr((x >> 1))), *(*int32)(unsafe.Pointer((bp) /* &values[0] */ + 2*4)), uv_stride, (8 / 2))
+ Flatten(tls, y_ptr+uintptr(x), *(*int32)(unsafe.Pointer(bp)), y_stride, 8)
+ Flatten(tls, u_ptr+uintptr(x>>1), *(*int32)(unsafe.Pointer(bp + 1*4)), uv_stride, 8/2)
+ Flatten(tls, v_ptr+uintptr(x>>1), *(*int32)(unsafe.Pointer(bp + 2*4)), uv_stride, 8/2)
} else {
need_reset = 1
}
}
if x < width {
- SmoothenBlock(tls, (a_ptr + uintptr(x)), a_stride, (y_ptr + uintptr(x)), y_stride,
- (width - x), 8)
+ SmoothenBlock(tls, a_ptr+uintptr(x), a_stride, y_ptr+uintptr(x), y_stride,
+ width-x, 8)
}
- a_ptr += (uintptr(8 * a_stride))
- y_ptr += (uintptr(8 * y_stride))
- u_ptr += (uintptr((8 / 2) * uv_stride))
- v_ptr += (uintptr((8 / 2) * uv_stride))
+ a_ptr += uintptr(8 * a_stride)
+ y_ptr += uintptr(8 * y_stride)
+ u_ptr += uintptr(8 / 2 * uv_stride)
+ v_ptr += uintptr(8 / 2 * uv_stride)
}
if y < height {
- var sub_height int32 = (height - y)
- for x = 0; (x + 8) <= width; x = x + (8) {
- SmoothenBlock(tls, (a_ptr + uintptr(x)), a_stride, (y_ptr + uintptr(x)), y_stride,
+ var sub_height int32 = height - y
+ for x = 0; x+8 <= width; x = x + 8 {
+ SmoothenBlock(tls, a_ptr+uintptr(x), a_stride, y_ptr+uintptr(x), y_stride,
8, sub_height)
}
if x < width {
- SmoothenBlock(tls, (a_ptr + uintptr(x)), a_stride, (y_ptr + uintptr(x)), y_stride,
- (width - x), sub_height)
+ SmoothenBlock(tls, a_ptr+uintptr(x), a_stride, y_ptr+uintptr(x), y_stride,
+ width-x, sub_height)
}
}
}
@@ -31651,30 +31353,30 @@ func WebPCleanupTransparentArea(tls *libc.TLS, pic uintptr) { /* picture_tools_e
// Blend color and remove transparency info
func MakeARGB321(tls *libc.TLS, r int32, g int32, b int32) uint32_t { /* picture_tools_enc.c:189:29: */
- return (((0xff000000 | (uint32(r << 16))) | (uint32(g << 8))) | uint32(b))
+ return 0xff000000 | uint32(r<<16) | uint32(g<<8) | uint32(b)
}
func WebPBlendAlpha(tls *libc.TLS, pic uintptr, background_rgb uint32_t) { /* picture_tools_enc.c:193:6: */
- var red int32 = (int32((background_rgb >> 16) & uint32_t(0xff)))
- var green int32 = (int32((background_rgb >> 8) & uint32_t(0xff)))
- var blue int32 = (int32((background_rgb >> 0) & uint32_t(0xff)))
+ var red int32 = int32(background_rgb >> 16 & uint32_t(0xff))
+ var green int32 = int32(background_rgb >> 8 & uint32_t(0xff))
+ var blue int32 = int32(background_rgb >> 0 & uint32_t(0xff))
var x int32
var y int32
- if pic == (uintptr(0)) {
+ if pic == uintptr(0) {
return
}
if !((*WebPPicture)(unsafe.Pointer(pic)).use_argb != 0) {
- var uv_width int32 = ((*WebPPicture)(unsafe.Pointer(pic)).width >> 1) // omit last pixel during u/v loop
+ var uv_width int32 = (*WebPPicture)(unsafe.Pointer(pic)).width >> 1 // omit last pixel during u/v loop
var Y0 int32 = VP8RGBToY(tls, red, green, blue, YUV_HALF)
// VP8RGBToU/V expects the u/v values summed over four pixels
- var U0 int32 = VP8RGBToU(tls, (4 * red), (4 * green), (4 * blue), (4 * YUV_HALF))
- var V0 int32 = VP8RGBToV(tls, (4 * red), (4 * green), (4 * blue), (4 * YUV_HALF))
- var has_alpha int32 = (int32((*WebPPicture)(unsafe.Pointer(pic)).colorspace & WEBP_CSP_ALPHA_BIT))
+ var U0 int32 = VP8RGBToU(tls, 4*red, 4*green, 4*blue, 4*YUV_HALF)
+ var V0 int32 = VP8RGBToV(tls, 4*red, 4*green, 4*blue, 4*YUV_HALF)
+ var has_alpha int32 = int32((*WebPPicture)(unsafe.Pointer(pic)).colorspace & WEBP_CSP_ALPHA_BIT)
var y_ptr uintptr = (*WebPPicture)(unsafe.Pointer(pic)).y
var u_ptr uintptr = (*WebPPicture)(unsafe.Pointer(pic)).u
var v_ptr uintptr = (*WebPPicture)(unsafe.Pointer(pic)).v
var a_ptr uintptr = (*WebPPicture)(unsafe.Pointer(pic)).a
- if !(has_alpha != 0) || (a_ptr == (uintptr(0))) {
+ if !(has_alpha != 0) || a_ptr == uintptr(0) {
return
} // nothing to do
for y = 0; y < (*WebPPicture)(unsafe.Pointer(pic)).height; y++ {
@@ -31682,28 +31384,28 @@ func WebPBlendAlpha(tls *libc.TLS, pic uintptr, background_rgb uint32_t) { /* pi
for x = 0; x < (*WebPPicture)(unsafe.Pointer(pic)).width; x++ {
var alpha uint8_t = *(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(x)))
if int32(alpha) < 0xff {
- *(*uint8_t)(unsafe.Pointer(y_ptr + uintptr(x))) = (uint8_t((((((Y0) * (255 - (int32(alpha)))) + ((int32(*(*uint8_t)(unsafe.Pointer(y_ptr + uintptr(x))))) * (int32(alpha)))) * 0x101) + 256) >> 16))
+ *(*uint8_t)(unsafe.Pointer(y_ptr + uintptr(x))) = uint8_t(((Y0*(255-int32(alpha))+int32(*(*uint8_t)(unsafe.Pointer(y_ptr + uintptr(x))))*int32(alpha))*0x101 + 256) >> 16)
}
}
// Chroma blending every even line
- if (y & 1) == 0 {
+ if y&1 == 0 {
var a_ptr2 uintptr
- if (y + 1) == (*WebPPicture)(unsafe.Pointer(pic)).height {
+ if y+1 == (*WebPPicture)(unsafe.Pointer(pic)).height {
a_ptr2 = a_ptr
} else {
- a_ptr2 = (a_ptr + uintptr((*WebPPicture)(unsafe.Pointer(pic)).a_stride))
+ a_ptr2 = a_ptr + uintptr((*WebPPicture)(unsafe.Pointer(pic)).a_stride)
}
for x = 0; x < uv_width; x++ {
// Average four alpha values into a single blending weight.
// TODO(skal): might lead to visible contouring. Can we do better?
- var alpha uint32_t = (uint32_t(((int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(((2 * x) + 0))))) + int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(((2 * x) + 1)))))) + int32(*(*uint8_t)(unsafe.Pointer(a_ptr2 + uintptr(((2 * x) + 0)))))) + int32(*(*uint8_t)(unsafe.Pointer(a_ptr2 + uintptr(((2 * x) + 1)))))))
- *(*uint8_t)(unsafe.Pointer(u_ptr + uintptr(x))) = (uint8_t((((((uint32_t(U0)) * (uint32_t(1020) - (alpha))) + ((uint32_t(*(*uint8_t)(unsafe.Pointer(u_ptr + uintptr(x))))) * (alpha))) * uint32_t(0x101)) + uint32_t(1024)) >> 18))
- *(*uint8_t)(unsafe.Pointer(v_ptr + uintptr(x))) = (uint8_t((((((uint32_t(V0)) * (uint32_t(1020) - (alpha))) + ((uint32_t(*(*uint8_t)(unsafe.Pointer(v_ptr + uintptr(x))))) * (alpha))) * uint32_t(0x101)) + uint32_t(1024)) >> 18))
+ var alpha uint32_t = uint32_t(int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(2*x+0)))) + int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(2*x+1)))) + int32(*(*uint8_t)(unsafe.Pointer(a_ptr2 + uintptr(2*x+0)))) + int32(*(*uint8_t)(unsafe.Pointer(a_ptr2 + uintptr(2*x+1)))))
+ *(*uint8_t)(unsafe.Pointer(u_ptr + uintptr(x))) = uint8_t(((uint32_t(U0)*(uint32_t(1020)-alpha)+uint32_t(*(*uint8_t)(unsafe.Pointer(u_ptr + uintptr(x))))*alpha)*uint32_t(0x101) + uint32_t(1024)) >> 18)
+ *(*uint8_t)(unsafe.Pointer(v_ptr + uintptr(x))) = uint8_t(((uint32_t(V0)*(uint32_t(1020)-alpha)+uint32_t(*(*uint8_t)(unsafe.Pointer(v_ptr + uintptr(x))))*alpha)*uint32_t(0x101) + uint32_t(1024)) >> 18)
}
- if ((*WebPPicture)(unsafe.Pointer(pic)).width & 1) != 0 { // rightmost pixel
- var alpha uint32_t = (uint32_t(2 * (int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(((2 * x) + 0))))) + int32(*(*uint8_t)(unsafe.Pointer(a_ptr2 + uintptr(((2 * x) + 0))))))))
- *(*uint8_t)(unsafe.Pointer(u_ptr + uintptr(x))) = (uint8_t((((((uint32_t(U0)) * (uint32_t(1020) - (alpha))) + ((uint32_t(*(*uint8_t)(unsafe.Pointer(u_ptr + uintptr(x))))) * (alpha))) * uint32_t(0x101)) + uint32_t(1024)) >> 18))
- *(*uint8_t)(unsafe.Pointer(v_ptr + uintptr(x))) = (uint8_t((((((uint32_t(V0)) * (uint32_t(1020) - (alpha))) + ((uint32_t(*(*uint8_t)(unsafe.Pointer(v_ptr + uintptr(x))))) * (alpha))) * uint32_t(0x101)) + uint32_t(1024)) >> 18))
+ if (*WebPPicture)(unsafe.Pointer(pic)).width&1 != 0 { // rightmost pixel
+ var alpha uint32_t = uint32_t(2 * (int32(*(*uint8_t)(unsafe.Pointer(a_ptr + uintptr(2*x+0)))) + int32(*(*uint8_t)(unsafe.Pointer(a_ptr2 + uintptr(2*x+0))))))
+ *(*uint8_t)(unsafe.Pointer(u_ptr + uintptr(x))) = uint8_t(((uint32_t(U0)*(uint32_t(1020)-alpha)+uint32_t(*(*uint8_t)(unsafe.Pointer(u_ptr + uintptr(x))))*alpha)*uint32_t(0x101) + uint32_t(1024)) >> 18)
+ *(*uint8_t)(unsafe.Pointer(v_ptr + uintptr(x))) = uint8_t(((uint32_t(V0)*(uint32_t(1020)-alpha)+uint32_t(*(*uint8_t)(unsafe.Pointer(v_ptr + uintptr(x))))*alpha)*uint32_t(0x101) + uint32_t(1024)) >> 18)
}
} else {
u_ptr += uintptr((*WebPPicture)(unsafe.Pointer(pic)).uv_stride)
@@ -31718,22 +31420,22 @@ func WebPBlendAlpha(tls *libc.TLS, pic uintptr, background_rgb uint32_t) { /* pi
var background uint32_t = MakeARGB321(tls, red, green, blue)
for y = 0; y < (*WebPPicture)(unsafe.Pointer(pic)).height; y++ {
for x = 0; x < (*WebPPicture)(unsafe.Pointer(pic)).width; x++ {
- var alpha int32 = (int32((*(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4)) >> 24) & uint32_t(0xff)))
+ var alpha int32 = int32(*(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4)) >> 24 & uint32_t(0xff))
if alpha != 0xff {
if alpha > 0 {
- var r int32 = (int32((*(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4)) >> 16) & uint32_t(0xff)))
- var g int32 = (int32((*(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4)) >> 8) & uint32_t(0xff)))
- var b int32 = (int32((*(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4)) >> 0) & uint32_t(0xff)))
- r = ((((((red) * (255 - (alpha))) + ((r) * (alpha))) * 0x101) + 256) >> 16)
- g = ((((((green) * (255 - (alpha))) + ((g) * (alpha))) * 0x101) + 256) >> 16)
- b = ((((((blue) * (255 - (alpha))) + ((b) * (alpha))) * 0x101) + 256) >> 16)
+ var r int32 = int32(*(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4)) >> 16 & uint32_t(0xff))
+ var g int32 = int32(*(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4)) >> 8 & uint32_t(0xff))
+ var b int32 = int32(*(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4)) >> 0 & uint32_t(0xff))
+ r = ((red*(255-alpha)+r*alpha)*0x101 + 256) >> 16
+ g = ((green*(255-alpha)+g*alpha)*0x101 + 256) >> 16
+ b = ((blue*(255-alpha)+b*alpha)*0x101 + 256) >> 16
*(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4)) = MakeARGB321(tls, r, g, b)
} else {
*(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4)) = background
}
}
}
- argb += 4 * (uintptr((*WebPPicture)(unsafe.Pointer(pic)).argb_stride))
+ argb += 4 * uintptr((*WebPPicture)(unsafe.Pointer(pic)).argb_stride)
}
}
}
@@ -31758,15 +31460,15 @@ func GetMin(tls *libc.TLS, a int32, b int32) int32 { /* predictor_enc.c:28:24: *
// Methods to calculate Entropy (Shannon).
func PredictionCostSpatial(tls *libc.TLS, counts uintptr, weight_0 int32, exp_val float64) float32 { /* predictor_enc.c:33:14: */
- var significant_symbols int32 = (int32(256) >> 4)
+ var significant_symbols int32 = int32(256) >> 4
var exp_decay_factor float64 = 0.6
- var bits float64 = (float64(weight_0 * *(*int32)(unsafe.Pointer(counts))))
+ var bits float64 = float64(weight_0 * *(*int32)(unsafe.Pointer(counts)))
var i int32
for i = 1; i < significant_symbols; i++ {
- bits = bits + (exp_val * (float64(*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + *(*int32)(unsafe.Pointer(counts + uintptr((256-i))*4)))))
- exp_val = exp_val * (exp_decay_factor)
+ bits = bits + exp_val*float64(*(*int32)(unsafe.Pointer(counts + uintptr(i)*4))+*(*int32)(unsafe.Pointer(counts + uintptr(256-i)*4)))
+ exp_val = exp_val * exp_decay_factor
}
- return (float32(-0.1 * bits))
+ return float32(-0.1 * bits)
}
func PredictionCostSpatialHistogram(tls *libc.TLS, accumulated uintptr, tile uintptr) float32 { /* predictor_enc.c:46:14: */
@@ -31774,19 +31476,19 @@ func PredictionCostSpatialHistogram(tls *libc.TLS, accumulated uintptr, tile uin
var retval float64 = float64(0)
for i = 0; i < 4; i++ {
var kExpValue float64 = 0.94
- retval = retval + (float64(PredictionCostSpatial(tls, (tile + uintptr(i)*1024), 1, kExpValue)))
- retval = retval + (float64((*struct {
+ retval = retval + float64(PredictionCostSpatial(tls, tile+uintptr(i)*1024, 1, kExpValue))
+ retval = retval + float64((*struct {
f func(*libc.TLS, uintptr, uintptr) float32
- })(unsafe.Pointer(&struct{ uintptr }{VP8LCombinedShannonEntropy})).f(tls, (tile + uintptr(i)*1024), (accumulated + uintptr(i)*1024))))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LCombinedShannonEntropy})).f(tls, tile+uintptr(i)*1024, accumulated+uintptr(i)*1024))
}
return float32(retval)
}
func UpdateHisto(tls *libc.TLS, histo_argb uintptr, argb uint32_t) { /* predictor_enc.c:58:25: */
- *(*int32)(unsafe.Pointer((histo_argb) + uintptr((argb>>24))*4))++
- *(*int32)(unsafe.Pointer((histo_argb + 1*1024) + uintptr(((argb>>16)&uint32_t(0xff)))*4))++
- *(*int32)(unsafe.Pointer((histo_argb + 2*1024) + uintptr(((argb>>8)&uint32_t(0xff)))*4))++
- *(*int32)(unsafe.Pointer((histo_argb + 3*1024) + uintptr((argb&uint32_t(0xff)))*4))++
+ *(*int32)(unsafe.Pointer(histo_argb + uintptr(argb>>24)*4))++
+ *(*int32)(unsafe.Pointer(histo_argb + 1*1024 + uintptr(argb>>16&uint32_t(0xff))*4))++
+ *(*int32)(unsafe.Pointer(histo_argb + 2*1024 + uintptr(argb>>8&uint32_t(0xff))*4))++
+ *(*int32)(unsafe.Pointer(histo_argb + 3*1024 + uintptr(argb&uint32_t(0xff))*4))++
}
//------------------------------------------------------------------------------
@@ -31798,7 +31500,7 @@ func PredictBatch(tls *libc.TLS, mode int32, x_start int32, y int32, num_pixels
// ARGB_BLACK.
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LPredictorsSub[0]})).f(tls, current, (uintptr(0)), 1, out)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LPredictorsSub[0]})).f(tls, current, uintptr(0), 1, out)
} else {
// Top one.
(*struct {
@@ -31813,11 +31515,11 @@ func PredictBatch(tls *libc.TLS, mode int32, x_start int32, y int32, num_pixels
// Left one.
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LPredictorsSub[1]})).f(tls, (current + uintptr(x_start)*4), (uintptr(0)), num_pixels, out)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LPredictorsSub[1]})).f(tls, current+uintptr(x_start)*4, uintptr(0), num_pixels, out)
} else {
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LPredictorsSub[mode]})).f(tls, (current + uintptr(x_start)*4), (upper + uintptr(x_start)*4), num_pixels,
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LPredictorsSub[mode]})).f(tls, current+uintptr(x_start)*4, upper+uintptr(x_start)*4, num_pixels,
out)
}
}
@@ -31830,10 +31532,10 @@ func GetMax(tls *libc.TLS, a int32, b int32) int32 { /* predictor_enc.c:93:24: *
}
func MaxDiffBetweenPixels(tls *libc.TLS, p1 uint32_t, p2 uint32_t) int32 { /* predictor_enc.c:95:12: */
- var diff_a int32 = libc.Xabs(tls, ((int32(p1 >> 24)) - (int32(p2 >> 24))))
- var diff_r int32 = libc.Xabs(tls, ((int32((p1 >> 16) & uint32_t(0xff))) - (int32((p2 >> 16) & uint32_t(0xff)))))
- var diff_g int32 = libc.Xabs(tls, ((int32((p1 >> 8) & uint32_t(0xff))) - (int32((p2 >> 8) & uint32_t(0xff)))))
- var diff_b int32 = libc.Xabs(tls, ((int32(p1 & uint32_t(0xff))) - (int32(p2 & uint32_t(0xff)))))
+ var diff_a int32 = libc.Xabs(tls, int32(p1>>24)-int32(p2>>24))
+ var diff_r int32 = libc.Xabs(tls, int32(p1>>16&uint32_t(0xff))-int32(p2>>16&uint32_t(0xff)))
+ var diff_g int32 = libc.Xabs(tls, int32(p1>>8&uint32_t(0xff))-int32(p2>>8&uint32_t(0xff)))
+ var diff_b int32 = libc.Xabs(tls, int32(p1&uint32_t(0xff))-int32(p2&uint32_t(0xff)))
return GetMax(tls, GetMax(tls, diff_a, diff_r), GetMax(tls, diff_g, diff_b))
}
@@ -31846,11 +31548,11 @@ func MaxDiffAroundPixel(tls *libc.TLS, current uint32_t, up uint32_t, down uint3
}
func AddGreenToBlueAndRed(tls *libc.TLS, argb uint32_t) uint32_t { /* predictor_enc.c:112:17: */
- var green uint32_t = ((argb >> 8) & uint32_t(0xff))
- var red_blue uint32_t = (argb & 0x00ff00ff)
- red_blue = red_blue + ((green << 16) | green)
- red_blue = red_blue & (0x00ff00ff)
- return ((argb & 0xff00ff00) | red_blue)
+ var green uint32_t = argb >> 8 & uint32_t(0xff)
+ var red_blue uint32_t = argb & 0x00ff00ff
+ red_blue = red_blue + (green<<16 | green)
+ red_blue = red_blue & 0x00ff00ff
+ return argb&0xff00ff00 | red_blue
}
func MaxDiffsForRow(tls *libc.TLS, width int32, stride int32, argb uintptr, max_diffs uintptr, used_subtract_green int32) { /* predictor_enc.c:120:13: */
@@ -31870,12 +31572,12 @@ func MaxDiffsForRow(tls *libc.TLS, width int32, stride int32, argb uintptr, max_
right = AddGreenToBlueAndRed(tls, right)
}
// max_diffs[0] and max_diffs[width - 1] are never used.
- for x = 1; x < (width - 1); x++ {
- up = *(*uint32_t)(unsafe.Pointer(argb + uintptr((-stride+x))*4))
- down = *(*uint32_t)(unsafe.Pointer(argb + uintptr((stride+x))*4))
+ for x = 1; x < width-1; x++ {
+ up = *(*uint32_t)(unsafe.Pointer(argb + uintptr(-stride+x)*4))
+ down = *(*uint32_t)(unsafe.Pointer(argb + uintptr(stride+x)*4))
left = current
current = right
- right = *(*uint32_t)(unsafe.Pointer(argb + uintptr((x+1))*4))
+ right = *(*uint32_t)(unsafe.Pointer(argb + uintptr(x+1)*4))
if used_subtract_green != 0 {
up = AddGreenToBlueAndRed(tls, up)
down = AddGreenToBlueAndRed(tls, down)
@@ -31889,37 +31591,37 @@ func MaxDiffsForRow(tls *libc.TLS, width int32, stride int32, argb uintptr, max_
// to a multiple of quantization, working modulo 256, taking care not to cross
// a boundary (inclusive upper limit).
func NearLosslessComponent(tls *libc.TLS, value uint8_t, predict uint8_t, boundary uint8_t, quantization int32) uint8_t { /* predictor_enc.c:150:16: */
- var residual int32 = ((int32(value) - int32(predict)) & 0xff)
- var boundary_residual int32 = ((int32(boundary) - int32(predict)) & 0xff)
- var lower int32 = (residual & ^(quantization - 1))
- var upper int32 = (lower + quantization)
+ var residual int32 = (int32(value) - int32(predict)) & 0xff
+ var boundary_residual int32 = (int32(boundary) - int32(predict)) & 0xff
+ var lower int32 = residual & ^(quantization - 1)
+ var upper int32 = lower + quantization
// Resolve ties towards a value closer to the prediction (i.e. towards lower
// if value comes after prediction and towards upper otherwise).
- var bias int32 = (libc.Bool32(((int32(boundary) - int32(value)) & 0xff) < boundary_residual))
- if (residual - lower) < ((upper - residual) + bias) {
+ var bias int32 = libc.Bool32((int32(boundary)-int32(value))&0xff < boundary_residual)
+ if residual-lower < upper-residual+bias {
// lower is closer to residual than upper.
- if (residual > boundary_residual) && (lower <= boundary_residual) {
+ if residual > boundary_residual && lower <= boundary_residual {
// Halve quantization step to avoid crossing boundary. This midpoint is
// on the same side of boundary as residual because midpoint >= residual
// (since lower is closer than upper) and residual is above the boundary.
- return (uint8_t(lower + (quantization >> 1)))
+ return uint8_t(lower + quantization>>1)
}
return uint8_t(lower)
} else {
// upper is closer to residual than lower.
- if (residual <= boundary_residual) && (upper > boundary_residual) {
+ if residual <= boundary_residual && upper > boundary_residual {
// Halve quantization step to avoid crossing boundary. This midpoint is
// on the same side of boundary as residual because midpoint <= residual
// (since upper is closer than lower) and residual is below the boundary.
- return (uint8_t(lower + (quantization >> 1)))
+ return uint8_t(lower + quantization>>1)
}
- return (uint8_t(upper & 0xff))
+ return uint8_t(upper & 0xff)
}
return uint8_t(0)
}
func NearLosslessDiff(tls *libc.TLS, a uint8_t, b uint8_t) uint8_t { /* predictor_enc.c:180:28: */
- return (uint8_t(((int32(a)) - (int32(b))) & 0xff))
+ return uint8_t((int32(a) - int32(b)) & 0xff)
}
// Quantize every component of the difference between the actual pixel value and
@@ -31942,29 +31644,29 @@ func NearLossless1(tls *libc.TLS, value uint32_t, predict uint32_t, max_quantiza
for quantization >= max_diff {
quantization >>= 1
}
- if ((value >> 24) == uint32_t(0)) || ((value >> 24) == uint32_t(0xff)) {
+ if value>>24 == uint32_t(0) || value>>24 == uint32_t(0xff) {
// Preserve transparency of fully transparent or fully opaque pixels.
- a = NearLosslessDiff(tls, (uint8((value >> 24) & uint32_t(0xff))), (uint8((predict >> 24) & uint32_t(0xff))))
+ a = NearLosslessDiff(tls, uint8(value>>24&uint32_t(0xff)), uint8(predict>>24&uint32_t(0xff)))
} else {
- a = NearLosslessComponent(tls, (uint8(value >> 24)), (uint8(predict >> 24)), uint8(0xff), quantization)
+ a = NearLosslessComponent(tls, uint8(value>>24), uint8(predict>>24), uint8(0xff), quantization)
}
- g = NearLosslessComponent(tls, (uint8((value >> 8) & uint32_t(0xff))), (uint8((predict >> 8) & uint32_t(0xff))), uint8(0xff),
+ g = NearLosslessComponent(tls, uint8(value>>8&uint32_t(0xff)), uint8(predict>>8&uint32_t(0xff)), uint8(0xff),
quantization)
if used_subtract_green != 0 {
// The green offset will be added to red and blue components during decoding
// to obtain the actual red and blue values.
- new_green = (uint8_t(((predict >> 8) + uint32_t(g)) & uint32_t(0xff)))
+ new_green = uint8_t((predict>>8 + uint32_t(g)) & uint32_t(0xff))
// The amount by which green has been adjusted during quantization. It is
// subtracted from red and blue for compensation, to avoid accumulating two
// quantization errors in them.
- green_diff = NearLosslessDiff(tls, new_green, (uint8((value >> 8) & uint32_t(0xff))))
+ green_diff = NearLosslessDiff(tls, new_green, uint8(value>>8&uint32_t(0xff)))
}
- r = NearLosslessComponent(tls, NearLosslessDiff(tls, (uint8((value>>16)&uint32_t(0xff))), green_diff),
- (uint8((predict >> 16) & uint32_t(0xff))), (uint8(0xff - int32(new_green))),
+ r = NearLosslessComponent(tls, NearLosslessDiff(tls, uint8(value>>16&uint32_t(0xff)), green_diff),
+ uint8(predict>>16&uint32_t(0xff)), uint8(0xff-int32(new_green)),
quantization)
- b = NearLosslessComponent(tls, NearLosslessDiff(tls, (uint8(value&uint32_t(0xff))), green_diff),
- (uint8(predict & uint32_t(0xff))), (uint8(0xff - int32(new_green))), quantization)
- return ((((uint32_t(a) << 24) | (uint32_t(r) << 16)) | (uint32_t(g) << 8)) | uint32_t(b))
+ b = NearLosslessComponent(tls, NearLosslessDiff(tls, uint8(value&uint32_t(0xff)), green_diff),
+ uint8(predict&uint32_t(0xff)), uint8(0xff-int32(new_green)), quantization)
+ return uint32_t(a)<<24 | uint32_t(r)<<16 | uint32_t(g)<<8 | uint32_t(b)
}
// Stores the difference between the pixel and its prediction in "out".
@@ -31973,7 +31675,7 @@ func NearLossless1(tls *libc.TLS, value uint32_t, predict uint32_t, max_quantiza
// predictions.
func GetResidual(tls *libc.TLS, width int32, height int32, upper_row uintptr, current_row uintptr, max_diffs uintptr, mode int32, x_start int32, x_end int32, y int32, max_quantization int32, exact int32, used_subtract_green int32, out uintptr) { /* predictor_enc.c:233:25: */
if exact != 0 {
- PredictBatch(tls, mode, x_start, y, (x_end - x_start), current_row, upper_row,
+ PredictBatch(tls, mode, x_start, y, x_end-x_start, current_row, upper_row,
out)
} else {
var pred_func VP8LPredictorFunc = VP8LPredictors[mode]
@@ -31985,16 +31687,16 @@ func GetResidual(tls *libc.TLS, width int32, height int32, upper_row uintptr, cu
if x == 0 {
predict = 0xff000000
} else {
- predict = *(*uint32_t)(unsafe.Pointer(current_row + uintptr((x-1))*4))
+ predict = *(*uint32_t)(unsafe.Pointer(current_row + uintptr(x-1)*4))
} // Left.
} else if x == 0 {
predict = *(*uint32_t)(unsafe.Pointer(upper_row + uintptr(x)*4)) // Top.
} else {
predict = (*struct {
f func(*libc.TLS, uintptr, uintptr) uint32_t
- })(unsafe.Pointer(&struct{ uintptr }{pred_func})).f(tls, (current_row + uintptr((x-1))*4), (upper_row + uintptr(x)*4))
+ })(unsafe.Pointer(&struct{ uintptr }{pred_func})).f(tls, current_row+uintptr(x-1)*4, upper_row+uintptr(x)*4)
}
- if (((((max_quantization == 1) || (mode == 0)) || (y == 0)) || (y == (height - 1))) || (x == 0)) || (x == (width - 1)) {
+ if max_quantization == 1 || mode == 0 || y == 0 || y == height-1 || x == 0 || x == width-1 {
residual = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(current_row + uintptr(x)*4)), predict)
} else {
residual = NearLossless1(tls, *(*uint32_t)(unsafe.Pointer(current_row + uintptr(x)*4)), predict, max_quantization,
@@ -32003,25 +31705,25 @@ func GetResidual(tls *libc.TLS, width int32, height int32, upper_row uintptr, cu
*(*uint32_t)(unsafe.Pointer(current_row + uintptr(x)*4)) = VP8LAddPixels(tls, predict, residual)
// x is never 0 here so we do not need to update upper_row like below.
}
- if (*(*uint32_t)(unsafe.Pointer(current_row + uintptr(x)*4)) & kMaskAlpha) == uint32_t(0) {
+ if *(*uint32_t)(unsafe.Pointer(current_row + uintptr(x)*4))&kMaskAlpha == uint32_t(0) {
// If alpha is 0, cleanup RGB. We can choose the RGB values of the
// residual for best compression. The prediction of alpha itself can be
// non-zero and must be kept though. We choose RGB of the residual to be
// 0.
- residual = residual & (kMaskAlpha)
+ residual = residual & kMaskAlpha
// Update the source image.
- *(*uint32_t)(unsafe.Pointer(current_row + uintptr(x)*4)) = (predict & ^kMaskAlpha)
+ *(*uint32_t)(unsafe.Pointer(current_row + uintptr(x)*4)) = predict & ^kMaskAlpha
// The prediction for the rightmost pixel in a row uses the leftmost
// pixel
// in that row as its top-right context pixel. Hence if we change the
// leftmost pixel of current_row, the corresponding change must be
// applied
// to upper_row as well where top-right context is being read from.
- if (x == 0) && (y != 0) {
+ if x == 0 && y != 0 {
*(*uint32_t)(unsafe.Pointer(upper_row + uintptr(width)*4)) = *(*uint32_t)(unsafe.Pointer(current_row))
}
}
- *(*uint32_t)(unsafe.Pointer(out + uintptr((x-x_start))*4)) = residual
+ *(*uint32_t)(unsafe.Pointer(out + uintptr(x-x_start)*4)) = residual
}
}
}
@@ -32036,28 +31738,28 @@ func GetBestPredictorForTile(tls *libc.TLS, width int32, height int32, tile_x in
defer tls.Free(8448)
var kNumPredModes int32 = 14
- var start_x int32 = (tile_x << bits)
- var start_y int32 = (tile_y << bits)
- var tile_size int32 = (int32(1) << bits)
- var max_y int32 = GetMin(tls, tile_size, (height - start_y))
- var max_x int32 = GetMin(tls, tile_size, (width - start_x))
+ var start_x int32 = tile_x << bits
+ var start_y int32 = tile_y << bits
+ var tile_size int32 = int32(1) << bits
+ var max_y int32 = GetMin(tls, tile_size, height-start_y)
+ var max_x int32 = GetMin(tls, tile_size, width-start_x)
// Whether there exist columns just outside the tile.
- var have_left int32 = (libc.Bool32(start_x > 0))
+ var have_left int32 = libc.Bool32(start_x > 0)
// Position and size of the strip covering the tile and adjacent columns if
// they exist.
- var context_start_x int32 = (start_x - have_left)
- var context_width int32 = ((max_x + have_left) + (libc.Bool32(max_x < (width - start_x))))
+ var context_start_x int32 = start_x - have_left
+ var context_width int32 = max_x + have_left + libc.Bool32(max_x < width-start_x)
var tiles_per_row int32 = int32(VP8LSubSampleSize(tls, uint32(width), uint32(bits)))
// Prediction modes of the left and above neighbor tiles.
var left_mode int32
if tile_x > 0 {
- left_mode = (int32((*(*uint32_t)(unsafe.Pointer(modes + uintptr((((tile_y*tiles_per_row)+tile_x)-1))*4)) >> 8) & uint32_t(0xff)))
+ left_mode = int32(*(*uint32_t)(unsafe.Pointer(modes + uintptr(tile_y*tiles_per_row+tile_x-1)*4)) >> 8 & uint32_t(0xff))
} else {
left_mode = 0xff
}
var above_mode int32
if tile_y > 0 {
- above_mode = (int32((*(*uint32_t)(unsafe.Pointer(modes + uintptr((((tile_y-1)*tiles_per_row)+tile_x))*4)) >> 8) & uint32_t(0xff)))
+ above_mode = int32(*(*uint32_t)(unsafe.Pointer(modes + uintptr((tile_y-1)*tiles_per_row+tile_x)*4)) >> 8 & uint32_t(0xff))
} else {
above_mode = 0xff
}
@@ -32065,9 +31767,9 @@ func GetBestPredictorForTile(tls *libc.TLS, width int32, height int32, tile_x in
// to allow the top right pixel to point to the leftmost pixel of the next row
// when at the right edge.
var upper_row uintptr = argb_scratch
- var current_row uintptr = ((upper_row + uintptr(width)*4) + uintptr(1)*4)
- var max_diffs uintptr = ((current_row + uintptr(width)*4) + uintptr(1)*4)
- var best_diff float32 = (1e30)
+ var current_row uintptr = upper_row + uintptr(width)*4 + uintptr(1)*4
+ var max_diffs uintptr = current_row + uintptr(width)*4 + uintptr(1)*4
+ var best_diff float32 = 1e30
var best_mode int32 = 0
var mode int32
// var histo_stack_1 [4][256]int32 at bp, 4096
@@ -32075,8 +31777,8 @@ func GetBestPredictorForTile(tls *libc.TLS, width int32, height int32, tile_x in
// var histo_stack_2 [4][256]int32 at bp+4096, 4096
// Need pointers to be able to swap arrays.
- var histo_argb uintptr = (bp) /* histo_stack_1 */
- var best_histo uintptr = (bp + 4096) /* histo_stack_2 */
+ var histo_argb uintptr = bp /* histo_stack_1 */
+ var best_histo uintptr = bp + 4096 /* histo_stack_2 */
var i int32
var j int32
// var residuals [64]uint32_t at bp+8192, 256
@@ -32090,12 +31792,12 @@ func GetBestPredictorForTile(tls *libc.TLS, width int32, height int32, tile_x in
// Include a pixel to the left if it exists; include a pixel to the right
// in all cases (wrapping to the leftmost pixel of the next row if it does
// not exist).
- libc.Xmemcpy(tls, (current_row + uintptr(context_start_x)*4),
- ((argb + uintptr(((start_y-1)*width))*4) + uintptr(context_start_x)*4),
- (uint64(unsafe.Sizeof(uint32_t(0))) * (uint64((max_x + have_left) + 1))))
+ libc.Xmemcpy(tls, current_row+uintptr(context_start_x)*4,
+ argb+uintptr((start_y-1)*width)*4+uintptr(context_start_x)*4,
+ uint64(unsafe.Sizeof(uint32_t(0)))*uint64(max_x+have_left+1))
}
for relative_y = 0; relative_y < max_y; relative_y++ {
- var y int32 = (start_y + relative_y)
+ var y int32 = start_y + relative_y
var relative_x int32
var tmp uintptr = upper_row
upper_row = current_row
@@ -32104,29 +31806,29 @@ func GetBestPredictorForTile(tls *libc.TLS, width int32, height int32, tile_x in
// pixel to the right in all cases except at the bottom right corner of
// the image (wrapping to the leftmost pixel of the next row if it does
// not exist in the current row).
- libc.Xmemcpy(tls, (current_row + uintptr(context_start_x)*4),
- ((argb + uintptr((y*width))*4) + uintptr(context_start_x)*4),
- (uint64(unsafe.Sizeof(uint32_t(0))) * (uint64((max_x + have_left) + (libc.Bool32((y + 1) < height))))))
- if ((max_quantization > 1) && (y >= 1)) && ((y + 1) < height) {
- MaxDiffsForRow(tls, context_width, width, ((argb + uintptr((y*width))*4) + uintptr(context_start_x)*4),
- (max_diffs + uintptr(context_start_x)), used_subtract_green)
+ libc.Xmemcpy(tls, current_row+uintptr(context_start_x)*4,
+ argb+uintptr(y*width)*4+uintptr(context_start_x)*4,
+ uint64(unsafe.Sizeof(uint32_t(0)))*uint64(max_x+have_left+libc.Bool32(y+1 < height)))
+ if max_quantization > 1 && y >= 1 && y+1 < height {
+ MaxDiffsForRow(tls, context_width, width, argb+uintptr(y*width)*4+uintptr(context_start_x)*4,
+ max_diffs+uintptr(context_start_x), used_subtract_green)
}
GetResidual(tls, width, height, upper_row, current_row, max_diffs, mode,
- start_x, (start_x + max_x), y, max_quantization, exact,
- used_subtract_green, (bp + 8192) /* &residuals[0] */)
+ start_x, start_x+max_x, y, max_quantization, exact,
+ used_subtract_green, bp+8192)
for relative_x = 0; relative_x < max_x; relative_x++ {
- UpdateHisto(tls, histo_argb, *(*uint32_t)(unsafe.Pointer((bp + 8192) /* &residuals[0] */ + uintptr(relative_x)*4)))
+ UpdateHisto(tls, histo_argb, *(*uint32_t)(unsafe.Pointer(bp + 8192 + uintptr(relative_x)*4)))
}
}
cur_diff = PredictionCostSpatialHistogram(tls,
accumulated, histo_argb)
// Favor keeping the areas locally similar.
if mode == left_mode {
- cur_diff = cur_diff - (kSpatialPredictorBias)
+ cur_diff = cur_diff - kSpatialPredictorBias
}
if mode == above_mode {
- cur_diff = cur_diff - (kSpatialPredictorBias)
+ cur_diff = cur_diff - kSpatialPredictorBias
}
if cur_diff < best_diff {
@@ -32140,7 +31842,7 @@ func GetBestPredictorForTile(tls *libc.TLS, width int32, height int32, tile_x in
for i = 0; i < 4; i++ {
for j = 0; j < 256; j++ {
- *(*int32)(unsafe.Pointer(((accumulated + uintptr(i)*1024) + uintptr(j)*4))) += (*(*int32)(unsafe.Pointer((best_histo + uintptr(i)*1024) + uintptr(j)*4)))
+ *(*int32)(unsafe.Pointer(accumulated + uintptr(i)*1024 + uintptr(j)*4)) += *(*int32)(unsafe.Pointer(best_histo + uintptr(i)*1024 + uintptr(j)*4))
}
}
@@ -32157,9 +31859,9 @@ func CopyImageWithPrediction(tls *libc.TLS, width int32, height int32, bits int3
// to allow the top right pixel to point to the leftmost pixel of the next row
// when at the right edge.
var upper_row uintptr = argb_scratch
- var current_row uintptr = ((upper_row + uintptr(width)*4) + uintptr(1)*4)
- var current_max_diffs uintptr = ((current_row + uintptr(width)*4) + uintptr(1)*4)
- var lower_max_diffs uintptr = (current_max_diffs + uintptr(width))
+ var current_row uintptr = upper_row + uintptr(width)*4 + uintptr(1)*4
+ var current_max_diffs uintptr = current_row + uintptr(width)*4 + uintptr(1)*4
+ var lower_max_diffs uintptr = current_max_diffs + uintptr(width)
var y int32
for y = 0; y < height; y++ {
@@ -32167,12 +31869,12 @@ func CopyImageWithPrediction(tls *libc.TLS, width int32, height int32, bits int3
var tmp32 uintptr = upper_row
upper_row = current_row
current_row = tmp32
- libc.Xmemcpy(tls, current_row, (argb + uintptr((y*width))*4),
- (uint64(unsafe.Sizeof(uint32_t(0))) * (uint64(width + (libc.Bool32((y + 1) < height))))))
+ libc.Xmemcpy(tls, current_row, argb+uintptr(y*width)*4,
+ uint64(unsafe.Sizeof(uint32_t(0)))*uint64(width+libc.Bool32(y+1 < height)))
if low_effort != 0 {
PredictBatch(tls, kPredLowEffort, 0, y, width, current_row, upper_row,
- (argb + uintptr((y*width))*4))
+ argb+uintptr(y*width)*4)
} else {
if max_quantization > 1 {
// Compute max_diffs for the lower row now, because that needs the
@@ -32181,20 +31883,20 @@ func CopyImageWithPrediction(tls *libc.TLS, width int32, height int32, bits int3
var tmp8 uintptr = current_max_diffs
current_max_diffs = lower_max_diffs
lower_max_diffs = tmp8
- if (y + 2) < height {
- MaxDiffsForRow(tls, width, width, (argb + uintptr(((y+1)*width))*4), lower_max_diffs,
+ if y+2 < height {
+ MaxDiffsForRow(tls, width, width, argb+uintptr((y+1)*width)*4, lower_max_diffs,
used_subtract_green)
}
}
for x = 0; x < width; {
- var mode int32 = (int32((*(*uint32_t)(unsafe.Pointer(modes + uintptr((((y>>bits)*tiles_per_row)+(x>>bits)))*4)) >> 8) & uint32_t(0xff)))
- var x_end int32 = (x + (int32(1) << bits))
+ var mode int32 = int32(*(*uint32_t)(unsafe.Pointer(modes + uintptr(y>>bits*tiles_per_row+x>>bits)*4)) >> 8 & uint32_t(0xff))
+ var x_end int32 = x + int32(1)<<bits
if x_end > width {
x_end = width
}
GetResidual(tls, width, height, upper_row, current_row, current_max_diffs,
mode, x, x_end, y, max_quantization, exact,
- used_subtract_green, ((argb + uintptr((y*width))*4) + uintptr(x)*4))
+ used_subtract_green, argb+uintptr(y*width)*4+uintptr(x)*4)
x = x_end
}
}
@@ -32214,21 +31916,21 @@ func VP8LResidualImage(tls *libc.TLS, width int32, height int32, bits int32, low
var tile_y int32
// var histo [4][256]int32 at bp, 4096
- var max_quantization int32 = (int32(1) << VP8LNearLosslessBits(tls, near_lossless_quality))
+ var max_quantization int32 = int32(1) << VP8LNearLosslessBits(tls, near_lossless_quality)
if low_effort != 0 {
var i int32
- for i = 0; i < (tiles_per_row * tiles_per_col); i++ {
- *(*uint32_t)(unsafe.Pointer(image + uintptr(i)*4)) = (0xff000000 | (uint32(kPredLowEffort << 8)))
+ for i = 0; i < tiles_per_row*tiles_per_col; i++ {
+ *(*uint32_t)(unsafe.Pointer(image + uintptr(i)*4)) = 0xff000000 | uint32(kPredLowEffort<<8)
}
} else {
- libc.Xmemset(tls, (bp) /* &histo[0] */, 0, uint64(unsafe.Sizeof([4][256]int32{})))
+ libc.Xmemset(tls, bp, 0, uint64(unsafe.Sizeof([4][256]int32{})))
for tile_y = 0; tile_y < tiles_per_col; tile_y++ {
var tile_x int32
for tile_x = 0; tile_x < tiles_per_row; tile_x++ {
var pred int32 = GetBestPredictorForTile(tls, width, height, tile_x, tile_y,
- bits, (bp) /* &histo[0] */, argb_scratch, argb, max_quantization, exact,
+ bits, bp, argb_scratch, argb, max_quantization, exact,
used_subtract_green, image)
- *(*uint32_t)(unsafe.Pointer(image + uintptr(((tile_y*tiles_per_row)+tile_x))*4)) = (0xff000000 | (uint32(pred << 8)))
+ *(*uint32_t)(unsafe.Pointer(image + uintptr(tile_y*tiles_per_row+tile_x)*4)) = 0xff000000 | uint32(pred<<8)
}
}
}
@@ -32248,19 +31950,19 @@ func MultipliersClear(tls *libc.TLS, m uintptr) { /* predictor_enc.c:510:25: */
}
func ColorCodeToMultipliers1(tls *libc.TLS, color_code uint32_t, m uintptr) { /* predictor_enc.c:516:25: */
- (*VP8LMultipliers)(unsafe.Pointer(m)).green_to_red_ = (uint8_t((color_code >> 0) & uint32_t(0xff)))
- (*VP8LMultipliers)(unsafe.Pointer(m)).green_to_blue_ = (uint8_t((color_code >> 8) & uint32_t(0xff)))
- (*VP8LMultipliers)(unsafe.Pointer(m)).red_to_blue_ = (uint8_t((color_code >> 16) & uint32_t(0xff)))
+ (*VP8LMultipliers)(unsafe.Pointer(m)).green_to_red_ = uint8_t(color_code >> 0 & uint32_t(0xff))
+ (*VP8LMultipliers)(unsafe.Pointer(m)).green_to_blue_ = uint8_t(color_code >> 8 & uint32_t(0xff))
+ (*VP8LMultipliers)(unsafe.Pointer(m)).red_to_blue_ = uint8_t(color_code >> 16 & uint32_t(0xff))
}
func MultipliersToColorCode(tls *libc.TLS, m uintptr) uint32_t { /* predictor_enc.c:523:29: */
- return (((0xff000000 | ((uint32_t((*VP8LMultipliers)(unsafe.Pointer(m)).red_to_blue_)) << 16)) | ((uint32_t((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_blue_)) << 8)) | uint32((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_red_))
+ return 0xff000000 | uint32_t((*VP8LMultipliers)(unsafe.Pointer(m)).red_to_blue_)<<16 | uint32_t((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_blue_)<<8 | uint32((*VP8LMultipliers)(unsafe.Pointer(m)).green_to_red_)
}
func PredictionCostCrossColor(tls *libc.TLS, accumulated uintptr, counts uintptr) float32 { /* predictor_enc.c:531:14: */
- return ((*struct {
+ return (*struct {
f func(*libc.TLS, uintptr, uintptr) float32
- })(unsafe.Pointer(&struct{ uintptr }{VP8LCombinedShannonEntropy})).f(tls, counts, accumulated) + PredictionCostSpatial(tls, counts, 3, kExpValue))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LCombinedShannonEntropy})).f(tls, counts, accumulated) + PredictionCostSpatial(tls, counts, 3, kExpValue)
}
var kExpValue float64 = 2.4 /* predictor_enc.c:535:23 */
@@ -32275,23 +31977,23 @@ func GetPredictionCostCrossColorRed(tls *libc.TLS, argb uintptr, stride int32, t
(*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, int32, uintptr)
})(unsafe.Pointer(&struct{ uintptr }{VP8LCollectColorRedTransforms})).f(tls, argb, stride, tile_width, tile_height,
- green_to_red, (bp) /* &histo[0] */)
+ green_to_red, bp /* &histo[0] */)
- cur_diff = PredictionCostCrossColor(tls, accumulated_red_histo, (bp) /* &histo[0] */)
+ cur_diff = PredictionCostCrossColor(tls, accumulated_red_histo, bp)
if int32(uint8_t(green_to_red)) == int32(prev_x.green_to_red_) {
- cur_diff = cur_diff - (float32(3)) // favor keeping the areas locally similar
+ cur_diff = cur_diff - float32(3) // favor keeping the areas locally similar
}
if int32(uint8_t(green_to_red)) == int32(prev_y.green_to_red_) {
- cur_diff = cur_diff - (float32(3)) // favor keeping the areas locally similar
+ cur_diff = cur_diff - float32(3) // favor keeping the areas locally similar
}
if green_to_red == 0 {
- cur_diff = cur_diff - (float32(3))
+ cur_diff = cur_diff - float32(3)
}
return cur_diff
}
func GetBestGreenToRed(tls *libc.TLS, argb uintptr, stride int32, tile_width int32, tile_height int32, prev_x VP8LMultipliers, prev_y VP8LMultipliers, quality int32, accumulated_red_histo uintptr, best_tx uintptr) { /* predictor_enc.c:563:13: */
- var kMaxIters int32 = (4 + ((7 * quality) >> 8)) // in range [4..6]
+ var kMaxIters int32 = 4 + 7*quality>>8 // in range [4..6]
var green_to_red_best int32 = 0
var iter int32
var offset int32
@@ -32302,10 +32004,10 @@ func GetBestGreenToRed(tls *libc.TLS, argb uintptr, stride int32, tile_width int
// ColorTransformDelta is a 3.5 bit fixed point, so 32 is equal to
// one in color computation. Having initial delta here as 1 is sufficient
// to explore the range of (-2, 2).
- var delta int32 = (int32(32) >> iter)
+ var delta int32 = int32(32) >> iter
// Try a negative and a positive delta from the best known value.
- for offset = -delta; offset <= delta; offset = offset + (2 * delta) {
- var green_to_red_cur int32 = (offset + green_to_red_best)
+ for offset = -delta; offset <= delta; offset = offset + 2*delta {
+ var green_to_red_cur int32 = offset + green_to_red_best
var cur_diff float32 = GetPredictionCostCrossColorRed(tls,
argb, stride, tile_width, tile_height, prev_x, prev_y,
green_to_red_cur, accumulated_red_histo)
@@ -32315,7 +32017,7 @@ func GetBestGreenToRed(tls *libc.TLS, argb uintptr, stride int32, tile_width int
}
}
}
- (*VP8LMultipliers)(unsafe.Pointer(best_tx)).green_to_red_ = (uint8_t(green_to_red_best & 0xff))
+ (*VP8LMultipliers)(unsafe.Pointer(best_tx)).green_to_red_ = uint8_t(green_to_red_best & 0xff)
}
func GetPredictionCostCrossColorBlue(tls *libc.TLS, argb uintptr, stride int32, tile_width int32, tile_height int32, prev_x VP8LMultipliers, prev_y VP8LMultipliers, green_to_blue int32, red_to_blue int32, accumulated_blue_histo uintptr) float32 { /* predictor_enc.c:593:14: */
@@ -32328,26 +32030,26 @@ func GetPredictionCostCrossColorBlue(tls *libc.TLS, argb uintptr, stride int32,
(*struct {
f func(*libc.TLS, uintptr, int32, int32, int32, int32, int32, uintptr)
})(unsafe.Pointer(&struct{ uintptr }{VP8LCollectColorBlueTransforms})).f(tls, argb, stride, tile_width, tile_height,
- green_to_blue, red_to_blue, (bp) /* &histo[0] */)
+ green_to_blue, red_to_blue, bp /* &histo[0] */)
- cur_diff = PredictionCostCrossColor(tls, accumulated_blue_histo, (bp) /* &histo[0] */)
+ cur_diff = PredictionCostCrossColor(tls, accumulated_blue_histo, bp)
if int32(uint8_t(green_to_blue)) == int32(prev_x.green_to_blue_) {
- cur_diff = cur_diff - (float32(3)) // favor keeping the areas locally similar
+ cur_diff = cur_diff - float32(3) // favor keeping the areas locally similar
}
if int32(uint8_t(green_to_blue)) == int32(prev_y.green_to_blue_) {
- cur_diff = cur_diff - (float32(3)) // favor keeping the areas locally similar
+ cur_diff = cur_diff - float32(3) // favor keeping the areas locally similar
}
if int32(uint8_t(red_to_blue)) == int32(prev_x.red_to_blue_) {
- cur_diff = cur_diff - (float32(3)) // favor keeping the areas locally similar
+ cur_diff = cur_diff - float32(3) // favor keeping the areas locally similar
}
if int32(uint8_t(red_to_blue)) == int32(prev_y.red_to_blue_) {
- cur_diff = cur_diff - (float32(3)) // favor keeping the areas locally similar
+ cur_diff = cur_diff - float32(3) // favor keeping the areas locally similar
}
if green_to_blue == 0 {
- cur_diff = cur_diff - (float32(3))
+ cur_diff = cur_diff - float32(3)
}
if red_to_blue == 0 {
- cur_diff = cur_diff - (float32(3))
+ cur_diff = cur_diff - float32(3)
}
return cur_diff
}
@@ -32357,7 +32059,7 @@ func GetBestGreenRedToBlue(tls *libc.TLS, argb uintptr, stride int32, tile_width
defer tls.Free(23)
*(*[8][2]int8_t)(unsafe.Pointer(bp + 7 /* offset */)) =
- [8][2]int8_t{[2]int8_t{int8(0), int8(-1)}, [2]int8_t{int8(0), int8(1)}, [2]int8_t{int8(-1), int8(0)}, [2]int8_t{int8(1), int8(0)}, [2]int8_t{int8(-1), int8(-1)}, [2]int8_t{int8(-1), int8(1)}, [2]int8_t{int8(1), int8(-1)}, [2]int8_t{int8(1), int8(1)}}
+ [8][2]int8_t{{int8(0), int8(-1)}, {int8(0), int8(1)}, {int8(-1), int8(0)}, {int8(1), int8(0)}, {int8(-1), int8(-1)}, {int8(-1), int8(1)}, {int8(1), int8(-1)}, {int8(1), int8(1)}}
*(*[7]int8_t)(unsafe.Pointer(bp /* delta_lut */)) = [7]int8_t{int8(16), int8(16), int8(8), int8(4), int8(2), int8(2), int8(2)}
var iters int32
if quality < 25 {
@@ -32377,11 +32079,11 @@ func GetBestGreenRedToBlue(tls *libc.TLS, argb uintptr, stride int32, tile_width
argb, stride, tile_width, tile_height, prev_x, prev_y,
green_to_blue_best, red_to_blue_best, accumulated_blue_histo)
for iter = 0; iter < iters; iter++ {
- var delta int32 = int32(*(*int8_t)(unsafe.Pointer((bp) /* &delta_lut[0] */ + uintptr(iter))))
+ var delta int32 = int32(*(*int8_t)(unsafe.Pointer(bp + uintptr(iter))))
var axis int32
for axis = 0; axis < 8; axis++ {
- var green_to_blue_cur int32 = ((int32(*(*int8_t)(unsafe.Pointer(((bp + 7) /* &offset[0] */ + uintptr(axis)*2)))) * delta) + green_to_blue_best)
- var red_to_blue_cur int32 = ((int32(*(*int8_t)(unsafe.Pointer(((bp + 7) /* &offset[0] */ + uintptr(axis)*2) + 1))) * delta) + red_to_blue_best)
+ var green_to_blue_cur int32 = int32(*(*int8_t)(unsafe.Pointer(bp + 7 + uintptr(axis)*2)))*delta + green_to_blue_best
+ var red_to_blue_cur int32 = int32(*(*int8_t)(unsafe.Pointer(bp + 7 + uintptr(axis)*2 + 1)))*delta + red_to_blue_best
var cur_diff float32 = GetPredictionCostCrossColorBlue(tls,
argb, stride, tile_width, tile_height, prev_x, prev_y,
green_to_blue_cur, red_to_blue_cur, accumulated_blue_histo)
@@ -32390,42 +32092,42 @@ func GetBestGreenRedToBlue(tls *libc.TLS, argb uintptr, stride int32, tile_width
green_to_blue_best = green_to_blue_cur
red_to_blue_best = red_to_blue_cur
}
- if (quality < 25) && (iter == 4) {
+ if quality < 25 && iter == 4 {
// Only axis aligned diffs for lower quality.
break // next iter.
}
}
- if ((delta == 2) && (green_to_blue_best == 0)) && (red_to_blue_best == 0) {
+ if delta == 2 && green_to_blue_best == 0 && red_to_blue_best == 0 {
// Further iterations would not help.
break // out of iter-loop.
}
}
- (*VP8LMultipliers)(unsafe.Pointer(best_tx)).green_to_blue_ = (uint8_t(green_to_blue_best & 0xff))
- (*VP8LMultipliers)(unsafe.Pointer(best_tx)).red_to_blue_ = (uint8_t(red_to_blue_best & 0xff))
+ (*VP8LMultipliers)(unsafe.Pointer(best_tx)).green_to_blue_ = uint8_t(green_to_blue_best & 0xff)
+ (*VP8LMultipliers)(unsafe.Pointer(best_tx)).red_to_blue_ = uint8_t(red_to_blue_best & 0xff)
}
func GetBestColorTransformForTile(tls *libc.TLS, tile_x int32, tile_y int32, bits int32, prev_x VP8LMultipliers, prev_y VP8LMultipliers, quality int32, xsize int32, ysize int32, accumulated_red_histo uintptr, accumulated_blue_histo uintptr, argb uintptr) VP8LMultipliers { /* predictor_enc.c:675:24: */
bp := tls.Alloc(3)
defer tls.Free(3)
- var max_tile_size int32 = (int32(1) << bits)
- var tile_y_offset int32 = (tile_y * max_tile_size)
- var tile_x_offset int32 = (tile_x * max_tile_size)
- var all_x_max int32 = GetMin(tls, (tile_x_offset + max_tile_size), xsize)
- var all_y_max int32 = GetMin(tls, (tile_y_offset + max_tile_size), ysize)
- var tile_width int32 = (all_x_max - tile_x_offset)
- var tile_height int32 = (all_y_max - tile_y_offset)
- var tile_argb uintptr = ((argb + uintptr((tile_y_offset*xsize))*4) +
- uintptr(tile_x_offset)*4)
- // var best_tx VP8LMultipliers at bp, 3
+ var max_tile_size int32 = int32(1) << bits
+ var tile_y_offset int32 = tile_y * max_tile_size
+ var tile_x_offset int32 = tile_x * max_tile_size
+ var all_x_max int32 = GetMin(tls, tile_x_offset+max_tile_size, xsize)
+ var all_y_max int32 = GetMin(tls, tile_y_offset+max_tile_size, ysize)
+ var tile_width int32 = all_x_max - tile_x_offset
+ var tile_height int32 = all_y_max - tile_y_offset
+ var tile_argb uintptr = argb + uintptr(tile_y_offset*xsize)*4 +
+ uintptr(tile_x_offset)*4
+ // var best_tx VP8LMultipliers at bp, 3
- MultipliersClear(tls, (bp) /* &best_tx */)
+ MultipliersClear(tls, bp)
GetBestGreenToRed(tls, tile_argb, xsize, tile_width, tile_height,
- prev_x, prev_y, quality, accumulated_red_histo, (bp) /* &best_tx */)
+ prev_x, prev_y, quality, accumulated_red_histo, bp)
GetBestGreenRedToBlue(tls, tile_argb, xsize, tile_width, tile_height,
prev_x, prev_y, quality, accumulated_blue_histo,
- (bp) /* &best_tx */)
+ bp)
return *(*VP8LMultipliers)(unsafe.Pointer(bp /* best_tx */))
}
@@ -32434,14 +32136,14 @@ func CopyTileWithColorTransform(tls *libc.TLS, xsize int32, ysize int32, tile_x
defer tls.Free(3)
*(*VP8LMultipliers)(unsafe.Pointer(bp)) = color_transform
- var xscan int32 = GetMin(tls, max_tile_size, (xsize - tile_x))
- var yscan int32 = GetMin(tls, max_tile_size, (ysize - tile_y))
- argb += 4 * (uintptr((tile_y * xsize) + tile_x))
+ var xscan int32 = GetMin(tls, max_tile_size, xsize-tile_x)
+ var yscan int32 = GetMin(tls, max_tile_size, ysize-tile_y)
+ argb += 4 * uintptr(tile_y*xsize+tile_x)
for libc.PostDecInt32(&yscan, 1) > 0 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LTransformColor})).f(tls, (bp) /* &color_transform */, argb, xscan)
- argb += 4 * (uintptr(xsize))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LTransformColor})).f(tls, bp /* &color_transform */, argb, xscan)
+ argb += 4 * uintptr(xsize)
}
}
@@ -32449,7 +32151,7 @@ func VP8LColorSpaceTransform(tls *libc.TLS, width int32, height int32, bits int3
bp := tls.Alloc(2056)
defer tls.Free(2056)
- var max_tile_size int32 = (int32(1) << bits)
+ var max_tile_size int32 = int32(1) << bits
var tile_xsize int32 = int32(VP8LSubSampleSize(tls, uint32(width), uint32(bits)))
var tile_ysize int32 = int32(VP8LSubSampleSize(tls, uint32(height), uint32(bits)))
*(*[256]int32)(unsafe.Pointer(bp + 8 /* accumulated_red_histo */)) = [256]int32{0: 0}
@@ -32460,43 +32162,43 @@ func VP8LColorSpaceTransform(tls *libc.TLS, width int32, height int32, bits int3
// var prev_y VP8LMultipliers at bp, 3
- MultipliersClear(tls, (bp) /* &prev_y */)
- MultipliersClear(tls, (bp + 3) /* &prev_x */)
+ MultipliersClear(tls, bp)
+ MultipliersClear(tls, bp+3)
for tile_y = 0; tile_y < tile_ysize; tile_y++ {
for tile_x = 0; tile_x < tile_xsize; tile_x++ {
var y int32
- var tile_x_offset int32 = (tile_x * max_tile_size)
- var tile_y_offset int32 = (tile_y * max_tile_size)
- var all_x_max int32 = GetMin(tls, (tile_x_offset + max_tile_size), width)
- var all_y_max int32 = GetMin(tls, (tile_y_offset + max_tile_size), height)
- var offset int32 = ((tile_y * tile_xsize) + tile_x)
+ var tile_x_offset int32 = tile_x * max_tile_size
+ var tile_y_offset int32 = tile_y * max_tile_size
+ var all_x_max int32 = GetMin(tls, tile_x_offset+max_tile_size, width)
+ var all_y_max int32 = GetMin(tls, tile_y_offset+max_tile_size, height)
+ var offset int32 = tile_y*tile_xsize + tile_x
if tile_y != 0 {
- ColorCodeToMultipliers1(tls, *(*uint32_t)(unsafe.Pointer(image + uintptr((offset-tile_xsize))*4)), (bp) /* &prev_y */)
+ ColorCodeToMultipliers1(tls, *(*uint32_t)(unsafe.Pointer(image + uintptr(offset-tile_xsize)*4)), bp)
}
*(*VP8LMultipliers)(unsafe.Pointer(bp + 3 /* prev_x */)) = GetBestColorTransformForTile(tls, tile_x, tile_y, bits,
*(*VP8LMultipliers)(unsafe.Pointer(bp + 3 /* prev_x */)), *(*VP8LMultipliers)(unsafe.Pointer(bp /* prev_y */)),
quality, width, height,
- (bp + 8), /* &accumulated_red_histo[0] */
- (bp + 1032), /* &accumulated_blue_histo[0] */
+ bp+8,
+ bp+1032,
argb)
- *(*uint32_t)(unsafe.Pointer(image + uintptr(offset)*4)) = MultipliersToColorCode(tls, (bp + 3) /* &prev_x */)
+ *(*uint32_t)(unsafe.Pointer(image + uintptr(offset)*4)) = MultipliersToColorCode(tls, bp+3)
CopyTileWithColorTransform(tls, width, height, tile_x_offset, tile_y_offset,
max_tile_size, *(*VP8LMultipliers)(unsafe.Pointer(bp + 3 /* prev_x */)), argb)
// Gather accumulated histogram data.
for y = tile_y_offset; y < all_y_max; y++ {
- var ix int32 = ((y * width) + tile_x_offset)
- var ix_end int32 = ((ix + all_x_max) - tile_x_offset)
+ var ix int32 = y*width + tile_x_offset
+ var ix_end int32 = ix + all_x_max - tile_x_offset
for ; ix < ix_end; ix++ {
var pix uint32_t = *(*uint32_t)(unsafe.Pointer(argb + uintptr(ix)*4))
- if ((ix >= 2) && (pix == *(*uint32_t)(unsafe.Pointer(argb + uintptr((ix-2))*4)))) && (pix == *(*uint32_t)(unsafe.Pointer(argb + uintptr((ix-1))*4))) {
+ if ix >= 2 && pix == *(*uint32_t)(unsafe.Pointer(argb + uintptr(ix-2)*4)) && pix == *(*uint32_t)(unsafe.Pointer(argb + uintptr(ix-1)*4)) {
continue // repeated pixels are handled by backward references
}
- if (((ix >= (width + 2)) && (*(*uint32_t)(unsafe.Pointer(argb + uintptr((ix-2))*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr(((ix-width)-2))*4)))) && (*(*uint32_t)(unsafe.Pointer(argb + uintptr((ix-1))*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr(((ix-width)-1))*4)))) && (pix == *(*uint32_t)(unsafe.Pointer(argb + uintptr((ix-width))*4))) {
+ if ix >= width+2 && *(*uint32_t)(unsafe.Pointer(argb + uintptr(ix-2)*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr(ix-width-2)*4)) && *(*uint32_t)(unsafe.Pointer(argb + uintptr(ix-1)*4)) == *(*uint32_t)(unsafe.Pointer(argb + uintptr(ix-width-1)*4)) && pix == *(*uint32_t)(unsafe.Pointer(argb + uintptr(ix-width)*4)) {
continue // repeated pixels are handled by backward references
}
- *(*int32)(unsafe.Pointer((bp + 8) /* &accumulated_red_histo[0] */ + uintptr(((pix>>16)&uint32_t(0xff)))*4))++
- *(*int32)(unsafe.Pointer((bp + 1032) /* &accumulated_blue_histo[0] */ + uintptr(((pix>>0)&uint32_t(0xff)))*4))++
+ *(*int32)(unsafe.Pointer(bp + 8 + uintptr(pix>>16&uint32_t(0xff))*4))++
+ *(*int32)(unsafe.Pointer(bp + 1032 + uintptr(pix>>0&uint32_t(0xff))*4))++
}
}
}
@@ -32521,12 +32223,12 @@ func IsFlat_C(tls *libc.TLS, levels uintptr, num_blocks int32, thresh int32) int
for libc.PostDecInt32(&num_blocks, 1) > 0 { // TODO(skal): refine positional scoring?
var i int32
for i = 1; i < 16; i++ { // omit DC, we're only interested in AC
- score = score + (libc.Bool32(int32(*(*int16_t)(unsafe.Pointer(levels + uintptr(i)*2))) != 0))
+ score = score + libc.Bool32(int32(*(*int16_t)(unsafe.Pointer(levels + uintptr(i)*2))) != 0)
if score > thresh {
return 0
}
}
- levels += 2 * (uintptr(16))
+ levels += 2 * uintptr(16)
}
return 1
}
@@ -32537,10 +32239,10 @@ func IsFlatSource16(tls *libc.TLS, src uintptr) int32 { /* quant.h:72:24: */
bp := tls.Alloc(4)
defer tls.Free(4)
- *(*uint32_t)(unsafe.Pointer(bp /* v */)) = (uint32(*(*uint8_t)(unsafe.Pointer(src))) * 0x01010101)
+ *(*uint32_t)(unsafe.Pointer(bp /* v */)) = uint32(*(*uint8_t)(unsafe.Pointer(src))) * 0x01010101
var i int32
for i = 0; i < 16; i++ {
- if (((libc.Xmemcmp(tls, (src+uintptr(0)), (bp) /* &v */, uint64(4)) != 0) || (libc.Xmemcmp(tls, (src+uintptr(4)), (bp) /* &v */, uint64(4)) != 0)) || (libc.Xmemcmp(tls, (src+uintptr(8)), (bp) /* &v */, uint64(4)) != 0)) || (libc.Xmemcmp(tls, (src+uintptr(12)), (bp) /* &v */, uint64(4)) != 0) {
+ if libc.Xmemcmp(tls, src+uintptr(0), bp, uint64(4)) != 0 || libc.Xmemcmp(tls, src+uintptr(4), bp, uint64(4)) != 0 || libc.Xmemcmp(tls, src+uintptr(8), bp, uint64(4)) != 0 || libc.Xmemcmp(tls, src+uintptr(12), bp, uint64(4)) != 0 {
return 0
}
src += uintptr(32)
@@ -32633,7 +32335,7 @@ var kAcTable2 = [128]uint16_t{
} /* quant_enc.c:172:23 */
var kBiasMatrices = [3][2]uint8_t{ // [luma-ac,luma-dc,chroma][dc,ac]
- [2]uint8_t{uint8_t(96), uint8_t(110)}, [2]uint8_t{uint8_t(96), uint8_t(108)}, [2]uint8_t{uint8_t(110), uint8_t(115)},
+ {uint8_t(96), uint8_t(110)}, {uint8_t(96), uint8_t(108)}, {uint8_t(110), uint8_t(115)},
} /* quant_enc.c:191:22 */
// Sharpening by (slightly) raising the hi-frequency coeffs.
@@ -32653,32 +32355,32 @@ func ExpandMatrix(tls *libc.TLS, m uintptr, type1 int32) int32 { /* quant_enc.c:
var i int32
var sum int32
for i = 0; i < 2; i++ {
- var is_ac_coeff int32 = (libc.Bool32(i > 0))
- var bias int32 = int32(*(*uint8_t)(unsafe.Pointer((uintptr(unsafe.Pointer(&kBiasMatrices)) + uintptr(type1)*2) + uintptr(is_ac_coeff))))
- *(*uint16_t)(unsafe.Pointer((m + 32 /* &.iq_ */) + uintptr(i)*2)) = (uint16_t((int32(1) << 17) / int32(*(*uint16_t)(unsafe.Pointer((m /* &.q_ */) + uintptr(i)*2)))))
- *(*uint32_t)(unsafe.Pointer((m + 64 /* &.bias_ */) + uintptr(i)*4)) = (uint32_t((bias) << (17 - 8)))
+ var is_ac_coeff int32 = libc.Bool32(i > 0)
+ var bias int32 = int32(*(*uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&kBiasMatrices)) + uintptr(type1)*2 + uintptr(is_ac_coeff))))
+ *(*uint16_t)(unsafe.Pointer(m + 32 + uintptr(i)*2)) = uint16_t(int32(1) << 17 / int32(*(*uint16_t)(unsafe.Pointer(m + uintptr(i)*2))))
+ *(*uint32_t)(unsafe.Pointer(m + 64 + uintptr(i)*4)) = uint32_t(bias << (17 - 8))
// zthresh_ is the exact value such that QUANTDIV(coeff, iQ, B) is:
// * zero if coeff <= zthresh
// * non-zero if coeff > zthresh
- *(*uint32_t)(unsafe.Pointer((m + 128 /* &.zthresh_ */) + uintptr(i)*4)) = (((uint32_t((int32(1) << 17) - 1)) - *(*uint32_t)(unsafe.Pointer((m + 64 /* &.bias_ */) + uintptr(i)*4))) / uint32_t(*(*uint16_t)(unsafe.Pointer((m + 32 /* &.iq_ */) + uintptr(i)*2))))
+ *(*uint32_t)(unsafe.Pointer(m + 128 + uintptr(i)*4)) = (uint32_t(int32(1)<<17-1) - *(*uint32_t)(unsafe.Pointer(m + 64 + uintptr(i)*4))) / uint32_t(*(*uint16_t)(unsafe.Pointer(m + 32 + uintptr(i)*2)))
}
for i = 2; i < 16; i++ {
- *(*uint16_t)(unsafe.Pointer((m /* &.q_ */) + uintptr(i)*2)) = *(*uint16_t)(unsafe.Pointer((m /* &.q_ */) + 1*2))
- *(*uint16_t)(unsafe.Pointer((m + 32 /* &.iq_ */) + uintptr(i)*2)) = *(*uint16_t)(unsafe.Pointer((m + 32 /* &.iq_ */) + 1*2))
- *(*uint32_t)(unsafe.Pointer((m + 64 /* &.bias_ */) + uintptr(i)*4)) = *(*uint32_t)(unsafe.Pointer((m + 64 /* &.bias_ */) + 1*4))
- *(*uint32_t)(unsafe.Pointer((m + 128 /* &.zthresh_ */) + uintptr(i)*4)) = *(*uint32_t)(unsafe.Pointer((m + 128 /* &.zthresh_ */) + 1*4))
+ *(*uint16_t)(unsafe.Pointer(m + uintptr(i)*2)) = *(*uint16_t)(unsafe.Pointer(m + 1*2))
+ *(*uint16_t)(unsafe.Pointer(m + 32 + uintptr(i)*2)) = *(*uint16_t)(unsafe.Pointer(m + 32 + 1*2))
+ *(*uint32_t)(unsafe.Pointer(m + 64 + uintptr(i)*4)) = *(*uint32_t)(unsafe.Pointer(m + 64 + 1*4))
+ *(*uint32_t)(unsafe.Pointer(m + 128 + uintptr(i)*4)) = *(*uint32_t)(unsafe.Pointer(m + 128 + 1*4))
}
sum = 0
i = 0
for ; i < 16; i++ {
if type1 == 0 { // we only use sharpening for AC luma coeffs
- *(*uint16_t)(unsafe.Pointer((m + 192 /* &.sharpen_ */) + uintptr(i)*2)) = (uint16_t((int32(kFreqSharpening[i]) * int32(*(*uint16_t)(unsafe.Pointer((m /* &.q_ */) + uintptr(i)*2)))) >> 11))
+ *(*uint16_t)(unsafe.Pointer(m + 192 + uintptr(i)*2)) = uint16_t(int32(kFreqSharpening[i]) * int32(*(*uint16_t)(unsafe.Pointer(m + uintptr(i)*2))) >> 11)
} else {
- *(*uint16_t)(unsafe.Pointer((m + 192 /* &.sharpen_ */) + uintptr(i)*2)) = uint16_t(0)
+ *(*uint16_t)(unsafe.Pointer(m + 192 + uintptr(i)*2)) = uint16_t(0)
}
- sum = sum + (int32(*(*uint16_t)(unsafe.Pointer((m /* &.q_ */) + uintptr(i)*2))))
+ sum = sum + int32(*(*uint16_t)(unsafe.Pointer(m + uintptr(i)*2)))
}
- return ((sum + 8) >> 4)
+ return (sum + 8) >> 4
}
func CheckLambdaValue(tls *libc.TLS, v uintptr) { /* quant_enc.c:238:13: */
@@ -32697,47 +32399,47 @@ func SetupMatrices(tls *libc.TLS, enc uintptr) { /* quant_enc.c:240:13: */
}
var num_segments int32 = (*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.num_segments_
for i = 0; i < num_segments; i++ {
- var m uintptr = ((enc + 608 /* &.dqm_ */) + uintptr(i)*744)
+ var m uintptr = enc + 608 + uintptr(i)*744
var q int32 = (*VP8SegmentInfo)(unsafe.Pointer(m)).quant_
var q_i4 int32
var q_i16 int32
var q_uv int32
- *(*uint16_t)(unsafe.Pointer((m /* &.y1_ */) /* &.q_ */)) = uint16_t(kDcTable1[clip3(tls, (q+(*VP8Encoder)(unsafe.Pointer(enc)).dq_y1_dc_), 0, 127)])
- *(*uint16_t)(unsafe.Pointer((m /* &.y1_ */) /* &.q_ */ + 1*2)) = kAcTable1[clip3(tls, q, 0, 127)]
+ *(*uint16_t)(unsafe.Pointer(m)) = uint16_t(kDcTable1[clip3(tls, q+(*VP8Encoder)(unsafe.Pointer(enc)).dq_y1_dc_, 0, 127)])
+ *(*uint16_t)(unsafe.Pointer(m + 1*2)) = kAcTable1[clip3(tls, q, 0, 127)]
- *(*uint16_t)(unsafe.Pointer((m + 224 /* &.y2_ */) /* &.q_ */)) = (uint16_t(int32(kDcTable1[clip3(tls, (q+(*VP8Encoder)(unsafe.Pointer(enc)).dq_y2_dc_), 0, 127)]) * 2))
- *(*uint16_t)(unsafe.Pointer((m + 224 /* &.y2_ */) /* &.q_ */ + 1*2)) = kAcTable2[clip3(tls, (q+(*VP8Encoder)(unsafe.Pointer(enc)).dq_y2_ac_), 0, 127)]
+ *(*uint16_t)(unsafe.Pointer(m + 224)) = uint16_t(int32(kDcTable1[clip3(tls, q+(*VP8Encoder)(unsafe.Pointer(enc)).dq_y2_dc_, 0, 127)]) * 2)
+ *(*uint16_t)(unsafe.Pointer(m + 224 + 1*2)) = kAcTable2[clip3(tls, q+(*VP8Encoder)(unsafe.Pointer(enc)).dq_y2_ac_, 0, 127)]
- *(*uint16_t)(unsafe.Pointer((m + 448 /* &.uv_ */) /* &.q_ */)) = uint16_t(kDcTable1[clip3(tls, (q+(*VP8Encoder)(unsafe.Pointer(enc)).dq_uv_dc_), 0, 117)])
- *(*uint16_t)(unsafe.Pointer((m + 448 /* &.uv_ */) /* &.q_ */ + 1*2)) = kAcTable1[clip3(tls, (q+(*VP8Encoder)(unsafe.Pointer(enc)).dq_uv_ac_), 0, 127)]
+ *(*uint16_t)(unsafe.Pointer(m + 448)) = uint16_t(kDcTable1[clip3(tls, q+(*VP8Encoder)(unsafe.Pointer(enc)).dq_uv_dc_, 0, 117)])
+ *(*uint16_t)(unsafe.Pointer(m + 448 + 1*2)) = kAcTable1[clip3(tls, q+(*VP8Encoder)(unsafe.Pointer(enc)).dq_uv_ac_, 0, 127)]
- q_i4 = ExpandMatrix(tls, (m /* &.y1_ */), 0)
- q_i16 = ExpandMatrix(tls, (m + 224 /* &.y2_ */), 1)
- q_uv = ExpandMatrix(tls, (m + 448 /* &.uv_ */), 2)
+ q_i4 = ExpandMatrix(tls, m, 0)
+ q_i16 = ExpandMatrix(tls, m+224, 1)
+ q_uv = ExpandMatrix(tls, m+448, 2)
- (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_i4_ = (((3 * q_i4) * q_i4) >> 7)
- (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_i16_ = ((3 * q_i16) * q_i16)
- (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_uv_ = (((3 * q_uv) * q_uv) >> 6)
- (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_mode_ = (((1 * q_i4) * q_i4) >> 7)
- (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_trellis_i4_ = (((7 * q_i4) * q_i4) >> 3)
- (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_trellis_i16_ = ((q_i16 * q_i16) >> 2)
- (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_trellis_uv_ = ((q_uv * q_uv) << 1)
- (*VP8SegmentInfo)(unsafe.Pointer(m)).tlambda_ = ((tlambda_scale * q_i4) >> 5)
+ (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_i4_ = 3 * q_i4 * q_i4 >> 7
+ (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_i16_ = 3 * q_i16 * q_i16
+ (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_uv_ = 3 * q_uv * q_uv >> 6
+ (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_mode_ = 1 * q_i4 * q_i4 >> 7
+ (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_trellis_i4_ = 7 * q_i4 * q_i4 >> 3
+ (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_trellis_i16_ = q_i16 * q_i16 >> 2
+ (*VP8SegmentInfo)(unsafe.Pointer(m)).lambda_trellis_uv_ = q_uv * q_uv << 1
+ (*VP8SegmentInfo)(unsafe.Pointer(m)).tlambda_ = tlambda_scale * q_i4 >> 5
// none of these constants should be < 1
- CheckLambdaValue(tls, (m + 700 /* &.lambda_i4_ */))
- CheckLambdaValue(tls, (m + 696 /* &.lambda_i16_ */))
- CheckLambdaValue(tls, (m + 704 /* &.lambda_uv_ */))
- CheckLambdaValue(tls, (m + 708 /* &.lambda_mode_ */))
- CheckLambdaValue(tls, (m + 724 /* &.lambda_trellis_i4_ */))
- CheckLambdaValue(tls, (m + 720 /* &.lambda_trellis_i16_ */))
- CheckLambdaValue(tls, (m + 728 /* &.lambda_trellis_uv_ */))
- CheckLambdaValue(tls, (m + 716 /* &.tlambda_ */))
-
- (*VP8SegmentInfo)(unsafe.Pointer(m)).min_disto_ = (20 * int32(*(*uint16_t)(unsafe.Pointer((m /* &.y1_ */) /* &.q_ */)))) // quantization-aware min disto
+ CheckLambdaValue(tls, m+700)
+ CheckLambdaValue(tls, m+696)
+ CheckLambdaValue(tls, m+704)
+ CheckLambdaValue(tls, m+708)
+ CheckLambdaValue(tls, m+724)
+ CheckLambdaValue(tls, m+720)
+ CheckLambdaValue(tls, m+728)
+ CheckLambdaValue(tls, m+716)
+
+ (*VP8SegmentInfo)(unsafe.Pointer(m)).min_disto_ = 20 * int32(*(*uint16_t)(unsafe.Pointer(m))) // quantization-aware min disto
(*VP8SegmentInfo)(unsafe.Pointer(m)).max_edge_ = 0
- (*VP8SegmentInfo)(unsafe.Pointer(m)).i4_penalty_ = (score_t((1000 * q_i4) * q_i4))
+ (*VP8SegmentInfo)(unsafe.Pointer(m)).i4_penalty_ = score_t(1000 * q_i4 * q_i4)
}
}
@@ -32750,14 +32452,14 @@ func SetupMatrices(tls *libc.TLS, enc uintptr) { /* quant_enc.c:240:13: */
func SetupFilterStrength(tls *libc.TLS, enc uintptr) { /* quant_enc.c:296:13: */
var i int32
// level0 is in [0..500]. Using '-f 50' as filter_strength is mid-filtering.
- var level0 int32 = (5 * (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).filter_strength)
+ var level0 int32 = 5 * (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).filter_strength
for i = 0; i < NUM_MB_SEGMENTS; i++ {
- var m uintptr = ((enc + 608 /* &.dqm_ */) + uintptr(i)*744)
+ var m uintptr = enc + 608 + uintptr(i)*744
// We focus on the quantization of AC coeffs.
- var qstep int32 = (int32(kAcTable1[clip3(tls, (*VP8SegmentInfo)(unsafe.Pointer(m)).quant_, 0, 127)]) >> 2)
+ var qstep int32 = int32(kAcTable1[clip3(tls, (*VP8SegmentInfo)(unsafe.Pointer(m)).quant_, 0, 127)]) >> 2
var base_strength int32 = VP8FilterStrengthFromDelta(tls, (*VP8Encoder)(unsafe.Pointer(enc)).filter_hdr_.sharpness_, qstep)
// Segments with lower complexity ('beta') will be less filtered.
- var f int32 = ((base_strength * level0) / (256 + (*VP8SegmentInfo)(unsafe.Pointer(m)).beta_))
+ var f int32 = base_strength * level0 / (256 + (*VP8SegmentInfo)(unsafe.Pointer(m)).beta_)
(*VP8SegmentInfo)(unsafe.Pointer(m)).fstrength_ = func() int32 {
if f < 2 {
return 0
@@ -32771,8 +32473,8 @@ func SetupFilterStrength(tls *libc.TLS, enc uintptr) { /* quant_enc.c:296:13: */
}()
}
// We record the initial strength (mainly for the case of 1-segment only).
- (*VP8Encoder)(unsafe.Pointer(enc)).filter_hdr_.level_ = (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */))).fstrength_
- (*VP8Encoder)(unsafe.Pointer(enc)).filter_hdr_.simple_ = (libc.Bool32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).filter_type == 0))
+ (*VP8Encoder)(unsafe.Pointer(enc)).filter_hdr_.level_ = (*VP8SegmentInfo)(unsafe.Pointer(enc + 608)).fstrength_
+ (*VP8Encoder)(unsafe.Pointer(enc)).filter_hdr_.simple_ = libc.Bool32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).filter_type == 0)
(*VP8Encoder)(unsafe.Pointer(enc)).filter_hdr_.sharpness_ = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).filter_sharpness
}
@@ -32787,9 +32489,9 @@ func SetupFilterStrength(tls *libc.TLS, enc uintptr) { /* quant_enc.c:296:13: */
func QualityToCompression(tls *libc.TLS, c float64) float64 { /* quant_enc.c:326:15: */
var linear_c float64
if c < 0.75 {
- linear_c = (c * (float64(2.) / 3.))
+ linear_c = c * (float64(2.) / 3.)
} else {
- linear_c = ((2. * c) - 1.)
+ linear_c = 2.*c - 1.
}
// The file size roughly scales as pow(quantizer, 3.). Actually, the
// exponent is somewhere between 2.8 and 3.2, but we're mostly interested
@@ -32797,7 +32499,7 @@ func QualityToCompression(tls *libc.TLS, c float64) float64 { /* quant_enc.c:326
// this power-law: quant ~= compression ^ 1/3. This law holds well for
// low quant. Finer modeling for high-quant would make use of kAcTable[]
// more explicitly.
- var v float64 = libc.Xpow(tls, linear_c, (float64(float64(1)) / 3.))
+ var v float64 = libc.Xpow(tls, linear_c, float64(float64(1))/3.)
return v
}
@@ -32810,7 +32512,7 @@ func QualityToJPEGCompression(tls *libc.TLS, c float64, alpha float64) float64 {
var amax float64 = 0.85
var exp_min float64 = 0.4
var exp_max float64 = 0.9
- var slope float64 = ((exp_min - exp_max) / (amax - amin))
+ var slope float64 = (exp_min - exp_max) / (amax - amin)
// Linearly interpolate 'expn' from exp_min to exp_max
// in the [amin, amax] range.
var expn float64
@@ -32820,7 +32522,7 @@ func QualityToJPEGCompression(tls *libc.TLS, c float64, alpha float64) float64 {
if alpha < amin {
expn = exp_max
} else {
- expn = (exp_max + (slope * (alpha - amin)))
+ expn = exp_max + slope*(alpha-amin)
}
}
var v float64 = libc.Xpow(tls, c, expn)
@@ -32828,7 +32530,7 @@ func QualityToJPEGCompression(tls *libc.TLS, c float64, alpha float64) float64 {
}
func SegmentsAreEquivalent(tls *libc.TLS, S1 uintptr, S2 uintptr) int32 { /* quant_enc.c:357:12: */
- return (libc.Bool32(((*VP8SegmentInfo)(unsafe.Pointer(S1)).quant_ == (*VP8SegmentInfo)(unsafe.Pointer(S2)).quant_) && ((*VP8SegmentInfo)(unsafe.Pointer(S1)).fstrength_ == (*VP8SegmentInfo)(unsafe.Pointer(S2)).fstrength_)))
+ return libc.Bool32((*VP8SegmentInfo)(unsafe.Pointer(S1)).quant_ == (*VP8SegmentInfo)(unsafe.Pointer(S2)).quant_ && (*VP8SegmentInfo)(unsafe.Pointer(S1)).fstrength_ == (*VP8SegmentInfo)(unsafe.Pointer(S2)).fstrength_)
}
func SimplifySegments(tls *libc.TLS, enc uintptr) { /* quant_enc.c:362:13: */
@@ -32849,33 +32551,33 @@ func SimplifySegments(tls *libc.TLS, enc uintptr) { /* quant_enc.c:362:13: */
var s1 int32
var s2 int32
for s1 = 1; s1 < num_segments; s1++ { // find similar segments
- var S1 uintptr = ((enc + 608 /* &.dqm_ */) + uintptr(s1)*744)
+ var S1 uintptr = enc + 608 + uintptr(s1)*744
var found int32 = 0
// check if we already have similar segment
for s2 = 0; s2 < num_final_segments; s2++ {
- var S2 uintptr = ((enc + 608 /* &.dqm_ */) + uintptr(s2)*744)
+ var S2 uintptr = enc + 608 + uintptr(s2)*744
if SegmentsAreEquivalent(tls, S1, S2) != 0 {
found = 1
break
}
}
- *(*int32)(unsafe.Pointer((bp) /* &map1[0] */ + uintptr(s1)*4)) = s2
+ *(*int32)(unsafe.Pointer(bp + uintptr(s1)*4)) = s2
if !(found != 0) {
if num_final_segments != s1 {
- *(*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(num_final_segments)*744)) = *(*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(s1)*744))
+ *(*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(num_final_segments)*744)) = *(*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(s1)*744))
}
num_final_segments++
}
}
if num_final_segments < num_segments { // Remap
- var i int32 = ((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_)
+ var i int32 = (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_
for libc.PostDecInt32(&i, 1) > 0 {
- libc.SetBitFieldPtr8Uint32(((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(i)*4) /* &.segment_ */, uint32(*(*int32)(unsafe.Pointer((bp) /* &map1[0] */ + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer(((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(i)*4) /* &.segment_ */))&0x60>>5))))*4))), 5, 0x60)
+ libc.SetBitFieldPtr8Uint32((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_+uintptr(i)*4, uint32(*(*int32)(unsafe.Pointer(bp + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ + uintptr(i)*4))&0x60>>5)))*4))), 5, 0x60)
}
(*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.num_segments_ = num_final_segments
// Replicate the trailing segment infos (it's mostly cosmetics)
for i = num_final_segments; i < num_segments; i++ {
- *(*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(i)*744)) = *(*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr((num_final_segments-1))*744))
+ *(*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(i)*744)) = *(*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(num_final_segments-1)*744))
}
}
}
@@ -32885,45 +32587,45 @@ func VP8SetSegmentParams(tls *libc.TLS, enc uintptr, quality float32) { /* quant
var dq_uv_ac int32
var dq_uv_dc int32
var num_segments int32 = (*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.num_segments_
- var amp float64 = (((0.9 * float64((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).sns_strength)) / 100.) / 128.)
- var Q float64 = (float64(quality) / 100.)
+ var amp float64 = 0.9 * float64((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).sns_strength) / 100. / 128.
+ var Q float64 = float64(quality) / 100.
var c_base float64
if (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).emulate_jpeg_size != 0 {
- c_base = QualityToJPEGCompression(tls, Q, (float64((*VP8Encoder)(unsafe.Pointer(enc)).alpha_) / 255.))
+ c_base = QualityToJPEGCompression(tls, Q, float64((*VP8Encoder)(unsafe.Pointer(enc)).alpha_)/255.)
} else {
c_base = QualityToCompression(tls, Q)
}
for i = 0; i < num_segments; i++ {
// We modulate the base coefficient to accommodate for the quantization
// susceptibility and allow denser segments to be quantized more.
- var expn float64 = (1. - (amp * float64((*VP8SegmentInfo)(unsafe.Pointer((enc+608 /* &.dqm_ */)+uintptr(i)*744)).alpha_)))
+ var expn float64 = 1. - amp*float64((*VP8SegmentInfo)(unsafe.Pointer(enc+608+uintptr(i)*744)).alpha_)
var c float64 = libc.Xpow(tls, c_base, expn)
- var q int32 = (libc.Int32FromFloat64(127. * (1. - c)))
+ var q int32 = libc.Int32FromFloat64(127. * (1. - c))
- (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(i)*744)).quant_ = clip3(tls, q, 0, 127)
+ (*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(i)*744)).quant_ = clip3(tls, q, 0, 127)
}
// purely indicative in the bitstream (except for the 1-segment case)
- (*VP8Encoder)(unsafe.Pointer(enc)).base_quant_ = (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */))).quant_
+ (*VP8Encoder)(unsafe.Pointer(enc)).base_quant_ = (*VP8SegmentInfo)(unsafe.Pointer(enc + 608)).quant_
// fill-in values for the unused segments (required by the syntax)
for i = num_segments; i < NUM_MB_SEGMENTS; i++ {
- (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(i)*744)).quant_ = (*VP8Encoder)(unsafe.Pointer(enc)).base_quant_
+ (*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(i)*744)).quant_ = (*VP8Encoder)(unsafe.Pointer(enc)).base_quant_
}
// uv_alpha_ is normally spread around ~60. The useful range is
// typically ~30 (quite bad) to ~100 (ok to decimate UV more).
// We map it to the safe maximal range of MAX/MIN_DQ_UV for dq_uv.
- dq_uv_ac = ((((*VP8Encoder)(unsafe.Pointer(enc)).uv_alpha_ - 64) * ((6) - (-4))) /
- (100 - 30))
+ dq_uv_ac = ((*VP8Encoder)(unsafe.Pointer(enc)).uv_alpha_ - 64) * (6 - -4) /
+ (100 - 30)
// we rescale by the user-defined strength of adaptation
- dq_uv_ac = ((dq_uv_ac * (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).sns_strength) / 100)
+ dq_uv_ac = dq_uv_ac * (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).sns_strength / 100
// and make it safe.
- dq_uv_ac = clip3(tls, dq_uv_ac, (-4), (6))
+ dq_uv_ac = clip3(tls, dq_uv_ac, -4, 6)
// We also boost the dc-uv-quant a little, based on sns-strength, since
// U/V channels are quite more reactive to high quants (flat DC-blocks
// tend to appear, and are unpleasant).
- dq_uv_dc = ((-4 * (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).sns_strength) / 100)
+ dq_uv_dc = -4 * (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).sns_strength / 100
dq_uv_dc = clip3(tls, dq_uv_dc, -15, 15) // 4bit-signed max allowed
(*VP8Encoder)(unsafe.Pointer(enc)).dq_y1_dc_ = 0 // TODO(skal): dq-lum
@@ -32945,12 +32647,12 @@ func VP8SetSegmentParams(tls *libc.TLS, enc uintptr, quality float32) { /* quant
// Form the predictions in cache
// Must be ordered using {DC_PRED, TM_PRED, V_PRED, H_PRED} as index
-var VP8I16ModeOffsets = [4]uint16_t{(uint16_t((0 * 16) * 32)), (uint16_t(((0 * 16) * 32) + 16)), (uint16_t((1 * 16) * 32)), (uint16_t(((1 * 16) * 32) + 16))} /* quant_enc.c:461:16 */
-var VP8UVModeOffsets = [4]uint16_t{(uint16_t((2 * 16) * 32)), (uint16_t(((2 * 16) * 32) + (1 * 16))), (uint16_t(((2 * 16) * 32) + (8 * 32))), (uint16_t((((2 * 16) * 32) + (8 * 32)) + (1 * 16)))} /* quant_enc.c:462:16 */
+var VP8I16ModeOffsets = [4]uint16_t{uint16_t(0 * 16 * 32), uint16_t(0*16*32 + 16), uint16_t(1 * 16 * 32), uint16_t(1*16*32 + 16)} /* quant_enc.c:461:16 */
+var VP8UVModeOffsets = [4]uint16_t{uint16_t(2 * 16 * 32), uint16_t(2*16*32 + 1*16), uint16_t(2*16*32 + 8*32), uint16_t(2*16*32 + 8*32 + 1*16)} /* quant_enc.c:462:16 */
// Must be indexed using {B_DC_PRED -> B_HU_PRED} as index
var VP8I4ModeOffsets = [10]uint16_t{
- (uint16_t(((3 * 16) * 32) + 0)), (uint16_t((((3 * 16) * 32) + 0) + 4)), (uint16_t((((3 * 16) * 32) + 0) + 8)), (uint16_t((((3 * 16) * 32) + 0) + 12)), (uint16_t((((3 * 16) * 32) + 0) + 16)), (uint16_t((((3 * 16) * 32) + 0) + 20)), (uint16_t((((3 * 16) * 32) + 0) + 24)), (uint16_t((((3 * 16) * 32) + 0) + 28)), (uint16_t(((3 * 16) * 32) + (4 * 32))), (uint16_t((((3 * 16) * 32) + (4 * 32)) + 4)),
+ uint16_t(3*16*32 + 0), uint16_t(3*16*32 + 0 + 4), uint16_t(3*16*32 + 0 + 8), uint16_t(3*16*32 + 0 + 12), uint16_t(3*16*32 + 0 + 16), uint16_t(3*16*32 + 0 + 20), uint16_t(3*16*32 + 0 + 24), uint16_t(3*16*32 + 0 + 28), uint16_t(3*16*32 + 4*32), uint16_t(3*16*32 + 4*32 + 4),
} /* quant_enc.c:465:16 */
func VP8MakeLuma16Preds(tls *libc.TLS, it uintptr) { /* quant_enc.c:469:6: */
@@ -32958,13 +32660,13 @@ func VP8MakeLuma16Preds(tls *libc.TLS, it uintptr) { /* quant_enc.c:469:6: */
if (*VP8EncIterator)(unsafe.Pointer(it)).x_ != 0 {
left = (*VP8EncIterator)(unsafe.Pointer(it)).y_left_
} else {
- left = (uintptr(0))
+ left = uintptr(0)
}
var top uintptr
if (*VP8EncIterator)(unsafe.Pointer(it)).y_ != 0 {
top = (*VP8EncIterator)(unsafe.Pointer(it)).y_top_
} else {
- top = (uintptr(0))
+ top = uintptr(0)
}
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr)
@@ -32976,13 +32678,13 @@ func VP8MakeChroma8Preds(tls *libc.TLS, it uintptr) { /* quant_enc.c:475:6: */
if (*VP8EncIterator)(unsafe.Pointer(it)).x_ != 0 {
left = (*VP8EncIterator)(unsafe.Pointer(it)).u_left_
} else {
- left = (uintptr(0))
+ left = uintptr(0)
}
var top uintptr
if (*VP8EncIterator)(unsafe.Pointer(it)).y_ != 0 {
top = (*VP8EncIterator)(unsafe.Pointer(it)).uv_top_
} else {
- top = (uintptr(0))
+ top = uintptr(0)
}
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr)
@@ -33007,15 +32709,15 @@ func VP8MakeIntra4Preds(tls *libc.TLS, it uintptr) { /* quant_enc.c:481:6: */
// +----+----+
var VP8Scan = [16]uint16_t{ // Luma
- (uint16_t(0 + (0 * 32))), (uint16_t(4 + (0 * 32))), (uint16_t(8 + (0 * 32))), (uint16_t(12 + (0 * 32))),
- (uint16_t(0 + (4 * 32))), (uint16_t(4 + (4 * 32))), (uint16_t(8 + (4 * 32))), (uint16_t(12 + (4 * 32))),
- (uint16_t(0 + (8 * 32))), (uint16_t(4 + (8 * 32))), (uint16_t(8 + (8 * 32))), (uint16_t(12 + (8 * 32))),
- (uint16_t(0 + (12 * 32))), (uint16_t(4 + (12 * 32))), (uint16_t(8 + (12 * 32))), (uint16_t(12 + (12 * 32))),
+ uint16_t(0 + 0*32), uint16_t(4 + 0*32), uint16_t(8 + 0*32), uint16_t(12 + 0*32),
+ uint16_t(0 + 4*32), uint16_t(4 + 4*32), uint16_t(8 + 4*32), uint16_t(12 + 4*32),
+ uint16_t(0 + 8*32), uint16_t(4 + 8*32), uint16_t(8 + 8*32), uint16_t(12 + 8*32),
+ uint16_t(0 + 12*32), uint16_t(4 + 12*32), uint16_t(8 + 12*32), uint16_t(12 + 12*32),
} /* quant_enc.c:496:16 */
var VP8ScanUV = [8]uint16_t{
- (uint16_t(0 + (0 * 32))), (uint16_t(4 + (0 * 32))), (uint16_t(0 + (4 * 32))), (uint16_t(4 + (4 * 32))), // U
- (uint16_t(8 + (0 * 32))), (uint16_t(12 + (0 * 32))), (uint16_t(8 + (4 * 32))), (uint16_t(12 + (4 * 32))), // V
+ uint16_t(0 + 0*32), uint16_t(4 + 0*32), uint16_t(0 + 4*32), uint16_t(4 + 4*32),
+ uint16_t(8 + 0*32), uint16_t(12 + 0*32), uint16_t(8 + 4*32), uint16_t(12 + 4*32),
} /* quant_enc.c:503:23 */
//------------------------------------------------------------------------------
@@ -33039,7 +32741,7 @@ func InitScore(tls *libc.TLS, rd uintptr) { /* quant_enc.c:527:13: */
(*VP8ModeScore)(unsafe.Pointer(rd)).R = int64(0)
(*VP8ModeScore)(unsafe.Pointer(rd)).H = int64(0)
(*VP8ModeScore)(unsafe.Pointer(rd)).nz = uint32_t(0)
- (*VP8ModeScore)(unsafe.Pointer(rd)).score = (0x7fffffffffffff)
+ (*VP8ModeScore)(unsafe.Pointer(rd)).score = 0x7fffffffffffff
}
func CopyScore(tls *libc.TLS, dst uintptr, src uintptr) { /* quant_enc.c:536:13: */
@@ -33052,12 +32754,12 @@ func CopyScore(tls *libc.TLS, dst uintptr, src uintptr) { /* quant_enc.c:536:13:
}
func AddScore(tls *libc.TLS, dst uintptr, src uintptr) { /* quant_enc.c:545:13: */
- *(*score_t)(unsafe.Pointer((dst /* &.D */))) += ((*VP8ModeScore)(unsafe.Pointer(src)).D)
- *(*score_t)(unsafe.Pointer((dst + 8 /* &.SD */))) += ((*VP8ModeScore)(unsafe.Pointer(src)).SD)
- *(*score_t)(unsafe.Pointer((dst + 24 /* &.R */))) += ((*VP8ModeScore)(unsafe.Pointer(src)).R)
- *(*score_t)(unsafe.Pointer((dst + 16 /* &.H */))) += ((*VP8ModeScore)(unsafe.Pointer(src)).H)
- *(*uint32_t)(unsafe.Pointer((dst + 864 /* &.nz */))) |= ((*VP8ModeScore)(unsafe.Pointer(src)).nz) // here, new nz bits are accumulated.
- *(*score_t)(unsafe.Pointer((dst + 32 /* &.score */))) += ((*VP8ModeScore)(unsafe.Pointer(src)).score)
+ *(*score_t)(unsafe.Pointer(dst)) += (*VP8ModeScore)(unsafe.Pointer(src)).D
+ *(*score_t)(unsafe.Pointer(dst + 8)) += (*VP8ModeScore)(unsafe.Pointer(src)).SD
+ *(*score_t)(unsafe.Pointer(dst + 24)) += (*VP8ModeScore)(unsafe.Pointer(src)).R
+ *(*score_t)(unsafe.Pointer(dst + 16)) += (*VP8ModeScore)(unsafe.Pointer(src)).H
+ *(*uint32_t)(unsafe.Pointer(dst + 864)) |= (*VP8ModeScore)(unsafe.Pointer(src)).nz // here, new nz bits are accumulated.
+ *(*score_t)(unsafe.Pointer(dst + 32)) += (*VP8ModeScore)(unsafe.Pointer(src)).score
}
//------------------------------------------------------------------------------
@@ -33081,19 +32783,19 @@ type ScoreState = struct {
// We don't test negative values though.
func SetRDScore(tls *libc.TLS, lambda int32, rd uintptr) { /* quant_enc.c:579:25: */
- (*VP8ModeScore)(unsafe.Pointer(rd)).score = ((((*VP8ModeScore)(unsafe.Pointer(rd)).R + (*VP8ModeScore)(unsafe.Pointer(rd)).H) * score_t(lambda)) + (int64(256) * ((*VP8ModeScore)(unsafe.Pointer(rd)).D + (*VP8ModeScore)(unsafe.Pointer(rd)).SD)))
+ (*VP8ModeScore)(unsafe.Pointer(rd)).score = ((*VP8ModeScore)(unsafe.Pointer(rd)).R+(*VP8ModeScore)(unsafe.Pointer(rd)).H)*score_t(lambda) + int64(256)*((*VP8ModeScore)(unsafe.Pointer(rd)).D+(*VP8ModeScore)(unsafe.Pointer(rd)).SD)
}
func RDScoreTrellis(tls *libc.TLS, lambda int32, rate score_t, distortion score_t) score_t { /* quant_enc.c:583:28: */
- return ((rate * score_t(lambda)) + (int64(256) * distortion))
+ return rate*score_t(lambda) + int64(256)*distortion
}
func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, ctx0 int32, coeff_type int32, mtx uintptr, lambda int32) int32 { /* quant_enc.c:591:12: */
bp := tls.Alloc(204)
defer tls.Free(204)
- var probas uintptr = (((enc + 3616 /* &.proba_ */) + 4 /* &.coeffs_ */) + uintptr(coeff_type)*264)
- var costs CostArrayPtr = (((enc + 3616 /* &.proba_ */) + 18344 /* &.remapped_costs_ */) + uintptr(coeff_type)*384)
+ var probas uintptr = enc + 3616 + 4 + uintptr(coeff_type)*264
+ var costs CostArrayPtr = enc + 3616 + 18344 + uintptr(coeff_type)*384
var first int32
if coeff_type == TYPE_I16_AC {
first = 1
@@ -33104,8 +32806,8 @@ func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, c
// var score_states [2][2]ScoreState at bp, 64
- var ss_cur uintptr = (bp) /* &score_states */
- var ss_prev uintptr = ((bp) /* &score_states */ + 1*32)
+ var ss_cur uintptr = bp
+ var ss_prev uintptr = bp + 1*32
*(*[3]int32)(unsafe.Pointer(bp + 192 /* best_path */)) = [3]int32{-1, -1, -1} // store best-last/best-level/best-previous
var best_score score_t
var n int32
@@ -33115,14 +32817,14 @@ func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, c
{
var cost score_t
- var thresh int32 = ((int32(*(*uint16_t)(unsafe.Pointer((mtx /* &.q_ */) + 1*2))) * int32(*(*uint16_t)(unsafe.Pointer((mtx /* &.q_ */) + 1*2)))) / 4)
- var last_proba int32 = int32(*(*uint8_t)(unsafe.Pointer(((probas + uintptr(VP8EncBands[first])*33) + uintptr(ctx0)*11))))
+ var thresh int32 = int32(*(*uint16_t)(unsafe.Pointer(mtx + 1*2))) * int32(*(*uint16_t)(unsafe.Pointer(mtx + 1*2))) / 4
+ var last_proba int32 = int32(*(*uint8_t)(unsafe.Pointer(probas + uintptr(VP8EncBands[first])*33 + uintptr(ctx0)*11)))
// compute the position of the last interesting coefficient
- last = (first - 1)
+ last = first - 1
for n = 15; n >= first; n-- {
var j int32 = int32(kZigzag2[n])
- var err int32 = (int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2))) * int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2))))
+ var err int32 = int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2))) * int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2)))
if err > thresh {
last = n
break
@@ -33147,7 +32849,7 @@ func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, c
rate = int64(0)
}
(*ScoreState)(unsafe.Pointer(ss_cur + uintptr(m)*16)).score = RDScoreTrellis(tls, lambda, rate, int64(0))
- (*ScoreState)(unsafe.Pointer(ss_cur + uintptr(m)*16)).costs = *(*uintptr)(unsafe.Pointer((costs + uintptr(first)*24) + uintptr(ctx0)*8))
+ (*ScoreState)(unsafe.Pointer(ss_cur + uintptr(m)*16)).costs = *(*uintptr)(unsafe.Pointer(costs + uintptr(first)*24 + uintptr(ctx0)*8))
}
}
@@ -33155,20 +32857,20 @@ func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, c
// traverse trellis.
for n = first; n <= last; n++ {
var j int32 = int32(kZigzag2[n])
- var Q uint32_t = uint32_t(*(*uint16_t)(unsafe.Pointer((mtx /* &.q_ */) + uintptr(j)*2)))
- var iQ uint32_t = uint32_t(*(*uint16_t)(unsafe.Pointer((mtx + 32 /* &.iq_ */) + uintptr(j)*2)))
- var B uint32_t = (uint32_t(int32((0x00)) << (17 - 8))) // neutral bias
+ var Q uint32_t = uint32_t(*(*uint16_t)(unsafe.Pointer(mtx + uintptr(j)*2)))
+ var iQ uint32_t = uint32_t(*(*uint16_t)(unsafe.Pointer(mtx + 32 + uintptr(j)*2)))
+ var B uint32_t = uint32_t(int32(0x00) << (17 - 8)) // neutral bias
// note: it's important to take sign of the _original_ coeff,
// so we don't have to consider level < 0 afterward.
- var sign int32 = (libc.Bool32(int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2))) < 0))
- var coeff0 uint32_t = (uint32_t((func() int32 {
+ var sign int32 = libc.Bool32(int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2))) < 0)
+ var coeff0 uint32_t = uint32_t(func() int32 {
if sign != 0 {
return -int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2)))
}
return int32(*(*int16_t)(unsafe.Pointer(in + uintptr(j)*2)))
- }()) + int32(*(*uint16_t)(unsafe.Pointer((mtx + 192 /* &.sharpen_ */) + uintptr(j)*2)))))
+ }() + int32(*(*uint16_t)(unsafe.Pointer(mtx + 192 + uintptr(j)*2))))
var level0 int32 = QUANTDIV(tls, coeff0, iQ, B)
- var thresh_level int32 = QUANTDIV(tls, coeff0, iQ, (uint32(int32((0x80)) << (17 - 8))))
+ var thresh_level int32 = QUANTDIV(tls, coeff0, iQ, uint32(int32(0x80)<<(17-8)))
if thresh_level > MAX_LEVEL {
thresh_level = MAX_LEVEL
}
@@ -33185,24 +32887,24 @@ func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, c
// test all alternate level values around level0.
for m = -0; m <= 1; m++ {
- var cur uintptr = (((bp + 64) /* &nodes */ + uintptr((n))*8) + uintptr(((m)+0))*4)
- var level int32 = (level0 + m)
+ var cur uintptr = bp + 64 + uintptr(n)*8 + uintptr(m+0)*4
+ var level int32 = level0 + m
var ctx int32
if level > 2 {
ctx = 2
} else {
ctx = level
}
- var band int32 = int32(VP8EncBands[(n + 1)])
+ var band int32 = int32(VP8EncBands[n+1])
var base_score score_t
var best_cur_score score_t
var best_prev int32
var cost score_t
var score score_t
- (*ScoreState)(unsafe.Pointer(ss_cur + uintptr(m)*16)).costs = *(*uintptr)(unsafe.Pointer((costs + uintptr((n+1))*24) + uintptr(ctx)*8))
- if (level < 0) || (level > thresh_level) {
- (*ScoreState)(unsafe.Pointer(ss_cur + uintptr(m)*16)).score = (0x7fffffffffffff)
+ (*ScoreState)(unsafe.Pointer(ss_cur + uintptr(m)*16)).costs = *(*uintptr)(unsafe.Pointer(costs + uintptr(n+1)*24 + uintptr(ctx)*8))
+ if level < 0 || level > thresh_level {
+ (*ScoreState)(unsafe.Pointer(ss_cur + uintptr(m)*16)).score = 0x7fffffffffffff
// Node is dead.
continue
}
@@ -33211,8 +32913,8 @@ func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, c
// Compute delta_error = how much coding this level will
// subtract to max_error as distortion.
// Here, distortion = sum of (|coeff_i| - level_i * Q_i)^2
- var new_error int32 = (int32(coeff0 - (uint32_t(level) * Q)))
- var delta_error int32 = (int32(uint32_t(kWeightTrellis[j]) * ((uint32_t(new_error * new_error)) - (coeff0 * coeff0))))
+ var new_error int32 = int32(coeff0 - uint32_t(level)*Q)
+ var delta_error int32 = int32(uint32_t(kWeightTrellis[j]) * (uint32_t(new_error*new_error) - coeff0*coeff0))
base_score = RDScoreTrellis(tls, lambda, int64(0), int64(delta_error))
}
@@ -33221,20 +32923,20 @@ func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, c
// The base_score is added to all scores so it is only added for the final
// value after the loop.
cost = score_t(VP8LevelCost(tls, (*ScoreState)(unsafe.Pointer(ss_prev)).costs, level))
- best_cur_score = ((*ScoreState)(unsafe.Pointer(ss_prev)).score + RDScoreTrellis(tls, lambda, cost, int64(0)))
+ best_cur_score = (*ScoreState)(unsafe.Pointer(ss_prev)).score + RDScoreTrellis(tls, lambda, cost, int64(0))
best_prev = -0
- for p = (-0 + 1); p <= 1; p++ {
+ for p = -0 + 1; p <= 1; p++ {
// Dead nodes (with ss_prev[p].score >= MAX_COST) are automatically
// eliminated since their score can't be better than the current best.
cost = score_t(VP8LevelCost(tls, (*ScoreState)(unsafe.Pointer(ss_prev+uintptr(p)*16)).costs, level))
// Examine node assuming it's a non-terminal one.
- score = ((*ScoreState)(unsafe.Pointer(ss_prev+uintptr(p)*16)).score + RDScoreTrellis(tls, lambda, cost, int64(0)))
+ score = (*ScoreState)(unsafe.Pointer(ss_prev+uintptr(p)*16)).score + RDScoreTrellis(tls, lambda, cost, int64(0))
if score < best_cur_score {
best_cur_score = score
best_prev = p
}
}
- best_cur_score = best_cur_score + (base_score)
+ best_cur_score = best_cur_score + base_score
// Store best finding in current node.
(*Node)(unsafe.Pointer(cur)).sign = int8_t(sign)
(*Node)(unsafe.Pointer(cur)).level = int16_t(level)
@@ -33242,20 +32944,20 @@ func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, c
(*ScoreState)(unsafe.Pointer(ss_cur + uintptr(m)*16)).score = best_cur_score
// Now, record best terminal node (and thus best entry in the graph).
- if (level != 0) && (best_cur_score < best_score) {
+ if level != 0 && best_cur_score < best_score {
var last_pos_cost score_t
if n < 15 {
- last_pos_cost = int64(VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(((probas + uintptr(band)*33) + uintptr(ctx)*11)))))
+ last_pos_cost = int64(VP8BitCost(tls, 0, *(*uint8_t)(unsafe.Pointer(probas + uintptr(band)*33 + uintptr(ctx)*11))))
} else {
last_pos_cost = int64(0)
}
var last_pos_score score_t = RDScoreTrellis(tls, lambda, last_pos_cost, int64(0))
- score = (best_cur_score + last_pos_score)
+ score = best_cur_score + last_pos_score
if score < best_score {
best_score = score
- *(*int32)(unsafe.Pointer((bp + 192) /* &best_path[0] */)) = n // best eob position
- *(*int32)(unsafe.Pointer((bp + 192) /* &best_path[0] */ + 1*4)) = m // best node index
- *(*int32)(unsafe.Pointer((bp + 192) /* &best_path[0] */ + 2*4)) = best_prev // best predecessor
+ *(*int32)(unsafe.Pointer(bp + 192)) = n // best eob position
+ *(*int32)(unsafe.Pointer(bp + 192 + 1*4)) = m // best node index
+ *(*int32)(unsafe.Pointer(bp + 192 + 2*4)) = best_prev // best predecessor
}
}
}
@@ -33264,13 +32966,13 @@ func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, c
// Fresh start
// Beware! We must preserve in[0]/out[0] value for TYPE_I16_AC case.
if coeff_type == TYPE_I16_AC {
- libc.Xmemset(tls, (in + uintptr(1)*2), 0, (uint64(15) * uint64(unsafe.Sizeof(int16_t(0)))))
- libc.Xmemset(tls, (out + uintptr(1)*2), 0, (uint64(15) * uint64(unsafe.Sizeof(int16_t(0)))))
+ libc.Xmemset(tls, in+uintptr(1)*2, 0, uint64(15)*uint64(unsafe.Sizeof(int16_t(0))))
+ libc.Xmemset(tls, out+uintptr(1)*2, 0, uint64(15)*uint64(unsafe.Sizeof(int16_t(0))))
} else {
- libc.Xmemset(tls, in, 0, (uint64(16) * uint64(unsafe.Sizeof(int16_t(0)))))
- libc.Xmemset(tls, out, 0, (uint64(16) * uint64(unsafe.Sizeof(int16_t(0)))))
+ libc.Xmemset(tls, in, 0, uint64(16)*uint64(unsafe.Sizeof(int16_t(0))))
+ libc.Xmemset(tls, out, 0, uint64(16)*uint64(unsafe.Sizeof(int16_t(0))))
}
- if *(*int32)(unsafe.Pointer((bp + 192) /* &best_path[0] */)) == -1 {
+ if *(*int32)(unsafe.Pointer(bp + 192)) == -1 {
return 0 // skip!
}
@@ -33279,12 +32981,12 @@ func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, c
// Note: best-prev on terminal node is not necessarily equal to the
// best_prev for non-terminal. So we patch best_path[2] in.
var nz int32 = 0
- var best_node int32 = *(*int32)(unsafe.Pointer((bp + 192) /* &best_path[0] */ + 1*4))
- n = *(*int32)(unsafe.Pointer((bp + 192) /* &best_path[0] */))
- (*Node)(unsafe.Pointer(((bp + 64) /* &nodes */ + uintptr((n))*8) + uintptr(((best_node)+0))*4)).prev = int8_t(*(*int32)(unsafe.Pointer((bp + 192) /* &best_path[0] */ + 2*4))) // force best-prev for terminal
+ var best_node int32 = *(*int32)(unsafe.Pointer(bp + 192 + 1*4))
+ n = *(*int32)(unsafe.Pointer(bp + 192))
+ (*Node)(unsafe.Pointer(bp + 64 + uintptr(n)*8 + uintptr(best_node+0)*4)).prev = int8_t(*(*int32)(unsafe.Pointer(bp + 192 + 2*4))) // force best-prev for terminal
for ; n >= first; n-- {
- var node uintptr = (((bp + 64) /* &nodes */ + uintptr((n))*8) + uintptr(((best_node)+0))*4)
+ var node uintptr = bp + 64 + uintptr(n)*8 + uintptr(best_node+0)*4
var j int32 = int32(kZigzag2[n])
*(*int16_t)(unsafe.Pointer(out + uintptr(n)*2)) = func() int16 {
if (*Node)(unsafe.Pointer(node)).sign != 0 {
@@ -33292,11 +32994,11 @@ func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, c
}
return (*Node)(unsafe.Pointer(node)).level
}()
- nz = nz | (int32((*Node)(unsafe.Pointer(node)).level))
- *(*int16_t)(unsafe.Pointer(in + uintptr(j)*2)) = (int16_t(int32(*(*int16_t)(unsafe.Pointer(out + uintptr(n)*2))) * int32(*(*uint16_t)(unsafe.Pointer((mtx /* &.q_ */) + uintptr(j)*2)))))
+ nz = nz | int32((*Node)(unsafe.Pointer(node)).level)
+ *(*int16_t)(unsafe.Pointer(in + uintptr(j)*2)) = int16_t(int32(*(*int16_t)(unsafe.Pointer(out + uintptr(n)*2))) * int32(*(*uint16_t)(unsafe.Pointer(mtx + uintptr(j)*2))))
best_node = int32((*Node)(unsafe.Pointer(node)).prev)
}
- return (libc.Bool32(nz != 0))
+ return libc.Bool32(nz != 0)
}
return int32(0)
@@ -33312,28 +33014,28 @@ func ReconstructIntra16(tls *libc.TLS, it uintptr, rd uintptr, yuv_out uintptr,
defer tls.Free(544)
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
- var ref uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8I16ModeOffsets[mode]))
- var src uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((0)))
- var dqm uintptr = ((enc + 608 /* &.dqm_ */) + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.segment_ */))&0x60>>5))))*744)
+ var ref uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8I16ModeOffsets[mode])
+ var src uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr(0)
+ var dqm uintptr = enc + 608 + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x60>>5)))*744
var nz int32 = 0
var n int32
// var tmp [16][16]int16_t at bp, 512
// var dc_tmp [16]int16_t at bp+512, 32
- for n = 0; n < 16; n = n + (2) {
+ for n = 0; n < 16; n = n + 2 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8FTransform2})).f(tls, (src + uintptr(VP8Scan[n])), (ref + uintptr(VP8Scan[n])), ((bp) /* &tmp[0] */ + uintptr(n)*32))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8FTransform2})).f(tls, src+uintptr(VP8Scan[n]), ref+uintptr(VP8Scan[n]), bp /* &tmp[0] */ +uintptr(n)*32)
}
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8FTransformWHT})).f(tls, (bp) /* &tmp[0] */, (bp + 512) /* &dc_tmp[0] */)
- nz = nz | ((*struct {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8FTransformWHT})).f(tls, bp /* &tmp[0] */, bp+512 /* &dc_tmp[0] */)
+ nz = nz | (*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlockWHT})).f(tls, (bp+512) /* &dc_tmp[0] */, (rd+40 /* &.y_dc_levels */), (dqm+224 /* &.y2_ */)) << 24)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlockWHT})).f(tls, bp+512, rd+40, dqm+224)<<24
- if (1 != 0) && ((*VP8EncIterator)(unsafe.Pointer(it)).do_trellis_ != 0) {
+ if 1 != 0 && (*VP8EncIterator)(unsafe.Pointer(it)).do_trellis_ != 0 {
var x int32
var y int32
VP8IteratorNzToBytes(tls, it)
@@ -33346,13 +33048,13 @@ func ReconstructIntra16(tls *libc.TLS, it uintptr, rd uintptr, yuv_out uintptr,
goto __3
}
{
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(y)*4)))
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(y)*4))
var non_zero int32 = TrellisQuantizeBlock(tls,
- enc, ((bp) /* &tmp[0] */ + uintptr(n)*32), ((rd + 72 /* &.y_ac_levels */) + uintptr(n)*32), ctx, TYPE_I16_AC, (dqm /* &.y1_ */),
+ enc, bp+uintptr(n)*32, rd+72+uintptr(n)*32, ctx, TYPE_I16_AC, dqm,
(*VP8SegmentInfo)(unsafe.Pointer(dqm)).lambda_trellis_i16_)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + uintptr(y)*4), non_zero)
- *(*int16_t)(unsafe.Pointer(((rd + 72 /* &.y_ac_levels */) + uintptr(n)*32))) = int16(0)
- nz = nz | (non_zero << n)
+ *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) = libc.AssignPtrInt32(it+168+uintptr(y)*4, non_zero)
+ *(*int16_t)(unsafe.Pointer(rd + 72 + uintptr(n)*32)) = int16(0)
+ nz = nz | non_zero<<n
}
goto __2
@@ -33364,13 +33066,13 @@ func ReconstructIntra16(tls *libc.TLS, it uintptr, rd uintptr, yuv_out uintptr,
__3:
}
} else {
- for n = 0; n < 16; n = n + (2) {
+ for n = 0; n < 16; n = n + 2 {
// Zero-out the first coeff, so that: a) nz is correct below, and
// b) finding 'last' non-zero coeffs in SetResidualCoeffs() is simplified.
- *(*int16_t)(unsafe.Pointer(((bp) /* &tmp[0] */ + uintptr(n)*32))) = libc.AssignPtrInt16(((bp) /* &tmp */ + uintptr((n+1))*32), int16(0))
- nz = nz | ((*struct {
+ *(*int16_t)(unsafe.Pointer(bp + uintptr(n)*32)) = libc.AssignPtrInt16(bp+uintptr(n+1)*32, int16(0))
+ nz = nz | (*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantize2Blocks})).f(tls, ((bp) /* &tmp[0] */ +uintptr(n)*32), ((rd+72 /* &.y_ac_levels */)+uintptr(n)*32), (dqm /* &.y1_ */)) << n)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantize2Blocks})).f(tls, bp+uintptr(n)*32, rd+72+uintptr(n)*32, dqm)<<n
}
}
@@ -33378,11 +33080,11 @@ func ReconstructIntra16(tls *libc.TLS, it uintptr, rd uintptr, yuv_out uintptr,
// Transform back
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8TransformWHT})).f(tls, (bp + 512) /* &dc_tmp[0] */, (bp) /* &tmp[0] */)
- for n = 0; n < 16; n = n + (2) {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8TransformWHT})).f(tls, bp+512 /* &dc_tmp[0] */, bp /* &tmp[0] */)
+ for n = 0; n < 16; n = n + 2 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8ITransform})).f(tls, (ref + uintptr(VP8Scan[n])), ((bp) /* &tmp[0] */ + uintptr(n)*32), (yuv_out + uintptr(VP8Scan[n])), 1)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8ITransform})).f(tls, ref+uintptr(VP8Scan[n]), bp /* &tmp[0] */ +uintptr(n)*32, yuv_out+uintptr(VP8Scan[n]), 1)
}
return nz
@@ -33393,28 +33095,28 @@ func ReconstructIntra4(tls *libc.TLS, it uintptr, levels uintptr, src uintptr, y
defer tls.Free(32)
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
- var ref uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8I4ModeOffsets[mode]))
- var dqm uintptr = ((enc + 608 /* &.dqm_ */) + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.segment_ */))&0x60>>5))))*744)
+ var ref uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8I4ModeOffsets[mode])
+ var dqm uintptr = enc + 608 + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x60>>5)))*744
var nz int32 = 0
// var tmp [16]int16_t at bp, 32
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8FTransform})).f(tls, src, ref, (bp) /* &tmp[0] */)
- if (1 != 0) && ((*VP8EncIterator)(unsafe.Pointer(it)).do_trellis_ != 0) {
- var x int32 = ((*VP8EncIterator)(unsafe.Pointer(it)).i4_ & 3)
- var y int32 = ((*VP8EncIterator)(unsafe.Pointer(it)).i4_ >> 2)
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(x)*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(y)*4)))
- nz = TrellisQuantizeBlock(tls, enc, (bp) /* &tmp[0] */, levels, ctx, TYPE_I4_AC, (dqm /* &.y1_ */),
+ })(unsafe.Pointer(&struct{ uintptr }{VP8FTransform})).f(tls, src, ref, bp /* &tmp[0] */)
+ if 1 != 0 && (*VP8EncIterator)(unsafe.Pointer(it)).do_trellis_ != 0 {
+ var x int32 = (*VP8EncIterator)(unsafe.Pointer(it)).i4_ & 3
+ var y int32 = (*VP8EncIterator)(unsafe.Pointer(it)).i4_ >> 2
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + uintptr(x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(y)*4))
+ nz = TrellisQuantizeBlock(tls, enc, bp, levels, ctx, TYPE_I4_AC, dqm,
(*VP8SegmentInfo)(unsafe.Pointer(dqm)).lambda_trellis_i4_)
} else {
nz = (*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlock})).f(tls, (bp) /* &tmp[0] */, levels, (dqm /* &.y1_ */))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlock})).f(tls, bp /* &tmp[0] */, levels, dqm /* &.y1_ */)
}
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8ITransform})).f(tls, ref, (bp) /* &tmp[0] */, yuv_out, 0)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8ITransform})).f(tls, ref, bp /* &tmp[0] */, yuv_out, 0)
return nz
}
@@ -33428,33 +33130,33 @@ func ReconstructIntra4(tls *libc.TLS, it uintptr, levels uintptr, src uintptr, y
// Error is already divided by DSHIFT.
func QuantizeSingle(tls *libc.TLS, v uintptr, mtx uintptr) int32 { /* quant_enc.c:858:12: */
var V int32 = int32(*(*int16_t)(unsafe.Pointer(v)))
- var sign int32 = (libc.Bool32(V < 0))
+ var sign int32 = libc.Bool32(V < 0)
if sign != 0 {
V = -V
}
- if V > int32(*(*uint32_t)(unsafe.Pointer((mtx + 128 /* &.zthresh_ */)))) {
- var qV int32 = (QUANTDIV(tls, uint32(V), uint32(*(*uint16_t)(unsafe.Pointer((mtx + 32 /* &.iq_ */)))), *(*uint32_t)(unsafe.Pointer((mtx + 64 /* &.bias_ */)))) * int32(*(*uint16_t)(unsafe.Pointer((mtx /* &.q_ */)))))
- var err int32 = (V - qV)
+ if V > int32(*(*uint32_t)(unsafe.Pointer(mtx + 128))) {
+ var qV int32 = QUANTDIV(tls, uint32(V), uint32(*(*uint16_t)(unsafe.Pointer(mtx + 32))), *(*uint32_t)(unsafe.Pointer(mtx + 64))) * int32(*(*uint16_t)(unsafe.Pointer(mtx)))
+ var err int32 = V - qV
*(*int16_t)(unsafe.Pointer(v)) = func() int16 {
if sign != 0 {
return int16(-qV)
}
return int16(qV)
}()
- return ((func() int32 {
+ return func() int32 {
if sign != 0 {
return -err
}
return err
- }()) >> 1)
+ }() >> 1
}
*(*int16_t)(unsafe.Pointer(v)) = int16(0)
- return ((func() int32 {
+ return func() int32 {
if sign != 0 {
return -V
}
return V
- }()) >> 1)
+ }() >> 1
}
func CorrectDCValues(tls *libc.TLS, it uintptr, mtx uintptr, tmp uintptr, rd uintptr) { /* quant_enc.c:872:13: */
@@ -33467,39 +33169,39 @@ func CorrectDCValues(tls *libc.TLS, it uintptr, mtx uintptr, tmp uintptr, rd uin
// as top[]/left[] on the next block.
var ch int32
for ch = 0; ch <= 1; ch++ {
- var top uintptr = (((*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).x_)*4) + uintptr(ch)*2)
- var left uintptr = (it + 344 /* &.left_derr_ */ + uintptr(ch)*2)
- var c uintptr = (tmp + uintptr((ch*4))*32)
+ var top uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).x_)*4 + uintptr(ch)*2
+ var left uintptr = it + 344 + uintptr(ch)*2
+ var c uintptr = tmp + uintptr(ch*4)*32
var err0 int32
var err1 int32
var err2 int32
var err3 int32
- *(*int16_t)(unsafe.Pointer((c))) += int16_t((((7 * int32(*(*int8_t)(unsafe.Pointer(top)))) + (8 * int32(*(*int8_t)(unsafe.Pointer(left))))) >> (4 - 1)))
- err0 = QuantizeSingle(tls, (c), mtx)
- *(*int16_t)(unsafe.Pointer((c + 1*32))) += int16_t((((7 * int32(*(*int8_t)(unsafe.Pointer(top + 1)))) + (8 * err0)) >> (4 - 1)))
- err1 = QuantizeSingle(tls, (c + 1*32), mtx)
- *(*int16_t)(unsafe.Pointer((c + 2*32))) += int16_t((((7 * err0) + (8 * int32(*(*int8_t)(unsafe.Pointer(left + 1))))) >> (4 - 1)))
- err2 = QuantizeSingle(tls, (c + 2*32), mtx)
- *(*int16_t)(unsafe.Pointer((c + 3*32))) += int16_t((((7 * err1) + (8 * err2)) >> (4 - 1)))
- err3 = QuantizeSingle(tls, (c + 3*32), mtx)
+ *(*int16_t)(unsafe.Pointer(c)) += int16_t((7*int32(*(*int8_t)(unsafe.Pointer(top))) + 8*int32(*(*int8_t)(unsafe.Pointer(left)))) >> (4 - 1))
+ err0 = QuantizeSingle(tls, c, mtx)
+ *(*int16_t)(unsafe.Pointer(c + 1*32)) += int16_t((7*int32(*(*int8_t)(unsafe.Pointer(top + 1))) + 8*err0) >> (4 - 1))
+ err1 = QuantizeSingle(tls, c+1*32, mtx)
+ *(*int16_t)(unsafe.Pointer(c + 2*32)) += int16_t((7*err0 + 8*int32(*(*int8_t)(unsafe.Pointer(left + 1)))) >> (4 - 1))
+ err2 = QuantizeSingle(tls, c+2*32, mtx)
+ *(*int16_t)(unsafe.Pointer(c + 3*32)) += int16_t((7*err1 + 8*err2) >> (4 - 1))
+ err3 = QuantizeSingle(tls, c+3*32, mtx)
// error 'err' is bounded by mtx->q_[0] which is 132 at max. Hence
// err >> DSCALE will fit in an int8_t type if DSCALE>=1.
- *(*int8_t)(unsafe.Pointer(((rd + 868 /* &.derr */) + uintptr(ch)*3))) = int8_t(err1)
- *(*int8_t)(unsafe.Pointer(((rd + 868 /* &.derr */) + uintptr(ch)*3) + 1)) = int8_t(err2)
- *(*int8_t)(unsafe.Pointer(((rd + 868 /* &.derr */) + uintptr(ch)*3) + 2)) = int8_t(err3)
+ *(*int8_t)(unsafe.Pointer(rd + 868 + uintptr(ch)*3)) = int8_t(err1)
+ *(*int8_t)(unsafe.Pointer(rd + 868 + uintptr(ch)*3 + 1)) = int8_t(err2)
+ *(*int8_t)(unsafe.Pointer(rd + 868 + uintptr(ch)*3 + 2)) = int8_t(err3)
}
}
func StoreDiffusionErrors(tls *libc.TLS, it uintptr, rd uintptr) { /* quant_enc.c:905:13: */
var ch int32
for ch = 0; ch <= 1; ch++ {
- var top uintptr = (((*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).x_)*4) + uintptr(ch)*2)
- var left uintptr = (it + 344 /* &.left_derr_ */ + uintptr(ch)*2)
- *(*int8_t)(unsafe.Pointer(left)) = *(*int8_t)(unsafe.Pointer(((rd + 868 /* &.derr */) + uintptr(ch)*3))) // restore err1
- *(*int8_t)(unsafe.Pointer(left + 1)) = (int8_t((3 * int32(*(*int8_t)(unsafe.Pointer(((rd + 868 /* &.derr */) + uintptr(ch)*3) + 2)))) >> 2)) // ... 3/4th of err3
- *(*int8_t)(unsafe.Pointer(top)) = *(*int8_t)(unsafe.Pointer(((rd + 868 /* &.derr */) + uintptr(ch)*3) + 1)) // ... err2
- *(*int8_t)(unsafe.Pointer(top + 1)) = (int8_t(int32(*(*int8_t)(unsafe.Pointer(((rd + 868 /* &.derr */) + uintptr(ch)*3) + 2))) - int32(*(*int8_t)(unsafe.Pointer(left + 1))))) // ... 1/4th of err3.
+ var top uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).x_)*4 + uintptr(ch)*2
+ var left uintptr = it + 344 + uintptr(ch)*2
+ *(*int8_t)(unsafe.Pointer(left)) = *(*int8_t)(unsafe.Pointer(rd + 868 + uintptr(ch)*3)) // restore err1
+ *(*int8_t)(unsafe.Pointer(left + 1)) = int8_t(3 * int32(*(*int8_t)(unsafe.Pointer(rd + 868 + uintptr(ch)*3 + 2))) >> 2) // ... 3/4th of err3
+ *(*int8_t)(unsafe.Pointer(top)) = *(*int8_t)(unsafe.Pointer(rd + 868 + uintptr(ch)*3 + 1)) // ... err2
+ *(*int8_t)(unsafe.Pointer(top + 1)) = int8_t(int32(*(*int8_t)(unsafe.Pointer(rd + 868 + uintptr(ch)*3 + 2))) - int32(*(*int8_t)(unsafe.Pointer(left + 1)))) // ... 1/4th of err3.
}
}
@@ -33510,29 +33212,29 @@ func ReconstructUV(tls *libc.TLS, it uintptr, rd uintptr, yuv_out uintptr, mode
defer tls.Free(256)
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
- var ref uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8UVModeOffsets[mode]))
- var src uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((16)))
- var dqm uintptr = ((enc + 608 /* &.dqm_ */) + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.segment_ */))&0x60>>5))))*744)
+ var ref uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8UVModeOffsets[mode])
+ var src uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr(16)
+ var dqm uintptr = enc + 608 + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x60>>5)))*744
var nz int32 = 0
var n int32
// var tmp [8][16]int16_t at bp, 256
- for n = 0; n < 8; n = n + (2) {
+ for n = 0; n < 8; n = n + 2 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8FTransform2})).f(tls, (src + uintptr(VP8ScanUV[n])), (ref + uintptr(VP8ScanUV[n])), ((bp) /* &tmp[0] */ + uintptr(n)*32))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8FTransform2})).f(tls, src+uintptr(VP8ScanUV[n]), ref+uintptr(VP8ScanUV[n]), bp /* &tmp[0] */ +uintptr(n)*32)
}
- if (*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ != (uintptr(0)) {
- CorrectDCValues(tls, it, (dqm + 448 /* &.uv_ */), (bp) /* &tmp[0] */, rd)
+ if (*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ != uintptr(0) {
+ CorrectDCValues(tls, it, dqm+448, bp, rd)
}
- if (0 != 0) && ((*VP8EncIterator)(unsafe.Pointer(it)).do_trellis_ != 0) {
+ if 0 != 0 && (*VP8EncIterator)(unsafe.Pointer(it)).do_trellis_ != 0 {
var ch int32
var x int32
var y int32
ch = 0
n = 0
- for ; ch <= 2; ch = ch + (2) {
+ for ; ch <= 2; ch = ch + 2 {
for y = 0; y < 2; y++ {
x = 0
__1:
@@ -33540,12 +33242,12 @@ func ReconstructUV(tls *libc.TLS, it uintptr, rd uintptr, yuv_out uintptr, mode
goto __3
}
{
- var ctx int32 = (*(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(((4+ch)+x))*4)) + *(*int32)(unsafe.Pointer((it + 168 /* &.left_nz_ */) + uintptr(((4+ch)+y))*4)))
+ var ctx int32 = *(*int32)(unsafe.Pointer(it + 132 + uintptr(4+ch+x)*4)) + *(*int32)(unsafe.Pointer(it + 168 + uintptr(4+ch+y)*4))
var non_zero int32 = TrellisQuantizeBlock(tls,
- enc, ((bp) /* &tmp[0] */ + uintptr(n)*32), ((rd + 584 /* &.uv_levels */) + uintptr(n)*32), ctx, TYPE_CHROMA_A, (dqm + 448 /* &.uv_ */),
+ enc, bp+uintptr(n)*32, rd+584+uintptr(n)*32, ctx, TYPE_CHROMA_A, dqm+448,
(*VP8SegmentInfo)(unsafe.Pointer(dqm)).lambda_trellis_uv_)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(((4+ch)+x))*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + uintptr(((4+ch)+y))*4), non_zero)
- nz = nz | (non_zero << n)
+ *(*int32)(unsafe.Pointer(it + 132 + uintptr(4+ch+x)*4)) = libc.AssignPtrInt32(it+168+uintptr(4+ch+y)*4, non_zero)
+ nz = nz | non_zero<<n
}
goto __2
@@ -33558,19 +33260,19 @@ func ReconstructUV(tls *libc.TLS, it uintptr, rd uintptr, yuv_out uintptr, mode
}
}
} else {
- for n = 0; n < 8; n = n + (2) {
- nz = nz | ((*struct {
+ for n = 0; n < 8; n = n + 2 {
+ nz = nz | (*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantize2Blocks})).f(tls, ((bp) /* &tmp[0] */ +uintptr(n)*32), ((rd+584 /* &.uv_levels */)+uintptr(n)*32), (dqm+448 /* &.uv_ */)) << n)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantize2Blocks})).f(tls, bp+uintptr(n)*32, rd+584+uintptr(n)*32, dqm+448)<<n
}
}
- for n = 0; n < 8; n = n + (2) {
+ for n = 0; n < 8; n = n + 2 {
(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8ITransform})).f(tls, (ref + uintptr(VP8ScanUV[n])), ((bp) /* &tmp[0] */ + uintptr(n)*32), (yuv_out + uintptr(VP8ScanUV[n])), 1)
+ })(unsafe.Pointer(&struct{ uintptr }{VP8ITransform})).f(tls, ref+uintptr(VP8ScanUV[n]), bp /* &tmp[0] */ +uintptr(n)*32, yuv_out+uintptr(VP8ScanUV[n]), 1)
}
- return (nz << 16)
+ return nz << 16
}
//------------------------------------------------------------------------------
@@ -33612,7 +33314,7 @@ func SwapPtr(tls *libc.TLS, a uintptr, b uintptr) { /* quant_enc.c:987:13: */
}
func SwapOut(tls *libc.TLS, it uintptr) { /* quant_enc.c:993:13: */
- SwapPtr(tls, (it + 16 /* &.yuv_out_ */), (it + 24 /* &.yuv_out2_ */))
+ SwapPtr(tls, it+16, it+24)
}
func PickBestIntra16(tls *libc.TLS, it uintptr, rd uintptr) { /* quant_enc.c:997:13: */
@@ -33620,20 +33322,20 @@ func PickBestIntra16(tls *libc.TLS, it uintptr, rd uintptr) { /* quant_enc.c:997
defer tls.Free(896)
var kNumBlocks int32 = 16
- var dqm uintptr = (((*VP8EncIterator)(unsafe.Pointer(it)).enc_ + 608 /* &.dqm_ */) + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.segment_ */))&0x60>>5))))*744)
+ var dqm uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_ + 608 + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x60>>5)))*744
var lambda int32 = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).lambda_i16_
var tlambda int32 = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).tlambda_
- var src uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((0)))
+ var src uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr(0)
// var rd_tmp VP8ModeScore at bp, 880
- *(*uintptr)(unsafe.Pointer(bp + 880 /* rd_cur */)) = (bp) /* &rd_tmp */
+ *(*uintptr)(unsafe.Pointer(bp + 880 /* rd_cur */)) = bp /* &rd_tmp */
*(*uintptr)(unsafe.Pointer(bp + 888 /* rd_best */)) = rd
var mode int32
- var is_flat int32 = IsFlatSource16(tls, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((0))))
+ var is_flat int32 = IsFlatSource16(tls, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_+uintptr(0))
(*VP8ModeScore)(unsafe.Pointer(rd)).mode_i16 = -1
for mode = 0; mode < NUM_PRED_MODES; mode++ {
- var tmp_dst uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr((0))) // scratch buffer
+ var tmp_dst uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr(0) // scratch buffer
(*VP8ModeScore)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 880 /* rd_cur */)))).mode_i16 = mode
// Reconstruct
@@ -33645,9 +33347,9 @@ func PickBestIntra16(tls *libc.TLS, it uintptr, rd uintptr) { /* quant_enc.c:997
})(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x16})).f(tls, src, tmp_dst))
(*VP8ModeScore)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 880 /* rd_cur */)))).SD = func() int64 {
if tlambda != 0 {
- return (int64((((tlambda) * ((*struct {
+ return int64((tlambda*(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8TDisto16x16})).f(tls, src, tmp_dst, uintptr(unsafe.Pointer(&kWeightY))))) + 128) >> 8))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8TDisto16x16})).f(tls, src, tmp_dst, uintptr(unsafe.Pointer(&kWeightY))) + 128) >> 8)
}
return int64(0)
}()
@@ -33655,22 +33357,22 @@ func PickBestIntra16(tls *libc.TLS, it uintptr, rd uintptr) { /* quant_enc.c:997
(*VP8ModeScore)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 880 /* rd_cur */)))).R = score_t(VP8GetCostLuma16(tls, it, *(*uintptr)(unsafe.Pointer(bp + 880 /* rd_cur */))))
if is_flat != 0 {
// refine the first impression (which was in pixel space)
- is_flat = IsFlat_C(tls, (*(*uintptr)(unsafe.Pointer(bp + 880 /* rd_cur */)) + 72 /* &.y_ac_levels */), kNumBlocks, 0)
+ is_flat = IsFlat_C(tls, *(*uintptr)(unsafe.Pointer(bp + 880))+72, kNumBlocks, 0)
if is_flat != 0 {
// Block is very flat. We put emphasis on the distortion being very low!
- *(*score_t)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(bp + 880 /* rd_cur */)) /* &.D */))) *= (int64(2))
- *(*score_t)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(bp + 880 /* rd_cur */)) + 8 /* &.SD */))) *= (int64(2))
+ *(*score_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 880)))) *= int64(2)
+ *(*score_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 880)) + 8)) *= int64(2)
}
}
// Since we always examine Intra16 first, we can overwrite *rd directly.
SetRDScore(tls, lambda, *(*uintptr)(unsafe.Pointer(bp + 880 /* rd_cur */)))
- if (mode == 0) || ((*VP8ModeScore)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 880 /* rd_cur */)))).score < (*VP8ModeScore)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 888 /* rd_best */)))).score) {
- SwapModeScore(tls, (bp + 880) /* &rd_cur */, (bp + 888) /* &rd_best */)
+ if mode == 0 || (*VP8ModeScore)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 880)))).score < (*VP8ModeScore)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 888)))).score {
+ SwapModeScore(tls, bp+880, bp+888)
SwapOut(tls, it)
}
}
- if *(*uintptr)(unsafe.Pointer(bp + 888 /* rd_best */)) != rd {
+ if *(*uintptr)(unsafe.Pointer(bp + 888)) != rd {
libc.Xmemcpy(tls, rd, *(*uintptr)(unsafe.Pointer(bp + 888 /* rd_best */)), uint64(unsafe.Sizeof(VP8ModeScore{})))
}
SetRDScore(tls, (*VP8SegmentInfo)(unsafe.Pointer(dqm)).lambda_mode_, rd) // finalize score for mode decision.
@@ -33679,8 +33381,8 @@ func PickBestIntra16(tls *libc.TLS, it uintptr, rd uintptr) { /* quant_enc.c:997
// we have a blocky macroblock (only DCs are non-zero) with fairly high
// distortion, record max delta so we can later adjust the minimal filtering
// strength needed to smooth these blocks out.
- if (((*VP8ModeScore)(unsafe.Pointer(rd)).nz & uint32_t(0x100ffff)) == uint32_t(0x1000000)) && ((*VP8ModeScore)(unsafe.Pointer(rd)).D > score_t((*VP8SegmentInfo)(unsafe.Pointer(dqm)).min_disto_)) {
- StoreMaxDelta(tls, dqm, (rd + 40 /* &.y_dc_levels */))
+ if (*VP8ModeScore)(unsafe.Pointer(rd)).nz&uint32_t(0x100ffff) == uint32_t(0x1000000) && (*VP8ModeScore)(unsafe.Pointer(rd)).D > score_t((*VP8SegmentInfo)(unsafe.Pointer(dqm)).min_disto_) {
+ StoreMaxDelta(tls, dqm, rd+40)
}
}
@@ -33689,21 +33391,21 @@ func PickBestIntra16(tls *libc.TLS, it uintptr, rd uintptr) { /* quant_enc.c:997
// return the cost array corresponding to the surrounding prediction modes.
func GetCostModeI4(tls *libc.TLS, it uintptr, modes uintptr) uintptr { /* quant_enc.c:1057:22: */
var preds_w int32 = (*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).enc_)).preds_w_
- var x int32 = ((*VP8EncIterator)(unsafe.Pointer(it)).i4_ & 3)
- var y int32 = ((*VP8EncIterator)(unsafe.Pointer(it)).i4_ >> 2)
+ var x int32 = (*VP8EncIterator)(unsafe.Pointer(it)).i4_ & 3
+ var y int32 = (*VP8EncIterator)(unsafe.Pointer(it)).i4_ >> 2
var left int32
if x == 0 {
- left = int32(*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).preds_ + uintptr(((y * preds_w) - 1)))))
+ left = int32(*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).preds_ + uintptr(y*preds_w-1))))
} else {
- left = int32(*(*uint8_t)(unsafe.Pointer(modes + uintptr(((*VP8EncIterator)(unsafe.Pointer(it)).i4_ - 1)))))
+ left = int32(*(*uint8_t)(unsafe.Pointer(modes + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_-1))))
}
var top int32
if y == 0 {
- top = int32(*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).preds_ + uintptr((-preds_w + x)))))
+ top = int32(*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).preds_ + uintptr(-preds_w+x))))
} else {
- top = int32(*(*uint8_t)(unsafe.Pointer(modes + uintptr(((*VP8EncIterator)(unsafe.Pointer(it)).i4_ - 4)))))
+ top = int32(*(*uint8_t)(unsafe.Pointer(modes + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_-4))))
}
- return ((uintptr(unsafe.Pointer(&VP8FixedCostsI4)) + uintptr(top)*200) + uintptr(left)*20)
+ return uintptr(unsafe.Pointer(&VP8FixedCostsI4)) + uintptr(top)*200 + uintptr(left)*20
}
func PickBestIntra4(tls *libc.TLS, it uintptr, rd uintptr) int32 { /* quant_enc.c:1066:12: */
@@ -33711,11 +33413,11 @@ func PickBestIntra4(tls *libc.TLS, it uintptr, rd uintptr) int32 { /* quant_enc.
defer tls.Free(2688)
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
- var dqm uintptr = ((enc + 608 /* &.dqm_ */) + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.segment_ */))&0x60>>5))))*744)
+ var dqm uintptr = enc + 608 + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x60>>5)))*744
var lambda int32 = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).lambda_i4_
var tlambda int32 = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).tlambda_
- var src0 uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((0)))
- var best_blocks uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr((0)))
+ var src0 uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr(0)
+ var best_blocks uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr(0)
var total_header_bits int32 = 0
// var rd_best VP8ModeScore at bp, 880
@@ -33723,22 +33425,22 @@ func PickBestIntra4(tls *libc.TLS, it uintptr, rd uintptr) int32 { /* quant_enc.
return 0
}
- InitScore(tls, (bp) /* &rd_best */)
+ InitScore(tls, bp)
(*VP8ModeScore)(unsafe.Pointer(bp /* &rd_best */)).H = int64(211) // '211' is the value of VP8BitCost(0, 145)
- SetRDScore(tls, (*VP8SegmentInfo)(unsafe.Pointer(dqm)).lambda_mode_, (bp) /* &rd_best */)
+ SetRDScore(tls, (*VP8SegmentInfo)(unsafe.Pointer(dqm)).lambda_mode_, bp)
VP8IteratorStartI4(tls, it)
- for ok := true; ok; ok = (VP8IteratorRotateI4(tls, it, best_blocks) != 0) {
+ for __ccgo := true; __ccgo; __ccgo = VP8IteratorRotateI4(tls, it, best_blocks) != 0 {
var kNumBlocks int32 = 1
// var rd_i4 VP8ModeScore at bp+880, 880
var mode int32
var best_mode int32 = -1
- var src uintptr = (src0 + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_]))
- var mode_costs uintptr = GetCostModeI4(tls, it, (rd + 844 /* &.modes_i4 */))
- *(*uintptr)(unsafe.Pointer(bp + 2680 /* best_block */)) = (best_blocks + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_]))
- *(*uintptr)(unsafe.Pointer(bp + 2672 /* tmp_dst */)) = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(((((3 * 16) * 32) + (4 * 32)) + 8))) // scratch buffer.
+ var src uintptr = src0 + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_])
+ var mode_costs uintptr = GetCostModeI4(tls, it, rd+844)
+ *(*uintptr)(unsafe.Pointer(bp + 2680 /* best_block */)) = best_blocks + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_])
+ *(*uintptr)(unsafe.Pointer(bp + 2672 /* tmp_dst */)) = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(3*16*32+4*32+8) // scratch buffer.
- InitScore(tls, (bp + 880) /* &rd_i4 */)
+ InitScore(tls, bp+880)
VP8MakeIntra4Preds(tls, it)
for mode = 0; mode < NUM_BMODES; mode++ {
// var rd_tmp VP8ModeScore at bp+1792, 880
@@ -33746,7 +33448,7 @@ func PickBestIntra4(tls *libc.TLS, it uintptr, rd uintptr) int32 { /* quant_enc.
// var tmp_levels [16]int16_t at bp+1760, 32
// Reconstruct
- (*VP8ModeScore)(unsafe.Pointer(bp + 1792 /* &rd_tmp */)).nz = (uint32_t(ReconstructIntra4(tls, it, (bp+1760) /* &tmp_levels[0] */, src, *(*uintptr)(unsafe.Pointer(bp + 2672 /* tmp_dst */)), mode) << (*VP8EncIterator)(unsafe.Pointer(it)).i4_))
+ (*VP8ModeScore)(unsafe.Pointer(bp + 1792 /* &rd_tmp */)).nz = uint32_t(ReconstructIntra4(tls, it, bp+1760, src, *(*uintptr)(unsafe.Pointer(bp + 2672)), mode) << (*VP8EncIterator)(unsafe.Pointer(it)).i4_)
// Compute RD-score
(*VP8ModeScore)(unsafe.Pointer(bp + 1792 /* &rd_tmp */)).D = score_t((*struct {
@@ -33754,9 +33456,9 @@ func PickBestIntra4(tls *libc.TLS, it uintptr, rd uintptr) int32 { /* quant_enc.
})(unsafe.Pointer(&struct{ uintptr }{VP8SSE4x4})).f(tls, src, *(*uintptr)(unsafe.Pointer(bp + 2672 /* tmp_dst */))))
(*VP8ModeScore)(unsafe.Pointer(bp + 1792 /* &rd_tmp */)).SD = func() int64 {
if tlambda != 0 {
- return (int64((((tlambda) * ((*struct {
+ return int64((tlambda*(*struct {
f func(*libc.TLS, uintptr, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8TDisto4x4})).f(tls, src, *(*uintptr)(unsafe.Pointer(bp + 2672 /* tmp_dst */)), uintptr(unsafe.Pointer(&kWeightY))))) + 128) >> 8))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8TDisto4x4})).f(tls, src, *(*uintptr)(unsafe.Pointer(bp + 2672)), uintptr(unsafe.Pointer(&kWeightY))) + 128) >> 8)
}
return int64(0)
}()
@@ -33764,59 +33466,59 @@ func PickBestIntra4(tls *libc.TLS, it uintptr, rd uintptr) int32 { /* quant_enc.
// Add flatness penalty, to avoid flat area to be mispredicted
// by a complex mode.
- if (mode > 0) && (IsFlat_C(tls, (bp+1760) /* &tmp_levels[0] */, kNumBlocks, 3) != 0) {
- (*VP8ModeScore)(unsafe.Pointer(bp + 1792 /* &rd_tmp */)).R = (score_t(140 * kNumBlocks))
+ if mode > 0 && IsFlat_C(tls, bp+1760, kNumBlocks, 3) != 0 {
+ (*VP8ModeScore)(unsafe.Pointer(bp + 1792 /* &rd_tmp */)).R = score_t(140 * kNumBlocks)
} else {
(*VP8ModeScore)(unsafe.Pointer(bp + 1792 /* &rd_tmp */)).R = int64(0)
}
// early-out check
- SetRDScore(tls, lambda, (bp + 1792) /* &rd_tmp */)
- if (best_mode >= 0) && ((*VP8ModeScore)(unsafe.Pointer(bp+1792 /* &rd_tmp */)).score >= (*VP8ModeScore)(unsafe.Pointer(bp+880 /* &rd_i4 */)).score) {
+ SetRDScore(tls, lambda, bp+1792)
+ if best_mode >= 0 && (*VP8ModeScore)(unsafe.Pointer(bp+1792)).score >= (*VP8ModeScore)(unsafe.Pointer(bp+880)).score {
continue
}
// finish computing score
- *(*score_t)(unsafe.Pointer(((bp + 1792) /* &rd_tmp */ + 24 /* &.R */))) += (score_t(VP8GetCostLuma4(tls, it, (bp + 1760) /* &tmp_levels[0] */)))
- SetRDScore(tls, lambda, (bp + 1792) /* &rd_tmp */)
+ *(*score_t)(unsafe.Pointer(bp + 1792 + 24)) += score_t(VP8GetCostLuma4(tls, it, bp+1760))
+ SetRDScore(tls, lambda, bp+1792)
- if (best_mode < 0) || ((*VP8ModeScore)(unsafe.Pointer(bp+1792 /* &rd_tmp */)).score < (*VP8ModeScore)(unsafe.Pointer(bp+880 /* &rd_i4 */)).score) {
- CopyScore(tls, (bp + 880) /* &rd_i4 */, (bp + 1792) /* &rd_tmp */)
+ if best_mode < 0 || (*VP8ModeScore)(unsafe.Pointer(bp+1792)).score < (*VP8ModeScore)(unsafe.Pointer(bp+880)).score {
+ CopyScore(tls, bp+880, bp+1792)
best_mode = mode
- SwapPtr(tls, (bp + 2672) /* &tmp_dst */, (bp + 2680) /* &best_block */)
- libc.Xmemcpy(tls, (((bp) /* &rd_best */ + 72 /* &.y_ac_levels */) + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_)*32), (bp + 1760), /* &tmp_levels[0] */
+ SwapPtr(tls, bp+2672, bp+2680)
+ libc.Xmemcpy(tls, bp+72+uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_)*32, bp+1760,
uint64(unsafe.Sizeof([16]int16_t{})))
}
}
- SetRDScore(tls, (*VP8SegmentInfo)(unsafe.Pointer(dqm)).lambda_mode_, (bp + 880) /* &rd_i4 */)
- AddScore(tls, (bp) /* &rd_best */, (bp + 880) /* &rd_i4 */)
- if (*VP8ModeScore)(unsafe.Pointer(bp /* &rd_best */)).score >= (*VP8ModeScore)(unsafe.Pointer(rd)).score {
+ SetRDScore(tls, (*VP8SegmentInfo)(unsafe.Pointer(dqm)).lambda_mode_, bp+880)
+ AddScore(tls, bp, bp+880)
+ if (*VP8ModeScore)(unsafe.Pointer(bp)).score >= (*VP8ModeScore)(unsafe.Pointer(rd)).score {
return 0
}
- total_header_bits = total_header_bits + (int32((*VP8ModeScore)(unsafe.Pointer(bp + 880 /* &rd_i4 */)).H)) // <- equal to mode_costs[best_mode];
+ total_header_bits = total_header_bits + int32((*VP8ModeScore)(unsafe.Pointer(bp+880)).H) // <- equal to mode_costs[best_mode];
if total_header_bits > (*VP8Encoder)(unsafe.Pointer(enc)).max_i4_header_bits_ {
return 0
}
// Copy selected samples if not in the right place already.
- if *(*uintptr)(unsafe.Pointer(bp + 2680 /* best_block */)) != (best_blocks + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_])) {
+ if *(*uintptr)(unsafe.Pointer(bp + 2680)) != best_blocks+uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_]) {
(*struct {
f func(*libc.TLS, uintptr, uintptr)
- })(unsafe.Pointer(&struct{ uintptr }{VP8Copy4x4})).f(tls, *(*uintptr)(unsafe.Pointer(bp + 2680 /* best_block */)), (best_blocks + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_])))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8Copy4x4})).f(tls, *(*uintptr)(unsafe.Pointer(bp + 2680 /* best_block */)), best_blocks+uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_]))
}
- *(*uint8_t)(unsafe.Pointer((rd + 844 /* &.modes_i4 */) + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_))) = uint8_t(best_mode)
- *(*int32)(unsafe.Pointer((it + 132 /* &.top_nz_ */) + uintptr(((*VP8EncIterator)(unsafe.Pointer(it)).i4_&3))*4)) = libc.AssignPtrInt32(((it + 168 /* &.left_nz_ */) + uintptr(((*VP8EncIterator)(unsafe.Pointer(it)).i4_>>2))*4), (func() int32 {
- if (*VP8ModeScore)(unsafe.Pointer(bp+880 /* &rd_i4 */)).nz != 0 {
+ *(*uint8_t)(unsafe.Pointer(rd + 844 + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_))) = uint8_t(best_mode)
+ *(*int32)(unsafe.Pointer(it + 132 + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_&3)*4)) = libc.AssignPtrInt32(it+168+uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_>>2)*4, func() int32 {
+ if (*VP8ModeScore)(unsafe.Pointer(bp+880)).nz != 0 {
return 1
}
return 0
- }()))
+ }())
}
// finalize state
- CopyScore(tls, rd, (bp) /* &rd_best */)
- VP8SetIntra4Mode(tls, it, (rd + 844 /* &.modes_i4 */))
+ CopyScore(tls, rd, bp)
+ VP8SetIntra4Mode(tls, it, rd+844)
SwapOut(tls, it)
- libc.Xmemcpy(tls, (rd + 72 /* &.y_ac_levels */), ((bp) /* &rd_best */ + 72 /* &.y_ac_levels */), uint64(unsafe.Sizeof([16][16]int16_t{})))
+ libc.Xmemcpy(tls, rd+72, bp+72, uint64(unsafe.Sizeof([16][16]int16_t{})))
return 1 // select intra4x4 over intra16x16
}
@@ -33827,23 +33529,23 @@ func PickBestUV(tls *libc.TLS, it uintptr, rd uintptr) { /* quant_enc.c:1162:13:
defer tls.Free(1776)
var kNumBlocks int32 = 8
- var dqm uintptr = (((*VP8EncIterator)(unsafe.Pointer(it)).enc_ + 608 /* &.dqm_ */) + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.segment_ */))&0x60>>5))))*744)
+ var dqm uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_ + 608 + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x60>>5)))*744
var lambda int32 = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).lambda_uv_
- var src uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((16)))
- *(*uintptr)(unsafe.Pointer(bp + 1768 /* tmp_dst */)) = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr((16))) // scratch buffer
- var dst0 uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((16)))
+ var src uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr(16)
+ *(*uintptr)(unsafe.Pointer(bp + 1768 /* tmp_dst */)) = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr(16) // scratch buffer
+ var dst0 uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr(16)
*(*uintptr)(unsafe.Pointer(bp + 1760 /* dst */)) = dst0
// var rd_best VP8ModeScore at bp, 880
var mode int32
(*VP8ModeScore)(unsafe.Pointer(rd)).mode_uv = -1
- InitScore(tls, (bp) /* &rd_best */)
+ InitScore(tls, bp)
for mode = 0; mode < NUM_PRED_MODES; mode++ {
// var rd_uv VP8ModeScore at bp+880, 880
// Reconstruct
- (*VP8ModeScore)(unsafe.Pointer(bp + 880 /* &rd_uv */)).nz = uint32_t(ReconstructUV(tls, it, (bp + 880) /* &rd_uv */, *(*uintptr)(unsafe.Pointer(bp + 1768 /* tmp_dst */)), mode))
+ (*VP8ModeScore)(unsafe.Pointer(bp + 880 /* &rd_uv */)).nz = uint32_t(ReconstructUV(tls, it, bp+880, *(*uintptr)(unsafe.Pointer(bp + 1768 /* tmp_dst */)), mode))
// Compute RD-score
(*VP8ModeScore)(unsafe.Pointer(bp + 880 /* &rd_uv */)).D = score_t((*struct {
@@ -33851,30 +33553,30 @@ func PickBestUV(tls *libc.TLS, it uintptr, rd uintptr) { /* quant_enc.c:1162:13:
})(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x8})).f(tls, src, *(*uintptr)(unsafe.Pointer(bp + 1768 /* tmp_dst */))))
(*VP8ModeScore)(unsafe.Pointer(bp + 880 /* &rd_uv */)).SD = int64(0) // not calling TDisto here: it tends to flatten areas.
(*VP8ModeScore)(unsafe.Pointer(bp + 880 /* &rd_uv */)).H = score_t(VP8FixedCostsUV[mode])
- (*VP8ModeScore)(unsafe.Pointer(bp + 880 /* &rd_uv */)).R = score_t(VP8GetCostUV(tls, it, (bp + 880) /* &rd_uv */))
- if (mode > 0) && (IsFlat_C(tls, ((bp+880) /* &rd_uv */ +584 /* &.uv_levels */), kNumBlocks, 2) != 0) {
- *(*score_t)(unsafe.Pointer(((bp + 880) /* &rd_uv */ + 24 /* &.R */))) += (score_t(140 * kNumBlocks))
+ (*VP8ModeScore)(unsafe.Pointer(bp + 880 /* &rd_uv */)).R = score_t(VP8GetCostUV(tls, it, bp+880))
+ if mode > 0 && IsFlat_C(tls, bp+880+584, kNumBlocks, 2) != 0 {
+ *(*score_t)(unsafe.Pointer(bp + 880 + 24)) += score_t(140 * kNumBlocks)
}
- SetRDScore(tls, lambda, (bp + 880) /* &rd_uv */)
- if (mode == 0) || ((*VP8ModeScore)(unsafe.Pointer(bp+880 /* &rd_uv */)).score < (*VP8ModeScore)(unsafe.Pointer(bp /* &rd_best */)).score) {
- CopyScore(tls, (bp) /* &rd_best */, (bp + 880) /* &rd_uv */)
+ SetRDScore(tls, lambda, bp+880)
+ if mode == 0 || (*VP8ModeScore)(unsafe.Pointer(bp+880)).score < (*VP8ModeScore)(unsafe.Pointer(bp)).score {
+ CopyScore(tls, bp, bp+880)
(*VP8ModeScore)(unsafe.Pointer(rd)).mode_uv = mode
- libc.Xmemcpy(tls, (rd + 584 /* &.uv_levels */), ((bp + 880) /* &rd_uv */ + 584 /* &.uv_levels */), uint64(unsafe.Sizeof([8][16]int16_t{})))
- if (*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ != (uintptr(0)) {
- libc.Xmemcpy(tls, (rd + 868 /* &.derr */), ((bp + 880) /* &rd_uv */ + 868 /* &.derr */), uint64(unsafe.Sizeof([2][3]int8_t{})))
+ libc.Xmemcpy(tls, rd+584, bp+880+584, uint64(unsafe.Sizeof([8][16]int16_t{})))
+ if (*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ != uintptr(0) {
+ libc.Xmemcpy(tls, rd+868, bp+880+868, uint64(unsafe.Sizeof([2][3]int8_t{})))
}
- SwapPtr(tls, (bp + 1760) /* &dst */, (bp + 1768) /* &tmp_dst */)
+ SwapPtr(tls, bp+1760, bp+1768)
}
}
VP8SetIntraUVMode(tls, it, (*VP8ModeScore)(unsafe.Pointer(rd)).mode_uv)
- AddScore(tls, rd, (bp) /* &rd_best */)
- if *(*uintptr)(unsafe.Pointer(bp + 1760 /* dst */)) != dst0 { // copy 16x8 block if needed
+ AddScore(tls, rd, bp)
+ if *(*uintptr)(unsafe.Pointer(bp + 1760)) != dst0 { // copy 16x8 block if needed
(*struct {
f func(*libc.TLS, uintptr, uintptr)
})(unsafe.Pointer(&struct{ uintptr }{VP8Copy16x8})).f(tls, *(*uintptr)(unsafe.Pointer(bp + 1760 /* dst */)), dst0)
}
- if (*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ != (uintptr(0)) { // store diffusion errors for next block
+ if (*VP8EncIterator)(unsafe.Pointer(it)).top_derr_ != uintptr(0) { // store diffusion errors for next block
StoreDiffusionErrors(tls, it, rd)
}
}
@@ -33884,35 +33586,35 @@ func PickBestUV(tls *libc.TLS, it uintptr, rd uintptr) { /* quant_enc.c:1162:13:
func SimpleQuantize(tls *libc.TLS, it uintptr, rd uintptr) { /* quant_enc.c:1214:13: */
var enc uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_
- var is_i16 int32 = (libc.Bool32((int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.type_ */)) & 0x3 >> 0)) == 1))
+ var is_i16 int32 = libc.Bool32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x3>>0) == 1)
var nz int32 = 0
if is_i16 != 0 {
- nz = ReconstructIntra16(tls, it, rd, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((0))), int32(*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).preds_))))
+ nz = ReconstructIntra16(tls, it, rd, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_+uintptr(0), int32(*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).preds_))))
} else {
VP8IteratorStartI4(tls, it)
- for ok := true; ok; ok = (VP8IteratorRotateI4(tls, it, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_+uintptr((0)))) != 0) {
- var mode int32 = int32(*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).preds_ + uintptr((((*VP8EncIterator)(unsafe.Pointer(it)).i4_ & 3) + (((*VP8EncIterator)(unsafe.Pointer(it)).i4_ >> 2) * (*VP8Encoder)(unsafe.Pointer(enc)).preds_w_))))))
- var src uintptr = (((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((0))) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_]))
- var dst uintptr = (((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((0))) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_]))
+ for __ccgo := true; __ccgo; __ccgo = VP8IteratorRotateI4(tls, it, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_+uintptr(0)) != 0 {
+ var mode int32 = int32(*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).preds_ + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_&3+(*VP8EncIterator)(unsafe.Pointer(it)).i4_>>2*(*VP8Encoder)(unsafe.Pointer(enc)).preds_w_))))
+ var src uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr(0) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_])
+ var dst uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr(0) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_])
VP8MakeIntra4Preds(tls, it)
- nz = nz | (ReconstructIntra4(tls, it, ((rd+72 /* &.y_ac_levels */)+uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_)*32),
- src, dst, mode) << (*VP8EncIterator)(unsafe.Pointer(it)).i4_)
+ nz = nz | ReconstructIntra4(tls, it, rd+72+uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_)*32,
+ src, dst, mode)<<(*VP8EncIterator)(unsafe.Pointer(it)).i4_
}
}
- nz = nz | (ReconstructUV(tls, it, rd, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((16))), (int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.uv_mode_ */)) & 0xc >> 2))))
+ nz = nz | ReconstructUV(tls, it, rd, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_+uintptr(16), int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0xc>>2))
(*VP8ModeScore)(unsafe.Pointer(rd)).nz = uint32_t(nz)
}
// Refine intra16/intra4 sub-modes based on distortion only (not rate).
func RefineUsingDistortion(tls *libc.TLS, it uintptr, try_both_modes int32, refine_uv_mode int32, rd uintptr) { /* quant_enc.c:1239:13: */
- var best_score score_t = (0x7fffffffffffff)
+ var best_score score_t = 0x7fffffffffffff
var nz int32 = 0
var mode int32
- var is_i16 int32 = (libc.Bool32((try_both_modes != 0) || ((int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.type_ */)) & 0x3 >> 0)) == 1)))
+ var is_i16 int32 = libc.Bool32(try_both_modes != 0 || int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x3>>0) == 1)
- var dqm uintptr = (((*VP8EncIterator)(unsafe.Pointer(it)).enc_ + 608 /* &.dqm_ */) + uintptr((uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.segment_ */))&0x60>>5))))*744)
+ var dqm uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).enc_ + 608 + uintptr(uint32(int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0x60>>5)))*744
// Some empiric constants, of approximate order of magnitude.
var lambda_d_i16 int32 = 106
var lambda_d_i4 int32 = 11
@@ -33923,19 +33625,19 @@ func RefineUsingDistortion(tls *libc.TLS, it uintptr, try_both_modes int32, refi
if try_both_modes != 0 {
bit_limit = int64((*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).enc_)).mb_header_limit_)
} else {
- bit_limit = (0x7fffffffffffff)
+ bit_limit = 0x7fffffffffffff
} // no early-out allowed
if is_i16 != 0 { // First, evaluate Intra16 distortion
var best_mode int32 = -1
- var src uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((0)))
+ var src uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr(0)
for mode = 0; mode < NUM_PRED_MODES; mode++ {
- var ref uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8I16ModeOffsets[mode]))
- var score score_t = ((score_t((*struct {
+ var ref uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8I16ModeOffsets[mode])
+ var score score_t = score_t((*struct {
f func(*libc.TLS, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x16})).f(tls, src, ref)) * int64(256)) +
- (score_t(int32(VP8FixedCostsI16[mode]) * lambda_d_i16)))
- if (mode > 0) && (score_t(VP8FixedCostsI16[mode]) > bit_limit) {
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x16})).f(tls, src, ref))*int64(256) +
+ score_t(int32(VP8FixedCostsI16[mode])*lambda_d_i16)
+ if mode > 0 && score_t(VP8FixedCostsI16[mode]) > bit_limit {
continue
}
@@ -33944,7 +33646,7 @@ func RefineUsingDistortion(tls *libc.TLS, it uintptr, try_both_modes int32, refi
best_score = score
}
}
- if ((*VP8EncIterator)(unsafe.Pointer(it)).x_ == 0) || ((*VP8EncIterator)(unsafe.Pointer(it)).y_ == 0) {
+ if (*VP8EncIterator)(unsafe.Pointer(it)).x_ == 0 || (*VP8EncIterator)(unsafe.Pointer(it)).y_ == 0 {
// avoid starting a checkerboard resonance from the border. See bug #432.
if IsFlatSource16(tls, src) != 0 {
if (*VP8EncIterator)(unsafe.Pointer(it)).x_ == 0 {
@@ -33960,64 +33662,64 @@ func RefineUsingDistortion(tls *libc.TLS, it uintptr, try_both_modes int32, refi
}
// Next, evaluate Intra4
- if (try_both_modes != 0) || !(is_i16 != 0) {
+ if try_both_modes != 0 || !(is_i16 != 0) {
// We don't evaluate the rate here, but just account for it through a
// constant penalty (i4 mode usually needs more bits compared to i16).
is_i16 = 0
VP8IteratorStartI4(tls, it)
- for ok := true; ok; ok = (VP8IteratorRotateI4(tls, it, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_+uintptr((0)))) != 0) {
+ for __ccgo := true; __ccgo; __ccgo = VP8IteratorRotateI4(tls, it, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_+uintptr(0)) != 0 {
var best_i4_mode int32 = -1
- var best_i4_score score_t = (0x7fffffffffffff)
- var src uintptr = (((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((0))) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_]))
- var mode_costs uintptr = GetCostModeI4(tls, it, (rd + 844 /* &.modes_i4 */))
+ var best_i4_score score_t = 0x7fffffffffffff
+ var src uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr(0) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_])
+ var mode_costs uintptr = GetCostModeI4(tls, it, rd+844)
VP8MakeIntra4Preds(tls, it)
for mode = 0; mode < NUM_BMODES; mode++ {
- var ref uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8I4ModeOffsets[mode]))
- var score score_t = (score_t(((*struct {
+ var ref uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8I4ModeOffsets[mode])
+ var score score_t = score_t((*struct {
f func(*libc.TLS, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSE4x4})).f(tls, src, ref) * 256) +
- (int32(*(*uint16_t)(unsafe.Pointer(mode_costs + uintptr(mode)*2))) * lambda_d_i4)))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSE4x4})).f(tls, src, ref)*256 +
+ int32(*(*uint16_t)(unsafe.Pointer(mode_costs + uintptr(mode)*2)))*lambda_d_i4)
if score < best_i4_score {
best_i4_mode = mode
best_i4_score = score
}
}
- i4_bit_sum = i4_bit_sum + (score_t(*(*uint16_t)(unsafe.Pointer(mode_costs + uintptr(best_i4_mode)*2))))
- *(*uint8_t)(unsafe.Pointer((rd + 844 /* &.modes_i4 */) + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_))) = uint8_t(best_i4_mode)
- score_i4 = score_i4 + (best_i4_score)
- if (score_i4 >= best_score) || (i4_bit_sum > bit_limit) {
+ i4_bit_sum = i4_bit_sum + score_t(*(*uint16_t)(unsafe.Pointer(mode_costs + uintptr(best_i4_mode)*2)))
+ *(*uint8_t)(unsafe.Pointer(rd + 844 + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_))) = uint8_t(best_i4_mode)
+ score_i4 = score_i4 + best_i4_score
+ if score_i4 >= best_score || i4_bit_sum > bit_limit {
// Intra4 won't be better than Intra16. Bail out and pick Intra16.
is_i16 = 1
break
} else { // reconstruct partial block inside yuv_out2_ buffer
- var tmp_dst uintptr = (((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr((0))) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_]))
- nz = nz | (ReconstructIntra4(tls, it, ((rd+72 /* &.y_ac_levels */)+uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_)*32),
- src, tmp_dst, best_i4_mode) << (*VP8EncIterator)(unsafe.Pointer(it)).i4_)
+ var tmp_dst uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out2_ + uintptr(0) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).i4_])
+ nz = nz | ReconstructIntra4(tls, it, rd+72+uintptr((*VP8EncIterator)(unsafe.Pointer(it)).i4_)*32,
+ src, tmp_dst, best_i4_mode)<<(*VP8EncIterator)(unsafe.Pointer(it)).i4_
}
}
}
// Final reconstruction, depending on which mode is selected.
if !(is_i16 != 0) {
- VP8SetIntra4Mode(tls, it, (rd + 844 /* &.modes_i4 */))
+ VP8SetIntra4Mode(tls, it, rd+844)
SwapOut(tls, it)
best_score = score_i4
} else {
- nz = ReconstructIntra16(tls, it, rd, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((0))), int32(*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).preds_))))
+ nz = ReconstructIntra16(tls, it, rd, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_+uintptr(0), int32(*(*uint8_t)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).preds_))))
}
// ... and UV!
if refine_uv_mode != 0 {
var best_mode int32 = -1
- var best_uv_score score_t = (0x7fffffffffffff)
- var src uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr((16)))
+ var best_uv_score score_t = 0x7fffffffffffff
+ var src uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_in_ + uintptr(16)
for mode = 0; mode < NUM_PRED_MODES; mode++ {
- var ref uintptr = ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8UVModeOffsets[mode]))
- var score score_t = (score_t(((*struct {
+ var ref uintptr = (*VP8EncIterator)(unsafe.Pointer(it)).yuv_p_ + uintptr(VP8UVModeOffsets[mode])
+ var score score_t = score_t((*struct {
f func(*libc.TLS, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x8})).f(tls, src, ref) * 256) +
- (int32(VP8FixedCostsUV[mode]) * lambda_d_uv)))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x8})).f(tls, src, ref)*256 +
+ int32(VP8FixedCostsUV[mode])*lambda_d_uv)
if score < best_uv_score {
best_mode = mode
best_uv_score = score
@@ -34025,7 +33727,7 @@ func RefineUsingDistortion(tls *libc.TLS, it uintptr, try_both_modes int32, refi
}
VP8SetIntraUVMode(tls, it, best_mode)
}
- nz = nz | (ReconstructUV(tls, it, rd, ((*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_ + uintptr((16))), (int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_ /* &.uv_mode_ */)) & 0xc >> 2))))
+ nz = nz | ReconstructUV(tls, it, rd, (*VP8EncIterator)(unsafe.Pointer(it)).yuv_out_+uintptr(16), int32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).mb_))&0xc>>2))
(*VP8ModeScore)(unsafe.Pointer(rd)).nz = uint32_t(nz)
(*VP8ModeScore)(unsafe.Pointer(rd)).score = best_score
@@ -34046,7 +33748,7 @@ func VP8Decimate(tls *libc.TLS, it uintptr, rd uintptr, rd_opt VP8RDLevel) int32
VP8MakeChroma8Preds(tls, it)
if rd_opt > RD_OPT_NONE {
- (*VP8EncIterator)(unsafe.Pointer(it)).do_trellis_ = (libc.Bool32(rd_opt >= RD_OPT_TRELLIS_ALL))
+ (*VP8EncIterator)(unsafe.Pointer(it)).do_trellis_ = libc.Bool32(rd_opt >= RD_OPT_TRELLIS_ALL)
PickBestIntra16(tls, it, rd)
if method >= 2 {
PickBestIntra4(tls, it, rd)
@@ -34061,9 +33763,9 @@ func VP8Decimate(tls *libc.TLS, it uintptr, rd uintptr, rd_opt VP8RDLevel) int32
// For method >= 2, pick the best intra4/intra16 based on SSE (~tad slower).
// For method <= 1, we don't re-examine the decision but just go ahead with
// quantization/reconstruction.
- RefineUsingDistortion(tls, it, (libc.Bool32(method >= 2)), (libc.Bool32(method >= 1)), rd)
+ RefineUsingDistortion(tls, it, libc.Bool32(method >= 2), libc.Bool32(method >= 1), rd)
}
- is_skipped = (libc.Bool32((*VP8ModeScore)(unsafe.Pointer(rd)).nz == uint32_t(0)))
+ is_skipped = libc.Bool32((*VP8ModeScore)(unsafe.Pointer(rd)).nz == uint32_t(0))
VP8SetSkip(tls, it, is_skipped)
return is_skipped
}
@@ -34074,7 +33776,7 @@ func VP8Decimate(tls *libc.TLS, it uintptr, rd uintptr, rd_opt VP8RDLevel) int32
// Helper functions
func IsVP8XNeeded(tls *libc.TLS, enc uintptr) int32 { /* syntax_enc.c:24:12: */
- return libc.BoolInt32(!(!((*VP8Encoder)(unsafe.Pointer(enc)).has_alpha_ != 0))) // Currently the only case when VP8X is needed.
+ return libc.BoolInt32(!!((*VP8Encoder)(unsafe.Pointer(enc)).has_alpha_ != 0)) // Currently the only case when VP8X is needed.
// This could change in the future.
}
@@ -34083,9 +33785,9 @@ func PutPaddingByte(tls *libc.TLS, pic uintptr) int32 { /* syntax_enc.c:29:12: *
defer tls.Free(1)
*(*[1]uint8_t)(unsafe.Pointer(bp /* pad_byte */)) = [1]uint8_t{uint8_t(0)}
- return libc.BoolInt32(!(!((*struct {
+ return libc.BoolInt32(!!((*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, (bp) /* &pad_byte[0] */, uint64(1), pic) != 0)))
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, bp, uint64(1), pic) != 0))
}
//------------------------------------------------------------------------------
@@ -34100,10 +33802,10 @@ func PutRIFFHeader(tls *libc.TLS, enc uintptr, riff_size size_t) WebPEncodingErr
uint8_t('R'), uint8_t('I'), uint8_t('F'), uint8_t('F'), uint8_t(0), uint8_t(0), uint8_t(0), uint8_t(0), uint8_t('W'), uint8_t('E'), uint8_t('B'), uint8_t('P'),
}
- PutLE32(tls, ((bp) /* &riff[0] */ + uintptr(4)), uint32_t(riff_size))
+ PutLE32(tls, bp+uintptr(4), uint32_t(riff_size))
if !((*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, (bp) /* &riff[0] */, uint64(unsafe.Sizeof([12]uint8_t{})), pic) != 0) {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, bp, uint64(unsafe.Sizeof([12]uint8_t{})), pic) != 0) {
return VP8_ENC_ERROR_BAD_WRITE
}
return VP8_ENC_OK
@@ -34120,16 +33822,16 @@ func PutVP8XHeader(tls *libc.TLS, enc uintptr) WebPEncodingError { /* syntax_enc
var flags uint32_t = uint32_t(0)
if (*VP8Encoder)(unsafe.Pointer(enc)).has_alpha_ != 0 {
- flags = flags | (ALPHA_FLAG)
+ flags = flags | ALPHA_FLAG
}
- PutLE32(tls, ((bp) /* &vp8x[0] */ + uintptr(4)), uint32(10))
- PutLE32(tls, ((bp) /* &vp8x[0] */ + uintptr(8)), flags)
- PutLE24(tls, (((bp) /* &vp8x[0] */ + uintptr(8)) + uintptr(4)), ((*WebPPicture)(unsafe.Pointer(pic)).width - 1))
- PutLE24(tls, (((bp) /* &vp8x[0] */ + uintptr(8)) + uintptr(7)), ((*WebPPicture)(unsafe.Pointer(pic)).height - 1))
+ PutLE32(tls, bp+uintptr(4), uint32(10))
+ PutLE32(tls, bp+uintptr(8), flags)
+ PutLE24(tls, bp+uintptr(8)+uintptr(4), (*WebPPicture)(unsafe.Pointer(pic)).width-1)
+ PutLE24(tls, bp+uintptr(8)+uintptr(7), (*WebPPicture)(unsafe.Pointer(pic)).height-1)
if !((*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, (bp) /* &vp8x[0] */, uint64(unsafe.Sizeof([18]uint8_t{})), pic) != 0) {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, bp, uint64(unsafe.Sizeof([18]uint8_t{})), pic) != 0) {
return VP8_ENC_ERROR_BAD_WRITE
}
return VP8_ENC_OK
@@ -34145,10 +33847,10 @@ func PutAlphaChunk(tls *libc.TLS, enc uintptr) WebPEncodingError { /* syntax_enc
}
// Alpha chunk header.
- PutLE32(tls, ((bp) /* &alpha_chunk_hdr[0] */ + uintptr(4)), (*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_size_)
+ PutLE32(tls, bp+uintptr(4), (*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_size_)
if !((*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, (bp) /* &alpha_chunk_hdr[0] */, uint64(unsafe.Sizeof([8]uint8_t{})), pic) != 0) {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, bp, uint64(unsafe.Sizeof([8]uint8_t{})), pic) != 0) {
return VP8_ENC_ERROR_BAD_WRITE
}
@@ -34160,7 +33862,7 @@ func PutAlphaChunk(tls *libc.TLS, enc uintptr) WebPEncodingError { /* syntax_enc
}
// Padding.
- if (((*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_size_ & uint32_t(1)) != 0) && !(PutPaddingByte(tls, pic) != 0) {
+ if (*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_size_&uint32_t(1) != 0 && !(PutPaddingByte(tls, pic) != 0) {
return VP8_ENC_ERROR_BAD_WRITE
}
return VP8_ENC_OK
@@ -34174,10 +33876,10 @@ func PutVP8Header(tls *libc.TLS, pic uintptr, vp8_size size_t) WebPEncodingError
0: uint8_t('V'), 1: uint8_t('P'), 2: uint8_t('8'), 3: uint8_t(' '),
}
- PutLE32(tls, ((bp) /* &vp8_chunk_hdr[0] */ + uintptr(4)), uint32_t(vp8_size))
+ PutLE32(tls, bp+uintptr(4), uint32_t(vp8_size))
if !((*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, (bp) /* &vp8_chunk_hdr[0] */, uint64(unsafe.Sizeof([8]uint8_t{})), pic) != 0) {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, bp, uint64(unsafe.Sizeof([8]uint8_t{})), pic) != 0) {
return VP8_ENC_ERROR_BAD_WRITE
}
return VP8_ENC_OK
@@ -34191,31 +33893,31 @@ func PutVP8FrameHeader(tls *libc.TLS, pic uintptr, profile int32, size0 size_t)
var bits uint32_t
- if size0 >= (uint64(int32(1) << 19)) { // partition #0 is too big to fit
+ if size0 >= uint64(int32(1)<<19) { // partition #0 is too big to fit
return VP8_ENC_ERROR_PARTITION0_OVERFLOW
}
// Paragraph 9.1.
- bits = ((uint32_t((0 | // keyframe (1b)
- (profile << 1)) | // profile (3b)
- (int32(1) << 4))) | // visible (1b)
- (uint32_t(size0) << 5)) // partition length (19b)
- *(*uint8_t)(unsafe.Pointer((bp) /* &vp8_frm_hdr[0] */)) = (uint8_t((bits >> 0) & uint32_t(0xff)))
- *(*uint8_t)(unsafe.Pointer((bp) /* &vp8_frm_hdr[0] */ + 1)) = (uint8_t((bits >> 8) & uint32_t(0xff)))
- *(*uint8_t)(unsafe.Pointer((bp) /* &vp8_frm_hdr[0] */ + 2)) = (uint8_t((bits >> 16) & uint32_t(0xff)))
+ bits = uint32_t(0|
+ profile<<1|
+ int32(1)<<4) |
+ uint32_t(size0)<<5 // partition length (19b)
+ *(*uint8_t)(unsafe.Pointer(bp)) = uint8_t(bits >> 0 & uint32_t(0xff))
+ *(*uint8_t)(unsafe.Pointer(bp + 1)) = uint8_t(bits >> 8 & uint32_t(0xff))
+ *(*uint8_t)(unsafe.Pointer(bp + 2)) = uint8_t(bits >> 16 & uint32_t(0xff))
// signature
- *(*uint8_t)(unsafe.Pointer((bp) /* &vp8_frm_hdr[0] */ + 3)) = (uint8_t((int32(0x9d012a) >> 16) & 0xff))
- *(*uint8_t)(unsafe.Pointer((bp) /* &vp8_frm_hdr[0] */ + 4)) = (uint8_t((int32(0x9d012a) >> 8) & 0xff))
- *(*uint8_t)(unsafe.Pointer((bp) /* &vp8_frm_hdr[0] */ + 5)) = (uint8_t((int32(0x9d012a) >> 0) & 0xff))
+ *(*uint8_t)(unsafe.Pointer(bp + 3)) = uint8_t(int32(0x9d012a) >> 16 & 0xff)
+ *(*uint8_t)(unsafe.Pointer(bp + 4)) = uint8_t(int32(0x9d012a) >> 8 & 0xff)
+ *(*uint8_t)(unsafe.Pointer(bp + 5)) = uint8_t(int32(0x9d012a) >> 0 & 0xff)
// dimensions
- *(*uint8_t)(unsafe.Pointer((bp) /* &vp8_frm_hdr[0] */ + 6)) = (uint8_t((*WebPPicture)(unsafe.Pointer(pic)).width & 0xff))
- *(*uint8_t)(unsafe.Pointer((bp) /* &vp8_frm_hdr[0] */ + 7)) = (uint8_t((*WebPPicture)(unsafe.Pointer(pic)).width >> 8))
- *(*uint8_t)(unsafe.Pointer((bp) /* &vp8_frm_hdr[0] */ + 8)) = (uint8_t((*WebPPicture)(unsafe.Pointer(pic)).height & 0xff))
- *(*uint8_t)(unsafe.Pointer((bp) /* &vp8_frm_hdr[0] */ + 9)) = (uint8_t((*WebPPicture)(unsafe.Pointer(pic)).height >> 8))
+ *(*uint8_t)(unsafe.Pointer(bp + 6)) = uint8_t((*WebPPicture)(unsafe.Pointer(pic)).width & 0xff)
+ *(*uint8_t)(unsafe.Pointer(bp + 7)) = uint8_t((*WebPPicture)(unsafe.Pointer(pic)).width >> 8)
+ *(*uint8_t)(unsafe.Pointer(bp + 8)) = uint8_t((*WebPPicture)(unsafe.Pointer(pic)).height & 0xff)
+ *(*uint8_t)(unsafe.Pointer(bp + 9)) = uint8_t((*WebPPicture)(unsafe.Pointer(pic)).height >> 8)
if !((*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, (bp) /* &vp8_frm_hdr[0] */, uint64(unsafe.Sizeof([10]uint8_t{})), pic) != 0) {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, bp, uint64(unsafe.Sizeof([10]uint8_t{})), pic) != 0) {
return VP8_ENC_ERROR_BAD_WRITE
}
return VP8_ENC_OK
@@ -34293,9 +33995,9 @@ Error:
// Segmentation header
func PutSegmentHeader(tls *libc.TLS, bw uintptr, enc uintptr) { /* syntax_enc.c:187:13: */
- var hdr uintptr = (enc + 32 /* &.segment_hdr_ */)
- var proba uintptr = (enc + 3616 /* &.proba_ */)
- if VP8PutBitUniform(tls, bw, (libc.Bool32((*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).num_segments_ > 1))) != 0 {
+ var hdr uintptr = enc + 32
+ var proba uintptr = enc + 3616
+ if VP8PutBitUniform(tls, bw, libc.Bool32((*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).num_segments_ > 1)) != 0 {
// We always 'update' the quant and filter strength values
var update_data int32 = 1
var s int32
@@ -34304,16 +34006,16 @@ func PutSegmentHeader(tls *libc.TLS, bw uintptr, enc uintptr) { /* syntax_enc.c:
// we always use absolute values, not relative ones
VP8PutBitUniform(tls, bw, 1) // (segment_feature_mode = 1. Paragraph 9.3.)
for s = 0; s < NUM_MB_SEGMENTS; s++ {
- VP8PutSignedBits(tls, bw, (*VP8SegmentInfo)(unsafe.Pointer((enc+608 /* &.dqm_ */)+uintptr(s)*744)).quant_, 7)
+ VP8PutSignedBits(tls, bw, (*VP8SegmentInfo)(unsafe.Pointer(enc+608+uintptr(s)*744)).quant_, 7)
}
for s = 0; s < NUM_MB_SEGMENTS; s++ {
- VP8PutSignedBits(tls, bw, (*VP8SegmentInfo)(unsafe.Pointer((enc+608 /* &.dqm_ */)+uintptr(s)*744)).fstrength_, 6)
+ VP8PutSignedBits(tls, bw, (*VP8SegmentInfo)(unsafe.Pointer(enc+608+uintptr(s)*744)).fstrength_, 6)
}
}
if (*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).update_map_ != 0 {
for s = 0; s < 3; s++ {
- if VP8PutBitUniform(tls, bw, (libc.Bool32(uint32(*(*uint8_t)(unsafe.Pointer((proba /* &.segments_ */) + uintptr(s)))) != 255))) != 0 {
- VP8PutBits(tls, bw, uint32(*(*uint8_t)(unsafe.Pointer((proba /* &.segments_ */) + uintptr(s)))), 8)
+ if VP8PutBitUniform(tls, bw, libc.Bool32(uint32(*(*uint8_t)(unsafe.Pointer(proba + uintptr(s)))) != 255)) != 0 {
+ VP8PutBits(tls, bw, uint32(*(*uint8_t)(unsafe.Pointer(proba + uintptr(s)))), 8)
}
}
}
@@ -34322,13 +34024,13 @@ func PutSegmentHeader(tls *libc.TLS, bw uintptr, enc uintptr) { /* syntax_enc.c:
// Filtering parameters header
func PutFilterHeader(tls *libc.TLS, bw uintptr, hdr uintptr) { /* syntax_enc.c:217:13: */
- var use_lf_delta int32 = (libc.Bool32((*VP8EncFilterHeader)(unsafe.Pointer(hdr)).i4x4_lf_delta_ != 0))
+ var use_lf_delta int32 = libc.Bool32((*VP8EncFilterHeader)(unsafe.Pointer(hdr)).i4x4_lf_delta_ != 0)
VP8PutBitUniform(tls, bw, (*VP8EncFilterHeader)(unsafe.Pointer(hdr)).simple_)
VP8PutBits(tls, bw, uint32((*VP8EncFilterHeader)(unsafe.Pointer(hdr)).level_), 6)
VP8PutBits(tls, bw, uint32((*VP8EncFilterHeader)(unsafe.Pointer(hdr)).sharpness_), 3)
if VP8PutBitUniform(tls, bw, use_lf_delta) != 0 {
// '0' is the default value for i4x4_lf_delta_ at frame #0.
- var need_update int32 = (libc.Bool32((*VP8EncFilterHeader)(unsafe.Pointer(hdr)).i4x4_lf_delta_ != 0))
+ var need_update int32 = libc.Bool32((*VP8EncFilterHeader)(unsafe.Pointer(hdr)).i4x4_lf_delta_ != 0)
if VP8PutBitUniform(tls, bw, need_update) != 0 {
// we don't use ref_lf_delta => emit four 0 bits
VP8PutBits(tls, bw, uint32(0), 4)
@@ -34357,19 +34059,19 @@ func EmitPartitionsSize(tls *libc.TLS, enc uintptr, pic uintptr) int32 { /* synt
// var buf [21]uint8_t at bp, 21
var p int32
- for p = 0; p < ((*VP8Encoder)(unsafe.Pointer(enc)).num_parts_ - 1); p++ {
- var part_size size_t = VP8BitWriterSize(tls, ((enc + 112 /* &.parts_ */) + uintptr(p)*48))
- if part_size >= (uint64(int32(1) << 24)) {
+ for p = 0; p < (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_-1; p++ {
+ var part_size size_t = VP8BitWriterSize(tls, enc+112+uintptr(p)*48)
+ if part_size >= uint64(int32(1)<<24) {
return WebPEncodingSetError(tls, pic, VP8_ENC_ERROR_PARTITION_OVERFLOW)
}
- *(*uint8_t)(unsafe.Pointer((bp) /* &buf[0] */ + uintptr(((3 * p) + 0)))) = (uint8_t((part_size >> 0) & uint64(0xff)))
- *(*uint8_t)(unsafe.Pointer((bp) /* &buf[0] */ + uintptr(((3 * p) + 1)))) = (uint8_t((part_size >> 8) & uint64(0xff)))
- *(*uint8_t)(unsafe.Pointer((bp) /* &buf[0] */ + uintptr(((3 * p) + 2)))) = (uint8_t((part_size >> 16) & uint64(0xff)))
+ *(*uint8_t)(unsafe.Pointer(bp + uintptr(3*p+0))) = uint8_t(part_size >> 0 & uint64(0xff))
+ *(*uint8_t)(unsafe.Pointer(bp + uintptr(3*p+1))) = uint8_t(part_size >> 8 & uint64(0xff))
+ *(*uint8_t)(unsafe.Pointer(bp + uintptr(3*p+2))) = uint8_t(part_size >> 16 & uint64(0xff))
}
if p != 0 {
return (*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, (bp) /* &buf[0] */, (uint64(3 * p)), pic)
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, bp /* &buf[0] */, uint64(3*p), pic)
}
return 1
}
@@ -34377,21 +34079,21 @@ func EmitPartitionsSize(tls *libc.TLS, enc uintptr, pic uintptr) int32 { /* synt
//------------------------------------------------------------------------------
func GeneratePartition0(tls *libc.TLS, enc uintptr) int32 { /* syntax_enc.c:266:12: */
- var bw uintptr = (enc + 64 /* &.bw_ */)
- var mb_size int32 = ((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_)
+ var bw uintptr = enc + 64
+ var mb_size int32 = (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_
var pos1 uint64_t
var pos2 uint64_t
var pos3 uint64_t
pos1 = VP8BitWriterPos(tls, bw)
- if !(VP8BitWriterInit(tls, bw, (uint64((mb_size*7)/8))) != 0) { // ~7 bits per macroblock
+ if !(VP8BitWriterInit(tls, bw, uint64(mb_size*7/8)) != 0) { // ~7 bits per macroblock
return WebPEncodingSetError(tls, (*VP8Encoder)(unsafe.Pointer(enc)).pic_, VP8_ENC_ERROR_OUT_OF_MEMORY)
}
VP8PutBitUniform(tls, bw, 0) // colorspace
VP8PutBitUniform(tls, bw, 0) // clamp type
PutSegmentHeader(tls, bw, enc)
- PutFilterHeader(tls, bw, (enc + 16 /* &.filter_hdr_ */))
+ PutFilterHeader(tls, bw, enc+16)
VP8PutBits(tls, bw, func() uint32 {
if (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_ == 8 {
return uint32(3)
@@ -34410,7 +34112,7 @@ func GeneratePartition0(tls *libc.TLS, enc uintptr) int32 { /* syntax_enc.c:266:
}(), 2)
PutQuant(tls, bw, enc)
VP8PutBitUniform(tls, bw, 0) // no proba update
- VP8WriteProbas(tls, bw, (enc + 3616 /* &.proba_ */))
+ VP8WriteProbas(tls, bw, enc+3616)
pos2 = VP8BitWriterPos(tls, bw)
VP8CodeIntraModes(tls, enc)
VP8BitWriterFinish(tls, bw)
@@ -34418,8 +34120,8 @@ func GeneratePartition0(tls *libc.TLS, enc uintptr) int32 { /* syntax_enc.c:266:
pos3 = VP8BitWriterPos(tls, bw)
if (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats != 0 {
- *(*int32)(unsafe.Pointer(((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats + 36 /* &.header_bytes */))) = (int32(((pos2 - pos1) + uint64(7)) >> 3))
- *(*int32)(unsafe.Pointer(((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats + 36 /* &.header_bytes */) + 1*4)) = (int32(((pos3 - pos2) + uint64(7)) >> 3))
+ *(*int32)(unsafe.Pointer((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats + 36)) = int32((pos2 - pos1 + uint64(7)) >> 3)
+ *(*int32)(unsafe.Pointer((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats + 36 + 1*4)) = int32((pos3 - pos2 + uint64(7)) >> 3)
(*WebPAuxStats)(unsafe.Pointer((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats)).alpha_data_size = int32((*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_size_)
}
if (*VP8BitWriter)(unsafe.Pointer(bw)).error_ != 0 {
@@ -34430,18 +34132,18 @@ func GeneratePartition0(tls *libc.TLS, enc uintptr) int32 { /* syntax_enc.c:266:
func VP8EncFreeBitWriters(tls *libc.TLS, enc uintptr) { /* syntax_enc.c:309:6: */
var p int32
- VP8BitWriterWipeOut(tls, (enc + 64 /* &.bw_ */))
+ VP8BitWriterWipeOut(tls, enc+64)
for p = 0; p < (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_; p++ {
- VP8BitWriterWipeOut(tls, ((enc + 112 /* &.parts_ */) + uintptr(p)*48))
+ VP8BitWriterWipeOut(tls, enc+112+uintptr(p)*48)
}
}
func VP8EncWrite(tls *libc.TLS, enc uintptr) int32 { /* syntax_enc.c:317:5: */
var pic uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).pic_
- var bw uintptr = (enc + 64 /* &.bw_ */)
+ var bw uintptr = enc + 64
var task_percent int32 = 19
- var percent_per_part int32 = (task_percent / (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_)
- var final_percent int32 = ((*VP8Encoder)(unsafe.Pointer(enc)).percent_ + task_percent)
+ var percent_per_part int32 = task_percent / (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_
+ var final_percent int32 = (*VP8Encoder)(unsafe.Pointer(enc)).percent_ + task_percent
var ok int32 = 0
var vp8_size size_t
var pad size_t
@@ -34455,22 +34157,22 @@ func VP8EncWrite(tls *libc.TLS, enc uintptr) int32 { /* syntax_enc.c:317:5: */
}
// Compute VP8 size
- vp8_size = ((uint64(10) + VP8BitWriterSize(tls, bw)) + (size_t(3 * ((*VP8Encoder)(unsafe.Pointer(enc)).num_parts_ - 1))))
+ vp8_size = uint64(10) + VP8BitWriterSize(tls, bw) + size_t(3*((*VP8Encoder)(unsafe.Pointer(enc)).num_parts_-1))
for p = 0; p < (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_; p++ {
- vp8_size = vp8_size + (VP8BitWriterSize(tls, ((enc + 112 /* &.parts_ */) + uintptr(p)*48)))
+ vp8_size = vp8_size + VP8BitWriterSize(tls, enc+112+uintptr(p)*48)
}
- pad = (vp8_size & uint64(1))
- vp8_size = vp8_size + (pad)
+ pad = vp8_size & uint64(1)
+ vp8_size = vp8_size + pad
// Compute RIFF size
// At the minimum it is: "WEBPVP8 nnnn" + VP8 data size.
- riff_size = ((uint64(4 + 8)) + vp8_size)
+ riff_size = uint64(4+8) + vp8_size
if IsVP8XNeeded(tls, enc) != 0 { // Add size for: VP8X header + data.
- riff_size = riff_size + (uint64(8 + 10))
+ riff_size = riff_size + uint64(8+10)
}
if (*VP8Encoder)(unsafe.Pointer(enc)).has_alpha_ != 0 { // Add size for: ALPH header + data.
- var padded_alpha_size uint32_t = ((*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_size_ + ((*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_size_ & uint32_t(1)))
- riff_size = riff_size + (size_t(uint32_t(8) + padded_alpha_size))
+ var padded_alpha_size uint32_t = (*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_size_ + (*VP8Encoder)(unsafe.Pointer(enc)).alpha_data_size_&uint32_t(1)
+ riff_size = riff_size + size_t(uint32_t(8)+padded_alpha_size)
}
// RIFF size should fit in 32-bits.
if riff_size > uint64(0xfffffffe) {
@@ -34481,36 +34183,36 @@ func VP8EncWrite(tls *libc.TLS, enc uintptr) int32 { /* syntax_enc.c:317:5: */
{
var part0 uintptr = VP8BitWriterBuf(tls, bw)
var size0 size_t = VP8BitWriterSize(tls, bw)
- ok = (libc.Bool32((((ok != 0) && (PutWebPHeaders(tls, enc, size0, vp8_size, riff_size) != 0)) &&
- ((*struct {
+ ok = libc.Bool32(ok != 0 && PutWebPHeaders(tls, enc, size0, vp8_size, riff_size) != 0 &&
+ (*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, part0, size0, pic) != 0)) &&
- (EmitPartitionsSize(tls, enc, pic) != 0)))
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, part0, size0, pic) != 0 &&
+ EmitPartitionsSize(tls, enc, pic) != 0)
VP8BitWriterWipeOut(tls, bw) // will free the internal buffer.
}
// Token partitions
for p = 0; p < (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_; p++ {
- var buf uintptr = VP8BitWriterBuf(tls, ((enc + 112 /* &.parts_ */) + uintptr(p)*48))
- var size size_t = VP8BitWriterSize(tls, ((enc + 112 /* &.parts_ */) + uintptr(p)*48))
+ var buf uintptr = VP8BitWriterBuf(tls, enc+112+uintptr(p)*48)
+ var size size_t = VP8BitWriterSize(tls, enc+112+uintptr(p)*48)
if size != 0 {
- ok = (libc.Bool32((ok != 0) && ((*struct {
+ ok = libc.Bool32(ok != 0 && (*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, buf, size, pic) != 0)))
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, buf, size, pic) != 0)
}
- VP8BitWriterWipeOut(tls, ((enc + 112 /* &.parts_ */) + uintptr(p)*48)) // will free the internal buffer.
- ok = (libc.Bool32((ok != 0) && (WebPReportProgress(tls, pic, ((*VP8Encoder)(unsafe.Pointer(enc)).percent_+percent_per_part),
- (enc+536 /* &.percent_ */)) != 0)))
+ VP8BitWriterWipeOut(tls, enc+112+uintptr(p)*48) // will free the internal buffer.
+ ok = libc.Bool32(ok != 0 && WebPReportProgress(tls, pic, (*VP8Encoder)(unsafe.Pointer(enc)).percent_+percent_per_part,
+ enc+536) != 0)
}
// Padding byte
- if (ok != 0) && (pad != 0) {
+ if ok != 0 && pad != 0 {
ok = PutPaddingByte(tls, pic)
}
- (*VP8Encoder)(unsafe.Pointer(enc)).coded_size_ = (int32(uint64(8) + riff_size))
- ok = (libc.Bool32((ok != 0) && (WebPReportProgress(tls, pic, final_percent, (enc+536 /* &.percent_ */)) != 0)))
+ (*VP8Encoder)(unsafe.Pointer(enc)).coded_size_ = int32(uint64(8) + riff_size)
+ ok = libc.Bool32(ok != 0 && WebPReportProgress(tls, pic, final_percent, enc+536) != 0)
return ok
}
@@ -34560,9 +34262,9 @@ type token_t = uint16_t /* token_enc.c:33:18 */
//------------------------------------------------------------------------------
func VP8TBufferInit(tls *libc.TLS, b uintptr, page_size int32) { /* token_enc.c:45:6: */
- (*VP8TBuffer)(unsafe.Pointer(b)).tokens_ = (uintptr(0))
- (*VP8TBuffer)(unsafe.Pointer(b)).pages_ = (uintptr(0))
- (*VP8TBuffer)(unsafe.Pointer(b)).last_page_ = (b /* &.pages_ */)
+ (*VP8TBuffer)(unsafe.Pointer(b)).tokens_ = uintptr(0)
+ (*VP8TBuffer)(unsafe.Pointer(b)).pages_ = uintptr(0)
+ (*VP8TBuffer)(unsafe.Pointer(b)).last_page_ = b
(*VP8TBuffer)(unsafe.Pointer(b)).left_ = 0
(*VP8TBuffer)(unsafe.Pointer(b)).page_size_ = func() int32 {
if page_size < 8192 {
@@ -34574,9 +34276,9 @@ func VP8TBufferInit(tls *libc.TLS, b uintptr, page_size int32) { /* token_enc.c:
}
func VP8TBufferClear(tls *libc.TLS, b uintptr) { /* token_enc.c:54:6: */
- if b != (uintptr(0)) {
+ if b != uintptr(0) {
var p uintptr = (*VP8TBuffer)(unsafe.Pointer(b)).pages_
- for p != (uintptr(0)) {
+ for p != uintptr(0) {
var next uintptr = (*VP8Tokens)(unsafe.Pointer(p)).next_
WebPSafeFree(tls, p)
p = next
@@ -34586,21 +34288,21 @@ func VP8TBufferClear(tls *libc.TLS, b uintptr) { /* token_enc.c:54:6: */
}
func TBufferNewPage(tls *libc.TLS, b uintptr) int32 { /* token_enc.c:66:12: */
- var page uintptr = (uintptr(0))
+ var page uintptr = uintptr(0)
if !((*VP8TBuffer)(unsafe.Pointer(b)).error_ != 0) {
- var size size_t = (uint64(unsafe.Sizeof(VP8Tokens{})) + (uint64((*VP8TBuffer)(unsafe.Pointer(b)).page_size_) * uint64(unsafe.Sizeof(token_t(0)))))
+ var size size_t = uint64(unsafe.Sizeof(VP8Tokens{})) + uint64((*VP8TBuffer)(unsafe.Pointer(b)).page_size_)*uint64(unsafe.Sizeof(token_t(0)))
page = WebPSafeMalloc(tls, 1, size)
}
- if page == (uintptr(0)) {
+ if page == uintptr(0) {
(*VP8TBuffer)(unsafe.Pointer(b)).error_ = 1
return 0
}
- (*VP8Tokens)(unsafe.Pointer(page)).next_ = (uintptr(0))
+ (*VP8Tokens)(unsafe.Pointer(page)).next_ = uintptr(0)
*(*uintptr)(unsafe.Pointer((*VP8TBuffer)(unsafe.Pointer(b)).last_page_)) = page
- (*VP8TBuffer)(unsafe.Pointer(b)).last_page_ = (page /* &.next_ */)
+ (*VP8TBuffer)(unsafe.Pointer(b)).last_page_ = page
(*VP8TBuffer)(unsafe.Pointer(b)).left_ = (*VP8TBuffer)(unsafe.Pointer(b)).page_size_
- (*VP8TBuffer)(unsafe.Pointer(b)).tokens_ = ((page) + 1*8)
+ (*VP8TBuffer)(unsafe.Pointer(b)).tokens_ = page + 1*8
return 1
}
@@ -34608,9 +34310,9 @@ func TBufferNewPage(tls *libc.TLS, b uintptr) int32 { /* token_enc.c:66:12: */
func AddToken(tls *libc.TLS, b uintptr, bit uint32_t, proba_idx uint32_t, stats uintptr) uint32_t { /* token_enc.c:90:29: */
- if ((*VP8TBuffer)(unsafe.Pointer(b)).left_ > 0) || (TBufferNewPage(tls, b) != 0) {
+ if (*VP8TBuffer)(unsafe.Pointer(b)).left_ > 0 || TBufferNewPage(tls, b) != 0 {
var slot int32 = libc.PreDecInt32(&(*VP8TBuffer)(unsafe.Pointer(b)).left_, 1)
- *(*uint16_t)(unsafe.Pointer((*VP8TBuffer)(unsafe.Pointer(b)).tokens_ + uintptr(slot)*2)) = (uint16_t((bit << 15) | proba_idx))
+ *(*uint16_t)(unsafe.Pointer((*VP8TBuffer)(unsafe.Pointer(b)).tokens_ + uintptr(slot)*2)) = uint16_t(bit<<15 | proba_idx)
}
VP8RecordStats(tls, int32(bit), stats)
return bit
@@ -34618,9 +34320,9 @@ func AddToken(tls *libc.TLS, b uintptr, bit uint32_t, proba_idx uint32_t, stats
func AddConstantToken(tls *libc.TLS, b uintptr, bit uint32_t, proba uint32_t) { /* token_enc.c:103:25: */
- if ((*VP8TBuffer)(unsafe.Pointer(b)).left_ > 0) || (TBufferNewPage(tls, b) != 0) {
+ if (*VP8TBuffer)(unsafe.Pointer(b)).left_ > 0 || TBufferNewPage(tls, b) != 0 {
var slot int32 = libc.PreDecInt32(&(*VP8TBuffer)(unsafe.Pointer(b)).left_, 1)
- *(*uint16_t)(unsafe.Pointer((*VP8TBuffer)(unsafe.Pointer(b)).tokens_ + uintptr(slot)*2)) = (uint16_t(((bit << 15) | (uint32(1) << 14)) | proba))
+ *(*uint16_t)(unsafe.Pointer((*VP8TBuffer)(unsafe.Pointer(b)).tokens_ + uintptr(slot)*2)) = uint16_t(bit<<15 | uint32(1)<<14 | proba)
}
}
@@ -34629,81 +34331,81 @@ func VP8RecordCoeffTokens(tls *libc.TLS, ctx int32, res uintptr, tokens uintptr)
var coeff_type int32 = (*VP8Residual1)(unsafe.Pointer(res)).coeff_type
var last int32 = (*VP8Residual1)(unsafe.Pointer(res)).last
var n int32 = (*VP8Residual1)(unsafe.Pointer(res)).first
- var base_id uint32_t = (uint32_t(NUM_PROBAS * ((ctx) + (NUM_CTX * ((n) + (NUM_BANDS * (coeff_type)))))))
+ var base_id uint32_t = uint32_t(NUM_PROBAS * (ctx + NUM_CTX*(n+NUM_BANDS*coeff_type)))
// should be stats[VP8EncBands[n]], but it's equivalent for n=0 or 1
- var s uintptr = (((*VP8Residual1)(unsafe.Pointer(res)).stats + uintptr(n)*132) + uintptr(ctx)*44)
- if !(AddToken(tls, tokens, (uint32(libc.Bool32(last >= 0))), (base_id+uint32_t(0)), (s+uintptr(0)*4)) != 0) {
+ var s uintptr = (*VP8Residual1)(unsafe.Pointer(res)).stats + uintptr(n)*132 + uintptr(ctx)*44
+ if !(AddToken(tls, tokens, uint32(libc.Bool32(last >= 0)), base_id+uint32_t(0), s+uintptr(0)*4) != 0) {
return 0
}
for n < 16 {
var c int32 = int32(*(*int16_t)(unsafe.Pointer(coeffs + uintptr(libc.PostIncInt32(&n, 1))*2)))
- var sign int32 = (libc.Bool32(c < 0))
+ var sign int32 = libc.Bool32(c < 0)
var v uint32_t
if sign != 0 {
v = uint32(-c)
} else {
v = uint32(c)
}
- if !(AddToken(tls, tokens, (uint32(libc.Bool32(v != uint32_t(0)))), (base_id+uint32_t(1)), (s+uintptr(1)*4)) != 0) {
- base_id = (uint32_t(NUM_PROBAS * ((0) + (NUM_CTX * ((int32(VP8EncBands[n])) + (NUM_BANDS * (coeff_type))))))) // ctx=0
- s = ((*VP8Residual1)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132)
+ if !(AddToken(tls, tokens, uint32(libc.Bool32(v != uint32_t(0))), base_id+uint32_t(1), s+uintptr(1)*4) != 0) {
+ base_id = uint32_t(NUM_PROBAS * (0 + NUM_CTX*(int32(VP8EncBands[n])+NUM_BANDS*coeff_type))) // ctx=0
+ s = (*VP8Residual1)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132
continue
}
- if !(AddToken(tls, tokens, (uint32(libc.Bool32(v > uint32_t(1)))), (base_id+uint32_t(2)), (s+uintptr(2)*4)) != 0) {
- base_id = (uint32_t(NUM_PROBAS * ((1) + (NUM_CTX * ((int32(VP8EncBands[n])) + (NUM_BANDS * (coeff_type))))))) // ctx=1
- s = (((*VP8Residual1)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132) + 1*44)
+ if !(AddToken(tls, tokens, uint32(libc.Bool32(v > uint32_t(1))), base_id+uint32_t(2), s+uintptr(2)*4) != 0) {
+ base_id = uint32_t(NUM_PROBAS * (1 + NUM_CTX*(int32(VP8EncBands[n])+NUM_BANDS*coeff_type))) // ctx=1
+ s = (*VP8Residual1)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132 + 1*44
} else {
- if !(AddToken(tls, tokens, (uint32(libc.Bool32(v > uint32_t(4)))), (base_id+uint32_t(3)), (s+uintptr(3)*4)) != 0) {
- if AddToken(tls, tokens, (uint32(libc.Bool32(v != uint32_t(2)))), (base_id+uint32_t(4)), (s+uintptr(4)*4)) != 0 {
- AddToken(tls, tokens, (uint32(libc.Bool32(v == uint32_t(4)))), (base_id + uint32_t(5)), (s + uintptr(5)*4))
+ if !(AddToken(tls, tokens, uint32(libc.Bool32(v > uint32_t(4))), base_id+uint32_t(3), s+uintptr(3)*4) != 0) {
+ if AddToken(tls, tokens, uint32(libc.Bool32(v != uint32_t(2))), base_id+uint32_t(4), s+uintptr(4)*4) != 0 {
+ AddToken(tls, tokens, uint32(libc.Bool32(v == uint32_t(4))), base_id+uint32_t(5), s+uintptr(5)*4)
}
- } else if !(AddToken(tls, tokens, (uint32(libc.Bool32(v > uint32_t(10)))), (base_id+uint32_t(6)), (s+uintptr(6)*4)) != 0) {
- if !(AddToken(tls, tokens, (uint32(libc.Bool32(v > uint32_t(6)))), (base_id+uint32_t(7)), (s+uintptr(7)*4)) != 0) {
- AddConstantToken(tls, tokens, (uint32(libc.Bool32(v == uint32_t(6)))), uint32(159))
+ } else if !(AddToken(tls, tokens, uint32(libc.Bool32(v > uint32_t(10))), base_id+uint32_t(6), s+uintptr(6)*4) != 0) {
+ if !(AddToken(tls, tokens, uint32(libc.Bool32(v > uint32_t(6))), base_id+uint32_t(7), s+uintptr(7)*4) != 0) {
+ AddConstantToken(tls, tokens, uint32(libc.Bool32(v == uint32_t(6))), uint32(159))
} else {
- AddConstantToken(tls, tokens, (uint32(libc.Bool32(v >= uint32_t(9)))), uint32(165))
- AddConstantToken(tls, tokens, libc.BoolUint32(!((v & uint32_t(1)) != 0)), uint32(145))
+ AddConstantToken(tls, tokens, uint32(libc.Bool32(v >= uint32_t(9))), uint32(165))
+ AddConstantToken(tls, tokens, libc.BoolUint32(!(v&uint32_t(1) != 0)), uint32(145))
}
} else {
var mask int32
var tab uintptr
- var residue uint32_t = (v - uint32_t(3))
- if residue < (uint32_t(int32(8) << 1)) { // VP8Cat3 (3b)
- AddToken(tls, tokens, uint32(0), (base_id + uint32_t(8)), (s + uintptr(8)*4))
- AddToken(tls, tokens, uint32(0), (base_id + uint32_t(9)), (s + uintptr(9)*4))
- residue = residue - (uint32_t(int32(8) << 0))
- mask = (int32(1) << 2)
+ var residue uint32_t = v - uint32_t(3)
+ if residue < uint32_t(int32(8)<<1) { // VP8Cat3 (3b)
+ AddToken(tls, tokens, uint32(0), base_id+uint32_t(8), s+uintptr(8)*4)
+ AddToken(tls, tokens, uint32(0), base_id+uint32_t(9), s+uintptr(9)*4)
+ residue = residue - uint32_t(int32(8)<<0)
+ mask = int32(1) << 2
tab = uintptr(unsafe.Pointer(&VP8Cat3))
- } else if residue < (uint32_t(int32(8) << 2)) { // VP8Cat4 (4b)
- AddToken(tls, tokens, uint32(0), (base_id + uint32_t(8)), (s + uintptr(8)*4))
- AddToken(tls, tokens, uint32(1), (base_id + uint32_t(9)), (s + uintptr(9)*4))
- residue = residue - (uint32_t(int32(8) << 1))
- mask = (int32(1) << 3)
+ } else if residue < uint32_t(int32(8)<<2) { // VP8Cat4 (4b)
+ AddToken(tls, tokens, uint32(0), base_id+uint32_t(8), s+uintptr(8)*4)
+ AddToken(tls, tokens, uint32(1), base_id+uint32_t(9), s+uintptr(9)*4)
+ residue = residue - uint32_t(int32(8)<<1)
+ mask = int32(1) << 3
tab = uintptr(unsafe.Pointer(&VP8Cat4))
- } else if residue < (uint32_t(int32(8) << 3)) { // VP8Cat5 (5b)
- AddToken(tls, tokens, uint32(1), (base_id + uint32_t(8)), (s + uintptr(8)*4))
- AddToken(tls, tokens, uint32(0), (base_id + uint32_t(10)), (s + uintptr(9)*4))
- residue = residue - (uint32_t(int32(8) << 2))
- mask = (int32(1) << 4)
+ } else if residue < uint32_t(int32(8)<<3) { // VP8Cat5 (5b)
+ AddToken(tls, tokens, uint32(1), base_id+uint32_t(8), s+uintptr(8)*4)
+ AddToken(tls, tokens, uint32(0), base_id+uint32_t(10), s+uintptr(9)*4)
+ residue = residue - uint32_t(int32(8)<<2)
+ mask = int32(1) << 4
tab = uintptr(unsafe.Pointer(&VP8Cat5))
} else { // VP8Cat6 (11b)
- AddToken(tls, tokens, uint32(1), (base_id + uint32_t(8)), (s + uintptr(8)*4))
- AddToken(tls, tokens, uint32(1), (base_id + uint32_t(10)), (s + uintptr(9)*4))
- residue = residue - (uint32_t(int32(8) << 3))
- mask = (int32(1) << 10)
+ AddToken(tls, tokens, uint32(1), base_id+uint32_t(8), s+uintptr(8)*4)
+ AddToken(tls, tokens, uint32(1), base_id+uint32_t(10), s+uintptr(9)*4)
+ residue = residue - uint32_t(int32(8)<<3)
+ mask = int32(1) << 10
tab = uintptr(unsafe.Pointer(&VP8Cat6))
}
for mask != 0 {
- AddConstantToken(tls, tokens, libc.BoolUint32(!(!((residue & uint32_t(mask)) != 0))), uint32(*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&tab, 1)))))
+ AddConstantToken(tls, tokens, libc.BoolUint32(!!(residue&uint32_t(mask) != 0)), uint32(*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&tab, 1)))))
mask >>= 1
}
}
- base_id = (uint32_t(NUM_PROBAS * ((2) + (NUM_CTX * ((int32(VP8EncBands[n])) + (NUM_BANDS * (coeff_type))))))) // ctx=2
- s = (((*VP8Residual1)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132) + 2*44)
+ base_id = uint32_t(NUM_PROBAS * (2 + NUM_CTX*(int32(VP8EncBands[n])+NUM_BANDS*coeff_type))) // ctx=2
+ s = (*VP8Residual1)(unsafe.Pointer(res)).stats + uintptr(VP8EncBands[n])*132 + 2*44
}
AddConstantToken(tls, tokens, uint32(sign), uint32(128))
- if (n == 16) || !(AddToken(tls, tokens, (uint32(libc.Bool32(n <= last))), (base_id+uint32_t(0)), (s+uintptr(0)*4)) != 0) {
+ if n == 16 || !(AddToken(tls, tokens, uint32(libc.Bool32(n <= last)), base_id+uint32_t(0), s+uintptr(0)*4) != 0) {
return 1 // EOB
}
}
@@ -34716,23 +34418,23 @@ func VP8RecordCoeffTokens(tls *libc.TLS, ctx int32, res uintptr, tokens uintptr)
func VP8EmitTokens(tls *libc.TLS, b uintptr, bw uintptr, probas uintptr, final_pass int32) int32 { /* token_enc.c:200:5: */
var p uintptr = (*VP8TBuffer)(unsafe.Pointer(b)).pages_
- for p != (uintptr(0)) {
+ for p != uintptr(0) {
var next uintptr = (*VP8Tokens)(unsafe.Pointer(p)).next_
var N int32
- if next == (uintptr(0)) {
+ if next == uintptr(0) {
N = (*VP8TBuffer)(unsafe.Pointer(b)).left_
} else {
N = 0
}
var n int32 = (*VP8TBuffer)(unsafe.Pointer(b)).page_size_
- var tokens uintptr = ((p) + 1*8)
+ var tokens uintptr = p + 1*8
for libc.PostDecInt32(&n, 1) > N {
var token token_t = *(*token_t)(unsafe.Pointer(tokens + uintptr(n)*2))
- var bit int32 = ((int32(token) >> 15) & 1)
- if (uint32(token) & (uint32(1) << 14)) != 0 {
- VP8PutBit(tls, bw, bit, (int32(uint32(token) & 0xff))) // constant proba
+ var bit int32 = int32(token) >> 15 & 1
+ if uint32(token)&(uint32(1)<<14) != 0 {
+ VP8PutBit(tls, bw, bit, int32(uint32(token)&0xff)) // constant proba
} else {
- VP8PutBit(tls, bw, bit, int32(*(*uint8_t)(unsafe.Pointer(probas + uintptr((uint32(token) & 0x3fff))))))
+ VP8PutBit(tls, bw, bit, int32(*(*uint8_t)(unsafe.Pointer(probas + uintptr(uint32(token)&0x3fff)))))
}
}
if final_pass != 0 {
@@ -34741,7 +34443,7 @@ func VP8EmitTokens(tls *libc.TLS, b uintptr, bw uintptr, probas uintptr, final_p
p = next
}
if final_pass != 0 {
- (*VP8TBuffer)(unsafe.Pointer(b)).pages_ = (uintptr(0))
+ (*VP8TBuffer)(unsafe.Pointer(b)).pages_ = uintptr(0)
}
return 1
}
@@ -34751,23 +34453,23 @@ func VP8EstimateTokenSize(tls *libc.TLS, b uintptr, probas uintptr) size_t { /*
var size size_t = uint64(0)
var p uintptr = (*VP8TBuffer)(unsafe.Pointer(b)).pages_
- for p != (uintptr(0)) {
+ for p != uintptr(0) {
var next uintptr = (*VP8Tokens)(unsafe.Pointer(p)).next_
var N int32
- if next == (uintptr(0)) {
+ if next == uintptr(0) {
N = (*VP8TBuffer)(unsafe.Pointer(b)).left_
} else {
N = 0
}
var n int32 = (*VP8TBuffer)(unsafe.Pointer(b)).page_size_
- var tokens uintptr = ((p) + 1*8)
+ var tokens uintptr = p + 1*8
for libc.PostDecInt32(&n, 1) > N {
var token token_t = *(*token_t)(unsafe.Pointer(tokens + uintptr(n)*2))
- var bit int32 = (int32(token) & (int32(1) << 15))
- if (uint32(token) & (uint32(1) << 14)) != 0 {
- size = size + (size_t(VP8BitCost(tls, bit, (uint8(uint32(token) & 0xff)))))
+ var bit int32 = int32(token) & (int32(1) << 15)
+ if uint32(token)&(uint32(1)<<14) != 0 {
+ size = size + size_t(VP8BitCost(tls, bit, uint8(uint32(token)&0xff)))
} else {
- size = size + (size_t(VP8BitCost(tls, bit, *(*uint8_t)(unsafe.Pointer(probas + uintptr((uint32(token) & 0x3fff)))))))
+ size = size + size_t(VP8BitCost(tls, bit, *(*uint8_t)(unsafe.Pointer(probas + uintptr(uint32(token)&0x3fff)))))
}
}
p = next
@@ -34783,269 +34485,269 @@ func VP8EstimateTokenSize(tls *libc.TLS, b uintptr, probas uintptr) size_t { /*
// Default probabilities
// Paragraph 13.5
-var VP8CoeffsProba0 = [4][8][3][11]uint8_t{[8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+var VP8CoeffsProba0 = [4][8][3][11]uint8_t{{
+ {{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(253), uint8_t(136), uint8_t(254), uint8_t(255), uint8_t(228), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(189), uint8_t(129), uint8_t(242), uint8_t(255), uint8_t(227), uint8_t(213), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(106), uint8_t(126), uint8_t(227), uint8_t(252), uint8_t(214), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(253), uint8_t(136), uint8_t(254), uint8_t(255), uint8_t(228), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(189), uint8_t(129), uint8_t(242), uint8_t(255), uint8_t(227), uint8_t(213), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(106), uint8_t(126), uint8_t(227), uint8_t(252), uint8_t(214), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(98), uint8_t(248), uint8_t(255), uint8_t(236), uint8_t(226), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(181), uint8_t(133), uint8_t(238), uint8_t(254), uint8_t(221), uint8_t(234), uint8_t(255), uint8_t(154), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(78), uint8_t(134), uint8_t(202), uint8_t(247), uint8_t(198), uint8_t(180), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(98), uint8_t(248), uint8_t(255), uint8_t(236), uint8_t(226), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(181), uint8_t(133), uint8_t(238), uint8_t(254), uint8_t(221), uint8_t(234), uint8_t(255), uint8_t(154), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(78), uint8_t(134), uint8_t(202), uint8_t(247), uint8_t(198), uint8_t(180), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(185), uint8_t(249), uint8_t(255), uint8_t(243), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(184), uint8_t(150), uint8_t(247), uint8_t(255), uint8_t(236), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(77), uint8_t(110), uint8_t(216), uint8_t(255), uint8_t(236), uint8_t(230), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(185), uint8_t(249), uint8_t(255), uint8_t(243), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(184), uint8_t(150), uint8_t(247), uint8_t(255), uint8_t(236), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(77), uint8_t(110), uint8_t(216), uint8_t(255), uint8_t(236), uint8_t(230), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(101), uint8_t(251), uint8_t(255), uint8_t(241), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(170), uint8_t(139), uint8_t(241), uint8_t(252), uint8_t(236), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(37), uint8_t(116), uint8_t(196), uint8_t(243), uint8_t(228), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(101), uint8_t(251), uint8_t(255), uint8_t(241), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(170), uint8_t(139), uint8_t(241), uint8_t(252), uint8_t(236), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(37), uint8_t(116), uint8_t(196), uint8_t(243), uint8_t(228), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(204), uint8_t(254), uint8_t(255), uint8_t(245), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(207), uint8_t(160), uint8_t(250), uint8_t(255), uint8_t(238), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(102), uint8_t(103), uint8_t(231), uint8_t(255), uint8_t(211), uint8_t(171), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(204), uint8_t(254), uint8_t(255), uint8_t(245), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(207), uint8_t(160), uint8_t(250), uint8_t(255), uint8_t(238), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(102), uint8_t(103), uint8_t(231), uint8_t(255), uint8_t(211), uint8_t(171), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(152), uint8_t(252), uint8_t(255), uint8_t(240), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(177), uint8_t(135), uint8_t(243), uint8_t(255), uint8_t(234), uint8_t(225), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(80), uint8_t(129), uint8_t(211), uint8_t(255), uint8_t(194), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(152), uint8_t(252), uint8_t(255), uint8_t(240), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(177), uint8_t(135), uint8_t(243), uint8_t(255), uint8_t(234), uint8_t(225), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(80), uint8_t(129), uint8_t(211), uint8_t(255), uint8_t(194), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(246), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(246), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(198), uint8_t(35), uint8_t(237), uint8_t(223), uint8_t(193), uint8_t(187), uint8_t(162), uint8_t(160), uint8_t(145), uint8_t(155), uint8_t(62)},
- [11]uint8_t{uint8_t(131), uint8_t(45), uint8_t(198), uint8_t(221), uint8_t(172), uint8_t(176), uint8_t(220), uint8_t(157), uint8_t(252), uint8_t(221), uint8_t(1)},
- [11]uint8_t{uint8_t(68), uint8_t(47), uint8_t(146), uint8_t(208), uint8_t(149), uint8_t(167), uint8_t(221), uint8_t(162), uint8_t(255), uint8_t(223), uint8_t(128)},
+ {
+ {{uint8_t(198), uint8_t(35), uint8_t(237), uint8_t(223), uint8_t(193), uint8_t(187), uint8_t(162), uint8_t(160), uint8_t(145), uint8_t(155), uint8_t(62)},
+ {uint8_t(131), uint8_t(45), uint8_t(198), uint8_t(221), uint8_t(172), uint8_t(176), uint8_t(220), uint8_t(157), uint8_t(252), uint8_t(221), uint8_t(1)},
+ {uint8_t(68), uint8_t(47), uint8_t(146), uint8_t(208), uint8_t(149), uint8_t(167), uint8_t(221), uint8_t(162), uint8_t(255), uint8_t(223), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(149), uint8_t(241), uint8_t(255), uint8_t(221), uint8_t(224), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(184), uint8_t(141), uint8_t(234), uint8_t(253), uint8_t(222), uint8_t(220), uint8_t(255), uint8_t(199), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(81), uint8_t(99), uint8_t(181), uint8_t(242), uint8_t(176), uint8_t(190), uint8_t(249), uint8_t(202), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {{uint8_t(1), uint8_t(149), uint8_t(241), uint8_t(255), uint8_t(221), uint8_t(224), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(184), uint8_t(141), uint8_t(234), uint8_t(253), uint8_t(222), uint8_t(220), uint8_t(255), uint8_t(199), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(81), uint8_t(99), uint8_t(181), uint8_t(242), uint8_t(176), uint8_t(190), uint8_t(249), uint8_t(202), uint8_t(255), uint8_t(255), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(129), uint8_t(232), uint8_t(253), uint8_t(214), uint8_t(197), uint8_t(242), uint8_t(196), uint8_t(255), uint8_t(255), uint8_t(128)},
- [11]uint8_t{uint8_t(99), uint8_t(121), uint8_t(210), uint8_t(250), uint8_t(201), uint8_t(198), uint8_t(255), uint8_t(202), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(23), uint8_t(91), uint8_t(163), uint8_t(242), uint8_t(170), uint8_t(187), uint8_t(247), uint8_t(210), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {{uint8_t(1), uint8_t(129), uint8_t(232), uint8_t(253), uint8_t(214), uint8_t(197), uint8_t(242), uint8_t(196), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {uint8_t(99), uint8_t(121), uint8_t(210), uint8_t(250), uint8_t(201), uint8_t(198), uint8_t(255), uint8_t(202), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(23), uint8_t(91), uint8_t(163), uint8_t(242), uint8_t(170), uint8_t(187), uint8_t(247), uint8_t(210), uint8_t(255), uint8_t(255), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(200), uint8_t(246), uint8_t(255), uint8_t(234), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(109), uint8_t(178), uint8_t(241), uint8_t(255), uint8_t(231), uint8_t(245), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(44), uint8_t(130), uint8_t(201), uint8_t(253), uint8_t(205), uint8_t(192), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(200), uint8_t(246), uint8_t(255), uint8_t(234), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(109), uint8_t(178), uint8_t(241), uint8_t(255), uint8_t(231), uint8_t(245), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(44), uint8_t(130), uint8_t(201), uint8_t(253), uint8_t(205), uint8_t(192), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(132), uint8_t(239), uint8_t(251), uint8_t(219), uint8_t(209), uint8_t(255), uint8_t(165), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(94), uint8_t(136), uint8_t(225), uint8_t(251), uint8_t(218), uint8_t(190), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(22), uint8_t(100), uint8_t(174), uint8_t(245), uint8_t(186), uint8_t(161), uint8_t(255), uint8_t(199), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(132), uint8_t(239), uint8_t(251), uint8_t(219), uint8_t(209), uint8_t(255), uint8_t(165), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(94), uint8_t(136), uint8_t(225), uint8_t(251), uint8_t(218), uint8_t(190), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(22), uint8_t(100), uint8_t(174), uint8_t(245), uint8_t(186), uint8_t(161), uint8_t(255), uint8_t(199), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(182), uint8_t(249), uint8_t(255), uint8_t(232), uint8_t(235), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(124), uint8_t(143), uint8_t(241), uint8_t(255), uint8_t(227), uint8_t(234), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(35), uint8_t(77), uint8_t(181), uint8_t(251), uint8_t(193), uint8_t(211), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(182), uint8_t(249), uint8_t(255), uint8_t(232), uint8_t(235), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(124), uint8_t(143), uint8_t(241), uint8_t(255), uint8_t(227), uint8_t(234), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(35), uint8_t(77), uint8_t(181), uint8_t(251), uint8_t(193), uint8_t(211), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(157), uint8_t(247), uint8_t(255), uint8_t(236), uint8_t(231), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(121), uint8_t(141), uint8_t(235), uint8_t(255), uint8_t(225), uint8_t(227), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(45), uint8_t(99), uint8_t(188), uint8_t(251), uint8_t(195), uint8_t(217), uint8_t(255), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(157), uint8_t(247), uint8_t(255), uint8_t(236), uint8_t(231), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(121), uint8_t(141), uint8_t(235), uint8_t(255), uint8_t(225), uint8_t(227), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(45), uint8_t(99), uint8_t(188), uint8_t(251), uint8_t(195), uint8_t(217), uint8_t(255), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(1), uint8_t(251), uint8_t(255), uint8_t(213), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(203), uint8_t(1), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(137), uint8_t(1), uint8_t(177), uint8_t(255), uint8_t(224), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(1), uint8_t(251), uint8_t(255), uint8_t(213), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(203), uint8_t(1), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(137), uint8_t(1), uint8_t(177), uint8_t(255), uint8_t(224), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(253), uint8_t(9), uint8_t(248), uint8_t(251), uint8_t(207), uint8_t(208), uint8_t(255), uint8_t(192), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(175), uint8_t(13), uint8_t(224), uint8_t(243), uint8_t(193), uint8_t(185), uint8_t(249), uint8_t(198), uint8_t(255), uint8_t(255), uint8_t(128)},
- [11]uint8_t{uint8_t(73), uint8_t(17), uint8_t(171), uint8_t(221), uint8_t(161), uint8_t(179), uint8_t(236), uint8_t(167), uint8_t(255), uint8_t(234), uint8_t(128)},
+ {
+ {{uint8_t(253), uint8_t(9), uint8_t(248), uint8_t(251), uint8_t(207), uint8_t(208), uint8_t(255), uint8_t(192), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(175), uint8_t(13), uint8_t(224), uint8_t(243), uint8_t(193), uint8_t(185), uint8_t(249), uint8_t(198), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {uint8_t(73), uint8_t(17), uint8_t(171), uint8_t(221), uint8_t(161), uint8_t(179), uint8_t(236), uint8_t(167), uint8_t(255), uint8_t(234), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(95), uint8_t(247), uint8_t(253), uint8_t(212), uint8_t(183), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(239), uint8_t(90), uint8_t(244), uint8_t(250), uint8_t(211), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(155), uint8_t(77), uint8_t(195), uint8_t(248), uint8_t(188), uint8_t(195), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(95), uint8_t(247), uint8_t(253), uint8_t(212), uint8_t(183), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(239), uint8_t(90), uint8_t(244), uint8_t(250), uint8_t(211), uint8_t(209), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(155), uint8_t(77), uint8_t(195), uint8_t(248), uint8_t(188), uint8_t(195), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(24), uint8_t(239), uint8_t(251), uint8_t(218), uint8_t(219), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(201), uint8_t(51), uint8_t(219), uint8_t(255), uint8_t(196), uint8_t(186), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(69), uint8_t(46), uint8_t(190), uint8_t(239), uint8_t(201), uint8_t(218), uint8_t(255), uint8_t(228), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(24), uint8_t(239), uint8_t(251), uint8_t(218), uint8_t(219), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(201), uint8_t(51), uint8_t(219), uint8_t(255), uint8_t(196), uint8_t(186), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(69), uint8_t(46), uint8_t(190), uint8_t(239), uint8_t(201), uint8_t(218), uint8_t(255), uint8_t(228), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(191), uint8_t(251), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(223), uint8_t(165), uint8_t(249), uint8_t(255), uint8_t(213), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(141), uint8_t(124), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(191), uint8_t(251), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(223), uint8_t(165), uint8_t(249), uint8_t(255), uint8_t(213), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(141), uint8_t(124), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(16), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(190), uint8_t(36), uint8_t(230), uint8_t(255), uint8_t(236), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(149), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(16), uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(190), uint8_t(36), uint8_t(230), uint8_t(255), uint8_t(236), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(149), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(226), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(247), uint8_t(192), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(240), uint8_t(128), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(226), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(247), uint8_t(192), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(240), uint8_t(128), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(134), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(213), uint8_t(62), uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(55), uint8_t(93), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(134), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(213), uint8_t(62), uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(55), uint8_t(93), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(202), uint8_t(24), uint8_t(213), uint8_t(235), uint8_t(186), uint8_t(191), uint8_t(220), uint8_t(160), uint8_t(240), uint8_t(175), uint8_t(255)},
- [11]uint8_t{uint8_t(126), uint8_t(38), uint8_t(182), uint8_t(232), uint8_t(169), uint8_t(184), uint8_t(228), uint8_t(174), uint8_t(255), uint8_t(187), uint8_t(128)},
- [11]uint8_t{uint8_t(61), uint8_t(46), uint8_t(138), uint8_t(219), uint8_t(151), uint8_t(178), uint8_t(240), uint8_t(170), uint8_t(255), uint8_t(216), uint8_t(128)},
+ {
+ {{uint8_t(202), uint8_t(24), uint8_t(213), uint8_t(235), uint8_t(186), uint8_t(191), uint8_t(220), uint8_t(160), uint8_t(240), uint8_t(175), uint8_t(255)},
+ {uint8_t(126), uint8_t(38), uint8_t(182), uint8_t(232), uint8_t(169), uint8_t(184), uint8_t(228), uint8_t(174), uint8_t(255), uint8_t(187), uint8_t(128)},
+ {uint8_t(61), uint8_t(46), uint8_t(138), uint8_t(219), uint8_t(151), uint8_t(178), uint8_t(240), uint8_t(170), uint8_t(255), uint8_t(216), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(112), uint8_t(230), uint8_t(250), uint8_t(199), uint8_t(191), uint8_t(247), uint8_t(159), uint8_t(255), uint8_t(255), uint8_t(128)},
- [11]uint8_t{uint8_t(166), uint8_t(109), uint8_t(228), uint8_t(252), uint8_t(211), uint8_t(215), uint8_t(255), uint8_t(174), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(39), uint8_t(77), uint8_t(162), uint8_t(232), uint8_t(172), uint8_t(180), uint8_t(245), uint8_t(178), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {{uint8_t(1), uint8_t(112), uint8_t(230), uint8_t(250), uint8_t(199), uint8_t(191), uint8_t(247), uint8_t(159), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {uint8_t(166), uint8_t(109), uint8_t(228), uint8_t(252), uint8_t(211), uint8_t(215), uint8_t(255), uint8_t(174), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(39), uint8_t(77), uint8_t(162), uint8_t(232), uint8_t(172), uint8_t(180), uint8_t(245), uint8_t(178), uint8_t(255), uint8_t(255), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(52), uint8_t(220), uint8_t(246), uint8_t(198), uint8_t(199), uint8_t(249), uint8_t(220), uint8_t(255), uint8_t(255), uint8_t(128)},
- [11]uint8_t{uint8_t(124), uint8_t(74), uint8_t(191), uint8_t(243), uint8_t(183), uint8_t(193), uint8_t(250), uint8_t(221), uint8_t(255), uint8_t(255), uint8_t(128)},
- [11]uint8_t{uint8_t(24), uint8_t(71), uint8_t(130), uint8_t(219), uint8_t(154), uint8_t(170), uint8_t(243), uint8_t(182), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {{uint8_t(1), uint8_t(52), uint8_t(220), uint8_t(246), uint8_t(198), uint8_t(199), uint8_t(249), uint8_t(220), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {uint8_t(124), uint8_t(74), uint8_t(191), uint8_t(243), uint8_t(183), uint8_t(193), uint8_t(250), uint8_t(221), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {uint8_t(24), uint8_t(71), uint8_t(130), uint8_t(219), uint8_t(154), uint8_t(170), uint8_t(243), uint8_t(182), uint8_t(255), uint8_t(255), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(182), uint8_t(225), uint8_t(249), uint8_t(219), uint8_t(240), uint8_t(255), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(149), uint8_t(150), uint8_t(226), uint8_t(252), uint8_t(216), uint8_t(205), uint8_t(255), uint8_t(171), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(28), uint8_t(108), uint8_t(170), uint8_t(242), uint8_t(183), uint8_t(194), uint8_t(254), uint8_t(223), uint8_t(255), uint8_t(255), uint8_t(128)},
+ {{uint8_t(1), uint8_t(182), uint8_t(225), uint8_t(249), uint8_t(219), uint8_t(240), uint8_t(255), uint8_t(224), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(149), uint8_t(150), uint8_t(226), uint8_t(252), uint8_t(216), uint8_t(205), uint8_t(255), uint8_t(171), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(28), uint8_t(108), uint8_t(170), uint8_t(242), uint8_t(183), uint8_t(194), uint8_t(254), uint8_t(223), uint8_t(255), uint8_t(255), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(81), uint8_t(230), uint8_t(252), uint8_t(204), uint8_t(203), uint8_t(255), uint8_t(192), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(123), uint8_t(102), uint8_t(209), uint8_t(247), uint8_t(188), uint8_t(196), uint8_t(255), uint8_t(233), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(20), uint8_t(95), uint8_t(153), uint8_t(243), uint8_t(164), uint8_t(173), uint8_t(255), uint8_t(203), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(81), uint8_t(230), uint8_t(252), uint8_t(204), uint8_t(203), uint8_t(255), uint8_t(192), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(123), uint8_t(102), uint8_t(209), uint8_t(247), uint8_t(188), uint8_t(196), uint8_t(255), uint8_t(233), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(20), uint8_t(95), uint8_t(153), uint8_t(243), uint8_t(164), uint8_t(173), uint8_t(255), uint8_t(203), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(222), uint8_t(248), uint8_t(255), uint8_t(216), uint8_t(213), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(168), uint8_t(175), uint8_t(246), uint8_t(252), uint8_t(235), uint8_t(205), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(47), uint8_t(116), uint8_t(215), uint8_t(255), uint8_t(211), uint8_t(212), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(222), uint8_t(248), uint8_t(255), uint8_t(216), uint8_t(213), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(168), uint8_t(175), uint8_t(246), uint8_t(252), uint8_t(235), uint8_t(205), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(47), uint8_t(116), uint8_t(215), uint8_t(255), uint8_t(211), uint8_t(212), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(121), uint8_t(236), uint8_t(253), uint8_t(212), uint8_t(214), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(141), uint8_t(84), uint8_t(213), uint8_t(252), uint8_t(201), uint8_t(202), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(42), uint8_t(80), uint8_t(160), uint8_t(240), uint8_t(162), uint8_t(185), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(121), uint8_t(236), uint8_t(253), uint8_t(212), uint8_t(214), uint8_t(255), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(141), uint8_t(84), uint8_t(213), uint8_t(252), uint8_t(201), uint8_t(202), uint8_t(255), uint8_t(219), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(42), uint8_t(80), uint8_t(160), uint8_t(240), uint8_t(162), uint8_t(185), uint8_t(255), uint8_t(205), uint8_t(128), uint8_t(128), uint8_t(128)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(1), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(244), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
- [11]uint8_t{uint8_t(238), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {{uint8_t(1), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(244), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
+ {uint8_t(238), uint8_t(1), uint8_t(255), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128), uint8_t(128)},
},
},
} /* tree_enc.c:21:3 */
func VP8DefaultProbas(tls *libc.TLS, enc uintptr) { /* tree_enc.c:156:6: */
- var probas uintptr = (enc + 3616 /* &.proba_ */)
+ var probas uintptr = enc + 3616
(*VP8EncProba)(unsafe.Pointer(probas)).use_skip_proba_ = 0
- libc.Xmemset(tls, (probas /* &.segments_ */), int32(255), uint64(unsafe.Sizeof([3]uint8_t{})))
- libc.Xmemcpy(tls, (probas + 4 /* &.coeffs_ */), uintptr(unsafe.Pointer(&VP8CoeffsProba0)), uint64(unsafe.Sizeof(VP8CoeffsProba0)))
+ libc.Xmemset(tls, probas, int32(255), uint64(unsafe.Sizeof([3]uint8_t{})))
+ libc.Xmemcpy(tls, probas+4, uintptr(unsafe.Pointer(&VP8CoeffsProba0)), uint64(unsafe.Sizeof(VP8CoeffsProba0)))
// Note: we could hard-code the level_costs_ corresponding to VP8CoeffsProba0,
// but that's ~11k of static data. Better call VP8CalculateLevelCosts() later.
(*VP8EncProba)(unsafe.Pointer(probas)).dirty_ = 1
}
// Paragraph 11.5. 900bytes.
-var kBModesProba1 = [10][10][9]uint8_t{[10][9]uint8_t{
- [9]uint8_t{uint8_t(231), uint8_t(120), uint8_t(48), uint8_t(89), uint8_t(115), uint8_t(113), uint8_t(120), uint8_t(152), uint8_t(112)},
- [9]uint8_t{uint8_t(152), uint8_t(179), uint8_t(64), uint8_t(126), uint8_t(170), uint8_t(118), uint8_t(46), uint8_t(70), uint8_t(95)},
- [9]uint8_t{uint8_t(175), uint8_t(69), uint8_t(143), uint8_t(80), uint8_t(85), uint8_t(82), uint8_t(72), uint8_t(155), uint8_t(103)},
- [9]uint8_t{uint8_t(56), uint8_t(58), uint8_t(10), uint8_t(171), uint8_t(218), uint8_t(189), uint8_t(17), uint8_t(13), uint8_t(152)},
- [9]uint8_t{uint8_t(114), uint8_t(26), uint8_t(17), uint8_t(163), uint8_t(44), uint8_t(195), uint8_t(21), uint8_t(10), uint8_t(173)},
- [9]uint8_t{uint8_t(121), uint8_t(24), uint8_t(80), uint8_t(195), uint8_t(26), uint8_t(62), uint8_t(44), uint8_t(64), uint8_t(85)},
- [9]uint8_t{uint8_t(144), uint8_t(71), uint8_t(10), uint8_t(38), uint8_t(171), uint8_t(213), uint8_t(144), uint8_t(34), uint8_t(26)},
- [9]uint8_t{uint8_t(170), uint8_t(46), uint8_t(55), uint8_t(19), uint8_t(136), uint8_t(160), uint8_t(33), uint8_t(206), uint8_t(71)},
- [9]uint8_t{uint8_t(63), uint8_t(20), uint8_t(8), uint8_t(114), uint8_t(114), uint8_t(208), uint8_t(12), uint8_t(9), uint8_t(226)},
- [9]uint8_t{uint8_t(81), uint8_t(40), uint8_t(11), uint8_t(96), uint8_t(182), uint8_t(84), uint8_t(29), uint8_t(16), uint8_t(36)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(134), uint8_t(183), uint8_t(89), uint8_t(137), uint8_t(98), uint8_t(101), uint8_t(106), uint8_t(165), uint8_t(148)},
- [9]uint8_t{uint8_t(72), uint8_t(187), uint8_t(100), uint8_t(130), uint8_t(157), uint8_t(111), uint8_t(32), uint8_t(75), uint8_t(80)},
- [9]uint8_t{uint8_t(66), uint8_t(102), uint8_t(167), uint8_t(99), uint8_t(74), uint8_t(62), uint8_t(40), uint8_t(234), uint8_t(128)},
- [9]uint8_t{uint8_t(41), uint8_t(53), uint8_t(9), uint8_t(178), uint8_t(241), uint8_t(141), uint8_t(26), uint8_t(8), uint8_t(107)},
- [9]uint8_t{uint8_t(74), uint8_t(43), uint8_t(26), uint8_t(146), uint8_t(73), uint8_t(166), uint8_t(49), uint8_t(23), uint8_t(157)},
- [9]uint8_t{uint8_t(65), uint8_t(38), uint8_t(105), uint8_t(160), uint8_t(51), uint8_t(52), uint8_t(31), uint8_t(115), uint8_t(128)},
- [9]uint8_t{uint8_t(104), uint8_t(79), uint8_t(12), uint8_t(27), uint8_t(217), uint8_t(255), uint8_t(87), uint8_t(17), uint8_t(7)},
- [9]uint8_t{uint8_t(87), uint8_t(68), uint8_t(71), uint8_t(44), uint8_t(114), uint8_t(51), uint8_t(15), uint8_t(186), uint8_t(23)},
- [9]uint8_t{uint8_t(47), uint8_t(41), uint8_t(14), uint8_t(110), uint8_t(182), uint8_t(183), uint8_t(21), uint8_t(17), uint8_t(194)},
- [9]uint8_t{uint8_t(66), uint8_t(45), uint8_t(25), uint8_t(102), uint8_t(197), uint8_t(189), uint8_t(23), uint8_t(18), uint8_t(22)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(88), uint8_t(88), uint8_t(147), uint8_t(150), uint8_t(42), uint8_t(46), uint8_t(45), uint8_t(196), uint8_t(205)},
- [9]uint8_t{uint8_t(43), uint8_t(97), uint8_t(183), uint8_t(117), uint8_t(85), uint8_t(38), uint8_t(35), uint8_t(179), uint8_t(61)},
- [9]uint8_t{uint8_t(39), uint8_t(53), uint8_t(200), uint8_t(87), uint8_t(26), uint8_t(21), uint8_t(43), uint8_t(232), uint8_t(171)},
- [9]uint8_t{uint8_t(56), uint8_t(34), uint8_t(51), uint8_t(104), uint8_t(114), uint8_t(102), uint8_t(29), uint8_t(93), uint8_t(77)},
- [9]uint8_t{uint8_t(39), uint8_t(28), uint8_t(85), uint8_t(171), uint8_t(58), uint8_t(165), uint8_t(90), uint8_t(98), uint8_t(64)},
- [9]uint8_t{uint8_t(34), uint8_t(22), uint8_t(116), uint8_t(206), uint8_t(23), uint8_t(34), uint8_t(43), uint8_t(166), uint8_t(73)},
- [9]uint8_t{uint8_t(107), uint8_t(54), uint8_t(32), uint8_t(26), uint8_t(51), uint8_t(1), uint8_t(81), uint8_t(43), uint8_t(31)},
- [9]uint8_t{uint8_t(68), uint8_t(25), uint8_t(106), uint8_t(22), uint8_t(64), uint8_t(171), uint8_t(36), uint8_t(225), uint8_t(114)},
- [9]uint8_t{uint8_t(34), uint8_t(19), uint8_t(21), uint8_t(102), uint8_t(132), uint8_t(188), uint8_t(16), uint8_t(76), uint8_t(124)},
- [9]uint8_t{uint8_t(62), uint8_t(18), uint8_t(78), uint8_t(95), uint8_t(85), uint8_t(57), uint8_t(50), uint8_t(48), uint8_t(51)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(193), uint8_t(101), uint8_t(35), uint8_t(159), uint8_t(215), uint8_t(111), uint8_t(89), uint8_t(46), uint8_t(111)},
- [9]uint8_t{uint8_t(60), uint8_t(148), uint8_t(31), uint8_t(172), uint8_t(219), uint8_t(228), uint8_t(21), uint8_t(18), uint8_t(111)},
- [9]uint8_t{uint8_t(112), uint8_t(113), uint8_t(77), uint8_t(85), uint8_t(179), uint8_t(255), uint8_t(38), uint8_t(120), uint8_t(114)},
- [9]uint8_t{uint8_t(40), uint8_t(42), uint8_t(1), uint8_t(196), uint8_t(245), uint8_t(209), uint8_t(10), uint8_t(25), uint8_t(109)},
- [9]uint8_t{uint8_t(88), uint8_t(43), uint8_t(29), uint8_t(140), uint8_t(166), uint8_t(213), uint8_t(37), uint8_t(43), uint8_t(154)},
- [9]uint8_t{uint8_t(61), uint8_t(63), uint8_t(30), uint8_t(155), uint8_t(67), uint8_t(45), uint8_t(68), uint8_t(1), uint8_t(209)},
- [9]uint8_t{uint8_t(100), uint8_t(80), uint8_t(8), uint8_t(43), uint8_t(154), uint8_t(1), uint8_t(51), uint8_t(26), uint8_t(71)},
- [9]uint8_t{uint8_t(142), uint8_t(78), uint8_t(78), uint8_t(16), uint8_t(255), uint8_t(128), uint8_t(34), uint8_t(197), uint8_t(171)},
- [9]uint8_t{uint8_t(41), uint8_t(40), uint8_t(5), uint8_t(102), uint8_t(211), uint8_t(183), uint8_t(4), uint8_t(1), uint8_t(221)},
- [9]uint8_t{uint8_t(51), uint8_t(50), uint8_t(17), uint8_t(168), uint8_t(209), uint8_t(192), uint8_t(23), uint8_t(25), uint8_t(82)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(138), uint8_t(31), uint8_t(36), uint8_t(171), uint8_t(27), uint8_t(166), uint8_t(38), uint8_t(44), uint8_t(229)},
- [9]uint8_t{uint8_t(67), uint8_t(87), uint8_t(58), uint8_t(169), uint8_t(82), uint8_t(115), uint8_t(26), uint8_t(59), uint8_t(179)},
- [9]uint8_t{uint8_t(63), uint8_t(59), uint8_t(90), uint8_t(180), uint8_t(59), uint8_t(166), uint8_t(93), uint8_t(73), uint8_t(154)},
- [9]uint8_t{uint8_t(40), uint8_t(40), uint8_t(21), uint8_t(116), uint8_t(143), uint8_t(209), uint8_t(34), uint8_t(39), uint8_t(175)},
- [9]uint8_t{uint8_t(47), uint8_t(15), uint8_t(16), uint8_t(183), uint8_t(34), uint8_t(223), uint8_t(49), uint8_t(45), uint8_t(183)},
- [9]uint8_t{uint8_t(46), uint8_t(17), uint8_t(33), uint8_t(183), uint8_t(6), uint8_t(98), uint8_t(15), uint8_t(32), uint8_t(183)},
- [9]uint8_t{uint8_t(57), uint8_t(46), uint8_t(22), uint8_t(24), uint8_t(128), uint8_t(1), uint8_t(54), uint8_t(17), uint8_t(37)},
- [9]uint8_t{uint8_t(65), uint8_t(32), uint8_t(73), uint8_t(115), uint8_t(28), uint8_t(128), uint8_t(23), uint8_t(128), uint8_t(205)},
- [9]uint8_t{uint8_t(40), uint8_t(3), uint8_t(9), uint8_t(115), uint8_t(51), uint8_t(192), uint8_t(18), uint8_t(6), uint8_t(223)},
- [9]uint8_t{uint8_t(87), uint8_t(37), uint8_t(9), uint8_t(115), uint8_t(59), uint8_t(77), uint8_t(64), uint8_t(21), uint8_t(47)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(104), uint8_t(55), uint8_t(44), uint8_t(218), uint8_t(9), uint8_t(54), uint8_t(53), uint8_t(130), uint8_t(226)},
- [9]uint8_t{uint8_t(64), uint8_t(90), uint8_t(70), uint8_t(205), uint8_t(40), uint8_t(41), uint8_t(23), uint8_t(26), uint8_t(57)},
- [9]uint8_t{uint8_t(54), uint8_t(57), uint8_t(112), uint8_t(184), uint8_t(5), uint8_t(41), uint8_t(38), uint8_t(166), uint8_t(213)},
- [9]uint8_t{uint8_t(30), uint8_t(34), uint8_t(26), uint8_t(133), uint8_t(152), uint8_t(116), uint8_t(10), uint8_t(32), uint8_t(134)},
- [9]uint8_t{uint8_t(39), uint8_t(19), uint8_t(53), uint8_t(221), uint8_t(26), uint8_t(114), uint8_t(32), uint8_t(73), uint8_t(255)},
- [9]uint8_t{uint8_t(31), uint8_t(9), uint8_t(65), uint8_t(234), uint8_t(2), uint8_t(15), uint8_t(1), uint8_t(118), uint8_t(73)},
- [9]uint8_t{uint8_t(75), uint8_t(32), uint8_t(12), uint8_t(51), uint8_t(192), uint8_t(255), uint8_t(160), uint8_t(43), uint8_t(51)},
- [9]uint8_t{uint8_t(88), uint8_t(31), uint8_t(35), uint8_t(67), uint8_t(102), uint8_t(85), uint8_t(55), uint8_t(186), uint8_t(85)},
- [9]uint8_t{uint8_t(56), uint8_t(21), uint8_t(23), uint8_t(111), uint8_t(59), uint8_t(205), uint8_t(45), uint8_t(37), uint8_t(192)},
- [9]uint8_t{uint8_t(55), uint8_t(38), uint8_t(70), uint8_t(124), uint8_t(73), uint8_t(102), uint8_t(1), uint8_t(34), uint8_t(98)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(125), uint8_t(98), uint8_t(42), uint8_t(88), uint8_t(104), uint8_t(85), uint8_t(117), uint8_t(175), uint8_t(82)},
- [9]uint8_t{uint8_t(95), uint8_t(84), uint8_t(53), uint8_t(89), uint8_t(128), uint8_t(100), uint8_t(113), uint8_t(101), uint8_t(45)},
- [9]uint8_t{uint8_t(75), uint8_t(79), uint8_t(123), uint8_t(47), uint8_t(51), uint8_t(128), uint8_t(81), uint8_t(171), uint8_t(1)},
- [9]uint8_t{uint8_t(57), uint8_t(17), uint8_t(5), uint8_t(71), uint8_t(102), uint8_t(57), uint8_t(53), uint8_t(41), uint8_t(49)},
- [9]uint8_t{uint8_t(38), uint8_t(33), uint8_t(13), uint8_t(121), uint8_t(57), uint8_t(73), uint8_t(26), uint8_t(1), uint8_t(85)},
- [9]uint8_t{uint8_t(41), uint8_t(10), uint8_t(67), uint8_t(138), uint8_t(77), uint8_t(110), uint8_t(90), uint8_t(47), uint8_t(114)},
- [9]uint8_t{uint8_t(115), uint8_t(21), uint8_t(2), uint8_t(10), uint8_t(102), uint8_t(255), uint8_t(166), uint8_t(23), uint8_t(6)},
- [9]uint8_t{uint8_t(101), uint8_t(29), uint8_t(16), uint8_t(10), uint8_t(85), uint8_t(128), uint8_t(101), uint8_t(196), uint8_t(26)},
- [9]uint8_t{uint8_t(57), uint8_t(18), uint8_t(10), uint8_t(102), uint8_t(102), uint8_t(213), uint8_t(34), uint8_t(20), uint8_t(43)},
- [9]uint8_t{uint8_t(117), uint8_t(20), uint8_t(15), uint8_t(36), uint8_t(163), uint8_t(128), uint8_t(68), uint8_t(1), uint8_t(26)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(102), uint8_t(61), uint8_t(71), uint8_t(37), uint8_t(34), uint8_t(53), uint8_t(31), uint8_t(243), uint8_t(192)},
- [9]uint8_t{uint8_t(69), uint8_t(60), uint8_t(71), uint8_t(38), uint8_t(73), uint8_t(119), uint8_t(28), uint8_t(222), uint8_t(37)},
- [9]uint8_t{uint8_t(68), uint8_t(45), uint8_t(128), uint8_t(34), uint8_t(1), uint8_t(47), uint8_t(11), uint8_t(245), uint8_t(171)},
- [9]uint8_t{uint8_t(62), uint8_t(17), uint8_t(19), uint8_t(70), uint8_t(146), uint8_t(85), uint8_t(55), uint8_t(62), uint8_t(70)},
- [9]uint8_t{uint8_t(37), uint8_t(43), uint8_t(37), uint8_t(154), uint8_t(100), uint8_t(163), uint8_t(85), uint8_t(160), uint8_t(1)},
- [9]uint8_t{uint8_t(63), uint8_t(9), uint8_t(92), uint8_t(136), uint8_t(28), uint8_t(64), uint8_t(32), uint8_t(201), uint8_t(85)},
- [9]uint8_t{uint8_t(75), uint8_t(15), uint8_t(9), uint8_t(9), uint8_t(64), uint8_t(255), uint8_t(184), uint8_t(119), uint8_t(16)},
- [9]uint8_t{uint8_t(86), uint8_t(6), uint8_t(28), uint8_t(5), uint8_t(64), uint8_t(255), uint8_t(25), uint8_t(248), uint8_t(1)},
- [9]uint8_t{uint8_t(56), uint8_t(8), uint8_t(17), uint8_t(132), uint8_t(137), uint8_t(255), uint8_t(55), uint8_t(116), uint8_t(128)},
- [9]uint8_t{uint8_t(58), uint8_t(15), uint8_t(20), uint8_t(82), uint8_t(135), uint8_t(57), uint8_t(26), uint8_t(121), uint8_t(40)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(164), uint8_t(50), uint8_t(31), uint8_t(137), uint8_t(154), uint8_t(133), uint8_t(25), uint8_t(35), uint8_t(218)},
- [9]uint8_t{uint8_t(51), uint8_t(103), uint8_t(44), uint8_t(131), uint8_t(131), uint8_t(123), uint8_t(31), uint8_t(6), uint8_t(158)},
- [9]uint8_t{uint8_t(86), uint8_t(40), uint8_t(64), uint8_t(135), uint8_t(148), uint8_t(224), uint8_t(45), uint8_t(183), uint8_t(128)},
- [9]uint8_t{uint8_t(22), uint8_t(26), uint8_t(17), uint8_t(131), uint8_t(240), uint8_t(154), uint8_t(14), uint8_t(1), uint8_t(209)},
- [9]uint8_t{uint8_t(45), uint8_t(16), uint8_t(21), uint8_t(91), uint8_t(64), uint8_t(222), uint8_t(7), uint8_t(1), uint8_t(197)},
- [9]uint8_t{uint8_t(56), uint8_t(21), uint8_t(39), uint8_t(155), uint8_t(60), uint8_t(138), uint8_t(23), uint8_t(102), uint8_t(213)},
- [9]uint8_t{uint8_t(83), uint8_t(12), uint8_t(13), uint8_t(54), uint8_t(192), uint8_t(255), uint8_t(68), uint8_t(47), uint8_t(28)},
- [9]uint8_t{uint8_t(85), uint8_t(26), uint8_t(85), uint8_t(85), uint8_t(128), uint8_t(128), uint8_t(32), uint8_t(146), uint8_t(171)},
- [9]uint8_t{uint8_t(18), uint8_t(11), uint8_t(7), uint8_t(63), uint8_t(144), uint8_t(171), uint8_t(4), uint8_t(4), uint8_t(246)},
- [9]uint8_t{uint8_t(35), uint8_t(27), uint8_t(10), uint8_t(146), uint8_t(174), uint8_t(171), uint8_t(12), uint8_t(26), uint8_t(128)}},
- [10][9]uint8_t{[9]uint8_t{uint8_t(190), uint8_t(80), uint8_t(35), uint8_t(99), uint8_t(180), uint8_t(80), uint8_t(126), uint8_t(54), uint8_t(45)},
- [9]uint8_t{uint8_t(85), uint8_t(126), uint8_t(47), uint8_t(87), uint8_t(176), uint8_t(51), uint8_t(41), uint8_t(20), uint8_t(32)},
- [9]uint8_t{uint8_t(101), uint8_t(75), uint8_t(128), uint8_t(139), uint8_t(118), uint8_t(146), uint8_t(116), uint8_t(128), uint8_t(85)},
- [9]uint8_t{uint8_t(56), uint8_t(41), uint8_t(15), uint8_t(176), uint8_t(236), uint8_t(85), uint8_t(37), uint8_t(9), uint8_t(62)},
- [9]uint8_t{uint8_t(71), uint8_t(30), uint8_t(17), uint8_t(119), uint8_t(118), uint8_t(255), uint8_t(17), uint8_t(18), uint8_t(138)},
- [9]uint8_t{uint8_t(101), uint8_t(38), uint8_t(60), uint8_t(138), uint8_t(55), uint8_t(70), uint8_t(43), uint8_t(26), uint8_t(142)},
- [9]uint8_t{uint8_t(146), uint8_t(36), uint8_t(19), uint8_t(30), uint8_t(171), uint8_t(255), uint8_t(97), uint8_t(27), uint8_t(20)},
- [9]uint8_t{uint8_t(138), uint8_t(45), uint8_t(61), uint8_t(62), uint8_t(219), uint8_t(1), uint8_t(81), uint8_t(188), uint8_t(64)},
- [9]uint8_t{uint8_t(32), uint8_t(41), uint8_t(20), uint8_t(117), uint8_t(151), uint8_t(142), uint8_t(20), uint8_t(21), uint8_t(163)},
- [9]uint8_t{uint8_t(112), uint8_t(19), uint8_t(12), uint8_t(61), uint8_t(195), uint8_t(128), uint8_t(48), uint8_t(4), uint8_t(24)}}} /* tree_enc.c:167:22 */
+var kBModesProba1 = [10][10][9]uint8_t{{
+ {uint8_t(231), uint8_t(120), uint8_t(48), uint8_t(89), uint8_t(115), uint8_t(113), uint8_t(120), uint8_t(152), uint8_t(112)},
+ {uint8_t(152), uint8_t(179), uint8_t(64), uint8_t(126), uint8_t(170), uint8_t(118), uint8_t(46), uint8_t(70), uint8_t(95)},
+ {uint8_t(175), uint8_t(69), uint8_t(143), uint8_t(80), uint8_t(85), uint8_t(82), uint8_t(72), uint8_t(155), uint8_t(103)},
+ {uint8_t(56), uint8_t(58), uint8_t(10), uint8_t(171), uint8_t(218), uint8_t(189), uint8_t(17), uint8_t(13), uint8_t(152)},
+ {uint8_t(114), uint8_t(26), uint8_t(17), uint8_t(163), uint8_t(44), uint8_t(195), uint8_t(21), uint8_t(10), uint8_t(173)},
+ {uint8_t(121), uint8_t(24), uint8_t(80), uint8_t(195), uint8_t(26), uint8_t(62), uint8_t(44), uint8_t(64), uint8_t(85)},
+ {uint8_t(144), uint8_t(71), uint8_t(10), uint8_t(38), uint8_t(171), uint8_t(213), uint8_t(144), uint8_t(34), uint8_t(26)},
+ {uint8_t(170), uint8_t(46), uint8_t(55), uint8_t(19), uint8_t(136), uint8_t(160), uint8_t(33), uint8_t(206), uint8_t(71)},
+ {uint8_t(63), uint8_t(20), uint8_t(8), uint8_t(114), uint8_t(114), uint8_t(208), uint8_t(12), uint8_t(9), uint8_t(226)},
+ {uint8_t(81), uint8_t(40), uint8_t(11), uint8_t(96), uint8_t(182), uint8_t(84), uint8_t(29), uint8_t(16), uint8_t(36)}},
+ {{uint8_t(134), uint8_t(183), uint8_t(89), uint8_t(137), uint8_t(98), uint8_t(101), uint8_t(106), uint8_t(165), uint8_t(148)},
+ {uint8_t(72), uint8_t(187), uint8_t(100), uint8_t(130), uint8_t(157), uint8_t(111), uint8_t(32), uint8_t(75), uint8_t(80)},
+ {uint8_t(66), uint8_t(102), uint8_t(167), uint8_t(99), uint8_t(74), uint8_t(62), uint8_t(40), uint8_t(234), uint8_t(128)},
+ {uint8_t(41), uint8_t(53), uint8_t(9), uint8_t(178), uint8_t(241), uint8_t(141), uint8_t(26), uint8_t(8), uint8_t(107)},
+ {uint8_t(74), uint8_t(43), uint8_t(26), uint8_t(146), uint8_t(73), uint8_t(166), uint8_t(49), uint8_t(23), uint8_t(157)},
+ {uint8_t(65), uint8_t(38), uint8_t(105), uint8_t(160), uint8_t(51), uint8_t(52), uint8_t(31), uint8_t(115), uint8_t(128)},
+ {uint8_t(104), uint8_t(79), uint8_t(12), uint8_t(27), uint8_t(217), uint8_t(255), uint8_t(87), uint8_t(17), uint8_t(7)},
+ {uint8_t(87), uint8_t(68), uint8_t(71), uint8_t(44), uint8_t(114), uint8_t(51), uint8_t(15), uint8_t(186), uint8_t(23)},
+ {uint8_t(47), uint8_t(41), uint8_t(14), uint8_t(110), uint8_t(182), uint8_t(183), uint8_t(21), uint8_t(17), uint8_t(194)},
+ {uint8_t(66), uint8_t(45), uint8_t(25), uint8_t(102), uint8_t(197), uint8_t(189), uint8_t(23), uint8_t(18), uint8_t(22)}},
+ {{uint8_t(88), uint8_t(88), uint8_t(147), uint8_t(150), uint8_t(42), uint8_t(46), uint8_t(45), uint8_t(196), uint8_t(205)},
+ {uint8_t(43), uint8_t(97), uint8_t(183), uint8_t(117), uint8_t(85), uint8_t(38), uint8_t(35), uint8_t(179), uint8_t(61)},
+ {uint8_t(39), uint8_t(53), uint8_t(200), uint8_t(87), uint8_t(26), uint8_t(21), uint8_t(43), uint8_t(232), uint8_t(171)},
+ {uint8_t(56), uint8_t(34), uint8_t(51), uint8_t(104), uint8_t(114), uint8_t(102), uint8_t(29), uint8_t(93), uint8_t(77)},
+ {uint8_t(39), uint8_t(28), uint8_t(85), uint8_t(171), uint8_t(58), uint8_t(165), uint8_t(90), uint8_t(98), uint8_t(64)},
+ {uint8_t(34), uint8_t(22), uint8_t(116), uint8_t(206), uint8_t(23), uint8_t(34), uint8_t(43), uint8_t(166), uint8_t(73)},
+ {uint8_t(107), uint8_t(54), uint8_t(32), uint8_t(26), uint8_t(51), uint8_t(1), uint8_t(81), uint8_t(43), uint8_t(31)},
+ {uint8_t(68), uint8_t(25), uint8_t(106), uint8_t(22), uint8_t(64), uint8_t(171), uint8_t(36), uint8_t(225), uint8_t(114)},
+ {uint8_t(34), uint8_t(19), uint8_t(21), uint8_t(102), uint8_t(132), uint8_t(188), uint8_t(16), uint8_t(76), uint8_t(124)},
+ {uint8_t(62), uint8_t(18), uint8_t(78), uint8_t(95), uint8_t(85), uint8_t(57), uint8_t(50), uint8_t(48), uint8_t(51)}},
+ {{uint8_t(193), uint8_t(101), uint8_t(35), uint8_t(159), uint8_t(215), uint8_t(111), uint8_t(89), uint8_t(46), uint8_t(111)},
+ {uint8_t(60), uint8_t(148), uint8_t(31), uint8_t(172), uint8_t(219), uint8_t(228), uint8_t(21), uint8_t(18), uint8_t(111)},
+ {uint8_t(112), uint8_t(113), uint8_t(77), uint8_t(85), uint8_t(179), uint8_t(255), uint8_t(38), uint8_t(120), uint8_t(114)},
+ {uint8_t(40), uint8_t(42), uint8_t(1), uint8_t(196), uint8_t(245), uint8_t(209), uint8_t(10), uint8_t(25), uint8_t(109)},
+ {uint8_t(88), uint8_t(43), uint8_t(29), uint8_t(140), uint8_t(166), uint8_t(213), uint8_t(37), uint8_t(43), uint8_t(154)},
+ {uint8_t(61), uint8_t(63), uint8_t(30), uint8_t(155), uint8_t(67), uint8_t(45), uint8_t(68), uint8_t(1), uint8_t(209)},
+ {uint8_t(100), uint8_t(80), uint8_t(8), uint8_t(43), uint8_t(154), uint8_t(1), uint8_t(51), uint8_t(26), uint8_t(71)},
+ {uint8_t(142), uint8_t(78), uint8_t(78), uint8_t(16), uint8_t(255), uint8_t(128), uint8_t(34), uint8_t(197), uint8_t(171)},
+ {uint8_t(41), uint8_t(40), uint8_t(5), uint8_t(102), uint8_t(211), uint8_t(183), uint8_t(4), uint8_t(1), uint8_t(221)},
+ {uint8_t(51), uint8_t(50), uint8_t(17), uint8_t(168), uint8_t(209), uint8_t(192), uint8_t(23), uint8_t(25), uint8_t(82)}},
+ {{uint8_t(138), uint8_t(31), uint8_t(36), uint8_t(171), uint8_t(27), uint8_t(166), uint8_t(38), uint8_t(44), uint8_t(229)},
+ {uint8_t(67), uint8_t(87), uint8_t(58), uint8_t(169), uint8_t(82), uint8_t(115), uint8_t(26), uint8_t(59), uint8_t(179)},
+ {uint8_t(63), uint8_t(59), uint8_t(90), uint8_t(180), uint8_t(59), uint8_t(166), uint8_t(93), uint8_t(73), uint8_t(154)},
+ {uint8_t(40), uint8_t(40), uint8_t(21), uint8_t(116), uint8_t(143), uint8_t(209), uint8_t(34), uint8_t(39), uint8_t(175)},
+ {uint8_t(47), uint8_t(15), uint8_t(16), uint8_t(183), uint8_t(34), uint8_t(223), uint8_t(49), uint8_t(45), uint8_t(183)},
+ {uint8_t(46), uint8_t(17), uint8_t(33), uint8_t(183), uint8_t(6), uint8_t(98), uint8_t(15), uint8_t(32), uint8_t(183)},
+ {uint8_t(57), uint8_t(46), uint8_t(22), uint8_t(24), uint8_t(128), uint8_t(1), uint8_t(54), uint8_t(17), uint8_t(37)},
+ {uint8_t(65), uint8_t(32), uint8_t(73), uint8_t(115), uint8_t(28), uint8_t(128), uint8_t(23), uint8_t(128), uint8_t(205)},
+ {uint8_t(40), uint8_t(3), uint8_t(9), uint8_t(115), uint8_t(51), uint8_t(192), uint8_t(18), uint8_t(6), uint8_t(223)},
+ {uint8_t(87), uint8_t(37), uint8_t(9), uint8_t(115), uint8_t(59), uint8_t(77), uint8_t(64), uint8_t(21), uint8_t(47)}},
+ {{uint8_t(104), uint8_t(55), uint8_t(44), uint8_t(218), uint8_t(9), uint8_t(54), uint8_t(53), uint8_t(130), uint8_t(226)},
+ {uint8_t(64), uint8_t(90), uint8_t(70), uint8_t(205), uint8_t(40), uint8_t(41), uint8_t(23), uint8_t(26), uint8_t(57)},
+ {uint8_t(54), uint8_t(57), uint8_t(112), uint8_t(184), uint8_t(5), uint8_t(41), uint8_t(38), uint8_t(166), uint8_t(213)},
+ {uint8_t(30), uint8_t(34), uint8_t(26), uint8_t(133), uint8_t(152), uint8_t(116), uint8_t(10), uint8_t(32), uint8_t(134)},
+ {uint8_t(39), uint8_t(19), uint8_t(53), uint8_t(221), uint8_t(26), uint8_t(114), uint8_t(32), uint8_t(73), uint8_t(255)},
+ {uint8_t(31), uint8_t(9), uint8_t(65), uint8_t(234), uint8_t(2), uint8_t(15), uint8_t(1), uint8_t(118), uint8_t(73)},
+ {uint8_t(75), uint8_t(32), uint8_t(12), uint8_t(51), uint8_t(192), uint8_t(255), uint8_t(160), uint8_t(43), uint8_t(51)},
+ {uint8_t(88), uint8_t(31), uint8_t(35), uint8_t(67), uint8_t(102), uint8_t(85), uint8_t(55), uint8_t(186), uint8_t(85)},
+ {uint8_t(56), uint8_t(21), uint8_t(23), uint8_t(111), uint8_t(59), uint8_t(205), uint8_t(45), uint8_t(37), uint8_t(192)},
+ {uint8_t(55), uint8_t(38), uint8_t(70), uint8_t(124), uint8_t(73), uint8_t(102), uint8_t(1), uint8_t(34), uint8_t(98)}},
+ {{uint8_t(125), uint8_t(98), uint8_t(42), uint8_t(88), uint8_t(104), uint8_t(85), uint8_t(117), uint8_t(175), uint8_t(82)},
+ {uint8_t(95), uint8_t(84), uint8_t(53), uint8_t(89), uint8_t(128), uint8_t(100), uint8_t(113), uint8_t(101), uint8_t(45)},
+ {uint8_t(75), uint8_t(79), uint8_t(123), uint8_t(47), uint8_t(51), uint8_t(128), uint8_t(81), uint8_t(171), uint8_t(1)},
+ {uint8_t(57), uint8_t(17), uint8_t(5), uint8_t(71), uint8_t(102), uint8_t(57), uint8_t(53), uint8_t(41), uint8_t(49)},
+ {uint8_t(38), uint8_t(33), uint8_t(13), uint8_t(121), uint8_t(57), uint8_t(73), uint8_t(26), uint8_t(1), uint8_t(85)},
+ {uint8_t(41), uint8_t(10), uint8_t(67), uint8_t(138), uint8_t(77), uint8_t(110), uint8_t(90), uint8_t(47), uint8_t(114)},
+ {uint8_t(115), uint8_t(21), uint8_t(2), uint8_t(10), uint8_t(102), uint8_t(255), uint8_t(166), uint8_t(23), uint8_t(6)},
+ {uint8_t(101), uint8_t(29), uint8_t(16), uint8_t(10), uint8_t(85), uint8_t(128), uint8_t(101), uint8_t(196), uint8_t(26)},
+ {uint8_t(57), uint8_t(18), uint8_t(10), uint8_t(102), uint8_t(102), uint8_t(213), uint8_t(34), uint8_t(20), uint8_t(43)},
+ {uint8_t(117), uint8_t(20), uint8_t(15), uint8_t(36), uint8_t(163), uint8_t(128), uint8_t(68), uint8_t(1), uint8_t(26)}},
+ {{uint8_t(102), uint8_t(61), uint8_t(71), uint8_t(37), uint8_t(34), uint8_t(53), uint8_t(31), uint8_t(243), uint8_t(192)},
+ {uint8_t(69), uint8_t(60), uint8_t(71), uint8_t(38), uint8_t(73), uint8_t(119), uint8_t(28), uint8_t(222), uint8_t(37)},
+ {uint8_t(68), uint8_t(45), uint8_t(128), uint8_t(34), uint8_t(1), uint8_t(47), uint8_t(11), uint8_t(245), uint8_t(171)},
+ {uint8_t(62), uint8_t(17), uint8_t(19), uint8_t(70), uint8_t(146), uint8_t(85), uint8_t(55), uint8_t(62), uint8_t(70)},
+ {uint8_t(37), uint8_t(43), uint8_t(37), uint8_t(154), uint8_t(100), uint8_t(163), uint8_t(85), uint8_t(160), uint8_t(1)},
+ {uint8_t(63), uint8_t(9), uint8_t(92), uint8_t(136), uint8_t(28), uint8_t(64), uint8_t(32), uint8_t(201), uint8_t(85)},
+ {uint8_t(75), uint8_t(15), uint8_t(9), uint8_t(9), uint8_t(64), uint8_t(255), uint8_t(184), uint8_t(119), uint8_t(16)},
+ {uint8_t(86), uint8_t(6), uint8_t(28), uint8_t(5), uint8_t(64), uint8_t(255), uint8_t(25), uint8_t(248), uint8_t(1)},
+ {uint8_t(56), uint8_t(8), uint8_t(17), uint8_t(132), uint8_t(137), uint8_t(255), uint8_t(55), uint8_t(116), uint8_t(128)},
+ {uint8_t(58), uint8_t(15), uint8_t(20), uint8_t(82), uint8_t(135), uint8_t(57), uint8_t(26), uint8_t(121), uint8_t(40)}},
+ {{uint8_t(164), uint8_t(50), uint8_t(31), uint8_t(137), uint8_t(154), uint8_t(133), uint8_t(25), uint8_t(35), uint8_t(218)},
+ {uint8_t(51), uint8_t(103), uint8_t(44), uint8_t(131), uint8_t(131), uint8_t(123), uint8_t(31), uint8_t(6), uint8_t(158)},
+ {uint8_t(86), uint8_t(40), uint8_t(64), uint8_t(135), uint8_t(148), uint8_t(224), uint8_t(45), uint8_t(183), uint8_t(128)},
+ {uint8_t(22), uint8_t(26), uint8_t(17), uint8_t(131), uint8_t(240), uint8_t(154), uint8_t(14), uint8_t(1), uint8_t(209)},
+ {uint8_t(45), uint8_t(16), uint8_t(21), uint8_t(91), uint8_t(64), uint8_t(222), uint8_t(7), uint8_t(1), uint8_t(197)},
+ {uint8_t(56), uint8_t(21), uint8_t(39), uint8_t(155), uint8_t(60), uint8_t(138), uint8_t(23), uint8_t(102), uint8_t(213)},
+ {uint8_t(83), uint8_t(12), uint8_t(13), uint8_t(54), uint8_t(192), uint8_t(255), uint8_t(68), uint8_t(47), uint8_t(28)},
+ {uint8_t(85), uint8_t(26), uint8_t(85), uint8_t(85), uint8_t(128), uint8_t(128), uint8_t(32), uint8_t(146), uint8_t(171)},
+ {uint8_t(18), uint8_t(11), uint8_t(7), uint8_t(63), uint8_t(144), uint8_t(171), uint8_t(4), uint8_t(4), uint8_t(246)},
+ {uint8_t(35), uint8_t(27), uint8_t(10), uint8_t(146), uint8_t(174), uint8_t(171), uint8_t(12), uint8_t(26), uint8_t(128)}},
+ {{uint8_t(190), uint8_t(80), uint8_t(35), uint8_t(99), uint8_t(180), uint8_t(80), uint8_t(126), uint8_t(54), uint8_t(45)},
+ {uint8_t(85), uint8_t(126), uint8_t(47), uint8_t(87), uint8_t(176), uint8_t(51), uint8_t(41), uint8_t(20), uint8_t(32)},
+ {uint8_t(101), uint8_t(75), uint8_t(128), uint8_t(139), uint8_t(118), uint8_t(146), uint8_t(116), uint8_t(128), uint8_t(85)},
+ {uint8_t(56), uint8_t(41), uint8_t(15), uint8_t(176), uint8_t(236), uint8_t(85), uint8_t(37), uint8_t(9), uint8_t(62)},
+ {uint8_t(71), uint8_t(30), uint8_t(17), uint8_t(119), uint8_t(118), uint8_t(255), uint8_t(17), uint8_t(18), uint8_t(138)},
+ {uint8_t(101), uint8_t(38), uint8_t(60), uint8_t(138), uint8_t(55), uint8_t(70), uint8_t(43), uint8_t(26), uint8_t(142)},
+ {uint8_t(146), uint8_t(36), uint8_t(19), uint8_t(30), uint8_t(171), uint8_t(255), uint8_t(97), uint8_t(27), uint8_t(20)},
+ {uint8_t(138), uint8_t(45), uint8_t(61), uint8_t(62), uint8_t(219), uint8_t(1), uint8_t(81), uint8_t(188), uint8_t(64)},
+ {uint8_t(32), uint8_t(41), uint8_t(20), uint8_t(117), uint8_t(151), uint8_t(142), uint8_t(20), uint8_t(21), uint8_t(163)},
+ {uint8_t(112), uint8_t(19), uint8_t(12), uint8_t(61), uint8_t(195), uint8_t(128), uint8_t(48), uint8_t(4), uint8_t(24)}}} /* tree_enc.c:167:22 */
func PutI4Mode(tls *libc.TLS, bw uintptr, mode int32, prob uintptr) int32 { /* tree_enc.c:270:12: */
- if VP8PutBit(tls, bw, (libc.Bool32(mode != B_DC_PRED)), int32(*(*uint8_t)(unsafe.Pointer(prob)))) != 0 {
- if VP8PutBit(tls, bw, (libc.Bool32(mode != B_TM_PRED)), int32(*(*uint8_t)(unsafe.Pointer(prob + 1)))) != 0 {
- if VP8PutBit(tls, bw, (libc.Bool32(mode != B_VE_PRED)), int32(*(*uint8_t)(unsafe.Pointer(prob + 2)))) != 0 {
- if !(VP8PutBit(tls, bw, (libc.Bool32(mode >= B_LD_PRED)), int32(*(*uint8_t)(unsafe.Pointer(prob + 3)))) != 0) {
- if VP8PutBit(tls, bw, (libc.Bool32(mode != B_HE_PRED)), int32(*(*uint8_t)(unsafe.Pointer(prob + 4)))) != 0 {
- VP8PutBit(tls, bw, (libc.Bool32(mode != B_RD_PRED)), int32(*(*uint8_t)(unsafe.Pointer(prob + 5))))
+ if VP8PutBit(tls, bw, libc.Bool32(mode != B_DC_PRED), int32(*(*uint8_t)(unsafe.Pointer(prob)))) != 0 {
+ if VP8PutBit(tls, bw, libc.Bool32(mode != B_TM_PRED), int32(*(*uint8_t)(unsafe.Pointer(prob + 1)))) != 0 {
+ if VP8PutBit(tls, bw, libc.Bool32(mode != B_VE_PRED), int32(*(*uint8_t)(unsafe.Pointer(prob + 2)))) != 0 {
+ if !(VP8PutBit(tls, bw, libc.Bool32(mode >= B_LD_PRED), int32(*(*uint8_t)(unsafe.Pointer(prob + 3)))) != 0) {
+ if VP8PutBit(tls, bw, libc.Bool32(mode != B_HE_PRED), int32(*(*uint8_t)(unsafe.Pointer(prob + 4)))) != 0 {
+ VP8PutBit(tls, bw, libc.Bool32(mode != B_RD_PRED), int32(*(*uint8_t)(unsafe.Pointer(prob + 5))))
}
} else {
- if VP8PutBit(tls, bw, (libc.Bool32(mode != B_LD_PRED)), int32(*(*uint8_t)(unsafe.Pointer(prob + 6)))) != 0 {
- if VP8PutBit(tls, bw, (libc.Bool32(mode != B_VL_PRED)), int32(*(*uint8_t)(unsafe.Pointer(prob + 7)))) != 0 {
- VP8PutBit(tls, bw, (libc.Bool32(mode != B_HD_PRED)), int32(*(*uint8_t)(unsafe.Pointer(prob + 8))))
+ if VP8PutBit(tls, bw, libc.Bool32(mode != B_LD_PRED), int32(*(*uint8_t)(unsafe.Pointer(prob + 6)))) != 0 {
+ if VP8PutBit(tls, bw, libc.Bool32(mode != B_VL_PRED), int32(*(*uint8_t)(unsafe.Pointer(prob + 7)))) != 0 {
+ VP8PutBit(tls, bw, libc.Bool32(mode != B_HD_PRED), int32(*(*uint8_t)(unsafe.Pointer(prob + 8))))
}
}
}
@@ -35056,203 +34758,203 @@ func PutI4Mode(tls *libc.TLS, bw uintptr, mode int32, prob uintptr) int32 { /* t
}
func PutI16Mode(tls *libc.TLS, bw uintptr, mode int32) { /* tree_enc.c:292:13: */
- if VP8PutBit(tls, bw, (libc.Bool32((mode == TM_PRED) || (mode == H_PRED))), 156) != 0 {
- VP8PutBit(tls, bw, (libc.Bool32(mode == TM_PRED)), 128) // TM or HE
+ if VP8PutBit(tls, bw, libc.Bool32(mode == TM_PRED || mode == H_PRED), 156) != 0 {
+ VP8PutBit(tls, bw, libc.Bool32(mode == TM_PRED), 128) // TM or HE
} else {
- VP8PutBit(tls, bw, (libc.Bool32(mode == V_PRED)), 163) // VE or DC
+ VP8PutBit(tls, bw, libc.Bool32(mode == V_PRED), 163) // VE or DC
}
}
func PutUVMode(tls *libc.TLS, bw uintptr, uv_mode int32) { /* tree_enc.c:300:13: */
- if VP8PutBit(tls, bw, (libc.Bool32(uv_mode != DC_PRED)), 142) != 0 {
- if VP8PutBit(tls, bw, (libc.Bool32(uv_mode != V_PRED)), 114) != 0 {
- VP8PutBit(tls, bw, (libc.Bool32(uv_mode != H_PRED)), 183) // else: TM_PRED
+ if VP8PutBit(tls, bw, libc.Bool32(uv_mode != DC_PRED), 142) != 0 {
+ if VP8PutBit(tls, bw, libc.Bool32(uv_mode != V_PRED), 114) != 0 {
+ VP8PutBit(tls, bw, libc.Bool32(uv_mode != H_PRED), 183) // else: TM_PRED
}
}
}
func PutSegment(tls *libc.TLS, bw uintptr, s int32, p uintptr) { /* tree_enc.c:308:13: */
- if VP8PutBit(tls, bw, (libc.Bool32(s >= 2)), int32(*(*uint8_t)(unsafe.Pointer(p)))) != 0 {
+ if VP8PutBit(tls, bw, libc.Bool32(s >= 2), int32(*(*uint8_t)(unsafe.Pointer(p)))) != 0 {
p += uintptr(1)
}
- VP8PutBit(tls, bw, (s & 1), int32(*(*uint8_t)(unsafe.Pointer(p + 1))))
+ VP8PutBit(tls, bw, s&1, int32(*(*uint8_t)(unsafe.Pointer(p + 1))))
}
func VP8CodeIntraModes(tls *libc.TLS, enc uintptr) { /* tree_enc.c:313:6: */
bp := tls.Alloc(3848)
defer tls.Free(3848)
- var bw uintptr = (enc + 64 /* &.bw_ */)
+ var bw uintptr = enc + 64
// var it VP8EncIterator at bp, 3848
- VP8IteratorInit(tls, enc, (bp) /* &it */)
- for ok := true; ok; ok = (VP8IteratorNext(tls, (bp) /* &it */) != 0) {
+ VP8IteratorInit(tls, enc, bp)
+ for __ccgo := true; __ccgo; __ccgo = VP8IteratorNext(tls, bp) != 0 {
var mb uintptr = (*VP8EncIterator)(unsafe.Pointer(bp /* &it */)).mb_
var preds uintptr = (*VP8EncIterator)(unsafe.Pointer(bp /* &it */)).preds_
if (*VP8Encoder)(unsafe.Pointer(enc)).segment_hdr_.update_map_ != 0 {
- PutSegment(tls, bw, (int32(*(*uint8)(unsafe.Pointer(mb /* &.segment_ */)) & 0x60 >> 5)), (enc + 3616 /* &.proba_ */) /* &.segments_ */)
+ PutSegment(tls, bw, int32(*(*uint8)(unsafe.Pointer(mb))&0x60>>5), enc+3616)
}
if (*VP8Encoder)(unsafe.Pointer(enc)).proba_.use_skip_proba_ != 0 {
- VP8PutBit(tls, bw, (int32(*(*uint8)(unsafe.Pointer(mb /* &.skip_ */)) & 0x10 >> 4)), int32((*VP8Encoder)(unsafe.Pointer(enc)).proba_.skip_proba_))
+ VP8PutBit(tls, bw, int32(*(*uint8)(unsafe.Pointer(mb))&0x10>>4), int32((*VP8Encoder)(unsafe.Pointer(enc)).proba_.skip_proba_))
}
- if VP8PutBit(tls, bw, (libc.Bool32((int32(*(*uint8)(unsafe.Pointer(mb /* &.type_ */))&0x3>>0)) != 0)), 145) != 0 { // i16x16
+ if VP8PutBit(tls, bw, libc.Bool32(int32(*(*uint8)(unsafe.Pointer(mb))&0x3>>0) != 0), 145) != 0 { // i16x16
PutI16Mode(tls, bw, int32(*(*uint8_t)(unsafe.Pointer(preds))))
} else {
var preds_w int32 = (*VP8Encoder)(unsafe.Pointer(enc)).preds_w_
- var top_pred uintptr = (preds - uintptr(preds_w))
+ var top_pred uintptr = preds - uintptr(preds_w)
var x int32
var y int32
for y = 0; y < 4; y++ {
var left int32 = int32(*(*uint8_t)(unsafe.Pointer(preds + libc.UintptrFromInt32(-1))))
for x = 0; x < 4; x++ {
- var probas uintptr = ((uintptr(unsafe.Pointer(&kBModesProba1)) + uintptr(*(*uint8_t)(unsafe.Pointer(top_pred + uintptr(x))))*90) + uintptr(left)*9)
+ var probas uintptr = uintptr(unsafe.Pointer(&kBModesProba1)) + uintptr(*(*uint8_t)(unsafe.Pointer(top_pred + uintptr(x))))*90 + uintptr(left)*9
left = PutI4Mode(tls, bw, int32(*(*uint8_t)(unsafe.Pointer(preds + uintptr(x)))), probas)
}
top_pred = preds
preds += uintptr(preds_w)
}
}
- PutUVMode(tls, bw, (int32(*(*uint8)(unsafe.Pointer(mb /* &.uv_mode_ */)) & 0xc >> 2)))
+ PutUVMode(tls, bw, int32(*(*uint8)(unsafe.Pointer(mb))&0xc>>2))
}
}
//------------------------------------------------------------------------------
// Paragraph 13
-var VP8CoeffsUpdateProba = [4][8][3][11]uint8_t{[8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+var VP8CoeffsUpdateProba = [4][8][3][11]uint8_t{{
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(176), uint8_t(246), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(223), uint8_t(241), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(249), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(176), uint8_t(246), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(223), uint8_t(241), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(249), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(244), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(234), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(244), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(234), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(246), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(239), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(246), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(239), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(248), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(251), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(248), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(251), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(251), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(251), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(250), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(250), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(217), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(225), uint8_t(252), uint8_t(241), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(234), uint8_t(250), uint8_t(241), uint8_t(250), uint8_t(253), uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {
+ {{uint8_t(217), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(225), uint8_t(252), uint8_t(241), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(234), uint8_t(250), uint8_t(241), uint8_t(250), uint8_t(253), uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(223), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(238), uint8_t(253), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(223), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(238), uint8_t(253), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(248), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(249), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(248), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(249), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(247), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(247), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(186), uint8_t(251), uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(234), uint8_t(251), uint8_t(244), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(251), uint8_t(251), uint8_t(243), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {
+ {{uint8_t(186), uint8_t(251), uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(234), uint8_t(251), uint8_t(244), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(251), uint8_t(251), uint8_t(243), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(236), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(251), uint8_t(253), uint8_t(253), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(236), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(251), uint8_t(253), uint8_t(253), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
},
- [8][3][11]uint8_t{
- [3][11]uint8_t{[11]uint8_t{uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(250), uint8_t(254), uint8_t(252), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(248), uint8_t(254), uint8_t(249), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {
+ {{uint8_t(248), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(250), uint8_t(254), uint8_t(252), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(248), uint8_t(254), uint8_t(249), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(246), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(252), uint8_t(254), uint8_t(251), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(246), uint8_t(253), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(252), uint8_t(254), uint8_t(251), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(248), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(253), uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(254), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(248), uint8_t(254), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(253), uint8_t(255), uint8_t(254), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(251), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(245), uint8_t(251), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(253), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(251), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(245), uint8_t(251), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(253), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(251), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(252), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(251), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(252), uint8_t(253), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(249), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(252), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(249), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(253), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(250), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
- [3][11]uint8_t{[11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
- [11]uint8_t{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {{uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(254), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
+ {uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255), uint8_t(255)},
},
},
} /* tree_enc.c:350:5 */
@@ -35266,9 +34968,9 @@ func VP8WriteProbas(tls *libc.TLS, bw uintptr, probas uintptr) { /* tree_enc.c:4
for b = 0; b < NUM_BANDS; b++ {
for c = 0; c < NUM_CTX; c++ {
for p = 0; p < NUM_PROBAS; p++ {
- var p0 uint8_t = *(*uint8_t)(unsafe.Pointer(((((probas + 4 /* &.coeffs_ */) + uintptr(t)*264) + uintptr(b)*33) + uintptr(c)*11) + uintptr(p)))
- var update int32 = (libc.Bool32(int32(p0) != int32(*(*uint8_t)(unsafe.Pointer((((uintptr(unsafe.Pointer(&VP8CoeffsProba0)) + uintptr(t)*264) + uintptr(b)*33) + uintptr(c)*11) + uintptr(p))))))
- if VP8PutBit(tls, bw, update, int32(*(*uint8_t)(unsafe.Pointer((((uintptr(unsafe.Pointer(&VP8CoeffsUpdateProba)) + uintptr(t)*264) + uintptr(b)*33) + uintptr(c)*11) + uintptr(p))))) != 0 {
+ var p0 uint8_t = *(*uint8_t)(unsafe.Pointer(probas + 4 + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p)))
+ var update int32 = libc.Bool32(int32(p0) != int32(*(*uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8CoeffsProba0)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p)))))
+ if VP8PutBit(tls, bw, update, int32(*(*uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8CoeffsUpdateProba)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))))) != 0 {
VP8PutBits(tls, bw, uint32(p0), 8)
}
}
@@ -35395,7 +35097,7 @@ func PaletteComponentDistance(tls *libc.TLS, v uint32_t) uint32_t { /* vp8l_enc.
if v <= uint32_t(128) {
return v
}
- return (uint32_t(256) - v)
+ return uint32_t(256) - v
}
// Computes a value that is related to the entropy created by the
@@ -35407,11 +35109,11 @@ func PaletteColorDistance(tls *libc.TLS, col1 uint32_t, col2 uint32_t) uint32_t
var diff uint32_t = VP8LSubPixels(tls, col1, col2)
var kMoreWeightForRGBThanForAlpha int32 = 9
var score uint32_t
- score = PaletteComponentDistance(tls, ((diff >> 0) & uint32_t(0xff)))
- score = score + (PaletteComponentDistance(tls, ((diff >> 8) & uint32_t(0xff))))
- score = score + (PaletteComponentDistance(tls, ((diff >> 16) & uint32_t(0xff))))
- score = score * (uint32_t(kMoreWeightForRGBThanForAlpha))
- score = score + (PaletteComponentDistance(tls, ((diff >> 24) & uint32_t(0xff))))
+ score = PaletteComponentDistance(tls, diff>>0&uint32_t(0xff))
+ score = score + PaletteComponentDistance(tls, diff>>8&uint32_t(0xff))
+ score = score + PaletteComponentDistance(tls, diff>>16&uint32_t(0xff))
+ score = score * uint32_t(kMoreWeightForRGBThanForAlpha)
+ score = score + PaletteComponentDistance(tls, diff>>24&uint32_t(0xff))
return score
}
@@ -35428,7 +35130,7 @@ func SearchColorNoIdx(tls *libc.TLS, sorted uintptr, color uint32_t, num_colors
return low
} // loop invariant: sorted[low] != color
for 1 != 0 {
- var mid int32 = ((low + hi) >> 1)
+ var mid int32 = (low + hi) >> 1
if *(*uint32_t)(unsafe.Pointer(sorted + uintptr(mid)*4)) == color {
return mid
} else if *(*uint32_t)(unsafe.Pointer(sorted + uintptr(mid)*4)) < color {
@@ -35453,43 +35155,43 @@ func PaletteHasNonMonotonousDeltas(tls *libc.TLS, palette uintptr, num_colors in
var sign_found uint8_t = uint8_t(0x00)
for i = 0; i < num_colors; i++ {
var diff uint32_t = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(palette + uintptr(i)*4)), predict)
- var rd uint8_t = (uint8_t((diff >> 16) & uint32_t(0xff)))
- var gd uint8_t = (uint8_t((diff >> 8) & uint32_t(0xff)))
- var bd uint8_t = (uint8_t((diff >> 0) & uint32_t(0xff)))
+ var rd uint8_t = uint8_t(diff >> 16 & uint32_t(0xff))
+ var gd uint8_t = uint8_t(diff >> 8 & uint32_t(0xff))
+ var bd uint8_t = uint8_t(diff >> 0 & uint32_t(0xff))
if int32(rd) != 0x00 {
- sign_found = uint8_t(int32(sign_found) | (func() int32 {
+ sign_found = uint8_t(int32(sign_found) | func() int32 {
if int32(rd) < 0x80 {
return 1
}
return 2
- }()))
+ }())
}
if int32(gd) != 0x00 {
- sign_found = uint8_t(int32(sign_found) | (func() int32 {
+ sign_found = uint8_t(int32(sign_found) | func() int32 {
if int32(gd) < 0x80 {
return 8
}
return 16
- }()))
+ }())
}
if int32(bd) != 0x00 {
- sign_found = uint8_t(int32(sign_found) | (func() int32 {
+ sign_found = uint8_t(int32(sign_found) | func() int32 {
if int32(bd) < 0x80 {
return 64
}
return 128
- }()))
+ }())
}
predict = *(*uint32_t)(unsafe.Pointer(palette + uintptr(i)*4))
}
- return (libc.Bool32((int32(sign_found) & (int32(sign_found) << 1)) != 0)) // two consequent signs.
+ return libc.Bool32(int32(sign_found)&(int32(sign_found)<<1) != 0) // two consequent signs.
}
func PaletteSortMinimizeDeltas(tls *libc.TLS, palette_sorted uintptr, num_colors int32, palette uintptr) { /* vp8l_enc.c:116:13: */
var predict uint32_t = uint32_t(0x00000000)
var i int32
var k int32
- libc.Xmemcpy(tls, palette, palette_sorted, (uint64(num_colors) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, palette, palette_sorted, uint64(num_colors)*uint64(unsafe.Sizeof(uint32_t(0))))
if !(PaletteHasNonMonotonousDeltas(tls, palette_sorted, num_colors) != 0) {
return
}
@@ -35506,7 +35208,7 @@ func PaletteSortMinimizeDeltas(tls *libc.TLS, palette_sorted uintptr, num_colors
best_ix = k
}
}
- SwapColor(tls, (palette + uintptr(best_ix)*4), (palette + uintptr(i)*4))
+ SwapColor(tls, palette+uintptr(best_ix)*4, palette+uintptr(i)*4)
predict = *(*uint32_t)(unsafe.Pointer(palette + uintptr(i)*4))
}
}
@@ -35514,7 +35216,7 @@ func PaletteSortMinimizeDeltas(tls *libc.TLS, palette_sorted uintptr, num_colors
// Sort palette in increasing order and prepare an inverse mapping array.
func PrepareMapToPalette(tls *libc.TLS, palette uintptr, num_colors uint32_t, sorted uintptr, idx_map uintptr) { /* vp8l_enc.c:141:13: */
var i uint32_t
- libc.Xmemcpy(tls, sorted, palette, (uint64(num_colors) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, sorted, palette, uint64(num_colors)*uint64(unsafe.Sizeof(uint32_t(0))))
libc.Xqsort(tls, sorted, uint64(num_colors), uint64(unsafe.Sizeof(uint32_t(0))), *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) int32
}{PaletteCompareColorsForQsort})))
@@ -35540,7 +35242,7 @@ func CoOccurrenceFindMax(tls *libc.TLS, cooccurrence uintptr, num_colors uint32_
for i = uint32_t(0); i < num_colors; i++ {
var sum uint32_t = uint32_t(0)
for j = uint32_t(0); j < num_colors; j++ {
- sum = sum + (*(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(((i*num_colors)+j))*4)))
+ sum = sum + *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(i*num_colors+j)*4))
}
if sum > best_sum {
best_sum = sum
@@ -35551,8 +35253,8 @@ func CoOccurrenceFindMax(tls *libc.TLS, cooccurrence uintptr, num_colors uint32_
*(*uint8_t)(unsafe.Pointer(c2)) = uint8(0)
best_cooccurrence = 0
for i = uint32_t(0); i < num_colors; i++ {
- if *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(((uint32_t(*(*uint8_t)(unsafe.Pointer(c1)))*num_colors)+i))*4)) > best_cooccurrence {
- best_cooccurrence = *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(((uint32_t(*(*uint8_t)(unsafe.Pointer(c1)))*num_colors)+i))*4))
+ if *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(uint32_t(*(*uint8_t)(unsafe.Pointer(c1)))*num_colors+i)*4)) > best_cooccurrence {
+ best_cooccurrence = *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(uint32_t(*(*uint8_t)(unsafe.Pointer(c1)))*num_colors+i)*4))
*(*uint8_t)(unsafe.Pointer(c2)) = uint8_t(i)
}
}
@@ -35576,38 +35278,38 @@ func CoOccurrenceBuild(tls *libc.TLS, pic uintptr, palette uintptr, num_colors u
*(*[256]uint32_t)(unsafe.Pointer(bp + 1024 /* idx_map */)) = [256]uint32_t{0: uint32_t(0)}
// var palette_sorted [256]uint32_t at bp, 1024
- lines = WebPSafeMalloc(tls, (uint64(2 * (*WebPPicture)(unsafe.Pointer(pic)).width)), uint64(unsafe.Sizeof(uint32_t(0))))
- if lines == (uintptr(0)) {
+ lines = WebPSafeMalloc(tls, uint64(2*(*WebPPicture)(unsafe.Pointer(pic)).width), uint64(unsafe.Sizeof(uint32_t(0))))
+ if lines == uintptr(0) {
return VP8_ENC_ERROR_OUT_OF_MEMORY
}
- line_top = (lines)
- line_current = (lines + uintptr((*WebPPicture)(unsafe.Pointer(pic)).width)*4)
- PrepareMapToPalette(tls, palette, num_colors, (bp) /* &palette_sorted[0] */, (bp + 1024) /* &idx_map[0] */)
+ line_top = lines
+ line_current = lines + uintptr((*WebPPicture)(unsafe.Pointer(pic)).width)*4
+ PrepareMapToPalette(tls, palette, num_colors, bp, bp+1024)
for y = 0; y < (*WebPPicture)(unsafe.Pointer(pic)).height; y++ {
for x = 0; x < (*WebPPicture)(unsafe.Pointer(pic)).width; x++ {
var pix uint32_t = *(*uint32_t)(unsafe.Pointer(src + uintptr(x)*4))
if pix != prev_pix {
- prev_idx = *(*uint32_t)(unsafe.Pointer((bp + 1024) /* &idx_map[0] */ + uintptr(SearchColorNoIdx(tls, (bp) /* &palette_sorted[0] */, pix, int32(num_colors)))*4))
+ prev_idx = *(*uint32_t)(unsafe.Pointer(bp + 1024 + uintptr(SearchColorNoIdx(tls, bp, pix, int32(num_colors)))*4))
prev_pix = pix
}
*(*uint32_t)(unsafe.Pointer(line_current + uintptr(x)*4)) = prev_idx
// 4-connectivity is what works best as mentioned in "On the relation
// between Memon's and the modified Zeng's palette reordering methods".
- if (x > 0) && (prev_idx != *(*uint32_t)(unsafe.Pointer(line_current + uintptr((x-1))*4))) {
- var left_idx uint32_t = *(*uint32_t)(unsafe.Pointer(line_current + uintptr((x-1))*4))
- *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(((prev_idx*num_colors)+left_idx))*4))++
- *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(((left_idx*num_colors)+prev_idx))*4))++
+ if x > 0 && prev_idx != *(*uint32_t)(unsafe.Pointer(line_current + uintptr(x-1)*4)) {
+ var left_idx uint32_t = *(*uint32_t)(unsafe.Pointer(line_current + uintptr(x-1)*4))
+ *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(prev_idx*num_colors+left_idx)*4))++
+ *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(left_idx*num_colors+prev_idx)*4))++
}
- if (y > 0) && (prev_idx != *(*uint32_t)(unsafe.Pointer(line_top + uintptr(x)*4))) {
+ if y > 0 && prev_idx != *(*uint32_t)(unsafe.Pointer(line_top + uintptr(x)*4)) {
var top_idx uint32_t = *(*uint32_t)(unsafe.Pointer(line_top + uintptr(x)*4))
- *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(((prev_idx*num_colors)+top_idx))*4))++
- *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(((top_idx*num_colors)+prev_idx))*4))++
+ *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(prev_idx*num_colors+top_idx)*4))++
+ *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(top_idx*num_colors+prev_idx)*4))++
}
}
line_tmp = line_top
line_top = line_current
line_current = line_tmp
- src += 4 * (uintptr((*WebPPicture)(unsafe.Pointer(pic)).argb_stride))
+ src += 4 * uintptr((*WebPPicture)(unsafe.Pointer(pic)).argb_stride)
}
WebPSafeFree(tls, lines)
return VP8_ENC_OK
@@ -35642,8 +35344,8 @@ func PaletteSortModifiedZeng(tls *libc.TLS, pic uintptr, palette_sorted uintptr,
return VP8_ENC_OK
}
// Build the co-occurrence matrix.
- cooccurrence = WebPSafeCalloc(tls, (uint64(num_colors * num_colors)), uint64(unsafe.Sizeof(uint32_t(0))))
- if cooccurrence == (uintptr(0)) {
+ cooccurrence = WebPSafeCalloc(tls, uint64(num_colors*num_colors), uint64(unsafe.Sizeof(uint32_t(0))))
+ if cooccurrence == uintptr(0) {
return VP8_ENC_ERROR_OUT_OF_MEMORY
}
if CoOccurrenceBuild(tls, pic, palette_sorted, num_colors, cooccurrence) != VP8_ENC_OK {
@@ -35652,29 +35354,29 @@ func PaletteSortModifiedZeng(tls *libc.TLS, pic uintptr, palette_sorted uintptr,
}
// Initialize the mapping list with the two best indices.
- CoOccurrenceFindMax(tls, cooccurrence, num_colors, (bp) /* &remapping */, ((bp) /* &remapping */ + 1))
+ CoOccurrenceFindMax(tls, cooccurrence, num_colors, bp, bp+1)
// We need to append and prepend to the list of remapping. To this end, we
// actually define the next start/end of the list as indices in a vector (with
// a wrap around when the end is reached).
first = uint32_t(0)
last = uint32_t(1)
- num_sums = (num_colors - uint32_t(2)) // -2 because we know the first two values
+ num_sums = num_colors - uint32_t(2) // -2 because we know the first two values
if num_sums > uint32_t(0) {
// Initialize the sums with the first two remappings and find the best one
- var best_sum uintptr = (bp + 256) /* &sums */
+ var best_sum uintptr = bp + 256
(*Sum)(unsafe.Pointer(best_sum)).index = uint8(0)
(*Sum)(unsafe.Pointer(best_sum)).sum = 0
i = uint32_t(0)
j = uint32_t(0)
for ; i < num_colors; i++ {
- if (i == uint32_t(*(*uint8_t)(unsafe.Pointer((bp) /* &remapping[0] */)))) || (i == uint32_t(*(*uint8_t)(unsafe.Pointer((bp) /* &remapping[0] */ + 1)))) {
+ if i == uint32_t(*(*uint8_t)(unsafe.Pointer(bp))) || i == uint32_t(*(*uint8_t)(unsafe.Pointer(bp + 1))) {
continue
}
- (*Sum)(unsafe.Pointer((bp + 256) /* &sums */ + uintptr(j)*8)).index = uint8_t(i)
- (*Sum)(unsafe.Pointer((bp + 256) /* &sums */ + uintptr(j)*8)).sum = (*(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(((i*num_colors)+uint32_t(*(*uint8_t)(unsafe.Pointer((bp) /* &remapping[0] */)))))*4)) + *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(((i*num_colors)+uint32_t(*(*uint8_t)(unsafe.Pointer((bp) /* &remapping[0] */ + 1)))))*4)))
- if (*Sum)(unsafe.Pointer((bp+256) /* &sums */ +uintptr(j)*8)).sum > (*Sum)(unsafe.Pointer(best_sum)).sum {
- best_sum = ((bp + 256) /* &sums */ + uintptr(j)*8)
+ (*Sum)(unsafe.Pointer(bp + 256 + uintptr(j)*8)).index = uint8_t(i)
+ (*Sum)(unsafe.Pointer(bp + 256 + uintptr(j)*8)).sum = *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(i*num_colors+uint32_t(*(*uint8_t)(unsafe.Pointer(bp))))*4)) + *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(i*num_colors+uint32_t(*(*uint8_t)(unsafe.Pointer(bp + 1))))*4))
+ if (*Sum)(unsafe.Pointer(bp+256+uintptr(j)*8)).sum > (*Sum)(unsafe.Pointer(best_sum)).sum {
+ best_sum = bp + 256 + uintptr(j)*8
}
j++
}
@@ -35683,33 +35385,33 @@ func PaletteSortModifiedZeng(tls *libc.TLS, pic uintptr, palette_sorted uintptr,
var best_index uint8_t = (*Sum)(unsafe.Pointer(best_sum)).index
// Compute delta to know if we need to prepend or append the best index.
var delta int32_t = 0
- var n int32_t = (int32_t(num_colors - num_sums))
+ var n int32_t = int32_t(num_colors - num_sums)
ind = first
j = uint32_t(0)
- for ; ((ind + j) % num_colors) != (last + uint32_t(1)); j++ {
- var l_j uint16_t = uint16_t(*(*uint8_t)(unsafe.Pointer((bp) /* &remapping[0] */ + uintptr(((ind + j) % num_colors)))))
- delta = delta + (((n - 1) - (2 * int32_t(j))) * int32_t(*(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(((uint32_t(best_index)*num_colors)+uint32_t(l_j)))*4))))
+ for ; (ind+j)%num_colors != last+uint32_t(1); j++ {
+ var l_j uint16_t = uint16_t(*(*uint8_t)(unsafe.Pointer(bp + uintptr((ind+j)%num_colors))))
+ delta = delta + (n-1-2*int32_t(j))*int32_t(*(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(uint32_t(best_index)*num_colors+uint32_t(l_j))*4)))
}
if delta > 0 {
if first == uint32_t(0) {
- first = (num_colors - uint32_t(1))
+ first = num_colors - uint32_t(1)
} else {
- first = (first - uint32_t(1))
+ first = first - uint32_t(1)
}
- *(*uint8_t)(unsafe.Pointer((bp) /* &remapping[0] */ + uintptr(first))) = best_index
+ *(*uint8_t)(unsafe.Pointer(bp + uintptr(first))) = best_index
} else {
last++
- *(*uint8_t)(unsafe.Pointer((bp) /* &remapping[0] */ + uintptr(last))) = best_index
+ *(*uint8_t)(unsafe.Pointer(bp + uintptr(last))) = best_index
}
// Remove best_sum from sums.
- *(*Sum)(unsafe.Pointer(best_sum)) = *(*Sum)(unsafe.Pointer((bp + 256) /* &sums[0] */ + uintptr((num_sums-uint32_t(1)))*8))
+ *(*Sum)(unsafe.Pointer(best_sum)) = *(*Sum)(unsafe.Pointer(bp + 256 + uintptr(num_sums-uint32_t(1))*8))
num_sums--
// Update all the sums and find the best one.
- best_sum = (bp + 256) /* &sums */
+ best_sum = bp + 256
for i = uint32_t(0); i < num_sums; i++ {
- *(*uint32_t)(unsafe.Pointer((((bp + 256) /* &sums */ + uintptr(i)*8) + 4 /* &.sum */))) += (*(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(((uint32_t(best_index)*num_colors)+uint32_t((*Sum)(unsafe.Pointer((bp+256) /* &sums */ +uintptr(i)*8)).index)))*4)))
- if (*Sum)(unsafe.Pointer((bp+256) /* &sums */ +uintptr(i)*8)).sum > (*Sum)(unsafe.Pointer(best_sum)).sum {
- best_sum = ((bp + 256) /* &sums */ + uintptr(i)*8)
+ *(*uint32_t)(unsafe.Pointer(bp + 256 + uintptr(i)*8 + 4)) += *(*uint32_t)(unsafe.Pointer(cooccurrence + uintptr(uint32_t(best_index)*num_colors+uint32_t((*Sum)(unsafe.Pointer(bp+256+uintptr(i)*8)).index))*4))
+ if (*Sum)(unsafe.Pointer(bp+256+uintptr(i)*8)).sum > (*Sum)(unsafe.Pointer(best_sum)).sum {
+ best_sum = bp + 256 + uintptr(i)*8
}
}
}
@@ -35719,7 +35421,7 @@ func PaletteSortModifiedZeng(tls *libc.TLS, pic uintptr, palette_sorted uintptr,
// Re-map the palette.
for i = uint32_t(0); i < num_colors; i++ {
- *(*uint32_t)(unsafe.Pointer(palette + uintptr(i)*4)) = *(*uint32_t)(unsafe.Pointer(palette_sorted + uintptr(*(*uint8_t)(unsafe.Pointer((bp) /* &remapping[0] */ + uintptr(((first + i) % num_colors)))))*4))
+ *(*uint32_t)(unsafe.Pointer(palette + uintptr(i)*4)) = *(*uint32_t)(unsafe.Pointer(palette_sorted + uintptr(*(*uint8_t)(unsafe.Pointer(bp + uintptr((first+i)%num_colors))))*4))
}
return VP8_ENC_OK
}
@@ -35735,22 +35437,22 @@ type PaletteSorting = uint32 /* vp8l_enc.c:341:3 */
type HistoIx = uint32 /* vp8l_enc.c:358:3 */
func AddSingleSubGreen(tls *libc.TLS, p int32, r uintptr, b uintptr) { /* vp8l_enc.c:360:13: */
- var green int32 = (p >> 8) // The upper bits are masked away later.
- *(*uint32_t)(unsafe.Pointer(r + uintptr((((p>>16)-green)&0xff))*4))++
- *(*uint32_t)(unsafe.Pointer(b + uintptr((((p>>0)-green)&0xff))*4))++
+ var green int32 = p >> 8 // The upper bits are masked away later.
+ *(*uint32_t)(unsafe.Pointer(r + uintptr((p>>16-green)&0xff)*4))++
+ *(*uint32_t)(unsafe.Pointer(b + uintptr((p>>0-green)&0xff)*4))++
}
func AddSingle(tls *libc.TLS, p uint32_t, a uintptr, r uintptr, g uintptr, b uintptr) { /* vp8l_enc.c:366:13: */
- *(*uint32_t)(unsafe.Pointer(a + uintptr(((p>>24)&uint32_t(0xff)))*4))++
- *(*uint32_t)(unsafe.Pointer(r + uintptr(((p>>16)&uint32_t(0xff)))*4))++
- *(*uint32_t)(unsafe.Pointer(g + uintptr(((p>>8)&uint32_t(0xff)))*4))++
- *(*uint32_t)(unsafe.Pointer(b + uintptr(((p>>0)&uint32_t(0xff)))*4))++
+ *(*uint32_t)(unsafe.Pointer(a + uintptr(p>>24&uint32_t(0xff))*4))++
+ *(*uint32_t)(unsafe.Pointer(r + uintptr(p>>16&uint32_t(0xff))*4))++
+ *(*uint32_t)(unsafe.Pointer(g + uintptr(p>>8&uint32_t(0xff))*4))++
+ *(*uint32_t)(unsafe.Pointer(b + uintptr(p>>0&uint32_t(0xff))*4))++
}
func HashPix(tls *libc.TLS, pix uint32_t) uint32_t { /* vp8l_enc.c:375:29: */
// Note that masking with 0xffffffffu is for preventing an
// 'unsigned int overflow' warning. Doesn't impact the compiled code.
- return (uint32_t((((uint64(uint64_t(pix) + (uint64_t(pix >> 19)))) * 0x39c5fba7) & uint64(0xffffffff)) >> 24))
+ return uint32_t(uint64(uint64_t(pix)+uint64_t(pix>>19)) * 0x39c5fba7 & uint64(0xffffffff) >> 24)
}
func AnalyzeEntropy(tls *libc.TLS, argb uintptr, width int32, height int32, argb_stride int32, use_palette int32, palette_size int32, transform_bits int32, min_entropy_ix uintptr, red_and_blue_always_zero uintptr) int32 { /* vp8l_enc.c:381:12: */
@@ -35760,19 +35462,19 @@ func AnalyzeEntropy(tls *libc.TLS, argb uintptr, width int32, height int32, argb
// Allocate histogram set with cache_bits = 0.
var histo uintptr
- if (use_palette != 0) && (palette_size <= 16) {
+ if use_palette != 0 && palette_size <= 16 {
// In the case of small palettes, we pack 2, 4 or 8 pixels together. In
// practice, small palettes are better than any other transform.
*(*EntropyIx)(unsafe.Pointer(min_entropy_ix)) = kPalette
*(*int32)(unsafe.Pointer(red_and_blue_always_zero)) = 1
return 1
}
- histo = WebPSafeCalloc(tls, kHistoTotal, (uint64(unsafe.Sizeof(uint32_t(0))) * uint64(256)))
- if histo != (uintptr(0)) {
+ histo = WebPSafeCalloc(tls, kHistoTotal, uint64(unsafe.Sizeof(uint32_t(0)))*uint64(256))
+ if histo != uintptr(0) {
var i int32
var x int32
var y int32
- var prev_row uintptr = (uintptr(0))
+ var prev_row uintptr = uintptr(0)
var curr_row uintptr = argb
var pix_prev uint32_t = *(*uint32_t)(unsafe.Pointer(argb)) // Skip the first pixel.
for y = 0; y < height; y++ {
@@ -35780,34 +35482,34 @@ func AnalyzeEntropy(tls *libc.TLS, argb uintptr, width int32, height int32, argb
var pix uint32_t = *(*uint32_t)(unsafe.Pointer(curr_row + uintptr(x)*4))
var pix_diff uint32_t = VP8LSubPixels(tls, pix, pix_prev)
pix_prev = pix
- if (pix_diff == uint32_t(0)) || ((prev_row != (uintptr(0))) && (pix == *(*uint32_t)(unsafe.Pointer(prev_row + uintptr(x)*4)))) {
+ if pix_diff == uint32_t(0) || prev_row != uintptr(0) && pix == *(*uint32_t)(unsafe.Pointer(prev_row + uintptr(x)*4)) {
continue
}
AddSingle(tls, pix,
- (histo),
- (histo + 1024*4),
- (histo + 512*4),
- (histo + 1536*4))
+ histo,
+ histo+1024*4,
+ histo+512*4,
+ histo+1536*4)
AddSingle(tls, pix_diff,
- (histo + 256*4),
- (histo + 1280*4),
- (histo + 768*4),
- (histo + 1792*4))
+ histo+256*4,
+ histo+1280*4,
+ histo+768*4,
+ histo+1792*4)
AddSingleSubGreen(tls, int32(pix),
- (histo + 2048*4),
- (histo + 2560*4))
+ histo+2048*4,
+ histo+2560*4)
AddSingleSubGreen(tls, int32(pix_diff),
- (histo + 2304*4),
- (histo + 2816*4))
+ histo+2304*4,
+ histo+2816*4)
{
// Approximate the palette by the entropy of the multiplicative hash.
var hash uint32_t = HashPix(tls, pix)
- *(*uint32_t)(unsafe.Pointer(histo + uintptr(((uint32_t(kHistoPalette*256))+hash))*4))++
+ *(*uint32_t)(unsafe.Pointer(histo + uintptr(uint32_t(kHistoPalette*256)+hash)*4))++
}
}
prev_row = curr_row
- curr_row += 4 * (uintptr(argb_stride))
+ curr_row += 4 * uintptr(argb_stride)
}
{
// var entropy_comp [13]float64 at bp, 104
@@ -35833,30 +35535,30 @@ func AnalyzeEntropy(tls *libc.TLS, argb uintptr, width int32, height int32, argb
*(*uint32_t)(unsafe.Pointer(histo + 256*4))++
for j = 0; j < kHistoTotal; j++ {
- *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + uintptr(j)*8)) = VP8LBitsEntropy(tls, (histo + uintptr((j*256))*4), 256)
+ *(*float64)(unsafe.Pointer(bp + uintptr(j)*8)) = VP8LBitsEntropy(tls, histo+uintptr(j*256)*4, 256)
}
- *(*float64)(unsafe.Pointer((bp + 104) /* &entropy[0] */)) = (((*(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */)) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 4*8))) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 2*8))) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 6*8)))
- *(*float64)(unsafe.Pointer((bp + 104) /* &entropy[0] */ + 1*8)) = (((*(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 1*8)) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 5*8))) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 3*8))) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 7*8)))
- *(*float64)(unsafe.Pointer((bp + 104) /* &entropy[0] */ + 2*8)) = (((*(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */)) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 8*8))) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 2*8))) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 10*8)))
- *(*float64)(unsafe.Pointer((bp + 104) /* &entropy[0] */ + 3*8)) = (((*(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 1*8)) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 9*8))) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 3*8))) + *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 11*8)))
- *(*float64)(unsafe.Pointer((bp + 104) /* &entropy[0] */ + 4*8)) = *(*float64)(unsafe.Pointer((bp) /* &entropy_comp[0] */ + 12*8))
+ *(*float64)(unsafe.Pointer(bp + 104)) = *(*float64)(unsafe.Pointer(bp)) + *(*float64)(unsafe.Pointer(bp + 4*8)) + *(*float64)(unsafe.Pointer(bp + 2*8)) + *(*float64)(unsafe.Pointer(bp + 6*8))
+ *(*float64)(unsafe.Pointer(bp + 104 + 1*8)) = *(*float64)(unsafe.Pointer(bp + 1*8)) + *(*float64)(unsafe.Pointer(bp + 5*8)) + *(*float64)(unsafe.Pointer(bp + 3*8)) + *(*float64)(unsafe.Pointer(bp + 7*8))
+ *(*float64)(unsafe.Pointer(bp + 104 + 2*8)) = *(*float64)(unsafe.Pointer(bp)) + *(*float64)(unsafe.Pointer(bp + 8*8)) + *(*float64)(unsafe.Pointer(bp + 2*8)) + *(*float64)(unsafe.Pointer(bp + 10*8))
+ *(*float64)(unsafe.Pointer(bp + 104 + 3*8)) = *(*float64)(unsafe.Pointer(bp + 1*8)) + *(*float64)(unsafe.Pointer(bp + 9*8)) + *(*float64)(unsafe.Pointer(bp + 3*8)) + *(*float64)(unsafe.Pointer(bp + 11*8))
+ *(*float64)(unsafe.Pointer(bp + 104 + 4*8)) = *(*float64)(unsafe.Pointer(bp + 12*8))
// When including transforms, there is an overhead in bits from
// storing them. This overhead is small but matters for small images.
// For spatial, there are 14 transformations.
- *(*float64)(unsafe.Pointer(((bp + 104) /* &entropy */ + 1*8))) += (float64((float32(VP8LSubSampleSize(tls, uint32(width), uint32(transform_bits)) * VP8LSubSampleSize(tls, uint32(height), uint32(transform_bits)))) * VP8LFastLog2(tls, uint32(14))))
+ *(*float64)(unsafe.Pointer(bp + 104 + 1*8)) += float64(float32(VP8LSubSampleSize(tls, uint32(width), uint32(transform_bits))*VP8LSubSampleSize(tls, uint32(height), uint32(transform_bits))) * VP8LFastLog2(tls, uint32(14)))
// For color transforms: 24 as only 3 channels are considered in a
// ColorTransformElement.
- *(*float64)(unsafe.Pointer(((bp + 104) /* &entropy */ + 3*8))) += (float64((float32(VP8LSubSampleSize(tls, uint32(width), uint32(transform_bits)) * VP8LSubSampleSize(tls, uint32(height), uint32(transform_bits)))) * VP8LFastLog2(tls, uint32(24))))
+ *(*float64)(unsafe.Pointer(bp + 104 + 3*8)) += float64(float32(VP8LSubSampleSize(tls, uint32(width), uint32(transform_bits))*VP8LSubSampleSize(tls, uint32(height), uint32(transform_bits))) * VP8LFastLog2(tls, uint32(24)))
// For palettes, add the cost of storing the palette.
// We empirically estimate the cost of a compressed entry as 8 bits.
// The palette is differential-coded when compressed hence a much
// lower cost than sizeof(uint32_t)*8.
- *(*float64)(unsafe.Pointer(((bp + 104) /* &entropy */ + 4*8))) += (float64(palette_size * 8))
+ *(*float64)(unsafe.Pointer(bp + 104 + 4*8)) += float64(palette_size * 8)
*(*EntropyIx)(unsafe.Pointer(min_entropy_ix)) = kDirect
- for k = (kDirect + 1); k <= last_mode_to_analyze; k++ {
- if *(*float64)(unsafe.Pointer((bp + 104) /* &entropy[0] */ + uintptr(*(*EntropyIx)(unsafe.Pointer(min_entropy_ix)))*8)) > *(*float64)(unsafe.Pointer((bp + 104) /* &entropy[0] */ + uintptr(k)*8)) {
+ for k = kDirect + 1; k <= last_mode_to_analyze; k++ {
+ if *(*float64)(unsafe.Pointer(bp + 104 + uintptr(*(*EntropyIx)(unsafe.Pointer(min_entropy_ix)))*8)) > *(*float64)(unsafe.Pointer(bp + 104 + uintptr(k)*8)) {
*(*EntropyIx)(unsafe.Pointer(min_entropy_ix)) = EntropyIx(k)
}
}
@@ -35866,10 +35568,10 @@ func AnalyzeEntropy(tls *libc.TLS, argb uintptr, width int32, height int32, argb
// non-zero red and blue values. If all are zero, we can later skip
// the cross color optimization.
{
- var red_histo uintptr = (histo + uintptr((256*int32(*(*uint8_t)(unsafe.Pointer((uintptr(unsafe.Pointer(&kHistoPairs)) + uintptr(*(*EntropyIx)(unsafe.Pointer(min_entropy_ix)))*2))))))*4)
- var blue_histo uintptr = (histo + uintptr((256*int32(*(*uint8_t)(unsafe.Pointer((uintptr(unsafe.Pointer(&kHistoPairs)) + uintptr(*(*EntropyIx)(unsafe.Pointer(min_entropy_ix)))*2) + 1)))))*4)
+ var red_histo uintptr = histo + uintptr(256*int32(*(*uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&kHistoPairs)) + uintptr(*(*EntropyIx)(unsafe.Pointer(min_entropy_ix)))*2))))*4
+ var blue_histo uintptr = histo + uintptr(256*int32(*(*uint8_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&kHistoPairs)) + uintptr(*(*EntropyIx)(unsafe.Pointer(min_entropy_ix)))*2 + 1))))*4
for i = 1; i < 256; i++ {
- if (*(*uint32_t)(unsafe.Pointer(red_histo + uintptr(i)*4)) | *(*uint32_t)(unsafe.Pointer(blue_histo + uintptr(i)*4))) != uint32_t(0) {
+ if *(*uint32_t)(unsafe.Pointer(red_histo + uintptr(i)*4))|*(*uint32_t)(unsafe.Pointer(blue_histo + uintptr(i)*4)) != uint32_t(0) {
*(*int32)(unsafe.Pointer(red_and_blue_always_zero)) = 0
break
}
@@ -35887,23 +35589,23 @@ func AnalyzeEntropy(tls *libc.TLS, argb uintptr, width int32, height int32, argb
}
var kHistoPairs = [5][2]uint8_t{
- [2]uint8_t{kHistoRed, kHistoBlue},
- [2]uint8_t{kHistoRedPred, kHistoBluePred},
- [2]uint8_t{kHistoRedSubGreen, kHistoBlueSubGreen},
- [2]uint8_t{kHistoRedPredSubGreen, kHistoBluePredSubGreen},
- [2]uint8_t{kHistoRed, kHistoBlue},
+ {kHistoRed, kHistoBlue},
+ {kHistoRedPred, kHistoBluePred},
+ {kHistoRedSubGreen, kHistoBlueSubGreen},
+ {kHistoRedPredSubGreen, kHistoBluePredSubGreen},
+ {kHistoRed, kHistoBlue},
} /* vp8l_enc.c:502:30 */
func GetHistoBits(tls *libc.TLS, method int32, use_palette int32, width int32, height int32) int32 { /* vp8l_enc.c:528:12: */
// Make tile size a function of encoding method (Range: 0 to 6).
- var histo_bits int32 = ((func() int32 {
+ var histo_bits int32 = func() int32 {
if use_palette != 0 {
return 9
}
return 7
- }()) - method)
+ }() - method
for 1 != 0 {
- var huff_image_size int32 = (int32(VP8LSubSampleSize(tls, uint32(width), uint32(histo_bits)) * VP8LSubSampleSize(tls, uint32(height), uint32(histo_bits))))
+ var huff_image_size int32 = int32(VP8LSubSampleSize(tls, uint32(width), uint32(histo_bits)) * VP8LSubSampleSize(tls, uint32(height), uint32(histo_bits)))
if huff_image_size <= 2600 {
break
}
@@ -35963,7 +35665,7 @@ func EncoderAnalyze(tls *libc.TLS, enc uintptr, crunch_configs uintptr, crunch_c
var height int32 = (*WebPPicture)(unsafe.Pointer(pic)).height
var config uintptr = (*VP8LEncoder)(unsafe.Pointer(enc)).config_
var method int32 = (*WebPConfig)(unsafe.Pointer(config)).method
- var low_effort int32 = (libc.Bool32((*WebPConfig)(unsafe.Pointer(config)).method == 0))
+ var low_effort int32 = libc.Bool32((*WebPConfig)(unsafe.Pointer(config)).method == 0)
var i int32
var use_palette int32
var n_lz77s int32
@@ -35972,12 +35674,12 @@ func EncoderAnalyze(tls *libc.TLS, enc uintptr, crunch_configs uintptr, crunch_c
var do_no_cache int32 = 0
// Check whether a palette is possible.
- (*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_ = WebPGetColorPalette(tls, pic, (enc + 1124 /* &.palette_sorted_ */))
- use_palette = (libc.Bool32((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_ <= 256))
+ (*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_ = WebPGetColorPalette(tls, pic, enc+1124)
+ use_palette = libc.Bool32((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_ <= 256)
if !(use_palette != 0) {
(*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_ = 0
} else {
- libc.Xqsort(tls, (enc + 1124 /* &.palette_sorted_ */), uint64((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_),
+ libc.Xqsort(tls, enc+1124, uint64((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_),
uint64(unsafe.Sizeof(uint32_t(0))), *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) int32
}{PaletteCompareColorsForQsort})))
@@ -36008,34 +35710,34 @@ func EncoderAnalyze(tls *libc.TLS, enc uintptr, crunch_configs uintptr, crunch_c
// var min_entropy_ix EntropyIx at bp, 4
// Try out multiple LZ77 on images with few colors.
- if ((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_ > 0) && ((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_ <= 16) {
+ if (*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_ > 0 && (*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_ <= 16 {
n_lz77s = 2
} else {
n_lz77s = 1
}
if !(AnalyzeEntropy(tls, (*WebPPicture)(unsafe.Pointer(pic)).argb, width, height, (*WebPPicture)(unsafe.Pointer(pic)).argb_stride, use_palette,
(*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_, (*VP8LEncoder)(unsafe.Pointer(enc)).transform_bits_,
- (bp) /* &min_entropy_ix */, red_and_blue_always_zero) != 0) {
+ bp, red_and_blue_always_zero) != 0) {
return 0
}
- if (method == 6) && ((*WebPConfig)(unsafe.Pointer(config)).quality == float32(100)) {
+ if method == 6 && (*WebPConfig)(unsafe.Pointer(config)).quality == float32(100) {
do_no_cache = 1
// Go brute force on all transforms.
*(*int32)(unsafe.Pointer(crunch_configs_size)) = 0
for i = 0; i < kNumEntropyIx; i++ {
// We can only apply kPalette or kPaletteAndSpatial if we can indeed use
// a palette.
- if ((i != kPalette) && (i != kPaletteAndSpatial)) || (use_palette != 0) {
+ if i != kPalette && i != kPaletteAndSpatial || use_palette != 0 {
- (*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr((*(*int32)(unsafe.Pointer(crunch_configs_size))))*28)).entropy_idx_ = i
- if (use_palette != 0) && ((i == kPalette) || (i == kPaletteAndSpatial)) {
- (*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr((*(*int32)(unsafe.Pointer(crunch_configs_size))))*28)).palette_sorting_type_ = kMinimizeDelta
+ (*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr(*(*int32)(unsafe.Pointer(crunch_configs_size)))*28)).entropy_idx_ = i
+ if use_palette != 0 && (i == kPalette || i == kPaletteAndSpatial) {
+ (*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr(*(*int32)(unsafe.Pointer(crunch_configs_size)))*28)).palette_sorting_type_ = kMinimizeDelta
*(*int32)(unsafe.Pointer(crunch_configs_size))++
// Also add modified Zeng's method.
- (*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr((*(*int32)(unsafe.Pointer(crunch_configs_size))))*28)).entropy_idx_ = i
- (*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr((*(*int32)(unsafe.Pointer(crunch_configs_size))))*28)).palette_sorting_type_ = kModifiedZeng
+ (*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr(*(*int32)(unsafe.Pointer(crunch_configs_size)))*28)).entropy_idx_ = i
+ (*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr(*(*int32)(unsafe.Pointer(crunch_configs_size)))*28)).palette_sorting_type_ = kModifiedZeng
} else {
- (*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr((*(*int32)(unsafe.Pointer(crunch_configs_size))))*28)).palette_sorting_type_ = kUnusedPalette
+ (*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr(*(*int32)(unsafe.Pointer(crunch_configs_size)))*28)).palette_sorting_type_ = kUnusedPalette
}
*(*int32)(unsafe.Pointer(crunch_configs_size))++
}
@@ -36050,11 +35752,11 @@ func EncoderAnalyze(tls *libc.TLS, enc uintptr, crunch_configs uintptr, crunch_c
}
return kUnusedPalette
}()
- if ((*WebPConfig)(unsafe.Pointer(config)).quality >= float32(75)) && (method == 5) {
+ if (*WebPConfig)(unsafe.Pointer(config)).quality >= float32(75) && method == 5 {
// Test with and without color cache.
do_no_cache = 1
// If we have a palette, also check in combination with spatial.
- if *(*EntropyIx)(unsafe.Pointer(bp /* min_entropy_ix */)) == kPalette {
+ if *(*EntropyIx)(unsafe.Pointer(bp)) == kPalette {
*(*int32)(unsafe.Pointer(crunch_configs_size)) = 2
(*CrunchConfig)(unsafe.Pointer(crunch_configs + 1*28)).entropy_idx_ = kPaletteAndSpatial
(*CrunchConfig)(unsafe.Pointer(crunch_configs + 1*28)).palette_sorting_type_ = kMinimizeDelta
@@ -36068,13 +35770,13 @@ func EncoderAnalyze(tls *libc.TLS, enc uintptr, crunch_configs uintptr, crunch_c
var j int32
for j = 0; j < n_lz77s; j++ {
- (*CrunchSubConfig)(unsafe.Pointer(((crunch_configs + uintptr(i)*28) + 8 /* &.sub_configs_ */) + uintptr(j)*8)).lz77_ = func() int32 {
+ (*CrunchSubConfig)(unsafe.Pointer(crunch_configs + uintptr(i)*28 + 8 + uintptr(j)*8)).lz77_ = func() int32 {
if j == 0 {
- return (kLZ77Standard | kLZ77RLE)
+ return kLZ77Standard | kLZ77RLE
}
return kLZ77Box
}()
- (*CrunchSubConfig)(unsafe.Pointer(((crunch_configs + uintptr(i)*28) + 8 /* &.sub_configs_ */) + uintptr(j)*8)).do_no_cache_ = do_no_cache
+ (*CrunchSubConfig)(unsafe.Pointer(crunch_configs + uintptr(i)*28 + 8 + uintptr(j)*8)).do_no_cache_ = do_no_cache
}
(*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr(i)*28)).sub_configs_size_ = n_lz77s
}
@@ -36085,17 +35787,17 @@ func EncoderInit(tls *libc.TLS, enc uintptr) int32 { /* vp8l_enc.c:673:12: */
var pic uintptr = (*VP8LEncoder)(unsafe.Pointer(enc)).pic_
var width int32 = (*WebPPicture)(unsafe.Pointer(pic)).width
var height int32 = (*WebPPicture)(unsafe.Pointer(pic)).height
- var pix_cnt int32 = (width * height)
+ var pix_cnt int32 = width * height
// we round the block size up, so we're guaranteed to have
// at most MAX_REFS_BLOCK_PER_IMAGE blocks used:
- var refs_block_size int32 = (((pix_cnt - 1) / 16) + 1)
+ var refs_block_size int32 = (pix_cnt-1)/16 + 1
var i int32
- if !(VP8LHashChainInit(tls, (enc+2312 /* &.hash_chain_ */), pix_cnt) != 0) {
+ if !(VP8LHashChainInit(tls, enc+2312, pix_cnt) != 0) {
return 0
}
for i = 0; i < 4; i++ {
- VP8LBackwardRefsInit(tls, ((enc + 2152 /* &.refs_ */) + uintptr(i)*40), refs_block_size)
+ VP8LBackwardRefsInit(tls, enc+2152+uintptr(i)*40, refs_block_size)
}
return 1
@@ -36122,11 +35824,11 @@ func GetHuffBitLengthsAndCodes(tls *libc.TLS, histogram_image uintptr, huffman_c
var histo1 uintptr
ok = 0
total_length_size = uint64(0)
- mem_buf = (uintptr(0))
+ mem_buf = uintptr(0)
histogram_image_size = (*VP8LHistogramSet)(unsafe.Pointer(histogram_image)).size
max_num_symbols = 0
- buf_rle = (uintptr(0))
- huff_tree = (uintptr(0))
+ buf_rle = uintptr(0)
+ huff_tree = uintptr(0)
// Iterate over all histograms and get the aggregate number of codes used.
i = 0
@@ -36135,7 +35837,7 @@ __1:
goto __3
}
histo = *(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(histogram_image)).histograms + uintptr(i)*8))
- codes = (huffman_codes + uintptr((5*i))*24)
+ codes = huffman_codes + uintptr(5*i)*24
k = 0
__4:
@@ -36152,7 +35854,7 @@ __4:
}
}
(*HuffmanTreeCode)(unsafe.Pointer(codes + uintptr(k)*24)).num_symbols = num_symbols
- total_length_size = total_length_size + (uint64_t(num_symbols))
+ total_length_size = total_length_size + uint64_t(num_symbols)
goto __5
__5:
k++
@@ -36171,8 +35873,8 @@ __3:
// Allocate and Set Huffman codes.
mem_buf = WebPSafeCalloc(tls, total_length_size,
- (uint64(unsafe.Sizeof(uint8_t(0))) + uint64(unsafe.Sizeof(uint16_t(0)))))
- if !(mem_buf == (uintptr(0))) {
+ uint64(unsafe.Sizeof(uint8_t(0)))+uint64(unsafe.Sizeof(uint16_t(0))))
+ if !(mem_buf == uintptr(0)) {
goto __7
}
goto End
@@ -36180,16 +35882,16 @@ __7:
;
codes1 = mem_buf
- lengths = (codes1 + uintptr(total_length_size)*2)
+ lengths = codes1 + uintptr(total_length_size)*2
i = 0
__8:
- if !(i < (5 * histogram_image_size)) {
+ if !(i < 5*histogram_image_size) {
goto __10
}
bit_length = (*HuffmanTreeCode)(unsafe.Pointer(huffman_codes + uintptr(i)*24)).num_symbols
(*HuffmanTreeCode)(unsafe.Pointer(huffman_codes + uintptr(i)*24)).codes = codes1
(*HuffmanTreeCode)(unsafe.Pointer(huffman_codes + uintptr(i)*24)).code_lengths = lengths
- codes1 += 2 * (uintptr(bit_length))
+ codes1 += 2 * uintptr(bit_length)
lengths += uintptr(bit_length)
if !(max_num_symbols < bit_length) {
goto __11
@@ -36206,9 +35908,9 @@ __10:
;
buf_rle = WebPSafeMalloc(tls, 1, uint64(max_num_symbols))
- huff_tree = WebPSafeMalloc(tls, (uint64(3 * uint64(max_num_symbols))),
+ huff_tree = WebPSafeMalloc(tls, uint64(3*uint64(max_num_symbols)),
uint64(unsafe.Sizeof(HuffmanTree{})))
- if !((buf_rle == (uintptr(0))) || (huff_tree == (uintptr(0)))) {
+ if !(buf_rle == uintptr(0) || huff_tree == uintptr(0)) {
goto __12
}
goto End
@@ -36221,13 +35923,13 @@ __13:
if !(i < histogram_image_size) {
goto __15
}
- codes2 = (huffman_codes + uintptr((5*i))*24)
+ codes2 = huffman_codes + uintptr(5*i)*24
histo1 = *(*uintptr)(unsafe.Pointer((*VP8LHistogramSet)(unsafe.Pointer(histogram_image)).histograms + uintptr(i)*8))
- VP8LCreateHuffmanTree(tls, (*VP8LHistogram)(unsafe.Pointer(histo1)).literal_, 15, buf_rle, huff_tree, (codes2 + uintptr(0)*24))
- VP8LCreateHuffmanTree(tls, (histo1 + 8 /* &.red_ */), 15, buf_rle, huff_tree, (codes2 + uintptr(1)*24))
- VP8LCreateHuffmanTree(tls, (histo1 + 1032 /* &.blue_ */), 15, buf_rle, huff_tree, (codes2 + uintptr(2)*24))
- VP8LCreateHuffmanTree(tls, (histo1 + 2056 /* &.alpha_ */), 15, buf_rle, huff_tree, (codes2 + uintptr(3)*24))
- VP8LCreateHuffmanTree(tls, (histo1 + 3080 /* &.distance_ */), 15, buf_rle, huff_tree, (codes2 + uintptr(4)*24))
+ VP8LCreateHuffmanTree(tls, (*VP8LHistogram)(unsafe.Pointer(histo1)).literal_, 15, buf_rle, huff_tree, codes2+uintptr(0)*24)
+ VP8LCreateHuffmanTree(tls, histo1+8, 15, buf_rle, huff_tree, codes2+uintptr(1)*24)
+ VP8LCreateHuffmanTree(tls, histo1+1032, 15, buf_rle, huff_tree, codes2+uintptr(2)*24)
+ VP8LCreateHuffmanTree(tls, histo1+2056, 15, buf_rle, huff_tree, codes2+uintptr(3)*24)
+ VP8LCreateHuffmanTree(tls, histo1+3080, 15, buf_rle, huff_tree, codes2+uintptr(4)*24)
goto __14
__14:
i++
@@ -36239,11 +35941,11 @@ __15:
End:
WebPSafeFree(tls, huff_tree)
WebPSafeFree(tls, buf_rle)
- if !(!(ok != 0)) {
+ if !!(ok != 0) {
goto __16
}
WebPSafeFree(tls, mem_buf)
- libc.Xmemset(tls, huffman_codes, 0, ((uint64(5 * histogram_image_size)) * uint64(unsafe.Sizeof(HuffmanTreeCode{}))))
+ libc.Xmemset(tls, huffman_codes, 0, uint64(5*histogram_image_size)*uint64(unsafe.Sizeof(HuffmanTreeCode{})))
__16:
;
return ok
@@ -36254,11 +35956,11 @@ func StoreHuffmanTreeOfHuffmanTreeToBitMask(tls *libc.TLS, bw uintptr, code_leng
// Throw away trailing zeros:
var codes_to_store int32 = 19
for ; codes_to_store > 4; codes_to_store-- {
- if int32(*(*uint8_t)(unsafe.Pointer(code_length_bitdepth + uintptr(kStorageOrder[(codes_to_store-1)])))) != 0 {
+ if int32(*(*uint8_t)(unsafe.Pointer(code_length_bitdepth + uintptr(kStorageOrder[codes_to_store-1])))) != 0 {
break
}
}
- VP8LPutBits(tls, bw, (uint32(codes_to_store - 4)), 4)
+ VP8LPutBits(tls, bw, uint32(codes_to_store-4), 4)
for i = 0; i < codes_to_store; i++ {
VP8LPutBits(tls, bw, uint32(*(*uint8_t)(unsafe.Pointer(code_length_bitdepth + uintptr(kStorageOrder[i])))), 3)
}
@@ -36317,8 +36019,8 @@ func StoreFullHuffmanCode(tls *libc.TLS, bw uintptr, huff_tree uintptr, tokens u
// var huffman_code HuffmanTreeCode at bp+160, 24
(*HuffmanTreeCode)(unsafe.Pointer(bp + 160 /* &huffman_code */)).num_symbols = 19
- (*HuffmanTreeCode)(unsafe.Pointer(bp + 160 /* &huffman_code */)).code_lengths = (bp) /* &code_length_bitdepth[0] */
- (*HuffmanTreeCode)(unsafe.Pointer(bp + 160 /* &huffman_code */)).codes = (bp + 20) /* &code_length_bitdepth_symbols[0] */
+ (*HuffmanTreeCode)(unsafe.Pointer(bp + 160 /* &huffman_code */)).code_lengths = bp /* &code_length_bitdepth[0] */
+ (*HuffmanTreeCode)(unsafe.Pointer(bp + 160 /* &huffman_code */)).codes = bp + 20 /* &code_length_bitdepth_symbols[0] */
VP8LPutBits(tls, bw, uint32(0), 1)
num_tokens = VP8LCreateCompressedHuffmanTree(tls, tree, tokens, max_tokens)
@@ -36327,15 +36029,15 @@ func StoreFullHuffmanCode(tls *libc.TLS, bw uintptr, huff_tree uintptr, tokens u
*(*[19]uint8_t)(unsafe.Pointer(bp + 136 /* buf_rle */)) = [19]uint8_t{0: uint8_t(0)}
var i int32
for i = 0; i < num_tokens; i++ {
- *(*uint32_t)(unsafe.Pointer((bp + 60) /* &histogram[0] */ + uintptr((*HuffmanTreeToken)(unsafe.Pointer(tokens+uintptr(i)*2)).code)*4))++
+ *(*uint32_t)(unsafe.Pointer(bp + 60 + uintptr((*HuffmanTreeToken)(unsafe.Pointer(tokens+uintptr(i)*2)).code)*4))++
}
- VP8LCreateHuffmanTree(tls, (bp + 60) /* &histogram[0] */, 7, (bp + 136) /* &buf_rle[0] */, huff_tree, (bp + 160) /* &huffman_code */)
+ VP8LCreateHuffmanTree(tls, bp+60, 7, bp+136, huff_tree, bp+160)
}
- StoreHuffmanTreeOfHuffmanTreeToBitMask(tls, bw, (bp) /* &code_length_bitdepth[0] */)
- ClearHuffmanTreeIfOnlyOneSymbol(tls, (bp + 160) /* &huffman_code */)
+ StoreHuffmanTreeOfHuffmanTreeToBitMask(tls, bw, bp)
+ ClearHuffmanTreeIfOnlyOneSymbol(tls, bp+160)
{
var trailing_zero_bits int32 = 0
var trimmed_length int32 = num_tokens
@@ -36344,19 +36046,19 @@ func StoreFullHuffmanCode(tls *libc.TLS, bw uintptr, huff_tree uintptr, tokens u
var i int32 = num_tokens
for libc.PostDecInt32(&i, 1) > 0 {
var ix int32 = int32((*HuffmanTreeToken)(unsafe.Pointer(tokens + uintptr(i)*2)).code)
- if ((ix == 0) || (ix == 17)) || (ix == 18) {
+ if ix == 0 || ix == 17 || ix == 18 {
trimmed_length-- // discount trailing zeros
- trailing_zero_bits = trailing_zero_bits + (int32(*(*uint8_t)(unsafe.Pointer((bp) /* &code_length_bitdepth[0] */ + uintptr(ix)))))
+ trailing_zero_bits = trailing_zero_bits + int32(*(*uint8_t)(unsafe.Pointer(bp + uintptr(ix))))
if ix == 17 {
- trailing_zero_bits = trailing_zero_bits + (3)
+ trailing_zero_bits = trailing_zero_bits + 3
} else if ix == 18 {
- trailing_zero_bits = trailing_zero_bits + (7)
+ trailing_zero_bits = trailing_zero_bits + 7
}
} else {
break
}
}
- write_trimmed_length = (libc.Bool32((trimmed_length > 1) && (trailing_zero_bits > 12)))
+ write_trimmed_length = libc.Bool32(trimmed_length > 1 && trailing_zero_bits > 12)
if write_trimmed_length != 0 {
length = trimmed_length
} else {
@@ -36365,16 +36067,16 @@ func StoreFullHuffmanCode(tls *libc.TLS, bw uintptr, huff_tree uintptr, tokens u
VP8LPutBits(tls, bw, uint32(write_trimmed_length), 1)
if write_trimmed_length != 0 {
if trimmed_length == 2 {
- VP8LPutBits(tls, bw, uint32(0), (3 + 2)) // nbitpairs=1, trimmed_length=2
+ VP8LPutBits(tls, bw, uint32(0), 3+2) // nbitpairs=1, trimmed_length=2
} else {
- var nbits int32 = BitsLog2Floor(tls, (uint32(trimmed_length - 2)))
- var nbitpairs int32 = ((nbits / 2) + 1)
+ var nbits int32 = BitsLog2Floor(tls, uint32(trimmed_length-2))
+ var nbitpairs int32 = nbits/2 + 1
- VP8LPutBits(tls, bw, (uint32(nbitpairs - 1)), 3)
- VP8LPutBits(tls, bw, (uint32(trimmed_length - 2)), (nbitpairs * 2))
+ VP8LPutBits(tls, bw, uint32(nbitpairs-1), 3)
+ VP8LPutBits(tls, bw, uint32(trimmed_length-2), nbitpairs*2)
}
}
- StoreHuffmanTreeToBitMask(tls, bw, tokens, length, (bp + 160) /* &huffman_code */)
+ StoreHuffmanTreeToBitMask(tls, bw, tokens, length, bp+160)
}
}
@@ -36388,13 +36090,13 @@ func StoreHuffmanCode(tls *libc.TLS, bw uintptr, huff_tree uintptr, tokens uintp
var count int32 = 0
*(*[2]int32)(unsafe.Pointer(bp /* symbols */)) = [2]int32{0, 0}
var kMaxBits int32 = 8
- var kMaxSymbol int32 = (int32(1) << kMaxBits)
+ var kMaxSymbol int32 = int32(1) << kMaxBits
// Check whether it's a small tree.
- for i = 0; (i < (*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).num_symbols) && (count < 3); i++ {
+ for i = 0; i < (*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).num_symbols && count < 3; i++ {
if int32(*(*uint8_t)(unsafe.Pointer((*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).code_lengths + uintptr(i)))) != 0 {
if count < 2 {
- *(*int32)(unsafe.Pointer((bp) /* &symbols[0] */ + uintptr(count)*4)) = i
+ *(*int32)(unsafe.Pointer(bp + uintptr(count)*4)) = i
}
count++
}
@@ -36403,18 +36105,18 @@ func StoreHuffmanCode(tls *libc.TLS, bw uintptr, huff_tree uintptr, tokens uintp
if count == 0 { // emit minimal tree for empty cases
// bits: small tree marker: 1, count-1: 0, large 8-bit code: 0, code: 0
VP8LPutBits(tls, bw, uint32(0x01), 4)
- } else if ((count <= 2) && (*(*int32)(unsafe.Pointer((bp) /* &symbols[0] */)) < kMaxSymbol)) && (*(*int32)(unsafe.Pointer((bp) /* &symbols[0] */ + 1*4)) < kMaxSymbol) {
+ } else if count <= 2 && *(*int32)(unsafe.Pointer(bp)) < kMaxSymbol && *(*int32)(unsafe.Pointer(bp + 1*4)) < kMaxSymbol {
VP8LPutBits(tls, bw, uint32(1), 1) // Small tree marker to encode 1 or 2 symbols.
- VP8LPutBits(tls, bw, (uint32(count - 1)), 1)
- if *(*int32)(unsafe.Pointer((bp) /* &symbols[0] */)) <= 1 {
+ VP8LPutBits(tls, bw, uint32(count-1), 1)
+ if *(*int32)(unsafe.Pointer(bp)) <= 1 {
VP8LPutBits(tls, bw, uint32(0), 1) // Code bit for small (1 bit) symbol value.
- VP8LPutBits(tls, bw, uint32(*(*int32)(unsafe.Pointer((bp) /* &symbols[0] */))), 1)
+ VP8LPutBits(tls, bw, uint32(*(*int32)(unsafe.Pointer(bp))), 1)
} else {
VP8LPutBits(tls, bw, uint32(1), 1)
- VP8LPutBits(tls, bw, uint32(*(*int32)(unsafe.Pointer((bp) /* &symbols[0] */))), 8)
+ VP8LPutBits(tls, bw, uint32(*(*int32)(unsafe.Pointer(bp))), 8)
}
if count == 2 {
- VP8LPutBits(tls, bw, uint32(*(*int32)(unsafe.Pointer((bp) /* &symbols[0] */ + 1*4))), 8)
+ VP8LPutBits(tls, bw, uint32(*(*int32)(unsafe.Pointer(bp + 1*4))), 8)
}
} else {
StoreFullHuffmanCode(tls, bw, huff_tree, tokens, huffman_code)
@@ -36430,7 +36132,7 @@ func WriteHuffmanCode(tls *libc.TLS, bw uintptr, code uintptr, code_index int32)
func WriteHuffmanCodeWithExtraBits(tls *libc.TLS, bw uintptr, code uintptr, code_index int32, bits int32, n_bits int32) { /* vp8l_enc.c:941:25: */
var depth int32 = int32(*(*uint8_t)(unsafe.Pointer((*HuffmanTreeCode)(unsafe.Pointer(code)).code_lengths + uintptr(code_index))))
var symbol int32 = int32(*(*uint16_t)(unsafe.Pointer((*HuffmanTreeCode)(unsafe.Pointer(code)).codes + uintptr(code_index)*2)))
- VP8LPutBits(tls, bw, (uint32((bits << depth) | symbol)), (depth + n_bits))
+ VP8LPutBits(tls, bw, uint32(bits<<depth|symbol), depth+n_bits)
}
func StoreImageToBitMask(tls *libc.TLS, bw uintptr, width int32, histo_bits int32, refs uintptr, histogram_symbols uintptr, huffman_codes uintptr) WebPEncodingError { /* vp8l_enc.c:952:26: */
@@ -36452,28 +36154,28 @@ func StoreImageToBitMask(tls *libc.TLS, bw uintptr, width int32, histo_bits int3
// x and y trace the position in the image.
var x int32 = 0
var y int32 = 0
- var tile_x int32 = (x & tile_mask)
- var tile_y int32 = (y & tile_mask)
+ var tile_x int32 = x & tile_mask
+ var tile_y int32 = y & tile_mask
var histogram_ix int32 = int32(*(*uint16_t)(unsafe.Pointer(histogram_symbols)))
- var codes uintptr = (huffman_codes + uintptr((5*histogram_ix))*24)
+ var codes uintptr = huffman_codes + uintptr(5*histogram_ix)*24
*(*VP8LRefsCursor)(unsafe.Pointer(bp /* c */)) = VP8LRefsCursorInit(tls, refs)
- for VP8LRefsCursorOk(tls, (bp) /* &c */) != 0 {
+ for VP8LRefsCursorOk(tls, bp) != 0 {
var v uintptr = (*VP8LRefsCursor)(unsafe.Pointer(bp /* &c */)).cur_pos
- if (tile_x != (x & tile_mask)) || (tile_y != (y & tile_mask)) {
- tile_x = (x & tile_mask)
- tile_y = (y & tile_mask)
- histogram_ix = int32(*(*uint16_t)(unsafe.Pointer(histogram_symbols + uintptr((((y>>histo_bits)*histo_xsize)+(x>>histo_bits)))*2)))
- codes = (huffman_codes + uintptr((5*histogram_ix))*24)
+ if tile_x != x&tile_mask || tile_y != y&tile_mask {
+ tile_x = x & tile_mask
+ tile_y = y & tile_mask
+ histogram_ix = int32(*(*uint16_t)(unsafe.Pointer(histogram_symbols + uintptr(y>>histo_bits*histo_xsize+x>>histo_bits)*2)))
+ codes = huffman_codes + uintptr(5*histogram_ix)*24
}
if PixOrCopyIsLiteral(tls, v) != 0 {
var k int32
for k = 0; k < 4; k++ {
var code int32 = int32(PixOrCopyLiteral(tls, v, int32(order[k])))
- WriteHuffmanCode(tls, bw, (codes + uintptr(k)*24), code)
+ WriteHuffmanCode(tls, bw, codes+uintptr(k)*24, code)
}
} else if PixOrCopyIsCacheIdx(tls, v) != 0 {
var code int32 = int32(PixOrCopyCacheIdx(tls, v))
- var literal_ix int32 = ((256 + 24) + code)
+ var literal_ix int32 = 256 + 24 + code
WriteHuffmanCode(tls, bw, codes, literal_ix)
} else {
// var bits int32 at bp+32, 4
@@ -36483,22 +36185,22 @@ func StoreImageToBitMask(tls *libc.TLS, bw uintptr, width int32, histo_bits int3
// var code int32 at bp+24, 4
var distance int32 = int32(PixOrCopyDistance(tls, v))
- VP8LPrefixEncode(tls, int32((*PixOrCopy)(unsafe.Pointer(v)).len), (bp + 24) /* &code */, (bp + 28) /* &n_bits */, (bp + 32) /* &bits */)
- WriteHuffmanCodeWithExtraBits(tls, bw, codes, (256 + *(*int32)(unsafe.Pointer(bp + 24 /* code */))), *(*int32)(unsafe.Pointer(bp + 32 /* bits */)), *(*int32)(unsafe.Pointer(bp + 28 /* n_bits */)))
+ VP8LPrefixEncode(tls, int32((*PixOrCopy)(unsafe.Pointer(v)).len), bp+24, bp+28, bp+32)
+ WriteHuffmanCodeWithExtraBits(tls, bw, codes, 256+*(*int32)(unsafe.Pointer(bp + 24)), *(*int32)(unsafe.Pointer(bp + 32 /* bits */)), *(*int32)(unsafe.Pointer(bp + 28 /* n_bits */)))
// Don't write the distance with the extra bits code since
// the distance can be up to 18 bits of extra bits, and the prefix
// 15 bits, totaling to 33, and our PutBits only supports up to 32 bits.
- VP8LPrefixEncode(tls, distance, (bp + 24) /* &code */, (bp + 28) /* &n_bits */, (bp + 32) /* &bits */)
- WriteHuffmanCode(tls, bw, (codes + uintptr(4)*24), *(*int32)(unsafe.Pointer(bp + 24 /* code */)))
+ VP8LPrefixEncode(tls, distance, bp+24, bp+28, bp+32)
+ WriteHuffmanCode(tls, bw, codes+uintptr(4)*24, *(*int32)(unsafe.Pointer(bp + 24 /* code */)))
VP8LPutBits(tls, bw, uint32(*(*int32)(unsafe.Pointer(bp + 32 /* bits */))), *(*int32)(unsafe.Pointer(bp + 28 /* n_bits */)))
}
- x = int32(uint32_t(x) + (PixOrCopyLength(tls, v)))
+ x = int32(uint32_t(x) + PixOrCopyLength(tls, v))
for x >= width {
- x = x - (width)
+ x = x - width
y++
}
- VP8LRefsCursorNext(tls, (bp) /* &c */)
+ VP8LRefsCursorNext(tls, bp)
}
if (*VP8LBitWriter)(unsafe.Pointer(bw)).error_ != 0 {
return VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -36530,14 +36232,14 @@ func EncodeImageNoHuffman(tls *libc.TLS, bw uintptr, argb uintptr, hash_chain ui
var codes1 uintptr
max_tokens = 0
err = VP8_ENC_OK
- tokens = (uintptr(0))
- *(*[5]HuffmanTreeCode)(unsafe.Pointer(bp + 8 /* huffman_codes */)) = [5]HuffmanTreeCode{0: HuffmanTreeCode{}}
+ tokens = uintptr(0)
+ *(*[5]HuffmanTreeCode)(unsafe.Pointer(bp + 8 /* huffman_codes */)) = [5]HuffmanTreeCode{0: {}}
*(*[1]uint16_t)(unsafe.Pointer(bp + 128 /* histogram_symbols */)) = [1]uint16_t{uint16_t(0)}
*(*int32)(unsafe.Pointer(bp /* cache_bits */)) = 0
- histogram_image = (uintptr(0))
+ histogram_image = uintptr(0)
huff_tree = WebPSafeMalloc(tls,
- (3 * uint64(19)), uint64(unsafe.Sizeof(HuffmanTree{})))
- if !(huff_tree == (uintptr(0))) {
+ 3*uint64(19), uint64(unsafe.Sizeof(HuffmanTree{})))
+ if !(huff_tree == uintptr(0)) {
goto __1
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -36546,8 +36248,8 @@ __1:
;
// Calculate backward references from ARGB image.
- if !(!(VP8LHashChainFill(tls, hash_chain, quality, argb, width, height,
- low_effort) != 0)) {
+ if !!(VP8LHashChainFill(tls, hash_chain, quality, argb, width, height,
+ low_effort) != 0) {
goto __2
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -36555,17 +36257,17 @@ __1:
__2:
;
err = VP8LGetBackwardReferences(tls,
- width, height, argb, quality /*low_effort=*/, 0, (kLZ77Standard | kLZ77RLE),
- *(*int32)(unsafe.Pointer(bp /* cache_bits */)) /*do_no_cache=*/, 0, hash_chain, refs_array, (bp) /* &cache_bits */)
+ width, height, argb, quality /*low_effort=*/, 0, kLZ77Standard|kLZ77RLE,
+ *(*int32)(unsafe.Pointer(bp /* cache_bits */)) /*do_no_cache=*/, 0, hash_chain, refs_array, bp)
if !(err != VP8_ENC_OK) {
goto __3
}
goto Error
__3:
;
- refs = (refs_array)
+ refs = refs_array
histogram_image = VP8LAllocateHistogramSet(tls, 1, *(*int32)(unsafe.Pointer(bp /* cache_bits */)))
- if !(histogram_image == (uintptr(0))) {
+ if !(histogram_image == uintptr(0)) {
goto __4
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -36579,7 +36281,7 @@ __4:
// Create Huffman bit lengths and codes for each histogram image.
- if !(!(GetHuffBitLengthsAndCodes(tls, histogram_image, (bp+8) /* &huffman_codes[0] */) != 0)) {
+ if !!(GetHuffBitLengthsAndCodes(tls, histogram_image, bp+8) != 0) {
goto __5
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -36596,7 +36298,7 @@ __6:
if !(i < 5) {
goto __8
}
- codes = ((bp + 8) /* &huffman_codes */ + uintptr(i)*24)
+ codes = bp + 8 + uintptr(i)*24
if !(max_tokens < (*HuffmanTreeCode)(unsafe.Pointer(codes)).num_symbols) {
goto __9
}
@@ -36612,7 +36314,7 @@ __8:
;
tokens = WebPSafeMalloc(tls, uint64(max_tokens), uint64(unsafe.Sizeof(HuffmanTreeToken{})))
- if !(tokens == (uintptr(0))) {
+ if !(tokens == uintptr(0)) {
goto __10
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -36626,7 +36328,7 @@ __11:
if !(i < 5) {
goto __13
}
- codes1 = ((bp + 8) /* &huffman_codes */ + uintptr(i)*24)
+ codes1 = bp + 8 + uintptr(i)*24
StoreHuffmanCode(tls, bw, huff_tree, tokens, codes1)
ClearHuffmanTreeIfOnlyOneSymbol(tls, codes1)
goto __12
@@ -36638,14 +36340,14 @@ __13:
;
// Store actual literals.
- err = StoreImageToBitMask(tls, bw, width, 0, refs, (bp + 128), /* &histogram_symbols[0] */
- (bp + 8) /* &huffman_codes[0] */)
+ err = StoreImageToBitMask(tls, bw, width, 0, refs, bp+128,
+ bp+8)
Error:
WebPSafeFree(tls, tokens)
WebPSafeFree(tls, huff_tree)
VP8LFreeHistogramSet(tls, histogram_image)
- WebPSafeFree(tls, (*HuffmanTreeCode)(unsafe.Pointer((bp + 8) /* &huffman_codes */)).codes)
+ WebPSafeFree(tls, (*HuffmanTreeCode)(unsafe.Pointer(bp+8)).codes)
return err
}
@@ -36689,15 +36391,15 @@ func EncodeImageInternal(tls *libc.TLS, bw uintptr, argb uintptr, hash_chain uin
var i_cache int32
err = VP8_ENC_ERROR_OUT_OF_MEMORY
histogram_image_xysize =
- (VP8LSubSampleSize(tls, uint32(width), uint32(histogram_bits)) * VP8LSubSampleSize(tls, uint32(height), uint32(histogram_bits)))
- histogram_image = (uintptr(0))
- tmp_histo = (uintptr(0))
+ VP8LSubSampleSize(tls, uint32(width), uint32(histogram_bits)) * VP8LSubSampleSize(tls, uint32(height), uint32(histogram_bits))
+ histogram_image = uintptr(0)
+ tmp_histo = uintptr(0)
histogram_image_size = 0
bit_array_size = uint64(0)
huff_tree = WebPSafeMalloc(tls,
- (3 * uint64(19)), uint64(unsafe.Sizeof(HuffmanTree{})))
- tokens = (uintptr(0))
- huffman_codes = (uintptr(0))
+ 3*uint64(19), uint64(unsafe.Sizeof(HuffmanTree{})))
+ tokens = uintptr(0)
+ huffman_codes = uintptr(0)
histogram_symbols =
WebPSafeMalloc(tls, uint64(histogram_image_xysize),
uint64(unsafe.Sizeof(uint16_t(0))))
@@ -36705,8 +36407,8 @@ func EncodeImageInternal(tls *libc.TLS, bw uintptr, argb uintptr, hash_chain uin
bw_size_best = libc.CplUint64(uint64(0))
// Make sure we can allocate the different objects.
- libc.Xmemset(tls, (bp) /* &hash_chain_histogram */, 0, uint64(unsafe.Sizeof(VP8LHashChain{})))
- if !((((huff_tree == (uintptr(0))) || (histogram_symbols == (uintptr(0)))) || !(VP8LHashChainInit(tls, (bp) /* &hash_chain_histogram */, int32(histogram_image_xysize)) != 0)) || !(VP8LHashChainFill(tls, hash_chain, quality, argb, width, height,
+ libc.Xmemset(tls, bp, 0, uint64(unsafe.Sizeof(VP8LHashChain{})))
+ if !(huff_tree == uintptr(0) || histogram_symbols == uintptr(0) || !(VP8LHashChainInit(tls, bp, int32(histogram_image_xysize)) != 0) || !(VP8LHashChainFill(tls, hash_chain, quality, argb, width, height,
low_effort) != 0)) {
goto __1
}
@@ -36729,7 +36431,7 @@ __2:
__3:
;
// If several iterations will happen, clone into bw_best.
- if !(!(VP8LBitWriterInit(tls, (bp+16) /* &bw_best */, uint64(0)) != 0) || ((((*CrunchConfig)(unsafe.Pointer(config)).sub_configs_size_ > 1) || ((*CrunchSubConfig)(unsafe.Pointer((config + 8 /* &.sub_configs_ */))).do_no_cache_ != 0)) && !(VP8LBitWriterClone(tls, bw, (bp+16) /* &bw_best */) != 0))) {
+ if !(!(VP8LBitWriterInit(tls, bp+16, uint64(0)) != 0) || ((*CrunchConfig)(unsafe.Pointer(config)).sub_configs_size_ > 1 || (*CrunchSubConfig)(unsafe.Pointer(config+8)).do_no_cache_ != 0) && !(VP8LBitWriterClone(tls, bw, bp+16) != 0)) {
goto __4
}
goto Error
@@ -36741,11 +36443,11 @@ __5:
goto __7
}
sub_config =
- ((config + 8 /* &.sub_configs_ */) + uintptr(sub_configs_idx)*8)
+ config + 8 + uintptr(sub_configs_idx)*8
err = VP8LGetBackwardReferences(tls, width, height, argb, quality, low_effort,
(*CrunchSubConfig)(unsafe.Pointer(sub_config)).lz77_, cache_bits_init,
(*CrunchSubConfig)(unsafe.Pointer(sub_config)).do_no_cache_, hash_chain,
- (refs_array), (bp + 64) /* &cache_bits_best */)
+ refs_array, bp+64)
if !(err != VP8_ENC_OK) {
goto __8
}
@@ -36755,12 +36457,12 @@ __8:
i_cache = 0
__9:
- if !(i_cache < (func() int32 {
+ if !(i_cache < func() int32 {
if (*CrunchSubConfig)(unsafe.Pointer(sub_config)).do_no_cache_ != 0 {
return 2
}
return 1
- }())) {
+ }()) {
goto __11
}
if i_cache == 0 {
@@ -36770,7 +36472,7 @@ __9:
}
// Speed-up: no need to study the no-cache case if it was already studied
// in i_cache == 0.
- if !((i_cache == 1) && (*(*int32)(unsafe.Pointer(bp + 64 /* cache_bits_best */)) == 0)) {
+ if !(i_cache == 1 && *(*int32)(unsafe.Pointer(bp + 64)) == 0) {
goto __12
}
goto __11
@@ -36778,12 +36480,12 @@ __12:
;
// Reset the bit writer for this iteration.
- VP8LBitWriterReset(tls, (bp + 72) /* &bw_init */, bw)
+ VP8LBitWriterReset(tls, bp+72, bw)
// Build histogram image and symbols from backward references.
histogram_image = VP8LAllocateHistogramSet(tls, int32(histogram_image_xysize), cache_bits_tmp)
tmp_histo = VP8LAllocateHistogram(tls, cache_bits_tmp)
- if !(((histogram_image == (uintptr(0))) || (tmp_histo == (uintptr(0)))) || !(VP8LGetHistoImageSymbols(tls, width, height, (refs_array+uintptr(i_cache)*40),
+ if !(histogram_image == uintptr(0) || tmp_histo == uintptr(0) || !(VP8LGetHistoImageSymbols(tls, width, height, refs_array+uintptr(i_cache)*40,
quality, low_effort, histogram_bits,
cache_bits_tmp, histogram_image, tmp_histo,
histogram_symbols) != 0)) {
@@ -36794,13 +36496,13 @@ __13:
;
// Create Huffman bit lengths and codes for each histogram image.
histogram_image_size = (*VP8LHistogramSet)(unsafe.Pointer(histogram_image)).size
- bit_array_size = (size_t(5 * histogram_image_size))
+ bit_array_size = size_t(5 * histogram_image_size)
huffman_codes = WebPSafeCalloc(tls, bit_array_size,
uint64(unsafe.Sizeof(HuffmanTreeCode{})))
// Note: some histogram_image entries may point to tmp_histos[], so the
// latter need to outlive the following call to
// GetHuffBitLengthsAndCodes().
- if !((huffman_codes == (uintptr(0))) || !(GetHuffBitLengthsAndCodes(tls, histogram_image, huffman_codes) != 0)) {
+ if !(huffman_codes == uintptr(0) || !(GetHuffBitLengthsAndCodes(tls, histogram_image, huffman_codes) != 0)) {
goto __14
}
goto Error
@@ -36808,11 +36510,11 @@ __14:
;
// Free combined histograms.
VP8LFreeHistogramSet(tls, histogram_image)
- histogram_image = (uintptr(0))
+ histogram_image = uintptr(0)
// Free scratch histograms.
VP8LFreeHistogram(tls, tmp_histo)
- tmp_histo = (uintptr(0))
+ tmp_histo = uintptr(0)
// Color Cache parameters.
if !(cache_bits_tmp > 0) {
@@ -36827,7 +36529,7 @@ __16:
;
// Huffman image + meta huffman.
- write_histogram_image = (libc.Bool32(histogram_image_size > 1))
+ write_histogram_image = libc.Bool32(histogram_image_size > 1)
VP8LPutBits(tls, bw, uint32(write_histogram_image), 1)
if !(write_histogram_image != 0) {
goto __17
@@ -36836,7 +36538,7 @@ __16:
WebPSafeMalloc(tls, uint64(histogram_image_xysize),
uint64(unsafe.Sizeof(uint32_t(0))))
max_index = 0
- if !(histogram_argb == (uintptr(0))) {
+ if !(histogram_argb == uintptr(0)) {
goto __18
}
goto Error
@@ -36847,12 +36549,12 @@ __19:
if !(i < histogram_image_xysize) {
goto __21
}
- symbol_index = (int32(*(*uint16_t)(unsafe.Pointer(histogram_symbols + uintptr(i)*2))) & 0xffff)
- *(*uint32_t)(unsafe.Pointer(histogram_argb + uintptr(i)*4)) = (uint32_t(symbol_index << 8))
+ symbol_index = int32(*(*uint16_t)(unsafe.Pointer(histogram_symbols + uintptr(i)*2))) & 0xffff
+ *(*uint32_t)(unsafe.Pointer(histogram_argb + uintptr(i)*4)) = uint32_t(symbol_index << 8)
if !(symbol_index >= max_index) {
goto __22
}
- max_index = (symbol_index + 1)
+ max_index = symbol_index + 1
__22:
;
goto __20
@@ -36864,9 +36566,9 @@ __21:
;
histogram_image_size = max_index
- VP8LPutBits(tls, bw, (uint32(histogram_bits - 2)), 3)
+ VP8LPutBits(tls, bw, uint32(histogram_bits-2), 3)
err = EncodeImageNoHuffman(tls,
- bw, histogram_argb, (bp) /* &hash_chain_histogram */, (refs_array + 2*40),
+ bw, histogram_argb, bp, refs_array+2*40,
int32(VP8LSubSampleSize(tls, uint32(width), uint32(histogram_bits))),
int32(VP8LSubSampleSize(tls, uint32(height), uint32(histogram_bits))), quality, low_effort)
WebPSafeFree(tls, histogram_argb)
@@ -36885,10 +36587,10 @@ __17:
// Find maximum number of symbols for the huffman tree-set.
i1 = 0
__24:
- if !(i1 < (5 * histogram_image_size)) {
+ if !(i1 < 5*histogram_image_size) {
goto __26
}
- codes = (huffman_codes + uintptr(i1)*24)
+ codes = huffman_codes + uintptr(i1)*24
if !(max_tokens < (*HuffmanTreeCode)(unsafe.Pointer(codes)).num_symbols) {
goto __27
}
@@ -36903,7 +36605,7 @@ __25:
__26:
;
tokens = WebPSafeMalloc(tls, uint64(max_tokens), uint64(unsafe.Sizeof(HuffmanTreeToken{})))
- if !(tokens == (uintptr(0))) {
+ if !(tokens == uintptr(0)) {
goto __28
}
goto Error
@@ -36911,10 +36613,10 @@ __28:
;
i1 = 0
__29:
- if !(i1 < (5 * histogram_image_size)) {
+ if !(i1 < 5*histogram_image_size) {
goto __31
}
- codes1 = (huffman_codes + uintptr(i1)*24)
+ codes1 = huffman_codes + uintptr(i1)*24
StoreHuffmanCode(tls, bw, huff_tree, tokens, codes1)
ClearHuffmanTreeIfOnlyOneSymbol(tls, codes1)
goto __30
@@ -36926,8 +36628,8 @@ __31:
;
// Store actual literals.
- hdr_size_tmp = (int32(VP8LBitWriterNumBytes(tls, bw) - init_byte_position))
- err = StoreImageToBitMask(tls, bw, width, histogram_bits, (refs_array + uintptr(i_cache)*40),
+ hdr_size_tmp = int32(VP8LBitWriterNumBytes(tls, bw) - init_byte_position)
+ err = StoreImageToBitMask(tls, bw, width, histogram_bits, refs_array+uintptr(i_cache)*40,
histogram_symbols, huffman_codes)
if !(err != VP8_ENC_OK) {
goto __32
@@ -36942,18 +36644,18 @@ __32:
bw_size_best = VP8LBitWriterNumBytes(tls, bw)
*(*int32)(unsafe.Pointer(cache_bits)) = cache_bits_tmp
*(*int32)(unsafe.Pointer(hdr_size)) = hdr_size_tmp
- *(*int32)(unsafe.Pointer(data_size)) = (int32((VP8LBitWriterNumBytes(tls, bw) - init_byte_position) - size_t(*(*int32)(unsafe.Pointer(hdr_size)))))
- VP8LBitWriterSwap(tls, bw, (bp + 16) /* &bw_best */)
+ *(*int32)(unsafe.Pointer(data_size)) = int32(VP8LBitWriterNumBytes(tls, bw) - init_byte_position - size_t(*(*int32)(unsafe.Pointer(hdr_size))))
+ VP8LBitWriterSwap(tls, bw, bp+16)
__33:
;
WebPSafeFree(tls, tokens)
- tokens = (uintptr(0))
- if !(huffman_codes != (uintptr(0))) {
+ tokens = uintptr(0)
+ if !(huffman_codes != uintptr(0)) {
goto __34
}
WebPSafeFree(tls, (*HuffmanTreeCode)(unsafe.Pointer(huffman_codes)).codes)
WebPSafeFree(tls, huffman_codes)
- huffman_codes = (uintptr(0))
+ huffman_codes = uintptr(0)
__34:
;
goto __10
@@ -36970,7 +36672,7 @@ __6:
goto __7
__7:
;
- VP8LBitWriterSwap(tls, bw, (bp + 16) /* &bw_best */)
+ VP8LBitWriterSwap(tls, bw, bp+16)
err = VP8_ENC_OK
Error:
@@ -36978,8 +36680,8 @@ Error:
WebPSafeFree(tls, huff_tree)
VP8LFreeHistogramSet(tls, histogram_image)
VP8LFreeHistogram(tls, tmp_histo)
- VP8LHashChainClear(tls, (bp) /* &hash_chain_histogram */)
- if !(huffman_codes != (uintptr(0))) {
+ VP8LHashChainClear(tls, bp)
+ if !(huffman_codes != uintptr(0)) {
goto __35
}
WebPSafeFree(tls, (*HuffmanTreeCode)(unsafe.Pointer(huffman_codes)).codes)
@@ -36987,7 +36689,7 @@ Error:
__35:
;
WebPSafeFree(tls, histogram_symbols)
- VP8LBitWriterWipeOut(tls, (bp + 16) /* &bw_best */)
+ VP8LBitWriterWipeOut(tls, bp+16)
return err
}
@@ -36999,7 +36701,7 @@ func ApplySubtractGreen(tls *libc.TLS, enc uintptr, width int32, height int32, b
VP8LPutBits(tls, bw, SUBTRACT_GREEN, 2)
(*struct {
f func(*libc.TLS, uintptr, int32)
- })(unsafe.Pointer(&struct{ uintptr }{VP8LSubtractGreenFromBlueAndRed})).f(tls, (*VP8LEncoder)(unsafe.Pointer(enc)).argb_, (width * height))
+ })(unsafe.Pointer(&struct{ uintptr }{VP8LSubtractGreenFromBlueAndRed})).f(tls, (*VP8LEncoder)(unsafe.Pointer(enc)).argb_, width*height)
}
func ApplyPredictFilter(tls *libc.TLS, enc uintptr, width int32, height int32, quality int32, low_effort int32, used_subtract_green int32, bw uintptr) WebPEncodingError { /* vp8l_enc.c:1308:26: */
@@ -37021,10 +36723,10 @@ func ApplyPredictFilter(tls *libc.TLS, enc uintptr, width int32, height int32, q
VP8LPutBits(tls, bw, uint32(1), 1)
VP8LPutBits(tls, bw, PREDICTOR_TRANSFORM, 2)
- VP8LPutBits(tls, bw, (uint32(pred_bits - 2)), 3)
+ VP8LPutBits(tls, bw, uint32(pred_bits-2), 3)
return EncodeImageNoHuffman(tls,
- bw, (*VP8LEncoder)(unsafe.Pointer(enc)).transform_data_, (enc + 2312 /* &.hash_chain_ */),
- (enc + 2152 /* &.refs_ */), transform_width, transform_height,
+ bw, (*VP8LEncoder)(unsafe.Pointer(enc)).transform_data_, enc+2312,
+ enc+2152, transform_width, transform_height,
quality, low_effort)
}
@@ -37038,10 +36740,10 @@ func ApplyCrossColorFilter(tls *libc.TLS, enc uintptr, width int32, height int32
VP8LPutBits(tls, bw, uint32(1), 1)
VP8LPutBits(tls, bw, CROSS_COLOR_TRANSFORM, 2)
- VP8LPutBits(tls, bw, (uint32(ccolor_transform_bits - 2)), 3)
+ VP8LPutBits(tls, bw, uint32(ccolor_transform_bits-2), 3)
return EncodeImageNoHuffman(tls,
- bw, (*VP8LEncoder)(unsafe.Pointer(enc)).transform_data_, (enc + 2312 /* &.hash_chain_ */),
- (enc + 2152 /* &.refs_ */), transform_width, transform_height,
+ bw, (*VP8LEncoder)(unsafe.Pointer(enc)).transform_data_, enc+2312,
+ enc+2152, transform_width, transform_height,
quality, low_effort)
}
@@ -37055,19 +36757,19 @@ func WriteRiffHeader(tls *libc.TLS, pic uintptr, riff_size size_t, vp8l_size siz
uint8_t('R'), uint8_t('I'), uint8_t('F'), uint8_t('F'), uint8_t(0), uint8_t(0), uint8_t(0), uint8_t(0), uint8_t('W'), uint8_t('E'), uint8_t('B'), uint8_t('P'),
uint8_t('V'), uint8_t('P'), uint8_t('8'), uint8_t('L'), uint8_t(0), uint8_t(0), uint8_t(0), uint8_t(0), uint8_t(0x2f),
}
- PutLE32(tls, ((bp) /* &riff[0] */ + uintptr(4)), uint32_t(riff_size))
- PutLE32(tls, (((bp) /* &riff[0] */ + uintptr(12)) + uintptr(4)), uint32_t(vp8l_size))
+ PutLE32(tls, bp+uintptr(4), uint32_t(riff_size))
+ PutLE32(tls, bp+uintptr(12)+uintptr(4), uint32_t(vp8l_size))
if !((*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, (bp) /* &riff[0] */, uint64(unsafe.Sizeof([21]uint8_t{})), pic) != 0) {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, bp, uint64(unsafe.Sizeof([21]uint8_t{})), pic) != 0) {
return VP8_ENC_ERROR_BAD_WRITE
}
return VP8_ENC_OK
}
func WriteImageSize(tls *libc.TLS, pic uintptr, bw uintptr) int32 { /* vp8l_enc.c:1370:12: */
- var width int32 = ((*WebPPicture)(unsafe.Pointer(pic)).width - 1)
- var height int32 = ((*WebPPicture)(unsafe.Pointer(pic)).height - 1)
+ var width int32 = (*WebPPicture)(unsafe.Pointer(pic)).width - 1
+ var height int32 = (*WebPPicture)(unsafe.Pointer(pic)).height - 1
VP8LPutBits(tls, bw, uint32(width), 14)
VP8LPutBits(tls, bw, uint32(height), 14)
@@ -37094,9 +36796,9 @@ func WriteImage(tls *libc.TLS, pic uintptr, bw uintptr, coded_size uintptr) WebP
err = VP8_ENC_OK
webpll_data = VP8LBitWriterFinish(tls, bw)
webpll_size = VP8LBitWriterNumBytes(tls, bw)
- vp8l_size = (uint64(1) + webpll_size)
- pad = (vp8l_size & uint64(1))
- riff_size = (((uint64(4 + 8)) + vp8l_size) + pad)
+ vp8l_size = uint64(1) + webpll_size
+ pad = vp8l_size & uint64(1)
+ riff_size = uint64(4+8) + vp8l_size + pad
err = WriteRiffHeader(tls, pic, riff_size, vp8l_size)
if !(err != VP8_ENC_OK) {
@@ -37106,9 +36808,9 @@ func WriteImage(tls *libc.TLS, pic uintptr, bw uintptr, coded_size uintptr) WebP
__1:
;
- if !(!((*struct {
+ if !!((*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, webpll_data, webpll_size, pic) != 0)) {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, webpll_data, webpll_size, pic) != 0) {
goto __2
}
err = VP8_ENC_ERROR_BAD_WRITE
@@ -37120,9 +36822,9 @@ __2:
goto __3
}
*(*[1]uint8_t)(unsafe.Pointer(bp /* pad_byte */)) = [1]uint8_t{uint8_t(0)}
- if !(!((*struct {
+ if !!((*struct {
f func(*libc.TLS, uintptr, size_t, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, (bp) /* &pad_byte[0] */, uint64(1), pic) != 0)) {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).writer})).f(tls, bp, uint64(1), pic) != 0) {
goto __4
}
err = VP8_ENC_ERROR_BAD_WRITE
@@ -37131,7 +36833,7 @@ __4:
;
__3:
;
- *(*size_t)(unsafe.Pointer(coded_size)) = (uint64(8) + riff_size)
+ *(*size_t)(unsafe.Pointer(coded_size)) = uint64(8) + riff_size
return VP8_ENC_OK
Error:
@@ -37142,7 +36844,7 @@ Error:
func ClearTransformBuffer(tls *libc.TLS, enc uintptr) { /* vp8l_enc.c:1421:13: */
WebPSafeFree(tls, (*VP8LEncoder)(unsafe.Pointer(enc)).transform_mem_)
- (*VP8LEncoder)(unsafe.Pointer(enc)).transform_mem_ = (uintptr(0))
+ (*VP8LEncoder)(unsafe.Pointer(enc)).transform_mem_ = uintptr(0)
(*VP8LEncoder)(unsafe.Pointer(enc)).transform_mem_size_ = uint64(0)
}
@@ -37163,28 +36865,28 @@ func AllocateTransformBuffer(tls *libc.TLS, enc uintptr, width int32, height int
var mem_size uint64_t
var mem uintptr
err = VP8_ENC_OK
- image_size = (uint64_t(width * height))
+ image_size = uint64_t(width * height)
if (*VP8LEncoder)(unsafe.Pointer(enc)).use_predict_ != 0 {
- argb_scratch_size = ((uint64((width + 1) * 2)) + ((((uint64(width * 2)) + uint64(unsafe.Sizeof(uint32_t(0)))) - uint64(1)) / uint64(unsafe.Sizeof(uint32_t(0)))))
+ argb_scratch_size = uint64((width+1)*2) + (uint64(width*2)+uint64(unsafe.Sizeof(uint32_t(0)))-uint64(1))/uint64(unsafe.Sizeof(uint32_t(0)))
} else {
argb_scratch_size = uint64(0)
}
- if ((*VP8LEncoder)(unsafe.Pointer(enc)).use_predict_ != 0) || ((*VP8LEncoder)(unsafe.Pointer(enc)).use_cross_color_ != 0) {
- transform_data_size = (uint64(VP8LSubSampleSize(tls, uint32(width), uint32((*VP8LEncoder)(unsafe.Pointer(enc)).transform_bits_)) * VP8LSubSampleSize(tls, uint32(height), uint32((*VP8LEncoder)(unsafe.Pointer(enc)).transform_bits_))))
+ if (*VP8LEncoder)(unsafe.Pointer(enc)).use_predict_ != 0 || (*VP8LEncoder)(unsafe.Pointer(enc)).use_cross_color_ != 0 {
+ transform_data_size = uint64(VP8LSubSampleSize(tls, uint32(width), uint32((*VP8LEncoder)(unsafe.Pointer(enc)).transform_bits_)) * VP8LSubSampleSize(tls, uint32(height), uint32((*VP8LEncoder)(unsafe.Pointer(enc)).transform_bits_)))
} else {
transform_data_size = uint64(0)
}
max_alignment_in_words =
- (((uint64(31) + uint64(unsafe.Sizeof(uint32_t(0)))) - uint64(1)) / uint64(unsafe.Sizeof(uint32_t(0))))
+ (uint64(31) + uint64(unsafe.Sizeof(uint32_t(0))) - uint64(1)) / uint64(unsafe.Sizeof(uint32_t(0)))
mem_size =
- ((((image_size + max_alignment_in_words) + argb_scratch_size) + max_alignment_in_words) + transform_data_size)
+ image_size + max_alignment_in_words + argb_scratch_size + max_alignment_in_words + transform_data_size
mem = (*VP8LEncoder)(unsafe.Pointer(enc)).transform_mem_
- if !((mem == (uintptr(0))) || (mem_size > (*VP8LEncoder)(unsafe.Pointer(enc)).transform_mem_size_)) {
+ if !(mem == uintptr(0) || mem_size > (*VP8LEncoder)(unsafe.Pointer(enc)).transform_mem_size_) {
goto __1
}
ClearTransformBuffer(tls, enc)
mem = WebPSafeMalloc(tls, mem_size, uint64(unsafe.Sizeof(uint32_t(0))))
- if !(mem == (uintptr(0))) {
+ if !(mem == uintptr(0)) {
goto __2
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -37197,9 +36899,9 @@ __2:
__1:
;
(*VP8LEncoder)(unsafe.Pointer(enc)).argb_ = mem
- mem = (uintptr((uintptr_t((mem + uintptr(image_size)*4)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
+ mem = uintptr((uintptr_t(mem+uintptr(image_size)*4) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
(*VP8LEncoder)(unsafe.Pointer(enc)).argb_scratch_ = mem
- mem = (uintptr((uintptr_t((mem + uintptr(argb_scratch_size)*4)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
+ mem = uintptr((uintptr_t(mem+uintptr(argb_scratch_size)*4) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
(*VP8LEncoder)(unsafe.Pointer(enc)).transform_data_ = mem
(*VP8LEncoder)(unsafe.Pointer(enc)).current_width_ = width
@@ -37226,9 +36928,9 @@ func MakeInputImageCopy(tls *libc.TLS, enc uintptr) WebPEncodingError { /* vp8l_
var src uintptr = (*WebPPicture)(unsafe.Pointer(picture)).argb
var y int32
for y = 0; y < height; y++ {
- libc.Xmemcpy(tls, dst, src, (uint64(width) * uint64(unsafe.Sizeof(uint32_t(0)))))
- dst += 4 * (uintptr(width))
- src += 4 * (uintptr((*WebPPicture)(unsafe.Pointer(picture)).argb_stride))
+ libc.Xmemcpy(tls, dst, src, uint64(width)*uint64(unsafe.Sizeof(uint32_t(0))))
+ dst += 4 * uintptr(width)
+ src += 4 * uintptr((*WebPPicture)(unsafe.Pointer(picture)).argb_stride)
}
}
@@ -37256,17 +36958,17 @@ func SearchColorGreedy(tls *libc.TLS, palette uintptr, palette_size int32, color
func ApplyPaletteHash0(tls *libc.TLS, color uint32_t) uint32_t { /* vp8l_enc.c:1519:29: */
// Focus on the green color.
- return ((color >> 8) & uint32_t(0xff))
+ return color >> 8 & uint32_t(0xff)
}
func ApplyPaletteHash1(tls *libc.TLS, color uint32_t) uint32_t { /* vp8l_enc.c:1527:29: */
// Forget about alpha.
- return ((uint32_t((uint64(color & 0x00ffffff)) * 4222244071)) >> (32 - 11))
+ return uint32_t(uint64(color&0x00ffffff)*4222244071) >> (32 - 11)
}
func ApplyPaletteHash2(tls *libc.TLS, color uint32_t) uint32_t { /* vp8l_enc.c:1533:29: */
// Forget about alpha.
- return ((uint32_t((uint64(color & 0x00ffffff)) * ((uint64(1) << 31) - uint64(1)))) >> (32 - 11))
+ return uint32_t(uint64(color&0x00ffffff)*(uint64(1)<<31-uint64(1))) >> (32 - 11)
}
// Use 1 pixel cache for ARGB pixels.
@@ -37285,12 +36987,12 @@ func ApplyPalette(tls *libc.TLS, src uintptr, src_stride uint32_t, dst uintptr,
var x int32
var y int32
- if tmp_row == (uintptr(0)) {
+ if tmp_row == uintptr(0) {
return VP8_ENC_ERROR_OUT_OF_MEMORY
}
if palette_size < 4 {
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
var prev_pix uint32_t = *(*uint32_t)(unsafe.Pointer(palette))
var prev_idx uint32_t = uint32_t(0)
for y = 0; y < height; y++ {
@@ -37305,8 +37007,8 @@ func ApplyPalette(tls *libc.TLS, src uintptr, src_stride uint32_t, dst uintptr,
(*struct {
f func(*libc.TLS, uintptr, int32, int32, uintptr)
})(unsafe.Pointer(&struct{ uintptr }{VP8LBundleColorMap})).f(tls, tmp_row, width, xbits, dst)
- src += 4 * (uintptr(src_stride))
- dst += 4 * (uintptr(dst_stride))
+ src += 4 * uintptr(src_stride)
+ dst += 4 * uintptr(dst_stride)
}
}
} else {
@@ -37330,16 +37032,16 @@ func ApplyPalette(tls *libc.TLS, src uintptr, src_stride uint32_t, dst uintptr,
for i = 0; i < 3; i++ {
var use_LUT int32 = 1
// Set each element in buffer to max uint16_t.
- libc.Xmemset(tls, (bp) /* &buffer[0] */, 0xff, uint64(unsafe.Sizeof([2048]uint16_t{})))
+ libc.Xmemset(tls, bp, 0xff, uint64(unsafe.Sizeof([2048]uint16_t{})))
for j = 0; j < palette_size; j++ {
var ind uint32_t = (*struct {
f func(*libc.TLS, uint32_t) uint32_t
- })(unsafe.Pointer(&struct{ uintptr }{*(*uintptr)(unsafe.Pointer((bp + 4096) /* &hash_functions[0] */ + uintptr(i)*8))})).f(tls, *(*uint32_t)(unsafe.Pointer(palette + uintptr(j)*4)))
- if uint32(*(*uint16_t)(unsafe.Pointer((bp) /* &buffer[0] */ + uintptr(ind)*2))) != 0xffff {
+ })(unsafe.Pointer(&struct{ uintptr }{*(*uintptr)(unsafe.Pointer(bp + 4096 /* &hash_functions[0] */ + uintptr(i)*8))})).f(tls, *(*uint32_t)(unsafe.Pointer(palette + uintptr(j)*4)))
+ if uint32(*(*uint16_t)(unsafe.Pointer(bp + uintptr(ind)*2))) != 0xffff {
use_LUT = 0
break
} else {
- *(*uint16_t)(unsafe.Pointer((bp) /* &buffer[0] */ + uintptr(ind)*2)) = uint16_t(j)
+ *(*uint16_t)(unsafe.Pointer(bp + uintptr(ind)*2)) = uint16_t(j)
}
}
if use_LUT != 0 {
@@ -37348,14 +37050,14 @@ func ApplyPalette(tls *libc.TLS, src uintptr, src_stride uint32_t, dst uintptr,
}
if i == 0 {
- for ok1 := true; ok1; ok1 = (0 != 0) {
+ for __ccgo1 := true; __ccgo1; __ccgo1 = 0 != 0 {
var prev_pix uint32_t = *(*uint32_t)(unsafe.Pointer(palette))
var prev_idx uint32_t = uint32_t(0)
for y = 0; y < height; y++ {
for x = 0; x < width; x++ {
var pix uint32_t = *(*uint32_t)(unsafe.Pointer(src + uintptr(x)*4))
if pix != prev_pix {
- prev_idx = uint32_t(*(*uint16_t)(unsafe.Pointer((bp) /* &buffer[0] */ + uintptr(ApplyPaletteHash0(tls, pix))*2)))
+ prev_idx = uint32_t(*(*uint16_t)(unsafe.Pointer(bp + uintptr(ApplyPaletteHash0(tls, pix))*2)))
prev_pix = pix
}
*(*uint8_t)(unsafe.Pointer(tmp_row + uintptr(x))) = uint8_t(prev_idx)
@@ -37363,19 +37065,19 @@ func ApplyPalette(tls *libc.TLS, src uintptr, src_stride uint32_t, dst uintptr,
(*struct {
f func(*libc.TLS, uintptr, int32, int32, uintptr)
})(unsafe.Pointer(&struct{ uintptr }{VP8LBundleColorMap})).f(tls, tmp_row, width, xbits, dst)
- src += 4 * (uintptr(src_stride))
- dst += 4 * (uintptr(dst_stride))
+ src += 4 * uintptr(src_stride)
+ dst += 4 * uintptr(dst_stride)
}
}
} else if i == 1 {
- for ok2 := true; ok2; ok2 = (0 != 0) {
+ for __ccgo2 := true; __ccgo2; __ccgo2 = 0 != 0 {
var prev_pix uint32_t = *(*uint32_t)(unsafe.Pointer(palette))
var prev_idx uint32_t = uint32_t(0)
for y = 0; y < height; y++ {
for x = 0; x < width; x++ {
var pix uint32_t = *(*uint32_t)(unsafe.Pointer(src + uintptr(x)*4))
if pix != prev_pix {
- prev_idx = uint32_t(*(*uint16_t)(unsafe.Pointer((bp) /* &buffer[0] */ + uintptr(ApplyPaletteHash1(tls, pix))*2)))
+ prev_idx = uint32_t(*(*uint16_t)(unsafe.Pointer(bp + uintptr(ApplyPaletteHash1(tls, pix))*2)))
prev_pix = pix
}
*(*uint8_t)(unsafe.Pointer(tmp_row + uintptr(x))) = uint8_t(prev_idx)
@@ -37383,19 +37085,19 @@ func ApplyPalette(tls *libc.TLS, src uintptr, src_stride uint32_t, dst uintptr,
(*struct {
f func(*libc.TLS, uintptr, int32, int32, uintptr)
})(unsafe.Pointer(&struct{ uintptr }{VP8LBundleColorMap})).f(tls, tmp_row, width, xbits, dst)
- src += 4 * (uintptr(src_stride))
- dst += 4 * (uintptr(dst_stride))
+ src += 4 * uintptr(src_stride)
+ dst += 4 * uintptr(dst_stride)
}
}
} else if i == 2 {
- for ok3 := true; ok3; ok3 = (0 != 0) {
+ for __ccgo3 := true; __ccgo3; __ccgo3 = 0 != 0 {
var prev_pix uint32_t = *(*uint32_t)(unsafe.Pointer(palette))
var prev_idx uint32_t = uint32_t(0)
for y = 0; y < height; y++ {
for x = 0; x < width; x++ {
var pix uint32_t = *(*uint32_t)(unsafe.Pointer(src + uintptr(x)*4))
if pix != prev_pix {
- prev_idx = uint32_t(*(*uint16_t)(unsafe.Pointer((bp) /* &buffer[0] */ + uintptr(ApplyPaletteHash2(tls, pix))*2)))
+ prev_idx = uint32_t(*(*uint16_t)(unsafe.Pointer(bp + uintptr(ApplyPaletteHash2(tls, pix))*2)))
prev_pix = pix
}
*(*uint8_t)(unsafe.Pointer(tmp_row + uintptr(x))) = uint8_t(prev_idx)
@@ -37403,8 +37105,8 @@ func ApplyPalette(tls *libc.TLS, src uintptr, src_stride uint32_t, dst uintptr,
(*struct {
f func(*libc.TLS, uintptr, int32, int32, uintptr)
})(unsafe.Pointer(&struct{ uintptr }{VP8LBundleColorMap})).f(tls, tmp_row, width, xbits, dst)
- src += 4 * (uintptr(src_stride))
- dst += 4 * (uintptr(dst_stride))
+ src += 4 * uintptr(src_stride)
+ dst += 4 * uintptr(dst_stride)
}
}
} else {
@@ -37412,15 +37114,15 @@ func ApplyPalette(tls *libc.TLS, src uintptr, src_stride uint32_t, dst uintptr,
// var palette_sorted [256]uint32_t at bp+4120, 1024
- PrepareMapToPalette(tls, palette, uint32(palette_size), (bp + 4120) /* &palette_sorted[0] */, (bp + 5144) /* &idx_map[0] */)
- for ok4 := true; ok4; ok4 = (0 != 0) {
+ PrepareMapToPalette(tls, palette, uint32(palette_size), bp+4120, bp+5144)
+ for __ccgo4 := true; __ccgo4; __ccgo4 = 0 != 0 {
var prev_pix uint32_t = *(*uint32_t)(unsafe.Pointer(palette))
var prev_idx uint32_t = uint32_t(0)
for y = 0; y < height; y++ {
for x = 0; x < width; x++ {
var pix uint32_t = *(*uint32_t)(unsafe.Pointer(src + uintptr(x)*4))
if pix != prev_pix {
- prev_idx = *(*uint32_t)(unsafe.Pointer((bp + 5144) /* &idx_map[0] */ + uintptr(SearchColorNoIdx(tls, (bp+4120) /* &palette_sorted[0] */, pix, palette_size))*4))
+ prev_idx = *(*uint32_t)(unsafe.Pointer(bp + 5144 + uintptr(SearchColorNoIdx(tls, bp+4120, pix, palette_size))*4))
prev_pix = pix
}
*(*uint8_t)(unsafe.Pointer(tmp_row + uintptr(x))) = uint8_t(prev_idx)
@@ -37428,8 +37130,8 @@ func ApplyPalette(tls *libc.TLS, src uintptr, src_stride uint32_t, dst uintptr,
(*struct {
f func(*libc.TLS, uintptr, int32, int32, uintptr)
})(unsafe.Pointer(&struct{ uintptr }{VP8LBundleColorMap})).f(tls, tmp_row, width, xbits, dst)
- src += 4 * (uintptr(src_stride))
- dst += 4 * (uintptr(dst_stride))
+ src += 4 * uintptr(src_stride)
+ dst += 4 * uintptr(dst_stride)
}
}
}
@@ -37501,13 +37203,13 @@ func EncodePalette(tls *libc.TLS, bw uintptr, low_effort int32, enc uintptr) Web
VP8LPutBits(tls, bw, uint32(1), 1)
VP8LPutBits(tls, bw, COLOR_INDEXING_TRANSFORM, 2)
- VP8LPutBits(tls, bw, (uint32(palette_size - 1)), 8)
- for i = (palette_size - 1); i >= 1; i-- {
- *(*uint32_t)(unsafe.Pointer((bp) /* &tmp_palette[0] */ + uintptr(i)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(palette + uintptr(i)*4)), *(*uint32_t)(unsafe.Pointer(palette + uintptr((i-1))*4)))
+ VP8LPutBits(tls, bw, uint32(palette_size-1), 8)
+ for i = palette_size - 1; i >= 1; i-- {
+ *(*uint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) = VP8LSubPixels(tls, *(*uint32_t)(unsafe.Pointer(palette + uintptr(i)*4)), *(*uint32_t)(unsafe.Pointer(palette + uintptr(i-1)*4)))
}
- *(*uint32_t)(unsafe.Pointer((bp) /* &tmp_palette[0] */)) = *(*uint32_t)(unsafe.Pointer(palette))
- return EncodeImageNoHuffman(tls, bw, (bp) /* &tmp_palette[0] */, (enc + 2312 /* &.hash_chain_ */),
- (enc + 2152 /* &.refs_ */), palette_size, 1 /*quality=*/, 20,
+ *(*uint32_t)(unsafe.Pointer(bp)) = *(*uint32_t)(unsafe.Pointer(palette))
+ return EncodeImageNoHuffman(tls, bw, bp, enc+2312,
+ enc+2152, palette_size, 1 /*quality=*/, 20,
low_effort)
}
@@ -37516,9 +37218,9 @@ func EncodePalette(tls *libc.TLS, bw uintptr, low_effort int32, enc uintptr) Web
func VP8LEncoderNew(tls *libc.TLS, config uintptr, picture uintptr) uintptr { /* vp8l_enc.c:1677:19: */
var enc uintptr = WebPSafeCalloc(tls, 1, uint64(unsafe.Sizeof(VP8LEncoder{})))
- if enc == (uintptr(0)) {
+ if enc == uintptr(0) {
WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_OUT_OF_MEMORY)
- return (uintptr(0))
+ return uintptr(0)
}
(*VP8LEncoder)(unsafe.Pointer(enc)).config_ = config
(*VP8LEncoder)(unsafe.Pointer(enc)).pic_ = picture
@@ -37530,11 +37232,11 @@ func VP8LEncoderNew(tls *libc.TLS, config uintptr, picture uintptr) uintptr { /*
}
func VP8LEncoderDelete(tls *libc.TLS, enc uintptr) { /* vp8l_enc.c:1693:13: */
- if enc != (uintptr(0)) {
+ if enc != uintptr(0) {
var i int32
- VP8LHashChainClear(tls, (enc + 2312 /* &.hash_chain_ */))
+ VP8LHashChainClear(tls, enc+2312)
for i = 0; i < 4; i++ {
- VP8LBackwardRefsClear(tls, ((enc + 2152 /* &.refs_ */) + uintptr(i)*40))
+ VP8LBackwardRefsClear(tls, enc+2152+uintptr(i)*40)
}
ClearTransformBuffer(tls, enc)
WebPSafeFree(tls, enc)
@@ -37602,7 +37304,7 @@ func EncodeStreamHook(tls *libc.TLS, input uintptr, data2 uintptr) int32 { /* vp
stats = (*StreamEncodeContext)(unsafe.Pointer(params)).stats_
err = VP8_ENC_OK
quality = libc.Int32FromFloat32((*WebPConfig)(unsafe.Pointer(config)).quality)
- low_effort = (libc.Bool32((*WebPConfig)(unsafe.Pointer(config)).method == 0))
+ low_effort = libc.Bool32((*WebPConfig)(unsafe.Pointer(config)).method == 0)
width = (*WebPPicture)(unsafe.Pointer(picture)).width
height = (*WebPPicture)(unsafe.Pointer(picture)).height
byte_position = VP8LBitWriterNumBytes(tls, bw)
@@ -37614,7 +37316,7 @@ func EncodeStreamHook(tls *libc.TLS, input uintptr, data2 uintptr) int32 { /* vp
*(*VP8LBitWriter)(unsafe.Pointer(bp + 56 /* bw_init */)) = *(*VP8LBitWriter)(unsafe.Pointer(bw))
_ = data2
- if !(!(VP8LBitWriterInit(tls, (bp) /* &bw_best */, uint64(0)) != 0) || ((num_crunch_configs > 1) && !(VP8LBitWriterClone(tls, bw, (bp) /* &bw_best */) != 0))) {
+ if !(!(VP8LBitWriterInit(tls, bp, uint64(0)) != 0) || num_crunch_configs > 1 && !(VP8LBitWriterClone(tls, bw, bp) != 0)) {
goto __1
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -37628,11 +37330,11 @@ __2:
goto __4
}
entropy_idx = (*CrunchConfig)(unsafe.Pointer(crunch_configs + uintptr(idx)*28)).entropy_idx_
- (*VP8LEncoder)(unsafe.Pointer(enc)).use_palette_ = (libc.Bool32((entropy_idx == kPalette) || (entropy_idx == kPaletteAndSpatial)))
- (*VP8LEncoder)(unsafe.Pointer(enc)).use_subtract_green_ = (libc.Bool32((entropy_idx == kSubGreen) || (entropy_idx == kSpatialSubGreen)))
- (*VP8LEncoder)(unsafe.Pointer(enc)).use_predict_ = (libc.Bool32(((entropy_idx == kSpatial) || (entropy_idx == kSpatialSubGreen)) || (entropy_idx == kPaletteAndSpatial)))
+ (*VP8LEncoder)(unsafe.Pointer(enc)).use_palette_ = libc.Bool32(entropy_idx == kPalette || entropy_idx == kPaletteAndSpatial)
+ (*VP8LEncoder)(unsafe.Pointer(enc)).use_subtract_green_ = libc.Bool32(entropy_idx == kSubGreen || entropy_idx == kSpatialSubGreen)
+ (*VP8LEncoder)(unsafe.Pointer(enc)).use_predict_ = libc.Bool32(entropy_idx == kSpatial || entropy_idx == kSpatialSubGreen || entropy_idx == kPaletteAndSpatial)
// When using a palette, R/B==0, hence no need to test for cross-color.
- if !((low_effort != 0) || ((*VP8LEncoder)(unsafe.Pointer(enc)).use_palette_ != 0)) {
+ if !(low_effort != 0 || (*VP8LEncoder)(unsafe.Pointer(enc)).use_palette_ != 0) {
goto __5
}
(*VP8LEncoder)(unsafe.Pointer(enc)).use_cross_color_ = 0
@@ -37648,11 +37350,11 @@ __6:
;
// Reset any parameter in the encoder that is set in the previous iteration.
(*VP8LEncoder)(unsafe.Pointer(enc)).cache_bits_ = 0
- VP8LBackwardRefsClear(tls, (enc + 2152 /* &.refs_ */))
- VP8LBackwardRefsClear(tls, ((enc + 2152 /* &.refs_ */) + 1*40))
+ VP8LBackwardRefsClear(tls, enc+2152)
+ VP8LBackwardRefsClear(tls, enc+2152+1*40)
// Apply near-lossless preprocessing.
- use_near_lossless = (libc.Bool32((((*WebPConfig)(unsafe.Pointer(config)).near_lossless < 100) && !((*VP8LEncoder)(unsafe.Pointer(enc)).use_palette_ != 0)) && !((*VP8LEncoder)(unsafe.Pointer(enc)).use_predict_ != 0)))
+ use_near_lossless = libc.Bool32((*WebPConfig)(unsafe.Pointer(config)).near_lossless < 100 && !((*VP8LEncoder)(unsafe.Pointer(enc)).use_palette_ != 0) && !((*VP8LEncoder)(unsafe.Pointer(enc)).use_predict_ != 0))
if !(use_near_lossless != 0) {
goto __7
}
@@ -37663,7 +37365,7 @@ __6:
goto Error
__9:
;
- if !(((*VP8LEncoder)(unsafe.Pointer(enc)).argb_content_ != kEncoderNearLossless) && !(VP8ApplyNearLossless(tls, picture, (*WebPConfig)(unsafe.Pointer(config)).near_lossless, (*VP8LEncoder)(unsafe.Pointer(enc)).argb_) != 0)) {
+ if !((*VP8LEncoder)(unsafe.Pointer(enc)).argb_content_ != kEncoderNearLossless && !(VP8ApplyNearLossless(tls, picture, (*WebPConfig)(unsafe.Pointer(config)).near_lossless, (*VP8LEncoder)(unsafe.Pointer(enc)).argb_) != 0)) {
goto __10
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -37685,20 +37387,20 @@ __8:
goto __12
}
// Nothing to do, we have already sorted the palette.
- libc.Xmemcpy(tls, (enc + 100 /* &.palette_ */), (enc + 1124 /* &.palette_sorted_ */),
- (uint64((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_) * uint64(unsafe.Sizeof(uint32_t(0)))))
+ libc.Xmemcpy(tls, enc+100, enc+1124,
+ uint64((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_)*uint64(unsafe.Sizeof(uint32_t(0))))
goto __13
__12:
if !((*CrunchConfig)(unsafe.Pointer(crunch_configs+uintptr(idx)*28)).palette_sorting_type_ == kMinimizeDelta) {
goto __14
}
- PaletteSortMinimizeDeltas(tls, (enc + 1124 /* &.palette_sorted_ */), (*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_,
- (enc + 100 /* &.palette_ */))
+ PaletteSortMinimizeDeltas(tls, enc+1124, (*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_,
+ enc+100)
goto __15
__14:
;
- err = PaletteSortModifiedZeng(tls, (*VP8LEncoder)(unsafe.Pointer(enc)).pic_, (enc + 1124 /* &.palette_sorted_ */),
- uint32((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_), (enc + 100 /* &.palette_ */))
+ err = PaletteSortModifiedZeng(tls, (*VP8LEncoder)(unsafe.Pointer(enc)).pic_, enc+1124,
+ uint32((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_), enc+100)
if !(err != VP8_ENC_OK) {
goto __16
}
@@ -37725,19 +37427,19 @@ __18:
;
// If using a color cache, do not have it bigger than the number of
// colors.
- if !((use_cache != 0) && ((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_ < (int32(1) << 10))) {
+ if !(use_cache != 0 && (*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_ < int32(1)<<10) {
goto __19
}
- (*VP8LEncoder)(unsafe.Pointer(enc)).cache_bits_ = (BitsLog2Floor(tls, uint32((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_)) + 1)
+ (*VP8LEncoder)(unsafe.Pointer(enc)).cache_bits_ = BitsLog2Floor(tls, uint32((*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_)) + 1
__19:
;
__11:
;
- if !(!(use_delta_palette != 0)) {
+ if !!(use_delta_palette != 0) {
goto __20
}
// In case image is not packed.
- if !(((*VP8LEncoder)(unsafe.Pointer(enc)).argb_content_ != kEncoderNearLossless) && ((*VP8LEncoder)(unsafe.Pointer(enc)).argb_content_ != kEncoderPalette)) {
+ if !((*VP8LEncoder)(unsafe.Pointer(enc)).argb_content_ != kEncoderNearLossless && (*VP8LEncoder)(unsafe.Pointer(enc)).argb_content_ != kEncoderPalette) {
goto __21
}
err = MakeInputImageCopy(tls, enc)
@@ -37794,11 +37496,11 @@ __20:
// -------------------------------------------------------------------------
// Encode and write the transformed image.
- err = EncodeImageInternal(tls, bw, (*VP8LEncoder)(unsafe.Pointer(enc)).argb_, (enc + 2312 /* &.hash_chain_ */), (enc + 2152 /* &.refs_ */),
+ err = EncodeImageInternal(tls, bw, (*VP8LEncoder)(unsafe.Pointer(enc)).argb_, enc+2312, enc+2152,
(*VP8LEncoder)(unsafe.Pointer(enc)).current_width_, height, quality, low_effort,
- use_cache, (crunch_configs + uintptr(idx)*28),
- (enc + 76 /* &.cache_bits_ */), (*VP8LEncoder)(unsafe.Pointer(enc)).histo_bits_,
- byte_position, (bp + 48) /* &hdr_size */, (bp + 52) /* &data_size */)
+ use_cache, crunch_configs+uintptr(idx)*28,
+ enc+76, (*VP8LEncoder)(unsafe.Pointer(enc)).histo_bits_,
+ byte_position, bp+48, bp+52)
if !(err != VP8_ENC_OK) {
goto __28
}
@@ -37812,41 +37514,41 @@ __28:
}
best_size = VP8LBitWriterNumBytes(tls, bw)
// Store the BitWriter.
- VP8LBitWriterSwap(tls, bw, (bp) /* &bw_best */)
+ VP8LBitWriterSwap(tls, bw, bp)
// Update the stats.
- if !(stats != (uintptr(0))) {
+ if !(stats != uintptr(0)) {
goto __30
}
(*WebPAuxStats)(unsafe.Pointer(stats)).lossless_features = uint32_t(0)
if !((*VP8LEncoder)(unsafe.Pointer(enc)).use_predict_ != 0) {
goto __31
}
- *(*uint32_t)(unsafe.Pointer((stats + 148 /* &.lossless_features */))) |= (uint32_t(1))
+ *(*uint32_t)(unsafe.Pointer(stats + 148)) |= uint32_t(1)
__31:
;
if !((*VP8LEncoder)(unsafe.Pointer(enc)).use_cross_color_ != 0) {
goto __32
}
- *(*uint32_t)(unsafe.Pointer((stats + 148 /* &.lossless_features */))) |= (uint32_t(2))
+ *(*uint32_t)(unsafe.Pointer(stats + 148)) |= uint32_t(2)
__32:
;
if !((*VP8LEncoder)(unsafe.Pointer(enc)).use_subtract_green_ != 0) {
goto __33
}
- *(*uint32_t)(unsafe.Pointer((stats + 148 /* &.lossless_features */))) |= (uint32_t(4))
+ *(*uint32_t)(unsafe.Pointer(stats + 148)) |= uint32_t(4)
__33:
;
if !((*VP8LEncoder)(unsafe.Pointer(enc)).use_palette_ != 0) {
goto __34
}
- *(*uint32_t)(unsafe.Pointer((stats + 148 /* &.lossless_features */))) |= (uint32_t(8))
+ *(*uint32_t)(unsafe.Pointer(stats + 148)) |= uint32_t(8)
__34:
;
(*WebPAuxStats)(unsafe.Pointer(stats)).histogram_bits = (*VP8LEncoder)(unsafe.Pointer(enc)).histo_bits_
(*WebPAuxStats)(unsafe.Pointer(stats)).transform_bits = (*VP8LEncoder)(unsafe.Pointer(enc)).transform_bits_
(*WebPAuxStats)(unsafe.Pointer(stats)).cache_bits = (*VP8LEncoder)(unsafe.Pointer(enc)).cache_bits_
(*WebPAuxStats)(unsafe.Pointer(stats)).palette_size = (*VP8LEncoder)(unsafe.Pointer(enc)).palette_size_
- (*WebPAuxStats)(unsafe.Pointer(stats)).lossless_size = (int32(best_size - byte_position))
+ (*WebPAuxStats)(unsafe.Pointer(stats)).lossless_size = int32(best_size - byte_position)
(*WebPAuxStats)(unsafe.Pointer(stats)).lossless_hdr_size = *(*int32)(unsafe.Pointer(bp + 48 /* hdr_size */))
(*WebPAuxStats)(unsafe.Pointer(stats)).lossless_data_size = *(*int32)(unsafe.Pointer(bp + 52 /* data_size */))
__30:
@@ -37857,7 +37559,7 @@ __29:
if !(num_crunch_configs > 1) {
goto __35
}
- VP8LBitWriterReset(tls, (bp + 56) /* &bw_init */, bw)
+ VP8LBitWriterReset(tls, bp+56, bw)
__35:
;
goto __3
@@ -37867,13 +37569,13 @@ __3:
goto __4
__4:
;
- VP8LBitWriterSwap(tls, (bp) /* &bw_best */, bw)
+ VP8LBitWriterSwap(tls, bp, bw)
Error:
- VP8LBitWriterWipeOut(tls, (bp) /* &bw_best */)
+ VP8LBitWriterWipeOut(tls, bp)
(*StreamEncodeContext)(unsafe.Pointer(params)).err_ = err
// The hook should return false in case of error.
- return (libc.Bool32(err == VP8_ENC_OK))
+ return libc.Bool32(err == VP8_ENC_OK)
}
func VP8LEncodeStream(tls *libc.TLS, config uintptr, picture uintptr, bw_main uintptr, use_cache int32) WebPEncodingError { /* vp8l_enc.c:1896:19: */
@@ -37914,14 +37616,14 @@ func VP8LEncodeStream(tls *libc.TLS, config uintptr, picture uintptr, bw_main ui
var ok_side int32
err = VP8_ENC_OK
enc_main = VP8LEncoderNew(tls, config, picture)
- enc_side = (uintptr(0))
+ enc_side = uintptr(0)
num_crunch_configs_side = 0
*(*int32)(unsafe.Pointer(bp + 228 /* red_and_blue_always_zero */)) = 0
worker_interface = WebPGetWorkerInterface(tls)
// Analyze image (entropy, num_palettes etc)
- if !((((enc_main == (uintptr(0))) || !(EncoderAnalyze(tls, enc_main, (bp) /* &crunch_configs[0] */, (bp+224), /* &num_crunch_configs_main */
- (bp+228) /* &red_and_blue_always_zero */) != 0)) || !(EncoderInit(tls, enc_main) != 0)) || !(VP8LBitWriterInit(tls, (bp+232) /* &bw_side */, uint64(0)) != 0)) {
+ if !(enc_main == uintptr(0) || !(EncoderAnalyze(tls, enc_main, bp, bp+224,
+ bp+228) != 0) || !(EncoderInit(tls, enc_main) != 0) || !(VP8LBitWriterInit(tls, bp+232, uint64(0)) != 0)) {
goto __1
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -37933,13 +37635,13 @@ __1:
if !((*WebPConfig)(unsafe.Pointer(config)).thread_level > 0) {
goto __2
}
- num_crunch_configs_side = (*(*int32)(unsafe.Pointer(bp + 224 /* num_crunch_configs_main */)) / 2)
+ num_crunch_configs_side = *(*int32)(unsafe.Pointer(bp + 224)) / 2
idx = 0
__3:
if !(idx < num_crunch_configs_side) {
goto __5
}
- *(*CrunchConfig)(unsafe.Pointer(((bp + 280) /* ¶ms_side */ + 36 /* &.crunch_configs_ */) + uintptr(idx)*28)) = *(*CrunchConfig)(unsafe.Pointer((bp) /* &crunch_configs[0] */ + uintptr(((*(*int32)(unsafe.Pointer(bp + 224 /* num_crunch_configs_main */))-num_crunch_configs_side)+idx))*28))
+ *(*CrunchConfig)(unsafe.Pointer(bp + 280 + 36 + uintptr(idx)*28)) = *(*CrunchConfig)(unsafe.Pointer(bp + uintptr(*(*int32)(unsafe.Pointer(bp + 224))-num_crunch_configs_side+idx)*28))
goto __4
__4:
idx++
@@ -37953,10 +37655,10 @@ __2:
*(*int32)(unsafe.Pointer(bp + 224 /* num_crunch_configs_main */)) -= num_crunch_configs_side
idx = 0
__6:
- if !(idx < *(*int32)(unsafe.Pointer(bp + 224 /* num_crunch_configs_main */))) {
+ if !(idx < *(*int32)(unsafe.Pointer(bp + 224))) {
goto __8
}
- *(*CrunchConfig)(unsafe.Pointer(((bp + 560) /* ¶ms_main */ + 36 /* &.crunch_configs_ */) + uintptr(idx)*28)) = *(*CrunchConfig)(unsafe.Pointer((bp) /* &crunch_configs[0] */ + uintptr(idx)*28))
+ *(*CrunchConfig)(unsafe.Pointer(bp + 560 + 36 + uintptr(idx)*28)) = *(*CrunchConfig)(unsafe.Pointer(bp + uintptr(idx)*28))
goto __7
__7:
idx++
@@ -37980,14 +37682,14 @@ __9:
}
// Create the parameters for each worker.
if idx == 0 {
- worker = (bp + 840) /* &worker_main */
+ worker = bp + 840 /* &worker_main */
} else {
- worker = (bp + 888) /* &worker_side */
+ worker = bp + 888 /* &worker_side */
}
if idx == 0 {
- param = (bp + 560) /* ¶ms_main */
+ param = bp + 560 /* ¶ms_main */
} else {
- param = (bp + 280) /* ¶ms_side */
+ param = bp + 280 /* ¶ms_side */
}
(*StreamEncodeContext)(unsafe.Pointer(param)).config_ = config
(*StreamEncodeContext)(unsafe.Pointer(param)).picture_ = picture
@@ -38002,23 +37704,23 @@ __9:
goto __13
__12:
(*StreamEncodeContext)(unsafe.Pointer(param)).stats_ = func() uintptr {
- if (*WebPPicture)(unsafe.Pointer(picture)).stats == (uintptr(0)) {
- return (uintptr(0))
+ if (*WebPPicture)(unsafe.Pointer(picture)).stats == uintptr(0) {
+ return uintptr(0)
}
- return (bp + 936) /* &stats_side */
+ return bp + 936 /* &stats_side */
}()
// Create a side bit writer.
- if !(!(VP8LBitWriterClone(tls, bw_main, (bp+232) /* &bw_side */) != 0)) {
+ if !!(VP8LBitWriterClone(tls, bw_main, bp+232) != 0) {
goto __14
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
goto Error
__14:
;
- (*StreamEncodeContext)(unsafe.Pointer(param)).bw_ = (bp + 232) /* &bw_side */
+ (*StreamEncodeContext)(unsafe.Pointer(param)).bw_ = bp + 232 /* &bw_side */
// Create a side encoder.
enc_side = VP8LEncoderNew(tls, config, picture)
- if !((enc_side == (uintptr(0))) || !(EncoderInit(tls, enc_side) != 0)) {
+ if !(enc_side == uintptr(0) || !(EncoderInit(tls, enc_side) != 0)) {
goto __15
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -38029,9 +37731,9 @@ __15:
(*VP8LEncoder)(unsafe.Pointer(enc_side)).histo_bits_ = (*VP8LEncoder)(unsafe.Pointer(enc_main)).histo_bits_
(*VP8LEncoder)(unsafe.Pointer(enc_side)).transform_bits_ = (*VP8LEncoder)(unsafe.Pointer(enc_main)).transform_bits_
(*VP8LEncoder)(unsafe.Pointer(enc_side)).palette_size_ = (*VP8LEncoder)(unsafe.Pointer(enc_main)).palette_size_
- libc.Xmemcpy(tls, (enc_side + 100 /* &.palette_ */), (enc_main + 100 /* &.palette_ */),
+ libc.Xmemcpy(tls, enc_side+100, enc_main+100,
uint64(unsafe.Sizeof([256]uint32_t{})))
- libc.Xmemcpy(tls, (enc_side + 1124 /* &.palette_sorted_ */), (enc_main + 1124 /* &.palette_sorted_ */),
+ libc.Xmemcpy(tls, enc_side+1124, enc_main+1124,
uint64(unsafe.Sizeof([256]uint32_t{})))
(*StreamEncodeContext)(unsafe.Pointer(param)).enc_ = enc_side
__13:
@@ -38039,7 +37741,7 @@ __13:
// Create the workers.
(*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Init})).f(tls, worker)
(*WebPWorker)(unsafe.Pointer(worker)).data1 = param
- (*WebPWorker)(unsafe.Pointer(worker)).data2 = (uintptr(0))
+ (*WebPWorker)(unsafe.Pointer(worker)).data2 = uintptr(0)
(*WebPWorker)(unsafe.Pointer(worker)).hook = *(*uintptr)(unsafe.Pointer(&struct {
f func(*libc.TLS, uintptr, uintptr) int32
}{EncodeStreamHook}))
@@ -38055,9 +37757,9 @@ __11:
if !(num_crunch_configs_side != 0) {
goto __16
}
- if !(!((*struct {
+ if !!((*struct {
f func(*libc.TLS, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Reset})).f(tls, (bp+888) /* &worker_side */) != 0)) {
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Reset})).f(tls, bp+888) != 0) {
goto __17
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -38066,31 +37768,31 @@ __17:
;
// This line is here and not in the param initialization above to remove a
// Clang static analyzer warning.
- if !((*WebPPicture)(unsafe.Pointer(picture)).stats != (uintptr(0))) {
+ if !((*WebPPicture)(unsafe.Pointer(picture)).stats != uintptr(0)) {
goto __18
}
- libc.Xmemcpy(tls, (bp + 936) /* &stats_side */, (*WebPPicture)(unsafe.Pointer(picture)).stats, uint64(unsafe.Sizeof(WebPAuxStats{})))
+ libc.Xmemcpy(tls, bp+936, (*WebPPicture)(unsafe.Pointer(picture)).stats, uint64(unsafe.Sizeof(WebPAuxStats{})))
__18:
;
// This line is only useful to remove a Clang static analyzer warning.
(*StreamEncodeContext)(unsafe.Pointer(bp + 280 /* ¶ms_side */)).err_ = VP8_ENC_OK
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Launch})).f(tls, (bp + 888) /* &worker_side */)
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Launch})).f(tls, bp+888 /* &worker_side */)
__16:
;
// Execute the main thread.
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Execute})).f(tls, (bp + 840) /* &worker_main */)
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Execute})).f(tls, bp+840 /* &worker_main */)
ok_main = (*struct {
f func(*libc.TLS, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Sync})).f(tls, (bp + 840) /* &worker_main */)
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).End})).f(tls, (bp + 840) /* &worker_main */)
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Sync})).f(tls, bp+840 /* &worker_main */)
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).End})).f(tls, bp+840 /* &worker_main */)
if !(num_crunch_configs_side != 0) {
goto __19
}
// Wait for the second thread.
ok_side = (*struct {
f func(*libc.TLS, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Sync})).f(tls, (bp + 888) /* &worker_side */)
- (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).End})).f(tls, (bp + 888) /* &worker_side */)
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).Sync})).f(tls, bp+888 /* &worker_side */)
+ (*struct{ f func(*libc.TLS, uintptr) })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).End})).f(tls, bp+888 /* &worker_side */)
if !(!(ok_main != 0) || !(ok_side != 0)) {
goto __21
}
@@ -38102,21 +37804,21 @@ __16:
goto Error
__21:
;
- if !(VP8LBitWriterNumBytes(tls, (bp+232) /* &bw_side */) < VP8LBitWriterNumBytes(tls, bw_main)) {
+ if !(VP8LBitWriterNumBytes(tls, bp+232) < VP8LBitWriterNumBytes(tls, bw_main)) {
goto __22
}
- VP8LBitWriterSwap(tls, bw_main, (bp + 232) /* &bw_side */)
- if !((*WebPPicture)(unsafe.Pointer(picture)).stats != (uintptr(0))) {
+ VP8LBitWriterSwap(tls, bw_main, bp+232)
+ if !((*WebPPicture)(unsafe.Pointer(picture)).stats != uintptr(0)) {
goto __23
}
- libc.Xmemcpy(tls, (*WebPPicture)(unsafe.Pointer(picture)).stats, (bp + 936) /* &stats_side */, uint64(unsafe.Sizeof(WebPAuxStats{})))
+ libc.Xmemcpy(tls, (*WebPPicture)(unsafe.Pointer(picture)).stats, bp+936, uint64(unsafe.Sizeof(WebPAuxStats{})))
__23:
;
__22:
;
goto __20
__19:
- if !(!(ok_main != 0)) {
+ if !!(ok_main != 0) {
goto __24
}
err = (*StreamEncodeContext)(unsafe.Pointer(bp + 560 /* ¶ms_main */)).err_
@@ -38127,7 +37829,7 @@ __20:
;
Error:
- VP8LBitWriterWipeOut(tls, (bp + 232) /* &bw_side */)
+ VP8LBitWriterWipeOut(tls, bp+232)
VP8LEncoderDelete(tls, enc_main)
VP8LEncoderDelete(tls, enc_side)
return err
@@ -38154,14 +37856,14 @@ func VP8LEncodeImage(tls *libc.TLS, config uintptr, picture uintptr) int32 { /*
*(*int32)(unsafe.Pointer(bp + 48 /* percent */)) = 0
err = VP8_ENC_OK
- if !(picture == (uintptr(0))) {
+ if !(picture == uintptr(0)) {
goto __1
}
return 0
__1:
;
- if !((config == (uintptr(0))) || ((*WebPPicture)(unsafe.Pointer(picture)).argb == (uintptr(0)))) {
+ if !(config == uintptr(0) || (*WebPPicture)(unsafe.Pointer(picture)).argb == uintptr(0)) {
goto __2
}
err = VP8_ENC_ERROR_NULL_PARAMETER
@@ -38175,11 +37877,11 @@ __2:
// Initialize BitWriter with size corresponding to 16 bpp to photo images and
// 8 bpp for graphical images.
if (*WebPConfig)(unsafe.Pointer(config)).image_hint == WEBP_HINT_GRAPH {
- initial_size = (width * height)
+ initial_size = width * height
} else {
- initial_size = ((width * height) * 2)
+ initial_size = width * height * 2
}
- if !(!(VP8LBitWriterInit(tls, (bp) /* &bw */, uint64(initial_size)) != 0)) {
+ if !!(VP8LBitWriterInit(tls, bp, uint64(initial_size)) != 0) {
goto __3
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -38187,7 +37889,7 @@ __2:
__3:
;
- if !(!(WebPReportProgress(tls, picture, 1, (bp+48) /* &percent */) != 0)) {
+ if !!(WebPReportProgress(tls, picture, 1, bp+48) != 0) {
goto __4
}
UserAbort:
@@ -38196,21 +37898,21 @@ UserAbort:
__4:
;
// Reset stats (for pure lossless coding)
- if !((*WebPPicture)(unsafe.Pointer(picture)).stats != (uintptr(0))) {
+ if !((*WebPPicture)(unsafe.Pointer(picture)).stats != uintptr(0)) {
goto __5
}
stats = (*WebPPicture)(unsafe.Pointer(picture)).stats
libc.Xmemset(tls, stats, 0, uint64(unsafe.Sizeof(WebPAuxStats{})))
- *(*float32)(unsafe.Pointer((stats + 4 /* &.PSNR */))) = 99.
- *(*float32)(unsafe.Pointer((stats + 4 /* &.PSNR */) + 1*4)) = 99.
- *(*float32)(unsafe.Pointer((stats + 4 /* &.PSNR */) + 2*4)) = 99.
- *(*float32)(unsafe.Pointer((stats + 4 /* &.PSNR */) + 3*4)) = 99.
- *(*float32)(unsafe.Pointer((stats + 4 /* &.PSNR */) + 4*4)) = 99.
+ *(*float32)(unsafe.Pointer(stats + 4)) = 99.
+ *(*float32)(unsafe.Pointer(stats + 4 + 1*4)) = 99.
+ *(*float32)(unsafe.Pointer(stats + 4 + 2*4)) = 99.
+ *(*float32)(unsafe.Pointer(stats + 4 + 3*4)) = 99.
+ *(*float32)(unsafe.Pointer(stats + 4 + 4*4)) = 99.
__5:
;
// Write image size.
- if !(!(WriteImageSize(tls, picture, (bp) /* &bw */) != 0)) {
+ if !!(WriteImageSize(tls, picture, bp) != 0) {
goto __6
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -38220,7 +37922,7 @@ __6:
has_alpha = WebPPictureHasTransparency(tls, picture)
// Write the non-trivial Alpha flag and lossless version.
- if !(!(WriteRealAlphaAndVersion(tls, (bp) /* &bw */, has_alpha) != 0)) {
+ if !!(WriteRealAlphaAndVersion(tls, bp, has_alpha) != 0) {
goto __7
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
@@ -38228,7 +37930,7 @@ __6:
__7:
;
- if !(!(WebPReportProgress(tls, picture, 5, (bp+48) /* &percent */) != 0)) {
+ if !!(WebPReportProgress(tls, picture, 5, bp+48) != 0) {
goto __8
}
goto UserAbort
@@ -38236,7 +37938,7 @@ __8:
;
// Encode main image stream.
- err = VP8LEncodeStream(tls, config, picture, (bp) /* &bw */, 1)
+ err = VP8LEncodeStream(tls, config, picture, bp, 1)
if !(err != VP8_ENC_OK) {
goto __9
}
@@ -38244,7 +37946,7 @@ __8:
__9:
;
- if !(!(WebPReportProgress(tls, picture, 90, (bp+48) /* &percent */) != 0)) {
+ if !!(WebPReportProgress(tls, picture, 90, bp+48) != 0) {
goto __10
}
goto UserAbort
@@ -38252,7 +37954,7 @@ __10:
;
// Finish the RIFF chunk.
- err = WriteImage(tls, picture, (bp) /* &bw */, (bp + 56) /* &coded_size */)
+ err = WriteImage(tls, picture, bp, bp+56)
if !(err != VP8_ENC_OK) {
goto __11
}
@@ -38260,7 +37962,7 @@ __10:
__11:
;
- if !(!(WebPReportProgress(tls, picture, 100, (bp+48) /* &percent */) != 0)) {
+ if !!(WebPReportProgress(tls, picture, 100, bp+48) != 0) {
goto __12
}
goto UserAbort
@@ -38268,31 +37970,31 @@ __12:
;
// Save size.
- if !((*WebPPicture)(unsafe.Pointer(picture)).stats != (uintptr(0))) {
+ if !((*WebPPicture)(unsafe.Pointer(picture)).stats != uintptr(0)) {
goto __13
}
- *(*int32)(unsafe.Pointer(((*WebPPicture)(unsafe.Pointer(picture)).stats /* &.coded_size */))) += (int32(*(*size_t)(unsafe.Pointer(bp + 56 /* coded_size */))))
+ *(*int32)(unsafe.Pointer((*WebPPicture)(unsafe.Pointer(picture)).stats)) += int32(*(*size_t)(unsafe.Pointer(bp + 56)))
(*WebPAuxStats)(unsafe.Pointer((*WebPPicture)(unsafe.Pointer(picture)).stats)).lossless_size = int32(*(*size_t)(unsafe.Pointer(bp + 56 /* coded_size */)))
__13:
;
- if !((*WebPPicture)(unsafe.Pointer(picture)).extra_info != (uintptr(0))) {
+ if !((*WebPPicture)(unsafe.Pointer(picture)).extra_info != uintptr(0)) {
goto __14
}
- mb_w = ((width + 15) >> 4)
- mb_h = ((height + 15) >> 4)
- libc.Xmemset(tls, (*WebPPicture)(unsafe.Pointer(picture)).extra_info, 0, ((uint64(mb_w * mb_h)) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ mb_w = (width + 15) >> 4
+ mb_h = (height + 15) >> 4
+ libc.Xmemset(tls, (*WebPPicture)(unsafe.Pointer(picture)).extra_info, 0, uint64(mb_w*mb_h)*uint64(unsafe.Sizeof(uint8_t(0))))
__14:
;
Error:
- if !((*VP8LBitWriter)(unsafe.Pointer(bp /* &bw */)).error_ != 0) {
+ if !((*VP8LBitWriter)(unsafe.Pointer(bp)).error_ != 0) {
goto __15
}
err = VP8_ENC_ERROR_OUT_OF_MEMORY
__15:
;
- VP8LBitWriterWipeOut(tls, (bp) /* &bw */)
+ VP8LBitWriterWipeOut(tls, bp)
if !(err != VP8_ENC_OK) {
goto __16
}
@@ -38326,7 +38028,7 @@ __16:
//------------------------------------------------------------------------------
func WebPGetEncoderVersion(tls *libc.TLS) int32 { /* webp_enc.c:32:5: */
- return (((int32(1) << 16) | (int32(2) << 8)) | 2)
+ return int32(1)<<16 | int32(2)<<8 | 2
}
//------------------------------------------------------------------------------
@@ -38334,14 +38036,14 @@ func WebPGetEncoderVersion(tls *libc.TLS) int32 { /* webp_enc.c:32:5: */
//------------------------------------------------------------------------------
func ResetSegmentHeader1(tls *libc.TLS, enc uintptr) { /* webp_enc.c:40:13: */
- var hdr uintptr = (enc + 32 /* &.segment_hdr_ */)
+ var hdr uintptr = enc + 32
(*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).num_segments_ = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).config_)).segments
- (*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).update_map_ = (libc.Bool32((*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).num_segments_ > 1))
+ (*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).update_map_ = libc.Bool32((*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).num_segments_ > 1)
(*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).size_ = 0
}
func ResetFilterHeader(tls *libc.TLS, enc uintptr) { /* webp_enc.c:47:13: */
- var hdr uintptr = (enc + 16 /* &.filter_hdr_ */)
+ var hdr uintptr = enc + 16
(*VP8EncFilterHeader)(unsafe.Pointer(hdr)).simple_ = 1
(*VP8EncFilterHeader)(unsafe.Pointer(hdr)).level_ = 0
(*VP8EncFilterHeader)(unsafe.Pointer(hdr)).sharpness_ = 0
@@ -38352,13 +38054,13 @@ func ResetBoundaryPredictions(tls *libc.TLS, enc uintptr) { /* webp_enc.c:55:13:
// init boundary values once for all
// Note: actually, initializing the preds_[] is only needed for intra4.
var i int32
- var top uintptr = ((*VP8Encoder)(unsafe.Pointer(enc)).preds_ - uintptr((*VP8Encoder)(unsafe.Pointer(enc)).preds_w_))
- var left uintptr = ((*VP8Encoder)(unsafe.Pointer(enc)).preds_ - uintptr(1))
- for i = -1; i < (4 * (*VP8Encoder)(unsafe.Pointer(enc)).mb_w_); i++ {
+ var top uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).preds_ - uintptr((*VP8Encoder)(unsafe.Pointer(enc)).preds_w_)
+ var left uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).preds_ - uintptr(1)
+ for i = -1; i < 4*(*VP8Encoder)(unsafe.Pointer(enc)).mb_w_; i++ {
*(*uint8_t)(unsafe.Pointer(top + uintptr(i))) = B_DC_PRED
}
- for i = 0; i < (4 * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_); i++ {
- *(*uint8_t)(unsafe.Pointer(left + uintptr((i * (*VP8Encoder)(unsafe.Pointer(enc)).preds_w_)))) = B_DC_PRED
+ for i = 0; i < 4*(*VP8Encoder)(unsafe.Pointer(enc)).mb_h_; i++ {
+ *(*uint8_t)(unsafe.Pointer(left + uintptr(i*(*VP8Encoder)(unsafe.Pointer(enc)).preds_w_))) = B_DC_PRED
}
*(*uint32_t)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).nz_ + libc.UintptrFromInt32(-1)*4)) = uint32_t(0) // constant
}
@@ -38391,7 +38093,7 @@ func ResetBoundaryPredictions(tls *libc.TLS, enc uintptr) { /* webp_enc.c:55:13:
func MapConfigToTools(tls *libc.TLS, enc uintptr) { /* webp_enc.c:95:13: */
var config uintptr = (*VP8Encoder)(unsafe.Pointer(enc)).config_
var method int32 = (*WebPConfig)(unsafe.Pointer(config)).method
- var limit int32 = (100 - (*WebPConfig)(unsafe.Pointer(config)).partition_limit)
+ var limit int32 = 100 - (*WebPConfig)(unsafe.Pointer(config)).partition_limit
(*VP8Encoder)(unsafe.Pointer(enc)).method_ = method
(*VP8Encoder)(unsafe.Pointer(enc)).rd_opt_level_ = func() uint32 {
if method >= 6 {
@@ -38409,16 +38111,16 @@ func MapConfigToTools(tls *libc.TLS, enc uintptr) { /* webp_enc.c:95:13: */
}()
}()
}()
- (*VP8Encoder)(unsafe.Pointer(enc)).max_i4_header_bits_ = ((((256 * 16) * 16) * (limit * limit)) / (100 * 100)) // ... modulated with a quadratic curve.
+ (*VP8Encoder)(unsafe.Pointer(enc)).max_i4_header_bits_ = 256 * 16 * 16 * (limit * limit) / (100 * 100) // ... modulated with a quadratic curve.
// partition0 = 512k max.
- (*VP8Encoder)(unsafe.Pointer(enc)).mb_header_limit_ = (int32((((int64(256) * int64(510)) * int64(8)) * int64(1024)) / (score_t((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ * (*VP8Encoder)(unsafe.Pointer(enc)).mb_h_))))
+ (*VP8Encoder)(unsafe.Pointer(enc)).mb_header_limit_ = int32(int64(256) * int64(510) * int64(8) * int64(1024) / score_t((*VP8Encoder)(unsafe.Pointer(enc)).mb_w_*(*VP8Encoder)(unsafe.Pointer(enc)).mb_h_))
(*VP8Encoder)(unsafe.Pointer(enc)).thread_level_ = (*WebPConfig)(unsafe.Pointer(config)).thread_level
- (*VP8Encoder)(unsafe.Pointer(enc)).do_search_ = (libc.Bool32(((*WebPConfig)(unsafe.Pointer(config)).target_size > 0) || ((*WebPConfig)(unsafe.Pointer(config)).target_PSNR > float32(0))))
+ (*VP8Encoder)(unsafe.Pointer(enc)).do_search_ = libc.Bool32((*WebPConfig)(unsafe.Pointer(config)).target_size > 0 || (*WebPConfig)(unsafe.Pointer(config)).target_PSNR > float32(0))
if !((*WebPConfig)(unsafe.Pointer(config)).low_memory != 0) {
- (*VP8Encoder)(unsafe.Pointer(enc)).use_tokens_ = (libc.Bool32((*VP8Encoder)(unsafe.Pointer(enc)).rd_opt_level_ >= RD_OPT_BASIC)) // need rd stats
+ (*VP8Encoder)(unsafe.Pointer(enc)).use_tokens_ = libc.Bool32((*VP8Encoder)(unsafe.Pointer(enc)).rd_opt_level_ >= RD_OPT_BASIC) // need rd stats
if (*VP8Encoder)(unsafe.Pointer(enc)).use_tokens_ != 0 {
(*VP8Encoder)(unsafe.Pointer(enc)).num_parts_ = 1 // doesn't work with multi-partition
}
@@ -38446,87 +38148,87 @@ func MapConfigToTools(tls *libc.TLS, enc uintptr) { /* webp_enc.c:95:13: */
func InitVP8Encoder(tls *libc.TLS, config uintptr, picture uintptr) uintptr { /* webp_enc.c:144:18: */
var enc uintptr
- var use_filter int32 = (libc.Bool32(((*WebPConfig)(unsafe.Pointer(config)).filter_strength > 0) || ((*WebPConfig)(unsafe.Pointer(config)).autofilter > 0)))
- var mb_w int32 = (((*WebPPicture)(unsafe.Pointer(picture)).width + 15) >> 4)
- var mb_h int32 = (((*WebPPicture)(unsafe.Pointer(picture)).height + 15) >> 4)
- var preds_w int32 = ((4 * mb_w) + 1)
- var preds_h int32 = ((4 * mb_h) + 1)
- var preds_size size_t = ((uint64(preds_w * preds_h)) * uint64(unsafe.Sizeof(uint8_t(0))))
- var top_stride int32 = (mb_w * 16)
- var nz_size size_t = (((uint64(mb_w + 1)) * uint64(unsafe.Sizeof(uint32_t(0)))) + uint64(31))
- var info_size size_t = ((uint64(mb_w * mb_h)) * uint64(unsafe.Sizeof(VP8MBInfo{})))
- var samples_size size_t = (((uint64(2 * top_stride)) * uint64(unsafe.Sizeof(uint8_t(0)))) + // top-luma/u/v
- uint64(31)) // align all
+ var use_filter int32 = libc.Bool32((*WebPConfig)(unsafe.Pointer(config)).filter_strength > 0 || (*WebPConfig)(unsafe.Pointer(config)).autofilter > 0)
+ var mb_w int32 = ((*WebPPicture)(unsafe.Pointer(picture)).width + 15) >> 4
+ var mb_h int32 = ((*WebPPicture)(unsafe.Pointer(picture)).height + 15) >> 4
+ var preds_w int32 = 4*mb_w + 1
+ var preds_h int32 = 4*mb_h + 1
+ var preds_size size_t = uint64(preds_w*preds_h) * uint64(unsafe.Sizeof(uint8_t(0)))
+ var top_stride int32 = mb_w * 16
+ var nz_size size_t = uint64(mb_w+1)*uint64(unsafe.Sizeof(uint32_t(0))) + uint64(31)
+ var info_size size_t = uint64(mb_w*mb_h) * uint64(unsafe.Sizeof(VP8MBInfo{}))
+ var samples_size size_t = uint64(2*top_stride)*uint64(unsafe.Sizeof(uint8_t(0))) +
+ uint64(31) // align all
var lf_stats_size size_t
if (*WebPConfig)(unsafe.Pointer(config)).autofilter != 0 {
- lf_stats_size = (uint64(unsafe.Sizeof(LFStats{})) + uint64(31))
+ lf_stats_size = uint64(unsafe.Sizeof(LFStats{})) + uint64(31)
} else {
lf_stats_size = uint64(0)
}
var top_derr_size size_t
- if ((*WebPConfig)(unsafe.Pointer(config)).quality <= float32(98)) || ((*WebPConfig)(unsafe.Pointer(config)).pass > 1) {
- top_derr_size = (uint64(mb_w) * uint64(unsafe.Sizeof(DError{})))
+ if (*WebPConfig)(unsafe.Pointer(config)).quality <= float32(98) || (*WebPConfig)(unsafe.Pointer(config)).pass > 1 {
+ top_derr_size = uint64(mb_w) * uint64(unsafe.Sizeof(DError{}))
} else {
top_derr_size = uint64(0)
}
var mem uintptr
- var size uint64_t = (((((((uint64_t(unsafe.Sizeof(VP8Encoder{})) + // main struct
- uint64(31)) + // cache alignment
- info_size) + // modes info
- preds_size) + // prediction modes
- samples_size) + // top/left samples
- top_derr_size) + // top diffusion error
- nz_size) + // coeff context bits
- lf_stats_size) // autofilter stats
+ var size uint64_t = uint64_t(unsafe.Sizeof(VP8Encoder{})) +
+ uint64(31) +
+ info_size +
+ preds_size +
+ samples_size +
+ top_derr_size +
+ nz_size +
+ lf_stats_size // autofilter stats
mem = WebPSafeMalloc(tls, size, uint64(unsafe.Sizeof(uint8_t(0))))
- if mem == (uintptr(0)) {
+ if mem == uintptr(0) {
WebPEncodingSetError(tls, picture, VP8_ENC_ERROR_OUT_OF_MEMORY)
- return (uintptr(0))
+ return uintptr(0)
}
enc = mem
- mem = (uintptr((uintptr_t((mem + uintptr(uint64(unsafe.Sizeof(VP8Encoder{}))))) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
+ mem = uintptr((uintptr_t(mem+uintptr(uint64(unsafe.Sizeof(VP8Encoder{})))) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
libc.Xmemset(tls, enc, 0, uint64(unsafe.Sizeof(VP8Encoder{})))
- (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_ = (int32(1) << (*WebPConfig)(unsafe.Pointer(config)).partitions)
+ (*VP8Encoder)(unsafe.Pointer(enc)).num_parts_ = int32(1) << (*WebPConfig)(unsafe.Pointer(config)).partitions
(*VP8Encoder)(unsafe.Pointer(enc)).mb_w_ = mb_w
(*VP8Encoder)(unsafe.Pointer(enc)).mb_h_ = mb_h
(*VP8Encoder)(unsafe.Pointer(enc)).preds_w_ = preds_w
(*VP8Encoder)(unsafe.Pointer(enc)).mb_info_ = mem
mem += uintptr(info_size)
- (*VP8Encoder)(unsafe.Pointer(enc)).preds_ = ((mem + uintptr(1)) + uintptr((*VP8Encoder)(unsafe.Pointer(enc)).preds_w_))
+ (*VP8Encoder)(unsafe.Pointer(enc)).preds_ = mem + uintptr(1) + uintptr((*VP8Encoder)(unsafe.Pointer(enc)).preds_w_)
mem += uintptr(preds_size)
- (*VP8Encoder)(unsafe.Pointer(enc)).nz_ = (uintptr(1)*4 + (uintptr((uintptr_t((mem)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))))
+ (*VP8Encoder)(unsafe.Pointer(enc)).nz_ = uintptr(1)*4 + uintptr((uintptr_t(mem)+uint64(31))&libc.Uint64FromInt32(libc.CplInt32(31)))
mem += uintptr(nz_size)
(*VP8Encoder)(unsafe.Pointer(enc)).lf_stats_ = func() uintptr {
if lf_stats_size != 0 {
- return (uintptr((uintptr_t((mem)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
+ return uintptr((uintptr_t(mem) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
}
- return (uintptr(0))
+ return uintptr(0)
}()
mem += uintptr(lf_stats_size)
// top samples (all 16-aligned)
- mem = (uintptr((uintptr_t((mem)) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31))))
+ mem = uintptr((uintptr_t(mem) + uint64(31)) & libc.Uint64FromInt32(libc.CplInt32(31)))
(*VP8Encoder)(unsafe.Pointer(enc)).y_top_ = mem
- (*VP8Encoder)(unsafe.Pointer(enc)).uv_top_ = ((*VP8Encoder)(unsafe.Pointer(enc)).y_top_ + uintptr(top_stride))
- mem += (uintptr(2 * top_stride))
+ (*VP8Encoder)(unsafe.Pointer(enc)).uv_top_ = (*VP8Encoder)(unsafe.Pointer(enc)).y_top_ + uintptr(top_stride)
+ mem += uintptr(2 * top_stride)
(*VP8Encoder)(unsafe.Pointer(enc)).top_derr_ = func() uintptr {
if top_derr_size != 0 {
return mem
}
- return (uintptr(0))
+ return uintptr(0)
}()
mem += uintptr(top_derr_size)
(*VP8Encoder)(unsafe.Pointer(enc)).config_ = config
(*VP8Encoder)(unsafe.Pointer(enc)).profile_ = func() int32 {
if use_filter != 0 {
- return (func() int32 {
+ return func() int32 {
if (*WebPConfig)(unsafe.Pointer(config)).filter_type == 1 {
return 0
}
return 1
- }())
+ }()
}
return 2
}()
@@ -38545,8 +38247,8 @@ func InitVP8Encoder(tls *libc.TLS, config uintptr, picture uintptr) uintptr { /*
// lower quality means smaller output -> we modulate a little the page
// size based on quality. This is just a crude 1rst-order prediction.
{
- var scale float32 = (1. + (((*WebPConfig)(unsafe.Pointer(config)).quality * 5.) / 100.)) // in [1,6]
- VP8TBufferInit(tls, (enc + 496 /* &.tokens_ */), (libc.Int32FromFloat32((float32((mb_w * mb_h) * 4)) * scale)))
+ var scale float32 = 1. + (*WebPConfig)(unsafe.Pointer(config)).quality*5./100. // in [1,6]
+ VP8TBufferInit(tls, enc+496, libc.Int32FromFloat32(float32(mb_w*mb_h*4)*scale))
}
return enc
@@ -38554,9 +38256,9 @@ func InitVP8Encoder(tls *libc.TLS, config uintptr, picture uintptr) uintptr { /*
func DeleteVP8Encoder(tls *libc.TLS, enc uintptr) int32 { /* webp_enc.c:254:12: */
var ok int32 = 1
- if enc != (uintptr(0)) {
+ if enc != uintptr(0) {
ok = VP8EncDeleteAlpha(tls, enc)
- VP8TBufferClear(tls, (enc + 496 /* &.tokens_ */))
+ VP8TBufferClear(tls, enc+496)
WebPSafeFree(tls, enc)
}
return ok
@@ -38565,8 +38267,8 @@ func DeleteVP8Encoder(tls *libc.TLS, enc uintptr) int32 { /* webp_enc.c:254:12:
//------------------------------------------------------------------------------
func GetPSNR2(tls *libc.TLS, err uint64_t, size uint64_t) float64 { /* webp_enc.c:267:15: */
- if (err > uint64(0)) && (size > uint64(0)) {
- return (10. * libc.Xlog10(tls, (((float64(255.)*255.)*float64(size))/float64(err))))
+ if err > uint64(0) && size > uint64(0) {
+ return 10. * libc.Xlog10(tls, float64(255.)*255.*float64(size)/float64(err))
}
return 99.
}
@@ -38575,43 +38277,43 @@ func FinalizePSNR(tls *libc.TLS, enc uintptr) { /* webp_enc.c:271:13: */
var stats uintptr = (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats
var size uint64_t = (*VP8Encoder)(unsafe.Pointer(enc)).sse_count_
var sse uintptr = enc + 23512 /* &.sse_ */
- *(*float32)(unsafe.Pointer((stats + 4 /* &.PSNR */))) = float32(GetPSNR2(tls, *(*uint64_t)(unsafe.Pointer(sse)), size))
- *(*float32)(unsafe.Pointer((stats + 4 /* &.PSNR */) + 1*4)) = float32(GetPSNR2(tls, *(*uint64_t)(unsafe.Pointer(sse + 1*8)), (size / uint64(4))))
- *(*float32)(unsafe.Pointer((stats + 4 /* &.PSNR */) + 2*4)) = float32(GetPSNR2(tls, *(*uint64_t)(unsafe.Pointer(sse + 2*8)), (size / uint64(4))))
- *(*float32)(unsafe.Pointer((stats + 4 /* &.PSNR */) + 3*4)) = float32(GetPSNR2(tls, ((*(*uint64_t)(unsafe.Pointer(sse)) + *(*uint64_t)(unsafe.Pointer(sse + 1*8))) + *(*uint64_t)(unsafe.Pointer(sse + 2*8))), ((size * uint64(3)) / uint64(2))))
- *(*float32)(unsafe.Pointer((stats + 4 /* &.PSNR */) + 4*4)) = float32(GetPSNR2(tls, *(*uint64_t)(unsafe.Pointer(sse + 3*8)), size))
+ *(*float32)(unsafe.Pointer(stats + 4)) = float32(GetPSNR2(tls, *(*uint64_t)(unsafe.Pointer(sse)), size))
+ *(*float32)(unsafe.Pointer(stats + 4 + 1*4)) = float32(GetPSNR2(tls, *(*uint64_t)(unsafe.Pointer(sse + 1*8)), size/uint64(4)))
+ *(*float32)(unsafe.Pointer(stats + 4 + 2*4)) = float32(GetPSNR2(tls, *(*uint64_t)(unsafe.Pointer(sse + 2*8)), size/uint64(4)))
+ *(*float32)(unsafe.Pointer(stats + 4 + 3*4)) = float32(GetPSNR2(tls, *(*uint64_t)(unsafe.Pointer(sse))+*(*uint64_t)(unsafe.Pointer(sse + 1*8))+*(*uint64_t)(unsafe.Pointer(sse + 2*8)), size*uint64(3)/uint64(2)))
+ *(*float32)(unsafe.Pointer(stats + 4 + 4*4)) = float32(GetPSNR2(tls, *(*uint64_t)(unsafe.Pointer(sse + 3*8)), size))
}
func StoreStats(tls *libc.TLS, enc uintptr) { /* webp_enc.c:283:13: */
var stats uintptr = (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).pic_)).stats
- if stats != (uintptr(0)) {
+ if stats != uintptr(0) {
var i int32
var s int32
for i = 0; i < NUM_MB_SEGMENTS; i++ {
- *(*int32)(unsafe.Pointer((stats + 124 /* &.segment_level */) + uintptr(i)*4)) = (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(i)*744)).fstrength_
- *(*int32)(unsafe.Pointer((stats + 108 /* &.segment_quant */) + uintptr(i)*4)) = (*VP8SegmentInfo)(unsafe.Pointer((enc + 608 /* &.dqm_ */) + uintptr(i)*744)).quant_
+ *(*int32)(unsafe.Pointer(stats + 124 + uintptr(i)*4)) = (*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(i)*744)).fstrength_
+ *(*int32)(unsafe.Pointer(stats + 108 + uintptr(i)*4)) = (*VP8SegmentInfo)(unsafe.Pointer(enc + 608 + uintptr(i)*744)).quant_
for s = 0; s <= 2; s++ {
- *(*int32)(unsafe.Pointer(((stats + 44 /* &.residual_bytes */) + uintptr(s)*16) + uintptr(i)*4)) = *(*int32)(unsafe.Pointer(((enc + 23556 /* &.residual_bytes_ */) + uintptr(s)*16) + uintptr(i)*4))
+ *(*int32)(unsafe.Pointer(stats + 44 + uintptr(s)*16 + uintptr(i)*4)) = *(*int32)(unsafe.Pointer(enc + 23556 + uintptr(s)*16 + uintptr(i)*4))
}
}
FinalizePSNR(tls, enc)
(*WebPAuxStats)(unsafe.Pointer(stats)).coded_size = (*VP8Encoder)(unsafe.Pointer(enc)).coded_size_
for i = 0; i < 3; i++ {
- *(*int32)(unsafe.Pointer((stats + 24 /* &.block_count */) + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((enc + 23604 /* &.block_count_ */) + uintptr(i)*4))
+ *(*int32)(unsafe.Pointer(stats + 24 + uintptr(i)*4)) = *(*int32)(unsafe.Pointer(enc + 23604 + uintptr(i)*4))
}
}
}
func WebPEncodingSetError(tls *libc.TLS, pic uintptr, error WebPEncodingError) int32 { /* webp_enc.c:306:5: */
- (*WebPPicture)(unsafe.Pointer((pic))).error_code = error
+ (*WebPPicture)(unsafe.Pointer(pic)).error_code = error
return 0
}
func WebPReportProgress(tls *libc.TLS, pic uintptr, percent int32, percent_store uintptr) int32 { /* webp_enc.c:314:5: */
- if (percent_store != (uintptr(0))) && (percent != *(*int32)(unsafe.Pointer(percent_store))) {
+ if percent_store != uintptr(0) && percent != *(*int32)(unsafe.Pointer(percent_store)) {
*(*int32)(unsafe.Pointer(percent_store)) = percent
- if ((*WebPPicture)(unsafe.Pointer(pic)).progress_hook != 0) && !((*struct {
+ if (*WebPPicture)(unsafe.Pointer(pic)).progress_hook != 0 && !((*struct {
f func(*libc.TLS, int32, uintptr) int32
})(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).progress_hook})).f(tls, percent, pic) != 0) {
// user abort requested
@@ -38626,45 +38328,45 @@ func WebPReportProgress(tls *libc.TLS, pic uintptr, percent int32, percent_store
func WebPEncode(tls *libc.TLS, config uintptr, pic uintptr) int32 { /* webp_enc.c:328:5: */
var ok int32 = 0
- if pic == (uintptr(0)) {
+ if pic == uintptr(0) {
return 0
}
WebPEncodingSetError(tls, pic, VP8_ENC_OK) // all ok so far
- if config == (uintptr(0)) { // bad params
+ if config == uintptr(0) { // bad params
return WebPEncodingSetError(tls, pic, VP8_ENC_ERROR_NULL_PARAMETER)
}
if !(WebPValidateConfig(tls, config) != 0) {
return WebPEncodingSetError(tls, pic, VP8_ENC_ERROR_INVALID_CONFIGURATION)
}
- if ((*WebPPicture)(unsafe.Pointer(pic)).width <= 0) || ((*WebPPicture)(unsafe.Pointer(pic)).height <= 0) {
+ if (*WebPPicture)(unsafe.Pointer(pic)).width <= 0 || (*WebPPicture)(unsafe.Pointer(pic)).height <= 0 {
return WebPEncodingSetError(tls, pic, VP8_ENC_ERROR_BAD_DIMENSION)
}
- if ((*WebPPicture)(unsafe.Pointer(pic)).width > 16383) || ((*WebPPicture)(unsafe.Pointer(pic)).height > 16383) {
+ if (*WebPPicture)(unsafe.Pointer(pic)).width > 16383 || (*WebPPicture)(unsafe.Pointer(pic)).height > 16383 {
return WebPEncodingSetError(tls, pic, VP8_ENC_ERROR_BAD_DIMENSION)
}
- if (*WebPPicture)(unsafe.Pointer(pic)).stats != (uintptr(0)) {
+ if (*WebPPicture)(unsafe.Pointer(pic)).stats != uintptr(0) {
libc.Xmemset(tls, (*WebPPicture)(unsafe.Pointer(pic)).stats, 0, uint64(unsafe.Sizeof(WebPAuxStats{})))
}
if !((*WebPConfig)(unsafe.Pointer(config)).lossless != 0) {
- var enc uintptr = (uintptr(0))
+ var enc uintptr = uintptr(0)
- if ((((*WebPPicture)(unsafe.Pointer(pic)).use_argb != 0) || ((*WebPPicture)(unsafe.Pointer(pic)).y == (uintptr(0)))) || ((*WebPPicture)(unsafe.Pointer(pic)).u == (uintptr(0)))) || ((*WebPPicture)(unsafe.Pointer(pic)).v == (uintptr(0))) {
+ if (*WebPPicture)(unsafe.Pointer(pic)).use_argb != 0 || (*WebPPicture)(unsafe.Pointer(pic)).y == uintptr(0) || (*WebPPicture)(unsafe.Pointer(pic)).u == uintptr(0) || (*WebPPicture)(unsafe.Pointer(pic)).v == uintptr(0) {
// Make sure we have YUVA samples.
- if ((*WebPConfig)(unsafe.Pointer(config)).use_sharp_yuv != 0) || (((*WebPConfig)(unsafe.Pointer(config)).preprocessing & 4) != 0) {
+ if (*WebPConfig)(unsafe.Pointer(config)).use_sharp_yuv != 0 || (*WebPConfig)(unsafe.Pointer(config)).preprocessing&4 != 0 {
if !(WebPPictureSharpARGBToYUVA(tls, pic) != 0) {
return 0
}
} else {
var dithering float32 = 0.
- if ((*WebPConfig)(unsafe.Pointer(config)).preprocessing & 2) != 0 {
- var x float32 = ((*WebPConfig)(unsafe.Pointer(config)).quality / 100.)
- var x2 float32 = (x * x)
+ if (*WebPConfig)(unsafe.Pointer(config)).preprocessing&2 != 0 {
+ var x float32 = (*WebPConfig)(unsafe.Pointer(config)).quality / 100.
+ var x2 float32 = x * x
// slowly decreasing from max dithering at low quality (q->0)
// to 0.5 dithering amplitude at high quality (q->100)
- dithering = (1.0 + (((float32(0.5) - 1.0) * x2) * x2))
+ dithering = 1.0 + (float32(0.5)-1.0)*x2*x2
}
if !(WebPPictureARGBToYUVADithered(tls, pic, WEBP_YUV420, dithering) != 0) {
return 0
@@ -38677,30 +38379,30 @@ func WebPEncode(tls *libc.TLS, config uintptr, pic uintptr) int32 { /* webp_enc.
}
enc = InitVP8Encoder(tls, config, pic)
- if enc == (uintptr(0)) {
+ if enc == uintptr(0) {
return 0
} // pic->error is already set.
// Note: each of the tasks below account for 20% in the progress report.
ok = VP8EncAnalyze(tls, enc)
// Analysis is done, proceed to actual coding.
- ok = (libc.Bool32((ok != 0) && (VP8EncStartAlpha(tls, enc) != 0))) // possibly done in parallel
+ ok = libc.Bool32(ok != 0 && VP8EncStartAlpha(tls, enc) != 0) // possibly done in parallel
if !((*VP8Encoder)(unsafe.Pointer(enc)).use_tokens_ != 0) {
- ok = (libc.Bool32((ok != 0) && (VP8EncLoop(tls, enc) != 0)))
+ ok = libc.Bool32(ok != 0 && VP8EncLoop(tls, enc) != 0)
} else {
- ok = (libc.Bool32((ok != 0) && (VP8EncTokenLoop(tls, enc) != 0)))
+ ok = libc.Bool32(ok != 0 && VP8EncTokenLoop(tls, enc) != 0)
}
- ok = (libc.Bool32((ok != 0) && (VP8EncFinishAlpha(tls, enc) != 0)))
+ ok = libc.Bool32(ok != 0 && VP8EncFinishAlpha(tls, enc) != 0)
- ok = (libc.Bool32((ok != 0) && (VP8EncWrite(tls, enc) != 0)))
+ ok = libc.Bool32(ok != 0 && VP8EncWrite(tls, enc) != 0)
StoreStats(tls, enc)
if !(ok != 0) {
VP8EncFreeBitWriters(tls, enc)
}
- ok = ok & (DeleteVP8Encoder(tls, enc)) // must always be called, even if !ok
+ ok = ok & DeleteVP8Encoder(tls, enc) // must always be called, even if !ok
} else {
// Make sure we have ARGB samples.
- if ((*WebPPicture)(unsafe.Pointer(pic)).argb == (uintptr(0))) && !(WebPPictureYUVAToARGB(tls, pic) != 0) {
+ if (*WebPPicture)(unsafe.Pointer(pic)).argb == uintptr(0) && !(WebPPictureYUVAToARGB(tls, pic) != 0) {
return 0
}
@@ -38733,10 +38435,10 @@ func WebPEncode(tls *libc.TLS, config uintptr, pic uintptr) int32 { /* webp_enc.
func VP8BitReaderSetBuffer(tls *libc.TLS, br uintptr, start uintptr, size size_t) { /* bit_reader_utils.c:24:6: */
(*VP8BitReader)(unsafe.Pointer(br)).buf_ = start
- (*VP8BitReader)(unsafe.Pointer(br)).buf_end_ = (start + uintptr(size))
+ (*VP8BitReader)(unsafe.Pointer(br)).buf_end_ = start + uintptr(size)
(*VP8BitReader)(unsafe.Pointer(br)).buf_max_ = func() uintptr {
if size >= size_t(unsafe.Sizeof(lbit_t(0))) {
- return (((start + uintptr(size)) - uintptr(uint64(unsafe.Sizeof(lbit_t(0))))) + uintptr(1))
+ return start + uintptr(size) - uintptr(uint64(unsafe.Sizeof(lbit_t(0)))) + uintptr(1)
}
return start
}()
@@ -38745,7 +38447,7 @@ func VP8BitReaderSetBuffer(tls *libc.TLS, br uintptr, start uintptr, size size_t
func VP8InitBitReader(tls *libc.TLS, br uintptr, start uintptr, size size_t) { /* bit_reader_utils.c:34:6: */
// limit ensured by format and upstream checks
- (*VP8BitReader)(unsafe.Pointer(br)).range_ = (range_t(255 - 1))
+ (*VP8BitReader)(unsafe.Pointer(br)).range_ = range_t(255 - 1)
(*VP8BitReader)(unsafe.Pointer(br)).value_ = uint64(0)
(*VP8BitReader)(unsafe.Pointer(br)).bits_ = -8 // to load the very first 8bits
(*VP8BitReader)(unsafe.Pointer(br)).eof_ = 0
@@ -38754,10 +38456,10 @@ func VP8InitBitReader(tls *libc.TLS, br uintptr, start uintptr, size size_t) { /
}
func VP8RemapBitReader(tls *libc.TLS, br uintptr, offset ptrdiff_t) { /* bit_reader_utils.c:47:6: */
- if (*VP8BitReader)(unsafe.Pointer(br)).buf_ != (uintptr(0)) {
- *(*uintptr)(unsafe.Pointer((br + 16 /* &.buf_ */))) += (uintptr(offset))
- *(*uintptr)(unsafe.Pointer((br + 24 /* &.buf_end_ */))) += (uintptr(offset))
- *(*uintptr)(unsafe.Pointer((br + 32 /* &.buf_max_ */))) += (uintptr(offset))
+ if (*VP8BitReader)(unsafe.Pointer(br)).buf_ != uintptr(0) {
+ *(*uintptr)(unsafe.Pointer(br + 16)) += uintptr(offset)
+ *(*uintptr)(unsafe.Pointer(br + 24)) += uintptr(offset)
+ *(*uintptr)(unsafe.Pointer(br + 32)) += uintptr(offset)
}
}
@@ -38797,11 +38499,11 @@ func VP8LoadFinalBytes(tls *libc.TLS, br uintptr) { /* bit_reader_utils.c:87:6:
// Only read 8bits at a time
if (*VP8BitReader)(unsafe.Pointer(br)).buf_ < (*VP8BitReader)(unsafe.Pointer(br)).buf_end_ {
- *(*int32)(unsafe.Pointer((br + 12 /* &.bits_ */))) += (8)
- (*VP8BitReader)(unsafe.Pointer(br)).value_ = ((bit_t(*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&(*VP8BitReader)(unsafe.Pointer(br)).buf_, 1))))) | ((*VP8BitReader)(unsafe.Pointer(br)).value_ << 8))
+ *(*int32)(unsafe.Pointer(br + 12)) += 8
+ (*VP8BitReader)(unsafe.Pointer(br)).value_ = bit_t(*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&(*VP8BitReader)(unsafe.Pointer(br)).buf_, 1)))) | (*VP8BitReader)(unsafe.Pointer(br)).value_<<8
} else if !((*VP8BitReader)(unsafe.Pointer(br)).eof_ != 0) {
- libc.AssignShlPtrUint64((br /* &.value_ */), int(8))
- *(*int32)(unsafe.Pointer((br + 12 /* &.bits_ */))) += (8)
+ libc.AssignShlPtrUint64(br, int(8))
+ *(*int32)(unsafe.Pointer(br + 12)) += 8
(*VP8BitReader)(unsafe.Pointer(br)).eof_ = 1
} else {
(*VP8BitReader)(unsafe.Pointer(br)).bits_ = 0 // This is to avoid undefined behaviour with shifts.
@@ -38814,7 +38516,7 @@ func VP8LoadFinalBytes(tls *libc.TLS, br uintptr) { /* bit_reader_utils.c:87:6:
func VP8GetValue(tls *libc.TLS, br uintptr, bits int32) uint32_t { /* bit_reader_utils.c:105:10: */
var v uint32_t = uint32_t(0)
for libc.PostDecInt32(&bits, 1) > 0 {
- v = v | (uint32_t(VP8GetBit(tls, br, 0x80) << bits))
+ v = v | uint32_t(VP8GetBit(tls, br, 0x80)<<bits)
}
return v
}
@@ -38855,7 +38557,7 @@ func VP8LInitBitReader(tls *libc.TLS, br uintptr, start uintptr, length size_t)
length = size_t(unsafe.Sizeof(vp8l_val_t(0)))
}
for i = uint64(0); i < length; i++ {
- value = value | (vp8l_val_t(*(*uint8_t)(unsafe.Pointer(start + uintptr(i)))) << (uint64(8) * i))
+ value = value | vp8l_val_t(*(*uint8_t)(unsafe.Pointer(start + uintptr(i))))<<(uint64(8)*i)
}
(*VP8LBitReader)(unsafe.Pointer(br)).val_ = value
(*VP8LBitReader)(unsafe.Pointer(br)).pos_ = length
@@ -38868,7 +38570,7 @@ func VP8LBitReaderSetBuffer(tls *libc.TLS, br uintptr, buf uintptr, len size_t)
(*VP8LBitReader)(unsafe.Pointer(br)).buf_ = buf
(*VP8LBitReader)(unsafe.Pointer(br)).len_ = len
// pos_ > len_ should be considered a param error.
- (*VP8LBitReader)(unsafe.Pointer(br)).eos_ = (libc.Bool32(((*VP8LBitReader)(unsafe.Pointer(br)).pos_ > (*VP8LBitReader)(unsafe.Pointer(br)).len_) || (VP8LIsEndOfStream(tls, br) != 0)))
+ (*VP8LBitReader)(unsafe.Pointer(br)).eos_ = libc.Bool32((*VP8LBitReader)(unsafe.Pointer(br)).pos_ > (*VP8LBitReader)(unsafe.Pointer(br)).len_ || VP8LIsEndOfStream(tls, br) != 0)
}
func VP8LSetEndOfStream(tls *libc.TLS, br uintptr) { /* bit_reader_utils.c:175:13: */
@@ -38878,11 +38580,11 @@ func VP8LSetEndOfStream(tls *libc.TLS, br uintptr) { /* bit_reader_utils.c:175:1
// If not at EOS, reload up to VP8L_LBITS byte-by-byte
func ShiftBytes(tls *libc.TLS, br uintptr) { /* bit_reader_utils.c:181:13: */
- for ((*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ >= 8) && ((*VP8LBitReader)(unsafe.Pointer(br)).pos_ < (*VP8LBitReader)(unsafe.Pointer(br)).len_) {
- libc.AssignShrPtrUint64((br /* &.val_ */), int(8))
- *(*vp8l_val_t)(unsafe.Pointer((br /* &.val_ */))) |= ((vp8l_val_t(*(*uint8_t)(unsafe.Pointer((*VP8LBitReader)(unsafe.Pointer(br)).buf_ + uintptr((*VP8LBitReader)(unsafe.Pointer(br)).pos_))))) << (64 - 8))
+ for (*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ >= 8 && (*VP8LBitReader)(unsafe.Pointer(br)).pos_ < (*VP8LBitReader)(unsafe.Pointer(br)).len_ {
+ libc.AssignShrPtrUint64(br, int(8))
+ *(*vp8l_val_t)(unsafe.Pointer(br)) |= vp8l_val_t(*(*uint8_t)(unsafe.Pointer((*VP8LBitReader)(unsafe.Pointer(br)).buf_ + uintptr((*VP8LBitReader)(unsafe.Pointer(br)).pos_)))) << (64 - 8)
(*VP8LBitReader)(unsafe.Pointer(br)).pos_++
- *(*int32)(unsafe.Pointer((br + 32 /* &.bit_pos_ */))) -= (8)
+ *(*int32)(unsafe.Pointer(br + 32)) -= 8
}
if VP8LIsEndOfStream(tls, br) != 0 {
VP8LSetEndOfStream(tls, br)
@@ -38891,11 +38593,11 @@ func ShiftBytes(tls *libc.TLS, br uintptr) { /* bit_reader_utils.c:181:13: */
func VP8LDoFillBitWindow(tls *libc.TLS, br uintptr) { /* bit_reader_utils.c:193:6: */
- if ((*VP8LBitReader)(unsafe.Pointer(br)).pos_ + size_t(unsafe.Sizeof(vp8l_val_t(0)))) < (*VP8LBitReader)(unsafe.Pointer(br)).len_ {
- libc.AssignShrPtrUint64((br /* &.val_ */), int(32))
- *(*int32)(unsafe.Pointer((br + 32 /* &.bit_pos_ */))) -= (32)
- *(*vp8l_val_t)(unsafe.Pointer((br /* &.val_ */))) |= ((vp8l_val_t(WebPMemToUint32(tls, ((*VP8LBitReader)(unsafe.Pointer(br)).buf_ + uintptr((*VP8LBitReader)(unsafe.Pointer(br)).pos_))))) << (64 - 32))
- *(*size_t)(unsafe.Pointer((br + 24 /* &.pos_ */))) += (uint64(4))
+ if (*VP8LBitReader)(unsafe.Pointer(br)).pos_+size_t(unsafe.Sizeof(vp8l_val_t(0))) < (*VP8LBitReader)(unsafe.Pointer(br)).len_ {
+ libc.AssignShrPtrUint64(br, int(32))
+ *(*int32)(unsafe.Pointer(br + 32)) -= 32
+ *(*vp8l_val_t)(unsafe.Pointer(br)) |= vp8l_val_t(WebPMemToUint32(tls, (*VP8LBitReader)(unsafe.Pointer(br)).buf_+uintptr((*VP8LBitReader)(unsafe.Pointer(br)).pos_))) << (64 - 32)
+ *(*size_t)(unsafe.Pointer(br + 24)) += uint64(4)
return
}
ShiftBytes(tls, br) // Slow path.
@@ -38904,9 +38606,9 @@ func VP8LDoFillBitWindow(tls *libc.TLS, br uintptr) { /* bit_reader_utils.c:193:
func VP8LReadBits(tls *libc.TLS, br uintptr, n_bits int32) uint32_t { /* bit_reader_utils.c:208:10: */
// Flag an error if end_of_stream or n_bits is more than allowed limit.
- if !((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0) && (n_bits <= 24) {
- var val uint32_t = (VP8LPrefetchBits(tls, br) & kBitMask[n_bits])
- var new_bits int32 = ((*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ + n_bits)
+ if !((*VP8LBitReader)(unsafe.Pointer(br)).eos_ != 0) && n_bits <= 24 {
+ var val uint32_t = VP8LPrefetchBits(tls, br) & kBitMask[n_bits]
+ var new_bits int32 = (*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ + n_bits
(*VP8LBitReader)(unsafe.Pointer(br)).bit_pos_ = new_bits
ShiftBytes(tls, br)
return val
@@ -38930,7 +38632,7 @@ func VP8LReadBits(tls *libc.TLS, br uintptr, n_bits int32) uint32_t { /* bit_rea
func BitWriterResize(tls *libc.TLS, bw uintptr, extra_size size_t) int32 { /* bit_writer_utils.c:26:12: */
var new_buf uintptr
var new_size size_t
- var needed_size_64b uint64_t = ((*VP8BitWriter)(unsafe.Pointer(bw)).pos_ + extra_size)
+ var needed_size_64b uint64_t = (*VP8BitWriter)(unsafe.Pointer(bw)).pos_ + extra_size
var needed_size size_t = needed_size_64b
if needed_size_64b != needed_size {
(*VP8BitWriter)(unsafe.Pointer(bw)).error_ = 1
@@ -38940,7 +38642,7 @@ func BitWriterResize(tls *libc.TLS, bw uintptr, extra_size size_t) int32 { /* bi
return 1
}
// If the following line wraps over 32bit, the test just after will catch it.
- new_size = (uint64(2) * (*VP8BitWriter)(unsafe.Pointer(bw)).max_pos_)
+ new_size = uint64(2) * (*VP8BitWriter)(unsafe.Pointer(bw)).max_pos_
if new_size < needed_size {
new_size = needed_size
}
@@ -38948,7 +38650,7 @@ func BitWriterResize(tls *libc.TLS, bw uintptr, extra_size size_t) int32 { /* bi
new_size = uint64(1024)
}
new_buf = WebPSafeMalloc(tls, 1, new_size)
- if new_buf == (uintptr(0)) {
+ if new_buf == uintptr(0) {
(*VP8BitWriter)(unsafe.Pointer(bw)).error_ = 1
return 0
}
@@ -38963,24 +38665,24 @@ func BitWriterResize(tls *libc.TLS, bw uintptr, extra_size size_t) int32 { /* bi
}
func Flush(tls *libc.TLS, bw uintptr) { /* bit_writer_utils.c:55:13: */
- var s int32 = (8 + (*VP8BitWriter)(unsafe.Pointer(bw)).nb_bits_)
- var bits int32_t = ((*VP8BitWriter)(unsafe.Pointer(bw)).value_ >> s)
+ var s int32 = 8 + (*VP8BitWriter)(unsafe.Pointer(bw)).nb_bits_
+ var bits int32_t = (*VP8BitWriter)(unsafe.Pointer(bw)).value_ >> s
- *(*int32_t)(unsafe.Pointer((bw + 4 /* &.value_ */))) -= (bits << s)
- *(*int32)(unsafe.Pointer((bw + 12 /* &.nb_bits_ */))) -= (8)
- if (bits & 0xff) != 0xff {
+ *(*int32_t)(unsafe.Pointer(bw + 4)) -= bits << s
+ *(*int32)(unsafe.Pointer(bw + 12)) -= 8
+ if bits&0xff != 0xff {
var pos size_t = (*VP8BitWriter)(unsafe.Pointer(bw)).pos_
- if !(BitWriterResize(tls, bw, (uint64((*VP8BitWriter)(unsafe.Pointer(bw)).run_+1))) != 0) {
+ if !(BitWriterResize(tls, bw, uint64((*VP8BitWriter)(unsafe.Pointer(bw)).run_+1)) != 0) {
return
}
- if (bits & 0x100) != 0 { // overflow -> propagate carry over pending 0xff's
+ if bits&0x100 != 0 { // overflow -> propagate carry over pending 0xff's
if pos > uint64(0) {
- *(*uint8_t)(unsafe.Pointer((*VP8BitWriter)(unsafe.Pointer(bw)).buf_ + uintptr((pos - uint64(1)))))++
+ *(*uint8_t)(unsafe.Pointer((*VP8BitWriter)(unsafe.Pointer(bw)).buf_ + uintptr(pos-uint64(1))))++
}
}
if (*VP8BitWriter)(unsafe.Pointer(bw)).run_ > 0 {
var value int32
- if (bits & 0x100) != 0 {
+ if bits&0x100 != 0 {
value = 0x00
} else {
value = 0xff
@@ -38989,7 +38691,7 @@ func Flush(tls *libc.TLS, bw uintptr) { /* bit_writer_utils.c:55:13: */
*(*uint8_t)(unsafe.Pointer((*VP8BitWriter)(unsafe.Pointer(bw)).buf_ + uintptr(libc.PostIncUint64(&pos, 1)))) = uint8_t(value)
}
}
- *(*uint8_t)(unsafe.Pointer((*VP8BitWriter)(unsafe.Pointer(bw)).buf_ + uintptr(libc.PostIncUint64(&pos, 1)))) = (uint8_t(bits & 0xff))
+ *(*uint8_t)(unsafe.Pointer((*VP8BitWriter)(unsafe.Pointer(bw)).buf_ + uintptr(libc.PostIncUint64(&pos, 1)))) = uint8_t(bits & 0xff)
(*VP8BitWriter)(unsafe.Pointer(bw)).pos_ = pos
} else {
(*VP8BitWriter)(unsafe.Pointer(bw)).run_++ // delay writing of bytes 0xff, pending eventual carry.
@@ -39025,18 +38727,18 @@ var kNewRange = [128]uint8_t{
} /* bit_writer_utils.c:96:22 */
func VP8PutBit(tls *libc.TLS, bw uintptr, bit int32, prob int32) int32 { /* bit_writer_utils.c:108:5: */
- var split int32 = (((*VP8BitWriter)(unsafe.Pointer(bw)).range_ * prob) >> 8)
+ var split int32 = (*VP8BitWriter)(unsafe.Pointer(bw)).range_ * prob >> 8
if bit != 0 {
- *(*int32_t)(unsafe.Pointer((bw + 4 /* &.value_ */))) += (split + 1)
- *(*int32_t)(unsafe.Pointer((bw /* &.range_ */))) -= (split + 1)
+ *(*int32_t)(unsafe.Pointer(bw + 4)) += split + 1
+ *(*int32_t)(unsafe.Pointer(bw)) -= split + 1
} else {
(*VP8BitWriter)(unsafe.Pointer(bw)).range_ = split
}
if (*VP8BitWriter)(unsafe.Pointer(bw)).range_ < 127 { // emit 'shift' bits out and renormalize
var shift int32 = int32(kNorm[(*VP8BitWriter)(unsafe.Pointer(bw)).range_])
(*VP8BitWriter)(unsafe.Pointer(bw)).range_ = int32_t(kNewRange[(*VP8BitWriter)(unsafe.Pointer(bw)).range_])
- libc.AssignShlPtrInt32((bw + 4 /* &.value_ */), int(shift))
- *(*int32)(unsafe.Pointer((bw + 12 /* &.nb_bits_ */))) += (shift)
+ libc.AssignShlPtrInt32(bw+4, int(shift))
+ *(*int32)(unsafe.Pointer(bw + 12)) += shift
if (*VP8BitWriter)(unsafe.Pointer(bw)).nb_bits_ > 0 {
Flush(tls, bw)
}
@@ -39045,17 +38747,17 @@ func VP8PutBit(tls *libc.TLS, bw uintptr, bit int32, prob int32) int32 { /* bit_
}
func VP8PutBitUniform(tls *libc.TLS, bw uintptr, bit int32) int32 { /* bit_writer_utils.c:126:5: */
- var split int32 = ((*VP8BitWriter)(unsafe.Pointer(bw)).range_ >> 1)
+ var split int32 = (*VP8BitWriter)(unsafe.Pointer(bw)).range_ >> 1
if bit != 0 {
- *(*int32_t)(unsafe.Pointer((bw + 4 /* &.value_ */))) += (split + 1)
- *(*int32_t)(unsafe.Pointer((bw /* &.range_ */))) -= (split + 1)
+ *(*int32_t)(unsafe.Pointer(bw + 4)) += split + 1
+ *(*int32_t)(unsafe.Pointer(bw)) -= split + 1
} else {
(*VP8BitWriter)(unsafe.Pointer(bw)).range_ = split
}
if (*VP8BitWriter)(unsafe.Pointer(bw)).range_ < 127 {
(*VP8BitWriter)(unsafe.Pointer(bw)).range_ = int32_t(kNewRange[(*VP8BitWriter)(unsafe.Pointer(bw)).range_])
- libc.AssignShlPtrInt32((bw + 4 /* &.value_ */), int(1))
- *(*int32)(unsafe.Pointer((bw + 12 /* &.nb_bits_ */))) += (1)
+ libc.AssignShlPtrInt32(bw+4, int(1))
+ *(*int32)(unsafe.Pointer(bw + 12)) += 1
if (*VP8BitWriter)(unsafe.Pointer(bw)).nb_bits_ > 0 {
Flush(tls, bw)
}
@@ -39066,33 +38768,33 @@ func VP8PutBitUniform(tls *libc.TLS, bw uintptr, bit int32) int32 { /* bit_write
func VP8PutBits(tls *libc.TLS, bw uintptr, value uint32_t, nb_bits int32) { /* bit_writer_utils.c:143:6: */
var mask uint32_t
- for mask = (uint32(1) << (nb_bits - 1)); mask != 0; mask >>= 1 {
- VP8PutBitUniform(tls, bw, (int32(value & mask)))
+ for mask = uint32(1) << (nb_bits - 1); mask != 0; mask >>= 1 {
+ VP8PutBitUniform(tls, bw, int32(value&mask))
}
}
func VP8PutSignedBits(tls *libc.TLS, bw uintptr, value int32, nb_bits int32) { /* bit_writer_utils.c:151:6: */
- if !(VP8PutBitUniform(tls, bw, (libc.Bool32(value != 0))) != 0) {
+ if !(VP8PutBitUniform(tls, bw, libc.Bool32(value != 0)) != 0) {
return
}
if value < 0 {
- VP8PutBits(tls, bw, (uint32(((-value) << 1) | 1)), (nb_bits + 1))
+ VP8PutBits(tls, bw, uint32(-value<<1|1), nb_bits+1)
} else {
- VP8PutBits(tls, bw, (uint32(value << 1)), (nb_bits + 1))
+ VP8PutBits(tls, bw, uint32(value<<1), nb_bits+1)
}
}
//------------------------------------------------------------------------------
func VP8BitWriterInit(tls *libc.TLS, bw uintptr, expected_size size_t) int32 { /* bit_writer_utils.c:162:5: */
- (*VP8BitWriter)(unsafe.Pointer(bw)).range_ = (255 - 1)
+ (*VP8BitWriter)(unsafe.Pointer(bw)).range_ = 255 - 1
(*VP8BitWriter)(unsafe.Pointer(bw)).value_ = 0
(*VP8BitWriter)(unsafe.Pointer(bw)).run_ = 0
(*VP8BitWriter)(unsafe.Pointer(bw)).nb_bits_ = -8
(*VP8BitWriter)(unsafe.Pointer(bw)).pos_ = uint64(0)
(*VP8BitWriter)(unsafe.Pointer(bw)).max_pos_ = uint64(0)
(*VP8BitWriter)(unsafe.Pointer(bw)).error_ = 0
- (*VP8BitWriter)(unsafe.Pointer(bw)).buf_ = (uintptr(0))
+ (*VP8BitWriter)(unsafe.Pointer(bw)).buf_ = uintptr(0)
if expected_size > uint64(0) {
return BitWriterResize(tls, bw, expected_size)
}
@@ -39100,7 +38802,7 @@ func VP8BitWriterInit(tls *libc.TLS, bw uintptr, expected_size size_t) int32 { /
}
func VP8BitWriterFinish(tls *libc.TLS, bw uintptr) uintptr { /* bit_writer_utils.c:174:8: */
- VP8PutBits(tls, bw, uint32(0), (9 - (*VP8BitWriter)(unsafe.Pointer(bw)).nb_bits_))
+ VP8PutBits(tls, bw, uint32(0), 9-(*VP8BitWriter)(unsafe.Pointer(bw)).nb_bits_)
(*VP8BitWriter)(unsafe.Pointer(bw)).nb_bits_ = 0 // pad with zeroes
Flush(tls, bw)
return (*VP8BitWriter)(unsafe.Pointer(bw)).buf_
@@ -39114,13 +38816,13 @@ func VP8BitWriterAppend(tls *libc.TLS, bw uintptr, data uintptr, size size_t) in
if !(BitWriterResize(tls, bw, size) != 0) {
return 0
}
- libc.Xmemcpy(tls, ((*VP8BitWriter)(unsafe.Pointer(bw)).buf_ + uintptr((*VP8BitWriter)(unsafe.Pointer(bw)).pos_)), data, size)
- *(*size_t)(unsafe.Pointer((bw + 24 /* &.pos_ */))) += (size)
+ libc.Xmemcpy(tls, (*VP8BitWriter)(unsafe.Pointer(bw)).buf_+uintptr((*VP8BitWriter)(unsafe.Pointer(bw)).pos_), data, size)
+ *(*size_t)(unsafe.Pointer(bw + 24)) += size
return 1
}
func VP8BitWriterWipeOut(tls *libc.TLS, bw uintptr) { /* bit_writer_utils.c:191:6: */
- if bw != (uintptr(0)) {
+ if bw != uintptr(0) {
WebPSafeFree(tls, (*VP8BitWriter)(unsafe.Pointer(bw)).buf_)
libc.Xmemset(tls, bw, 0, uint64(unsafe.Sizeof(VP8BitWriter{})))
}
@@ -39136,25 +38838,25 @@ func VP8BitWriterWipeOut(tls *libc.TLS, bw uintptr) { /* bit_writer_utils.c:191:
func VP8LBitWriterResize(tls *libc.TLS, bw uintptr, extra_size size_t) int32 { /* bit_writer_utils.c:206:12: */
var allocated_buf uintptr
var allocated_size size_t
- var max_bytes size_t = (size_t((int64((*VP8LBitWriter)(unsafe.Pointer(bw)).end_) - int64((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_)) / 1))
- var current_size size_t = (size_t((int64((*VP8LBitWriter)(unsafe.Pointer(bw)).cur_) - int64((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_)) / 1))
- var size_required_64b uint64_t = (current_size + extra_size)
+ var max_bytes size_t = size_t((int64((*VP8LBitWriter)(unsafe.Pointer(bw)).end_) - int64((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_)) / 1)
+ var current_size size_t = size_t((int64((*VP8LBitWriter)(unsafe.Pointer(bw)).cur_) - int64((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_)) / 1)
+ var size_required_64b uint64_t = current_size + extra_size
var size_required size_t = size_required_64b
if size_required != size_required_64b {
(*VP8LBitWriter)(unsafe.Pointer(bw)).error_ = 1
return 0
}
- if (max_bytes > uint64(0)) && (size_required <= max_bytes) {
+ if max_bytes > uint64(0) && size_required <= max_bytes {
return 1
}
- allocated_size = ((uint64(3) * max_bytes) >> 1)
+ allocated_size = uint64(3) * max_bytes >> 1
if allocated_size < size_required {
allocated_size = size_required
}
// make allocated size multiple of 1k
- allocated_size = (((allocated_size >> 10) + uint64(1)) << 10)
+ allocated_size = (allocated_size>>10 + uint64(1)) << 10
allocated_buf = WebPSafeMalloc(tls, 1, allocated_size)
- if allocated_buf == (uintptr(0)) {
+ if allocated_buf == uintptr(0) {
(*VP8LBitWriter)(unsafe.Pointer(bw)).error_ = 1
return 0
}
@@ -39163,8 +38865,8 @@ func VP8LBitWriterResize(tls *libc.TLS, bw uintptr, extra_size size_t) int32 { /
}
WebPSafeFree(tls, (*VP8LBitWriter)(unsafe.Pointer(bw)).buf_)
(*VP8LBitWriter)(unsafe.Pointer(bw)).buf_ = allocated_buf
- (*VP8LBitWriter)(unsafe.Pointer(bw)).cur_ = ((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_ + uintptr(current_size))
- (*VP8LBitWriter)(unsafe.Pointer(bw)).end_ = ((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_ + uintptr(allocated_size))
+ (*VP8LBitWriter)(unsafe.Pointer(bw)).cur_ = (*VP8LBitWriter)(unsafe.Pointer(bw)).buf_ + uintptr(current_size)
+ (*VP8LBitWriter)(unsafe.Pointer(bw)).end_ = (*VP8LBitWriter)(unsafe.Pointer(bw)).buf_ + uintptr(allocated_size)
return 1
}
@@ -39174,7 +38876,7 @@ func VP8LBitWriterInit(tls *libc.TLS, bw uintptr, expected_size size_t) int32 {
}
func VP8LBitWriterClone(tls *libc.TLS, src uintptr, dst uintptr) int32 { /* bit_writer_utils.c:242:5: */
- var current_size size_t = (size_t((int64((*VP8LBitWriter)(unsafe.Pointer(src)).cur_) - int64((*VP8LBitWriter)(unsafe.Pointer(src)).buf_)) / 1))
+ var current_size size_t = size_t((int64((*VP8LBitWriter)(unsafe.Pointer(src)).cur_) - int64((*VP8LBitWriter)(unsafe.Pointer(src)).buf_)) / 1)
if !(VP8LBitWriterResize(tls, dst, current_size) != 0) {
return 0
@@ -39183,12 +38885,12 @@ func VP8LBitWriterClone(tls *libc.TLS, src uintptr, dst uintptr) int32 { /* bit_
(*VP8LBitWriter)(unsafe.Pointer(dst)).bits_ = (*VP8LBitWriter)(unsafe.Pointer(src)).bits_
(*VP8LBitWriter)(unsafe.Pointer(dst)).used_ = (*VP8LBitWriter)(unsafe.Pointer(src)).used_
(*VP8LBitWriter)(unsafe.Pointer(dst)).error_ = (*VP8LBitWriter)(unsafe.Pointer(src)).error_
- (*VP8LBitWriter)(unsafe.Pointer(dst)).cur_ = ((*VP8LBitWriter)(unsafe.Pointer(dst)).buf_ + uintptr(current_size))
+ (*VP8LBitWriter)(unsafe.Pointer(dst)).cur_ = (*VP8LBitWriter)(unsafe.Pointer(dst)).buf_ + uintptr(current_size)
return 1
}
func VP8LBitWriterWipeOut(tls *libc.TLS, bw uintptr) { /* bit_writer_utils.c:255:6: */
- if bw != (uintptr(0)) {
+ if bw != uintptr(0) {
WebPSafeFree(tls, (*VP8LBitWriter)(unsafe.Pointer(bw)).buf_)
libc.Xmemset(tls, bw, 0, uint64(unsafe.Sizeof(VP8LBitWriter{})))
}
@@ -39197,7 +38899,7 @@ func VP8LBitWriterWipeOut(tls *libc.TLS, bw uintptr) { /* bit_writer_utils.c:255
func VP8LBitWriterReset(tls *libc.TLS, bw_init uintptr, bw uintptr) { /* bit_writer_utils.c:262:6: */
(*VP8LBitWriter)(unsafe.Pointer(bw)).bits_ = (*VP8LBitWriter)(unsafe.Pointer(bw_init)).bits_
(*VP8LBitWriter)(unsafe.Pointer(bw)).used_ = (*VP8LBitWriter)(unsafe.Pointer(bw_init)).used_
- (*VP8LBitWriter)(unsafe.Pointer(bw)).cur_ = ((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_ + uintptr(((int64((*VP8LBitWriter)(unsafe.Pointer(bw_init)).cur_) - int64((*VP8LBitWriter)(unsafe.Pointer(bw_init)).buf_)) / 1)))
+ (*VP8LBitWriter)(unsafe.Pointer(bw)).cur_ = (*VP8LBitWriter)(unsafe.Pointer(bw)).buf_ + uintptr((int64((*VP8LBitWriter)(unsafe.Pointer(bw_init)).cur_)-int64((*VP8LBitWriter)(unsafe.Pointer(bw_init)).buf_))/1)
(*VP8LBitWriter)(unsafe.Pointer(bw)).error_ = (*VP8LBitWriter)(unsafe.Pointer(bw_init)).error_
}
@@ -39210,18 +38912,18 @@ func VP8LBitWriterSwap(tls *libc.TLS, src uintptr, dst uintptr) { /* bit_writer_
func VP8LPutBitsFlushBits(tls *libc.TLS, bw uintptr) { /* bit_writer_utils.c:277:6: */
// If needed, make some room by flushing some bits out.
- if ((*VP8LBitWriter)(unsafe.Pointer(bw)).cur_ + uintptr(4)) > (*VP8LBitWriter)(unsafe.Pointer(bw)).end_ {
- var extra_size uint64_t = (uint64_t((uint64((int64((*VP8LBitWriter)(unsafe.Pointer(bw)).end_) - int64((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_)) / 1)) + (32768)))
+ if (*VP8LBitWriter)(unsafe.Pointer(bw)).cur_+uintptr(4) > (*VP8LBitWriter)(unsafe.Pointer(bw)).end_ {
+ var extra_size uint64_t = uint64_t(uint64((int64((*VP8LBitWriter)(unsafe.Pointer(bw)).end_)-int64((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_))/1) + 32768)
if !(CheckSizeOverflow(tls, extra_size) != 0) || !(VP8LBitWriterResize(tls, bw, extra_size) != 0) {
(*VP8LBitWriter)(unsafe.Pointer(bw)).cur_ = (*VP8LBitWriter)(unsafe.Pointer(bw)).buf_
(*VP8LBitWriter)(unsafe.Pointer(bw)).error_ = 1
return
}
}
- *(*vp8l_wtype_t)(unsafe.Pointer((*VP8LBitWriter)(unsafe.Pointer(bw)).cur_)) = (vp8l_wtype_t((*VP8LBitWriter)(unsafe.Pointer(bw)).bits_))
- *(*uintptr)(unsafe.Pointer((bw + 24 /* &.cur_ */))) += (uintptr(4))
- libc.AssignShrPtrUint64((bw /* &.bits_ */), int(32))
- *(*int32)(unsafe.Pointer((bw + 8 /* &.used_ */))) -= (32)
+ *(*vp8l_wtype_t)(unsafe.Pointer((*VP8LBitWriter)(unsafe.Pointer(bw)).cur_)) = vp8l_wtype_t((*VP8LBitWriter)(unsafe.Pointer(bw)).bits_)
+ *(*uintptr)(unsafe.Pointer(bw + 24)) += uintptr(4)
+ libc.AssignShrPtrUint64(bw, int(32))
+ *(*int32)(unsafe.Pointer(bw + 8)) -= 32
}
func VP8LPutBitsInternal(tls *libc.TLS, bw uintptr, bits uint32_t, n_bits int32) { /* bit_writer_utils.c:294:6: */
@@ -39234,31 +38936,31 @@ func VP8LPutBitsInternal(tls *libc.TLS, bw uintptr, bits uint32_t, n_bits int32)
// Special case of overflow handling for 32bit accumulator (2-steps flush).
// If needed, make some room by flushing some bits out.
for used >= 32 {
- if ((*VP8LBitWriter)(unsafe.Pointer(bw)).cur_ + uintptr(4)) > (*VP8LBitWriter)(unsafe.Pointer(bw)).end_ {
- var extra_size uint64_t = (uint64_t((uint64((int64((*VP8LBitWriter)(unsafe.Pointer(bw)).end_) - int64((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_)) / 1)) + (32768)))
+ if (*VP8LBitWriter)(unsafe.Pointer(bw)).cur_+uintptr(4) > (*VP8LBitWriter)(unsafe.Pointer(bw)).end_ {
+ var extra_size uint64_t = uint64_t(uint64((int64((*VP8LBitWriter)(unsafe.Pointer(bw)).end_)-int64((*VP8LBitWriter)(unsafe.Pointer(bw)).buf_))/1) + 32768)
if !(CheckSizeOverflow(tls, extra_size) != 0) || !(VP8LBitWriterResize(tls, bw, extra_size) != 0) {
(*VP8LBitWriter)(unsafe.Pointer(bw)).cur_ = (*VP8LBitWriter)(unsafe.Pointer(bw)).buf_
(*VP8LBitWriter)(unsafe.Pointer(bw)).error_ = 1
return
}
}
- *(*vp8l_wtype_t)(unsafe.Pointer((*VP8LBitWriter)(unsafe.Pointer(bw)).cur_)) = (vp8l_wtype_t(lbits))
- *(*uintptr)(unsafe.Pointer((bw + 24 /* &.cur_ */))) += (uintptr(4))
+ *(*vp8l_wtype_t)(unsafe.Pointer((*VP8LBitWriter)(unsafe.Pointer(bw)).cur_)) = vp8l_wtype_t(lbits)
+ *(*uintptr)(unsafe.Pointer(bw + 24)) += uintptr(4)
lbits >>= 32
- used = used - (32)
+ used = used - 32
}
- (*VP8LBitWriter)(unsafe.Pointer(bw)).bits_ = (lbits | (vp8l_atype_t(bits) << used))
- (*VP8LBitWriter)(unsafe.Pointer(bw)).used_ = (used + n_bits)
+ (*VP8LBitWriter)(unsafe.Pointer(bw)).bits_ = lbits | vp8l_atype_t(bits)<<used
+ (*VP8LBitWriter)(unsafe.Pointer(bw)).used_ = used + n_bits
}
}
func VP8LBitWriterFinish(tls *libc.TLS, bw uintptr) uintptr { /* bit_writer_utils.c:334:8: */
// flush leftover bits
- if VP8LBitWriterResize(tls, bw, (uint64(((*VP8LBitWriter)(unsafe.Pointer(bw)).used_+7)>>3))) != 0 {
+ if VP8LBitWriterResize(tls, bw, uint64(((*VP8LBitWriter)(unsafe.Pointer(bw)).used_+7)>>3)) != 0 {
for (*VP8LBitWriter)(unsafe.Pointer(bw)).used_ > 0 {
*(*uint8_t)(unsafe.Pointer(libc.PostIncUintptr(&(*VP8LBitWriter)(unsafe.Pointer(bw)).cur_, 1))) = uint8_t((*VP8LBitWriter)(unsafe.Pointer(bw)).bits_)
- libc.AssignShrPtrUint64((bw /* &.bits_ */), int(8))
- *(*int32)(unsafe.Pointer((bw + 8 /* &.used_ */))) -= (8)
+ libc.AssignShrPtrUint64(bw, int(8))
+ *(*int32)(unsafe.Pointer(bw + 8)) -= 8
}
(*VP8LBitWriter)(unsafe.Pointer(bw)).used_ = 0
}
@@ -39273,37 +38975,37 @@ func VP8LBitWriterFinish(tls *libc.TLS, bw uintptr) uintptr { /* bit_writer_util
// VP8LColorCache.
func VP8LColorCacheInit(tls *libc.TLS, color_cache uintptr, hash_bits int32) int32 { /* color_cache_utils.c:23:5: */
- var hash_size int32 = (int32(1) << hash_bits)
+ var hash_size int32 = int32(1) << hash_bits
(*VP8LColorCache)(unsafe.Pointer(color_cache)).colors_ = WebPSafeCalloc(tls,
uint64_t(hash_size), uint64(unsafe.Sizeof(uint32_t(0))))
- if (*VP8LColorCache)(unsafe.Pointer(color_cache)).colors_ == (uintptr(0)) {
+ if (*VP8LColorCache)(unsafe.Pointer(color_cache)).colors_ == uintptr(0) {
return 0
}
- (*VP8LColorCache)(unsafe.Pointer(color_cache)).hash_shift_ = (32 - hash_bits)
+ (*VP8LColorCache)(unsafe.Pointer(color_cache)).hash_shift_ = 32 - hash_bits
(*VP8LColorCache)(unsafe.Pointer(color_cache)).hash_bits_ = hash_bits
return 1
}
func VP8LColorCacheClear(tls *libc.TLS, color_cache uintptr) { /* color_cache_utils.c:35:6: */
- if color_cache != (uintptr(0)) {
+ if color_cache != uintptr(0) {
WebPSafeFree(tls, (*VP8LColorCache)(unsafe.Pointer(color_cache)).colors_)
- (*VP8LColorCache)(unsafe.Pointer(color_cache)).colors_ = (uintptr(0))
+ (*VP8LColorCache)(unsafe.Pointer(color_cache)).colors_ = uintptr(0)
}
}
func VP8LColorCacheCopy(tls *libc.TLS, src uintptr, dst uintptr) { /* color_cache_utils.c:42:6: */
libc.Xmemcpy(tls, (*VP8LColorCache)(unsafe.Pointer(dst)).colors_, (*VP8LColorCache)(unsafe.Pointer(src)).colors_,
- ((size_t(uint64(1)) << (*VP8LColorCache)(unsafe.Pointer(dst)).hash_bits_) * size_t(unsafe.Sizeof(uint32_t(0)))))
+ size_t(uint64(1))<<(*VP8LColorCache)(unsafe.Pointer(dst)).hash_bits_*size_t(unsafe.Sizeof(uint32_t(0))))
}
// -----------------------------------------------------------------------------
// Quick estimate of a potentially interesting filter mode to try.
func GradientPredictor(tls *libc.TLS, a uint8_t, b uint8_t, c uint8_t) int32 { /* filters_utils.c:24:24: */
- var g int32 = ((int32(a) + int32(b)) - int32(c))
- if (g & libc.CplInt32(0xff)) == 0 {
+ var g int32 = int32(a) + int32(b) - int32(c)
+ if g&libc.CplInt32(0xff) == 0 {
return g
}
if g < 0 {
@@ -39320,23 +39022,23 @@ func WebPEstimateBestFilter(tls *libc.TLS, data uintptr, width int32, height int
var j int32
// var bins [4][16]int32 at bp, 256
- libc.Xmemset(tls, (bp) /* &bins[0] */, 0, uint64(unsafe.Sizeof([4][16]int32{})))
+ libc.Xmemset(tls, bp, 0, uint64(unsafe.Sizeof([4][16]int32{})))
// We only sample every other pixels. That's enough.
- for j = 2; j < (height - 1); j = j + (2) {
- var p uintptr = (data + uintptr((j * stride)))
+ for j = 2; j < height-1; j = j + 2 {
+ var p uintptr = data + uintptr(j*stride)
var mean int32 = int32(*(*uint8_t)(unsafe.Pointer(p)))
- for i = 2; i < (width - 1); i = i + (2) {
- var diff0 int32 = (libc.Xabs(tls, ((int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i)))))-(mean))) >> 4)
- var diff1 int32 = (libc.Xabs(tls, ((int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i)))))-(int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((i - 1)))))))) >> 4)
- var diff2 int32 = (libc.Xabs(tls, ((int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i)))))-(int32(*(*uint8_t)(unsafe.Pointer(p + uintptr((i - width)))))))) >> 4)
- var grad_pred int32 = GradientPredictor(tls, *(*uint8_t)(unsafe.Pointer(p + uintptr((i - 1)))), *(*uint8_t)(unsafe.Pointer(p + uintptr((i - width)))), *(*uint8_t)(unsafe.Pointer(p + uintptr(((i - width) - 1)))))
- var diff3 int32 = (libc.Xabs(tls, ((int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i)))))-(grad_pred))) >> 4)
- *(*int32)(unsafe.Pointer((bp) /* &bins[0] */ + uintptr(diff0)*4)) = 1
- *(*int32)(unsafe.Pointer(((bp) /* &bins[0] */ + 1*64) + uintptr(diff1)*4)) = 1
- *(*int32)(unsafe.Pointer(((bp) /* &bins[0] */ + 2*64) + uintptr(diff2)*4)) = 1
- *(*int32)(unsafe.Pointer(((bp) /* &bins[0] */ + 3*64) + uintptr(diff3)*4)) = 1
- mean = ((((3 * mean) + int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i))))) + 2) >> 2)
+ for i = 2; i < width-1; i = i + 2 {
+ var diff0 int32 = libc.Xabs(tls, int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i))))-mean) >> 4
+ var diff1 int32 = libc.Xabs(tls, int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i))))-int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i-1))))) >> 4
+ var diff2 int32 = libc.Xabs(tls, int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i))))-int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i-width))))) >> 4
+ var grad_pred int32 = GradientPredictor(tls, *(*uint8_t)(unsafe.Pointer(p + uintptr(i-1))), *(*uint8_t)(unsafe.Pointer(p + uintptr(i-width))), *(*uint8_t)(unsafe.Pointer(p + uintptr(i-width-1))))
+ var diff3 int32 = libc.Xabs(tls, int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i))))-grad_pred) >> 4
+ *(*int32)(unsafe.Pointer(bp + uintptr(diff0)*4)) = 1
+ *(*int32)(unsafe.Pointer(bp + 1*64 + uintptr(diff1)*4)) = 1
+ *(*int32)(unsafe.Pointer(bp + 2*64 + uintptr(diff2)*4)) = 1
+ *(*int32)(unsafe.Pointer(bp + 3*64 + uintptr(diff3)*4)) = 1
+ mean = (3*mean + int32(*(*uint8_t)(unsafe.Pointer(p + uintptr(i)))) + 2) >> 2
}
}
{
@@ -39346,8 +39048,8 @@ func WebPEstimateBestFilter(tls *libc.TLS, data uintptr, width int32, height int
for filter = WEBP_FILTER_NONE; filter < WEBP_FILTER_LAST; filter++ {
var score int32 = 0
for i = 0; i < 16; i++ {
- if *(*int32)(unsafe.Pointer(((bp) /* &bins[0] */ + uintptr(filter)*64) + uintptr(i)*4)) > 0 {
- score = score + (i)
+ if *(*int32)(unsafe.Pointer(bp + uintptr(filter)*64 + uintptr(i)*4)) > 0 {
+ score = score + i
}
}
if score < best_score {
@@ -39375,7 +39077,7 @@ func WebPEstimateBestFilter(tls *libc.TLS, data uintptr, width int32, height int
// Heuristics for selecting the stride ranges to collapse.
func ValuesShouldBeCollapsedToStrideAverage(tls *libc.TLS, a int32, b int32) int32 { /* huffman_encode_utils.c:25:12: */
- return (libc.Bool32(libc.Xabs(tls, (a-b)) < 4))
+ return libc.Bool32(libc.Xabs(tls, a-b) < 4)
}
// Change the population counts in a way that the consequent
@@ -39387,7 +39089,7 @@ func OptimizeHuffmanForRle(tls *libc.TLS, length int32, good_for_rle uintptr, co
if length == 0 {
return // All zeros.
}
- if *(*uint32_t)(unsafe.Pointer(counts + uintptr((length-1))*4)) != uint32_t(0) {
+ if *(*uint32_t)(unsafe.Pointer(counts + uintptr(length-1)*4)) != uint32_t(0) {
// Now counts[0..length - 1] does not have trailing zeros.
break
}
@@ -39400,12 +39102,12 @@ func OptimizeHuffmanForRle(tls *libc.TLS, length int32, good_for_rle uintptr, co
// Mark any seq of non-0's that is longer as 7 as a good_for_rle.
var symbol uint32_t = *(*uint32_t)(unsafe.Pointer(counts))
var stride int32 = 0
- for i = 0; i < (length + 1); i++ {
- if (i == length) || (*(*uint32_t)(unsafe.Pointer(counts + uintptr(i)*4)) != symbol) {
- if ((symbol == uint32_t(0)) && (stride >= 5)) || ((symbol != uint32_t(0)) && (stride >= 7)) {
+ for i = 0; i < length+1; i++ {
+ if i == length || *(*uint32_t)(unsafe.Pointer(counts + uintptr(i)*4)) != symbol {
+ if symbol == uint32_t(0) && stride >= 5 || symbol != uint32_t(0) && stride >= 7 {
var k int32
for k = 0; k < stride; k++ {
- *(*uint8_t)(unsafe.Pointer(good_for_rle + uintptr(((i - k) - 1)))) = uint8_t(1)
+ *(*uint8_t)(unsafe.Pointer(good_for_rle + uintptr(i-k-1))) = uint8_t(1)
}
}
stride = 1
@@ -39423,12 +39125,12 @@ func OptimizeHuffmanForRle(tls *libc.TLS, length int32, good_for_rle uintptr, co
var stride uint32_t = uint32_t(0)
var limit uint32_t = *(*uint32_t)(unsafe.Pointer(counts))
var sum uint32_t = uint32_t(0)
- for i = 0; i < (length + 1); i++ {
- if (((i == length) || (*(*uint8_t)(unsafe.Pointer(good_for_rle + uintptr(i))) != 0)) || ((i != 0) && (*(*uint8_t)(unsafe.Pointer(good_for_rle + uintptr((i - 1)))) != 0))) || !(ValuesShouldBeCollapsedToStrideAverage(tls, int32(*(*uint32_t)(unsafe.Pointer(counts + uintptr(i)*4))), int32(limit)) != 0) {
- if (stride >= uint32_t(4)) || ((stride >= uint32_t(3)) && (sum == uint32_t(0))) {
+ for i = 0; i < length+1; i++ {
+ if i == length || *(*uint8_t)(unsafe.Pointer(good_for_rle + uintptr(i))) != 0 || i != 0 && *(*uint8_t)(unsafe.Pointer(good_for_rle + uintptr(i-1))) != 0 || !(ValuesShouldBeCollapsedToStrideAverage(tls, int32(*(*uint32_t)(unsafe.Pointer(counts + uintptr(i)*4))), int32(limit)) != 0) {
+ if stride >= uint32_t(4) || stride >= uint32_t(3) && sum == uint32_t(0) {
var k uint32_t
// The stride must end, collapse what we have, if we have enough (4).
- var count uint32_t = ((sum + (stride / uint32_t(2))) / stride)
+ var count uint32_t = (sum + stride/uint32_t(2)) / stride
if count < uint32_t(1) {
count = uint32_t(1)
}
@@ -39439,15 +39141,15 @@ func OptimizeHuffmanForRle(tls *libc.TLS, length int32, good_for_rle uintptr, co
for k = uint32_t(0); k < stride; k++ {
// We don't want to change value at counts[i],
// that is already belonging to the next stride. Thus - 1.
- *(*uint32_t)(unsafe.Pointer(counts + uintptr(((uint32_t(i)-k)-uint32_t(1)))*4)) = count
+ *(*uint32_t)(unsafe.Pointer(counts + uintptr(uint32_t(i)-k-uint32_t(1))*4)) = count
}
}
stride = uint32_t(0)
sum = uint32_t(0)
- if i < (length - 3) {
+ if i < length-3 {
// All interesting strides have a count of at least 4,
// at least when non-zeros.
- limit = (((((*(*uint32_t)(unsafe.Pointer(counts + uintptr(i)*4)) + *(*uint32_t)(unsafe.Pointer(counts + uintptr((i+1))*4))) + *(*uint32_t)(unsafe.Pointer(counts + uintptr((i+2))*4))) + *(*uint32_t)(unsafe.Pointer(counts + uintptr((i+3))*4))) + uint32_t(2)) / uint32_t(4))
+ limit = (*(*uint32_t)(unsafe.Pointer(counts + uintptr(i)*4)) + *(*uint32_t)(unsafe.Pointer(counts + uintptr(i+1)*4)) + *(*uint32_t)(unsafe.Pointer(counts + uintptr(i+2)*4)) + *(*uint32_t)(unsafe.Pointer(counts + uintptr(i+3)*4)) + uint32_t(2)) / uint32_t(4)
} else if i < length {
limit = *(*uint32_t)(unsafe.Pointer(counts + uintptr(i)*4))
} else {
@@ -39456,9 +39158,9 @@ func OptimizeHuffmanForRle(tls *libc.TLS, length int32, good_for_rle uintptr, co
}
stride++
if i != length {
- sum = sum + (*(*uint32_t)(unsafe.Pointer(counts + uintptr(i)*4)))
+ sum = sum + *(*uint32_t)(unsafe.Pointer(counts + uintptr(i)*4))
if stride >= uint32_t(4) {
- limit = ((sum + (stride / uint32_t(2))) / stride)
+ limit = (sum + stride/uint32_t(2)) / stride
}
}
}
@@ -39487,8 +39189,8 @@ func CompareHuffmanTrees(tls *libc.TLS, ptr1 uintptr, ptr2 uintptr) int32 { /* h
func SetBitDepths(tls *libc.TLS, tree uintptr, pool uintptr, bit_depths uintptr, level int32) { /* huffman_encode_utils.c:135:13: */
if (*HuffmanTree)(unsafe.Pointer(tree)).pool_index_left_ >= 0 {
- SetBitDepths(tls, (pool + uintptr((*HuffmanTree)(unsafe.Pointer(tree)).pool_index_left_)*16), pool, bit_depths, (level + 1))
- SetBitDepths(tls, (pool + uintptr((*HuffmanTree)(unsafe.Pointer(tree)).pool_index_right_)*16), pool, bit_depths, (level + 1))
+ SetBitDepths(tls, pool+uintptr((*HuffmanTree)(unsafe.Pointer(tree)).pool_index_left_)*16, pool, bit_depths, level+1)
+ SetBitDepths(tls, pool+uintptr((*HuffmanTree)(unsafe.Pointer(tree)).pool_index_right_)*16, pool, bit_depths, level+1)
} else {
*(*uint8_t)(unsafe.Pointer(bit_depths + uintptr((*HuffmanTree)(unsafe.Pointer(tree)).value_))) = uint8_t(level)
}
@@ -39529,14 +39231,14 @@ func GenerateOptimalTree(tls *libc.TLS, histogram uintptr, histogram_size int32,
return
}
- tree_pool = (tree + uintptr(tree_size_orig)*16)
+ tree_pool = tree + uintptr(tree_size_orig)*16
// For block sizes with less than 64k symbols we never need to do a
// second iteration of this loop.
// If we actually start running inside this loop a lot, we would perhaps
// be better off with the Katajainen algorithm.
- for count_min = uint32_t(1); ; count_min = count_min * (uint32_t(2)) {
+ for count_min = uint32_t(1); ; count_min = count_min * uint32_t(2) {
var tree_size int32 = tree_size_orig
// We need to pack the Huffman tree in tree_depth_limit bits.
// So, we try by faking histogram entries to be at least 'count_min'.
@@ -39567,10 +39269,10 @@ func GenerateOptimalTree(tls *libc.TLS, histogram uintptr, histogram_size int32,
var tree_pool_size int32 = 0
for tree_size > 1 { // Finish when we have only one root.
var count uint32_t
- *(*HuffmanTree)(unsafe.Pointer(tree_pool + uintptr(libc.PostIncInt32(&tree_pool_size, 1))*16)) = *(*HuffmanTree)(unsafe.Pointer(tree + uintptr((tree_size-1))*16))
- *(*HuffmanTree)(unsafe.Pointer(tree_pool + uintptr(libc.PostIncInt32(&tree_pool_size, 1))*16)) = *(*HuffmanTree)(unsafe.Pointer(tree + uintptr((tree_size-2))*16))
- count = ((*HuffmanTree)(unsafe.Pointer(tree_pool+uintptr((tree_pool_size-1))*16)).total_count_ + (*HuffmanTree)(unsafe.Pointer(tree_pool+uintptr((tree_pool_size-2))*16)).total_count_)
- tree_size = tree_size - (2)
+ *(*HuffmanTree)(unsafe.Pointer(tree_pool + uintptr(libc.PostIncInt32(&tree_pool_size, 1))*16)) = *(*HuffmanTree)(unsafe.Pointer(tree + uintptr(tree_size-1)*16))
+ *(*HuffmanTree)(unsafe.Pointer(tree_pool + uintptr(libc.PostIncInt32(&tree_pool_size, 1))*16)) = *(*HuffmanTree)(unsafe.Pointer(tree + uintptr(tree_size-2)*16))
+ count = (*HuffmanTree)(unsafe.Pointer(tree_pool+uintptr(tree_pool_size-1)*16)).total_count_ + (*HuffmanTree)(unsafe.Pointer(tree_pool+uintptr(tree_pool_size-2)*16)).total_count_
+ tree_size = tree_size - 2
{
// Search for the insertion point.
var k int32
@@ -39579,17 +39281,17 @@ func GenerateOptimalTree(tls *libc.TLS, histogram uintptr, histogram_size int32,
break
}
}
- libc.Xmemmove(tls, (tree + uintptr((k+1))*16), (tree + uintptr(k)*16), ((uint64(tree_size - k)) * uint64(unsafe.Sizeof(HuffmanTree{}))))
+ libc.Xmemmove(tls, tree+uintptr(k+1)*16, tree+uintptr(k)*16, uint64(tree_size-k)*uint64(unsafe.Sizeof(HuffmanTree{})))
(*HuffmanTree)(unsafe.Pointer(tree + uintptr(k)*16)).total_count_ = count
(*HuffmanTree)(unsafe.Pointer(tree + uintptr(k)*16)).value_ = -1
- (*HuffmanTree)(unsafe.Pointer(tree + uintptr(k)*16)).pool_index_left_ = (tree_pool_size - 1)
- (*HuffmanTree)(unsafe.Pointer(tree + uintptr(k)*16)).pool_index_right_ = (tree_pool_size - 2)
- tree_size = (tree_size + 1)
+ (*HuffmanTree)(unsafe.Pointer(tree + uintptr(k)*16)).pool_index_left_ = tree_pool_size - 1
+ (*HuffmanTree)(unsafe.Pointer(tree + uintptr(k)*16)).pool_index_right_ = tree_pool_size - 2
+ tree_size = tree_size + 1
}
}
- SetBitDepths(tls, (tree), tree_pool, bit_depths, 0)
+ SetBitDepths(tls, tree, tree_pool, bit_depths, 0)
} else if tree_size == 1 { // Trivial case: only one element.
*(*uint8_t)(unsafe.Pointer(bit_depths + uintptr((*HuffmanTree)(unsafe.Pointer(tree)).value_))) = uint8_t(1)
}
@@ -39632,14 +39334,14 @@ func CodeRepeatedValues(tls *libc.TLS, repetitions int32, tokens uintptr, value
break
} else if repetitions < 7 {
(*HuffmanTreeToken)(unsafe.Pointer(tokens)).code = uint8_t(16)
- (*HuffmanTreeToken)(unsafe.Pointer(tokens)).extra_bits = (uint8_t(repetitions - 3))
+ (*HuffmanTreeToken)(unsafe.Pointer(tokens)).extra_bits = uint8_t(repetitions - 3)
tokens += 2
break
} else {
(*HuffmanTreeToken)(unsafe.Pointer(tokens)).code = uint8_t(16)
(*HuffmanTreeToken)(unsafe.Pointer(tokens)).extra_bits = uint8_t(3)
tokens += 2
- repetitions = repetitions - (6)
+ repetitions = repetitions - 6
}
}
return tokens
@@ -39657,19 +39359,19 @@ func CodeRepeatedZeros(tls *libc.TLS, repetitions int32, tokens uintptr) uintptr
break
} else if repetitions < 11 {
(*HuffmanTreeToken)(unsafe.Pointer(tokens)).code = uint8_t(17)
- (*HuffmanTreeToken)(unsafe.Pointer(tokens)).extra_bits = (uint8_t(repetitions - 3))
+ (*HuffmanTreeToken)(unsafe.Pointer(tokens)).extra_bits = uint8_t(repetitions - 3)
tokens += 2
break
} else if repetitions < 139 {
(*HuffmanTreeToken)(unsafe.Pointer(tokens)).code = uint8_t(18)
- (*HuffmanTreeToken)(unsafe.Pointer(tokens)).extra_bits = (uint8_t(repetitions - 11))
+ (*HuffmanTreeToken)(unsafe.Pointer(tokens)).extra_bits = uint8_t(repetitions - 11)
tokens += 2
break
} else {
(*HuffmanTreeToken)(unsafe.Pointer(tokens)).code = uint8_t(18)
(*HuffmanTreeToken)(unsafe.Pointer(tokens)).extra_bits = uint8_t(0x7f) // 138 repeated 0s
tokens += 2
- repetitions = repetitions - (138)
+ repetitions = repetitions - 138
}
}
return tokens
@@ -39677,7 +39379,7 @@ func CodeRepeatedZeros(tls *libc.TLS, repetitions int32, tokens uintptr) uintptr
func VP8LCreateCompressedHuffmanTree(tls *libc.TLS, tree uintptr, tokens uintptr, max_tokens int32) int32 { /* huffman_encode_utils.c:326:5: */
var starting_token uintptr = tokens
- var ending_token uintptr = (tokens + uintptr(max_tokens)*2)
+ var ending_token uintptr = tokens + uintptr(max_tokens)*2
_ = ending_token
var depth_size int32 = (*HuffmanTreeCode)(unsafe.Pointer(tree)).num_symbols
var prev_value int32 = 8 // 8 is the initial value for rle.
@@ -39685,23 +39387,23 @@ func VP8LCreateCompressedHuffmanTree(tls *libc.TLS, tree uintptr, tokens uintptr
for i < depth_size {
var value int32 = int32(*(*uint8_t)(unsafe.Pointer((*HuffmanTreeCode)(unsafe.Pointer(tree)).code_lengths + uintptr(i))))
- var k int32 = (i + 1)
+ var k int32 = i + 1
var runs int32
- for (k < depth_size) && (int32(*(*uint8_t)(unsafe.Pointer((*HuffmanTreeCode)(unsafe.Pointer(tree)).code_lengths + uintptr(k)))) == value) {
+ for k < depth_size && int32(*(*uint8_t)(unsafe.Pointer((*HuffmanTreeCode)(unsafe.Pointer(tree)).code_lengths + uintptr(k)))) == value {
k++
}
- runs = (k - i)
+ runs = k - i
if value == 0 {
tokens = CodeRepeatedZeros(tls, runs, tokens)
} else {
tokens = CodeRepeatedValues(tls, runs, tokens, value, prev_value)
prev_value = value
}
- i = i + (runs)
+ i = i + runs
}
_ = ending_token // suppress 'unused variable' warning
- return (int32((int64(tokens) - int64(starting_token)) / 2))
+ return int32((int64(tokens) - int64(starting_token)) / 2)
}
// -----------------------------------------------------------------------------
@@ -39716,11 +39418,11 @@ func ReverseBits(tls *libc.TLS, num_bits int32, bits uint32_t) uint32_t { /* huf
var retval uint32_t = uint32_t(0)
var i int32 = 0
for i < num_bits {
- i = i + (4)
- retval = retval | (uint32_t(int32(kReversedBits[(bits&uint32_t(0xf))]) << ((15 + 1) - i)))
+ i = i + 4
+ retval = retval | uint32_t(int32(kReversedBits[bits&uint32_t(0xf)])<<(15+1-i))
bits >>= 4
}
- retval >>= ((15 + 1) - num_bits)
+ retval >>= 15 + 1 - num_bits
return retval
}
@@ -39740,21 +39442,21 @@ func ConvertBitDepthsToSymbols(tls *libc.TLS, tree uintptr) { /* huffman_encode_
for i = 0; i < len; i++ {
var code_length int32 = int32(*(*uint8_t)(unsafe.Pointer((*HuffmanTreeCode)(unsafe.Pointer(tree)).code_lengths + uintptr(i))))
- *(*int32)(unsafe.Pointer((bp) /* &depth_count[0] */ + uintptr(code_length)*4))++
+ *(*int32)(unsafe.Pointer(bp + uintptr(code_length)*4))++
}
- *(*int32)(unsafe.Pointer((bp) /* &depth_count[0] */)) = 0 // ignore unused symbol
- *(*uint32_t)(unsafe.Pointer((bp + 64) /* &next_code[0] */)) = uint32_t(0)
+ *(*int32)(unsafe.Pointer(bp)) = 0 // ignore unused symbol
+ *(*uint32_t)(unsafe.Pointer(bp + 64)) = uint32_t(0)
{
var code uint32_t = uint32_t(0)
for i = 1; i <= 15; i++ {
- code = ((code + uint32_t(*(*int32)(unsafe.Pointer((bp) /* &depth_count[0] */ + uintptr((i-1))*4)))) << 1)
- *(*uint32_t)(unsafe.Pointer((bp + 64) /* &next_code[0] */ + uintptr(i)*4)) = code
+ code = (code + uint32_t(*(*int32)(unsafe.Pointer(bp + uintptr(i-1)*4)))) << 1
+ *(*uint32_t)(unsafe.Pointer(bp + 64 + uintptr(i)*4)) = code
}
}
for i = 0; i < len; i++ {
var code_length int32 = int32(*(*uint8_t)(unsafe.Pointer((*HuffmanTreeCode)(unsafe.Pointer(tree)).code_lengths + uintptr(i))))
- *(*uint16_t)(unsafe.Pointer((*HuffmanTreeCode)(unsafe.Pointer(tree)).codes + uintptr(i)*2)) = uint16_t(ReverseBits(tls, code_length, libc.PostIncUint32(&*(*uint32_t)(unsafe.Pointer((bp + 64) /* &next_code[0] */ + uintptr(code_length)*4)), 1)))
+ *(*uint16_t)(unsafe.Pointer((*HuffmanTreeCode)(unsafe.Pointer(tree)).codes + uintptr(i)*2)) = uint16_t(ReverseBits(tls, code_length, libc.PostIncUint32(&*(*uint32_t)(unsafe.Pointer(bp + 64 + uintptr(code_length)*4)), 1)))
}
}
@@ -39763,7 +39465,7 @@ func ConvertBitDepthsToSymbols(tls *libc.TLS, tree uintptr) { /* huffman_encode_
func VP8LCreateHuffmanTree(tls *libc.TLS, histogram uintptr, tree_depth_limit int32, buf_rle uintptr, huff_tree uintptr, huff_code uintptr) { /* huffman_encode_utils.c:406:6: */
var num_symbols int32 = (*HuffmanTreeCode)(unsafe.Pointer(huff_code)).num_symbols
- libc.Xmemset(tls, buf_rle, 0, (uint64(num_symbols) * uint64(unsafe.Sizeof(uint8_t(0)))))
+ libc.Xmemset(tls, buf_rle, 0, uint64(num_symbols)*uint64(unsafe.Sizeof(uint8_t(0))))
OptimizeHuffmanForRle(tls, num_symbols, buf_rle, histogram)
GenerateOptimalTree(tls, histogram, num_symbols, huff_tree, tree_depth_limit,
(*HuffmanTreeCode)(unsafe.Pointer(huff_code)).code_lengths)
@@ -39791,15 +39493,15 @@ func VP8LCreateHuffmanTree(tls *libc.TLS, histogram uintptr, tree_depth_limit in
func VP8LHtreeGroupsNew(tls *libc.TLS, num_htree_groups int32) uintptr { /* huffman_utils.c:25:11: */
var htree_groups uintptr = WebPSafeMalloc(tls, uint64(num_htree_groups), uint64(unsafe.Sizeof(HTreeGroup{})))
- if htree_groups == (uintptr(0)) {
- return (uintptr(0))
+ if htree_groups == uintptr(0) {
+ return uintptr(0)
}
return htree_groups
}
func VP8LHtreeGroupsFree(tls *libc.TLS, htree_groups uintptr) { /* huffman_utils.c:35:6: */
- if htree_groups != (uintptr(0)) {
+ if htree_groups != uintptr(0) {
WebPSafeFree(tls, htree_groups)
}
}
@@ -39807,12 +39509,12 @@ func VP8LHtreeGroupsFree(tls *libc.TLS, htree_groups uintptr) { /* huffman_utils
// Returns reverse(reverse(key, len) + 1, len), where reverse(key, len) is the
// bit-wise reversal of the len least significant bits of key.
func GetNextKey(tls *libc.TLS, key uint32_t, len int32) uint32_t { /* huffman_utils.c:43:29: */
- var step uint32_t = (uint32_t(int32(1) << (len - 1)))
- for (key & step) != 0 {
+ var step uint32_t = uint32_t(int32(1) << (len - 1))
+ for key&step != 0 {
step >>= 1
}
if step != 0 {
- return ((key & (step - uint32_t(1))) + step)
+ return key&(step-uint32_t(1)) + step
}
return key
}
@@ -39821,8 +39523,8 @@ func GetNextKey(tls *libc.TLS, key uint32_t, len int32) uint32_t { /* huffman_ut
// Assumes that end is an integer multiple of step.
func ReplicateValue(tls *libc.TLS, table uintptr, step int32, end int32, code HuffmanCode) { /* huffman_utils.c:53:25: */
- for ok := true; ok; ok = (end > 0) {
- end = end - (step)
+ for __ccgo := true; __ccgo; __ccgo = end > 0 {
+ end = end - step
*(*HuffmanCode)(unsafe.Pointer(table + uintptr(end)*4)) = code
}
}
@@ -39831,16 +39533,16 @@ func ReplicateValue(tls *libc.TLS, table uintptr, step int32, end int32, code Hu
// of bit lengths for the remaining symbols, len is the code length of the next
// processed symbol
func NextTableBitSize(tls *libc.TLS, count uintptr, len int32, root_bits int32) int32 { /* huffman_utils.c:66:24: */
- var left int32 = (int32(1) << (len - root_bits))
+ var left int32 = int32(1) << (len - root_bits)
for len < 15 {
- left = left - (*(*int32)(unsafe.Pointer(count + uintptr(len)*4)))
+ left = left - *(*int32)(unsafe.Pointer(count + uintptr(len)*4))
if left <= 0 {
break
}
len++
left <<= 1
}
- return (len - root_bits)
+ return len - root_bits
}
// sorted[code_lengths_size] is a pre-allocated array for sorting symbols
@@ -39849,10 +39551,10 @@ func BuildHuffmanTable(tls *libc.TLS, root_table uintptr, root_bits int32, code_
bp := tls.Alloc(128)
defer tls.Free(128)
- var table uintptr = root_table // next available space in table
- var total_size int32 = (int32(1) << root_bits) // total size root table + 2nd level table
- var len int32 // current code length
- var symbol int32 // symbol index in original or sorted table
+ var table uintptr = root_table // next available space in table
+ var total_size int32 = int32(1) << root_bits // total size root table + 2nd level table
+ var len int32 // current code length
+ var symbol int32 // symbol index in original or sorted table
// number of codes of each length:
*(*[16]int32)(unsafe.Pointer(bp /* count */)) = [16]int32{0: 0}
// offsets in sorted table for each length:
@@ -39863,38 +39565,38 @@ func BuildHuffmanTable(tls *libc.TLS, root_table uintptr, root_bits int32, code_
if *(*int32)(unsafe.Pointer(code_lengths + uintptr(symbol)*4)) > 15 {
return 0
}
- *(*int32)(unsafe.Pointer((bp) /* &count[0] */ + uintptr(*(*int32)(unsafe.Pointer(code_lengths + uintptr(symbol)*4)))*4))++
+ *(*int32)(unsafe.Pointer(bp + uintptr(*(*int32)(unsafe.Pointer(code_lengths + uintptr(symbol)*4)))*4))++
}
// Error, all code lengths are zeros.
- if *(*int32)(unsafe.Pointer((bp) /* &count[0] */)) == code_lengths_size {
+ if *(*int32)(unsafe.Pointer(bp)) == code_lengths_size {
return 0
}
// Generate offsets into sorted symbol table by code length.
- *(*int32)(unsafe.Pointer((bp + 64) /* &offset[0] */ + 1*4)) = 0
+ *(*int32)(unsafe.Pointer(bp + 64 + 1*4)) = 0
for len = 1; len < 15; len++ {
- if *(*int32)(unsafe.Pointer((bp) /* &count[0] */ + uintptr(len)*4)) > (int32(1) << len) {
+ if *(*int32)(unsafe.Pointer(bp + uintptr(len)*4)) > int32(1)<<len {
return 0
}
- *(*int32)(unsafe.Pointer((bp + 64) /* &offset[0] */ + uintptr((len+1))*4)) = (*(*int32)(unsafe.Pointer((bp + 64) /* &offset[0] */ + uintptr(len)*4)) + *(*int32)(unsafe.Pointer((bp) /* &count[0] */ + uintptr(len)*4)))
+ *(*int32)(unsafe.Pointer(bp + 64 + uintptr(len+1)*4)) = *(*int32)(unsafe.Pointer(bp + 64 + uintptr(len)*4)) + *(*int32)(unsafe.Pointer(bp + uintptr(len)*4))
}
// Sort symbols by length, by symbol order within each length.
for symbol = 0; symbol < code_lengths_size; symbol++ {
var symbol_code_length int32 = *(*int32)(unsafe.Pointer(code_lengths + uintptr(symbol)*4))
if *(*int32)(unsafe.Pointer(code_lengths + uintptr(symbol)*4)) > 0 {
- if sorted != (uintptr(0)) {
- *(*uint16_t)(unsafe.Pointer(sorted + uintptr(libc.PostIncInt32(&*(*int32)(unsafe.Pointer((bp + 64) /* &offset[0] */ + uintptr(symbol_code_length)*4)), 1))*2)) = uint16_t(symbol)
+ if sorted != uintptr(0) {
+ *(*uint16_t)(unsafe.Pointer(sorted + uintptr(libc.PostIncInt32(&*(*int32)(unsafe.Pointer(bp + 64 + uintptr(symbol_code_length)*4)), 1))*2)) = uint16_t(symbol)
} else {
- *(*int32)(unsafe.Pointer((bp + 64) /* &offset[0] */ + uintptr(symbol_code_length)*4))++
+ *(*int32)(unsafe.Pointer(bp + 64 + uintptr(symbol_code_length)*4))++
}
}
}
// Special case code with only one value.
- if *(*int32)(unsafe.Pointer((bp + 64) /* &offset[0] */ + 15*4)) == 1 {
- if sorted != (uintptr(0)) {
+ if *(*int32)(unsafe.Pointer(bp + 64 + 15*4)) == 1 {
+ if sorted != uintptr(0) {
var code HuffmanCode
code.bits = uint8_t(0)
code.value = *(*uint16_t)(unsafe.Pointer(sorted))
@@ -39904,14 +39606,14 @@ func BuildHuffmanTable(tls *libc.TLS, root_table uintptr, root_bits int32, code_
}
{
- var step int32 // step size to replicate values in current table
- var low uint32_t = libc.Uint32FromInt32(-1) // low bits for current root entry
- var mask uint32_t = (uint32_t(total_size - 1)) // mask for low bits
- var key uint32_t = uint32_t(0) // reversed prefix code
- var num_nodes int32 = 1 // number of Huffman tree nodes
- var num_open int32 = 1 // number of open branches in current tree level
- var table_bits int32 = root_bits // key length of current table
- var table_size int32 = (int32(1) << table_bits) // size of current table
+ var step int32 // step size to replicate values in current table
+ var low uint32_t = libc.Uint32FromInt32(-1) // low bits for current root entry
+ var mask uint32_t = uint32_t(total_size - 1) // mask for low bits
+ var key uint32_t = uint32_t(0) // reversed prefix code
+ var num_nodes int32 = 1 // number of Huffman tree nodes
+ var num_open int32 = 1 // number of open branches in current tree level
+ var table_bits int32 = root_bits // key length of current table
+ var table_size int32 = int32(1) << table_bits // size of current table
symbol = 0
// Fill in root table.
len = 1
@@ -39922,19 +39624,19 @@ func BuildHuffmanTable(tls *libc.TLS, root_table uintptr, root_bits int32, code_
}
{
num_open <<= 1
- num_nodes = num_nodes + (num_open)
- num_open = num_open - (*(*int32)(unsafe.Pointer((bp) /* &count[0] */ + uintptr(len)*4)))
+ num_nodes = num_nodes + num_open
+ num_open = num_open - *(*int32)(unsafe.Pointer(bp + uintptr(len)*4))
if num_open < 0 {
return 0
}
- if root_table == (uintptr(0)) {
+ if root_table == uintptr(0) {
goto __2
}
- for ; *(*int32)(unsafe.Pointer((bp) /* &count[0] */ + uintptr(len)*4)) > 0; *(*int32)(unsafe.Pointer((bp) /* &count[0] */ + uintptr(len)*4))-- {
+ for ; *(*int32)(unsafe.Pointer(bp + uintptr(len)*4)) > 0; *(*int32)(unsafe.Pointer(bp + uintptr(len)*4))-- {
var code HuffmanCode
code.bits = uint8_t(len)
code.value = *(*uint16_t)(unsafe.Pointer(sorted + uintptr(libc.PostIncInt32(&symbol, 1))*2))
- ReplicateValue(tls, (table + uintptr(key)*4), step, table_size, code)
+ ReplicateValue(tls, table+uintptr(key)*4, step, table_size, code)
key = GetNextKey(tls, key, len)
}
@@ -39949,7 +39651,7 @@ func BuildHuffmanTable(tls *libc.TLS, root_table uintptr, root_bits int32, code_
;
// Fill in 2nd level tables and add pointers to root table.
- len = (root_bits + 1)
+ len = root_bits + 1
step = 2
__4:
if !(len <= 15) {
@@ -39957,28 +39659,28 @@ func BuildHuffmanTable(tls *libc.TLS, root_table uintptr, root_bits int32, code_
}
{
num_open <<= 1
- num_nodes = num_nodes + (num_open)
- num_open = num_open - (*(*int32)(unsafe.Pointer((bp) /* &count[0] */ + uintptr(len)*4)))
+ num_nodes = num_nodes + num_open
+ num_open = num_open - *(*int32)(unsafe.Pointer(bp + uintptr(len)*4))
if num_open < 0 {
return 0
}
- if root_table == (uintptr(0)) {
+ if root_table == uintptr(0) {
goto __5
}
- for ; *(*int32)(unsafe.Pointer((bp) /* &count[0] */ + uintptr(len)*4)) > 0; *(*int32)(unsafe.Pointer((bp) /* &count[0] */ + uintptr(len)*4))-- {
+ for ; *(*int32)(unsafe.Pointer(bp + uintptr(len)*4)) > 0; *(*int32)(unsafe.Pointer(bp + uintptr(len)*4))-- {
var code HuffmanCode
- if (key & mask) != low {
- table += 4 * (uintptr(table_size))
- table_bits = NextTableBitSize(tls, (bp) /* &count[0] */, len, root_bits)
- table_size = (int32(1) << table_bits)
- total_size = total_size + (table_size)
- low = (key & mask)
- (*HuffmanCode)(unsafe.Pointer(root_table + uintptr(low)*4)).bits = (uint8_t(table_bits + root_bits))
- (*HuffmanCode)(unsafe.Pointer(root_table + uintptr(low)*4)).value = (uint16_t(((int64(table) - int64(root_table)) / 4) - int64(low)))
+ if key&mask != low {
+ table += 4 * uintptr(table_size)
+ table_bits = NextTableBitSize(tls, bp, len, root_bits)
+ table_size = int32(1) << table_bits
+ total_size = total_size + table_size
+ low = key & mask
+ (*HuffmanCode)(unsafe.Pointer(root_table + uintptr(low)*4)).bits = uint8_t(table_bits + root_bits)
+ (*HuffmanCode)(unsafe.Pointer(root_table + uintptr(low)*4)).value = uint16_t((int64(table)-int64(root_table))/4 - int64(low))
}
- code.bits = (uint8_t(len - root_bits))
+ code.bits = uint8_t(len - root_bits)
code.value = *(*uint16_t)(unsafe.Pointer(sorted + uintptr(libc.PostIncInt32(&symbol, 1))*2))
- ReplicateValue(tls, (table + uintptr((key>>root_bits))*4), step, table_size, code)
+ ReplicateValue(tls, table+uintptr(key>>root_bits)*4, step, table_size, code)
key = GetNextKey(tls, key, len)
}
@@ -39993,7 +39695,7 @@ func BuildHuffmanTable(tls *libc.TLS, root_table uintptr, root_bits int32, code_
;
// Check if tree is full.
- if num_nodes != ((2 * *(*int32)(unsafe.Pointer((bp + 64) /* &offset[0] */ + 15*4))) - 1) {
+ if num_nodes != 2**(*int32)(unsafe.Pointer(bp + 64 + 15*4))-1 {
return 0
}
@@ -40011,18 +39713,18 @@ func VP8LBuildHuffmanTable(tls *libc.TLS, root_table uintptr, root_bits int32, c
var total_size int32
- if root_table == (uintptr(0)) {
- total_size = BuildHuffmanTable(tls, (uintptr(0)), root_bits,
- code_lengths, code_lengths_size, (uintptr(0)))
+ if root_table == uintptr(0) {
+ total_size = BuildHuffmanTable(tls, uintptr(0), root_bits,
+ code_lengths, code_lengths_size, uintptr(0))
} else if code_lengths_size <= 512 {
// use local stack-allocated array.
// var sorted [512]uint16_t at bp, 1024
total_size = BuildHuffmanTable(tls, root_table, root_bits,
- code_lengths, code_lengths_size, (bp) /* &sorted[0] */)
+ code_lengths, code_lengths_size, bp)
} else { // rare case. Use heap allocation.
var sorted uintptr = WebPSafeMalloc(tls, uint64(code_lengths_size), uint64(unsafe.Sizeof(uint16_t(0))))
- if sorted == (uintptr(0)) {
+ if sorted == uintptr(0) {
return 0
}
total_size = BuildHuffmanTable(tls, root_table, root_bits,
@@ -40061,8 +39763,8 @@ type SmoothParams = struct {
//------------------------------------------------------------------------------
func clip_8b3(tls *libc.TLS, v int32) uint8_t { /* quant_levels_dec_utils.c:75:28: */
- if !((v & (libc.Int32FromUint32(libc.Uint32(libc.CplUint32(libc.Uint32(0))) << (8 + 0)))) != 0) {
- return (uint8_t(v >> 0))
+ if !(v&libc.Int32FromUint32(libc.Uint32(libc.CplUint32(libc.Uint32(0)))<<(8+0)) != 0) {
+ return uint8_t(v >> 0)
}
if v < 0 {
return uint8(0)
@@ -40082,21 +39784,21 @@ func VFilter(tls *libc.TLS, p uintptr) { /* quant_levels_dec_utils.c:81:13: */
for x = 0; x < w; x++ {
var new_value uint16_t
- sum = uint16_t(int32(sum) + (int32(*(*uint8_t)(unsafe.Pointer(src + uintptr(x))))))
- new_value = (uint16_t(int32(*(*uint16_t)(unsafe.Pointer(top + uintptr(x)*2))) + int32(sum)))
- *(*uint16_t)(unsafe.Pointer(out + uintptr(x)*2)) = (uint16_t(int32(new_value) - int32(*(*uint16_t)(unsafe.Pointer(cur + uintptr(x)*2))))) // vertical sum of 'r' pixels.
+ sum = uint16_t(int32(sum) + int32(*(*uint8_t)(unsafe.Pointer(src + uintptr(x)))))
+ new_value = uint16_t(int32(*(*uint16_t)(unsafe.Pointer(top + uintptr(x)*2))) + int32(sum))
+ *(*uint16_t)(unsafe.Pointer(out + uintptr(x)*2)) = uint16_t(int32(new_value) - int32(*(*uint16_t)(unsafe.Pointer(cur + uintptr(x)*2)))) // vertical sum of 'r' pixels.
*(*uint16_t)(unsafe.Pointer(cur + uintptr(x)*2)) = new_value
}
// move input pointers one row down
(*SmoothParams)(unsafe.Pointer(p)).top_ = (*SmoothParams)(unsafe.Pointer(p)).cur_
- *(*uintptr)(unsafe.Pointer((p + 56 /* &.cur_ */))) += (uintptr(w)) * 2
+ *(*uintptr)(unsafe.Pointer(p + 56)) += uintptr(w) * 2
if (*SmoothParams)(unsafe.Pointer(p)).cur_ == (*SmoothParams)(unsafe.Pointer(p)).end_ {
(*SmoothParams)(unsafe.Pointer(p)).cur_ = (*SmoothParams)(unsafe.Pointer(p)).start_
} // roll-over
// We replicate edges, as it's somewhat easier as a boundary condition.
// That's why we don't update the 'src' pointer on top/bottom area:
- if ((*SmoothParams)(unsafe.Pointer(p)).row_ >= 0) && ((*SmoothParams)(unsafe.Pointer(p)).row_ < ((*SmoothParams)(unsafe.Pointer(p)).height_ - 1)) {
- *(*uintptr)(unsafe.Pointer((p + 16 /* &.src_ */))) += (uintptr((*SmoothParams)(unsafe.Pointer(p)).stride_))
+ if (*SmoothParams)(unsafe.Pointer(p)).row_ >= 0 && (*SmoothParams)(unsafe.Pointer(p)).row_ < (*SmoothParams)(unsafe.Pointer(p)).height_-1 {
+ *(*uintptr)(unsafe.Pointer(p + 16)) += uintptr((*SmoothParams)(unsafe.Pointer(p)).stride_)
}
}
@@ -40110,16 +39812,16 @@ func HFilter(tls *libc.TLS, p uintptr) { /* quant_levels_dec_utils.c:110:13: */
var r int32 = (*SmoothParams)(unsafe.Pointer(p)).radius_
var x int32
for x = 0; x <= r; x++ { // left mirroring
- var delta uint16_t = (uint16_t(int32(*(*uint16_t)(unsafe.Pointer(in + uintptr(((x+r)-1))*2))) + int32(*(*uint16_t)(unsafe.Pointer(in + uintptr((r-x))*2)))))
- *(*uint16_t)(unsafe.Pointer(out + uintptr(x)*2)) = (uint16_t((uint32_t(delta) * scale) >> 16))
+ var delta uint16_t = uint16_t(int32(*(*uint16_t)(unsafe.Pointer(in + uintptr(x+r-1)*2))) + int32(*(*uint16_t)(unsafe.Pointer(in + uintptr(r-x)*2))))
+ *(*uint16_t)(unsafe.Pointer(out + uintptr(x)*2)) = uint16_t(uint32_t(delta) * scale >> 16)
}
- for ; x < (w - r); x++ { // bulk middle run
- var delta uint16_t = (uint16_t(int32(*(*uint16_t)(unsafe.Pointer(in + uintptr((x+r))*2))) - int32(*(*uint16_t)(unsafe.Pointer(in + uintptr(((x-r)-1))*2)))))
- *(*uint16_t)(unsafe.Pointer(out + uintptr(x)*2)) = (uint16_t((uint32_t(delta) * scale) >> 16))
+ for ; x < w-r; x++ { // bulk middle run
+ var delta uint16_t = uint16_t(int32(*(*uint16_t)(unsafe.Pointer(in + uintptr(x+r)*2))) - int32(*(*uint16_t)(unsafe.Pointer(in + uintptr(x-r-1)*2))))
+ *(*uint16_t)(unsafe.Pointer(out + uintptr(x)*2)) = uint16_t(uint32_t(delta) * scale >> 16)
}
for ; x < w; x++ { // right mirroring
- var delta uint16_t = (uint16_t(((2 * int32(*(*uint16_t)(unsafe.Pointer(in + uintptr((w-1))*2)))) - int32(*(*uint16_t)(unsafe.Pointer(in + uintptr(((((2*w)-2)-r)-x))*2)))) - int32(*(*uint16_t)(unsafe.Pointer(in + uintptr(((x-r)-1))*2)))))
- *(*uint16_t)(unsafe.Pointer(out + uintptr(x)*2)) = (uint16_t((uint32_t(delta) * scale) >> 16))
+ var delta uint16_t = uint16_t(2*int32(*(*uint16_t)(unsafe.Pointer(in + uintptr(w-1)*2))) - int32(*(*uint16_t)(unsafe.Pointer(in + uintptr(2*w-2-r-x)*2))) - int32(*(*uint16_t)(unsafe.Pointer(in + uintptr(x-r-1)*2))))
+ *(*uint16_t)(unsafe.Pointer(out + uintptr(x)*2)) = uint16_t(uint32_t(delta) * scale >> 16)
}
}
@@ -40132,12 +39834,12 @@ func ApplyFilter(tls *libc.TLS, p uintptr) { /* quant_levels_dec_utils.c:134:13:
var x int32
for x = 0; x < w; x++ {
var v int32 = int32(*(*uint8_t)(unsafe.Pointer(dst + uintptr(x))))
- if (v < (*SmoothParams)(unsafe.Pointer(p)).max_) && (v > (*SmoothParams)(unsafe.Pointer(p)).min_) {
- var c int32 = ((v << 0) + int32(*(*int16_t)(unsafe.Pointer(correction + uintptr((int32(*(*uint16_t)(unsafe.Pointer(average + uintptr(x)*2)))-(v<<2)))*2))))
+ if v < (*SmoothParams)(unsafe.Pointer(p)).max_ && v > (*SmoothParams)(unsafe.Pointer(p)).min_ {
+ var c int32 = v<<0 + int32(*(*int16_t)(unsafe.Pointer(correction + uintptr(int32(*(*uint16_t)(unsafe.Pointer(average + uintptr(x)*2)))-v<<2)*2)))
*(*uint8_t)(unsafe.Pointer(dst + uintptr(x))) = clip_8b3(tls, c)
}
}
- *(*uintptr)(unsafe.Pointer((p + 24 /* &.dst_ */))) += (uintptr((*SmoothParams)(unsafe.Pointer(p)).stride_)) // advance output pointer
+ *(*uintptr)(unsafe.Pointer(p + 24)) += uintptr((*SmoothParams)(unsafe.Pointer(p)).stride_) // advance output pointer
}
//------------------------------------------------------------------------------
@@ -40150,18 +39852,18 @@ func InitCorrectionLUT(tls *libc.TLS, lut uintptr, min_dist int32) { /* quant_le
// and a linear interpolation for range x=[threshold2, threshold1]
// (along with f(-x) = -f(x) symmetry).
// Note that: threshold2 = 3/4 * threshold1
- var threshold1 int32 = (min_dist << 2)
- var threshold2 int32 = ((3 * threshold1) >> 2)
- var max_threshold int32 = (threshold2 << 0)
- var delta int32 = (threshold1 - threshold2)
+ var threshold1 int32 = min_dist << 2
+ var threshold2 int32 = 3 * threshold1 >> 2
+ var max_threshold int32 = threshold2 << 0
+ var delta int32 = threshold1 - threshold2
var i int32
- for i = 1; i <= ((int32(1) << (8 + 2)) - 1); i++ {
+ for i = 1; i <= int32(1)<<(8+2)-1; i++ {
var c int32
if i <= threshold2 {
- c = (i << 0)
+ c = i << 0
} else {
if i < threshold1 {
- c = ((max_threshold * (threshold1 - i)) / delta)
+ c = max_threshold * (threshold1 - i) / delta
} else {
c = 0
}
@@ -40193,18 +39895,18 @@ func CountLevels(tls *libc.TLS, p uintptr) { /* quant_levels_dec_utils.c:183:13:
if v > (*SmoothParams)(unsafe.Pointer(p)).max_ {
(*SmoothParams)(unsafe.Pointer(p)).max_ = v
}
- *(*uint8_t)(unsafe.Pointer((bp) /* &used_levels[0] */ + uintptr(v))) = uint8_t(1)
+ *(*uint8_t)(unsafe.Pointer(bp + uintptr(v))) = uint8_t(1)
}
data += uintptr((*SmoothParams)(unsafe.Pointer(p)).stride_)
}
// Compute the mininum distance between two non-zero levels.
- (*SmoothParams)(unsafe.Pointer(p)).min_level_dist_ = ((*SmoothParams)(unsafe.Pointer(p)).max_ - (*SmoothParams)(unsafe.Pointer(p)).min_)
+ (*SmoothParams)(unsafe.Pointer(p)).min_level_dist_ = (*SmoothParams)(unsafe.Pointer(p)).max_ - (*SmoothParams)(unsafe.Pointer(p)).min_
last_level = -1
for i = 0; i < 256; i++ {
- if *(*uint8_t)(unsafe.Pointer((bp) /* &used_levels[0] */ + uintptr(i))) != 0 {
+ if *(*uint8_t)(unsafe.Pointer(bp + uintptr(i))) != 0 {
(*SmoothParams)(unsafe.Pointer(p)).num_levels_++
if last_level >= 0 {
- var level_dist int32 = (i - last_level)
+ var level_dist int32 = i - last_level
if level_dist < (*SmoothParams)(unsafe.Pointer(p)).min_level_dist_ {
(*SmoothParams)(unsafe.Pointer(p)).min_level_dist_ = level_dist
}
@@ -40216,24 +39918,24 @@ func CountLevels(tls *libc.TLS, p uintptr) { /* quant_levels_dec_utils.c:183:13:
// Initialize all params.
func InitParams(tls *libc.TLS, data uintptr, width int32, height int32, stride int32, radius int32, p uintptr) int32 { /* quant_levels_dec_utils.c:216:12: */
- var R int32 = ((2 * radius) + 1) // total size of the kernel
+ var R int32 = 2*radius + 1 // total size of the kernel
- var size_scratch_m size_t = ((uint64((R + 1) * width)) * uint64(unsafe.Sizeof(uint16_t(0))))
- var size_m size_t = (uint64(width) * uint64(unsafe.Sizeof(uint16_t(0))))
- var size_lut size_t = ((uint64(1 + (2 * ((int32(1) << (8 + 2)) - 1)))) * uint64(unsafe.Sizeof(int16_t(0))))
- var total_size size_t = ((size_scratch_m + size_m) + size_lut)
+ var size_scratch_m size_t = uint64((R+1)*width) * uint64(unsafe.Sizeof(uint16_t(0)))
+ var size_m size_t = uint64(width) * uint64(unsafe.Sizeof(uint16_t(0)))
+ var size_lut size_t = uint64(1+2*(int32(1)<<(8+2)-1)) * uint64(unsafe.Sizeof(int16_t(0)))
+ var total_size size_t = size_scratch_m + size_m + size_lut
var mem uintptr = WebPSafeMalloc(tls, uint64(1), total_size)
- if mem == (uintptr(0)) {
+ if mem == uintptr(0) {
return 0
}
(*SmoothParams)(unsafe.Pointer(p)).mem_ = mem
(*SmoothParams)(unsafe.Pointer(p)).start_ = mem
(*SmoothParams)(unsafe.Pointer(p)).cur_ = (*SmoothParams)(unsafe.Pointer(p)).start_
- (*SmoothParams)(unsafe.Pointer(p)).end_ = ((*SmoothParams)(unsafe.Pointer(p)).start_ + uintptr((R*width))*2)
- (*SmoothParams)(unsafe.Pointer(p)).top_ = ((*SmoothParams)(unsafe.Pointer(p)).end_ - uintptr(width)*2)
- libc.Xmemset(tls, (*SmoothParams)(unsafe.Pointer(p)).top_, 0, (uint64(width) * uint64(unsafe.Sizeof(uint16_t(0)))))
+ (*SmoothParams)(unsafe.Pointer(p)).end_ = (*SmoothParams)(unsafe.Pointer(p)).start_ + uintptr(R*width)*2
+ (*SmoothParams)(unsafe.Pointer(p)).top_ = (*SmoothParams)(unsafe.Pointer(p)).end_ - uintptr(width)*2
+ libc.Xmemset(tls, (*SmoothParams)(unsafe.Pointer(p)).top_, 0, uint64(width)*uint64(unsafe.Sizeof(uint16_t(0))))
mem += uintptr(size_scratch_m)
(*SmoothParams)(unsafe.Pointer(p)).average_ = mem
@@ -40245,14 +39947,14 @@ func InitParams(tls *libc.TLS, data uintptr, width int32, height int32, stride i
(*SmoothParams)(unsafe.Pointer(p)).src_ = data
(*SmoothParams)(unsafe.Pointer(p)).dst_ = data
(*SmoothParams)(unsafe.Pointer(p)).radius_ = radius
- (*SmoothParams)(unsafe.Pointer(p)).scale_ = ((int32(1) << (16 + 2)) / (R * R)) // normalization constant
+ (*SmoothParams)(unsafe.Pointer(p)).scale_ = int32(1) << (16 + 2) / (R * R) // normalization constant
(*SmoothParams)(unsafe.Pointer(p)).row_ = -radius
// analyze the input distribution so we can best-fit the threshold
CountLevels(tls, p)
// correction table
- (*SmoothParams)(unsafe.Pointer(p)).correction_ = ((mem) + uintptr(((int32(1)<<(8+2))-1))*2)
+ (*SmoothParams)(unsafe.Pointer(p)).correction_ = mem + uintptr(int32(1)<<(8+2)-1)*2
InitCorrectionLUT(tls, (*SmoothParams)(unsafe.Pointer(p)).correction_, (*SmoothParams)(unsafe.Pointer(p)).min_level_dist_)
return 1
@@ -40266,42 +39968,42 @@ func WebPDequantizeLevels(tls *libc.TLS, data uintptr, width int32, height int32
bp := tls.Alloc(112)
defer tls.Free(112)
- var radius int32 = ((4 * strength) / 100)
+ var radius int32 = 4 * strength / 100
- if (strength < 0) || (strength > 100) {
+ if strength < 0 || strength > 100 {
return 0
}
- if ((data == (uintptr(0))) || (width <= 0)) || (height <= 0) {
+ if data == uintptr(0) || width <= 0 || height <= 0 {
return 0
} // bad params
// limit the filter size to not exceed the image dimensions
- if ((2 * radius) + 1) > width {
- radius = ((width - 1) >> 1)
+ if 2*radius+1 > width {
+ radius = (width - 1) >> 1
}
- if ((2 * radius) + 1) > height {
- radius = ((height - 1) >> 1)
+ if 2*radius+1 > height {
+ radius = (height - 1) >> 1
}
if radius > 0 {
// var p SmoothParams at bp, 112
- libc.Xmemset(tls, (bp) /* &p */, 0, uint64(unsafe.Sizeof(SmoothParams{})))
- if !(InitParams(tls, data, width, height, stride, radius, (bp) /* &p */) != 0) {
+ libc.Xmemset(tls, bp, 0, uint64(unsafe.Sizeof(SmoothParams{})))
+ if !(InitParams(tls, data, width, height, stride, radius, bp) != 0) {
return 0
}
- if (*SmoothParams)(unsafe.Pointer(bp /* &p */)).num_levels_ > 2 {
- for ; (*SmoothParams)(unsafe.Pointer(bp /* &p */)).row_ < (*SmoothParams)(unsafe.Pointer(bp /* &p */)).height_; (*SmoothParams)(unsafe.Pointer(bp /* &p */)).row_++ {
- VFilter(tls, (bp) /* &p */) // accumulate average of input
+ if (*SmoothParams)(unsafe.Pointer(bp)).num_levels_ > 2 {
+ for ; (*SmoothParams)(unsafe.Pointer(bp)).row_ < (*SmoothParams)(unsafe.Pointer(bp)).height_; (*SmoothParams)(unsafe.Pointer(bp /* &p */)).row_++ {
+ VFilter(tls, bp) // accumulate average of input
// Need to wait few rows in order to prime the filter,
// before emitting some output.
- if (*SmoothParams)(unsafe.Pointer(bp /* &p */)).row_ >= (*SmoothParams)(unsafe.Pointer(bp /* &p */)).radius_ {
- HFilter(tls, (bp) /* &p */)
- ApplyFilter(tls, (bp) /* &p */)
+ if (*SmoothParams)(unsafe.Pointer(bp)).row_ >= (*SmoothParams)(unsafe.Pointer(bp)).radius_ {
+ HFilter(tls, bp)
+ ApplyFilter(tls, bp)
}
}
}
- CleanupParams(tls, (bp) /* &p */)
+ CleanupParams(tls, bp)
}
return 1
}
@@ -40350,26 +40052,26 @@ func QuantizeLevels(tls *libc.TLS, data uintptr, width int32, height int32, num_
*(*[256]float64)(unsafe.Pointer(bp + 1024 /* inv_q_level */)) = [256]float64{0: float64(0)}
min_s = 255
max_s = 0
- data_size = (size_t(height * width))
+ data_size = size_t(height * width)
last_err = 1.e38
err = 0.
- err_threshold = (1e-4 * float64(data_size))
+ err_threshold = 1e-4 * float64(data_size)
- if !(data == (uintptr(0))) {
+ if !(data == uintptr(0)) {
goto __1
}
return 0
__1:
;
- if !((width <= 0) || (height <= 0)) {
+ if !(width <= 0 || height <= 0) {
goto __2
}
return 0
__2:
;
- if !((num_levels < 2) || (num_levels > 256)) {
+ if !(num_levels < 2 || num_levels > 256) {
goto __3
}
return 0
@@ -40382,7 +40084,7 @@ __4:
if !(n < data_size) {
goto __6
}
- num_levels_in = num_levels_in + (libc.Bool32(*(*int32)(unsafe.Pointer((bp) /* &freq[0] */ + uintptr(*(*uint8_t)(unsafe.Pointer(data + uintptr(n))))*4)) == 0))
+ num_levels_in = num_levels_in + libc.Bool32(*(*int32)(unsafe.Pointer(bp + uintptr(*(*uint8_t)(unsafe.Pointer(data + uintptr(n))))*4)) == 0)
if !(min_s > int32(*(*uint8_t)(unsafe.Pointer(data + uintptr(n))))) {
goto __7
}
@@ -40395,7 +40097,7 @@ __7:
max_s = int32(*(*uint8_t)(unsafe.Pointer(data + uintptr(n))))
__8:
;
- *(*int32)(unsafe.Pointer((bp) /* &freq[0] */ + uintptr(*(*uint8_t)(unsafe.Pointer(data + uintptr(n))))*4))++
+ *(*int32)(unsafe.Pointer(bp + uintptr(*(*uint8_t)(unsafe.Pointer(data + uintptr(n))))*4))++
goto __5
__5:
n++
@@ -40417,7 +40119,7 @@ __10:
if !(i < num_levels) {
goto __12
}
- *(*float64)(unsafe.Pointer((bp + 1024) /* &inv_q_level[0] */ + uintptr(i)*8)) = (float64(min_s) + (((float64(max_s - min_s)) * float64(i)) / (float64(num_levels - 1))))
+ *(*float64)(unsafe.Pointer(bp + 1024 + uintptr(i)*8)) = float64(min_s) + float64(max_s-min_s)*float64(i)/float64(num_levels-1)
goto __11
__11:
i++
@@ -40427,8 +40129,8 @@ __12:
;
// Fixed values. Won't be changed.
- *(*int32)(unsafe.Pointer((bp + 3072) /* &q_level[0] */ + uintptr(min_s)*4)) = 0
- *(*int32)(unsafe.Pointer((bp + 3072) /* &q_level[0] */ + uintptr(max_s)*4)) = (num_levels - 1)
+ *(*int32)(unsafe.Pointer(bp + 3072 + uintptr(min_s)*4)) = 0
+ *(*int32)(unsafe.Pointer(bp + 3072 + uintptr(max_s)*4)) = num_levels - 1
// k-Means iterations.
iter = 0
@@ -40448,21 +40150,21 @@ __16:
}
// Keep track of the nearest neighbour 'slot'
__19:
- if !((slot < (num_levels - 1)) && ((float64(2 * s)) > (*(*float64)(unsafe.Pointer((bp + 1024) /* &inv_q_level[0] */ + uintptr(slot)*8)) + *(*float64)(unsafe.Pointer((bp + 1024) /* &inv_q_level[0] */ + uintptr((slot+1))*8))))) {
+ if !(slot < num_levels-1 && float64(2*s) > *(*float64)(unsafe.Pointer(bp + 1024 + uintptr(slot)*8))+*(*float64)(unsafe.Pointer(bp + 1024 + uintptr(slot+1)*8))) {
goto __20
}
slot++
goto __19
__20:
;
- if !(*(*int32)(unsafe.Pointer((bp) /* &freq[0] */ + uintptr(s)*4)) > 0) {
+ if !(*(*int32)(unsafe.Pointer(bp + uintptr(s)*4)) > 0) {
goto __21
}
- *(*float64)(unsafe.Pointer(((bp + 4096) /* &q_sum */ + uintptr(slot)*8))) += (float64(s * *(*int32)(unsafe.Pointer((bp) /* &freq[0] */ + uintptr(s)*4))))
- *(*float64)(unsafe.Pointer(((bp + 6144) /* &q_count */ + uintptr(slot)*8))) += (float64(*(*int32)(unsafe.Pointer((bp) /* &freq[0] */ + uintptr(s)*4))))
+ *(*float64)(unsafe.Pointer(bp + 4096 + uintptr(slot)*8)) += float64(s * *(*int32)(unsafe.Pointer(bp + uintptr(s)*4)))
+ *(*float64)(unsafe.Pointer(bp + 6144 + uintptr(slot)*8)) += float64(*(*int32)(unsafe.Pointer(bp + uintptr(s)*4)))
__21:
;
- *(*int32)(unsafe.Pointer((bp + 3072) /* &q_level[0] */ + uintptr(s)*4)) = slot
+ *(*int32)(unsafe.Pointer(bp + 3072 + uintptr(s)*4)) = slot
goto __17
__17:
s++
@@ -40477,14 +40179,14 @@ __18:
}
slot = 1
__23:
- if !(slot < (num_levels - 1)) {
+ if !(slot < num_levels-1) {
goto __25
}
- count = *(*float64)(unsafe.Pointer((bp + 6144) /* &q_count[0] */ + uintptr(slot)*8))
+ count = *(*float64)(unsafe.Pointer(bp + 6144 + uintptr(slot)*8))
if !(count > 0.) {
goto __26
}
- *(*float64)(unsafe.Pointer((bp + 1024) /* &inv_q_level[0] */ + uintptr(slot)*8)) = (*(*float64)(unsafe.Pointer((bp + 4096) /* &q_sum[0] */ + uintptr(slot)*8)) / count)
+ *(*float64)(unsafe.Pointer(bp + 1024 + uintptr(slot)*8)) = *(*float64)(unsafe.Pointer(bp + 4096 + uintptr(slot)*8)) / count
__26:
;
goto __24
@@ -40504,8 +40206,8 @@ __27:
if !(s <= max_s) {
goto __29
}
- error = (float64(s) - *(*float64)(unsafe.Pointer((bp + 1024) /* &inv_q_level[0] */ + uintptr(*(*int32)(unsafe.Pointer((bp + 3072) /* &q_level[0] */ + uintptr(s)*4)))*8)))
- err = err + ((float64(*(*int32)(unsafe.Pointer((bp) /* &freq[0] */ + uintptr(s)*4))) * error) * error)
+ error = float64(s) - *(*float64)(unsafe.Pointer(bp + 1024 + uintptr(*(*int32)(unsafe.Pointer(bp + 3072 + uintptr(s)*4)))*8))
+ err = err + float64(*(*int32)(unsafe.Pointer(bp + uintptr(s)*4)))*error*error
goto __28
__28:
s++
@@ -40516,7 +40218,7 @@ __29:
// Check for convergence: we stop as soon as the error is no
// longer improving.
- if !((last_err - err) < err_threshold) {
+ if !(last_err-err < err_threshold) {
goto __30
}
goto __15
@@ -40538,8 +40240,8 @@ __31:
if !(s1 <= max_s) {
goto __33
}
- slot1 = *(*int32)(unsafe.Pointer((bp + 3072) /* &q_level[0] */ + uintptr(s1)*4))
- *(*uint8_t)(unsafe.Pointer((bp + 8192) /* &map1[0] */ + uintptr(s1))) = (libc.Uint8FromFloat64(*(*float64)(unsafe.Pointer((bp + 1024) /* &inv_q_level[0] */ + uintptr(slot1)*8)) + .5))
+ slot1 = *(*int32)(unsafe.Pointer(bp + 3072 + uintptr(s1)*4))
+ *(*uint8_t)(unsafe.Pointer(bp + 8192 + uintptr(s1))) = libc.Uint8FromFloat64(*(*float64)(unsafe.Pointer(bp + 1024 + uintptr(slot1)*8)) + .5)
goto __32
__32:
s1++
@@ -40553,7 +40255,7 @@ __34:
if !(n1 < data_size) {
goto __36
}
- *(*uint8_t)(unsafe.Pointer(data + uintptr(n1))) = *(*uint8_t)(unsafe.Pointer((bp + 8192) /* &map1[0] */ + uintptr(*(*uint8_t)(unsafe.Pointer(data + uintptr(n1))))))
+ *(*uint8_t)(unsafe.Pointer(data + uintptr(n1))) = *(*uint8_t)(unsafe.Pointer(bp + 8192 + uintptr(*(*uint8_t)(unsafe.Pointer(data + uintptr(n1))))))
goto __35
__35:
n1++
@@ -40564,7 +40266,7 @@ __36:
End:
// Store sum of squared error if needed.
- if !(sse != (uintptr(0))) {
+ if !(sse != uintptr(0)) {
goto __37
}
*(*uint64_t)(unsafe.Pointer(sse)) = uint64_t(err)
@@ -40591,7 +40293,7 @@ var kRandomTable = [55]uint32_t{
} /* random_utils.c:20:23 */
func VP8InitRandom(tls *libc.TLS, rg uintptr, dithering float32) { /* random_utils.c:33:6: */
- libc.Xmemcpy(tls, (rg + 8 /* &.tab_ */), uintptr(unsafe.Pointer(&kRandomTable)), uint64(unsafe.Sizeof([55]uint32_t{})))
+ libc.Xmemcpy(tls, rg+8, uintptr(unsafe.Pointer(&kRandomTable)), uint64(unsafe.Sizeof([55]uint32_t{})))
(*VP8Random)(unsafe.Pointer(rg)).index1_ = 0
(*VP8Random)(unsafe.Pointer(rg)).index2_ = 31
(*VP8Random)(unsafe.Pointer(rg)).amp_ = func() int32 {
@@ -40600,9 +40302,9 @@ func VP8InitRandom(tls *libc.TLS, rg uintptr, dithering float32) { /* random_uti
}
return func() int32 {
if float64(dithering) > 1.0 {
- return (int32(1) << 8)
+ return int32(1) << 8
}
- return int32((libc.Uint32FromFloat32((float32(int32(1) << 8)) * dithering)))
+ return int32(libc.Uint32FromFloat32(float32(int32(1)<<8) * dithering))
}()
}()
}
@@ -40618,13 +40320,13 @@ func WebPRescalerInit(tls *libc.TLS, rescaler uintptr, src_width int32, src_heig
var x_sub int32 = dst_width
var y_add int32 = src_height
var y_sub int32 = dst_height
- var total_size uint64_t = (uint64_t(((2 * uint64(dst_width)) * uint64(num_channels)) * uint64(unsafe.Sizeof(rescaler_t(0)))))
+ var total_size uint64_t = uint64_t(2 * uint64(dst_width) * uint64(num_channels) * uint64(unsafe.Sizeof(rescaler_t(0))))
if !(CheckSizeOverflow(tls, total_size) != 0) {
return 0
}
- (*WebPRescaler)(unsafe.Pointer(rescaler)).x_expand = (libc.Bool32(src_width < dst_width))
- (*WebPRescaler)(unsafe.Pointer(rescaler)).y_expand = (libc.Bool32(src_height < dst_height))
+ (*WebPRescaler)(unsafe.Pointer(rescaler)).x_expand = libc.Bool32(src_width < dst_width)
+ (*WebPRescaler)(unsafe.Pointer(rescaler)).y_expand = libc.Bool32(src_height < dst_height)
(*WebPRescaler)(unsafe.Pointer(rescaler)).src_width = src_width
(*WebPRescaler)(unsafe.Pointer(rescaler)).src_height = src_height
(*WebPRescaler)(unsafe.Pointer(rescaler)).dst_width = dst_width
@@ -40638,29 +40340,29 @@ func WebPRescalerInit(tls *libc.TLS, rescaler uintptr, src_width int32, src_heig
// for 'x_expand', we use bilinear interpolation
(*WebPRescaler)(unsafe.Pointer(rescaler)).x_add = func() int32 {
if (*WebPRescaler)(unsafe.Pointer(rescaler)).x_expand != 0 {
- return (x_sub - 1)
+ return x_sub - 1
}
return x_add
}()
(*WebPRescaler)(unsafe.Pointer(rescaler)).x_sub = func() int32 {
if (*WebPRescaler)(unsafe.Pointer(rescaler)).x_expand != 0 {
- return (x_add - 1)
+ return x_add - 1
}
return x_sub
}()
if !((*WebPRescaler)(unsafe.Pointer(rescaler)).x_expand != 0) { // fx_scale is not used otherwise
- (*WebPRescaler)(unsafe.Pointer(rescaler)).fx_scale = (uint32_t((uint64_t((uint64(1))) << 32) / (uint64_t((*WebPRescaler)(unsafe.Pointer(rescaler)).x_sub))))
+ (*WebPRescaler)(unsafe.Pointer(rescaler)).fx_scale = uint32_t(uint64_t(uint64(1)) << 32 / uint64_t((*WebPRescaler)(unsafe.Pointer(rescaler)).x_sub))
}
// vertical scaling parameters
(*WebPRescaler)(unsafe.Pointer(rescaler)).y_add = func() int32 {
if (*WebPRescaler)(unsafe.Pointer(rescaler)).y_expand != 0 {
- return (y_add - 1)
+ return y_add - 1
}
return y_add
}()
(*WebPRescaler)(unsafe.Pointer(rescaler)).y_sub = func() int32 {
if (*WebPRescaler)(unsafe.Pointer(rescaler)).y_expand != 0 {
- return (y_sub - 1)
+ return y_sub - 1
}
return y_sub
}()
@@ -40674,9 +40376,9 @@ func WebPRescalerInit(tls *libc.TLS, rescaler uintptr, src_width int32, src_heig
// This is WEBP_RESCALER_FRAC(dst_height, x_add * y_add) without the cast.
// Its value is <= WEBP_RESCALER_ONE, because dst_height <= rescaler->y_add
// and rescaler->x_add >= 1;
- var num uint64_t = (uint64_t(uint64(uint64_t(dst_height)) * (uint64(1) << 32)))
- var den uint64_t = (uint64_t((*WebPRescaler)(unsafe.Pointer(rescaler)).x_add) * uint64_t((*WebPRescaler)(unsafe.Pointer(rescaler)).y_add))
- var ratio uint64_t = (num / den)
+ var num uint64_t = uint64_t(uint64(uint64_t(dst_height)) * (uint64(1) << 32))
+ var den uint64_t = uint64_t((*WebPRescaler)(unsafe.Pointer(rescaler)).x_add) * uint64_t((*WebPRescaler)(unsafe.Pointer(rescaler)).y_add)
+ var ratio uint64_t = num / den
if ratio != uint64_t(uint32_t(ratio)) {
// When ratio == WEBP_RESCALER_ONE, we can't represent the ratio with the
// current fixed-point precision. This happens when src_height ==
@@ -40686,13 +40388,13 @@ func WebPRescalerInit(tls *libc.TLS, rescaler uintptr, src_width int32, src_heig
} else {
(*WebPRescaler)(unsafe.Pointer(rescaler)).fxy_scale = uint32_t(ratio)
}
- (*WebPRescaler)(unsafe.Pointer(rescaler)).fy_scale = (uint32_t((uint64_t((uint64(1))) << 32) / (uint64_t((*WebPRescaler)(unsafe.Pointer(rescaler)).y_sub))))
+ (*WebPRescaler)(unsafe.Pointer(rescaler)).fy_scale = uint32_t(uint64_t(uint64(1)) << 32 / uint64_t((*WebPRescaler)(unsafe.Pointer(rescaler)).y_sub))
} else {
- (*WebPRescaler)(unsafe.Pointer(rescaler)).fy_scale = (uint32_t((uint64_t((uint64(1))) << 32) / (uint64_t((*WebPRescaler)(unsafe.Pointer(rescaler)).x_add))))
+ (*WebPRescaler)(unsafe.Pointer(rescaler)).fy_scale = uint32_t(uint64_t(uint64(1)) << 32 / uint64_t((*WebPRescaler)(unsafe.Pointer(rescaler)).x_add))
// rescaler->fxy_scale is unused here.
}
(*WebPRescaler)(unsafe.Pointer(rescaler)).irow = work
- (*WebPRescaler)(unsafe.Pointer(rescaler)).frow = (work + uintptr((num_channels*dst_width))*4)
+ (*WebPRescaler)(unsafe.Pointer(rescaler)).frow = work + uintptr(num_channels*dst_width)*4
libc.Xmemset(tls, work, 0, total_size)
WebPRescalerDspInit(tls)
@@ -40704,18 +40406,18 @@ func WebPRescalerGetScaledDimensions(tls *libc.TLS, src_width int32, src_height
{
var width int32 = *(*int32)(unsafe.Pointer(scaled_width))
var height int32 = *(*int32)(unsafe.Pointer(scaled_height))
- var max_size int32 = (0x7fffffff / 2)
+ var max_size int32 = 0x7fffffff / 2
// if width is unspecified, scale original proportionally to height ratio.
- if (width == 0) && (src_height > 0) {
- width = (int32((((uint64_t(src_width) * uint64_t(height)) + uint64_t(src_height)) - uint64(1)) / uint64_t(src_height)))
+ if width == 0 && src_height > 0 {
+ width = int32((uint64_t(src_width)*uint64_t(height) + uint64_t(src_height) - uint64(1)) / uint64_t(src_height))
}
// if height is unspecified, scale original proportionally to width ratio.
- if (height == 0) && (src_width > 0) {
- height = (int32((((uint64_t(src_height) * uint64_t(width)) + uint64_t(src_width)) - uint64(1)) / uint64_t(src_width)))
+ if height == 0 && src_width > 0 {
+ height = int32((uint64_t(src_height)*uint64_t(width) + uint64_t(src_width) - uint64(1)) / uint64_t(src_width))
}
// Check if the overall dimensions still make sense.
- if (((width <= 0) || (height <= 0)) || (width > max_size)) || (height > max_size) {
+ if width <= 0 || height <= 0 || width > max_size || height > max_size {
return 0
}
@@ -40731,7 +40433,7 @@ func WebPRescalerGetScaledDimensions(tls *libc.TLS, src_width int32, src_height
// all-in-one calls
func WebPRescaleNeededLines(tls *libc.TLS, rescaler uintptr, max_num_lines int32) int32 { /* rescaler_utils.c:119:5: */
- var num_lines int32 = ((((*WebPRescaler)(unsafe.Pointer(rescaler)).y_accum + (*WebPRescaler)(unsafe.Pointer(rescaler)).y_sub) - 1) / (*WebPRescaler)(unsafe.Pointer(rescaler)).y_sub)
+ var num_lines int32 = ((*WebPRescaler)(unsafe.Pointer(rescaler)).y_accum + (*WebPRescaler)(unsafe.Pointer(rescaler)).y_sub - 1) / (*WebPRescaler)(unsafe.Pointer(rescaler)).y_sub
if num_lines > max_num_lines {
return max_num_lines
}
@@ -40740,7 +40442,7 @@ func WebPRescaleNeededLines(tls *libc.TLS, rescaler uintptr, max_num_lines int32
func WebPRescalerImport(tls *libc.TLS, rescaler uintptr, num_lines int32, src uintptr, src_stride int32) int32 { /* rescaler_utils.c:126:5: */
var total_imported int32 = 0
- for (total_imported < num_lines) && !(WebPRescalerHasPendingOutput(tls, rescaler) != 0) {
+ for total_imported < num_lines && !(WebPRescalerHasPendingOutput(tls, rescaler) != 0) {
if (*WebPRescaler)(unsafe.Pointer(rescaler)).y_expand != 0 {
var tmp uintptr = (*WebPRescaler)(unsafe.Pointer(rescaler)).irow
(*WebPRescaler)(unsafe.Pointer(rescaler)).irow = (*WebPRescaler)(unsafe.Pointer(rescaler)).frow
@@ -40749,14 +40451,14 @@ func WebPRescalerImport(tls *libc.TLS, rescaler uintptr, num_lines int32, src ui
WebPRescalerImportRow(tls, rescaler, src)
if !((*WebPRescaler)(unsafe.Pointer(rescaler)).y_expand != 0) { // Accumulate the contribution of the new row.
var x int32
- for x = 0; x < ((*WebPRescaler)(unsafe.Pointer(rescaler)).num_channels * (*WebPRescaler)(unsafe.Pointer(rescaler)).dst_width); x++ {
- *(*rescaler_t)(unsafe.Pointer(((*WebPRescaler)(unsafe.Pointer(rescaler)).irow + uintptr(x)*4))) += (*(*rescaler_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer(rescaler)).frow + uintptr(x)*4)))
+ for x = 0; x < (*WebPRescaler)(unsafe.Pointer(rescaler)).num_channels*(*WebPRescaler)(unsafe.Pointer(rescaler)).dst_width; x++ {
+ *(*rescaler_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer(rescaler)).irow + uintptr(x)*4)) += *(*rescaler_t)(unsafe.Pointer((*WebPRescaler)(unsafe.Pointer(rescaler)).frow + uintptr(x)*4))
}
}
(*WebPRescaler)(unsafe.Pointer(rescaler)).src_y++
src += uintptr(src_stride)
total_imported++
- *(*int32)(unsafe.Pointer((rescaler + 24 /* &.y_accum */))) -= ((*WebPRescaler)(unsafe.Pointer(rescaler)).y_sub)
+ *(*int32)(unsafe.Pointer(rescaler + 24)) -= (*WebPRescaler)(unsafe.Pointer(rescaler)).y_sub
}
return total_imported
}
@@ -40799,10 +40501,10 @@ func Reset(tls *libc.TLS, worker uintptr) int32 { /* thread_utils.c:276:12: */
}
func Execute(tls *libc.TLS, worker uintptr) { /* thread_utils.c:316:13: */
- if (*WebPWorker)(unsafe.Pointer(worker)).hook != (uintptr(0)) {
- *(*int32)(unsafe.Pointer((worker + 40 /* &.had_error */))) |= (libc.BoolInt32(!((*struct {
+ if (*WebPWorker)(unsafe.Pointer(worker)).hook != uintptr(0) {
+ *(*int32)(unsafe.Pointer(worker + 40)) |= libc.BoolInt32(!((*struct {
f func(*libc.TLS, uintptr, uintptr) int32
- })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorker)(unsafe.Pointer(worker)).hook})).f(tls, (*WebPWorker)(unsafe.Pointer(worker)).data1, (*WebPWorker)(unsafe.Pointer(worker)).data2) != 0)))
+ })(unsafe.Pointer(&struct{ uintptr }{(*WebPWorker)(unsafe.Pointer(worker)).hook})).f(tls, (*WebPWorker)(unsafe.Pointer(worker)).data1, (*WebPWorker)(unsafe.Pointer(worker)).data2) != 0))
}
}
@@ -40822,7 +40524,7 @@ var g_worker_interface = WebPWorkerInterface{
} /* thread_utils.c:350:28 */
func WebPSetWorkerInterface(tls *libc.TLS, winterface uintptr) int32 { /* thread_utils.c:354:5: */
- if ((((((winterface == (uintptr(0))) || ((*WebPWorkerInterface)(unsafe.Pointer(winterface)).Init == (uintptr(0)))) || ((*WebPWorkerInterface)(unsafe.Pointer(winterface)).Reset == (uintptr(0)))) || ((*WebPWorkerInterface)(unsafe.Pointer(winterface)).Sync == (uintptr(0)))) || ((*WebPWorkerInterface)(unsafe.Pointer(winterface)).Launch == (uintptr(0)))) || ((*WebPWorkerInterface)(unsafe.Pointer(winterface)).Execute == (uintptr(0)))) || ((*WebPWorkerInterface)(unsafe.Pointer(winterface)).End == (uintptr(0))) {
+ if winterface == uintptr(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).Init == uintptr(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).Reset == uintptr(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).Sync == uintptr(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).Launch == uintptr(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).Execute == uintptr(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).End == uintptr(0) {
return 0
}
g_worker_interface = *(*WebPWorkerInterface)(unsafe.Pointer(winterface))
@@ -40867,11 +40569,11 @@ func WebPGetWorkerInterface(tls *libc.TLS) uintptr { /* thread_utils.c:365:26: *
// Returns 0 in case of overflow of nmemb * size.
func CheckSizeArgumentsOverflow(tls *libc.TLS, nmemb uint64_t, size size_t) int32 { /* utils.c:171:12: */
- var total_size uint64_t = (nmemb * size)
+ var total_size uint64_t = nmemb * size
if nmemb == uint64(0) {
return 1
}
- if uint64(size) > ((uint64(1) << 34) / uint64(nmemb)) {
+ if uint64(size) > uint64(1)<<34/uint64(nmemb) {
return 0
}
if !(CheckSizeOverflow(tls, total_size) != 0) {
@@ -40883,37 +40585,37 @@ func CheckSizeArgumentsOverflow(tls *libc.TLS, nmemb uint64_t, size size_t) int3
func WebPSafeMalloc(tls *libc.TLS, nmemb uint64_t, size size_t) uintptr { /* utils.c:194:5: */
var ptr uintptr
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
}
if !(CheckSizeArgumentsOverflow(tls, nmemb, size) != 0) {
- return (uintptr(0))
+ return uintptr(0)
}
- ptr = libc.Xmalloc(tls, (nmemb * size))
- for ok1 := true; ok1; ok1 = (0 != 0) {
+ ptr = libc.Xmalloc(tls, nmemb*size)
+ for __ccgo1 := true; __ccgo1; __ccgo1 = 0 != 0 {
}
return ptr
}
func WebPSafeCalloc(tls *libc.TLS, nmemb uint64_t, size size_t) uintptr { /* utils.c:204:5: */
var ptr uintptr
- for ok := true; ok; ok = (0 != 0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
}
if !(CheckSizeArgumentsOverflow(tls, nmemb, size) != 0) {
- return (uintptr(0))
+ return uintptr(0)
}
ptr = libc.Xcalloc(tls, nmemb, size)
- for ok1 := true; ok1; ok1 = (0 != 0) {
+ for __ccgo1 := true; __ccgo1; __ccgo1 = 0 != 0 {
}
return ptr
}
func WebPSafeFree(tls *libc.TLS, ptr uintptr) { /* utils.c:214:6: */
- if ptr != (uintptr(0)) {
- for ok := true; ok; ok = (0 != 0) {
+ if ptr != uintptr(0) {
+ for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
}
- for ok1 := true; ok1; ok1 = (0 != 0) {
+ for __ccgo1 := true; __ccgo1; __ccgo1 = 0 != 0 {
}
}
libc.Xfree(tls, ptr)
@@ -40942,8 +40644,8 @@ func WebPCopyPlane(tls *libc.TLS, src uintptr, src_stride int32, dst uintptr, ds
func WebPCopyPixels(tls *libc.TLS, src uintptr, dst uintptr) { /* utils.c:245:6: */
- WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).argb, (4 * (*WebPPicture)(unsafe.Pointer(src)).argb_stride), (*WebPPicture)(unsafe.Pointer(dst)).argb,
- (4 * (*WebPPicture)(unsafe.Pointer(dst)).argb_stride), (4 * (*WebPPicture)(unsafe.Pointer(src)).width), (*WebPPicture)(unsafe.Pointer(src)).height)
+ WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).argb, 4*(*WebPPicture)(unsafe.Pointer(src)).argb_stride, (*WebPPicture)(unsafe.Pointer(dst)).argb,
+ 4*(*WebPPicture)(unsafe.Pointer(dst)).argb_stride, 4*(*WebPPicture)(unsafe.Pointer(src)).width, (*WebPPicture)(unsafe.Pointer(src)).height)
}
//------------------------------------------------------------------------------
@@ -40973,31 +40675,31 @@ func WebPGetColorPalette(tls *libc.TLS, pic uintptr, palette uintptr) int32 { /*
last_pix = *(*uint32_t)(unsafe.Pointer(argb + uintptr(x)*4))
key = VP8LHashPix(tls, last_pix, 22)
for 1 != 0 {
- if !(int32(*(*uint8_t)(unsafe.Pointer((bp) /* &in_use[0] */ + uintptr(key)))) != 0) {
- *(*uint32_t)(unsafe.Pointer((bp + 1024) /* &colors[0] */ + uintptr(key)*4)) = last_pix
- *(*uint8_t)(unsafe.Pointer((bp) /* &in_use[0] */ + uintptr(key))) = uint8_t(1)
+ if !(int32(*(*uint8_t)(unsafe.Pointer(bp + uintptr(key)))) != 0) {
+ *(*uint32_t)(unsafe.Pointer(bp + 1024 + uintptr(key)*4)) = last_pix
+ *(*uint8_t)(unsafe.Pointer(bp + uintptr(key))) = uint8_t(1)
num_colors++
if num_colors > 256 {
- return (256 + 1) // Exact count not needed.
+ return 256 + 1 // Exact count not needed.
}
break
- } else if *(*uint32_t)(unsafe.Pointer((bp + 1024) /* &colors[0] */ + uintptr(key)*4)) == last_pix {
+ } else if *(*uint32_t)(unsafe.Pointer(bp + 1024 + uintptr(key)*4)) == last_pix {
break // The color is already there.
} else {
// Some other color sits here, so do linear conflict resolution.
key++
- key = key & ((256 * 4) - 1) // Key mask.
+ key = key & (256*4 - 1) // Key mask.
}
}
}
- argb += 4 * (uintptr((*WebPPicture)(unsafe.Pointer(pic)).argb_stride))
+ argb += 4 * uintptr((*WebPPicture)(unsafe.Pointer(pic)).argb_stride)
}
- if palette != (uintptr(0)) { // Fill the colors into palette.
+ if palette != uintptr(0) { // Fill the colors into palette.
num_colors = 0
- for i = 0; i < (256 * 4); i++ {
- if *(*uint8_t)(unsafe.Pointer((bp) /* &in_use[0] */ + uintptr(i))) != 0 {
- *(*uint32_t)(unsafe.Pointer(palette + uintptr(num_colors)*4)) = *(*uint32_t)(unsafe.Pointer((bp + 1024) /* &colors[0] */ + uintptr(i)*4))
+ for i = 0; i < 256*4; i++ {
+ if *(*uint8_t)(unsafe.Pointer(bp + uintptr(i))) != 0 {
+ *(*uint32_t)(unsafe.Pointer(palette + uintptr(num_colors)*4)) = *(*uint32_t)(unsafe.Pointer(bp + 1024 + uintptr(i)*4))
num_colors++
}
}
@@ -41022,26 +40724,26 @@ func init() {
*(*VP8CPUInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8LDspInit_body_last_cpuinfo_used)) + 0)) = uintptr(unsafe.Pointer(&VP8LDspInit_body_last_cpuinfo_used)) // lossless.c:616:1:
*(*VP8CPUInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8LEncDspInit_body_last_cpuinfo_used)) + 0)) = uintptr(unsafe.Pointer(&VP8LEncDspInit_body_last_cpuinfo_used)) // lossless_enc.c:801:1:
*(*VP8CPUInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8SSIMDspInit_body_last_cpuinfo_used)) + 0)) = uintptr(unsafe.Pointer(&VP8SSIMDspInit_body_last_cpuinfo_used)) // ssim.c:142:1:
- *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8kabs0)) + 0)) = (uintptr(unsafe.Pointer(&abs0)) + 255) // dec_clip_tables.c:348:33:
- *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8kabs0)) + 0)) = (uintptr(unsafe.Pointer(&abs0)) + 255) // dec_clip_tables.c:348:33:
- *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8kclip1)) + 0)) = (uintptr(unsafe.Pointer(&clip1)) + 255) // dec_clip_tables.c:347:34:
- *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8kclip1)) + 0)) = (uintptr(unsafe.Pointer(&clip1)) + 255) // dec_clip_tables.c:347:34:
- *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8ksclip1)) + 0)) = (uintptr(unsafe.Pointer(&sclip1)) + 1020) // dec_clip_tables.c:345:34:
- *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8ksclip1)) + 0)) = (uintptr(unsafe.Pointer(&sclip1)) + 1020) // dec_clip_tables.c:345:34:
- *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8ksclip2)) + 0)) = (uintptr(unsafe.Pointer(&sclip2)) + 112) // dec_clip_tables.c:346:34:
- *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8ksclip2)) + 0)) = (uintptr(unsafe.Pointer(&sclip2)) + 112) // dec_clip_tables.c:346:34:
+ *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8kabs0)) + 0)) = uintptr(unsafe.Pointer(&abs0)) + 255 // dec_clip_tables.c:348:33:
+ *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8kabs0)) + 0)) = uintptr(unsafe.Pointer(&abs0)) + 255 // dec_clip_tables.c:348:33:
+ *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8kclip1)) + 0)) = uintptr(unsafe.Pointer(&clip1)) + 255 // dec_clip_tables.c:347:34:
+ *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8kclip1)) + 0)) = uintptr(unsafe.Pointer(&clip1)) + 255 // dec_clip_tables.c:347:34:
+ *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8ksclip1)) + 0)) = uintptr(unsafe.Pointer(&sclip1)) + 1020 // dec_clip_tables.c:345:34:
+ *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8ksclip1)) + 0)) = uintptr(unsafe.Pointer(&sclip1)) + 1020 // dec_clip_tables.c:345:34:
+ *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8ksclip2)) + 0)) = uintptr(unsafe.Pointer(&sclip2)) + 112 // dec_clip_tables.c:346:34:
+ *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&VP8ksclip2)) + 0)) = uintptr(unsafe.Pointer(&sclip2)) + 112 // dec_clip_tables.c:346:34:
*(*VP8CPUInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(&WebPInitAlphaProcessing_body_last_cpuinfo_used)) + 0)) = uintptr(unsafe.Pointer(&WebPInitAlphaProcessing_body_last_cpuinfo_used)) // alpha_processing.c:433:1:
*(*VP8CPUInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(&WebPInitConvertARGBToYUV_body_last_cpuinfo_used)) + 0)) = uintptr(unsafe.Pointer(&WebPInitConvertARGBToYUV_body_last_cpuinfo_used)) // yuv.c:263:1:
*(*VP8CPUInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(&WebPInitSamplers_body_last_cpuinfo_used)) + 0)) = uintptr(unsafe.Pointer(&WebPInitSamplers_body_last_cpuinfo_used)) // yuv.c:78:1:
*(*VP8CPUInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(&WebPInitUpsamplers_body_last_cpuinfo_used)) + 0)) = uintptr(unsafe.Pointer(&WebPInitUpsamplers_body_last_cpuinfo_used)) // upsampling.c:263:1:
*(*VP8CPUInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(&WebPInitYUV444Converters_body_last_cpuinfo_used)) + 0)) = uintptr(unsafe.Pointer(&WebPInitYUV444Converters_body_last_cpuinfo_used)) // upsampling.c:222:1:
*(*VP8CPUInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(&WebPRescalerDspInit_body_last_cpuinfo_used)) + 0)) = uintptr(unsafe.Pointer(&WebPRescalerDspInit_body_last_cpuinfo_used)) // rescaler.c:206:1:
- *(*func(*libc.TLS, uintptr))(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 0 /* .Init */)) = Init // thread_utils.c:351:3:
- *(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 8 /* .Reset */)) = Reset // thread_utils.c:351:9:
- *(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 16 /* .Sync */)) = Sync // thread_utils.c:351:16:
- *(*func(*libc.TLS, uintptr))(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 24 /* .Launch */)) = Launch // thread_utils.c:351:22:
- *(*func(*libc.TLS, uintptr))(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 32 /* .Execute */)) = Execute // thread_utils.c:351:30:
- *(*func(*libc.TLS, uintptr))(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 40 /* .End */)) = End // thread_utils.c:351:39:
+ *(*func(*libc.TLS, uintptr))(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 0)) = Init // thread_utils.c:351:3:
+ *(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 8)) = Reset // thread_utils.c:351:9:
+ *(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 16)) = Sync // thread_utils.c:351:16:
+ *(*func(*libc.TLS, uintptr))(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 24)) = Launch // thread_utils.c:351:22:
+ *(*func(*libc.TLS, uintptr))(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 32)) = Execute // thread_utils.c:351:30:
+ *(*func(*libc.TLS, uintptr))(unsafe.Pointer(uintptr(unsafe.Pointer(&g_worker_interface)) + 40)) = End // thread_utils.c:351:39:
*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&kCat3456)) + 0)) = uintptr(unsafe.Pointer(&kCat3)) // vp8_dec.c:401:44:
*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&kCat3456)) + 8)) = uintptr(unsafe.Pointer(&kCat4)) // vp8_dec.c:401:51:
*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&kCat3456)) + 16)) = uintptr(unsafe.Pointer(&kCat5)) // vp8_dec.c:401:58:
diff --git a/main.go b/main.go
@@ -1,7 +1,6 @@
package main
import (
- "encoding/binary"
"fmt"
"image"
"os"
@@ -43,9 +42,8 @@ func run(args []string) error {
}
}
var (
- quality = float32(1.0)
- // BUG: turning this off leads to divide by zero.
- lossless = int32(1)
+ quality = float32(100.0)
+ lossless = int32(0)
// out buffer to contain webp data.
out *byte = nil
)
@@ -81,46 +79,3 @@ func run(args []string) error {
}
return nil
}
-
-// bsearch stub that ostensibly implements a binary search on unsafe data.
-//
-// NOTE(jfm): current implementation is actually just a linear search
-// that ignores the predicate function for now.
-//
-// Input data is expected to be sorted low to high, and contain i32.
-//
-// Assuming i32 is technically eroneous and we should use the predicate
-// function to capture type information to keep this function data agnostic.
-// However it might be better to simply implement a Go idiomatic function
-// that doesn't operate on raw memory.
-//
-// Given that this function is used exactly once and the data used is i32
-// this works.
-//
-// key: raw pointer to object that serves as key
-// base: raw pointer to first element in array
-// elements: number of elements in array
-// size: size of each element in bytes
-// predicate: comparison function applied to each set of candidates [type predicate func(left, right uintptr) int32]
-//
-func bsearch(tls *libc.TLS, key, base uintptr, elements, size uint64, predicate uintptr) uintptr {
- var (
- // This conversion from uintptr to unsafe.Pointer may actually be valid based
- // on the codebase using uintptr exclusively, the memory is not GC'd like standard Go
- // but rather allocated with `libc.Alloc`.
- k int32 = *(*int32)(unsafe.Pointer(key))
- data = libc.GoBytes(base, int(elements*size))
- )
- // Linear search for exact match.
- for ii := uint64(0); ii < uint64(len(data)); ii += size {
- n := int32(binary.LittleEndian.Uint32(data[ii : ii+size]))
- if n == k {
- // return the base pointer offset by the number of bytes
- // at which the value exists.
- return base + uintptr(ii)
- }
- }
- // return the base memory offset if we didn't find a match. May not
- // be correct semantically, but should avoid memory corruption.
- return base
-}
