1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <FLAC/stream_decoder.h>
#include "codec.h"
#include "cflac.h"
#include "common.h"
static FLAC__StreamDecoder *decoder = 0;
#define BUFFERSIZE 40000
static char buffer[BUFFERSIZE];
static int remaining; // bytes remaining in buffer from last read
FLAC__StreamDecoderWriteStatus
cflac_write_callback (const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const inputbuffer[], void *client_data) {
if (frame->header.blocksize == 0) {
return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
}
int readbytes = frame->header.blocksize * cflac.info.channels * cflac.info.bitsPerSample / 8;
int bufsize = BUFFERSIZE-remaining;
int bufsamples = bufsize / (cflac.info.channels * cflac.info.bitsPerSample / 8);
int nsamples = min (bufsamples, frame->header.blocksize);
char *bufptr = &buffer[remaining];
for (int i = 0; i < nsamples; i++) {
FLAC__int16 lsample = (FLAC__int16)inputbuffer[0][i];
((int16_t*)bufptr)[0] = lsample;
bufptr += cflac.info.bitsPerSample / 8;
remaining += cflac.info.bitsPerSample / 8;
if (cflac.info.channels > 1) {
FLAC__int16 rsample = (FLAC__int16)inputbuffer[1][i];
((int16_t*)bufptr)[0] = rsample;
bufptr += cflac.info.bitsPerSample / 8;
remaining += cflac.info.bitsPerSample / 8;
}
}
if (readbytes > bufsize) {
printf ("flac: buffer overflow, distortion will occur\n");
// return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
}
return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}
void
cflac_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) {
FLAC__uint64 total_samples = metadata->data.stream_info.total_samples;
int sample_rate = metadata->data.stream_info.sample_rate;
int channels = metadata->data.stream_info.channels;
int bps = metadata->data.stream_info.bits_per_sample;
cflac.info.samplesPerSecond = sample_rate;
cflac.info.channels = channels;
cflac.info.bitsPerSample = bps;
cflac.info.duration = total_samples / (float)sample_rate;
cflac.info.position = 0;
}
void
cflac_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) {
fprintf(stderr, "cflac: got error callback: %s\n", FLAC__StreamDecoderErrorStatusString[status]);
}
int
cflac_init (const char *fname, int track, float start, float end) {
printf ("cflac_init called for %s\n", fname);
FLAC__StreamDecoderInitStatus status;
decoder = FLAC__stream_decoder_new();
if (!decoder) {
printf ("FLAC__stream_decoder_new failed\n");
return -1;
}
FLAC__stream_decoder_set_md5_checking(decoder, 0);
status = FLAC__stream_decoder_init_file(decoder, fname, cflac_write_callback, cflac_metadata_callback, cflac_error_callback, NULL);
cflac.info.duration = -1;
cflac.info.position = 0;
FLAC__stream_decoder_process_until_end_of_metadata (decoder);
if (cflac.info.duration == -1) {
printf ("FLAC duration calculation failed\n");
return -1;
}
remaining = 0;
return 0;
}
void
cflac_free (void) {
if (decoder) {
FLAC__stream_decoder_delete(decoder);
decoder = NULL;
}
}
int
cflac_read (char *bytes, int size) {
int nsamples = size / (cflac.info.channels * cflac.info.bitsPerSample / 8);
do {
if (remaining) {
int sz = min (remaining, size);
memcpy (bytes, buffer, sz);
if (sz < remaining) {
memmove (buffer, &buffer[sz], remaining-sz);
}
remaining -= sz;
bytes += sz;
size -= sz;
}
if (!size) {
break;
}
if (!FLAC__stream_decoder_process_single (decoder)) {
memset (bytes, 0, size);
return -1;
}
if (FLAC__stream_decoder_get_state (decoder) == FLAC__STREAM_DECODER_END_OF_STREAM) {
return -1;
}
} while (size > 0);
cflac.info.position += (float)nsamples / cflac.info.samplesPerSecond;
return 0;
}
int
cflac_seek (float time) {
if (!FLAC__stream_decoder_seek_absolute (decoder, (FLAC__uint64)(time * cflac.info.samplesPerSecond))) {
return -1;
}
remaining = 0;
cflac.info.position = time;
return 0;
}
int
cflac_add (const char *fname) {
return 0;
}
codec_t cflac = {
.init = cflac_init,
.free = cflac_free,
.read = cflac_read,
.seek = cflac_seek,
.add = cflac_add
};
|
