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

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

Windows CE

开发平台：

C/C++

stream_encoder.cpp：源码内容
  1. /* libFLAC++ - Free Lossless Audio Codec 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 "FLAC++/encoder.h"
  33. #include "FLAC++/metadata.h"
  34. #include "FLAC/assert.h"
  36. #ifdef _MSC_VER
  37. // warning C4800: 'int' : forcing to bool 'true' or 'false' (performance warning)
  38. #pragma warning ( disable : 4800 )
  39. #endif
  41. namespace FLAC {
  42. namespace Encoder {
  44. Stream::Stream():
  45. encoder_(::FLAC__stream_encoder_new())
  46. { }
  48. Stream::~Stream()
  49. {
  50. if(0 != encoder_) {
  51. ::FLAC__stream_encoder_finish(encoder_);
  52. ::FLAC__stream_encoder_delete(encoder_);
  53. }
  54. }
  56. bool Stream::is_valid() const
  57. {
  58. return 0 != encoder_;
  59. }
  61. bool Stream::set_verify(bool value)
  62. {
  63. FLAC__ASSERT(is_valid());
  64. return (bool)::FLAC__stream_encoder_set_verify(encoder_, value);
  65. }
  67. bool Stream::set_streamable_subset(bool value)
  68. {
  69. FLAC__ASSERT(is_valid());
  70. return (bool)::FLAC__stream_encoder_set_streamable_subset(encoder_, value);
  71. }
  73. bool Stream::set_do_mid_side_stereo(bool value)
  74. {
  75. FLAC__ASSERT(is_valid());
  76. return (bool)::FLAC__stream_encoder_set_do_mid_side_stereo(encoder_, value);
  77. }
  79. bool Stream::set_loose_mid_side_stereo(bool value)
  80. {
  81. FLAC__ASSERT(is_valid());
  82. return (bool)::FLAC__stream_encoder_set_loose_mid_side_stereo(encoder_, value);
  83. }
  85. bool Stream::set_channels(unsigned value)
  86. {
  87. FLAC__ASSERT(is_valid());
  88. return (bool)::FLAC__stream_encoder_set_channels(encoder_, value);
  89. }
  91. bool Stream::set_bits_per_sample(unsigned value)
  92. {
  93. FLAC__ASSERT(is_valid());
  94. return (bool)::FLAC__stream_encoder_set_bits_per_sample(encoder_, value);
  95. }
  97. bool Stream::set_sample_rate(unsigned value)
  98. {
  99. FLAC__ASSERT(is_valid());
  100. return (bool)::FLAC__stream_encoder_set_sample_rate(encoder_, value);
  101. }
  103. bool Stream::set_blocksize(unsigned value)
  104. {
  105. FLAC__ASSERT(is_valid());
  106. return (bool)::FLAC__stream_encoder_set_blocksize(encoder_, value);
  107. }
  109. bool Stream::set_max_lpc_order(unsigned value)
  110. {
  111. FLAC__ASSERT(is_valid());
  112. return (bool)::FLAC__stream_encoder_set_max_lpc_order(encoder_, value);
  113. }
  115. bool Stream::set_qlp_coeff_precision(unsigned value)
  116. {
  117. FLAC__ASSERT(is_valid());
  118. return (bool)::FLAC__stream_encoder_set_qlp_coeff_precision(encoder_, value);
  119. }
  121. bool Stream::set_do_qlp_coeff_prec_search(bool value)
  122. {
  123. FLAC__ASSERT(is_valid());
  124. return (bool)::FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder_, value);
  125. }
  127. bool Stream::set_do_escape_coding(bool value)
  128. {
  129. FLAC__ASSERT(is_valid());
  130. return (bool)::FLAC__stream_encoder_set_do_escape_coding(encoder_, value);
  131. }
  133. bool Stream::set_do_exhaustive_model_search(bool value)
  134. {
  135. FLAC__ASSERT(is_valid());
  136. return (bool)::FLAC__stream_encoder_set_do_exhaustive_model_search(encoder_, value);
  137. }
  139. bool Stream::set_min_residual_partition_order(unsigned value)
  140. {
  141. FLAC__ASSERT(is_valid());
  142. return (bool)::FLAC__stream_encoder_set_min_residual_partition_order(encoder_, value);
  143. }
  145. bool Stream::set_max_residual_partition_order(unsigned value)
  146. {
  147. FLAC__ASSERT(is_valid());
  148. return (bool)::FLAC__stream_encoder_set_max_residual_partition_order(encoder_, value);
  149. }
  151. bool Stream::set_rice_parameter_search_dist(unsigned value)
  152. {
  153. FLAC__ASSERT(is_valid());
  154. return (bool)::FLAC__stream_encoder_set_rice_parameter_search_dist(encoder_, value);
  155. }
  157. bool Stream::set_total_samples_estimate(FLAC__uint64 value)
  158. {
  159. FLAC__ASSERT(is_valid());
  160. return (bool)::FLAC__stream_encoder_set_total_samples_estimate(encoder_, value);
  161. }
  163. bool Stream::set_metadata(::FLAC__StreamMetadata **metadata, unsigned num_blocks)
  164. {
  165. FLAC__ASSERT(is_valid());
  166. return (bool)::FLAC__stream_encoder_set_metadata(encoder_, metadata, num_blocks);
  167. }
  169. bool Stream::set_metadata(FLAC::Metadata::Prototype **metadata, unsigned num_blocks)
  170. {
  171. FLAC__ASSERT(is_valid());
  172. #if (defined _MSC_VER) || (defined __SUNPRO_CC)
  173. // MSVC++ can't handle:
  174. // ::FLAC__StreamMetadata *m[num_blocks];
  175. // so we do this ugly workaround
  176. ::FLAC__StreamMetadata **m = new ::FLAC__StreamMetadata*[num_blocks];
  177. #else
  178. ::FLAC__StreamMetadata *m[num_blocks];
  179. #endif
  180. for(unsigned i = 0; i < num_blocks; i++) {
  181. // we can get away with this since we know the encoder will only correct the is_last flags
  182. m[i] = const_cast< ::FLAC__StreamMetadata*>((::FLAC__StreamMetadata*)metadata[i]);
  183. }
  184. #if (defined _MSC_VER) || (defined __SUNPRO_CC)
  185. // complete the hack
  186. const bool ok = (bool)::FLAC__stream_encoder_set_metadata(encoder_, m, num_blocks);
  187. delete [] m;
  188. return ok;
  189. #else
  190. return (bool)::FLAC__stream_encoder_set_metadata(encoder_, m, num_blocks);
  191. #endif
  192. }
  194. Stream::State Stream::get_state() const
  195. {
  196. FLAC__ASSERT(is_valid());
  197. return State(::FLAC__stream_encoder_get_state(encoder_));
  198. }
  200. Decoder::Stream::State Stream::get_verify_decoder_state() const
  201. {
  202. FLAC__ASSERT(is_valid());
  203. return Decoder::Stream::State(::FLAC__stream_encoder_get_verify_decoder_state(encoder_));
  204. }
  206. void Stream::get_verify_decoder_error_stats(FLAC__uint64 *absolute_sample, unsigned *frame_number, unsigned *channel, unsigned *sample, FLAC__int32 *expected, FLAC__int32 *got)
  207. {
  208. FLAC__ASSERT(is_valid());
  209. ::FLAC__stream_encoder_get_verify_decoder_error_stats(encoder_, absolute_sample, frame_number, channel, sample, expected, got);
  210. }
  212. bool Stream::get_verify() const
  213. {
  214. FLAC__ASSERT(is_valid());
  215. return (bool)::FLAC__stream_encoder_get_verify(encoder_);
  216. }
  218. bool Stream::get_streamable_subset() const
  219. {
  220. FLAC__ASSERT(is_valid());
  221. return (bool)::FLAC__stream_encoder_get_streamable_subset(encoder_);
  222. }
  224. bool Stream::get_do_mid_side_stereo() const
  225. {
  226. FLAC__ASSERT(is_valid());
  227. return (bool)::FLAC__stream_encoder_get_do_mid_side_stereo(encoder_);
  228. }
  230. bool Stream::get_loose_mid_side_stereo() const
  231. {
  232. FLAC__ASSERT(is_valid());
  233. return (bool)::FLAC__stream_encoder_get_loose_mid_side_stereo(encoder_);
  234. }
  236. unsigned Stream::get_channels() const
  237. {
  238. FLAC__ASSERT(is_valid());
  239. return ::FLAC__stream_encoder_get_channels(encoder_);
  240. }
  242. unsigned Stream::get_bits_per_sample() const
  243. {
  244. FLAC__ASSERT(is_valid());
  245. return ::FLAC__stream_encoder_get_bits_per_sample(encoder_);
  246. }
  248. unsigned Stream::get_sample_rate() const
  249. {
  250. FLAC__ASSERT(is_valid());
  251. return ::FLAC__stream_encoder_get_sample_rate(encoder_);
  252. }
  254. unsigned Stream::get_blocksize() const
  255. {
  256. FLAC__ASSERT(is_valid());
  257. return ::FLAC__stream_encoder_get_blocksize(encoder_);
  258. }
  260. unsigned Stream::get_max_lpc_order() const
  261. {
  262. FLAC__ASSERT(is_valid());
  263. return ::FLAC__stream_encoder_get_max_lpc_order(encoder_);
  264. }
  266. unsigned Stream::get_qlp_coeff_precision() const
  267. {
  268. FLAC__ASSERT(is_valid());
  269. return ::FLAC__stream_encoder_get_qlp_coeff_precision(encoder_);
  270. }
  272. bool Stream::get_do_qlp_coeff_prec_search() const
  273. {
  274. FLAC__ASSERT(is_valid());
  275. return (bool)::FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder_);
  276. }
  278. bool Stream::get_do_escape_coding() const
  279. {
  280. FLAC__ASSERT(is_valid());
  281. return (bool)::FLAC__stream_encoder_get_do_escape_coding(encoder_);
  282. }
  284. bool Stream::get_do_exhaustive_model_search() const
  285. {
  286. FLAC__ASSERT(is_valid());
  287. return (bool)::FLAC__stream_encoder_get_do_exhaustive_model_search(encoder_);
  288. }
  290. unsigned Stream::get_min_residual_partition_order() const
  291. {
  292. FLAC__ASSERT(is_valid());
  293. return ::FLAC__stream_encoder_get_min_residual_partition_order(encoder_);
  294. }
  296. unsigned Stream::get_max_residual_partition_order() const
  297. {
  298. FLAC__ASSERT(is_valid());
  299. return ::FLAC__stream_encoder_get_max_residual_partition_order(encoder_);
  300. }
  302. unsigned Stream::get_rice_parameter_search_dist() const
  303. {
  304. FLAC__ASSERT(is_valid());
  305. return ::FLAC__stream_encoder_get_rice_parameter_search_dist(encoder_);
  306. }
  308. FLAC__uint64 Stream::get_total_samples_estimate() const
  309. {
  310. FLAC__ASSERT(is_valid());
  311. return ::FLAC__stream_encoder_get_total_samples_estimate(encoder_);
  312. }
  314. Stream::State Stream::init()
  315. {
  316. FLAC__ASSERT(is_valid());
  317. ::FLAC__stream_encoder_set_write_callback(encoder_, write_callback_);
  318. ::FLAC__stream_encoder_set_metadata_callback(encoder_, metadata_callback_);
  319. ::FLAC__stream_encoder_set_client_data(encoder_, (void*)this);
  320. return State(::FLAC__stream_encoder_init(encoder_));
  321. }
  323. void Stream::finish()
  324. {
  325. FLAC__ASSERT(is_valid());
  326. ::FLAC__stream_encoder_finish(encoder_);
  327. }
  329. bool Stream::process(const FLAC__int32 * const buffer[], unsigned samples)
  330. {
  331. FLAC__ASSERT(is_valid());
  332. return (bool)::FLAC__stream_encoder_process(encoder_, buffer, samples);
  333. }
  335. bool Stream::process_interleaved(const FLAC__int32 buffer[], unsigned samples)
  336. {
  337. FLAC__ASSERT(is_valid());
  338. return (bool)::FLAC__stream_encoder_process_interleaved(encoder_, buffer, samples);
  339. }
  341. ::FLAC__StreamEncoderWriteStatus Stream::write_callback_(const ::FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
  342. {
  343. (void)encoder;
  344. FLAC__ASSERT(0 != client_data);
  345. Stream *instance = reinterpret_cast<Stream *>(client_data);
  346. FLAC__ASSERT(0 != instance);
  347. return instance->write_callback(buffer, bytes, samples, current_frame);
  348. }
  350. void Stream::metadata_callback_(const ::FLAC__StreamEncoder *encoder, const ::FLAC__StreamMetadata *metadata, void *client_data)
  351. {
  352. (void)encoder;
  353. FLAC__ASSERT(0 != client_data);
  354. Stream *instance = reinterpret_cast<Stream *>(client_data);
  355. FLAC__ASSERT(0 != instance);
  356. instance->metadata_callback(metadata);
  357. }
  359. }
  360. }