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

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

Windows CE

开发平台：

C/C++

file_decoder.c：源码内容
  1. /* libFLAC - Free Lossless Audio Codec library
  2.  * Copyright (C) 2000,2001,2002,2003,2004,2005  Josh Coalson
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions
  6.  * are met:
  7.  *
  8.  * - Redistributions of source code must retain the above copyright
  9.  * notice, this list of conditions and the following disclaimer.
  10.  *
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  * notice, this list of conditions and the following disclaimer in the
  13.  * documentation and/or other materials provided with the distribution.
  14.  *
  15.  * - Neither the name of the Xiph.org Foundation nor the names of its
  16.  * contributors may be used to endorse or promote products derived from
  17.  * this software without specific prior written permission.
  18.  *
  19.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20.  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22.  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
  23.  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24.  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25.  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26.  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27.  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28.  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29.  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30.  */
  32. #include <stdio.h>
  33. #include <stdlib.h> /* for malloc() */
  34. #include <string.h> /* for strcmp() */
  35. #include "FLAC/assert.h"
  36. #include "protected/file_decoder.h"
  37. #include "protected/seekable_stream_decoder.h"
  39. /***********************************************************************
  40.  *
  41.  * Private class method prototypes
  42.  *
  43.  ***********************************************************************/
  45. static void set_defaults_(FLAC__FileDecoder *decoder);
  46. static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
  47. static void metadata_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
  48. static void error_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
  50. /***********************************************************************
  51.  *
  52.  * Private class data
  53.  *
  54.  ***********************************************************************/
  56. typedef struct FLAC__FileDecoderPrivate {
  57. FLAC__FileDecoderWriteCallback write_callback;
  58. FLAC__FileDecoderMetadataCallback metadata_callback;
  59. FLAC__FileDecoderErrorCallback error_callback;
  60. void *client_data;
  61. FILE *file;
  62. char *filename; /* == NULL if stdin */
  63. FLAC__SeekableStreamDecoder *seekable_stream_decoder;
  64. } FLAC__FileDecoderPrivate;
  66. /***********************************************************************
  67.  *
  68.  * Public static class data
  69.  *
  70.  ***********************************************************************/
  72. FLAC_API const char * const FLAC__FileDecoderStateString[] = {
  73. "FLAC__FILE_DECODER_OK",
  74. "FLAC__FILE_DECODER_END_OF_FILE",
  75. "FLAC__FILE_DECODER_ERROR_OPENING_FILE",
  76. "FLAC__FILE_DECODER_MEMORY_ALLOCATION_ERROR",
  77. "FLAC__FILE_DECODER_SEEK_ERROR",
  78. "FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR",
  79. "FLAC__FILE_DECODER_ALREADY_INITIALIZED",
  80. "FLAC__FILE_DECODER_INVALID_CALLBACK",
  81. "FLAC__FILE_DECODER_UNINITIALIZED"
  82. };
  84. /***********************************************************************
  85.  *
  86.  * Class constructor/destructor
  87.  *
  88.  ***********************************************************************/
  90. FLAC_API FLAC__FileDecoder *FLAC__file_decoder_new()
  91. {
  92. FLAC__FileDecoder *decoder;
  94. FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
  96. decoder = (FLAC__FileDecoder*)calloc(1, sizeof(FLAC__FileDecoder));
  97. if(decoder == 0) {
  98. return 0;
  99. }
  101. decoder->protected_ = (FLAC__FileDecoderProtected*)calloc(1, sizeof(FLAC__FileDecoderProtected));
  102. if(decoder->protected_ == 0) {
  103. free(decoder);
  104. return 0;
  105. }
  107. decoder->private_ = (FLAC__FileDecoderPrivate*)calloc(1, sizeof(FLAC__FileDecoderPrivate));
  108. if(decoder->private_ == 0) {
  109. free(decoder->protected_);
  110. free(decoder);
  111. return 0;
  112. }
  114. decoder->private_->seekable_stream_decoder = FLAC__seekable_stream_decoder_new();
  115. if(0 == decoder->private_->seekable_stream_decoder) {
  116. free(decoder->private_);
  117. free(decoder->protected_);
  118. free(decoder);
  119. return 0;
  120. }
  122. decoder->private_->file = 0;
  124. set_defaults_(decoder);
  126. decoder->protected_->state = FLAC__FILE_DECODER_UNINITIALIZED;
  128. return decoder;
  129. }
  131. FLAC_API void FLAC__file_decoder_delete(FLAC__FileDecoder *decoder)
  132. {
  133. FLAC__ASSERT(0 != decoder);
  134. FLAC__ASSERT(0 != decoder->protected_);
  135. FLAC__ASSERT(0 != decoder->private_);
  136. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  138. (void)FLAC__file_decoder_finish(decoder);
  140. FLAC__seekable_stream_decoder_delete(decoder->private_->seekable_stream_decoder);
  142. free(decoder->private_);
  143. free(decoder->protected_);
  144. free(decoder);
  145. }
  147. /***********************************************************************
  148.  *
  149.  * Public class methods
  150.  *
  151.  ***********************************************************************/
  153. FLAC_API FLAC__FileDecoderState FLAC__file_decoder_init(FLAC__FileDecoder *decoder)
  154. {
  155. FLAC__ASSERT(0 != decoder);
  157. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  158. return decoder->protected_->state = FLAC__FILE_DECODER_ALREADY_INITIALIZED;
  160. if(0 == decoder->private_->write_callback || 0 == decoder->private_->metadata_callback || 0 == decoder->private_->error_callback)
  161. return decoder->protected_->state = FLAC__FILE_DECODER_INVALID_CALLBACK;
  163.   decoder->private_->file = fopen(decoder->private_->filename, "rb");
  165. if(decoder->private_->file == 0)
  166. return decoder->protected_->state = FLAC__FILE_DECODER_ERROR_OPENING_FILE;
  168. FLAC__seekable_stream_decoder_set_read_callback(decoder->private_->seekable_stream_decoder, read_callback_);
  169. FLAC__seekable_stream_decoder_set_seek_callback(decoder->private_->seekable_stream_decoder, seek_callback_);
  170. FLAC__seekable_stream_decoder_set_tell_callback(decoder->private_->seekable_stream_decoder, tell_callback_);
  171. FLAC__seekable_stream_decoder_set_length_callback(decoder->private_->seekable_stream_decoder, length_callback_);
  172. FLAC__seekable_stream_decoder_set_eof_callback(decoder->private_->seekable_stream_decoder, eof_callback_);
  173. FLAC__seekable_stream_decoder_set_write_callback(decoder->private_->seekable_stream_decoder, write_callback_);
  174. FLAC__seekable_stream_decoder_set_metadata_callback(decoder->private_->seekable_stream_decoder, metadata_callback_);
  175. FLAC__seekable_stream_decoder_set_error_callback(decoder->private_->seekable_stream_decoder, error_callback_);
  176. FLAC__seekable_stream_decoder_set_client_data(decoder->private_->seekable_stream_decoder, decoder);
  178. if(FLAC__seekable_stream_decoder_init(decoder->private_->seekable_stream_decoder) != FLAC__SEEKABLE_STREAM_DECODER_OK)
  179. return decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
  181. return decoder->protected_->state = FLAC__FILE_DECODER_OK;
  182. }
  184. FLAC_API FLAC__bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder)
  185. {
  186. FLAC__ASSERT(0 != decoder);
  188. if(decoder->protected_->state == FLAC__FILE_DECODER_UNINITIALIZED)
  189. return true;
  191. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  193. if(0 != decoder->private_->file && decoder->private_->file != stdin) {
  194. fclose(decoder->private_->file);
  195. decoder->private_->file = 0;
  196. }
  198. if(0 != decoder->private_->filename) {
  199. free(decoder->private_->filename);
  200. decoder->private_->filename = 0;
  201. }
  203. set_defaults_(decoder);
  205. decoder->protected_->state = FLAC__FILE_DECODER_UNINITIALIZED;
  207. return FLAC__seekable_stream_decoder_finish(decoder->private_->seekable_stream_decoder);
  208. }
  210. FLAC_API FLAC__bool FLAC__file_decoder_set_md5_checking(FLAC__FileDecoder *decoder, FLAC__bool value)
  211. {
  212. FLAC__ASSERT(0 != decoder);
  213. FLAC__ASSERT(0 != decoder->private_);
  214. FLAC__ASSERT(0 != decoder->protected_);
  215. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  216. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  217. return false;
  218. return FLAC__seekable_stream_decoder_set_md5_checking(decoder->private_->seekable_stream_decoder, value);
  219. }
  221. FLAC_API FLAC__bool FLAC__file_decoder_set_filename(FLAC__FileDecoder *decoder, const char *value)
  222. {
  223. FLAC__ASSERT(0 != decoder);
  224. FLAC__ASSERT(0 != decoder->private_);
  225. FLAC__ASSERT(0 != decoder->protected_);
  226. FLAC__ASSERT(0 != value);
  227. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  228. return false;
  229. if(0 != decoder->private_->filename) {
  230. free(decoder->private_->filename);
  231. decoder->private_->filename = 0;
  232. }
  233. if(0 != strcmp(value, "-")) {
  234. if(0 == (decoder->private_->filename = (char*)malloc(strlen(value)+1))) {
  235. decoder->protected_->state = FLAC__FILE_DECODER_MEMORY_ALLOCATION_ERROR;
  236. return false;
  237. }
  238. strcpy(decoder->private_->filename, value);
  239. }
  240. return true;
  241. }
  243. FLAC_API FLAC__bool FLAC__file_decoder_set_write_callback(FLAC__FileDecoder *decoder, FLAC__FileDecoderWriteCallback value)
  244. {
  245. FLAC__ASSERT(0 != decoder);
  246. FLAC__ASSERT(0 != decoder->private_);
  247. FLAC__ASSERT(0 != decoder->protected_);
  248. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  249. return false;
  250. decoder->private_->write_callback = value;
  251. return true;
  252. }
  254. FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_callback(FLAC__FileDecoder *decoder, FLAC__FileDecoderMetadataCallback value)
  255. {
  256. FLAC__ASSERT(0 != decoder);
  257. FLAC__ASSERT(0 != decoder->private_);
  258. FLAC__ASSERT(0 != decoder->protected_);
  259. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  260. return false;
  261. decoder->private_->metadata_callback = value;
  262. return true;
  263. }
  265. FLAC_API FLAC__bool FLAC__file_decoder_set_error_callback(FLAC__FileDecoder *decoder, FLAC__FileDecoderErrorCallback value)
  266. {
  267. FLAC__ASSERT(0 != decoder);
  268. FLAC__ASSERT(0 != decoder->private_);
  269. FLAC__ASSERT(0 != decoder->protected_);
  270. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  271. return false;
  272. decoder->private_->error_callback = value;
  273. return true;
  274. }
  276. FLAC_API FLAC__bool FLAC__file_decoder_set_client_data(FLAC__FileDecoder *decoder, void *value)
  277. {
  278. FLAC__ASSERT(0 != decoder);
  279. FLAC__ASSERT(0 != decoder->private_);
  280. FLAC__ASSERT(0 != decoder->protected_);
  281. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  282. return false;
  283. decoder->private_->client_data = value;
  284. return true;
  285. }
  287. FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_respond(FLAC__FileDecoder *decoder, FLAC__MetadataType type)
  288. {
  289. FLAC__ASSERT(0 != decoder);
  290. FLAC__ASSERT(0 != decoder->private_);
  291. FLAC__ASSERT(0 != decoder->protected_);
  292. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  293. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  294. return false;
  295. return FLAC__seekable_stream_decoder_set_metadata_respond(decoder->private_->seekable_stream_decoder, type);
  296. }
  298. FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_respond_application(FLAC__FileDecoder *decoder, const FLAC__byte id[4])
  299. {
  300. FLAC__ASSERT(0 != decoder);
  301. FLAC__ASSERT(0 != decoder->private_);
  302. FLAC__ASSERT(0 != decoder->protected_);
  303. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  304. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  305. return false;
  306. return FLAC__seekable_stream_decoder_set_metadata_respond_application(decoder->private_->seekable_stream_decoder, id);
  307. }
  309. FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_respond_all(FLAC__FileDecoder *decoder)
  310. {
  311. FLAC__ASSERT(0 != decoder);
  312. FLAC__ASSERT(0 != decoder->private_);
  313. FLAC__ASSERT(0 != decoder->protected_);
  314. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  315. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  316. return false;
  317. return FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder->private_->seekable_stream_decoder);
  318. }
  320. FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_ignore(FLAC__FileDecoder *decoder, FLAC__MetadataType type)
  321. {
  322. FLAC__ASSERT(0 != decoder);
  323. FLAC__ASSERT(0 != decoder->private_);
  324. FLAC__ASSERT(0 != decoder->protected_);
  325. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  326. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  327. return false;
  328. return FLAC__seekable_stream_decoder_set_metadata_ignore(decoder->private_->seekable_stream_decoder, type);
  329. }
  331. FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_ignore_application(FLAC__FileDecoder *decoder, const FLAC__byte id[4])
  332. {
  333. FLAC__ASSERT(0 != decoder);
  334. FLAC__ASSERT(0 != decoder->private_);
  335. FLAC__ASSERT(0 != decoder->protected_);
  336. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  337. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  338. return false;
  339. return FLAC__seekable_stream_decoder_set_metadata_ignore_application(decoder->private_->seekable_stream_decoder, id);
  340. }
  342. FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_ignore_all(FLAC__FileDecoder *decoder)
  343. {
  344. FLAC__ASSERT(0 != decoder);
  345. FLAC__ASSERT(0 != decoder->private_);
  346. FLAC__ASSERT(0 != decoder->protected_);
  347. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  348. if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
  349. return false;
  350. return FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder->private_->seekable_stream_decoder);
  351. }
  353. FLAC_API FLAC__FileDecoderState FLAC__file_decoder_get_state(const FLAC__FileDecoder *decoder)
  354. {
  355. FLAC__ASSERT(0 != decoder);
  356. FLAC__ASSERT(0 != decoder->protected_);
  357. return decoder->protected_->state;
  358. }
  360. FLAC_API FLAC__SeekableStreamDecoderState FLAC__file_decoder_get_seekable_stream_decoder_state(const FLAC__FileDecoder *decoder)
  361. {
  362. FLAC__ASSERT(0 != decoder);
  363. FLAC__ASSERT(0 != decoder->private_);
  364. return FLAC__seekable_stream_decoder_get_state(decoder->private_->seekable_stream_decoder);
  365. }
  367. FLAC_API FLAC__StreamDecoderState FLAC__file_decoder_get_stream_decoder_state(const FLAC__FileDecoder *decoder)
  368. {
  369. FLAC__ASSERT(0 != decoder);
  370. FLAC__ASSERT(0 != decoder->private_);
  371. return FLAC__seekable_stream_decoder_get_stream_decoder_state(decoder->private_->seekable_stream_decoder);
  372. }
  374. FLAC_API const char *FLAC__file_decoder_get_resolved_state_string(const FLAC__FileDecoder *decoder)
  375. {
  376. if(decoder->protected_->state != FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR)
  377. return FLAC__FileDecoderStateString[decoder->protected_->state];
  378. else
  379. return FLAC__seekable_stream_decoder_get_resolved_state_string(decoder->private_->seekable_stream_decoder);
  380. }
  382. FLAC_API FLAC__bool FLAC__file_decoder_get_md5_checking(const FLAC__FileDecoder *decoder)
  383. {
  384. FLAC__ASSERT(0 != decoder);
  385. FLAC__ASSERT(0 != decoder->private_);
  386. return FLAC__seekable_stream_decoder_get_md5_checking(decoder->private_->seekable_stream_decoder);
  387. }
  389. FLAC_API unsigned FLAC__file_decoder_get_channels(const FLAC__FileDecoder *decoder)
  390. {
  391. FLAC__ASSERT(0 != decoder);
  392. FLAC__ASSERT(0 != decoder->private_);
  393. return FLAC__seekable_stream_decoder_get_channels(decoder->private_->seekable_stream_decoder);
  394. }
  396. FLAC_API FLAC__ChannelAssignment FLAC__file_decoder_get_channel_assignment(const FLAC__FileDecoder *decoder)
  397. {
  398. FLAC__ASSERT(0 != decoder);
  399. FLAC__ASSERT(0 != decoder->private_);
  400. return FLAC__seekable_stream_decoder_get_channel_assignment(decoder->private_->seekable_stream_decoder);
  401. }
  403. FLAC_API unsigned FLAC__file_decoder_get_bits_per_sample(const FLAC__FileDecoder *decoder)
  404. {
  405. FLAC__ASSERT(0 != decoder);
  406. FLAC__ASSERT(0 != decoder->private_);
  407. return FLAC__seekable_stream_decoder_get_bits_per_sample(decoder->private_->seekable_stream_decoder);
  408. }
  410. FLAC_API unsigned FLAC__file_decoder_get_sample_rate(const FLAC__FileDecoder *decoder)
  411. {
  412. FLAC__ASSERT(0 != decoder);
  413. FLAC__ASSERT(0 != decoder->private_);
  414. return FLAC__seekable_stream_decoder_get_sample_rate(decoder->private_->seekable_stream_decoder);
  415. }
  417. FLAC_API unsigned FLAC__file_decoder_get_blocksize(const FLAC__FileDecoder *decoder)
  418. {
  419. FLAC__ASSERT(0 != decoder);
  420. FLAC__ASSERT(0 != decoder->private_);
  421. return FLAC__seekable_stream_decoder_get_blocksize(decoder->private_->seekable_stream_decoder);
  422. }
  424. FLAC_API FLAC__bool FLAC__file_decoder_get_decode_position(const FLAC__FileDecoder *decoder, FLAC__uint64 *position)
  425. {
  426. FLAC__ASSERT(0 != decoder);
  427. FLAC__ASSERT(0 != decoder->private_);
  428. return FLAC__seekable_stream_decoder_get_decode_position(decoder->private_->seekable_stream_decoder, position);
  429. }
  431. FLAC_API FLAC__bool FLAC__file_decoder_process_single(FLAC__FileDecoder *decoder)
  432. {
  433. FLAC__bool ret;
  434. FLAC__ASSERT(0 != decoder);
  436. if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
  437. decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
  439. if(decoder->protected_->state == FLAC__FILE_DECODER_END_OF_FILE)
  440. return true;
  442. FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
  444. ret = FLAC__seekable_stream_decoder_process_single(decoder->private_->seekable_stream_decoder);
  445. if(!ret)
  446. decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
  448. return ret;
  449. }
  451. FLAC_API FLAC__bool FLAC__file_decoder_process_until_end_of_metadata(FLAC__FileDecoder *decoder)
  452. {
  453. FLAC__bool ret;
  454. FLAC__ASSERT(0 != decoder);
  456. if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
  457. decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
  459. if(decoder->protected_->state == FLAC__FILE_DECODER_END_OF_FILE)
  460. return true;
  462. FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
  464. ret = FLAC__seekable_stream_decoder_process_until_end_of_metadata(decoder->private_->seekable_stream_decoder);
  465. if(!ret)
  466. decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
  468. return ret;
  469. }
  471. FLAC_API FLAC__bool FLAC__file_decoder_process_until_end_of_file(FLAC__FileDecoder *decoder)
  472. {
  473. FLAC__bool ret;
  474. FLAC__ASSERT(0 != decoder);
  476. if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
  477. decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
  479. if(decoder->protected_->state == FLAC__FILE_DECODER_END_OF_FILE)
  480. return true;
  482. FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
  484. ret = FLAC__seekable_stream_decoder_process_until_end_of_stream(decoder->private_->seekable_stream_decoder);
  485. if(!ret)
  486. decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
  488. return ret;
  489. }
  491. FLAC_API FLAC__bool FLAC__file_decoder_skip_single_frame(FLAC__FileDecoder *decoder)
  492. {
  493. FLAC__bool ret;
  494. FLAC__ASSERT(0 != decoder);
  496. if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
  497. decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
  499. if(decoder->protected_->state == FLAC__FILE_DECODER_END_OF_FILE)
  500. return true;
  502. FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
  504. ret = FLAC__seekable_stream_decoder_skip_single_frame(decoder->private_->seekable_stream_decoder);
  505. if(!ret)
  506. decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
  508. return ret;
  509. }
  511. FLAC_API FLAC__bool FLAC__file_decoder_seek_absolute(FLAC__FileDecoder *decoder, FLAC__uint64 sample)
  512. {
  513. FLAC__ASSERT(0 != decoder);
  514. FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK || decoder->protected_->state == FLAC__FILE_DECODER_END_OF_FILE);
  516. if(decoder->private_->filename == 0) { /* means the file is stdin... */
  517. decoder->protected_->state = FLAC__FILE_DECODER_SEEK_ERROR;
  518. return false;
  519. }
  521. if(!FLAC__seekable_stream_decoder_seek_absolute(decoder->private_->seekable_stream_decoder, sample)) {
  522. decoder->protected_->state = FLAC__FILE_DECODER_SEEK_ERROR;
  523. return false;
  524. }
  525. else {
  526. decoder->protected_->state = FLAC__FILE_DECODER_OK;
  527. return true;
  528. }
  529. }