fuzzer/flac_enc_fuzzer.cpp

/******************************************************************************
 *
 * 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;
}