开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
ttadec.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：18k
源码类别：

Windows CE

开发平台：

C/C++

ttadec.c：源码内容
  1. /*
  2.  * ttadec.c
  3.  *
  4.  * Description:  TTAv1 decoder library for HW players
  5.  * Developed by: Alexander Djourik <ald@true-audio.com>
  6.  *               Pavel Zhilin <pzh@true-audio.com>
  7.  *
  8.  * Copyright (c) 2004 True Audio Software. All rights reserved.
  9.  *
  10.  */
  12. /*
  13.  * Redistribution and use in source and binary forms, with or without
  14.  * modification, are permitted provided that the following conditions
  15.  * are met:
  16.  *
  17.  * 1. Redistributions of source code must retain the above copyright
  18.  *    notice, this list of conditions and the following disclaimer.
  19.  * 2. Redistributions in binary form must reproduce the above copyright
  20.  *    notice, this list of conditions and the following disclaimer in the
  21.  *    documentation and/or other materials provided with the distribution.
  22.  * 3. Neither the name of the True Audio Software nor the names of its
  23.  *    contributors may be used to endorse or promote products derived
  24.  *    from this software without specific prior written permission.
  25.  *
  26.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  27.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  28.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  29.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  30.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  31.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  32.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  33.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  34.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  35.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  36.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37.  */
  39. #include <stdlib.h>
  40. #include <string.h>
  42. #include "ttalib.h"
  43. #include "ttadec.h"
  44. #include "filter.h"
  46. /******************* static variables and structures *******************/
  48. static unsigned char isobuffers[ISO_BUFFERS_SIZE + 4];
  49. static unsigned char *iso_buffers_end = isobuffers + ISO_BUFFERS_SIZE;
  50. static unsigned int pcm_buffer_size;
  52. static decoder tta[MAX_NCH]; // decoder state
  53. static int cache[MAX_NCH]; // decoder cache
  55. tta_info *ttainfo; // currently playing file info
  57. static unsigned int fframes; // number of frames in file
  58. static unsigned int framelen; // the frame length in samples
  59. static unsigned int lastlen; // the length of the last frame in samples
  60. static unsigned int data_pos; // currently playing frame index
  61. static unsigned int data_cur; // the playing position in frame
  63. static int maxvalue; // output data max value
  64. static unsigned int *seek_table; // the playing position table
  65. static unsigned int st_state; //seek table status
  67. static unsigned int frame_crc32;
  68. static unsigned int bit_count;
  69. static unsigned int bit_cache;
  70. static unsigned char *bitpos;
  72. static int read_id3_tags (tta_info *info);
  74. /************************* crc32 functions *****************************/
  76. #define UPDATE_CRC32(x, crc) crc = 
  77. (((crc>>8) & 0x00FFFFFF) ^ crc32_table[(crc^x) & 0xFF])
  79. static unsigned int 
  80. crc32 (unsigned char *buffer, unsigned int len) {
  81. unsigned int i;
  82. unsigned int crc = 0xFFFFFFFF;
  84. for (i = 0; i < len; i++) UPDATE_CRC32(buffer[i], crc);
  86. return (crc ^ 0xFFFFFFFF);
  87. }
  89. /************************* bit operations ******************************/
  91. #define GET_BINARY(value, bits) 
  92. while (bit_count < bits) { 
  93. if (bitpos == iso_buffers_end) { 
  94. if (!ttainfo->Reader->Read(ttainfo->Reader, isobuffers, 
  95.     ISO_BUFFERS_SIZE)) { 
  96.     ttainfo->STATE = READ_ERROR; 
  97.     return -1; } 
  98. bitpos = isobuffers; } 
  99. UPDATE_CRC32(*bitpos, frame_crc32); 
  100. bit_cache |= *bitpos << bit_count; 
  101. bit_count += 8; 
  102. bitpos++; } 
  103. value = bit_cache & bit_mask[bits]; 
  104. bit_cache >>= bits; 
  105. bit_count -= bits; 
  106. bit_cache &= bit_mask[bit_count];
  108. #define GET_UNARY(value) 
  109. value = 0; 
  110. while (!(bit_cache ^ bit_mask[bit_count])) { 
  111. if (bitpos == iso_buffers_end) { 
  112. if (!ttainfo->Reader->Read(ttainfo->Reader, isobuffers, 
  113.     ISO_BUFFERS_SIZE)) { 
  114.     ttainfo->STATE = READ_ERROR; 
  115.     return -1; } 
  116. bitpos = isobuffers; } 
  117. value += bit_count; 
  118. bit_cache = *bitpos++; 
  119. UPDATE_CRC32(bit_cache, frame_crc32); 
  120. bit_count = 8; } 
  121. while (bit_cache & 1) { 
  122. value++; 
  123. bit_cache >>= 1; 
  124. bit_count--; } 
  125. bit_cache >>= 1; 
  126. bit_count--;
  128. static void init_buffer_read() {
  129. frame_crc32 = 0xFFFFFFFFUL;
  130. bit_count = bit_cache = 0;
  131. bitpos = iso_buffers_end;
  132. }
  134. static int done_buffer_read() {
  135. unsigned int crc32, rbytes;
  137. frame_crc32 ^= 0xFFFFFFFFUL;
  138. rbytes = iso_buffers_end - bitpos;
  140. if (rbytes < sizeof(int)) {
  141.     memcpy(isobuffers, bitpos, 4);
  142.     if (!ttainfo->Reader->Read(ttainfo->Reader, isobuffers + rbytes,
  143. ISO_BUFFERS_SIZE - rbytes))
  144. return -1;
  145.     bitpos = isobuffers;
  146. }
  148. memcpy(&crc32, bitpos, 4);
  149. crc32 = ENDSWAP_INT32(crc32);
  150. bitpos += sizeof(int);
  151.     
  152. if (crc32 != frame_crc32) return -1;
  154. bit_cache = bit_count = 0;
  155. frame_crc32 = 0xFFFFFFFFUL;
  157. return 0;
  158. }
  160. /************************* decoder functions ****************************/
  162. const char *get_error_str (int error) {
  163. switch (error) {
  164. case NO_ERROR:      return "No errors found";
  165. case OPEN_ERROR:    return "Can't open file";
  166. case FORMAT_ERROR:  return "Not supported file format";
  167. case FILE_ERROR:    return "File is corrupted";
  168. case READ_ERROR:    return "Can't read from file";
  169. case MEMORY_ERROR:  return "Insufficient memory available";
  170. default:            return "Unknown error code";
  171. }
  172. }
  174. int open_tta_file (tta_info *info, unsigned int data_offset) {
  175. unsigned int checksum;
  176. unsigned int datasize;
  177. unsigned int origsize;
  178. tta_hdr ttahdr;
  180. // clear the memory
  181. //memset (info, 0, sizeof(tta_info));
  183. // get file size
  184. info->Reader->Seek(info->Reader, 0, SEEK_END);
  185. info->FILESIZE = info->Reader->FilePos;
  186. info->Reader->Seek(info->Reader, 0, SEEK_SET);
  188. // read id3 tags
  189. if (!data_offset) {
  190. // if ((data_offset = skip_id3_tag (info)) < 0) {
  191. if ((data_offset = read_id3_tags (info)) < 0) {
  192.     return -1;
  193. }
  194. } else info->Reader->Seek(info->Reader, data_offset, SEEK_SET);
  196. // read TTA header
  197. if (info->Reader->Read(info->Reader, &ttahdr, sizeof (ttahdr)) == 0) {
  198. info->STATE = READ_ERROR;
  199. return -1;
  200. }
  202. // check for TTA3 signature
  203. if (ENDSWAP_INT32(ttahdr.TTAid) != TTA1_SIGN) {
  204. info->STATE = FORMAT_ERROR;
  205. return -1;
  206. }
  208. ttahdr.CRC32 = ENDSWAP_INT32(ttahdr.CRC32);
  209. checksum = crc32((unsigned char *) &ttahdr,
  210. sizeof(tta_hdr) - sizeof(int));
  211. if (checksum != ttahdr.CRC32) {
  212. info->STATE = FILE_ERROR;
  213. return -1;
  214. }
  216. ttahdr.AudioFormat = ENDSWAP_INT16(ttahdr.AudioFormat);
  217. ttahdr.NumChannels = ENDSWAP_INT16(ttahdr.NumChannels);
  218. ttahdr.BitsPerSample = ENDSWAP_INT16(ttahdr.BitsPerSample);
  219. ttahdr.SampleRate = ENDSWAP_INT32(ttahdr.SampleRate);
  220. ttahdr.DataLength = ENDSWAP_INT32(ttahdr.DataLength);
  222. // check for player supported formats
  223. if (ttahdr.AudioFormat != WAVE_FORMAT_PCM ||
  224. ttahdr.NumChannels > MAX_NCH ||
  225. ttahdr.BitsPerSample > MAX_BPS ||(
  226. ttahdr.SampleRate != 16000 &&
  227. ttahdr.SampleRate != 22050 &&
  228. ttahdr.SampleRate != 24000 &&
  229. ttahdr.SampleRate != 32000 &&
  230. ttahdr.SampleRate != 44100 &&
  231. ttahdr.SampleRate != 48000 &&
  232. ttahdr.SampleRate != 64000 &&
  233. ttahdr.SampleRate != 88200 &&
  234. ttahdr.SampleRate != 96000)) {
  235. info->STATE = FORMAT_ERROR;
  236. return -1;
  237. }
  239. // fill the File Info
  240. info->NCH = ttahdr.NumChannels;
  241. info->BPS = ttahdr.BitsPerSample;
  242. info->BSIZE = (ttahdr.BitsPerSample + 7)/8;
  243. info->FORMAT = ttahdr.AudioFormat;
  244. info->SAMPLERATE = ttahdr.SampleRate;
  245. info->DATALENGTH = ttahdr.DataLength;
  246. info->FRAMELEN = (int) (FRAME_TIME * ttahdr.SampleRate);
  247. info->LENGTH = ttahdr.DataLength / ttahdr.SampleRate;
  248. info->DATAPOS = data_offset;
  250.         datasize = info->FILESIZE - info->DATAPOS;
  251.         origsize = info->DATALENGTH * info->BSIZE * info->NCH;
  253. info->COMPRESS = (double) datasize / origsize;
  254. info->BITRATE = (int) (info->COMPRESS * info->SAMPLERATE *
  255. info->NCH * info->BPS / 1000);
  257. return 0;
  258. }
  260. static void rice_init(adapt *rice, unsigned int k0, unsigned int k1) {
  261. rice->k0 = k0;
  262. rice->k1 = k1;
  263. rice->sum0 = shift_16[k0];
  264. rice->sum1 = shift_16[k1];
  265. }
  267. static void decoder_init(decoder *tta, int nch, int byte_size) {
  268. int shift = flt_set[byte_size - 1];
  269. int i;
  271. for (i = 0; i < nch; i++) {
  272. filter_init(&tta[i].fst, shift);
  273. rice_init(&tta[i].rice, 10, 10);
  274. tta[i].last = 0;
  275. }
  276. }
  278. static void seek_table_init (unsigned int *seek_table,
  279. unsigned int len, unsigned int data_offset) {
  280. unsigned int *st, frame_len;
  282. for (st = seek_table; st < (seek_table + len); st++) {
  283. frame_len = ENDSWAP_INT32(*st);
  284. *st = data_offset;
  285. data_offset += frame_len;
  286. }
  287. }
  289. int set_position (unsigned int pos) {
  290. unsigned int seek_pos;
  292. if (pos >= fframes) return 0;
  293. if (!st_state) {
  294. ttainfo->STATE = FILE_ERROR;
  295. return -1;
  296. }
  298. seek_pos = ttainfo->DATAPOS + seek_table[data_pos = pos];
  299. if (ttainfo->Reader->Seek(ttainfo->Reader, seek_pos, SEEK_SET) < 0) {
  300. ttainfo->STATE = READ_ERROR;
  301. return -1;
  302. }
  304. data_cur = 0;
  305. framelen = 0;
  307. // init bit reader
  308. init_buffer_read();
  310. return 0;
  311. }
  313. int player_init (tta_info *info) {
  314. unsigned int checksum;
  315. unsigned int data_offset;
  316. unsigned int st_size;
  318. ttainfo = info;
  320. framelen = 0;
  321. data_pos = 0;
  322. data_cur = 0;
  324. lastlen = ttainfo->DATALENGTH % ttainfo->FRAMELEN;
  325. fframes = ttainfo->DATALENGTH / ttainfo->FRAMELEN + (lastlen ? 1 : 0);
  326. st_size = (fframes + 1) * sizeof(int);
  328. seek_table = (unsigned int *) malloc(st_size);
  329. if (!seek_table) {
  330. ttainfo->STATE = MEMORY_ERROR;
  331. return -1;
  332. }
  334. // read seek table
  335. if (!info->Reader->Read(info->Reader, seek_table, st_size)) {
  336. ttainfo->STATE = READ_ERROR;
  337. return -1;
  338. }
  340. checksum = crc32((unsigned char *) seek_table, st_size - sizeof(int));
  341. st_state = (checksum == ENDSWAP_INT32(seek_table[fframes]));
  342. data_offset = sizeof(tta_hdr) + st_size;
  344. // init seek table
  345. seek_table_init(seek_table, fframes, data_offset);
  347. // init bit reader
  348. init_buffer_read();
  350. pcm_buffer_size = PCM_BUFFER_LENGTH * ttainfo->BSIZE * ttainfo->NCH;
  351. maxvalue = (1UL << ttainfo->BPS) - 1;
  353. return 0;
  354. }
  356. void close_tta_file (tta_info *info) {
  358. }
  360. void player_stop () {
  361. if (seek_table) {
  362. free(seek_table);
  363. seek_table = NULL;
  364. }
  365. }
  367. int get_samples (byte *buffer) {
  368. unsigned int k, depth, unary, binary;
  369. byte *p = buffer;
  370. decoder *dec = tta;
  371. int *prev = cache;
  372. int value, res;
  374. for (res = 0; p < buffer + pcm_buffer_size;) {
  375. fltst *fst = &dec->fst;
  376. adapt *rice = &dec->rice;
  377. int *last = &dec->last;
  379. if (data_cur == framelen) {
  380. if (data_pos == fframes) break;
  381. if (framelen && done_buffer_read()) {
  382.     if (set_position(data_pos)) return -1;
  383.     if (res) break;
  384. }
  386. if (data_pos == fframes - 1 && lastlen)
  387. framelen = lastlen;
  388. else framelen = ttainfo->FRAMELEN;
  390. decoder_init(tta, ttainfo->NCH, ttainfo->BSIZE);
  391. data_pos++; data_cur = 0;
  392. }
  394. // decode Rice unsigned
  395. GET_UNARY(unary);
  397. switch (unary) {
  398. case 0: depth = 0; k = rice->k0; break;
  399. default:
  400. depth = 1; k = rice->k1;
  401. unary--;
  402. }
  404. if (k) {
  405. GET_BINARY(binary, k);
  406. value = (unary << k) + binary;
  407. } else value = unary;
  409. switch (depth) {
  410. case 1: 
  411. rice->sum1 += value - (rice->sum1 >> 4);
  412. if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
  413. rice->k1--;
  414. else if (rice->sum1 > shift_16[rice->k1 + 1])
  415. rice->k1++;
  416. value += bit_shift[rice->k0];
  417. default:
  418. rice->sum0 += value - (rice->sum0 >> 4);
  419. if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
  420. rice->k0--;
  421. else if (rice->sum0 > shift_16[rice->k0 + 1])
  422. rice->k0++;
  423. }
  425. value = DEC(value);
  427. // decompress stage 1: adaptive hybrid filter
  428. hybrid_filter(fst, &value);
  430. // decompress stage 2: fixed order 1 prediction
  431. switch (ttainfo->BSIZE) {
  432. case 1: value += PREDICTOR1(*last, 4); break; // bps 8
  433. case 2: value += PREDICTOR1(*last, 5); break; // bps 16
  434. case 3: value += PREDICTOR1(*last, 5); break; // bps 24
  435. } *last = value;
  437. // check for errors
  438. if (abs(value) > maxvalue) {
  439. unsigned int tail =
  440. pcm_buffer_size / (ttainfo->BSIZE * ttainfo->NCH) - res;
  441. memset(buffer, 0, pcm_buffer_size);
  442. data_cur += tail; res += tail;
  443. break;
  444. }
  446. if (dec < tta + (ttainfo->NCH - 1)) {
  447. *prev++ = value; dec++;
  448. } else {
  449. *prev = value;
  450. if (ttainfo->NCH > 1) {
  451. int *r = prev - 1;
  452. for (*prev += *r/2; r >= cache; r--)
  453. *r = *(r + 1) - *r;
  454. for (r = cache; r < prev; r++)
  455. WRITE_BUFFER(r, ttainfo->BSIZE, p)
  456. }
  457. WRITE_BUFFER(prev, ttainfo->BSIZE, p)
  458. prev = cache;
  459. data_cur++; res++;
  460. dec = tta;
  461. }
  462. }
  464. return res;
  465. }
  467. /*
  468.  * Description:  ID3 tags manipulation routines
  469.  *               Provides read access to ID3 tags v1.1, v2.3.x, v2.4.x
  470.  *               Supported ID3v2 frames: Title, Artist, Album, Track,
  471.  *               Year, Genre, Comment.
  472.  *
  473.  * Copyright (c) 2004 Alexander Djourik. All rights reserved.
  474.  *
  475.  */
  477. static unsigned int unpack_sint28 (const char *ptr) {
  478. unsigned int value = 0;
  480. if (ptr[0] & 0x80) return 0;
  482. value =  value       | (ptr[0] & 0x7f);
  483. value = (value << 7) | (ptr[1] & 0x7f);
  484. value = (value << 7) | (ptr[2] & 0x7f);
  485. value = (value << 7) | (ptr[3] & 0x7f);
  487. return value;
  488. }
  490. static unsigned int unpack_sint32 (const char *ptr) {
  491. unsigned int value = 0;
  493. if (ptr[0] & 0x80) return 0;
  495. value = (value << 8) | ptr[0];
  496. value = (value << 8) | ptr[1];
  497. value = (value << 8) | ptr[2];
  498. value = (value << 8) | ptr[3];
  500. return value;
  501. }
  503. static int get_frame_id (const char *id) {
  504. if (!memcmp(id, "TIT2", 4)) return TIT2; // Title
  505. if (!memcmp(id, "TPE1", 4)) return TPE1; // Artist
  506. if (!memcmp(id, "TALB", 4)) return TALB; // Album
  507. if (!memcmp(id, "TRCK", 4)) return TRCK; // Track
  508. if (!memcmp(id, "TYER", 4)) return TYER; // Year
  509. if (!memcmp(id, "TCON", 4)) return TCON; // Genre
  510. if (!memcmp(id, "COMM", 4)) return COMM; // Comment
  511. return 0;
  512. }
  514. #if 0
  516. static int skip_id3_tag (tta_info *info) {
  517. id3v2_tag id3v2;
  518. int id3v2_size;
  520. ////////////////////////////////////////
  521. // skip ID3v2 tag
  522. if (!info->Reader->Read(info->Reader, &id3v2, sizeof(id3v2_tag)))
  523. goto read_error;
  525. if (memcmp(id3v2.id, "ID3", 3)) {
  526. if (info->Reader->Seek(info->Reader, 0, SEEK_SET) < 0)
  527.     goto read_error;
  528. return 0;
  529. }
  531. if (id3v2.size[0] & 0x80) goto file_error;
  532. id3v2_size = unpack_sint28(id3v2.size);
  534. id3v2_size += (id3v2.flags &
  535. ID3_FOOTERPRESENT_FLAG) ? 20 : 10;
  536. info->Reader->Seek(info->Reader, id3v2_size, SEEK_SET);
  537. info->ID3.size = id3v2_size;
  539. return id3v2_size;
  541. file_error:
  542. ttainfo->STATE = FILE_ERROR;
  543. return -1;
  545. read_error:
  546. ttainfo->STATE = READ_ERROR;
  547. return -1;
  548. }
  550. #endif
  552. static int read_id3_tags (tta_info *info) {
  553. id3v1_tag id3v1;
  554. id3v2_tag id3v2;
  555. id3v2_frame frame_header;
  556. int id3v2_size;
  557. char *buffer = NULL;
  558. char *ptr;
  560. ////////////////////////////////////////
  561. // ID3v1 support
  562. if (info->Reader->Seek(info->Reader, -(int) sizeof(id3v1_tag),
  563. SEEK_END) < 0) goto read_error;
  565. if (!info->Reader->Read(info->Reader, &id3v1, sizeof(id3v1_tag))) 
  566.     goto read_error;
  568. if (!memcmp (id3v1.id, "TAG", 3)) {
  569. memcpy(info->ID3.title, id3v1.title, 30);
  570. memcpy(info->ID3.artist, id3v1.artist, 30);
  571. memcpy(info->ID3.album, id3v1.album, 30);
  572. memcpy(info->ID3.year, id3v1.year, 4);
  573. memcpy(info->ID3.comment, id3v1.comment, 28);
  575. if (id3v1.genre > GENRES-1) id3v1.genre = 12;
  576. sprintf(info->ID3.track, "%02d", id3v1.track);
  577. if (id3v1.genre && id3v1.genre != 0xFF)
  578.     sprintf(info->ID3.genre, "%s", genre[id3v1.genre]);
  579. info->ID3.id3has |= 1;
  580. }
  582. if (info->Reader->Seek(info->Reader, 0, SEEK_SET) < 0)
  583. goto read_error;
  585. ////////////////////////////////////////
  586. // ID3v2 minimal support
  587. if (!info->Reader->Read(info->Reader, &id3v2, sizeof(id3v2_tag)))
  588. goto read_error;
  590. if (memcmp(id3v2.id, "ID3", 3)) {
  591. if (info->Reader->Seek(info->Reader, 0, SEEK_SET) < 0)
  592.     goto read_error;
  593. return 0;
  594. }
  596. if (id3v2.size[0] & 0x80) goto file_error;
  597. id3v2_size = unpack_sint28(id3v2.size);
  599. if (!(buffer = (unsigned char *) malloc (id3v2_size))) {
  600. ttainfo->STATE = MEMORY_ERROR;
  601. goto read_done;
  602. }
  604. if ((id3v2.flags & ID3_UNSYNCHRONISATION_FLAG) ||
  605. (id3v2.flags & ID3_EXPERIMENTALTAG_FLAG) ||
  606. (id3v2.version < 3)) goto read_done;
  608. if (!info->Reader->Read(info->Reader, buffer, id3v2_size)) {
  609. free (buffer);
  610. goto read_error;
  611. }
  613. ptr = buffer;
  615. // skip extended header if present
  616. if (id3v2.flags & ID3_EXTENDEDHEADER_FLAG) {
  617. int offset = unpack_sint32(ptr);
  618. ptr += offset;
  619. }
  621. // read id3v2 frames
  622. while (ptr - buffer < id3v2_size) {
  623. char *data = NULL;
  624. int data_size, frame_id;
  625. int size = 0;
  627. // get frame header
  628. memcpy(&frame_header, ptr, sizeof(id3v2_frame));
  629. ptr += sizeof(id3v2_frame);
  630. data_size = unpack_sint32(frame_header.size);
  632. // skip unsupported frames
  633. if (!(frame_id = get_frame_id(frame_header.id)) ||
  634. frame_header.flags & FRAME_COMPRESSION_FLAG ||
  635. frame_header.flags & FRAME_ENCRYPTION_FLAG ||
  636. frame_header.flags & FRAME_UNSYNCHRONISATION_FLAG || (
  637. *ptr != FIELD_TEXT_ISO_8859_1 &&
  638. *ptr != FIELD_TEXT_UTF_8)) {
  639. ptr += data_size;
  640. continue;
  641. }
  643. data_size--; ptr++;
  645. switch (frame_id) {
  646. case TIT2: data = info->ID3.title;
  647. size = sizeof(info->ID3.title) - 1; break;
  648. case TPE1: data = info->ID3.artist;
  649. size = sizeof(info->ID3.artist) - 1; break;
  650. case TALB: data = info->ID3.album;
  651. size = sizeof(info->ID3.album) - 1; break;
  652. case TRCK: data = info->ID3.track;
  653. size = sizeof(info->ID3.track) - 1; break;
  654. case TYER: data = info->ID3.year;
  655. size = sizeof(info->ID3.year) - 1; break;
  656. case TCON: data = info->ID3.genre;
  657. size = sizeof(info->ID3.genre) - 1; break;
  658. case COMM: data = info->ID3.comment;
  659. size = sizeof(info->ID3.comment) - 1;
  660. data_size -= 3; ptr += 3;
  662. // skip zero short description
  663. if (*ptr == 0) { data_size--; ptr++; }
  664. break;
  665. }
  667. if (data_size < size) size = data_size;
  668. memcpy(data, ptr, size); data[size] = '';
  669. ptr += data_size;
  670. }
  672. info->ID3.id3has |= 2;
  674. read_done:
  675. if (buffer) free(buffer);
  677. id3v2_size += (id3v2.flags &
  678. ID3_FOOTERPRESENT_FLAG) ? 20 : 10;
  679. info->Reader->Seek(info->Reader, id3v2_size, SEEK_SET);
  680. info->ID3.size = id3v2_size;
  682. return id3v2_size;
  684. file_error:
  685. ttainfo->STATE = FILE_ERROR;
  686. return -1;
  688. read_error:
  689. ttainfo->STATE = READ_ERROR;
  690. return -1;
  691. }
  693. /* eof */