ExoPlayer 源码阅读小记--HLS播放带缓存加载M3U8文件过程

已于 2023-08-04 10:56:58 修改
阅读量2.8k 收藏 7
点赞数 2
分类专栏： Android ExoPlayer 文章标签： android exoplayer 播放器 源码
于 2022-05-23 11:11:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blovecat/article/details/124867216
版权

基于ExoPlayer 2.17.1源码分析，基本是一边看一边写的流水账，记录下防止以后忘了：

第一步createMediaSource创建HlsMediaSource对象时同时会实例化出HlsPlaylistTracker.Factory

mediaSource = new HlsMediaSource.Factory(getDataSourceFactoryCache(mAppContext, cacheEnable, preview, cacheDir, uerAgent))
                    .setAllowChunklessPreparation(true)
                    .setPlaylistParserFactory(new HlsPlaylistParserFactory())
                    .createMediaSource(mediaItem);

    public HlsMediaSource createMediaSource(MediaItem mediaItem) {
      checkNotNull(mediaItem.localConfiguration);
      HlsPlaylistParserFactory playlistParserFactory = this.playlistParserFactory;
      List<StreamKey> streamKeys = mediaItem.localConfiguration.streamKeys;
      if (!streamKeys.isEmpty()) {
        playlistParserFactory =
            new FilteringHlsPlaylistParserFactory(playlistParserFactory, streamKeys);
      }

      return new HlsMediaSource(
          mediaItem,
          hlsDataSourceFactory,
          extractorFactory,
          compositeSequenceableLoaderFactory,
          drmSessionManagerProvider.get(mediaItem),
          loadErrorHandlingPolicy,
          playlistTrackerFactory.createTracker(
              hlsDataSourceFactory, loadErrorHandlingPolicy, playlistParserFactory),//实例化TrackerFactory
          elapsedRealTimeOffsetMs,
          allowChunklessPreparation,
          metadataType,
          useSessionKeys);
    }

第二步调用prepare(),在准备阶段将m3u8文件下载并解析

     player.prepare();

//ExoPlayerImpl
public void prepare() {
   ....
    internalPlayer.prepare();
   ......
  }

//ExoPlayerImplInternal
  private void prepareInternal() {
   ....
    mediaSourceList.prepare(bandwidthMeter.getTransferListener());
  ....
  }

//MediaSourceList
  public void prepare(@Nullable TransferListener mediaTransferListener) {
    ....
    for (int i = 0; i < mediaSourceHolders.size(); i++) {
      MediaSourceHolder mediaSourceHolder = mediaSourceHolders.get(i);
      prepareChildSource(mediaSourceHolder);
      enabledMediaSourceHolders.add(mediaSourceHolder);
    }
    ....
  }
  
  private void prepareChildSource(MediaSourceHolder holder) {
   .....
    mediaSource.prepareSource(caller, mediaTransferListener, playerId);
  }

//BaseMediaSource
public final void prepareSource(
      MediaSourceCaller caller,
      @Nullable TransferListener mediaTransferListener,
      PlayerId playerId) {
   ....
      prepareSourceInternal(mediaTransferListener);
  ....
  }

//HlsMediaSource
protected void prepareSourceInternal(@Nullable TransferListener mediaTransferListener) {
....
    playlistTracker.start(
        localConfiguration.uri, eventDispatcher, /* primaryPlaylistListener= */ this);
  }

到这里使用HlsPlaylistTracker，这个类主要是管理播放列表（控制加载解析流程）,主列表叫primary playlist,另外该类还能获取当前播放的列表快照，该类入口就在这个start方法

