/*

** Copyright (C) 1999-2019 Erik de Castro Lopo <erikd@mega-nerd.com>

**

** This program is free software; you can redistribute it and/or modify

** it under the terms of the GNU Lesser General Public License as published by

** the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.

**

** You should have received a copy of the GNU Lesser 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.

*/

#include "sfconfig.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include "sndfile.h"

#include "sfendian.h"

#include "common.h"

#include "wavlike.h"

#include "GSM610/gsm.h"

#define GSM610_BLOCKSIZE    33

#define GSM610_SAMPLES      160

typedef struct gsm610_tag

{ int       blocks ;

  int       blockcount, samplecount ;

  int       samplesperblock, blocksize ;

  int       (*decode_block) (SF_PRIVATE *psf, struct gsm610_tag *pgsm610) ;

  int       (*encode_block) (SF_PRIVATE *psf, struct gsm610_tag *pgsm610) ;

  short     samples [WAVLIKE_GSM610_SAMPLES] ;

  unsigned char block [WAVLIKE_GSM610_BLOCKSIZE] ;

  /* Damn I hate typedef-ed pointers; yes, gsm is a pointer type. */

  gsm       gsm_data ;

} GSM610_PRIVATE ;

static sf_count_t gsm610_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;

static sf_count_t gsm610_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;

static sf_count_t gsm610_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;

static sf_count_t gsm610_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;

