1 /*
2  * Copyright (c) 2024-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 HISTREAMER_WRITE_BITRATE_CACULATOR_H
17 #define HISTREAMER_WRITE_BITRATE_CACULATOR_H
18 
19 #include "common/log.h"
20 #include "osal/utils/steady_clock.h"
21 
22 namespace OHOS {
23 namespace Media {
24 namespace Plugins {
25 namespace HttpPlugin {
26 
27 constexpr uint32_t BYTES_TO_BIT = 8;
28 constexpr uint32_t SECOND_TO_MILLIONSECOND = 1000;
29 
30 class WriteBitrateCaculator {
31 public:
32     WriteBitrateCaculator() = default;
33     ~WriteBitrateCaculator() = default;
StartClock()34     void StartClock()
35     {
36         if (isTiming_) {
37             return;
38         }
39         isTiming_ = true;
40         steadyClock_.Reset();
41         startTime_ = static_cast<uint64_t>(steadyClock_.ElapsedMilliseconds());
42     }
StopClock()43     void StopClock()
44     {
45         if (!isTiming_) {
46             return;
47         }
48         CaculateWriteBitrate();
49         writeBytes_ = 0;
50         isTiming_ = false;
51         stopTime_ = static_cast<uint64_t>(steadyClock_.ElapsedMilliseconds());
52     }
ResetClock()53     void ResetClock()
54     {
55         isTiming_ = true;
56         CaculateWriteBitrate();
57         writeBytes_ = 0;
58         steadyClock_.Reset();
59         startTime_ = static_cast<uint64_t>(steadyClock_.ElapsedMilliseconds());
60     }
GetWriteTime()61     uint64_t GetWriteTime()
62     {
63         writeTime_ = stopTime_ > startTime_ ? stopTime_ - startTime_ : 0;
64         return writeTime_;
65     }
UpdateWriteBytes(size_t writeBytes)66     void UpdateWriteBytes(size_t writeBytes)
67     {
68         writeBytes_ += static_cast<uint64_t>(writeBytes);
69     }
CaculateWriteBitrate()70     void CaculateWriteBitrate()
71     {
72         stopTime_ = static_cast<uint64_t>(steadyClock_.ElapsedMilliseconds());
73         uint64_t writeTime = GetWriteTime();
74         if (writeTime == 0) {
75             writeBitrate_ = 0;
76             return;
77         }
78         writeBitrate_ = static_cast<float>(writeBytes_ * BYTES_TO_BIT * SECOND_TO_MILLIONSECOND) / writeTime;
79     }
GetWriteBitrate()80     uint64_t GetWriteBitrate()
81     {
82         CaculateWriteBitrate();
83         return writeBitrate_;
84     }
85 
86 private:
87     SteadyClock steadyClock_;
88     bool isTiming_ {false};
89     uint64_t startTime_ {0};
90     uint64_t stopTime_ {0};
91     uint64_t writeTime_ {0};
92     uint64_t writeBytes_ {0};
93     uint64_t writeBitrate_ {0};
94 };
95 
96 }
97 }
98 }
99 }
100 #endif