Add test for mp3 decoder (3508d77c) · Commits · e / os / android_frameworks_av

media/libstagefright/codecs/mp3dec/Android.mk

+22 −0

Original line number	Diff line number	Diff line
		@@ -83,3 +83,25 @@ LOCAL_MODULE := libstagefright_soft_mp3dec
		LOCAL_MODULE_TAGS := optional

		include $(BUILD_SHARED_LIBRARY)

		################################################################################
		include $(CLEAR_VARS)
		LOCAL_SRC_FILES := \
		test/mp3dec_test.cpp \
		test/mp3reader.cpp

		LOCAL_C_INCLUDES := \
		$(LOCAL_PATH)/src \
		$(LOCAL_PATH)/include \
		$(LOCAL_PATH)/test/include \
		$(call include-path-for, audio-utils)

		LOCAL_STATIC_LIBRARIES := \
		libstagefright_mp3dec libsndfile

		LOCAL_SHARED_LIBRARIES := libaudioutils

		LOCAL_MODULE := libstagefright_mp3dec_test
		LOCAL_MODULE_TAGS := tests

		include $(BUILD_EXECUTABLE)

media/libstagefright/codecs/mp3dec/test/mp3dec_test.cpp

0 → 100644

+133 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 The Android Open Source Project
		* All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		* * Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		* * Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in
		* the documentation and/or other materials provided with the
		* distribution.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
		* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
		* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
		* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
		* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
		* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
		* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
		* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
		* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		* SUCH DAMAGE.
		*/

		#include <stdlib.h>
		#include <stdio.h>
		#include <assert.h>
		#include <string.h>

		#include "pvmp3decoder_api.h"
		#include "mp3reader.h"
		#include <audio_utils/sndfile.h>

		using namespace std;

		enum {
		kInputBufferSize = 10 * 1024,
		kOutputBufferSize = 4608 * 2,
		};

		int main(int argc, const char **argv) {

		if (argc != 3) {
		fprintf(stderr, "Usage %s <input file> <output file>\n", argv[0]);
		return EXIT_FAILURE;
		}

		// Initialize the config.
		tPVMP3DecoderExternal config;
		config.equalizerType = flat;
		config.crcEnabled = false;

		// Allocate the decoder memory.
		uint32_t memRequirements = pvmp3_decoderMemRequirements();
		void *decoderBuf = malloc(memRequirements);
		assert(decoderBuf != NULL);

		// Initialize the decoder.
		pvmp3_InitDecoder(&config, decoderBuf);

		// Open the input file.
		Mp3Reader mp3Reader;
		bool success = mp3Reader.init(argv[1]);
		if (!success) {
		fprintf(stderr, "Encountered error reading %s\n", argv[1]);
		free(decoderBuf);
		return EXIT_FAILURE;
		}

		// Open the output file.
		SF_INFO sfInfo;
		memset(&sfInfo, 0, sizeof(SF_INFO));
		sfInfo.channels = mp3Reader.getNumChannels();
		sfInfo.format = SF_FORMAT_WAV \| SF_FORMAT_PCM_16;
		sfInfo.samplerate = mp3Reader.getSampleRate();
		SNDFILE *handle = sf_open(argv[2], SFM_WRITE, &sfInfo);
		if (handle == NULL) {
		fprintf(stderr, "Encountered error writing %s\n", argv[2]);
		mp3Reader.close();
		free(decoderBuf);
		return EXIT_FAILURE;
		}

		// Allocate input buffer.
		uint8_t inputBuf = static_cast<uint8_t>(malloc(kInputBufferSize));
		assert(inputBuf != NULL);

		// Allocate output buffer.
		int16_t outputBuf = static_cast<int16_t>(malloc(kOutputBufferSize));
		assert(outputBuf != NULL);

		// Decode loop.
		int retVal = EXIT_SUCCESS;
		while (1) {
		// Read input from the file.
		uint32_t bytesRead;
		bool success = mp3Reader.getFrame(inputBuf, &bytesRead);
		if (!success) break;

		// Set the input config.
		config.inputBufferCurrentLength = bytesRead;
		config.inputBufferMaxLength = 0;
		config.inputBufferUsedLength = 0;
		config.pInputBuffer = inputBuf;
		config.pOutputBuffer = outputBuf;
		config.outputFrameSize = kOutputBufferSize / sizeof(int16_t);

		ERROR_CODE decoderErr;
		decoderErr = pvmp3_framedecoder(&config, decoderBuf);
		if (decoderErr != NO_DECODING_ERROR) {
		fprintf(stderr, "Decoder encountered error\n");
		retVal = EXIT_FAILURE;
		break;
		}
		sf_writef_short(handle, outputBuf,
		config.outputFrameSize / sfInfo.channels);
		}

		// Close input reader and output writer.
		mp3Reader.close();
		sf_close(handle);

		// Free allocated memory.
		free(inputBuf);
		free(outputBuf);
		free(decoderBuf);

		return retVal;
		}

