API tools faq
paste
Guest User

Untitled

a guest
Apr 21st, 2018
93
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 11.53 KB | None | 0 0
raw download clone embed print report
  1. diff --git a/arm7SndMod/source/main.c b/arm7SndMod/source/main.c
  2. index 6e606d3..3bd525e 100644
  3. --- a/arm7SndMod/source/main.c
  4. +++ b/arm7SndMod/source/main.c
  5. @@ -23,7 +23,7 @@ void FifoMsgHandler(int num_bytes, void *userdata)
  6. case FIFO_AUDIO_START:
  7. if(channels <=2 && channels > 0) {
  8. for(i=0; i<channels; i++) {
  9. - SCHANNEL_TIMER(i) = SOUND_FREQ((u16)(msg.property));
  10. + SCHANNEL_TIMER(i) = SOUND_FREQ((int)msg.property&0xFFFF);
  11. SCHANNEL_SOURCE(i) = (u32)(msg.buffer+msg.bufLen*i*2);
  12. SCHANNEL_LENGTH(i) = msg.bufLen/2; // length is counted in words, sample is halfword
  13. SCHANNEL_REPEAT_POINT(i) = 0;
  14. diff --git a/codecs/flac/source/flac.c b/codecs/flac/source/flac.c
  15. index 2072a44..2a39c9c 100644
  16. --- a/codecs/flac/source/flac.c
  17. +++ b/codecs/flac/source/flac.c
  18. @@ -1,14 +1,16 @@
  19. #if HAVE_CONFIG_H
  20. #include <config.h>
  21. #endif
  22. +#include <string.h>
  23. #include <stdio.h>
  24. +#include <stdlib.h>
  25. #include "FLAC/stream_decoder.h"
  26. #include "flac.h"
  27.  
  28. typedef struct {
  29. - const FLAC__Frame *frame;
  30. - const FLAC__int32 * const *buffer;
  31. - int pos;
  32. + const FLAC__Frame *frame;
  33. + const FLAC__int32 * const *buffer;
  34. + int pos;
  35. } FLACinfo;
  36.  
  37. FLAC__StreamDecoder *decoder = NULL;
  38. @@ -21,139 +23,154 @@ static int bps = 0; //bits per sample
  39. FILE * fp;
  40.  
  41. static FLAC__StreamDecoderWriteStatus write_callback(
  42. - const FLAC__StreamDecoder *decoder,
  43. - const FLAC__Frame *frame,
  44. - const FLAC__int32 * const buffer[],
  45. - void *client_data);
  46. + const FLAC__StreamDecoder *decoder,
  47. + const FLAC__Frame *frame,
  48. + const FLAC__int32 * const buffer[],
  49. + void *client_data);
  50. static void metadata_callback(
  51. - const FLAC__StreamDecoder *decoder,
  52. - const FLAC__StreamMetadata *metadata,
  53. - void *client_data);
  54. + const FLAC__StreamDecoder *decoder,
  55. + const FLAC__StreamMetadata *metadata,
  56. + void *client_data);
  57. static void error_callback(const FLAC__StreamDecoder *decoder,
  58. - FLAC__StreamDecoderErrorStatus status,
  59. - void *client_data);
  60. + FLAC__StreamDecoderErrorStatus status,
  61. + void *client_data);
  62.  
  63.  
  64. int openFile(const char * name)
  65. {
  66. - FLAC__StreamDecoderInitStatus init_status;
  67. + FLAC__StreamDecoderInitStatus init_status;
  68.  
  69. - finfo.frame = NULL;
  70. - finfo.buffer = NULL;
  71. - finfo.pos = 0;
  72. + finfo.frame = NULL;
  73. + finfo.buffer = NULL;
  74. + finfo.pos = 0;
  75.  
  76. - if((decoder = FLAC__stream_decoder_new()) == NULL)
  77. - return 0;
  78. + if((decoder = FLAC__stream_decoder_new()) == NULL)
  79. + return 0;
  80.  
  81. - init_status = FLAC__stream_decoder_init_file(
  82. - decoder, name,
  83. - write_callback, metadata_callback, error_callback,
  84. - NULL);
  85. - if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK)
  86. - return 0;
  87. + init_status = FLAC__stream_decoder_init_file(
  88. + decoder, name,
  89. + write_callback, metadata_callback, error_callback,
  90. + NULL);
  91. + if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK)
  92. + return 0;
  93.  
  94. - return FLAC__stream_decoder_process_until_end_of_metadata(decoder);
  95. + return FLAC__stream_decoder_process_until_end_of_metadata(decoder);
  96. }
  97.  
  98. -int getSampleRate(void) {
  99. - return sample_rate;
  100. +int getSampleRate(void)
  101. +{
  102. + return sample_rate;
  103. }
  104.  
  105. -int getnChannels(void) {
  106. - return channels;
  107. +int getnChannels(void)
  108. +{
  109. + return (channels);// | (1<<16));
  110. }
  111.  
  112. -int seekPercentage(int perc) {
  113. - return 0;
  114. +int seekPercentage(int perc)
  115. +{
  116. + return 0;
  117. }
  118.  
  119. -int getPercentage(void) {
  120. - return 0;
  121. +int getPercentage(void)
  122. +{
  123. + return 0;
  124. }
  125.  
  126. -void freeDecoder(void) {
  127. - FLAC__stream_decoder_delete(decoder);
  128. - decoder = NULL;
  129. +void freeDecoder(void)
  130. +{
  131. + FLAC__stream_decoder_delete(decoder);
  132. + decoder = NULL;
  133. }
  134.  
  135. -int decSamples(int length, short * destBuf) {
  136. - int decoded = 0;
  137. - FLAC__bool success = false;
  138. - FLAC__StreamDecoderState state;
  139. -
  140. - if(length <= 0)
  141. - return 0;
  142. -
  143. - state = FLAC__stream_decoder_get_state(decoder);
  144. - if(state == FLAC__STREAM_DECODER_END_OF_STREAM
  145. - || state == FLAC__STREAM_DECODER_ABORTED)
  146. - return -1;
  147. -
  148. - while(decoded < length) {
  149. - if(finfo.frame == NULL || finfo.pos == finfo.frame->header.blocksize) {
  150. - success = FLAC__stream_decoder_process_single(decoder);
  151. - if(success == false)
  152. - return -1;
  153. - state = FLAC__stream_decoder_get_state(decoder);
  154. - if(state == FLAC__STREAM_DECODER_END_OF_STREAM
  155. - || state == FLAC__STREAM_DECODER_ABORTED)
  156. - return decoded;
  157. - }
  158. -
  159. - for(;
  160. - decoded < length && finfo.pos < finfo.frame->header.blocksize;
  161. - finfo.pos++, decoded++) {
  162. - /* write to the buffer here; convert from BE to LE */
  163. - destBuf[decoded*2] = finfo.buffer[0][finfo.pos];
  164. - destBuf[decoded*2+1] = finfo.buffer[1][finfo.pos];
  165. - }
  166. - }
  167. -
  168. - return decoded;
  169. +int decSamples(int length, short * destBuf)
  170. +{
  171. + int decoded = 0;
  172. + FLAC__bool success = false;
  173. + FLAC__StreamDecoderState state;
  174. +
  175. + if(length <= 0)
  176. + return 0;
  177. +
  178. + state = FLAC__stream_decoder_get_state(decoder);
  179. + if(state == FLAC__STREAM_DECODER_END_OF_STREAM
  180. + || state == FLAC__STREAM_DECODER_ABORTED)
  181. + return -1;
  182. +
  183. + while(decoded < length) {
  184. + if(finfo.frame == NULL || finfo.pos == finfo.frame->header.blocksize) {
  185. + success = FLAC__stream_decoder_process_single(decoder);
  186. + if(success == false)
  187. + return -1;
  188. + state = FLAC__stream_decoder_get_state(decoder);
  189. + if(state == FLAC__STREAM_DECODER_END_OF_STREAM
  190. + || state == FLAC__STREAM_DECODER_ABORTED)
  191. + return decoded;
  192. + }
  193. +
  194. + int toCopy = (length-decoded);
  195. +
  196. + if(toCopy + finfo.pos > finfo.frame->header.blocksize){
  197. + toCopy = finfo.frame->header.blocksize - finfo.pos;
  198. + }
  199. +
  200. + memcpy(destBuf, &finfo.buffer[0][finfo.pos], toCopy*2);
  201. + memcpy(&destBuf[length], &finfo.buffer[1][finfo.pos], toCopy*2);
  202. + decoded += toCopy;
  203. + finfo.pos+= toCopy;
  204. + destBuf +=toCopy;
  205. + }
  206. + return decoded;
  207. }
  208.  
  209. -FLAC__StreamDecoderWriteStatus write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data) {
  210. - if(total_samples == 0) {
  211. - fprintf(stderr, "No samples to decode!\n");
  212. - return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
  213. - }
  214. - if(channels != 2 || bps != 16) {
  215. - fprintf(stderr, "Not stereo 16-bit!\n");
  216. - return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
  217. - }
  218. -
  219. - finfo.frame = frame;
  220. - finfo.buffer = buffer;
  221. - finfo.pos = 0;
  222. -
  223. - return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
  224. +FLAC__StreamDecoderWriteStatus write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
  225. +{
  226. + if(total_samples == 0) {
  227. + fprintf(stderr, "No samples to decode!\n");
  228. + return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
  229. + }
  230. + if(channels != 2 || bps != 16) {
  231. + fprintf(stderr, "Not stereo 16-bit!\n");
  232. + return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
  233. + }
  234. +
  235. + finfo.frame = frame;
  236. + finfo.buffer = buffer;
  237. + finfo.pos = 0;
  238. +
  239. + return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
  240. }
  241.  
  242. -void metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) {
  243. - if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
  244. - /* save for later */
  245. - total_samples = metadata->data.stream_info.total_samples;
  246. - sample_rate = metadata->data.stream_info.sample_rate;
  247. - channels = metadata->data.stream_info.channels;
  248. - bps = metadata->data.stream_info.bits_per_sample;
  249. - }
  250. +void metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
  251. +{
  252. + if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
  253. + /* save for later */
  254. + total_samples = metadata->data.stream_info.total_samples;
  255. + sample_rate = metadata->data.stream_info.sample_rate;
  256. + channels = metadata->data.stream_info.channels;
  257. + bps = metadata->data.stream_info.bits_per_sample;
  258. + }
  259. }
  260.  
  261. -void error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) {
  262. - char *err;
  263. - switch(status) {
  264. - case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
  265. - err = "Lost sync"; break;
  266. - case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
  267. - err = "Bad header"; break;
  268. - case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
  269. - err = "Frame CRC mismatch"; break;
  270. - case FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM:
  271. - err = "Unparseable stream"; break;
  272. - default:
  273. - err = "???";
  274. - }
  275. -
  276. - fprintf(stderr, "error: %s\n", err);
  277. +void error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
  278. +{
  279. + char *err;
  280. + switch(status) {
  281. + case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
  282. + err = "Lost sync";
  283. + break;
  284. + case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
  285. + err = "Bad header";
  286. + break;
  287. + case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
  288. + err = "Frame CRC mismatch";
  289. + break;
  290. + case FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM:
  291. + err = "Unparseable stream";
  292. + break;
  293. + default:
  294. + err = "???";
  295. + }
  296. +
  297. + fprintf(stderr, "error: %s\n", err);
  298. }
  299. -
  300. diff --git a/source/SndStream.arm.c b/source/SndStream.arm.c
  301. index e03521e..c6ee663 100644
  302. --- a/source/SndStream.arm.c
  303. +++ b/source/SndStream.arm.c
  304. @@ -91,7 +91,7 @@ int updateStream(CODEC_INTERFACE * cdc)
  305. return 0;
  306. }
  307. if(ret) {
  308. - copySamples(workBuf.buffer, 1, ret);
  309. + copySamples(workBuf.buffer, 0 , ret);
  310. smpNc -= ret;
  311. }
  312.  
  313. @@ -109,7 +109,7 @@ void preFill(CODEC_INTERFACE * cdc)
  314. if(ret<=0) {
  315. break;
  316. }
  317. - copySamples(workBuf.buffer, 1, ret);
  318. + copySamples(workBuf.buffer, 0, ret);
  319. smpNc -=ret;
  320. }
  321. }
  322. @@ -131,10 +131,7 @@ void deFragReadbuf(unsigned char * readBuf, unsigned char ** readOff, int dataLe
  323. void copySamples(short * inBuf, int deinterleave, int samples)
  324. {
  325. int toEnd = ((outBuf.bufOff + samples) > STREAM_BUF_SIZE? STREAM_BUF_SIZE - outBuf.bufOff : samples);
  326. -
  327. - DC_FlushAll();
  328. - FeOS_DrainWriteBuffer();
  329. -
  330. + int totalSamps = samples;
  331. copy:
  332.  
  333. if(toEnd) {
  334. @@ -143,7 +140,7 @@ copy:
  335. //. Right channel
  336. case 2:
  337. if(!deinterleave)
  338. - memcpy(&outBuf.buffer[STREAM_BUF_SIZE+outBuf.bufOff], &inBuf[toEnd], toEnd*2);
  339. + memcpy(&outBuf.buffer[STREAM_BUF_SIZE+outBuf.bufOff], &inBuf[totalSamps], toEnd*2);
  340. // has to be stereo
  341. else {
  342. _deInterleave(inBuf, &outBuf.buffer[outBuf.bufOff], toEnd);
  343. @@ -156,15 +153,20 @@ copy:
  344. }
  345. }
  346.  
  347. -
  348. samples -= toEnd;
  349.  
  350. if(samples) {
  351. outBuf.bufOff = 0;
  352. - inBuf += toEnd*nChans;
  353. + if(!deinterleave && nChans == 2)
  354. + inBuf+=toEnd;
  355. + else
  356. + inBuf += toEnd*nChans;
  357. toEnd = samples;
  358. goto copy;
  359. }
  360. +
  361. outBuf.bufOff += toEnd;
  362. -
  363. +
  364. + DC_FlushAll();
  365. + FeOS_DrainWriteBuffer();
  366. }
  367. diff --git a/source/main.c b/source/main.c
  368. index 648d560..119df94 100644
  369. --- a/source/main.c
  370. +++ b/source/main.c
  371. @@ -54,7 +54,7 @@ int main(int argc, char ** argv)
  372. int i;
  373. initSoundStreamer();
  374.  
  375. - if(argc == 1)
  376. + /*if(argc == 1)
  377. path = pickFile("/", filter, compar);
  378. else
  379. path = strdup(argv[1]);
  380. @@ -71,9 +71,9 @@ int main(int argc, char ** argv)
  381. free(path);
  382. return 0;
  383. }
  384. -
  385. - startStream(&codec, type, path);
  386. -
  387. + */
  388. + //startStream(&codec, type, path);
  389. + startStream(&codec, "flac", "sample.flac");
  390. while(1) {
  391. FeOS_WaitForVBlank();
  392. if(!updateStream(&codec)) {
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!