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