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

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

Windows CE

开发平台：

C/C++

stream_encoder.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 calloc() */
  34. #include "FLAC/assert.h"
  35. #include "OggFLAC/stream_encoder.h"
  36. #include "protected/stream_encoder.h"
  38. /***********************************************************************
  39.  *
  40.  * Private class method prototypes
  41.  *
  42.  ***********************************************************************/
  44. /* unpublished debug routines */
  45. extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
  46. extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
  47. extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
  49. static void set_defaults_(OggFLAC__StreamEncoder *encoder);
  50. static FLAC__StreamEncoderWriteStatus write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
  51. static void metadata_callback_(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data);
  54. /***********************************************************************
  55.  *
  56.  * Private class data
  57.  *
  58.  ***********************************************************************/
  60. typedef struct OggFLAC__StreamEncoderPrivate {
  61. OggFLAC__StreamEncoderWriteCallback write_callback;
  62. OggFLAC__StreamEncoderMetadataCallback metadata_callback;
  63. void *client_data;
  64. FLAC__StreamEncoder *FLAC_stream_encoder;
  65. } OggFLAC__StreamEncoderPrivate;
  68. /***********************************************************************
  69.  *
  70.  * Public static class data
  71.  *
  72.  ***********************************************************************/
  74. OggFLAC_API const char * const OggFLAC__StreamEncoderStateString[] = {
  75. "OggFLAC__STREAM_ENCODER_OK",
  76. "OggFLAC__STREAM_ENCODER_OGG_ERROR",
  77. "OggFLAC__STREAM_ENCODER_FLAC_STREAM_ENCODER_ERROR",
  78. "OggFLAC__STREAM_ENCODER_INVALID_CALLBACK",
  79. "OggFLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR",
  80. "OggFLAC__STREAM_ENCODER_ALREADY_INITIALIZED",
  81. "OggFLAC__STREAM_ENCODER_UNINITIALIZED"
  82. };
  85. /***********************************************************************
  86.  *
  87.  * Class constructor/destructor
  88.  *
  89.  */
  90. OggFLAC_API OggFLAC__StreamEncoder *OggFLAC__stream_encoder_new()
  91. {
  92. OggFLAC__StreamEncoder *encoder;
  94. encoder = (OggFLAC__StreamEncoder*)calloc(1, sizeof(OggFLAC__StreamEncoder));
  95. if(encoder == 0) {
  96. return 0;
  97. }
  99. encoder->protected_ = (OggFLAC__StreamEncoderProtected*)calloc(1, sizeof(OggFLAC__StreamEncoderProtected));
  100. if(encoder->protected_ == 0) {
  101. free(encoder);
  102. return 0;
  103. }
  105. encoder->private_ = (OggFLAC__StreamEncoderPrivate*)calloc(1, sizeof(OggFLAC__StreamEncoderPrivate));
  106. if(encoder->private_ == 0) {
  107. free(encoder->protected_);
  108. free(encoder);
  109. return 0;
  110. }
  112. encoder->private_->FLAC_stream_encoder = FLAC__stream_encoder_new();
  113. if(0 == encoder->private_->FLAC_stream_encoder) {
  114. free(encoder->private_);
  115. free(encoder->protected_);
  116. free(encoder);
  117. return 0;
  118. }
  120. set_defaults_(encoder);
  122. encoder->protected_->state = OggFLAC__STREAM_ENCODER_UNINITIALIZED;
  124. return encoder;
  125. }
  127. OggFLAC_API void OggFLAC__stream_encoder_delete(OggFLAC__StreamEncoder *encoder)
  128. {
  129. FLAC__ASSERT(0 != encoder);
  130. FLAC__ASSERT(0 != encoder->protected_);
  131. FLAC__ASSERT(0 != encoder->private_);
  132. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  134. (void)OggFLAC__stream_encoder_finish(encoder);
  136. FLAC__stream_encoder_delete(encoder->private_->FLAC_stream_encoder);
  138. free(encoder->private_);
  139. free(encoder->protected_);
  140. free(encoder);
  141. }
  144. /***********************************************************************
  145.  *
  146.  * Public class methods
  147.  *
  148.  ***********************************************************************/
  150. OggFLAC_API OggFLAC__StreamEncoderState OggFLAC__stream_encoder_init(OggFLAC__StreamEncoder *encoder)
  151. {
  152. FLAC__ASSERT(0 != encoder);
  154. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  155. return encoder->protected_->state = OggFLAC__STREAM_ENCODER_ALREADY_INITIALIZED;
  157. if(0 == encoder->private_->write_callback || 0 == encoder->private_->metadata_callback)
  158. return encoder->protected_->state = OggFLAC__STREAM_ENCODER_INVALID_CALLBACK;
  160. if(!OggFLAC__ogg_encoder_aspect_init(&encoder->protected_->ogg_encoder_aspect))
  161. return encoder->protected_->state = OggFLAC__STREAM_ENCODER_OGG_ERROR;
  163. FLAC__stream_encoder_set_write_callback(encoder->private_->FLAC_stream_encoder, write_callback_);
  164. FLAC__stream_encoder_set_metadata_callback(encoder->private_->FLAC_stream_encoder, metadata_callback_);
  165. FLAC__stream_encoder_set_client_data(encoder->private_->FLAC_stream_encoder, encoder);
  167. if(FLAC__stream_encoder_init(encoder->private_->FLAC_stream_encoder) != FLAC__STREAM_ENCODER_OK)
  168. return encoder->protected_->state = OggFLAC__STREAM_ENCODER_FLAC_STREAM_ENCODER_ERROR;
  170. return encoder->protected_->state = OggFLAC__STREAM_ENCODER_OK;
  171. }
  173. OggFLAC_API void OggFLAC__stream_encoder_finish(OggFLAC__StreamEncoder *encoder)
  174. {
  175. FLAC__ASSERT(0 != encoder);
  176. FLAC__ASSERT(0 != encoder->private_);
  177. FLAC__ASSERT(0 != encoder->protected_);
  179. if(encoder->protected_->state == OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  180. return;
  182. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  184. FLAC__stream_encoder_finish(encoder->private_->FLAC_stream_encoder);
  186. OggFLAC__ogg_encoder_aspect_finish(&encoder->protected_->ogg_encoder_aspect);
  188. set_defaults_(encoder);
  190. encoder->protected_->state = OggFLAC__STREAM_ENCODER_UNINITIALIZED;
  191. }
  193. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_serial_number(OggFLAC__StreamEncoder *encoder, long value)
  194. {
  195. FLAC__ASSERT(0 != encoder);
  196. FLAC__ASSERT(0 != encoder->private_);
  197. FLAC__ASSERT(0 != encoder->protected_);
  198. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  199. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  200. return false;
  201. OggFLAC__ogg_encoder_aspect_set_serial_number(&encoder->protected_->ogg_encoder_aspect, value);
  202. return true;
  203. }
  205. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_verify(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
  206. {
  207. FLAC__ASSERT(0 != encoder);
  208. FLAC__ASSERT(0 != encoder->private_);
  209. FLAC__ASSERT(0 != encoder->protected_);
  210. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  211. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  212. return false;
  213. return FLAC__stream_encoder_set_verify(encoder->private_->FLAC_stream_encoder, value);
  214. }
  216. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_streamable_subset(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
  217. {
  218. FLAC__ASSERT(0 != encoder);
  219. FLAC__ASSERT(0 != encoder->private_);
  220. FLAC__ASSERT(0 != encoder->protected_);
  221. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  222. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  223. return false;
  224. return FLAC__stream_encoder_set_streamable_subset(encoder->private_->FLAC_stream_encoder, value);
  225. }
  227. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_do_mid_side_stereo(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
  228. {
  229. FLAC__ASSERT(0 != encoder);
  230. FLAC__ASSERT(0 != encoder->private_);
  231. FLAC__ASSERT(0 != encoder->protected_);
  232. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  233. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  234. return false;
  235. return FLAC__stream_encoder_set_do_mid_side_stereo(encoder->private_->FLAC_stream_encoder, value);
  236. }
  238. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_loose_mid_side_stereo(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
  239. {
  240. FLAC__ASSERT(0 != encoder);
  241. FLAC__ASSERT(0 != encoder->private_);
  242. FLAC__ASSERT(0 != encoder->protected_);
  243. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  244. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  245. return false;
  246. return FLAC__stream_encoder_set_loose_mid_side_stereo(encoder->private_->FLAC_stream_encoder, value);
  247. }
  249. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_channels(OggFLAC__StreamEncoder *encoder, unsigned value)
  250. {
  251. FLAC__ASSERT(0 != encoder);
  252. FLAC__ASSERT(0 != encoder->private_);
  253. FLAC__ASSERT(0 != encoder->protected_);
  254. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  255. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  256. return false;
  257. return FLAC__stream_encoder_set_channels(encoder->private_->FLAC_stream_encoder, value);
  258. }
  260. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_bits_per_sample(OggFLAC__StreamEncoder *encoder, unsigned value)
  261. {
  262. FLAC__ASSERT(0 != encoder);
  263. FLAC__ASSERT(0 != encoder->private_);
  264. FLAC__ASSERT(0 != encoder->protected_);
  265. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  266. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  267. return false;
  268. return FLAC__stream_encoder_set_bits_per_sample(encoder->private_->FLAC_stream_encoder, value);
  269. }
  271. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_sample_rate(OggFLAC__StreamEncoder *encoder, unsigned value)
  272. {
  273. FLAC__ASSERT(0 != encoder);
  274. FLAC__ASSERT(0 != encoder->private_);
  275. FLAC__ASSERT(0 != encoder->protected_);
  276. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  277. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  278. return false;
  279. return FLAC__stream_encoder_set_sample_rate(encoder->private_->FLAC_stream_encoder, value);
  280. }
  282. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_blocksize(OggFLAC__StreamEncoder *encoder, unsigned value)
  283. {
  284. FLAC__ASSERT(0 != encoder);
  285. FLAC__ASSERT(0 != encoder->private_);
  286. FLAC__ASSERT(0 != encoder->protected_);
  287. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  288. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  289. return false;
  290. return FLAC__stream_encoder_set_blocksize(encoder->private_->FLAC_stream_encoder, value);
  291. }
  293. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_max_lpc_order(OggFLAC__StreamEncoder *encoder, unsigned value)
  294. {
  295. FLAC__ASSERT(0 != encoder);
  296. FLAC__ASSERT(0 != encoder->private_);
  297. FLAC__ASSERT(0 != encoder->protected_);
  298. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  299. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  300. return false;
  301. return FLAC__stream_encoder_set_max_lpc_order(encoder->private_->FLAC_stream_encoder, value);
  302. }
  304. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_qlp_coeff_precision(OggFLAC__StreamEncoder *encoder, unsigned value)
  305. {
  306. FLAC__ASSERT(0 != encoder);
  307. FLAC__ASSERT(0 != encoder->private_);
  308. FLAC__ASSERT(0 != encoder->protected_);
  309. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  310. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  311. return false;
  312. return FLAC__stream_encoder_set_qlp_coeff_precision(encoder->private_->FLAC_stream_encoder, value);
  313. }
  315. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_do_qlp_coeff_prec_search(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
  316. {
  317. FLAC__ASSERT(0 != encoder);
  318. FLAC__ASSERT(0 != encoder->private_);
  319. FLAC__ASSERT(0 != encoder->protected_);
  320. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  321. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  322. return false;
  323. return FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder->private_->FLAC_stream_encoder, value);
  324. }
  326. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_do_escape_coding(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
  327. {
  328. FLAC__ASSERT(0 != encoder);
  329. FLAC__ASSERT(0 != encoder->private_);
  330. FLAC__ASSERT(0 != encoder->protected_);
  331. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  332. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  333. return false;
  334. return FLAC__stream_encoder_set_do_escape_coding(encoder->private_->FLAC_stream_encoder, value);
  335. }
  337. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_do_exhaustive_model_search(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
  338. {
  339. FLAC__ASSERT(0 != encoder);
  340. FLAC__ASSERT(0 != encoder->private_);
  341. FLAC__ASSERT(0 != encoder->protected_);
  342. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  343. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  344. return false;
  345. return FLAC__stream_encoder_set_do_exhaustive_model_search(encoder->private_->FLAC_stream_encoder, value);
  346. }
  348. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_min_residual_partition_order(OggFLAC__StreamEncoder *encoder, unsigned value)
  349. {
  350. FLAC__ASSERT(0 != encoder);
  351. FLAC__ASSERT(0 != encoder->private_);
  352. FLAC__ASSERT(0 != encoder->protected_);
  353. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  354. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  355. return false;
  356. return FLAC__stream_encoder_set_min_residual_partition_order(encoder->private_->FLAC_stream_encoder, value);
  357. }
  359. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_max_residual_partition_order(OggFLAC__StreamEncoder *encoder, unsigned value)
  360. {
  361. FLAC__ASSERT(0 != encoder);
  362. FLAC__ASSERT(0 != encoder->private_);
  363. FLAC__ASSERT(0 != encoder->protected_);
  364. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  365. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  366. return false;
  367. return FLAC__stream_encoder_set_max_residual_partition_order(encoder->private_->FLAC_stream_encoder, value);
  368. }
  370. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_rice_parameter_search_dist(OggFLAC__StreamEncoder *encoder, unsigned value)
  371. {
  372. FLAC__ASSERT(0 != encoder);
  373. FLAC__ASSERT(0 != encoder->private_);
  374. FLAC__ASSERT(0 != encoder->protected_);
  375. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  376. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  377. return false;
  378. return FLAC__stream_encoder_set_rice_parameter_search_dist(encoder->private_->FLAC_stream_encoder, value);
  379. }
  381. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_total_samples_estimate(OggFLAC__StreamEncoder *encoder, FLAC__uint64 value)
  382. {
  383. FLAC__ASSERT(0 != encoder);
  384. FLAC__ASSERT(0 != encoder->private_);
  385. FLAC__ASSERT(0 != encoder->protected_);
  386. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  387. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  388. return false;
  389. return FLAC__stream_encoder_set_total_samples_estimate(encoder->private_->FLAC_stream_encoder, value);
  390. }
  392. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_metadata(OggFLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks)
  393. {
  394. FLAC__ASSERT(0 != encoder);
  395. FLAC__ASSERT(0 != encoder->private_);
  396. FLAC__ASSERT(0 != encoder->protected_);
  397. FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
  398. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  399. return false;
  400. /* reorder metadata if necessary to ensure that any VORBIS_COMMENT is the first, according to the mapping spec */
  401. if(0 != metadata && num_blocks > 1) {
  402. unsigned i;
  403. for(i = 1; i < num_blocks; i++) {
  404. if(0 != metadata[i] && metadata[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
  405. FLAC__StreamMetadata *vc = metadata[i];
  406. for( ; i > 0; i--)
  407. metadata[i] = metadata[i-1];
  408. metadata[0] = vc;
  409. break;
  410. }
  411. }
  412. }
  413. if(!OggFLAC__ogg_encoder_aspect_set_num_metadata(&encoder->protected_->ogg_encoder_aspect, num_blocks))
  414. return false;
  415. return FLAC__stream_encoder_set_metadata(encoder->private_->FLAC_stream_encoder, metadata, num_blocks);
  416. }
  418. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_write_callback(OggFLAC__StreamEncoder *encoder, OggFLAC__StreamEncoderWriteCallback value)
  419. {
  420. FLAC__ASSERT(0 != encoder);
  421. FLAC__ASSERT(0 != encoder->private_);
  422. FLAC__ASSERT(0 != encoder->protected_);
  423. FLAC__ASSERT(0 != value);
  424. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  425. return false;
  426. encoder->private_->write_callback = value;
  427. return true;
  428. }
  430. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_metadata_callback(OggFLAC__StreamEncoder *encoder, OggFLAC__StreamEncoderMetadataCallback value)
  431. {
  432. FLAC__ASSERT(0 != encoder);
  433. FLAC__ASSERT(0 != encoder->private_);
  434. FLAC__ASSERT(0 != encoder->protected_);
  435. FLAC__ASSERT(0 != value);
  436. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  437. return false;
  438. encoder->private_->metadata_callback = value;
  439. return true;
  440. }
  442. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_client_data(OggFLAC__StreamEncoder *encoder, void *value)
  443. {
  444. FLAC__ASSERT(0 != encoder);
  445. FLAC__ASSERT(0 != encoder->private_);
  446. FLAC__ASSERT(0 != encoder->protected_);
  447. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  448. return false;
  449. encoder->private_->client_data = value;
  450. return true;
  451. }
  453. /*
  454.  * These three functions are not static, but not publically exposed in
  455.  * include/FLAC/ either.  They are used by the test suite.
  456.  */
  457. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_disable_constant_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
  458. {
  459. FLAC__ASSERT(0 != encoder);
  460. FLAC__ASSERT(0 != encoder->private_);
  461. FLAC__ASSERT(0 != encoder->protected_);
  462. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  463. return false;
  464. return FLAC__stream_encoder_disable_constant_subframes(encoder->private_->FLAC_stream_encoder, value);
  465. }
  467. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_disable_fixed_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
  468. {
  469. FLAC__ASSERT(0 != encoder);
  470. FLAC__ASSERT(0 != encoder->private_);
  471. FLAC__ASSERT(0 != encoder->protected_);
  472. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  473. return false;
  474. return FLAC__stream_encoder_disable_fixed_subframes(encoder->private_->FLAC_stream_encoder, value);
  475. }
  477. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_disable_verbatim_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
  478. {
  479. FLAC__ASSERT(0 != encoder);
  480. FLAC__ASSERT(0 != encoder->private_);
  481. FLAC__ASSERT(0 != encoder->protected_);
  482. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
  483. return false;
  484. return FLAC__stream_encoder_disable_verbatim_subframes(encoder->private_->FLAC_stream_encoder, value);
  485. }
  487. OggFLAC_API OggFLAC__StreamEncoderState OggFLAC__stream_encoder_get_state(const OggFLAC__StreamEncoder *encoder)
  488. {
  489. FLAC__ASSERT(0 != encoder);
  490. FLAC__ASSERT(0 != encoder->private_);
  491. FLAC__ASSERT(0 != encoder->protected_);
  492. return encoder->protected_->state;
  493. }
  495. OggFLAC_API FLAC__StreamEncoderState OggFLAC__stream_encoder_get_FLAC_stream_encoder_state(const OggFLAC__StreamEncoder *encoder)
  496. {
  497. FLAC__ASSERT(0 != encoder);
  498. FLAC__ASSERT(0 != encoder->private_);
  499. FLAC__ASSERT(0 != encoder->protected_);
  500. return FLAC__stream_encoder_get_state(encoder->private_->FLAC_stream_encoder);
  501. }
  503. OggFLAC_API FLAC__StreamDecoderState OggFLAC__stream_encoder_get_verify_decoder_state(const OggFLAC__StreamEncoder *encoder)
  504. {
  505. FLAC__ASSERT(0 != encoder);
  506. FLAC__ASSERT(0 != encoder->private_);
  507. FLAC__ASSERT(0 != encoder->protected_);
  508. return FLAC__stream_encoder_get_verify_decoder_state(encoder->private_->FLAC_stream_encoder);
  509. }
  511. OggFLAC_API const char *OggFLAC__stream_encoder_get_resolved_state_string(const OggFLAC__StreamEncoder *encoder)
  512. {
  513. if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_FLAC_STREAM_ENCODER_ERROR)
  514. return OggFLAC__StreamEncoderStateString[encoder->protected_->state];
  515. else
  516. return FLAC__stream_encoder_get_resolved_state_string(encoder->private_->FLAC_stream_encoder);
  517. }
  519. OggFLAC_API void OggFLAC__stream_encoder_get_verify_decoder_error_stats(const OggFLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, unsigned *frame_number, unsigned *channel, unsigned *sample, FLAC__int32 *expected, FLAC__int32 *got)
  520. {
  521. FLAC__ASSERT(0 != encoder);
  522. FLAC__ASSERT(0 != encoder->private_);
  523. FLAC__stream_encoder_get_verify_decoder_error_stats(encoder->private_->FLAC_stream_encoder, absolute_sample, frame_number, channel, sample, expected, got);
  524. }
  526. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_verify(const OggFLAC__StreamEncoder *encoder)
  527. {
  528. FLAC__ASSERT(0 != encoder);
  529. FLAC__ASSERT(0 != encoder->private_);
  530. FLAC__ASSERT(0 != encoder->protected_);
  531. return FLAC__stream_encoder_get_verify(encoder->private_->FLAC_stream_encoder);
  532. }
  534. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_streamable_subset(const OggFLAC__StreamEncoder *encoder)
  535. {
  536. FLAC__ASSERT(0 != encoder);
  537. FLAC__ASSERT(0 != encoder->private_);
  538. FLAC__ASSERT(0 != encoder->protected_);
  539. return FLAC__stream_encoder_get_streamable_subset(encoder->private_->FLAC_stream_encoder);
  540. }
  542. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_do_mid_side_stereo(const OggFLAC__StreamEncoder *encoder)
  543. {
  544. FLAC__ASSERT(0 != encoder);
  545. FLAC__ASSERT(0 != encoder->private_);
  546. FLAC__ASSERT(0 != encoder->protected_);
  547. return FLAC__stream_encoder_get_do_mid_side_stereo(encoder->private_->FLAC_stream_encoder);
  548. }
  550. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_loose_mid_side_stereo(const OggFLAC__StreamEncoder *encoder)
  551. {
  552. FLAC__ASSERT(0 != encoder);
  553. FLAC__ASSERT(0 != encoder->private_);
  554. FLAC__ASSERT(0 != encoder->protected_);
  555. return FLAC__stream_encoder_get_loose_mid_side_stereo(encoder->private_->FLAC_stream_encoder);
  556. }
  558. OggFLAC_API unsigned OggFLAC__stream_encoder_get_channels(const OggFLAC__StreamEncoder *encoder)
  559. {
  560. FLAC__ASSERT(0 != encoder);
  561. FLAC__ASSERT(0 != encoder->private_);
  562. FLAC__ASSERT(0 != encoder->protected_);
  563. return FLAC__stream_encoder_get_channels(encoder->private_->FLAC_stream_encoder);
  564. }
  566. OggFLAC_API unsigned OggFLAC__stream_encoder_get_bits_per_sample(const OggFLAC__StreamEncoder *encoder)
  567. {
  568. FLAC__ASSERT(0 != encoder);
  569. FLAC__ASSERT(0 != encoder->private_);
  570. FLAC__ASSERT(0 != encoder->protected_);
  571. return FLAC__stream_encoder_get_bits_per_sample(encoder->private_->FLAC_stream_encoder);
  572. }
  574. OggFLAC_API unsigned OggFLAC__stream_encoder_get_sample_rate(const OggFLAC__StreamEncoder *encoder)
  575. {
  576. FLAC__ASSERT(0 != encoder);
  577. FLAC__ASSERT(0 != encoder->private_);
  578. FLAC__ASSERT(0 != encoder->protected_);
  579. return FLAC__stream_encoder_get_sample_rate(encoder->private_->FLAC_stream_encoder);
  580. }
  582. OggFLAC_API unsigned OggFLAC__stream_encoder_get_blocksize(const OggFLAC__StreamEncoder *encoder)
  583. {
  584. FLAC__ASSERT(0 != encoder);
  585. FLAC__ASSERT(0 != encoder->private_);
  586. FLAC__ASSERT(0 != encoder->protected_);
  587. return FLAC__stream_encoder_get_blocksize(encoder->private_->FLAC_stream_encoder);
  588. }
  590. OggFLAC_API unsigned OggFLAC__stream_encoder_get_max_lpc_order(const OggFLAC__StreamEncoder *encoder)
  591. {
  592. FLAC__ASSERT(0 != encoder);
  593. FLAC__ASSERT(0 != encoder->private_);
  594. FLAC__ASSERT(0 != encoder->protected_);
  595. return FLAC__stream_encoder_get_max_lpc_order(encoder->private_->FLAC_stream_encoder);
  596. }
  598. OggFLAC_API unsigned OggFLAC__stream_encoder_get_qlp_coeff_precision(const OggFLAC__StreamEncoder *encoder)
  599. {
  600. FLAC__ASSERT(0 != encoder);
  601. FLAC__ASSERT(0 != encoder->private_);
  602. FLAC__ASSERT(0 != encoder->protected_);
  603. return FLAC__stream_encoder_get_qlp_coeff_precision(encoder->private_->FLAC_stream_encoder);
  604. }
  606. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_do_qlp_coeff_prec_search(const OggFLAC__StreamEncoder *encoder)
  607. {
  608. FLAC__ASSERT(0 != encoder);
  609. FLAC__ASSERT(0 != encoder->private_);
  610. FLAC__ASSERT(0 != encoder->protected_);
  611. return FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder->private_->FLAC_stream_encoder);
  612. }
  614. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_do_escape_coding(const OggFLAC__StreamEncoder *encoder)
  615. {
  616. FLAC__ASSERT(0 != encoder);
  617. FLAC__ASSERT(0 != encoder->private_);
  618. FLAC__ASSERT(0 != encoder->protected_);
  619. return FLAC__stream_encoder_get_do_escape_coding(encoder->private_->FLAC_stream_encoder);
  620. }
  622. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_do_exhaustive_model_search(const OggFLAC__StreamEncoder *encoder)
  623. {
  624. FLAC__ASSERT(0 != encoder);
  625. FLAC__ASSERT(0 != encoder->private_);
  626. FLAC__ASSERT(0 != encoder->protected_);
  627. return FLAC__stream_encoder_get_do_exhaustive_model_search(encoder->private_->FLAC_stream_encoder);
  628. }
  630. OggFLAC_API unsigned OggFLAC__stream_encoder_get_min_residual_partition_order(const OggFLAC__StreamEncoder *encoder)
  631. {
  632. FLAC__ASSERT(0 != encoder);
  633. FLAC__ASSERT(0 != encoder->private_);
  634. FLAC__ASSERT(0 != encoder->protected_);
  635. return FLAC__stream_encoder_get_min_residual_partition_order(encoder->private_->FLAC_stream_encoder);
  636. }
  638. OggFLAC_API unsigned OggFLAC__stream_encoder_get_max_residual_partition_order(const OggFLAC__StreamEncoder *encoder)
  639. {
  640. FLAC__ASSERT(0 != encoder);
  641. FLAC__ASSERT(0 != encoder->private_);
  642. FLAC__ASSERT(0 != encoder->protected_);
  643. return FLAC__stream_encoder_get_max_residual_partition_order(encoder->private_->FLAC_stream_encoder);
  644. }
  646. OggFLAC_API unsigned OggFLAC__stream_encoder_get_rice_parameter_search_dist(const OggFLAC__StreamEncoder *encoder)
  647. {
  648. FLAC__ASSERT(0 != encoder);
  649. FLAC__ASSERT(0 != encoder->private_);
  650. FLAC__ASSERT(0 != encoder->protected_);
  651. return FLAC__stream_encoder_get_rice_parameter_search_dist(encoder->private_->FLAC_stream_encoder);
  652. }
  654. OggFLAC_API FLAC__uint64 OggFLAC__stream_encoder_get_total_samples_estimate(const OggFLAC__StreamEncoder *encoder)
  655. {
  656. FLAC__ASSERT(0 != encoder);
  657. FLAC__ASSERT(0 != encoder->private_);
  658. FLAC__ASSERT(0 != encoder->protected_);
  659. return FLAC__stream_encoder_get_total_samples_estimate(encoder->private_->FLAC_stream_encoder);
  660. }
  662. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_process(OggFLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples)
  663. {
  664. FLAC__ASSERT(0 != encoder);
  665. FLAC__ASSERT(0 != encoder->private_);
  666. FLAC__ASSERT(0 != encoder->protected_);
  667. return FLAC__stream_encoder_process(encoder->private_->FLAC_stream_encoder, buffer, samples);
  668. }
  670. OggFLAC_API FLAC__bool OggFLAC__stream_encoder_process_interleaved(OggFLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples)
  671. {
  672. FLAC__ASSERT(0 != encoder);
  673. FLAC__ASSERT(0 != encoder->private_);
  674. FLAC__ASSERT(0 != encoder->protected_);
  675. return FLAC__stream_encoder_process_interleaved(encoder->private_->FLAC_stream_encoder, buffer, samples);
  676. }
  678. /***********************************************************************
  679.  *
  680.  * Private class methods
  681.  *
  682.  ***********************************************************************/
  684. void set_defaults_(OggFLAC__StreamEncoder *encoder)
  685. {
  686. FLAC__ASSERT(0 != encoder);
  688. encoder->private_->write_callback = 0;
  689. encoder->private_->metadata_callback = 0;
  690. encoder->private_->client_data = 0;
  691. OggFLAC__ogg_encoder_aspect_set_defaults(&encoder->protected_->ogg_encoder_aspect);
  692. }
  694. FLAC__StreamEncoderWriteStatus write_callback_(const FLAC__StreamEncoder *unused, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
  695. {
  696. OggFLAC__StreamEncoder *encoder = (OggFLAC__StreamEncoder*)client_data;
  697. const FLAC__uint64 total_samples_estimate = FLAC__stream_encoder_get_total_samples_estimate(encoder->private_->FLAC_stream_encoder);
  699. (void)unused;
  700. FLAC__ASSERT(encoder->private_->FLAC_stream_encoder == unused);
  702. return OggFLAC__ogg_encoder_aspect_write_callback_wrapper(&encoder->protected_->ogg_encoder_aspect, total_samples_estimate, buffer, bytes, samples, current_frame, (OggFLAC__OggEncoderAspectWriteCallbackProxy)encoder->private_->write_callback, encoder, encoder->private_->client_data);
  703. }
  705. void metadata_callback_(const FLAC__StreamEncoder *unused, const FLAC__StreamMetadata *metadata, void *client_data)
  706. {
  707. OggFLAC__StreamEncoder *encoder = (OggFLAC__StreamEncoder*)client_data;
  709. (void)unused;
  710. FLAC__ASSERT(encoder->private_->FLAC_stream_encoder == unused);
  712. encoder->private_->metadata_callback(encoder, metadata, encoder->private_->client_data);
  713. }