src/libFLAC/stream_encoder_framing.c

   1 /* libFLAC - Free Lossless Audio Codec library
   2  * Copyright (C) 2000,2001,2002  Josh Coalson
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA  02111-1307, USA.
  18  */
  19
  20 #include <stdio.h>
  21 #include <string.h> /* for strlen() */
  22 #include "private/stream_encoder_framing.h"
  23 #include "private/crc.h"
  24 #include "FLAC/assert.h"
  25
  26 #ifdef max
  27 #undef max
  28 #endif
  29 #define max(x,y) ((x)>(y)?(x):(y))
  30
  31 static FLAC__bool add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method);
  32 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);
  33
  34 FLAC__bool FLAC__add_metadata_block(const FLAC__StreamMetadata *metadata, FLAC__BitBuffer *bb)
  35 {
  36         unsigned i;
  37         const unsigned vendor_string_length = (unsigned)strlen(FLAC__VENDOR_STRING);
  38
  39         if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->is_last, FLAC__STREAM_METADATA_IS_LAST_LEN))
  40                 return false;
  41
  42         if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->type, FLAC__STREAM_METADATA_TYPE_LEN))
  43                 return false;
  44
  45         /*
  46          * First, for VORBIS_COMMENTs, adjust the length to reflect our vendor string
  47          */
  48         i = metadata->length;
  49         if(metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
  50                 i -= metadata->data.vorbis_comment.vendor_string.length;
  51                 i += vendor_string_length;
  52         }
  53         FLAC__ASSERT(i < (1u << FLAC__STREAM_METADATA_LENGTH_LEN));
  54         if(!FLAC__bitbuffer_write_raw_uint32(bb, i, FLAC__STREAM_METADATA_LENGTH_LEN))
  55                 return false;
  56
  57         switch(metadata->type) {
  58                 case FLAC__METADATA_TYPE_STREAMINFO:
  59                         FLAC__ASSERT(metadata->data.stream_info.min_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN));
  60                         if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.min_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN))
  61                                 return false;
  62                         FLAC__ASSERT(metadata->data.stream_info.max_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN));
  63                         if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.max_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN))
  64                                 return false;
  65                         FLAC__ASSERT(metadata->data.stream_info.min_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN));
  66                         if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.min_framesize, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN))
  67                                 return false;
  68                         FLAC__ASSERT(metadata->data.stream_info.max_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN));
  69                         if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.max_framesize, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN))
  70                                 return false;
  71                         FLAC__ASSERT(FLAC__format_sample_rate_is_valid(metadata->data.stream_info.sample_rate));
  72                         if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.sample_rate, FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN))
  73                                 return false;
  74                         FLAC__ASSERT(metadata->data.stream_info.channels > 0);
  75                         FLAC__ASSERT(metadata->data.stream_info.channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN));
  76                         if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.channels-1, FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN))
  77                                 return false;
  78                         FLAC__ASSERT(metadata->data.stream_info.bits_per_sample > 0);
  79                         FLAC__ASSERT(metadata->data.stream_info.bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN));
  80                         if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.bits_per_sample-1, FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN))
  81                                 return false;
  82                         if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.stream_info.total_samples, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN))
  83                                 return false;
  84                         if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.stream_info.md5sum, 16))
  85                                 return false;
  86                         break;
  87                 case FLAC__METADATA_TYPE_PADDING:
  88                         if(!FLAC__bitbuffer_write_zeroes(bb, metadata->length * 8))
  89                                 return false;
  90                         break;
  91                 case FLAC__METADATA_TYPE_APPLICATION:
  92                         if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8))
  93                                 return false;
  94                         if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.application.data, metadata->length - (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8)))
  95                                 return false;
  96                         break;
  97                 case FLAC__METADATA_TYPE_SEEKTABLE:
  98                         for(i = 0; i < metadata->data.seek_table.num_points; i++) {
  99                                 if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.seek_table.points[i].sample_number, FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN))
 100                                         return false;
 101                                 if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.seek_table.points[i].stream_offset, FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN))
 102                                         return false;
 103                                 if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.seek_table.points[i].frame_samples, FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN))
 104                                         return false;
 105                         }
 106                         break;
 107                 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
 108                         if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, vendor_string_length))
 109                                 return false;
 110                         if(!FLAC__bitbuffer_write_byte_block(bb, (const FLAC__byte*)FLAC__VENDOR_STRING, vendor_string_length))
 111                                 return false;
 112                         if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, metadata->data.vorbis_comment.num_comments))
 113                                 return false;
 114                         for(i = 0; i < metadata->data.vorbis_comment.num_comments; i++) {
 115                                 if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, metadata->data.vorbis_comment.comments[i].length))
 116                                         return false;
 117                                 if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.vorbis_comment.comments[i].entry, metadata->data.vorbis_comment.comments[i].length))
 118                                         return false;
 119                         }
 120                         break;
 121                 default:
 122                         FLAC__ASSERT(0);
 123         }
 124
 125         return true;
 126 }
 127
 128 FLAC__bool FLAC__frame_add_header(const FLAC__FrameHeader *header, FLAC__bool streamable_subset, FLAC__bool is_last_block, FLAC__BitBuffer *bb)
 129 {
 130         unsigned u, blocksize_hint, sample_rate_hint;
 131
 132         FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(bb));
 133
 134         if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__FRAME_HEADER_SYNC, FLAC__FRAME_HEADER_SYNC_LEN))
 135                 return false;
 136
 137         if(!FLAC__bitbuffer_write_raw_uint32(bb, 0, FLAC__FRAME_HEADER_RESERVED_LEN))
 138                 return false;
 139
 140         FLAC__ASSERT(header->blocksize > 0 && header->blocksize <= FLAC__MAX_BLOCK_SIZE);
 141         blocksize_hint = 0;
 142         switch(header->blocksize) {
 143                 case   192: u = 1; break;
 144                 case   576: u = 2; break;
 145                 case  1152: u = 3; break;
 146                 case  2304: u = 4; break;
 147                 case  4608: u = 5; break;
 148                 case   256: u = 8; break;
 149                 case   512: u = 9; break;
 150                 case  1024: u = 10; break;
 151                 case  2048: u = 11; break;
 152                 case  4096: u = 12; break;
 153                 case  8192: u = 13; break;
 154                 case 16384: u = 14; break;
 155                 case 32768: u = 15; break;
 156                 default:
 157                         if(streamable_subset || is_last_block) {
 158                                 if(header->blocksize <= 0x100)
 159                                         blocksize_hint = u = 6;
 160                                 else
 161                                         blocksize_hint = u = 7;
 162                         }
 163                         else
 164                                 u = 0;
 165                         break;
 166         }
 167         if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_BLOCK_SIZE_LEN))
 168                 return false;
 169
 170         FLAC__ASSERT(FLAC__format_sample_rate_is_valid(header->sample_rate));
 171         sample_rate_hint = 0;
 172         switch(header->sample_rate) {
 173                 case  8000: u = 4; break;
 174                 case 16000: u = 5; break;
 175                 case 22050: u = 6; break;
 176                 case 24000: u = 7; break;
 177                 case 32000: u = 8; break;
 178                 case 44100: u = 9; break;
 179                 case 48000: u = 10; break;
 180                 case 96000: u = 11; break;
 181                 default:
 182                         if(streamable_subset) {
 183                                 if(header->sample_rate % 1000 == 0)
 184                                         sample_rate_hint = u = 12;
 185                                 else if(header->sample_rate % 10 == 0)
 186                                         sample_rate_hint = u = 14;
 187                                 else
 188                                         sample_rate_hint = u = 13;
 189                         }
 190                         else
 191                                 u = 0;
 192                         break;
 193         }
 194         if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_SAMPLE_RATE_LEN))
 195                 return false;
 196
 197         FLAC__ASSERT(header->channels > 0 && header->channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN) && header->channels <= FLAC__MAX_CHANNELS);
 198         switch(header->channel_assignment) {
 199                 case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
 200                         u = header->channels - 1;
 201                         break;
 202                 case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
 203                         FLAC__ASSERT(header->channels == 2);
 204                         u = 8;
 205                         break;
 206                 case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
 207                         FLAC__ASSERT(header->channels == 2);
 208                         u = 9;
 209                         break;
 210                 case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
 211                         FLAC__ASSERT(header->channels == 2);
 212                         u = 10;
 213                         break;
 214                 default:
 215                         FLAC__ASSERT(0);
 216         }
 217         if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN))
 218                 return false;
 219
 220         FLAC__ASSERT(header->bits_per_sample > 0 && header->bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN));
 221         switch(header->bits_per_sample) {
 222                 case 8 : u = 1; break;
 223                 case 12: u = 2; break;
 224                 case 16: u = 4; break;
 225                 case 20: u = 5; break;
 226                 case 24: u = 6; break;
 227                 default: u = 0; break;
 228         }
 229         if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN))
 230                 return false;
 231
 232         if(!FLAC__bitbuffer_write_raw_uint32(bb, 0, FLAC__FRAME_HEADER_ZERO_PAD_LEN))
 233                 return false;
 234
 235         FLAC__ASSERT(header->number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER);
 236         if(!FLAC__bitbuffer_write_utf8_uint32(bb, header->number.frame_number))
 237                 return false;
 238
 239         if(blocksize_hint)
 240                 if(!FLAC__bitbuffer_write_raw_uint32(bb, header->blocksize-1, (blocksize_hint==6)? 8:16))
 241                         return false;
 242
 243         switch(sample_rate_hint) {
 244                 case 12:
 245                         if(!FLAC__bitbuffer_write_raw_uint32(bb, header->sample_rate / 1000, 8))
 246                                 return false;
 247                         break;
 248                 case 13:
 249                         if(!FLAC__bitbuffer_write_raw_uint32(bb, header->sample_rate, 16))
 250                                 return false;
 251                         break;
 252                 case 14:
 253                         if(!FLAC__bitbuffer_write_raw_uint32(bb, header->sample_rate / 10, 16))
 254                                 return false;
 255                         break;
 256         }
 257
 258         /* write the CRC */
 259         if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__bitbuffer_get_write_crc8(bb), FLAC__FRAME_HEADER_CRC_LEN))
 260                 return false;
 261
 262         return true;
 263 }
 264
 265 FLAC__bool FLAC__subframe_add_constant(const FLAC__Subframe_Constant *subframe, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
 266 {
 267         FLAC__bool ok;
 268
 269         ok =
 270                 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) &&
 271                 (wasted_bits? FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1) : true) &&
 272                 FLAC__bitbuffer_write_raw_int32(bb, subframe->value, subframe_bps)
 273         ;
 274
 275         return ok;
 276 }
 277
 278 FLAC__bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
 279 {
 280         unsigned i;
 281
 282         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))
 283                 return false;
 284         if(wasted_bits)
 285                 if(!FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1))
 286                         return false;
 287
 288         for(i = 0; i < subframe->order; i++)
 289                 if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->warmup[i], subframe_bps))
 290                         return false;
 291
 292         if(!add_entropy_coding_method_(bb, &subframe->entropy_coding_method))
 293                 return false;
 294         switch(subframe->entropy_coding_method.type) {
 295                 case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
 296                         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))
 297                                 return false;
 298                         break;
 299                 default:
 300                         FLAC__ASSERT(0);
 301         }
 302
 303         return true;
 304 }
 305
 306 FLAC__bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
 307 {
 308         unsigned i;
 309
 310         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))
 311                 return false;
 312         if(wasted_bits)
 313                 if(!FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1))
 314                         return false;
 315
 316         for(i = 0; i < subframe->order; i++)
 317                 if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->warmup[i], subframe_bps))
 318                         return false;
 319
 320         if(!FLAC__bitbuffer_write_raw_uint32(bb, subframe->qlp_coeff_precision-1, FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN))
 321                 return false;
 322         if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->quantization_level, FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN))
 323                 return false;
 324         for(i = 0; i < subframe->order; i++)
 325                 if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->qlp_coeff[i], subframe->qlp_coeff_precision))
 326                         return false;
 327
 328         if(!add_entropy_coding_method_(bb, &subframe->entropy_coding_method))
 329                 return false;
 330         switch(subframe->entropy_coding_method.type) {
 331                 case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
 332                         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))
 333                                 return false;
 334                         break;
 335                 default:
 336                         FLAC__ASSERT(0);
 337         }
 338
 339         return true;
 340 }
 341
 342 FLAC__bool FLAC__subframe_add_verbatim(const FLAC__Subframe_Verbatim *subframe, unsigned samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb)
 343 {
 344         unsigned i;
 345         const FLAC__int32 *signal = subframe->data;
 346
 347         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))
 348                 return false;
 349         if(wasted_bits)
 350                 if(!FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1))
 351                         return false;
 352
 353         for(i = 0; i < samples; i++)
 354                 if(!FLAC__bitbuffer_write_raw_int32(bb, signal[i], subframe_bps))
 355                         return false;
 356
 357         return true;
 358 }
 359
 360 FLAC__bool add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method)
 361 {
 362         if(!FLAC__bitbuffer_write_raw_uint32(bb, method->type, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN))
 363                 return false;
 364         switch(method->type) {
 365                 case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
 366                         if(!FLAC__bitbuffer_write_raw_uint32(bb, method->data.partitioned_rice.order, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN))
 367                                 return false;
 368                         break;
 369                 default:
 370                         FLAC__ASSERT(0);
 371         }
 372         return true;
 373 }
 374
 375 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)
 376 {
 377         if(partition_order == 0) {
 378                 unsigned i;
 379
 380                 if(!FLAC__bitbuffer_write_raw_uint32(bb, rice_parameters[0], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN))
 381                         return false;
 382                 if(rice_parameters[0] < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
 383                         for(i = 0; i < residual_samples; i++) {
 384 #ifdef FLAC__SYMMETRIC_RICE
 385                                 if(!FLAC__bitbuffer_write_symmetric_rice_signed(bb, residual[i], rice_parameters[0]))
 386                                         return false;
 387 #else
 388                                 if(!FLAC__bitbuffer_write_rice_signed(bb, residual[i], rice_parameters[0]))
 389                                         return false;
 390 #endif
 391                         }
 392                 }
 393                 else {
 394                         if(!FLAC__bitbuffer_write_raw_uint32(bb, raw_bits[0], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN))
 395                                 return false;
 396                         for(i = 0; i < residual_samples; i++) {
 397                                 if(!FLAC__bitbuffer_write_raw_int32(bb, residual[i], raw_bits[0]))
 398                                         return false;
 399                         }
 400                 }
 401                 return true;
 402         }
 403         else {
 404                 unsigned i, j, k = 0, k_last = 0;
 405                 unsigned partition_samples;
 406                 const unsigned default_partition_samples = (residual_samples+predictor_order) >> partition_order;
 407                 for(i = 0; i < (1u<<partition_order); i++) {
 408                         if(!FLAC__bitbuffer_write_raw_uint32(bb, rice_parameters[i], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN))
 409                                 return false;
 410                         partition_samples = default_partition_samples;
 411                         if(i == 0)
 412                                 partition_samples -= predictor_order;
 413                         k += partition_samples;
 414                         if(rice_parameters[i] < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
 415                                 for(j = k_last; j < k; j++) {
 416 #ifdef FLAC__SYMMETRIC_RICE
 417                                         if(!FLAC__bitbuffer_write_symmetric_rice_signed(bb, residual[j], rice_parameters[i]))
 418                                                 return false;
 419 #else
 420                                         if(!FLAC__bitbuffer_write_rice_signed(bb, residual[j], rice_parameters[i]))
 421                                                 return false;
 422 #endif
 423                                 }
 424                         }
 425                         else {
 426                                 if(!FLAC__bitbuffer_write_raw_uint32(bb, raw_bits[i], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN))
 427                                         return false;
 428                                 for(j = k_last; j < k; j++) {
 429                                         if(!FLAC__bitbuffer_write_raw_int32(bb, residual[j], raw_bits[i]))
 430                                                 return false;
 431                                 }
 432                         }
 433                         k_last = k;
 434                 }
 435                 return true;
 436         }
 437 }