Revert "FM Radio: Add support for FM Radio in Android" (4ae65f93) · Commits · e / os / android_frameworks_av

include/media/stagefright/FMRadioSource.h

deleted100644 → 0

+0 −64

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) ST-Ericsson SA 2012
	* 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.
	*
	* Author: Stefan Ekenberg (stefan.ekenberg@stericsson.com) for ST-Ericsson
	*/

	#ifndef FMRADIO_SOURCE_H_

	#define FMRADIO_SOURCE_H_

	#include <media/AudioRecord.h>
	#include <media/stagefright/DataSource.h>
	#include <media/stagefright/foundation/ABase.h>
	#include <system/audio.h>

	namespace android {

	class FMRadioSource : public DataSource {
	public:
	FMRadioSource();

	virtual status_t initCheck() const;
	virtual ssize_t readAt(off64_t offset, void *data, size_t size);
	virtual status_t getSize(off64_t *size);

	protected:
	virtual ~FMRadioSource();

	private:
	struct Buffer {
	size_t frameCount;
	size_t size;
	int8_t* data;
	};

	status_t openRecord(int frameCount, audio_io_handle_t input);
	status_t obtainBuffer(Buffer* audioBuffer);

	status_t mInitCheck;
	bool mStarted;
	int mSessionId;
	sp<IAudioRecord> mAudioRecord;
	sp<IMemory> mCblkMemory;
	audio_track_cblk_t* mCblk;

	DISALLOW_EVIL_CONSTRUCTORS(FMRadioSource);
	};

	} // namespace android

	#endif // FMRADIO_SOURCE_H_

media/libstagefright/Android.mk

+1 −14

Original line number	Original line	Diff line number	Diff line
	@@ -69,20 +69,7 @@ LOCAL_C_INCLUDES:= \
	$(TOP)/frameworks/native/services/connectivitymanager \		$(TOP)/frameworks/native/services/connectivitymanager \
	$(TOP)/external/flac/include \		$(TOP)/external/flac/include \
	$(TOP)/external/tremolo \		$(TOP)/external/tremolo \
	$(TOP)/external/openssl/include		$(TOP)/external/openssl/include \

	ifneq ($(TI_CUSTOM_DOMX_PATH),)
	LOCAL_C_INCLUDES += $(TI_CUSTOM_DOMX_PATH)/omx_core/inc
	LOCAL_CPPFLAGS += -DUSE_TI_CUSTOM_DOMX
	else
	LOCAL_C_INCLUDES += $(TOP)/frameworks/native/include/media/openmax
	endif

	ifeq ($(BOARD_USES_STE_FMRADIO),true)
	LOCAL_SRC_FILES += \
	FMRadioSource.cpp \
	PCMExtractor.cpp
	endif

	ifeq ($(TARGET_QCOM_MEDIA_VARIANT),caf)		ifeq ($(TARGET_QCOM_MEDIA_VARIANT),caf)
	LOCAL_C_INCLUDES += \		LOCAL_C_INCLUDES += \

media/libstagefright/AwesomePlayer.cpp

+0 −10

Original line number	Original line	Diff line number	Diff line
	@@ -42,7 +42,6 @@
	#include <media/stagefright/AudioPlayer.h>		#include <media/stagefright/AudioPlayer.h>
	#include <media/stagefright/DataSource.h>		#include <media/stagefright/DataSource.h>
	#include <media/stagefright/FileSource.h>		#include <media/stagefright/FileSource.h>
	#include <media/stagefright/FMRadioSource.h>
	#include <media/stagefright/MediaBuffer.h>		#include <media/stagefright/MediaBuffer.h>
	#include <media/stagefright/MediaDefs.h>		#include <media/stagefright/MediaDefs.h>
	#include <media/stagefright/MediaExtractor.h>		#include <media/stagefright/MediaExtractor.h>
	@@ -2282,15 +2281,6 @@ status_t AwesomePlayer::finishSetDataSource_l() {
	return UNKNOWN_ERROR;		return UNKNOWN_ERROR;
	}		}
	}		}
	#ifdef STE_FM
	} else if (!strncasecmp("fmradio://rx", mUri.string(), 12)) {
	sniffedMIME = MEDIA_MIMETYPE_AUDIO_RAW;
	dataSource = new FMRadioSource();
	status_t err = dataSource->initCheck();
	if (err != OK) {
	return err;
	}
	#endif
	} else {		} else {
	dataSource = DataSource::CreateFromURI(mUri.string(), &mUriHeaders);		dataSource = DataSource::CreateFromURI(mUri.string(), &mUriHeaders);
	}		}

