HLSCustom: Copying KK-mr2 files from httplive to httplivecustom (0778792e) · Commits · e / os / android_frameworks_av

media/libmediaplayerservice/nuplayer/HTTPLiveSourceCustom.cpp

0 → 100644

+283 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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 "HTTPLiveSource"
		#include <utils/Log.h>

		#include "HTTPLiveSource.h"

		#include "AnotherPacketSource.h"
		#include "LiveDataSource.h"
		#include "LiveSession.h"

		#include <media/IMediaHTTPService.h>
		#include <media/stagefright/foundation/ABuffer.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/foundation/AMessage.h>
		#include <media/stagefright/MediaErrors.h>
		#include <media/stagefright/MetaData.h>

		namespace android {

		NuPlayer::HTTPLiveSource::HTTPLiveSource(
		const sp<AMessage> &notify,
		const sp<IMediaHTTPService> &httpService,
		const char *url,
		const KeyedVector<String8, String8> *headers)
		: Source(notify),
		mHTTPService(httpService),
		mURL(url),
		mFlags(0),
		mFinalResult(OK),
		mOffset(0),
		mFetchSubtitleDataGeneration(0) {
		if (headers) {
		mExtraHeaders = *headers;

		ssize_t index =
		mExtraHeaders.indexOfKey(String8("x-hide-urls-from-log"));

		if (index >= 0) {
		mFlags \|= kFlagIncognito;

		mExtraHeaders.removeItemsAt(index);
		}
		}
		}

		NuPlayer::HTTPLiveSource::~HTTPLiveSource() {
		if (mLiveSession != NULL) {
		mLiveSession->disconnect();

		mLiveLooper->unregisterHandler(mLiveSession->id());
		mLiveLooper->unregisterHandler(id());
		mLiveLooper->stop();

		mLiveSession.clear();
		mLiveLooper.clear();
		}
		}

		void NuPlayer::HTTPLiveSource::prepareAsync() {
		if (mLiveLooper == NULL) {
		mLiveLooper = new ALooper;
		mLiveLooper->setName("http live");
		mLiveLooper->start();

		mLiveLooper->registerHandler(this);
		}

		sp<AMessage> notify = new AMessage(kWhatSessionNotify, id());

		mLiveSession = new LiveSession(
		notify,
		(mFlags & kFlagIncognito) ? LiveSession::kFlagIncognito : 0,
		mHTTPService);

		mLiveLooper->registerHandler(mLiveSession);

		mLiveSession->connectAsync(
		mURL.c_str(), mExtraHeaders.isEmpty() ? NULL : &mExtraHeaders);
		}

		void NuPlayer::HTTPLiveSource::start() {
		}

		sp<AMessage> NuPlayer::HTTPLiveSource::getFormat(bool audio) {
		sp<AMessage> format;
		status_t err = mLiveSession->getStreamFormat(
		audio ? LiveSession::STREAMTYPE_AUDIO
		: LiveSession::STREAMTYPE_VIDEO,
		&format);

		if (err != OK) {
		return NULL;
		}

		return format;
		}

		status_t NuPlayer::HTTPLiveSource::feedMoreTSData() {
		return OK;
		}

		status_t NuPlayer::HTTPLiveSource::dequeueAccessUnit(
		bool audio, sp<ABuffer> *accessUnit) {
		return mLiveSession->dequeueAccessUnit(
		audio ? LiveSession::STREAMTYPE_AUDIO
		: LiveSession::STREAMTYPE_VIDEO,
		accessUnit);
		}

		status_t NuPlayer::HTTPLiveSource::getDuration(int64_t *durationUs) {
		return mLiveSession->getDuration(durationUs);
		}

		size_t NuPlayer::HTTPLiveSource::getTrackCount() const {
		return mLiveSession->getTrackCount();
		}

		sp<AMessage> NuPlayer::HTTPLiveSource::getTrackInfo(size_t trackIndex) const {
		return mLiveSession->getTrackInfo(trackIndex);
		}

		status_t NuPlayer::HTTPLiveSource::selectTrack(size_t trackIndex, bool select) {
		status_t err = mLiveSession->selectTrack(trackIndex, select);

		if (err == OK) {
		mFetchSubtitleDataGeneration++;
		if (select) {
		sp<AMessage> msg = new AMessage(kWhatFetchSubtitleData, id());
		msg->setInt32("generation", mFetchSubtitleDataGeneration);
		msg->post();
		}
		}

		// LiveSession::selectTrack returns BAD_VALUE when selecting the currently
		// selected track, or unselecting a non-selected track. In this case it's an
		// no-op so we return OK.
		return (err == OK \|\| err == BAD_VALUE) ? (status_t)OK : err;
		}

		status_t NuPlayer::HTTPLiveSource::seekTo(int64_t seekTimeUs) {
		return mLiveSession->seekTo(seekTimeUs);
		}

		void NuPlayer::HTTPLiveSource::onMessageReceived(const sp<AMessage> &msg) {
		switch (msg->what()) {
		case kWhatSessionNotify:
		{
		onSessionNotify(msg);
		break;
		}

		case kWhatFetchSubtitleData:
		{
		int32_t generation;
		CHECK(msg->findInt32("generation", &generation));

		if (generation != mFetchSubtitleDataGeneration) {
		// stale
		break;
		}

		sp<ABuffer> buffer;
		if (mLiveSession->dequeueAccessUnit(
		LiveSession::STREAMTYPE_SUBTITLES, &buffer) == OK) {
		sp<AMessage> notify = dupNotify();
		notify->setInt32("what", kWhatSubtitleData);
		notify->setBuffer("buffer", buffer);
		notify->post();

		int64_t timeUs, baseUs, durationUs, delayUs;
		CHECK(buffer->meta()->findInt64("baseUs", &baseUs));
		CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
		CHECK(buffer->meta()->findInt64("durationUs", &durationUs));
		delayUs = baseUs + timeUs - ALooper::GetNowUs();

		msg->post(delayUs > 0ll ? delayUs : 0ll);
		} else {
		// try again in 1 second
		msg->post(1000000ll);
		}

		break;
		}

		default:
		Source::onMessageReceived(msg);
		break;
		}
		}

		void NuPlayer::HTTPLiveSource::onSessionNotify(const sp<AMessage> &msg) {
		int32_t what;
		CHECK(msg->findInt32("what", &what));

		switch (what) {
		case LiveSession::kWhatPrepared:
		{
		// notify the current size here if we have it, otherwise report an initial size of (0,0)
		sp<AMessage> format = getFormat(false /* audio */);
		int32_t width;
		int32_t height;
		if (format != NULL &&
		format->findInt32("width", &width) && format->findInt32("height", &height)) {
		notifyVideoSizeChanged(format);
		} else {
		notifyVideoSizeChanged();
		}

		uint32_t flags = FLAG_CAN_PAUSE;
		if (mLiveSession->isSeekable()) {
		flags \|= FLAG_CAN_SEEK;
		flags \|= FLAG_CAN_SEEK_BACKWARD;
		flags \|= FLAG_CAN_SEEK_FORWARD;
		}

		if (mLiveSession->hasDynamicDuration()) {
		flags \|= FLAG_DYNAMIC_DURATION;
		}

		notifyFlagsChanged(flags);

		notifyPrepared();
		break;
		}

		case LiveSession::kWhatPreparationFailed:
		{
		status_t err;
		CHECK(msg->findInt32("err", &err));

		notifyPrepared(err);
		break;
		}

		case LiveSession::kWhatStreamsChanged:
		{
		uint32_t changedMask;
		CHECK(msg->findInt32(
		"changedMask", (int32_t *)&changedMask));

		bool audio = changedMask & LiveSession::STREAMTYPE_AUDIO;
		bool video = changedMask & LiveSession::STREAMTYPE_VIDEO;

		sp<AMessage> reply;
		CHECK(msg->findMessage("reply", &reply));

		sp<AMessage> notify = dupNotify();
		notify->setInt32("what", kWhatQueueDecoderShutdown);
		notify->setInt32("audio", audio);
		notify->setInt32("video", video);
		notify->setMessage("reply", reply);
		notify->post();
		break;
		}

		case LiveSession::kWhatError:
		{
		break;
		}

		default:
		TRESPASS();
		}
		}

		} // namespace android