static sf_count_t gsm610_write_s  (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;

static sf_count_t gsm610_write_i  (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;

static sf_count_t gsm610_write_f  (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;

static sf_count_t gsm610_write_d  (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;

static  int gsm610_read_block (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610, short *ptr, int len) ;

static  int gsm610_write_block  (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610, const short *ptr, int len) ;

static  int gsm610_decode_block (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610) ;

static  int gsm610_encode_block (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610) ;

static  int gsm610_wav_decode_block (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610) ;

static  int gsm610_wav_encode_block (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610) ;

static sf_count_t gsm610_seek (SF_PRIVATE *psf, int mode, sf_count_t offset) ;

static int  gsm610_close  (SF_PRIVATE *psf) ;

/*============================================================================================

** WAV GSM610 initialisation function.

*/

int

gsm610_init (SF_PRIVATE *psf)

{ GSM610_PRIVATE  *pgsm610 ;

  int   true_flag = 1 ;

  if (psf->codec_data != NULL)

  { psf_log_printf (psf, "*** psf->codec_data is not NULL.\n") ;

    return SFE_INTERNAL ;

    } ;

  if (psf->file.mode == SFM_RDWR)

    return SFE_BAD_MODE_RW ;

  psf->sf.seekable = SF_FALSE ;

  if ((pgsm610 = calloc (1, sizeof (GSM610_PRIVATE))) == NULL)

    return SFE_MALLOC_FAILED ;

  psf->codec_data = pgsm610 ;

  memset (pgsm610, 0, sizeof (GSM610_PRIVATE)) ;

/*============================================================

Need separate gsm_data structs for encode and decode.

============================================================*/

  if ((pgsm610->gsm_data = gsm_create ()) == NULL)

    return SFE_MALLOC_FAILED ;

  switch (SF_CONTAINER (psf->sf.format))

  { case SF_FORMAT_WAV :

    case SF_FORMAT_WAVEX :

    case SF_FORMAT_W64 :

      gsm_option (pgsm610->gsm_data, GSM_OPT_WAV49, &true_flag) ;

      pgsm610->encode_block = gsm610_wav_encode_block ;

      pgsm610->decode_block = gsm610_wav_decode_block ;

      pgsm610->samplesperblock = WAVLIKE_GSM610_SAMPLES ;

      pgsm610->blocksize = WAVLIKE_GSM610_BLOCKSIZE ;

      break ;

    case SF_FORMAT_AIFF :

    case SF_FORMAT_RAW :

      pgsm610->encode_block = gsm610_encode_block ;

      pgsm610->decode_block = gsm610_decode_block ;

      pgsm610->samplesperblock = GSM610_SAMPLES ;

      pgsm610->blocksize = GSM610_BLOCKSIZE ;

      break ;

    default :

      return SFE_INTERNAL ;

      break ;

    } ;

  if (psf->file.mode == SFM_READ)

  { if (psf->datalength % pgsm610->blocksize == 0)

      pgsm610->blocks = psf->datalength / pgsm610->blocksize ;

    else if (psf->datalength % pgsm610->blocksize == 1 && pgsm610->blocksize == GSM610_BLOCKSIZE)

    { /*

      **  Weird AIFF specific case.

      **  AIFF chunks must be at an even offset from the start of file and

      **  GSM610_BLOCKSIZE is odd which can result in an odd length SSND

      **  chunk. The SSND chunk then gets padded on write which means that

      **  when it is read the datalength is too big by 1.

      */

      pgsm610->blocks = psf->datalength / pgsm610->blocksize ;

      }

    else

    { psf_log_printf (psf, "*** Warning : data chunk seems to be truncated.\n") ;

      pgsm610->blocks = psf->datalength / pgsm610->blocksize + 1 ;

      } ;

    psf->sf.frames = (sf_count_t) pgsm610->samplesperblock * pgsm610->blocks ;

    psf_fseek (psf, psf->dataoffset, SEEK_SET) ;

    pgsm610->decode_block (psf, pgsm610) ;  /* Read first block. */

    psf->read_short   = gsm610_read_s ;

    psf->read_int   = gsm610_read_i ;

    psf->read_float   = gsm610_read_f ;

    psf->read_double  = gsm610_read_d ;

    } ;

  if (psf->file.mode == SFM_WRITE)

  { pgsm610->blockcount = 0 ;

    pgsm610->samplecount = 0 ;

    psf->write_short  = gsm610_write_s ;

    psf->write_int    = gsm610_write_i ;

    psf->write_float  = gsm610_write_f ;

    psf->write_double = gsm610_write_d ;

    } ;

  psf->codec_close = gsm610_close ;

  psf->seek = gsm610_seek ;

  psf->filelength = psf_get_filelen (psf) ;

  psf->datalength = psf->filelength - psf->dataoffset ;

  return 0 ;

} /* gsm610_init */

/*============================================================================================

** GSM 6.10 Read Functions.

*/

static int

gsm610_wav_decode_block (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610)

{ int k ;

  pgsm610->blockcount ++ ;

  pgsm610->samplecount = 0 ;

  if (pgsm610->blockcount > pgsm610->blocks)

  { memset (pgsm610->samples, 0, sizeof (pgsm610->samples)) ;

    return 1 ;

    } ;

  if ((k = (int) psf_fread (pgsm610->block, 1, WAVLIKE_GSM610_BLOCKSIZE, psf)) != WAVLIKE_GSM610_BLOCKSIZE)

    psf_log_printf (psf, "*** Warning : short read (%d != %d).\n", k, WAVLIKE_GSM610_BLOCKSIZE) ;

  if (gsm_decode (pgsm610->gsm_data, pgsm610->block, pgsm610->samples) < 0)

  { psf_log_printf (psf, "Error from WAV gsm_decode() on frame : %d\n", pgsm610->blockcount) ;

    return 0 ;

    } ;

  if (gsm_decode (pgsm610->gsm_data, pgsm610->block + (WAVLIKE_GSM610_BLOCKSIZE + 1) / 2, pgsm610->samples + WAVLIKE_GSM610_SAMPLES / 2) < 0)

  { psf_log_printf (psf, "Error from WAV gsm_decode() on frame : %d.5\n", pgsm610->blockcount) ;

    return 0 ;

    } ;

  return 1 ;

} /* gsm610_wav_decode_block */

static int

gsm610_decode_block (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610)

{ int k ;

  pgsm610->blockcount ++ ;

  pgsm610->samplecount = 0 ;

  if (pgsm610->blockcount > pgsm610->blocks)

  { memset (pgsm610->samples, 0, sizeof (pgsm610->samples)) ;

    return 1 ;

    } ;

  if ((k = (int) psf_fread (pgsm610->block, 1, GSM610_BLOCKSIZE, psf)) != GSM610_BLOCKSIZE)

    psf_log_printf (psf, "*** Warning : short read (%d != %d).\n", k, GSM610_BLOCKSIZE) ;

  if (gsm_decode (pgsm610->gsm_data, pgsm610->block, pgsm610->samples) < 0)

  { psf_log_printf (psf, "Error from standard gsm_decode() on frame : %d\n", pgsm610->blockcount) ;

    return 0 ;

    } ;

  return 1 ;

} /* gsm610_decode_block */

static int

gsm610_read_block (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610, short *ptr, int len)

{ int count, total = 0, indx = 0 ;

  while (indx < len)

  { if (pgsm610->blockcount >= pgsm610->blocks && pgsm610->samplecount >= pgsm610->samplesperblock)

    { memset (ptr + indx, 0, (len - indx) * sizeof (short)) ;

      return total ;

      } ;

    if (pgsm610->samplecount >= pgsm610->samplesperblock)

      pgsm610->decode_block (psf, pgsm610) ;

    count = pgsm610->samplesperblock - pgsm610->samplecount ;

    count = (len - indx > count) ? count : len - indx ;

    memcpy (&(ptr [indx]), &(pgsm610->samples [pgsm610->samplecount]), count * sizeof (short)) ;

    indx += count ;

    pgsm610->samplecount += count ;

    total = indx ;

    } ;

  return total ;

} /* gsm610_read_block */

static sf_count_t

gsm610_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len)

{ GSM610_PRIVATE  *pgsm610 ;

  int     readcount, count ;

  sf_count_t  total = 0 ;

  if (psf->codec_data == NULL)

    return 0 ;

  pgsm610 = (GSM610_PRIVATE*) psf->codec_data ;

  while (len > 0)

  { readcount = (len > 0x10000000) ? 0x1000000 : (int) len ;

    count = gsm610_read_block (psf, pgsm610, ptr, readcount) ;

    total += count ;

    len -= count ;

    if (count != readcount)

      break ;

    } ;

  return total ;

} /* gsm610_read_s */

static sf_count_t

gsm610_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len)

{ GSM610_PRIVATE *pgsm610 ;

  BUF_UNION ubuf ;

  short   *sptr ;

  int     k, bufferlen, readcount = 0, count ;

  sf_count_t  total = 0 ;

  if (psf->codec_data == NULL)

    return 0 ;

  pgsm610 = (GSM610_PRIVATE*) psf->codec_data ;

  sptr = ubuf.sbuf ;

  bufferlen = ARRAY_LEN (ubuf.sbuf) ;

  while (len > 0)

  { readcount = (len >= bufferlen) ? bufferlen : (int) len ;

    count = gsm610_read_block (psf, pgsm610, sptr, readcount) ;

    for (k = 0 ; k < readcount ; k++)

      ptr [total + k] = arith_shift_left (sptr [k], 16) ;

    total += count ;

    len -= readcount ;

    } ;

  return total ;

} /* gsm610_read_i */

static sf_count_t

gsm610_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len)

{ GSM610_PRIVATE *pgsm610 ;

  BUF_UNION ubuf ;

  short   *sptr ;

  int     k, bufferlen, readcount = 0, count ;

  sf_count_t  total = 0 ;

  float   normfact ;

  if (psf->codec_data == NULL)

    return 0 ;

  pgsm610 = (GSM610_PRIVATE*) psf->codec_data ;

  normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x8000) : 1.0 ;

  sptr = ubuf.sbuf ;

  bufferlen = ARRAY_LEN (ubuf.sbuf) ;

  while (len > 0)

  { readcount = (len >= bufferlen) ? bufferlen : (int) len ;

    count = gsm610_read_block (psf, pgsm610, sptr, readcount) ;

    for (k = 0 ; k < readcount ; k++)

      ptr [total + k] = normfact * sptr [k] ;

    total += count ;

    len -= readcount ;

    } ;

  return total ;

} /* gsm610_read_f */