//DefaultHlsPlaylistTracker
public void start(
      Uri initialPlaylistUri,
      EventDispatcher eventDispatcher,
      PrimaryPlaylistListener primaryPlaylistListener) {
   ....
    ParsingLoadable<HlsPlaylist> multivariantPlaylistLoadable =
        new ParsingLoadable<>(
            dataSourceFactory.createDataSource(C.DATA_TYPE_MANIFEST),
            initialPlaylistUri,
            C.DATA_TYPE_MANIFEST,
            playlistParserFactory.createPlaylistParser());
    Assertions.checkState(initialPlaylistLoader == null);
    initialPlaylistLoader = new Loader("DefaultHlsPlaylistTracker:MultivariantPlaylist");//创建m3u8文件的网络加载解析线程
    long elapsedRealtime =
        initialPlaylistLoader.startLoading(
            multivariantPlaylistLoadable,
            this,
            loadErrorHandlingPolicy.getMinimumLoadableRetryCount(
                multivariantPlaylistLoadable.type));
   .....
  }

ParsingLoadable主要代码就这个方法，先通过DataSource获取需要加载的文件流，将文件流传入解析器解析，这里说下DataSourceInputStream本质是InputStream子类，但是里面包含一个datasSource和dataSpec，datasSource可以理解为数据源访问工具（如网络数据源访问Okhttp）获取到数据流后会将流保存在datasSource以供读取，dataSpec用来标记当前数据范围，里面还封装了读取数据的方式参数（如http请求url和header）

//ParsingLoadable
  public final void load() throws IOException {
    // We always load from the beginning, so reset bytesRead to 0.
    dataSource.resetBytesRead();
    DataSourceInputStream inputStream = new DataSourceInputStream(dataSource, dataSpec);
    try {
      inputStream.open();
      Uri dataSourceUri = Assertions.checkNotNull(dataSource.getUri());
      result = parser.parse(dataSourceUri, inputStream);
    } finally {
      Util.closeQuietly(inputStream);
    }
  }

当DataSourceInputStream调用open时，就会通过 dataSource.open(dataSpec)
当DataSourceInputStream，reader时就读取dataSource的数据流

//DataSourceInputStream
 private void checkOpened() throws IOException {
    if (!opened) {
      dataSource.open(dataSpec);
      opened = true;
    }
  }
  public int read(byte[] buffer, int offset, int length) throws IOException {
    Assertions.checkState(!closed);
    checkOpened();
    int bytesRead = dataSource.read(buffer, offset, length);
    if (bytesRead == C.RESULT_END_OF_INPUT) {
      return -1;
    } else {
      totalBytesRead += bytesRead;
      return bytesRead;
    }
  }

好了我们继续open流程，StatsDataSource是一个封装DataSource的DataSource，里面包含一个DataSource 重定向的 uri 和响应标头等数据

//StatsDataSource
  public long open(DataSpec dataSpec) throws IOException {
    // Reassign defaults in case dataSource.open throws an exception.
    lastOpenedUri = dataSpec.uri;
    lastResponseHeaders = Collections.emptyMap();
    long availableBytes = dataSource.open(dataSpec);
    lastOpenedUri = Assertions.checkNotNull(getUri());
    lastResponseHeaders = getResponseHeaders();
    return availableBytes;
  }

继续调用StatsDataSource封装的DataSource，继续套娃，套娃一般是为了分层，因为设置的是CacheDataSource这里会调用TeeDataSource 的open，Tees翻译就是三通的意思，这是个一进二出的三通，一个水龙头冷水进，一路进小厨宝缓存加热后出，一路直接水龙出，

//TeeDataSource
public long open(DataSpec dataSpec) throws IOException {
    bytesRemaining = upstream.open(dataSpec);//调用OkHttpDataSource open打开冷水进水阀门，准备一路上出水到水龙头，一路到小厨宝缓存
    if (bytesRemaining == 0) {
      return 0;
    }
    if (dataSpec.length == C.LENGTH_UNSET && bytesRemaining != C.LENGTH_UNSET) {
      // Reconstruct dataSpec in order to provide the resolved length to the sink.
      dataSpec = dataSpec.subrange(0, bytesRemaining);
    }
    dataSinkNeedsClosing = true;
    dataSink.open(dataSpec);//dataSink由CacheDataSource设置,调用CacheDataSink open打开厨宝的进水阀，准备下出水到小厨宝缓存
    return bytesRemaining;
  }

