1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.0 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Buffer copying tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es3fBufferCopyTests.hpp" 25 #include "glsBufferTestUtil.hpp" 26 #include "tcuTestLog.hpp" 27 #include "deMemory.h" 28 #include "deString.h" 29 #include "glwEnums.hpp" 30 #include "glwFunctions.hpp" 31 32 #include <algorithm> 33 34 using std::vector; 35 using std::string; 36 using tcu::TestLog; 37 38 namespace deqp 39 { 40 namespace gles3 41 { 42 namespace Functional 43 { 44 45 using namespace gls::BufferTestUtil; 46 47 class BasicBufferCopyCase : public BufferCase 48 { 49 public: 50 BasicBufferCopyCase (Context& context, 51 const char* name, 52 const char* desc, 53 deUint32 srcTarget, 54 int srcSize, 55 deUint32 srcHint, 56 deUint32 dstTarget, 57 int dstSize, 58 deUint32 dstHint, 59 int copySrcOffset, 60 int copyDstOffset, 61 int copySize, 62 VerifyType verifyType) 63 : BufferCase (context.getTestContext(), context.getRenderContext(), name, desc) 64 , m_srcTarget (srcTarget) 65 , m_srcSize (srcSize) 66 , m_srcHint (srcHint) 67 , m_dstTarget (dstTarget) 68 , m_dstSize (dstSize) 69 , m_dstHint (dstHint) 70 , m_copySrcOffset (copySrcOffset) 71 , m_copyDstOffset (copyDstOffset) 72 , m_copySize (copySize) 73 , m_verifyType (verifyType) 74 { 75 DE_ASSERT(de::inBounds(m_copySrcOffset, 0, m_srcSize) && de::inRange(m_copySrcOffset+m_copySize, m_copySrcOffset, m_srcSize)); 76 DE_ASSERT(de::inBounds(m_copyDstOffset, 0, m_dstSize) && de::inRange(m_copyDstOffset+m_copySize, m_copyDstOffset, m_dstSize)); 77 } 78 79 IterateResult iterate (void) 80 { 81 BufferVerifier verifier (m_renderCtx, m_testCtx.getLog(), m_verifyType); 82 ReferenceBuffer srcRef; 83 ReferenceBuffer dstRef; 84 deUint32 srcBuf = 0; 85 deUint32 dstBuf = 0; 86 deUint32 srcSeed = deStringHash(getName()) ^ 0xabcd; 87 deUint32 dstSeed = deStringHash(getName()) ^ 0xef01; 88 bool isOk = true; 89 90 srcRef.setSize(m_srcSize); 91 fillWithRandomBytes(srcRef.getPtr(), m_srcSize, srcSeed); 92 93 dstRef.setSize(m_dstSize); 94 fillWithRandomBytes(dstRef.getPtr(), m_dstSize, dstSeed); 95 96 // Create source buffer and fill with data. 97 srcBuf = genBuffer(); 98 glBindBuffer(m_srcTarget, srcBuf); 99 glBufferData(m_srcTarget, m_srcSize, srcRef.getPtr(), m_srcHint); 100 GLU_CHECK_MSG("glBufferData"); 101 102 // Create destination buffer and fill with data. 103 dstBuf = genBuffer(); 104 glBindBuffer(m_dstTarget, dstBuf); 105 glBufferData(m_dstTarget, m_dstSize, dstRef.getPtr(), m_dstHint); 106 GLU_CHECK_MSG("glBufferData"); 107 108 // Verify both buffers before executing copy. 109 isOk = verifier.verify(srcBuf, srcRef.getPtr(), 0, m_srcSize, m_srcTarget) && isOk; 110 isOk = verifier.verify(dstBuf, dstRef.getPtr(), 0, m_dstSize, m_dstTarget) && isOk; 111 112 // Execute copy. 113 deMemcpy(dstRef.getPtr()+m_copyDstOffset, srcRef.getPtr()+m_copySrcOffset, m_copySize); 114 115 glBindBuffer(m_srcTarget, srcBuf); 116 glBindBuffer(m_dstTarget, dstBuf); 117 glCopyBufferSubData(m_srcTarget, m_dstTarget, m_copySrcOffset, m_copyDstOffset, m_copySize); 118 GLU_CHECK_MSG("glCopyBufferSubData"); 119 120 // Verify both buffers after copy. 121 isOk = verifier.verify(srcBuf, srcRef.getPtr(), 0, m_srcSize, m_srcTarget) && isOk; 122 isOk = verifier.verify(dstBuf, dstRef.getPtr(), 0, m_dstSize, m_dstTarget) && isOk; 123 124 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 125 isOk ? "Pass" : "Buffer verification failed"); 126 return STOP; 127 } 128 129 private: 130 deUint32 m_srcTarget; 131 int m_srcSize; 132 deUint32 m_srcHint; 133 134 deUint32 m_dstTarget; 135 int m_dstSize; 136 deUint32 m_dstHint; 137 138 int m_copySrcOffset; 139 int m_copyDstOffset; 140 int m_copySize; 141 142 VerifyType m_verifyType; 143 }; 144 145 // Case B: same buffer, take range as parameter 146 147 class SingleBufferCopyCase : public BufferCase 148 { 149 public: 150 SingleBufferCopyCase (Context& context, 151 const char* name, 152 const char* desc, 153 deUint32 srcTarget, 154 deUint32 dstTarget, 155 deUint32 hint, 156 VerifyType verifyType) 157 : BufferCase (context.getTestContext(), context.getRenderContext(), name, desc) 158 , m_srcTarget (srcTarget) 159 , m_dstTarget (dstTarget) 160 , m_hint (hint) 161 , m_verifyType (verifyType) 162 { 163 } 164 165 IterateResult iterate (void) 166 { 167 const int size = 1000; 168 BufferVerifier verifier (m_renderCtx, m_testCtx.getLog(), m_verifyType); 169 ReferenceBuffer ref; 170 deUint32 buf = 0; 171 deUint32 baseSeed = deStringHash(getName()); 172 bool isOk = true; 173 174 ref.setSize(size); 175 176 // Create buffer. 177 buf = genBuffer(); 178 glBindBuffer(m_srcTarget, buf); 179 180 static const struct 181 { 182 int srcOffset; 183 int dstOffset; 184 int copySize; 185 } copyRanges[] = 186 { 187 { 57, 701, 101 }, // Non-adjecent, from low to high. 188 { 640, 101, 101 }, // Non-adjecent, from high to low. 189 { 0, 500, 500 }, // Lower half to upper half. 190 { 500, 0, 500 } // Upper half to lower half. 191 }; 192 193 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(copyRanges) && isOk; ndx++) 194 { 195 int srcOffset = copyRanges[ndx].srcOffset; 196 int dstOffset = copyRanges[ndx].dstOffset; 197 int copySize = copyRanges[ndx].copySize; 198 199 fillWithRandomBytes(ref.getPtr(), size, baseSeed ^ deInt32Hash(ndx)); 200 201 // Fill with data. 202 glBindBuffer(m_srcTarget, buf); 203 glBufferData(m_srcTarget, size, ref.getPtr(), m_hint); 204 GLU_CHECK_MSG("glBufferData"); 205 206 // Execute copy. 207 deMemcpy(ref.getPtr()+dstOffset, ref.getPtr()+srcOffset, copySize); 208 209 glBindBuffer(m_dstTarget, buf); 210 glCopyBufferSubData(m_srcTarget, m_dstTarget, srcOffset, dstOffset, copySize); 211 GLU_CHECK_MSG("glCopyBufferSubData"); 212 213 // Verify buffer after copy. 214 isOk = verifier.verify(buf, ref.getPtr(), 0, size, m_dstTarget) && isOk; 215 } 216 217 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 218 isOk ? "Pass" : "Buffer verification failed"); 219 return STOP; 220 } 221 222 private: 223 deUint32 m_srcTarget; 224 deUint32 m_dstTarget; 225 deUint32 m_hint; 226 227 VerifyType m_verifyType; 228 }; 229 230 BufferCopyTests::BufferCopyTests (Context& context) 231 : TestCaseGroup(context, "copy", "Buffer copy tests") 232 { 233 } 234 235 BufferCopyTests::~BufferCopyTests (void) 236 { 237 } 238 239 void BufferCopyTests::init (void) 240 { 241 static const deUint32 bufferTargets[] = 242 { 243 GL_ARRAY_BUFFER, 244 GL_COPY_READ_BUFFER, 245 GL_COPY_WRITE_BUFFER, 246 GL_ELEMENT_ARRAY_BUFFER, 247 GL_PIXEL_PACK_BUFFER, 248 GL_PIXEL_UNPACK_BUFFER, 249 GL_TRANSFORM_FEEDBACK_BUFFER, 250 GL_UNIFORM_BUFFER 251 }; 252 253 // .basic 254 { 255 tcu::TestCaseGroup* basicGroup = new tcu::TestCaseGroup(m_testCtx, "basic", "Basic buffer copy cases"); 256 addChild(basicGroup); 257 258 for (int srcTargetNdx = 0; srcTargetNdx < DE_LENGTH_OF_ARRAY(bufferTargets); srcTargetNdx++) 259 { 260 for (int dstTargetNdx = 0; dstTargetNdx < DE_LENGTH_OF_ARRAY(bufferTargets); dstTargetNdx++) 261 { 262 if (srcTargetNdx == dstTargetNdx) 263 continue; 264 265 deUint32 srcTarget = bufferTargets[srcTargetNdx]; 266 deUint32 dstTarget = bufferTargets[dstTargetNdx]; 267 const int size = 1017; 268 const deUint32 hint = GL_STATIC_DRAW; 269 VerifyType verify = VERIFY_AS_VERTEX_ARRAY; 270 string name = string(getBufferTargetName(srcTarget)) + "_" + getBufferTargetName(dstTarget); 271 272 basicGroup->addChild(new BasicBufferCopyCase(m_context, name.c_str(), "", srcTarget, size, hint, dstTarget, size, hint, 0, 0, size, verify)); 273 } 274 } 275 } 276 277 // .subrange 278 { 279 tcu::TestCaseGroup* subrangeGroup = new tcu::TestCaseGroup(m_testCtx, "subrange", "Buffer subrange copy tests"); 280 addChild(subrangeGroup); 281 282 static const struct 283 { 284 const char* name; 285 int srcSize; 286 int dstSize; 287 int srcOffset; 288 int dstOffset; 289 int copySize; 290 } cases[] = 291 { 292 // srcSize dstSize srcOffs dstOffs copySize 293 { "middle", 1000, 1000, 250, 250, 500 }, 294 { "small_to_large", 100, 1000, 0, 409, 100 }, 295 { "large_to_small", 1000, 100, 409, 0, 100 }, 296 { "low_to_high_1", 1000, 1000, 0, 500, 500 }, 297 { "low_to_high_2", 997, 1027, 0, 701, 111 }, 298 { "high_to_low_1", 1000, 1000, 500, 0, 500 }, 299 { "high_to_low_2", 1027, 997, 701, 17, 111 } 300 }; 301 302 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++) 303 { 304 deUint32 srcTarget = GL_COPY_READ_BUFFER; 305 deUint32 dstTarget = GL_COPY_WRITE_BUFFER; 306 deUint32 hint = GL_STATIC_DRAW; 307 VerifyType verify = VERIFY_AS_VERTEX_ARRAY; 308 309 subrangeGroup->addChild(new BasicBufferCopyCase(m_context, cases[ndx].name, "", 310 srcTarget, cases[ndx].srcSize, hint, 311 dstTarget, cases[ndx].dstSize, hint, 312 cases[ndx].srcOffset, cases[ndx].dstOffset, cases[ndx].copySize, 313 verify)); 314 } 315 } 316 317 // .single_buffer 318 { 319 tcu::TestCaseGroup* singleBufGroup = new tcu::TestCaseGroup(m_testCtx, "single_buffer", "Copies within single buffer"); 320 addChild(singleBufGroup); 321 322 for (int srcTargetNdx = 0; srcTargetNdx < DE_LENGTH_OF_ARRAY(bufferTargets); srcTargetNdx++) 323 { 324 for (int dstTargetNdx = 0; dstTargetNdx < DE_LENGTH_OF_ARRAY(bufferTargets); dstTargetNdx++) 325 { 326 if (srcTargetNdx == dstTargetNdx) 327 continue; 328 329 deUint32 srcTarget = bufferTargets[srcTargetNdx]; 330 deUint32 dstTarget = bufferTargets[dstTargetNdx]; 331 const deUint32 hint = GL_STATIC_DRAW; 332 VerifyType verify = VERIFY_AS_VERTEX_ARRAY; 333 string name = string(getBufferTargetName(srcTarget)) + "_" + getBufferTargetName(dstTarget); 334 335 singleBufGroup->addChild(new SingleBufferCopyCase(m_context, name.c_str(), "", srcTarget, dstTarget, hint, verify)); 336 } 337 } 338 } 339 } 340 341 } // Functional 342 } // gles3 343 } // deqp 344
