stagefright: Remove unused TimedTextDriver and Sources (0e449bc8) · Commits · e / os / android_frameworks_av

include/media/stagefright/timedtext/TimedTextDriver.h

deleted100644 → 0

+0 −104

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 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.
		*/

		#ifndef TIMED_TEXT_DRIVER_H_
		#define TIMED_TEXT_DRIVER_H_

		#include <media/IMediaSource.h>
		#include <media/stagefright/foundation/ABase.h> // for DISALLOW_* macro
		#include <utils/Errors.h> // for status_t
		#include <utils/RefBase.h>
		#include <utils/threads.h>

		namespace android {

		struct ALooper;
		struct IMediaHTTPService;
		class MediaPlayerBase;
		class Parcel;
		class TimedTextPlayer;
		class TimedTextSource;
		class DataSource;

		class TimedTextDriver {
		public:
		TimedTextDriver(
		const wp<MediaPlayerBase> &listener,
		const sp<IMediaHTTPService> &httpService);

		~TimedTextDriver();

		status_t start();
		status_t pause();
		status_t selectTrack(size_t index);
		status_t unselectTrack(size_t index);

		status_t seekToAsync(int64_t timeUs);

		status_t addInBandTextSource(
		size_t trackIndex, const sp<IMediaSource>& source);

		status_t addOutOfBandTextSource(
		size_t trackIndex, const char uri, const char mimeType);

		// Caller owns the file desriptor and caller is responsible for closing it.
		status_t addOutOfBandTextSource(
		size_t trackIndex, int fd, off64_t offset,
		off64_t length, const char *mimeType);

		void getExternalTrackInfo(Parcel *parcel);
		size_t countExternalTracks() const;

		private:
		Mutex mLock;

		enum State {
		UNINITIALIZED,
		PREPARED,
		PLAYING,
		PAUSED,
		};

		enum TextSourceType {
		TEXT_SOURCE_TYPE_IN_BAND = 0,
		TEXT_SOURCE_TYPE_OUT_OF_BAND,
		};

		sp<ALooper> mLooper;
		sp<TimedTextPlayer> mPlayer;
		wp<MediaPlayerBase> mListener;
		sp<IMediaHTTPService> mHTTPService;

		// Variables to be guarded by mLock.
		State mState;
		size_t mCurrentTrackIndex;
		KeyedVector<size_t, sp<TimedTextSource> > mTextSourceVector;
		Vector<TextSourceType> mTextSourceTypeVector;

		// -- End of variables to be guarded by mLock

		status_t selectTrack_l(size_t index);

		status_t createOutOfBandTextSource(
		size_t trackIndex, const char* mimeType,
		const sp<DataSource>& dataSource);

		DISALLOW_EVIL_CONSTRUCTORS(TimedTextDriver);
		};

		} // namespace android

		#endif // TIMED_TEXT_DRIVER_H_

media/libstagefright/timedtext/Android.mk

+0 −5

Original line number	Diff line number	Diff line
		@@ -3,11 +3,6 @@ include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		TextDescriptions.cpp \
		TimedTextDriver.cpp \
		TimedText3GPPSource.cpp \
		TimedTextSource.cpp \
		TimedTextSRTSource.cpp \
		TimedTextPlayer.cpp

		LOCAL_CFLAGS += -Wno-multichar -Werror -Wall
		LOCAL_CLANG := true

media/libstagefright/timedtext/TimedText3GPPSource.cpp

deleted100644 → 0