OkHttpDataSource 就忽略了，就是访问网络获取m3u8的文件流，这里看下CacheDataSink ,openNextOutputStream主要就是创建缓存的目录，创建缓存文件并获取输出流，这里并没有写入数据

//CacheDataSink 
public void open(DataSpec dataSpec) throws CacheDataSinkException {
   ....
    try {
      openNextOutputStream(dataSpec);
    } catch (IOException e) {
      throw new CacheDataSinkException(e);
    }
  }
private void openNextOutputStream(DataSpec dataSpec) throws IOException {
    ....
    file =
        cache.startFile(
            castNonNull(dataSpec.key), dataSpec.position + dataSpecBytesWritten, length);
    FileOutputStream underlyingFileOutputStream = new FileOutputStream(file);
    if (bufferSize > 0) {
      if (bufferedOutputStream == null) {
        bufferedOutputStream =
            new ReusableBufferedOutputStream(underlyingFileOutputStream, bufferSize);
      } else {
        bufferedOutputStream.reset(underlyingFileOutputStream);
      }
      outputStream = bufferedOutputStream;
    } else {
      outputStream = underlyingFileOutputStream;
    }
  ....
  }

那么在哪里什么时机写入缓存文件了呢,通过上面open的流程知道，open的流也没有立即读取而是缓存在DataSource里，当调用DataSource的read方法才会读取，所以理所应当写入缓存的时机就在读取的时候
，回到TeeDataSource read方法，具体的read时间点在下面会讲到，我们继续往下看

//TeeDataSource
  public int read(byte[] buffer, int offset, int length) throws IOException {
    if (bytesRemaining == 0) {
      return C.RESULT_END_OF_INPUT;
    }
    int bytesRead = upstream.read(buffer, offset, length);
    if (bytesRead > 0) {
      // TODO: Consider continuing even if writes to the sink fail.这里还有个TODO作者想要缓存写入失败的时候也不要影响读取
      dataSink.write(buffer, offset, bytesRead);
      if (bytesRemaining != C.LENGTH_UNSET) {
        bytesRemaining -= bytesRead;
      }
    }
    return bytesRead;
  }

缓存相关先不展开说了，读取看完继续看解析，这里没啥好说的需要熟悉m3u8文件的格式，返回一个解析后的数据结构

//HlsPlaylistParser
public HlsPlaylist parse(Uri uri, InputStream inputStream) throws IOException {
    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
    Queue<String> extraLines = new ArrayDeque<>();
    String line;
    try {
      if (!checkPlaylistHeader(reader)) {//这里校验M3U8文件头，有些不规范的M3U8文件会包含BOM头校验会不通过，可以在创建MediaSource时通过setPlaylistParserFactory设置自定义HlsPlaylistParser修改支持BOM头
        throw ParserException.createForMalformedManifest(
            /* message= */ "Input does not start with the #EXTM3U header.", /* cause= */ null);
      }
      while ((line = reader.readLine()) != null) {
        line = line.trim();
        if (line.isEmpty()) {
          // Do nothing.
        } else if (line.startsWith(TAG_STREAM_INF)) {
          extraLines.add(line);
          return parseMultivariantPlaylist(new LineIterator(extraLines, reader), uri.toString());
        } else if (line.startsWith(TAG_TARGET_DURATION)
            || line.startsWith(TAG_MEDIA_SEQUENCE)
            || line.startsWith(TAG_MEDIA_DURATION)
            || line.startsWith(TAG_KEY)
            || line.startsWith(TAG_BYTERANGE)
            || line.equals(TAG_DISCONTINUITY)
            || line.equals(TAG_DISCONTINUITY_SEQUENCE)
            || line.equals(TAG_ENDLIST)) {
          extraLines.add(line);
          return parseMediaPlaylist(
              multivariantPlaylist,
              previousMediaPlaylist,
              new LineIterator(extraLines, reader),
              uri.toString());
        } else {
          extraLines.add(line);
        }
      }
    } finally {
      Util.closeQuietly(reader);
    }
    throw ParserException.createForMalformedManifest(
        "Failed to parse the playlist, could not identify any tags.", /* cause= */ null);
  }

