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 RENDER_PROFILER_APPLICATION
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_RENDER_ANIMESTARTTIMES_ADDED 0x240723
34 #define RSFILE_VERSION_RENDER_TYPEFACE_FIX 0x240801
35 #define RSFILE_VERSION_LATEST RSFILE_VERSION_RENDER_TYPEFACE_FIX
36 
37 struct RSFileLayer final {
38     std::pair<uint32_t, uint32_t> layerHeader; // to put in GLOBAL HEADER
39 
40     RSCaptureData property;
41 
42     using TrackMarkup = std::vector<std::pair<uint32_t, uint32_t>>;
43     static constexpr size_t MARKUP_SIZE = sizeof(TrackMarkup::value_type);
44 
45     TrackMarkup rsData;
46     TrackMarkup oglData;
47     TrackMarkup rsMetrics;
48     TrackMarkup oglMetrics;
49     TrackMarkup gfxMetrics;
50     TrackMarkup renderMetrics;
51 
52     uint32_t readindexRsData = 0;
53     uint32_t readindexOglData = 0;
54     uint32_t readindexRsMetrics = 0;
55     uint32_t readindexOglMetrics = 0;
56     uint32_t readindexGfxMetrics = 0;
57     uint32_t readindexRenderMetrics = 0;
58 };
59 
60 class RSFile final {
61 public:
62     RSFile();
63 
64     void Create(const std::string& fname);
65     bool Open(const std::string& fname);
66 
67     bool IsOpen() const;
68 
69     void SetWriteTime(double time);
70     double GetWriteTime() const;
71 
72     const std::string& GetHeaderFirstFrame() const;
73     void AddHeaderFirstFrame(const std::string& dataFirstFrame);
74 
75     const std::vector<std::pair<uint64_t, int64_t>>& GetAnimeStartTimes() const;
76     void AddAnimeStartTimes(const std::vector<std::pair<uint64_t, int64_t>>& startTimes);
77 
78     void AddHeaderPid(pid_t pid);
79     const std::vector<pid_t>& GetHeaderPids() const;
80 
81     uint32_t AddLayer();
82     void LayerAddHeaderProperty(uint32_t layer, const std::string& name, const std::string& value);
83 
84     void WriteRSData(double time, const void* data, size_t size);
85     void WriteOGLData(uint32_t layer, double time, const void* data, size_t size);
86     void WriteRSMetrics(uint32_t layer, double time, const void* data, size_t size);
87     void WriteRenderMetrics(uint32_t layer, double time, const void* data, size_t size);
88     void WriteOGLMetrics(uint32_t layer, double time, uint32_t frame, const void* data, size_t size);
89     void WriteGFXMetrics(uint32_t layer, double time, uint32_t frame, const void* data, size_t size);
90 
91     void ReadRSDataRestart();
92     void ReadOGLDataRestart(uint32_t layer);
93     void ReadRSMetricsRestart(uint32_t layer);
94     void ReadRenderMetricsRestart(uint32_t layer);
95     void ReadOGLMetricsRestart(uint32_t layer);
96     void ReadGFXMetricsRestart(uint32_t layer);
97 
98     bool RSDataEOF() const;
99     bool OGLDataEOF(uint32_t layer) const;
100     bool RSMetricsEOF(uint32_t layer) const;
101     bool RenderMetricsEOF(uint32_t layer) const;
102     bool OGLMetricsEOF(uint32_t layer) const;
103     bool GFXMetricsEOF(uint32_t layer) const;
104 
105     bool ReadRSData(double untilTime, std::vector<uint8_t>& data, double& readTime);
106     bool ReadOGLData(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
107     bool ReadRSMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
108     bool ReadRenderMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
109     bool ReadOGLMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
110     bool ReadGFXMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
111     bool GetDataCopy(std::vector<uint8_t>& data); // copy the content of RSFile so far
112 
113     bool HasLayer(uint32_t layer) const;
114 
115     void SetPreparedHeader(const std::vector<uint8_t>& headerData);
116     void GetPreparedHeader(std::vector<uint8_t>& headerData);
117     void SetPreparedHeaderMode(bool mode);
118     void Close();
119 
120     uint32_t GetVersion() const;
121     void SetVersion(uint32_t version);
122 
123     static const std::string& GetDefaultPath();
124 
125     void CacheVsyncId2Time(uint32_t layer);
126     double ConvertVsyncId2Time(int64_t vsyncId);
127     int64_t ConvertTime2VsyncId(double time);
128 
129 private:
130     void WriteHeaders();
131     void WriteHeader();
132     void LayerWriteHeader(uint32_t layer);
133 
134     template<typename Track>
LayerWriteHeaderOfTrack(const Track& track)135     void LayerWriteHeaderOfTrack(const Track& track)
136     {
137         uint32_t recordSize = track.size();
138         Utils::FileWrite(&recordSize, sizeof(recordSize), 1, file_);
139         for (auto item : track) {
140             Utils::FileWrite(&item.first, sizeof(item.first), 1, file_);
141             Utils::FileWrite(&item.second, sizeof(item.second), 1, file_);
142         }
143     }
144 
145     void ReadHeaders();
146     void ReadHeader();
147     void LayerReadHeader(uint32_t layer);
148 
149     template<typename Track>
LayerReadHeaderOfTrack(Track& track)150     void LayerReadHeaderOfTrack(Track& track)
151     {
152         uint32_t recordSize;
153         Utils::FileRead(&recordSize, sizeof(recordSize), 1, file_);
154         track.resize(recordSize);
155         for (size_t i = 0; i < recordSize; i++) {
156             Utils::FileRead(&track[i].first, sizeof(track[i].first), 1, file_);
157             Utils::FileRead(&track[i].second, sizeof(track[i].second), 1, file_);
158         }
159     }
160 
161     using LayerTrackIndexPtr = uint32_t RSFileLayer::*;
162     using LayerTrackMarkupPtr = RSFileLayer::TrackMarkup RSFileLayer::*;
163     struct LayerTrackPtr {
164         LayerTrackIndexPtr index;
165         LayerTrackMarkupPtr markup;
166     };
167 
168     void WriteTrackData(LayerTrackMarkupPtr trackMarkup, uint32_t layer, double time, const void* data, size_t size);
169     bool ReadTrackData(
170         LayerTrackPtr track, double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime);
171     void ReadTrackDataRestart(LayerTrackIndexPtr trackIndex, uint32_t layer);
172     bool TrackEOF(LayerTrackPtr track, uint32_t layer) const;
173 
174 private:
175     FILE* file_ = nullptr;
176     uint32_t versionId_ = 0;
177     double writeStartTime_ = 0.0;
178     uint32_t headerOff_ = 0u;
179     std::vector<pid_t> headerPidList_;
180     std::vector<RSFileLayer> layerData_;
181     uint32_t writeDataOff_ = 0u; // last byte of file where we can continue writing
182     std::string headerFirstFrame_;
183     std::vector<std::pair<uint64_t, int64_t>> headerAnimeStartTimes_;
184     std::mutex writeMutex_;
185     bool wasChanged_ = false;
186     std::vector<uint8_t> preparedHeader_;
187     bool preparedHeaderMode_ = false;
188     std::map<int64_t, double> mapVsyncId2Time_;
189 };
190 
191 } // namespace OHOS::Rosen
192 
193 #endif // RS_PROFILER_FILE_H