media/libstagefright/FMRadioSource.cpp

deleted100644 → 0

+0 −201

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) ST-Ericsson SA 2012
	* 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.
	*
	* Author: Stefan Ekenberg (stefan.ekenberg@stericsson.com) for ST-Ericsson
	*/

	#define LOG_TAG "FMRadioSource"
	#include <utils/Log.h>

	#include <media/stagefright/FMRadioSource.h>
	#include <media/AudioSystem.h>
	#include <private/media/AudioTrackShared.h>
	#include <cutils/compiler.h>

	namespace android {

	static const int kSampleRate = 48000;
	static const audio_format_t kAudioFormat = AUDIO_FORMAT_PCM_16_BIT;
	static const audio_channel_mask_t kChannelMask = AUDIO_CHANNEL_IN_STEREO;
	static const int kBufferTimeoutMs = 3000;

	FMRadioSource::FMRadioSource()
	: mInitCheck(NO_INIT),
	mStarted(false),
	mSessionId(AudioSystem::newAudioSessionId()) {

	// get FM Radio RX input
	audio_io_handle_t input = AudioSystem::getInput(AUDIO_SOURCE_FM_RADIO_RX,
	kSampleRate,
	kAudioFormat,
	kChannelMask,
	mSessionId);
	if (input == 0) {
	ALOGE("Could not get audio input for FM Radio source");
	mInitCheck = UNKNOWN_ERROR;
	return;
	}

	// get frame count
	int frameCount = 0;
	status_t status = AudioRecord::getMinFrameCount(&frameCount, kSampleRate,
	kAudioFormat, popcount(kChannelMask));
	if (status != NO_ERROR) {
	mInitCheck = status;
	return;
	}

	// create the IAudioRecord
	status = openRecord(frameCount, input);
	if (status != NO_ERROR) {
	mInitCheck = status;
	return;
	}

	AudioSystem::acquireAudioSessionId(mSessionId);

	mInitCheck = OK;
	return;
	}

	FMRadioSource::~FMRadioSource() {
	AudioSystem::releaseAudioSessionId(mSessionId);
	}

	status_t FMRadioSource::initCheck() const {
	return mInitCheck;
	}

	ssize_t FMRadioSource::readAt(off64_t offset, void *data, size_t size) {
	Buffer audioBuffer;

	if (!mStarted) {
	status_t err = mAudioRecord->start(AudioSystem::SYNC_EVENT_NONE, 0);
	if (err == OK) {
	mStarted = true;
	} else {
	ALOGE("Failed to start audio source");
	return 0;
	}
	}

	// acquire a strong reference on the IAudioRecord and IMemory so that they cannot be destroyed
	// while we are accessing the cblk
	sp<IAudioRecord> audioRecord = mAudioRecord;
	sp<IMemory> iMem = mCblkMemory;
	audio_track_cblk_t* cblk = mCblk;

	audioBuffer.frameCount = size / cblk->frameSize;

	status_t err = obtainBuffer(&audioBuffer);
	if (err != NO_ERROR) {
	ALOGE("Error obtaining an audio buffer, giving up (err:%d).", err);
	return 0;
	}

	memcpy(data, audioBuffer.data, audioBuffer.size);
	mCblk->stepUser(audioBuffer.frameCount);

	return audioBuffer.size;
	}

	status_t FMRadioSource::getSize(off64_t *size) {
	*size = 0;
	return OK;
	}

	// -------------------------------------------------------------------------

	status_t FMRadioSource::openRecord(int frameCount, audio_io_handle_t input)
	{
	status_t status;
	const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
	if (audioFlinger == 0) {
	return NO_INIT;
	}

	sp<IAudioRecord> record = audioFlinger->openRecord(getpid(), input,
	kSampleRate,
	kAudioFormat,
	kChannelMask,
	frameCount,
	IAudioFlinger::TRACK_DEFAULT,
	gettid(),
	&mSessionId,
	&status);

	if (record == 0) {
	ALOGE("AudioFlinger could not create record track, status: %d", status);
	return status;
	}

	sp<IMemory> cblk = record->getCblk();
	if (cblk == 0) {
	ALOGE("Could not get control block");
	return NO_INIT;
	}
	mAudioRecord = record;
	mCblkMemory = cblk;
	mCblk = static_cast<audio_track_cblk_t*>(cblk->pointer());
	mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t);
	android_atomic_and(~CBLK_DIRECTION_MSK, &mCblk->flags);
	return NO_ERROR;
	}

	status_t FMRadioSource::obtainBuffer(Buffer* audioBuffer)
	{
	status_t result = NO_ERROR;
	uint32_t framesReq = audioBuffer->frameCount;

	audioBuffer->frameCount = 0;
	audioBuffer->size = 0;

	mCblk->lock.lock();
	uint32_t framesReady = mCblk->framesReady();
	if (framesReady == 0) {
	do {
	result = mCblk->cv.waitRelative(mCblk->lock, milliseconds(kBufferTimeoutMs));
	if (CC_UNLIKELY(result != NO_ERROR)) {
	ALOGE("obtainBuffer timed out (is the CPU pegged?) "
	"user=%08x, server=%08x", mCblk->user, mCblk->server);
	mCblk->lock.unlock();
	return TIMED_OUT;
	}

	framesReady = mCblk->framesReady();
	} while (framesReady == 0);
	}
	mCblk->lock.unlock();

	if (framesReq > framesReady) {
	framesReq = framesReady;
	}

	uint32_t u = mCblk->user;
	uint32_t bufferEnd = mCblk->userBase + mCblk->frameCount;

	if (framesReq > bufferEnd - u) {
	framesReq = bufferEnd - u;
	}

	audioBuffer->frameCount = framesReq;
	audioBuffer->size = framesReq * mCblk->frameSize;
	audioBuffer->data = (int8_t*)mCblk->buffer(u);

	return NO_ERROR;
	}

	} // namespace android

media/libstagefright/MediaExtractor.cpp

+0 −5

Original line number	Original line	Diff line number	Diff line
	@@ -23,7 +23,6 @@
	#include "include/MPEG4Extractor.h"		#include "include/MPEG4Extractor.h"
	#include "include/WAVExtractor.h"		#include "include/WAVExtractor.h"
	#include "include/OggExtractor.h"		#include "include/OggExtractor.h"
	#include "include/PCMExtractor.h"
	#include "include/MPEG2PSExtractor.h"		#include "include/MPEG2PSExtractor.h"
	#include "include/MPEG2TSExtractor.h"		#include "include/MPEG2TSExtractor.h"
	#include "include/DRMExtractor.h"		#include "include/DRMExtractor.h"
	@@ -117,10 +116,6 @@ sp<MediaExtractor> MediaExtractor::Create(
	ret = new AACExtractor(source, meta);		ret = new AACExtractor(source, meta);
	} else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2PS)) {		} else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2PS)) {
	ret = new MPEG2PSExtractor(source);		ret = new MPEG2PSExtractor(source);
	#ifdef STE_FM
	} else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW)) {
	ret = new PCMExtractor(source);
	#endif
	}		}

	if (ret != NULL) {		if (ret != NULL) {