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

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

Windows CE

开发平台：

C/C++

decoders.cpp：源码内容
  1. /* test_libFLAC++ - Unit tester for libFLAC++
  2.  * Copyright (C) 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 "decoders.h"
  20. extern "C" {
  21. #include "file_utils.h"
  22. #include "metadata_utils.h"
  23. }
  24. #include "FLAC/assert.h"
  25. #include "FLAC/metadata.h" // for ::FLAC__metadata_object_is_equal()
  26. #include "FLAC++/decoder.h"
  27. #include "share/grabbag.h"
  28. #include <errno.h>
  29. #include <stdio.h>
  30. #include <stdlib.h>
  31. #include <string.h>
  33. #ifdef _MSC_VER
  34. // warning C4800: 'int' : forcing to bool 'true' or 'false' (performance warning)
  35. #pragma warning ( disable : 4800 )
  36. #endif
  38. static ::FLAC__StreamMetadata streaminfo_, padding_, seektable_, application1_, application2_, vorbiscomment_, cuesheet_, unknown_;
  39. static ::FLAC__StreamMetadata *expected_metadata_sequence_[8];
  40. static unsigned num_expected_;
  41. static const char *flacfilename_ = "metadata.flac";
  42. static unsigned flacfilesize_;
  44. static bool die_(const char *msg)
  45. {
  46. printf("ERROR: %sn", msg);
  47. return false;
  48. }
  50. static void init_metadata_blocks_()
  51. {
  52. mutils__init_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_);
  53. }
  55. static void free_metadata_blocks_()
  56. {
  57. mutils__free_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_);
  58. }
  60. static bool generate_file_()
  61. {
  62. printf("nngenerating FLAC file for decoder tests...n");
  64. num_expected_ = 0;
  65. expected_metadata_sequence_[num_expected_++] = &padding_;
  66. expected_metadata_sequence_[num_expected_++] = &seektable_;
  67. expected_metadata_sequence_[num_expected_++] = &application1_;
  68. expected_metadata_sequence_[num_expected_++] = &application2_;
  69. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  70. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  71. expected_metadata_sequence_[num_expected_++] = &unknown_;
  73. if(!file_utils__generate_flacfile(flacfilename_, &flacfilesize_, 512 * 1024, &streaminfo_, expected_metadata_sequence_, num_expected_))
  74. return die_("creating the encoded file");
  76. return true;
  77. }
  80. class DecoderCommon {
  81. public:
  82. FILE *file_;
  83. unsigned current_metadata_number_;
  84. bool ignore_errors_;
  85. bool error_occurred_;
  87. DecoderCommon(): file_(0), current_metadata_number_(0), ignore_errors_(false), error_occurred_(false) { }
  88. ::FLAC__StreamDecoderReadStatus common_read_callback_(FLAC__byte buffer[], unsigned *bytes);
  89. ::FLAC__StreamDecoderWriteStatus common_write_callback_(const ::FLAC__Frame *frame);
  90. void common_metadata_callback_(const ::FLAC__StreamMetadata *metadata);
  91. void common_error_callback_(::FLAC__StreamDecoderErrorStatus status);
  92. };
  94. ::FLAC__StreamDecoderReadStatus DecoderCommon::common_read_callback_(FLAC__byte buffer[], unsigned *bytes)
  95. {
  96. if(error_occurred_)
  97. return ::FLAC__STREAM_DECODER_READ_STATUS_ABORT;
  99. if(feof(file_))
  100. return ::FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
  101. else if(*bytes > 0) {
  102. unsigned bytes_read = ::fread(buffer, 1, *bytes, file_);
  103. if(bytes_read == 0) {
  104. if(feof(file_))
  105. return ::FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
  106. else
  107. return ::FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
  108. }
  109. else {
  110. *bytes = bytes_read;
  111. return ::FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
  112. }
  113. }
  114. else
  115. return ::FLAC__STREAM_DECODER_READ_STATUS_ABORT; /* abort to avoid a deadlock */
  116. }
  118. ::FLAC__StreamDecoderWriteStatus DecoderCommon::common_write_callback_(const ::FLAC__Frame *frame)
  119. {
  120. if(error_occurred_)
  121. return ::FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
  123. if(
  124. (frame->header.number_type == ::FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER && frame->header.number.frame_number == 0) ||
  125. (frame->header.number_type == ::FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER && frame->header.number.sample_number == 0)
  126. ) {
  127. printf("content... ");
  128. fflush(stdout);
  129. }
  131. return ::FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
  132. }
  134. void DecoderCommon::common_metadata_callback_(const ::FLAC__StreamMetadata *metadata)
  135. {
  136. if(error_occurred_)
  137. return;
  139. printf("%d... ", current_metadata_number_);
  140. fflush(stdout);
  142. if(current_metadata_number_ >= num_expected_) {
  143. (void)die_("got more metadata blocks than expected");
  144. error_occurred_ = true;
  145. }
  146. else {
  147. if(!::FLAC__metadata_object_is_equal(expected_metadata_sequence_[current_metadata_number_], metadata)) {
  148. (void)die_("metadata block mismatch");
  149. error_occurred_ = true;
  150. }
  151. }
  152. current_metadata_number_++;
  153. }
  155. void DecoderCommon::common_error_callback_(::FLAC__StreamDecoderErrorStatus status)
  156. {
  157. if(!ignore_errors_) {
  158. printf("ERROR: got error callback: err = %u (%s)n", (unsigned)status, ::FLAC__StreamDecoderErrorStatusString[status]);
  159. error_occurred_ = true;
  160. }
  161. }
  163. class StreamDecoder : public FLAC::Decoder::Stream, public DecoderCommon {
  164. public:
  165. StreamDecoder(): FLAC::Decoder::Stream(), DecoderCommon() { }
  166. ~StreamDecoder() { }
  168. // from FLAC::Decoder::Stream
  169. ::FLAC__StreamDecoderReadStatus read_callback(FLAC__byte buffer[], unsigned *bytes);
  170. ::FLAC__StreamDecoderWriteStatus write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]);
  171. void metadata_callback(const ::FLAC__StreamMetadata *metadata);
  172. void error_callback(::FLAC__StreamDecoderErrorStatus status);
  174. bool die(const char *msg = 0) const;
  176. bool test_respond();
  177. };
  179. ::FLAC__StreamDecoderReadStatus StreamDecoder::read_callback(FLAC__byte buffer[], unsigned *bytes)
  180. {
  181. return common_read_callback_(buffer, bytes);
  182. }
  184. ::FLAC__StreamDecoderWriteStatus StreamDecoder::write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[])
  185. {
  186. (void)buffer;
  188. return common_write_callback_(frame);
  189. }
  191. void StreamDecoder::metadata_callback(const ::FLAC__StreamMetadata *metadata)
  192. {
  193. common_metadata_callback_(metadata);
  194. }
  196. void StreamDecoder::error_callback(::FLAC__StreamDecoderErrorStatus status)
  197. {
  198. common_error_callback_(status);
  199. }
  201. bool StreamDecoder::die(const char *msg) const
  202. {
  203. State state = get_state();
  205. if(msg)
  206. printf("FAILED, %s", msg);
  207. else
  208. printf("FAILED");
  210. printf(", state = %u (%s)n", (unsigned)((::FLAC__StreamDecoderState)state), state.as_cstring());
  212. return false;
  213. }
  215. bool StreamDecoder::test_respond()
  216. {
  217. printf("testing init()... ");
  218. if(init() != ::FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
  219. return die();
  220. printf("OKn");
  222. current_metadata_number_ = 0;
  224. if(::fseek(file_, 0, SEEK_SET) < 0) {
  225. printf("FAILED rewinding input, errno = %dn", errno);
  226. return false;
  227. }
  229. printf("testing process_until_end_of_stream()... ");
  230. if(!process_until_end_of_stream()) {
  231. State state = get_state();
  232. printf("FAILED, returned false, state = %u (%s)n", (unsigned)((::FLAC__StreamDecoderState)state), state.as_cstring());
  233. return false;
  234. }
  235. printf("OKn");
  237. printf("testing finish()... ");
  238. finish();
  239. printf("OKn");
  241. return true;
  242. }
  244. static bool test_stream_decoder()
  245. {
  246. StreamDecoder *decoder;
  248. printf("n+++ libFLAC++ unit test: FLAC::Decoder::Streamnn");
  250. //
  251. // test new -> delete
  252. //
  253. printf("allocating decoder instance... ");
  254. decoder = new StreamDecoder();
  255. if(0 == decoder) {
  256. printf("FAILED, new returned NULLn");
  257. return false;
  258. }
  259. printf("OKn");
  261. printf("testing is_valid()... ");
  262. if(!decoder->is_valid()) {
  263. printf("FAILED, returned falsen");
  264. return false;
  265. }
  266. printf("OKn");
  268. printf("freeing decoder instance... ");
  269. delete decoder;
  270. printf("OKn");
  272. //
  273. // test new -> init -> delete
  274. //
  275. printf("allocating decoder instance... ");
  276. decoder = new StreamDecoder();
  277. if(0 == decoder) {
  278. printf("FAILED, new returned NULLn");
  279. return false;
  280. }
  281. printf("OKn");
  283. printf("testing is_valid()... ");
  284. if(!decoder->is_valid()) {
  285. printf("FAILED, returned falsen");
  286. return false;
  287. }
  288. printf("OKn");
  290. printf("testing init()... ");
  291. if(decoder->init() != ::FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
  292. return decoder->die();
  293. printf("OKn");
  295. printf("freeing decoder instance... ");
  296. delete decoder;
  297. printf("OKn");
  299. //
  300. // test normal usage
  301. //
  302. num_expected_ = 0;
  303. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  305. printf("allocating decoder instance... ");
  306. decoder = new StreamDecoder();
  307. if(0 == decoder) {
  308. printf("FAILED, new returned NULLn");
  309. return false;
  310. }
  311. printf("OKn");
  313. printf("testing is_valid()... ");
  314. if(!decoder->is_valid()) {
  315. printf("FAILED, returned falsen");
  316. return false;
  317. }
  318. printf("OKn");
  320. printf("testing init()... ");
  321. if(decoder->init() != ::FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
  322. return decoder->die();
  323. printf("OKn");
  325. printf("testing get_state()... ");
  326. FLAC::Decoder::Stream::State state = decoder->get_state();
  327. printf("returned state = %u (%s)... OKn", (unsigned)((::FLAC__StreamDecoderState)state), state.as_cstring());
  329. decoder->current_metadata_number_ = 0;
  330. decoder->ignore_errors_ = false;
  331. decoder->error_occurred_ = false;
  333. printf("opening FLAC file... ");
  334. decoder->file_ = ::fopen(flacfilename_, "rb");
  335. if(0 == decoder->file_) {
  336. printf("ERRORn");
  337. return false;
  338. }
  339. printf("OKn");
  341. printf("testing process_until_end_of_metadata()... ");
  342. if(!decoder->process_until_end_of_metadata())
  343. return decoder->die("returned false");
  344. printf("OKn");
  346. printf("testing process_single()... ");
  347. if(!decoder->process_single())
  348. return decoder->die("returned false");
  349. printf("OKn");
  351. printf("testing skip_single_frame()... ");
  352. if(!decoder->skip_single_frame())
  353. return decoder->die("returned false");
  354. printf("OKn");
  356. printf("testing flush()... ");
  357. if(!decoder->flush())
  358. return decoder->die("returned false");
  359. printf("OKn");
  361. decoder->ignore_errors_ = true;
  362. printf("testing process_single()... ");
  363. if(!decoder->process_single())
  364. return decoder->die("returned false");
  365. printf("OKn");
  366. decoder->ignore_errors_ = false;
  368. printf("testing process_until_end_of_stream()... ");
  369. if(!decoder->process_until_end_of_stream())
  370. return decoder->die("returned false");
  371. printf("OKn");
  373. printf("testing get_channels()... ");
  374. {
  375. unsigned channels = decoder->get_channels();
  376. if(channels != streaminfo_.data.stream_info.channels) {
  377. printf("FAILED, returned %u, expected %un", channels, streaminfo_.data.stream_info.channels);
  378. return false;
  379. }
  380. }
  381. printf("OKn");
  383. printf("testing get_bits_per_sample()... ");
  384. {
  385. unsigned bits_per_sample = decoder->get_bits_per_sample();
  386. if(bits_per_sample != streaminfo_.data.stream_info.bits_per_sample) {
  387. printf("FAILED, returned %u, expected %un", bits_per_sample, streaminfo_.data.stream_info.bits_per_sample);
  388. return false;
  389. }
  390. }
  391. printf("OKn");
  393. printf("testing get_sample_rate()... ");
  394. {
  395. unsigned sample_rate = decoder->get_sample_rate();
  396. if(sample_rate != streaminfo_.data.stream_info.sample_rate) {
  397. printf("FAILED, returned %u, expected %un", sample_rate, streaminfo_.data.stream_info.sample_rate);
  398. return false;
  399. }
  400. }
  401. printf("OKn");
  403. printf("testing get_blocksize()... ");
  404. {
  405. unsigned blocksize = decoder->get_blocksize();
  406. /* value could be anything since we're at the last block, so accept any answer */
  407. printf("returned %u... OKn", blocksize);
  408. }
  410. printf("testing get_channel_assignment()... ");
  411. {
  412. ::FLAC__ChannelAssignment ca = decoder->get_channel_assignment();
  413. printf("returned %u (%s)... OKn", (unsigned)ca, ::FLAC__ChannelAssignmentString[ca]);
  414. }
  416. printf("testing reset()... ");
  417. if(!decoder->reset())
  418. return decoder->die("returned false");
  419. printf("OKn");
  421. decoder->current_metadata_number_ = 0;
  423. printf("rewinding input... ");
  424. if(::fseek(decoder->file_, 0, SEEK_SET) < 0) {
  425. printf("FAILED, errno = %dn", errno);
  426. return false;
  427. }
  428. printf("OKn");
  430. printf("testing process_until_end_of_stream()... ");
  431. if(!decoder->process_until_end_of_stream())
  432. return decoder->die("returned false");
  433. printf("OKn");
  435. printf("testing finish()... ");
  436. decoder->finish();
  437. printf("OKn");
  439. /*
  440.  * respond all
  441.  */
  443. printf("testing set_metadata_respond_all()... ");
  444. if(!decoder->set_metadata_respond_all()) {
  445. printf("FAILED, returned falsen");
  446. return false;
  447. }
  448. printf("OKn");
  450. num_expected_ = 0;
  451. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  452. expected_metadata_sequence_[num_expected_++] = &padding_;
  453. expected_metadata_sequence_[num_expected_++] = &seektable_;
  454. expected_metadata_sequence_[num_expected_++] = &application1_;
  455. expected_metadata_sequence_[num_expected_++] = &application2_;
  456. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  457. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  458. expected_metadata_sequence_[num_expected_++] = &unknown_;
  460. if(!decoder->test_respond())
  461. return false;
  463. /*
  464.  * ignore all
  465.  */
  467. printf("testing set_metadata_ignore_all()... ");
  468. if(!decoder->set_metadata_ignore_all()) {
  469. printf("FAILED, returned falsen");
  470. return false;
  471. }
  472. printf("OKn");
  474. num_expected_ = 0;
  476. if(!decoder->test_respond())
  477. return false;
  479. /*
  480.  * respond all, ignore VORBIS_COMMENT
  481.  */
  483. printf("testing set_metadata_respond_all()... ");
  484. if(!decoder->set_metadata_respond_all()) {
  485. printf("FAILED, returned falsen");
  486. return false;
  487. }
  488. printf("OKn");
  490. printf("testing set_metadata_ignore(VORBIS_COMMENT)... ");
  491. if(!decoder->set_metadata_ignore(FLAC__METADATA_TYPE_VORBIS_COMMENT)) {
  492. printf("FAILED, returned falsen");
  493. return false;
  494. }
  495. printf("OKn");
  497. num_expected_ = 0;
  498. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  499. expected_metadata_sequence_[num_expected_++] = &padding_;
  500. expected_metadata_sequence_[num_expected_++] = &seektable_;
  501. expected_metadata_sequence_[num_expected_++] = &application1_;
  502. expected_metadata_sequence_[num_expected_++] = &application2_;
  503. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  504. expected_metadata_sequence_[num_expected_++] = &unknown_;
  506. if(!decoder->test_respond())
  507. return false;
  509. /*
  510.  * respond all, ignore APPLICATION
  511.  */
  513. printf("testing set_metadata_respond_all()... ");
  514. if(!decoder->set_metadata_respond_all()) {
  515. printf("FAILED, returned falsen");
  516. return false;
  517. }
  518. printf("OKn");
  520. printf("testing set_metadata_ignore(APPLICATION)... ");
  521. if(!decoder->set_metadata_ignore(FLAC__METADATA_TYPE_APPLICATION)) {
  522. printf("FAILED, returned falsen");
  523. return false;
  524. }
  525. printf("OKn");
  527. num_expected_ = 0;
  528. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  529. expected_metadata_sequence_[num_expected_++] = &padding_;
  530. expected_metadata_sequence_[num_expected_++] = &seektable_;
  531. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  532. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  533. expected_metadata_sequence_[num_expected_++] = &unknown_;
  535. if(!decoder->test_respond())
  536. return false;
  538. /*
  539.  * respond all, ignore APPLICATION id of app#1
  540.  */
  542. printf("testing set_metadata_respond_all()... ");
  543. if(!decoder->set_metadata_respond_all()) {
  544. printf("FAILED, returned falsen");
  545. return false;
  546. }
  547. printf("OKn");
  549. printf("testing set_metadata_ignore_application(of app block #1)... ");
  550. if(!decoder->set_metadata_ignore_application(application1_.data.application.id)) {
  551. printf("FAILED, returned falsen");
  552. return false;
  553. }
  554. printf("OKn");
  556. num_expected_ = 0;
  557. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  558. expected_metadata_sequence_[num_expected_++] = &padding_;
  559. expected_metadata_sequence_[num_expected_++] = &seektable_;
  560. expected_metadata_sequence_[num_expected_++] = &application2_;
  561. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  562. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  563. expected_metadata_sequence_[num_expected_++] = &unknown_;
  565. if(!decoder->test_respond())
  566. return false;
  568. /*
  569.  * respond all, ignore APPLICATION id of app#1 & app#2
  570.  */
  572. printf("testing set_metadata_respond_all()... ");
  573. if(!decoder->set_metadata_respond_all()) {
  574. printf("FAILED, returned falsen");
  575. return false;
  576. }
  577. printf("OKn");
  579. printf("testing set_metadata_ignore_application(of app block #1)... ");
  580. if(!decoder->set_metadata_ignore_application(application1_.data.application.id)) {
  581. printf("FAILED, returned falsen");
  582. return false;
  583. }
  584. printf("OKn");
  586. printf("testing set_metadata_ignore_application(of app block #2)... ");
  587. if(!decoder->set_metadata_ignore_application(application2_.data.application.id)) {
  588. printf("FAILED, returned falsen");
  589. return false;
  590. }
  591. printf("OKn");
  593. num_expected_ = 0;
  594. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  595. expected_metadata_sequence_[num_expected_++] = &padding_;
  596. expected_metadata_sequence_[num_expected_++] = &seektable_;
  597. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  598. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  599. expected_metadata_sequence_[num_expected_++] = &unknown_;
  601. if(!decoder->test_respond())
  602. return false;
  604. /*
  605.  * ignore all, respond VORBIS_COMMENT
  606.  */
  608. printf("testing set_metadata_ignore_all()... ");
  609. if(!decoder->set_metadata_ignore_all()) {
  610. printf("FAILED, returned falsen");
  611. return false;
  612. }
  613. printf("OKn");
  615. printf("testing set_metadata_respond(VORBIS_COMMENT)... ");
  616. if(!decoder->set_metadata_respond(FLAC__METADATA_TYPE_VORBIS_COMMENT)) {
  617. printf("FAILED, returned falsen");
  618. return false;
  619. }
  620. printf("OKn");
  622. num_expected_ = 0;
  623. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  625. if(!decoder->test_respond())
  626. return false;
  628. /*
  629.  * ignore all, respond APPLICATION
  630.  */
  632. printf("testing set_metadata_ignore_all()... ");
  633. if(!decoder->set_metadata_ignore_all()) {
  634. printf("FAILED, returned falsen");
  635. return false;
  636. }
  637. printf("OKn");
  639. printf("testing set_metadata_respond(APPLICATION)... ");
  640. if(!decoder->set_metadata_respond(FLAC__METADATA_TYPE_APPLICATION)) {
  641. printf("FAILED, returned falsen");
  642. return false;
  643. }
  644. printf("OKn");
  646. num_expected_ = 0;
  647. expected_metadata_sequence_[num_expected_++] = &application1_;
  648. expected_metadata_sequence_[num_expected_++] = &application2_;
  650. if(!decoder->test_respond())
  651. return false;
  653. /*
  654.  * ignore all, respond APPLICATION id of app#1
  655.  */
  657. printf("testing set_metadata_ignore_all()... ");
  658. if(!decoder->set_metadata_ignore_all()) {
  659. printf("FAILED, returned falsen");
  660. return false;
  661. }
  662. printf("OKn");
  664. printf("testing set_metadata_respond_application(of app block #1)... ");
  665. if(!decoder->set_metadata_respond_application(application1_.data.application.id)) {
  666. printf("FAILED, returned falsen");
  667. return false;
  668. }
  669. printf("OKn");
  671. num_expected_ = 0;
  672. expected_metadata_sequence_[num_expected_++] = &application1_;
  674. if(!decoder->test_respond())
  675. return false;
  677. /*
  678.  * ignore all, respond APPLICATION id of app#1 & app#2
  679.  */
  681. printf("testing set_metadata_ignore_all()... ");
  682. if(!decoder->set_metadata_ignore_all()) {
  683. printf("FAILED, returned falsen");
  684. return false;
  685. }
  686. printf("OKn");
  688. printf("testing set_metadata_respond_application(of app block #1)... ");
  689. if(!decoder->set_metadata_respond_application(application1_.data.application.id)) {
  690. printf("FAILED, returned falsen");
  691. return false;
  692. }
  693. printf("OKn");
  695. printf("testing set_metadata_respond_application(of app block #2)... ");
  696. if(!decoder->set_metadata_respond_application(application2_.data.application.id)) {
  697. printf("FAILED, returned falsen");
  698. return false;
  699. }
  700. printf("OKn");
  702. num_expected_ = 0;
  703. expected_metadata_sequence_[num_expected_++] = &application1_;
  704. expected_metadata_sequence_[num_expected_++] = &application2_;
  706. if(!decoder->test_respond())
  707. return false;
  709. /*
  710.  * respond all, ignore APPLICATION, respond APPLICATION id of app#1
  711.  */
  713. printf("testing set_metadata_respond_all()... ");
  714. if(!decoder->set_metadata_respond_all()) {
  715. printf("FAILED, returned falsen");
  716. return false;
  717. }
  718. printf("OKn");
  720. printf("testing set_metadata_ignore(APPLICATION)... ");
  721. if(!decoder->set_metadata_ignore(FLAC__METADATA_TYPE_APPLICATION)) {
  722. printf("FAILED, returned falsen");
  723. return false;
  724. }
  725. printf("OKn");
  727. printf("testing set_metadata_respond_application(of app block #1)... ");
  728. if(!decoder->set_metadata_respond_application(application1_.data.application.id)) {
  729. printf("FAILED, returned falsen");
  730. return false;
  731. }
  732. printf("OKn");
  734. num_expected_ = 0;
  735. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  736. expected_metadata_sequence_[num_expected_++] = &padding_;
  737. expected_metadata_sequence_[num_expected_++] = &seektable_;
  738. expected_metadata_sequence_[num_expected_++] = &application1_;
  739. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  740. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  741. expected_metadata_sequence_[num_expected_++] = &unknown_;
  743. if(!decoder->test_respond())
  744. return false;
  746. /*
  747.  * ignore all, respond APPLICATION, ignore APPLICATION id of app#1
  748.  */
  750. printf("testing set_metadata_ignore_all()... ");
  751. if(!decoder->set_metadata_ignore_all()) {
  752. printf("FAILED, returned falsen");
  753. return false;
  754. }
  755. printf("OKn");
  757. printf("testing set_metadata_respond(APPLICATION)... ");
  758. if(!decoder->set_metadata_respond(FLAC__METADATA_TYPE_APPLICATION)) {
  759. printf("FAILED, returned falsen");
  760. return false;
  761. }
  762. printf("OKn");
  764. printf("testing set_metadata_ignore_application(of app block #1)... ");
  765. if(!decoder->set_metadata_ignore_application(application1_.data.application.id)) {
  766. printf("FAILED, returned falsen");
  767. return false;
  768. }
  769. printf("OKn");
  771. num_expected_ = 0;
  772. expected_metadata_sequence_[num_expected_++] = &application2_;
  774. if(!decoder->test_respond())
  775. return false;
  777. /* done, now leave the sequence the way we found it... */
  778. num_expected_ = 0;
  779. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  780. expected_metadata_sequence_[num_expected_++] = &padding_;
  781. expected_metadata_sequence_[num_expected_++] = &seektable_;
  782. expected_metadata_sequence_[num_expected_++] = &application1_;
  783. expected_metadata_sequence_[num_expected_++] = &application2_;
  784. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  785. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  786. expected_metadata_sequence_[num_expected_++] = &unknown_;
  788. ::fclose(decoder->file_);
  790. printf("freeing decoder instance... ");
  791. delete decoder;
  792. printf("OKn");
  794. printf("nPASSED!n");
  796. return true;
  797. }
  799. class SeekableStreamDecoder : public FLAC::Decoder::SeekableStream, public DecoderCommon {
  800. public:
  801. SeekableStreamDecoder(): FLAC::Decoder::SeekableStream(), DecoderCommon() { }
  802. ~SeekableStreamDecoder() { }
  804. // from FLAC::Decoder::SeekableStream
  805. ::FLAC__SeekableStreamDecoderReadStatus read_callback(FLAC__byte buffer[], unsigned *bytes);
  806. ::FLAC__SeekableStreamDecoderSeekStatus seek_callback(FLAC__uint64 absolute_byte_offset);
  807. ::FLAC__SeekableStreamDecoderTellStatus tell_callback(FLAC__uint64 *absolute_byte_offset);
  808. ::FLAC__SeekableStreamDecoderLengthStatus length_callback(FLAC__uint64 *stream_length);
  809. bool eof_callback();
  810. ::FLAC__StreamDecoderWriteStatus write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]);
  811. void metadata_callback(const ::FLAC__StreamMetadata *metadata);
  812. void error_callback(::FLAC__StreamDecoderErrorStatus status);
  814. bool die(const char *msg = 0) const;
  816. bool test_respond();
  817. };
  819. ::FLAC__SeekableStreamDecoderReadStatus SeekableStreamDecoder::read_callback(FLAC__byte buffer[], unsigned *bytes)
  820. {
  821. switch(common_read_callback_(buffer, bytes)) {
  822. case ::FLAC__STREAM_DECODER_READ_STATUS_CONTINUE:
  823. return ::FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK;
  824. case ::FLAC__STREAM_DECODER_READ_STATUS_ABORT:
  825. case ::FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM:
  826. return ::FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
  827. default:
  828. FLAC__ASSERT(0);
  829. return ::FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
  830. }
  831. }
  833. ::FLAC__SeekableStreamDecoderSeekStatus SeekableStreamDecoder::seek_callback(FLAC__uint64 absolute_byte_offset)
  834. {
  835. if(error_occurred_)
  836. return ::FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
  838. if(::fseek(file_, (long)absolute_byte_offset, SEEK_SET) < 0) {
  839. error_occurred_ = true;
  840. return ::FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
  841. }
  843. return ::FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK;
  844. }
  846. ::FLAC__SeekableStreamDecoderTellStatus SeekableStreamDecoder::tell_callback(FLAC__uint64 *absolute_byte_offset)
  847. {
  848. if(error_occurred_)
  849. return ::FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;
  851. long offset = ::ftell(file_);
  852. *absolute_byte_offset = (FLAC__uint64)offset;
  854. if(offset < 0) {
  855. error_occurred_ = true;
  856. return ::FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;
  857. }
  859. return ::FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK;
  860. }
  862. ::FLAC__SeekableStreamDecoderLengthStatus SeekableStreamDecoder::length_callback(FLAC__uint64 *stream_length)
  863. {
  864. if(error_occurred_)
  865. return ::FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR;
  867. *stream_length = (FLAC__uint64)flacfilesize_;
  868. return ::FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK;
  869. }
  871. bool SeekableStreamDecoder::eof_callback()
  872. {
  873. if(error_occurred_)
  874. return true;
  876. return (bool)feof(file_);
  877. }
  879. ::FLAC__StreamDecoderWriteStatus SeekableStreamDecoder::write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[])
  880. {
  881. (void)buffer;
  883. return common_write_callback_(frame);
  884. }
  886. void SeekableStreamDecoder::metadata_callback(const ::FLAC__StreamMetadata *metadata)
  887. {
  888. common_metadata_callback_(metadata);
  889. }
  891. void SeekableStreamDecoder::error_callback(::FLAC__StreamDecoderErrorStatus status)
  892. {
  893. common_error_callback_(status);
  894. }
  896. bool SeekableStreamDecoder::die(const char *msg) const
  897. {
  898. State state = get_state();
  900. if(msg)
  901. printf("FAILED, %s", msg);
  902. else
  903. printf("FAILED");
  905. printf(", state = %u (%s)n", (unsigned)((::FLAC__SeekableStreamDecoderState)state), state.as_cstring());
  906. if(state == ::FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR) {
  907. FLAC::Decoder::Stream::State state_ = get_stream_decoder_state();
  908. printf("      stream decoder state = %u (%s)n", (unsigned)((::FLAC__StreamDecoderState)state_), state_.as_cstring());
  909. }
  911. return false;
  912. }
  914. bool SeekableStreamDecoder::test_respond()
  915. {
  916. if(!set_md5_checking(true)) {
  917. printf("FAILED at set_md5_checking(), returned falsen");
  918. return false;
  919. }
  921. printf("testing init()... ");
  922. if(init() != ::FLAC__SEEKABLE_STREAM_DECODER_OK)
  923. return die();
  924. printf("OKn");
  926. current_metadata_number_ = 0;
  928. if(::fseek(file_, 0, SEEK_SET) < 0) {
  929. printf("FAILED rewinding input, errno = %dn", errno);
  930. return false;
  931. }
  933. printf("testing process_until_end_of_stream()... ");
  934. if(!process_until_end_of_stream()) {
  935. State state = get_state();
  936. printf("FAILED, returned false, state = %u (%s)n", (unsigned)((::FLAC__SeekableStreamDecoderState)state), state.as_cstring());
  937. return false;
  938. }
  939. printf("OKn");
  941. printf("testing finish()... ");
  942. finish();
  943. printf("OKn");
  945. return true;
  946. }
  948. static bool test_seekable_stream_decoder()
  949. {
  950. SeekableStreamDecoder *decoder;
  952. printf("n+++ libFLAC++ unit test: FLAC::Decoder::SeekableStreamnn");
  954. //
  955. // test new -> delete
  956. //
  957. printf("allocating decoder instance... ");
  958. decoder = new SeekableStreamDecoder();
  959. if(0 == decoder) {
  960. printf("FAILED, new returned NULLn");
  961. return false;
  962. }
  963. printf("OKn");
  965. printf("testing is_valid()... ");
  966. if(!decoder->is_valid()) {
  967. printf("FAILED, returned falsen");
  968. return false;
  969. }
  970. printf("OKn");
  972. printf("freeing decoder instance... ");
  973. delete decoder;
  974. printf("OKn");
  976. //
  977. // test new -> init -> delete
  978. //
  979. printf("allocating decoder instance... ");
  980. decoder = new SeekableStreamDecoder();
  981. if(0 == decoder) {
  982. printf("FAILED, new returned NULLn");
  983. return false;
  984. }
  985. printf("OKn");
  987. printf("testing is_valid()... ");
  988. if(!decoder->is_valid()) {
  989. printf("FAILED, returned falsen");
  990. return false;
  991. }
  992. printf("OKn");
  994. printf("testing init()... ");
  995. if(decoder->init() != ::FLAC__SEEKABLE_STREAM_DECODER_OK)
  996. return decoder->die();
  997. printf("OKn");
  999. printf("freeing decoder instance... ");
  1000. delete decoder;
  1001. printf("OKn");
  1003. //
  1004. // test normal usage
  1005. //
  1006. num_expected_ = 0;
  1007. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1009. printf("allocating decoder instance... ");
  1010. decoder = new SeekableStreamDecoder();
  1011. if(0 == decoder) {
  1012. printf("FAILED, new returned NULLn");
  1013. return false;
  1014. }
  1015. printf("OKn");
  1017. printf("testing is_valid()... ");
  1018. if(!decoder->is_valid()) {
  1019. printf("FAILED, returned falsen");
  1020. return false;
  1021. }
  1022. printf("OKn");
  1024. printf("testing set_md5_checking()... ");
  1025. if(!decoder->set_md5_checking(true)) {
  1026. printf("FAILED, returned falsen");
  1027. return false;
  1028. }
  1029. printf("OKn");
  1031. printf("testing init()... ");
  1032. if(decoder->init() != ::FLAC__SEEKABLE_STREAM_DECODER_OK)
  1033. return decoder->die();
  1034. printf("OKn");
  1036. printf("testing get_state()... ");
  1037. FLAC::Decoder::SeekableStream::State state = decoder->get_state();
  1038. printf("returned state = %u (%s)... OKn", (unsigned)((::FLAC__SeekableStreamDecoderState)state), state.as_cstring());
  1040. printf("testing get_stream_decoder_state()... ");
  1041. FLAC::Decoder::Stream::State state_ = decoder->get_stream_decoder_state();
  1042. printf("returned state = %u (%s)... OKn", (unsigned)((::FLAC__StreamDecoderState)state_), state_.as_cstring());
  1044. decoder->current_metadata_number_ = 0;
  1045. decoder->ignore_errors_ = false;
  1046. decoder->error_occurred_ = false;
  1048. printf("opening FLAC file... ");
  1049. decoder->file_ = ::fopen(flacfilename_, "rb");
  1050. if(0 == decoder->file_) {
  1051. printf("ERRORn");
  1052. return false;
  1053. }
  1054. printf("OKn");
  1056. printf("testing get_md5_checking()... ");
  1057. if(!decoder->get_md5_checking()) {
  1058. printf("FAILED, returned false, expected truen");
  1059. return false;
  1060. }
  1061. printf("OKn");
  1063. printf("testing process_until_end_of_metadata()... ");
  1064. if(!decoder->process_until_end_of_metadata())
  1065. return decoder->die("returned false");
  1066. printf("OKn");
  1068. printf("testing process_single()... ");
  1069. if(!decoder->process_single())
  1070. return decoder->die("returned false");
  1071. printf("OKn");
  1073. printf("testing skip_single_frame()... ");
  1074. if(!decoder->skip_single_frame())
  1075. return decoder->die("returned false");
  1076. printf("OKn");
  1078. printf("testing flush()... ");
  1079. if(!decoder->flush())
  1080. return decoder->die("returned false");
  1081. printf("OKn");
  1083. decoder->ignore_errors_ = true;
  1084. printf("testing process_single()... ");
  1085. if(!decoder->process_single())
  1086. return decoder->die("returned false");
  1087. printf("OKn");
  1088. decoder->ignore_errors_ = false;
  1090. printf("testing seek_absolute()... ");
  1091. if(!decoder->seek_absolute(0))
  1092. return decoder->die("returned false");
  1093. printf("OKn");
  1095. printf("testing process_until_end_of_stream()... ");
  1096. if(!decoder->process_until_end_of_stream())
  1097. return decoder->die("returned false");
  1098. printf("OKn");
  1100. printf("testing get_channels()... ");
  1101. {
  1102. unsigned channels = decoder->get_channels();
  1103. if(channels != streaminfo_.data.stream_info.channels) {
  1104. printf("FAILED, returned %u, expected %un", channels, streaminfo_.data.stream_info.channels);
  1105. return false;
  1106. }
  1107. }
  1108. printf("OKn");
  1110. printf("testing get_bits_per_sample()... ");
  1111. {
  1112. unsigned bits_per_sample = decoder->get_bits_per_sample();
  1113. if(bits_per_sample != streaminfo_.data.stream_info.bits_per_sample) {
  1114. printf("FAILED, returned %u, expected %un", bits_per_sample, streaminfo_.data.stream_info.bits_per_sample);
  1115. return false;
  1116. }
  1117. }
  1118. printf("OKn");
  1120. printf("testing get_sample_rate()... ");
  1121. {
  1122. unsigned sample_rate = decoder->get_sample_rate();
  1123. if(sample_rate != streaminfo_.data.stream_info.sample_rate) {
  1124. printf("FAILED, returned %u, expected %un", sample_rate, streaminfo_.data.stream_info.sample_rate);
  1125. return false;
  1126. }
  1127. }
  1128. printf("OKn");
  1130. printf("testing get_blocksize()... ");
  1131. {
  1132. unsigned blocksize = decoder->get_blocksize();
  1133. /* value could be anything since we're at the last block, so accept any answer */
  1134. printf("returned %u... OKn", blocksize);
  1135. }
  1137. printf("testing get_channel_assignment()... ");
  1138. {
  1139. ::FLAC__ChannelAssignment ca = decoder->get_channel_assignment();
  1140. printf("returned %u (%s)... OKn", (unsigned)ca, ::FLAC__ChannelAssignmentString[ca]);
  1141. }
  1143. printf("testing reset()... ");
  1144. if(!decoder->reset())
  1145. return decoder->die("returned false");
  1146. printf("OKn");
  1148. decoder->current_metadata_number_ = 0;
  1150. printf("rewinding input... ");
  1151. if(::fseek(decoder->file_, 0, SEEK_SET) < 0) {
  1152. printf("FAILED, errno = %dn", errno);
  1153. return false;
  1154. }
  1155. printf("OKn");
  1157. printf("testing process_until_end_of_stream()... ");
  1158. if(!decoder->process_until_end_of_stream())
  1159. return decoder->die("returned false");
  1160. printf("OKn");
  1162. printf("testing finish()... ");
  1163. decoder->finish();
  1164. printf("OKn");
  1166. /*
  1167.  * respond all
  1168.  */
  1170. printf("testing set_metadata_respond_all()... ");
  1171. if(!decoder->set_metadata_respond_all()) {
  1172. printf("FAILED, returned falsen");
  1173. return false;
  1174. }
  1175. printf("OKn");
  1177. num_expected_ = 0;
  1178. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1179. expected_metadata_sequence_[num_expected_++] = &padding_;
  1180. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1181. expected_metadata_sequence_[num_expected_++] = &application1_;
  1182. expected_metadata_sequence_[num_expected_++] = &application2_;
  1183. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1184. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1185. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1187. if(!decoder->test_respond())
  1188. return false;
  1190. /*
  1191.  * ignore all
  1192.  */
  1194. printf("testing set_metadata_ignore_all()... ");
  1195. if(!decoder->set_metadata_ignore_all()) {
  1196. printf("FAILED, returned falsen");
  1197. return false;
  1198. }
  1199. printf("OKn");
  1201. num_expected_ = 0;
  1203. if(!decoder->test_respond())
  1204. return false;
  1206. /*
  1207.  * respond all, ignore VORBIS_COMMENT
  1208.  */
  1210. printf("testing set_metadata_respond_all()... ");
  1211. if(!decoder->set_metadata_respond_all()) {
  1212. printf("FAILED, returned falsen");
  1213. return false;
  1214. }
  1215. printf("OKn");
  1217. printf("testing set_metadata_ignore(VORBIS_COMMENT)... ");
  1218. if(!decoder->set_metadata_ignore(FLAC__METADATA_TYPE_VORBIS_COMMENT)) {
  1219. printf("FAILED, returned falsen");
  1220. return false;
  1221. }
  1222. printf("OKn");
  1224. num_expected_ = 0;
  1225. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1226. expected_metadata_sequence_[num_expected_++] = &padding_;
  1227. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1228. expected_metadata_sequence_[num_expected_++] = &application1_;
  1229. expected_metadata_sequence_[num_expected_++] = &application2_;
  1230. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1231. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1233. if(!decoder->test_respond())
  1234. return false;
  1236. /*
  1237.  * respond all, ignore APPLICATION
  1238.  */
  1240. printf("testing set_metadata_respond_all()... ");
  1241. if(!decoder->set_metadata_respond_all()) {
  1242. printf("FAILED, returned falsen");
  1243. return false;
  1244. }
  1245. printf("OKn");
  1247. printf("testing set_metadata_ignore(APPLICATION)... ");
  1248. if(!decoder->set_metadata_ignore(FLAC__METADATA_TYPE_APPLICATION)) {
  1249. printf("FAILED, returned falsen");
  1250. return false;
  1251. }
  1252. printf("OKn");
  1254. num_expected_ = 0;
  1255. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1256. expected_metadata_sequence_[num_expected_++] = &padding_;
  1257. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1258. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1259. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1260. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1262. if(!decoder->test_respond())
  1263. return false;
  1265. /*
  1266.  * respond all, ignore APPLICATION id of app#1
  1267.  */
  1269. printf("testing set_metadata_respond_all()... ");
  1270. if(!decoder->set_metadata_respond_all()) {
  1271. printf("FAILED, returned falsen");
  1272. return false;
  1273. }
  1274. printf("OKn");
  1276. printf("testing set_metadata_ignore_application(of app block #1)... ");
  1277. if(!decoder->set_metadata_ignore_application(application1_.data.application.id)) {
  1278. printf("FAILED, returned falsen");
  1279. return false;
  1280. }
  1281. printf("OKn");
  1283. num_expected_ = 0;
  1284. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1285. expected_metadata_sequence_[num_expected_++] = &padding_;
  1286. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1287. expected_metadata_sequence_[num_expected_++] = &application2_;
  1288. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1289. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1290. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1292. if(!decoder->test_respond())
  1293. return false;
  1295. /*
  1296.  * respond all, ignore APPLICATION id of app#1 & app#2
  1297.  */
  1299. printf("testing set_metadata_respond_all()... ");
  1300. if(!decoder->set_metadata_respond_all()) {
  1301. printf("FAILED, returned falsen");
  1302. return false;
  1303. }
  1304. printf("OKn");
  1306. printf("testing set_metadata_ignore_application(of app block #1)... ");
  1307. if(!decoder->set_metadata_ignore_application(application1_.data.application.id)) {
  1308. printf("FAILED, returned falsen");
  1309. return false;
  1310. }
  1311. printf("OKn");
  1313. printf("testing set_metadata_ignore_application(of app block #2)... ");
  1314. if(!decoder->set_metadata_ignore_application(application2_.data.application.id)) {
  1315. printf("FAILED, returned falsen");
  1316. return false;
  1317. }
  1318. printf("OKn");
  1320. num_expected_ = 0;
  1321. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1322. expected_metadata_sequence_[num_expected_++] = &padding_;
  1323. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1324. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1325. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1326. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1328. if(!decoder->test_respond())
  1329. return false;
  1331. /*
  1332.  * ignore all, respond VORBIS_COMMENT
  1333.  */
  1335. printf("testing set_metadata_ignore_all()... ");
  1336. if(!decoder->set_metadata_ignore_all()) {
  1337. printf("FAILED, returned falsen");
  1338. return false;
  1339. }
  1340. printf("OKn");
  1342. printf("testing set_metadata_respond(VORBIS_COMMENT)... ");
  1343. if(!decoder->set_metadata_respond(FLAC__METADATA_TYPE_VORBIS_COMMENT)) {
  1344. printf("FAILED, returned falsen");
  1345. return false;
  1346. }
  1347. printf("OKn");
  1349. num_expected_ = 0;
  1350. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1352. if(!decoder->test_respond())
  1353. return false;
  1355. /*
  1356.  * ignore all, respond APPLICATION
  1357.  */
  1359. printf("testing set_metadata_ignore_all()... ");
  1360. if(!decoder->set_metadata_ignore_all()) {
  1361. printf("FAILED, returned falsen");
  1362. return false;
  1363. }
  1364. printf("OKn");
  1366. printf("testing set_metadata_respond(APPLICATION)... ");
  1367. if(!decoder->set_metadata_respond(FLAC__METADATA_TYPE_APPLICATION)) {
  1368. printf("FAILED, returned falsen");
  1369. return false;
  1370. }
  1371. printf("OKn");
  1373. num_expected_ = 0;
  1374. expected_metadata_sequence_[num_expected_++] = &application1_;
  1375. expected_metadata_sequence_[num_expected_++] = &application2_;
  1377. if(!decoder->test_respond())
  1378. return false;
  1380. /*
  1381.  * ignore all, respond APPLICATION id of app#1
  1382.  */
  1384. printf("testing set_metadata_ignore_all()... ");
  1385. if(!decoder->set_metadata_ignore_all()) {
  1386. printf("FAILED, returned falsen");
  1387. return false;
  1388. }
  1389. printf("OKn");
  1391. printf("testing set_metadata_respond_application(of app block #1)... ");
  1392. if(!decoder->set_metadata_respond_application(application1_.data.application.id)) {
  1393. printf("FAILED, returned falsen");
  1394. return false;
  1395. }
  1396. printf("OKn");
  1398. num_expected_ = 0;
  1399. expected_metadata_sequence_[num_expected_++] = &application1_;
  1401. if(!decoder->test_respond())
  1402. return false;
  1404. /*
  1405.  * ignore all, respond APPLICATION id of app#1 & app#2
  1406.  */
  1408. printf("testing set_metadata_ignore_all()... ");
  1409. if(!decoder->set_metadata_ignore_all()) {
  1410. printf("FAILED, returned falsen");
  1411. return false;
  1412. }
  1413. printf("OKn");
  1415. printf("testing set_metadata_respond_application(of app block #1)... ");
  1416. if(!decoder->set_metadata_respond_application(application1_.data.application.id)) {
  1417. printf("FAILED, returned falsen");
  1418. return false;
  1419. }
  1420. printf("OKn");
  1422. printf("testing set_metadata_respond_application(of app block #2)... ");
  1423. if(!decoder->set_metadata_respond_application(application2_.data.application.id)) {
  1424. printf("FAILED, returned falsen");
  1425. return false;
  1426. }
  1427. printf("OKn");
  1429. num_expected_ = 0;
  1430. expected_metadata_sequence_[num_expected_++] = &application1_;
  1431. expected_metadata_sequence_[num_expected_++] = &application2_;
  1433. if(!decoder->test_respond())
  1434. return false;
  1436. /*
  1437.  * respond all, ignore APPLICATION, respond APPLICATION id of app#1
  1438.  */
  1440. printf("testing set_metadata_respond_all()... ");
  1441. if(!decoder->set_metadata_respond_all()) {
  1442. printf("FAILED, returned falsen");
  1443. return false;
  1444. }
  1445. printf("OKn");
  1447. printf("testing set_metadata_ignore(APPLICATION)... ");
  1448. if(!decoder->set_metadata_ignore(FLAC__METADATA_TYPE_APPLICATION)) {
  1449. printf("FAILED, returned falsen");
  1450. return false;
  1451. }
  1452. printf("OKn");
  1454. printf("testing set_metadata_respond_application(of app block #1)... ");
  1455. if(!decoder->set_metadata_respond_application(application1_.data.application.id)) {
  1456. printf("FAILED, returned falsen");
  1457. return false;
  1458. }
  1459. printf("OKn");
  1461. num_expected_ = 0;
  1462. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1463. expected_metadata_sequence_[num_expected_++] = &padding_;
  1464. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1465. expected_metadata_sequence_[num_expected_++] = &application1_;
  1466. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1467. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1468. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1470. if(!decoder->test_respond())
  1471. return false;
  1473. /*
  1474.  * ignore all, respond APPLICATION, ignore APPLICATION id of app#1
  1475.  */
  1477. printf("testing set_metadata_ignore_all()... ");
  1478. if(!decoder->set_metadata_ignore_all()) {
  1479. printf("FAILED, returned falsen");
  1480. return false;
  1481. }
  1482. printf("OKn");
  1484. printf("testing set_metadata_respond(APPLICATION)... ");
  1485. if(!decoder->set_metadata_respond(FLAC__METADATA_TYPE_APPLICATION)) {
  1486. printf("FAILED, returned falsen");
  1487. return false;
  1488. }
  1489. printf("OKn");
  1491. printf("testing set_metadata_ignore_application(of app block #1)... ");
  1492. if(!decoder->set_metadata_ignore_application(application1_.data.application.id)) {
  1493. printf("FAILED, returned falsen");
  1494. return false;
  1495. }
  1496. printf("OKn");
  1498. num_expected_ = 0;
  1499. expected_metadata_sequence_[num_expected_++] = &application2_;
  1501. if(!decoder->test_respond())
  1502. return false;
  1504. /* done, now leave the sequence the way we found it... */
  1505. num_expected_ = 0;
  1506. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1507. expected_metadata_sequence_[num_expected_++] = &padding_;
  1508. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1509. expected_metadata_sequence_[num_expected_++] = &application1_;
  1510. expected_metadata_sequence_[num_expected_++] = &application2_;
  1511. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1512. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1513. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1515. ::fclose(decoder->file_);
  1517. printf("freeing decoder instance... ");
  1518. delete decoder;
  1519. printf("OKn");
  1521. printf("nPASSED!n");
  1523. return true;
  1524. }
  1526. class FileDecoder : public FLAC::Decoder::File, public DecoderCommon {
  1527. public:
  1528. FileDecoder(): FLAC::Decoder::File(), DecoderCommon() { }
  1529. ~FileDecoder() { }
  1531. // from FLAC::Decoder::File
  1532. ::FLAC__StreamDecoderWriteStatus write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]);
  1533. void metadata_callback(const ::FLAC__StreamMetadata *metadata);
  1534. void error_callback(::FLAC__StreamDecoderErrorStatus status);
  1536. bool die(const char *msg = 0) const;
  1538. bool test_respond();
  1539. };
  1541. ::FLAC__StreamDecoderWriteStatus FileDecoder::write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[])
  1542. {
  1543. (void)buffer;
  1544. return common_write_callback_(frame);
  1545. }
  1547. void FileDecoder::metadata_callback(const ::FLAC__StreamMetadata *metadata)
  1548. {
  1549. common_metadata_callback_(metadata);
  1550. }
  1552. void FileDecoder::error_callback(::FLAC__StreamDecoderErrorStatus status)
  1553. {
  1554. common_error_callback_(status);
  1555. }
  1557. bool FileDecoder::die(const char *msg) const
  1558. {
  1559. State state = get_state();
  1561. if(msg)
  1562. printf("FAILED, %s", msg);
  1563. else
  1564. printf("FAILED");
  1566. printf(", state = %u (%s)n", (unsigned)((::FLAC__FileDecoderState)state), state.as_cstring());
  1567. if(state == ::FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR) {
  1568. FLAC::Decoder::SeekableStream::State state_ = get_seekable_stream_decoder_state();
  1569. printf("      seekable stream decoder state = %u (%s)n", (unsigned)((::FLAC__SeekableStreamDecoderState)state_), state_.as_cstring());
  1570. if(state_ == ::FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR) {
  1571. FLAC::Decoder::Stream::State state__ = get_stream_decoder_state();
  1572. printf("      stream decoder state = %u (%s)n", (unsigned)((::FLAC__StreamDecoderState)state__), state__.as_cstring());
  1573. }
  1574. }
  1576. return false;
  1577. }
  1579. bool FileDecoder::test_respond()
  1580. {
  1581. if(!set_filename(flacfilename_)) {
  1582. printf("FAILED at set_filename(), returned falsen");
  1583. return false;
  1584. }
  1586. if(!set_md5_checking(true)) {
  1587. printf("FAILED at set_md5_checking(), returned falsen");
  1588. return false;
  1589. }
  1591. printf("testing init()... ");
  1592. if(init() != ::FLAC__FILE_DECODER_OK)
  1593. return die();
  1594. printf("OKn");
  1596. current_metadata_number_ = 0;
  1598. printf("testing process_until_end_of_file()... ");
  1599. if(!process_until_end_of_file()) {
  1600. State state = get_state();
  1601. printf("FAILED, returned false, state = %u (%s)n", (unsigned)((::FLAC__FileDecoderState)state), state.as_cstring());
  1602. return false;
  1603. }
  1604. printf("OKn");
  1606. printf("testing finish()... ");
  1607. finish();
  1608. printf("OKn");
  1610. return true;
  1611. }
  1613. static bool test_file_decoder()
  1614. {
  1615. FileDecoder *decoder;
  1617. printf("n+++ libFLAC++ unit test: FLAC::Decoder::Filenn");
  1619. //
  1620. // test new -> delete
  1621. //
  1622. printf("allocating decoder instance... ");
  1623. decoder = new FileDecoder();
  1624. if(0 == decoder) {
  1625. printf("FAILED, new returned NULLn");
  1626. return false;
  1627. }
  1628. printf("OKn");
  1630. printf("testing is_valid()... ");
  1631. if(!decoder->is_valid()) {
  1632. printf("FAILED, returned falsen");
  1633. return false;
  1634. }
  1635. printf("OKn");
  1637. printf("freeing decoder instance... ");
  1638. delete decoder;
  1639. printf("OKn");
  1641. //
  1642. // test new -> init -> delete
  1643. //
  1644. printf("allocating decoder instance... ");
  1645. decoder = new FileDecoder();
  1646. if(0 == decoder) {
  1647. printf("FAILED, new returned NULLn");
  1648. return false;
  1649. }
  1650. printf("OKn");
  1652. printf("testing is_valid()... ");
  1653. if(!decoder->is_valid()) {
  1654. printf("FAILED, returned falsen");
  1655. return false;
  1656. }
  1657. printf("OKn");
  1659. printf("testing init()... ");
  1660. if(decoder->init() != ::FLAC__FILE_DECODER_OK)
  1661. return decoder->die();
  1662. printf("OKn");
  1664. printf("freeing decoder instance... ");
  1665. delete decoder;
  1666. printf("OKn");
  1668. //
  1669. // test normal usage
  1670. //
  1671. num_expected_ = 0;
  1672. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1674. printf("allocating decoder instance... ");
  1675. decoder = new FileDecoder();
  1676. if(0 == decoder) {
  1677. printf("FAILED, new returned NULLn");
  1678. return false;
  1679. }
  1680. printf("OKn");
  1682. printf("testing is_valid()... ");
  1683. if(!decoder->is_valid()) {
  1684. printf("FAILED, returned falsen");
  1685. return false;
  1686. }
  1687. printf("OKn");
  1689. printf("testing set_filename()... ");
  1690. if(!decoder->set_filename(flacfilename_)) {
  1691. printf("FAILED, returned falsen");
  1692. return false;
  1693. }
  1694. printf("OKn");
  1696. printf("testing set_md5_checking()... ");
  1697. if(!decoder->set_md5_checking(true)) {
  1698. printf("FAILED, returned falsen");
  1699. return false;
  1700. }
  1701. printf("OKn");
  1703. printf("testing init()... ");
  1704. if(decoder->init() != ::FLAC__FILE_DECODER_OK)
  1705. return decoder->die();
  1706. printf("OKn");
  1708. printf("testing get_state()... ");
  1709. FLAC::Decoder::File::State state = decoder->get_state();
  1710. printf("returned state = %u (%s)... OKn", (unsigned)((::FLAC__FileDecoderState)state), state.as_cstring());
  1712. printf("testing get_seekable_stream_decoder_state()... ");
  1713. FLAC::Decoder::SeekableStream::State state_ = decoder->get_seekable_stream_decoder_state();
  1714. printf("returned state = %u (%s)... OKn", (unsigned)((::FLAC__SeekableStreamDecoderState)state_), state_.as_cstring());
  1716. printf("testing get_stream_decoder_state()... ");
  1717. FLAC::Decoder::Stream::State state__ = decoder->get_stream_decoder_state();
  1718. printf("returned state = %u (%s)... OKn", (unsigned)((::FLAC__StreamDecoderState)state__), state__.as_cstring());
  1720. decoder->current_metadata_number_ = 0;
  1721. decoder->ignore_errors_ = false;
  1722. decoder->error_occurred_ = false;
  1724. printf("testing get_md5_checking()... ");
  1725. if(!decoder->get_md5_checking()) {
  1726. printf("FAILED, returned false, expected truen");
  1727. return false;
  1728. }
  1729. printf("OKn");
  1731. printf("testing process_until_end_of_metadata()... ");
  1732. if(!decoder->process_until_end_of_metadata())
  1733. return decoder->die("returned false");
  1734. printf("OKn");
  1736. printf("testing process_single()... ");
  1737. if(!decoder->process_single())
  1738. return decoder->die("returned false");
  1739. printf("OKn");
  1741. printf("testing skip_single_frame()... ");
  1742. if(!decoder->skip_single_frame())
  1743. return decoder->die("returned false");
  1744. printf("OKn");
  1746. printf("testing seek_absolute()... ");
  1747. if(!decoder->seek_absolute(0))
  1748. return decoder->die("returned false");
  1749. printf("OKn");
  1751. printf("testing process_until_end_of_file()... ");
  1752. if(!decoder->process_until_end_of_file())
  1753. return decoder->die("returned false");
  1754. printf("OKn");
  1756. printf("testing get_channels()... ");
  1757. {
  1758. unsigned channels = decoder->get_channels();
  1759. if(channels != streaminfo_.data.stream_info.channels) {
  1760. printf("FAILED, returned %u, expected %un", channels, streaminfo_.data.stream_info.channels);
  1761. return false;
  1762. }
  1763. }
  1764. printf("OKn");
  1766. printf("testing get_bits_per_sample()... ");
  1767. {
  1768. unsigned bits_per_sample = decoder->get_bits_per_sample();
  1769. if(bits_per_sample != streaminfo_.data.stream_info.bits_per_sample) {
  1770. printf("FAILED, returned %u, expected %un", bits_per_sample, streaminfo_.data.stream_info.bits_per_sample);
  1771. return false;
  1772. }
  1773. }
  1774. printf("OKn");
  1776. printf("testing get_sample_rate()... ");
  1777. {
  1778. unsigned sample_rate = decoder->get_sample_rate();
  1779. if(sample_rate != streaminfo_.data.stream_info.sample_rate) {
  1780. printf("FAILED, returned %u, expected %un", sample_rate, streaminfo_.data.stream_info.sample_rate);
  1781. return false;
  1782. }
  1783. }
  1784. printf("OKn");
  1786. printf("testing get_blocksize()... ");
  1787. {
  1788. unsigned blocksize = decoder->get_blocksize();
  1789. /* value could be anything since we're at the last block, so accept any answer */
  1790. printf("returned %u... OKn", blocksize);
  1791. }
  1793. printf("testing get_channel_assignment()... ");
  1794. {
  1795. ::FLAC__ChannelAssignment ca = decoder->get_channel_assignment();
  1796. printf("returned %u (%s)... OKn", (unsigned)ca, ::FLAC__ChannelAssignmentString[ca]);
  1797. }
  1799. printf("testing finish()... ");
  1800. decoder->finish();
  1801. printf("OKn");
  1803. /*
  1804.  * respond all
  1805.  */
  1807. printf("testing set_metadata_respond_all()... ");
  1808. if(!decoder->set_metadata_respond_all()) {
  1809. printf("FAILED, returned falsen");
  1810. return false;
  1811. }
  1812. printf("OKn");
  1814. num_expected_ = 0;
  1815. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1816. expected_metadata_sequence_[num_expected_++] = &padding_;
  1817. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1818. expected_metadata_sequence_[num_expected_++] = &application1_;
  1819. expected_metadata_sequence_[num_expected_++] = &application2_;
  1820. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1821. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1822. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1824. if(!decoder->test_respond())
  1825. return false;
  1827. /*
  1828.  * ignore all
  1829.  */
  1831. printf("testing set_metadata_ignore_all()... ");
  1832. if(!decoder->set_metadata_ignore_all()) {
  1833. printf("FAILED, returned falsen");
  1834. return false;
  1835. }
  1836. printf("OKn");
  1838. num_expected_ = 0;
  1840. if(!decoder->test_respond())
  1841. return false;
  1843. /*
  1844.  * respond all, ignore VORBIS_COMMENT
  1845.  */
  1847. printf("testing set_metadata_respond_all()... ");
  1848. if(!decoder->set_metadata_respond_all()) {
  1849. printf("FAILED, returned falsen");
  1850. return false;
  1851. }
  1852. printf("OKn");
  1854. printf("testing set_metadata_ignore(VORBIS_COMMENT)... ");
  1855. if(!decoder->set_metadata_ignore(FLAC__METADATA_TYPE_VORBIS_COMMENT)) {
  1856. printf("FAILED, returned falsen");
  1857. return false;
  1858. }
  1859. printf("OKn");
  1861. num_expected_ = 0;
  1862. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1863. expected_metadata_sequence_[num_expected_++] = &padding_;
  1864. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1865. expected_metadata_sequence_[num_expected_++] = &application1_;
  1866. expected_metadata_sequence_[num_expected_++] = &application2_;
  1867. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1868. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1870. if(!decoder->test_respond())
  1871. return false;
  1873. /*
  1874.  * respond all, ignore APPLICATION
  1875.  */
  1877. printf("testing set_metadata_respond_all()... ");
  1878. if(!decoder->set_metadata_respond_all()) {
  1879. printf("FAILED, returned falsen");
  1880. return false;
  1881. }
  1882. printf("OKn");
  1884. printf("testing set_metadata_ignore(APPLICATION)... ");
  1885. if(!decoder->set_metadata_ignore(FLAC__METADATA_TYPE_APPLICATION)) {
  1886. printf("FAILED, returned falsen");
  1887. return false;
  1888. }
  1889. printf("OKn");
  1891. num_expected_ = 0;
  1892. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1893. expected_metadata_sequence_[num_expected_++] = &padding_;
  1894. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1895. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1896. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1897. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1899. if(!decoder->test_respond())
  1900. return false;
  1902. /*
  1903.  * respond all, ignore APPLICATION id of app#1
  1904.  */
  1906. printf("testing set_metadata_respond_all()... ");
  1907. if(!decoder->set_metadata_respond_all()) {
  1908. printf("FAILED, returned falsen");
  1909. return false;
  1910. }
  1911. printf("OKn");
  1913. printf("testing set_metadata_ignore_application(of app block #1)... ");
  1914. if(!decoder->set_metadata_ignore_application(application1_.data.application.id)) {
  1915. printf("FAILED, returned falsen");
  1916. return false;
  1917. }
  1918. printf("OKn");
  1920. num_expected_ = 0;
  1921. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1922. expected_metadata_sequence_[num_expected_++] = &padding_;
  1923. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1924. expected_metadata_sequence_[num_expected_++] = &application2_;
  1925. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1926. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1927. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1929. if(!decoder->test_respond())
  1930. return false;
  1932. /*
  1933.  * respond all, ignore APPLICATION id of app#1 & app#2
  1934.  */
  1936. printf("testing set_metadata_respond_all()... ");
  1937. if(!decoder->set_metadata_respond_all()) {
  1938. printf("FAILED, returned falsen");
  1939. return false;
  1940. }
  1941. printf("OKn");
  1943. printf("testing set_metadata_ignore_application(of app block #1)... ");
  1944. if(!decoder->set_metadata_ignore_application(application1_.data.application.id)) {
  1945. printf("FAILED, returned falsen");
  1946. return false;
  1947. }
  1948. printf("OKn");
  1950. printf("testing set_metadata_ignore_application(of app block #2)... ");
  1951. if(!decoder->set_metadata_ignore_application(application2_.data.application.id)) {
  1952. printf("FAILED, returned falsen");
  1953. return false;
  1954. }
  1955. printf("OKn");
  1957. num_expected_ = 0;
  1958. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  1959. expected_metadata_sequence_[num_expected_++] = &padding_;
  1960. expected_metadata_sequence_[num_expected_++] = &seektable_;
  1961. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1962. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  1963. expected_metadata_sequence_[num_expected_++] = &unknown_;
  1965. if(!decoder->test_respond())
  1966. return false;
  1968. /*
  1969.  * ignore all, respond VORBIS_COMMENT
  1970.  */
  1972. printf("testing set_metadata_ignore_all()... ");
  1973. if(!decoder->set_metadata_ignore_all()) {
  1974. printf("FAILED, returned falsen");
  1975. return false;
  1976. }
  1977. printf("OKn");
  1979. printf("testing set_metadata_respond(VORBIS_COMMENT)... ");
  1980. if(!decoder->set_metadata_respond(FLAC__METADATA_TYPE_VORBIS_COMMENT)) {
  1981. printf("FAILED, returned falsen");
  1982. return false;
  1983. }
  1984. printf("OKn");
  1986. num_expected_ = 0;
  1987. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  1989. if(!decoder->test_respond())
  1990. return false;
  1992. /*
  1993.  * ignore all, respond APPLICATION
  1994.  */
  1996. printf("testing set_metadata_ignore_all()... ");
  1997. if(!decoder->set_metadata_ignore_all()) {
  1998. printf("FAILED, returned falsen");
  1999. return false;
  2000. }
  2001. printf("OKn");
  2003. printf("testing set_metadata_respond(APPLICATION)... ");
  2004. if(!decoder->set_metadata_respond(FLAC__METADATA_TYPE_APPLICATION)) {
  2005. printf("FAILED, returned falsen");
  2006. return false;
  2007. }
  2008. printf("OKn");
  2010. num_expected_ = 0;
  2011. expected_metadata_sequence_[num_expected_++] = &application1_;
  2012. expected_metadata_sequence_[num_expected_++] = &application2_;
  2014. if(!decoder->test_respond())
  2015. return false;
  2017. /*
  2018.  * ignore all, respond APPLICATION id of app#1
  2019.  */
  2021. printf("testing set_metadata_ignore_all()... ");
  2022. if(!decoder->set_metadata_ignore_all()) {
  2023. printf("FAILED, returned falsen");
  2024. return false;
  2025. }
  2026. printf("OKn");
  2028. printf("testing set_metadata_respond_application(of app block #1)... ");
  2029. if(!decoder->set_metadata_respond_application(application1_.data.application.id)) {
  2030. printf("FAILED, returned falsen");
  2031. return false;
  2032. }
  2033. printf("OKn");
  2035. num_expected_ = 0;
  2036. expected_metadata_sequence_[num_expected_++] = &application1_;
  2038. if(!decoder->test_respond())
  2039. return false;
  2041. /*
  2042.  * ignore all, respond APPLICATION id of app#1 & app#2
  2043.  */
  2045. printf("testing set_metadata_ignore_all()... ");
  2046. if(!decoder->set_metadata_ignore_all()) {
  2047. printf("FAILED, returned falsen");
  2048. return false;
  2049. }
  2050. printf("OKn");
  2052. printf("testing set_metadata_respond_application(of app block #1)... ");
  2053. if(!decoder->set_metadata_respond_application(application1_.data.application.id)) {
  2054. printf("FAILED, returned falsen");
  2055. return false;
  2056. }
  2057. printf("OKn");
  2059. printf("testing set_metadata_respond_application(of app block #2)... ");
  2060. if(!decoder->set_metadata_respond_application(application2_.data.application.id)) {
  2061. printf("FAILED, returned falsen");
  2062. return false;
  2063. }
  2064. printf("OKn");
  2066. num_expected_ = 0;
  2067. expected_metadata_sequence_[num_expected_++] = &application1_;
  2068. expected_metadata_sequence_[num_expected_++] = &application2_;
  2070. if(!decoder->test_respond())
  2071. return false;
  2073. /*
  2074.  * respond all, ignore APPLICATION, respond APPLICATION id of app#1
  2075.  */
  2077. printf("testing set_metadata_respond_all()... ");
  2078. if(!decoder->set_metadata_respond_all()) {
  2079. printf("FAILED, returned falsen");
  2080. return false;
  2081. }
  2082. printf("OKn");
  2084. printf("testing set_metadata_ignore(APPLICATION)... ");
  2085. if(!decoder->set_metadata_ignore(FLAC__METADATA_TYPE_APPLICATION)) {
  2086. printf("FAILED, returned falsen");
  2087. return false;
  2088. }
  2089. printf("OKn");
  2091. printf("testing set_metadata_respond_application(of app block #1)... ");
  2092. if(!decoder->set_metadata_respond_application(application1_.data.application.id)) {
  2093. printf("FAILED, returned falsen");
  2094. return false;
  2095. }
  2096. printf("OKn");
  2098. num_expected_ = 0;
  2099. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  2100. expected_metadata_sequence_[num_expected_++] = &padding_;
  2101. expected_metadata_sequence_[num_expected_++] = &seektable_;
  2102. expected_metadata_sequence_[num_expected_++] = &application1_;
  2103. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  2104. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  2105. expected_metadata_sequence_[num_expected_++] = &unknown_;
  2107. if(!decoder->test_respond())
  2108. return false;
  2110. /*
  2111.  * ignore all, respond APPLICATION, ignore APPLICATION id of app#1
  2112.  */
  2114. printf("testing set_metadata_ignore_all()... ");
  2115. if(!decoder->set_metadata_ignore_all()) {
  2116. printf("FAILED, returned falsen");
  2117. return false;
  2118. }
  2119. printf("OKn");
  2121. printf("testing set_metadata_respond(APPLICATION)... ");
  2122. if(!decoder->set_metadata_respond(FLAC__METADATA_TYPE_APPLICATION)) {
  2123. printf("FAILED, returned falsen");
  2124. return false;
  2125. }
  2126. printf("OKn");
  2128. printf("testing set_metadata_ignore_application(of app block #1)... ");
  2129. if(!decoder->set_metadata_ignore_application(application1_.data.application.id)) {
  2130. printf("FAILED, returned falsen");
  2131. return false;
  2132. }
  2133. printf("OKn");
  2135. num_expected_ = 0;
  2136. expected_metadata_sequence_[num_expected_++] = &application2_;
  2138. if(!decoder->test_respond())
  2139. return false;
  2141. /* done, now leave the sequence the way we found it... */
  2142. num_expected_ = 0;
  2143. expected_metadata_sequence_[num_expected_++] = &streaminfo_;
  2144. expected_metadata_sequence_[num_expected_++] = &padding_;
  2145. expected_metadata_sequence_[num_expected_++] = &seektable_;
  2146. expected_metadata_sequence_[num_expected_++] = &application1_;
  2147. expected_metadata_sequence_[num_expected_++] = &application2_;
  2148. expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
  2149. expected_metadata_sequence_[num_expected_++] = &cuesheet_;
  2150. expected_metadata_sequence_[num_expected_++] = &unknown_;
  2152. printf("freeing decoder instance... ");
  2153. delete decoder;
  2154. printf("OKn");
  2156. printf("nPASSED!n");
  2158. return true;
  2159. }
  2161. bool test_decoders()
  2162. {
  2163. init_metadata_blocks_();
  2165. if(!generate_file_())
  2166. return false;
  2168. if(!test_stream_decoder())
  2169. return false;
  2171. if(!test_seekable_stream_decoder())
  2172. return false;
  2174. if(!test_file_decoder())
  2175. return false;
  2177. (void) grabbag__file_remove_file(flacfilename_);
  2179. free_metadata_blocks_();
  2181. return true;
  2182. }