1#!/usr/bin/env python 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): 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 return 233 234 def init(self, nr_blocks, nr_subbands, nr_channels): 235 self.scale_factor = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 236 self.scalefactor = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 237 self.audio_sample = np.zeros(shape=(nr_blocks, nr_channels, nr_subbands), dtype = np.uint16) 238 self.sb_sample = np.zeros(shape=(nr_blocks, nr_channels, nr_subbands), dtype = np.int32) 239 self.levels = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 240 self.pcm = np.zeros(shape=(nr_channels, nr_subbands*nr_blocks), dtype = np.int16) 241 self.join = np.zeros(nr_subbands, dtype = np.uint8) 242 self.X = np.zeros(nr_subbands, dtype = np.int16) 243 self.EX = np.zeros(nr_subbands) 244 245 def dump_audio_samples(self, blk, ch): 246 print self.audio_sample[blk][ch] 247 248 def dump_subband_samples(self, blk, ch): 249 print self.sb_sample[blk][ch] 250 251 def dump_state(self): 252 res = "SBCFrameHeader state:" 253 res += "\n - nr channels %d" % self.nr_channels 254 res += "\n - nr blocks %d" % self.nr_blocks 255 res += "\n - nr subbands %d" % self.nr_subbands 256 res += "\n - scale factors: %s" % self.scale_factor 257 res += "\n - levels: %s" % self.levels 258 res += "\n - join: %s" % self.join 259 res += "\n - bits: %s" % self.bits 260 print res 261 262 def __str__(self): 263 res = "SBCFrameHeader:" 264 res += "\n - syncword %x" % self.syncword 265 res += "\n - sampling frequency %d Hz" % sampling_frequency_to_str(self.sampling_frequency) 266 267 res += "\n - nr channels %d" % self.nr_channels 268 res += "\n - nr blocks %d" % self.nr_blocks 269 res += "\n - nr subbands %d" % self.nr_subbands 270 271 res += "\n - channel mode %s" % channel_mode_to_str(self.channel_mode) 272 res += "\n - allocation method %s" % allocation_method_to_str(self.allocation_method) 273 274 res += "\n - bitpool %d" % self.bitpool 275 res += "\n - crc check %x" % self.crc_check 276 return res 277 278 279def sbc_bit_allocation_stereo_joint(frame): 280 bitneed = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 281 bits = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 282 283 loudness = 0 284 285 if frame.allocation_method == SNR: 286 for ch in range(frame.nr_channels): 287 for sb in range(frame.nr_subbands): 288 bitneed[ch][sb] = frame.scale_factor[ch][sb] 289 else: 290 for ch in range(frame.nr_channels): 291 for sb in range(frame.nr_subbands): 292 if frame.scale_factor[ch][sb] == 0: 293 bitneed[ch][sb] = -5 294 else: 295 if frame.nr_subbands == 4: 296 loudness = frame.scale_factor[ch][sb] - offset4[frame.sampling_frequency][sb] 297 else: 298 loudness = frame.scale_factor[ch][sb] - offset8[frame.sampling_frequency][sb] 299 300 if loudness > 0: 301 bitneed[ch][sb] = loudness/2 302 else: 303 bitneed[ch][sb] = loudness 304 305 # search the maximum bitneed index 306 max_bitneed = 0 307 for ch in range(frame.nr_channels): 308 for sb in range(frame.nr_subbands): 309 if bitneed[ch][sb] > max_bitneed: 310 max_bitneed = bitneed[ch][sb] 311 312 313 # calculate how many bitslices fit into the bitpool 314 bitcount = 0 315 slicecount = 0 316 bitslice = max_bitneed + 1 #/* init just above the largest sf */ 317 318 while True: 319 bitslice -= 1 320 bitcount += slicecount 321 slicecount = 0 322 for ch in range(frame.nr_channels): 323 for sb in range(frame.nr_subbands): 324 if (bitneed[ch][sb] > bitslice+1) and (bitneed[ch][sb] < bitslice+16): 325 slicecount += 1 326 elif bitneed[ch][sb] == bitslice + 1: 327 slicecount += 2 328 if bitcount + slicecount >= frame.bitpool: 329 break 330 331 if bitcount + slicecount == frame.bitpool: 332 bitcount += slicecount 333 bitslice -= 1 334 335 # bits are distributed until the last bitslice is reached 336 for ch in range(frame.nr_channels): 337 for sb in range(frame.nr_subbands): 338 if bitneed[ch][sb] < bitslice+2: 339 bits[ch][sb]=0 340 else: 341 bits[ch][sb] = min(bitneed[ch][sb]-bitslice,16) 342 343 ch = 0 344 sb = 0 345 while bitcount < frame.bitpool and sb < frame.nr_subbands: 346 if bits[ch][sb] >= 2 and bits[ch][sb] < 16: 347 bits[ch][sb] += 1 348 bitcount += 1 349 elif (bitneed[ch][sb] == bitslice+1) and (frame.bitpool > bitcount+1): 350 bits[ch][sb] = 2 351 bitcount += 2 352 if ch == 1: 353 ch = 0 354 sb += 1 355 else: 356 ch = 1 357 358 359 ch = 0 360 sb = 0 361 while bitcount < frame.bitpool and sb < frame.nr_subbands: 362 if bits[ch][sb] < 16: 363 bits[ch][sb]+=1 364 bitcount+=1 365 if ch == 1: 366 ch = 0 367 sb += 1 368 else: 369 ch = 1 370 371 372 if bits.sum() != frame.bitpool: 373 print "bit allocation failed, bitpool %d, allocated %d" % (bits.sum() , frame.bitpool) 374 exit(1) 375 return bits 376 377 378def sbc_bit_allocation_mono_dual(frame): 379 #print "Bit allocation for mono/dual channel" 380 bitneed = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 381 bits = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 382 loudness = 0 383 384 for ch in range(frame.nr_channels): 385 # bitneed values are derived from the scale factors 386 if frame.allocation_method == SNR: 387 for sb in range(frame.nr_subbands): 388 bitneed[ch][sb] = frame.scale_factor[ch][sb] 389 else: 390 for sb in range(frame.nr_subbands): 391 if frame.scale_factor[ch][sb] == 0: 392 bitneed[ch][sb] = -5 393 else: 394 if frame.nr_subbands == 4: 395 loudness = frame.scale_factor[ch][sb] - offset4[frame.sampling_frequency][sb] 396 else: 397 loudness = frame.scale_factor[ch][sb] - offset8[frame.sampling_frequency][sb] 398 if loudness > 0: 399 bitneed[ch][sb] = loudness/2 400 else: 401 bitneed[ch][sb] = loudness 402 403 # search the maximum bitneed index 404 max_bitneed = 0 405 for sb in range(frame.nr_subbands): 406 if bitneed[ch][sb] > max_bitneed: 407 max_bitneed = bitneed[ch][sb] 408 409 # calculate how many bitslices fit into the bitpool 410 bitcount = 0 411 slicecount = 0 412 bitslice = max_bitneed + 1 413 414 while True: 415 bitslice = bitslice - 1 416 bitcount = bitcount + slicecount 417 slicecount = 0 418 for sb in range(frame.nr_subbands): 419 if (bitneed[ch][sb] > bitslice+1) and (bitneed[ch][sb] < bitslice+16): 420 slicecount = slicecount + 1 421 elif bitneed[ch][sb] == bitslice + 1: 422 slicecount = slicecount + 2 423 if bitcount + slicecount >= frame.bitpool: 424 break 425 426 if bitcount + slicecount == frame.bitpool: 427 bitcount = bitcount + slicecount 428 bitslice = bitslice - 1 429 430 for sb in range(frame.nr_subbands): 431 if bitneed[ch][sb] < bitslice+2 : 432 bits[ch][sb]=0; 433 else: 434 bits[ch][sb] = min(bitneed[ch][sb]-bitslice,16) 435 436 sb = 0 437 while bitcount < frame.bitpool and sb < frame.nr_subbands: 438 if bits[ch][sb] >= 2 and bits[ch][sb] < 16: 439 bits[ch][sb] = bits[ch][sb] + 1 440 bitcount = bitcount + 1 441 442 elif (bitneed[ch][sb] == bitslice+1) and (frame.bitpool > bitcount+1): 443 bits[ch][sb] = 2 444 bitcount += 2 445 446 sb = sb + 1 447 448 sb = 0 449 while bitcount < frame.bitpool and sb < frame.nr_subbands: 450 if bits[ch][sb] < 16: 451 bits[ch][sb] = bits[ch][sb] + 1 452 bitcount = bitcount + 1 453 sb = sb + 1 454 455 return bits 456 457def sbc_bit_allocation(frame): 458 if frame.channel_mode == MONO or frame.channel_mode == DUAL_CHANNEL: 459 return sbc_bit_allocation_mono_dual(frame) 460 elif frame.channel_mode == STEREO or frame.channel_mode == JOINT_STEREO: 461 return sbc_bit_allocation_stereo_joint(frame) 462 else: 463 print "Wrong channel mode ", frame.channel_mode 464 return -1 465 466def sbc_sampling_frequency_index(sample_rate): 467 sbc_sampling_frequency_index = 0 468 for i in range(len(sampling_frequency)): 469 if sample_rate == sampling_frequency[i]: 470 sbc_sampling_frequency_index = i 471 break 472 return sbc_sampling_frequency_index 473 474 475def sbc_crc8(data, data_len): 476 crc = 0x0f 477 j = 0 478 for i in range(data_len / 8): 479 crc = crc_table[crc ^ data[i]] 480 j = i + 1 481 482 bits_left = data_len%8 483 if bits_left: 484 octet = data[j] 485 for i in range(data_len%8): 486 bit = ((octet ^ crc) & 0x80) >> 7 487 if bit: 488 bit = 0x1d 489 crc = ((crc & 0x7f) << 1) ^ bit 490 octet = octet << 1 491 return crc 492 493 494bitstream = None 495bitstream_index = -1 496bitstream_bits_available = 0 497 498def init_bitstream(): 499 global bitstream, bitstream_bits_available, bitstream_index 500 bitstream = [] 501 bitstream_index = -1 502 bitstream_bits_available = 0 503 504def add_bit(bit): 505 global bitstream, bitstream_bits_available, bitstream_index 506 if bitstream_bits_available == 0: 507 bitstream.append(0) 508 bitstream_bits_available = 8 509 bitstream_index += 1 510 511 bitstream[bitstream_index] |= bit << (bitstream_bits_available - 1) 512 bitstream_bits_available -= 1 513 514 515def add_bits(bits, len): 516 global bitstream, bitstream_bits_available 517 for i in range(len): 518 add_bit((bits >> (len-1-i)) & 1) 519 520ibuffer = None 521ibuffer_count = 0 522 523def get_bit(fin): 524 global ibuffer, ibuffer_count 525 if ibuffer_count == 0: 526 ibuffer = ord(fin.read(1)) 527 ibuffer_count = 8 528 529 bit = (ibuffer >> 7) & 1 530 ibuffer = ibuffer << 1 531 ibuffer_count = ibuffer_count - 1 532 return bit 533 534def drop_remaining_bits(): 535 global ibuffer_count 536 #print "dropping %d bits" % ibuffer_count 537 ibuffer_count = 0 538 539def get_bits(fin, bit_count): 540 bits = 0 541 for i in range(bit_count): 542 bits = (bits << 1) | get_bit(fin) 543 # print "get bits: %d -> %02x" %(bit_count, bits) 544 return bits 545 546 547def calculate_crc(frame): 548 global bitstream, bitstream_bits_available, bitstream_index 549 init_bitstream() 550 551 add_bits(frame.sampling_frequency, 2) 552 add_bits(frame.nr_blocks/4-1, 2) 553 add_bits(frame.channel_mode, 2) 554 add_bits(frame.allocation_method, 1) 555 add_bits(frame.nr_subbands/4-1, 1) 556 add_bits(frame.bitpool, 8) 557 if frame.channel_mode == JOINT_STEREO: 558 for sb in range(frame.nr_subbands): 559 add_bits(frame.join[sb],1) 560 561 for ch in range(frame.nr_channels): 562 for sb in range(frame.nr_subbands): 563 add_bits(frame.scale_factor[ch][sb], 4) 564 565 bitstream_len = (bitstream_index + 1) * 8 566 if bitstream_bits_available: 567 bitstream_len -= bitstream_bits_available 568 569 return sbc_crc8(bitstream, bitstream_len) 570 571def calculate_crc_mSBC(frame): 572 init_bitstream() 573 add_bits(frame.reserved_for_future_use, 16) 574 for sb in range(8): 575 add_bits(frame.scale_factor[0][sb], 4) 576 bitstream_len = (bitstream_index + 1) * 8 577 if bitstream_bits_available: 578 bitstream_len -= bitstream_bits_available 579 return sbc_crc8(bitstream, bitstream_len) 580 581def frame_to_bitstream(frame): 582 global bitstream, bitstream_bits_available, bitstream_index 583 init_bitstream() 584 585 add_bits(frame.syncword, 8) 586 add_bits(frame.sampling_frequency, 2) 587 add_bits(frame.nr_blocks/4-1, 2) 588 add_bits(frame.channel_mode, 2) 589 add_bits(frame.allocation_method, 1) 590 add_bits(frame.nr_subbands/4-1, 1) 591 add_bits(frame.bitpool, 8) 592 add_bits(frame.crc_check, 8) 593 594 if frame.channel_mode == JOINT_STEREO: 595 for sb in range(frame.nr_subbands-1): 596 add_bits(frame.join[sb],1) 597 add_bits(0,1) 598 599 for ch in range(frame.nr_channels): 600 for sb in range(frame.nr_subbands): 601 add_bits(frame.scale_factor[ch][sb], 4) 602 603 for blk in range(frame.nr_blocks): 604 for ch in range(frame.nr_channels): 605 for sb in range(frame.nr_subbands): 606 add_bits(frame.audio_sample[blk][ch][sb], frame.bits[ch][sb]) 607 608 bitstream_bits_available = 0 609 return bitstream 610 611def mse(a,b): 612 count = 1 613 for i in a.shape: 614 count *= i 615 delta = a - b 616 sqr = delta ** 2 617 res = sqr.sum()*1.0/count 618 # res = ((a - b) ** 2).mean() 619 return res 620