/* Mednafen - Multi-system Emulator
 *
 *  Subchannel Q CRC Code:  Copyright (C) 1998  Andreas Mueller <mueller@daneb.ping.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
 */

#include "CDUtility.h"
#include "edc_crc32.h"
#include "galois.h"
#include "l-ec.h"
#include "recover-raw.h"
#include "lec.h"

#include <assert.h>

/* lookup table for crc calculation */
static uint16_t subq_crctab[256] = 
{
   0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108,
   0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210,
   0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B,
   0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401,
   0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE,
   0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6,
   0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D,
   0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
   0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5,
   0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC,
   0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87, 0x4CE4,
   0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD,
   0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13,
   0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A,
   0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E,
   0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
   0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1,
   0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB,
   0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0,
   0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8,
   0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657,
   0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9,
   0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882,
   0x28A3, 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
   0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E,
   0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07,
   0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D,
   0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74,
   0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
};


static uint8_t cdutil_scramble_table[2352 - 12];

static bool CDUtility_Inited = false;

static void InitScrambleTable(void)
{
   unsigned i, b;
   unsigned cv = 1;

   for(i = 12; i < 2352; i++)
   {
      unsigned char z = 0;

      for(b = 0; b < 8; b++)
      {
         z |= (cv & 1) << b;

         int feedback = ((cv >> 1) & 1) ^ (cv & 1);
         cv = (cv >> 1) | (feedback << 14);
      }

      cdutil_scramble_table[i - 12] = z;
   }
}

void CDUtility_Init(void)
{
   if(!CDUtility_Inited)
   {
      Init_LEC_Correct();

      InitScrambleTable();
      lec_tables_init();

      CDUtility_Inited = true;
   }
}

/* Companion to CDUtility_Init. Frees the Reed-Solomon and Galois
 * tables that Init_LEC_Correct allocated. Safe to call when
 * CDUtility_Init was never called - just a no-op. Must be called
 * before the libretro core is unloaded; otherwise the ~4KB of LEC
 * tables leak per dlopen/dlclose cycle (cheats frontend-CD-swap
 * tooling that load and unload cores in tight loops). The scramble
 * table and lec_tables are static arrays - no allocation, nothing
 * to free for those. */
void CDUtility_Kill(void)
{
   if(CDUtility_Inited)
   {
      Kill_LEC_Correct();
      CDUtility_Inited = false;
   }
}

void encode_mode0_sector(uint32_t aba, uint8_t *sector_data)
{
   CDUtility_Init();

   lec_encode_mode0_sector(aba, sector_data);
}

void encode_mode1_sector(uint32_t aba, uint8_t *sector_data)
{
   CDUtility_Init();

   lec_encode_mode1_sector(aba, sector_data);
}

void encode_mode2_sector(uint32_t aba, uint8_t *sector_data)
{
   CDUtility_Init();

   lec_encode_mode2_sector(aba, sector_data);
}

void encode_mode2_form1_sector(uint32_t aba, uint8_t *sector_data)
{
   CDUtility_Init();

   lec_encode_mode2_form1_sector(aba, sector_data);
}

void encode_mode2_form2_sector(uint32_t aba, uint8_t *sector_data)
{
   CDUtility_Init();

   lec_encode_mode2_form2_sector(aba, sector_data);
}

bool edc_check(const uint8_t *sector_data, bool xa)
{
   CDUtility_Init();

   return(CheckEDC(sector_data, xa));
}

bool edc_lec_check_and_correct(uint8_t *sector_data, bool xa)
{
   CDUtility_Init();

   return(ValidateRawSector(sector_data, xa));
}


bool subq_check_checksum(const uint8_t *SubQBuf)
{
   unsigned i;
   uint16_t        crc = 0;
   uint16_t stored_crc = SubQBuf[0xA] << 8;

   stored_crc |= SubQBuf[0xB];

   for(i = 0; i < 0xA; i++)
      crc = subq_crctab[(crc >> 8) ^ SubQBuf[i]] ^ (crc << 8);

   crc = ~crc;

   return(crc == stored_crc);
}

void subq_generate_checksum(uint8_t *buf)
{
   unsigned i;
   uint16_t crc = 0;

   for(i = 0; i < 0xA; i++)
      crc = subq_crctab[(crc >> 8) ^ buf[i]] ^ (crc << 8);

   /* Checksum */
   buf[0xa] = ~(crc >> 8);
   buf[0xb] = ~(crc);
}

void subq_deinterleave(const uint8_t *SubPWBuf, uint8_t *qbuf)
{
   unsigned i;

   memset(qbuf, 0, 0xC);

   for(i = 0; i < 96; i++)
      qbuf[i >> 3] |= ((SubPWBuf[i] >> 6) & 0x1) << (7 - (i & 0x7));
}