static sf_count_t

gsm610_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len)

{ GSM610_PRIVATE *pgsm610 ;

  BUF_UNION ubuf ;

  short   *sptr ;

  int     k, bufferlen, readcount = 0, count ;

  sf_count_t  total = 0 ;

  double    normfact ;

  normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x8000) : 1.0 ;

  if (psf->codec_data == NULL)

    return 0 ;

  pgsm610 = (GSM610_PRIVATE*) psf->codec_data ;

  sptr = ubuf.sbuf ;

  bufferlen = ARRAY_LEN (ubuf.sbuf) ;

  while (len > 0)

  { readcount = (len >= bufferlen) ? bufferlen : (int) len ;

    count = gsm610_read_block (psf, pgsm610, sptr, readcount) ;

    for (k = 0 ; k < readcount ; k++)

      ptr [total + k] = normfact * sptr [k] ;

    total += count ;

    len -= readcount ;

    } ;

  return total ;

} /* gsm610_read_d */

static sf_count_t

gsm610_seek (SF_PRIVATE *psf, int UNUSED (mode), sf_count_t offset)

{ GSM610_PRIVATE *pgsm610 ;

  int     newblock, newsample ;

  if (psf->codec_data == NULL)

    return 0 ;

  pgsm610 = (GSM610_PRIVATE*) psf->codec_data ;

  if (psf->dataoffset < 0)

  { psf->error = SFE_BAD_SEEK ;

    return  PSF_SEEK_ERROR ;

    } ;

  if (offset == 0)

  { int true_flag = 1 ;

    psf_fseek (psf, psf->dataoffset, SEEK_SET) ;

    pgsm610->blockcount = 0 ;

    gsm_init (pgsm610->gsm_data) ;

    if ((SF_CONTAINER (psf->sf.format)) == SF_FORMAT_WAV ||

        (SF_CONTAINER (psf->sf.format)) == SF_FORMAT_W64)

      gsm_option (pgsm610->gsm_data, GSM_OPT_WAV49, &true_flag) ;

    pgsm610->decode_block (psf, pgsm610) ;

    pgsm610->samplecount = 0 ;

    return 0 ;

    } ;

  if (offset < 0 || offset > pgsm610->blocks * pgsm610->samplesperblock)

  { psf->error = SFE_BAD_SEEK ;

    return  PSF_SEEK_ERROR ;

    } ;

  newblock  = offset / pgsm610->samplesperblock ;

  newsample = offset % pgsm610->samplesperblock ;

  if (psf->file.mode == SFM_READ)

  { if (psf->read_current != newblock * pgsm610->samplesperblock + newsample)

    { psf_fseek (psf, psf->dataoffset + newblock * pgsm610->samplesperblock, SEEK_SET) ;

      pgsm610->blockcount = newblock ;

      pgsm610->decode_block (psf, pgsm610) ;

      pgsm610->samplecount = newsample ;

      } ;

    return newblock * pgsm610->samplesperblock + newsample ;

    } ;

  /* What to do about write??? */

  psf->error = SFE_BAD_SEEK ;

  return  PSF_SEEK_ERROR ;

} /* gsm610_seek */

