ExoPlayer播放关键帧加密FLV视频及seek操作

一、FLV格式文件结构

FLV文件的结构可以划分为两大块：文件头和文件体。文件体由ScriptTag、VideoTag和AudioTag组成

参考资料

Adobe FLV 官方文档

https://www.adobe.com/content/dam/Adobe/en/devnet/flv/pdfs/video_file_format_spec_v10.pdf

http://download.macromedia.com/f4v/video_file_format_spec_v10_1.pdf

FLV头：

Field	Type	Comment
签名（Signature）	UI8	'F'(0X46)
签名（Signature）	UI8	'L'(0X4C)
签名（Signature）	UI8	'V'(0x56)
版本（Version）	UI8	FLV的版本。0x01表示FLV 版本是1
保留字段（TypeFlagsReserved）	UB5	前五位必须是0
是否有音频流（TypeFlagsAudio）	UB1	音频Tag是否存在
保留字段（TypeFlagsReserved）	UB1	必须是0
是否有视频流（TypeFlagsVideo）	UB1	视频Tag是否存在
文件头大小（DataOffset）	UI32	FLV版本1时填写9，表明的是FLV头的大小，为后期的FLV版本扩展使用。包括这四个字节。数据的起始位置就是从文件开头偏移这么多的大小。

Signature: FLV 文件的前3个字节为固定的’F’、’L’、’V’，用来标识这个文件是flv格式的。在做格式探测的时候，如果发现前3个字节为“FLV”，就认为它是flv文件。
Flags: 第5个字节中的第0位和第2位,分别表示 video 与 audio 存在的情况(1表示存在,0表示不存在)。
DataOffset : 最后4个字节表示FLV header 长度。

FLV文件体结构：

Field	Type	Comment
PreviousTagSize0	UI32	总是0，前一个没有TAG，所以是0
Tag1	FLVTAG	第一个Tag
PreviousTagSize1	UI32	前一个TAG的大小
Tag2	FLVTAG
PreviousTagSize2	UI32
...	UB1
PreviousTagSize[N-1]	UB1
Tag[N]	UB1
PreviousTagSize[N]	UI32

FLV头之后，就是FLV文件体。
FLV文件体是由一连串的back-pointers + tags构成.back-pointers就是4个字节数据,表示前一个tag的size

FLV Tag结构:

Field	Type	Comment
TAG类型	UI8	8: audio 9: video 18: script data——Metadata。 all others: reserved其他所有值未使用。
数据大小	UI24	数据区的大小，不包括包头。包头总大小是11个字节。
时间戳	UI24	当前帧时戳，单位是毫秒。相对于FLV文件的第一个TAG时戳。第一个tag的时戳总是0。——不是时戳增量，rtmp中是时戳增量。
时戳扩展字段	UI8	如果时戳大于0xFFFFFF，将会使用这个字节。这个字节是时戳的高8位，上面的三个字节是低24位。
流ID	UI24	总是0
数据区	UI8[N]

Audio Tag:

Field	Type	Comment
音频格式(SoundFormat)	UB4	0 = Linear PCM, platform endian 1 = ADPCM 2 = MP3 3 = Linear PCM, little endian 4 = Nellymoser 16-kHz mono 5 = Nellymoser 8-kHz mono 6 = Nellymoser 7 = G.711 A-law logarithmic PCM 8 = G.711 mu-law logarithmic PCM 9 = reserved 10 = AAC 11 = Speex 14 = MP3 8-Khz 15 = Device-specific sound 7, 8, 14, and 15：内部保留使用。 flv是不支持g711a的，如果要用，可能要用线性音频。
采样率	UB2	For AAC: always 3 0 = 5.5-kHz 1 = 11-kHz 2 = 22-kHz 3 = 44-kHz
采样大小	UB1	0 = snd8Bit 1 = snd16Bit
声道	UB1	0=单声道 1=立体声,双声道。AAC永远是1
AACPacketType	IF SoundFormat == 10 UI8	The following values are defined: 0 = AAC sequence header 1 = AAC raw

如果音频格式（SoundFormat）是10 = AAC，AudioTagHeader中会多出1个字节的数据AACPacketType，这个字段来表示AACAUDIODATA的类型：0 = AAC sequence header，1 = AAC raw