media/libstagefright/codecs/mp3dec/test/mp3reader.cpp

0 → 100644

+425 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 The Android Open Source Project
		* All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		* * Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		* * Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in
		* the documentation and/or other materials provided with the
		* distribution.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
		* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
		* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
		* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
		* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
		* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
		* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
		* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
		* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		* SUCH DAMAGE.
		*/

		#include <stdlib.h>
		#include <stdio.h>
		#include <assert.h>
		#include <string.h>
		#include <stdint.h>
		#include "mp3reader.h"

		static uint32_t U32_AT(const uint8_t *ptr) {
		return ptr[0] << 24 \| ptr[1] << 16 \| ptr[2] << 8 \| ptr[3];
		}

		static bool parseHeader(
		uint32_t header, size_t *frame_size,
		uint32_t out_sampling_rate = NULL, uint32_t out_channels = NULL ,
		uint32_t out_bitrate = NULL, uint32_t out_num_samples = NULL) {
		*frame_size = 0;

		if (out_sampling_rate) {
		*out_sampling_rate = 0;
		}

		if (out_channels) {
		*out_channels = 0;
		}

		if (out_bitrate) {
		*out_bitrate = 0;
		}

		if (out_num_samples) {
		*out_num_samples = 1152;
		}

		if ((header & 0xffe00000) != 0xffe00000) {
		return false;
		}

		unsigned version = (header >> 19) & 3;

		if (version == 0x01) {
		return false;
		}

		unsigned layer = (header >> 17) & 3;

		if (layer == 0x00) {
		return false;
		}

		unsigned bitrate_index = (header >> 12) & 0x0f;

		if (bitrate_index == 0 \|\| bitrate_index == 0x0f) {
		// Disallow "free" bitrate.
		return false;
		}

		unsigned sampling_rate_index = (header >> 10) & 3;

		if (sampling_rate_index == 3) {
		return false;
		}

		static const int kSamplingRateV1[] = { 44100, 48000, 32000 };
		int sampling_rate = kSamplingRateV1[sampling_rate_index];
		if (version == 2 /* V2 */) {
		sampling_rate /= 2;
		} else if (version == 0 /* V2.5 */) {
		sampling_rate /= 4;
		}

		unsigned padding = (header >> 9) & 1;

		if (layer == 3) {
		// layer I

		static const int kBitrateV1[] = {
		32, 64, 96, 128, 160, 192, 224, 256,
		288, 320, 352, 384, 416, 448
		};

		static const int kBitrateV2[] = {
		32, 48, 56, 64, 80, 96, 112, 128,
		144, 160, 176, 192, 224, 256
		};

		int bitrate =
		(version == 3 /* V1 */)
		? kBitrateV1[bitrate_index - 1]
		: kBitrateV2[bitrate_index - 1];

		if (out_bitrate) {
		*out_bitrate = bitrate;
		}

		frame_size = (12000 bitrate / sampling_rate + padding) * 4;

		if (out_num_samples) {
		*out_num_samples = 384;
		}
		} else {
		// layer II or III

		static const int kBitrateV1L2[] = {
		32, 48, 56, 64, 80, 96, 112, 128,
		160, 192, 224, 256, 320, 384
		};

		static const int kBitrateV1L3[] = {
		32, 40, 48, 56, 64, 80, 96, 112,
		128, 160, 192, 224, 256, 320
		};

		static const int kBitrateV2[] = {
		8, 16, 24, 32, 40, 48, 56, 64,
		80, 96, 112, 128, 144, 160
		};

		int bitrate;
		if (version == 3 /* V1 */) {
		bitrate = (layer == 2 /* L2 */)
		? kBitrateV1L2[bitrate_index - 1]
		: kBitrateV1L3[bitrate_index - 1];

		if (out_num_samples) {
		*out_num_samples = 1152;
		}
		} else {
		// V2 (or 2.5)

		bitrate = kBitrateV2[bitrate_index - 1];
		if (out_num_samples) {
		out_num_samples = (layer == 1 / L3 */) ? 576 : 1152;
		}
		}

		if (out_bitrate) {
		*out_bitrate = bitrate;
		}

		if (version == 3 /* V1 */) {
		frame_size = 144000 bitrate / sampling_rate + padding;
		} else {
		// V2 or V2.5
		size_t tmp = (layer == 1 /* L3 */) ? 72000 : 144000;
		frame_size = tmp bitrate / sampling_rate + padding;
		}
		}

		if (out_sampling_rate) {
		*out_sampling_rate = sampling_rate;
		}

		if (out_channels) {
		int channel_mode = (header >> 6) & 3;

		*out_channels = (channel_mode == 3) ? 1 : 2;
		}

		return true;
		}

		// Mask to extract the version, layer, sampling rate parts of the MP3 header,
		// which should be same for all MP3 frames.
		static const uint32_t kMask = 0xfffe0c00;

		static ssize_t sourceReadAt(FILE fp, off64_t offset, void data, size_t size) {
		int retVal = fseek(fp, offset, SEEK_SET);
		if (retVal != EXIT_SUCCESS) {
		return 0;
		} else {
		return fread(data, 1, size, fp);
		}
		}

		// Resync to next valid MP3 frame in the file.
		static bool resync(
		FILE *fp, uint32_t match_header,
		off64_t inout_pos, uint32_t out_header) {

		if (*inout_pos == 0) {
		// Skip an optional ID3 header if syncing at the very beginning
		// of the datasource.

		for (;;) {
		uint8_t id3header[10];
		int retVal = sourceReadAt(fp, *inout_pos, id3header,
		sizeof(id3header));
		if (retVal < (ssize_t)sizeof(id3header)) {
		// If we can't even read these 10 bytes, we might as well bail
		// out, even if there _were_ 10 bytes of valid mp3 audio data...
		return false;
		}

		if (memcmp("ID3", id3header, 3)) {
		break;
		}

		// Skip the ID3v2 header.

		size_t len =
		((id3header[6] & 0x7f) << 21)
		\| ((id3header[7] & 0x7f) << 14)
		\| ((id3header[8] & 0x7f) << 7)
		\| (id3header[9] & 0x7f);

		len += 10;

		*inout_pos += len;
		}

		}

		off64_t pos = *inout_pos;
		bool valid = false;

		const int32_t kMaxReadBytes = 1024;
		const int32_t kMaxBytesChecked = 128 * 1024;
		uint8_t buf[kMaxReadBytes];
		ssize_t bytesToRead = kMaxReadBytes;
		ssize_t totalBytesRead = 0;
		ssize_t remainingBytes = 0;
		bool reachEOS = false;
		uint8_t *tmp = buf;

		do {
		if (pos >= *inout_pos + kMaxBytesChecked) {
		// Don't scan forever.
		break;
		}

		if (remainingBytes < 4) {
		if (reachEOS) {
		break;
		} else {
		memcpy(buf, tmp, remainingBytes);
		bytesToRead = kMaxReadBytes - remainingBytes;

		/*
		* The next read position should start from the end of
		* the last buffer, and thus should include the remaining
		* bytes in the buffer.
		*/
		totalBytesRead = sourceReadAt(fp, pos + remainingBytes,
		buf + remainingBytes, bytesToRead);

		if (totalBytesRead <= 0) {
		break;
		}
		reachEOS = (totalBytesRead != bytesToRead);
		remainingBytes += totalBytesRead;
		tmp = buf;
		continue;
		}
		}

		uint32_t header = U32_AT(tmp);

		if (match_header != 0 && (header & kMask) != (match_header & kMask)) {
		++pos;
		++tmp;
		--remainingBytes;
		continue;
		}

		size_t frame_size;
		uint32_t sample_rate, num_channels, bitrate;
		if (!parseHeader(
		header, &frame_size,
		&sample_rate, &num_channels, &bitrate)) {
		++pos;
		++tmp;
		--remainingBytes;
		continue;
		}

		// We found what looks like a valid frame,
		// now find its successors.

		off64_t test_pos = pos + frame_size;

		valid = true;
		const int FRAME_MATCH_REQUIRED = 3;
		for (int j = 0; j < FRAME_MATCH_REQUIRED; ++j) {
		uint8_t tmp[4];
		ssize_t retval = sourceReadAt(fp, test_pos, tmp, sizeof(tmp));
		if (retval < (ssize_t)sizeof(tmp)) {
		valid = false;
		break;
		}

		uint32_t test_header = U32_AT(tmp);

		if ((test_header & kMask) != (header & kMask)) {
		valid = false;
		break;
		}

		size_t test_frame_size;
		if (!parseHeader(test_header, &test_frame_size)) {
		valid = false;
		break;
		}

		test_pos += test_frame_size;
		}

		if (valid) {
		*inout_pos = pos;

		if (out_header != NULL) {
		*out_header = header;
		}
		}

		++pos;
		++tmp;
		--remainingBytes;
		} while (!valid);

		return valid;
		}

		Mp3Reader::Mp3Reader() : mFp(NULL) {
		}

		// Initialize the MP3 reader.
		bool Mp3Reader::init(const char *file) {

		// Open the file.
		mFp = fopen(file, "rb");
		if (mFp == NULL) return false;

		// Sync to the first valid frame.
		off64_t pos = 0;
		uint32_t header;
		bool success = resync(mFp, 0 /match_header/, &pos, &header);
		if (success == false) return false;

		mCurrentPos = pos;
		mFixedHeader = header;

		size_t frame_size;
		return parseHeader(header, &frame_size, &mSampleRate,
		&mNumChannels, &mBitrate);
		}

		// Get the next valid MP3 frame.
		bool Mp3Reader::getFrame(void buffer, uint32_t size) {

		size_t frame_size;
		uint32_t bitrate;
		uint32_t num_samples;
		uint32_t sample_rate;
		for (;;) {
		ssize_t n = sourceReadAt(mFp, mCurrentPos, buffer, 4);
		if (n < 4) {
		return false;
		}

		uint32_t header = U32_AT((const uint8_t *)buffer);

		if ((header & kMask) == (mFixedHeader & kMask)
		&& parseHeader(
		header, &frame_size, &sample_rate, NULL /out_channels/,
		&bitrate, &num_samples)) {
		break;
		}

		// Lost sync.
		off64_t pos = mCurrentPos;
		if (!resync(mFp, mFixedHeader, &pos, NULL /out_header/)) {
		// Unable to resync. Signalling end of stream.
		return false;
		}

		mCurrentPos = pos;

		// Try again with the new position.
		}
		ssize_t n = sourceReadAt(mFp, mCurrentPos, buffer, frame_size);
		if (n < (ssize_t)frame_size) {
		return false;
		}

		*size = frame_size;
		mCurrentPos += frame_size;
		return true;
		}

		// Close the MP3 reader.
		void Mp3Reader::close() {
		assert(mFp != NULL);
		fclose(mFp);
		}

		Mp3Reader::~Mp3Reader() {
		}

media/libstagefright/codecs/mp3dec/test/mp3reader.h

0 → 100644

+51 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 The Android Open Source Project
		* All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		* * Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		* * Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in
		* the documentation and/or other materials provided with the
		* distribution.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
		* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
		* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
		* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
		* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
		* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
		* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
		* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
		* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		* SUCH DAMAGE.
		*/

		#ifndef MP3READER_H_
		#define MP3READER_H_

		class Mp3Reader {
		public:
		Mp3Reader();
		bool init(const char *file);
		bool getFrame(void buffer, uint32_t size);
		uint32_t getSampleRate() { return mSampleRate;}
		uint32_t getNumChannels() { return mNumChannels;}
		void close();
		~Mp3Reader();
		private:
		FILE *mFp;
		uint32_t mFixedHeader;
		off64_t mCurrentPos;
		uint32_t mSampleRate;
		uint32_t mNumChannels;
		uint32_t mBitrate;
		};


		#endif /* MP3READER_H_ */