From 8ddc73511e0129f73b09f76d8028753c9b1f67d6 Mon Sep 17 00:00:00 2001 From: joli Date: Tue, 29 Sep 2015 03:30:57 +0200 Subject: [PATCH] FLV Support - Added Audio and Script Data readers --- .../android/exoplayer/demo/Samples.java | 3 + .../extractor/ExtractorSampleSource.java | 7 + .../extractor/flv/AudioTagReader.java | 150 +++++++++++ .../exoplayer/extractor/flv/FlvExtractor.java | 236 ++++++++++++++++++ .../extractor/flv/MetadataReader.java | 203 +++++++++++++++ .../exoplayer/extractor/flv/TagHeader.java | 15 ++ .../exoplayer/extractor/flv/TagReader.java | 75 ++++++ .../extractor/flv/VideoTagReader.java | 104 ++++++++ 8 files changed, 793 insertions(+) create mode 100644 library/src/main/java/com/google/android/exoplayer/extractor/flv/AudioTagReader.java create mode 100644 library/src/main/java/com/google/android/exoplayer/extractor/flv/FlvExtractor.java create mode 100644 library/src/main/java/com/google/android/exoplayer/extractor/flv/MetadataReader.java create mode 100644 library/src/main/java/com/google/android/exoplayer/extractor/flv/TagHeader.java create mode 100644 library/src/main/java/com/google/android/exoplayer/extractor/flv/TagReader.java create mode 100644 library/src/main/java/com/google/android/exoplayer/extractor/flv/VideoTagReader.java diff --git a/demo/src/main/java/com/google/android/exoplayer/demo/Samples.java b/demo/src/main/java/com/google/android/exoplayer/demo/Samples.java index ef54b3ebc0..98c8bb2066 100644 --- a/demo/src/main/java/com/google/android/exoplayer/demo/Samples.java +++ b/demo/src/main/java/com/google/android/exoplayer/demo/Samples.java @@ -145,6 +145,9 @@ import java.util.Locale; "http://storage.googleapis.com/exoplayer-test-media-0/play.mp3", PlayerActivity.TYPE_OTHER), new Sample("Google Glass (WebM Video with Vorbis Audio)", "http://demos.webmproject.org/exoplayer/glass_vp9_vorbis.webm", PlayerActivity.TYPE_OTHER), + new Sample("FLV Sample", + "http://master255.org/res/%D0%9A%D0%BB%D0%B8%D0%BF%D1%8B/B/Black%20Eyed%20Peas/black%20ey" + + "ed%20peas-My%20Humps.flv", PlayerActivity.TYPE_OTHER), }; private Samples() {} diff --git a/library/src/main/java/com/google/android/exoplayer/extractor/ExtractorSampleSource.java b/library/src/main/java/com/google/android/exoplayer/extractor/ExtractorSampleSource.java index 8f0bc4977b..982894e4b5 100644 --- a/library/src/main/java/com/google/android/exoplayer/extractor/ExtractorSampleSource.java +++ b/library/src/main/java/com/google/android/exoplayer/extractor/ExtractorSampleSource.java @@ -146,6 +146,13 @@ public final class ExtractorSampleSource implements SampleSource, SampleSourceRe } catch (ClassNotFoundException e) { // Extractor not found. } + try { + DEFAULT_EXTRACTOR_CLASSES.add( + Class.forName("com.google.android.exoplayer.extractor.flv.FlvExtractor") + .asSubclass(Extractor.class)); + } catch (ClassNotFoundException e) { + // Extractor not found. + } } private final ExtractorHolder extractorHolder; diff --git a/library/src/main/java/com/google/android/exoplayer/extractor/flv/AudioTagReader.java b/library/src/main/java/com/google/android/exoplayer/extractor/flv/AudioTagReader.java new file mode 100644 index 0000000000..bde1cbbdea --- /dev/null +++ b/library/src/main/java/com/google/android/exoplayer/extractor/flv/AudioTagReader.java @@ -0,0 +1,150 @@ +package com.google.android.exoplayer.extractor.flv; + +import android.util.Log; +import android.util.Pair; + +import com.google.android.exoplayer.C; +import com.google.android.exoplayer.MediaFormat; +import com.google.android.exoplayer.extractor.TrackOutput; +import com.google.android.exoplayer.util.CodecSpecificDataUtil; +import com.google.android.exoplayer.util.MimeTypes; +import com.google.android.exoplayer.util.ParsableBitArray; +import com.google.android.exoplayer.util.ParsableByteArray; + +import java.util.Collections; + +/** + * Created by joliva on 9/27/15. + */ +public class AudioTagReader extends TagReader{ + + private static final String TAG = "AudioTagReader"; + + // Sound format + private static final int AUDIO_FORMAT_LINEAR_PCM_PLATFORM_ENDIAN = 0; + private static final int AUDIO_FORMAT_ADPCM = 1; + private static final int AUDIO_FORMAT_MP3 = 2; + private static final int AUDIO_FORMAT_LINEAR_PCM_LITTLE_ENDIAN = 3; + private static final int AUDIO_FORMAT_NELLYMOSER_16KHZ_MONO = 4; + private static final int AUDIO_FORMAT_NELLYMOSER_8KHZ_MONO = 5; + private static final int AUDIO_FORMAT_NELLYMOSER = 6; + private static final int AUDIO_FORMAT_G711_A_LAW = 7; + private static final int AUDIO_FORMAT_G711_MU_LAW = 8; + private static final int AUDIO_FORMAT_RESERVED = 9; + private static final int AUDIO_FORMAT_AAC = 10; + private static final int AUDIO_FORMAT_SPEEX = 11; + private static final int AUDIO_FORMAT_MP3_8KHZ = 14; + private static final int AUDIO_FORMAT_DEVICE_SPECIFIC = 15; + + // AAC PACKET TYPE + private static final int AAC_PACKET_TYPE_SEQUENCE_HEADER = 0; + private static final int AAC_PACKET_TYPE_AAC_RAW = 1; + + private static final int[] AUDIO_SAMPLING_RATE_TABLE = new int[] { + 5500, 11000, 22000, 44000 + }; + + private int format; + private int sampleRate; + private int bitsPerSample; + private int channels; + + private boolean hasParsedAudioData; + private boolean hasOutputFormat; + + /** + * @param output A {@link TrackOutput} to which samples should be written. + */ + public AudioTagReader(TrackOutput output) { + super(output); + } + + @Override + public void seek() { + + } + + @Override + protected void parseHeader(ParsableByteArray data) throws UnsupportedTrack { + if (!hasParsedAudioData) { + int header = data.readUnsignedByte(); + int soundFormat = (header >> 4) & 0x0F; + int sampleRateIndex = (header >> 2) & 0x03; + int bitsPerSample = (header & 0x02) == 0x02 ? 16 : 8; + int channels = (header & 0x01) + 1; + + if (sampleRateIndex < 0 || sampleRateIndex >= AUDIO_SAMPLING_RATE_TABLE.length) { + throw new UnsupportedTrack("Invalid sample rate for the audio track"); + } + + if (!hasOutputFormat) { + switch (soundFormat) { + // raw audio data. Just creates media format + case AUDIO_FORMAT_LINEAR_PCM_LITTLE_ENDIAN: + output.format(MediaFormat.createAudioFormat(MimeTypes.AUDIO_RAW, MediaFormat.NO_VALUE, + MediaFormat.NO_VALUE, MediaFormat.NO_VALUE, channels, + AUDIO_SAMPLING_RATE_TABLE[sampleRateIndex], null, null)); + hasOutputFormat = true; + break; + + case AUDIO_FORMAT_AAC: + break; + + case AUDIO_FORMAT_MP3: + case AUDIO_FORMAT_MP3_8KHZ: + case AUDIO_FORMAT_LINEAR_PCM_PLATFORM_ENDIAN: + default: + throw new UnsupportedTrack("Audio track not supported. Format: " + soundFormat + + ", Sample rate: " + sampleRateIndex + ", bps: " + bitsPerSample + ", channels: " + + channels); + } + } + + this.format = soundFormat; + this.sampleRate = AUDIO_SAMPLING_RATE_TABLE[sampleRateIndex]; + this.bitsPerSample = bitsPerSample; + this.channels = channels; + + hasParsedAudioData = true; + } else { + data.skipBytes(1); + } + } + + @Override + protected void parsePayload(ParsableByteArray data, long timeUs) { + int packetType = data.readUnsignedByte(); + if (packetType == AAC_PACKET_TYPE_SEQUENCE_HEADER && !hasOutputFormat) { + ParsableBitArray adtsScratch = new ParsableBitArray(new byte[data.bytesLeft()]); + data.readBytes(adtsScratch.data, 0, data.bytesLeft()); + + int audioObjectType = adtsScratch.readBits(5); + int sampleRateIndex = adtsScratch.readBits(4); + int channelConfig = adtsScratch.readBits(4); + + byte[] audioSpecificConfig = CodecSpecificDataUtil.buildAacAudioSpecificConfig( + audioObjectType, sampleRateIndex, channelConfig); + Pair audioParams = CodecSpecificDataUtil.parseAacAudioSpecificConfig( + audioSpecificConfig); + + MediaFormat mediaFormat = MediaFormat.createAudioFormat(MimeTypes.AUDIO_AAC, + MediaFormat.NO_VALUE, MediaFormat.NO_VALUE, durationUs, audioParams.second, + audioParams.first, Collections.singletonList(audioSpecificConfig), null); + + output.format(mediaFormat); + hasOutputFormat = true; + } else if (packetType == AAC_PACKET_TYPE_AAC_RAW) { + int bytesToWrite = data.bytesLeft(); + output.sampleData(data, bytesToWrite); + output.sampleMetadata(timeUs, C.SAMPLE_FLAG_SYNC, bytesToWrite, 0, null); + + Log.d(TAG, "AAC TAG. Size: " + bytesToWrite + ", timeUs: " + timeUs); + } + } + + @Override + protected boolean shouldParsePayload() { + return (format == AUDIO_FORMAT_AAC); + } + +} diff --git a/library/src/main/java/com/google/android/exoplayer/extractor/flv/FlvExtractor.java b/library/src/main/java/com/google/android/exoplayer/extractor/flv/FlvExtractor.java new file mode 100644 index 0000000000..e94be312b0 --- /dev/null +++ b/library/src/main/java/com/google/android/exoplayer/extractor/flv/FlvExtractor.java @@ -0,0 +1,236 @@ +package com.google.android.exoplayer.extractor.flv; + +import com.google.android.exoplayer.C; +import com.google.android.exoplayer.extractor.Extractor; +import com.google.android.exoplayer.extractor.ExtractorInput; +import com.google.android.exoplayer.extractor.ExtractorOutput; +import com.google.android.exoplayer.extractor.PositionHolder; +import com.google.android.exoplayer.extractor.SeekMap; +import com.google.android.exoplayer.extractor.TrackOutput; +import com.google.android.exoplayer.util.Assertions; +import com.google.android.exoplayer.util.ParsableByteArray; +import com.google.android.exoplayer.util.Util; + +import java.io.EOFException; +import java.io.IOException; + +/** + * Created by joliva on 9/26/15. + */ +public final class FlvExtractor implements Extractor { + // Header sizes + private static final int FLV_MIN_HEADER_SIZE = 9; + private static final int FLV_TAG_HEADER_SIZE = 11; + + // Parser states. + private static final int STATE_READING_TAG_HEADER = 1; + private static final int STATE_READING_SAMPLE = 2; + + // Tag types + private static final int TAG_TYPE_AUDIO = 8; + private static final int TAG_TYPE_VIDEO = 9; + private static final int TAG_TYPE_SCRIPT_DATA = 18; + + private static final int FLV_TAG = Util.getIntegerCodeForString("FLV"); + + private final ParsableByteArray scratch; + private final ParsableByteArray headerBuffer; + private final ParsableByteArray tagHeaderBuffer; + private ParsableByteArray tagData; + + // Extractor outputs. + private ExtractorOutput extractorOutput; + private TrackOutput trackOutput; + + private boolean hasAudio; + private boolean hasVideo; + private int dataOffset; + + private int parserState; + private TagHeader currentTagHeader; + + private AudioTagReader audioReader; + private VideoTagReader videoReader; + private MetadataReader metadataReader; + + public FlvExtractor() { + scratch = new ParsableByteArray(4); + headerBuffer = new ParsableByteArray(FLV_MIN_HEADER_SIZE); + tagHeaderBuffer = new ParsableByteArray(FLV_TAG_HEADER_SIZE); + dataOffset = 0; + hasAudio = false; + hasVideo = false; + currentTagHeader = new TagHeader(); + } + + @Override + public void init(ExtractorOutput output) { + this.extractorOutput = output; + trackOutput = extractorOutput.track(0); + extractorOutput.endTracks(); + + output.seekMap(SeekMap.UNSEEKABLE); + } + + @Override + public boolean sniff(ExtractorInput input) throws IOException, InterruptedException { + // Check if file starts with "FLV" tag + input.peekFully(scratch.data, 0, 3); + scratch.setPosition(0); + if (scratch.readUnsignedInt24() != FLV_TAG) { + return false; + } +/* + + // Checking reserved flags are set to 0 + input.peekFully(scratch.data, 0, 2); + scratch.setPosition(0); + if ((scratch.readUnsignedShort() & 0xFA) != 0) { + return false; + } + + // Read data offset + input.peekFully(scratch.data, 0, 4); + scratch.setPosition(0); + int dataOffset = scratch.readInt(); + + input.resetPeekPosition(); + input.advancePeekPosition(dataOffset); + + // Checking first "previous tag size" is set to 0 + input.peekFully(scratch.data, 0, 1); + scratch.setPosition(0); + if (scratch.readInt() != 0) { + return false; + } +*/ + return true; + } + + @Override + public int read(ExtractorInput input, PositionHolder seekPosition) throws IOException, + InterruptedException { + if (dataOffset == 0 + && !readHeader(input)) { + return RESULT_END_OF_INPUT; + } + + try { + while (true) { + switch (parserState) { + case STATE_READING_TAG_HEADER: + if (!readTagHeader(input)) { + return RESULT_END_OF_INPUT; + } + break; + + default: + return readSample(input, seekPosition); + } + } + } catch (AudioTagReader.UnsupportedTrack unsupportedTrack) { + unsupportedTrack.printStackTrace(); + return RESULT_END_OF_INPUT; + + } + } + + @Override + public void seek() { + dataOffset = 0; + } + + private boolean readHeader(ExtractorInput input) throws IOException, InterruptedException { + try { + input.readFully(headerBuffer.data, 0, FLV_MIN_HEADER_SIZE); + headerBuffer.setPosition(0); + headerBuffer.skipBytes(4); + int flags = headerBuffer.readUnsignedByte(); + hasAudio = (flags & 0x04) != 0; + hasVideo = (flags & 0x01) != 0; + + if (hasAudio) { + audioReader = new AudioTagReader(trackOutput); + } + if (hasVideo) { + //videoReader = new VideoTagReader(trackOutput); + } + metadataReader = new MetadataReader(trackOutput); + + dataOffset = headerBuffer.readInt(); + + input.skipFully(dataOffset - FLV_MIN_HEADER_SIZE); + parserState = STATE_READING_TAG_HEADER; + } catch (EOFException eof) { + return false; + } + + return true; + } + + private boolean readTagHeader(ExtractorInput input) throws IOException, InterruptedException, + TagReader.UnsupportedTrack { + try { + input.skipFully(4); + input.readFully(tagHeaderBuffer.data, 0, FLV_TAG_HEADER_SIZE); + + tagHeaderBuffer.setPosition(0); + // skipping previous tag size field. + int type = tagHeaderBuffer.readUnsignedByte(); + int dataSize = tagHeaderBuffer.readUnsignedInt24(); + long timestamp = tagHeaderBuffer.readUnsignedInt24(); + timestamp = (tagHeaderBuffer.readUnsignedByte() << 24) | timestamp; + int streamId = tagHeaderBuffer.readUnsignedInt24(); + + currentTagHeader.type = type; + currentTagHeader.dataSize = dataSize; + currentTagHeader.timestamp = timestamp * 1000; + currentTagHeader.streamId = streamId; + + Assertions.checkState(dataSize <= Integer.MAX_VALUE); + tagData = new ParsableByteArray((int) dataSize); + parserState = STATE_READING_SAMPLE; + + } catch (EOFException eof) { + return false; + } + + return true; + } + + private int readSample(ExtractorInput input, PositionHolder seekPosition) throws IOException, + InterruptedException, AudioTagReader.UnsupportedTrack { + if (tagData != null) { + if (!input.readFully(tagData.data, 0, currentTagHeader.dataSize, true)) { + return RESULT_END_OF_INPUT; + } + tagData.setPosition(0); + } else { + input.skipFully(currentTagHeader.dataSize); + return RESULT_CONTINUE; + } + + if (currentTagHeader.type == TAG_TYPE_AUDIO && audioReader != null) { + audioReader.consume(tagData, currentTagHeader.timestamp); + } else if (currentTagHeader.type == TAG_TYPE_VIDEO && videoReader != null) { + videoReader.consume(tagData, currentTagHeader.timestamp); + } else if (currentTagHeader.type == TAG_TYPE_SCRIPT_DATA && metadataReader != null) { + metadataReader.consume(tagData, currentTagHeader.timestamp); + if (metadataReader.durationUs != C.UNKNOWN_TIME_US) { + if (audioReader != null) { + audioReader.durationUs = metadataReader.durationUs; + } + if (videoReader != null) { + videoReader.durationUs = metadataReader.durationUs; + } + } + } else { + tagData.reset(); + } + + parserState = STATE_READING_TAG_HEADER; + + return RESULT_CONTINUE; + } + +} diff --git a/library/src/main/java/com/google/android/exoplayer/extractor/flv/MetadataReader.java b/library/src/main/java/com/google/android/exoplayer/extractor/flv/MetadataReader.java new file mode 100644 index 0000000000..aac3ff6a4c --- /dev/null +++ b/library/src/main/java/com/google/android/exoplayer/extractor/flv/MetadataReader.java @@ -0,0 +1,203 @@ +package com.google.android.exoplayer.extractor.flv; + +import android.util.Log; + +import com.google.android.exoplayer.C; +import com.google.android.exoplayer.extractor.TrackOutput; +import com.google.android.exoplayer.util.ParsableBitArray; +import com.google.android.exoplayer.util.ParsableByteArray; + +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.Map; + +/** + * Created by joliva on 9/28/15. + */ +public class MetadataReader extends TagReader{ + + private static final int METADATA_TYPE_UNKNOWN = -1; + private static final int METADATA_TYPE_NUMBER = 0; + private static final int METADATA_TYPE_BOOLEAN = 1; + private static final int METADATA_TYPE_STRING = 2; + private static final int METADATA_TYPE_OBJECT = 3; + private static final int METADATA_TYPE_MOVIE_CLIP = 4; + private static final int METADATA_TYPE_NULL = 5; + private static final int METADATA_TYPE_UNDEFINED = 6; + private static final int METADATA_TYPE_REFERENCE = 7; + private static final int METADATA_TYPE_ECMA_ARRAY = 8; + private static final int METADATA_TYPE_STRICT_ARRAY = 10; + private static final int METADATA_TYPE_DATE = 11; + private static final int METADATA_TYPE_LONG_STRING = 12; + + public long startTime = C.UNKNOWN_TIME_US; + public float frameRate; + public float videoDataRate; + public float audioDataRate; + public int height; + public int width; + public boolean canSeekOnTime; + public String httpHostHeader; + + /** + * @param output A {@link TrackOutput} to which samples should be written. + */ + public MetadataReader(TrackOutput output) { + super(output); + } + + @Override + public void seek() { + + } + + @Override + protected void parseHeader(ParsableByteArray data) throws UnsupportedTrack { + + } + + @Override + protected void parsePayload(ParsableByteArray data, long timeUs) { + Object messageName = readAMFData(data, METADATA_TYPE_UNKNOWN); + Object obj = readAMFData(data, METADATA_TYPE_UNKNOWN); + + if(obj instanceof Map) { + Map extractedMetadata = (Map) obj; + for (Map.Entry entry : extractedMetadata.entrySet()) { + if (entry.getValue() == null) { + continue; + } + Log.d("Metadata", "Key: " + entry.getKey() + ", Value: " + entry.getValue().toString()); + + switch (entry.getKey()) { + case "totalduration": + this.durationUs = (long)(C.MICROS_PER_SECOND * (Double)(entry.getValue())); + break; + + case "starttime": + this.startTime = (long)(C.MICROS_PER_SECOND * (Double)(entry.getValue())); + break; + + case "videodatarate": + this.videoDataRate = ((Double)entry.getValue()).floatValue(); + break; + + case "audiodatarate": + this.audioDataRate = ((Double)entry.getValue()).floatValue(); + break; + + case "framerate": + this.frameRate = ((Double)entry.getValue()).floatValue(); + break; + + case "width": + this.width = Math.round(((Double) entry.getValue()).floatValue()); + break; + + case "height": + this.height = Math.round(((Double) entry.getValue()).floatValue()); + break; + + case "canseekontime": + this.canSeekOnTime = (boolean) entry.getValue(); + break; + + case "httphostheader": + this.httpHostHeader = (String) entry.getValue(); + break; + + default: + break; + } + } + } + } + + @Override + protected boolean shouldParsePayload() { + return true; + } + + private Object readAMFData(ParsableByteArray data, int type) { + if (type == METADATA_TYPE_UNKNOWN) { + type = data.readUnsignedByte(); + } + byte [] b; + switch (type) { + case METADATA_TYPE_NUMBER: + return readAMFDouble(data); + case METADATA_TYPE_BOOLEAN: + return readAMFBoolean(data); + case METADATA_TYPE_STRING: + return readAMFString(data); + case METADATA_TYPE_OBJECT: + return readAMFObject(data); + case METADATA_TYPE_ECMA_ARRAY: + return readAMFEcmaArray(data); + case METADATA_TYPE_STRICT_ARRAY: + return readAMFStrictArray(data); + case METADATA_TYPE_DATE: + return readAMFDouble(data); + default: + return null; + } + } + + private Boolean readAMFBoolean(ParsableByteArray data) { + return Boolean.valueOf(data.readUnsignedByte() == 1); + } + + private Double readAMFDouble(ParsableByteArray data) { + byte []b = new byte[8]; + data.readBytes(b, 0, b.length); + return ByteBuffer.wrap(b).getDouble(); + } + + private String readAMFString(ParsableByteArray data) { + int size = data.readUnsignedShort(); + byte []b = new byte[size]; + data.readBytes(b, 0, b.length); + return new String(b); + } + + private Object readAMFStrictArray(ParsableByteArray data) { + long count = data.readUnsignedInt(); + ArrayList list = new ArrayList(); + for (int i = 0; i < count; i++) { + list.add(readAMFData(data, METADATA_TYPE_UNKNOWN)); + } + return list; + } + + private Object readAMFObject(ParsableByteArray data) { + HashMap array = new HashMap(); + while (true) { + String key = readAMFString(data); + int type = data.readUnsignedByte(); + if (type == 9) { // object end marker + break; + } + array.put(key, readAMFData(data, type)); + } + return array; + } + + private Object readAMFEcmaArray(ParsableByteArray data) { + long count = data.readUnsignedInt(); + HashMap array = new HashMap(); + for (int i = 0; i < count; i++) { + String key = readAMFString(data); + int type = data.readUnsignedByte(); + array.put(key, readAMFData(data, type)); + } + return array; + } + + private Date readAMFDate(ParsableByteArray data) { + final Date date = new Date((long) readAMFDouble(data).doubleValue()); + data.readUnsignedShort(); + return date; + } +} diff --git a/library/src/main/java/com/google/android/exoplayer/extractor/flv/TagHeader.java b/library/src/main/java/com/google/android/exoplayer/extractor/flv/TagHeader.java new file mode 100644 index 0000000000..be0f9ef1a8 --- /dev/null +++ b/library/src/main/java/com/google/android/exoplayer/extractor/flv/TagHeader.java @@ -0,0 +1,15 @@ +package com.google.android.exoplayer.extractor.flv; + +/** + * Created by joliva on 9/26/15. + */ +final class TagHeader { + public static final int TAG_TYPE_AUDIO = 8; + public static final int TAG_TYPE_VIDEO = 9; + public static final int TAG_TYPE_SCRIPT_DATA = 18; + + public int type; + public int dataSize; + public long timestamp; + public int streamId; +} diff --git a/library/src/main/java/com/google/android/exoplayer/extractor/flv/TagReader.java b/library/src/main/java/com/google/android/exoplayer/extractor/flv/TagReader.java new file mode 100644 index 0000000000..9df4d8416a --- /dev/null +++ b/library/src/main/java/com/google/android/exoplayer/extractor/flv/TagReader.java @@ -0,0 +1,75 @@ +package com.google.android.exoplayer.extractor.flv; + +import com.google.android.exoplayer.C; +import com.google.android.exoplayer.extractor.TrackOutput; +import com.google.android.exoplayer.util.ParsableByteArray; + +/** + * Extracts individual samples from FLV tags. + */ +/* package */ abstract class TagReader { + + protected final TrackOutput output; + public long durationUs; + + /** + * @param output A {@link TrackOutput} to which samples should be written. + */ + protected TagReader(TrackOutput output) { + this.output = output; + this.durationUs = C.UNKNOWN_TIME_US; + } + + /** + * Notifies the reader that a seek has occurred. + *

+ * Following a call to this method, the data passed to the next invocation of + * {@link #consume(ParsableByteArray, long)} will not be a continuation of the data that + * was previously passed. Hence the reader should reset any internal state. + */ + public abstract void seek(); + + /** + * Parses tag header + * @param data Buffer where the tag header is stored + */ + protected abstract void parseHeader(ParsableByteArray data) throws UnsupportedTrack; + + /** + * Parses tag payload + * @param data Buffer where tag payload is stored + * @param timeUs Time position of the frame + */ + protected abstract void parsePayload(ParsableByteArray data, long timeUs); + + /** + * Evaluate if for the current tag, payload should be parsed + * @return + */ + protected abstract boolean shouldParsePayload(); + + /** + * Consumes (possibly partial) payload data. + * + * @param data The payload data to consume. + * @param timeUs The timestamp associated with the payload. + */ + public void consume(ParsableByteArray data, long timeUs) throws UnsupportedTrack { + parseHeader(data); + + if (shouldParsePayload()) { + parsePayload(data, timeUs); + } + } + + /** + * Thrown when format described in the AudioTrack is not supported + */ + public static final class UnsupportedTrack extends Exception { + + public UnsupportedTrack(String msg) { + super(msg); + } + + } +} diff --git a/library/src/main/java/com/google/android/exoplayer/extractor/flv/VideoTagReader.java b/library/src/main/java/com/google/android/exoplayer/extractor/flv/VideoTagReader.java new file mode 100644 index 0000000000..3b2496e4a5 --- /dev/null +++ b/library/src/main/java/com/google/android/exoplayer/extractor/flv/VideoTagReader.java @@ -0,0 +1,104 @@ +package com.google.android.exoplayer.extractor.flv; + +import android.util.Log; +import android.util.Pair; + +import com.google.android.exoplayer.C; +import com.google.android.exoplayer.MediaFormat; +import com.google.android.exoplayer.extractor.TrackOutput; +import com.google.android.exoplayer.util.CodecSpecificDataUtil; +import com.google.android.exoplayer.util.MimeTypes; +import com.google.android.exoplayer.util.ParsableBitArray; +import com.google.android.exoplayer.util.ParsableByteArray; + +import java.util.Collections; + +/** + * Created by joliva on 9/27/15. + */ +public class VideoTagReader extends TagReader{ + private static final String TAG = "VideoTagReader"; + + // Video codec + private static final int VIDEO_CODEC_JPEG = 1; + private static final int VIDEO_CODEC_H263 = 2; + private static final int VIDEO_CODEC_SCREEN_VIDEO = 3; + private static final int VIDEO_CODEC_VP6 = 4; + private static final int VIDEO_CODEC_VP6_WITH_ALPHA_CHANNEL = 5; + private static final int VIDEO_CODEC_SCREEN_VIDEO_V2 = 6; + private static final int VIDEO_CODEC_AVC = 7; + + // FRAME TYPE + private static final int VIDEO_FRAME_KEYFRAME = 1; + private static final int VIDEO_FRAME_INTERFRAME = 2; + private static final int VIDEO_FRAME_DISPOSABLE_INTERFRAME = 3; + private static final int VIDEO_FRAME_GENERATED_KEYFRAME = 4; + private static final int VIDEO_FRAME_VIDEO_INFO = 5; + + // PACKET TYPE + private static final int AVC_PACKET_TYPE_SEQUENCE_HEADER = 0; + private static final int AVC_PACKET_TYPE_AVC_NALU = 1; + private static final int AVC_PACKET_TYPE_AVC_END_OF_SEQUENCE = 2; + + private boolean hasOutputFormat; + private int format; + private int frameType; + + /** + * @param output A {@link TrackOutput} to which samples should be written. + */ + public VideoTagReader(TrackOutput output) { + super(output); + } + + @Override + public void seek() { + + } + + @Override + protected void parseHeader(ParsableByteArray data) throws UnsupportedTrack { + int header = data.readUnsignedByte(); + int frameType = (header >> 4) & 0x0F; + int videoCodec = (header & 0x0F); + + if (videoCodec != VIDEO_CODEC_AVC) { + throw new UnsupportedTrack("Video codec not supported. Codec: " + videoCodec); + } + + this.format = videoCodec; + this.frameType = frameType; + } + + @Override + protected void parsePayload(ParsableByteArray data, long timeUs) { + int packetType = data.readUnsignedByte(); + int compositionTime = data.readUnsignedInt24(); + if (packetType == AVC_PACKET_TYPE_SEQUENCE_HEADER && !hasOutputFormat) { + ParsableBitArray videoSequence = new ParsableBitArray(new byte[data.bytesLeft()]); + data.readBytes(videoSequence.data, 0, data.bytesLeft()); + + +/* + // Construct and output the format. + output.format(MediaFormat.createVideoFormat(MimeTypes.VIDEO_H264, MediaFormat.NO_VALUE, + MediaFormat.NO_VALUE, C.UNKNOWN_TIME_US, parsedSpsData.width, parsedSpsData.height, + initializationData, MediaFormat.NO_VALUE, parsedSpsData.pixelWidthAspectRatio)); +*/ +// output.format(mediaFormat); + hasOutputFormat = true; + } else if (packetType == AVC_PACKET_TYPE_AVC_NALU) { + int bytesToWrite = data.bytesLeft(); + output.sampleData(data, bytesToWrite); + output.sampleMetadata(timeUs, frameType == VIDEO_FRAME_KEYFRAME ? C.SAMPLE_FLAG_SYNC : 0, + bytesToWrite, 0, null); + + Log.d(TAG, "AAC TAG. Size: " + bytesToWrite + ", timeUs: " + timeUs); + } + } + + @Override + protected boolean shouldParsePayload() { + return (format == VIDEO_CODEC_AVC && frameType != VIDEO_FRAME_VIDEO_INFO); + } +}