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

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

Windows CE

开发平台：

C/C++

stream_encoder_framing.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 <string.h> /* for strlen() */
  34. #include "private/stream_encoder_framing.h"
  35. #include "private/crc.h"
  36. #include "FLAC/assert.h"
  38. #ifdef max
  39. #undef max
  40. #endif
  41. #define max(x,y) ((x)>(y)?(x):(y))
  43. static FLAC__bool add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method);
  44. static FLAC__bool add_residual_partitioned_rice_(FLAC__BitBuffer *bb, const FLAC__int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned rice_parameters[], const unsigned raw_bits[], const unsigned partition_order);
  46. FLAC__bool FLAC__add_metadata_block(const FLAC__StreamMetadata *metadata, FLAC__BitBuffer *bb)
  47. {
  48. unsigned i, j;
  49. const unsigned vendor_string_length = (unsigned)strlen(FLAC__VENDOR_STRING);
  51. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->is_last, FLAC__STREAM_METADATA_IS_LAST_LEN))
  52. return false;
  54. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->type, FLAC__STREAM_METADATA_TYPE_LEN))
  55. return false;
  57. /*
  58.  * First, for VORBIS_COMMENTs, adjust the length to reflect our vendor string
  59.  */
  60. i = metadata->length;
  61. if(metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
  62. FLAC__ASSERT(metadata->data.vorbis_comment.vendor_string.length == 0 || 0 != metadata->data.vorbis_comment.vendor_string.entry);
  63. i -= metadata->data.vorbis_comment.vendor_string.length;
  64. i += vendor_string_length;
  65. }
  66. FLAC__ASSERT(i < (1u << FLAC__STREAM_METADATA_LENGTH_LEN));
  67. if(!FLAC__bitbuffer_write_raw_uint32(bb, i, FLAC__STREAM_METADATA_LENGTH_LEN))
  68. return false;
  70. switch(metadata->type) {
  71. case FLAC__METADATA_TYPE_STREAMINFO:
  72. FLAC__ASSERT(metadata->data.stream_info.min_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN));
  73. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.min_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN))
  74. return false;
  75. FLAC__ASSERT(metadata->data.stream_info.max_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN));
  76. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.max_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN))
  77. return false;
  78. FLAC__ASSERT(metadata->data.stream_info.min_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN));
  79. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.min_framesize, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN))
  80. return false;
  81. FLAC__ASSERT(metadata->data.stream_info.max_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN));
  82. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.max_framesize, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN))
  83. return false;
  84. FLAC__ASSERT(FLAC__format_sample_rate_is_valid(metadata->data.stream_info.sample_rate));
  85. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.sample_rate, FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN))
  86. return false;
  87. FLAC__ASSERT(metadata->data.stream_info.channels > 0);
  88. FLAC__ASSERT(metadata->data.stream_info.channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN));
  89. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.channels-1, FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN))
  90. return false;
  91. FLAC__ASSERT(metadata->data.stream_info.bits_per_sample > 0);
  92. FLAC__ASSERT(metadata->data.stream_info.bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN));
  93. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.bits_per_sample-1, FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN))
  94. return false;
  95. if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.stream_info.total_samples, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN))
  96. return false;
  97. if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.stream_info.md5sum, 16))
  98. return false;
  99. break;
  100. case FLAC__METADATA_TYPE_PADDING:
  101. if(!FLAC__bitbuffer_write_zeroes(bb, metadata->length * 8))
  102. return false;
  103. break;
  104. case FLAC__METADATA_TYPE_APPLICATION:
  105. if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8))
  106. return false;
  107. if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.application.data, metadata->length - (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8)))
  108. return false;
  109. break;
  110. case FLAC__METADATA_TYPE_SEEKTABLE:
  111. for(i = 0; i < metadata->data.seek_table.num_points; i++) {
  112. if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.seek_table.points[i].sample_number, FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN))
  113. return false;
  114. if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.seek_table.points[i].stream_offset, FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN))
  115. return false;
  116. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.seek_table.points[i].frame_samples, FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN))
  117. return false;
  118. }
  119. break;
  120. case FLAC__METADATA_TYPE_VORBIS_COMMENT:
  121. if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, vendor_string_length))
  122. return false;
  123. if(!FLAC__bitbuffer_write_byte_block(bb, (const FLAC__byte*)FLAC__VENDOR_STRING, vendor_string_length))
  124. return false;
  125. if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, metadata->data.vorbis_comment.num_comments))
  126. return false;
  127. for(i = 0; i < metadata->data.vorbis_comment.num_comments; i++) {
  128. if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, metadata->data.vorbis_comment.comments[i].length))
  129. return false;
  130. if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.vorbis_comment.comments[i].entry, metadata->data.vorbis_comment.comments[i].length))
  131. return false;
  132. }
  133. break;
  134. case FLAC__METADATA_TYPE_CUESHEET:
  135. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN % 8 == 0);
  136. if(!FLAC__bitbuffer_write_byte_block(bb, (const FLAC__byte*)metadata->data.cue_sheet.media_catalog_number, FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN/8))
  137. return false;
  138. if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.cue_sheet.lead_in, FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN))
  139. return false;
  140. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.cue_sheet.is_cd? 1 : 0, FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN))
  141. return false;
  142. if(!FLAC__bitbuffer_write_zeroes(bb, FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN))
  143. return false;
  144. if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.cue_sheet.num_tracks, FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN))
  145. return false;
  146. for(i = 0; i < metadata->data.cue_sheet.num_tracks; i++) {
  147. const FLAC__StreamMetadata_CueSheet_Track *track = metadata->data.cue_sheet.tracks + i;
  149. if(!FLAC__bitbuffer_write_raw_uint64(bb, track->offset, FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN))
  150. return false;
  151. if(!FLAC__bitbuffer_write_raw_uint32(bb, track->number, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN))
  152. return false;
  153. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN % 8 == 0);
  154. if(!FLAC__bitbuffer_write_byte_block(bb, (const FLAC__byte*)track->isrc, FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN/8))
  155. return false;
  156. if(!FLAC__bitbuffer_write_raw_uint32(bb, track->type, FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN))
  157. return false;
  158. if(!FLAC__bitbuffer_write_raw_uint32(bb, track->pre_emphasis, FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN))
  159. return false;
  160. if(!FLAC__bitbuffer_write_zeroes(bb, FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN))
  161. return false;
  162. if(!FLAC__bitbuffer_write_raw_uint32(bb, track->num_indices, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN))
  163. return false;
  164. for(j = 0; j < track->num_indices; j++) {
  165. const FLAC__StreamMetadata_CueSheet_Index *index = track->indices + j;
  167. if(!FLAC__bitbuffer_write_raw_uint64(bb, index->offset, FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN))
  168. return false;
  169. if(!FLAC__bitbuffer_write_raw_uint32(bb, index->number, FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN))
  170. return false;
  171. if(!FLAC__bitbuffer_write_zeroes(bb, FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN))
  172. return false;
  173. }
  174. }
  175. break;
  176. default:
  177. if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.unknown.data, metadata->length))
  178. return false;
  179. break;
  180. }
  182. FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(bb));
  183. return true;
  184. }
  186. FLAC__bool FLAC__frame_add_header(const FLAC__FrameHeader *header, FLAC__bool streamable_subset, FLAC__BitBuffer *bb)
  187. {
  188. unsigned u, blocksize_hint, sample_rate_hint;
  190. FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(bb));
  192. if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__FRAME_HEADER_SYNC, FLAC__FRAME_HEADER_SYNC_LEN))
  193. return false;
  195. if(!FLAC__bitbuffer_write_raw_uint32(bb, 0, FLAC__FRAME_HEADER_RESERVED_LEN))
  196. return false;
  198. FLAC__ASSERT(header->blocksize > 0 && header->blocksize <= FLAC__MAX_BLOCK_SIZE);
  199. /* when this assertion holds true, any legal blocksize can be expressed in the frame header */
  200. FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE <= 65535u);
  201. blocksize_hint = 0;
  202. switch(header->blocksize) {
  203. case   192: u = 1; break;
  204. case   576: u = 2; break;
  205. case  1152: u = 3; break;
  206. case  2304: u = 4; break;
  207. case  4608: u = 5; break;
  208. case   256: u = 8; break;
  209. case   512: u = 9; break;
  210. case  1024: u = 10; break;
  211. case  2048: u = 11; break;
  212. case  4096: u = 12; break;
  213. case  8192: u = 13; break;
  214. case 16384: u = 14; break;
  215. case 32768: u = 15; break;
  216. default:
  217. if(header->blocksize <= 0x100)
  218. blocksize_hint = u = 6;
  219. else if(header->blocksize <= 0x10000)
  220. blocksize_hint = u = 7;
  221. else {
  222. FLAC__ASSERT(0);
  223. return false;
  224. }
  225. break;
  226. }
  227. if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_BLOCK_SIZE_LEN))
  228. return false;
  230. FLAC__ASSERT(FLAC__format_sample_rate_is_valid(header->sample_rate));
  231. sample_rate_hint = 0;
  232. switch(header->sample_rate) {
  233. case  8000: u = 4; break;
  234. case 16000: u = 5; break;
  235. case 22050: u = 6; break;
  236. case 24000: u = 7; break;
  237. case 32000: u = 8; break;
  238. case 44100: u = 9; break;
  239. case 48000: u = 10; break;
  240. case 96000: u = 11; break;
  241. default:
  242. if(header->sample_rate <= 255000 && header->sample_rate % 1000 == 0)
  243. sample_rate_hint = u = 12;
  244. else if(header->sample_rate % 10 == 0)
  245. sample_rate_hint = u = 14;
  246. else if(header->sample_rate <= 0xffff)
  247. sample_rate_hint = u = 13;
  248. else if(streamable_subset) {
  249. FLAC__ASSERT(0);
  250. return false;
  251. }
  252. else
  253. u = 0;
  254. break;
  255. }
  256. if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_SAMPLE_RATE_LEN))
  257. return false;
  259. FLAC__ASSERT(header->channels > 0 && header->channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN) && header->channels <= FLAC__MAX_CHANNELS);
  260. switch(header->channel_assignment) {
  261. case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
  262. u = header->channels - 1;
  263. break;
  264. case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
  265. FLAC__ASSERT(header->channels == 2);
  266. u = 8;
  267. break;
  268. case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
  269. FLAC__ASSERT(header->channels == 2);
  270. u = 9;
  271. break;
  272. case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
  273. FLAC__ASSERT(header->channels == 2);
  274. u = 10;
  275. break;
  276. default:
  277. FLAC__ASSERT(0);
  278. }
  279. if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN))
  280. return false;
  282. FLAC__ASSERT(header->bits_per_sample > 0 && header->bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN));
  283. switch(header->bits_per_sample) {
  284. case 8 : u = 1; break;
  285. case 12: u = 2; break;
  286. case 16: u = 4; break;
  287. case 20: u = 5; break;
  288. case 24: u = 6; break;
  289. default: u = 0; break;
  290. }
  291. if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN))
  292. return false;
  294. if(!FLAC__bitbuffer_write_raw_uint32(bb, 0, FLAC__FRAME_HEADER_ZERO_PAD_LEN))
  295. return false;
  297. FLAC__ASSERT(header->number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER);
  298. if(!FLAC__bitbuffer_write_utf8_uint32(bb, header->number.frame_number))
  299. return false;
  301. if(blocksize_hint)
  302. if(!FLAC__bitbuffer_write_raw_uint32(bb, header->blocksize-1, (blocksize_hint==6)? 8:16))
  303. return false;
  305. switch(sample_rate_hint) {
  306. case 12:
  307. if(!FLAC__bitbuffer_write_raw_uint32(bb, header->sample_rate / 1000, 8))
  308. return false;
  309. break;
  310. case 13:
  311. if(!FLAC__bitbuffer_write_raw_uint32(bb, header->sample_rate, 16))
  312. return false;
  313. break;
  314. case 14:
  315. if(!FLAC__bitbuffer_write_raw_uint32(bb, header->sample_rate / 10, 16))
  316. return false;
  317. break;
  318. }
  320. /* write the CRC */
  321. if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__bitbuffer_get_write_crc8(bb), FLAC__FRAME_HEADER_CRC_LEN))
  322. return false;
  324. return true;
  325. }
  327. FLAC__bool FLAC__subframe_add_constant(const FLAC__Subframe_Constant *subframe, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
  328. {
  329. FLAC__bool ok;
  331. ok =
  332. FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN) &&
  333. (wasted_bits? FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1) : true) &&
  334. FLAC__bitbuffer_write_raw_int32(bb, subframe->value, subframe_bps)
  335. ;
  337. return ok;
  338. }
  340. FLAC__bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
  341. {
  342. unsigned i;
  344. if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK | (subframe->order<<1) | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN))
  345. return false;
  346. if(wasted_bits)
  347. if(!FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1))
  348. return false;
  350. for(i = 0; i < subframe->order; i++)
  351. if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->warmup[i], subframe_bps))
  352. return false;
  354. if(!add_entropy_coding_method_(bb, &subframe->entropy_coding_method))
  355. return false;
  356. switch(subframe->entropy_coding_method.type) {
  357. case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
  358. if(!add_residual_partitioned_rice_(bb, subframe->residual, residual_samples, subframe->order, subframe->entropy_coding_method.data.partitioned_rice.contents->parameters, subframe->entropy_coding_method.data.partitioned_rice.contents->raw_bits, subframe->entropy_coding_method.data.partitioned_rice.order))
  359. return false;
  360. break;
  361. default:
  362. FLAC__ASSERT(0);
  363. }
  365. return true;
  366. }
  368. FLAC__bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
  369. {
  370. unsigned i;
  372. if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK | ((subframe->order-1)<<1) | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN))
  373. return false;
  374. if(wasted_bits)
  375. if(!FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1))
  376. return false;
  378. for(i = 0; i < subframe->order; i++)
  379. if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->warmup[i], subframe_bps))
  380. return false;
  382. if(!FLAC__bitbuffer_write_raw_uint32(bb, subframe->qlp_coeff_precision-1, FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN))
  383. return false;
  384. if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->quantization_level, FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN))
  385. return false;
  386. for(i = 0; i < subframe->order; i++)
  387. if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->qlp_coeff[i], subframe->qlp_coeff_precision))
  388. return false;
  390. if(!add_entropy_coding_method_(bb, &subframe->entropy_coding_method))
  391. return false;
  392. switch(subframe->entropy_coding_method.type) {
  393. case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
  394. if(!add_residual_partitioned_rice_(bb, subframe->residual, residual_samples, subframe->order, subframe->entropy_coding_method.data.partitioned_rice.contents->parameters, subframe->entropy_coding_method.data.partitioned_rice.contents->raw_bits, subframe->entropy_coding_method.data.partitioned_rice.order))
  395. return false;
  396. break;
  397. default:
  398. FLAC__ASSERT(0);
  399. }
  401. return true;
  402. }
  404. FLAC__bool FLAC__subframe_add_verbatim(const FLAC__Subframe_Verbatim *subframe, unsigned samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
  405. {
  406. unsigned i;
  407. const FLAC__int32 *signal = subframe->data;
  409. if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN))
  410. return false;
  411. if(wasted_bits)
  412. if(!FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1))
  413. return false;
  415. for(i = 0; i < samples; i++)
  416. if(!FLAC__bitbuffer_write_raw_int32(bb, signal[i], subframe_bps))
  417. return false;
  419. return true;
  420. }
  422. FLAC__bool add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method)
  423. {
  424. if(!FLAC__bitbuffer_write_raw_uint32(bb, method->type, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN))
  425. return false;
  426. switch(method->type) {
  427. case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
  428. if(!FLAC__bitbuffer_write_raw_uint32(bb, method->data.partitioned_rice.order, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN))
  429. return false;
  430. break;
  431. default:
  432. FLAC__ASSERT(0);
  433. }
  434. return true;
  435. }
  437. FLAC__bool add_residual_partitioned_rice_(FLAC__BitBuffer *bb, const FLAC__int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned rice_parameters[], const unsigned raw_bits[], const unsigned partition_order)
  438. {
  439. if(partition_order == 0) {
  440. unsigned i;
  442. if(!FLAC__bitbuffer_write_raw_uint32(bb, rice_parameters[0], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN))
  443. return false;
  444. if(rice_parameters[0] < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
  445. for(i = 0; i < residual_samples; i++) {
  446. #ifdef FLAC__SYMMETRIC_RICE
  447. if(!FLAC__bitbuffer_write_symmetric_rice_signed(bb, residual[i], rice_parameters[0]))
  448. return false;
  449. #else
  450. if(!FLAC__bitbuffer_write_rice_signed(bb, residual[i], rice_parameters[0]))
  451. return false;
  452. #endif
  453. }
  454. }
  455. else {
  456. if(!FLAC__bitbuffer_write_raw_uint32(bb, raw_bits[0], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN))
  457. return false;
  458. for(i = 0; i < residual_samples; i++) {
  459. if(!FLAC__bitbuffer_write_raw_int32(bb, residual[i], raw_bits[0]))
  460. return false;
  461. }
  462. }
  463. return true;
  464. }
  465. else {
  466. unsigned i, j, k = 0, k_last = 0;
  467. unsigned partition_samples;
  468. const unsigned default_partition_samples = (residual_samples+predictor_order) >> partition_order;
  469. for(i = 0; i < (1u<<partition_order); i++) {
  470. if(!FLAC__bitbuffer_write_raw_uint32(bb, rice_parameters[i], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN))
  471. return false;
  472. partition_samples = default_partition_samples;
  473. if(i == 0)
  474. partition_samples -= predictor_order;
  475. k += partition_samples;
  476. if(rice_parameters[i] < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
  477. for(j = k_last; j < k; j++) {
  478. #ifdef FLAC__SYMMETRIC_RICE
  479. if(!FLAC__bitbuffer_write_symmetric_rice_signed(bb, residual[j], rice_parameters[i]))
  480. return false;
  481. #else
  482. if(!FLAC__bitbuffer_write_rice_signed(bb, residual[j], rice_parameters[i]))
  483. return false;
  484. #endif
  485. }
  486. }
  487. else {
  488. if(!FLAC__bitbuffer_write_raw_uint32(bb, raw_bits[i], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN))
  489. return false;
  490. for(j = k_last; j < k; j++) {
  491. if(!FLAC__bitbuffer_write_raw_int32(bb, residual[j], raw_bits[i]))
  492. return false;
  493. }
  494. }
  495. k_last = k;
  496. }
  497. return true;
  498. }
  499. }