fix android decode error

Author: Nevermore1994

src/base/Time.cpp

@@ -20,8 +20,8 @@ using std::chrono::microseconds;
     return std::chrono::milliseconds(static_cast<uint64_t>( std::round(static_cast<double>(count) / 1000.0)));
 }
 
-long double Time::TimePoint::second() const noexcept {
-    return std::round(static_cast<long double>(count) / 1000.0) / 1000;
+double Time::TimePoint::second() const noexcept {
+    return std::round(static_cast<double>(count) / 1000.0) / 1000;
 }
 
 Time::TimePoint Time::TimePoint::operator+(std::chrono::milliseconds delta) const noexcept {

src/base/Time.hpp

@@ -48,9 +48,21 @@ struct Time {
         : count(static_cast<uint64_t>(ms.count() * 1000)) {
 
         }
+
+        static TimePoint fromMilliSeconds(std::chrono::milliseconds ms) noexcept {
+            return {static_cast<uint64_t>(ms.count() * 1000)};
+        }
+
+
+        template <typename T> requires std::is_floating_point_v<T>
+        static TimePoint fromSeconds(T seconds) noexcept {
+            return {static_cast<uint64_t>(seconds * kMicroSecondScale)};
+        }
+
+
 #pragma clang diagnostic pop
         [[nodiscard]] std::chrono::milliseconds toMilliSeconds() const noexcept;
-        [[nodiscard]] long double second() const noexcept;
+        [[nodiscard]] double second() const noexcept;
         TimePoint operator+(std::chrono::milliseconds delta) const noexcept;
         TimePoint& operator+=(std::chrono::milliseconds delta) noexcept;
         TimePoint operator-(std::chrono::milliseconds delta) const noexcept;
@@ -70,7 +82,7 @@ struct Time {
 
 struct CTime {
 private:
-    constexpr static long double kTimePrecision = std::numeric_limits<double>::epsilon();
+    constexpr static double kTimePrecision = std::numeric_limits<double>::epsilon();
     constexpr static uint64_t kDefaultScale = 1000U;
 public:
     int64_t value;
@@ -87,12 +99,12 @@ struct CTime {
     }
 
     /// init with seconds
-    explicit CTime(long double t)
+    explicit CTime(double t)
         : value(static_cast<int64_t>(kDefaultScale * t))
         , scale(kDefaultScale) {
     }
 
-    [[nodiscard]] inline long double second() const noexcept {
+    [[nodiscard]] inline double second() const noexcept {
         bool isValid = this->isValid();
         SAssert(isValid, "time is invalid");
         if (isValid) {
@@ -123,12 +135,12 @@ struct CTime {
 
     inline CTime operator-(const CTime& rhs) const noexcept {
         auto t = second() - rhs.second();
-        return CTime(static_cast<int64_t>(t * static_cast<long double>(scale)), scale);
+        return CTime(static_cast<int64_t>(t * static_cast<double>(scale)), scale);
     }
 
     inline CTime operator+(const CTime& rhs) const noexcept {
         auto t = second() + rhs.second();
-        return CTime(static_cast<int64_t>(t * static_cast<long double>(scale)), scale);
+        return CTime(static_cast<int64_t>(t * static_cast<double>(scale)), scale);
     }
 
     [[nodiscard]] inline bool isValid() const noexcept {

src/core/AVFrame.hpp

@@ -29,6 +29,7 @@ enum class FrameFormat {
     Unknown = 0,
     VideoToolBox = 1,
     MediaCodecSurface = 2,
+    MediaCodecByteBuffer = 3,
 };
 
 struct Statistics {
@@ -47,14 +48,14 @@ struct FrameInfo {
 };
 
 struct AudioFrameInfo : public FrameInfo {
-    void copy(std::shared_ptr<AudioFrameInfo> info) noexcept {
+    void copy(std::shared_ptr<AudioFrameInfo> info) const noexcept {
         if (!info) {
             return;
         }
         *info = *this;
     }
 
-    double duration(uint64_t size) const noexcept {
+    [[nodiscard]] double duration(uint64_t size) const noexcept {
         return static_cast<double>(size) / static_cast<double>(bitsPerSample / 8 * channels * sampleRate);
     }
 
@@ -138,12 +139,12 @@ struct AVFrame {
         return d;
     }
 
-    long double dtsTime() const noexcept {
-        return std::round(static_cast<long double>(dts) / static_cast<long double>(timeScale) * 1000) / 1000;
+    [[nodiscard]] double dtsTime() const noexcept {
+        return std::round(static_cast<double>(dts) / static_cast<double>(timeScale) * 1000) / 1000;
     }
 
-    long double ptsTime() const noexcept {
-        return std::round(static_cast<long double>(pts) / static_cast<long double>(timeScale) * 1000) / 1000;
+    [[nodiscard]] double ptsTime() const noexcept {
+        return std::round(static_cast<double>(pts) / static_cast<double>(timeScale) * 1000) / 1000;
     }
 
     [[nodiscard]] inline std::unique_ptr<AVFrame> copy() const noexcept {
@@ -192,7 +193,7 @@ struct AVFrame {
         return frameType == AVFrameType::Audio;
     }
 
-    DataView view() const noexcept {
+    [[nodiscard]] DataView view() const noexcept {
         if (data) {
             return data->view();
         }

src/core/HLSReader.cpp

@@ -6,6 +6,8 @@
 //
 
 #include "HLSReader.h"
+
+#include <utility>
 #include "Log.hpp"
 #include "Util.hpp"
 
@@ -15,7 +17,7 @@ static constexpr std::string_view kM3u8Tag = "HLSRequestM3u8";
 static constexpr std::string_view kTsTag = "HLSRequestTs";
 
 bool parseTsTag(const std::string& tag, uint32_t& tsIndex) noexcept {
-    auto pos = tag.find("_");
+    auto pos = tag.find('_');
     if (pos == std::string::npos) {
         return false;
     }
@@ -99,7 +101,7 @@ void HLSReader::sendM3u8Request(const std::string& m3u8Url) noexcept {
     LogI("send m3u8 request:{}", m3u8Url);
 }
 
-void HLSReader::setupDataProvoider() noexcept {
+void HLSReader::setupDataProvider() noexcept {
     std::lock_guard<std::mutex> lock(requestMutex_);
     if (requestSession_) {
         requestSession_->close();
@@ -155,7 +157,7 @@ bool HLSReader::open(ReaderTaskPtr task) noexcept {
     if (isClosed_ || !task) {
         return false;
     }
-    setupDataProvoider();
+    setupDataProvider();
     auto m3u8Url = task->path;
     DemuxerConfig config;
     config.filePath = m3u8Url;
@@ -207,13 +209,12 @@ IOState HLSReader::state() noexcept {
 
 void HLSReader::setDemuxer(std::shared_ptr<HLSDemuxer> demuxer) noexcept {
     std::lock_guard<std::mutex> lock(taskMutex_);
-    demuxer_ = demuxer;
+    demuxer_ = std::move(demuxer);
 }
 
 void HLSReader::fetchTSData(uint32_t tsIndex) noexcept {
     const auto& tsInfos = demuxer_->getTSInfos();
-    if (tsIndex < 0 ||
-        tsIndex >= tsInfos.size()) {
+    if (tsIndex >= tsInfos.size()) {
         isCompleted_ = true;
         return;
     }
@@ -269,14 +270,14 @@ uint64_t HLSReader::size() noexcept {
 }
 
 void HLSReader::seek(uint64_t pos) noexcept {
-    setupDataProvoider();
+    setupDataProvider();
     requestTasks_.withLock([](auto& tasks) {
         tasks.clear();
     });
     auto tsIndex = static_cast<size_t>(pos);
     const auto& infos = demuxer_->getTSInfos();
     if (0 <= tsIndex && tsIndex < infos.size()) {
-        fetchTSData(tsIndex);
+        fetchTSData(static_cast<uint32_t>(tsIndex));
         worker_.start();
     } else {
         LogE("seek error:{}, info size:{}", tsIndex, infos.size());

src/core/HLSReader.h

@@ -49,20 +49,26 @@ class HLSReader : public IReader {
 
     void setDemuxer(std::shared_ptr<HLSDemuxer> demuxer) noexcept;
 private:
-    void setupDataProvoider() noexcept;
+    void setupDataProvider() noexcept;
+
     void addRequest(http::RequestInfoPtr) noexcept;
+
     void sendRequest() noexcept;
+
     void fetchTSData(uint32_t tsIndex) noexcept;
+
     void sendM3u8Request(const std::string& m3u8Url) noexcept;
+
     void sendTSRequest(uint32_t index, const std::string& url, Range range) noexcept;
-    
-    void handleM3u8Header(const http::ResponseHeader& header) noexcept;
+
     void handleM3u8Data(DataPtr dataPtr) noexcept;
+
     void handleM3u8Completed() noexcept;
-    
-    void handleTSHeader(const http::ResponseHeader& header) noexcept;
+
     void handleTSData(uint32_t index, DataPtr dataPtr) noexcept;
+
     void handleTSCompleted(uint32_t tsIndex) noexcept;
+
     void handleError(const http::ErrorInfo& info) noexcept;
 private:
     std::atomic_bool isPause_ = false;