AAC AudioData格式：

Field	Type	Comment
Data	IF AACPacketType ==0 AudioSpecificConfig	The AudioSpecificConfig is defined in ISO14496-3. Note that this is not the same as the contents of the esds box from an MP4/F4V file.
	ELSE IF AACPacketType == 1 Raw AAC frame data in UI8[n]	音频负载数据

VideoTag

Field	Type	Comment
帧类型	UB4	1: keyframe (for AVC, a seekable frame)——h264的IDR，关键帧。 2: inter frame (for AVC, a non- seekable frame)——h264的普通帧 3: disposable inter frame (H.263 only) 4: generated keyframe (reserved for server use only) 5: video info/command frame
编码ID	UB4	使用哪种编码类型： 1: JPEG (currently unused) 2: Sorenson H.263 3: Screen video 4: On2 VP6 5: On2 VP6 with alpha channel 6: Screen video version 2 7: AVC
视频数据	UI[N]	如果是avc，则参考下面的介绍： AVCVIDEOPACKET

AVC VIDEO PACKET:

Field	Type	Comment
AVC packet类型	UI8	0：AVC序列头 1：AVC NALU单元 2：AVC序列结束。低级别avc不需要。
CTS	SI24	如果AVC packet类型是1，则为cts偏移，为0则为0
数据	UI8[n]	如果AVC packet类型是0，则是解码器配置，sps，pps。如果是1，则是NAL单元，可以是多个

AVC VIDEO PACKET data格式：

Field	Type	Comment
长度	UI32	NAL单元(NAL unit，建成NALU)的长度，不包括长度字段。
nalu数据	UI8[N]	NALU数据，没有四个字节的NAL单元头，直接从h264头开始，比如：65 ，41
长度	UI32	NAL单元的长度，不包括长度字段。
nalu数据	UI8[N]	NALU数据，没有四个字节的NAL单元头，直接从h264头开始，比如：65 ，41
...	...	...

二、ExoPlayer解析FLV文件流程

1、通过DataSource打开数据源

2、通过提取器接口Extractor提取（读取）数据，这里的Extractor为FlvExtractor，循环调用Extractor的read方法，直到不需要继续读取。

final class ExtractingLoadable implements Loadable{
……
//打开媒体资源
length=dataSource.open(newDataSpec(uri,position,C.LENGTH_UNSET,Util.sha1(uri.toString())));
……
input=newDefaultExtractorInput(dataSource,position,length);
……
while(未取消&&需要继续读取){
    ……
    result=extractor.read(input,positionHolder);//从输入源中读取
    ……
    }
}

}

3、FlvExtractor读取数据

public final class FlvExtractor implements Extractor,SeekMap{
@Override
publicintread(ExtractorInputinput,PositionHolderseekPosition)throwsIOException,
InterruptedException{
while(true){
    switch(parserState){
     case STATE_READING_FLV_HEADER:
        //读取FLVHeader
        if(!readFlvHeader(input)){
            returnRESULT_END_OF_INPUT;
        }
     break;
     case STATE_SKIPPING_TO_TAG_HEADER:
        //跳过前上一个读取过的TAG，跳至下一个TAG的头
        skipToTagHeader(input);
     break;
     caseSTATE_READING_TAG_HEADER:
        //读取每个TAG的Header信息
        if(!readTagHeader(input)){
            returnRESULT_END_OF_INPUT;
        }
     break;
     case STATE_READING_TAG_DATA:
        //读取TAG数据
        if(readTagData(input)){
            returnRESULT_CONTINUE;
        }
     break;
    }
  }
 }
}

3.1.读取FLVHeader

