Skip to content

SDK / exoplayer

Go to a project
Commit 731d4283 by eguven Committed by Oliver Woodman
Options

Ogg/Opus and Ogg/Flac search seeking 

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=122977123
parent 7465db2a
Expand all
Inline Side-by-side
Showing with 1089 additions and 1008 deletions
library/src/androidTest/java/com/google/android/exoplayer/extractor/ogg/OggSeekerTest.java → library/src/androidTest/java/com/google/android/exoplayer/extractor/ogg/DefaultOggSeekerTest.java
......@@ -24,96 +24,72 @@ import junit.framework.TestCase;
import java.io.IOException;
/**
* Unit test for {@link OggSeeker}.
* Unit test for {@link DefaultOggSeeker}.
*/
public final class OggSeekerTest extends TestCase {
public final class DefaultOggSeekerTest extends TestCase {
private OggSeeker oggSeeker;
private static final long HEADER_GRANULE = 200000;
private static final int START_POSITION = 0;
private static final int END_POSITION = 1000000;
private static final int TOTAL_SAMPLES = END_POSITION - START_POSITION;
private DefaultOggSeeker oggSeeker;
@Override
public void setUp() throws Exception {
super.setUp();
oggSeeker = new OggSeeker();
oggSeeker.setup(1, 1);
oggSeeker = DefaultOggSeeker.createOggSeekerForTesting(START_POSITION, END_POSITION,
TOTAL_SAMPLES);
}
public void testSetupUnboundAudioLength() {
try {
new OggSeeker().setup(C.LENGTH_UNBOUNDED, 1000);
new DefaultOggSeeker(0, C.LENGTH_UNBOUNDED, new FlacReader());
fail();
} catch (IllegalArgumentException e) {
// ignored
}
}
public void testSetupZeroOrNegativeTotalSamples() {
try {
new OggSeeker().setup(1000, 0);
fail();
} catch (IllegalArgumentException e) {
// ignored
}
try {
new OggSeeker().setup(1000, -1000);
fail();
} catch (IllegalArgumentException e) {
// ignored
}
public void testGetNextSeekPositionMatch() throws IOException, InterruptedException {
assertGetNextSeekPosition(HEADER_GRANULE + DefaultOggSeeker.MATCH_RANGE);
assertGetNextSeekPosition(HEADER_GRANULE + 1);
}
public void testGetNextSeekPositionSetupNotCalled() throws IOException, InterruptedException {
try {
new OggSeeker().getNextSeekPosition(1000, TestData.createInput(new byte[0], false));
fail();
} catch (IllegalStateException e) {
// ignored
}
public void testGetNextSeekPositionTooHigh() throws IOException, InterruptedException {
assertGetNextSeekPosition(HEADER_GRANULE - 100000);
assertGetNextSeekPosition(HEADER_GRANULE);
}
public void testGetNextSeekPositionMatch() throws IOException, InterruptedException {
long targetGranule = 100000;
long headerGranule = 52001;
FakeExtractorInput input = TestData.createInput(TestUtil.joinByteArrays(
TestData.buildOggHeader(0x00, headerGranule, 22, 2),
TestUtil.createByteArray(54, 55) // laces
), false);
long expectedPosition = -1;
assertGetNextSeekPosition(expectedPosition, targetGranule, input);
public void testGetNextSeekPositionTooLow() throws IOException, InterruptedException {
assertGetNextSeekPosition(HEADER_GRANULE + DefaultOggSeeker.MATCH_RANGE + 1);
assertGetNextSeekPosition(HEADER_GRANULE + 100000);
}
public void testGetNextSeekPositionTooHigh() throws IOException, InterruptedException {
long targetGranule = 100000;
long headerGranule = 200000;
FakeExtractorInput input = TestData.createInput(TestUtil.joinByteArrays(
TestData.buildOggHeader(0x00, headerGranule, 22, 2),
TestUtil.createByteArray(54, 55) // laces
), false);
long doublePageSize = 2 * (input.getLength() + 54 + 55);
long expectedPosition = -doublePageSize + (targetGranule - headerGranule);
assertGetNextSeekPosition(expectedPosition, targetGranule, input);
public void testGetNextSeekPositionBounds() throws IOException, InterruptedException {
assertGetNextSeekPosition(HEADER_GRANULE + TOTAL_SAMPLES);
assertGetNextSeekPosition(HEADER_GRANULE - TOTAL_SAMPLES);
}
public void testGetNextSeekPositionTooHighDistanceLower48000()
private void assertGetNextSeekPosition(long targetGranule)
throws IOException, InterruptedException {
long targetGranule = 199999;
long headerGranule = 200000;
int pagePosition = 500000;
FakeExtractorInput input = TestData.createInput(TestUtil.joinByteArrays(
TestData.buildOggHeader(0x00, headerGranule, 22, 2),
new byte[pagePosition],
TestData.buildOggHeader(0x00, HEADER_GRANULE, 22, 2),
TestUtil.createByteArray(54, 55) // laces
), false);
long doublePageSize = 2 * (input.getLength() + 54 + 55);
long expectedPosition = -doublePageSize - 1;
assertGetNextSeekPosition(expectedPosition, targetGranule, input);
}
public void testGetNextSeekPositionTooLow() throws IOException, InterruptedException {
long headerGranule = 200000;
FakeExtractorInput input = TestData.createInput(TestUtil.joinByteArrays(
TestData.buildOggHeader(0x00, headerGranule, 22, 2),
TestUtil.createByteArray(54, 55) // laces
), false);
long targetGranule = 300000;
long expectedPosition = -(27 + 2 + 54 + 55) + (targetGranule - headerGranule);
input.setPosition(pagePosition);
long granuleDiff = targetGranule - HEADER_GRANULE;
long expectedPosition;
if (granuleDiff > 0 && granuleDiff <= DefaultOggSeeker.MATCH_RANGE) {
expectedPosition = -1;
} else {
long doublePageSize = (27 + 2 + 54 + 55) * (granuleDiff <= 0 ? 2 : 1);
expectedPosition = pagePosition - doublePageSize + granuleDiff;
expectedPosition = Math.max(expectedPosition, START_POSITION);
expectedPosition = Math.min(expectedPosition, END_POSITION - 1);
}
assertGetNextSeekPosition(expectedPosition, targetGranule, input);
}
......
library/src/androidTest/java/com/google/android/exoplayer/extractor/ogg/DefaultOggSeekerUtilMethodsTest.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.ogg;
import com.google.android.exoplayer.ParserException;
import com.google.android.exoplayer.extractor.ExtractorInput;
import com.google.android.exoplayer.testutil.FakeExtractorInput;
import com.google.android.exoplayer.testutil.TestUtil;
import junit.framework.TestCase;
import java.io.EOFException;
import java.io.IOException;
import java.util.Random;
/**
* Unit test for {@link DefaultOggSeeker} utility methods.
*/
public class DefaultOggSeekerUtilMethodsTest extends TestCase {
private Random random = new Random(0);
private DefaultOggSeeker oggSeeker = new DefaultOggSeeker(0, 100, new FlacReader());
public void testSkipToNextPage() throws Exception {
FakeExtractorInput extractorInput = TestData.createInput(
TestUtil.joinByteArrays(
TestUtil.buildTestData(4000, random),
new byte[]{'O', 'g', 'g', 'S'},
TestUtil.buildTestData(4000, random)
), false);
skipToNextPage(extractorInput);
assertEquals(4000, extractorInput.getPosition());
}
public void testSkipToNextPageUnbounded() throws Exception {
FakeExtractorInput extractorInput = TestData.createInput(
TestUtil.joinByteArrays(
TestUtil.buildTestData(4000, random),
new byte[]{'O', 'g', 'g', 'S'},
TestUtil.buildTestData(4000, random)
), true);
skipToNextPage(extractorInput);
assertEquals(4000, extractorInput.getPosition());
}
public void testSkipToNextPageOverlap() throws Exception {
FakeExtractorInput extractorInput = TestData.createInput(
TestUtil.joinByteArrays(
TestUtil.buildTestData(2046, random),
new byte[]{'O', 'g', 'g', 'S'},
TestUtil.buildTestData(4000, random)
), false);
skipToNextPage(extractorInput);
assertEquals(2046, extractorInput.getPosition());
}
public void testSkipToNextPageOverlapUnbounded() throws Exception {
FakeExtractorInput extractorInput = TestData.createInput(
TestUtil.joinByteArrays(
TestUtil.buildTestData(2046, random),
new byte[]{'O', 'g', 'g', 'S'},
TestUtil.buildTestData(4000, random)
), true);
skipToNextPage(extractorInput);
assertEquals(2046, extractorInput.getPosition());
}
public void testSkipToNextPageInputShorterThanPeekLength() throws Exception {
FakeExtractorInput extractorInput = TestData.createInput(
TestUtil.joinByteArrays(
new byte[]{'x', 'O', 'g', 'g', 'S'}
), false);
skipToNextPage(extractorInput);
assertEquals(1, extractorInput.getPosition());
}
public void testSkipToNextPageNoMatch() throws Exception {
FakeExtractorInput extractorInput = TestData.createInput(
new byte[]{'g', 'g', 'S', 'O', 'g', 'g'}, false);
try {
skipToNextPage(extractorInput);
fail();
} catch (EOFException e) {
// expected
}
}
private static void skipToNextPage(ExtractorInput extractorInput)
throws IOException, InterruptedException {
while (true) {
try {
DefaultOggSeeker.skipToNextPage(extractorInput);
break;
} catch (FakeExtractorInput.SimulatedIOException e) { /* ignored */ }
}
}
public void testSkipToPageOfGranule() throws IOException, InterruptedException {
byte[] packet = TestUtil.buildTestData(3 * 254, random);
FakeExtractorInput input = TestData.createInput(
TestUtil.joinByteArrays(
TestData.buildOggHeader(0x01, 20000, 1000, 0x03),
TestUtil.createByteArray(254, 254, 254), // Laces.
packet,
TestData.buildOggHeader(0x04, 40000, 1001, 0x03),
TestUtil.createByteArray(254, 254, 254), // Laces.
packet,
TestData.buildOggHeader(0x04, 60000, 1002, 0x03),
TestUtil.createByteArray(254, 254, 254), // Laces.
packet), false);
// expect to be granule of the previous page returned as elapsedSamples
skipToPageOfGranule(input, 54000, 40000);
// expect to be at the start of the third page
assertEquals(2 * (30 + (3 * 254)), input.getPosition());
}
public void testSkipToPageOfGranulePreciseMatch() throws IOException, InterruptedException {
byte[] packet = TestUtil.buildTestData(3 * 254, random);
FakeExtractorInput input = TestData.createInput(
TestUtil.joinByteArrays(
TestData.buildOggHeader(0x01, 20000, 1000, 0x03),
TestUtil.createByteArray(254, 254, 254), // Laces.
packet,
TestData.buildOggHeader(0x04, 40000, 1001, 0x03),
TestUtil.createByteArray(254, 254, 254), // Laces.
packet,
TestData.buildOggHeader(0x04, 60000, 1002, 0x03),
TestUtil.createByteArray(254, 254, 254), // Laces.
packet), false);
skipToPageOfGranule(input, 40000, 20000);
// expect to be at the start of the second page
assertEquals((30 + (3 * 254)), input.getPosition());
}
public void testSkipToPageOfGranuleAfterTargetPage() throws IOException, InterruptedException {
byte[] packet = TestUtil.buildTestData(3 * 254, random);
FakeExtractorInput input = TestData.createInput(
TestUtil.joinByteArrays(
TestData.buildOggHeader(0x01, 20000, 1000, 0x03),
TestUtil.createByteArray(254, 254, 254), // Laces.
packet,
TestData.buildOggHeader(0x04, 40000, 1001, 0x03),
TestUtil.createByteArray(254, 254, 254), // Laces.
packet,
TestData.buildOggHeader(0x04, 60000, 1002, 0x03),
TestUtil.createByteArray(254, 254, 254), // Laces.
packet), false);
try {
skipToPageOfGranule(input, 10000, 20000);
fail();
} catch (ParserException e) {
// ignored
}
assertEquals(0, input.getPosition());
}
private void skipToPageOfGranule(ExtractorInput input, long granule,
long elapsedSamplesExpected) throws IOException, InterruptedException {
while (true) {
try {
assertEquals(elapsedSamplesExpected, oggSeeker.skipToPageOfGranule(input, granule));
return;
} catch (FakeExtractorInput.SimulatedIOException e) {
input.resetPeekPosition();
}
}
}
public void testReadGranuleOfLastPage() throws IOException, InterruptedException {
FakeExtractorInput input = TestData.createInput(TestUtil.joinByteArrays(
TestUtil.buildTestData(100, random),
TestData.buildOggHeader(0x00, 20000, 66, 3),
TestUtil.createByteArray(254, 254, 254), // laces
TestUtil.buildTestData(3 * 254, random),
TestData.buildOggHeader(0x00, 40000, 67, 3),
TestUtil.createByteArray(254, 254, 254), // laces
TestUtil.buildTestData(3 * 254, random),
TestData.buildOggHeader(0x05, 60000, 68, 3),
TestUtil.createByteArray(254, 254, 254), // laces
TestUtil.buildTestData(3 * 254, random)
), false);
assertReadGranuleOfLastPage(input, 60000);
}
public void testReadGranuleOfLastPageAfterLastHeader() throws IOException, InterruptedException {
FakeExtractorInput input = TestData.createInput(TestUtil.buildTestData(100, random), false);
try {
assertReadGranuleOfLastPage(input, 60000);
fail();
} catch (EOFException e) {
// ignored
}
}
public void testReadGranuleOfLastPageWithUnboundedLength()
throws IOException, InterruptedException {
FakeExtractorInput input = TestData.createInput(new byte[0], true);
try {
assertReadGranuleOfLastPage(input, 60000);
fail();
} catch (IllegalArgumentException e) {
// ignored
}
}
private void assertReadGranuleOfLastPage(FakeExtractorInput input, int expected)
throws IOException, InterruptedException {
while (true) {
try {
assertEquals(expected, oggSeeker.readGranuleOfLastPage(input));
break;
} catch (FakeExtractorInput.SimulatedIOException e) {
// ignored
}
}
}
}
library/src/androidTest/java/com/google/android/exoplayer/extractor/ogg/OggExtractorFileTests.java 0 → 100644
/*
* Copyright (C) 2016 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.ogg;
import com.google.android.exoplayer.C;
import com.google.android.exoplayer.Format;
import com.google.android.exoplayer.extractor.SeekMap;
import com.google.android.exoplayer.testutil.FakeExtractorInput;
import com.google.android.exoplayer.testutil.FakeExtractorOutput;
import com.google.android.exoplayer.testutil.FakeTrackOutput;
import com.google.android.exoplayer.testutil.TestUtil;
import com.google.android.exoplayer.util.MimeTypes;
import android.test.InstrumentationTestCase;
/**
* Unit test for {@link OpusReader}.
*/
public final class OggExtractorFileTests extends InstrumentationTestCase {
public static final String OPUS_TEST_FILE = "ogg/bear.opus";
public static final String FLAC_TEST_FILE = "ogg/bear_flac.ogg";
public static final String FLAC_NS_TEST_FILE = "ogg/bear_flac_noseektable.ogg";
public void testOpus() throws Exception {
parseFile(OPUS_TEST_FILE, false, false, false, MimeTypes.AUDIO_OPUS, 2747500, 275);
parseFile(OPUS_TEST_FILE, false, true, false, MimeTypes.AUDIO_OPUS, C.UNSET_TIME_US, 275);
parseFile(OPUS_TEST_FILE, true, false, true, MimeTypes.AUDIO_OPUS, 2747500, 275);
parseFile(OPUS_TEST_FILE, true, true, true, MimeTypes.AUDIO_OPUS, C.UNSET_TIME_US, 275);
}
public void testFlac() throws Exception {
parseFile(FLAC_TEST_FILE, false, false, false, MimeTypes.AUDIO_FLAC, 2741000, 33);
parseFile(FLAC_TEST_FILE, false, true, false, MimeTypes.AUDIO_FLAC, 2741000, 33);
parseFile(FLAC_TEST_FILE, true, false, true, MimeTypes.AUDIO_FLAC, 2741000, 33);
parseFile(FLAC_TEST_FILE, true, true, true, MimeTypes.AUDIO_FLAC, 2741000, 33);
}
public void testFlacNoSeektable() throws Exception {
parseFile(FLAC_NS_TEST_FILE, false, false, false, MimeTypes.AUDIO_FLAC, 2741000, 33);
parseFile(FLAC_NS_TEST_FILE, false, true, false, MimeTypes.AUDIO_FLAC, C.UNSET_TIME_US, 33);
parseFile(FLAC_NS_TEST_FILE, true, false, true, MimeTypes.AUDIO_FLAC, 2741000, 33);
parseFile(FLAC_NS_TEST_FILE, true, true, true, MimeTypes.AUDIO_FLAC, C.UNSET_TIME_US, 33);
}
private void parseFile(String testFile, boolean simulateIOErrors, boolean simulateUnknownLength,
boolean simulatePartialReads, String expectedMimeType, long expectedDuration,
int expectedSampleCount)
throws Exception {
byte[] fileData = TestUtil.getByteArray(getInstrumentation(), testFile);
FakeExtractorInput input = new FakeExtractorInput.Builder().setData(fileData)
.setSimulateIOErrors(simulateIOErrors)
.setSimulateUnknownLength(simulateUnknownLength)
.setSimulatePartialReads(simulatePartialReads).build();
OggExtractor extractor = new OggExtractor();
assertTrue(TestUtil.sniffTestData(extractor, input));
input.resetPeekPosition();
FakeExtractorOutput extractorOutput = new FakeExtractorOutput();
extractor.init(extractorOutput);
TestUtil.consumeTestData(extractor, input);
assertEquals(1, extractorOutput.trackOutputs.size());
FakeTrackOutput trackOutput = extractorOutput.trackOutputs.get(0);
assertNotNull(trackOutput);
Format format = trackOutput.format;
assertNotNull(format);
assertEquals(expectedMimeType, format.sampleMimeType);
assertEquals(48000, format.sampleRate);
assertEquals(2, format.channelCount);
SeekMap seekMap = extractorOutput.seekMap;
assertNotNull(seekMap);
assertEquals(expectedDuration, seekMap.getDurationUs());
assertEquals(expectedDuration != C.UNSET_TIME_US, seekMap.isSeekable());
trackOutput.assertSampleCount(expectedSampleCount);
}
}
library/src/androidTest/java/com/google/android/exoplayer/extractor/ogg/OggExtractorTest.java
......@@ -16,7 +16,6 @@
package com.google.android.exoplayer.extractor.ogg;
import com.google.android.exoplayer.testutil.FakeExtractorInput;
import com.google.android.exoplayer.testutil.FakeExtractorInput.SimulatedIOException;
import com.google.android.exoplayer.testutil.TestUtil;
import junit.framework.TestCase;
......@@ -40,56 +39,48 @@ public final class OggExtractorTest extends TestCase {
byte[] data = TestUtil.joinByteArrays(
TestData.buildOggHeader(0x02, 0, 1000, 1),
TestUtil.createByteArray(7), // Laces
new byte[]{0x01, 'v', 'o', 'r', 'b', 'i', 's'});
assertTrue(sniff(createInput(data)));
new byte[] {0x01, 'v', 'o', 'r', 'b', 'i', 's'});
assertTrue(sniff(data));
}
public void testSniffFlac() throws Exception {
byte[] data = TestUtil.joinByteArrays(
TestData.buildOggHeader(0x02, 0, 1000, 1),
TestUtil.createByteArray(5), // Laces
new byte[]{0x7F, 'F', 'L', 'A', 'C'});
assertTrue(sniff(createInput(data)));
new byte[] {0x7F, 'F', 'L', 'A', 'C'});
assertTrue(sniff(data));
}
public void testSniffFailsOpusFile() throws Exception {
byte[] data = TestUtil.joinByteArrays(
TestData.buildOggHeader(0x02, 0, 1000, 0x00),
new byte[]{'O', 'p', 'u', 's'});
assertFalse(sniff(createInput(data)));
new byte[] {'O', 'p', 'u', 's'});
assertFalse(sniff(data));
}
public void testSniffFailsInvalidOggHeader() throws Exception {
byte[] data = TestData.buildOggHeader(0x00, 0, 1000, 0x00);
assertFalse(sniff(createInput(data)));
assertFalse(sniff(data));
}
public void testSniffInvalidHeader() throws Exception {
byte[] data = TestUtil.joinByteArrays(
TestData.buildOggHeader(0x02, 0, 1000, 1),
TestUtil.createByteArray(7), // Laces
new byte[]{0x7F, 'X', 'o', 'r', 'b', 'i', 's'});
assertFalse(sniff(createInput(data)));
new byte[] {0x7F, 'X', 'o', 'r', 'b', 'i', 's'});
assertFalse(sniff(data));
}
public void testSniffFailsEOF() throws Exception {
byte[] data = TestData.buildOggHeader(0x02, 0, 1000, 0x00);
assertFalse(sniff(createInput(data)));
assertFalse(sniff(data));
}
private static FakeExtractorInput createInput(byte[] data) {
return new FakeExtractorInput.Builder().setData(data).setSimulateIOErrors(true)
.setSimulateUnknownLength(true).setSimulatePartialReads(true).build();
}
private boolean sniff(FakeExtractorInput input) throws InterruptedException, IOException {
while (true) {
try {
return extractor.sniff(input);
} catch (SimulatedIOException e) {
// Ignore.
}
}
private boolean sniff(byte[] data) throws InterruptedException, IOException {
FakeExtractorInput input = new FakeExtractorInput.Builder().setData(data)
.setSimulateIOErrors(true).setSimulateUnknownLength(true).setSimulatePartialReads(true)
.build();
return TestUtil.sniffTestData(extractor, input);
}
}
library/src/androidTest/java/com/google/android/exoplayer/extractor/ogg/OggUtilTest.java → library/src/androidTest/java/com/google/android/exoplayer/extractor/ogg/OggPageHeaderTest.java
......@@ -15,40 +15,26 @@
*/
package com.google.android.exoplayer.extractor.ogg;
import com.google.android.exoplayer.extractor.ExtractorInput;
import com.google.android.exoplayer.testutil.FakeExtractorInput;
import com.google.android.exoplayer.testutil.FakeExtractorInput.SimulatedIOException;
import com.google.android.exoplayer.testutil.TestUtil;
import com.google.android.exoplayer.util.ParsableByteArray;
import junit.framework.TestCase;
import java.io.EOFException;
import java.io.IOException;
import java.util.Random;
/**
* Unit test for {@link OggUtil}.
* Unit test for {@link OggPageHeader}.
*/
public final class OggUtilTest extends TestCase {
private Random random = new Random(0);
public void testReadBits() throws Exception {
assertEquals(0, OggUtil.readBits((byte) 0x00, 2, 2));
assertEquals(1, OggUtil.readBits((byte) 0x02, 1, 1));
assertEquals(15, OggUtil.readBits((byte) 0xF0, 4, 4));
assertEquals(1, OggUtil.readBits((byte) 0x80, 1, 7));
}
public final class OggPageHeaderTest extends TestCase {
public void testPopulatePageHeader() throws IOException, InterruptedException {
FakeExtractorInput input = TestData.createInput(TestUtil.joinByteArrays(
TestData.buildOggHeader(0x01, 123456, 4, 2),
TestUtil.createByteArray(2, 2)
), true);
OggUtil.PageHeader header = new OggUtil.PageHeader();
ParsableByteArray byteArray = new ParsableByteArray(27 + 2);
populatePageHeader(input, header, byteArray, false);
OggPageHeader header = new OggPageHeader();
populatePageHeader(input, header, false);
assertEquals(0x01, header.type);
assertEquals(27 + 2, header.headerSize);
......@@ -64,9 +50,8 @@ public final class OggUtilTest extends TestCase {
public void testPopulatePageHeaderQuiteOnExceptionLessThan27Bytes()
throws IOException, InterruptedException {
FakeExtractorInput input = TestData.createInput(TestUtil.createByteArray(2, 2), false);
OggUtil.PageHeader header = new OggUtil.PageHeader();
ParsableByteArray byteArray = new ParsableByteArray(27 + 2);
assertFalse(populatePageHeader(input, header, byteArray, true));
OggPageHeader header = new OggPageHeader();
assertFalse(populatePageHeader(input, header, true));
}
public void testPopulatePageHeaderQuiteOnExceptionNotOgg()
......@@ -78,9 +63,8 @@ public final class OggUtilTest extends TestCase {
// change from 'O' to 'o'
headerBytes[0] = 'o';
FakeExtractorInput input = TestData.createInput(headerBytes, false);
OggUtil.PageHeader header = new OggUtil.PageHeader();
ParsableByteArray byteArray = new ParsableByteArray(27 + 2);
assertFalse(populatePageHeader(input, header, byteArray, true));
OggPageHeader header = new OggPageHeader();
assertFalse(populatePageHeader(input, header, true));
}
public void testPopulatePageHeaderQuiteOnExceptionWrongRevision()
......@@ -92,99 +76,20 @@ public final class OggUtilTest extends TestCase {
// change revision from 0 to 1
headerBytes[4] = 0x01;
FakeExtractorInput input = TestData.createInput(headerBytes, false);
OggUtil.PageHeader header = new OggUtil.PageHeader();
ParsableByteArray byteArray = new ParsableByteArray(27 + 2);
assertFalse(populatePageHeader(input, header, byteArray, true));
OggPageHeader header = new OggPageHeader();
assertFalse(populatePageHeader(input, header, true));
}
private boolean populatePageHeader(FakeExtractorInput input, OggUtil.PageHeader header,
ParsableByteArray byteArray, boolean quite) throws IOException, InterruptedException {
private boolean populatePageHeader(FakeExtractorInput input, OggPageHeader header,
boolean quite) throws IOException, InterruptedException {
while (true) {
try {
return OggUtil.populatePageHeader(input, header, byteArray, quite);
return header.populate(input, quite);
} catch (SimulatedIOException e) {
// ignored
}
}
}
public void testSkipToNextPage() throws Exception {
FakeExtractorInput extractorInput = createInput(
TestUtil.joinByteArrays(
TestUtil.buildTestData(4000, random),
new byte[]{'O', 'g', 'g', 'S'},
TestUtil.buildTestData(4000, random)
), false);
skipToNextPage(extractorInput);
assertEquals(4000, extractorInput.getPosition());
}
public void testSkipToNextPageUnbounded() throws Exception {
FakeExtractorInput extractorInput = createInput(
TestUtil.joinByteArrays(
TestUtil.buildTestData(4000, random),
new byte[]{'O', 'g', 'g', 'S'},
TestUtil.buildTestData(4000, random)
), true);
skipToNextPage(extractorInput);
assertEquals(4000, extractorInput.getPosition());
}
public void testSkipToNextPageOverlap() throws Exception {
FakeExtractorInput extractorInput = createInput(
TestUtil.joinByteArrays(
TestUtil.buildTestData(2046, random),
new byte[]{'O', 'g', 'g', 'S'},
TestUtil.buildTestData(4000, random)
), false);
skipToNextPage(extractorInput);
assertEquals(2046, extractorInput.getPosition());
}
public void testSkipToNextPageOverlapUnbounded() throws Exception {
FakeExtractorInput extractorInput = createInput(
TestUtil.joinByteArrays(
TestUtil.buildTestData(2046, random),
new byte[]{'O', 'g', 'g', 'S'},
TestUtil.buildTestData(4000, random)
), true);
skipToNextPage(extractorInput);
assertEquals(2046, extractorInput.getPosition());
}
public void testSkipToNextPageInputShorterThanPeekLength() throws Exception {
FakeExtractorInput extractorInput = createInput(
TestUtil.joinByteArrays(
new byte[]{'x', 'O', 'g', 'g', 'S'}
), false);
skipToNextPage(extractorInput);
assertEquals(1, extractorInput.getPosition());
}
public void testSkipToNextPageNoMatch() throws Exception {
FakeExtractorInput extractorInput = createInput(new byte[]{'g', 'g', 'S', 'O', 'g', 'g'},
false);
try {
skipToNextPage(extractorInput);
fail();
} catch (EOFException e) {
// expected
}
}
private static void skipToNextPage(ExtractorInput extractorInput)
throws IOException, InterruptedException {
while (true) {
try {
OggUtil.skipToNextPage(extractorInput);
break;
} catch (SimulatedIOException e) { /* ignored */ }
}
}
private static FakeExtractorInput createInput(byte[] data, boolean simulateUnknownLength) {
return new FakeExtractorInput.Builder().setData(data).setSimulateIOErrors(true)
.setSimulateUnknownLength(simulateUnknownLength).setSimulatePartialReads(true).build();
}
}
library/src/androidTest/java/com/google/android/exoplayer/extractor/ogg/OpusReaderTest.java deleted 100644 → 0
/*
* Copyright (C) 2016 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.ogg;
import com.google.android.exoplayer.C;
import com.google.android.exoplayer.Format;
import com.google.android.exoplayer.extractor.DefaultExtractorInput;
import com.google.android.exoplayer.extractor.Extractor;
import com.google.android.exoplayer.extractor.PositionHolder;
import com.google.android.exoplayer.testutil.FakeExtractorOutput;
import com.google.android.exoplayer.testutil.FakeTrackOutput;
import com.google.android.exoplayer.upstream.DataSource;
import com.google.android.exoplayer.upstream.DataSpec;
import com.google.android.exoplayer.upstream.DefaultDataSource;
import com.google.android.exoplayer.util.MimeTypes;
import com.google.android.exoplayer.util.Util;
import android.content.Context;
import android.net.Uri;
import android.test.InstrumentationTestCase;
import java.io.IOException;
/**
* Unit test for {@link OpusReader}.
*/
public final class OpusReaderTest extends InstrumentationTestCase {
private static final String TEST_FILE = "asset:///ogg/bear.opus";
private OggExtractor extractor;
private FakeExtractorOutput extractorOutput;
private DefaultExtractorInput extractorInput;
@Override
public void setUp() throws Exception {
super.setUp();
Context context = getInstrumentation().getContext();
DataSource dataSource = new DefaultDataSource(context, null, Util
.getUserAgent(context, "ExoPlayerExtFlacTest"), false);
Uri uri = Uri.parse(TEST_FILE);
long length = dataSource.open(new DataSpec(uri, 0, C.LENGTH_UNBOUNDED, null));
extractorInput = new DefaultExtractorInput(dataSource, 0, length);
extractor = new OggExtractor();
assertTrue(extractor.sniff(extractorInput));
extractorInput.resetPeekPosition();
extractorOutput = new FakeExtractorOutput();
extractor.init(extractorOutput);
}
public void testSniffOpus() throws Exception {
// Do nothing. All assertions are in setUp()
}
public void testParseHeader() throws Exception {
FakeTrackOutput trackOutput = parseFile(false);
trackOutput.assertSampleCount(0);
Format format = trackOutput.format;
assertNotNull(format);
assertEquals(MimeTypes.AUDIO_OPUS, format.sampleMimeType);
assertEquals(48000, format.sampleRate);
assertEquals(2, format.channelCount);
}
public void testParseWholeFile() throws Exception {
FakeTrackOutput trackOutput = parseFile(true);
trackOutput.assertSampleCount(275);
}
private FakeTrackOutput parseFile(boolean parseAll) throws IOException, InterruptedException {
PositionHolder seekPositionHolder = new PositionHolder();
int readResult = Extractor.RESULT_CONTINUE;
do {
readResult = extractor.read(extractorInput, seekPositionHolder);
if (readResult == Extractor.RESULT_SEEK) {
fail("There should be no seek");
}
} while (readResult != Extractor.RESULT_END_OF_INPUT && parseAll);
assertEquals(1, extractorOutput.trackOutputs.size());
FakeTrackOutput trackOutput = extractorOutput.trackOutputs.get(0);
assertNotNull(trackOutput);
return trackOutput;
}
}
library/src/androidTest/java/com/google/android/exoplayer/extractor/ogg/VorbisReaderTest.java
......@@ -30,13 +30,18 @@ import java.io.IOException;
public final class VorbisReaderTest extends TestCase {
private VorbisReader extractor;
private ParsableByteArray scratch;
@Override
public void setUp() throws Exception {
super.setUp();
extractor = new VorbisReader();
scratch = new ParsableByteArray(new byte[255 * 255], 0);
}
public void testReadBits() throws Exception {
assertEquals(0, VorbisReader.readBits((byte) 0x00, 2, 2));
assertEquals(1, VorbisReader.readBits((byte) 0x02, 1, 1));
assertEquals(15, VorbisReader.readBits((byte) 0xF0, 4, 4));
assertEquals(1, VorbisReader.readBits((byte) 0x80, 1, 7));
}
public void testAppendNumberOfSamples() throws Exception {
......@@ -90,9 +95,16 @@ public final class VorbisReaderTest extends TestCase {
private VorbisSetup readSetupHeaders(FakeExtractorInput input)
throws IOException, InterruptedException {
OggPacket oggPacket = new OggPacket();
while (true) {
try {
return extractor.readSetupHeaders(input, scratch);
if (!oggPacket.populate(input)) {
fail();
}
VorbisSetup vorbisSetup = extractor.readSetupHeaders(oggPacket.getPayload());
if (vorbisSetup != null) {
return vorbisSetup;
}
} catch (SimulatedIOException e) {
// Ignore.
}
......
library/src/androidTest/java/com/google/android/exoplayer/testutil/TestUtil.java
......@@ -17,12 +17,12 @@ package com.google.android.exoplayer.testutil;
import com.google.android.exoplayer.extractor.Extractor;
import com.google.android.exoplayer.extractor.PositionHolder;
import com.google.android.exoplayer.testutil.FakeExtractorInput.SimulatedIOException;
import com.google.android.exoplayer.util.Assertions;
import com.google.android.exoplayer.util.Util;
import android.app.Instrumentation;
import android.test.InstrumentationTestCase;
import org.mockito.MockitoAnnotations;
import java.io.IOException;
......@@ -36,17 +36,41 @@ public class TestUtil {
private TestUtil() {}
public static boolean sniffTestData(Extractor extractor, byte[] data)
throws IOException, InterruptedException {
return sniffTestData(extractor, newExtractorInput(data));
}
public static boolean sniffTestData(Extractor extractor, FakeExtractorInput input)
throws IOException, InterruptedException {
while (true) {
try {
return extractor.sniff(input);
} catch (SimulatedIOException e) {
// Ignore.
}
}
}
public static void consumeTestData(Extractor extractor, byte[] data)
throws IOException, InterruptedException {
FakeExtractorInput input = new FakeExtractorInput.Builder().setData(data).build();
consumeTestData(extractor, newExtractorInput(data));
}
public static void consumeTestData(Extractor extractor, FakeExtractorInput input)
throws IOException, InterruptedException {
PositionHolder seekPositionHolder = new PositionHolder();
int readResult = Extractor.RESULT_CONTINUE;
while (readResult != Extractor.RESULT_END_OF_INPUT) {
readResult = extractor.read(input, seekPositionHolder);
if (readResult == Extractor.RESULT_SEEK) {
long seekPosition = seekPositionHolder.position;
Assertions.checkState(0 < seekPosition && seekPosition <= Integer.MAX_VALUE);
input.setPosition((int) seekPosition);
try {
readResult = extractor.read(input, seekPositionHolder);
if (readResult == Extractor.RESULT_SEEK) {
long seekPosition = seekPositionHolder.position;
Assertions.checkState(0 <= seekPosition && seekPosition <= Integer.MAX_VALUE);
input.setPosition((int) seekPosition);
}
} catch (SimulatedIOException e) {
// Ignore.
}
}
}
......@@ -107,4 +131,8 @@ public class TestUtil {
return Util.toByteArray(is);
}
private static FakeExtractorInput newExtractorInput(byte[] data) {
return new FakeExtractorInput.Builder().setData(data).build();
}
}
library/src/main/java/com/google/android/exoplayer/C.java
......@@ -44,6 +44,11 @@ public interface C {
long MICROS_PER_SECOND = 1000000L;
/**
* The number of nanoseconds in one second.
*/
public static final long NANOS_PER_SECOND = 1000000000L;
/**
* Represents an unbounded length of data.
*/
int LENGTH_UNBOUNDED = -1;
......
library/src/main/java/com/google/android/exoplayer/extractor/ogg/FlacReader.java
......@@ -15,17 +15,14 @@
*/
package com.google.android.exoplayer.extractor.ogg;
import com.google.android.exoplayer.C;
import com.google.android.exoplayer.Format;
import com.google.android.exoplayer.extractor.Extractor;
import com.google.android.exoplayer.extractor.ExtractorInput;
import com.google.android.exoplayer.extractor.PositionHolder;
import com.google.android.exoplayer.extractor.SeekMap;
import com.google.android.exoplayer.util.FlacSeekTable;
import com.google.android.exoplayer.util.Assertions;
import com.google.android.exoplayer.util.FlacStreamInfo;
import com.google.android.exoplayer.util.FlacUtil;
import com.google.android.exoplayer.util.MimeTypes;
import com.google.android.exoplayer.util.ParsableByteArray;
import com.google.android.exoplayer.util.Util;
import java.io.IOException;
import java.util.Arrays;
......@@ -40,11 +37,10 @@ import java.util.List;
private static final byte AUDIO_PACKET_TYPE = (byte) 0xFF;
private static final byte SEEKTABLE_PACKET_TYPE = 0x03;
private FlacStreamInfo streamInfo;
private FlacSeekTable seekTable;
private static final int FRAME_HEADER_SAMPLE_NUMBER_OFFSET = 4;
private boolean firstAudioPacketProcessed;
private FlacStreamInfo streamInfo;
private FlacOggSeeker flacOggSeeker;
public static boolean verifyBitstreamType(ParsableByteArray data) {
return data.bytesLeft() >= 5 && data.readUnsignedByte() == 0x7F && // packet type
......@@ -52,46 +48,150 @@ import java.util.List;
}
@Override
public int read(ExtractorInput input, PositionHolder seekPosition)
throws IOException, InterruptedException {
long position = input.getPosition();
if (!oggParser.readPacket(input, scratch)) {
return Extractor.RESULT_END_OF_INPUT;
protected long preparePayload(ParsableByteArray packet) {
if (packet.data[0] != AUDIO_PACKET_TYPE) {
return -1;
}
return getFlacFrameBlockSize(packet);
}
byte[] data = scratch.data;
@Override
protected boolean readHeaders(ParsableByteArray packet, long position, SetupData setupData)
throws IOException, InterruptedException {
byte[] data = packet.data;
if (streamInfo == null) {
streamInfo = new FlacStreamInfo(data, 17);
byte[] metadata = Arrays.copyOfRange(data, 9, scratch.limit());
byte[] metadata = Arrays.copyOfRange(data, 9, packet.limit());
metadata[4] = (byte) 0x80; // Set the last metadata block flag, ignore the other blocks
List<byte[]> initializationData = Collections.singletonList(metadata);
trackOutput.format(Format.createAudioSampleFormat(null, MimeTypes.AUDIO_FLAC,
streamInfo.bitRate(), Format.NO_VALUE, streamInfo.channels, streamInfo.sampleRate,
initializationData, null, 0, null));
setupData.format = Format.createAudioSampleFormat(null, MimeTypes.AUDIO_FLAC, Format.NO_VALUE,
streamInfo.bitRate(), streamInfo.channels, streamInfo.sampleRate, initializationData,
null, 0, null);
} else if ((data[0] & 0x7F) == SEEKTABLE_PACKET_TYPE) {
Assertions.checkArgument(flacOggSeeker == null);
flacOggSeeker = new FlacOggSeeker();
flacOggSeeker.parseSeekTable(packet);
} else if (data[0] == AUDIO_PACKET_TYPE) {
if (!firstAudioPacketProcessed) {
if (seekTable != null) {
extractorOutput.seekMap(seekTable.createSeekMap(position, streamInfo.sampleRate,
streamInfo.durationUs()));
seekTable = null;
if (flacOggSeeker != null) {
flacOggSeeker.setFirstFrameOffset(position);
setupData.oggSeeker = flacOggSeeker;
}
return false;
}
return true;
}
private int getFlacFrameBlockSize(ParsableByteArray packet) {
int blockSizeCode = (packet.data[2] & 0xFF) >> 4;
switch (blockSizeCode) {
case 1:
return 192;
case 2:
case 3:
case 4:
case 5:
return 576 << (blockSizeCode - 2);
case 6:
case 7:
// skip the sample number
packet.skipBytes(FRAME_HEADER_SAMPLE_NUMBER_OFFSET);
packet.readUtf8EncodedLong();
if (blockSizeCode == 6) {
return packet.readUnsignedByte() + 1;
} else {
extractorOutput.seekMap(new SeekMap.Unseekable(streamInfo.durationUs()));
return packet.readUnsignedShort() + 1;
}
firstAudioPacketProcessed = true;
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
return 256 << (blockSizeCode - 8);
}
return -1;
}
private class FlacOggSeeker implements OggSeeker, SeekMap {
private static final int METADATA_LENGTH_OFFSET = 1;
private static final int SEEK_POINT_SIZE = 18;
private long[] sampleNumbers;
private long[] offsets;
private long firstFrameOffset = -1;
private volatile long queriedGranule;
private volatile long seekedGranule;
private long currentGranule = -1;
public void setFirstFrameOffset(long firstFrameOffset) {
this.firstFrameOffset = firstFrameOffset;
}
/**
* Parses a FLAC file seek table metadata structure and initializes internal fields.
*
* @param data
* A ParsableByteArray including whole seek table metadata block. Its position should be set
* to the beginning of the block.
* @see <a href="https://xiph.org/flac/format.html#metadata_block_seektable">FLAC format
* METADATA_BLOCK_SEEKTABLE</a>
*/
public void parseSeekTable(ParsableByteArray data) {
data.skipBytes(METADATA_LENGTH_OFFSET);
int length = data.readUnsignedInt24();
int numberOfSeekPoints = length / SEEK_POINT_SIZE;
sampleNumbers = new long[numberOfSeekPoints];
offsets = new long[numberOfSeekPoints];
for (int i = 0; i < numberOfSeekPoints; i++) {
sampleNumbers[i] = data.readLong();
offsets[i] = data.readLong();
data.skipBytes(2); // Skip "Number of samples in the target frame."
}
}
@Override
public long read(ExtractorInput input) throws IOException, InterruptedException {
if (currentGranule >= 0) {
currentGranule = -currentGranule - 2;
return currentGranule;
}
return -1;
}
@Override
public synchronized long startSeek() {
currentGranule = seekedGranule;
return queriedGranule;
}
@Override
public SeekMap createSeekMap() {
return this;
}
@Override
public boolean isSeekable() {
return true;
}
trackOutput.sampleData(scratch, scratch.limit());
scratch.setPosition(0);
long timeUs = FlacUtil.extractSampleTimestamp(streamInfo, scratch);
trackOutput.sampleMetadata(timeUs, C.BUFFER_FLAG_KEY_FRAME, scratch.limit(), 0, null);
@Override
public synchronized long getPosition(long timeUs) {
queriedGranule = convertTimeToGranule(timeUs);
int index = Util.binarySearchFloor(sampleNumbers, queriedGranule, true, true);
seekedGranule = sampleNumbers[index];
return firstFrameOffset + offsets[index];
}
} else if ((data[0] & 0x7F) == SEEKTABLE_PACKET_TYPE && seekTable == null) {
seekTable = FlacSeekTable.parseSeekTable(scratch);
@Override
public long getDurationUs() {
return streamInfo.durationUs();
}
scratch.reset();
return Extractor.RESULT_CONTINUE;
}
}
library/src/main/java/com/google/android/exoplayer/extractor/ogg/OggExtractor.java
......@@ -30,19 +30,22 @@ import java.io.IOException;
*/
public class OggExtractor implements Extractor {
private static final int MAX_VERIFICATION_BYTES = 8;
private StreamReader streamReader;
@Override
public boolean sniff(ExtractorInput input) throws IOException, InterruptedException {
try {
ParsableByteArray scratch = new ParsableByteArray(new byte[OggUtil.PAGE_HEADER_SIZE], 0);
OggUtil.PageHeader header = new OggUtil.PageHeader();
if (!OggUtil.populatePageHeader(input, header, scratch, true)
|| (header.type & 0x02) != 0x02) {
OggPageHeader header = new OggPageHeader();
if (!header.populate(input, true) || (header.type & 0x02) != 0x02) {
return false;
}
input.peekFully(scratch.data, 0, header.bodySize);
scratch.setLimit(header.bodySize);
int length = Math.min(header.bodySize, MAX_VERIFICATION_BYTES);
ParsableByteArray scratch = new ParsableByteArray(length);
input.peekFully(scratch.data, 0, length);
if (FlacReader.verifyBitstreamType(resetPosition(scratch))) {
streamReader = new FlacReader();
} else if (VorbisReader.verifyBitstreamType(resetPosition(scratch))) {
......@@ -62,6 +65,7 @@ public class OggExtractor implements Extractor {
public void init(ExtractorOutput output) {
TrackOutput trackOutput = output.track(0);
output.endTracks();
// TODO: fix the case if sniff() isn't called
streamReader.init(output, trackOutput);
}
......
library/src/main/java/com/google/android/exoplayer/extractor/ogg/OggParser.java → library/src/main/java/com/google/android/exoplayer/extractor/ogg/OggPacket.java
......@@ -15,36 +15,33 @@
*/
package com.google.android.exoplayer.extractor.ogg;
import com.google.android.exoplayer.C;
import com.google.android.exoplayer.ParserException;
import com.google.android.exoplayer.extractor.ExtractorInput;
import com.google.android.exoplayer.extractor.ogg.OggUtil.PacketInfoHolder;
import com.google.android.exoplayer.util.Assertions;
import com.google.android.exoplayer.util.ParsableByteArray;
import java.io.IOException;
/**
* Reads OGG packets from an {@link ExtractorInput}.
* OGG packet class.
*/
/* package */ final class OggParser {
/* package */ final class OggPacket {
public static final int OGG_MAX_SEGMENT_SIZE = 255;
private final OggUtil.PageHeader pageHeader = new OggUtil.PageHeader();
private final ParsableByteArray headerArray = new ParsableByteArray(27 + 255);
private final PacketInfoHolder holder = new PacketInfoHolder();
private final OggPageHeader pageHeader = new OggPageHeader();
private final ParsableByteArray packetArray =
new ParsableByteArray(new byte[OggPageHeader.MAX_PAGE_PAYLOAD], 0);
private int currentSegmentIndex = -1;
private long elapsedSamples;
private int segmentCount;
private boolean populated;
/**
* Resets this reader.
*/
public void reset() {
pageHeader.reset();
headerArray.reset();
packetArray.reset();
currentSegmentIndex = -1;
populated = false;
}
/**
......@@ -54,21 +51,23 @@ import java.io.IOException;
* pages.
*
* @param input the {@link ExtractorInput} to read data from.
* @param packetArray the {@link ParsableByteArray} to write the packet data into.
* @return {@code true} if the read was successful. {@code false} if the end of the input was
* encountered having read no data.
* @throws IOException thrown if reading from the input fails.
* @throws InterruptedException thrown if interrupted while reading from input.
*/
public boolean readPacket(ExtractorInput input, ParsableByteArray packetArray)
throws IOException, InterruptedException {
Assertions.checkState(input != null && packetArray != null);
public boolean populate(ExtractorInput input) throws IOException, InterruptedException {
Assertions.checkState(input != null);
if (populated) {
populated = false;
packetArray.reset();
}
boolean packetComplete = false;
while (!packetComplete) {
while (!populated) {
if (currentSegmentIndex < 0) {
// We're at the start of a page.
if (!OggUtil.populatePageHeader(input, pageHeader, headerArray, true)) {
if (!pageHeader.populate(input, true)) {
return false;
}
int segmentIndex = 0;
......@@ -76,20 +75,19 @@ import java.io.IOException;
if ((pageHeader.type & 0x01) == 0x01 && packetArray.limit() == 0) {
// After seeking, the first packet may be the remainder
// part of a continued packet which has to be discarded.
OggUtil.calculatePacketSize(pageHeader, segmentIndex, holder);
segmentIndex += holder.segmentCount;
bytesToSkip += holder.size;
bytesToSkip += calculatePacketSize(segmentIndex);
segmentIndex += segmentCount;
}
input.skipFully(bytesToSkip);
currentSegmentIndex = segmentIndex;
}
OggUtil.calculatePacketSize(pageHeader, currentSegmentIndex, holder);
int segmentIndex = currentSegmentIndex + holder.segmentCount;
if (holder.size > 0) {
input.readFully(packetArray.data, packetArray.limit(), holder.size);
packetArray.setLimit(packetArray.limit() + holder.size);
packetComplete = pageHeader.laces[segmentIndex - 1] != 255;
int size = calculatePacketSize(currentSegmentIndex);
int segmentIndex = currentSegmentIndex + segmentCount;
if (size > 0) {
input.readFully(packetArray.data, packetArray.limit(), size);
packetArray.setLimit(packetArray.limit() + size);
populated = pageHeader.laces[segmentIndex - 1] != 255;
}
// advance now since we are sure reading didn't throw an exception
currentSegmentIndex = segmentIndex == pageHeader.pageSegmentCount ? -1
......@@ -99,75 +97,45 @@ import java.io.IOException;
}
/**
* Skips to the last Ogg page in the stream and reads the header's granule field which is the
* total number of samples per channel.
* An OGG Packet may span multiple pages. Returns the {@link OggPageHeader} of the last page read,
* or an empty header if the packet has yet to be populated.
* <p>
* Note that the returned {@link OggPageHeader} is mutable and may be updated during subsequent
* calls to {@link #populate(ExtractorInput)}.
*
* @param input The {@link ExtractorInput} to read from.
* @return the total number of samples of this input.
* @throws IOException thrown if reading from the input fails.
* @throws InterruptedException thrown if interrupted while reading from the input.
* @return the {@code PageHeader} of the last page read or an empty header if the packet has yet
* to be populated.
*/
public long readGranuleOfLastPage(ExtractorInput input)
throws IOException, InterruptedException {
Assertions.checkArgument(input.getLength() != C.LENGTH_UNBOUNDED); // never read forever!
OggUtil.skipToNextPage(input);
pageHeader.reset();
while ((pageHeader.type & 0x04) != 0x04 && input.getPosition() < input.getLength()) {
OggUtil.populatePageHeader(input, pageHeader, headerArray, false);
input.skipFully(pageHeader.headerSize + pageHeader.bodySize);
}
return pageHeader.granulePosition;
//@VisibleForTesting
public OggPageHeader getPageHeader() {
return pageHeader;
}
/**
* Skips to the position of the start of the page containing the {@code targetGranule} and
* returns the elapsed samples which is the granule of the page previous to the target page.
* <p>
* Note that the position of the {@code input} must be before the start of the page previous to
* the page containing the targetGranule to get the correct number of elapsed samples.
* Which is in short like: {@code pos(input) <= pos(targetPage.pageSequence - 1)}.
*
* @param input the {@link ExtractorInput} to read from.
* @param targetGranule the target granule (number of frames per channel).
* @return the number of elapsed samples at the start of the target page.
* @throws ParserException thrown if populating the page header fails.
* @throws IOException thrown if reading from the input fails.
* @throws InterruptedException thrown if interrupted while reading from the input.
* @return A ParsableByteArray containing the payload of the packet.
*/
public long skipToPageOfGranule(ExtractorInput input, long targetGranule)
throws IOException, InterruptedException {
OggUtil.skipToNextPage(input);
OggUtil.populatePageHeader(input, pageHeader, headerArray, false);
while (pageHeader.granulePosition < targetGranule) {
input.skipFully(pageHeader.headerSize + pageHeader.bodySize);
// Store in a member field to be able to resume after IOExceptions.
elapsedSamples = pageHeader.granulePosition;
// Peek next header.
OggUtil.populatePageHeader(input, pageHeader, headerArray, false);
}
if (elapsedSamples == 0) {
throw new ParserException();
}
input.resetPeekPosition();
long returnValue = elapsedSamples;
// Reset member state.
elapsedSamples = 0;
currentSegmentIndex = -1;
return returnValue;
public ParsableByteArray getPayload() {
return packetArray;
}
/**
* Returns the {@link OggUtil.PageHeader} of the current page. The header might not have been
* populated if the first packet has yet to be read.
* <p>
* Note that there is only a single instance of {@code OggParser.PageHeader} which is mutable.
* The value of the fields might be changed by the reader when reading the stream advances and
* the next page is read (which implies reading and populating the next header).
* Calculates the size of the packet starting from {@code startSegmentIndex}.
*
* @return the {@code PageHeader} of the current page or {@code null}.
* @param startSegmentIndex the index of the first segment of the packet.
* @return Size of the packet.
*/
public OggUtil.PageHeader getPageHeader() {
return pageHeader;
private int calculatePacketSize(int startSegmentIndex) {
segmentCount = 0;
int size = 0;
while (startSegmentIndex + segmentCount < pageHeader.pageSegmentCount) {
int segmentLength = pageHeader.laces[startSegmentIndex + segmentCount++];
size += segmentLength;
if (segmentLength != 255) {
// packets end at first lace < 255
break;
}
}
return size;
}
}
library/src/main/java/com/google/android/exoplayer/extractor/ogg/OggPageHeader.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.ogg;
import com.google.android.exoplayer.C;
import com.google.android.exoplayer.ParserException;
import com.google.android.exoplayer.extractor.ExtractorInput;
import com.google.android.exoplayer.util.ParsableByteArray;
import com.google.android.exoplayer.util.Util;
import java.io.EOFException;
import java.io.IOException;
/**
* Data object to store header information.
*/
/* package */ final class OggPageHeader {
public static final int EMPTY_PAGE_HEADER_SIZE = 27;
public static final int MAX_SEGMENT_COUNT = 255;
public static final int MAX_PAGE_PAYLOAD = 255 * 255;
public static final int MAX_PAGE_SIZE = EMPTY_PAGE_HEADER_SIZE + MAX_SEGMENT_COUNT
+ MAX_PAGE_PAYLOAD;
private static final int TYPE_OGGS = Util.getIntegerCodeForString("OggS");
public int revision;
public int type;
public long granulePosition;
public long streamSerialNumber;
public long pageSequenceNumber;
public long pageChecksum;
public int pageSegmentCount;
public int headerSize;
public int bodySize;
/**
* Be aware that {@code laces.length} is always {@link #MAX_SEGMENT_COUNT}. Instead use
* {@link #pageSegmentCount} to iterate.
*/
public final int[] laces = new int[MAX_SEGMENT_COUNT];
private final ParsableByteArray scratch = new ParsableByteArray(MAX_SEGMENT_COUNT);
/**
* Resets all primitive member fields to zero.
*/
public void reset() {
revision = 0;
type = 0;
granulePosition = 0;
streamSerialNumber = 0;
pageSequenceNumber = 0;
pageChecksum = 0;
pageSegmentCount = 0;
headerSize = 0;
bodySize = 0;
}
/**
* Peeks an Ogg page header and updates this {@link OggPageHeader}.
*
* @param input the {@link ExtractorInput} to read from.
* @param quiet if {@code true} no Exceptions are thrown but {@code false} is return if something
* goes wrong.
* @return {@code true} if the read was successful. {@code false} if the end of the input was
* encountered having read no data.
* @throws IOException thrown if reading data fails or the stream is invalid.
* @throws InterruptedException thrown if thread is interrupted when reading/peeking.
*/
public boolean populate(ExtractorInput input, boolean quiet)
throws IOException, InterruptedException {
scratch.reset();
reset();
boolean hasEnoughBytes = input.getLength() == C.LENGTH_UNBOUNDED
|| input.getLength() - input.getPeekPosition() >= EMPTY_PAGE_HEADER_SIZE;
if (!hasEnoughBytes || !input.peekFully(scratch.data, 0, EMPTY_PAGE_HEADER_SIZE, true)) {
if (quiet) {
return false;
} else {
throw new EOFException();
}
}
if (scratch.readUnsignedInt() != TYPE_OGGS) {
if (quiet) {
return false;
} else {
throw new ParserException("expected OggS capture pattern at begin of page");
}
}
revision = scratch.readUnsignedByte();
if (revision != 0x00) {
if (quiet) {
return false;
} else {
throw new ParserException("unsupported bit stream revision");
}
}
type = scratch.readUnsignedByte();
granulePosition = scratch.readLittleEndianLong();
streamSerialNumber = scratch.readLittleEndianUnsignedInt();
pageSequenceNumber = scratch.readLittleEndianUnsignedInt();
pageChecksum = scratch.readLittleEndianUnsignedInt();
pageSegmentCount = scratch.readUnsignedByte();
headerSize = EMPTY_PAGE_HEADER_SIZE + pageSegmentCount;
// calculate total size of header including laces
scratch.reset();
input.peekFully(scratch.data, 0, pageSegmentCount);
for (int i = 0; i < pageSegmentCount; i++) {
laces[i] = scratch.readUnsignedByte();
bodySize += laces[i];
}
return true;
}
}
library/src/main/java/com/google/android/exoplayer/extractor/ogg/OggSeeker.java
......@@ -15,65 +15,45 @@
*/
package com.google.android.exoplayer.extractor.ogg;
import com.google.android.exoplayer.C;
import com.google.android.exoplayer.extractor.ExtractorInput;
import com.google.android.exoplayer.util.Assertions;
import com.google.android.exoplayer.util.ParsableByteArray;
import com.google.android.exoplayer.extractor.SeekMap;
import java.io.IOException;
/**
* Used to seek in an Ogg stream.
* Used to seek in an Ogg stream. OggSeeker implementation may do direct seeking or progressive
* seeking. OggSeeker works together with a {@link SeekMap} instance to capture the queried position
* and start the seeking with an initial estimated position.
*/
/* package */ final class OggSeeker {
/* package */ interface OggSeeker {
private static final int MATCH_RANGE = 72000;
private final OggUtil.PageHeader pageHeader = new OggUtil.PageHeader();
private final ParsableByteArray headerArray = new ParsableByteArray(27 + 255);
private long audioDataLength = C.LENGTH_UNBOUNDED;
private long totalSamples;
/**
* @return a SeekMap instance which returns an initial estimated position for progressive seeking
* or the final position for direct seeking. Returns null if {@link #read} hasn't returned -1
* yet.
*/
SeekMap createSeekMap();
/**
* Setup the seeker with the data it needs to to an educated guess of seeking positions.
* Initializes a seek operation.
*
* @param audioDataLength the length of the audio data (total bytes - header bytes).
* @param totalSamples the total number of samples of audio data.
* @return The granule position targeted by the seek.
*/
public void setup(long audioDataLength, long totalSamples) {
Assertions.checkArgument(audioDataLength > 0 && totalSamples > 0);
this.audioDataLength = audioDataLength;
this.totalSamples = totalSamples;
}
long startSeek();
/**
* Returns a position converging to the {@code targetGranule} to which the {@link ExtractorInput}
* has to seek and then be passed for another call until -1 is return. If -1 is returned the
* input is at a position which is before the start of the page before the target page and at
* which it is sensible to just skip pages to the target granule and pre-roll instead of doing
* another seek request.
* Reads data from the {@link ExtractorInput} to build the {@link SeekMap} or to continue a
* progressive seek.
* <p/>
* If more data is required or if the position of the input needs to be modified then a position
* from which data should be provided is returned. Else a negative value is returned. If a seek
* has been completed then the value returned is -(currentGranule + 2). Else -1 is returned.
*
* @param targetGranule the target granule position to seek to.
* @param input the {@link ExtractorInput} to read from.
* @return the position to seek the {@link ExtractorInput} to for a next call or -1 if it's close
* enough to skip to the target page.
* @return the non-negative position to seek the {@link ExtractorInput} to or -1 seeking not
* necessary or at the end of seeking a negative number < -1 which is -(currentGranule + 2).
* @throws IOException thrown if reading from the input fails.
* @throws InterruptedException thrown if interrupted while reading from the input.
*/
public long getNextSeekPosition(long targetGranule, ExtractorInput input)
throws IOException, InterruptedException {
Assertions.checkState(audioDataLength != C.LENGTH_UNBOUNDED && totalSamples != 0);
OggUtil.populatePageHeader(input, pageHeader, headerArray, false);
long granuleDistance = targetGranule - pageHeader.granulePosition;
if (granuleDistance <= 0 || granuleDistance > MATCH_RANGE) {
// estimated position too high or too low
long offset = (pageHeader.bodySize + pageHeader.headerSize)
* (granuleDistance <= 0 ? 2 : 1);
return input.getPosition() - offset + (granuleDistance * audioDataLength / totalSamples);
}
// position accepted (below target granule and within MATCH_RANGE)
input.resetPeekPosition();
return -1;
}
long read(ExtractorInput input) throws IOException, InterruptedException;
}
library/src/main/java/com/google/android/exoplayer/extractor/ogg/OggUtil.java deleted 100644 → 0
/*
* 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.ogg;
import com.google.android.exoplayer.C;
import com.google.android.exoplayer.ParserException;
import com.google.android.exoplayer.extractor.ExtractorInput;
import com.google.android.exoplayer.util.ParsableByteArray;
import com.google.android.exoplayer.util.Util;
import java.io.EOFException;
import java.io.IOException;
/**
* Utility methods for reading ogg streams.
*/
/* package */ final class OggUtil {
public static final int PAGE_HEADER_SIZE = 27;
private static final int TYPE_OGGS = Util.getIntegerCodeForString("OggS");
/**
* Reads an int of {@code length} bits from {@code src} starting at
* {@code leastSignificantBitIndex}.
*
* @param src the {@code byte} to read from.
* @param length the length in bits of the int to read.
* @param leastSignificantBitIndex the index of the least significant bit of the int to read.
* @return the int value read.
*/
public static int readBits(byte src, int length, int leastSignificantBitIndex) {
return (src >> leastSignificantBitIndex) & (255 >>> (8 - length));
}
/**
* Skips to the next page.
*
* @param input The {@code ExtractorInput} to skip to the next page.
* @throws IOException thrown if peeking/reading from the input fails.
* @throws InterruptedException thrown if interrupted while peeking/reading from the input.
*/
public static void skipToNextPage(ExtractorInput input)
throws IOException, InterruptedException {
byte[] buffer = new byte[2048];
int peekLength = buffer.length;
while (true) {
if (input.getLength() != C.LENGTH_UNBOUNDED
&& input.getPosition() + peekLength > input.getLength()) {
// Make sure to not peek beyond the end of the input.
peekLength = (int) (input.getLength() - input.getPosition());
if (peekLength < 4) {
// Not found until eof.
throw new EOFException();
}
}
input.peekFully(buffer, 0, peekLength, false);
for (int i = 0; i < peekLength - 3; i++) {
if (buffer[i] == 'O' && buffer[i + 1] == 'g' && buffer[i + 2] == 'g'
&& buffer[i + 3] == 'S') {
// Match! Skip to the start of the pattern.
input.skipFully(i);
return;
}
}
// Overlap by not skipping the entire peekLength.
input.skipFully(peekLength - 3);
}
}
/**
* Peeks an Ogg page header and stores the data in the {@code header} object passed
* as argument.
*
* @param input the {@link ExtractorInput} to read from.
* @param header the {@link PageHeader} to be populated.
* @param scratch a scratch array temporary use. Its size should be at least PAGE_HEADER_SIZE
* @param quite if {@code true} no Exceptions are thrown but {@code false} is return if something
* goes wrong.
* @return {@code true} if the read was successful. {@code false} if the end of the
* input was encountered having read no data.
* @throws IOException thrown if reading data fails or the stream is invalid.
* @throws InterruptedException thrown if thread is interrupted when reading/peeking.
*/
public static boolean populatePageHeader(ExtractorInput input, PageHeader header,
ParsableByteArray scratch, boolean quite) throws IOException, InterruptedException {
scratch.reset();
header.reset();
boolean hasEnoughBytes = input.getLength() == C.LENGTH_UNBOUNDED
|| input.getLength() - input.getPeekPosition() >= PAGE_HEADER_SIZE;
if (!hasEnoughBytes || !input.peekFully(scratch.data, 0, PAGE_HEADER_SIZE, true)) {
if (quite) {
return false;
} else {
throw new EOFException();
}
}
if (scratch.readUnsignedInt() != TYPE_OGGS) {
if (quite) {
return false;
} else {
throw new ParserException("expected OggS capture pattern at begin of page");
}
}
header.revision = scratch.readUnsignedByte();
if (header.revision != 0x00) {
if (quite) {
return false;
} else {
throw new ParserException("unsupported bit stream revision");
}
}
header.type = scratch.readUnsignedByte();
header.granulePosition = scratch.readLittleEndianLong();
header.streamSerialNumber = scratch.readLittleEndianUnsignedInt();
header.pageSequenceNumber = scratch.readLittleEndianUnsignedInt();
header.pageChecksum = scratch.readLittleEndianUnsignedInt();
header.pageSegmentCount = scratch.readUnsignedByte();
scratch.reset();
// calculate total size of header including laces
header.headerSize = PAGE_HEADER_SIZE + header.pageSegmentCount;
input.peekFully(scratch.data, 0, header.pageSegmentCount);
for (int i = 0; i < header.pageSegmentCount; i++) {
header.laces[i] = scratch.readUnsignedByte();
header.bodySize += header.laces[i];
}
return true;
}
/**
* Calculates the size of the packet starting from {@code startSegmentIndex}.
*
* @param header the {@link PageHeader} with laces.
* @param startSegmentIndex the index of the first segment of the packet.
* @param holder a position holder to store the resulting size value.
*/
public static void calculatePacketSize(PageHeader header, int startSegmentIndex,
PacketInfoHolder holder) {
holder.segmentCount = 0;
holder.size = 0;
while (startSegmentIndex + holder.segmentCount < header.pageSegmentCount) {
int segmentLength = header.laces[startSegmentIndex + holder.segmentCount++];
holder.size += segmentLength;
if (segmentLength != 255) {
// packets end at first lace < 255
break;
}
}
}
/**
* Data object to store header information. Be aware that {@code laces.length} is always 255.
* Instead use {@code pageSegmentCount} to iterate.
*/
public static final class PageHeader {
public int revision;
public int type;
public long granulePosition;
public long streamSerialNumber;
public long pageSequenceNumber;
public long pageChecksum;
public int pageSegmentCount;
public int headerSize;
public int bodySize;
public final int[] laces = new int[255];
/**
* Resets all primitive member fields to zero.
*/
public void reset() {
revision = 0;
type = 0;
granulePosition = 0;
streamSerialNumber = 0;
pageSequenceNumber = 0;
pageChecksum = 0;
pageSegmentCount = 0;
headerSize = 0;
bodySize = 0;
}
}
/**
* Holds size and number of segments of a packet.
*/
public static class PacketInfoHolder {
public int size;
public int segmentCount;
}
}
library/src/main/java/com/google/android/exoplayer/extractor/ogg/OpusReader.java
......@@ -17,16 +17,14 @@ package com.google.android.exoplayer.extractor.ogg;
import com.google.android.exoplayer.C;
import com.google.android.exoplayer.Format;
import com.google.android.exoplayer.extractor.Extractor;
import com.google.android.exoplayer.extractor.ExtractorInput;
import com.google.android.exoplayer.extractor.PositionHolder;
import com.google.android.exoplayer.extractor.SeekMap;
import com.google.android.exoplayer.util.MimeTypes;
import com.google.android.exoplayer.util.ParsableByteArray;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
......@@ -34,19 +32,16 @@ import java.util.List;
*/
/* package */ final class OpusReader extends StreamReader {
private static final int DEFAULT_SEEK_PRE_ROLL_SAMPLES = 3840;
/**
* Opus streams are always decoded at 48000 Hz.
*/
private static final int SAMPLE_RATE = 48000;
private static final byte[] OPUS_SIGNATURE = {'O', 'p', 'u', 's', 'H', 'e', 'a', 'd'};
private static final int STATE_READ_HEADER = 0;
private static final int STATE_READ_TAGS = 1;
private static final int STATE_READ_AUDIO = 2;
private int state = STATE_READ_HEADER;
private long timeUs;
private boolean headerRead;
private boolean tagsSkipped;
public static boolean verifyBitstreamType(ParsableByteArray data) {
if (data.bytesLeft() < OPUS_SIGNATURE.length) {
......@@ -58,42 +53,48 @@ import java.util.List;
}
@Override
public int read(ExtractorInput input, PositionHolder seekPosition)
protected long preparePayload(ParsableByteArray packet) {
return convertTimeToGranule(getPacketDurationUs(packet.data));
}
@Override
protected boolean readHeaders(ParsableByteArray packet, long position, SetupData setupData)
throws IOException, InterruptedException {
if (!oggParser.readPacket(input, scratch)) {
return Extractor.RESULT_END_OF_INPUT;
}
if (!headerRead) {
byte[] metadata = Arrays.copyOf(packet.data, packet.limit());
int channelCount = metadata[9] & 0xFF;
int preskip = ((metadata[11] & 0xFF) << 8) | (metadata[10] & 0xFF);
byte[] data = scratch.data;
int dataSize = scratch.limit();
List<byte[]> initializationData = new ArrayList<>(3);
initializationData.add(metadata);
putNativeOrderLong(initializationData, preskip);
putNativeOrderLong(initializationData, DEFAULT_SEEK_PRE_ROLL_SAMPLES);
switch (state) {
case STATE_READ_HEADER: {
byte[] metadata = Arrays.copyOfRange(data, 0, dataSize);
int channelCount = metadata[9] & 0xFF;
List<byte[]> initializationData = Collections.singletonList(metadata);
trackOutput.format(Format.createAudioSampleFormat(null, MimeTypes.AUDIO_OPUS,
Format.NO_VALUE, Format.NO_VALUE, channelCount, SAMPLE_RATE,
initializationData, null, 0, null));
state = STATE_READ_TAGS;
} break;
case STATE_READ_TAGS:
// skip this packet
state = STATE_READ_AUDIO;
extractorOutput.seekMap(new SeekMap.Unseekable(C.UNSET_TIME_US));
break;
case STATE_READ_AUDIO:
trackOutput.sampleData(scratch, dataSize);
trackOutput.sampleMetadata(timeUs, C.BUFFER_FLAG_KEY_FRAME, dataSize, 0, null);
timeUs += getPacketDuration(data);
break;
setupData.format = Format.createAudioSampleFormat(null, MimeTypes.AUDIO_OPUS, Format.NO_VALUE,
Format.NO_VALUE, channelCount, SAMPLE_RATE, initializationData, null, 0, "und");
headerRead = true;
} else if (!tagsSkipped) {
// Skip tags packet
tagsSkipped = true;
} else {
return false;
}
return true;
}
scratch.reset();
return Extractor.RESULT_CONTINUE;
private void putNativeOrderLong(List<byte[]> initializationData, int samples) {
long ns = (samples * C.NANOS_PER_SECOND) / SAMPLE_RATE;
byte[] array = ByteBuffer.allocate(8).order(ByteOrder.nativeOrder()).putLong(ns).array();
initializationData.add(array);
}
private long getPacketDuration(byte[] packet) {
/**
* Returns the duration of the given audio packet.
*
* @param packet Contains audio data.
* @return Returns the duration of the given audio packet.
*/
private long getPacketDurationUs(byte[] packet) {
int toc = packet[0] & 0xFF;
int frames;
switch (toc & 0x3) {
......
library/src/main/java/com/google/android/exoplayer/extractor/ogg/StreamReader.java
package com.google.android.exoplayer.extractor.ogg;
import com.google.android.exoplayer.C;
import com.google.android.exoplayer.Format;
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.ParsableByteArray;
......@@ -14,31 +17,202 @@ import java.io.IOException;
*/
/* package */ abstract class StreamReader {
protected final ParsableByteArray scratch = new ParsableByteArray(
new byte[OggParser.OGG_MAX_SEGMENT_SIZE * 255], 0);
private static final int STATE_READ_HEADERS = 0;
private static final int STATE_READ_PAYLOAD = 1;
private static final int STATE_END_OF_INPUT = 2;
protected final OggParser oggParser = new OggParser();
protected TrackOutput trackOutput;
static class SetupData {
Format format;
OggSeeker oggSeeker;
}
protected ExtractorOutput extractorOutput;
private OggPacket oggPacket;
private TrackOutput trackOutput;
private ExtractorOutput extractorOutput;
private OggSeeker oggSeeker;
private long targetGranule;
private long payloadStartPosition;
private long currentGranule;
private int state;
private int sampleRate;
private SetupData setupData;
private long lengthOfReadPacket;
private boolean seekMapSet;
void init(ExtractorOutput output, TrackOutput trackOutput) {
this.extractorOutput = output;
this.trackOutput = trackOutput;
this.oggPacket = new OggPacket();
this.setupData = new SetupData();
this.state = STATE_READ_HEADERS;
this.targetGranule = -1;
this.payloadStartPosition = 0;
}
/**
* @see Extractor#seek()
*/
void seek() {
oggParser.reset();
scratch.reset();
final void seek() {
oggPacket.reset();
if (state != STATE_READ_HEADERS) {
targetGranule = oggSeeker.startSeek();
state = STATE_READ_PAYLOAD;
}
}
/**
* @see Extractor#read(ExtractorInput, PositionHolder)
*/
abstract int read(ExtractorInput input, PositionHolder seekPosition)
throws IOException, InterruptedException;
final int read(ExtractorInput input, PositionHolder seekPosition)
throws IOException, InterruptedException {
switch (state) {
case STATE_READ_HEADERS:
return readHeaders(input);
case STATE_READ_PAYLOAD:
return readPayload(input, seekPosition);
default:
// Never happens.
throw new IllegalStateException();
}
}
private int readHeaders(ExtractorInput input)
throws IOException, InterruptedException {
boolean readingHeaders = true;
while (readingHeaders) {
if (!oggPacket.populate(input)) {
state = STATE_END_OF_INPUT;
return Extractor.RESULT_END_OF_INPUT;
}
lengthOfReadPacket = input.getPosition() - payloadStartPosition;
readingHeaders = readHeaders(oggPacket.getPayload(), payloadStartPosition, setupData);
if (readingHeaders) {
payloadStartPosition = input.getPosition();
}
}
sampleRate = setupData.format.sampleRate;
trackOutput.format(setupData.format);
if (setupData.oggSeeker != null) {
oggSeeker = setupData.oggSeeker;
} else if (input.getLength() == C.LENGTH_UNBOUNDED) {
oggSeeker = new UnseekableOggSeeker();
} else {
oggSeeker = new DefaultOggSeeker(payloadStartPosition, input.getLength(), this);
}
setupData = null;
state = STATE_READ_PAYLOAD;
return Extractor.RESULT_CONTINUE;
}
private int readPayload(ExtractorInput input, PositionHolder seekPosition)
throws IOException, InterruptedException {
long position = oggSeeker.read(input);
if (position >= 0) {
seekPosition.position = position;
return Extractor.RESULT_SEEK;
} else if (position < -1) {
onSeekEnd(-position - 2);
}
if (!seekMapSet) {
SeekMap seekMap = oggSeeker.createSeekMap();
extractorOutput.seekMap(seekMap);
seekMapSet = true;
}
if (lengthOfReadPacket > 0 || oggPacket.populate(input)) {
lengthOfReadPacket = 0;
ParsableByteArray payload = oggPacket.getPayload();
long granulesInPacket = preparePayload(payload);
if (granulesInPacket >= 0 && currentGranule + granulesInPacket >= targetGranule) {
// calculate time and send payload data to codec
long timeUs = convertGranuleToTime(currentGranule);
trackOutput.sampleData(payload, payload.limit());
trackOutput.sampleMetadata(timeUs, C.BUFFER_FLAG_KEY_FRAME, payload.limit(), 0, null);
targetGranule = -1;
}
currentGranule += granulesInPacket;
} else {
state = STATE_END_OF_INPUT;
return Extractor.RESULT_END_OF_INPUT;
}
return Extractor.RESULT_CONTINUE;
}
/**
* Converts granule value to time.
*
* @param granule
* granule value.
* @return Returns time in milliseconds.
*/
protected long convertGranuleToTime(long granule) {
return (granule * C.MICROS_PER_SECOND) / sampleRate;
}
/**
* Converts time value to granule.
*
* @param timeUs
* Time in milliseconds.
* @return Granule value.
*/
protected long convertTimeToGranule(long timeUs) {
return (sampleRate * timeUs) / C.MICROS_PER_SECOND;
}
/**
* Prepares payload data in the packet for submitting to TrackOutput and returns number of
* granules in the packet.
*
* @param packet
* Ogg payload data packet
* @return Number of granules in the packet or -1 if the packet doesn't contain payload data.
*/
protected abstract long preparePayload(ParsableByteArray packet);
/**
* Checks if the given packet is a header packet and reads it.
*
* @param packet An ogg packet.
* @param position Position of the given header packet.
* @param setupData Setup data to be filled.
* @return Return true if the packet contains header data.
*/
protected abstract boolean readHeaders(ParsableByteArray packet, long position,
SetupData setupData) throws IOException, InterruptedException;
/**
* Called on end of seeking.
*
* @param currentGranule Current granule at the current position of input.
*/
protected void onSeekEnd(long currentGranule) {
this.currentGranule = currentGranule;
}
private class UnseekableOggSeeker implements OggSeeker {
@Override
public long read(ExtractorInput input) throws IOException, InterruptedException {
return -1;
}
@Override
public long startSeek() {
return 0;
}
@Override
public SeekMap createSeekMap() {
return new SeekMap.Unseekable(C.UNSET_TIME_US);
}
}
}
library/src/main/java/com/google/android/exoplayer/util/FlacSeekTable.java deleted 100644 → 0
/*
* Copyright (C) 2016 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.util;
import com.google.android.exoplayer.extractor.SeekMap;
/**
* FLAC seek table class
*/
public final class FlacSeekTable {
private static final int METADATA_LENGTH_OFFSET = 1;
private static final int SEEK_POINT_SIZE = 18;
private final long[] sampleNumbers;
private final long[] offsets;
/**
* Parses a FLAC file seek table metadata structure and creates a FlacSeekTable instance.
*
* @param data A ParsableByteArray including whole seek table metadata block. Its position should
* be set to the beginning of the block.
* @return A FlacSeekTable instance keeping seek table data
* @see <a href="https://xiph.org/flac/format.html#metadata_block_seektable">FLAC format
* METADATA_BLOCK_SEEKTABLE</a>
*/
public static FlacSeekTable parseSeekTable(ParsableByteArray data) {
data.skipBytes(METADATA_LENGTH_OFFSET);
int length = data.readUnsignedInt24();
int numberOfSeekPoints = length / SEEK_POINT_SIZE;
long[] sampleNumbers = new long[numberOfSeekPoints];
long[] offsets = new long[numberOfSeekPoints];
for (int i = 0; i < numberOfSeekPoints; i++) {
sampleNumbers[i] = data.readLong();
offsets[i] = data.readLong();
data.skipBytes(2); // Skip "Number of samples in the target frame."
}
return new FlacSeekTable(sampleNumbers, offsets);
}
private FlacSeekTable(long[] sampleNumbers, long[] offsets) {
this.sampleNumbers = sampleNumbers;
this.offsets = offsets;
}
/**
* Creates a {@link SeekMap} wrapper for this FlacSeekTable.
*
* @param firstFrameOffset Offset of the first FLAC frame
* @param sampleRate Sample rate of the FLAC file.
* @return A SeekMap wrapper for this FlacSeekTable.
*/
public SeekMap createSeekMap(final long firstFrameOffset, final long sampleRate,
final long durationUs) {
return new SeekMap() {
@Override
public boolean isSeekable() {
return true;
}
@Override
public long getPosition(long timeUs) {
long sample = (timeUs * sampleRate) / 1000000L;
int index = Util.binarySearchFloor(sampleNumbers, sample, true, true);
return firstFrameOffset + offsets[index];
}
@Override
public long getDurationUs() {
return durationUs;
}
};
}
}
library/src/main/java/com/google/android/exoplayer/util/FlacUtil.java deleted 100644 → 0
/*
* Copyright (C) 2016 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.util;
/**
* Utility functions for FLAC
*/
public final class FlacUtil {
private static final int FRAME_HEADER_SAMPLE_NUMBER_OFFSET = 4;
/**
* Prevents initialization.
*/
private FlacUtil() {}
/**
* Extracts sample timestamp from the given binary FLAC frame header data structure.
*
* @param streamInfo A {@link FlacStreamInfo} instance
* @param frameData A {@link ParsableByteArray} including binary FLAC frame header data structure.
* Its position should be set to the beginning of the structure.
* @return Sample timestamp
* @see <a href="https://xiph.org/flac/format.html#frame_header">FLAC format FRAME_HEADER</a>
*/
public static long extractSampleTimestamp(FlacStreamInfo streamInfo,
ParsableByteArray frameData) {
frameData.skipBytes(FRAME_HEADER_SAMPLE_NUMBER_OFFSET);
long sampleNumber = frameData.readUtf8EncodedLong();
if (streamInfo.minBlockSize == streamInfo.maxBlockSize) {
// if fixed block size then sampleNumber is frame number
sampleNumber *= streamInfo.minBlockSize;
}
return (sampleNumber * 1000000L) / streamInfo.sampleRate;
}
}
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