/*==========================================================================================

** GSM 6.10 Write Functions.

*/

static int

gsm610_encode_block (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610)

{ int k ;

  /* Encode the samples. */

  gsm_encode (pgsm610->gsm_data, pgsm610->samples, pgsm610->block) ;

  /* Write the block to disk. */

  if ((k = (int) psf_fwrite (pgsm610->block, 1, GSM610_BLOCKSIZE, psf)) != GSM610_BLOCKSIZE)

    psf_log_printf (psf, "*** Warning : short write (%d != %d).\n", k, GSM610_BLOCKSIZE) ;

  pgsm610->samplecount = 0 ;

  pgsm610->blockcount ++ ;

  /* Set samples to zero for next block. */

  memset (pgsm610->samples, 0, sizeof (pgsm610->samples)) ;

  return 1 ;

} /* gsm610_encode_block */

static int

gsm610_wav_encode_block (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610)

{ int k ;

  /* Encode the samples. */

  gsm_encode (pgsm610->gsm_data, pgsm610->samples, pgsm610->block) ;

  gsm_encode (pgsm610->gsm_data, pgsm610->samples+WAVLIKE_GSM610_SAMPLES / 2, pgsm610->block+WAVLIKE_GSM610_BLOCKSIZE / 2) ;

  /* Write the block to disk. */

  if ((k = (int) psf_fwrite (pgsm610->block, 1, WAVLIKE_GSM610_BLOCKSIZE, psf)) != WAVLIKE_GSM610_BLOCKSIZE)

    psf_log_printf (psf, "*** Warning : short write (%d != %d).\n", k, WAVLIKE_GSM610_BLOCKSIZE) ;

  pgsm610->samplecount = 0 ;

  pgsm610->blockcount ++ ;

  /* Set samples to zero for next block. */

  memset (pgsm610->samples, 0, sizeof (pgsm610->samples)) ;

  return 1 ;

} /* gsm610_wav_encode_block */

static int

gsm610_write_block  (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610, const short *ptr, int len)

{ int   count, total = 0, indx = 0 ;

  while (indx < len)

  { count = pgsm610->samplesperblock - pgsm610->samplecount ;

    if (count > len - indx)

      count = len - indx ;

    memcpy (&(pgsm610->samples [pgsm610->samplecount]), &(ptr [indx]), count * sizeof (short)) ;

    indx += count ;

    pgsm610->samplecount += count ;

    total = indx ;

    if (pgsm610->samplecount >= pgsm610->samplesperblock)

      pgsm610->encode_block (psf, pgsm610) ;

    } ;

  return total ;

} /* gsm610_write_block */

static sf_count_t

gsm610_write_s  (SF_PRIVATE *psf, const short *ptr, sf_count_t len)