private boolean readFlvHeader(ExtractorInput input) throws IOException,InterruptedException{
    //固定读取从0开始的9个字节数据
    if(!input.readFully(headerBuffer.data,0,FLV_HEADER_SIZE,true)){
       //We'vereachedtheendofthestream.
       return false;
    }
    
    headerBuffer.setPosition(0);
    headerBuffer.skipBytes(4);//跳过前4个字节，分别为'F'、'L'、'V'和版本号
    int flags=headerBuffer.readUnsignedByte();//读取下一个字节
    boolean hasAudio=(flags&0x04)!=0;//是否有音频
    boolean hasVideo=(flags&0x01)!=0;//是否有视频
    if(hasAudio&&audioReader==null){
      //有音频且AudioTagPayloadReader未创建，则创建AudioTagPayloadReader
      audioReader=newAudioTagPayloadReader(extractorOutput.track(TAG_TYPE_AUDIO));
    }
    if(hasVideo&&videoReader==null){
      //有视频且VideoTagPayloadReader未创建，则创建VideoTagPayloadReader
      videoReader=newVideoTagPayloadReader(extractorOutput.track(TAG_TYPE_VIDEO));
    }
    if(metadataReader==null){
      //创建ScriptTagPayloadReader，用来读取Metadata数据
      metadataReader=newScriptTagPayloadReader(null);
    }
    extractorOutput.endTracks();
    extractorOutput.seekMap(this);
    
    //WeneedtoskipanyadditionalcontentintheFLVheader,plusthe4byteprevioustagsize.
    bytesToNextTagHeader=headerBuffer.readInt()-FLV_HEADER_SIZE+4;
    parserState=STATE_SKIPPING_TO_TAG_HEADER;
    return true;
}

3.2.读取TAGHeader

private boolean readTagHeader(ExtractorInput input) throws IOException,InterruptedException{
    if(!input.readFully(tagHeaderBuffer.data,0,FLV_TAG_HEADER_SIZE,true)){
      //We'vereachedtheendofthestream.
      return false;
    }
    
    tagHeaderBuffer.setPosition(0);
    tagType=tagHeaderBuffer.readUnsignedByte();//读取1字节数据，其中记录TAG的类型（8:audio,9:video,18:Metadata）
    tagDataSize=tagHeaderBuffer.readUnsignedInt24();//读取24位，即3字节，记录数据区大小
    tagTimestampUs=tagHeaderBuffer.readUnsignedInt24();//读取24位，TAG的时间戳
    tagTimestampUs=((tagHeaderBuffer.readUnsignedByte()<<24)|tagTimestampUs)*1000L;
    tagHeaderBuffer.skipBytes(3);//streamId跳过3字节流ID数据，因为它总是0
    //剩余的8*N位数据就是各TAG的数据区了，将state置为“读取TAG数据状态”，下一次循环便是读取具体的TAG数据
    parserState=STATE_READING_TAG_DATA;
    return true;

}

3.3.读取TAG Data

根据TagType对各种类型的TagData进行读取，每次循环只读取一种类型的TagData:

private boolean readTagData(ExtractorInput input) throws IOException, InterruptedException {
    boolean wasConsumed = true;
    if (tagType == TAG_TYPE_AUDIO && audioReader != null) {
      //音频
      audioReader.consume(prepareTagData(input), tagTimestampUs);
    } else if (tagType == TAG_TYPE_VIDEO && videoReader != null) {
      //视频
      videoReader.consume(prepareTagData(input), tagTimestampUs);
    } else if (tagType == TAG_TYPE_SCRIPT_DATA && metadataReader != null) {
      //metadata
      metadataReader.consume(prepareTagData(input), tagTimestampUs);
    } else {
      input.skipFully(tagDataSize);
      wasConsumed = false;
    }
    bytesToNextTagHeader = 4; // There's a 4 byte previous tag size before the next header.
    parserState = STATE_SKIPPING_TO_TAG_HEADER;
    return wasConsumed;
  }

VideoReader、AudioReader、MetadataReader均继承自TagPayloadReader，其consume方法内部调用抽象方法parseHeader和parsePayload对各种TagHeader和TagData进行解析，解析过程都是先解析头后解析负载：

public final void consume(ParsableByteArray data, long timeUs) throws ParserException {
    if (parseHeader(data)) {
      parsePayload(data, timeUs);
    }
  }

首先调用的是MetadataReader，得到视音频编码方式等媒体信息，之后的循环会调用或对音频或视频Tag进行解析。下面分别对VideoReader和AudioReader进行介绍。

3.3.1.VideoReader解析VideoTag:

解析VideoTag头数据