解析完成又会回到DefaultHlsPlaylistTracker的onLoadCompleted，会获取刚才的额解析结果

//DefaultHlsPlaylistTracker
public void onLoadCompleted(
      ParsingLoadable<HlsPlaylist> loadable, long elapsedRealtimeMs, long loadDurationMs) {
    HlsPlaylist result = loadable.getResult();//获取解析结果
  .......
    MediaPlaylistBundle primaryBundle = playlistBundles.get(primaryMediaPlaylistUrl);
    if (isMediaPlaylist) {
      // We don't need to load the playlist again. We can use the same result.
      primaryBundle.processLoadedPlaylist((HlsMediaPlaylist) result, loadEventInfo);
    } else {
      primaryBundle.loadPlaylist();
    }
  ....
  }

private void processLoadedPlaylist(
        HlsMediaPlaylist loadedPlaylist, LoadEventInfo loadEventInfo) {
      @Nullable HlsMediaPlaylist oldPlaylist = playlistSnapshot;
    ....
      if (playlistSnapshot != oldPlaylist) {
        playlistError = null;
        lastSnapshotChangeMs = currentTimeMs;
        onPlaylistUpdated(playlistUrl, playlistSnapshot);
      } ....
      }

  private void onPlaylistUpdated(Uri url, HlsMediaPlaylist newSnapshot) {
    if (url.equals(primaryMediaPlaylistUrl)) {
 ....
      primaryMediaPlaylistSnapshot = newSnapshot;
      primaryPlaylistListener.onPrimaryPlaylistRefreshed(newSnapshot);//首次加载primary
    }
....
  }

playlist获取后就会交友MediaSource类处理，MediaSource 有两个主要职责：

  1. 为播放器提供Timeline(定义了媒体结构)，当在媒体结构发生变化时提供新的Timeline。MediaSource 通过调用MediaSource.MediaSourceCaller.onSourceInfoRefreshed来提供这些时间线。
  2. 为其时间线中的Period提供MediaPeriod实例。MediaPeriods 是通过调用createPeriod获得的，并为播放器提供了一种加载和读取媒体的方式。关于Timeline
//HlsMediaSource
public void onPrimaryPlaylistRefreshed(HlsMediaPlaylist mediaPlaylist) {
    ....
    SinglePeriodTimeline timeline =
        playlistTracker.isLive()
            ? createTimelineForLive(
                mediaPlaylist, presentationStartTimeMs, windowStartTimeMs, manifest)
            : createTimelineForOnDemand(
                mediaPlaylist, presentationStartTimeMs, windowStartTimeMs, manifest);//Timeline在这里创建
    refreshSourceInfo(timeline);
  }

//BaseMediaSource
  protected final void refreshSourceInfo(Timeline timeline) {
    this.timeline = timeline;
    for (MediaSourceCaller caller : mediaSourceCallers) {
      caller.onSourceInfoRefreshed(/* source= */ this, timeline);
    }
  }

//CompositeMediaSource
protected final void prepareChildSource(@UnknownNull T id, MediaSource mediaSource) {
   ,....
    MediaSourceCaller caller =
        (source, timeline) -> onChildSourceInfoRefreshed(id, source, timeline);//调用此处prepare时注册的caller
  ....
  }