{ GSM610_PRIVATE  *pgsm610 ;

  int     writecount, count ;

  sf_count_t  total = 0 ;

  if (psf->codec_data == NULL)

    return 0 ;

  pgsm610 = (GSM610_PRIVATE*) psf->codec_data ;

  while (len > 0)

  { writecount = (len > 0x10000000) ? 0x10000000 : (int) len ;

    count = gsm610_write_block (psf, pgsm610, ptr, writecount) ;

    total += count ;

    len -= count ;

    if (count != writecount)

      break ;

    } ;

  return total ;

} /* gsm610_write_s */

static sf_count_t

gsm610_write_i  (SF_PRIVATE *psf, const int *ptr, sf_count_t len)

{ GSM610_PRIVATE *pgsm610 ;

  BUF_UNION ubuf ;

  short   *sptr ;

  int     k, bufferlen, writecount = 0, count ;

  sf_count_t  total = 0 ;

  if (psf->codec_data == NULL)

    return 0 ;

  pgsm610 = (GSM610_PRIVATE*) psf->codec_data ;

  sptr = ubuf.sbuf ;

  bufferlen = ARRAY_LEN (ubuf.sbuf) ;

  while (len > 0)

  { writecount = (len >= bufferlen) ? bufferlen : (int) len ;

    for (k = 0 ; k < writecount ; k++)

      sptr [k] = ptr [total + k] >> 16 ;

    count = gsm610_write_block (psf, pgsm610, sptr, writecount) ;

    total += count ;

    len -= writecount ;

    } ;

  return total ;

} /* gsm610_write_i */

static sf_count_t

gsm610_write_f  (SF_PRIVATE *psf, const float *ptr, sf_count_t len)

{ GSM610_PRIVATE *pgsm610 ;

  BUF_UNION ubuf ;

  short   *sptr ;

  int     k, bufferlen, writecount = 0, count ;

  sf_count_t  total = 0 ;

  float   normfact ;

  if (psf->codec_data == NULL)

    return 0 ;

  pgsm610 = (GSM610_PRIVATE*) psf->codec_data ;

  normfact = (psf->norm_float == SF_TRUE) ? (1.0 * 0x7FFF) : 1.0 ;

  sptr = ubuf.sbuf ;

  bufferlen = ARRAY_LEN (ubuf.sbuf) ;

  while (len > 0)

  { writecount = (len >= bufferlen) ? bufferlen : (int) len ;

    for (k = 0 ; k < writecount ; k++)

      sptr [k] = psf_lrintf (normfact * ptr [total + k]) ;

    count = gsm610_write_block (psf, pgsm610, sptr, writecount) ;

    total += count ;

    len -= writecount ;

    if (count != writecount)

      break ;

    } ;

  return total ;

} /* gsm610_write_f */

static sf_count_t

gsm610_write_d  (SF_PRIVATE *psf, const double *ptr, sf_count_t len)

{ GSM610_PRIVATE *pgsm610 ;

  BUF_UNION ubuf ;

  short   *sptr ;

  int     k, bufferlen, writecount = 0, count ;

  sf_count_t  total = 0 ;

  double    normfact ;

  if (psf->codec_data == NULL)

    return 0 ;

  pgsm610 = (GSM610_PRIVATE*) psf->codec_data ;

  normfact = (psf->norm_double == SF_TRUE) ? (1.0 * 0x7FFF) : 1.0 ;

  sptr = ubuf.sbuf ;

  bufferlen = ARRAY_LEN (ubuf.sbuf) ;

  while (len > 0)

  { writecount = (len >= bufferlen) ? bufferlen : (int) len ;

    for (k = 0 ; k < writecount ; k++)

      sptr [k] = psf_lrint (normfact * ptr [total + k]) ;

    count = gsm610_write_block (psf, pgsm610, sptr, writecount) ;

    total += count ;

    len -= writecount ;

    } ;

  return total ;

} /* gsm610_write_d */

static int

gsm610_close  (SF_PRIVATE *psf)

{ GSM610_PRIVATE *pgsm610 ;

  if (psf->codec_data == NULL)

    return 0 ;

  pgsm610 = (GSM610_PRIVATE*) psf->codec_data ;

  if (psf->file.mode == SFM_WRITE)

  { /*  If a block has been partially assembled, write it out

    **  as the final block.

    */

    if (pgsm610->samplecount && pgsm610->samplecount < pgsm610->samplesperblock)

      pgsm610->encode_block (psf, pgsm610) ;

    } ;

  if (pgsm610->gsm_data)

    gsm_destroy (pgsm610->gsm_data) ;

  return 0 ;

} /* gsm610_close */