Function encode_audio

kleidiai-examples/audiogen/app/audiogen.cpp:281–342

}

static void encode_audio(const std::string& audio_input_path, const std::string& encoder_model_path, std::vector<float>& encoded_audio, size_t num_threads, litert::Environment& env) {

    std::vector<float> packed;
    std::vector<float> left_ch_input;
    std::vector<float> right_ch_input;

    // Read input audio file
    read_wav(audio_input_path, left_ch_input, right_ch_input);
    fprintf(stderr, "Using %s as an audio input file...\n", audio_input_path.c_str());

    auto encoder_options = get_litert_value(litert::Options::Create());
    AUDIOGEN_CHECK(encoder_options.SetHardwareAccelerators(litert::HwAccelerators::kCpu));
    auto& encoder_cpu_options = get_litert_value(encoder_options.GetCpuOptions());
    AUDIOGEN_CHECK(encoder_cpu_options.SetNumThreads(static_cast<int>(num_threads)));
    AUDIOGEN_CHECK(encoder_cpu_options.SetXNNPackFlags(k_xnnpack_flags_base | TFLITE_XNNPACK_DELEGATE_FLAG_FORCE_FP16));

    auto autoencoder_encoder_model = get_litert_value(litert::CompiledModel::Create(env, encoder_model_path, encoder_options));

    auto encoder_inputs = get_litert_value(autoencoder_encoder_model.CreateInputBuffers());
    auto encoder_outputs = get_litert_value(autoencoder_encoder_model.CreateOutputBuffers());
    AUDIOGEN_CHECK(encoder_inputs.size() >= 1);
    AUDIOGEN_CHECK(encoder_outputs.size() >= 1);

    auto encoder_in_type = get_litert_value(autoencoder_encoder_model.GetInputTensorType(0, 0));
    auto encoder_out_type = get_litert_value(autoencoder_encoder_model.GetOutputTensorType(0, 0));

    const size_t audio_input_dim0 = get_num_elems(encoder_in_type);

    // Divided by 2 because we have two channels
    AUDIOGEN_CHECK(left_ch_input.size() <= audio_input_dim0 / 2);
    AUDIOGEN_CHECK(right_ch_input.size() <= audio_input_dim0 / 2);

    // Resize if needed and fill with zero the newly added values
    left_ch_input.resize(audio_input_dim0 / 2, 0);
    right_ch_input.resize(audio_input_dim0 / 2, 0);

    // Pack the data
    {
        auto encoder_in_lock_and_ptr = scoped_lock<float>(encoder_inputs[0],
                                                          litert::TensorBuffer::LockMode::kWrite);
        auto* autoencoder_encoder_in_data = encoder_in_lock_and_ptr.second;
        prepare_encoder_input(left_ch_input, right_ch_input, autoencoder_encoder_in_data, audio_input_dim0);
    }

    // Run the encoder
    auto start_encoder = time_in_ms();
    AUDIOGEN_CHECK(autoencoder_encoder_model.Run(encoder_inputs, encoder_outputs));
    auto end_encoder = time_in_ms();

    // Copy the output to the output buffer
    const size_t encoder_output_num_elems = get_num_elems(encoder_out_type);
    {
        auto encoder_out_lock_and_ptr = scoped_lock<const float>(encoder_outputs[0],
                                                                 litert::TensorBuffer::LockMode::kRead);
        const auto* autoencoder_encoder_out_data = encoder_out_lock_and_ptr.second;
        encoded_audio.resize(encoder_output_num_elems);
        memcpy(encoded_audio.data(), autoencoder_encoder_out_data, encoder_output_num_elems * sizeof(float));
    }