cc68a136 |
1 | /* faked 940 code just uses local copy of ym2612 */ |
2 | #include <stdio.h> |
3 | #include <stdlib.h> |
4 | #include <string.h> |
5 | #include <unistd.h> |
6 | #include <sys/mman.h> |
7 | #include <sys/ioctl.h> |
8 | #include <fcntl.h> |
9 | #include <errno.h> |
10 | |
11 | #include "../../Pico/sound/ym2612.h" |
12 | #include "../gp2x/gp2x.h" |
13 | #include "../gp2x/emu.h" |
14 | #include "../gp2x/menu.h" |
cb0316e4 |
15 | #include "../gp2x/code940/940shared.h" |
16 | #include "../gp2x/helix/pub/mp3dec.h" |
17 | #include "../../Pico/PicoInt.h" |
cc68a136 |
18 | |
19 | |
20 | static YM2612 ym2612; |
21 | |
22 | YM2612 *ym2612_940 = &ym2612; |
23 | int mix_buffer_[44100/50*2]; /* this is where the YM2612 samples will be mixed to */ |
24 | int *mix_buffer = mix_buffer_; |
25 | |
51a902ae |
26 | // static _940_data_t shared_data_; |
cb0316e4 |
27 | static _940_ctl_t shared_ctl_; |
51a902ae |
28 | // static _940_data_t *shared_data = &shared_data_; |
cb0316e4 |
29 | static _940_ctl_t *shared_ctl = &shared_ctl_; |
30 | |
31 | unsigned char *mp3_mem = 0; |
32 | |
33 | #define MP3_SIZE_MAX (0x1000000 - 4*640*480) |
cc68a136 |
34 | |
35 | /***********************************************************/ |
36 | |
37 | #define MAXOUT (+32767) |
38 | #define MINOUT (-32768) |
39 | |
40 | /* limitter */ |
41 | #define Limit(val, max,min) { \ |
42 | if ( val > max ) val = max; \ |
43 | else if ( val < min ) val = min; \ |
44 | } |
45 | |
46 | |
47 | int YM2612Write_940(unsigned int a, unsigned int v) |
48 | { |
49 | YM2612Write_(a, v); |
50 | |
51 | return 0; // cause the engine to do updates once per frame only |
52 | } |
53 | |
54 | UINT8 YM2612Read_940(void) |
55 | { |
56 | return YM2612Read_(); |
57 | } |
58 | |
59 | |
60 | int YM2612PicoTick_940(int n) |
61 | { |
62 | YM2612PicoTick_(n); |
63 | |
64 | return 0; |
65 | } |
66 | |
67 | |
68 | void YM2612PicoStateLoad_940(void) |
69 | { |
70 | int i; |
71 | |
72 | YM2612PicoStateLoad_(); |
73 | |
74 | for(i = 0; i < 0x100; i++) { |
75 | YM2612Write_(0, i); |
76 | YM2612Write_(1, ym2612.REGS[i]); |
77 | } |
78 | for(i = 0; i < 0x100; i++) { |
79 | YM2612Write_(2, i); |
80 | YM2612Write_(3, ym2612.REGS[i|0x100]); |
81 | } |
82 | } |
83 | |
84 | |
85 | void YM2612Init_940(int baseclock, int rate) |
86 | { |
cb0316e4 |
87 | mp3_mem = malloc(MP3_SIZE_MAX); |
88 | |
cc68a136 |
89 | YM2612Init_(baseclock, rate); |
90 | } |
91 | |
92 | |
93 | void YM2612ResetChip_940(void) |
94 | { |
95 | YM2612ResetChip_(); |
96 | } |
97 | |
98 | |
cb0316e4 |
99 | static void mix_samples(short *dest_buf, int *ym_buf, short *mp3_buf, int len, int stereo) |
100 | { |
101 | if (mp3_buf) |
102 | { |
103 | if (stereo) |
104 | { |
105 | for (; len > 0; len--) |
106 | { |
107 | int l, r; |
108 | l = r = *dest_buf; |
109 | l += *ym_buf++; r += *ym_buf++; |
110 | l += *mp3_buf++; r += *mp3_buf++; |
111 | Limit( l, MAXOUT, MINOUT ); |
112 | Limit( r, MAXOUT, MINOUT ); |
113 | *dest_buf++ = l; *dest_buf++ = r; |
114 | } |
115 | } else { |
116 | for (; len > 0; len--) |
117 | { |
118 | int l = *ym_buf++; |
119 | l += *dest_buf; |
120 | l += *mp3_buf++; |
121 | Limit( l, MAXOUT, MINOUT ); |
122 | *dest_buf++ = l; |
123 | } |
124 | } |
125 | } |
126 | else |
127 | { |
128 | if (stereo) |
129 | { |
130 | for (; len > 0; len--) |
131 | { |
132 | int l, r; |
133 | l = r = *dest_buf; |
134 | l += *ym_buf++, r += *ym_buf++; |
135 | Limit( l, MAXOUT, MINOUT ); |
136 | Limit( r, MAXOUT, MINOUT ); |
137 | *dest_buf++ = l; *dest_buf++ = r; |
138 | } |
139 | } else { |
140 | for (; len > 0; len--) |
141 | { |
142 | int l = *ym_buf++; |
143 | l += *dest_buf; |
144 | Limit( l, MAXOUT, MINOUT ); |
145 | *dest_buf++ = l; |
146 | } |
147 | } |
148 | } |
149 | } |
150 | |
151 | #if 0 |
152 | static void local_decode(void) |
153 | { |
154 | int mp3_offs = shared_ctl->mp3_offs; |
155 | unsigned char *readPtr = mp3_mem + mp3_offs; |
156 | int bytesLeft = shared_ctl->mp3_len - mp3_offs; |
157 | int offset; // frame offset from readPtr |
158 | int err = 0; |
159 | |
160 | if (bytesLeft <= 0) return; // EOF, nothing to do |
161 | |
162 | offset = MP3FindSyncWord(readPtr, bytesLeft); |
163 | if (offset < 0) { |
164 | shared_ctl->mp3_offs = shared_ctl->mp3_len; |
165 | return; // EOF |
166 | } |
167 | readPtr += offset; |
168 | bytesLeft -= offset; |
169 | |
170 | err = MP3Decode(shared_data->mp3dec, &readPtr, &bytesLeft, |
171 | shared_data->mp3_buffer[shared_ctl->mp3_buffsel], 0); |
172 | if (err) { |
173 | if (err == ERR_MP3_INDATA_UNDERFLOW) { |
174 | shared_ctl->mp3_offs = shared_ctl->mp3_len; // EOF |
175 | return; |
176 | } else if (err <= -6 && err >= -12) { |
177 | // ERR_MP3_INVALID_FRAMEHEADER, ERR_MP3_INVALID_* |
178 | // just try to skip the offending frame.. |
179 | readPtr++; |
180 | } |
181 | shared_ctl->mp3_errors++; |
182 | shared_ctl->mp3_lasterr = err; |
183 | } |
184 | shared_ctl->mp3_offs = readPtr - mp3_mem; |
185 | } |
186 | #endif |
187 | |
188 | |
189 | |
190 | |
191 | static FILE *loaded_mp3 = 0; |
192 | |
cc68a136 |
193 | void YM2612UpdateOne_940(short *buffer, int length, int stereo) |
194 | { |
cb0316e4 |
195 | #if 0 |
196 | int cdda_on, *ym_buffer = mix_buffer; |
197 | static int mp3_samples_ready = 0, mp3_buffer_offs = 0; |
198 | static int mp3_play_bufsel = 1; |
199 | |
200 | |
201 | YM2612UpdateOne_(buffer, length, stereo); // really writes to mix_buffer |
cc68a136 |
202 | |
cb0316e4 |
203 | // emulatind MCD, not data track, CDC is reading, playback was started, track not ended |
204 | cdda_on = (PicoMCD & 1) && !(Pico_mcd->s68k_regs[0x36] & 1) && (Pico_mcd->scd.Status_CDC & 1) |
205 | && loaded_mp3 && shared_ctl->mp3_offs < shared_ctl->mp3_len; |
206 | |
207 | /* mix data from previous go */ |
208 | if (cdda_on && mp3_samples_ready >= length) |
209 | { |
210 | if (1152 - mp3_buffer_offs >= length) { |
211 | mix_samples(buffer, ym_buffer, shared_data->mp3_buffer[mp3_play_bufsel] + mp3_buffer_offs*2, length, stereo); |
212 | |
213 | mp3_buffer_offs += length; |
214 | } else { |
215 | // collect from both buffers.. |
216 | int left = 1152 - mp3_buffer_offs; |
217 | mix_samples(buffer, ym_buffer, shared_data->mp3_buffer[mp3_play_bufsel] + mp3_buffer_offs*2, left, stereo); |
218 | mp3_play_bufsel ^= 1; |
219 | mp3_buffer_offs = length - left; |
220 | mix_samples(buffer + left * 2, ym_buffer + left * 2, |
221 | shared_data->mp3_buffer[mp3_play_bufsel], mp3_buffer_offs, stereo); |
cc68a136 |
222 | } |
cb0316e4 |
223 | mp3_samples_ready -= length; |
cc68a136 |
224 | } else { |
cb0316e4 |
225 | mix_samples(buffer, ym_buffer, 0, length, stereo); |
226 | } |
227 | |
228 | // make sure we will have enough mp3 samples next frame |
229 | if (cdda_on && mp3_samples_ready < length) |
230 | { |
231 | shared_ctl->mp3_buffsel ^= 1; |
232 | local_decode(); |
233 | mp3_samples_ready += 1152; |
234 | } |
235 | #else |
236 | YM2612UpdateOne_(buffer, length, stereo); // really writes to mix_buffer |
237 | |
238 | mix_samples(buffer, mix_buffer, 0, length, stereo); |
239 | #endif |
240 | } |
241 | |
242 | |
243 | /***********************************************************/ |
244 | |
245 | void mp3_start_play(FILE *f, int pos) // pos is 0-1023 |
246 | { |
247 | int byte_offs = 0; |
248 | |
249 | if (loaded_mp3 != f) |
250 | { |
251 | printf("loading mp3... "); fflush(stdout); |
252 | fseek(f, 0, SEEK_SET); |
253 | fread(mp3_mem, 1, MP3_SIZE_MAX, f); |
254 | if (feof(f)) printf("done.\n"); |
255 | else printf("done. mp3 too large, not all data loaded.\n"); |
256 | shared_ctl->mp3_len = ftell(f); |
257 | loaded_mp3 = f; |
cc68a136 |
258 | } |
cb0316e4 |
259 | |
260 | // seek.. |
261 | if (pos) { |
262 | byte_offs = (shared_ctl->mp3_len << 6) >> 10; |
263 | byte_offs *= pos; |
264 | byte_offs >>= 6; |
265 | } |
266 | printf("mp3 pos1024: %i, byte_offs %i/%i\n", pos, byte_offs, shared_ctl->mp3_len); |
267 | |
268 | shared_ctl->mp3_offs = byte_offs; |
cc68a136 |
269 | } |
270 | |
cb0316e4 |
271 | |
272 | |