diff options
Diffstat (limited to 'apps/codecs/libcook/rm.c')
-rw-r--r-- | apps/codecs/libcook/rm.c | 504 |
1 files changed, 504 insertions, 0 deletions
diff --git a/apps/codecs/libcook/rm.c b/apps/codecs/libcook/rm.c new file mode 100644 index 0000000000..f2e9635bfc --- /dev/null +++ b/apps/codecs/libcook/rm.c | |||
@@ -0,0 +1,504 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2008 Dave Chapman | ||
11 | * Copyright (C) 2009 Mohamed Tarek | ||
12 | * | ||
13 | * This program is free software; you can redistribute it and/or | ||
14 | * modify it under the terms of the GNU General Public License | ||
15 | * as published by the Free Software Foundation; either version 2 | ||
16 | * of the License, or (at your option) any later version. | ||
17 | * | ||
18 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
19 | * KIND, either express or implied. | ||
20 | * | ||
21 | ****************************************************************************/ | ||
22 | #include <stdio.h> | ||
23 | #include <string.h> | ||
24 | #include <stdint.h> | ||
25 | #include <sys/types.h> | ||
26 | #include <sys/stat.h> | ||
27 | #include <fcntl.h> | ||
28 | #include <unistd.h> | ||
29 | |||
30 | #include "rm2wav.h" | ||
31 | |||
32 | #define MAX_PATH 260 | ||
33 | #define PKT_HEADER_SIZE 12 | ||
34 | #define RAW_AUDIO_DATA packet_length-PKT_HEADER_SIZE | ||
35 | |||
36 | |||
37 | #if 0 | ||
38 | #define DEBUG | ||
39 | #define DEBUGF printf | ||
40 | #else | ||
41 | #define DEBUGF(...) | ||
42 | #endif | ||
43 | |||
44 | /* ASF codec IDs */ | ||
45 | #define CODEC_ID_WMAV1 0x160 | ||
46 | #define CODEC_ID_WMAV2 0x161 | ||
47 | |||
48 | /* Some Rockbox-like functions (these should be implemented in metadata_common.[ch] */ | ||
49 | struct cook_extradata { | ||
50 | uint32_t cook_version; | ||
51 | uint16_t samples_pf_pc; /* samples per frame per channel */ | ||
52 | uint16_t nb_subbands; /* number of subbands in the frequency domain */ | ||
53 | |||
54 | /* extra 8 bytes for stereo data */ | ||
55 | uint32_t unused; | ||
56 | uint16_t js_subband_start; /* joint stereo subband start */ | ||
57 | uint16_t js_vlc_bits; | ||
58 | }; | ||
59 | |||
60 | static int read_uint8(int fd, uint8_t* buf) | ||
61 | { | ||
62 | unsigned char tmp[1]; | ||
63 | int res; | ||
64 | |||
65 | res=read(fd, tmp, 1); | ||
66 | *buf = tmp[0]; | ||
67 | return res; | ||
68 | } | ||
69 | |||
70 | static int read_uint16be(int fd, uint16_t* buf) | ||
71 | { | ||
72 | unsigned char tmp[2]; | ||
73 | int res; | ||
74 | |||
75 | res=read(fd, tmp, 2); | ||
76 | *buf = (tmp[0] << 8) | tmp[1]; | ||
77 | return res; | ||
78 | } | ||
79 | |||
80 | static int read_uint32be(int fd, uint32_t* buf) | ||
81 | { | ||
82 | unsigned char tmp[4]; | ||
83 | int res; | ||
84 | |||
85 | res=read(fd, tmp, 4); | ||
86 | *buf = (tmp[0] << 24) | (tmp[1] << 16) | (tmp[2] << 8) | tmp[3]; | ||
87 | return res; | ||
88 | } | ||
89 | |||
90 | off_t filesize(int fd) | ||
91 | { | ||
92 | struct stat buf; | ||
93 | |||
94 | if (fstat(fd,&buf) == -1) { | ||
95 | return -1; | ||
96 | } else { | ||
97 | return buf.st_size; | ||
98 | } | ||
99 | } | ||
100 | |||
101 | int read_cook_extradata(int fd, RMContext *rmctx) { | ||
102 | read_uint32be(fd, &rmctx->cook_version); | ||
103 | read_uint16be(fd, &rmctx->samples_pf_pc); | ||
104 | read_uint16be(fd, &rmctx->nb_subbands); | ||
105 | if(rmctx->extradata_size == 16) { | ||
106 | read_uint32be(fd, &rmctx->unused); | ||
107 | read_uint16be(fd, &rmctx->js_subband_start); | ||
108 | read_uint16be(fd, &rmctx->js_vlc_bits); | ||
109 | } | ||
110 | return rmctx->extradata_size; /* for 'skipped' */ | ||
111 | } | ||
112 | |||
113 | void print_cook_extradata(RMContext *rmctx) { | ||
114 | |||
115 | printf(" cook_version = 0x%08x\n", rmctx->cook_version); | ||
116 | printf(" samples_per_frame_per_channel = %d\n", rmctx->samples_pf_pc); | ||
117 | printf(" number_of_subbands_in_freq_domain = %d\n", rmctx->nb_subbands); | ||
118 | if(rmctx->extradata_size == 16) { | ||
119 | printf(" joint_stereo_subband_start = %d\n",rmctx->js_subband_start); | ||
120 | printf(" joint_stereo_vlc_bits = %d\n", rmctx->js_vlc_bits); | ||
121 | } | ||
122 | } | ||
123 | |||
124 | |||
125 | struct real_object_t | ||
126 | { | ||
127 | uint32_t fourcc; | ||
128 | uint32_t size; | ||
129 | uint16_t version; | ||
130 | }; | ||
131 | |||
132 | #define FOURCC(a,b,c,d) (((a)<<24) | ((b) << 16) | ((c) << 8) | (d)) | ||
133 | |||
134 | static int real_read_object_header(int fd, struct real_object_t* obj) | ||
135 | { | ||
136 | int n; | ||
137 | |||
138 | if ((n = read_uint32be(fd, &obj->fourcc)) <= 0) return n; | ||
139 | if ((n = read_uint32be(fd, &obj->size)) <= 0) return n; | ||
140 | if ((n = read_uint16be(fd, &obj->version)) <= 0) return n; | ||
141 | |||
142 | return 1; | ||
143 | } | ||
144 | |||
145 | static char* fourcc2str(uint32_t f) | ||
146 | { | ||
147 | static char res[5]; | ||
148 | |||
149 | res[0] = (f & 0xff000000) >> 24; | ||
150 | res[1] = (f & 0xff0000) >> 16; | ||
151 | res[2] = (f & 0xff00) >> 8; | ||
152 | res[3] = (f & 0xff); | ||
153 | res[4] = 0; | ||
154 | |||
155 | return res; | ||
156 | } | ||
157 | |||
158 | static int read_str(int fd, char* buf) | ||
159 | { | ||
160 | uint8_t len; | ||
161 | int res; | ||
162 | |||
163 | res = read(fd, &len, 1); | ||
164 | res = read(fd, buf, len); | ||
165 | buf[len]=0; | ||
166 | |||
167 | return len+1; | ||
168 | } | ||
169 | |||
170 | static int real_read_audio_stream_info(int fd, RMContext *rmctx) | ||
171 | { | ||
172 | int skipped = 0; | ||
173 | uint32_t version; | ||
174 | struct real_object_t obj; | ||
175 | memset(&obj,0,sizeof(obj)); | ||
176 | uint32_t header_size; | ||
177 | uint16_t flavor; | ||
178 | uint32_t coded_framesize; | ||
179 | uint32_t unknown1; | ||
180 | uint32_t unknown2; | ||
181 | uint32_t unknown3; | ||
182 | uint16_t unknown4; | ||
183 | uint16_t unknown5; | ||
184 | uint16_t unknown6; | ||
185 | uint16_t unknown7; | ||
186 | uint32_t unknown8; | ||
187 | uint8_t interleaver_id_length; | ||
188 | uint32_t interleaver_id; | ||
189 | uint8_t fourcc_length; | ||
190 | uint32_t fourcc = 0; | ||
191 | uint8_t unknown9; | ||
192 | uint16_t unknown10; | ||
193 | uint8_t unknown11; | ||
194 | |||
195 | read_uint32be(fd, &version); | ||
196 | skipped += 4; | ||
197 | |||
198 | printf(" version=0x%04x\n",((version >> 16) & 0xff)); | ||
199 | if (((version >> 16) & 0xff) == 3) { | ||
200 | /* Very old version */ | ||
201 | } else { | ||
202 | real_read_object_header(fd, &obj); | ||
203 | skipped += 10; | ||
204 | read_uint32be(fd, &header_size); | ||
205 | skipped += 4; | ||
206 | /* obj.size will be filled with an unknown value, replaced with header_size */ | ||
207 | printf(" Object: %s, size: %d bytes, version: 0x%04x\n",fourcc2str(obj.fourcc),header_size,obj.version); | ||
208 | |||
209 | read_uint16be(fd, &flavor); | ||
210 | read_uint32be(fd, &coded_framesize); | ||
211 | read_uint32be(fd, &unknown1); | ||
212 | read_uint32be(fd, &unknown2); | ||
213 | read_uint32be(fd, &unknown3); | ||
214 | read_uint16be(fd, &rmctx->sub_packet_h); | ||
215 | read_uint16be(fd, &rmctx->block_align); | ||
216 | read_uint16be(fd, &rmctx->sub_packet_size); | ||
217 | read_uint16be(fd, &unknown4); | ||
218 | skipped += 26; | ||
219 | if (((version >> 16) & 0xff) == 5) | ||
220 | { | ||
221 | read_uint16be(fd, &unknown5); | ||
222 | read_uint16be(fd, &unknown6); | ||
223 | read_uint16be(fd, &unknown7); | ||
224 | skipped += 6; | ||
225 | } | ||
226 | read_uint16be(fd, &rmctx->sample_rate); | ||
227 | read_uint32be(fd, &unknown8); | ||
228 | read_uint16be(fd, &rmctx->nb_channels); | ||
229 | skipped += 8; | ||
230 | if (((version >> 16) & 0xff) == 4) | ||
231 | { | ||
232 | read_uint8(fd, &interleaver_id_length); | ||
233 | read_uint32be(fd, &interleaver_id); | ||
234 | read_uint8(fd, &fourcc_length); | ||
235 | read_uint32be(fd, &fourcc); | ||
236 | skipped += 10; | ||
237 | } | ||
238 | if (((version >> 16) & 0xff) == 5) | ||
239 | { | ||
240 | read_uint32be(fd, &interleaver_id); | ||
241 | read_uint32be(fd, &fourcc); | ||
242 | skipped += 8; | ||
243 | } | ||
244 | read_uint8(fd,&unknown9); | ||
245 | read_uint16be(fd,&unknown10); | ||
246 | skipped += 3; | ||
247 | if (((version >> 16) & 0xff) == 5) | ||
248 | { | ||
249 | read_uint8(fd, &unknown11); | ||
250 | skipped += 1; | ||
251 | } | ||
252 | |||
253 | read_uint32be(fd, &rmctx->extradata_size); | ||
254 | skipped += 4; | ||
255 | if(!strncmp(fourcc2str(fourcc),"cook",4)) | ||
256 | skipped += read_cook_extradata(fd, rmctx); | ||
257 | |||
258 | |||
259 | printf(" flavor = %d\n",flavor); | ||
260 | printf(" coded_frame_size = %d\n",coded_framesize); | ||
261 | printf(" sub_packet_h = %d\n",rmctx->sub_packet_h); | ||
262 | printf(" frame_size = %d\n",rmctx->block_align); | ||
263 | printf(" sub_packet_size = %d\n",rmctx->sub_packet_size); | ||
264 | printf(" sample_rate= %d\n",rmctx->sample_rate); | ||
265 | printf(" channels= %d\n",rmctx->nb_channels); | ||
266 | printf(" fourcc = %s\n",fourcc2str(fourcc)); | ||
267 | printf(" codec_extra_data_length = %d\n",rmctx->extradata_size); | ||
268 | printf(" codec_extradata :\n"); | ||
269 | print_cook_extradata(rmctx); | ||
270 | |||
271 | } | ||
272 | |||
273 | return skipped; | ||
274 | } | ||
275 | |||
276 | int real_parse_header(int fd, RMContext *rmctx) | ||
277 | { | ||
278 | struct real_object_t obj; | ||
279 | memset(&obj,0,sizeof(obj)); | ||
280 | int res; | ||
281 | int skipped; | ||
282 | off_t curpos; | ||
283 | |||
284 | uint32_t unknown1; | ||
285 | uint32_t unknown2; | ||
286 | |||
287 | uint32_t max_bitrate; | ||
288 | uint32_t avg_bitrate = 0; | ||
289 | uint32_t max_packet_size; | ||
290 | uint32_t avg_packet_size; | ||
291 | uint32_t packet_count; | ||
292 | uint32_t duration; | ||
293 | uint32_t preroll; | ||
294 | uint32_t index_offset; | ||
295 | uint32_t data_offset; | ||
296 | uint16_t num_streams; | ||
297 | uint16_t flags = 0; | ||
298 | |||
299 | uint16_t stream_id; | ||
300 | uint32_t start_time; | ||
301 | char desc[256]; | ||
302 | char mimetype[256]; | ||
303 | uint32_t codec_data_size; | ||
304 | uint32_t v; | ||
305 | |||
306 | char title[256]; | ||
307 | char author[256]; | ||
308 | char copyright[256]; | ||
309 | char comment[256]; | ||
310 | |||
311 | uint32_t next_data_off; | ||
312 | uint8_t header_end; | ||
313 | |||
314 | curpos = lseek(fd, 0, SEEK_SET); | ||
315 | res = real_read_object_header(fd, &obj); | ||
316 | |||
317 | if (obj.fourcc == FOURCC('.','r','a',0xfd)) | ||
318 | { | ||
319 | /* Very old .ra format - not yet supported */ | ||
320 | return -1; | ||
321 | } | ||
322 | else if (obj.fourcc != FOURCC('.','R','M','F')) | ||
323 | { | ||
324 | return -1; | ||
325 | } | ||
326 | |||
327 | read_uint32be(fd, &unknown1); | ||
328 | read_uint32be(fd, &unknown2); | ||
329 | |||
330 | printf("Object: %s, size: %d bytes, version: 0x%04x, pos: %d\n",fourcc2str(obj.fourcc),(int)obj.size,obj.version,(int)curpos); | ||
331 | printf(" unknown1=%d (0x%08x)\n",unknown1,unknown1); | ||
332 | printf(" unknown2=%d (0x%08x)\n",unknown2,unknown2); | ||
333 | |||
334 | res = real_read_object_header(fd, &obj); | ||
335 | header_end = 0; | ||
336 | while(res) | ||
337 | { | ||
338 | printf("Object: %s, size: %d bytes, version: 0x%04x, pos: %d\n",fourcc2str(obj.fourcc),(int)obj.size,obj.version,(int)curpos); | ||
339 | skipped = 10; | ||
340 | if(obj.fourcc == FOURCC('I','N','D','X')) | ||
341 | break; | ||
342 | switch (obj.fourcc) | ||
343 | { | ||
344 | case FOURCC('P','R','O','P'): /* File properties */ | ||
345 | read_uint32be(fd, &max_bitrate); | ||
346 | read_uint32be(fd, &rmctx->bit_rate); /*avg bitrate*/ | ||
347 | read_uint32be(fd, &max_packet_size); | ||
348 | read_uint32be(fd, &avg_packet_size); | ||
349 | read_uint32be(fd, &packet_count); | ||
350 | read_uint32be(fd, &duration); | ||
351 | read_uint32be(fd, &preroll); | ||
352 | read_uint32be(fd, &index_offset); | ||
353 | read_uint32be(fd, &data_offset); | ||
354 | read_uint16be(fd, &num_streams); | ||
355 | read_uint16be(fd, &rmctx->flags); | ||
356 | skipped += 40; | ||
357 | |||
358 | printf(" max_bitrate = %d\n",max_bitrate); | ||
359 | printf(" avg_bitrate = %d\n",avg_bitrate); | ||
360 | printf(" max_packet_size = %d\n",max_packet_size); | ||
361 | printf(" avg_packet_size = %d\n",avg_packet_size); | ||
362 | printf(" packet_count = %d\n",packet_count); | ||
363 | printf(" duration = %d\n",duration); | ||
364 | printf(" preroll = %d\n",preroll); | ||
365 | printf(" index_offset = %d\n",index_offset); | ||
366 | printf(" data_offset = %d\n",data_offset); | ||
367 | printf(" num_streams = %d\n",num_streams); | ||
368 | printf(" flags=0x%04x\n",flags); | ||
369 | break; | ||
370 | |||
371 | case FOURCC('C','O','N','T'): | ||
372 | /* Four strings - Title, Author, Copyright, Comment */ | ||
373 | skipped += read_str(fd,title); | ||
374 | skipped += read_str(fd,author); | ||
375 | skipped += read_str(fd,copyright); | ||
376 | skipped += read_str(fd,comment); | ||
377 | |||
378 | printf(" title=\"%s\"\n",title); | ||
379 | printf(" author=\"%s\"\n",author); | ||
380 | printf(" copyright=\"%s\"\n",copyright); | ||
381 | printf(" comment=\"%s\"\n",comment); | ||
382 | break; | ||
383 | |||
384 | case FOURCC('M','D','P','R'): /* Media properties */ | ||
385 | read_uint16be(fd,&stream_id); | ||
386 | skipped += 2; | ||
387 | read_uint32be(fd,&max_bitrate); | ||
388 | skipped += 4; | ||
389 | read_uint32be(fd,&avg_bitrate); | ||
390 | skipped += 4; | ||
391 | read_uint32be(fd,&max_packet_size); | ||
392 | skipped += 4; | ||
393 | read_uint32be(fd,&avg_packet_size); | ||
394 | skipped += 4; | ||
395 | read_uint32be(fd,&start_time); | ||
396 | skipped += 4; | ||
397 | read_uint32be(fd,&preroll); | ||
398 | skipped += 4; | ||
399 | read_uint32be(fd,&duration); | ||
400 | skipped += 4; | ||
401 | skipped += read_str(fd,desc); | ||
402 | skipped += read_str(fd,mimetype); | ||
403 | read_uint32be(fd,&codec_data_size); | ||
404 | skipped += 4; | ||
405 | //From ffmpeg: codec_pos = url_ftell(pb); | ||
406 | read_uint32be(fd,&v); | ||
407 | skipped += 4; | ||
408 | |||
409 | printf(" stream_id = 0x%04x\n",stream_id); | ||
410 | printf(" max_bitrate = %d\n",max_bitrate); | ||
411 | printf(" avg_bitrate = %d\n",avg_bitrate); | ||
412 | printf(" max_packet_size = %d\n",max_packet_size); | ||
413 | printf(" avg_packet_size = %d\n",avg_packet_size); | ||
414 | printf(" start_time = %d\n",start_time); | ||
415 | printf(" preroll = %d\n",preroll); | ||
416 | printf(" duration = %d\n",duration); | ||
417 | printf(" desc=\"%s\"\n",desc); | ||
418 | printf(" mimetype=\"%s\"\n",mimetype); | ||
419 | printf(" codec_data_size = %d\n",codec_data_size); | ||
420 | printf(" v=\"%s\"\n", fourcc2str(v)); | ||
421 | |||
422 | if (v == FOURCC('.','r','a',0xfd)) | ||
423 | { | ||
424 | skipped += real_read_audio_stream_info(fd, rmctx); | ||
425 | } | ||
426 | |||
427 | break; | ||
428 | |||
429 | case FOURCC('D','A','T','A'): | ||
430 | |||
431 | read_uint32be(fd,&rmctx->nb_packets); | ||
432 | skipped += 4; | ||
433 | read_uint32be(fd,&next_data_off); | ||
434 | skipped += 4; | ||
435 | if (!rmctx->nb_packets && (rmctx->flags & 4)) | ||
436 | rmctx->nb_packets = 3600 * 25; | ||
437 | printf(" data_nb_packets = %d\n",rmctx->nb_packets); | ||
438 | printf(" next DATA offset = %d\n",next_data_off); | ||
439 | header_end = 1; | ||
440 | break; | ||
441 | } | ||
442 | if(header_end) break; | ||
443 | curpos = lseek(fd, obj.size - skipped, SEEK_CUR); | ||
444 | res = real_read_object_header(fd, &obj); | ||
445 | } | ||
446 | |||
447 | |||
448 | return 0; | ||
449 | } | ||
450 | |||
451 | void rm_get_packet(int fd,RMContext *rmctx, RMPacket *pkt) | ||
452 | { | ||
453 | uint8_t unknown,packet_group; | ||
454 | uint16_t x, place; | ||
455 | uint16_t sps = rmctx->sub_packet_size; | ||
456 | uint16_t h = rmctx->sub_packet_h; | ||
457 | uint16_t y = rmctx->sub_packet_cnt; | ||
458 | uint16_t w = rmctx->audio_framesize; | ||
459 | do | ||
460 | { | ||
461 | y = rmctx->sub_packet_cnt; | ||
462 | read_uint16be(fd,&pkt->version); | ||
463 | read_uint16be(fd,&pkt->length); | ||
464 | read_uint16be(fd,&pkt->stream_number); | ||
465 | read_uint32be(fd,&pkt->timestamp); | ||
466 | DEBUGF(" version = %d\n" | ||
467 | " length = %d\n" | ||
468 | " stream = %d\n" | ||
469 | " timestmp= %d\n",pkt->version,pkt->length,pkt->stream_number,pkt->timestamp); | ||
470 | |||
471 | //getchar(); | ||
472 | if(pkt->version == 0) | ||
473 | { | ||
474 | read_uint8(fd,&packet_group); | ||
475 | read_uint8(fd,&pkt->flags); | ||
476 | } | ||
477 | if(pkt->version == 1) | ||
478 | read_uint8(fd,&unknown); | ||
479 | |||
480 | if (pkt->flags & 2) /* keyframe */ | ||
481 | y = rmctx->sub_packet_cnt = 0; | ||
482 | if (!y) /* if keyframe update playback elapsed time */ | ||
483 | rmctx->audiotimestamp = pkt->timestamp; | ||
484 | |||
485 | for(x = 0 ; x < w/sps; x++) | ||
486 | { | ||
487 | place = sps*(h*x+((h+1)/2)*(y&1)+(y>>1)); | ||
488 | read(fd,pkt->data+place, sps); | ||
489 | //DEBUGF("place = %d data[place] = %d\n",place,pkt->data[place]); | ||
490 | } | ||
491 | rmctx->audio_pkt_cnt++; | ||
492 | }while(++(rmctx->sub_packet_cnt) < h); | ||
493 | |||
494 | //return pkt->data; | ||
495 | } | ||
496 | #ifdef DEBUG | ||
497 | void dump_rm_context(RMContext *rmctx) | ||
498 | { | ||
499 | DEBUGF("block_align = %d\n", rmctx->block_align); | ||
500 | DEBUGF("nb_channels = %d\n", rmctx->nb_channels); | ||
501 | DEBUGF("sample_rate = %d\n", rmctx->sample_rate); | ||
502 | DEBUGF("bit_rate = %d\n", rmctx->bit_rate ); | ||
503 | } | ||
504 | #endif | ||