|
DOSBox-X
|
|
DOSBox-X
|
00001 #include "np2glue.h" 00002 //#include "compiler.h" 00003 #include "getsnd.h" 00004 00005 00006 #if defined(__GNUC__) 00007 typedef struct { 00008 char head[4]; 00009 UINT8 size[4]; 00010 char fmt[4]; 00011 } __attribute__ ((packed)) RIFF_HEADER; 00012 00013 typedef struct { 00014 char head[4]; 00015 UINT8 size[4]; 00016 } __attribute__ ((packed)) WAVE_HEADER; 00017 00018 typedef struct { 00019 UINT8 format[2]; 00020 UINT8 channel[2]; 00021 UINT8 rate[4]; 00022 UINT8 rps[4]; 00023 UINT8 block[2]; 00024 UINT8 bit[2]; 00025 } __attribute__ ((packed)) WAVE_INFOS; 00026 00027 typedef struct { 00028 UINT8 exsize[2]; 00029 UINT8 spb[2]; 00030 UINT8 numcoef[2]; 00031 } __attribute__ ((packed)) WAVE_MSA_INFO; 00032 00033 #else /* __GNUC__ */ 00034 00035 #pragma pack(push, 1) 00036 typedef struct { 00037 char head[4]; 00038 UINT8 size[4]; 00039 char fmt[4]; 00040 } RIFF_HEADER; 00041 00042 typedef struct { 00043 char head[4]; 00044 UINT8 size[4]; 00045 } WAVE_HEADER; 00046 00047 typedef struct { 00048 UINT8 format[2]; 00049 UINT8 channel[2]; 00050 UINT8 rate[4]; 00051 UINT8 rps[4]; 00052 UINT8 block[2]; 00053 UINT8 bit[2]; 00054 } WAVE_INFOS; 00055 00056 typedef struct { 00057 UINT8 exsize[2]; 00058 UINT8 spb[2]; 00059 UINT8 numcoef[2]; 00060 } WAVE_MSA_INFO; 00061 #pragma pack(pop) 00062 00063 #endif /* __GNUC__ */ 00064 00065 static const char fmt_riff[] = "RIFF"; 00066 static const char fmt_wave[] = "WAVE"; 00067 static const char fmt_rmp3[] = "RMP3"; 00068 static const char chunk_fmt[] = "fmt "; 00069 static const char chunk_data[] = "data"; 00070 00071 00072 // ---- PCM 00073 00074 #if defined(BYTESEX_LITTLE) 00075 static UINT pcm_dec(GETSND snd, void *dst) { 00076 00077 UINT size; 00078 00079 size = min(snd->blocksize, snd->datsize); 00080 if (size) { 00081 CopyMemory(dst, snd->datptr, size); 00082 snd->datptr += size; 00083 snd->datsize -= size; 00084 size >>= (int)((uintptr_t)snd->snd); 00085 } 00086 return(size); 00087 } 00088 #elif defined(BYTESEX_BIG) 00089 static UINT pcm_dec(GETSND snd, UINT8 *dst) { 00090 00091 UINT size; 00092 UINT cnt; 00093 UINT8 *src; 00094 00095 size = min(snd->blocksize, snd->datsize); 00096 if (size) { 00097 if (snd->bit == 16) { 00098 cnt = size >> 1; 00099 src = snd->datptr; 00100 while(cnt) { 00101 cnt--; 00102 dst[0] = src[1]; 00103 dst[1] = src[0]; 00104 src += 2; 00105 dst += 2; 00106 } 00107 } 00108 else { 00109 CopyMemory(dst, snd->datptr, size); 00110 } 00111 snd->datptr += size; 00112 snd->datsize -= size; 00113 size >>= (int)((uintptr_t)snd->snd); 00114 } 00115 return(size); 00116 } 00117 #endif 00118 00119 static const UINT8 abits[4] = {0, 1, 0, 2}; 00120 00121 static BOOL pcm_open(GETSND snd) { 00122 00123 UINT align; 00124 00125 if ((snd->bit != 8) && (snd->bit != 16)) { 00126 goto pcmopn_err; 00127 } 00128 align = snd->channels * (snd->bit >> 3); 00129 if (snd->blocksize != align) { 00130 goto pcmopn_err; 00131 } 00132 snd->blocksamples = 0x800; // 適当に。 00133 snd->blocksize *= snd->blocksamples; 00134 snd->snd = (void*)((uintptr_t)abits[align - 1]); 00135 snd->dec = (GSDEC)pcm_dec; 00136 return(SUCCESS); 00137 00138 pcmopn_err: 00139 return(FAILURE); 00140 } 00141 00142 00143 // ---- MS-ADPCM 00144 00145 typedef struct { 00146 SINT16 Coef1; 00147 SINT16 Coef2; 00148 } __COEFPAIR; 00149 00150 static const int MSADPCMTable[16] = { 00151 230, 230, 230, 230, 307, 409, 512, 614, 00152 768, 614, 512, 409, 307, 230, 230, 230 00153 }; 00154 00155 static UINT msa_dec(GETSND snd, SINT16 *dst) { 00156 00157 UINT8 *buf; 00158 UINT size; 00159 UINT outsamples; 00160 int pred[2], delta[2], nibble; 00161 UINT i; 00162 UINT8 indata; 00163 __COEFPAIR *coef; 00164 UINT ch; 00165 SINT32 outdata; 00166 00167 buf = snd->datptr; // ワーク使ってません。 00168 size = min(snd->datsize, snd->blocksize); 00169 snd->datptr += size; 00170 snd->datsize -= size; 00171 00172 outsamples = 0; 00173 if (snd->channels == 1) { 00174 if (size >= 7) { 00175 pred[0] = buf[0]; 00176 pred[1] = 0; 00177 delta[0] = LOADINTELWORD(buf+1); 00178 delta[1] = 0; 00179 *dst++ = (SINT16)LOADINTELWORD(buf+5); 00180 *dst++ = (SINT16)LOADINTELWORD(buf+3); 00181 buf += 7; 00182 outsamples = 2 + ((size - 7) * 2); 00183 } 00184 } 00185 else { 00186 if (size >= 14) { 00187 pred[0] = buf[0]; 00188 pred[1] = buf[1]; 00189 delta[0] = LOADINTELWORD(buf+2); 00190 delta[1] = LOADINTELWORD(buf+4); 00191 *dst++ = (SINT16)LOADINTELWORD(buf+10); 00192 *dst++ = (SINT16)LOADINTELWORD(buf+12); 00193 *dst++ = (SINT16)LOADINTELWORD(buf+6); 00194 *dst++ = (SINT16)LOADINTELWORD(buf+8); 00195 buf += 14; 00196 outsamples = 2 + (size - 14); 00197 } 00198 } 00199 coef = (__COEFPAIR *)snd->snd; 00200 nibble = 0; 00201 indata = 0; // for gcc 00202 for (i=2; i<outsamples; i++) { 00203 for (ch=0; ch<snd->channels; ch++) { 00204 int d = delta[ch], p, data; 00205 if (!nibble) { 00206 indata = *buf++; 00207 data = indata >> 4; 00208 } 00209 else { 00210 data = indata & 15; 00211 } 00212 nibble ^= 1; 00213 delta[ch] = (MSADPCMTable[data] * d) >> 8; 00214 if (delta[ch] < 16) { 00215 delta[ch] = 16; 00216 } 00217 p = (((*(dst - snd->channels )) * coef[pred[ch]].Coef1) 00218 +((*(dst - snd->channels*2)) * coef[pred[ch]].Coef2)); 00219 p >>= 8; 00220 outdata = (((data>=8)?(data-16):data) * d) + p; 00221 if (outdata > 32767) { 00222 outdata = 32767; 00223 } 00224 else if (outdata < -32768) { 00225 outdata = -32768; 00226 } 00227 *dst++ = (SINT16)outdata; 00228 } 00229 } 00230 return(outsamples); 00231 } 00232 00233 static void msa_decend(GETSND snd) { 00234 00235 _MFREE(snd->snd); 00236 } 00237 00238 static BOOL msa_open(GETSND snd, WAVE_INFOS *wavehead, UINT headsize) { 00239 00240 WAVE_MSA_INFO *info; 00241 UINT exsize; 00242 UINT numcoef; 00243 UINT spb; 00244 UINT blk; 00245 __COEFPAIR *coef; 00246 UINT8 *p; 00247 00248 if ((snd->bit != 4) || 00249 (headsize < (sizeof(WAVE_INFOS) + sizeof(WAVE_MSA_INFO)))) { 00250 goto msaopn_err; 00251 } 00252 info = (WAVE_MSA_INFO *)(wavehead + 1); 00253 headsize -= sizeof(WAVE_INFOS); 00254 headsize -= sizeof(WAVE_MSA_INFO); 00255 exsize = LOADINTELWORD(info->exsize); 00256 spb = LOADINTELWORD(info->spb); 00257 numcoef = LOADINTELWORD(info->numcoef); 00258 blk = snd->blocksize; 00259 blk /= snd->channels; 00260 blk -= 6; 00261 blk *= 2; 00262 TRACEOUT(("wav: msa: ExtraSize %d / SPB=%d NumOfCoefs=%d", 00263 exsize, spb, numcoef)); 00264 00265 if (blk != spb) { 00266 TRACEOUT(("wav: msa: block size error")); 00267 goto msaopn_err; 00268 } 00269 if (exsize < (numcoef * 4 + 4)) { 00270 TRACEOUT(("wav: msa: extra info size error")); 00271 goto msaopn_err; 00272 } 00273 if (numcoef == 0) { 00274 TRACEOUT(("wav: msa: coef == 0")); 00275 goto msaopn_err; 00276 } 00277 00278 coef = (__COEFPAIR*)_MALLOC(numcoef * sizeof(__COEFPAIR), "adpcm coefs"); 00279 if (coef == NULL) { 00280 goto msaopn_err; 00281 } 00282 00283 snd->blocksamples = spb; 00284 snd->bit = 16; 00285 snd->dec = (GSDEC)msa_dec; 00286 snd->decend = msa_decend; 00287 snd->snd = (void *)coef; 00288 00289 p = (UINT8 *)(info + 1); 00290 do { 00291 coef->Coef1 = LOADINTELWORD(p + 0); 00292 coef->Coef2 = LOADINTELWORD(p + 2); 00293 coef++; 00294 p += 4; 00295 } while(--numcoef); 00296 return(SUCCESS); 00297 00298 msaopn_err: 00299 return(FAILURE); 00300 } 00301 00302 00303 // ---- IMA 00304 00305 #define IMA_MAXSTEP 89 00306 00307 static BOOL ima_init = FALSE; 00308 static UINT8 ima_statetbl[IMA_MAXSTEP][8]; 00309 00310 static const int ima_stateadj[8] = {-1, -1, -1, -1, 2, 4, 6, 8}; 00311 00312 static const int ima_steptable[IMA_MAXSTEP] = { 00313 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 00314 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 00315 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 00316 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449, 00317 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 00318 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660, 00319 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493,10442, 00320 11487,12635,13899,15289,16818,18500,20350,22385,24623,27086,29794,32767}; 00321 00322 static void ima_inittable(void) { 00323 00324 int i, j, k; 00325 00326 for (i=0; i<IMA_MAXSTEP; i++) { 00327 for (j=0; j<8; j++) { 00328 k = i + ima_stateadj[j]; 00329 if (k < 0) { 00330 k = 0; 00331 } 00332 else if (k >= IMA_MAXSTEP) { 00333 k = IMA_MAXSTEP - 1; 00334 } 00335 ima_statetbl[i][j] = (UINT8)k; 00336 } 00337 } 00338 } 00339 00340 static UINT ima_dec(GETSND snd, SINT16 *dst) { 00341 00342 UINT c; 00343 SINT32 val[2]; 00344 int state[2]; 00345 UINT8 *src; 00346 UINT blk; 00347 00348 if (snd->blocksize > snd->datsize) { 00349 goto imadec_err; 00350 } 00351 src = snd->datptr; // ワーク使ってません。 00352 snd->datptr += snd->blocksize; 00353 snd->datsize -= snd->blocksize; 00354 00355 blk = snd->blocksamples; 00356 for (c=0; c<snd->channels; c++) { 00357 SINT16 tmp; 00358 tmp = LOADINTELWORD(src); 00359 val[c] = tmp; 00360 *dst++ = (SINT16)val[c]; 00361 state[c] = src[2]; 00362 if (state[c] >= IMA_MAXSTEP) { 00363 state[c] = 0; 00364 } 00365 src += 4; 00366 } 00367 blk--; 00368 00369 while(blk >= 8) { 00370 blk -= 8; 00371 for (c=0; c<snd->channels; c++) { 00372 UINT samp, r; 00373 samp = 0; // for gcc 00374 r = 8; 00375 do { 00376 int step, dp; 00377 if (!(r & 1)) { 00378 samp = *src++; 00379 } 00380 else { 00381 samp >>= 4; 00382 } 00383 step = ima_steptable[state[c]]; 00384 state[c] = ima_statetbl[state[c]][samp & 7]; 00385 dp = ((((samp & 7) << 1) + 1) * step) >> 3; 00386 if (!(samp & 8)) { 00387 val[c] += dp; 00388 if (val[c] > 32767) { 00389 val[c] = 32767; 00390 } 00391 } 00392 else { 00393 val[c] -= dp; 00394 if (val[c] < -32768) { 00395 val[c] = -32768; 00396 } 00397 } 00398 *dst = (SINT16)val[c]; 00399 dst += snd->channels; 00400 } while(--r); 00401 dst -= (8 * snd->channels); 00402 dst++; 00403 } 00404 dst += (7 * snd->channels); 00405 } 00406 return(snd->blocksamples); 00407 00408 imadec_err: 00409 return(0); 00410 } 00411 00412 static BOOL ima_open(GETSND snd) { 00413 00414 int blk; 00415 00416 if (snd->bit != 4) { 00417 goto imaopn_err; 00418 } 00419 blk = snd->blocksize; 00420 blk /= snd->channels; 00421 if (blk & 3) { 00422 goto imaopn_err; 00423 } 00424 blk -= 4; // first block; 00425 blk *= 2; 00426 blk += 1; 00427 snd->blocksamples = blk; 00428 snd->bit = 16; 00429 snd->dec = (GSDEC)ima_dec; 00430 if (!ima_init) { 00431 ima_init = TRUE; 00432 ima_inittable(); 00433 } 00434 return(SUCCESS); 00435 00436 imaopn_err: 00437 return(FAILURE); 00438 } 00439 00440 00441 // ---- MP3 00442 00443 #if defined(SUPPORT_MP3) 00444 extern BOOL __mp3_open(GETSND snd, UINT8 *ptr, UINT size); 00445 #endif 00446 00447 00448 // ---- 00449 00450 BOOL getwave_open(GETSND snd, UINT8 *ptr, UINT size) { 00451 00452 RIFF_HEADER *riff; 00453 WAVE_HEADER *head; 00454 WAVE_INFOS *info; 00455 UINT pos; 00456 UINT format; 00457 BOOL r; 00458 UINT headsize = 0; 00459 UINT datasize; 00460 00461 info = NULL; // for gcc 00462 00463 // RIFFのチェック 00464 riff = (RIFF_HEADER *)ptr; 00465 pos = sizeof(RIFF_HEADER); 00466 if (size < pos) { 00467 TRACEOUT(("wav: error RIFF header")); 00468 goto gwopn_err; 00469 } 00470 if (memcmp(riff->head, fmt_riff, 4)) { 00471 TRACEOUT(("wav: error RIFF header")); 00472 goto gwopn_err; 00473 } 00474 if (!memcmp(riff->fmt, fmt_wave, 4)) { 00475 // フォーマットヘッダチェック 00476 head = (WAVE_HEADER *)(ptr + pos); 00477 pos += sizeof(WAVE_HEADER); 00478 if (size < pos) { 00479 TRACEOUT(("wav: error fmt header")); 00480 goto gwopn_err; 00481 } 00482 if (memcmp(head->head, chunk_fmt, 4)) { 00483 TRACEOUT(("wav: error fmt header")); 00484 goto gwopn_err; 00485 } 00486 headsize = LOADINTELDWORD(head->size); 00487 if (headsize < sizeof(WAVE_INFOS)) { 00488 TRACEOUT(("wav: error fmt length")); 00489 goto gwopn_err; 00490 } 00491 00492 // フォーマットチェック 00493 info = (WAVE_INFOS *)(ptr + pos); 00494 pos += headsize; 00495 if (size < pos) { 00496 TRACEOUT(("wav: error fmt data")); 00497 goto gwopn_err; 00498 } 00499 format = LOADINTELWORD(info->format); 00500 snd->channels = LOADINTELWORD(info->channel); 00501 snd->samplingrate = LOADINTELDWORD(info->rate); 00502 snd->blocksize = LOADINTELWORD(info->block); 00503 snd->bit = LOADINTELWORD(info->bit); 00504 TRACEOUT(("wav: fmt: %x / %dch %dHz %dbit", 00505 format, snd->channels, snd->samplingrate, snd->bit)); 00506 if ((UINT)(snd->channels - 1) >= 2) { 00507 TRACEOUT(("wav: channels err")); 00508 goto gwopn_err; 00509 } 00510 } 00511 else if (!memcmp(riff->fmt, fmt_rmp3, 4)) { 00512 format = 0x55; 00513 } 00514 else { 00515 TRACEOUT(("wav: error WAVE header")); 00516 goto gwopn_err; 00517 } 00518 00519 // dataまで移動。 00520 while(1) { 00521 head = (WAVE_HEADER *)(ptr + pos); 00522 pos += sizeof(WAVE_HEADER); 00523 if (size < pos) { 00524 TRACEOUT(("wav: error data header")); 00525 goto gwopn_err; 00526 } 00527 if (!memcmp(head->head, chunk_data, 4)) { 00528 break; 00529 } 00530 pos += LOADINTELDWORD(head->size); 00531 } 00532 ptr += pos; 00533 size -= pos; 00534 datasize = LOADINTELDWORD(head->size); 00535 size = min(size, datasize); 00536 00537 switch(format) { 00538 case 0x01: // PCM 00539 r = pcm_open(snd); 00540 break; 00541 00542 case 0x02: 00543 r = msa_open(snd, info, headsize); 00544 break; 00545 00546 case 0x11: 00547 r = ima_open(snd); 00548 break; 00549 00550 #if defined(SUPPORT_MP3) 00551 case 0x55: 00552 return(__mp3_open(snd, ptr, size)); 00553 #endif 00554 00555 #if defined(SUPPORT_OGG) 00556 case 0x6751: 00557 return(getogg_open(snd, ptr, size)); 00558 #endif 00559 00560 default: 00561 r = FAILURE; 00562 break; 00563 } 00564 if (r != SUCCESS) { 00565 TRACEOUT(("wav: decord open error")); 00566 goto gwopn_err; 00567 } 00568 00569 // 登録〜 00570 snd->datptr = ptr; 00571 snd->datsize = size; 00572 return(SUCCESS); 00573 00574 gwopn_err: 00575 return(FAILURE); 00576 } 00577
1.8.0
