/*
 *  Patch transfer callback for Emu10k1
 *
 *  Copyright (C) 2000 Takashi iwai <tiwai@suse.de>
 *
 *   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */
/*
 * All the code for loading in a patch.  There is very little that is
 * chip specific here.  Just the actual writing to the board.
 */

#include "emu10k1_synth_local.h"

/*
 */
#define BLANK_LOOP_START        4
#define BLANK_LOOP_END          8
#define BLANK_LOOP_SIZE         12
#define BLANK_HEAD_SIZE         32

/*
 * allocate a sample block and copy data from userspace
 */
int
snd_emu10k1_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp,
                       struct snd_util_memhdr *hdr,
                       const void __user *data, long count)
{
        int offset;
        int truesize, size, loopsize, blocksize;
        int loopend, sampleend;
        unsigned int start_addr;
        struct snd_emu10k1 *emu;

        emu = rec->hw;
        snd_assert(sp != NULL, return -EINVAL);
        snd_assert(hdr != NULL, return -EINVAL);

        if (sp->v.size == 0) {
                snd_printd("emu: rom font for sample %d\n", sp->v.sample);
                return 0;
        }

        /* recalculate address offset */
        sp->v.end -= sp->v.start;
        sp->v.loopstart -= sp->v.start;
        sp->v.loopend -= sp->v.start;
        sp->v.start = 0;

        /* some samples have invalid data.  the addresses are corrected in voice info */
        sampleend = sp->v.end;
        if (sampleend > sp->v.size)
                sampleend = sp->v.size;
        loopend = sp->v.loopend;
        if (loopend > sampleend)
                loopend = sampleend;

        /* be sure loop points start < end */
        if (sp->v.loopstart >= sp->v.loopend) {
                int tmp = sp->v.loopstart;
                sp->v.loopstart = sp->v.loopend;
                sp->v.loopend = tmp;
        }

        /* compute true data size to be loaded */
        truesize = sp->v.size + BLANK_HEAD_SIZE;
        loopsize = 0;
#if 0 /* not supported */
        if (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP|SNDRV_SFNT_SAMPLE_REVERSE_LOOP))
                loopsize = sp->v.loopend - sp->v.loopstart;
        truesize += loopsize;
#endif
        if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK)
                truesize += BLANK_LOOP_SIZE;

        /* try to allocate a memory block */
        blocksize = truesize;
        if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
                blocksize *= 2;
        sp->block = snd_emu10k1_synth_alloc(emu, blocksize);
        if (sp->block == NULL) {
                snd_printd("emu10k1: synth malloc failed (size=%d)\n", blocksize);
                /* not ENOMEM (for compatibility with OSS) */
                return -ENOSPC;
        }
        /* set the total size */
        sp->v.truesize = blocksize;

        /* write blank samples at head */
        offset = 0;
        size = BLANK_HEAD_SIZE;
        if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
                size *= 2;
        snd_assert(offset + size <= blocksize, return -EINVAL);
        snd_emu10k1_synth_bzero(emu, sp->block, offset, size);
        offset += size;

        /* copy start->loopend */
        size = loopend;
        if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
                size *= 2;
        snd_assert(offset + size <= blocksize, return -EINVAL);
        if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size)) {
                snd_emu10k1_synth_free(emu, sp->block);
                sp->block = NULL;
                return -EFAULT;
        }
        offset += size;
        data += size;

#if 0 /* not suppported yet */
        /* handle reverse (or bidirectional) loop */
        if (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP|SNDRV_SFNT_SAMPLE_REVERSE_LOOP)) {
                /* copy loop in reverse */
                if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS)) {
                        int woffset;
                        unsigned short *wblock = (unsigned short*)block;
                        woffset = offset / 2;
                        snd_assert(offset + loopsize*2 <= blocksize, return -EINVAL);
                        for (i = 0; i < loopsize; i++)
                                wblock[woffset + i] = wblock[woffset - i -1];
                        offset += loopsize * 2;
                } else {
                        snd_assert(offset + loopsize <= blocksize, return -EINVAL);
                        for (i = 0; i < loopsize; i++)
                                block[offset + i] = block[offset - i -1];
                        offset += loopsize;
                }

                /* modify loop pointers */
                if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_BIDIR_LOOP) {
                        sp->v.loopend += loopsize;
                } else {
                        sp->v.loopstart += loopsize;
                        sp->v.loopend += loopsize;
                }
                /* add sample pointer */
                sp->v.end += loopsize;
        }
#endif

        /* loopend -> sample end */
        size = sp->v.size - loopend;
        snd_assert(size >= 0, return -EINVAL);
        if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
                size *= 2;
        if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size)) {
                snd_emu10k1_synth_free(emu, sp->block);
                sp->block = NULL;
                return -EFAULT;
        }
        offset += size;

        /* clear rest of samples (if any) */
        if (offset < blocksize)
                snd_emu10k1_synth_bzero(emu, sp->block, offset, blocksize - offset);

        if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK) {
                /* if no blank loop is attached in the sample, add it */
                if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_SINGLESHOT) {
                        sp->v.loopstart = sp->v.end + BLANK_LOOP_START;
                        sp->v.loopend = sp->v.end + BLANK_LOOP_END;
                }
        }

#if 0 /* not supported yet */
        if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_UNSIGNED) {
                /* unsigned -> signed */
                if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS)) {
                        unsigned short *wblock = (unsigned short*)block;
                        for (i = 0; i < truesize; i++)
                                wblock[i] ^= 0x8000;
                } else {
                        for (i = 0; i < truesize; i++)
                                block[i] ^= 0x80;
                }
        }
#endif

        /* recalculate offset */
        start_addr = BLANK_HEAD_SIZE * 2;
        if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
                start_addr >>= 1;
        sp->v.start += start_addr;
        sp->v.end += start_addr;
        sp->v.loopstart += start_addr;
        sp->v.loopend += start_addr;

        return 0;
}

/*
 * free a sample block
 */
int
snd_emu10k1_sample_free(struct snd_emux *rec, struct snd_sf_sample *sp,
                        struct snd_util_memhdr *hdr)
{
        struct snd_emu10k1 *emu;

        emu = rec->hw;
        snd_assert(sp != NULL, return -EINVAL);
        snd_assert(hdr != NULL, return -EINVAL);

        if (sp->block) {
                snd_emu10k1_synth_free(emu, sp->block);
                sp->block = NULL;
        }
        return 0;
}