media/libmediaplayerservice/nuplayer/HTTPLiveSourceCustom.h

0 → 100644

+81 −0

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

		#define HTTP_LIVE_SOURCE_H_

		#include "NuPlayer.h"
		#include "NuPlayerSource.h"

		namespace android {

		struct LiveSession;

		struct NuPlayer::HTTPLiveSource : public NuPlayer::Source {
		HTTPLiveSource(
		const sp<AMessage> &notify,
		const sp<IMediaHTTPService> &httpService,
		const char *url,
		const KeyedVector<String8, String8> *headers);

		virtual void prepareAsync();
		virtual void start();

		virtual status_t dequeueAccessUnit(bool audio, sp<ABuffer> *accessUnit);
		virtual sp<AMessage> getFormat(bool audio);

		virtual status_t feedMoreTSData();
		virtual status_t getDuration(int64_t *durationUs);
		virtual size_t getTrackCount() const;
		virtual sp<AMessage> getTrackInfo(size_t trackIndex) const;
		virtual status_t selectTrack(size_t trackIndex, bool select);
		virtual status_t seekTo(int64_t seekTimeUs);

		protected:
		virtual ~HTTPLiveSource();

		virtual void onMessageReceived(const sp<AMessage> &msg);

		private:
		enum Flags {
		// Don't log any URLs.
		kFlagIncognito = 1,
		};

		enum {
		kWhatSessionNotify,
		kWhatFetchSubtitleData,
		};

		sp<IMediaHTTPService> mHTTPService;
		AString mURL;
		KeyedVector<String8, String8> mExtraHeaders;
		uint32_t mFlags;
		status_t mFinalResult;
		off64_t mOffset;
		sp<ALooper> mLiveLooper;
		sp<LiveSession> mLiveSession;
		int32_t mFetchSubtitleDataGeneration;

		void onSessionNotify(const sp<AMessage> &msg);

		DISALLOW_EVIL_CONSTRUCTORS(HTTPLiveSource);
		};

		} // namespace android

		#endif // HTTP_LIVE_SOURCE_H_

