1#!/usr/bin/env python 2import numpy as np 3import wave 4import struct 5import sys 6 7# channel mode 8MONO = 0 9DUAL_CHANNEL = 1 10STEREO = 2 11JOINT_STEREO = 3 12channel_modes = ["MONO", "DUAL CHANNEL", "STEREO", "JOINT STEREO"] 13 14# allocation method 15LOUDNESS = 0 16SNR = 1 17allocation_methods = ["LOUDNESS", "SNR"] 18 19sampling_frequencies = [16000, 32000, 44100, 48000] 20nr_blocks = [4, 8, 12, 16] 21nr_subbands = [4, 8] 22 23 24def allocation_method_to_str(allocation_method): 25 global allocation_methods 26 return allocation_methods[allocation_method] 27 28def channel_mode_to_str(channel_mode): 29 global channel_modes 30 return channel_modes[channel_mode] 31 32def sampling_frequency_to_str(sampling_frequency): 33 global sampling_frequencies 34 return sampling_frequencies[sampling_frequency] 35 36def sampling_frequency_index(sampling_frequency): 37 global sampling_frequencies 38 for index, value in enumerate(sampling_frequencies): 39 if value == sampling_frequency: 40 return index 41 return -1 42 43Proto_4_40 = [ 44 0.00000000E+00, 5.36548976E-04, 1.49188357E-03, 2.73370904E-03, 45 3.83720193E-03, 3.89205149E-03, 1.86581691E-03, -3.06012286E-03, 46 1.09137620E-02, 2.04385087E-02, 2.88757392E-02, 3.21939290E-02, 47 2.58767811E-02, 6.13245186E-03, -2.88217274E-02, -7.76463494E-02, 48 1.35593274E-01, 1.94987841E-01, 2.46636662E-01, 2.81828203E-01, 49 2.94315332E-01, 2.81828203E-01, 2.46636662E-01, 1.94987841E-01, 50 -1.35593274E-01, -7.76463494E-02, -2.88217274E-02, 6.13245186E-03, 51 2.58767811E-02, 3.21939290E-02, 2.88757392E-02, 2.04385087E-02, 52 -1.09137620E-02, -3.06012286E-03, 1.86581691E-03, 3.89205149E-03, 53 3.83720193E-03, 2.73370904E-03, 1.49188357E-03, 5.36548976E-04 54] 55 56Proto_8_80 = [ 57 0.00000000E+00, 1.56575398E-04, 3.43256425E-04, 5.54620202E-04, 58 8.23919506E-04, 1.13992507E-03, 1.47640169E-03, 1.78371725E-03, 59 2.01182542E-03, 2.10371989E-03, 1.99454554E-03, 1.61656283E-03, 60 9.02154502E-04, -1.78805361E-04, -1.64973098E-03, -3.49717454E-03, 61 5.65949473E-03, 8.02941163E-03, 1.04584443E-02, 1.27472335E-02, 62 1.46525263E-02, 1.59045603E-02, 1.62208471E-02, 1.53184106E-02, 63 1.29371806E-02, 8.85757540E-03, 2.92408442E-03, -4.91578024E-03, 64 -1.46404076E-02, -2.61098752E-02, -3.90751381E-02, -5.31873032E-02, 65 6.79989431E-02, 8.29847578E-02, 9.75753918E-02, 1.11196689E-01, 66 1.23264548E-01, 1.33264415E-01, 1.40753505E-01, 1.45389847E-01, 67 1.46955068E-01, 1.45389847E-01, 1.40753505E-01, 1.33264415E-01, 68 1.23264548E-01, 1.11196689E-01, 9.75753918E-02, 8.29847578E-02, 69 -6.79989431E-02, -5.31873032E-02, -3.90751381E-02, -2.61098752E-02, 70 -1.46404076E-02, -4.91578024E-03, 2.92408442E-03, 8.85757540E-03, 71 1.29371806E-02, 1.53184106E-02, 1.62208471E-02, 1.59045603E-02, 72 1.46525263E-02, 1.27472335E-02, 1.04584443E-02, 8.02941163E-03, 73 -5.65949473E-03, -3.49717454E-03, -1.64973098E-03, -1.78805361E-04, 74 9.02154502E-04, 1.61656283E-03, 1.99454554E-03, 2.10371989E-03, 75 2.01182542E-03, 1.78371725E-03, 1.47640169E-03, 1.13992507E-03, 76 8.23919506E-04, 5.54620202E-04, 3.43256425E-04, 1.56575398E-04 77] 78 79crc_table = [ 80 0x00, 0x1D, 0x3A, 0x27, 0x74, 0x69, 0x4E, 0x53, 81 0xE8, 0xF5, 0xD2, 0xCF, 0x9C, 0x81, 0xA6, 0xBB, 82 0xCD, 0xD0, 0xF7, 0xEA, 0xB9, 0xA4, 0x83, 0x9E, 83 0x25, 0x38, 0x1F, 0x02, 0x51, 0x4C, 0x6B, 0x76, 84 0x87, 0x9A, 0xBD, 0xA0, 0xF3, 0xEE, 0xC9, 0xD4, 85 0x6F, 0x72, 0x55, 0x48, 0x1B, 0x06, 0x21, 0x3C, 86 0x4A, 0x57, 0x70, 0x6D, 0x3E, 0x23, 0x04, 0x19, 87 0xA2, 0xBF, 0x98, 0x85, 0xD6, 0xCB, 0xEC, 0xF1, 88 0x13, 0x0E, 0x29, 0x34, 0x67, 0x7A, 0x5D, 0x40, 89 0xFB, 0xE6, 0xC1, 0xDC, 0x8F, 0x92, 0xB5, 0xA8, 90 0xDE, 0xC3, 0xE4, 0xF9, 0xAA, 0xB7, 0x90, 0x8D, 91 0x36, 0x2B, 0x0C, 0x11, 0x42, 0x5F, 0x78, 0x65, 92 0x94, 0x89, 0xAE, 0xB3, 0xE0, 0xFD, 0xDA, 0xC7, 93 0x7C, 0x61, 0x46, 0x5B, 0x08, 0x15, 0x32, 0x2F, 94 0x59, 0x44, 0x63, 0x7E, 0x2D, 0x30, 0x17, 0x0A, 95 0xB1, 0xAC, 0x8B, 0x96, 0xC5, 0xD8, 0xFF, 0xE2, 96 0x26, 0x3B, 0x1C, 0x01, 0x52, 0x4F, 0x68, 0x75, 97 0xCE, 0xD3, 0xF4, 0xE9, 0xBA, 0xA7, 0x80, 0x9D, 98 0xEB, 0xF6, 0xD1, 0xCC, 0x9F, 0x82, 0xA5, 0xB8, 99 0x03, 0x1E, 0x39, 0x24, 0x77, 0x6A, 0x4D, 0x50, 100 0xA1, 0xBC, 0x9B, 0x86, 0xD5, 0xC8, 0xEF, 0xF2, 101 0x49, 0x54, 0x73, 0x6E, 0x3D, 0x20, 0x07, 0x1A, 102 0x6C, 0x71, 0x56, 0x4B, 0x18, 0x05, 0x22, 0x3F, 103 0x84, 0x99, 0xBE, 0xA3, 0xF0, 0xED, 0xCA, 0xD7, 104 0x35, 0x28, 0x0F, 0x12, 0x41, 0x5C, 0x7B, 0x66, 105 0xDD, 0xC0, 0xE7, 0xFA, 0xA9, 0xB4, 0x93, 0x8E, 106 0xF8, 0xE5, 0xC2, 0xDF, 0x8C, 0x91, 0xB6, 0xAB, 107 0x10, 0x0D, 0x2A, 0x37, 0x64, 0x79, 0x5E, 0x43, 108 0xB2, 0xAF, 0x88, 0x95, 0xC6, 0xDB, 0xFC, 0xE1, 109 0x5A, 0x47, 0x60, 0x7D, 0x2E, 0x33, 0x14, 0x09, 110 0x7F, 0x62, 0x45, 0x58, 0x0B, 0x16, 0x31, 0x2C, 111 0x97, 0x8A, 0xAD, 0xB0, 0xE3, 0xFE, 0xD9, 0xC4 112] 113# offset table for 4-subbands 114offset4 = np.array([[ -1, 0, 0, 0 ], 115 [ -2, 0, 0, 1 ], 116 [ -2, 0, 0, 1 ], 117 [ -2, 0, 0, 1 ] 118 ]) 119 120# offset tables for 8-subbands 121offset8 = np.array([[ -2, 0, 0, 0, 0, 0, 0, 1 ], 122 [ -3, 0, 0, 0, 0, 0, 1, 2 ], 123 [ -4, 0, 0, 0, 0, 0, 1, 2 ], 124 [ -4, 0, 0, 0, 0, 0, 1, 2 ] 125 ]) 126 127def calculate_scalefactor(max_subbandsample): 128 x = 0 129 while True: 130 y = 1 << (x + 1) 131 if y > max_subbandsample: 132 break 133 x += 1 134 return (x,y) 135 136 137def calculate_max_subbandsample(nr_blocks, nr_channels, nr_subbands, sb_sample): 138 max_subbandsample = np.zeros(shape = (nr_channels, nr_subbands)) 139 140 for blk in range(nr_blocks): 141 for ch in range(nr_channels): 142 for sb in range(nr_subbands): 143 m = abs(sb_sample[blk][ch][sb]) 144 if max_subbandsample[ch][sb] < m: 145 max_subbandsample[ch][sb] = m 146 return max_subbandsample 147 148def calculate_scalefactors(nr_blocks, nr_channels, nr_subbands, sb_sample): 149 scale_factor = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 150 scalefactor = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 151 152 max_subbandsample = calculate_max_subbandsample(nr_blocks, nr_channels, nr_subbands, sb_sample) 153 for ch in range(nr_channels): 154 for sb in range(nr_subbands): 155 (scale_factor[ch][sb], scalefactor[ch][sb]) = calculate_scalefactor(max_subbandsample[ch][sb]) 156 return scale_factor, scalefactor 157 158def calculate_channel_mode_and_scale_factors(frame, force_channel_mode): 159 frame.scale_factor, frame.scalefactor = calculate_scalefactors(frame.nr_blocks, frame.nr_channels, frame.nr_subbands, frame.sb_sample) 160 161 if frame.nr_channels == 1: 162 frame.channel_mode = MONO 163 return 164 165 frame.join = np.zeros(frame.nr_subbands, dtype = np.uint8) 166 167 if force_channel_mode == STEREO: 168 frame.channel_mode = STEREO 169 return 170 171 sb_sample = np.zeros(shape = (frame.nr_blocks,2,frame.nr_subbands), dtype = np.int32) 172 for blk in range(frame.nr_blocks): 173 for sb in range(frame.nr_subbands): 174 sb_sample[blk][0][sb] = (frame.sb_sample[blk][0][sb] + frame.sb_sample[blk][1][sb])/2 175 sb_sample[blk][1][sb] = (frame.sb_sample[blk][0][sb] - frame.sb_sample[blk][1][sb])/2 176 177 scale_factor, scalefactor = calculate_scalefactors(frame.nr_blocks, frame.nr_channels, frame.nr_subbands, sb_sample) 178 179 for sb in range(frame.nr_subbands-1): 180 suma = frame.scale_factor[0][sb] + frame.scale_factor[1][sb] 181 sumb = scale_factor[0][sb] + scale_factor[1][sb] 182 183 if suma > sumb or force_channel_mode == JOINT_STEREO: 184 frame.channel_mode = JOINT_STEREO 185 frame.join[sb] = 1 186 187 frame.scale_factor[0][sb] = scale_factor[0][sb] 188 frame.scale_factor[1][sb] = scale_factor[1][sb] 189 frame.scalefactor[0][sb] = scalefactor[0][sb] 190 frame.scalefactor[1][sb] = scalefactor[1][sb] 191 192 for blk in range(frame.nr_blocks): 193 frame.sb_sample[blk][0][sb] = sb_sample[blk][0][sb] 194 frame.sb_sample[blk][1][sb] = sb_sample[blk][1][sb] 195 196 197class SBCFrame: 198 syncword = 0 199 sampling_frequency = 0 200 nr_blocks = 0 201 channel_mode = 0 202 nr_channels = 0 203 allocation_method = 0 204 nr_subbands = 0 205 bitpool = 0 206 crc_check = 0 207 # pro subband - 1 208 join = np.zeros(8, dtype = np.uint8) 209 scale_factor = np.zeros(shape=(2, 8), dtype = np.int32) 210 scalefactor = np.zeros(shape=(2, 8), dtype = np.int32) 211 audio_sample = np.zeros(shape = (16,2,8), dtype = np.uint16) 212 sb_sample = np.zeros(shape = (16,2,8), dtype = np.int32) 213 X = np.zeros(8, dtype = np.int16) 214 EX = np.zeros(8) 215 pcm = np.zeros(shape=(2, 8*16), dtype = np.int16) 216 bits = np.zeros(shape=(2, 8)) 217 levels = np.zeros(shape=(2, 8), dtype = np.int32) 218 219 220 def __init__(self, nr_blocks=16, nr_subbands=4, nr_channels=1, bitpool=31, sampling_frequency=44100, allocation_method = 0): 221 self.nr_blocks = nr_blocks 222 self.nr_subbands = nr_subbands 223 self.nr_channels = nr_channels 224 self.sampling_frequency = sampling_frequency_index(sampling_frequency) 225 self.bitpool = bitpool 226 self.allocation_method = allocation_method 227 self.init(nr_blocks, nr_subbands, nr_channels) 228 return 229 230 def init(self, nr_blocks, nr_subbands, nr_channels): 231 self.scale_factor = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 232 self.scalefactor = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 233 self.audio_sample = np.zeros(shape=(nr_blocks, nr_channels, nr_subbands), dtype = np.uint16) 234 self.sb_sample = np.zeros(shape=(nr_blocks, nr_channels, nr_subbands), dtype = np.int32) 235 self.levels = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 236 self.pcm = np.zeros(shape=(nr_channels, nr_subbands*nr_blocks), dtype = np.int16) 237 self.join = np.zeros(nr_subbands, dtype = np.uint8) 238 self.X = np.zeros(nr_subbands, dtype = np.int16) 239 self.EX = np.zeros(nr_subbands) 240 241 def dump_audio_samples(self, blk, ch): 242 print self.audio_sample[blk][ch] 243 244 def dump_subband_samples(self, blk, ch): 245 print self.sb_sample[blk][ch] 246 247 def dump_state(self): 248 res = "SBCFrameHeader state:" 249 res += "\n - nr channels %d" % self.nr_channels 250 res += "\n - nr blocks %d" % self.nr_blocks 251 res += "\n - nr subbands %d" % self.nr_subbands 252 res += "\n - scale factors: %s" % self.scale_factor 253 res += "\n - levels: %s" % self.levels 254 res += "\n - join: %s" % self.join 255 res += "\n - bits: %s" % self.bits 256 print res 257 258 def __str__(self): 259 res = "SBCFrameHeader:" 260 res += "\n - syncword %d" % self.syncword 261 res += "\n - sampling frequency %d Hz" % sampling_frequency_to_str(self.sampling_frequency) 262 263 res += "\n - nr channels %d" % self.nr_channels 264 res += "\n - nr blocks %d" % self.nr_blocks 265 res += "\n - nr subbands %d" % self.nr_subbands 266 267 res += "\n - channel mode %s" % channel_mode_to_str(self.channel_mode) 268 res += "\n - allocation method %s" % allocation_method_to_str(self.allocation_method) 269 270 res += "\n - bitpool %d" % self.bitpool 271 res += "\n - crc check %d" % self.crc_check 272 return res 273 274 275def sbc_bit_allocation_stereo_joint(frame): 276 bitneed = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 277 bits = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 278 279 loudness = 0 280 281 if frame.allocation_method == SNR: 282 for ch in range(frame.nr_channels): 283 for sb in range(frame.nr_subbands): 284 bitneed[ch][sb] = frame.scale_factor[ch][sb] 285 else: 286 for ch in range(frame.nr_channels): 287 for sb in range(frame.nr_subbands): 288 if frame.scale_factor[ch][sb] == 0: 289 bitneed[ch][sb] = -5 290 else: 291 if frame.nr_subbands == 4: 292 loudness = frame.scale_factor[ch][sb] - offset4[frame.sampling_frequency][sb] 293 else: 294 loudness = frame.scale_factor[ch][sb] - offset8[frame.sampling_frequency][sb] 295 296 if loudness > 0: 297 bitneed[ch][sb] = loudness/2 298 else: 299 bitneed[ch][sb] = loudness 300 301 # search the maximum bitneed index 302 max_bitneed = 0 303 for ch in range(frame.nr_channels): 304 for sb in range(frame.nr_subbands): 305 if bitneed[ch][sb] > max_bitneed: 306 max_bitneed = bitneed[ch][sb] 307 308 309 # calculate how many bitslices fit into the bitpool 310 bitcount = 0 311 slicecount = 0 312 bitslice = max_bitneed + 1 #/* init just above the largest sf */ 313 314 while True: 315 bitslice -= 1 316 bitcount += slicecount 317 slicecount = 0 318 for ch in range(frame.nr_channels): 319 for sb in range(frame.nr_subbands): 320 if (bitneed[ch][sb] > bitslice+1) and (bitneed[ch][sb] < bitslice+16): 321 slicecount += 1 322 elif bitneed[ch][sb] == bitslice + 1: 323 slicecount += 2 324 if bitcount + slicecount >= frame.bitpool: 325 break 326 327 if bitcount + slicecount == frame.bitpool: 328 bitcount += slicecount 329 bitslice -= 1 330 331 # bits are distributed until the last bitslice is reached 332 for ch in range(frame.nr_channels): 333 for sb in range(frame.nr_subbands): 334 if bitneed[ch][sb] < bitslice+2: 335 bits[ch][sb]=0 336 else: 337 bits[ch][sb] = min(bitneed[ch][sb]-bitslice,16) 338 339 ch = 0 340 sb = 0 341 while bitcount < frame.bitpool and sb < frame.nr_subbands: 342 if bits[ch][sb] >= 2 and bits[ch][sb] < 16: 343 bits[ch][sb] += 1 344 bitcount += 1 345 elif (bitneed[ch][sb] == bitslice+1) and (frame.bitpool > bitcount+1): 346 bits[ch][sb] = 2 347 bitcount += 2 348 if ch == 1: 349 ch = 0 350 sb += 1 351 else: 352 ch = 1 353 354 355 ch = 0 356 sb = 0 357 while bitcount < frame.bitpool and sb < frame.nr_subbands: 358 if bits[ch][sb] < 16: 359 bits[ch][sb]+=1 360 bitcount+=1 361 if ch == 1: 362 ch = 0 363 sb += 1 364 else: 365 ch = 1 366 367 368 if bits.sum() != frame.bitpool: 369 print "bit allocation failed, bitpool %d, allocated %d" % (bits.sum() , frame.bitpool) 370 exit(1) 371 return bits 372 373 374def sbc_bit_allocation_mono_dual(frame): 375 #print "Bit allocation for mono/dual channel" 376 bitneed = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 377 bits = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 378 loudness = 0 379 380 for ch in range(frame.nr_channels): 381 # bitneed values are derived from the scale factors 382 if frame.allocation_method == SNR: 383 for sb in range(frame.nr_subbands): 384 bitneed[ch][sb] = frame.scale_factor[ch][sb] 385 else: 386 for sb in range(frame.nr_subbands): 387 if frame.scale_factor[ch][sb] == 0: 388 bitneed[ch][sb] = -5 389 else: 390 if frame.nr_subbands == 4: 391 loudness = frame.scale_factor[ch][sb] - offset4[frame.sampling_frequency][sb] 392 else: 393 loudness = frame.scale_factor[ch][sb] - offset8[frame.sampling_frequency][sb] 394 if loudness > 0: 395 bitneed[ch][sb] = loudness/2 396 else: 397 bitneed[ch][sb] = loudness 398 399 # search the maximum bitneed index 400 max_bitneed = 0 401 for sb in range(frame.nr_subbands): 402 if bitneed[ch][sb] > max_bitneed: 403 max_bitneed = bitneed[ch][sb] 404 405 # calculate how many bitslices fit into the bitpool 406 bitcount = 0 407 slicecount = 0 408 bitslice = max_bitneed + 1 409 410 while True: 411 bitslice = bitslice - 1 412 bitcount = bitcount + slicecount 413 slicecount = 0 414 for sb in range(frame.nr_subbands): 415 if (bitneed[ch][sb] > bitslice+1) and (bitneed[ch][sb] < bitslice+16): 416 slicecount = slicecount + 1 417 elif bitneed[ch][sb] == bitslice + 1: 418 slicecount = slicecount + 2 419 if bitcount + slicecount >= frame.bitpool: 420 break 421 422 if bitcount + slicecount == frame.bitpool: 423 bitcount = bitcount + slicecount 424 bitslice = bitslice - 1 425 426 for sb in range(frame.nr_subbands): 427 if bitneed[ch][sb] < bitslice+2 : 428 bits[ch][sb]=0; 429 else: 430 bits[ch][sb] = min(bitneed[ch][sb]-bitslice,16) 431 432 sb = 0 433 while bitcount < frame.bitpool and sb < frame.nr_subbands: 434 if bits[ch][sb] >= 2 and bits[ch][sb] < 16: 435 bits[ch][sb] = bits[ch][sb] + 1 436 bitcount = bitcount + 1 437 438 elif (bitneed[ch][sb] == bitslice+1) and (frame.bitpool > bitcount+1): 439 bits[ch][sb] = 2 440 bitcount += 2 441 442 sb = sb + 1 443 444 sb = 0 445 while bitcount < frame.bitpool and sb < frame.nr_subbands: 446 if bits[ch][sb] < 16: 447 bits[ch][sb] = bits[ch][sb] + 1 448 bitcount = bitcount + 1 449 sb = sb + 1 450 451 return bits 452 453def sbc_bit_allocation(frame): 454 if frame.channel_mode == MONO or frame.channel_mode == DUAL_CHANNEL: 455 return sbc_bit_allocation_mono_dual(frame) 456 elif frame.channel_mode == STEREO or frame.channel_mode == JOINT_STEREO: 457 return sbc_bit_allocation_stereo_joint(frame) 458 else: 459 print "Wrong channel mode ", frame.channel_mode 460 return -1 461 462def sbc_sampling_frequency_index(sample_rate): 463 sbc_sampling_frequency_index = 0 464 for i in range(len(sampling_frequency)): 465 if sample_rate == sampling_frequency[i]: 466 sbc_sampling_frequency_index = i 467 break 468 return sbc_sampling_frequency_index 469 470 471def sbc_crc8(data, data_len): 472 crc = 0x0f 473 j = 0 474 for i in range(data_len / 8): 475 crc = crc_table[crc ^ data[i]] 476 j = i + 1 477 478 bits_left = data_len%8 479 if bits_left: 480 octet = data[j] 481 for i in range(data_len%8): 482 bit = ((octet ^ crc) & 0x80) >> 7 483 if bit: 484 bit = 0x1d 485 crc = ((crc & 0x7f) << 1) ^ bit 486 octet = octet << 1 487 return crc 488 489 490bitstream = None 491bitstream_index = -1 492bitstream_bits_available = 0 493 494def init_bitstream(): 495 global bitstream, bitstream_bits_available, bitstream_index 496 bitstream = [] 497 bitstream_index = -1 498 bitstream_bits_available = 0 499 500def add_bit(bit): 501 global bitstream, bitstream_bits_available, bitstream_index 502 if bitstream_bits_available == 0: 503 bitstream.append(0) 504 bitstream_bits_available = 8 505 bitstream_index += 1 506 507 bitstream[bitstream_index] |= bit << (bitstream_bits_available - 1) 508 bitstream_bits_available -= 1 509 510 511def add_bits(bits, len): 512 global bitstream, bitstream_bits_available 513 for i in range(len): 514 add_bit((bits >> (len-1-i)) & 1) 515 516ibuffer = None 517ibuffer_count = 0 518 519def get_bit(fin): 520 global ibuffer, ibuffer_count 521 if ibuffer_count == 0: 522 ibuffer = ord(fin.read(1)) 523 ibuffer_count = 8 524 525 bit = (ibuffer >> 7) & 1 526 ibuffer = ibuffer << 1 527 ibuffer_count = ibuffer_count - 1 528 return bit 529 530def drop_remaining_bits(): 531 global ibuffer_count 532 #print "dropping %d bits" % ibuffer_count 533 ibuffer_count = 0 534 535def get_bits(fin, bit_count): 536 bits = 0 537 for i in range(bit_count): 538 bits = (bits << 1) | get_bit(fin) 539 # print "get bits: %d -> %02x" %(bit_count, bits) 540 return bits 541 542 543def calculate_crc(frame): 544 global bitstream, bitstream_bits_available, bitstream_index 545 init_bitstream() 546 547 add_bits(frame.sampling_frequency, 2) 548 add_bits(frame.nr_blocks/4-1, 2) 549 add_bits(frame.channel_mode, 2) 550 add_bits(frame.allocation_method, 1) 551 add_bits(frame.nr_subbands/4-1, 1) 552 add_bits(frame.bitpool, 8) 553 if frame.channel_mode == JOINT_STEREO: 554 for sb in range(frame.nr_subbands): 555 add_bits(frame.join[sb],1) 556 557 for ch in range(frame.nr_channels): 558 for sb in range(frame.nr_subbands): 559 add_bits(frame.scale_factor[ch][sb], 4) 560 561 bitstream_len = (bitstream_index + 1) * 8 562 if bitstream_bits_available: 563 bitstream_len -= bitstream_bits_available 564 565 return sbc_crc8(bitstream, bitstream_len) 566 567 568 569def frame_to_bitstream(frame): 570 global bitstream, bitstream_bits_available, bitstream_index 571 init_bitstream() 572 573 add_bits(frame.syncword, 8) 574 add_bits(frame.sampling_frequency, 2) 575 add_bits(frame.nr_blocks/4-1, 2) 576 add_bits(frame.channel_mode, 2) 577 add_bits(frame.allocation_method, 1) 578 add_bits(frame.nr_subbands/4-1, 1) 579 add_bits(frame.bitpool, 8) 580 add_bits(frame.crc_check, 8) 581 582 if frame.channel_mode == JOINT_STEREO: 583 for sb in range(frame.nr_subbands-1): 584 add_bits(frame.join[sb],1) 585 add_bits(0,1) 586 587 for ch in range(frame.nr_channels): 588 for sb in range(frame.nr_subbands): 589 add_bits(frame.scale_factor[ch][sb], 4) 590 591 for blk in range(frame.nr_blocks): 592 for ch in range(frame.nr_channels): 593 for sb in range(frame.nr_subbands): 594 add_bits(frame.audio_sample[blk][ch][sb], frame.bits[ch][sb]) 595 596 bitstream_bits_available = 0 597 return bitstream 598 599def mse(a,b): 600 count = 1 601 for i in a.shape: 602 count *= i 603 delta = a - b 604 sqr = delta ** 2 605 res = sqr.sum()*1.0/count 606 # res = ((a - b) ** 2).mean() 607 return res 608