+0 −119

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 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.
		*/

		//#define LOG_NDEBUG 0
		#define LOG_TAG "TimedText3GPPSource"
		#include <utils/Log.h>

		#include <binder/Parcel.h>
		#include <media/stagefright/foundation/ADebug.h> // CHECK_XX macro
		#include <media/stagefright/MediaBuffer.h>
		#include <media/stagefright/MediaDefs.h> // for MEDIA_MIMETYPE_xxx
		#include <media/stagefright/MediaErrors.h>
		#include <media/stagefright/MediaSource.h>
		#include <media/stagefright/MetaData.h>

		#include "TimedText3GPPSource.h"
		#include "TextDescriptions.h"

		namespace android {

		TimedText3GPPSource::TimedText3GPPSource(const sp<IMediaSource>& mediaSource)
		: mSource(mediaSource) {
		}

		TimedText3GPPSource::~TimedText3GPPSource() {
		}

		status_t TimedText3GPPSource::read(
		int64_t startTimeUs, int64_t endTimeUs, Parcel *parcel,
		const MediaSource::ReadOptions *options) {
		MediaBuffer *textBuffer = NULL;
		status_t err = mSource->read(&textBuffer, options);
		if (err != OK) {
		return err;
		}
		CHECK(textBuffer != NULL);
		textBuffer->meta_data()->findInt64(kKeyTime, startTimeUs);
		CHECK_GE(*startTimeUs, 0);
		extractAndAppendLocalDescriptions(*startTimeUs, textBuffer, parcel);
		textBuffer->release();
		// endTimeUs is a dummy parameter for 3gpp timed text format.
		// Set a negative value to it to mark it is unavailable.
		*endTimeUs = -1;
		return OK;
		}

		// Each text sample consists of a string of text, optionally with sample
		// modifier description. The modifier description could specify a new
		// text style for the string of text. These descriptions are present only
		// if they are needed. This method is used to extract the modifier
		// description and append it at the end of the text.
		status_t TimedText3GPPSource::extractAndAppendLocalDescriptions(
		int64_t timeUs, const MediaBuffer textBuffer, Parcel parcel) {
		const void *data;
		size_t size = 0;
		int32_t flag = TextDescriptions::LOCAL_DESCRIPTIONS;

		const char *mime;
		CHECK(mSource->getFormat()->findCString(kKeyMIMEType, &mime));
		CHECK(strcasecmp(mime, MEDIA_MIMETYPE_TEXT_3GPP) == 0);

		data = textBuffer->data();
		size = textBuffer->size();

		if (size > 0) {
		parcel->freeData();
		flag \|= TextDescriptions::IN_BAND_TEXT_3GPP;
		return TextDescriptions::getParcelOfDescriptions(
		(const uint8_t *)data, size, flag, timeUs / 1000, parcel);
		}
		return OK;
		}

		// To extract and send the global text descriptions for all the text samples
		// in the text track or text file.
		// TODO: send error message to application via notifyListener()...?
		status_t TimedText3GPPSource::extractGlobalDescriptions(Parcel *parcel) {
		const void *data;
		size_t size = 0;
		int32_t flag = TextDescriptions::GLOBAL_DESCRIPTIONS;

		const char *mime;
		CHECK(mSource->getFormat()->findCString(kKeyMIMEType, &mime));
		CHECK(strcasecmp(mime, MEDIA_MIMETYPE_TEXT_3GPP) == 0);

		uint32_t type;
		// get the 'tx3g' box content. This box contains the text descriptions
		// used to render the text track
		if (!mSource->getFormat()->findData(
		kKeyTextFormatData, &type, &data, &size)) {
		return ERROR_MALFORMED;
		}

		if (size > 0) {
		flag \|= TextDescriptions::IN_BAND_TEXT_3GPP;
		return TextDescriptions::getParcelOfDescriptions(
		(const uint8_t *)data, size, flag, 0, parcel);
		}
		return OK;
		}

		sp<MetaData> TimedText3GPPSource::getFormat() {
		return mSource->getFormat();
		}

		} // namespace android

media/libstagefright/timedtext/TimedText3GPPSource.h

deleted100644 → 0

+0 −57

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 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.
		*/

		#ifndef TIMED_TEXT_3GPP_SOURCE_H_
		#define TIMED_TEXT_3GPP_SOURCE_H_

		#include <media/stagefright/MediaErrors.h>
		#include <media/stagefright/MediaSource.h>

		#include "TimedTextSource.h"

		namespace android {

		class MediaBuffer;
		class Parcel;

		class TimedText3GPPSource : public TimedTextSource {
		public:
		TimedText3GPPSource(const sp<IMediaSource>& mediaSource);
		virtual status_t start() { return mSource->start(); }
		virtual status_t stop() { return mSource->stop(); }
		virtual status_t read(
		int64_t *startTimeUs,
		int64_t *endTimeUs,
		Parcel *parcel,
		const MediaSource::ReadOptions *options = NULL);
		virtual status_t extractGlobalDescriptions(Parcel *parcel);
		virtual sp<MetaData> getFormat();

		protected:
		virtual ~TimedText3GPPSource();

		private:
		sp<IMediaSource> mSource;

		status_t extractAndAppendLocalDescriptions(
		int64_t timeUs, const MediaBuffer textBuffer, Parcel parcel);

		DISALLOW_EVIL_CONSTRUCTORS(TimedText3GPPSource);
		};

		} // namespace android

		#endif // TIMED_TEXT_3GPP_SOURCE_H_

