1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef RS_PROFILER_FILE_H
17 #define RS_PROFILER_FILE_H
18 
19 #include <mutex>
20 
21 #include "rs_profiler_capturedata.h"
22 #include "rs_profiler_utils.h"
23 
24 #ifdef REPLAY_TOOL_CLIENT // adapt to windows on client side
25 #include <memory>
26 
27 #include "rs_adapt.h"
28 #endif
29 
30 namespace OHOS::Rosen {
31 
32 #define RSFILE_VERSION_RENDER_METRICS_ADDED 0x240701
33 #define RSFILE_VERSION_LATEST RSFILE_VERSION_RENDER_METRICS_ADDED
34 
35 struct RSFileLayer final {
36     std::pair<uint32_t, uint32_t> layerHeader; // to put in GLOBAL HEADER
37 
38     RSCaptureData property;
39 
40     using TrackMarkup = std::vector<std::pair<uint32_t, uint32_t>>;
41     static constexpr size_t MARKUP_SIZE = sizeof(TrackMarkup::value_type);
42 
43     TrackMarkup rsData;
44     TrackMarkup oglData;
45     TrackMarkup rsMetrics;
46     TrackMarkup oglMetrics;
47     TrackMarkup gfxMetrics;
48     TrackMarkup renderMetrics;
49 
50     uint32_t readindexRsData = 0;
51     uint32_t readindexOglData = 0;
52     uint32_t readindexRsMetrics = 0;
53     uint32_t readindexOglMetrics = 0;
54     uint32_t readindexGfxMetrics = 0;
55     uint32_t readindexRenderMetrics = 0;
56 };
57 
58 class RSFile final {
59 public:
60     RSFile();
61 
62     void Create(const std::string& fname);
63     bool Open(const std::string& fname);
64 
65     bool IsOpen() const;
66 
67     void SetWriteTime(double time);
68     double GetWriteTime() const;
69 
70     const std::string& GetHeaderFirstFrame() const;
71     void AddHeaderFirstFrame(const std::string& dataFirstFrame);
72 
73     void AddHeaderPid(pid_t pid);
74     const std::vector<pid_t>& GetHeaderPids() const;
75 
76     uint32_t AddLayer();
77     void LayerAddHeaderProperty(uint32_t layer, const std::string& name, const std::string& value);
78 
79     void WriteRSData(double time, const void* data, size_t size);
80     void WriteOGLData(uint32_t layer, double time, const void* data, size_t size);
81     void WriteRSMetrics(uint32_t layer, double time, const void* data, size_t size);
82     void WriteRenderMetrics(uint32_t layer, double time, const void* data, size_t size);
83     void WriteOGLMetrics(uint32_t layer, double time, uint32_t frame, const void* data, size_t size);
84     void WriteGFXMetrics(uint32_t layer, double time, uint32_t frame, const void* data, size_t size);
85 
86     void ReadRSDataRestart();
87     void ReadOGLDataRestart(uint32_t layer);
88     void ReadRSMetricsRestart(uint32_t layer);
89     void ReadRenderMetricsRestart(uint32_t layer);
90     void ReadOGLMetricsRestart(uint32_t layer);
91     void ReadGFXMetricsRestart(uint32_t layer);
92 
93     bool RSDataEOF() const;
94     bool OGLDataEOF(uint32_t layer) const;
95     bool RSMetricsEOF(uint32_t layer) const;
96     bool RenderMetricsEOF(uint32_t layer) const;
97     bool OGLMetricsEOF(uint32_t layer) const;
98     bool GFXMetricsEOF(uint32_t layer) const;
99 
100     bool ReadRSData(double untilTime, std::vector<uint8_t>& data, double& readTime);
101     bool ReadOGLData(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
102     bool ReadRSMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
103     bool ReadRenderMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
104     bool ReadOGLMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
105     bool ReadGFXMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
106     bool GetDataCopy(std::vector<uint8_t>& data); // copy the content of RSFile so far
107 
108     bool HasLayer(uint32_t layer) const;
109 
110     void SetPreparedHeader(const std::vector<uint8_t>& headerData);
111     void GetPreparedHeader(std::vector<uint8_t>& headerData);
112     void SetPreparedHeaderMode(bool mode);
113     void Close();
114 
115     uint32_t GetVersion();
116 
117     static const std::string& GetDefaultPath();
118 
119 private:
120     void WriteHeaders();
121     void WriteHeader();
122     void LayerWriteHeader(uint32_t layer);
123 
124     template<typename Track>
LayerWriteHeaderOfTrack(const Track & track)125     void LayerWriteHeaderOfTrack(const Track& track)
126     {
127         uint32_t recordSize = track.size();
128         Utils::FileWrite(&recordSize, sizeof(recordSize), 1, file_);
129         for (auto item : track) {
130             Utils::FileWrite(&item.first, sizeof(item.first), 1, file_);
131             Utils::FileWrite(&item.second, sizeof(item.second), 1, file_);
132         }
133     }
134 
135     void ReadHeaders();
136     void ReadHeader();
137     void LayerReadHeader(uint32_t layer);
138 
139     template<typename Track>
LayerReadHeaderOfTrack(Track & track)140     void LayerReadHeaderOfTrack(Track& track)
141     {
142         uint32_t recordSize;
143         Utils::FileRead(&recordSize, sizeof(recordSize), 1, file_);
144         track.resize(recordSize);
145         for (size_t i = 0; i < recordSize; i++) {
146             Utils::FileRead(&track[i].first, sizeof(track[i].first), 1, file_);
147             Utils::FileRead(&track[i].second, sizeof(track[i].second), 1, file_);
148         }
149     }
150 
151     using LayerTrackIndexPtr = uint32_t RSFileLayer::*;
152     using LayerTrackMarkupPtr = RSFileLayer::TrackMarkup RSFileLayer::*;
153     struct LayerTrackPtr {
154         LayerTrackIndexPtr index;
155         LayerTrackMarkupPtr markup;
156     };
157 
158     void WriteTrackData(LayerTrackMarkupPtr trackMarkup, uint32_t layer, double time, const void* data, size_t size);
159     bool ReadTrackData(
160         LayerTrackPtr track, double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
161     void ReadTrackDataRestart(LayerTrackIndexPtr trackIndex, uint32_t layer);
162     bool TrackEOF(LayerTrackPtr track, uint32_t layer) const;
163 
164 private:
165     FILE* file_ = nullptr;
166     uint32_t versionId_ = 0;
167     double writeStartTime_ = 0.0;
168     uint32_t headerOff_ = 0u;
169     std::vector<pid_t> headerPidList_;
170     std::vector<RSFileLayer> layerData_;
171     uint32_t writeDataOff_ = 0u; // last byte of file where we can continue writing
172     std::string headerFirstFrame_;
173     std::mutex writeMutex_;
174     bool wasChanged_ = false;
175     std::vector<uint8_t> preparedHeader_;
176     bool preparedHeaderMode_ = false;
177 };
178 
179 } // namespace OHOS::Rosen
180 
181 #endif // RS_PROFILER_FILE_H