fuzzer/flac_enc_fuzzer.cpp - platform/external/flac - Git at Google

 /******************************************************************************
  *
  * Copyright (C) 2020 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.
  *
  *****************************************************************************
  * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
  */

 #include <math.h>
 #include <stdlib.h>
 #include <algorithm>

 #include "FLAC/stream_encoder.h"
 #include "audio_utils/primitives.h"
 #include "share/compat.h"

 constexpr int kMinSampleRate = 1;
 constexpr int kFramesPerBlock = 1152;
 constexpr int kMaxSampleRate = 655350;
 constexpr uint8_t kMinNumChannels = 1;
 constexpr uint8_t kMaxNumChannels = 2;
 constexpr uint8_t kMinCompressionLevel = 0;
 constexpr uint8_t kMaxCompressionLevel = 8;

 enum Encoding { PCM_16, PCM_FLOAT };

 enum {
     IDX_SAMPLE_RATE_INDEX_1 = 0,
     IDX_SAMPLE_RATE_INDEX_2,
     IDX_SAMPLE_RATE_INDEX_3,
     IDX_CHANNEL,
     IDX_COMPRESSION_LEVEL,
     IDX_PCM,
     IDX_SET_VERIFY,
     IDX_SET_STREAMABLE_SUBSET,
     IDX_SET_DO_MID_SIDE_STEREO,
     IDX_SET_LOOSE_MID_SIDE_STEREO,
     IDX_SET_MAX_LPC_ORDER,
     IDX_SET_COEFF_PRECISION,
     IDX_SET_COEFF_PREC_SEARCH,
     IDX_SET_DO_ESCAPE_CODING,
     IDX_SET_DO_EXHAUSTIVE_MODEL_SEARCH,
     IDX_SET_MIN_RESIDUAL_PARTITION_ORDER,
     IDX_SET_MAX_RESIDUAL_PARTITION_ORDER,
     IDX_SET_RICE_PARAMETER_SEARCH_DIST,
     IDX_SET_TOTAL_SAMPLES_ESTIMATE,
     IDX_LAST
 };

 class Codec {
    public:
     ~Codec() { deInitEncoder(); }
     bool initEncoder(uint8_t **dataPtr, size_t *sizePtr);
     void encodeFrames(const uint8_t *data, size_t size);
     void deInitEncoder();
     static FLAC__StreamEncoderWriteStatus flacEncoderWriteCallback(
         const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes,
         unsigned samples, unsigned current_frame, void *client_data);

    private:
     bool verifyStateAndReturn();
     FLAC__StreamEncoder *mFlacStreamEncoder = nullptr;
     uint32_t mChannels = 0;
     uint32_t mPcmEncodingInfo = 0;
     FLAC__int32 mInputBufferPcm32[kFramesPerBlock * kMaxNumChannels] = {};
 };

 FLAC__StreamEncoderWriteStatus Codec::flacEncoderWriteCallback(const FLAC__StreamEncoder *encoder,
                                                                const FLAC__byte buffer[],
                                                                size_t bytes, unsigned samples,
                                                                unsigned current_frame,
                                                                void *client_data) {
     (void)encoder;
     (void)buffer;
     (void)bytes;
     (void)samples;
     (void)current_frame;
     (void)client_data;
     return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
 }

 bool Codec::verifyStateAndReturn() {
     FLAC__StreamEncoderState state = FLAC__stream_encoder_get_state(mFlacStreamEncoder);
     if (state == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
         FLAC__stream_encoder_get_verify_decoder_state(mFlacStreamEncoder);
     }
     return false;
 }

 template <typename type1, typename type2, typename type3>
 auto generateNumberInRangeFromData(type1 data, type2 min, type3 max) -> decltype(max) {
     return (data % (1 + max - min)) + min;
 }

 bool Codec::initEncoder(uint8_t **dataPtr, size_t *sizePtr) {
     uint8_t *data = *dataPtr;
     mFlacStreamEncoder = FLAC__stream_encoder_new();
     if (!mFlacStreamEncoder) {
         return false;
     }

     // Clubbing 3 bytes of data to ensure sample rate in the range [1, 655350]
     uint32_t tempValue = (data[IDX_SAMPLE_RATE_INDEX_1] << 16) |
                          (data[IDX_SAMPLE_RATE_INDEX_2] << 8) | data[IDX_SAMPLE_RATE_INDEX_3];
     uint32_t sampleRate = generateNumberInRangeFromData(tempValue, kMinSampleRate, kMaxSampleRate);
     FLAC__stream_encoder_set_sample_rate(mFlacStreamEncoder, sampleRate);

     mChannels = generateNumberInRangeFromData(data[IDX_CHANNEL], kMinNumChannels, kMaxNumChannels);
     FLAC__stream_encoder_set_channels(mFlacStreamEncoder, mChannels);

     int compression = generateNumberInRangeFromData(data[IDX_COMPRESSION_LEVEL],
                                                     kMinCompressionLevel, kMaxCompressionLevel);
     FLAC__stream_encoder_set_compression_level(mFlacStreamEncoder, compression);

     uint32_t pcmEncodingInfo =
         generateNumberInRangeFromData(data[IDX_PCM], (int)PCM_16, (int)PCM_FLOAT);
     mPcmEncodingInfo = pcmEncodingInfo;
     uint32_t bitsPerSample = (mPcmEncodingInfo == PCM_FLOAT) ? 24 : 16;
     FLAC__stream_encoder_set_bits_per_sample(mFlacStreamEncoder, bitsPerSample);

     int ver = data[IDX_SET_VERIFY] % 2;
     FLAC__stream_encoder_set_verify(mFlacStreamEncoder, ver);

     int streamableSubset = data[IDX_SET_STREAMABLE_SUBSET] % 2;
     FLAC__stream_encoder_set_streamable_subset(mFlacStreamEncoder, streamableSubset);

     int doMidSideStereo = data[IDX_SET_DO_MID_SIDE_STEREO] % 2;
     FLAC__stream_encoder_set_do_mid_side_stereo(mFlacStreamEncoder, doMidSideStereo);

     int looseMidSideStereo = data[IDX_SET_LOOSE_MID_SIDE_STEREO] % 2;
     FLAC__stream_encoder_set_loose_mid_side_stereo(mFlacStreamEncoder, looseMidSideStereo);

     int maxLpcOrder = data[IDX_SET_MAX_LPC_ORDER] % 2;
     FLAC__stream_encoder_set_max_lpc_order(mFlacStreamEncoder, maxLpcOrder);

     int coeffPrec = data[IDX_SET_COEFF_PRECISION] % 2;
     FLAC__stream_encoder_set_qlp_coeff_precision(mFlacStreamEncoder, coeffPrec);

     int coeffPrecSearch = data[IDX_SET_COEFF_PREC_SEARCH] % 2;
     FLAC__stream_encoder_set_do_qlp_coeff_prec_search(mFlacStreamEncoder, coeffPrecSearch);

     int escCoding = data[IDX_SET_DO_ESCAPE_CODING] % 2;
     FLAC__stream_encoder_set_do_escape_coding(mFlacStreamEncoder, escCoding);

     int exhaustiveModelSearch = data[IDX_SET_DO_EXHAUSTIVE_MODEL_SEARCH] % 2;
     FLAC__stream_encoder_set_do_exhaustive_model_search(mFlacStreamEncoder, exhaustiveModelSearch);

     int minResidualPartitionOrder = data[IDX_SET_MIN_RESIDUAL_PARTITION_ORDER] % 2;
     FLAC__stream_encoder_set_min_residual_partition_order(mFlacStreamEncoder,
                                                           minResidualPartitionOrder);

     int maxResidualPartitionOrder = data[IDX_SET_MAX_RESIDUAL_PARTITION_ORDER] % 2;
     FLAC__stream_encoder_set_max_residual_partition_order(mFlacStreamEncoder,
                                                           maxResidualPartitionOrder);

     int riceParam = data[IDX_SET_RICE_PARAMETER_SEARCH_DIST] % 2;
     FLAC__stream_encoder_set_rice_parameter_search_dist(mFlacStreamEncoder, riceParam);

     int totalSamplesEstimate = data[IDX_SET_TOTAL_SAMPLES_ESTIMATE] % 2;
     FLAC__stream_encoder_set_total_samples_estimate(mFlacStreamEncoder, totalSamplesEstimate);

     FLAC__StreamEncoderInitStatus status = FLAC__stream_encoder_init_stream(
         mFlacStreamEncoder, flacEncoderWriteCallback /*write_callback*/, nullptr /*seek_callback*/,
         nullptr /*tell_callback*/, nullptr /*metadata_callback*/, (void *)this /*client_data*/);

     if (status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
         return verifyStateAndReturn();
     }

     // Not re-using the data which was used for configuration for encoding
     *dataPtr += IDX_LAST;
     *sizePtr -= IDX_LAST;
     return true;
 }

 void Codec::encodeFrames(const uint8_t *data, size_t size) {
     size_t sampleSize = (mPcmEncodingInfo == PCM_FLOAT) ? sizeof(float) : sizeof(int16_t);
     size_t frameSize = mChannels * sampleSize;
     do {
         const size_t bytesConsumed = std::min(kFramesPerBlock * frameSize, size);
         const unsigned inputFrames = bytesConsumed / frameSize;
         const unsigned inputSamples = inputFrames * mChannels;
         if (mPcmEncodingInfo == PCM_FLOAT) {
             const float *const pcmFloat = reinterpret_cast<const float *>(data);
             memcpy_to_q8_23_from_float_with_clamp(mInputBufferPcm32, pcmFloat, inputSamples);
         } else {
             const int16_t *const pcm16 = reinterpret_cast<const int16_t *>(data);
             for (unsigned i = 0; i < inputSamples; ++i) {
                 mInputBufferPcm32[i] = (FLAC__int32)pcm16[i];
             }
         }
         FLAC__stream_encoder_process_interleaved(mFlacStreamEncoder, mInputBufferPcm32,
                                                  inputFrames);
         data += bytesConsumed;
         size -= bytesConsumed;
     } while (size > 0);
 }

 void Codec::deInitEncoder() {
     if (mFlacStreamEncoder) {
         FLAC__stream_encoder_finish(mFlacStreamEncoder);
         FLAC__stream_encoder_delete(mFlacStreamEncoder);
         mFlacStreamEncoder = nullptr;
     }
 }

 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
     if (size < IDX_LAST) {
         return 0;
     }
     Codec encoder;
     if (encoder.initEncoder(const_cast<uint8_t **>(&data), &size)) {
         encoder.encodeFrames(data, size);
     }
     return 0;
 }
	/******************************************************************************
	*
	* Copyright (C) 2020 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.
	*
	*****************************************************************************
	* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
	*/

	#include <math.h>
	#include <stdlib.h>
	#include <algorithm>

	#include "FLAC/stream_encoder.h"
	#include "audio_utils/primitives.h"
	#include "share/compat.h"

	constexpr int kMinSampleRate = 1;
	constexpr int kFramesPerBlock = 1152;
	constexpr int kMaxSampleRate = 655350;
	constexpr uint8_t kMinNumChannels = 1;
	constexpr uint8_t kMaxNumChannels = 2;
	constexpr uint8_t kMinCompressionLevel = 0;
	constexpr uint8_t kMaxCompressionLevel = 8;

	enum Encoding { PCM_16, PCM_FLOAT };

	enum {
	IDX_SAMPLE_RATE_INDEX_1 = 0,
	IDX_SAMPLE_RATE_INDEX_2,
	IDX_SAMPLE_RATE_INDEX_3,
	IDX_CHANNEL,
	IDX_COMPRESSION_LEVEL,
	IDX_PCM,
	IDX_SET_VERIFY,
	IDX_SET_STREAMABLE_SUBSET,
	IDX_SET_DO_MID_SIDE_STEREO,
	IDX_SET_LOOSE_MID_SIDE_STEREO,
	IDX_SET_MAX_LPC_ORDER,
	IDX_SET_COEFF_PRECISION,
	IDX_SET_COEFF_PREC_SEARCH,
	IDX_SET_DO_ESCAPE_CODING,
	IDX_SET_DO_EXHAUSTIVE_MODEL_SEARCH,
	IDX_SET_MIN_RESIDUAL_PARTITION_ORDER,
	IDX_SET_MAX_RESIDUAL_PARTITION_ORDER,
	IDX_SET_RICE_PARAMETER_SEARCH_DIST,
	IDX_SET_TOTAL_SAMPLES_ESTIMATE,
	IDX_LAST
	};

	class Codec {
	public:
	~Codec() { deInitEncoder(); }
	bool initEncoder(uint8_t *dataPtr, size_t sizePtr);
	void encodeFrames(const uint8_t *data, size_t size);
	void deInitEncoder();
	static FLAC__StreamEncoderWriteStatus flacEncoderWriteCallback(
	const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes,
	unsigned samples, unsigned current_frame, void *client_data);

	private:
	bool verifyStateAndReturn();
	FLAC__StreamEncoder *mFlacStreamEncoder = nullptr;
	uint32_t mChannels = 0;
	uint32_t mPcmEncodingInfo = 0;
	FLAC__int32 mInputBufferPcm32[kFramesPerBlock * kMaxNumChannels] = {};
	};

	FLAC__StreamEncoderWriteStatus Codec::flacEncoderWriteCallback(const FLAC__StreamEncoder *encoder,
	const FLAC__byte buffer[],
	size_t bytes, unsigned samples,
	unsigned current_frame,
	void *client_data) {
	(void)encoder;
	(void)buffer;
	(void)bytes;
	(void)samples;
	(void)current_frame;
	(void)client_data;
	return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
	}

	bool Codec::verifyStateAndReturn() {
	FLAC__StreamEncoderState state = FLAC__stream_encoder_get_state(mFlacStreamEncoder);
	if (state == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
	FLAC__stream_encoder_get_verify_decoder_state(mFlacStreamEncoder);
	}
	return false;
	}

	template <typename type1, typename type2, typename type3>
	auto generateNumberInRangeFromData(type1 data, type2 min, type3 max) -> decltype(max) {
	return (data % (1 + max - min)) + min;
	}

	bool Codec::initEncoder(uint8_t *dataPtr, size_t sizePtr) {
	uint8_t data = dataPtr;
	mFlacStreamEncoder = FLAC__stream_encoder_new();
	if (!mFlacStreamEncoder) {
	return false;
	}

	// Clubbing 3 bytes of data to ensure sample rate in the range [1, 655350]
	uint32_t tempValue = (data[IDX_SAMPLE_RATE_INDEX_1] << 16) \|
	(data[IDX_SAMPLE_RATE_INDEX_2] << 8) \| data[IDX_SAMPLE_RATE_INDEX_3];
	uint32_t sampleRate = generateNumberInRangeFromData(tempValue, kMinSampleRate, kMaxSampleRate);
	FLAC__stream_encoder_set_sample_rate(mFlacStreamEncoder, sampleRate);

	mChannels = generateNumberInRangeFromData(data[IDX_CHANNEL], kMinNumChannels, kMaxNumChannels);
	FLAC__stream_encoder_set_channels(mFlacStreamEncoder, mChannels);

	int compression = generateNumberInRangeFromData(data[IDX_COMPRESSION_LEVEL],
	kMinCompressionLevel, kMaxCompressionLevel);
	FLAC__stream_encoder_set_compression_level(mFlacStreamEncoder, compression);

	uint32_t pcmEncodingInfo =
	generateNumberInRangeFromData(data[IDX_PCM], (int)PCM_16, (int)PCM_FLOAT);
	mPcmEncodingInfo = pcmEncodingInfo;
	uint32_t bitsPerSample = (mPcmEncodingInfo == PCM_FLOAT) ? 24 : 16;
	FLAC__stream_encoder_set_bits_per_sample(mFlacStreamEncoder, bitsPerSample);

	int ver = data[IDX_SET_VERIFY] % 2;
	FLAC__stream_encoder_set_verify(mFlacStreamEncoder, ver);

	int streamableSubset = data[IDX_SET_STREAMABLE_SUBSET] % 2;
	FLAC__stream_encoder_set_streamable_subset(mFlacStreamEncoder, streamableSubset);

	int doMidSideStereo = data[IDX_SET_DO_MID_SIDE_STEREO] % 2;
	FLAC__stream_encoder_set_do_mid_side_stereo(mFlacStreamEncoder, doMidSideStereo);

	int looseMidSideStereo = data[IDX_SET_LOOSE_MID_SIDE_STEREO] % 2;
	FLAC__stream_encoder_set_loose_mid_side_stereo(mFlacStreamEncoder, looseMidSideStereo);

	int maxLpcOrder = data[IDX_SET_MAX_LPC_ORDER] % 2;
	FLAC__stream_encoder_set_max_lpc_order(mFlacStreamEncoder, maxLpcOrder);

	int coeffPrec = data[IDX_SET_COEFF_PRECISION] % 2;
	FLAC__stream_encoder_set_qlp_coeff_precision(mFlacStreamEncoder, coeffPrec);

	int coeffPrecSearch = data[IDX_SET_COEFF_PREC_SEARCH] % 2;
	FLAC__stream_encoder_set_do_qlp_coeff_prec_search(mFlacStreamEncoder, coeffPrecSearch);

	int escCoding = data[IDX_SET_DO_ESCAPE_CODING] % 2;
	FLAC__stream_encoder_set_do_escape_coding(mFlacStreamEncoder, escCoding);

	int exhaustiveModelSearch = data[IDX_SET_DO_EXHAUSTIVE_MODEL_SEARCH] % 2;
	FLAC__stream_encoder_set_do_exhaustive_model_search(mFlacStreamEncoder, exhaustiveModelSearch);

	int minResidualPartitionOrder = data[IDX_SET_MIN_RESIDUAL_PARTITION_ORDER] % 2;
	FLAC__stream_encoder_set_min_residual_partition_order(mFlacStreamEncoder,
	minResidualPartitionOrder);

	int maxResidualPartitionOrder = data[IDX_SET_MAX_RESIDUAL_PARTITION_ORDER] % 2;
	FLAC__stream_encoder_set_max_residual_partition_order(mFlacStreamEncoder,
	maxResidualPartitionOrder);

	int riceParam = data[IDX_SET_RICE_PARAMETER_SEARCH_DIST] % 2;
	FLAC__stream_encoder_set_rice_parameter_search_dist(mFlacStreamEncoder, riceParam);

	int totalSamplesEstimate = data[IDX_SET_TOTAL_SAMPLES_ESTIMATE] % 2;
	FLAC__stream_encoder_set_total_samples_estimate(mFlacStreamEncoder, totalSamplesEstimate);

	FLAC__StreamEncoderInitStatus status = FLAC__stream_encoder_init_stream(
	mFlacStreamEncoder, flacEncoderWriteCallback /write_callback/, nullptr /seek_callback/,
	nullptr /tell_callback/, nullptr /metadata_callback/, (void )this /client_data*/);

	if (status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
	return verifyStateAndReturn();
	}

	// Not re-using the data which was used for configuration for encoding
	*dataPtr += IDX_LAST;
	*sizePtr -= IDX_LAST;
	return true;
	}

	void Codec::encodeFrames(const uint8_t *data, size_t size) {
	size_t sampleSize = (mPcmEncodingInfo == PCM_FLOAT) ? sizeof(float) : sizeof(int16_t);
	size_t frameSize = mChannels * sampleSize;
	do {
	const size_t bytesConsumed = std::min(kFramesPerBlock * frameSize, size);
	const unsigned inputFrames = bytesConsumed / frameSize;
	const unsigned inputSamples = inputFrames * mChannels;
	if (mPcmEncodingInfo == PCM_FLOAT) {
	const float const pcmFloat = reinterpret_cast<const float >(data);
	memcpy_to_q8_23_from_float_with_clamp(mInputBufferPcm32, pcmFloat, inputSamples);
	} else {
	const int16_t const pcm16 = reinterpret_cast<const int16_t >(data);
	for (unsigned i = 0; i < inputSamples; ++i) {
	mInputBufferPcm32[i] = (FLAC__int32)pcm16[i];
	}
	}
	FLAC__stream_encoder_process_interleaved(mFlacStreamEncoder, mInputBufferPcm32,
	inputFrames);
	data += bytesConsumed;
	size -= bytesConsumed;
	} while (size > 0);
	}

	void Codec::deInitEncoder() {
	if (mFlacStreamEncoder) {
	FLAC__stream_encoder_finish(mFlacStreamEncoder);
	FLAC__stream_encoder_delete(mFlacStreamEncoder);
	mFlacStreamEncoder = nullptr;
	}
	}

	extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
	if (size < IDX_LAST) {
	return 0;
	}
	Codec encoder;
	if (encoder.initEncoder(const_cast<uint8_t **>(&data), &size)) {
	encoder.encodeFrames(data, size);
	}
	return 0;
	}