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

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

Windows CE

开发平台：

C/C++

file_decoder.c：源码内容
  1. /* libOggFLAC - Free Lossless Audio Codec + Ogg library
  2.  * Copyright (C) 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 <sys/stat.h> /* for stat() */
  36. #if defined _MSC_VER || defined __MINGW32__
  37. #include <io.h> /* for _setmode() */
  38. #include <fcntl.h> /* for _O_BINARY */
  39. #elif defined __CYGWIN__
  40. #include <io.h> /* for setmode(), O_BINARY */
  41. #include <fcntl.h> /* for _O_BINARY */
  42. #endif
  43. #include "FLAC/assert.h"
  44. #include "protected/file_decoder.h"
  45. #include "protected/seekable_stream_decoder.h"
  47. /***********************************************************************
  48.  *
  49.  * Private class method prototypes
  50.  *
  51.  ***********************************************************************/
  53. static void set_defaults_(OggFLAC__FileDecoder *decoder);
  54. static FILE *get_binary_stdin_();
  55. static OggFLAC__SeekableStreamDecoderReadStatus read_callback_(const OggFLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
  56. static OggFLAC__SeekableStreamDecoderSeekStatus seek_callback_(const OggFLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
  57. static OggFLAC__SeekableStreamDecoderTellStatus tell_callback_(const OggFLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
  58. static OggFLAC__SeekableStreamDecoderLengthStatus length_callback_(const OggFLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
  59. static FLAC__bool eof_callback_(const OggFLAC__SeekableStreamDecoder *decoder, void *client_data);
  60. static FLAC__StreamDecoderWriteStatus write_callback_(const OggFLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
  61. static void metadata_callback_(const OggFLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
  62. static void error_callback_(const OggFLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
  64. /***********************************************************************
  65.  *
  66.  * Private class data
  67.  *
  68.  ***********************************************************************/
  70. typedef struct OggFLAC__FileDecoderPrivate {
  71. OggFLAC__FileDecoderWriteCallback write_callback;
  72. OggFLAC__FileDecoderMetadataCallback metadata_callback;
  73. OggFLAC__FileDecoderErrorCallback error_callback;
  74. void *client_data;
  75. FILE *file;
  76. char *filename; /* == NULL if stdin */
  77. OggFLAC__SeekableStreamDecoder *seekable_stream_decoder;
  78. } OggFLAC__FileDecoderPrivate;
  80. /***********************************************************************
  81.  *
  82.  * Public static class data
  83.  *
  84.  ***********************************************************************/
  86. OggFLAC_API const char * const OggFLAC__FileDecoderStateString[] = {
  87. "OggFLAC__FILE_DECODER_OK",
  88. "OggFLAC__FILE_DECODER_END_OF_FILE",
  89. "OggFLAC__FILE_DECODER_ERROR_OPENING_FILE",
  90. "OggFLAC__FILE_DECODER_SEEK_ERROR",
  91. "OggFLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR",
  92. "OggFLAC__FILE_DECODER_MEMORY_ALLOCATION_ERROR",
  93. "OggFLAC__FILE_DECODER_ALREADY_INITIALIZED",
  94. "OggFLAC__FILE_DECODER_INVALID_CALLBACK",
  95. "OggFLAC__FILE_DECODER_UNINITIALIZED"
  96. };
  98. /***********************************************************************
  99.  *
  100.  * Class constructor/destructor
  101.  *
  102.  ***********************************************************************/
  104. OggFLAC_API OggFLAC__FileDecoder *OggFLAC__file_decoder_new()
  105. {
  106. OggFLAC__FileDecoder *decoder;
  108. FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
  110. decoder = (OggFLAC__FileDecoder*)calloc(1, sizeof(OggFLAC__FileDecoder));
  111. if(decoder == 0) {
  112. return 0;
  113. }
  115. decoder->protected_ = (OggFLAC__FileDecoderProtected*)calloc(1, sizeof(OggFLAC__FileDecoderProtected));
  116. if(decoder->protected_ == 0) {
  117. free(decoder);
  118. return 0;
  119. }
  121. decoder->private_ = (OggFLAC__FileDecoderPrivate*)calloc(1, sizeof(OggFLAC__FileDecoderPrivate));
  122. if(decoder->private_ == 0) {
  123. free(decoder->protected_);
  124. free(decoder);
  125. return 0;
  126. }
  128. decoder->private_->seekable_stream_decoder = OggFLAC__seekable_stream_decoder_new();
  129. if(0 == decoder->private_->seekable_stream_decoder) {
  130. free(decoder->private_);
  131. free(decoder->protected_);
  132. free(decoder);
  133. return 0;
  134. }
  136. decoder->private_->file = 0;
  138. set_defaults_(decoder);
  140. decoder->protected_->state = OggFLAC__FILE_DECODER_UNINITIALIZED;
  142. return decoder;
  143. }
  145. OggFLAC_API void OggFLAC__file_decoder_delete(OggFLAC__FileDecoder *decoder)
  146. {
  147. FLAC__ASSERT(0 != decoder);
  148. FLAC__ASSERT(0 != decoder->protected_);
  149. FLAC__ASSERT(0 != decoder->private_);
  150. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  152. (void)OggFLAC__file_decoder_finish(decoder);
  154. OggFLAC__seekable_stream_decoder_delete(decoder->private_->seekable_stream_decoder);
  156. free(decoder->private_);
  157. free(decoder->protected_);
  158. free(decoder);
  159. }
  161. /***********************************************************************
  162.  *
  163.  * Public class methods
  164.  *
  165.  ***********************************************************************/
  167. OggFLAC_API OggFLAC__FileDecoderState OggFLAC__file_decoder_init(OggFLAC__FileDecoder *decoder)
  168. {
  169. FLAC__ASSERT(0 != decoder);
  171. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  172. return decoder->protected_->state = OggFLAC__FILE_DECODER_ALREADY_INITIALIZED;
  174. if(0 == decoder->private_->write_callback || 0 == decoder->private_->metadata_callback || 0 == decoder->private_->error_callback)
  175. return decoder->protected_->state = OggFLAC__FILE_DECODER_INVALID_CALLBACK;
  177. if(0 == decoder->private_->filename)
  178. decoder->private_->file = get_binary_stdin_();
  179. else
  180. decoder->private_->file = fopen(decoder->private_->filename, "rb");
  182. if(decoder->private_->file == 0)
  183. return decoder->protected_->state = OggFLAC__FILE_DECODER_ERROR_OPENING_FILE;
  185. OggFLAC__seekable_stream_decoder_set_read_callback(decoder->private_->seekable_stream_decoder, read_callback_);
  186. OggFLAC__seekable_stream_decoder_set_seek_callback(decoder->private_->seekable_stream_decoder, seek_callback_);
  187. OggFLAC__seekable_stream_decoder_set_tell_callback(decoder->private_->seekable_stream_decoder, tell_callback_);
  188. OggFLAC__seekable_stream_decoder_set_length_callback(decoder->private_->seekable_stream_decoder, length_callback_);
  189. OggFLAC__seekable_stream_decoder_set_eof_callback(decoder->private_->seekable_stream_decoder, eof_callback_);
  190. OggFLAC__seekable_stream_decoder_set_write_callback(decoder->private_->seekable_stream_decoder, write_callback_);
  191. OggFLAC__seekable_stream_decoder_set_metadata_callback(decoder->private_->seekable_stream_decoder, metadata_callback_);
  192. OggFLAC__seekable_stream_decoder_set_error_callback(decoder->private_->seekable_stream_decoder, error_callback_);
  193. OggFLAC__seekable_stream_decoder_set_client_data(decoder->private_->seekable_stream_decoder, decoder);
  195. if(OggFLAC__seekable_stream_decoder_init(decoder->private_->seekable_stream_decoder) != OggFLAC__SEEKABLE_STREAM_DECODER_OK)
  196. return decoder->protected_->state = OggFLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
  198. return decoder->protected_->state = OggFLAC__FILE_DECODER_OK;
  199. }
  201. OggFLAC_API FLAC__bool OggFLAC__file_decoder_finish(OggFLAC__FileDecoder *decoder)
  202. {
  203. FLAC__ASSERT(0 != decoder);
  205. if(decoder->protected_->state == OggFLAC__FILE_DECODER_UNINITIALIZED)
  206. return true;
  208. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  210. if(0 != decoder->private_->file && decoder->private_->file != stdin) {
  211. fclose(decoder->private_->file);
  212. decoder->private_->file = 0;
  213. }
  215. if(0 != decoder->private_->filename) {
  216. free(decoder->private_->filename);
  217. decoder->private_->filename = 0;
  218. }
  220. set_defaults_(decoder);
  222. decoder->protected_->state = OggFLAC__FILE_DECODER_UNINITIALIZED;
  224. return OggFLAC__seekable_stream_decoder_finish(decoder->private_->seekable_stream_decoder);
  225. }
  227. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_md5_checking(OggFLAC__FileDecoder *decoder, FLAC__bool value)
  228. {
  229. FLAC__ASSERT(0 != decoder);
  230. FLAC__ASSERT(0 != decoder->private_);
  231. FLAC__ASSERT(0 != decoder->protected_);
  232. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  233. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  234. return false;
  235. return OggFLAC__seekable_stream_decoder_set_md5_checking(decoder->private_->seekable_stream_decoder, value);
  236. }
  238. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_filename(OggFLAC__FileDecoder *decoder, const char *value)
  239. {
  240. FLAC__ASSERT(0 != decoder);
  241. FLAC__ASSERT(0 != decoder->private_);
  242. FLAC__ASSERT(0 != decoder->protected_);
  243. FLAC__ASSERT(0 != value);
  244. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  245. return false;
  246. if(0 != decoder->private_->filename) {
  247. free(decoder->private_->filename);
  248. decoder->private_->filename = 0;
  249. }
  250. if(0 != strcmp(value, "-")) {
  251. if(0 == (decoder->private_->filename = (char*)malloc(strlen(value)+1))) {
  252. decoder->protected_->state = OggFLAC__FILE_DECODER_MEMORY_ALLOCATION_ERROR;
  253. return false;
  254. }
  255. strcpy(decoder->private_->filename, value);
  256. }
  257. return true;
  258. }
  260. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_write_callback(OggFLAC__FileDecoder *decoder, OggFLAC__FileDecoderWriteCallback value)
  261. {
  262. FLAC__ASSERT(0 != decoder);
  263. FLAC__ASSERT(0 != decoder->private_);
  264. FLAC__ASSERT(0 != decoder->protected_);
  265. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  266. return false;
  267. decoder->private_->write_callback = value;
  268. return true;
  269. }
  271. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_metadata_callback(OggFLAC__FileDecoder *decoder, OggFLAC__FileDecoderMetadataCallback value)
  272. {
  273. FLAC__ASSERT(0 != decoder);
  274. FLAC__ASSERT(0 != decoder->private_);
  275. FLAC__ASSERT(0 != decoder->protected_);
  276. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  277. return false;
  278. decoder->private_->metadata_callback = value;
  279. return true;
  280. }
  282. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_error_callback(OggFLAC__FileDecoder *decoder, OggFLAC__FileDecoderErrorCallback value)
  283. {
  284. FLAC__ASSERT(0 != decoder);
  285. FLAC__ASSERT(0 != decoder->private_);
  286. FLAC__ASSERT(0 != decoder->protected_);
  287. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  288. return false;
  289. decoder->private_->error_callback = value;
  290. return true;
  291. }
  293. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_client_data(OggFLAC__FileDecoder *decoder, void *value)
  294. {
  295. FLAC__ASSERT(0 != decoder);
  296. FLAC__ASSERT(0 != decoder->private_);
  297. FLAC__ASSERT(0 != decoder->protected_);
  298. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  299. return false;
  300. decoder->private_->client_data = value;
  301. return true;
  302. }
  304. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_serial_number(OggFLAC__FileDecoder *decoder, long value)
  305. {
  306. FLAC__ASSERT(0 != decoder);
  307. FLAC__ASSERT(0 != decoder->private_);
  308. FLAC__ASSERT(0 != decoder->protected_);
  309. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  310. return false;
  311. OggFLAC__seekable_stream_decoder_set_serial_number(decoder->private_->seekable_stream_decoder, value);
  312. return true;
  313. }
  315. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_metadata_respond(OggFLAC__FileDecoder *decoder, FLAC__MetadataType type)
  316. {
  317. FLAC__ASSERT(0 != decoder);
  318. FLAC__ASSERT(0 != decoder->private_);
  319. FLAC__ASSERT(0 != decoder->protected_);
  320. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  321. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  322. return false;
  323. return OggFLAC__seekable_stream_decoder_set_metadata_respond(decoder->private_->seekable_stream_decoder, type);
  324. }
  326. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_metadata_respond_application(OggFLAC__FileDecoder *decoder, const FLAC__byte id[4])
  327. {
  328. FLAC__ASSERT(0 != decoder);
  329. FLAC__ASSERT(0 != decoder->private_);
  330. FLAC__ASSERT(0 != decoder->protected_);
  331. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  332. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  333. return false;
  334. return OggFLAC__seekable_stream_decoder_set_metadata_respond_application(decoder->private_->seekable_stream_decoder, id);
  335. }
  337. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_metadata_respond_all(OggFLAC__FileDecoder *decoder)
  338. {
  339. FLAC__ASSERT(0 != decoder);
  340. FLAC__ASSERT(0 != decoder->private_);
  341. FLAC__ASSERT(0 != decoder->protected_);
  342. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  343. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  344. return false;
  345. return OggFLAC__seekable_stream_decoder_set_metadata_respond_all(decoder->private_->seekable_stream_decoder);
  346. }
  348. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_metadata_ignore(OggFLAC__FileDecoder *decoder, FLAC__MetadataType type)
  349. {
  350. FLAC__ASSERT(0 != decoder);
  351. FLAC__ASSERT(0 != decoder->private_);
  352. FLAC__ASSERT(0 != decoder->protected_);
  353. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  354. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  355. return false;
  356. return OggFLAC__seekable_stream_decoder_set_metadata_ignore(decoder->private_->seekable_stream_decoder, type);
  357. }
  359. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_metadata_ignore_application(OggFLAC__FileDecoder *decoder, const FLAC__byte id[4])
  360. {
  361. FLAC__ASSERT(0 != decoder);
  362. FLAC__ASSERT(0 != decoder->private_);
  363. FLAC__ASSERT(0 != decoder->protected_);
  364. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  365. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  366. return false;
  367. return OggFLAC__seekable_stream_decoder_set_metadata_ignore_application(decoder->private_->seekable_stream_decoder, id);
  368. }
  370. OggFLAC_API FLAC__bool OggFLAC__file_decoder_set_metadata_ignore_all(OggFLAC__FileDecoder *decoder)
  371. {
  372. FLAC__ASSERT(0 != decoder);
  373. FLAC__ASSERT(0 != decoder->private_);
  374. FLAC__ASSERT(0 != decoder->protected_);
  375. FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
  376. if(decoder->protected_->state != OggFLAC__FILE_DECODER_UNINITIALIZED)
  377. return false;
  378. return OggFLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder->private_->seekable_stream_decoder);
  379. }
  381. OggFLAC_API OggFLAC__FileDecoderState OggFLAC__file_decoder_get_state(const OggFLAC__FileDecoder *decoder)
  382. {
  383. FLAC__ASSERT(0 != decoder);
  384. FLAC__ASSERT(0 != decoder->protected_);
  385. return decoder->protected_->state;
  386. }
  388. OggFLAC_API OggFLAC__SeekableStreamDecoderState OggFLAC__file_decoder_get_seekable_stream_decoder_state(const OggFLAC__FileDecoder *decoder)
  389. {
  390. FLAC__ASSERT(0 != decoder);
  391. FLAC__ASSERT(0 != decoder->private_);
  392. return OggFLAC__seekable_stream_decoder_get_state(decoder->private_->seekable_stream_decoder);
  393. }
  395. OggFLAC_API OggFLAC__StreamDecoderState OggFLAC__file_decoder_get_stream_decoder_state(const OggFLAC__FileDecoder *decoder)
  396. {
  397. FLAC__ASSERT(0 != decoder);
  398. FLAC__ASSERT(0 != decoder->private_);
  399. return OggFLAC__seekable_stream_decoder_get_stream_decoder_state(decoder->private_->seekable_stream_decoder);
  400. }
  402. OggFLAC_API FLAC__StreamDecoderState OggFLAC__file_decoder_get_FLAC_stream_decoder_state(const OggFLAC__FileDecoder *decoder)
  403. {
  404. FLAC__ASSERT(0 != decoder);
  405. FLAC__ASSERT(0 != decoder->private_);
  406. return OggFLAC__seekable_stream_decoder_get_FLAC_stream_decoder_state(decoder->private_->seekable_stream_decoder);
  407. }
  409. OggFLAC_API const char *OggFLAC__file_decoder_get_resolved_state_string(const OggFLAC__FileDecoder *decoder)
  410. {
  411. if(decoder->protected_->state != OggFLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR)
  412. return OggFLAC__FileDecoderStateString[decoder->protected_->state];
  413. else
  414. return OggFLAC__seekable_stream_decoder_get_resolved_state_string(decoder->private_->seekable_stream_decoder);
  415. }
  417. OggFLAC_API FLAC__bool OggFLAC__file_decoder_get_md5_checking(const OggFLAC__FileDecoder *decoder)
  418. {
  419. FLAC__ASSERT(0 != decoder);
  420. FLAC__ASSERT(0 != decoder->private_);
  421. return OggFLAC__seekable_stream_decoder_get_md5_checking(decoder->private_->seekable_stream_decoder);
  422. }
  424. OggFLAC_API unsigned OggFLAC__file_decoder_get_channels(const OggFLAC__FileDecoder *decoder)
  425. {
  426. FLAC__ASSERT(0 != decoder);
  427. FLAC__ASSERT(0 != decoder->private_);
  428. return OggFLAC__seekable_stream_decoder_get_channels(decoder->private_->seekable_stream_decoder);
  429. }
  431. OggFLAC_API FLAC__ChannelAssignment OggFLAC__file_decoder_get_channel_assignment(const OggFLAC__FileDecoder *decoder)
  432. {
  433. FLAC__ASSERT(0 != decoder);
  434. FLAC__ASSERT(0 != decoder->private_);
  435. return OggFLAC__seekable_stream_decoder_get_channel_assignment(decoder->private_->seekable_stream_decoder);
  436. }
  438. OggFLAC_API unsigned OggFLAC__file_decoder_get_bits_per_sample(const OggFLAC__FileDecoder *decoder)
  439. {
  440. FLAC__ASSERT(0 != decoder);
  441. FLAC__ASSERT(0 != decoder->private_);
  442. return OggFLAC__seekable_stream_decoder_get_bits_per_sample(decoder->private_->seekable_stream_decoder);
  443. }
  445. OggFLAC_API unsigned OggFLAC__file_decoder_get_sample_rate(const OggFLAC__FileDecoder *decoder)
  446. {
  447. FLAC__ASSERT(0 != decoder);
  448. FLAC__ASSERT(0 != decoder->private_);
  449. return OggFLAC__seekable_stream_decoder_get_sample_rate(decoder->private_->seekable_stream_decoder);
  450. }
  452. OggFLAC_API unsigned OggFLAC__file_decoder_get_blocksize(const OggFLAC__FileDecoder *decoder)
  453. {
  454. FLAC__ASSERT(0 != decoder);
  455. FLAC__ASSERT(0 != decoder->private_);
  456. return OggFLAC__seekable_stream_decoder_get_blocksize(decoder->private_->seekable_stream_decoder);
  457. }
  459. OggFLAC_API FLAC__bool OggFLAC__file_decoder_process_single(OggFLAC__FileDecoder *decoder)
  460. {
  461. FLAC__bool ret;
  462. FLAC__ASSERT(0 != decoder);
  464. if(decoder->private_->seekable_stream_decoder->protected_->state == OggFLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
  465. decoder->protected_->state = OggFLAC__FILE_DECODER_END_OF_FILE;
  467. if(decoder->protected_->state == OggFLAC__FILE_DECODER_END_OF_FILE)
  468. return true;
  470. FLAC__ASSERT(decoder->protected_->state == OggFLAC__FILE_DECODER_OK);
  472. ret = OggFLAC__seekable_stream_decoder_process_single(decoder->private_->seekable_stream_decoder);
  473. if(!ret)
  474. decoder->protected_->state = OggFLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
  476. return ret;
  477. }
  479. OggFLAC_API FLAC__bool OggFLAC__file_decoder_process_until_end_of_metadata(OggFLAC__FileDecoder *decoder)
  480. {
  481. FLAC__bool ret;
  482. FLAC__ASSERT(0 != decoder);
  484. if(decoder->private_->seekable_stream_decoder->protected_->state == OggFLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
  485. decoder->protected_->state = OggFLAC__FILE_DECODER_END_OF_FILE;
  487. if(decoder->protected_->state == OggFLAC__FILE_DECODER_END_OF_FILE)
  488. return true;
  490. FLAC__ASSERT(decoder->protected_->state == OggFLAC__FILE_DECODER_OK);
  492. ret = OggFLAC__seekable_stream_decoder_process_until_end_of_metadata(decoder->private_->seekable_stream_decoder);
  493. if(!ret)
  494. decoder->protected_->state = OggFLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
  496. return ret;
  497. }
  499. OggFLAC_API FLAC__bool OggFLAC__file_decoder_process_until_end_of_file(OggFLAC__FileDecoder *decoder)
  500. {
  501. FLAC__bool ret;
  502. FLAC__ASSERT(0 != decoder);
  504. if(decoder->private_->seekable_stream_decoder->protected_->state == OggFLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
  505. decoder->protected_->state = OggFLAC__FILE_DECODER_END_OF_FILE;
  507. if(decoder->protected_->state == OggFLAC__FILE_DECODER_END_OF_FILE)
  508. return true;
  510. FLAC__ASSERT(decoder->protected_->state == OggFLAC__FILE_DECODER_OK);
  512. ret = OggFLAC__seekable_stream_decoder_process_until_end_of_stream(decoder->private_->seekable_stream_decoder);
  513. if(!ret)
  514. decoder->protected_->state = OggFLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
  516. return ret;
  517. }
  519. OggFLAC_API FLAC__bool OggFLAC__file_decoder_seek_absolute(OggFLAC__FileDecoder *decoder, FLAC__uint64 sample)
  520. {
  521. FLAC__ASSERT(0 != decoder);
  522. FLAC__ASSERT(decoder->protected_->state == OggFLAC__FILE_DECODER_OK || decoder->protected_->state == OggFLAC__FILE_DECODER_END_OF_FILE);
  524. if(decoder->private_->filename == 0) { /* means the file is stdin... */
  525. decoder->protected_->state = OggFLAC__FILE_DECODER_SEEK_ERROR;
  526. return false;
  527. }
  529. if(!OggFLAC__seekable_stream_decoder_seek_absolute(decoder->private_->seekable_stream_decoder, sample)) {
  530. decoder->protected_->state = OggFLAC__FILE_DECODER_SEEK_ERROR;
  531. return false;
  532. }
  533. else {
  534. decoder->protected_->state = OggFLAC__FILE_DECODER_OK;
  535. return true;
  536. }
  537. }
  540. /***********************************************************************
  541.  *
  542.  * Private class methods
  543.  *
  544.  ***********************************************************************/
  546. void set_defaults_(OggFLAC__FileDecoder *decoder)
  547. {
  548. FLAC__ASSERT(0 != decoder);
  549. FLAC__ASSERT(0 != decoder->private_);
  551. decoder->private_->filename = 0;
  552. decoder->private_->write_callback = 0;
  553. decoder->private_->metadata_callback = 0;
  554. decoder->private_->error_callback = 0;
  555. decoder->private_->client_data = 0;
  556. }
  558. /*
  559.  * This will forcibly set stdin to binary mode (for OSes that require it)
  560.  */
  561. FILE *get_binary_stdin_()
  562. {
  563. /* if something breaks here it is probably due to the presence or
  564.  * absence of an underscore before the identifiers 'setmode',
  565.  * 'fileno', and/or 'O_BINARY'; check your system header files.
  566.  */
  567. #if defined _MSC_VER || defined __MINGW32__
  568. _setmode(_fileno(stdin), _O_BINARY);
  569. #elif defined __CYGWIN__
  570. /* almost certainly not needed for any modern Cygwin, but let's be safe... */
  571. setmode(_fileno(stdin), _O_BINARY);
  572. #endif
  574. return stdin;
  575. }
  577. OggFLAC__SeekableStreamDecoderReadStatus read_callback_(const OggFLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
  578. {
  579. OggFLAC__FileDecoder *file_decoder = (OggFLAC__FileDecoder *)client_data;
  580. (void)decoder;
  582. if(*bytes > 0) {
  583. *bytes = (unsigned)fread(buffer, sizeof(FLAC__byte), *bytes, file_decoder->private_->file);
  584. if(ferror(file_decoder->private_->file)) {
  585. return OggFLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
  586. }
  587. else {
  588. return OggFLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK;
  589. }
  590. }
  591. else
  592. return OggFLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR; /* abort to avoid a deadlock */
  593. }
  595. OggFLAC__SeekableStreamDecoderSeekStatus seek_callback_(const OggFLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
  596. {
  597. OggFLAC__FileDecoder *file_decoder = (OggFLAC__FileDecoder *)client_data;
  598. (void)decoder;
  600. if(fseek(file_decoder->private_->file, (long)absolute_byte_offset, SEEK_SET) < 0)
  601. return OggFLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
  602. else
  603. return OggFLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK;
  604. }
  606. OggFLAC__SeekableStreamDecoderTellStatus tell_callback_(const OggFLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
  607. {
  608. OggFLAC__FileDecoder *file_decoder = (OggFLAC__FileDecoder *)client_data;
  609. long pos;
  610. (void)decoder;
  612. if((pos = ftell(file_decoder->private_->file)) < 0)
  613. return OggFLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;
  614. else {
  615. *absolute_byte_offset = (FLAC__uint64)pos;
  616. return OggFLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK;
  617. }
  618. }
  620. OggFLAC__SeekableStreamDecoderLengthStatus length_callback_(const OggFLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
  621. {
  622. OggFLAC__FileDecoder *file_decoder = (OggFLAC__FileDecoder *)client_data;
  623. struct stat filestats;
  624. (void)decoder;
  626. if(0 == file_decoder->private_->filename || stat(file_decoder->private_->filename, &filestats) != 0)
  627. return OggFLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR;
  628. else {
  629. *stream_length = (FLAC__uint64)filestats.st_size;
  630. return OggFLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK;
  631. }
  632. }
  634. FLAC__bool eof_callback_(const OggFLAC__SeekableStreamDecoder *decoder, void *client_data)
  635. {
  636. OggFLAC__FileDecoder *file_decoder = (OggFLAC__FileDecoder *)client_data;
  637. (void)decoder;
  639. return feof(file_decoder->private_->file)? true : false;
  640. }
  642. FLAC__StreamDecoderWriteStatus write_callback_(const OggFLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
  643. {
  644. OggFLAC__FileDecoder *file_decoder = (OggFLAC__FileDecoder *)client_data;
  645. (void)decoder;
  647. return file_decoder->private_->write_callback(file_decoder, frame, buffer, file_decoder->private_->client_data);
  648. }
  650. void metadata_callback_(const OggFLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
  651. {
  652. OggFLAC__FileDecoder *file_decoder = (OggFLAC__FileDecoder *)client_data;
  653. (void)decoder;
  655. file_decoder->private_->metadata_callback(file_decoder, metadata, file_decoder->private_->client_data);
  656. }
  658. void error_callback_(const OggFLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
  659. {
  660. OggFLAC__FileDecoder *file_decoder = (OggFLAC__FileDecoder *)client_data;
  661. (void)decoder;
  663. file_decoder->private_->error_callback(file_decoder, status, file_decoder->private_->client_data);
  664. }