audio: Remove unused source code (86c62dfd) · Commits · e / devices / Fairphone 4 / android_hardware_qcom_audio

hal_mpq/Android.mk

deleted100644 → 0

+0 −59

Original line number	Diff line number	Diff line
		ifeq ($(strip $(BOARD_USES_ALSA_AUDIO)),true)

		LOCAL_PATH := $(call my-dir)

		include $(CLEAR_VARS)

		LOCAL_ARM_MODE := arm

		AUDIO_PLATFORM := $(TARGET_BOARD_PLATFORM)

		LOCAL_SRC_FILES := \
		audio_hw.c \
		audio_stream_out.c \
		audio_bitstream_sm.c \
		$(AUDIO_PLATFORM)/hw_info.c \
		$(AUDIO_PLATFORM)/platform.c

		ifneq ($(strip $(AUDIO_FEATURE_DISABLED_ANC_HEADSET)),true)
		LOCAL_CFLAGS += -DANC_HEADSET_ENABLED
		endif

		ifneq ($(strip $(AUDIO_FEATURE_DISABLED_PROXY_DEVICE)),true)
		LOCAL_CFLAGS += -DAFE_PROXY_ENABLED
		endif


		ifdef MULTIPLE_HW_VARIANTS_ENABLED
		LOCAL_CFLAGS += -DHW_VARIANTS_ENABLED
		LOCAL_SRC_FILES += $(AUDIO_PLATFORM)/hw_info.c
		endif

		LOCAL_SHARED_LIBRARIES := \
		liblog \
		libcutils \
		libtinyalsa \
		libtinycompress \
		libaudioroute \
		libdl

		LOCAL_C_INCLUDES := \
		external/tinyalsa/include \
		external/tinycompress/include \
		$(call include-path-for, audio-route) \
		$(call include-path-for, audio-effects) \
		$(LOCAL_PATH)/$(AUDIO_PLATFORM)


		LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
		LOCAL_ADDITIONAL_DEPENDENCIES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr

		LOCAL_MODULE := audio.primary.$(TARGET_BOARD_PLATFORM)

		LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw

		LOCAL_MODULE_TAGS := optional

		include $(BUILD_SHARED_LIBRARY)

		endif

hal_mpq/audio_bitstream_sm.c

deleted100644 → 0

