src/promemul/dreamcast_scramble.c

/*
 *  GXemul: $Id: dreamcast_scramble.c,v 1.4 2007/06/19 03:52:07 debug Exp $
 *
 *  COMMENT: Dreamcast emulation (helper module)
 *
 *  This is from Marcus Comstedt's Dreamcast development files
 *  (http://mc.pp.se/dc/files/scramble.c). Public Domain, according to
 *  Marcus software page.
 *
 *  The only modification done to make it fit into the emulator is that
 *  it is executed internally from src/file.c.
 */

/*  #define STAND_ALONE  */


#include <stdio.h>
#include <stdlib.h>

#define MAXCHUNK (2048*1024)

static unsigned int seed;

void my_srand(unsigned int n)
{
  seed = n & 0xffff;
}

unsigned int my_rand(void)
{
  seed = (seed * 2109 + 9273) & 0x7fff;
  return (seed + 0xc000) & 0xffff;
}

void load(FILE *fh, unsigned char *ptr, unsigned long sz)
{
  if(fread(ptr, 1, sz, fh) != sz)
    {
      fprintf(stderr, "Read error!\n");
      exit(1);
    }
}

void load_chunk(FILE *fh, unsigned char *ptr, unsigned long sz)
{
  static int idx[MAXCHUNK/32];
  int i;

  /* Convert chunk size to number of slices */
  sz /= 32;

  /* Initialize index table with unity,
     so that each slice gets loaded exactly once */
  for(i = 0; i < (int)sz; i++)
    idx[i] = i;

  for(i = sz-1; i >= 0; --i)
    {
      /* Select a replacement index */
      int x = (my_rand() * i) >> 16;

      /* Swap */
      int tmp = idx[i];
      idx[i] = idx[x];
      idx[x] = tmp;

      /* Load resulting slice */
      load(fh, ptr+32*idx[i], 32);
    }
}

void load_file(FILE *fh, unsigned char *ptr, unsigned long filesz)
{
  unsigned long chunksz;

  my_srand(filesz);

  /* Descramble 2 meg blocks for as long as possible, then
     gradually reduce the window down to 32 bytes (1 slice) */
  for(chunksz = MAXCHUNK; chunksz >= 32; chunksz >>= 1)
    while(filesz >= chunksz)
      {
        load_chunk(fh, ptr, chunksz);
        filesz -= chunksz;
        ptr += chunksz;
      }

  /* Load final incomplete slice */
  if(filesz)
    load(fh, ptr, filesz);
}

void read_file(char *filename, unsigned char **ptr, unsigned long *sz)
{
  FILE *fh = fopen(filename, "rb");
  if(fh == NULL)
    {
      fprintf(stderr, "Can't open \"%s\".\n", filename);
      exit(1);
    }
  if(fseek(fh, 0, SEEK_END)<0)
    {
      fprintf(stderr, "Seek error.\n");
      exit(1);
    }
  *sz = ftell(fh);
  *ptr = malloc(*sz);
  if( *ptr == NULL )
    {
      fprintf(stderr, "Out of memory.\n");
      exit(1);
    }
  if(fseek(fh, 0, SEEK_SET)<0)
    {
      fprintf(stderr, "Seek error.\n");
      exit(1);
    }
  load_file(fh, *ptr, *sz);
  fclose(fh);
}

void save(FILE *fh, unsigned char *ptr, unsigned long sz)
{
  if(fwrite(ptr, 1, sz, fh) != sz)
    {
      fprintf(stderr, "Write error!\n");
      exit(1);
    }
}