//MaskingMediaSource
protected void onChildSourceInfoRefreshed(
      Void id, MediaSource mediaSource, Timeline newTimeline) {
    @Nullable MediaPeriodId idForMaskingPeriodPreparation = null;
    ....
    if (idForMaskingPeriodPreparation != null) {
      Assertions.checkNotNull(unpreparedMaskingMediaPeriod)
          .createPeriod(idForMaskingPeriodPreparation);//创建HlsMediaPeriod
    }
  }
public void createPeriod(MediaPeriodId id) {
....
    if (callback != null) {
      mediaPeriod.prepare(/* callback= */ this, preparePositionUs);
    }
  }

HlsMediaPeriod用来加载Timeline里的Period

//HlsMediaPeriod
  public void prepare(Callback callback, long positionUs) {
    this.callback = callback;
    playlistTracker.addListener(this);
    buildAndPrepareSampleStreamWrappers(positionUs);
  }


private void buildAndPrepareSampleStreamWrappers(long positionUs) {
....
  
    for (HlsSampleStreamWrapper sampleStreamWrapper : this.sampleStreamWrappers) {
      sampleStreamWrapper.continuePreparing();
    }
   ....
  }

HlsSampleStreamWrapper包含一个HlsChunkSource用来获取HlsMediaChunk进行加载提供出SampleStream，
Chunk可以理解为数据块，这里对应一个ts文件，通过ChunkSource获取Chunk执行加载

//HlsSampleStreamWrapper
  public void continuePreparing() {
    if (!prepared) {
      continueLoading(lastSeekPositionUs);
    }
  }
public boolean continueLoading(long positionUs) {
....
    chunkSource.getNextChunk(
        positionUs,
        loadPositionUs,
        chunkQueue,
        /* allowEndOfStream= */ prepared || !chunkQueue.isEmpty(),
        nextChunkHolder);
....
    @Nullable Chunk loadable = nextChunkHolder.chunk;
   ....
    long elapsedRealtimeMs =
        loader.startLoading(//加载获取到的chunk，这里可以看到将回调函数设置在了HlsSampleStreamWrapper，后面加载完成后会回调它的onLoadCompleted方法
            loadable, this, loadErrorHandlingPolicy.getMinimumLoadableRetryCount(loadable.type));
  ....
    return true;
  }

这里看下获取下一个chunk 的代码，其实就是从解析的playerlist里通过获取Segment创建出对应的chunk

//HlsChunkSource
public void getNextChunk(
      long playbackPositionUs,
      long loadPositionUs,
      List<HlsMediaChunk> queue,
      boolean allowEndOfStream,
      HlsChunkHolder out) {
  ....
    // Select the track.
    MediaChunkIterator[] mediaChunkIterators = createMediaChunkIterators(previous, loadPositionUs);
    trackSelection.updateSelectedTrack(
        playbackPositionUs, bufferedDurationUs, timeToLiveEdgeUs, queue, mediaChunkIterators);
  ....
    @Nullable
    HlsMediaPlaylist playlist =
        playlistTracker.getPlaylistSnapshot(selectedPlaylistUrl, /* isForPlayback= */ true);//通过Tracker获取当前播放的列表
....
    Pair<Long, Integer> nextMediaSequenceAndPartIndex =
        getNextMediaSequenceAndPartIndex(
            previous, switchingTrack, playlist, startOfPlaylistInPeriodUs, loadPositionUs);//获取下一个Sequence也就是m3u8里的下一个片段索引
    long chunkMediaSequence = nextMediaSequenceAndPartIndex.first;
    int partIndex = nextMediaSequenceAndPartIndex.second;
   ....
    @Nullable
    SegmentBaseHolder segmentBaseHolder =
        getNextSegmentHolder(playlist, chunkMediaSequence, partIndex);//获取信息
   ....
   //创建通过获取的Segment创建出对应的chunk
    out.chunk =
        HlsMediaChunk.createInstance(
            extractorFactory,
            mediaDataSource,
            playlistFormats[selectedTrackIndex],
            startOfPlaylistInPeriodUs,
            playlist,
            segmentBaseHolder,
            selectedPlaylistUrl,
            muxedCaptionFormats,
            trackSelection.getSelectionReason(),
            trackSelection.getSelectionData(),
            isTimestampMaster,
            timestampAdjusterProvider,
            previous,
            /* mediaSegmentKey= */ keyCache.get(mediaSegmentKeyUri),
            /* initSegmentKey= */ keyCache.get(initSegmentKeyUri),
            shouldSpliceIn,
            playerId);
  }