media/libstagefright/httplivecustom/Android.mk

0 → 100644

+31 −0

Original line number	Diff line number	Diff line
		LOCAL_PATH:= $(call my-dir)

		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		LiveDataSource.cpp \
		LiveSession.cpp \
		M3UParser.cpp \
		PlaylistFetcher.cpp \

		LOCAL_C_INCLUDES:= \
		$(TOP)/frameworks/av/media/libstagefright \
		$(TOP)/frameworks/native/include/media/openmax \
		$(TOP)/external/openssl/include

		LOCAL_SHARED_LIBRARIES := \
		libbinder \
		libcrypto \
		libcutils \
		libmedia \
		libstagefright \
		libstagefright_foundation \
		libutils \

		LOCAL_MODULE:= libstagefright_httplive

		ifeq ($(TARGET_ARCH),arm)
		LOCAL_CFLAGS += -Wno-psabi
		endif

		include $(BUILD_SHARED_LIBRARY)

media/libstagefright/httplivecustom/LiveDataSource.cpp

0 → 100644

+173 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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 "LiveDataSource"
		#include <utils/Log.h>

		#include "LiveDataSource.h"

		#include <media/stagefright/foundation/ABuffer.h>
		#include <media/stagefright/foundation/ADebug.h>

		#define SAVE_BACKUP 0

		namespace android {

		LiveDataSource::LiveDataSource()
		: mOffset(0),
		mFinalResult(OK),
		mBackupFile(NULL) {
		#if SAVE_BACKUP
		mBackupFile = fopen("/data/misc/backup.ts", "wb");
		CHECK(mBackupFile != NULL);
		#endif
		}

		LiveDataSource::~LiveDataSource() {
		if (mBackupFile != NULL) {
		fclose(mBackupFile);
		mBackupFile = NULL;
		}
		}

		status_t LiveDataSource::initCheck() const {
		return OK;
		}

		size_t LiveDataSource::countQueuedBuffers() {
		Mutex::Autolock autoLock(mLock);

		return mBufferQueue.size();
		}

		ssize_t LiveDataSource::readAtNonBlocking(
		off64_t offset, void *data, size_t size) {
		Mutex::Autolock autoLock(mLock);

		if (offset != mOffset) {
		ALOGE("Attempt at reading non-sequentially from LiveDataSource.");
		return -EPIPE;
		}

		size_t totalAvailable = 0;
		for (List<sp<ABuffer> >::iterator it = mBufferQueue.begin();
		it != mBufferQueue.end(); ++it) {
		sp<ABuffer> buffer = *it;

		totalAvailable += buffer->size();

		if (totalAvailable >= size) {
		break;
		}
		}

		if (totalAvailable < size) {
		return mFinalResult == OK ? -EWOULDBLOCK : mFinalResult;
		}

		return readAt_l(offset, data, size);
		}

		ssize_t LiveDataSource::readAt(off64_t offset, void *data, size_t size) {
		Mutex::Autolock autoLock(mLock);
		return readAt_l(offset, data, size);
		}

		ssize_t LiveDataSource::readAt_l(off64_t offset, void *data, size_t size) {
		if (offset != mOffset) {
		ALOGE("Attempt at reading non-sequentially from LiveDataSource.");
		return -EPIPE;
		}

		size_t sizeDone = 0;

		while (sizeDone < size) {
		while (mBufferQueue.empty() && mFinalResult == OK) {
		mCondition.wait(mLock);
		}

		if (mBufferQueue.empty()) {
		if (sizeDone > 0) {
		mOffset += sizeDone;
		return sizeDone;
		}

		return mFinalResult;
		}

		sp<ABuffer> buffer = *mBufferQueue.begin();

		size_t copy = size - sizeDone;

		if (copy > buffer->size()) {
		copy = buffer->size();
		}

		memcpy((uint8_t *)data + sizeDone, buffer->data(), copy);

		sizeDone += copy;

		buffer->setRange(buffer->offset() + copy, buffer->size() - copy);

		if (buffer->size() == 0) {
		mBufferQueue.erase(mBufferQueue.begin());
		}
		}

		mOffset += sizeDone;

		return sizeDone;
		}

		void LiveDataSource::queueBuffer(const sp<ABuffer> &buffer) {
		Mutex::Autolock autoLock(mLock);

		if (mFinalResult != OK) {
		return;
		}

		#if SAVE_BACKUP
		if (mBackupFile != NULL) {
		CHECK_EQ(fwrite(buffer->data(), 1, buffer->size(), mBackupFile),
		buffer->size());
		}
		#endif

		mBufferQueue.push_back(buffer);
		mCondition.broadcast();
		}

		void LiveDataSource::queueEOS(status_t finalResult) {
		CHECK_NE(finalResult, (status_t)OK);

		Mutex::Autolock autoLock(mLock);

		mFinalResult = finalResult;
		mCondition.broadcast();
		}

		void LiveDataSource::reset() {
		Mutex::Autolock autoLock(mLock);

		// XXX FIXME: If we've done a partial read and waiting for more buffers,
		// we'll mix old and new data...

		mFinalResult = OK;
		mBufferQueue.clear();
		}

		} // namespace android

media/libstagefright/httplivecustom/LiveDataSource.h

0 → 100644

+64 −0

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

		#define LIVE_DATA_SOURCE_H_

		#include <media/stagefright/foundation/ABase.h>
		#include <media/stagefright/DataSource.h>
		#include <utils/threads.h>
		#include <utils/List.h>

		namespace android {

		struct ABuffer;

		struct LiveDataSource : public DataSource {
		LiveDataSource();

		virtual status_t initCheck() const;

		virtual ssize_t readAt(off64_t offset, void *data, size_t size);
		ssize_t readAtNonBlocking(off64_t offset, void *data, size_t size);

		void queueBuffer(const sp<ABuffer> &buffer);
		void queueEOS(status_t finalResult);
		void reset();

		size_t countQueuedBuffers();

		protected:
		virtual ~LiveDataSource();

		private:
		Mutex mLock;
		Condition mCondition;

		off64_t mOffset;
		List<sp<ABuffer> > mBufferQueue;
		status_t mFinalResult;

		FILE *mBackupFile;

		ssize_t readAt_l(off64_t offset, void *data, size_t size);

		DISALLOW_EVIL_CONSTRUCTORS(LiveDataSource);
		};

		} // namespace android

		#endif // LIVE_DATA_SOURCE_H_