Function bark_generate_audio

bark.cpp:2180–2227

}

bool bark_generate_audio(struct bark_context* bctx, const char* text, int n_threads) {
    if (!bctx) {
        fprintf(stderr, "%s: invalid bark context\n", __func__);
        return false;
    }

    bark_reset_statistics(bctx);

    int64_t t_start_eval_us = ggml_time_us();

    std::string text_str(text);
    bark_tokenize_input(bctx, text_str);

    if (!bark_forward_eval(bctx, n_threads)) {
        fprintf(stderr, "%s: failed to forward eval\n", __func__);
        return false;
    }

    auto& params = bctx->params;

    int32_t target_bandwidth = params.target_bandwidth;
    int32_t sample_rate = params.sample_rate;

    encodec_set_target_bandwidth(bctx->encodec_ctx, target_bandwidth);
    encodec_set_sample_rate(bctx->encodec_ctx, sample_rate);

    // current shape fine_tokens: [seq_length][n_channels], n_channels are contiguous
    // encodec expects shape fine_tokens: [n_channels][seq_length], time steps are contiguous
    std::vector<bark_vocab::id> encodec_tokens;

    for (int i = 0; i < (int)bctx->fine_tokens[0].size(); i++) {
        for (int j = 0; j < (int)bctx->fine_tokens.size(); j++) {
            encodec_tokens.push_back(bctx->fine_tokens[j][i]);
        }
    }

    if (!encodec_decompress_audio(bctx->encodec_ctx, encodec_tokens.data(), encodec_tokens.size(), n_threads)) {
        printf("%s: Could not generate waveform from tokens with Encodec\n", __func__);
        return false;
    }

    bctx->generated_audio = encodec_get_audio(bctx->encodec_ctx);
    bctx->n_generated_samples = encodec_get_audio_size(bctx->encodec_ctx);

    bctx->stats.t_eval_us = ggml_time_us() - t_start_eval_us;

    return true;
}

static void bark_free_model(struct gpt_model* model) {
    if (!model) {