SDL_libretro_options.h

Go to the documentation of this file.

 
#if defined(SDL_LIBRETRO_IMPLEMENTATION) && !defined(SDL_LIBRETRO_OPTIONS_IMPL_ONCE)
#define SDL_LIBRETRO_OPTIONS_IMPL_ONCE
 
static char* SDL_Libretro_Strdup(const char* s) {
    if (!s) return SDL_strdup("");
    return SDL_strdup(s);
}
 
static void SDL_Libretro_InitCoreOption(SDL_Libretro* lr, const char* key, const char* defaultValue,
    const char* desc, const struct retro_core_option_value* values,
    const char* info, const char* categoryKey) {
    if (!lr || !key) return;
 
    // Check if already registered. Re-registration is intentionally ignored:
    // the first definition wins, so an option's declared values and default stay
    // stable for the life of the core.
    if (SDL_Libretro_GetOption(lr, key)) {
        return;
    }
 
    // Grow array if needed
    if (lr->core.optionCount >= lr->core.optionCapacity) {
        unsigned newCap = lr->core.optionCapacity ? lr->core.optionCapacity * 2 : 16;
        SDL_LibretroOption* newOpts = (SDL_LibretroOption*)SDL_realloc(lr->core.options, newCap * sizeof(SDL_LibretroOption));
        if (!newOpts) return;
        lr->core.options = newOpts;
        lr->core.optionCapacity = newCap;
    }
 
    // Set the option; strings are deep-copied and owned by the context.
    SDL_LibretroOption* slot = &lr->core.options[lr->core.optionCount];
    slot->key = SDL_Libretro_Strdup(key);
    slot->value = SDL_Libretro_Strdup(defaultValue);
    slot->defaultValue = SDL_Libretro_Strdup(defaultValue);
    slot->desc = SDL_Libretro_Strdup(desc);
    slot->info = SDL_Libretro_Strdup(info);
    slot->category = SDL_Libretro_Strdup(categoryKey);
    slot->visible = true;
 
    // The available values.
    slot->values = NULL;
    slot->valuesCount = 0;
    slot->valuesCapacity = 0;
    if (values) {
        // Count how many values there are available for the option.
        unsigned count = 0;
        while (values[count].value) count++;
 
        // Build the available values.
        if (count > 0) {
            slot->values = (SDL_LibretroOptionValue*)SDL_calloc(count, sizeof(SDL_LibretroOptionValue));
            if (slot->values) {
                slot->valuesCapacity = count;
                for (unsigned v = 0; v < count; v++) {
                    slot->values[v].value = SDL_Libretro_Strdup(values[v].value);
                    slot->values[v].label = values[v].label ? SDL_Libretro_Strdup(values[v].label) : NULL;
                    slot->valuesCount++;
                }
            }
        }
    }
 
    lr->core.optionCount++;
}
 
static void SDL_Libretro_InitCoreOptionCategory(SDL_Libretro* lr, const char* key,
    const char* desc, const char* info) {
    if (!lr || !key || key[0] == '\0') return;
 
    // Check if already registered
    for (unsigned i = 0; i < lr->core.optionCategoryCount; i++) {
        if (lr->core.optionCategories[i].key && SDL_strcmp(lr->core.optionCategories[i].key, key) == 0) {
            return;
        }
    }
 
    // Grow array if needed
    if (lr->core.optionCategoryCount >= lr->core.optionCategoryCapacity) {
        unsigned newCap = lr->core.optionCategoryCapacity ? lr->core.optionCategoryCapacity * 2 : 8;
        SDL_LibretroCategory* newCats = (SDL_LibretroCategory*)SDL_realloc(lr->core.optionCategories, newCap * sizeof(SDL_LibretroCategory));
        if (!newCats) return;
        lr->core.optionCategories = newCats;
        lr->core.optionCategoryCapacity = newCap;
    }
 
    // Set the category; strings are deep-copied and owned by the context.
    SDL_LibretroCategory* cat = &lr->core.optionCategories[lr->core.optionCategoryCount];
    cat->key = SDL_Libretro_Strdup(key);
    cat->desc = SDL_Libretro_Strdup(desc);
    cat->info = SDL_Libretro_Strdup(info);
 
    lr->core.optionCategoryCount++;
}
 
static void SDL_Libretro_FreeCoreOptions(SDL_Libretro* lr) {
    if (!lr) return;
 
    // Options
    if (lr->core.options) {
        for (unsigned i = 0; i < lr->core.optionCount; i++) {
            SDL_LibretroOption* opt = &lr->core.options[i];
            SDL_free((void*)opt->key);
            SDL_free((void*)opt->value);
            SDL_free((void*)opt->defaultValue);
            SDL_free((void*)opt->desc);
            SDL_free((void*)opt->info);
            SDL_free((void*)opt->category);
            for (unsigned v = 0; v < opt->valuesCount; v++) {
                SDL_free((void*)opt->values[v].value);
                SDL_free((void*)opt->values[v].label);
            }
            SDL_free(opt->values);
        }
        SDL_free(lr->core.options);
        lr->core.options = NULL;
    }
    lr->core.optionCount = 0;
    lr->core.optionCapacity = 0;
 
    // Categories
    if (lr->core.optionCategories) {
        for (unsigned i = 0; i < lr->core.optionCategoryCount; i++) {
            SDL_free((void*)lr->core.optionCategories[i].key);
            SDL_free((void*)lr->core.optionCategories[i].desc);
            SDL_free((void*)lr->core.optionCategories[i].info);
        }
        SDL_free(lr->core.optionCategories);
        lr->core.optionCategories = NULL;
    }
    lr->core.optionCategoryCount = 0;
    lr->core.optionCategoryCapacity = 0;
}
 
