Skip to content

SDK / exoplayer

Go to a project
Commit 69a42b60 by eguven Committed by Oliver Woodman
Options

Implement ID3 Metadata support for audio only HLS. 

Issue: #862
-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=111403855
parent 1e4f2f6a
Inline Side-by-side
Showing with 383 additions and 51 deletions
library/src/androidTest/java/com/google/android/exoplayer/extractor/ts/AdtsReaderTest.java 0 → 100644
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer.extractor.ts;
import com.google.android.exoplayer.C;
import com.google.android.exoplayer.testutil.FakeTrackOutput;
import com.google.android.exoplayer.testutil.TestUtil;
import com.google.android.exoplayer.util.ParsableByteArray;
import junit.framework.TestCase;
import java.util.Arrays;
/**
* Test for {@link AdtsReader}.
*/
public class AdtsReaderTest extends TestCase {
public static final byte[] ID3_DATA_1 = TestUtil.createByteArray(
0x49, 0x44, 0x33, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x54, 0x58,
0x58, 0x58, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x03, 0x00, 0x20, 0x2a,
0x2a, 0x2a, 0x20, 0x54, 0x48, 0x49, 0x53, 0x20, 0x49, 0x53, 0x20, 0x54,
0x69, 0x6d, 0x65, 0x64, 0x20, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74,
0x61, 0x20, 0x40, 0x20, 0x2d, 0x2d, 0x20, 0x30, 0x30, 0x3a, 0x30, 0x30,
0x3a, 0x30, 0x30, 0x2e, 0x30, 0x20, 0x2a, 0x2a, 0x2a, 0x20, 0x00);
public static final byte[] ID3_DATA_2 = TestUtil.createByteArray(
0x49,
0x44, 0x33, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x50, 0x52, 0x49,
0x56, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x63, 0x6f, 0x6d, 0x2e, 0x61,
0x70, 0x70, 0x6c, 0x65, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69,
0x6e, 0x67, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74,
0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74,
0x61, 0x6d, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0xbb, 0xa0);
public static final byte[] ADTS_HEADER = TestUtil.createByteArray(
0xff, 0xf1, 0x50, 0x80, 0x01, 0xdf, 0xfc);
public static final byte[] ADTS_CONTENT = TestUtil.createByteArray(
0x20, 0x00, 0x20, 0x00, 0x00, 0x80, 0x0e);
private static final byte TEST_DATA[] = TestUtil.joinByteArrays(
ID3_DATA_1,
ID3_DATA_2,
ADTS_HEADER,
ADTS_CONTENT);
private static final long ADTS_SAMPLE_DURATION = 23219L;
private ParsableByteArray data;
private AdtsReader adtsReader;
private FakeTrackOutput adtsOutput;
private FakeTrackOutput id3Output;
@Override
protected void setUp() throws Exception {
adtsOutput = new FakeTrackOutput();
id3Output = new FakeTrackOutput();
adtsReader = new AdtsReader(adtsOutput, id3Output);
data = new ParsableByteArray(TEST_DATA);
}
public void testSkipToNextSample() throws Exception {
for (int i = 1; i <= ID3_DATA_1.length + ID3_DATA_2.length; i++) {
data.setPosition(i);
feed();
// Once the data position set to ID3_DATA_1.length, no more id3 samples are read
int id3SampleCount = Math.min(i, ID3_DATA_1.length);
assertSampleCounts(id3SampleCount, i);
}
}
public void testSkipToNextSampleResetsState() throws Exception {
data = new ParsableByteArray(TestUtil.joinByteArrays(
ADTS_HEADER,
ADTS_CONTENT,
// Adts sample missing the first sync byte
Arrays.copyOfRange(ADTS_HEADER, 1, ADTS_HEADER.length),
ADTS_CONTENT));
feed();
assertSampleCounts(0, 1);
adtsOutput.assertSample(0, ADTS_CONTENT, 0, C.SAMPLE_FLAG_SYNC, null);
}
public void testNoData() throws Exception {
feedLimited(0);
assertSampleCounts(0, 0);
}
public void testNotEnoughDataForIdentifier() throws Exception {
feedLimited(3 - 1);
assertSampleCounts(0, 0);
}
public void testNotEnoughDataForHeader() throws Exception {
feedLimited(10 - 1);
assertSampleCounts(0, 0);
}
public void testNotEnoughDataForWholeId3Packet() throws Exception {
feedLimited(ID3_DATA_1.length - 1);
assertSampleCounts(0, 0);
}
public void testConsumeWholeId3Packet() throws Exception {
feedLimited(ID3_DATA_1.length);
assertSampleCounts(1, 0);
id3Output.assertSample(0, ID3_DATA_1, 0, C.SAMPLE_FLAG_SYNC, null);
}
public void testMultiId3Packet() throws Exception {
feedLimited(ID3_DATA_1.length + ID3_DATA_2.length - 1);
assertSampleCounts(1, 0);
id3Output.assertSample(0, ID3_DATA_1, 0, C.SAMPLE_FLAG_SYNC, null);
}
public void testMultiId3PacketConsumed() throws Exception {
feedLimited(ID3_DATA_1.length + ID3_DATA_2.length);
assertSampleCounts(2, 0);
id3Output.assertSample(0, ID3_DATA_1, 0, C.SAMPLE_FLAG_SYNC, null);
id3Output.assertSample(1, ID3_DATA_2, 0, C.SAMPLE_FLAG_SYNC, null);
}
public void testMultiPacketConsumed() throws Exception {
for (int i = 0; i < 10; i++) {
data.setPosition(0);
adtsReader.consume(data, 0, i == 0);
long timeUs = ADTS_SAMPLE_DURATION * i;
int j = i * 2;
assertSampleCounts(j + 2, i + 1);
id3Output.assertSample(j, ID3_DATA_1, timeUs, C.SAMPLE_FLAG_SYNC, null);
id3Output.assertSample(j + 1, ID3_DATA_2, timeUs, C.SAMPLE_FLAG_SYNC, null);
adtsOutput.assertSample(i, ADTS_CONTENT, timeUs, C.SAMPLE_FLAG_SYNC, null);
}
}
public void testAdtsDataOnly() throws Exception {
data.setPosition(ID3_DATA_1.length + ID3_DATA_2.length);
feed();
assertSampleCounts(0, 1);
adtsOutput.assertSample(0, ADTS_CONTENT, 0, C.SAMPLE_FLAG_SYNC, null);
}
private void feedLimited(int limit) {
data.setLimit(limit);
feed();
}
private void feed() {
adtsReader.consume(data, 0, true);
}
private void assertSampleCounts(int id3SampleCount, int adtsSampleCount) {
id3Output.assertSampleCount(id3SampleCount);
adtsOutput.assertSampleCount(adtsSampleCount);
}
}
library/src/main/java/com/google/android/exoplayer/MediaFormat.java
......@@ -16,6 +16,7 @@
package com.google.android.exoplayer;
import com.google.android.exoplayer.util.Assertions;
import com.google.android.exoplayer.util.MimeTypes;
import com.google.android.exoplayer.util.Util;
import android.annotation.SuppressLint;
......@@ -180,6 +181,11 @@ public final class MediaFormat {
NO_VALUE);
}
public static MediaFormat createId3Format() {
return createFormatForMimeType(null, MimeTypes.APPLICATION_ID3, MediaFormat.NO_VALUE,
C.UNKNOWN_TIME_US);
}
/* package */ MediaFormat(String trackId, String mimeType, int bitrate, int maxInputSize,
long durationUs, int width, int height, int rotationDegrees, float pixelWidthHeightRatio,
int channelCount, int sampleRate, String language, long subsampleOffsetUs,
......
library/src/main/java/com/google/android/exoplayer/extractor/DummyTrackOutput.java 0 → 100644
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer.extractor;
import com.google.android.exoplayer.MediaFormat;
import com.google.android.exoplayer.util.ParsableByteArray;
import java.io.IOException;
/**
* A dummy {@link TrackOutput} implementation.
*/
public class DummyTrackOutput implements TrackOutput {
@Override
public void format(MediaFormat format) {
// Do nothing.
}
@Override
public int sampleData(ExtractorInput input, int length, boolean allowEndOfInput)
throws IOException, InterruptedException {
return input.skip(length);
}
@Override
public void sampleData(ParsableByteArray data, int length) {
data.skipBytes(length);
}
@Override
public void sampleMetadata(long timeUs, int flags, int size, int offset, byte[] encryptionKey) {
// Do nothing.
}
}
library/src/main/java/com/google/android/exoplayer/extractor/ts/AdtsExtractor.java
......@@ -110,7 +110,7 @@ public final class AdtsExtractor implements Extractor {
@Override
public void init(ExtractorOutput output) {
adtsReader = new AdtsReader(output.track(0));
adtsReader = new AdtsReader(output.track(0), output.track(1));
output.endTracks();
output.seekMap(SeekMap.UNSEEKABLE);
}
......
library/src/main/java/com/google/android/exoplayer/extractor/ts/AdtsReader.java
......@@ -25,6 +25,7 @@ import com.google.android.exoplayer.util.ParsableByteArray;
import android.util.Pair;
import java.util.Arrays;
import java.util.Collections;
/**
......@@ -32,20 +33,34 @@ import java.util.Collections;
*/
/* package */ final class AdtsReader extends ElementaryStreamReader {
private static final int STATE_FINDING_SYNC = 0;
private static final int STATE_READING_HEADER = 1;
private static final int STATE_READING_SAMPLE = 2;
private static final int STATE_FINDING_SAMPLE = 0;
private static final int STATE_READING_ID3_HEADER = 1;
private static final int STATE_READING_ADTS_HEADER = 2;
private static final int STATE_READING_SAMPLE = 3;
private static final int HEADER_SIZE = 5;
private static final int CRC_SIZE = 2;
// Match states used while looking for the next sample
private static final int MATCH_STATE_VALUE_SHIFT = 8;
private static final int MATCH_STATE_START = 1 << MATCH_STATE_VALUE_SHIFT;
private static final int MATCH_STATE_FF = 2 << MATCH_STATE_VALUE_SHIFT;
private static final int MATCH_STATE_I = 3 << MATCH_STATE_VALUE_SHIFT;
private static final int MATCH_STATE_ID = 4 << MATCH_STATE_VALUE_SHIFT;
private static final int ID3_HEADER_SIZE = 10;
private static final int ID3_SIZE_OFFSET = 6;
private static final byte[] ID3_IDENTIFIER = {'I', 'D', '3'};
private final ParsableBitArray adtsScratch;
private final ParsableByteArray id3HeaderBuffer;
private final TrackOutput id3Output;
private int state;
private int bytesRead;
// Used to find the header.
private boolean lastByteWasFF;
private int matchState;
private boolean hasCrc;
// Used when parsing the header.
......@@ -56,17 +71,25 @@ import java.util.Collections;
// Used when reading the samples.
private long timeUs;
public AdtsReader(TrackOutput output) {
private TrackOutput currentOutput;
private long currentSampleDuration;
/**
* @param output A {@link TrackOutput} to which AAC samples should be written.
* @param id3Output A {@link TrackOutput} to which ID3 samples should be written.
*/
public AdtsReader(TrackOutput output, TrackOutput id3Output) {
super(output);
this.id3Output = id3Output;
id3Output.format(MediaFormat.createId3Format());
adtsScratch = new ParsableBitArray(new byte[HEADER_SIZE + CRC_SIZE]);
state = STATE_FINDING_SYNC;
id3HeaderBuffer = new ParsableByteArray(Arrays.copyOf(ID3_IDENTIFIER, ID3_HEADER_SIZE));
setFindingSampleState();
}
@Override
public void seek() {
state = STATE_FINDING_SYNC;
bytesRead = 0;
lastByteWasFF = false;
setFindingSampleState();
}
@Override
......@@ -76,30 +99,22 @@ import java.util.Collections;
}
while (data.bytesLeft() > 0) {
switch (state) {
case STATE_FINDING_SYNC:
if (skipToNextSync(data)) {
bytesRead = 0;
state = STATE_READING_HEADER;
case STATE_FINDING_SAMPLE:
findNextSample(data);
break;
case STATE_READING_ID3_HEADER:
if (continueRead(data, id3HeaderBuffer.data, ID3_HEADER_SIZE)) {
parseId3Header();
}
break;
case STATE_READING_HEADER:
case STATE_READING_ADTS_HEADER:
int targetLength = hasCrc ? HEADER_SIZE + CRC_SIZE : HEADER_SIZE;
if (continueRead(data, adtsScratch.data, targetLength)) {
parseHeader();
bytesRead = 0;
state = STATE_READING_SAMPLE;
parseAdtsHeader();
}
break;
case STATE_READING_SAMPLE:
int bytesToRead = Math.min(data.bytesLeft(), sampleSize - bytesRead);
output.sampleData(data, bytesToRead);
bytesRead += bytesToRead;
if (bytesRead == sampleSize) {
output.sampleMetadata(timeUs, C.SAMPLE_FLAG_SYNC, sampleSize, 0, null);
timeUs += sampleDurationUs;
bytesRead = 0;
state = STATE_FINDING_SYNC;
}
readSample(data);
break;
}
}
......@@ -127,36 +142,109 @@ import java.util.Collections;
}
/**
* Locates the next sync word, advancing the position to the byte that immediately follows it.
* If a sync word was not located, the position is advanced to the limit.
* Sets the state to STATE_FINDING_SAMPLE.
*/
private void setFindingSampleState() {
state = STATE_FINDING_SAMPLE;
bytesRead = 0;
matchState = MATCH_STATE_START;
}
/**
* Sets the state to STATE_READING_ID3_HEADER and resets the fields required for
* {@link #parseId3Header()}.
*/
private void setReadingId3HeaderState() {
state = STATE_READING_ID3_HEADER;
bytesRead = ID3_IDENTIFIER.length;
sampleSize = 0;
id3HeaderBuffer.setPosition(0);
}
/**
* Sets the state to STATE_READING_SAMPLE.
*
* @param outputToUse TrackOutput object to write the sample to
* @param currentSampleDuration Duration of the sample to be read
* @param priorReadBytes Size of prior read bytes
* @param sampleSize Size of the sample
*/
private void setReadingSampleState(TrackOutput outputToUse, long currentSampleDuration,
int priorReadBytes, int sampleSize) {
state = STATE_READING_SAMPLE;
bytesRead = priorReadBytes;
this.currentOutput = outputToUse;
this.currentSampleDuration = currentSampleDuration;
this.sampleSize = sampleSize;
}
/**
* Sets the state to STATE_READING_ADTS_HEADER.
*/
private void setReadingAdtsHeaderState() {
state = STATE_READING_ADTS_HEADER;
bytesRead = 0;
}
/**
* Locates the next sample start, advancing the position to the byte that immediately follows
* identifier. If a sample was not located, the position is advanced to the limit.
*
* @param pesBuffer The buffer whose position should be advanced.
* @return True if a sync word position was found. False otherwise.
*/
private boolean skipToNextSync(ParsableByteArray pesBuffer) {
private void findNextSample(ParsableByteArray pesBuffer) {
byte[] adtsData = pesBuffer.data;
int startOffset = pesBuffer.getPosition();
int position = pesBuffer.getPosition();
int endOffset = pesBuffer.limit();
for (int i = startOffset; i < endOffset; i++) {
boolean byteIsFF = (adtsData[i] & 0xFF) == 0xFF;
boolean found = lastByteWasFF && !byteIsFF && (adtsData[i] & 0xF0) == 0xF0;
lastByteWasFF = byteIsFF;
if (found) {
hasCrc = (adtsData[i] & 0x1) == 0;
pesBuffer.setPosition(i + 1);
// Reset lastByteWasFF for next time.
lastByteWasFF = false;
return true;
while (position < endOffset) {
int data = adtsData[position++] & 0xFF;
if (matchState == MATCH_STATE_FF && data >= 0xF0 && data != 0xFF) {
hasCrc = (data & 0x1) == 0;
setReadingAdtsHeaderState();
pesBuffer.setPosition(position);
return;
}
switch (matchState | data) {
case MATCH_STATE_START | 0xFF:
matchState = MATCH_STATE_FF;
break;
case MATCH_STATE_START | 'I':
matchState = MATCH_STATE_I;
break;
case MATCH_STATE_I | 'D':
matchState = MATCH_STATE_ID;
break;
case MATCH_STATE_ID | '3':
setReadingId3HeaderState();
pesBuffer.setPosition(position);
return;
default:
if (matchState != MATCH_STATE_START) {
// If matching fails in a later state, revert to MATCH_STATE_START and
// check this byte again
matchState = MATCH_STATE_START;
position--;
}
break;
}
}
pesBuffer.setPosition(endOffset);
return false;
pesBuffer.setPosition(position);
}
/**
* Parses the Id3 header.
*/
private void parseId3Header() {
id3Output.sampleData(id3HeaderBuffer, ID3_HEADER_SIZE);
id3HeaderBuffer.setPosition(ID3_SIZE_OFFSET);
setReadingSampleState(id3Output, 0, ID3_HEADER_SIZE,
id3HeaderBuffer.readSynchSafeInt() + ID3_HEADER_SIZE);
}
/**
* Parses the sample header.
*/
private void parseHeader() {
private void parseAdtsHeader() {
adtsScratch.setPosition(0);
if (!hasOutputFormat) {
......@@ -183,10 +271,26 @@ import java.util.Collections;
}
adtsScratch.skipBits(4);
sampleSize = adtsScratch.readBits(13) - 2 /* the sync word */ - HEADER_SIZE;
int sampleSize = adtsScratch.readBits(13) - 2 /* the sync word */ - HEADER_SIZE;
if (hasCrc) {
sampleSize -= CRC_SIZE;
}
setReadingSampleState(output, sampleDurationUs, 0, sampleSize);
}
/**
* Reads the rest of the sample
*/
private void readSample(ParsableByteArray data) {
int bytesToRead = Math.min(data.bytesLeft(), sampleSize - bytesRead);
currentOutput.sampleData(data, bytesToRead);
bytesRead += bytesToRead;
if (bytesRead == sampleSize) {
currentOutput.sampleMetadata(timeUs, C.SAMPLE_FLAG_SYNC, sampleSize, 0, null);
timeUs += currentSampleDuration;
setFindingSampleState();
}
}
}
library/src/main/java/com/google/android/exoplayer/extractor/ts/Id3Reader.java
......@@ -18,7 +18,6 @@ package com.google.android.exoplayer.extractor.ts;
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.MimeTypes;
import com.google.android.exoplayer.util.ParsableByteArray;
/**
......@@ -35,8 +34,7 @@ import com.google.android.exoplayer.util.ParsableByteArray;
public Id3Reader(TrackOutput output) {
super(output);
output.format(MediaFormat.createFormatForMimeType(null, MimeTypes.APPLICATION_ID3,
MediaFormat.NO_VALUE, C.UNKNOWN_TIME_US));
output.format(MediaFormat.createId3Format());
}
@Override
......
library/src/main/java/com/google/android/exoplayer/extractor/ts/TsExtractor.java
......@@ -15,6 +15,7 @@
*/
package com.google.android.exoplayer.extractor.ts;
import com.google.android.exoplayer.extractor.DummyTrackOutput;
import com.google.android.exoplayer.extractor.Extractor;
import com.google.android.exoplayer.extractor.ExtractorInput;
import com.google.android.exoplayer.extractor.ExtractorOutput;
......@@ -334,7 +335,8 @@ public final class TsExtractor implements Extractor {
pesPayloadReader = new MpegAudioReader(output.track(TS_STREAM_TYPE_MPA_LSF));
break;
case TS_STREAM_TYPE_AAC:
pesPayloadReader = new AdtsReader(output.track(TS_STREAM_TYPE_AAC));
pesPayloadReader = new AdtsReader(output.track(TS_STREAM_TYPE_AAC),
new DummyTrackOutput());
break;
case TS_STREAM_TYPE_AC3:
pesPayloadReader = new Ac3Reader(output.track(TS_STREAM_TYPE_AC3), false);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment