annotate src/sid/xs_slsup.c @ 3189:ab6c7ebcd301

alsa-ng: Only support 16bit output for now. Someone else can debug this crap.

/*
   XMMS-SID - SIDPlay input plugin for X MultiMedia System (XMMS)

   File information window

   Programmed and designed by Matti 'ccr' Hamalainen <[e-mail]>
   (C) Copyright 1999-2007 Tecnic Software productions (TNSP)

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "xs_slsup.h"
#include "xs_config.h"


static xs_sldb_t *xs_sldb_db = NULL;
XS_MUTEX(xs_sldb_db);

static xs_stildb_t *xs_stildb_db = NULL;
XS_MUTEX(xs_stildb_db);


/* STIL-database handling
 */
gint xs_stil_init(void)
{
    XS_MUTEX_LOCK(xs_cfg);

    if (!xs_cfg.stilDBPath) {
        XS_MUTEX_UNLOCK(xs_cfg);
        return -1;
    }

    XS_MUTEX_LOCK(xs_stildb_db);

    /* Check if already initialized */
    if (xs_stildb_db)
        xs_stildb_free(xs_stildb_db);

    /* Allocate database */
    xs_stildb_db = (xs_stildb_t *) g_malloc0(sizeof(xs_stildb_t));
    if (!xs_stildb_db) {
        XS_MUTEX_UNLOCK(xs_cfg);
        XS_MUTEX_UNLOCK(xs_stildb_db);
        return -2;
    }

    /* Read the database */
    if (xs_stildb_read(xs_stildb_db, xs_cfg.stilDBPath) != 0) {
        xs_stildb_free(xs_stildb_db);
        xs_stildb_db = NULL;
        XS_MUTEX_UNLOCK(xs_cfg);
        XS_MUTEX_UNLOCK(xs_stildb_db);
        return -3;
    }

    /* Create index */
    if (xs_stildb_index(xs_stildb_db) != 0) {
        xs_stildb_free(xs_stildb_db);
        xs_stildb_db = NULL;
        XS_MUTEX_UNLOCK(xs_cfg);
        XS_MUTEX_UNLOCK(xs_stildb_db);
        return -4;
    }

    XS_MUTEX_UNLOCK(xs_cfg);
    XS_MUTEX_UNLOCK(xs_stildb_db);
    return 0;
}


void xs_stil_close(void)
{
    XS_MUTEX_LOCK(xs_stildb_db);
    xs_stildb_free(xs_stildb_db);
    xs_stildb_db = NULL;
    XS_MUTEX_UNLOCK(xs_stildb_db);
}


stil_node_t *xs_stil_get(gchar *filename)
{
    stil_node_t *result;
    gchar *tmpFilename;

    XS_MUTEX_LOCK(xs_stildb_db);
    XS_MUTEX_LOCK(xs_cfg);

    if (xs_cfg.stilDBEnable && xs_stildb_db) {
        if (xs_cfg.hvscPath) {
            /* Remove postfixed directory separator from HVSC-path */
            tmpFilename = xs_strrchr(xs_cfg.hvscPath, '/');
            if (tmpFilename && (tmpFilename[1] == 0))
                tmpFilename[0] = 0;

            /* Remove HVSC location-prefix from filename */
            tmpFilename = strstr(filename, xs_cfg.hvscPath);
            if (tmpFilename)
                tmpFilename += strlen(xs_cfg.hvscPath);
            else
                tmpFilename = filename;
        } else
            tmpFilename = filename;

        result = xs_stildb_get_node(xs_stildb_db, tmpFilename);
    } else
        result = NULL;

    XS_MUTEX_UNLOCK(xs_stildb_db);
    XS_MUTEX_UNLOCK(xs_cfg);

    return result;
}


/* Song length database handling glue
 */
gint xs_songlen_init(void)
{
    XS_MUTEX_LOCK(xs_cfg);

    if (!xs_cfg.songlenDBPath) {
        XS_MUTEX_UNLOCK(xs_cfg);
        return -1;
    }

    XS_MUTEX_LOCK(xs_sldb_db);

    /* Check if already initialized */
    if (xs_sldb_db)
        xs_sldb_free(xs_sldb_db);

    /* Allocate database */
    xs_sldb_db = (xs_sldb_t *) g_malloc0(sizeof(xs_sldb_t));
    if (!xs_sldb_db) {
        XS_MUTEX_UNLOCK(xs_cfg);
        XS_MUTEX_UNLOCK(xs_sldb_db);
        return -2;
    }

    /* Read the database */
    if (xs_sldb_read(xs_sldb_db, xs_cfg.songlenDBPath) != 0) {
        xs_sldb_free(xs_sldb_db);
        xs_sldb_db = NULL;
        XS_MUTEX_UNLOCK(xs_cfg);
        XS_MUTEX_UNLOCK(xs_sldb_db);
        return -3;
    }

    /* Create index */
    if (xs_sldb_index(xs_sldb_db) != 0) {
        xs_sldb_free(xs_sldb_db);
        xs_sldb_db = NULL;
        XS_MUTEX_UNLOCK(xs_cfg);
        XS_MUTEX_UNLOCK(xs_sldb_db);
        return -4;
    }

    XS_MUTEX_UNLOCK(xs_cfg);
    XS_MUTEX_UNLOCK(xs_sldb_db);
    return 0;
}


void xs_songlen_close(void)
{
    XS_MUTEX_LOCK(xs_sldb_db);
    xs_sldb_free(xs_sldb_db);
    xs_sldb_db = NULL;
    XS_MUTEX_UNLOCK(xs_sldb_db);
}


sldb_node_t *xs_songlen_get(const gchar * filename)
{
    sldb_node_t *result;

    XS_MUTEX_LOCK(xs_sldb_db);

    if (xs_cfg.songlenDBEnable && xs_sldb_db)
        result = xs_sldb_get(xs_sldb_db, filename);
    else
        result = NULL;

    XS_MUTEX_UNLOCK(xs_sldb_db);

    return result;
}


/* Allocate a new tune information structure
 */
xs_tuneinfo_t *xs_tuneinfo_new(const gchar * filename,
        gint nsubTunes, gint startTune, const gchar * sidName,
        const gchar * sidComposer, const gchar * sidCopyright,
        gint loadAddr, gint initAddr, gint playAddr,
        gint dataFileLen, const gchar *sidFormat, gint sidModel)
{
    xs_tuneinfo_t *result;
    sldb_node_t *tmpLength;
    gint i;

    /* Allocate structure */
    result = (xs_tuneinfo_t *) g_malloc0(sizeof(xs_tuneinfo_t));
    if (!result) {
        xs_error("Could not allocate memory for tuneinfo ('%s')\n",
            filename);
        return NULL;
    }

    result->sidFilename = XS_CS_FILENAME(filename);
    if (!result->sidFilename) {
        xs_error("Could not allocate sidFilename ('%s')\n",
            filename);
        g_free(result);
        return NULL;
    }

    /* Allocate space for subtune information */
    result->subTunes = g_malloc0(sizeof(xs_subtuneinfo_t) * (nsubTunes + 1));
    if (!result->subTunes) {
        xs_error("Could not allocate memory for subtuneinfo ('%s', %i)\n",
            filename, nsubTunes);

        g_free(result->sidFilename);
        g_free(result);
        return NULL;
    }

    /* The following allocations don't matter if they fail */
    result->sidName = XS_CS_SID(sidName);
    result->sidComposer = XS_CS_SID(sidComposer);
    result->sidCopyright = XS_CS_SID(sidCopyright);

    result->nsubTunes = nsubTunes;
    result->startTune = startTune;

    result->loadAddr = loadAddr;
    result->initAddr = initAddr;
    result->playAddr = playAddr;
    result->dataFileLen = dataFileLen;
    result->sidFormat = XS_CS_SID(sidFormat);
    
    result->sidModel = sidModel;

    /* Get length information (NOTE: Do not free this!) */
    tmpLength = xs_songlen_get(filename);
    
    /* Fill in sub-tune information */
    for (i = 0; i < result->nsubTunes; i++) {
        if (tmpLength && (i < tmpLength->nlengths))
            result->subTunes[i].tuneLength = tmpLength->lengths[i];
        else
            result->subTunes[i].tuneLength = -1;
        
        result->subTunes[i].tuneSpeed = -1;
    }
    
    return result;
}


/* Free given tune information structure
 */
void xs_tuneinfo_free(xs_tuneinfo_t * tune)
{
    if (!tune) return;

    g_free(tune->subTunes);
    g_free(tune->sidFilename);
    g_free(tune->sidName);
    g_free(tune->sidComposer);
    g_free(tune->sidCopyright);
    g_free(tune->sidFormat);
    g_free(tune);
}