protected boolean parseHeader(ParsableByteArray data) throws UnsupportedFormatException {
        int header = data.readUnsignedByte();//读取1字节数据
        int frameType = (header >> 4) & 0x0F;//前4位代表帧类型 1：关键帧，2：普通帧。其它3/4/5类型说明
        int videoCodec = (header & 0x0F);//后4位代表编码方式，7
        // Support just H.264 encoded content.
        if (videoCodec != VIDEO_CODEC_AVC) {
            //不是AVC编码的不能播放，直接抛出异常
            throw new UnsupportedFormatException("Video format not supported: " + videoCodec);
        }
        this.frameType = frameType;
        return (frameType != VIDEO_FRAME_VIDEO_INFO);
    }

解析VideoTag负载数据

protected void parsePayload(ParsableByteArray data, long timeUs) throws ParserException {
//读取1字节，AVC packet类型
        // 0：AVC序列头
        // 1：AVC NALU单元
        // 2：AVC序列结束
        int packetType = data.readUnsignedByte();
        int compositionTimeMs = data.readUnsignedInt24();
        timeUs += compositionTimeMs * 1000L;
        // Parse avc sequence header in case this was not done before.
// Parse avc sequence header in case this was not done before.
        if (packetType == AVC_PACKET_TYPE_SEQUENCE_HEADER && !hasOutputFormat) {
            //读取ACV packet序列头
            ParsableByteArray videoSequence = new ParsableByteArray(new byte[data.bytesLeft()]);
            data.readBytes(videoSequence.data, 0, data.bytesLeft());
            AvcConfig avcConfig = AvcConfig.parse(videoSequence);
            nalUnitLengthFieldLength = avcConfig.nalUnitLengthFieldLength;
            // Construct and output the format.
            Format format = Format.createVideoSampleFormat(null, MimeTypes.VIDEO_H264, null,
                    Format.NO_VALUE, Format.NO_VALUE, avcConfig.width, avcConfig.height, Format.NO_VALUE,
                    avcConfig.initializationData, Format.NO_VALUE, avcConfig.pixelWidthAspectRatio, null);
            output.format(format);
            hasOutputFormat = true;
        }else if (packetType == AVC_PACKET_TYPE_AVC_NALU) {
            //读取ACV packet NALU单元
            // TODO: Deduplicate with Mp4Extractor.
            // Zero the top three bytes of the array that we'll use to decode nal unit lengths, in case
            // they're only 1 or 2 bytes long.
            byte[] nalLengthData = nalLength.data;
            nalLengthData[0] = 0;
            nalLengthData[1] = 0;
            nalLengthData[2] = 0;
            int nalUnitLengthFieldLengthDiff = 4 - nalUnitLengthFieldLength;
            // NAL units are length delimited, but the decoder requires start code delimited units.
            // Loop until we've written the sample to the track output, replacing length delimiters with
            // start codes as we encounter them.
            int bytesWritten = 0;
            int bytesToWrite;
            while (data.bytesLeft() > 0) {
            //读取NAL数据单元
            // Read the NAL length so that we know where we find the next one.
            data.readBytes(nalLength.data, nalUnitLengthFieldLengthDiff, nalUnitLengthFieldLength);
            nalLength.setPosition(0);
            bytesToWrite = nalLength.readUnsignedIntToInt();

            // Write a start code for the current NAL unit.
            nalStartCode.setPosition(0);
            output.sampleData(nalStartCode, 4);
            bytesWritten += 4;
            
            // Write the payload of the NAL unit.
            //输出负载数据
            output.sampleData(data, bytesToWrite);
            bytesWritten += bytesToWrite;
       }
       output.sampleMetadata(timeUs, frameType == VIDEO_FRAME_KEYFRAME ? C.BUFFER_FLAG_KEY_FRAME : 0,
                    bytesWritten, 0, null);
     }
}

3.3.2.AudioReader解析AudioTag:

解析AudioTag头数据

protected boolean parseHeader(ParsableByteArray data) throws UnsupportedFormatException {
    if (!hasParsedAudioDataHeader) {
      int header = data.readUnsignedByte();//读取第1字节数据
      int audioFormat = (header >> 4) & 0x0F;//前4位代表音频格式，AAC:10
      int sampleRateIndex = (header >> 2) & 0x03;//接着2位代表采样率，44000：3
      if (sampleRateIndex < 0 || sampleRateIndex >= AUDIO_SAMPLING_RATE_TABLE.length) {
        throw new UnsupportedFormatException("Invalid sample rate index: " + sampleRateIndex);
      }
      // TODO: Add support for MP3 and PCM.
      if (audioFormat != AUDIO_FORMAT_AAC) {
        //暂时不支持除AAC以外的音频格式
        throw new UnsupportedFormatException("Audio format not supported: " + audioFormat);
      }
      hasParsedAudioDataHeader = true;
    } else {
      // Skip header if it was parsed previously.
      data.skipBytes(1);//跳过第一字节
    }
    return true;
  }

