com.google.android.exoplayer.upstream.DataSpec

Here are the examples of the java api class com.google.android.exoplayer.upstream.DataSpec taken from open source projects.

1. SmoothStreamingChunkSource#newMediaChunk()

Project: ExoPlayer
File: SmoothStreamingChunkSource.java
private static MediaChunk newMediaChunk(Format formatInfo, Uri uri, String cacheKey, ChunkExtractorWrapper extractorWrapper, DrmInitData drmInitData, DataSource dataSource, int chunkIndex, long chunkStartTimeUs, long chunkEndTimeUs, int trigger, MediaFormat mediaFormat, int adaptiveMaxWidth, int adaptiveMaxHeight) {
    long offset = 0;
    DataSpec dataSpec = new DataSpec(uri, offset, -1, cacheKey);
    // To convert them the absolute timestamps, we need to set sampleOffsetUs to -chunkStartTimeUs.
    return new ContainerMediaChunk(dataSource, dataSpec, trigger, formatInfo, chunkStartTimeUs, chunkEndTimeUs, chunkIndex, chunkStartTimeUs, extractorWrapper, mediaFormat, adaptiveMaxWidth, adaptiveMaxHeight, drmInitData, true, Chunk.NO_PARENT_ID);
}

2. DashChunkSource#newMediaChunk()

Project: ExoPlayer
File: DashChunkSource.java
protected Chunk newMediaChunk(PeriodHolder periodHolder, RepresentationHolder representationHolder, DataSource dataSource, MediaFormat mediaFormat, ExposedTrack enabledTrack, int segmentNum, int trigger) {
    Representation representation = representationHolder.representation;
    Format format = representation.format;
    long startTimeUs = representationHolder.getSegmentStartTimeUs(segmentNum);
    long endTimeUs = representationHolder.getSegmentEndTimeUs(segmentNum);
    RangedUri segmentUri = representationHolder.getSegmentUrl(segmentNum);
    DataSpec dataSpec = new DataSpec(segmentUri.getUri(), segmentUri.start, segmentUri.length, representation.getCacheKey());
    long sampleOffsetUs = periodHolder.startTimeUs - representation.presentationTimeOffsetUs;
    if (mimeTypeIsRawText(format.mimeType)) {
        return new SingleSampleMediaChunk(dataSource, dataSpec, Chunk.TRIGGER_INITIAL, format, startTimeUs, endTimeUs, segmentNum, enabledTrack.trackFormat, null, periodHolder.localIndex);
    } else {
        boolean isMediaFormatFinal = (mediaFormat != null);
        return new ContainerMediaChunk(dataSource, dataSpec, trigger, format, startTimeUs, endTimeUs, segmentNum, sampleOffsetUs, representationHolder.extractorWrapper, mediaFormat, enabledTrack.adaptiveMaxWidth, enabledTrack.adaptiveMaxHeight, periodHolder.drmInitData, isMediaFormatFinal, periodHolder.localIndex);
    }
}

3. DashChunkSource#newInitializationChunk()

Project: ExoPlayer
File: DashChunkSource.java
private Chunk newInitializationChunk(RangedUri initializationUri, RangedUri indexUri, Representation representation, ChunkExtractorWrapper extractor, DataSource dataSource, int manifestIndex, int trigger) {
    RangedUri requestUri;
    if (initializationUri != null) {
        // It's common for initialization and index data to be stored adjacently. Attempt to merge
        // the two requests together to request both at once.
        requestUri = initializationUri.attemptMerge(indexUri);
        if (requestUri == null) {
            requestUri = initializationUri;
        }
    } else {
        requestUri = indexUri;
    }
    DataSpec dataSpec = new DataSpec(requestUri.getUri(), requestUri.start, requestUri.length, representation.getCacheKey());
    return new InitializationChunk(dataSource, dataSpec, trigger, representation.format, extractor, manifestIndex);
}

4. SingleSampleMediaChunk#load()

Project: ExoPlayer
File: SingleSampleMediaChunk.java
@SuppressWarnings("NonAtomicVolatileUpdate")
@Override
public void load() throws IOException, InterruptedException {
    DataSpec loadDataSpec = Util.getRemainderDataSpec(dataSpec, bytesLoaded);
    try {
        // Create and open the input.
        dataSource.open(loadDataSpec);
        // Load the sample data.
        int result = 0;
        while (result != C.RESULT_END_OF_INPUT) {
            bytesLoaded += result;
            result = getOutput().sampleData(dataSource, Integer.MAX_VALUE, true);
        }
        int sampleSize = bytesLoaded;
        getOutput().sampleMetadata(startTimeUs, C.SAMPLE_FLAG_SYNC, sampleSize, 0, null);
    } finally {
        dataSource.close();
    }
}

5. InitializationChunk#load()

Project: ExoPlayer
File: InitializationChunk.java
@SuppressWarnings("NonAtomicVolatileUpdate")
@Override
public void load() throws IOException, InterruptedException {
    DataSpec loadDataSpec = Util.getRemainderDataSpec(dataSpec, bytesLoaded);
    try {
        // Create and open the input.
        ExtractorInput input = new DefaultExtractorInput(dataSource, loadDataSpec.absoluteStreamPosition, dataSource.open(loadDataSpec));
        if (bytesLoaded == 0) {
            // Set the target to ourselves.
            extractorWrapper.init(this);
        }
        // Load and parse the initialization data.
        try {
            int result = Extractor.RESULT_CONTINUE;
            while (result == Extractor.RESULT_CONTINUE && !loadCanceled) {
                result = extractorWrapper.read(input);
            }
        } finally {
            bytesLoaded = (int) (input.getPosition() - dataSpec.absoluteStreamPosition);
        }
    } finally {
        dataSource.close();
    }
}

