1 /* 2 * Copyright (c) 2023-2025 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 MEDIA_DEMUXER_H 17 #define MEDIA_DEMUXER_H 18 19 #include <atomic> 20 #include <limits> 21 #include <string> 22 #include <shared_mutex> 23 #include <unordered_set> 24 25 #include "osal/task/condition_variable.h" 26 #include "avcodec_common.h" 27 #include "buffer/avbuffer.h" 28 #include "common/media_source.h" 29 #include "common/seek_callback.h" 30 #include "demuxer/type_finder.h" 31 #include "demuxer/sample_queue.h" 32 #include "filter/filter.h" 33 #include "meta/media_types.h" 34 #include "osal/task/autolock.h" 35 #include "osal/task/task.h" 36 #include "plugin/plugin_base.h" 37 #include "plugin/plugin_info.h" 38 #include "plugin/plugin_time.h" 39 #include "plugin/demuxer_plugin.h" 40 #include "interrupt_listener.h" 41 #include "performance_utils.h" 42 #include "media_sync_manager.h" 43 44 namespace OHOS { 45 namespace Media { 46 class BaseStreamDemuxer; 47 class DemuxerPluginManager; 48 class Source; 49 50 using MediaSource = OHOS::Media::Plugins::MediaSource; 51 using MediaSyncManager = OHOS::Media::Pipeline::MediaSyncManager; 52 using FileType = OHOS::Media::Plugins::FileType; 53 using funcPreReadSample = std::function<int64_t(int32_t trackId)>; 54 55 class AVBufferQueueProducer; 56 enum class DemuxerTrackType : int32_t { 57 VIDEO = 0, 58 AUDIO, 59 SUBTITLE, 60 }; 61 62 class MediaDemuxer : public std::enable_shared_from_this<MediaDemuxer>, 63 public Plugins::Callback, 64 public InterruptListener, 65 public SampleQueueCallback { 66 public: 67 explicit MediaDemuxer(); 68 ~MediaDemuxer() override; 69 70 Status SetDataSource(const std::shared_ptr<MediaSource> &source); 71 Status SetSubtitleSource(const std::shared_ptr<MediaSource> &source); 72 void SetBundleName(const std::string& bundleName); 73 Status SetOutputBufferQueue(int32_t trackId, const sptr<AVBufferQueueProducer>& producer); 74 75 std::shared_ptr<Meta> GetGlobalMetaInfo(); 76 std::vector<std::shared_ptr<Meta>> GetStreamMetaInfo() const; 77 std::shared_ptr<Meta> GetUserMeta(); 78 79 Status SeekTo(int64_t seekTime, Plugins::SeekMode mode, int64_t& realSeekTime); 80 Status Reset(); 81 Status Start(); 82 Status Stop(); 83 Status Pause(); 84 Status PauseDragging(); 85 Status PauseAudioAlign(); 86 Status Resume(); 87 Status ResumeDragging(); 88 Status ResumeAudioAlign(); 89 Status Flush(); 90 Status Preroll(); 91 Status PausePreroll(); 92 93 Status StartTask(int32_t trackId); 94 Status SelectTrack(uint32_t trackIndex); // Interface for AVDemuxer 95 Status UnselectTrack(uint32_t trackIndex); // Interface for AVDemuxer 96 Status ReadSample(uint32_t trackIndex, std::shared_ptr<AVBuffer> sample); // Interface for AVDemuxer 97 Status GetBitRates(std::vector<uint32_t> &bitRates); 98 Status SelectBitRate(uint32_t bitRate, bool isAutoSelect = false); 99 Status GetDownloadInfo(DownloadInfo& downloadInfo); 100 Status GetPlaybackInfo(PlaybackInfo& playbackInfo); 101 Status GetMediaKeySystemInfo(std::multimap<std::string, std::vector<uint8_t>> &infos); 102 void SetDrmCallback(const std::shared_ptr<OHOS::MediaAVCodec::AVDemuxerCallback> &callback); 103 void HandleEvent(const Plugins::PluginEvent &event); 104 void OnEvent(const Plugins::PluginEvent &event) override; 105 void OnEventBuffer(const Plugins::PluginEvent &event, std::shared_ptr<Pipeline::EventReceiver> eventReceiver); 106 void OnSeekReadyEvent(const Plugins::PluginEvent &event); 107 void OnDashSeekReadyEvent(const Plugins::PluginEvent &event); 108 void OnHlsSeekReadyEvent(const Plugins::PluginEvent &event); 109 void OnDfxEvent(const Plugins::PluginDfxEvent &event) override; 110 111 Status SetPerfRecEnabled(bool isPerfRecEnabled); 112 113 std::map<int32_t, sptr<AVBufferQueueProducer>> GetBufferQueueProducerMap(); 114 Status PauseTaskByTrackId(int32_t trackId); 115 bool IsRenderNextVideoFrameSupported(); 116 117 void SetEventReceiver(const std::shared_ptr<Pipeline::EventReceiver> &receiver); 118 bool GetDuration(int64_t& durationMs); 119 void SetPlayerId(std::string playerId); 120 void SetDumpInfo(bool isDump, uint64_t instanceId); 121 122 Status OptimizeDecodeSlow(bool isDecodeOptimizationEnabled); 123 Status SetDecoderFramerateUpperLimit(int32_t decoderFramerateUpperLimit, int32_t trackId); 124 Status SetSpeed(float speed); 125 Status SetFrameRate(double framerate, int32_t trackId); 126 void OnInterrupted(bool isInterruptNeeded) override; 127 void OnDumpInfo(int32_t fd); 128 bool IsLocalDrmInfosExisted(); 129 Status DisableMediaTrack(Plugins::MediaType mediaType); 130 void OnBufferAvailable(int32_t trackId); 131 132 void SetSelectBitRateFlag(bool flag, uint32_t desBitRate) override; 133 bool CanAutoSelectBitRate() override; 134 135 bool IsRefParserSupported(); 136 Status StartReferenceParser(int64_t startTimeMs, bool isForward = true); 137 Status GetFrameLayerInfo(std::shared_ptr<AVBuffer> videoSample, FrameLayerInfo &frameLayerInfo); 138 Status GetFrameLayerInfo(uint32_t frameId, FrameLayerInfo &frameLayerInfo); 139 Status GetGopLayerInfo(uint32_t gopId, GopLayerInfo &gopLayerInfo); 140 bool IsVideoEos(); 141 bool HasEosTrack(); IsAudioDemuxDecodeAsync()142 inline bool IsAudioDemuxDecodeAsync() const 143 { 144 return isAudioDemuxDecodeAsync_; 145 } 146 Status GetIFramePos(std::vector<uint32_t> &IFramePos); 147 Status Dts2FrameId(int64_t dts, uint32_t &frameId); 148 Status SeekMs2FrameId(int64_t seekMs, uint32_t &frameId); 149 Status FrameId2SeekMs(uint32_t frameId, int64_t &seekMs); 150 void RegisterVideoStreamReadyCallback(const std::shared_ptr<VideoStreamReadyCallback> &callback); 151 void DeregisterVideoStreamReadyCallback(); 152 153 Status GetIndexByRelativePresentationTimeUs(const uint32_t trackIndex, 154 const uint64_t relativePresentationTimeUs, uint32_t &index); // Interface for AVDemuxer 155 Status GetRelativePresentationTimeUsByIndex(const uint32_t trackIndex, 156 const uint32_t index, uint64_t &relativePresentationTimeUs); // Interface for AVDemuxer 157 Status ResumeDemuxerReadLoop(); 158 Status PauseDemuxerReadLoop(); 159 Status SetTranscoderMode(); 160 Status SetSkippingAudioDecAndEnc(); 161 void SetCacheLimit(uint32_t limitSize); 162 void SetEnableOnlineFdCache(bool isEnableFdCache); 163 void WaitForBufferingEnd(); 164 int32_t GetCurrentVideoTrackId(); 165 int32_t GetTargetVideoTrackId(std::vector<std::shared_ptr<Meta>> trackInfos); 166 void SetIsEnableReselectVideoTrack(bool isEnable); 167 void SetApiVersion(int32_t apiVersion); 168 bool IsLocalFd(); 169 Status RebootPlugin(); 170 uint64_t GetCachedDuration(); 171 void RestartAndClearBuffer(); 172 bool IsFlvLive(); 173 174 void SetSyncCenter(std::shared_ptr<MediaSyncManager> syncCenter); 175 bool HasVideo(); 176 bool HasAudio(); 177 bool IsSeekToTimeSupported(); 178 179 void SetIsCreatedByFilter(bool isCreatedByFilter); 180 181 Status GetCurrentCacheSize(uint32_t trackIndex, uint32_t& size); // Interface for AVDemuxer 182 Status StopBufferring(bool isAppBackground); 183 184 void SetMediaMuted(OHOS::Media::MediaType mediaType, bool isMuted); 185 void HandleDecoderErrorFrame(int64_t pts); IsVideoMuted()186 inline bool IsVideoMuted() const 187 { 188 return isVideoMuted_ || needRestore_; 189 } 190 void NotifyResumeUnMute(); 191 private: 192 class AVBufferQueueProducerListener; 193 class TrackWrapper; 194 struct MediaMetaData { 195 std::vector<std::shared_ptr<Meta>> trackMetas; 196 std::shared_ptr<Meta> globalMeta; 197 }; 198 199 struct MaintainBaseInfo { 200 int64_t segmentOffset = -1; 201 int64_t basePts = -1; 202 int64_t candidateBasePts = -1; 203 int64_t lastPts = 0; 204 int64_t lastPtsModifyedMax = -1; 205 bool isLastPtsChange = false; 206 }; 207 208 struct SyncFrameInfo { 209 int64_t pts = -1; 210 int32_t skipOpenGopUnrefFrameCnt = 0; 211 }; 212 213 bool isHttpSource_ = false; 214 std::string videoMime_{}; 215 216 static constexpr int32_t TRACK_ID_INVALID = -1; 217 static constexpr int32_t DEFAULT_DECODE_FRAMERATE_UPPER_LIMIT = 120; IsValidTrackId(const int32_t trackId)218 static inline bool IsValidTrackId(const int32_t trackId) { return trackId >= 0; } 219 220 Status InnerPrepare(); 221 void InitMediaMetaData(const Plugins::MediaInfo& mediaInfo); 222 void InitDefaultTrack(const Plugins::MediaInfo& mediaInfo, int32_t& videoTrackId, 223 int32_t& audioTrackId, int32_t& subtitleTrackId, std::string& videoMime); 224 bool IsOffsetValid(int64_t offset) const; 225 std::shared_ptr<Meta> GetTrackMeta(int32_t trackId); 226 Status AddDemuxerCopyTask(int32_t trackId, TaskType type); 227 Status AddDemuxerCopyTaskByTrack(int32_t trackId, DemuxerTrackType type); 228 void AddDemuxerCopyTaskByTrackIfFilter(int32_t trackId, DemuxerTrackType type); 229 void AddDemuxerCopyTaskIfFilter(int32_t trackId, TaskType type); 230 void AddHandleFlvSelectBitrateTask(); 231 232 void InitIsAudioDemuxDecodeAsync(); 233 Status StopAllTask(); 234 Status PauseAllTask(); 235 Status PauseAllTaskAsync(); 236 Status ResumeAllTask(); 237 void AccelerateTrackTask(int32_t trackId); 238 void SetTrackNotifyFlag(int32_t trackId, bool isNotifyNeeded); 239 void AccelerateSampleConsumerTask(int32_t trackId); 240 void ResetInner(); 241 242 bool GetDrmInfosUpdated(const std::multimap<std::string, std::vector<uint8_t>> &newInfos, 243 std::multimap<std::string, std::vector<uint8_t>> &result); 244 Status ProcessDrmInfos(); 245 void HandleSourceDrmInfoEvent(const std::multimap<std::string, std::vector<uint8_t>> &info); 246 Status ReportDrmInfos(const std::multimap<std::string, std::vector<uint8_t>> &info); 247 248 void DumpBufferToFile(int32_t trackId, std::shared_ptr<AVBuffer> buffer); 249 bool IsBufferDroppable(std::shared_ptr<AVBuffer> sample, int32_t trackId); 250 bool CheckDropAudioFrame(std::shared_ptr<AVBuffer> sample, int32_t trackId); 251 bool IsTrackDisabled(Plugins::MediaType mediaType); 252 bool CheckTrackEnabledById(int32_t trackId); 253 bool HandleDashChangeStream(int32_t trackId); 254 255 void GetMemoryUsage(int32_t trackId, std::shared_ptr<Plugins::DemuxerPlugin> &pluginTemp); 256 void ReportMemoryUsage(int32_t trackId, std::shared_ptr<Plugins::DemuxerPlugin> &pluginTemp); 257 Status SeekToTimeAfter(); 258 bool SelectBitRateChangeStream(int32_t trackId); 259 bool SelectTrackChangeStream(int32_t trackId); 260 bool HandleSelectTrackChangeStream(int32_t trackId, int32_t newStreamID, int32_t& newTrackId); 261 void HandleSelectTrackStreamSeek(int32_t streamID, int32_t& trackId); 262 std::shared_ptr<Plugins::DemuxerPlugin> GetCurFFmpegPlugin(); 263 void UpdateThreadPriority(int32_t trackId); 264 bool IsNeedMapToInnerTrackID(); 265 int64_t GetReadLoopRetryUs(int32_t trackId); 266 uint64_t GetSampleQueueDuration(); 267 void UpdateSampleQueueCache(); 268 void ReportEosEvent(); 269 Status GenerateDfxBufferQueue(int32_t trackId); 270 void InitEnableDfxBufferQueue(); 271 void CopyBufferToDfxBufferQueue(std::shared_ptr<AVBuffer> buffer, bool dropable); 272 273 Plugins::Seekable seekable_; 274 Plugins::Seekable subSeekable_; 275 std::string uri_; 276 std::string SubtitleUri_; 277 uint64_t mediaDataSize_; 278 uint64_t subMediaDataSize_; 279 280 std::shared_ptr<MediaSource> mediaSource_; 281 std::shared_ptr<Source> source_; 282 std::shared_ptr<Source> subtitleSource_; 283 MediaMetaData mediaMetaData_; 284 285 int64_t DoBeforeEachLoop(int32_t trackId); 286 int64_t DoBeforeSubtitleTrackReadLoop(int32_t trackId); 287 int64_t ReadLoop(int32_t trackId); 288 Status CopyFrameToUserQueue(int32_t trackId); 289 bool GetBufferFromUserQueue(int32_t queueIndex, int32_t size = 0); 290 Status InnerReadSample(int32_t trackId, std::shared_ptr<AVBuffer> sample, bool isAVDemuxer); 291 Status InnerSelectTrack(int32_t trackId); 292 Status HandleReadSample(int32_t trackId); 293 int64_t ParserRefInfo(); 294 void TryReclaimParserTask(); 295 296 Status HandleSelectTrack(int32_t trackId); 297 Status HandleDashSelectTrack(int32_t trackId); 298 Status DoSelectTrack(int32_t trackId, int32_t curTrackId); 299 Status HandleRebootPlugin(int32_t trackId, bool& isRebooted); 300 Status HandleHlsRebootPlugin(); 301 Status HandleSeekChangeStream(int32_t currentStreamId, int32_t newStreamId, int32_t trackId); 302 bool IsSubtitleMime(const std::string& mime); 303 void HandleAutoMaintainPts(int32_t trackeId, std::shared_ptr<AVBuffer> sample); 304 void InitPtsInfo(); 305 void InitMediaStartPts(); 306 void TranscoderInitMediaStartPts(); 307 void UpdateBufferQueueListener(int32_t trackId); 308 bool IsOpenGopBufferDroppable(std::shared_ptr<AVBuffer> sample, int32_t trackId); 309 void HandleEosDrag(int32_t trackId, bool isDiscardable = false); 310 void UpdateSyncFrameInfo(std::shared_ptr<AVBuffer> sample, int32_t trackId, bool isDiscardable = false); 311 void EnterDraggingOpenGopCnt(); 312 void ResetDraggingOpenGopCnt(); 313 Status ReadSampleWithPerfRecord(const std::shared_ptr<Plugins::DemuxerPlugin> &pluginTemp, 314 const int32_t &innerTrackID, const std::shared_ptr<AVBuffer> &sample, bool isAVDemuxer); 315 Status HandleTrackEos(int32_t trackId); 316 void SetOutputBufferPts(std::shared_ptr<AVBuffer> &outputBuffer); 317 void TranscoderUpdateOutputBufferPts(int32_t trackId, std::shared_ptr<AVBuffer> &outputBuffer); 318 319 Status AddSampleBufferQueue(int32_t trackId); 320 int64_t SampleConsumerLoop(int32_t trackId); 321 void SetTrackNotifySampleConsumerFlag(int32_t trackId, bool isNotifySampleConsumerNeeded); 322 bool IsRightMediaTrack(int32_t trackId, DemuxerTrackType type) const; 323 int64_t GetLastVideoBufferAbsPts(int32_t trackId) const; 324 void UpdateLastVideoBufferAbsPts(int32_t trackId); 325 std::string InferDemuxerPluginNameByContentType(); 326 bool IsHitPlugin(std::string& plugin, std::string& contentType); 327 Status OnSelectBitrateOk(int64_t startPts, uint32_t bitRate) override; 328 Status SelectBitrateForNonSQ(int64_t startPts, uint32_t bitRate); 329 Status OnSampleQueueBufferAvailable(int32_t queueId) override; 330 Status OnSampleQueueBufferConsume(int32_t queueId) override; 331 Status NotifySampleQueueBufferConsume(int32_t queueId); 332 Status HandleSelectBitrateForFlvLive(int64_t startPts, uint32_t bitrate); 333 bool IsIgonreBuffering(); 334 void InitEnableSampleQueueFlag(); GetEnableSampleQueueFlag()335 inline bool GetEnableSampleQueueFlag() const 336 { 337 return enableSampleQueue_ && isAudioDemuxDecodeAsync_ && !isTranscoderMode_; 338 } 339 Status StartTaskWithSampleQueue(int32_t trackId); 340 Status PushBufferToQueue(int32_t trackId, std::shared_ptr<AVBuffer>& buffer, bool available); 341 void StartTaskInner(int32_t trackId); 342 void InitAudioTrack(); 343 void InitVideoTrack(); 344 void InitSubtitleTrack(); 345 void HandlePacketConvertError(); 346 void HandleVideoTrack(int32_t trackId); 347 Status HandlePushBuffer(int32_t trackId, std::shared_ptr<AVBuffer>& dstBuffer, 348 sptr<AVBufferQueueProducer>& bufferQueue, Status status); 349 void HandleSeek(int32_t trackId); 350 void RecordErrorCount(int32_t queueIndex, Status ret); 351 void HandleVideoSampleQueue(); 352 std::atomic<bool> isFlvLiveSelectingBitRate_ = false; 353 uint64_t demuxerCacheDuration_ = 0; 354 uint64_t sourceCacheDuration_ = 0; 355 int64_t lastClockTimeMs_ = 0; 356 bool enableSampleQueue_ = true; 357 358 Mutex mapMutex_{}; 359 std::map<int32_t, std::shared_ptr<TrackWrapper>> trackMap_; 360 std::map<int32_t, sptr<AVBufferQueueProducer>> bufferQueueMap_; 361 std::map<int32_t, std::shared_ptr<AVBuffer>> bufferMap_; 362 363 // memoryUsage 364 std::unordered_map<uint32_t, uint32_t> trackMemoryUsages_; // Event parameter 365 std::mutex memoryReportLimitMutex_ {}; 366 std::unordered_map<int32_t, uint32_t> memoryReportLimitCount_; 367 std::unordered_map<uint32_t, funcPreReadSample> funcBeforeReadSampleMap_; 368 369 std::map<int32_t, std::shared_ptr<SampleQueue>> sampleQueueMap_; 370 std::map<int32_t, bool> eosMap_; 371 std::map<int32_t, uint32_t> requestBufferErrorCountMap_; 372 std::atomic<bool> isThreadExit_ = true; 373 bool useBufferQueue_ = false; 374 bool isAccurateSeekForHLS_ = false; 375 int64_t videoStartTime_{0}; 376 377 std::shared_mutex drmMutex{}; 378 std::mutex isSelectTrackMutex_{}; 379 std::mutex rebootPluginMutex_{}; 380 std::multimap<std::string, std::vector<uint8_t>> localDrmInfos_; 381 std::shared_ptr<OHOS::MediaAVCodec::AVDemuxerCallback> drmCallback_; 382 383 std::map<int32_t, std::unique_ptr<Task>> taskMap_; 384 std::map<int32_t, std::unique_ptr<Task>> sampleConsumerTaskMap_; 385 std::shared_ptr<MediaSyncManager> syncCenter_; 386 bool isFlvLiveStream_ = false; 387 std::unique_ptr<Task> handleFlvSelectBitrateTask_; 388 std::unique_ptr<Task> notifySampleConsumeTask_; 389 std::unique_ptr<Task> notifySampleProduceTask_; 390 391 std::shared_ptr<Pipeline::EventReceiver> eventReceiver_; 392 int64_t lastSeekTime_{Plugins::HST_TIME_NONE}; 393 bool isSeeked_{false}; 394 int32_t videoTrackId_ {TRACK_ID_INVALID}; 395 int32_t audioTrackId_ {TRACK_ID_INVALID}; 396 int32_t subtitleTrackId_ {TRACK_ID_INVALID}; 397 bool firstAudio_{true}; 398 std::mutex stopMutex_ {}; 399 400 std::atomic<bool> isStopped_ = true; 401 std::atomic<bool> isPaused_ = false; 402 std::shared_ptr<BaseStreamDemuxer> streamDemuxer_; 403 std::shared_ptr<BaseStreamDemuxer> subStreamDemuxer_; 404 std::string bundleName_ {}; 405 std::string playerId_; 406 407 std::atomic<bool> isDecodeOptimizationEnabled_ {false}; 408 std::atomic<float> speed_ {1.0f}; 409 std::atomic<double> framerate_ {0.0}; 410 std::atomic<int32_t> decoderFramerateUpperLimit_ {DEFAULT_DECODE_FRAMERATE_UPPER_LIMIT}; 411 412 std::string subtitlePluginName_; 413 std::shared_ptr<Plugins::DemuxerPlugin> subtitlePlugin_; 414 std::shared_ptr<MediaSource> subtitleMediaSource_; 415 bool isDump_ = false; 416 std::shared_ptr<DemuxerPluginManager> demuxerPluginManager_; 417 std::atomic<bool> isSelectBitRate_ = false; 418 std::atomic<bool> isManualBitRateSetting_ = false; 419 uint32_t targetBitRate_ = 0; 420 std::string dumpPrefix_ = ""; 421 std::unordered_set<Plugins::MediaType> disabledMediaTracks_ {}; 422 423 std::unique_ptr<Task> parserRefInfoTask_; 424 bool isFirstParser_ = true; 425 bool isParserTaskEnd_ = false; 426 bool isAudioDemuxDecodeAsync_ = true; 427 bool isVideoTrackDisabled_ = true; 428 std::mutex parserTaskMutex_ {}; 429 int64_t duration_ {0}; 430 FileType fileType_ = FileType::UNKNOW; 431 432 std::mutex prerollMutex_ {}; 433 std::atomic<bool> inPreroll_ = false; 434 435 std::map<int32_t, int32_t> inSelectTrackType_{}; 436 std::map<int32_t, std::pair<int32_t, int32_t>> seekReadyStreamInfo_{}; 437 std::condition_variable rebootPluginCondition_; 438 std::atomic<bool> isSelectTrack_ = false; 439 std::atomic<bool> shouldCheckAudioFramePts_ = false; 440 int64_t lastAudioPts_ = 0; 441 int64_t lastVideoPts_ = 0; 442 int64_t lastAudioPtsInMute_ = 0; 443 std::atomic<bool> isOnEventNoMemory_ = false; 444 std::atomic<bool> isSeekError_ = false; 445 std::atomic<bool> shouldCheckSubtitleFramePts_ = false; 446 int64_t lastSubtitlePts_ = 0; 447 std::shared_ptr<VideoStreamReadyCallback> VideoStreamReadyCallback_ = nullptr; 448 std::mutex draggingMutex_ {}; 449 std::atomic<bool> isDemuxerLoopExecuting_ {false}; 450 std::atomic<bool> isFirstFrameAfterSeek_ {false}; 451 std::atomic<bool> isInterruptNeeded_ {false}; 452 bool isAutoMaintainPts_ = false; 453 std::map<int32_t, std::shared_ptr<MaintainBaseInfo>> maintainBaseInfos_; 454 int64_t mediaStartPts_ {HST_TIME_NONE}; 455 int64_t transcoderStartPts_ {HST_TIME_NONE}; 456 bool isEnableReselectVideoTrack_ {false}; 457 int32_t targetVideoTrackId_ {TRACK_ID_INVALID}; 458 SyncFrameInfo syncFrameInfo_ {}; 459 std::mutex syncFrameInfoMutex_ {}; 460 bool isTranscoderMode_ {false}; 461 bool isSkippingAudioDecAndEnc_ {false}; 462 bool perfRecEnabled_ { false }; 463 PerfRecorder perfRecorder_ {}; 464 int32_t apiVersion_ {0}; 465 bool isHlsFmp4_ {false}; 466 467 bool isCreatedByFilter_ {false}; 468 469 int64_t videoSeekTime_ {0}; 470 bool isInSeekDropAudio_ {false}; 471 std::atomic<int32_t> convertErrorTime_ {0}; 472 bool isVideoMuted_ = false; 473 bool needReleaseVideoDecoder_ = false; 474 bool needRestore_ {false}; 475 bool hasSetLargeSize_ {false}; 476 477 uint32_t timeout_ = {10}; // 10 represents 10ms. Optimization can consider dynamic adjustment. 478 bool enableAsyncDemuxer_ = true; 479 480 bool enableDfxBufferQueue_ {false}; 481 std::shared_ptr<AVBufferQueue> dfxBufferQueue_ {nullptr}; 482 sptr<AVBufferQueueProducer> dfxBufferQueueProducer_ {nullptr}; 483 sptr<AVBufferQueueConsumer> dfxBufferQueueConsumer_ {nullptr}; 484 }; 485 } // namespace Media 486 } // namespace OHOS 487 #endif // MEDIA_DEMUXER_H