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