Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 1 | /* |
Stephen Hines | 4419977 | 2012-02-21 20:13:12 -0800 | [diff] [blame] | 2 | * Copyright (C) 2009-2012 The Android Open Source Project |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include "rsContext.h" |
| 18 | #include "rsScriptC.h" |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 19 | #include "rsMatrix4x4.h" |
| 20 | #include "rsMatrix3x3.h" |
| 21 | #include "rsMatrix2x2.h" |
Alex Sakhartchouk | 4edf030 | 2012-03-09 10:47:27 -0800 | [diff] [blame] | 22 | #include "rsgApiStructs.h" |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 23 | |
Stephen Hines | b0934b6 | 2013-07-03 17:27:38 -0700 | [diff] [blame] | 24 | #if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB) |
Joe Onorato | 9c4e4ca | 2009-08-09 11:39:02 -0700 | [diff] [blame] | 25 | #include "utils/Timers.h" |
Tim Murray | 0b575de | 2013-03-15 15:56:43 -0700 | [diff] [blame] | 26 | #endif |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 27 | |
Romain Guy | 98e10fd | 2009-07-30 18:45:01 -0700 | [diff] [blame] | 28 | #include <time.h> |
Romain Guy | 98e10fd | 2009-07-30 18:45:01 -0700 | [diff] [blame] | 29 | |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 30 | using namespace android; |
| 31 | using namespace android::renderscript; |
| 32 | |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 33 | |
| 34 | namespace android { |
| 35 | namespace renderscript { |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 36 | |
Jason Sams | be36bf3 | 2010-05-11 14:03:58 -0700 | [diff] [blame] | 37 | |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 38 | ////////////////////////////////////////////////////////////////////////////// |
| 39 | // Math routines |
| 40 | ////////////////////////////////////////////////////////////////////////////// |
| 41 | |
Stephen Hines | 196c111 | 2011-03-01 17:34:59 -0800 | [diff] [blame] | 42 | #if 0 |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 43 | static float SC_sinf_fast(float x) { |
Romain Guy | 2275d63 | 2009-08-18 11:39:17 -0700 | [diff] [blame] | 44 | const float A = 1.0f / (2.0f * M_PI); |
| 45 | const float B = -16.0f; |
| 46 | const float C = 8.0f; |
Jason Sams | a57c0a7 | 2009-09-04 14:42:41 -0700 | [diff] [blame] | 47 | |
Romain Guy | 2275d63 | 2009-08-18 11:39:17 -0700 | [diff] [blame] | 48 | // scale angle for easy argument reduction |
| 49 | x *= A; |
Jason Sams | a57c0a7 | 2009-09-04 14:42:41 -0700 | [diff] [blame] | 50 | |
Romain Guy | 2275d63 | 2009-08-18 11:39:17 -0700 | [diff] [blame] | 51 | if (fabsf(x) >= 0.5f) { |
| 52 | // argument reduction |
| 53 | x = x - ceilf(x + 0.5f) + 1.0f; |
| 54 | } |
Jason Sams | a57c0a7 | 2009-09-04 14:42:41 -0700 | [diff] [blame] | 55 | |
Romain Guy | 2275d63 | 2009-08-18 11:39:17 -0700 | [diff] [blame] | 56 | const float y = B * x * fabsf(x) + C * x; |
| 57 | return 0.2215f * (y * fabsf(y) - y) + y; |
| 58 | } |
| 59 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 60 | static float SC_cosf_fast(float x) { |
Romain Guy | 2275d63 | 2009-08-18 11:39:17 -0700 | [diff] [blame] | 61 | x += float(M_PI / 2); |
| 62 | |
| 63 | const float A = 1.0f / (2.0f * M_PI); |
| 64 | const float B = -16.0f; |
| 65 | const float C = 8.0f; |
Jason Sams | a57c0a7 | 2009-09-04 14:42:41 -0700 | [diff] [blame] | 66 | |
Romain Guy | 2275d63 | 2009-08-18 11:39:17 -0700 | [diff] [blame] | 67 | // scale angle for easy argument reduction |
| 68 | x *= A; |
Jason Sams | a57c0a7 | 2009-09-04 14:42:41 -0700 | [diff] [blame] | 69 | |
Romain Guy | 2275d63 | 2009-08-18 11:39:17 -0700 | [diff] [blame] | 70 | if (fabsf(x) >= 0.5f) { |
| 71 | // argument reduction |
| 72 | x = x - ceilf(x + 0.5f) + 1.0f; |
| 73 | } |
Jason Sams | a57c0a7 | 2009-09-04 14:42:41 -0700 | [diff] [blame] | 74 | |
Romain Guy | 2275d63 | 2009-08-18 11:39:17 -0700 | [diff] [blame] | 75 | const float y = B * x * fabsf(x) + C * x; |
| 76 | return 0.2215f * (y * fabsf(y) - y) + y; |
| 77 | } |
Stephen Hines | 196c111 | 2011-03-01 17:34:59 -0800 | [diff] [blame] | 78 | #endif |
Romain Guy | 2275d63 | 2009-08-18 11:39:17 -0700 | [diff] [blame] | 79 | |
Romain Guy | 98e10fd | 2009-07-30 18:45:01 -0700 | [diff] [blame] | 80 | ////////////////////////////////////////////////////////////////////////////// |
| 81 | // Time routines |
| 82 | ////////////////////////////////////////////////////////////////////////////// |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 83 | |
Jason Sams | 709a097 | 2012-11-15 18:18:04 -0800 | [diff] [blame] | 84 | time_t rsrTime(Context *rsc, time_t *timer) { |
Stephen Hines | ca3f09c | 2011-01-07 15:11:30 -0800 | [diff] [blame] | 85 | return time(timer); |
Romain Guy | 98e10fd | 2009-07-30 18:45:01 -0700 | [diff] [blame] | 86 | } |
| 87 | |
Jason Sams | 709a097 | 2012-11-15 18:18:04 -0800 | [diff] [blame] | 88 | tm* rsrLocalTime(Context *rsc, tm *local, time_t *timer) { |
Stephen Hines | ca3f09c | 2011-01-07 15:11:30 -0800 | [diff] [blame] | 89 | if (!local) { |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 90 | return nullptr; |
Stephen Hines | ca3f09c | 2011-01-07 15:11:30 -0800 | [diff] [blame] | 91 | } |
Jason Sams | e5ffb87 | 2009-08-09 17:01:55 -0700 | [diff] [blame] | 92 | |
Stephen Hines | ca3f09c | 2011-01-07 15:11:30 -0800 | [diff] [blame] | 93 | // The native localtime function is not thread-safe, so we |
| 94 | // have to apply locking for proper behavior in RenderScript. |
| 95 | pthread_mutex_lock(&rsc->gLibMutex); |
| 96 | tm *tmp = localtime(timer); |
Jason Sams | 110f181 | 2013-03-14 16:02:18 -0700 | [diff] [blame] | 97 | #ifndef RS_COMPATIBILITY_LIB |
Stephen Hines | ca3f09c | 2011-01-07 15:11:30 -0800 | [diff] [blame] | 98 | memcpy(local, tmp, sizeof(*tmp)); |
Jason Sams | 110f181 | 2013-03-14 16:02:18 -0700 | [diff] [blame] | 99 | #else |
| 100 | // WORKAROUND to struct rs_tm != struct tm |
| 101 | memcpy(local, tmp, sizeof(int)*9); |
| 102 | #endif |
Stephen Hines | ca3f09c | 2011-01-07 15:11:30 -0800 | [diff] [blame] | 103 | pthread_mutex_unlock(&rsc->gLibMutex); |
| 104 | return local; |
Romain Guy | 39dbc80 | 2009-07-31 11:20:59 -0700 | [diff] [blame] | 105 | } |
| 106 | |
Jason Sams | 709a097 | 2012-11-15 18:18:04 -0800 | [diff] [blame] | 107 | int64_t rsrUptimeMillis(Context *rsc) { |
Tim Murray | 0b575de | 2013-03-15 15:56:43 -0700 | [diff] [blame] | 108 | #ifndef RS_SERVER |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 109 | return nanoseconds_to_milliseconds(systemTime(SYSTEM_TIME_MONOTONIC)); |
Tim Murray | 0b575de | 2013-03-15 15:56:43 -0700 | [diff] [blame] | 110 | #else |
| 111 | return 0; |
| 112 | #endif |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 113 | } |
| 114 | |
Jason Sams | 709a097 | 2012-11-15 18:18:04 -0800 | [diff] [blame] | 115 | int64_t rsrUptimeNanos(Context *rsc) { |
Tim Murray | 0b575de | 2013-03-15 15:56:43 -0700 | [diff] [blame] | 116 | #ifndef RS_SERVER |
Jason Sams | 7349547 | 2010-07-29 17:31:14 -0700 | [diff] [blame] | 117 | return systemTime(SYSTEM_TIME_MONOTONIC); |
Tim Murray | 0b575de | 2013-03-15 15:56:43 -0700 | [diff] [blame] | 118 | #else |
| 119 | return 0; |
| 120 | #endif |
Jason Sams | 22fa371 | 2010-05-19 17:22:57 -0700 | [diff] [blame] | 121 | } |
| 122 | |
Jason Sams | 709a097 | 2012-11-15 18:18:04 -0800 | [diff] [blame] | 123 | float rsrGetDt(Context *rsc, const Script *sc) { |
Tim Murray | 0b575de | 2013-03-15 15:56:43 -0700 | [diff] [blame] | 124 | #ifndef RS_SERVER |
Jason Sams | ef5867a | 2010-07-28 11:17:53 -0700 | [diff] [blame] | 125 | int64_t l = sc->mEnviroment.mLastDtTime; |
| 126 | sc->mEnviroment.mLastDtTime = systemTime(SYSTEM_TIME_MONOTONIC); |
| 127 | return ((float)(sc->mEnviroment.mLastDtTime - l)) / 1.0e9; |
Tim Murray | 0b575de | 2013-03-15 15:56:43 -0700 | [diff] [blame] | 128 | #else |
| 129 | return 0.f; |
| 130 | #endif |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 131 | } |
| 132 | |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 133 | ////////////////////////////////////////////////////////////////////////////// |
| 134 | // |
| 135 | ////////////////////////////////////////////////////////////////////////////// |
| 136 | |
Jason Sams | a36c50a | 2014-06-17 12:06:06 -0700 | [diff] [blame] | 137 | static void SetObjectRef(const Context *rsc, const ObjectBase *dst, const ObjectBase *src) { |
| 138 | //ALOGE("setObjectRef %p,%p %p", rsc, dst, src); |
Jason Sams | bad8074 | 2011-03-16 16:29:28 -0700 | [diff] [blame] | 139 | if (src) { |
| 140 | CHECK_OBJ(src); |
| 141 | src->incSysRef(); |
Jason Sams | f24d7d0 | 2010-09-17 13:17:17 -0700 | [diff] [blame] | 142 | } |
Jason Sams | a36c50a | 2014-06-17 12:06:06 -0700 | [diff] [blame] | 143 | if (dst) { |
| 144 | CHECK_OBJ(dst); |
| 145 | dst->decSysRef(); |
Jason Sams | f24d7d0 | 2010-09-17 13:17:17 -0700 | [diff] [blame] | 146 | } |
Jason Sams | c093685 | 2010-08-16 12:41:48 -0700 | [diff] [blame] | 147 | } |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 148 | |
Jason Sams | 05ef73f | 2014-08-05 14:59:22 -0700 | [diff] [blame] | 149 | // Legacy, remove when drivers are updated |
Jason Sams | a36c50a | 2014-06-17 12:06:06 -0700 | [diff] [blame] | 150 | void rsrSetObject(const Context *rsc, void *dst, ObjectBase *src) { |
| 151 | ObjectBase **odst = (ObjectBase **)dst; |
| 152 | //ALOGE("rsrSetObject (base) %p,%p %p", dst, *odst, src); |
| 153 | SetObjectRef(rsc, odst[0], src); |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 154 | if (src != nullptr) { |
Jason Sams | a36c50a | 2014-06-17 12:06:06 -0700 | [diff] [blame] | 155 | src->callUpdateCacheObject(rsc, dst); |
Jason Sams | f24d7d0 | 2010-09-17 13:17:17 -0700 | [diff] [blame] | 156 | } |
Jason Sams | a36c50a | 2014-06-17 12:06:06 -0700 | [diff] [blame] | 157 | } |
| 158 | |
Jason Sams | 05ef73f | 2014-08-05 14:59:22 -0700 | [diff] [blame] | 159 | void rsrSetObject(const Context *rsc, rs_object_base *dst, const ObjectBase *src) { |
| 160 | ObjectBase **odst = (ObjectBase **)dst; |
| 161 | //ALOGE("rsrSetObject (base) %p,%p %p", dst, *odst, src); |
| 162 | SetObjectRef(rsc, odst[0], src); |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 163 | if (src != nullptr) { |
Jason Sams | 05ef73f | 2014-08-05 14:59:22 -0700 | [diff] [blame] | 164 | src->callUpdateCacheObject(rsc, dst); |
| 165 | } |
| 166 | } |
Jason Sams | a36c50a | 2014-06-17 12:06:06 -0700 | [diff] [blame] | 167 | |
Jason Sams | 05ef73f | 2014-08-05 14:59:22 -0700 | [diff] [blame] | 168 | // Legacy, remove when drivers are updated |
Jason Sams | a36c50a | 2014-06-17 12:06:06 -0700 | [diff] [blame] | 169 | void rsrClearObject(const Context *rsc, void *dst) { |
| 170 | ObjectBase **odst = (ObjectBase **)dst; |
| 171 | //ALOGE("rsrClearObject %p,%p", odst, *odst); |
| 172 | if (odst[0]) { |
| 173 | CHECK_OBJ(odst[0]); |
| 174 | odst[0]->decSysRef(); |
| 175 | } |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 176 | *odst = nullptr; |
Jason Sams | c093685 | 2010-08-16 12:41:48 -0700 | [diff] [blame] | 177 | } |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 178 | |
Jason Sams | 05ef73f | 2014-08-05 14:59:22 -0700 | [diff] [blame] | 179 | void rsrClearObject(const Context *rsc, rs_object_base *dst) { |
| 180 | //ALOGE("rsrClearObject %p,%p", odst, *odst); |
| 181 | if (dst->p) { |
| 182 | CHECK_OBJ(dst->p); |
| 183 | dst->p->decSysRef(); |
| 184 | } |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 185 | dst->p = nullptr; |
Jason Sams | 05ef73f | 2014-08-05 14:59:22 -0700 | [diff] [blame] | 186 | } |
| 187 | |
| 188 | // Legacy, remove when drivers are updated |
Tim Murray | 6a45ddb | 2014-08-06 11:49:02 -0700 | [diff] [blame] | 189 | bool rsrIsObject(const Context *, ObjectBase* src) { |
Jason Sams | 05ef73f | 2014-08-05 14:59:22 -0700 | [diff] [blame] | 190 | ObjectBase **osrc = (ObjectBase **)src; |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 191 | return osrc != nullptr; |
Jason Sams | 05ef73f | 2014-08-05 14:59:22 -0700 | [diff] [blame] | 192 | } |
| 193 | |
| 194 | bool rsrIsObject(const Context *rsc, rs_object_base o) { |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 195 | return o.p != nullptr; |
Jason Sams | c093685 | 2010-08-16 12:41:48 -0700 | [diff] [blame] | 196 | } |
| 197 | |
Jason Sams | 7dce6bc | 2010-08-06 16:22:50 -0700 | [diff] [blame] | 198 | |
Tim Murray | 6a45ddb | 2014-08-06 11:49:02 -0700 | [diff] [blame] | 199 | |
Stephen Hines | 276000a | 2013-12-03 09:33:32 -0800 | [diff] [blame] | 200 | uint32_t rsrToClient(Context *rsc, int cmdID, const void *data, int len) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 201 | //ALOGE("SC_toClient %i %i %i", cmdID, len); |
Jason Sams | aad4bc5 | 2010-11-08 17:06:46 -0800 | [diff] [blame] | 202 | return rsc->sendMessageToClient(data, RS_MESSAGE_TO_CLIENT_USER, cmdID, len, false); |
Jason Sams | 8c401ef | 2009-10-06 13:58:47 -0700 | [diff] [blame] | 203 | } |
| 204 | |
Stephen Hines | 276000a | 2013-12-03 09:33:32 -0800 | [diff] [blame] | 205 | uint32_t rsrToClientBlocking(Context *rsc, int cmdID, const void *data, int len) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 206 | //ALOGE("SC_toClientBlocking %i %i", cmdID, len); |
Jason Sams | aad4bc5 | 2010-11-08 17:06:46 -0800 | [diff] [blame] | 207 | return rsc->sendMessageToClient(data, RS_MESSAGE_TO_CLIENT_USER, cmdID, len, true); |
Jason Sams | ef5867a | 2010-07-28 11:17:53 -0700 | [diff] [blame] | 208 | } |
| 209 | |
Stephen Hines | 70537f5 | 2013-12-03 16:44:44 -0800 | [diff] [blame] | 210 | // Keep these two routines (using non-const void pointers) so that we can |
| 211 | // still use existing GPU drivers. |
| 212 | uint32_t rsrToClient(Context *rsc, int cmdID, void *data, int len) { |
| 213 | return rsrToClient(rsc, cmdID, (const void *)data, len); |
| 214 | } |
| 215 | |
| 216 | uint32_t rsrToClientBlocking(Context *rsc, int cmdID, void *data, int len) { |
| 217 | return rsrToClientBlocking(rsc, cmdID, (const void *)data, len); |
| 218 | } |
| 219 | |
Jason Sams | ddceab9 | 2013-08-07 13:02:32 -0700 | [diff] [blame] | 220 | void rsrAllocationIoSend(Context *rsc, Allocation *src) { |
| 221 | src->ioSend(rsc); |
| 222 | } |
| 223 | |
| 224 | void rsrAllocationIoReceive(Context *rsc, Allocation *src) { |
| 225 | src->ioReceive(rsc); |
| 226 | } |
Jason Sams | 3a27c95 | 2009-10-07 18:14:01 -0700 | [diff] [blame] | 227 | |
Jason Sams | 709a097 | 2012-11-15 18:18:04 -0800 | [diff] [blame] | 228 | void rsrForEach(Context *rsc, |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 229 | Script *target, |
| 230 | Allocation *in, Allocation *out, |
| 231 | const void *usr, uint32_t usrBytes, |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 232 | const RsScriptCall *call) { |
Chris Wailes | f371213 | 2014-07-16 15:18:30 -0700 | [diff] [blame] | 233 | |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 234 | if (in == nullptr) { |
| 235 | target->runForEach(rsc, /* root slot */ 0, nullptr, 0, out, usr, |
Chris Wailes | f371213 | 2014-07-16 15:18:30 -0700 | [diff] [blame] | 236 | usrBytes, call); |
| 237 | |
| 238 | } else { |
| 239 | const Allocation *ins[1] = {in}; |
| 240 | target->runForEach(rsc, /* root slot */ 0, ins, |
| 241 | sizeof(ins) / sizeof(RsAllocation), out, usr, |
| 242 | usrBytes, call); |
| 243 | } |
Jason Sams | c61346b | 2010-05-28 18:23:22 -0700 | [diff] [blame] | 244 | } |
| 245 | |
Jason Sams | 709a097 | 2012-11-15 18:18:04 -0800 | [diff] [blame] | 246 | void rsrAllocationSyncAll(Context *rsc, Allocation *a, RsAllocationUsageType usage) { |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 247 | a->syncAll(rsc, usage); |
Jason Sams | 693080e | 2011-01-25 21:33:44 -0800 | [diff] [blame] | 248 | } |
| 249 | |
Alex Sakhartchouk | 74a8279 | 2011-06-14 11:13:19 -0700 | [diff] [blame] | 250 | void rsrAllocationCopy1DRange(Context *rsc, Allocation *dstAlloc, |
| 251 | uint32_t dstOff, |
| 252 | uint32_t dstMip, |
| 253 | uint32_t count, |
| 254 | Allocation *srcAlloc, |
| 255 | uint32_t srcOff, uint32_t srcMip) { |
| 256 | rsi_AllocationCopy2DRange(rsc, dstAlloc, dstOff, 0, |
| 257 | dstMip, 0, count, 1, |
| 258 | srcAlloc, srcOff, 0, srcMip, 0); |
| 259 | } |
| 260 | |
| 261 | void rsrAllocationCopy2DRange(Context *rsc, Allocation *dstAlloc, |
| 262 | uint32_t dstXoff, uint32_t dstYoff, |
| 263 | uint32_t dstMip, uint32_t dstFace, |
| 264 | uint32_t width, uint32_t height, |
| 265 | Allocation *srcAlloc, |
| 266 | uint32_t srcXoff, uint32_t srcYoff, |
| 267 | uint32_t srcMip, uint32_t srcFace) { |
| 268 | rsi_AllocationCopy2DRange(rsc, dstAlloc, dstXoff, dstYoff, |
| 269 | dstMip, dstFace, width, height, |
| 270 | srcAlloc, srcXoff, srcYoff, srcMip, srcFace); |
| 271 | } |
| 272 | |
Jason Sams | 693080e | 2011-01-25 21:33:44 -0800 | [diff] [blame] | 273 | |
Jason Sams | 693080e | 2011-01-25 21:33:44 -0800 | [diff] [blame] | 274 | } |
Jason Sams | e45ac6e | 2009-07-20 14:31:06 -0700 | [diff] [blame] | 275 | } |