void save_chunk(FILE *fh, unsigned char *ptr, unsigned long sz)
{
  static int idx[MAXCHUNK/32];
  int i;

  /* Convert chunk size to number of slices */
  sz /= 32;

  /* Initialize index table with unity,
     so that each slice gets saved exactly once */
  for(i = 0; i < (int)sz; i++)
    idx[i] = i;

  for(i = sz-1; i >= 0; --i)
    {
      /* Select a replacement index */
      int x = (my_rand() * i) >> 16;

      /* Swap */
      int tmp = idx[i];
      idx[i] = idx[x];
      idx[x] = tmp;

      /* Save resulting slice */
      save(fh, ptr+32*idx[i], 32);
    }
}

void save_file(FILE *fh, unsigned char *ptr, unsigned long filesz)
{
  unsigned long chunksz;

  my_srand(filesz);

  /* Descramble 2 meg blocks for as long as possible, then
     gradually reduce the window down to 32 bytes (1 slice) */
  for(chunksz = MAXCHUNK; chunksz >= 32; chunksz >>= 1)
    while(filesz >= chunksz)
      {
        save_chunk(fh, ptr, chunksz);
        filesz -= chunksz;
        ptr += chunksz;
      }

  /* Save final incomplete slice */
  if(filesz)
    save(fh, ptr, filesz);
}

void write_file(char *filename, unsigned char *ptr, unsigned long sz)
{
  FILE *fh = fopen(filename, "wb");
  if(fh == NULL)
    {
      fprintf(stderr, "Can't open \"%s\".\n", filename);
      exit(1);
    }
  save_file(fh, ptr, sz);
  fclose(fh);
}

void dreamcast_descramble(char *src, char *dst)
{
  unsigned char *ptr = NULL;
  unsigned long sz = 0;
  FILE *fh;

  read_file(src, &ptr, &sz);

  fh = fopen(dst, "wb");
  if(fh == NULL)
    {
      fprintf(stderr, "Can't open \"%s\".\n", dst);
      exit(1);
    }
  if( fwrite(ptr, 1, sz, fh) != sz )
    {
      fprintf(stderr, "Write error.\n");
      exit(1);
    }
  fclose(fh);
  free(ptr);
}

void scramble(char *src, char *dst)
{
  unsigned char *ptr = NULL;
  unsigned long sz = 0;
  FILE *fh;

  fh = fopen(src, "rb");
  if(fh == NULL)
    {
      fprintf(stderr, "Can't open \"%s\".\n", src);
      exit(1);
    }
  if(fseek(fh, 0, SEEK_END)<0)
    {
      fprintf(stderr, "Seek error.\n");
      exit(1);
    }
  sz = ftell(fh);
  ptr = malloc(sz);
  if( ptr == NULL )
    {
      fprintf(stderr, "Out of memory.\n");
      exit(1);
    }
  if(fseek(fh, 0, SEEK_SET)<0)
    {
      fprintf(stderr, "Seek error.\n");
      exit(1);
    }
  if( fread(ptr, 1, sz, fh) != sz )
    {
      fprintf(stderr, "Read error.\n");
      exit(1);
    }
  fclose(fh);

  write_file(dst, ptr, sz);

  free(ptr);
}


#ifdef STAND_ALONE

int main(int argc, char *argv[])
{
  int opt = 0;

  if(argc > 1 && !strcmp(argv[1], "-d"))
    opt ++;

  if(argc != 3+opt)
    {
      fprintf(stderr, "Usage: %s [-d] from to\n", argv[0]);
      exit(1);
    }
  
  if(opt)
    dreamcast_descramble(argv[2], argv[3]);
  else
    scramble(argv[1], argv[2]);

  return 0;
}