解析AudioTag负载数据

protected void parsePayload(ParsableByteArray data, long timeUs) {
    /**
     * 如果是AAC，负载数据的第一个字节为AACPacketType：
     * 0 = AAC sequence header（AAC序列头）
     * 1 = AAC raw（音频ES流）
     */
    int packetType = data.readUnsignedByte();
    // Parse sequence header just in case it was not done before.
    if (packetType == AAC_PACKET_TYPE_SEQUENCE_HEADER && !hasOutputFormat) {
      byte[] audioSpecifiConfig = new byte[data.bytesLeft()];
      data.readBytes(audioSpecifiConfig, 0, audioSpecifiConfig.length);
      Pair<Integer, Integer> audioParams = CodecSpecificDataUtil.parseAacAudioSpecificConfig(
          audioSpecifiConfig);
      Format format = Format.createAudioSampleFormat(null, MimeTypes.AUDIO_AAC, null,
          Format.NO_VALUE, Format.NO_VALUE, audioParams.second, audioParams.first,
          Collections.singletonList(audioSpecifiConfig), null, 0, null);
      output.format(format);
      hasOutputFormat = true;
    } else if (packetType == AAC_PACKET_TYPE_AAC_RAW) {
      // Sample audio AAC frames
      int bytesToWrite = data.bytesLeft();
      output.sampleData(data, bytesToWrite);
      output.sampleMetadata(timeUs, C.BUFFER_FLAG_KEY_FRAME, bytesToWrite, 0, null);
    }
  }

三、解密关键帧数据

由于VideoReader、AudioReader均继承自TagPayloadReader，在TagPayloadReader中增加解密数据的方法:

/**
   *
   * @param originBytes 原始数据
   * @return 解密后数据
   */
  protected byte[] decryptBytes(byte[] originBytes) {
    try {
      final Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
      cipher.init(Cipher.DECRYPT_MODE, ecbSecretKey);//ecbSecretKey为解密key
      return cipher.doFinal(originBytes);
    } catch (Exception e) {
      e.printStackTrace();
    }
    return originBytes;
  }

需要对数据解密时，只需调用父类的decryptBytes方法即可。
因此，在VideoReader、AudioReader加入解密代码：