// Deinterleaves 96 bytes of subchannel P-W data from 96 bytes of interleaved subchannel PW data.
void subpw_deinterleave(const uint8_t *in_buf, uint8_t *out_buf)
{
   unsigned ch, i;
   assert(in_buf != out_buf);

   memset(out_buf, 0, 96);

   for(ch = 0; ch < 8; ch++)
   {
      for(i = 0; i < 96; i++)
         out_buf[(ch * 12) + (i >> 3)] |= ((in_buf[i] >> (7 - ch)) & 0x1) << (7 - (i & 0x7));
   }

}

// Interleaves 96 bytes of subchannel P-W data from 96 bytes of uninterleaved subchannel PW data.
void subpw_interleave(const uint8_t *in_buf, uint8_t *out_buf)
{
   unsigned d, bitpoodle, ch;

   assert(in_buf != out_buf);

   for(d = 0; d < 12; d++)
   {
      for(bitpoodle = 0; bitpoodle < 8; bitpoodle++)
      {
         uint8_t rawb = 0;

         for(ch = 0; ch < 8; ch++)
            rawb |= ((in_buf[ch * 12 + d] >> (7 - bitpoodle)) & 1) << (7 - ch);
         out_buf[(d << 3) + bitpoodle] = rawb;
      }
   }
}

// NOTES ON LEADOUT AREA SYNTHESIS
//
//  I'm not trusting that the "control" field for the TOC leadout entry will always be set properly, so | the control fields for the last track entry
//  and the leadout entry together before extracting the D2 bit.  Audio track->data leadout is fairly benign though maybe noisy(especially if we ever implement
//  data scrambling properly), but data track->audio leadout could break things in an insidious manner for the more accurate drive emulation code).
//
void subpw_synth_leadout_lba(const struct TOC *toc, const int32_t lba, uint8_t* SubPWBuf)
{
   unsigned i;
   uint8_t buf[0xC];
   uint32_t lba_relative = lba - toc->tracks[100].lba;
   uint32_t f  = (lba_relative  % 75);
   uint32_t s  = ((lba_relative / 75) % 60);
   uint32_t m  = (lba_relative  / 75 / 60);
   uint32_t fa = (lba + 150)    % 75;
   uint32_t sa = ((lba + 150)  / 75) % 60;
   uint32_t ma = ((lba + 150)  / 75 / 60);

   uint8_t adr     = 0x1; // Q channel data encodes position
   uint8_t control =  toc->tracks[100].control;

   if (toc->tracks[toc->last_track].valid)
      control |= toc->tracks[toc->last_track].control & 0x4;
   else if (toc->disc_type == DISC_TYPE_CD_I)
      control |= 0x4;

   memset(buf, 0, 0xC);
   buf[0] = (adr << 0) | (control << 4);
   buf[1] = 0xAA;
   buf[2] = 0x01;

   /* Track relative MSF address */
   buf[3] = U8_to_BCD(m);
   buf[4] = U8_to_BCD(s);
   buf[5] = U8_to_BCD(f);

   buf[6] = 0; /* Zerroooo */

   /* Absolute MSF address */
   buf[7] = U8_to_BCD(ma);
   buf[8] = U8_to_BCD(sa);
   buf[9] = U8_to_BCD(fa);

   subq_generate_checksum(buf);

   for(i = 0; i < 96; i++)
      SubPWBuf[i] = (((buf[i >> 3] >> (7 - (i & 0x7))) & 1) ? 0x40 : 0x00) | 0x80;
}

void synth_leadout_sector_lba(uint8_t mode, const struct TOC *toc, const int32_t lba, uint8_t* out_buf)
{
   memset(out_buf, 0, 2352 + 96);
   subpw_synth_leadout_lba(toc, lba, out_buf + 2352);

   if(out_buf[2352 + 1] & 0x40)
   {
      if(mode == 0xFF) 
      {
         if(toc->disc_type == DISC_TYPE_CD_XA || toc->disc_type == DISC_TYPE_CD_I)
            mode = 0x02;
         else
            mode = 0x01;
      }

      switch(mode)
      {
         default:
            encode_mode0_sector(LBA_to_ABA(lba), out_buf);
            break;

         case 0x01:
            encode_mode1_sector(LBA_to_ABA(lba), out_buf);
            break;

         case 0x02:
            out_buf[12 +  6] = 0x20;
            out_buf[12 + 10] = 0x20;
            encode_mode2_form2_sector(LBA_to_ABA(lba), out_buf);
            break;
      }
   }
}