+0 −485

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2011 The Android Open Source Project
		* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
		* Not a Contribution.
		*
		* 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.
		*/

		#include <errno.h>
		#include <stdarg.h>
		#include <sys/stat.h>
		#include <fcntl.h>
		#include <stdlib.h>
		#include <unistd.h>
		#include <dlfcn.h>
		#include <math.h>

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

		#include <cutils/properties.h>
		#include "audio_hw.h"
		#include "platform_api.h"
		#include <platform.h>
		// ----------------------------------------------------------------------------

		/*
		Initialize all input and output pointers
		Allocate twice the max buffer size of input and output for sufficient buffering
		*/
		int audio_bitstream_init(struct audio_bitstream_sm *bstream, int buffering_factor)
		{
		bstream->buffering_factor = buffering_factor;
		bstream->buffering_factor_cnt = 0;
		bstream->inp_buf_size = SAMPLES_PER_CHANNEL *
		MAX_INPUT_CHANNELS_SUPPORTED*
		(bstream->buffering_factor+1);
		bstream->inp_buf = (char *)malloc( bstream->inp_buf_size);

		// multiplied by 2 to convert to bytes
		if(bstream->inp_buf != NULL) {
		bstream->inp_buf_curr_ptr = bstream->inp_buf;
		bstream->inp_buf_write_ptr = bstream->inp_buf;
		} else {
		ALOGE("MS11 input buffer not allocated");
		bstream->inp_buf_size = 0;
		return 0;
		}

		bstream->enc_out_buf_size = SAMPLES_PER_CHANNEL * MAX_INPUT_CHANNELS_SUPPORTED*
		FACTOR_FOR_BUFFERING;
		bstream->enc_out_buf =(char *)malloc(bstream->enc_out_buf_size);

		if(bstream->enc_out_buf) {
		bstream->enc_out_buf_write_ptr = bstream->enc_out_buf;
		} else {
		ALOGE("MS11 Enc output buffer not allocated");
		bstream->enc_out_buf_size = 0;
		return 0;
		}
		bstream->pcm_2_out_buf_size = SAMPLES_PER_CHANNELSTEREO_CHANNELS
		FACTOR_FOR_BUFFERING;
		bstream->pcm_2_out_buf =(char *)malloc(bstream->pcm_2_out_buf_size);
		if(bstream->pcm_2_out_buf) {
		bstream->pcm_2_out_buf_write_ptr = bstream->pcm_2_out_buf;
		} else {
		ALOGE("MS11 PCM2Ch output buffer not allocated");
		bstream->pcm_2_out_buf_size = 0;
		return 0;
		}
		bstream->pcm_mch_out_buf_size = SAMPLES_PER_CHANNEL * MAX_OUTPUT_CHANNELS_SUPPORTED *
		FACTOR_FOR_BUFFERING;

		bstream->pcm_mch_out_buf =(char *)malloc(bstream->pcm_mch_out_buf_size);
		if(bstream->pcm_mch_out_buf) {
		bstream->pcm_mch_out_buf_write_ptr = bstream->pcm_mch_out_buf;
		} else {
		ALOGE("MS11 PCMMCh output buffer not allocated");
		bstream->pcm_mch_out_buf_size = 0;
		return 0;
		}
		bstream->passt_out_buf_size =SAMPLES_PER_CHANNEL *
		MAX_INPUT_CHANNELS_SUPPORTED *
		FACTOR_FOR_BUFFERING;
		bstream->passt_out_buf =(char *)malloc(bstream->passt_out_buf_size);
		if(bstream->passt_out_buf) {
		bstream->passt_out_buf_write_ptr = bstream->passt_out_buf;
		} else {
		ALOGE("MS11 Enc output buffer not allocated");
		bstream->passt_out_buf_size = 0;
		return 0;
		}
		return 1;
		}

		/*
		Free the allocated memory
		*/
		int audio_bitstream_close(struct audio_bitstream_sm *bstream)
		{
		if(bstream->inp_buf != NULL) {
		free(bstream->inp_buf);
		bstream->inp_buf = NULL;
		}
		if(bstream->enc_out_buf != NULL) {
		free(bstream->enc_out_buf);
		bstream->enc_out_buf = NULL;
		}
		if(bstream->pcm_2_out_buf != NULL) {
		free(bstream->pcm_2_out_buf);
		bstream->pcm_2_out_buf = NULL;
		}
		if(bstream->pcm_mch_out_buf != NULL) {
		free(bstream->pcm_mch_out_buf);
		bstream->pcm_mch_out_buf = NULL;
		}
		if(bstream->passt_out_buf != NULL) {
		free(bstream->passt_out_buf);
		bstream->passt_out_buf = NULL;
		}
		bstream->buffering_factor = 1;
		bstream->buffering_factor_cnt = 0;
		return 0;
		}

		/*
		Reset the buffer pointers to start for. This will be help in flush and close
		*/
		void audio_bitstream_reset_ptr( struct audio_bitstream_sm *bstream)
		{
		bstream->inp_buf_curr_ptr = bstream->inp_buf_write_ptr = bstream->inp_buf;
		bstream->enc_out_buf_write_ptr = bstream->enc_out_buf;
		bstream->pcm_2_out_buf_write_ptr = bstream->pcm_2_out_buf;
		bstream->pcm_mch_out_buf_write_ptr = bstream->pcm_mch_out_buf;
		bstream->passt_out_buf_write_ptr = bstream->passt_out_buf;
		bstream->buffering_factor_cnt = 0;
		}

		/*
		Reset the output buffer pointers to start for port reconfiguration
		*/
		void audio_bitstream_reset_output_bitstream_ptr(
		struct audio_bitstream_sm *bstream)
		{
		bstream->enc_out_buf_write_ptr = bstream->enc_out_buf;
		bstream->pcm_2_out_buf_write_ptr = bstream->pcm_2_out_buf;
		bstream->pcm_mch_out_buf_write_ptr = bstream->pcm_mch_out_buf;
		bstream->passt_out_buf_write_ptr = bstream->passt_out_buf;
		}

		/*
		Copy the bitstream/pcm from Player to internal buffer.
		The incoming bitstream is appended to existing bitstream
		*/
		void audio_bitstream_copy_to_internal_buffer(
		struct audio_bitstream_sm *bstream,
		char *buf_ptr, size_t bytes)
		{
		// flush the input buffer if input is not consumed
		if( (bstream->inp_buf_write_ptr+bytes) > (bstream->inp_buf+bstream->inp_buf_size) ) {
		ALOGE("Input bitstream is not consumed");
		return;
		}

		memcpy(bstream->inp_buf_write_ptr, buf_ptr, bytes);
		bstream->inp_buf_write_ptr += bytes;
		if(bstream->buffering_factor_cnt < bstream->buffering_factor)
		bstream->buffering_factor_cnt++;
		}

		/*
		Append zeros to the bitstream, so that the entire bitstream in ADIF is pushed
		out for decoding
		*/
		void audio_bitstream_append_silence_internal_buffer(
		struct audio_bitstream_sm *bstream,
		uint32_t bytes, unsigned char value)
		{
		int32_t bufLen = SAMPLES_PER_CHANNELMAX_INPUT_CHANNELS_SUPPORTED
		(bstream->buffering_factor+1);
		uint32_t i = 0;
		if( (bstream->inp_buf_write_ptr+bytes) > (bstream->inp_buf+bufLen) ) {
		bytes = bufLen + bstream->inp_buf - bstream->inp_buf_write_ptr;
		}
		for(i=0; i< bytes; i++)
		*bstream->inp_buf_write_ptr++ = value;
		if(bstream->buffering_factor_cnt < bstream->buffering_factor)
		bstream->buffering_factor_cnt++;
		}

		/*
		Flags if sufficient bitstream is available to proceed to decode based on
		the threshold
		*/
		int audio_bitstream_sufficient_buffer_to_decode(
		struct audio_bitstream_sm *bstream,
		int min_bytes_to_decode)
		{
		int proceed_decode = 0;
		if( (bstream->inp_buf_write_ptr -\
		bstream->inp_buf_curr_ptr) > min_bytes_to_decode)
		proceed_decode = 1;
		return proceed_decode;
		}

		/*
		Gets the start address of the bitstream buffer. This is used for start of decode
		*/
		char* audio_bitstream_get_input_buffer_ptr(
		struct audio_bitstream_sm *bstream)
		{
		return bstream->inp_buf_curr_ptr;
		}

		/*
		Gets the writePtr of the bitstream buffer. This is used for calculating length of
		bitstream
		*/
		char* audio_bitstream_get_input_buffer_write_ptr(
		struct audio_bitstream_sm *bstream)
		{
		return bstream->inp_buf_write_ptr;
		}

		int audio_bitstream_set_input_buffer_ptr(
		struct audio_bitstream_sm *bstream, int bytes)
		{
		if(((bstream->inp_buf_curr_ptr + bytes) <=
		(bstream->inp_buf + bstream->inp_buf_size)) &&
		((bstream->inp_buf_curr_ptr + bytes) >= bstream->inp_buf))

		bstream->inp_buf_curr_ptr += bytes;
		else {
		ALOGE("Invalid input buffer size %d bytes", bytes);
		return -EINVAL;
		}

		return 0;
		}

		int audio_bitstream_set_input_buffer_write_ptr(
		struct audio_bitstream_sm *bstream, int bytes)
		{
		if(((bstream->inp_buf_write_ptr + bytes) <=
		(bstream->inp_buf + bstream->inp_buf_size)) &&
		((bstream->inp_buf_write_ptr + bytes) >= bstream->inp_buf))

		bstream->inp_buf_write_ptr += bytes;
		else {
		ALOGE("Invalid input buffer size %d bytes", bytes);
		return -EINVAL;
		}

		return 0;
		}

		/*
		Get the output buffer start pointer to start rendering the pcm sampled to driver
		*/
		char* audio_bitstream_get_output_buffer_ptr(
		struct audio_bitstream_sm *bstream,
		int format)
		{
		switch(format) {
		case PCM_MCH_OUT:
		return bstream->pcm_mch_out_buf;
		case PCM_2CH_OUT:
		return bstream->pcm_2_out_buf;
		case COMPRESSED_OUT:
		return bstream->enc_out_buf;
		case TRANSCODE_OUT:
		return bstream->passt_out_buf;
		default:
		return NULL;
		}
		}

		/*
		Output the pointer from where the next PCM samples can be copied to buffer
		*/
		char* audio_bitstream_get_output_buffer_write_ptr(
		struct audio_bitstream_sm *bstream,
		int format)
		{
		switch(format) {
		case PCM_MCH_OUT:
		return bstream->pcm_mch_out_buf_write_ptr;
		case PCM_2CH_OUT:
		return bstream->pcm_2_out_buf_write_ptr;
		case COMPRESSED_OUT:
		return bstream->enc_out_buf_write_ptr;
		case TRANSCODE_OUT:
		return bstream->passt_out_buf_write_ptr;
		default:
		return NULL;
		}
		}

		/*
		Provides the bitstream size available in the internal buffer
		*/
		size_t audio_bitstream_get_size(struct audio_bitstream_sm *bstream)
		{
		return (bstream->inp_buf_write_ptr-bstream->inp_buf_curr_ptr);
		}

		/*
		After decode, the residue bitstream in the buffer is moved to start, so as to
		avoid circularity constraints
		*/
		void audio_bitstream_copy_residue_to_start(
		struct audio_bitstream_sm *bstream,
		size_t bytes_consumed_in_decode)
		{
		size_t remaining_curr_valid_bytes = bstream->inp_buf_write_ptr -
		(bytes_consumed_in_decode+bstream->inp_buf_curr_ptr);
		size_t remainingTotalBytes = bstream->inp_buf_write_ptr -
		(bytes_consumed_in_decode+bstream->inp_buf);
		if(bstream->buffering_factor_cnt == bstream->buffering_factor) {
		memcpy(bstream->inp_buf, bstream->inp_buf+bytes_consumed_in_decode, remainingTotalBytes);
		bstream->inp_buf_write_ptr = bstream->inp_buf+remainingTotalBytes;
		bstream->inp_buf_curr_ptr = bstream->inp_buf_write_ptr-remaining_curr_valid_bytes;
		} else {
		bstream->inp_buf_curr_ptr += bytes_consumed_in_decode;
		}
		}

		/*
		Remaing samples less than the one period size required for the pcm driver
		is moved to start of the buffer
		*/
		void audio_bitstream_copy_residue_output_start(
		struct audio_bitstream_sm *bstream,
		int format,
		size_t samplesRendered)
		{
		size_t remaining_bytes;
		switch(format) {
		case PCM_MCH_OUT:
		remaining_bytes = bstream->pcm_mch_out_buf_write_ptr-\
		(bstream->pcm_mch_out_buf+samplesRendered);
		memcpy(bstream->pcm_mch_out_buf,
		bstream->pcm_mch_out_buf+samplesRendered,
		remaining_bytes);
		bstream->pcm_mch_out_buf_write_ptr = \
		bstream->pcm_mch_out_buf + remaining_bytes;
		break;
		case PCM_2CH_OUT:
		remaining_bytes = bstream->pcm_2_out_buf_write_ptr-\
		(bstream->pcm_2_out_buf+samplesRendered);
		memcpy(bstream->pcm_2_out_buf,
		bstream->pcm_2_out_buf+samplesRendered,
		remaining_bytes);
		bstream->pcm_2_out_buf_write_ptr = \
		bstream->pcm_2_out_buf + remaining_bytes;
		break;
		case COMPRESSED_OUT:
		remaining_bytes = bstream->enc_out_buf_write_ptr-\
		(bstream->enc_out_buf+samplesRendered);
		memcpy(bstream->enc_out_buf,
		bstream->enc_out_buf+samplesRendered,
		remaining_bytes);
		bstream->enc_out_buf_write_ptr = \
		bstream->enc_out_buf + remaining_bytes;
		break;
		case TRANSCODE_OUT:
		remaining_bytes = bstream->passt_out_buf_write_ptr-\
		(bstream->passt_out_buf+samplesRendered);
		memcpy(bstream->passt_out_buf,
		bstream->passt_out_buf+samplesRendered,
		remaining_bytes);
		bstream->passt_out_buf_write_ptr = \
		bstream->passt_out_buf + remaining_bytes;
		break;
		default:
		break;
		}
		}

		/*
		The write pointer is updated after the incoming PCM samples are copied to the
		output buffer
		*/
		void audio_bitstream_set_output_buffer_write_ptr(
		struct audio_bitstream_sm *bstream,
		int format, size_t output_pcm_sample)
		{
		int alloc_bytes;
		switch(format) {
		case PCM_MCH_OUT:
		alloc_bytes = SAMPLES_PER_CHANNEL*\
		MAX_OUTPUT_CHANNELS_SUPPORTED*FACTOR_FOR_BUFFERING;
		if (bstream->pcm_mch_out_buf + alloc_bytes >\
		bstream->pcm_mch_out_buf_write_ptr + output_pcm_sample)
		bstream->pcm_mch_out_buf_write_ptr += output_pcm_sample;
		break;
		case PCM_2CH_OUT:
		alloc_bytes = SAMPLES_PER_CHANNELSTEREO_CHANNELSFACTOR_FOR_BUFFERING;
		if(bstream->pcm_2_out_buf + alloc_bytes > \
		bstream->pcm_2_out_buf_write_ptr + output_pcm_sample)
		bstream->pcm_2_out_buf_write_ptr += output_pcm_sample;
		break;
		case COMPRESSED_OUT:
		alloc_bytes = SAMPLES_PER_CHANNEL*\
		MAX_INPUT_CHANNELS_SUPPORTED*FACTOR_FOR_BUFFERING;
		if (bstream->enc_out_buf + alloc_bytes > \
		bstream->enc_out_buf_write_ptr + output_pcm_sample)
		bstream->enc_out_buf_write_ptr += output_pcm_sample;
		break;
		case TRANSCODE_OUT:
		alloc_bytes = SAMPLES_PER_CHANNEL*\
		MAX_INPUT_CHANNELS_SUPPORTED*FACTOR_FOR_BUFFERING;
		if (bstream->passt_out_buf + alloc_bytes > \
		bstream->passt_out_buf_write_ptr + output_pcm_sample)
		bstream->passt_out_buf_write_ptr += output_pcm_sample;
		break;
		default:
		break;
		}
		}

		/*
		Flags if sufficient samples are available to render to PCM driver
		*/
		int audio_bitstream_sufficient_sample_to_render(
		struct audio_bitstream_sm *bstream,
		int format, int mid_size_reqd)
		{
		int status = 0;
		char buf_ptr = NULL, buf_write_ptr = NULL;
		switch(format) {
		case PCM_MCH_OUT:
		buf_ptr = bstream->pcm_mch_out_buf;
		buf_write_ptr = bstream->pcm_mch_out_buf_write_ptr;
		break;
		case PCM_2CH_OUT:
		buf_ptr = bstream->pcm_2_out_buf;
		buf_write_ptr = bstream->pcm_2_out_buf_write_ptr;
		break;
		case COMPRESSED_OUT:
		buf_ptr = bstream->enc_out_buf;
		buf_write_ptr = bstream->enc_out_buf_write_ptr;
		break;
		case TRANSCODE_OUT:
		buf_ptr = bstream->passt_out_buf;
		buf_write_ptr = bstream->passt_out_buf_write_ptr;
		break;
		default:
		break;
		}
		if( (buf_write_ptr-buf_ptr) >= mid_size_reqd )
		status = 1;
		return status;
		}

		void audio_bitstream_start_input_buffering_mode(
		struct audio_bitstream_sm *bstream)
		{
		bstream->buffering_factor_cnt = 0;
		}

		void audio_bitstream_stop_input_buffering_mode(
		struct audio_bitstream_sm *bstream)
		{
		size_t remaining_curr_valid_bytes = \
		bstream->inp_buf_write_ptr - bstream->inp_buf_curr_ptr;
		bstream->buffering_factor_cnt = bstream->buffering_factor;
		memcpy(bstream->inp_buf,
		bstream->inp_buf_curr_ptr,
		remaining_curr_valid_bytes);
		bstream->inp_buf_curr_ptr = bstream->inp_buf;
		bstream->inp_buf_write_ptr = bstream->inp_buf + remaining_curr_valid_bytes;
		}