6. ContainerMediaChunk#load()

Project: ExoPlayer
File: ContainerMediaChunk.java
@SuppressWarnings("NonAtomicVolatileUpdate")
@Override
public final void load() throws IOException, InterruptedException {
    DataSpec loadDataSpec = Util.getRemainderDataSpec(dataSpec, bytesLoaded);
    try {
        // Create and open the input.
        ExtractorInput input = new DefaultExtractorInput(dataSource, loadDataSpec.absoluteStreamPosition, dataSource.open(loadDataSpec));
        if (bytesLoaded == 0) {
            // Set the target to ourselves.
            extractorWrapper.init(this);
        }
        // Load and parse the sample data.
        try {
            int result = Extractor.RESULT_CONTINUE;
            while (result == Extractor.RESULT_CONTINUE && !loadCanceled) {
                result = extractorWrapper.read(input);
            }
        } finally {
            bytesLoaded = (int) (input.getPosition() - dataSpec.absoluteStreamPosition);
        }
    } finally {
        dataSource.close();
    }
}

7. CacheDataSource#openNextSource()

Project: ExoPlayer
File: CacheDataSource.java
/**
   * Opens the next source. If the cache contains data spanning the current read position then
   * {@link #cacheReadDataSource} is opened to read from it. Else {@link #upstreamDataSource} is
   * opened to read from the upstream source and write into the cache.
   */
private void openNextSource() throws IOException {
    DataSpec dataSpec;
    CacheSpan span;
    if (ignoreCache) {
        span = null;
    } else if (bytesRemaining == C.LENGTH_UNBOUNDED) {
        // TODO: Support caching for unbounded requests. This requires storing the source length
        // into the cache (the simplest approach is to incorporate it into each cache file's name).
        Log.w(TAG, "Cache bypassed due to unbounded length.");
        span = null;
    } else if (blockOnCache) {
        try {
            span = cache.startReadWrite(key, readPosition);
        } catch (InterruptedException e) {
            throw new InterruptedIOException();
        }
    } else {
        span = cache.startReadWriteNonBlocking(key, readPosition);
    }
    if (span == null) {
        // The data is locked in the cache, or we're ignoring the cache. Bypass the cache and read
        // from upstream.
        currentDataSource = upstreamDataSource;
        dataSpec = new DataSpec(uri, readPosition, bytesRemaining, key, flags);
    } else if (span.isCached) {
        // Data is cached, read from cache.
        Uri fileUri = Uri.fromFile(span.file);
        long filePosition = readPosition - span.position;
        long length = Math.min(span.length - filePosition, bytesRemaining);
        dataSpec = new DataSpec(fileUri, readPosition, filePosition, length, key, flags);
        currentDataSource = cacheReadDataSource;
    } else {
        // Data is not cached, and data is not locked, read from upstream with cache backing.
        lockedSpan = span;
        long length = span.isOpenEnded() ? bytesRemaining : Math.min(span.length, bytesRemaining);
        dataSpec = new DataSpec(uri, readPosition, length, key, flags);
        currentDataSource = cacheWriteDataSource != null ? cacheWriteDataSource : upstreamDataSource;
    }
    currentDataSource.open(dataSpec);
}

8. TsChunk#load()

Project: ExoPlayer
File: TsChunk.java
@Override
public void load() throws IOException, InterruptedException {
    // If we previously fed part of this chunk to the extractor, we need to skip it this time. For
    // encrypted content we need to skip the data by reading it through the source, so as to ensure
    // correct decryption of the remainder of the chunk. For clear content, we can request the
    // remainder of the chunk directly.
    DataSpec loadDataSpec;
    boolean skipLoadedBytes;
    if (isEncrypted) {
        loadDataSpec = dataSpec;
        skipLoadedBytes = bytesLoaded != 0;
    } else {
        loadDataSpec = Util.getRemainderDataSpec(dataSpec, bytesLoaded);
        skipLoadedBytes = false;
    }
    try {
        ExtractorInput input = new DefaultExtractorInput(dataSource, loadDataSpec.absoluteStreamPosition, dataSource.open(loadDataSpec));
        if (skipLoadedBytes) {
            input.skipFully(bytesLoaded);
        }
        try {
            int result = Extractor.RESULT_CONTINUE;
            while (result == Extractor.RESULT_CONTINUE && !loadCanceled) {
                result = extractorWrapper.read(input);
            }
        } finally {
            bytesLoaded = (int) (input.getPosition() - dataSpec.absoluteStreamPosition);
        }
    } finally {
        dataSource.close();
    }
}

9. HlsChunkSource#newEncryptionKeyChunk()

Project: ExoPlayer
File: HlsChunkSource.java
private EncryptionKeyChunk newEncryptionKeyChunk(Uri keyUri, String iv, int variantIndex) {
    DataSpec dataSpec = new DataSpec(keyUri, 0, C.LENGTH_UNBOUNDED, null, DataSpec.FLAG_ALLOW_GZIP);
    return new EncryptionKeyChunk(dataSource, dataSpec, scratchSpace, iv, variantIndex);
}

10. HlsChunkSource#newMediaPlaylistChunk()

Project: ExoPlayer
File: HlsChunkSource.java
private MediaPlaylistChunk newMediaPlaylistChunk(int variantIndex) {
    Uri mediaPlaylistUri = UriUtil.resolveToUri(baseUri, variants[variantIndex].url);
    DataSpec dataSpec = new DataSpec(mediaPlaylistUri, 0, C.LENGTH_UNBOUNDED, null, DataSpec.FLAG_ALLOW_GZIP);
    return new MediaPlaylistChunk(dataSource, dataSpec, scratchSpace, playlistParser, variantIndex, mediaPlaylistUri.toString());
}