MediaChunk执行chunk加载，首先通过prepareExtraction创建出input数据流和HlsMediaChunkExtractor执行器，然后通过执行器执行相应的流，流的这块后续处理还是比较复杂的不是本文重点，主要目的就是ts文件的Demux，解析出Demux（对应代码里的Sample，相当于一帧）后的数据发送到一个DataQuene里供Renderer获取，Renderer最终调用系统的MediaCodec渲染到surface上

//HlsMediaChunk
public void load() throws IOException {
   ....
    if (!loadCanceled) {
      if (!hasGapTag) {
        loadMedia();
      }
      loadCompleted = !loadCanceled;
    }
}

private void loadMedia() throws IOException {
    feedDataToExtractor(
        dataSource, dataSpec, mediaSegmentEncrypted, /* initializeTimestampAdjuster= */ true);
}

private void feedDataToExtractor(
      DataSource dataSource,
      DataSpec dataSpec,
      boolean dataIsEncrypted,
      boolean initializeTimestampAdjuster)
      throws IOException {
....
    try {
      ExtractorInput input =
          prepareExtraction(dataSource, loadDataSpec, initializeTimestampAdjuster);
      if (skipLoadedBytes) {
        input.skipFully(nextLoadPosition);
      }
      try {
        while (!loadCanceled && extractor.read(input)) {}//通过执行器执行相应的流
      } catch (EOFException e) {
        ....
}

private DefaultExtractorInput prepareExtraction(
      DataSource dataSource, DataSpec dataSpec, boolean initializeTimestampAdjuster)
      throws IOException {
    long bytesToRead = dataSource.open(dataSpec);//这里又看到熟悉的代码类似ParsingLoadable加载m3u8文件一样，调用我们的三通TeeDataSource从网络获取ts文件，数据流会保存在datasource等待读取，读取时缓存文件
   ....
    DefaultExtractorInput extractorInput =
        new DefaultExtractorInput(dataSource, dataSpec.position, bytesToRead);//数据流

    if (extractor == null) {
....
      extractor =//执行器
          previousExtractor != null
              ? previousExtractor.recreate()
              : extractorFactory.createExtractor(
                  dataSpec.uri,
                  trackFormat,
                  muxedCaptionFormats,
                  timestampAdjuster,
                  dataSource.getResponseHeaders(),
                  extractorInput,
                  playerId);
   ....
    return extractorInput;
}

到这里第一个ts文件已经加载，读取流，完成后会回到HlsSampleStreamWrapper这个类的onLoadCompleted方法，后续的ts文件加载会在播放器主loop里循环判断是否要继续加载，如果判断需要继续加载，最终调用continueLoading实现加载下一个ts文件。最具调用判断过程后续会讲到。

//HlsSampleStreamWrapper
public void onLoadCompleted(Chunk loadable, long elapsedRealtimeMs, long loadDurationMs) {
    loadingChunk = null;
    chunkSource.onChunkLoadCompleted(loadable);
....
    if (!prepared) {
      continueLoading(lastSeekPositionUs);
    } else {
      callback.onContinueLoadingRequested(this);
    }
  }

至此HLS的m3u8文件加载解析以及ts文件读取的大致流程就完成了

山雨楼
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
HLS流媒体协议介绍
RdaOniCelK的专栏
12-18 1432
HLS流媒体协议介绍HLS流媒体协议介绍 简介 结构 组件 传输协议HTTP 封装格式mpegts 多码率自适应m3u8一级 媒体内容描述m3u8二级 应用架构实战 相关工具使用简介HLS(HTTP Live Streaming)是苹果公司推出的流媒体协议, 用于直播或点播场景, 应该算是当前平台兼容性最好的流媒体协议了. 其他主流的流媒体协议还有RTP(内容传输使用UDP)和Adobe的RTMP(
m3u8-parser:Java的简单HLS播放列表解析器
05-09
m3u8解析器 一个用于Java的简单HLS播放列表解析器。 该项目的目标是根据实现解析器和一致的Java对象模型。 该解析器与iHeartRadio的非常相似。 主要区别在于： m3u8-parser不会尝试验证播放列表。 您负责创建...
Android ExoPlayer2播放m3u8视频设置Cookie
qq751132143的博客
09-20 2780
Android ExoPlayer2播放m3u8视频设置Cookie
Android-基于googleExoPlayer播放hls的m3u8rtmpmp4文件；
08-12
基于google ExoPlayer播放hls的m3u8，rtmp，mp4文件,；简单自定义播放界面
Exoplayer播放 .m3u8格式的视频问题总结
唐诺
06-10 1963
您的视频使用这些特定设备不支持的 H.264 Main Profile (avc1.4D)。Main Profile 的最低要求是 6.0+。
ExoPlayer 2.18.2 基本使用（三）
Jeffray1991的博客
02-10 1049
如何用exoplayer实现m3u8视频文件的播放？一篇文章帮你搞定！
基于 Web 实现 m3u8 视频播放的简单应用示例
Python栈
06-16 6142
将视频（MP4 等）转换为 M3U8 视频的服务，可以按照以下步骤进行操作
m3u8下载器N-m3u8DL-CLI v3.0.2便携版.zip
08-30
m3u8文件是一个包含多媒体数据片段的索引文件，用于指示播放器如何组合这些片段以播放完整的视频。N-m3u8DL-CLI能够高效地解析这些文件，并将每个片段下载到本地，然后合并成一个完整的视频文件，从而实现离线观看。...
HTML5播放m3u8(hls)格式视频以及播放直播m3u8(hls)视频完整代码
01-03
否则，创建一个HLS.js实例，加载M3U8源，并将其与视频元素关联，解析完成后自动开始播放。 在提供的压缩包中，`index.html`可能是基础的HTML5视频播放器示例，`本地媒体映射播放直播m3u8(hls)格式视频播放器.html`...
uniapp npm引入Dplayer与hls解析播放m3u8格式视频
09-08
uniapp npm引入Dplayer与hls解析播放m3u8格式视频
exoplayer播放器简单实用播放dash、hls流
05-23
简单的实现了exoplayer的集成，和测试播放dash流、hls流。文章：https://blog.csdn.net/u012560369/article/details/80417191
ExoPlayer系列1. HLS流播放
elvia7的博客
10-10 814
ExoPlayer是Google出品的视频播放器，功能强大，使用简单，独立于Android代码框架，以一个开源代码库的形式存在，可定制性强。ExoPlayer也是Google官方推荐的Android媒体播放器，可以在Android官方文档的音频和视频目录中找到。ExoPlayer和MediaPlayer相比，多了支持基于 HTTP 的动态自适应流 (DASH)、SmoothStreaming 和通用加密等功能。
加密Hls的播放
Jun的博客
09-26 440
目前存在很严重的视频资源泄露，视频资源倒卖的问题，为了加强版权保护，使用Hls加密，app本地解密播放。
Exoplayer 播放M3U8格式视频失败
tifuling7666的博客
01-02 5469
有人使用过EXOPLAYER的SDK嘛 ~  我用官方的DEMO，并不能直接播放优酷m3u8的流，求解决办法~~~
音视频开发（四十四）：M3U8边缓存边播放
m0_60259116的博客
04-16 2708
目录 MP4的“问题” m3u8是什么 m3u8的好处 源码分析 扩展思考：mp4能不能像m3u8一样进行分片缓存呐？ 一、MP4的“问题” 1.1 moov在mdat后影响秒开率 Mp4格式是一个个Box，其中moov存储的是metadata信息，mdat存储具体音视频数据信息。如果无法解析出moov数据，是无法播放该mp4文件的。而一般情况下ffmpeg生成moov是在mdat写入完成之后的，即mdat会在moov的前面，用mediaParse来查看
ExoPlayer详解——媒体类型（官方文档）
MRYZJ的博客
08-07 7988
一、DASH ExoPlayer支持多种容器格式的DASH。必须对媒体流进行解复用，这意味着必须在DASH清单中的不同AdaptationSet元素中定义视频，音频和文本（CEA-608是一个例外，如下表所述）。还必须支持包含的音频和视频样本格式（有关详细信息，请参阅 示例格式部分）。 特征 支持 评论 集装箱 FMP4 是 仅拆分流 WebM 是 仅拆分流 Mat...
ExoPlayer详解——入门（官方文档）
csdn_zxw的博客
03-05 1万+
ExoPlayer详解系列文章 ExoPlayer详解——入门（官方文档） ExoPlayer详解——媒体类型（官方文档） ExoPlayer详解——高级主题（官方文档） 一、ExoPlayer，你好 简单用例 入门ExoPlayer包括实现以下步骤： 将 ExoPlayer 添加为项目的依赖项。 创建一个 SimpleExoPlayer 实例。 将播放器连接到视图（用于视频输出和用户输入）。 ...
第二模块（函数编程（极速版））-第一章-函数编程
qq_36993243的博客
10-03 262
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、bytes类型二、字符编码的转换三、深浅copy三、函数来了四、函数返回值与作用域总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下
Android m3u8网络视频播放
热门推荐
冬无雪的博客
04-14 1万+
最近在做 m3u8网络视频播放，踩了不少坑，也试了不少的 框架，特别记录一下其中用的比较三种 第一种：media:ijkplayer media:ijkplayer 是由 bilbil 提供的开源的视频 框架，但是由过之后感觉不太好用： 优点： 1、支持 Android 和 IOS 2、支持多种视频的硬解码 缺点： 1、加载时间过长；从开始加载 到 开始播放 第一帧视频，中间最少需要十秒时间（一开始以为是自己的配置有问题，但在网上找了一下，但都没有找到好的解决方案） 2、不支持实时视频截图（由于项目的需要，
vue vue-video-player无法播放无音频流的m3u8
最新发布
01-18
根据提供的引用内容，可以使用vue-video-player播放m3u8格式的视频，但是无法播放无音频流的m3u8。为了解决这个问题，需要安装videojs-contrib-hls插件，并在Vue项目中进行配置。 以下是一个使用vue-video-player播放m3u8格式视频的示例： 1. 首先，安装vue-video-player和videojs-contrib-hls插件： ```shell npm install vue-video-player --save npm install videojs-contrib-hls --save ``` 2. 在main.js中引入vue-video-player和videojs-contrib-hls： ```javascript import Vue from 'vue' import VideoPlayer from 'vue-video-player' import 'vue-video-player/src/custom-theme.css' import 'video.js/dist/video-js.css' import 'videojs-contrib-hls' Vue.use(VideoPlayer) ``` 3. 在Vue组件中使用vue-video-player播放m3u8格式视频： ```html <template> <div> <video-player :options="playerOptions"></video-player> </div> </template> <script> export default { data() { return { playerOptions: { sources: [{ type: 'application/x-mpegURL', src: 'path/to/your/video.m3u8' }], autoplay: true, controls: true } } } } </script> ``` 请注意，以上示例中的"path/to/your/video.m3u8"应替换为实际的m3u8视频文件路径。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值