hal_mpq/audio_bitstream_sm.h

deleted100644 → 0

+0 −65

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2011 The Android Open Source Project
		* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
		* Not a Contribution.
		*
		* 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 QCOM_AUDIO_BITSTRM_SM_H
		#define QCOM_AUDIO_BITSTRM_SM_H
		int audio_bitstream_init(struct audio_bitstream_sm *bstream, int buffering_factor);
		int audio_bitstream_close(struct audio_bitstream_sm *bstream);
		int audio_bitstream_with_buffering_factor(struct audio_bitstream_sm *bstream,
		int in_buffering_factor);
		void audio_bitstream_reset_ptr( struct audio_bitstream_sm *bstream);
		void audio_bitstream_reset_output_bitstream_ptr(
		struct audio_bitstream_sm *bstream);
		void audio_bitstream_copy_to_internal_buffer(
		struct audio_bitstream_sm *bstream,
		char *buf_ptr, size_t bytes);
		void audio_bitstream_append_silence_internal_buffer(
		struct audio_bitstream_sm *bstream,
		uint32_t bytes, unsigned char value);
		int audio_bitstream_sufficient_buffer_to_decode(
		struct audio_bitstream_sm *bstream,
		int min_bytes_to_decode);
		char* audio_bitstream_get_input_buffer_ptr(
		struct audio_bitstream_sm *bstream);
		char* audio_bitstream_get_input_buffer_write_ptr(
		struct audio_bitstream_sm *bstream);
		char* audio_bitstream_get_output_buffer_ptr(
		struct audio_bitstream_sm *bstream,
		int format);
		char* audio_bitstream_get_output_buffer_write_ptr(
		struct audio_bitstream_sm *bstream,
		int format);
		size_t audio_bitstream_get_size(struct audio_bitstream_sm *bstream);
		void audio_bitstream_copy_residue_to_start(
		struct audio_bitstream_sm *bstream,
		size_t bytes_consumed_in_decode);
		void audio_bitstream_copy_residue_output_start(
		struct audio_bitstream_sm *bstream,
		int format,
		size_t samplesRendered);
		void audio_bitstream_set_output_buffer_write_ptr(
		struct audio_bitstream_sm *bstream,
		int format, size_t output_pcm_sample);
		int audio_bitstream_sufficient_sample_to_render(
		struct audio_bitstream_sm *bstream,
		int format, int mid_size_reqd);
		void audio_bitstream_start_input_buffering_mode(
		struct audio_bitstream_sm *bstream);
		void audio_bitstream_stop_input_buffering_mode(
		struct audio_bitstream_sm *bstream);
		#endif

hal_mpq/audio_hw.c

deleted100644 → 0

+0 −1240

File deleted.

Preview size limit exceeded, changes collapsed.

hal_mpq/audio_hw.h

deleted100644 → 0

+0 −384

File deleted.

Preview size limit exceeded, changes collapsed.