-rw-r--r-- | core/multimedia/opieplayer/libmad/libmadplugin.cpp | 2 |
1 files changed, 1 insertions, 1 deletions
diff --git a/core/multimedia/opieplayer/libmad/libmadplugin.cpp b/core/multimedia/opieplayer/libmad/libmadplugin.cpp index c744c6d..319e0ff 100644 --- a/core/multimedia/opieplayer/libmad/libmadplugin.cpp +++ b/core/multimedia/opieplayer/libmad/libmadplugin.cpp | |||
@@ -42,769 +42,769 @@ | |||
42 | // for network handling | 42 | // for network handling |
43 | #include <netinet/in.h> | 43 | #include <netinet/in.h> |
44 | #include <netdb.h> | 44 | #include <netdb.h> |
45 | #include <sys/socket.h> | 45 | #include <sys/socket.h> |
46 | #include <arpa/inet.h> | 46 | #include <arpa/inet.h> |
47 | #include <unistd.h> | 47 | #include <unistd.h> |
48 | 48 | ||
49 | 49 | ||
50 | //#define HAVE_MMAP | 50 | //#define HAVE_MMAP |
51 | 51 | ||
52 | #if defined(HAVE_MMAP) | 52 | #if defined(HAVE_MMAP) |
53 | # include <sys/mman.h> | 53 | # include <sys/mman.h> |
54 | #endif | 54 | #endif |
55 | #include "libmadplugin.h" | 55 | #include "libmadplugin.h" |
56 | 56 | ||
57 | 57 | ||
58 | extern "C" { | 58 | extern "C" { |
59 | #include "mad.h" | 59 | #include "mad.h" |
60 | } | 60 | } |
61 | 61 | ||
62 | 62 | ||
63 | #define MPEG_BUFFER_SIZE 65536 | 63 | #define MPEG_BUFFER_SIZE 65536 |
64 | //#define MPEG_BUFFER_SIZE 32768 //16384 // 8192 | 64 | //#define MPEG_BUFFER_SIZE 32768 //16384 // 8192 |
65 | //#define debugMsg(a) qDebug(a) | 65 | //#define debugMsg(a) qDebug(a) |
66 | #define debugMsg(a) | 66 | #define debugMsg(a) |
67 | 67 | ||
68 | 68 | ||
69 | class Input { | 69 | class Input { |
70 | public: | 70 | public: |
71 | char const *path; | 71 | char const *path; |
72 | int fd; | 72 | int fd; |
73 | #if defined(HAVE_MMAP) | 73 | #if defined(HAVE_MMAP) |
74 | void *fdm; | 74 | void *fdm; |
75 | #endif | 75 | #endif |
76 | unsigned char *data; | 76 | unsigned char *data; |
77 | unsigned long length; | 77 | unsigned long length; |
78 | int eof; | 78 | int eof; |
79 | }; | 79 | }; |
80 | 80 | ||
81 | 81 | ||
82 | class Output { | 82 | class Output { |
83 | public: | 83 | public: |
84 | mad_fixed_t attenuate; | 84 | mad_fixed_t attenuate; |
85 | struct filter *filters; | 85 | struct filter *filters; |
86 | unsigned int channels_in; | 86 | unsigned int channels_in; |
87 | unsigned int channels_out; | 87 | unsigned int channels_out; |
88 | unsigned int speed_in; | 88 | unsigned int speed_in; |
89 | unsigned int speed_out; | 89 | unsigned int speed_out; |
90 | const char *path; | 90 | const char *path; |
91 | }; | 91 | }; |
92 | 92 | ||
93 | 93 | ||
94 | # if defined(HAVE_MMAP) | 94 | # if defined(HAVE_MMAP) |
95 | static void *map_file(int fd, unsigned long *length) | 95 | static void *map_file(int fd, unsigned long *length) |
96 | { | 96 | { |
97 | void *fdm; | 97 | void *fdm; |
98 | 98 | ||
99 | *length += MAD_BUFFER_GUARD; | 99 | *length += MAD_BUFFER_GUARD; |
100 | 100 | ||
101 | fdm = mmap(0, *length, PROT_READ, MAP_SHARED, fd, 0); | 101 | fdm = mmap(0, *length, PROT_READ, MAP_SHARED, fd, 0); |
102 | if (fdm == MAP_FAILED) | 102 | if (fdm == MAP_FAILED) |
103 | return 0; | 103 | return 0; |
104 | 104 | ||
105 | # if defined(HAVE_MADVISE) | 105 | # if defined(HAVE_MADVISE) |
106 | madvise(fdm, *length, MADV_SEQUENTIAL); | 106 | madvise(fdm, *length, MADV_SEQUENTIAL); |
107 | # endif | 107 | # endif |
108 | 108 | ||
109 | return fdm; | 109 | return fdm; |
110 | } | 110 | } |
111 | 111 | ||
112 | 112 | ||
113 | static int unmap_file(void *fdm, unsigned long length) | 113 | static int unmap_file(void *fdm, unsigned long length) |
114 | { | 114 | { |
115 | if (munmap(fdm, length) == -1) | 115 | if (munmap(fdm, length) == -1) |
116 | return -1; | 116 | return -1; |
117 | 117 | ||
118 | return 0; | 118 | return 0; |
119 | } | 119 | } |
120 | # endif | 120 | # endif |
121 | 121 | ||
122 | 122 | ||
123 | static inline QString tr( const char *str ) { | 123 | static inline QString tr( const char *str ) { |
124 | // Apparently this is okay from a plugin as it runs in the process space of the owner of the plugin | 124 | // Apparently this is okay from a plugin as it runs in the process space of the owner of the plugin |
125 | return qApp->translate( "OpiePlayer", str, "libmad strings for mp3 file info" ); | 125 | return qApp->translate( "OpiePlayer", str, "libmad strings for mp3 file info" ); |
126 | } | 126 | } |
127 | 127 | ||
128 | 128 | ||
129 | class LibMadPluginData { | 129 | class LibMadPluginData { |
130 | public: | 130 | public: |
131 | Input input; | 131 | Input input; |
132 | Output output; | 132 | Output output; |
133 | int bad_last_frame; | 133 | int bad_last_frame; |
134 | struct mad_stream stream; | 134 | struct mad_stream stream; |
135 | struct mad_frame frame; | 135 | struct mad_frame frame; |
136 | struct mad_synth synth; | 136 | struct mad_synth synth; |
137 | bool flush; | 137 | bool flush; |
138 | }; | 138 | }; |
139 | 139 | ||
140 | 140 | ||
141 | LibMadPlugin::LibMadPlugin() { | 141 | LibMadPlugin::LibMadPlugin() { |
142 | d = new LibMadPluginData; | 142 | d = new LibMadPluginData; |
143 | d->input.fd = 0; | 143 | d->input.fd = 0; |
144 | #if defined(HAVE_MMAP) | 144 | #if defined(HAVE_MMAP) |
145 | d->input.fdm = 0; | 145 | d->input.fdm = 0; |
146 | #endif | 146 | #endif |
147 | d->input.data = 0; | 147 | d->input.data = 0; |
148 | d->flush = TRUE; | 148 | d->flush = TRUE; |
149 | info = tr( "No Song Open" ); | 149 | info = tr( "No Song Open" ); |
150 | } | 150 | } |
151 | 151 | ||
152 | 152 | ||
153 | LibMadPlugin::~LibMadPlugin() { | 153 | LibMadPlugin::~LibMadPlugin() { |
154 | close(); | 154 | close(); |
155 | delete d; | 155 | delete d; |
156 | } | 156 | } |
157 | 157 | ||
158 | 158 | ||
159 | bool LibMadPlugin::isFileSupported( const QString& path ) { | 159 | bool LibMadPlugin::isFileSupported( const QString& path ) { |
160 | debugMsg( "LibMadPlugin::isFileSupported" ); | 160 | debugMsg( "LibMadPlugin::isFileSupported" ); |
161 | 161 | ||
162 | // Mpeg file extensions | 162 | // Mpeg file extensions |
163 | // "mp2","mp3","m1v","m2v","m2s","mpg","vob","mpeg","ac3" | 163 | // "mp2","mp3","m1v","m2v","m2s","mpg","vob","mpeg","ac3" |
164 | // Other media extensions | 164 | // Other media extensions |
165 | // "wav","mid","mod","s3m","ogg","avi","mov","sid" | 165 | // "wav","mid","mod","s3m","ogg","avi","mov","sid" |
166 | 166 | ||
167 | char *ext = strrchr( path.latin1(), '.' ); | 167 | char *ext = strrchr( path.latin1(), '.' ); |
168 | 168 | ||
169 | // Test file extension | 169 | // Test file extension |
170 | if ( ext ) { | 170 | if ( ext ) { |
171 | if ( strncasecmp(ext, ".mp2", 4) == 0 ) | 171 | if ( strncasecmp(ext, ".mp2", 4) == 0 ) |
172 | return TRUE; | 172 | return TRUE; |
173 | if ( strncasecmp(ext, ".mp3", 4) == 0 ) | 173 | if ( strncasecmp(ext, ".mp3", 4) == 0 ) |
174 | return TRUE; | 174 | return TRUE; |
175 | } | 175 | } |
176 | 176 | ||
177 | // UGLY - just for fast testing | 177 | // UGLY - just for fast testing |
178 | if ( path.left(4) == "http") { | 178 | if ( path.left(4) == "http") { |
179 | return TRUE; | 179 | return TRUE; |
180 | } | 180 | } |
181 | 181 | ||
182 | return FALSE; | 182 | return FALSE; |
183 | } | 183 | } |
184 | 184 | ||
185 | 185 | ||
186 | 186 | ||
187 | int LibMadPlugin::is_address_multicast(unsigned long address) { | 187 | int LibMadPlugin::is_address_multicast(unsigned long address) { |
188 | if ((address & 255) >= 224 && (address & 255) <= 239) | 188 | if ((address & 255) >= 224 && (address & 255) <= 239) |
189 | return (1); | 189 | return (1); |
190 | return (0); | 190 | return (0); |
191 | } | 191 | } |
192 | 192 | ||
193 | 193 | ||
194 | int LibMadPlugin::udp_open(char *address, int port) { | 194 | int LibMadPlugin::udp_open(char *address, int port) { |
195 | 195 | ||
196 | int enable = 1L; | 196 | int enable = 1L; |
197 | struct sockaddr_in stAddr; | 197 | struct sockaddr_in stAddr; |
198 | struct sockaddr_in stLclAddr; | 198 | struct sockaddr_in stLclAddr; |
199 | struct ip_mreq stMreq; | 199 | struct ip_mreq stMreq; |
200 | struct hostent *host; | 200 | struct hostent *host; |
201 | int sock; | 201 | int sock; |
202 | 202 | ||
203 | stAddr.sin_family = AF_INET; | 203 | stAddr.sin_family = AF_INET; |
204 | stAddr.sin_port = htons(port); | 204 | stAddr.sin_port = htons(port); |
205 | 205 | ||
206 | if ((host = gethostbyname(address)) == NULL) { | 206 | if ((host = gethostbyname(address)) == NULL) { |
207 | return (0); | 207 | return (0); |
208 | } | 208 | } |
209 | 209 | ||
210 | stAddr.sin_addr = *((struct in_addr *)host->h_addr_list[0]); | 210 | stAddr.sin_addr = *((struct in_addr *)host->h_addr_list[0]); |
211 | 211 | ||
212 | /* Create a UDP socket */ | 212 | /* Create a UDP socket */ |
213 | if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { | 213 | if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { |
214 | return (0); | 214 | return (0); |
215 | } | 215 | } |
216 | 216 | ||
217 | /* Allow multiple instance of the client to share the same address and port */ | 217 | /* Allow multiple instance of the client to share the same address and port */ |
218 | if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&enable, sizeof(unsigned long int)) < 0) { | 218 | if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&enable, sizeof(unsigned long int)) < 0) { |
219 | return (0); | 219 | return (0); |
220 | } | 220 | } |
221 | 221 | ||
222 | /* If the address is multicast, register to the multicast group */ | 222 | /* If the address is multicast, register to the multicast group */ |
223 | if (is_address_multicast(stAddr.sin_addr.s_addr)) { | 223 | if (is_address_multicast(stAddr.sin_addr.s_addr)) { |
224 | /* Bind the socket to port */ | 224 | /* Bind the socket to port */ |
225 | stLclAddr.sin_family = AF_INET; | 225 | stLclAddr.sin_family = AF_INET; |
226 | stLclAddr.sin_addr.s_addr = htonl(INADDR_ANY); | 226 | stLclAddr.sin_addr.s_addr = htonl(INADDR_ANY); |
227 | stLclAddr.sin_port = stAddr.sin_port; | 227 | stLclAddr.sin_port = stAddr.sin_port; |
228 | if (bind(sock, (struct sockaddr *)&stLclAddr, sizeof(stLclAddr)) < 0) { | 228 | if (bind(sock, (struct sockaddr *)&stLclAddr, sizeof(stLclAddr)) < 0) { |
229 | return (0); | 229 | return (0); |
230 | } | 230 | } |
231 | 231 | ||
232 | /* Register to a multicast address */ | 232 | /* Register to a multicast address */ |
233 | stMreq.imr_multiaddr.s_addr = stAddr.sin_addr.s_addr; | 233 | stMreq.imr_multiaddr.s_addr = stAddr.sin_addr.s_addr; |
234 | stMreq.imr_interface.s_addr = INADDR_ANY; | 234 | stMreq.imr_interface.s_addr = INADDR_ANY; |
235 | if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&stMreq, sizeof(stMreq)) < 0) { | 235 | if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&stMreq, sizeof(stMreq)) < 0) { |
236 | return (0); | 236 | return (0); |
237 | } | 237 | } |
238 | } else { | 238 | } else { |
239 | /* Bind the socket to port */ | 239 | /* Bind the socket to port */ |
240 | stLclAddr.sin_family = AF_INET; | 240 | stLclAddr.sin_family = AF_INET; |
241 | stLclAddr.sin_addr.s_addr = htonl(INADDR_ANY); | 241 | stLclAddr.sin_addr.s_addr = htonl(INADDR_ANY); |
242 | stLclAddr.sin_port = htons(0); | 242 | stLclAddr.sin_port = htons(0); |
243 | if (bind(sock, (struct sockaddr *)&stLclAddr, sizeof(stLclAddr)) < 0) { | 243 | if (bind(sock, (struct sockaddr *)&stLclAddr, sizeof(stLclAddr)) < 0) { |
244 | return (0); | 244 | return (0); |
245 | } | 245 | } |
246 | } | 246 | } |
247 | return (sock); | 247 | return (sock); |
248 | } | 248 | } |
249 | 249 | ||
250 | int LibMadPlugin::tcp_open(char *address, int port) { | 250 | int LibMadPlugin::tcp_open(char *address, int port) { |
251 | struct sockaddr_in stAddr; | 251 | struct sockaddr_in stAddr; |
252 | struct hostent *host; | 252 | struct hostent *host; |
253 | int sock; | 253 | int sock; |
254 | struct linger l; | 254 | struct linger l; |
255 | 255 | ||
256 | memset(&stAddr, 0, sizeof(stAddr)); | 256 | memset(&stAddr, 0, sizeof(stAddr)); |
257 | stAddr.sin_family = AF_INET; | 257 | stAddr.sin_family = AF_INET; |
258 | stAddr.sin_port = htons(port); | 258 | stAddr.sin_port = htons(port); |
259 | 259 | ||
260 | if ((host = gethostbyname(address)) == NULL) { | 260 | if ((host = gethostbyname(address)) == NULL) { |
261 | return (0); | 261 | return (0); |
262 | } | 262 | } |
263 | 263 | ||
264 | stAddr.sin_addr = *((struct in_addr *)host->h_addr_list[0]); | 264 | stAddr.sin_addr = *((struct in_addr *)host->h_addr_list[0]); |
265 | 265 | ||
266 | if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { | 266 | if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { |
267 | return (0); | 267 | return (0); |
268 | } | 268 | } |
269 | 269 | ||
270 | l.l_onoff = 1; | 270 | l.l_onoff = 1; |
271 | l.l_linger = 5; | 271 | l.l_linger = 5; |
272 | if (setsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&l, sizeof(l)) < 0) { | 272 | if (setsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&l, sizeof(l)) < 0) { |
273 | return (0); | 273 | return (0); |
274 | } | 274 | } |
275 | 275 | ||
276 | if (connect(sock, (struct sockaddr *)&stAddr, sizeof(stAddr)) < 0) { | 276 | if (connect(sock, (struct sockaddr *)&stAddr, sizeof(stAddr)) < 0) { |
277 | return (0); | 277 | return (0); |
278 | } | 278 | } |
279 | 279 | ||
280 | return (sock); | 280 | return (sock); |
281 | } | 281 | } |
282 | 282 | ||
283 | 283 | ||
284 | /** | 284 | /** |
285 | * Read a http line header. | 285 | * Read a http line header. |
286 | * This function read character by character. | 286 | * This function read character by character. |
287 | * @param tcp_sock the socket use to read the stream | 287 | * @param tcp_sock the socket use to read the stream |
288 | * @param buf a buffer to receive the data | 288 | * @param buf a buffer to receive the data |
289 | * @param size size of the buffer | 289 | * @param size size of the buffer |
290 | * @return the size of the stream read or -1 if an error occured | 290 | * @return the size of the stream read or -1 if an error occured |
291 | */ | 291 | */ |
292 | int LibMadPlugin::http_read_line(int tcp_sock, char *buf, int size) { | 292 | int LibMadPlugin::http_read_line(int tcp_sock, char *buf, int size) { |
293 | int offset = 0; | 293 | int offset = 0; |
294 | 294 | ||
295 | do { | 295 | do { |
296 | if (std::read(tcp_sock, buf + offset, 1) < 0) | 296 | if (std::read(tcp_sock, buf + offset, 1) < 0) |
297 | return -1; | 297 | return -1; |
298 | if (buf[offset] != '\r') /* Strip \r from answer */ | 298 | if (buf[offset] != '\r') /* Strip \r from answer */ |
299 | offset++; | 299 | offset++; |
300 | } while (offset < size - 1 && buf[offset - 1] != '\n'); | 300 | } while (offset < size - 1 && buf[offset - 1] != '\n'); |
301 | 301 | ||
302 | buf[offset] = 0; | 302 | buf[offset] = 0; |
303 | return offset; | 303 | return offset; |
304 | } | 304 | } |
305 | 305 | ||
306 | int LibMadPlugin::http_open(const QString& path ) { | 306 | int LibMadPlugin::http_open(const QString& path ) { |
307 | char *host; | 307 | char *host; |
308 | int port; | 308 | int port; |
309 | char *request; | 309 | char *request; |
310 | int tcp_sock; | 310 | int tcp_sock; |
311 | char http_request[PATH_MAX]; | 311 | char http_request[PATH_MAX]; |
312 | char filename[PATH_MAX]; | 312 | char filename[PATH_MAX]; |
313 | //char c; | 313 | //char c; |
314 | char *arg =strdup(path.latin1()); | 314 | char *arg =strdup(path.latin1()); |
315 | 315 | ||
316 | /* Check for URL syntax */ | 316 | /* Check for URL syntax */ |
317 | if (strncmp(arg, "http://", strlen("http://"))) { | 317 | if (strncmp(arg, "http://", strlen("http://"))) { |
318 | return (0); | 318 | return (0); |
319 | } | 319 | } |
320 | 320 | ||
321 | /* Parse URL */ | 321 | /* Parse URL */ |
322 | port = 80; | 322 | port = 80; |
323 | host = arg + strlen("http://"); | 323 | host = arg + strlen("http://"); |
324 | if ((request = strchr(host, '/')) == NULL) { | 324 | if ((request = strchr(host, '/')) == NULL) { |
325 | return (0); | 325 | return (0); |
326 | } | 326 | } |
327 | 327 | ||
328 | *request++ = 0; | 328 | *request++ = 0; |
329 | 329 | ||
330 | if (strchr(host, ':') != NULL) { /* port is specified */ | 330 | if (strchr(host, ':') != NULL) { /* port is specified */ |
331 | port = atoi(strchr(host, ':') + 1); | 331 | port = atoi(strchr(host, ':') + 1); |
332 | *strchr(host, ':') = 0; | 332 | *strchr(host, ':') = 0; |
333 | } | 333 | } |
334 | 334 | ||
335 | /* Open a TCP socket */ | 335 | /* Open a TCP socket */ |
336 | if (!(tcp_sock = tcp_open(host, port))) { | 336 | if (!(tcp_sock = tcp_open(host, port))) { |
337 | perror("http_open"); | 337 | perror("http_open"); |
338 | return (0); | 338 | return (0); |
339 | } | 339 | } |
340 | 340 | ||
341 | snprintf(filename, sizeof(filename) - strlen(host) - 75, "%s", request); | 341 | snprintf(filename, sizeof(filename) - strlen(host) - 75, "%s", request); |
342 | 342 | ||
343 | /* Send HTTP GET request */ | 343 | /* Send HTTP GET request */ |
344 | /* Please don't use a Agent know by shoutcast (Lynx, Mozilla) seems to be reconized and print | 344 | /* Please don't use a Agent know by shoutcast (Lynx, Mozilla) seems to be reconized and print |
345 | * a html page and not the stream */ | 345 | * a html page and not the stream */ |
346 | snprintf(http_request, sizeof(http_request), "GET /%s HTTP/1.0\r\n" | 346 | snprintf(http_request, sizeof(http_request), "GET /%s HTTP/1.0\r\n" |
347 | /* "User-Agent: Mozilla/2.0 (Win95; I)\r\n" */ | 347 | /* "User-Agent: Mozilla/2.0 (Win95; I)\r\n" */ |
348 | "Pragma: no-cache\r\n" "Host: %s\r\n" "Accept: */*\r\n" "\r\n", filename, host); | 348 | "Pragma: no-cache\r\n" "Host: %s\r\n" "Accept: */*\r\n" "\r\n", filename, host); |
349 | 349 | ||
350 | send(tcp_sock, http_request, strlen(http_request), 0); | 350 | send(tcp_sock, http_request, strlen(http_request), 0); |
351 | 351 | ||
352 | /* Parse server reply */ | 352 | /* Parse server reply */ |
353 | #if 0 | 353 | #if 0 |
354 | do | 354 | do |
355 | read(tcp_sock, &c, sizeof(char)); | 355 | read(tcp_sock, &c, sizeof(char)); |
356 | while (c != ' '); | 356 | while (c != ' '); |
357 | read(tcp_sock, http_request, 4 * sizeof(char)); | 357 | read(tcp_sock, http_request, 4 * sizeof(char)); |
358 | http_request[4] = 0; | 358 | http_request[4] = 0; |
359 | if (strcmp(http_request, "200 ")) { | 359 | if (strcmp(http_request, "200 ")) { |
360 | fprintf(stderr, "http_open: "); | 360 | fprintf(stderr, "http_open: "); |
361 | do { | 361 | do { |
362 | read(tcp_sock, &c, sizeof(char)); | 362 | read(tcp_sock, &c, sizeof(char)); |
363 | fprintf(stderr, "%c", c); | 363 | fprintf(stderr, "%c", c); |
364 | } while (c != '\r'); | 364 | } while (c != '\r'); |
365 | fprintf(stderr, "\n"); | 365 | fprintf(stderr, "\n"); |
366 | return (0); | 366 | return (0); |
367 | } | 367 | } |
368 | #endif | 368 | #endif |
369 | 369 | ||
370 | QString name; | 370 | QString name; |
371 | QString genre; | 371 | QString genre; |
372 | QString bitrate; | 372 | QString bitrate; |
373 | QString url; | 373 | QString url; |
374 | QString message = tr("Info: "); | 374 | QString message = tr("Info: "); |
375 | do { | 375 | do { |
376 | 376 | ||
377 | int len; | 377 | int len; |
378 | 378 | ||
379 | len = http_read_line(tcp_sock, http_request, sizeof(http_request)); | 379 | len = http_read_line(tcp_sock, http_request, sizeof(http_request)); |
380 | 380 | ||
381 | if (len == -1) { | 381 | if (len == -1) { |
382 | qDebug( "http_open: "+ QString(strerror(errno)) +"\n"); | 382 | qDebug( "http_open: "+ QString(strerror(errno)) +"\n"); |
383 | return 0; | 383 | return 0; |
384 | } | 384 | } |
385 | 385 | ||
386 | if (QString(http_request).left(9) == "Location:") { | 386 | if (QString(http_request).left(9) == "Location:") { |
387 | /* redirect */ | 387 | /* redirect */ |
388 | std::close(tcp_sock); | 388 | std::close(tcp_sock); |
389 | http_request[strlen(http_request) - 1] = '\0'; | 389 | http_request[strlen(http_request) - 1] = '\0'; |
390 | return http_open(&http_request[10]); | 390 | return http_open(&http_request[10]); |
391 | } | 391 | } |
392 | 392 | ||
393 | if (QString(http_request).left(4) == "ICY ") { | 393 | if (QString(http_request).left(4) == "ICY ") { |
394 | /* This is shoutcast/icecast streaming */ | 394 | /* This is shoutcast/icecast streaming */ |
395 | if (strncmp(http_request + 4, "200 ", 4)) { | 395 | if (strncmp(http_request + 4, "200 ", 4)) { |
396 | qDebug("http_open: " + QString(http_request) + "\n"); | 396 | qDebug("http_open: " + QString(http_request) + "\n"); |
397 | return 0; | 397 | return 0; |
398 | } | 398 | } |
399 | } else if (QString(http_request).left(4) == "icy-") { | 399 | } else if (QString(http_request).left(4) == "icy-") { |
400 | /* we can have: icy-noticeX, icy-name, icy-genre, icy-url, icy-pub, icy-metaint, icy-br */ | 400 | /* we can have: icy-noticeX, icy-name, icy-genre, icy-url, icy-pub, icy-metaint, icy-br */ |
401 | if ( QString( http_request ).left( 8 ) == "icy-name" ) { | 401 | if ( QString( http_request ).left( 8 ) == "icy-name" ) { |
402 | name = tr("Name: ") + QString(http_request).mid(9, (QString(http_request).length())- 9 ); | 402 | name = tr("Name: ") + QString(http_request).mid(9, (QString(http_request).length())- 9 ); |
403 | } else if ( QString( http_request ).left( 9 ) == "icy-genre" ) { | 403 | } else if ( QString( http_request ).left( 9 ) == "icy-genre" ) { |
404 | genre = tr("Genre: ") + QString(http_request).mid(10, (QString(http_request).length())-10 ); | 404 | genre = tr("Genre: ") + QString(http_request).mid(10, (QString(http_request).length())-10 ); |
405 | } else if ( QString( http_request ).left( 6 ) == "icy-br" ) { | 405 | } else if ( QString( http_request ).left( 6 ) == "icy-br" ) { |
406 | bitrate = tr("Bitrate: ") + QString(http_request).mid(7, (QString(http_request).length())- 7 ); | 406 | bitrate = tr("Bitrate: ") + QString(http_request).mid(7, (QString(http_request).length())- 7 ); |
407 | } else if ( QString( http_request ).left( 7 ) == "icy-url" ) { | 407 | } else if ( QString( http_request ).left( 7 ) == "icy-url" ) { |
408 | url = tr("URL: ") + QString(http_request).mid(8, (QString(http_request).length())- 8 ); | 408 | url = tr("URL: ") + QString(http_request).mid(8, (QString(http_request).length())- 8 ); |
409 | } else if ( QString( http_request ).left( 10 ) == "icy-notice" ) { | 409 | } else if ( QString( http_request ).left( 10 ) == "icy-notice" ) { |
410 | message += QString(http_request).mid(11, QString(http_request).length()-11 ) ; | 410 | message += QString(http_request).mid(11, QString(http_request).length()-11 ) ; |
411 | } | 411 | } |
412 | } | 412 | } |
413 | } while (strcmp(http_request, "\n") != 0); | 413 | } while (strcmp(http_request, "\n") != 0); |
414 | 414 | ||
415 | info = QString(name + genre + url + bitrate + message).replace( QRegExp("\n"), " : " ); | 415 | info = QString(name + genre + url + bitrate + message).replace( QRegExp("\n"), " : " ); |
416 | 416 | ||
417 | qDebug("Stream info: " + info); | 417 | qDebug("Stream info: " + info); |
418 | 418 | ||
419 | return (tcp_sock); | 419 | return (tcp_sock); |
420 | } | 420 | } |
421 | 421 | ||
422 | 422 | ||
423 | 423 | ||
424 | bool LibMadPlugin::open( const QString& path ) { | 424 | bool LibMadPlugin::open( const QString& path ) { |
425 | debugMsg( "LibMadPlugin::open" ); | 425 | debugMsg( "LibMadPlugin::open" ); |
426 | Config cfg("MediaPlayer"); | 426 | Config cfg("OpiePlayer"); |
427 | cfg.setGroup("Options"); | 427 | cfg.setGroup("Options"); |
428 | bufferSize = cfg.readNumEntry("MPeg_BufferSize",MPEG_BUFFER_SIZE); | 428 | bufferSize = cfg.readNumEntry("MPeg_BufferSize",MPEG_BUFFER_SIZE); |
429 | qDebug("buffer size is %d", bufferSize); | 429 | qDebug("buffer size is %d", bufferSize); |
430 | d->bad_last_frame = 0; | 430 | d->bad_last_frame = 0; |
431 | d->flush = TRUE; | 431 | d->flush = TRUE; |
432 | info = QString( "" ); | 432 | info = QString( "" ); |
433 | 433 | ||
434 | //qDebug( "Opening %s", path.latin1() ); | 434 | //qDebug( "Opening %s", path.latin1() ); |
435 | 435 | ||
436 | 436 | ||
437 | if (path.left( 4 ) == "http" ) { | 437 | if (path.left( 4 ) == "http" ) { |
438 | qDebug("Test2"); | 438 | qDebug("Test2"); |
439 | // in case of any error we get 0 here | 439 | // in case of any error we get 0 here |
440 | if ( !(http_open(path) == 0) ) { | 440 | if ( !(http_open(path) == 0) ) { |
441 | qDebug("Test3"); | 441 | qDebug("Test3"); |
442 | d->input.fd = http_open(path); | 442 | d->input.fd = http_open(path); |
443 | } else { | 443 | } else { |
444 | qDebug("Test5"); | 444 | qDebug("Test5"); |
445 | return FALSE; | 445 | return FALSE; |
446 | } | 446 | } |
447 | } else { | 447 | } else { |
448 | qDebug("Test4"); | 448 | qDebug("Test4"); |
449 | d->input.path = path.latin1(); | 449 | d->input.path = path.latin1(); |
450 | d->input.fd = ::open( d->input.path, O_RDONLY ); | 450 | d->input.fd = ::open( d->input.path, O_RDONLY ); |
451 | // thats a better place, since it should only seek for ID3 tags on mp3 files, not streams | 451 | // thats a better place, since it should only seek for ID3 tags on mp3 files, not streams |
452 | printID3Tags(); | 452 | printID3Tags(); |
453 | } | 453 | } |
454 | if (d->input.fd == -1) { | 454 | if (d->input.fd == -1) { |
455 | qDebug("error opening %s", d->input.path ); | 455 | qDebug("error opening %s", d->input.path ); |
456 | return FALSE; | 456 | return FALSE; |
457 | } | 457 | } |
458 | 458 | ||
459 | // printID3Tags(); | 459 | // printID3Tags(); |
460 | 460 | ||
461 | #if defined(HAVE_MMAP) | 461 | #if defined(HAVE_MMAP) |
462 | struct stat stat; | 462 | struct stat stat; |
463 | if (fstat(d->input.fd, &stat) == -1) { | 463 | if (fstat(d->input.fd, &stat) == -1) { |
464 | //qDebug("error calling fstat"); return FALSE; | 464 | //qDebug("error calling fstat"); return FALSE; |
465 | } | 465 | } |
466 | if (S_ISREG(stat.st_mode) && stat.st_size > 0) { | 466 | if (S_ISREG(stat.st_mode) && stat.st_size > 0) { |
467 | d->input.length = stat.st_size; | 467 | d->input.length = stat.st_size; |
468 | d->input.fdm = map_file(d->input.fd, &d->input.length); | 468 | d->input.fdm = map_file(d->input.fd, &d->input.length); |
469 | if (d->input.fdm == 0) { | 469 | if (d->input.fdm == 0) { |
470 | qDebug("error mmapping file"); return FALSE; | 470 | qDebug("error mmapping file"); return FALSE; |
471 | } | 471 | } |
472 | d->input.data = (unsigned char *)d->input.fdm; | 472 | d->input.data = (unsigned char *)d->input.fdm; |
473 | } | 473 | } |
474 | #endif | 474 | #endif |
475 | 475 | ||
476 | if (d->input.data == 0) { | 476 | if (d->input.data == 0) { |
477 | d->input.data = (unsigned char *)malloc( bufferSize /*MPEG_BUFFER_SIZE*/); | 477 | d->input.data = (unsigned char *)malloc( bufferSize /*MPEG_BUFFER_SIZE*/); |
478 | if (d->input.data == 0) { | 478 | if (d->input.data == 0) { |
479 | qDebug("error allocating input buffer"); | 479 | qDebug("error allocating input buffer"); |
480 | return FALSE; | 480 | return FALSE; |
481 | } | 481 | } |
482 | d->input.length = 0; | 482 | d->input.length = 0; |
483 | } | 483 | } |
484 | 484 | ||
485 | d->input.eof = 0; | 485 | d->input.eof = 0; |
486 | 486 | ||
487 | mad_stream_init(&d->stream); | 487 | mad_stream_init(&d->stream); |
488 | mad_frame_init(&d->frame); | 488 | mad_frame_init(&d->frame); |
489 | mad_synth_init(&d->synth); | 489 | mad_synth_init(&d->synth); |
490 | 490 | ||
491 | return TRUE; | 491 | return TRUE; |
492 | } | 492 | } |
493 | 493 | ||
494 | 494 | ||
495 | bool LibMadPlugin::close() { | 495 | bool LibMadPlugin::close() { |
496 | debugMsg( "LibMadPlugin::close" ); | 496 | debugMsg( "LibMadPlugin::close" ); |
497 | 497 | ||
498 | int result = TRUE; | 498 | int result = TRUE; |
499 | 499 | ||
500 | mad_synth_finish(&d->synth); | 500 | mad_synth_finish(&d->synth); |
501 | mad_frame_finish(&d->frame); | 501 | mad_frame_finish(&d->frame); |
502 | mad_stream_finish(&d->stream); | 502 | mad_stream_finish(&d->stream); |
503 | 503 | ||
504 | #if defined(HAVE_MMAP) | 504 | #if defined(HAVE_MMAP) |
505 | if (d->input.fdm) { | 505 | if (d->input.fdm) { |
506 | if (unmap_file(d->input.fdm, d->input.length) == -1) { | 506 | if (unmap_file(d->input.fdm, d->input.length) == -1) { |
507 | qDebug("error munmapping file"); | 507 | qDebug("error munmapping file"); |
508 | result = FALSE; | 508 | result = FALSE; |
509 | } | 509 | } |
510 | d->input.fdm = 0; | 510 | d->input.fdm = 0; |
511 | d->input.data = 0; | 511 | d->input.data = 0; |
512 | } | 512 | } |
513 | #endif | 513 | #endif |
514 | 514 | ||
515 | if (d->input.data) { | 515 | if (d->input.data) { |
516 | free(d->input.data); | 516 | free(d->input.data); |
517 | d->input.data = 0; | 517 | d->input.data = 0; |
518 | } | 518 | } |
519 | 519 | ||
520 | if (::close(d->input.fd) == -1) { | 520 | if (::close(d->input.fd) == -1) { |
521 | qDebug("error closing file %s", d->input.path); | 521 | qDebug("error closing file %s", d->input.path); |
522 | result = FALSE; | 522 | result = FALSE; |
523 | } | 523 | } |
524 | 524 | ||
525 | d->input.fd = 0; | 525 | d->input.fd = 0; |
526 | 526 | ||
527 | return result; | 527 | return result; |
528 | } | 528 | } |
529 | 529 | ||
530 | 530 | ||
531 | bool LibMadPlugin::isOpen() { | 531 | bool LibMadPlugin::isOpen() { |
532 | debugMsg( "LibMadPlugin::isOpen" ); | 532 | debugMsg( "LibMadPlugin::isOpen" ); |
533 | return ( d->input.fd != 0 ); | 533 | return ( d->input.fd != 0 ); |
534 | } | 534 | } |
535 | 535 | ||
536 | 536 | ||
537 | int LibMadPlugin::audioStreams() { | 537 | int LibMadPlugin::audioStreams() { |
538 | debugMsg( "LibMadPlugin::audioStreams" ); | 538 | debugMsg( "LibMadPlugin::audioStreams" ); |
539 | return 1; | 539 | return 1; |
540 | } | 540 | } |
541 | 541 | ||
542 | 542 | ||
543 | int LibMadPlugin::audioChannels( int ) { | 543 | int LibMadPlugin::audioChannels( int ) { |
544 | debugMsg( "LibMadPlugin::audioChannels" ); | 544 | debugMsg( "LibMadPlugin::audioChannels" ); |
545 | /* | 545 | /* |
546 | long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 ); | 546 | long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 ); |
547 | qDebug( "LibMadPlugin::audioChannels: %i", d->frame.header.mode > 0 ? 2 : 1 ); | 547 | qDebug( "LibMadPlugin::audioChannels: %i", d->frame.header.mode > 0 ? 2 : 1 ); |
548 | return d->frame.header.mode > 0 ? 2 : 1; | 548 | return d->frame.header.mode > 0 ? 2 : 1; |
549 | */ | 549 | */ |
550 | return 2; | 550 | return 2; |
551 | } | 551 | } |
552 | 552 | ||
553 | 553 | ||
554 | int LibMadPlugin::audioFrequency( int ) { | 554 | int LibMadPlugin::audioFrequency( int ) { |
555 | debugMsg( "LibMadPlugin::audioFrequency" ); | 555 | debugMsg( "LibMadPlugin::audioFrequency" ); |
556 | long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 ); | 556 | long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 ); |
557 | qDebug( "LibMadPlugin::audioFrequency: %i", d->frame.header.samplerate ); | 557 | qDebug( "LibMadPlugin::audioFrequency: %i", d->frame.header.samplerate ); |
558 | return d->frame.header.samplerate; | 558 | return d->frame.header.samplerate; |
559 | } | 559 | } |
560 | 560 | ||
561 | 561 | ||
562 | int LibMadPlugin::audioSamples( int ) { | 562 | int LibMadPlugin::audioSamples( int ) { |
563 | debugMsg( "LibMadPlugin::audioSamples" ); | 563 | debugMsg( "LibMadPlugin::audioSamples" ); |
564 | 564 | ||
565 | // long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 ); | 565 | // long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 ); |
566 | // mad_header_decode( (struct mad_header *)&d->frame.header, &d->stream ); | 566 | // mad_header_decode( (struct mad_header *)&d->frame.header, &d->stream ); |
567 | // qDebug( "LibMadPlugin::audioSamples: %i*%i", d->frame.header.duration.seconds, d->frame.header.samplerate ); | 567 | // qDebug( "LibMadPlugin::audioSamples: %i*%i", d->frame.header.duration.seconds, d->frame.header.samplerate ); |
568 | // return d->frame.header.duration.seconds * d->frame.header.samplerate; | 568 | // return d->frame.header.duration.seconds * d->frame.header.samplerate; |
569 | 569 | ||
570 | return 10000000; | 570 | return 10000000; |
571 | } | 571 | } |
572 | 572 | ||
573 | 573 | ||
574 | bool LibMadPlugin::audioSetSample( long, int ) { | 574 | bool LibMadPlugin::audioSetSample( long, int ) { |
575 | debugMsg( "LibMadPlugin::audioSetSample" ); | 575 | debugMsg( "LibMadPlugin::audioSetSample" ); |
576 | return FALSE; | 576 | return FALSE; |
577 | } | 577 | } |
578 | 578 | ||
579 | 579 | ||
580 | long LibMadPlugin::audioGetSample( int ) { | 580 | long LibMadPlugin::audioGetSample( int ) { |
581 | debugMsg( "LibMadPlugin::audioGetSample" ); | 581 | debugMsg( "LibMadPlugin::audioGetSample" ); |
582 | return 0; | 582 | return 0; |
583 | } | 583 | } |
584 | 584 | ||
585 | /* | 585 | /* |
586 | bool LibMadPlugin::audioReadSamples( short *, int, long, int ) { | 586 | bool LibMadPlugin::audioReadSamples( short *, int, long, int ) { |
587 | debugMsg( "LibMadPlugin::audioReadSamples" ); | 587 | debugMsg( "LibMadPlugin::audioReadSamples" ); |
588 | return FALSE; | 588 | return FALSE; |
589 | } | 589 | } |
590 | 590 | ||
591 | 591 | ||
592 | bool LibMadPlugin::audioReReadSamples( short *, int, long, int ) { | 592 | bool LibMadPlugin::audioReReadSamples( short *, int, long, int ) { |
593 | debugMsg( "LibMadPlugin::audioReReadSamples" ); | 593 | debugMsg( "LibMadPlugin::audioReReadSamples" ); |
594 | return FALSE; | 594 | return FALSE; |
595 | } | 595 | } |
596 | */ | 596 | */ |
597 | 597 | ||
598 | bool LibMadPlugin::read() { | 598 | bool LibMadPlugin::read() { |
599 | debugMsg( "LibMadPlugin::read" ); | 599 | debugMsg( "LibMadPlugin::read" ); |
600 | int len; | 600 | int len; |
601 | 601 | ||
602 | if (d->input.eof) | 602 | if (d->input.eof) |
603 | return FALSE; | 603 | return FALSE; |
604 | 604 | ||
605 | #if defined(HAVE_MMAP) | 605 | #if defined(HAVE_MMAP) |
606 | if (d->input.fdm) { | 606 | if (d->input.fdm) { |
607 | unsigned long skip = 0; | 607 | unsigned long skip = 0; |
608 | 608 | ||
609 | if (d->stream.next_frame) { | 609 | if (d->stream.next_frame) { |
610 | struct stat stat; | 610 | struct stat stat; |
611 | 611 | ||
612 | if (fstat(d->input.fd, &stat) == -1) | 612 | if (fstat(d->input.fd, &stat) == -1) |
613 | return FALSE; | 613 | return FALSE; |
614 | 614 | ||
615 | if (stat.st_size + MAD_BUFFER_GUARD <= (signed)d->input.length) | 615 | if (stat.st_size + MAD_BUFFER_GUARD <= (signed)d->input.length) |
616 | return FALSE; | 616 | return FALSE; |
617 | 617 | ||
618 | // file size changed; update memory map | 618 | // file size changed; update memory map |
619 | skip = d->stream.next_frame - d->input.data; | 619 | skip = d->stream.next_frame - d->input.data; |
620 | 620 | ||
621 | if (unmap_file(d->input.fdm, d->input.length) == -1) { | 621 | if (unmap_file(d->input.fdm, d->input.length) == -1) { |
622 | d->input.fdm = 0; | 622 | d->input.fdm = 0; |
623 | d->input.data = 0; | 623 | d->input.data = 0; |
624 | return FALSE; | 624 | return FALSE; |
625 | } | 625 | } |
626 | 626 | ||
627 | d->input.length = stat.st_size; | 627 | d->input.length = stat.st_size; |
628 | 628 | ||
629 | d->input.fdm = map_file(d->input.fd, &d->input.length); | 629 | d->input.fdm = map_file(d->input.fd, &d->input.length); |
630 | if (d->input.fdm == 0) { | 630 | if (d->input.fdm == 0) { |
631 | d->input.data = 0; | 631 | d->input.data = 0; |
632 | return FALSE; | 632 | return FALSE; |
633 | } | 633 | } |
634 | 634 | ||
635 | d->input.data = (unsigned char *)d->input.fdm; | 635 | d->input.data = (unsigned char *)d->input.fdm; |
636 | } | 636 | } |
637 | 637 | ||
638 | mad_stream_buffer(&d->stream, d->input.data + skip, d->input.length - skip); | 638 | mad_stream_buffer(&d->stream, d->input.data + skip, d->input.length - skip); |
639 | 639 | ||
640 | } else | 640 | } else |
641 | #endif | 641 | #endif |
642 | { | 642 | { |
643 | if (d->stream.next_frame) { | 643 | if (d->stream.next_frame) { |
644 | memmove(d->input.data, d->stream.next_frame, | 644 | memmove(d->input.data, d->stream.next_frame, |
645 | d->input.length = &d->input.data[d->input.length] - d->stream.next_frame); | 645 | d->input.length = &d->input.data[d->input.length] - d->stream.next_frame); |
646 | } | 646 | } |
647 | 647 | ||
648 | do { | 648 | do { |
649 | len = ::read(d->input.fd, d->input.data + d->input.length, bufferSize /* MPEG_BUFFER_SIZE*/ - d->input.length); | 649 | len = ::read(d->input.fd, d->input.data + d->input.length, bufferSize /* MPEG_BUFFER_SIZE*/ - d->input.length); |
650 | } | 650 | } |
651 | while (len == -1 && errno == EINTR); | 651 | while (len == -1 && errno == EINTR); |
652 | 652 | ||
653 | if (len == -1) { | 653 | if (len == -1) { |
654 | qDebug("error reading audio"); | 654 | qDebug("error reading audio"); |
655 | return FALSE; | 655 | return FALSE; |
656 | } | 656 | } |
657 | else if (len == 0) { | 657 | else if (len == 0) { |
658 | d->input.eof = 1; | 658 | d->input.eof = 1; |
659 | 659 | ||
660 | assert(bufferSize /*MPEG_BUFFER_SIZE*/ - d->input.length >= MAD_BUFFER_GUARD); | 660 | assert(bufferSize /*MPEG_BUFFER_SIZE*/ - d->input.length >= MAD_BUFFER_GUARD); |
661 | 661 | ||
662 | while (len < MAD_BUFFER_GUARD) | 662 | while (len < MAD_BUFFER_GUARD) |
663 | d->input.data[d->input.length + len++] = 0; | 663 | d->input.data[d->input.length + len++] = 0; |
664 | } | 664 | } |
665 | 665 | ||
666 | mad_stream_buffer(&d->stream, d->input.data, d->input.length += len); | 666 | mad_stream_buffer(&d->stream, d->input.data, d->input.length += len); |
667 | } | 667 | } |
668 | 668 | ||
669 | return TRUE; | 669 | return TRUE; |
670 | } | 670 | } |
671 | 671 | ||
672 | 672 | ||
673 | static mad_fixed_t left_err, right_err; | 673 | static mad_fixed_t left_err, right_err; |
674 | static const int bits = 16; | 674 | static const int bits = 16; |
675 | static const int shift = MAD_F_FRACBITS + 1 - bits; | 675 | static const int shift = MAD_F_FRACBITS + 1 - bits; |
676 | 676 | ||
677 | 677 | ||
678 | inline long audio_linear_dither( mad_fixed_t sample, mad_fixed_t& error ) { | 678 | inline long audio_linear_dither( mad_fixed_t sample, mad_fixed_t& error ) { |
679 | sample += error; | 679 | sample += error; |
680 | mad_fixed_t quantized = (sample >= MAD_F_ONE) ? MAD_F_ONE - 1 : ( (sample < -MAD_F_ONE) ? -MAD_F_ONE : sample ); | 680 | mad_fixed_t quantized = (sample >= MAD_F_ONE) ? MAD_F_ONE - 1 : ( (sample < -MAD_F_ONE) ? -MAD_F_ONE : sample ); |
681 | quantized &= ~((1L << shift) - 1); | 681 | quantized &= ~((1L << shift) - 1); |
682 | error = sample - quantized; | 682 | error = sample - quantized; |
683 | return quantized >> shift; | 683 | return quantized >> shift; |
684 | } | 684 | } |
685 | 685 | ||
686 | 686 | ||
687 | inline void audio_pcm( short *data, unsigned int nsamples, mad_fixed_t *left, mad_fixed_t *right ) { | 687 | inline void audio_pcm( short *data, unsigned int nsamples, mad_fixed_t *left, mad_fixed_t *right ) { |
688 | if ( right ) { | 688 | if ( right ) { |
689 | while (nsamples--) { | 689 | while (nsamples--) { |
690 | data[0] = audio_linear_dither( *left++, left_err ); | 690 | data[0] = audio_linear_dither( *left++, left_err ); |
691 | data[1] = audio_linear_dither( *right++, right_err ); | 691 | data[1] = audio_linear_dither( *right++, right_err ); |
692 | data += 2; | 692 | data += 2; |
693 | } | 693 | } |
694 | } else { | 694 | } else { |
695 | while (nsamples--) { | 695 | while (nsamples--) { |
696 | data[0] = data[1] = audio_linear_dither( *left++, left_err ); | 696 | data[0] = data[1] = audio_linear_dither( *left++, left_err ); |
697 | data += 2; | 697 | data += 2; |
698 | } | 698 | } |
699 | } | 699 | } |
700 | } | 700 | } |
701 | 701 | ||
702 | 702 | ||
703 | bool LibMadPlugin::decode( short *output, long samples, long& samplesMade ) { | 703 | bool LibMadPlugin::decode( short *output, long samples, long& samplesMade ) { |
704 | debugMsg( "LibMadPlugin::decode" ); | 704 | debugMsg( "LibMadPlugin::decode" ); |
705 | 705 | ||
706 | static int buffered = 0; | 706 | static int buffered = 0; |
707 | static mad_fixed_t buffer[2][65536 * 2]; | 707 | static mad_fixed_t buffer[2][65536 * 2]; |
708 | int offset = buffered; | 708 | int offset = buffered; |
709 | samplesMade = 0; | 709 | samplesMade = 0; |
710 | 710 | ||
711 | static int maxBuffered = 8000; // 65536; | 711 | static int maxBuffered = 8000; // 65536; |
712 | 712 | ||
713 | if ( samples > maxBuffered ) { | 713 | if ( samples > maxBuffered ) { |
714 | samples = maxBuffered; | 714 | samples = maxBuffered; |
715 | } | 715 | } |
716 | 716 | ||
717 | if ( d->flush ) { | 717 | if ( d->flush ) { |
718 | buffered = 0; | 718 | buffered = 0; |
719 | offset = 0; | 719 | offset = 0; |
720 | d->flush = FALSE; | 720 | d->flush = FALSE; |
721 | } | 721 | } |
722 | 722 | ||
723 | while ( buffered < maxBuffered ) { | 723 | while ( buffered < maxBuffered ) { |
724 | 724 | ||
725 | while (mad_frame_decode(&d->frame, &d->stream) == -1) { | 725 | while (mad_frame_decode(&d->frame, &d->stream) == -1) { |
726 | if (!MAD_RECOVERABLE(d->stream.error)) { | 726 | if (!MAD_RECOVERABLE(d->stream.error)) { |
727 | debugMsg( "feed me" ); | 727 | debugMsg( "feed me" ); |
728 | return FALSE; // Feed me | 728 | return FALSE; // Feed me |
729 | } | 729 | } |
730 | if ( d->stream.error == MAD_ERROR_BADCRC ) { | 730 | if ( d->stream.error == MAD_ERROR_BADCRC ) { |
731 | mad_frame_mute(&d->frame); | 731 | mad_frame_mute(&d->frame); |
732 | qDebug( "error decoding, bad crc" ); | 732 | qDebug( "error decoding, bad crc" ); |
733 | } | 733 | } |
734 | } | 734 | } |
735 | 735 | ||
736 | mad_synth_frame(&d->synth, &d->frame); | 736 | mad_synth_frame(&d->synth, &d->frame); |
737 | int decodedSamples = d->synth.pcm.length; | 737 | int decodedSamples = d->synth.pcm.length; |
738 | memcpy( &(buffer[0][offset]), d->synth.pcm.samples[0], decodedSamples * sizeof(mad_fixed_t) ); | 738 | memcpy( &(buffer[0][offset]), d->synth.pcm.samples[0], decodedSamples * sizeof(mad_fixed_t) ); |
739 | if ( d->synth.pcm.channels == 2 ) | 739 | if ( d->synth.pcm.channels == 2 ) |
740 | memcpy( &(buffer[1][offset]), d->synth.pcm.samples[1], decodedSamples * sizeof(mad_fixed_t) ); | 740 | memcpy( &(buffer[1][offset]), d->synth.pcm.samples[1], decodedSamples * sizeof(mad_fixed_t) ); |
741 | offset += decodedSamples; | 741 | offset += decodedSamples; |
742 | buffered += decodedSamples; | 742 | buffered += decodedSamples; |
743 | } | 743 | } |
744 | 744 | ||
745 | //qApp->processEvents(); | 745 | //qApp->processEvents(); |
746 | audio_pcm( output, samples, buffer[0], (d->synth.pcm.channels == 2) ? buffer[1] : 0 ); | 746 | audio_pcm( output, samples, buffer[0], (d->synth.pcm.channels == 2) ? buffer[1] : 0 ); |
747 | // audio_pcm( output, samples, buffer[1], buffer[0] ); | 747 | // audio_pcm( output, samples, buffer[1], buffer[0] ); |
748 | // audio_pcm( output, samples, buffer[0], buffer[1] ); | 748 | // audio_pcm( output, samples, buffer[0], buffer[1] ); |
749 | samplesMade = samples; | 749 | samplesMade = samples; |
750 | memmove( buffer[0], &(buffer[0][samples]), (buffered - samples) * sizeof(mad_fixed_t) ); | 750 | memmove( buffer[0], &(buffer[0][samples]), (buffered - samples) * sizeof(mad_fixed_t) ); |
751 | if ( d->synth.pcm.channels == 2 ) { | 751 | if ( d->synth.pcm.channels == 2 ) { |
752 | memmove( buffer[1], &(buffer[1][samples]), (buffered - samples) * sizeof(mad_fixed_t) ); | 752 | memmove( buffer[1], &(buffer[1][samples]), (buffered - samples) * sizeof(mad_fixed_t) ); |
753 | } | 753 | } |
754 | buffered -= samples; | 754 | buffered -= samples; |
755 | 755 | ||
756 | return TRUE; | 756 | return TRUE; |
757 | } | 757 | } |
758 | 758 | ||
759 | /*bool LibMadPlugin::audioReadStereoSamples( short *output, long samples, long& samplesMade, int ) { | 759 | /*bool LibMadPlugin::audioReadStereoSamples( short *output, long samples, long& samplesMade, int ) { |
760 | */ | 760 | */ |
761 | bool LibMadPlugin::audioReadSamples( short *output, int /*channels*/, long samples, long& samplesMade, int ) { | 761 | bool LibMadPlugin::audioReadSamples( short *output, int /*channels*/, long samples, long& samplesMade, int ) { |
762 | debugMsg( "LibMadPlugin::audioReadStereoSamples" ); | 762 | debugMsg( "LibMadPlugin::audioReadStereoSamples" ); |
763 | 763 | ||
764 | static bool needInput = TRUE; | 764 | static bool needInput = TRUE; |
765 | 765 | ||
766 | if ( samples == 0 ) | 766 | if ( samples == 0 ) |
767 | return FALSE; | 767 | return FALSE; |
768 | 768 | ||
769 | do { | 769 | do { |
770 | if ( needInput ) | 770 | if ( needInput ) |
771 | if ( !read() ) { | 771 | if ( !read() ) { |
772 | return FALSE; | 772 | return FALSE; |
773 | } | 773 | } |
774 | 774 | ||
775 | needInput = FALSE; | 775 | needInput = FALSE; |
776 | 776 | ||
777 | if ( decode( output, samples, samplesMade ) ) | 777 | if ( decode( output, samples, samplesMade ) ) |
778 | return TRUE; | 778 | return TRUE; |
779 | else | 779 | else |
780 | needInput = TRUE; | 780 | needInput = TRUE; |
781 | } | 781 | } |
782 | while ( ( samplesMade < samples ) && ( !d->input.eof ) ); | 782 | while ( ( samplesMade < samples ) && ( !d->input.eof ) ); |
783 | 783 | ||
784 | return FALSE; | 784 | return FALSE; |
785 | } | 785 | } |
786 | 786 | ||
787 | 787 | ||
788 | double LibMadPlugin::getTime() { | 788 | double LibMadPlugin::getTime() { |
789 | debugMsg( "LibMadPlugin::getTime" ); | 789 | debugMsg( "LibMadPlugin::getTime" ); |
790 | return 0.0; | 790 | return 0.0; |
791 | } | 791 | } |
792 | 792 | ||
793 | 793 | ||
794 | void LibMadPlugin::printID3Tags() { | 794 | void LibMadPlugin::printID3Tags() { |
795 | qDebug( "LibMadPlugin::printID3Tags" ); | 795 | qDebug( "LibMadPlugin::printID3Tags" ); |
796 | 796 | ||
797 | char id3v1[128 + 1]; | 797 | char id3v1[128 + 1]; |
798 | 798 | ||
799 | if ( ::lseek( d->input.fd, -128, SEEK_END ) == -1 ) { | 799 | if ( ::lseek( d->input.fd, -128, SEEK_END ) == -1 ) { |
800 | qDebug( "error seeking to id3 tags" ); | 800 | qDebug( "error seeking to id3 tags" ); |
801 | return; | 801 | return; |
802 | } | 802 | } |
803 | 803 | ||
804 | if ( ::read( d->input.fd, id3v1, 128 ) != 128 ) { | 804 | if ( ::read( d->input.fd, id3v1, 128 ) != 128 ) { |
805 | qDebug( "error reading in id3 tags" ); | 805 | qDebug( "error reading in id3 tags" ); |
806 | return; | 806 | return; |
807 | } | 807 | } |
808 | 808 | ||
809 | if ( ::strncmp( (const char *)id3v1, "TAG", 3 ) != 0 ) { | 809 | if ( ::strncmp( (const char *)id3v1, "TAG", 3 ) != 0 ) { |
810 | debugMsg( "sorry, no id3 tags" ); | 810 | debugMsg( "sorry, no id3 tags" ); |