unsigned SDL_Libretro_GetOptionCount(const SDL_Libretro* lr) {
    return lr ? lr->core.optionCount : 0;
}
 
const SDL_LibretroOption* SDL_Libretro_GetOption(const SDL_Libretro* lr, const char* key) {
    if (!lr || !key) return NULL;
    for (unsigned i = 0; i < lr->core.optionCount; i++) {
        if (lr->core.options[i].key && SDL_strcmp(lr->core.options[i].key, key) == 0) {
            return &lr->core.options[i];
        }
    }
    return NULL;
}
 
const SDL_LibretroOption* SDL_Libretro_GetOptionByIndex(const SDL_Libretro* lr, unsigned index) {
    if (!lr || index >= lr->core.optionCount) return NULL;
    return &lr->core.options[index];
}
 
bool SDL_Libretro_SetOptionValue(SDL_Libretro* lr, const char* key, const char* value) {
    if (!lr || !key || !value) return false;
    SDL_LibretroOption* opt = (SDL_LibretroOption*)SDL_Libretro_GetOption(lr, key);
    if (!opt) return false;
 
    // Reject values the core never offered, so GET_VARIABLE only ever hands the
    // core a value it declared. Options with no declared values accept anything.
    if (opt->valuesCount > 0) {
        bool valid = false;
        for (unsigned v = 0; v < opt->valuesCount; v++) {
            if (opt->values[v].value && SDL_strcmp(opt->values[v].value, value) == 0) {
                valid = true;
                break;
            }
        }
        if (!valid) {
            return SDL_SetError("[SDL_Libretro] '%s' is not a valid value for option '%s'", value, key);
        }
    }
 
    SDL_free((void*)opt->value);
    opt->value = SDL_strdup(value);
    lr->core.optionsDirty = true;
    return true;
}
 
const char* SDL_Libretro_GetOptionValue(SDL_Libretro* lr, const char* key) {
    const SDL_LibretroOption* opt = SDL_Libretro_GetOption(lr, key);
    if (!opt) return NULL;
    return opt->value;
}
 
const char* SDL_Libretro_GetOptionValueLabel(SDL_Libretro* lr, const char* key) {
    const SDL_LibretroOption* opt = SDL_Libretro_GetOption(lr, key);
    if (!opt || !opt->value) return NULL;
    for (unsigned v = 0; v < opt->valuesCount; v++) {
        if (opt->values[v].value && SDL_strcmp(opt->values[v].value, opt->value) == 0) {
            return opt->values[v].label ? opt->values[v].label : opt->values[v].value;
        }
    }
    return opt->value;
}
 
bool SDL_Libretro_CycleOptionValue(SDL_Libretro* lr, const char* key, int direction) {
    if (direction == 0) return false;
    SDL_LibretroOption* opt = (SDL_LibretroOption*)SDL_Libretro_GetOption(lr, key);
    if (!opt || opt->valuesCount == 0) return false;
 
    // Find the current value's index; default to 0 if it isn't in the list.
    unsigned current = 0;
    for (unsigned v = 0; v < opt->valuesCount; v++) {
        if (opt->values[v].value && opt->value && SDL_strcmp(opt->values[v].value, opt->value) == 0) {
            current = v;
            break;
        }
    }
 
    unsigned count = opt->valuesCount;
    unsigned step = (direction > 0) ? 1 : count - 1;
    unsigned next = (current + step) % count;
    return SDL_Libretro_SetOptionValue(lr, key, opt->values[next].value);
}
 
bool SDL_Libretro_ResetOption(SDL_Libretro* lr, const char* key) {
    SDL_LibretroOption* opt = (SDL_LibretroOption*)SDL_Libretro_GetOption(lr, key);
    if (!opt) return false;
    SDL_free((void*)opt->value);
    opt->value = SDL_strdup(opt->defaultValue);
    lr->core.optionsDirty = true;
    return true;
}
 
void SDL_Libretro_ResetAllOptions(SDL_Libretro* lr) {
    if (!lr) return;
    for (unsigned i = 0; i < lr->core.optionCount; i++) {
        SDL_LibretroOption* opt = &lr->core.options[i];
        SDL_free((void*)opt->value);
        opt->value = SDL_strdup(opt->defaultValue);
    }
    lr->core.optionsDirty = true;
}
 
bool SDL_Libretro_AreOptionsDirty(SDL_Libretro* lr) {
    if (!lr) return false;
    bool dirty = lr->core.optionsDirty;
    lr->core.optionsDirty = false;
    return dirty;
}
 
bool SDL_Libretro_UpdateOptionVisibility(SDL_Libretro* lr) {
    if (!lr || !lr->core.optionsUpdateDisplayCallback) return false;
    return lr->core.optionsUpdateDisplayCallback();
}
 
unsigned SDL_Libretro_GetCategoryCount(const SDL_Libretro* lr) {
    return lr ? lr->core.optionCategoryCount : 0;
}
 
const SDL_LibretroCategory* SDL_Libretro_GetCategory(const SDL_Libretro* lr, const char* key) {
    if (!lr || !key) return NULL;
    for (unsigned i = 0; i < lr->core.optionCategoryCount; i++) {
        if (lr->core.optionCategories[i].key && SDL_strcmp(lr->core.optionCategories[i].key, key) == 0) {
            return &lr->core.optionCategories[i];
        }
    }
    return NULL;
}
 
const SDL_LibretroCategory* SDL_Libretro_GetCategoryByIndex(const SDL_Libretro* lr, unsigned index) {
    if (!lr || index >= lr->core.optionCategoryCount) return NULL;
    return &lr->core.optionCategories[index];
}
 
#endif /* SDL_LIBRETRO_OPTIONS_IMPL_ONCE */