//VideoReader代码片段 
//…………
else if (packetType == AVC_PACKET_TYPE_AVC_NALU) {
            //对关键帧数据进行解密
            Log.i("VIDEO", "是否关键帧 = " + (frameType == VIDEO_FRAME_KEYFRAME));
            //TODO 在while循环之前就应该把data.bytesLeft()这部分加密的数据解出来。
            if (frameType == VIDEO_FRAME_KEYFRAME) {
                try {
                    final byte[] tmpData = new byte[data.bytesLeft()];
                    data.readBytesToBuffer(tmpData, 0, data.bytesLeft());
                    final byte[] decryptBytes = decryptBytes(tmpData);//解密数据
                    data.reset(decryptBytes, decryptBytes.length, 0);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //解密关键帧数据结束
            while (data.bytesLeft() > 0) {
                //读取NAL数据单元
                //……           
          }
            //…………
        }

//AudioReader代码片段
//………… 
else if (packetType == AAC_PACKET_TYPE_AAC_RAW) {
      // Sample audio AAC frames
      //TODO 在这里将加密的data.bytesLeft()音频帧数据解密
      try {
        final byte[] tmpData = new byte[data.bytesLeft()];
        data.readBytesToBuffer(tmpData,0,data.bytesLeft());
        final byte[] decryptBytes = decryptBytes(tmpData);//解密数据
        final long start = System.nanoTime();
        Log.i("AUDIO", "lost time:"+(System.nanoTime()-start));
        data.reset(decryptBytes,decryptBytes.length);
      } catch (Exception e) {
        e.printStackTrace();
      }
      int bytesToWrite = data.bytesLeft();
      output.sampleData(data, bytesToWrite);
      output.sampleMetadata(timeUs, C.BUFFER_FLAG_KEY_FRAME, bytesToWrite, 0, null);
    }

以上，只需在播放关键帧加密的FLV视频时提供正确的key，就可以实现关键帧加密FLV的正常播放。

四、使ExoPlayer支持FLV文件seek播放

FLV文件没有建立器keyframe索引，每次拖动播放都必须从当前位置加载所有Tag数据，直到目标位置，缓冲时间长，效果极差。民间的一般做法是在ScriptTag中加入keyframes数据，用来建立起关键帧和文件位置的索引，这是一种非官方的标。

keyframes字段包含filepositions和times两个集合。times字段的值为关键帧数组，filepositions字段的值为times字段关键帧对应的在文件中的位置数组。filepositions和times两个数组的长度必须相同，数据类型均为double类型，且fileposition和time一一对应。

在播放器解析ScriptTag的负载数据时，将keyframes中的两个集合filepositions、times读取出来。在用户进行seek操作时，根据用户seek到的时间点，去times数组中比对跟这个时间点最接近值，拿到这个值在times数组中的位置mostCloseTimeIndex,由于fileposition和time一一对应，因此根据这个mostCloseTimeIndex去filepositions取对应位置的position值，就是用户拖动的时间点最接近的关键帧在文件中的位置。从该位置读取数据源，即可实现seek播放。
具体操作见代码片段：

1、从ScriptTag中提取keyframes数据

protected void parsePayload(ParsableByteArray data, long timeUs) throws ParserException {
    …………
    //有hasKeyframes域，且hasKeyframes的值为true
   if (metadata.containsKey(KEY_HAS_KEYFRAMES) && (boolean) metadata.get(KEY_HAS_KEYFRAMES)) {
     Log.i("ScriptReader", "hasKeyframes = true");

        //从元数据中取keyframes数据
     final HashMap<String, ArrayList<Double>> keyframes = (HashMap) metadata.get(KEY_KEYFRAMES);

        //keyframes不为null，且filepositions、times字段均存在
     if (keyframes != null && keyframes.containsKey(KEY_FILE_POSITIONS) && keyframes.containsKey(KEY_TIMES)) {
           //取filepositions集合
           mFilePositions = keyframes.get(KEY_FILE_POSITIONS);

           //取times集合
           mTimes = keyframes.get(KEY_TIMES);

           //只有在filepositions、times集合都不为空且长度相等时，在已进行seek
          if (mFilePositions != null && mFilePositions.size() > 0 && mTimes != null && mTimes.size() == mFilePositions.size())
              mSeekable = true;

             Log.i("ScriptReader", "filePositions = " + mFilePositions);
             Log.i("ScriptReader", "times = " + mTimes);
        }
    } else {
       //否则不可seek
        mSeekable = false;
    }
}

2、FlvExtractor中的操作
在读取完ScriptTag之后，得到seekable状态：

private boolean readTagData(ExtractorInput input) throws IOException, InterruptedException {
        boolean wasConsumed = true;
        if (tagType == TAG_TYPE_AUDIO && audioReader != null) {
            //音频
            audioReader.consume(prepareTagData(input), tagTimestampUs);
        } else if (tagType == TAG_TYPE_VIDEO && videoReader != null) {
            //视频
            videoReader.consume(prepareTagData(input), tagTimestampUs);
        } else if (tagType == TAG_TYPE_SCRIPT_DATA && metadataReader != null) {
            //metadata
            metadataReader.consume(prepareTagData(input), tagTimestampUs);
            mSeekAble = metadataReader.isSeekAble();//获取seekable状态
        } else {
            input.skipFully(tagDataSize);
            wasConsumed = false;
        }
        bytesToNextTagHeader = 4; // There's a 4 byte previous tag size before the next header.
        parserState = STATE_SKIPPING_TO_TAG_HEADER;
        return wasConsumed;
    }

根据用户操作拖动的时间点，获取对应的应该开始加载的文件位置，并返回，数据加载器会从这个位置开始加载数据，跳过中间部分：

public long getPosition(long timeUs) {
        final long startT = System.nanoTime();
        double tmpTime = (double) timeUs / 1000 / 1000;
        final ArrayList<Double> times = metadataReader.getTimes();
        double tmpAbs = 0;
        int mostCloseIndex = 0;
        //取给定时间最接近的关键帧时间点
        for (int i = 0; i < times.size(); i++) {
            final double abs = Math.abs(times.get(i) - tmpTime);
            if (tmpAbs == 0) {
                tmpAbs = abs;
                mostCloseIndex = i;
            } else if (abs <= tmpAbs) {
                tmpAbs = abs;
                mostCloseIndex = i;
            }
        }
        final double mostCloseTime = metadataReader.getTimes().get(mostCloseIndex);

      //取给定时间最接近的关键帧时间点对应的在文件中的位置
        final double mostClosePos = metadataReader.getFilePositions().get(mostCloseIndex);

        Log.i("FlvExtractor", "getPosition lost time : " + (System.nanoTime()-startT));
        Log.i("FlvExtractor", "mostCloseIndex: " + mostCloseIndex + ",mostCloseTime: " + mostCloseTime + ",mostClosePos: " + mostClosePos);
        Log.i("FlvExtractor", "tmpTime: " + tmpTime);
        Log.i("FlvExtractor", "getPosition: " + timeUs);
        return (long) mostClosePos;
    }

从指定位置开始加载数据

 ExtractingLoadable loadable = new ExtractingLoadable(uri, dataSource, extractorHolder, loadCondition);
·······
    loadable.setLoadPosition(seekMap.getPosition(pendingResetPositionUs));//
·······

final class ExtractingLoadable implements Loadable{
······
public void setLoadPosition(long position) {
   positionHolder.position = position;
   pendingExtractorSeek = true;
}
······
}

dataSource.open( new DataSpec(uri, position, C.LENGTH_UNSET, Util.sha1(uri.toString())));//打开媒体资源

private HttpURLConnection makeConnection(URL url, byte[] postBody, long position,
      long length, boolean allowGzip, boolean followRedirects) throws IOException {
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setConnectTimeout(connectTimeoutMillis);
    connection.setReadTimeout(readTimeoutMillis);
    synchronized (requestProperties) {
      for (Map.Entry<String, String> property : requestProperties.entrySet()) {
        connection.setRequestProperty(property.getKey(), property.getValue());
      }
    }
    if (!(position == 0 && length == C.LENGTH_UNSET)) {
      String rangeRequest = "bytes=" + position + "-";//从指定位置开始加载数据
      if (length != C.LENGTH_UNSET) {
        rangeRequest += (position + length - 1);
      }
      connection.setRequestProperty("Range", rangeRequest);
    }
·········

以上便可实现flv的拖动播放。

kllanc说道：

2020年10月16日 06:50

请问支持FLV文件seek播放部分
getPosition 及后续代码是添加在那里？

回复
- gongshoudao说道：
  
  2020年10月29日 14:33
  
  1.关于getPosition，它是SeekMap接口中的一个方法，FlvExtractor（com.google.android.exoplayer2.extractor.flv.FlvExtractor）实现了它但是getPosition返回0（即官方没有实现FLV的seek功能），因此需要自己做getPosition的逻辑。其中，final ArrayList times = metadataReader.getTimes(); 及metadataReader.getFilePositions()这几行代码中的metadataReader是ScriptTagPayloadReader，你需要在consume方法中解析并缓存上文提到的“民间方法”加入进去的关键帧位置信息，在getPosition方法中进行匹配。
  
  2.后面两块代码，是ExtractorMediaPeriod、DefaultHttpDataSource中本来就有的，是通用的其它封装格式媒体的seek逻辑；
  
  具体怎么实现，看一下EXOPlayer 2.0的源码，结合文章应该就能明白。
  
  回复
Robertswest说道：

2024年5月15日 08:37

Как осуществляется доставка?
Пакеты-майки https://мир-пак.рф/products/gilza-kartonnaya-1500mm-d65x2mm

回复

一、FLV格式文件结构

二、ExoPlayer解析FLV文件流程

三、解密关键帧数据

四、使ExoPlayer支持FLV文件seek播放

No Responses

发表评论 取消回复

发表评论取消回复