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

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

Windows CE

开发平台：

C/C++

bitbuffer.c：源码内容
  1. /* test_libFLAC - Unit tester for libFLAC
  2.  * Copyright (C) 2000,2001,2002,2003,2004,2005  Josh Coalson
  3.  *
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License
  6.  * as published by the Free Software Foundation; either version 2
  7.  * of the License, or (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17.  */
  19. #include "FLAC/assert.h"
  20. #include "private/bitbuffer.h" /* from the libFLAC private include area */
  21. #include <stdio.h>
  22. #include <string.h> /* for memcmp() */
  24. /* adjust for compilers that can't understand using LLU suffix for uint64_t literals */
  25. #ifdef _MSC_VER
  26. #define FLAC__U64L(x) x
  27. #else
  28. #define FLAC__U64L(x) x##LLU
  29. #endif
  31. /*
  32.  * WATCHOUT!  Since FLAC__BitBuffer is a private structure, we use a copy of
  33.  * the definition here to get at the internals.  Make sure this is kept up
  34.  * to date with what is in ../libFLAC/bitbuffer.c
  35.  */
  36. struct FLAC__BitBuffer {
  37. FLAC__blurb *buffer;
  38. unsigned capacity; /* in blurbs */
  39. unsigned blurbs, bits;
  40. unsigned total_bits; /* must always == FLAC__BITS_PER_BLURB*blurbs+bits */
  41. unsigned consumed_blurbs, consumed_bits;
  42. unsigned total_consumed_bits; /* must always == FLAC__BITS_PER_BLURB*consumed_blurbs+consumed_bits */
  43. FLAC__uint16 read_crc16;
  44. #if FLAC__BITS_PER_BLURB == 32
  45. unsigned crc16_align;
  46. #endif
  47. FLAC__blurb save_head, save_tail;
  48. };
  51. static FLAC__bool dummy_read_callback(FLAC__byte buffer[], unsigned *bytes, void *client_data)
  52. {
  53. (void)buffer, (void)bytes, (void)client_data;
  54. return true;
  55. }
  57. FLAC__bool test_bitbuffer()
  58. {
  59. FLAC__BitBuffer *bb, *bb_zero, *bb_one, *bbcopy;
  60. FLAC__bool ok;
  61. unsigned i, j;
  62. static FLAC__byte test_pattern1[19] = { 0xaa, 0xf0, 0xaa, 0xbe, 0xaa, 0xaa, 0xaa, 0xa8, 0x30, 0x0a, 0xaa, 0xaa, 0xaa, 0xad, 0xea, 0xdb, 0xee, 0xfa, 0xce };
  64. FLAC__ASSERT(FLAC__BITS_PER_BLURB == 8);
  66. printf("n+++ libFLAC unit test: bitbuffernn");
  68. /*
  69.  * test new -> delete
  70.  */
  71. printf("testing new... ");
  72. bb = FLAC__bitbuffer_new();
  73. if(0 == bb) {
  74. printf("FAILED, returned NULLn");
  75. return false;
  76. }
  77. printf("OKn");
  79. printf("testing delete... ");
  80. FLAC__bitbuffer_delete(bb);
  81. printf("OKn");
  83. /*
  84.  * test new -> init -> delete
  85.  */
  86. printf("testing new... ");
  87. bb = FLAC__bitbuffer_new();
  88. if(0 == bb) {
  89. printf("FAILED, returned NULLn");
  90. return false;
  91. }
  92. printf("OKn");
  94. printf("testing init... ");
  95. FLAC__bitbuffer_init(bb);
  96. if(0 == bb) {
  97. printf("FAILED, returned NULLn");
  98. return false;
  99. }
  100. printf("OKn");
  102. printf("testing delete... ");
  103. FLAC__bitbuffer_delete(bb);
  104. printf("OKn");
  106. /*
  107.  * test new -> init -> clear -> delete
  108.  */
  109. printf("testing new... ");
  110. bb = FLAC__bitbuffer_new();
  111. if(0 == bb) {
  112. printf("FAILED, returned NULLn");
  113. return false;
  114. }
  115. printf("OKn");
  117. printf("testing init... ");
  118. FLAC__bitbuffer_init(bb);
  119. if(0 == bb) {
  120. printf("FAILED, returned NULLn");
  121. return false;
  122. }
  123. printf("OKn");
  125. printf("testing clear... ");
  126. FLAC__bitbuffer_clear(bb);
  127. if(0 == bb) {
  128. printf("FAILED, returned NULLn");
  129. return false;
  130. }
  131. printf("OKn");
  133. printf("testing delete... ");
  134. FLAC__bitbuffer_delete(bb);
  135. printf("OKn");
  137. /*
  138.  * test normal usage
  139.  */
  140. printf("testing new... ");
  141. bb = FLAC__bitbuffer_new();
  142. bb_zero = FLAC__bitbuffer_new();
  143. bb_one = FLAC__bitbuffer_new();
  144. bbcopy = FLAC__bitbuffer_new();
  145. if(0 == bb || 0 == bb_zero || 0 == bb_one || 0 == bbcopy) {
  146. printf("FAILED, returned NULLn");
  147. return false;
  148. }
  149. printf("OKn");
  151. printf("testing init... ");
  152. ok = FLAC__bitbuffer_init(bb) && FLAC__bitbuffer_init(bb_zero) && FLAC__bitbuffer_init(bb_one) && FLAC__bitbuffer_init(bbcopy);
  153. printf("%sn", ok?"OK":"FAILED");
  154. if(!ok)
  155. return false;
  157. printf("testing clear... ");
  158. ok = FLAC__bitbuffer_clear(bb) && FLAC__bitbuffer_clear(bb_zero) && FLAC__bitbuffer_clear(bb_one) && FLAC__bitbuffer_clear(bbcopy);
  159. printf("%sn", ok?"OK":"FAILED");
  160. if(!ok)
  161. return false;
  163. printf("setting up bb_one... ");
  164. ok = FLAC__bitbuffer_write_raw_uint32(bb_one, 1, 7) && FLAC__bitbuffer_read_raw_uint32(bb_one, &i, 6, dummy_read_callback, 0);
  165. printf("%sn", ok?"OK":"FAILED");
  166. if(!ok)
  167. return false;
  168. FLAC__bitbuffer_dump(bb_one, stdout);
  170. printf("capacity = %un", bb->capacity);
  172. printf("testing zeroes, raw_uint32*... ");
  173. ok =
  174. FLAC__bitbuffer_write_raw_uint32(bb, 0x1, 1) &&
  175. FLAC__bitbuffer_write_raw_uint32(bb, 0x1, 2) &&
  176. FLAC__bitbuffer_write_raw_uint32(bb, 0xa, 5) &&
  177. FLAC__bitbuffer_write_raw_uint32(bb, 0xf0, 8) &&
  178. FLAC__bitbuffer_write_raw_uint32(bb, 0x2aa, 10) &&
  179. FLAC__bitbuffer_write_raw_uint32(bb, 0xf, 4) &&
  180. FLAC__bitbuffer_write_raw_uint32(bb, 0xaaaaaaaa, 32) &&
  181. FLAC__bitbuffer_write_zeroes(bb, 4) &&
  182. FLAC__bitbuffer_write_raw_uint32(bb, 0x3, 2) &&
  183. FLAC__bitbuffer_write_zeroes(bb, 8) &&
  184. FLAC__bitbuffer_write_raw_uint64(bb, FLAC__U64L(0xaaaaaaaadeadbeef), 64) &&
  185. FLAC__bitbuffer_write_raw_uint32(bb, 0xace, 12)
  186. ;
  187. if(!ok) {
  188. printf("FAILEDn");
  189. FLAC__bitbuffer_dump(bb, stdout);
  190. return false;
  191. }
  192. if(bb->blurbs != sizeof(test_pattern1)) {
  193. printf("FAILED byte count %u != %un", bb->blurbs, (unsigned)sizeof(test_pattern1));
  194. FLAC__bitbuffer_dump(bb, stdout);
  195. return false;
  196. }
  197. if(bb->bits != 0) {
  198. printf("FAILED bit count %u != 0n", bb->bits);
  199. FLAC__bitbuffer_dump(bb, stdout);
  200. return false;
  201. }
  202. if(bb->total_bits != 8*bb->blurbs+bb->bits) {
  203. printf("FAILED total_bits count %u != %u (%u:%u)n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
  204. FLAC__bitbuffer_dump(bb, stdout);
  205. return false;
  206. }
  207. if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0) {
  208. printf("FAILED pattern matchn");
  209. FLAC__bitbuffer_dump(bb, stdout);
  210. return false;
  211. }
  212. printf("OKn");
  213. FLAC__bitbuffer_dump(bb, stdout);
  215. printf("testing raw_uint32 some more... ");
  216. ok = FLAC__bitbuffer_write_raw_uint32(bb, 0x3d, 6);
  217. if(!ok) {
  218. printf("FAILEDn");
  219. FLAC__bitbuffer_dump(bb, stdout);
  220. return false;
  221. }
  222. if(bb->blurbs != sizeof(test_pattern1)) {
  223. printf("FAILED byte count %u != %un", bb->blurbs, (unsigned)sizeof(test_pattern1));
  224. FLAC__bitbuffer_dump(bb, stdout);
  225. return false;
  226. }
  227. if(bb->bits != 6) {
  228. printf("FAILED bit count %u != 6n", bb->bits);
  229. FLAC__bitbuffer_dump(bb, stdout);
  230. return false;
  231. }
  232. if(bb->total_bits != 8*bb->blurbs+bb->bits) {
  233. printf("FAILED total_bits count %u != %u (%u:%u)n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
  234. FLAC__bitbuffer_dump(bb, stdout);
  235. return false;
  236. }
  237. if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x3d) {
  238. printf("FAILED pattern matchn");
  239. FLAC__bitbuffer_dump(bb, stdout);
  240. return false;
  241. }
  242. printf("OKn");
  243. FLAC__bitbuffer_dump(bb, stdout);
  245. printf("testing concatenate_aligned (bb_zero)... ");
  246. ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_zero);
  247. if(!ok) {
  248. printf("FAILEDn");
  249. FLAC__bitbuffer_dump(bb, stdout);
  250. return false;
  251. }
  252. if(bb->blurbs != sizeof(test_pattern1)) {
  253. printf("FAILED byte count %u != %un", bb->blurbs, (unsigned)sizeof(test_pattern1));
  254. FLAC__bitbuffer_dump(bb, stdout);
  255. return false;
  256. }
  257. if(bb->bits != 6) {
  258. printf("FAILED bit count %u != 6n", bb->bits);
  259. FLAC__bitbuffer_dump(bb, stdout);
  260. return false;
  261. }
  262. if(bb->total_bits != 8*bb->blurbs+bb->bits) {
  263. printf("FAILED total_bits count %u != %u (%u:%u)n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
  264. FLAC__bitbuffer_dump(bb, stdout);
  265. return false;
  266. }
  267. if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x3d) {
  268. printf("FAILED pattern matchn");
  269. FLAC__bitbuffer_dump(bb, stdout);
  270. return false;
  271. }
  272. printf("OKn");
  273. FLAC__bitbuffer_dump(bb, stdout);
  275. printf("testing concatenate_aligned (bb_one)... ");
  276. ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
  277. if(!ok) {
  278. printf("FAILEDn");
  279. FLAC__bitbuffer_dump(bb, stdout);
  280. return false;
  281. }
  282. if(bb->blurbs != sizeof(test_pattern1)) {
  283. printf("FAILED byte count %u != %un", bb->blurbs, (unsigned)sizeof(test_pattern1));
  284. FLAC__bitbuffer_dump(bb, stdout);
  285. return false;
  286. }
  287. if(bb->bits != 7) {
  288. printf("FAILED bit count %u != 7n", bb->bits);
  289. FLAC__bitbuffer_dump(bb, stdout);
  290. return false;
  291. }
  292. if(bb->total_bits != 8*bb->blurbs+bb->bits) {
  293. printf("FAILED total_bits count %u != %u (%u:%u)n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
  294. FLAC__bitbuffer_dump(bb, stdout);
  295. return false;
  296. }
  297. if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x7b) {
  298. printf("FAILED pattern matchn");
  299. FLAC__bitbuffer_dump(bb, stdout);
  300. return false;
  301. }
  302. printf("OKn");
  303. FLAC__bitbuffer_dump(bb, stdout);
  305. printf("testing concatenate_aligned (bb_one again)... ");
  306. (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 1, 1);
  307. (void)FLAC__bitbuffer_read_raw_uint32(bb_one, &i, 1, dummy_read_callback, 0);
  308. ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
  309. if(!ok) {
  310. printf("FAILEDn");
  311. FLAC__bitbuffer_dump(bb, stdout);
  312. return false;
  313. }
  314. if(bb->blurbs != sizeof(test_pattern1)+1) {
  315. printf("FAILED byte count %u != %un", bb->blurbs, (unsigned)sizeof(test_pattern1)+1);
  316. FLAC__bitbuffer_dump(bb, stdout);
  317. return false;
  318. }
  319. if(bb->bits != 0) {
  320. printf("FAILED bit count %u != 0n", bb->bits);
  321. FLAC__bitbuffer_dump(bb, stdout);
  322. return false;
  323. }
  324. if(bb->total_bits != 8*bb->blurbs+bb->bits) {
  325. printf("FAILED total_bits count %u != %u (%u:%u)n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
  326. FLAC__bitbuffer_dump(bb, stdout);
  327. return false;
  328. }
  329. if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs-1] != 0xf7) {
  330. printf("FAILED pattern matchn");
  331. FLAC__bitbuffer_dump(bb, stdout);
  332. return false;
  333. }
  334. printf("OKn");
  335. FLAC__bitbuffer_dump(bb, stdout);
  337. printf("testing concatenate_aligned (bb_four)... ");
  338. (void)FLAC__bitbuffer_clear(bb_one);
  339. (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 8, 4);
  340. ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
  341. if(!ok) {
  342. printf("FAILEDn");
  343. FLAC__bitbuffer_dump(bb, stdout);
  344. return false;
  345. }
  346. if(bb->blurbs != sizeof(test_pattern1)+1) {
  347. printf("FAILED byte count %u != %un", bb->blurbs, (unsigned)sizeof(test_pattern1)+1);
  348. FLAC__bitbuffer_dump(bb, stdout);
  349. return false;
  350. }
  351. if(bb->bits != 4) {
  352. printf("FAILED bit count %u != 4n", bb->bits);
  353. FLAC__bitbuffer_dump(bb, stdout);
  354. return false;
  355. }
  356. if(bb->total_bits != 8*bb->blurbs+bb->bits) {
  357. printf("FAILED total_bits count %u != %u (%u:%u)n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
  358. FLAC__bitbuffer_dump(bb, stdout);
  359. return false;
  360. }
  361. if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x08) {
  362. printf("FAILED pattern matchn");
  363. FLAC__bitbuffer_dump(bb, stdout);
  364. return false;
  365. }
  366. printf("OKn");
  367. FLAC__bitbuffer_dump(bb, stdout);
  369. printf("testing concatenate_aligned (bb_eight)... ");
  370. (void)FLAC__bitbuffer_read_raw_uint32(bb_one, &i, 4, dummy_read_callback, 0);
  371. (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 0xaa, 8);
  372. ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
  373. if(!ok) {
  374. printf("FAILEDn");
  375. FLAC__bitbuffer_dump(bb, stdout);
  376. return false;
  377. }
  378. if(bb->blurbs != sizeof(test_pattern1)+2) {
  379. printf("FAILED byte count %u != %un", bb->blurbs, (unsigned)sizeof(test_pattern1)+2);
  380. FLAC__bitbuffer_dump(bb, stdout);
  381. return false;
  382. }
  383. if(bb->bits != 4) {
  384. printf("FAILED bit count %u != 4n", bb->bits);
  385. FLAC__bitbuffer_dump(bb, stdout);
  386. return false;
  387. }
  388. if(bb->total_bits != 8*bb->blurbs+bb->bits) {
  389. printf("FAILED total_bits count %u != %u (%u:%u)n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
  390. FLAC__bitbuffer_dump(bb, stdout);
  391. return false;
  392. }
  393. if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs-1] != 0x8a || bb->buffer[bb->blurbs] != 0x0a) {
  394. printf("FAILED pattern matchn");
  395. FLAC__bitbuffer_dump(bb, stdout);
  396. return false;
  397. }
  398. printf("OKn");
  399. FLAC__bitbuffer_dump(bb, stdout);
  401. printf("testing concatenate_aligned (bb_seventeen)... ");
  402. (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 0x155, 9);
  403. ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
  404. if(!ok) {
  405. printf("FAILEDn");
  406. FLAC__bitbuffer_dump(bb, stdout);
  407. return false;
  408. }
  409. if(bb->blurbs != sizeof(test_pattern1)+4) {
  410. printf("FAILED byte count %u != %un", bb->blurbs, (unsigned)sizeof(test_pattern1)+4);
  411. FLAC__bitbuffer_dump(bb, stdout);
  412. return false;
  413. }
  414. if(bb->bits != 5) {
  415. printf("FAILED bit count %u != 5n", bb->bits);
  416. FLAC__bitbuffer_dump(bb, stdout);
  417. return false;
  418. }
  419. if(bb->total_bits != 8*bb->blurbs+bb->bits) {
  420. printf("FAILED total_bits count %u != %u (%u:%u)n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
  421. FLAC__bitbuffer_dump(bb, stdout);
  422. return false;
  423. }
  424. if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs-3] != 0x8a || bb->buffer[bb->blurbs-2] != 0xaa || bb->buffer[bb->blurbs-1] != 0xaa || bb->buffer[bb->blurbs] != 0x15) {
  425. printf("FAILED pattern matchn");
  426. FLAC__bitbuffer_dump(bb, stdout);
  427. return false;
  428. }
  429. printf("OKn");
  430. FLAC__bitbuffer_dump(bb, stdout);
  432. printf("testing utf8_uint32(0x00000000)... ");
  433. FLAC__bitbuffer_clear(bb);
  434. FLAC__bitbuffer_write_utf8_uint32(bb, 0x00000000);
  435. ok = bb->total_bits == 8 && bb->buffer[0] == 0;
  436. printf("%sn", ok?"OK":"FAILED");
  437. if(!ok) {
  438. FLAC__bitbuffer_dump(bb, stdout);
  439. return false;
  440. }
  442. printf("testing utf8_uint32(0x0000007F)... ");
  443. FLAC__bitbuffer_clear(bb);
  444. FLAC__bitbuffer_write_utf8_uint32(bb, 0x0000007F);
  445. ok = bb->total_bits == 8 && bb->buffer[0] == 0x7F;
  446. printf("%sn", ok?"OK":"FAILED");
  447. if(!ok) {
  448. FLAC__bitbuffer_dump(bb, stdout);
  449. return false;
  450. }
  452. printf("testing utf8_uint32(0x00000080)... ");
  453. FLAC__bitbuffer_clear(bb);
  454. FLAC__bitbuffer_write_utf8_uint32(bb, 0x00000080);
  455. ok = bb->total_bits == 16 && bb->buffer[0] == 0xC2 && bb->buffer[1] == 0x80;
  456. printf("%sn", ok?"OK":"FAILED");
  457. if(!ok) {
  458. FLAC__bitbuffer_dump(bb, stdout);
  459. return false;
  460. }
  462. printf("testing utf8_uint32(0x000007FF)... ");
  463. FLAC__bitbuffer_clear(bb);
  464. FLAC__bitbuffer_write_utf8_uint32(bb, 0x000007FF);
  465. ok = bb->total_bits == 16 && bb->buffer[0] == 0xDF && bb->buffer[1] == 0xBF;
  466. printf("%sn", ok?"OK":"FAILED");
  467. if(!ok) {
  468. FLAC__bitbuffer_dump(bb, stdout);
  469. return false;
  470. }
  472. printf("testing utf8_uint32(0x00000800)... ");
  473. FLAC__bitbuffer_clear(bb);
  474. FLAC__bitbuffer_write_utf8_uint32(bb, 0x00000800);
  475. ok = bb->total_bits == 24 && bb->buffer[0] == 0xE0 && bb->buffer[1] == 0xA0 && bb->buffer[2] == 0x80;
  476. printf("%sn", ok?"OK":"FAILED");
  477. if(!ok) {
  478. FLAC__bitbuffer_dump(bb, stdout);
  479. return false;
  480. }
  482. printf("testing utf8_uint32(0x0000FFFF)... ");
  483. FLAC__bitbuffer_clear(bb);
  484. FLAC__bitbuffer_write_utf8_uint32(bb, 0x0000FFFF);
  485. ok = bb->total_bits == 24 && bb->buffer[0] == 0xEF && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF;
  486. printf("%sn", ok?"OK":"FAILED");
  487. if(!ok) {
  488. FLAC__bitbuffer_dump(bb, stdout);
  489. return false;
  490. }
  492. printf("testing utf8_uint32(0x00010000)... ");
  493. FLAC__bitbuffer_clear(bb);
  494. FLAC__bitbuffer_write_utf8_uint32(bb, 0x00010000);
  495. ok = bb->total_bits == 32 && bb->buffer[0] == 0xF0 && bb->buffer[1] == 0x90 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80;
  496. printf("%sn", ok?"OK":"FAILED");
  497. if(!ok) {
  498. FLAC__bitbuffer_dump(bb, stdout);
  499. return false;
  500. }
  502. printf("testing utf8_uint32(0x001FFFFF)... ");
  503. FLAC__bitbuffer_clear(bb);
  504. FLAC__bitbuffer_write_utf8_uint32(bb, 0x001FFFFF);
  505. ok = bb->total_bits == 32 && bb->buffer[0] == 0xF7 && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF;
  506. printf("%sn", ok?"OK":"FAILED");
  507. if(!ok) {
  508. FLAC__bitbuffer_dump(bb, stdout);
  509. return false;
  510. }
  512. printf("testing utf8_uint32(0x00200000)... ");
  513. FLAC__bitbuffer_clear(bb);
  514. FLAC__bitbuffer_write_utf8_uint32(bb, 0x00200000);
  515. ok = bb->total_bits == 40 && bb->buffer[0] == 0xF8 && bb->buffer[1] == 0x88 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80 && bb->buffer[4] == 0x80;
  516. printf("%sn", ok?"OK":"FAILED");
  517. if(!ok) {
  518. FLAC__bitbuffer_dump(bb, stdout);
  519. return false;
  520. }
  522. printf("testing utf8_uint32(0x03FFFFFF)... ");
  523. FLAC__bitbuffer_clear(bb);
  524. FLAC__bitbuffer_write_utf8_uint32(bb, 0x03FFFFFF);
  525. ok = bb->total_bits == 40 && bb->buffer[0] == 0xFB && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF && bb->buffer[4] == 0xBF;
  526. printf("%sn", ok?"OK":"FAILED");
  527. if(!ok) {
  528. FLAC__bitbuffer_dump(bb, stdout);
  529. return false;
  530. }
  532. printf("testing utf8_uint32(0x04000000)... ");
  533. FLAC__bitbuffer_clear(bb);
  534. FLAC__bitbuffer_write_utf8_uint32(bb, 0x04000000);
  535. ok = bb->total_bits == 48 && bb->buffer[0] == 0xFC && bb->buffer[1] == 0x84 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80 && bb->buffer[4] == 0x80 && bb->buffer[5] == 0x80;
  536. printf("%sn", ok?"OK":"FAILED");
  537. if(!ok) {
  538. FLAC__bitbuffer_dump(bb, stdout);
  539. return false;
  540. }
  542. printf("testing utf8_uint32(0x7FFFFFFF)... ");
  543. FLAC__bitbuffer_clear(bb);
  544. FLAC__bitbuffer_write_utf8_uint32(bb, 0x7FFFFFFF);
  545. ok = bb->total_bits == 48 && bb->buffer[0] == 0xFD && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF && bb->buffer[4] == 0xBF && bb->buffer[5] == 0xBF;
  546. printf("%sn", ok?"OK":"FAILED");
  547. if(!ok) {
  548. FLAC__bitbuffer_dump(bb, stdout);
  549. return false;
  550. }
  552. printf("testing utf8_uint64(0x0000000000000000)... ");
  553. FLAC__bitbuffer_clear(bb);
  554. FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000000000);
  555. ok = bb->total_bits == 8 && bb->buffer[0] == 0;
  556. printf("%sn", ok?"OK":"FAILED");
  557. if(!ok) {
  558. FLAC__bitbuffer_dump(bb, stdout);
  559. return false;
  560. }
  562. printf("testing utf8_uint64(0x000000000000007F)... ");
  563. FLAC__bitbuffer_clear(bb);
  564. FLAC__bitbuffer_write_utf8_uint64(bb, 0x000000000000007F);
  565. ok = bb->total_bits == 8 && bb->buffer[0] == 0x7F;
  566. printf("%sn", ok?"OK":"FAILED");
  567. if(!ok) {
  568. FLAC__bitbuffer_dump(bb, stdout);
  569. return false;
  570. }
  572. printf("testing utf8_uint64(0x0000000000000080)... ");
  573. FLAC__bitbuffer_clear(bb);
  574. FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000000080);
  575. ok = bb->total_bits == 16 && bb->buffer[0] == 0xC2 && bb->buffer[1] == 0x80;
  576. printf("%sn", ok?"OK":"FAILED");
  577. if(!ok) {
  578. FLAC__bitbuffer_dump(bb, stdout);
  579. return false;
  580. }
  582. printf("testing utf8_uint64(0x00000000000007FF)... ");
  583. FLAC__bitbuffer_clear(bb);
  584. FLAC__bitbuffer_write_utf8_uint64(bb, 0x00000000000007FF);
  585. ok = bb->total_bits == 16 && bb->buffer[0] == 0xDF && bb->buffer[1] == 0xBF;
  586. printf("%sn", ok?"OK":"FAILED");
  587. if(!ok) {
  588. FLAC__bitbuffer_dump(bb, stdout);
  589. return false;
  590. }
  592. printf("testing utf8_uint64(0x0000000000000800)... ");
  593. FLAC__bitbuffer_clear(bb);
  594. FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000000800);
  595. ok = bb->total_bits == 24 && bb->buffer[0] == 0xE0 && bb->buffer[1] == 0xA0 && bb->buffer[2] == 0x80;
  596. printf("%sn", ok?"OK":"FAILED");
  597. if(!ok) {
  598. FLAC__bitbuffer_dump(bb, stdout);
  599. return false;
  600. }
  602. printf("testing utf8_uint64(0x000000000000FFFF)... ");
  603. FLAC__bitbuffer_clear(bb);
  604. FLAC__bitbuffer_write_utf8_uint64(bb, 0x000000000000FFFF);
  605. ok = bb->total_bits == 24 && bb->buffer[0] == 0xEF && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF;
  606. printf("%sn", ok?"OK":"FAILED");
  607. if(!ok) {
  608. FLAC__bitbuffer_dump(bb, stdout);
  609. return false;
  610. }
  612. printf("testing utf8_uint64(0x0000000000010000)... ");
  613. FLAC__bitbuffer_clear(bb);
  614. FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000010000);
  615. ok = bb->total_bits == 32 && bb->buffer[0] == 0xF0 && bb->buffer[1] == 0x90 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80;
  616. printf("%sn", ok?"OK":"FAILED");
  617. if(!ok) {
  618. FLAC__bitbuffer_dump(bb, stdout);
  619. return false;
  620. }
  622. printf("testing utf8_uint64(0x00000000001FFFFF)... ");
  623. FLAC__bitbuffer_clear(bb);
  624. FLAC__bitbuffer_write_utf8_uint64(bb, 0x00000000001FFFFF);
  625. ok = bb->total_bits == 32 && bb->buffer[0] == 0xF7 && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF;
  626. printf("%sn", ok?"OK":"FAILED");
  627. if(!ok) {
  628. FLAC__bitbuffer_dump(bb, stdout);
  629. return false;
  630. }
  632. printf("testing utf8_uint64(0x0000000000200000)... ");
  633. FLAC__bitbuffer_clear(bb);
  634. FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000200000);
  635. ok = bb->total_bits == 40 && bb->buffer[0] == 0xF8 && bb->buffer[1] == 0x88 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80 && bb->buffer[4] == 0x80;
  636. printf("%sn", ok?"OK":"FAILED");
  637. if(!ok) {
  638. FLAC__bitbuffer_dump(bb, stdout);
  639. return false;
  640. }
  642. printf("testing utf8_uint64(0x0000000003FFFFFF)... ");
  643. FLAC__bitbuffer_clear(bb);
  644. FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000003FFFFFF);
  645. ok = bb->total_bits == 40 && bb->buffer[0] == 0xFB && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF && bb->buffer[4] == 0xBF;
  646. printf("%sn", ok?"OK":"FAILED");
  647. if(!ok) {
  648. FLAC__bitbuffer_dump(bb, stdout);
  649. return false;
  650. }
  652. printf("testing utf8_uint64(0x0000000004000000)... ");
  653. FLAC__bitbuffer_clear(bb);
  654. FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000004000000);
  655. ok = bb->total_bits == 48 && bb->buffer[0] == 0xFC && bb->buffer[1] == 0x84 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80 && bb->buffer[4] == 0x80 && bb->buffer[5] == 0x80;
  656. printf("%sn", ok?"OK":"FAILED");
  657. if(!ok) {
  658. FLAC__bitbuffer_dump(bb, stdout);
  659. return false;
  660. }
  662. printf("testing utf8_uint64(0x000000007FFFFFFF)... ");
  663. FLAC__bitbuffer_clear(bb);
  664. FLAC__bitbuffer_write_utf8_uint64(bb, 0x000000007FFFFFFF);
  665. ok = bb->total_bits == 48 && bb->buffer[0] == 0xFD && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF && bb->buffer[4] == 0xBF && bb->buffer[5] == 0xBF;
  666. printf("%sn", ok?"OK":"FAILED");
  667. if(!ok) {
  668. FLAC__bitbuffer_dump(bb, stdout);
  669. return false;
  670. }
  672. printf("testing utf8_uint64(0x0000000080000000)... ");
  673. FLAC__bitbuffer_clear(bb);
  674. FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000080000000);
  675. ok = bb->total_bits == 56 && bb->buffer[0] == 0xFE && bb->buffer[1] == 0x82 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80 && bb->buffer[4] == 0x80 && bb->buffer[5] == 0x80 && bb->buffer[6] == 0x80;
  676. printf("%sn", ok?"OK":"FAILED");
  677. if(!ok) {
  678. FLAC__bitbuffer_dump(bb, stdout);
  679. return false;
  680. }
  682. printf("testing utf8_uint64(0x0000000FFFFFFFFF)... ");
  683. FLAC__bitbuffer_clear(bb);
  684. FLAC__bitbuffer_write_utf8_uint64(bb, FLAC__U64L(0x0000000FFFFFFFFF));
  685. ok = bb->total_bits == 56 && bb->buffer[0] == 0xFE && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF && bb->buffer[4] == 0xBF && bb->buffer[5] == 0xBF && bb->buffer[6] == 0xBF;
  686. printf("%sn", ok?"OK":"FAILED");
  687. if(!ok) {
  688. FLAC__bitbuffer_dump(bb, stdout);
  689. return false;
  690. }
  692. printf("testing grow... ");
  693. FLAC__bitbuffer_clear(bb);
  694. FLAC__bitbuffer_write_raw_uint32(bb, 0xa, 4);
  695. j = bb->capacity;
  696. for(i = 0; i < j; i++)
  697. FLAC__bitbuffer_write_raw_uint32(bb, 0xaa, 8);
  698. ok = bb->total_bits = i*8+4 && bb->buffer[0] == 0xaa && bb->buffer[i] == 0xa;
  699. printf("%sn", ok?"OK":"FAILED");
  700. if(!ok) {
  701. FLAC__bitbuffer_dump(bb, stdout);
  702. return false;
  703. }
  704. printf("capacity = %un", bb->capacity);
  706. printf("testing clone... ");
  707. ok = FLAC__bitbuffer_clone(bbcopy, bb);
  708. if(!ok) {
  709. printf("FAILEDn");
  710. FLAC__bitbuffer_dump(bb, stdout);
  711. FLAC__bitbuffer_dump(bbcopy, stdout);
  712. return false;
  713. }
  714. if(bb->blurbs != bbcopy->blurbs) {
  715. printf("FAILED byte count %u != %un", bb->blurbs, bbcopy->blurbs);
  716. FLAC__bitbuffer_dump(bb, stdout);
  717. FLAC__bitbuffer_dump(bbcopy, stdout);
  718. return false;
  719. }
  720. if(bb->bits != bbcopy->bits) {
  721. printf("FAILED bit count %u != %un", bb->bits, bbcopy->bits);
  722. FLAC__bitbuffer_dump(bb, stdout);
  723. FLAC__bitbuffer_dump(bbcopy, stdout);
  724. return false;
  725. }
  726. if(bb->total_bits != bbcopy->total_bits) {
  727. printf("FAILED total_bits count %u != %un", bb->total_bits, bbcopy->total_bits);
  728. FLAC__bitbuffer_dump(bb, stdout);
  729. FLAC__bitbuffer_dump(bbcopy, stdout);
  730. return false;
  731. }
  732. if(memcmp(bb->buffer, bbcopy->buffer, sizeof(FLAC__byte)*bb->capacity) != 0) {
  733. printf("FAILED pattern matchn");
  734. FLAC__bitbuffer_dump(bb, stdout);
  735. FLAC__bitbuffer_dump(bbcopy, stdout);
  736. return false;
  737. }
  738. printf("OKn");
  740. printf("testing free... ");
  741. FLAC__bitbuffer_free(bb);
  742. FLAC__bitbuffer_free(bbcopy);
  743. printf("OKn");
  745. printf("testing delete... ");
  746. FLAC__bitbuffer_delete(bb);
  747. FLAC__bitbuffer_delete(bb_zero);
  748. FLAC__bitbuffer_delete(bb_one);
  749. FLAC__bitbuffer_delete(bbcopy);
  750. printf("OKn");
  752. printf("nPASSED!n");
  753. return true;
  754. }