#endif
1	dpavlin	34	/*
2	dpavlin	44	* GXemul: $Id: dreamcast_scramble.c,v 1.4 2007/06/19 03:52:07 debug Exp $
3	dpavlin	34	*
4	dpavlin	44	* COMMENT: Dreamcast emulation (helper module)
5			*
6	dpavlin	34	* This is from Marcus Comstedt's Dreamcast development files
7			* (http://mc.pp.se/dc/files/scramble.c). Public Domain, according to
8			* Marcus software page.
9			*
10			* The only modification done to make it fit into the emulator is that
11			* it is executed internally from src/file.c.
12			*/
13
14			/* #define STAND_ALONE */
15
16
17			#include <stdio.h>
18			#include <stdlib.h>
19
20			#define MAXCHUNK (2048*1024)
21
22			static unsigned int seed;
23
24			void my_srand(unsigned int n)
25			{
26			seed = n & 0xffff;
27			}
28
29			unsigned int my_rand(void)
30			{
31			seed = (seed * 2109 + 9273) & 0x7fff;
32			return (seed + 0xc000) & 0xffff;
33			}
34
35			void load(FILE fh, unsigned char ptr, unsigned long sz)
36			{
37			if(fread(ptr, 1, sz, fh) != sz)
38			{
39			fprintf(stderr, "Read error!\n");
40			exit(1);
41			}
42			}
43
44			void load_chunk(FILE fh, unsigned char ptr, unsigned long sz)
45			{
46			static int idx[MAXCHUNK/32];
47			int i;
48
49			/* Convert chunk size to number of slices */
50			sz /= 32;
51
52			/* Initialize index table with unity,
53			so that each slice gets loaded exactly once */
54	dpavlin	44	for(i = 0; i < (int)sz; i++)
55	dpavlin	34	idx[i] = i;
56
57			for(i = sz-1; i >= 0; --i)
58			{
59			/* Select a replacement index */
60			int x = (my_rand() * i) >> 16;
61
62			/* Swap */
63			int tmp = idx[i];
64			idx[i] = idx[x];
65			idx[x] = tmp;
66
67			/* Load resulting slice */
68			load(fh, ptr+32*idx[i], 32);
69			}
70			}
71
72			void load_file(FILE fh, unsigned char ptr, unsigned long filesz)
73			{
74			unsigned long chunksz;
75
76			my_srand(filesz);
77
78			/* Descramble 2 meg blocks for as long as possible, then
79			gradually reduce the window down to 32 bytes (1 slice) */
80			for(chunksz = MAXCHUNK; chunksz >= 32; chunksz >>= 1)
81			while(filesz >= chunksz)
82			{
83			load_chunk(fh, ptr, chunksz);
84			filesz -= chunksz;
85			ptr += chunksz;
86			}
87
88			/* Load final incomplete slice */
89			if(filesz)
90			load(fh, ptr, filesz);
91			}
92
93			void read_file(char filename, unsigned char ptr, unsigned long sz)
94			{
95			FILE *fh = fopen(filename, "rb");
96			if(fh == NULL)
97			{
98			fprintf(stderr, "Can't open \"%s\".\n", filename);
99			exit(1);
100			}
101			if(fseek(fh, 0, SEEK_END)<0)
102			{
103			fprintf(stderr, "Seek error.\n");
104			exit(1);
105			}
106			*sz = ftell(fh);
107			ptr = malloc(sz);
108			if( *ptr == NULL )
109			{
110			fprintf(stderr, "Out of memory.\n");
111			exit(1);
112			}
113			if(fseek(fh, 0, SEEK_SET)<0)
114			{
115			fprintf(stderr, "Seek error.\n");
116			exit(1);
117			}
118			load_file(fh, ptr, sz);
119			fclose(fh);
120			}
121
122			void save(FILE fh, unsigned char ptr, unsigned long sz)
123			{
124			if(fwrite(ptr, 1, sz, fh) != sz)
125			{
126			fprintf(stderr, "Write error!\n");
127			exit(1);
128			}
129			}
130
131			void save_chunk(FILE fh, unsigned char ptr, unsigned long sz)
132			{
133			static int idx[MAXCHUNK/32];
134			int i;
135
136			/* Convert chunk size to number of slices */
137			sz /= 32;
138
139			/* Initialize index table with unity,
140			so that each slice gets saved exactly once */
141	dpavlin	44	for(i = 0; i < (int)sz; i++)
142	dpavlin	34	idx[i] = i;
143
144			for(i = sz-1; i >= 0; --i)
145			{
146			/* Select a replacement index */
147			int x = (my_rand() * i) >> 16;
148
149			/* Swap */
150			int tmp = idx[i];
151			idx[i] = idx[x];
152			idx[x] = tmp;
153
154			/* Save resulting slice */
155			save(fh, ptr+32*idx[i], 32);
156			}
157			}
158
159			void save_file(FILE fh, unsigned char ptr, unsigned long filesz)
160			{
161			unsigned long chunksz;
162
163			my_srand(filesz);
164
165			/* Descramble 2 meg blocks for as long as possible, then
166			gradually reduce the window down to 32 bytes (1 slice) */
167			for(chunksz = MAXCHUNK; chunksz >= 32; chunksz >>= 1)
168			while(filesz >= chunksz)
169			{
170			save_chunk(fh, ptr, chunksz);
171			filesz -= chunksz;
172			ptr += chunksz;
173			}
174
175			/* Save final incomplete slice */
176			if(filesz)
177			save(fh, ptr, filesz);
178			}
179
180			void write_file(char filename, unsigned char ptr, unsigned long sz)
181			{
182			FILE *fh = fopen(filename, "wb");
183			if(fh == NULL)
184			{
185			fprintf(stderr, "Can't open \"%s\".\n", filename);
186			exit(1);
187			}
188			save_file(fh, ptr, sz);
189			fclose(fh);
190			}
191
192			void dreamcast_descramble(char src, char dst)
193			{
194			unsigned char *ptr = NULL;
195			unsigned long sz = 0;
196			FILE *fh;
197
198			read_file(src, &ptr, &sz);
199
200			fh = fopen(dst, "wb");
201			if(fh == NULL)
202			{
203			fprintf(stderr, "Can't open \"%s\".\n", dst);
204			exit(1);
205			}
206			if( fwrite(ptr, 1, sz, fh) != sz )
207			{
208			fprintf(stderr, "Write error.\n");
209			exit(1);
210			}
211			fclose(fh);
212			free(ptr);
213			}
214
215			void scramble(char src, char dst)
216			{
217			unsigned char *ptr = NULL;
218			unsigned long sz = 0;
219			FILE *fh;
220
221			fh = fopen(src, "rb");
222			if(fh == NULL)
223			{
224			fprintf(stderr, "Can't open \"%s\".\n", src);
225			exit(1);
226			}
227			if(fseek(fh, 0, SEEK_END)<0)
228			{
229			fprintf(stderr, "Seek error.\n");
230			exit(1);
231			}
232			sz = ftell(fh);
233			ptr = malloc(sz);
234			if( ptr == NULL )
235			{
236			fprintf(stderr, "Out of memory.\n");
237			exit(1);
238			}
239			if(fseek(fh, 0, SEEK_SET)<0)
240			{
241			fprintf(stderr, "Seek error.\n");
242			exit(1);
243			}
244			if( fread(ptr, 1, sz, fh) != sz )
245			{
246			fprintf(stderr, "Read error.\n");
247			exit(1);
248			}
249			fclose(fh);
250
251			write_file(dst, ptr, sz);
252
253			free(ptr);
254			}
255
256
257			#ifdef STAND_ALONE
258
259			int main(int argc, char *argv[])
260			{
261			int opt = 0;
262
263			if(argc > 1 && !strcmp(argv[1], "-d"))
264			opt ++;
265
266			if(argc != 3+opt)
267			{
268			fprintf(stderr, "Usage: %s [-d] from to\n", argv[0]);
269			exit(1);
270			}
271
272			if(opt)
273			dreamcast_descramble(argv[2], argv[3]);
274			else
275			scramble(argv[1], argv[2]);
276
277			return 0;
278			}
279
280			#endif