1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// frame_capture_test_utils:
// Helper functions for capture and replay of traces.
//
#ifndef UTIL_FRAME_CAPTURE_TEST_UTILS_H_
#define UTIL_FRAME_CAPTURE_TEST_UTILS_H_
#include <iostream>
#include <memory>
#include <sstream>
#include <type_traits>
#include <vector>
#include "common/angleutils.h"
#include "common/system_utils.h"
#define USE_SYSTEM_ZLIB
#include "compression_utils_portable.h"
#define ANGLE_MACRO_STRINGIZE_AUX(a) #a
#define ANGLE_MACRO_STRINGIZE(a) ANGLE_MACRO_STRINGIZE_AUX(a)
#define ANGLE_MACRO_CONCAT_AUX(a, b) a##b
#define ANGLE_MACRO_CONCAT(a, b) ANGLE_MACRO_CONCAT_AUX(a, b)
namespace angle
{
inline uint8_t *DecompressBinaryData(const std::vector<uint8_t> &compressedData)
{
uint32_t uncompressedSize =
zlib_internal::GetGzipUncompressedSize(compressedData.data(), compressedData.size());
std::unique_ptr<uint8_t[]> uncompressedData(new uint8_t[uncompressedSize]);
uLong destLen = uncompressedSize;
int zResult =
zlib_internal::GzipUncompressHelper(uncompressedData.get(), &destLen, compressedData.data(),
static_cast<uLong>(compressedData.size()));
if (zResult != Z_OK)
{
std::cerr << "Failure to decompressed binary data: " << zResult << "\n";
return nullptr;
}
return uncompressedData.release();
}
using DecompressCallback = uint8_t *(*)(const std::vector<uint8_t> &);
using ValidateSerializedStateCallback = void (*)(const char *, const char *, uint32_t);
using SetBinaryDataDecompressCallbackFunc = void (*)(DecompressCallback);
using SetBinaryDataDirFunc = void (*)(const char *);
using SetupReplayFunc = void (*)();
using ReplayFrameFunc = void (*)(uint32_t);
using ResetReplayFunc = void (*)();
using FinishReplayFunc = void (*)();
using GetSerializedContextStateFunc = const char *(*)(uint32_t);
using SetValidateSerializedStateCallbackFunc = void (*)(ValidateSerializedStateCallback);
class TraceLibrary
{
public:
TraceLibrary(const char *traceNameIn)
{
std::stringstream traceNameStr;
#if !defined(ANGLE_PLATFORM_WINDOWS)
traceNameStr << "lib";
#endif // !defined(ANGLE_PLATFORM_WINDOWS)
traceNameStr << traceNameIn;
#if defined(ANGLE_PLATFORM_ANDROID) && defined(COMPONENT_BUILD)
// Added to shared library names in Android component builds in
// https://chromium.googlesource.com/chromium/src/+/9bacc8c4868cc802f69e1e858eea6757217a508f/build/toolchain/toolchain.gni#56
traceNameStr << ".cr";
#endif // defined(ANGLE_PLATFORM_ANDROID) && defined(COMPONENT_BUILD)
std::string traceName = traceNameStr.str();
mTraceLibrary.reset(OpenSharedLibrary(traceName.c_str(), SearchType::ModuleDir));
}
bool valid() const { return mTraceLibrary != nullptr; }
void setBinaryDataDir(const char *dataDir)
{
callFunc<SetBinaryDataDirFunc>("SetBinaryDataDir", dataDir);
}
void setBinaryDataDecompressCallback(DecompressCallback callback)
{
callFunc<SetBinaryDataDecompressCallbackFunc>("SetBinaryDataDecompressCallback", callback);
}
void replayFrame(uint32_t frameIndex) { callFunc<ReplayFrameFunc>("ReplayFrame", frameIndex); }
void setupReplay() { callFunc<SetupReplayFunc>("SetupReplay"); }
void resetReplay() { callFunc<ResetReplayFunc>("ResetReplay"); }
void finishReplay() { callFunc<FinishReplayFunc>("FinishReplay"); }
const char *getSerializedContextState(uint32_t frameIndex)
{
return callFunc<GetSerializedContextStateFunc>("GetSerializedContextState", frameIndex);
}
void setValidateSerializedStateCallback(ValidateSerializedStateCallback callback)
{
return callFunc<SetValidateSerializedStateCallbackFunc>(
"SetValidateSerializedStateCallback", callback);
}
private:
template <typename FuncT, typename... ArgsT>
typename std::result_of<FuncT(ArgsT...)>::type callFunc(const char *funcName, ArgsT... args)
{
void *untypedFunc = mTraceLibrary->getSymbol(funcName);
if (!untypedFunc)
{
fprintf(stderr, "Error loading function: %s\n", funcName);
ASSERT(untypedFunc);
}
auto typedFunc = reinterpret_cast<FuncT>(untypedFunc);
return typedFunc(args...);
}
std::unique_ptr<Library> mTraceLibrary;
};
} // namespace angle
#endif // UTIL_FRAME_CAPTURE_TEST_UTILS_H_
|