media/libstagefright/timedtext/TimedTextDriver.cpp

deleted100644 → 0

+0 −287

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 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.
		*/

		//#define LOG_NDEBUG 0
		#define LOG_TAG "TimedTextDriver"
		#include <utils/Log.h>

		#include <binder/IPCThreadState.h>

		#include <media/IMediaHTTPService.h>
		#include <media/mediaplayer.h>
		#include <media/MediaPlayerInterface.h>
		#include <media/stagefright/DataSource.h>
		#include <media/stagefright/FileSource.h>
		#include <media/stagefright/MediaDefs.h>
		#include <media/stagefright/MediaErrors.h>
		#include <media/stagefright/MediaSource.h>
		#include <media/stagefright/MetaData.h>
		#include <media/stagefright/Utils.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/foundation/ALooper.h>
		#include <media/stagefright/timedtext/TimedTextDriver.h>

		#include "TextDescriptions.h"
		#include "TimedTextPlayer.h"
		#include "TimedTextSource.h"

		namespace android {

		TimedTextDriver::TimedTextDriver(
		const wp<MediaPlayerBase> &listener,
		const sp<IMediaHTTPService> &httpService)
		: mLooper(new ALooper),
		mListener(listener),
		mHTTPService(httpService),
		mState(UNINITIALIZED),
		mCurrentTrackIndex(UINT_MAX) {
		mLooper->setName("TimedTextDriver");
		mLooper->start();
		mPlayer = new TimedTextPlayer(listener);
		mLooper->registerHandler(mPlayer);
		}

		TimedTextDriver::~TimedTextDriver() {
		mTextSourceVector.clear();
		mTextSourceTypeVector.clear();
		mLooper->stop();
		}

		status_t TimedTextDriver::selectTrack_l(size_t index) {
		if (mCurrentTrackIndex == index) {
		return OK;
		}
		sp<TimedTextSource> source;
		source = mTextSourceVector.valueFor(index);
		mPlayer->setDataSource(source);
		if (mState == UNINITIALIZED) {
		mState = PREPARED;
		}
		mCurrentTrackIndex = index;
		return OK;
		}

		status_t TimedTextDriver::start() {
		Mutex::Autolock autoLock(mLock);
		switch (mState) {
		case UNINITIALIZED:
		return INVALID_OPERATION;
		case PLAYING:
		return OK;
		case PREPARED:
		mPlayer->start();
		mState = PLAYING;
		return OK;
		case PAUSED:
		mPlayer->resume();
		mState = PLAYING;
		return OK;
		default:
		TRESPASS();
		}
		return UNKNOWN_ERROR;
		}

		status_t TimedTextDriver::pause() {
		Mutex::Autolock autoLock(mLock);
		ALOGV("%s() is called", __FUNCTION__);
		switch (mState) {
		case UNINITIALIZED:
		return INVALID_OPERATION;
		case PLAYING:
		mPlayer->pause();
		mState = PAUSED;
		return OK;
		case PREPARED:
		return INVALID_OPERATION;
		case PAUSED:
		return OK;
		default:
		TRESPASS();
		}
		return UNKNOWN_ERROR;
		}

		status_t TimedTextDriver::selectTrack(size_t index) {
		status_t ret = OK;
		Mutex::Autolock autoLock(mLock);
		ALOGV("%s() is called", __FUNCTION__);
		switch (mState) {
		case UNINITIALIZED:
		case PREPARED:
		case PAUSED:
		ret = selectTrack_l(index);
		break;
		case PLAYING:
		mPlayer->pause();
		ret = selectTrack_l(index);
		if (ret != OK) {
		break;
		}
		mPlayer->start();
		break;
		default:
		TRESPASS();
		}
		return ret;
		}

		status_t TimedTextDriver::unselectTrack(size_t index) {
		Mutex::Autolock autoLock(mLock);
		ALOGV("%s() is called", __FUNCTION__);
		if (mCurrentTrackIndex != index) {
		return INVALID_OPERATION;
		}
		mCurrentTrackIndex = UINT_MAX;
		switch (mState) {
		case UNINITIALIZED:
		return INVALID_OPERATION;
		case PLAYING:
		mPlayer->setDataSource(NULL);
		mState = UNINITIALIZED;
		return OK;
		case PREPARED:
		case PAUSED:
		mState = UNINITIALIZED;
		return OK;
		default:
		TRESPASS();
		}
		return UNKNOWN_ERROR;
		}

		status_t TimedTextDriver::seekToAsync(int64_t timeUs) {
		Mutex::Autolock autoLock(mLock);
		ALOGV("%s() is called", __FUNCTION__);
		switch (mState) {
		case UNINITIALIZED:
		return INVALID_OPERATION;
		case PREPARED:
		mPlayer->seekToAsync(timeUs);
		mPlayer->pause();
		mState = PAUSED;
		return OK;
		case PAUSED:
		mPlayer->seekToAsync(timeUs);
		mPlayer->pause();
		return OK;
		case PLAYING:
		mPlayer->seekToAsync(timeUs);
		return OK;
		default:
		TRESPASS();
		}
		return UNKNOWN_ERROR;
		}

		status_t TimedTextDriver::addInBandTextSource(
		size_t trackIndex, const sp<IMediaSource>& mediaSource) {
		sp<TimedTextSource> source =
		TimedTextSource::CreateTimedTextSource(mediaSource);
		if (source == NULL) {
		return ERROR_UNSUPPORTED;
		}
		Mutex::Autolock autoLock(mLock);
		mTextSourceVector.add(trackIndex, source);
		mTextSourceTypeVector.add(TEXT_SOURCE_TYPE_IN_BAND);
		return OK;
		}

		status_t TimedTextDriver::addOutOfBandTextSource(
		size_t trackIndex, const char uri, const char mimeType) {

		// To support local subtitle file only for now
		if (strncasecmp("file://", uri, 7)) {
		ALOGE("uri('%s') is not a file", uri);
		return ERROR_UNSUPPORTED;
		}

		sp<DataSource> dataSource =
		DataSource::CreateFromURI(mHTTPService, uri);
		return createOutOfBandTextSource(trackIndex, mimeType, dataSource);
		}

		status_t TimedTextDriver::addOutOfBandTextSource(
		size_t trackIndex, int fd, off64_t offset, off64_t length, const char *mimeType) {

		if (fd < 0) {
		ALOGE("Invalid file descriptor: %d", fd);
		return ERROR_UNSUPPORTED;
		}

		sp<DataSource> dataSource = new FileSource(dup(fd), offset, length);
		return createOutOfBandTextSource(trackIndex, mimeType, dataSource);
		}

		status_t TimedTextDriver::createOutOfBandTextSource(
		size_t trackIndex,
		const char *mimeType,
		const sp<DataSource>& dataSource) {

		if (dataSource == NULL) {
		return ERROR_UNSUPPORTED;
		}

		sp<TimedTextSource> source;
		if (strcasecmp(mimeType, MEDIA_MIMETYPE_TEXT_SUBRIP) == 0) {
		source = TimedTextSource::CreateTimedTextSource(
		dataSource, TimedTextSource::OUT_OF_BAND_FILE_SRT);
		}

		if (source == NULL) {
		ALOGE("Failed to create timed text source");
		return ERROR_UNSUPPORTED;
		}

		Mutex::Autolock autoLock(mLock);
		mTextSourceVector.add(trackIndex, source);
		mTextSourceTypeVector.add(TEXT_SOURCE_TYPE_OUT_OF_BAND);
		return OK;
		}

		size_t TimedTextDriver::countExternalTracks() const {
		size_t nTracks = 0;
		for (size_t i = 0, n = mTextSourceTypeVector.size(); i < n; ++i) {
		if (mTextSourceTypeVector[i] == TEXT_SOURCE_TYPE_OUT_OF_BAND) {
		++nTracks;
		}
		}
		return nTracks;
		}

		void TimedTextDriver::getExternalTrackInfo(Parcel *parcel) {
		Mutex::Autolock autoLock(mLock);
		for (size_t i = 0, n = mTextSourceTypeVector.size(); i < n; ++i) {
		if (mTextSourceTypeVector[i] == TEXT_SOURCE_TYPE_IN_BAND) {
		continue;
		}

		sp<MetaData> meta = mTextSourceVector.valueAt(i)->getFormat();

		// There are two fields.
		parcel->writeInt32(2);

		// track type.
		parcel->writeInt32(MEDIA_TRACK_TYPE_TIMEDTEXT);
		const char *lang = "und";
		if (meta != NULL) {
		meta->findCString(kKeyMediaLanguage, &lang);
		}
		parcel->writeString16(String16(lang));
		}
		}

		} // namespace android