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): 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.channel_mode = STEREO 166 frame.join = np.zeros(frame.nr_subbands, dtype = np.uint8) 167 return 168 169 sb_sample = np.zeros(shape = (frame.nr_blocks,2,frame.nr_subbands), dtype = np.uint16) 170 for blk in range(frame.nr_blocks): 171 for sb in range(frame.nr_subbands): 172 sb_sample[blk][0][sb] = np.uint16(frame.sb_sample[blk][0][sb] + frame.sb_sample[blk][1][sb])/2 173 sb_sample[blk][1][sb] = np.uint16(frame.sb_sample[blk][0][sb] - frame.sb_sample[blk][1][sb])/2 174 175 scale_factor, scalefactor = calculate_scalefactors(frame.nr_blocks, frame.nr_channels, frame.nr_subbands, sb_sample) 176 177 for sb in range(frame.nr_subbands): 178 suma = frame.scale_factor[0][sb] + frame.scale_factor[1][sb] 179 sumb = scale_factor[0][sb] + scale_factor[1][sb] 180 181 if suma > sumb: 182 frame.channel_mode = JOINT_STEREO 183 frame.join[sb] = 1 184 185 frame.scale_factor[0][sb] = scale_factor[0][sb] 186 frame.scale_factor[1][sb] = scale_factor[1][sb] 187 frame.scalefactor[0][sb] = scalefactor[0][sb] 188 frame.scalefactor[1][sb] = scalefactor[1][sb] 189 190 for blk in range(frame.nr_blocks): 191 frame.sb_sample[blk][0][sb] = sb_sample[blk][0][sb] 192 frame.sb_sample[blk][1][sb] = sb_sample[blk][1][sb] 193 194 195class SBCFrame: 196 syncword = 0 197 sampling_frequency = 0 198 nr_blocks = 0 199 channel_mode = 0 200 nr_channels = 0 201 allocation_method = 0 202 nr_subbands = 0 203 bitpool = 0 204 crc_check = 0 205 # pro subband - 1 206 join = np.zeros(8, dtype = np.uint8) 207 scale_factor = np.zeros(shape=(2, 8), dtype = np.int32) 208 scalefactor = np.zeros(shape=(2, 8), dtype = np.int32) 209 audio_sample = np.zeros(shape = (16,2,8), dtype = np.uint16) 210 sb_sample = np.zeros(shape = (16,2,8), dtype = np.uint16) 211 X = np.zeros(8, dtype = np.int16) 212 EX = np.zeros(8) 213 pcm = np.zeros(shape=(2, 8*16), dtype = np.int16) 214 bits = np.zeros(shape=(2, 8)) 215 levels = np.zeros(shape=(2, 8), dtype = np.int32) 216 217 218 def __init__(self, nr_blocks=16, nr_subbands=4, nr_channels=1, bitpool=31, sampling_frequency=44100, allocation_method = 0): 219 self.nr_blocks = nr_blocks 220 self.nr_subbands = nr_subbands 221 self.nr_channels = nr_channels 222 self.sampling_frequency = sampling_frequency_index(sampling_frequency) 223 self.bitpool = bitpool 224 self.allocation_method = allocation_method 225 self.init(nr_blocks, nr_subbands, nr_channels) 226 return 227 228 def init(self, nr_blocks, nr_subbands, nr_channels): 229 self.scale_factor = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 230 self.scalefactor = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 231 self.audio_sample = np.zeros(shape=(nr_blocks, nr_channels, nr_subbands), dtype = np.uint16) 232 self.sb_sample = np.zeros(shape=(nr_blocks, nr_channels, nr_subbands), dtype = np.uint16) 233 self.levels = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 234 self.pcm = np.zeros(shape=(nr_channels, nr_subbands*nr_blocks), dtype = np.int16) 235 self.join = np.zeros(nr_subbands, dtype = np.uint8) 236 self.X = np.zeros(nr_subbands, dtype = np.int16) 237 self.EX = np.zeros(nr_subbands) 238 239 def dump_audio_samples(self, blk, ch): 240 print self.audio_sample[blk][ch] 241 242 def dump_subband_samples(self, blk, ch): 243 print self.sb_sample[blk][ch] 244 245 def dump_state(self): 246 res = "SBCFrameHeader state:" 247 res += "\n - nr channels %d" % self.nr_channels 248 res += "\n - nr blocks %d" % self.nr_blocks 249 res += "\n - nr subbands %d" % self.nr_subbands 250 res += "\n - scale factors: %s" % self.scale_factor 251 res += "\n - levels: %s" % self.levels 252 res += "\n - join: %s" % self.join 253 res += "\n - bits: %s" % self.bits 254 print res 255 256 def __str__(self): 257 res = "SBCFrameHeader:" 258 res += "\n - syncword %d" % self.syncword 259 res += "\n - sampling frequency %d Hz" % sampling_frequency_to_str(self.sampling_frequency) 260 261 res += "\n - nr channels %d" % self.nr_channels 262 res += "\n - nr blocks %d" % self.nr_blocks 263 res += "\n - nr subbands %d" % self.nr_subbands 264 265 res += "\n - channel mode %s" % channel_mode_to_str(self.channel_mode) 266 res += "\n - allocation method %s" % allocation_method_to_str(self.allocation_method) 267 268 res += "\n - bitpool %d" % self.bitpool 269 res += "\n - crc check %d" % self.crc_check 270 return res 271 272 273def sbc_bit_allocation_stereo_joint(frame): 274 bitneed = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 275 bits = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 276 277 loudness = 0 278 279 if frame.allocation_method == SNR: 280 for ch in range(frame.nr_channels): 281 for sb in range(frame.nr_subbands): 282 bitneed[ch][sb] = frame.scale_factor[ch][sb] 283 else: 284 for ch in range(frame.nr_channels): 285 for sb in range(frame.nr_subbands): 286 if frame.scale_factor[ch][sb] == 0: 287 bitneed[ch][sb] = -5 288 else: 289 if frame.nr_subbands == 4: 290 loudness = frame.scale_factor[ch][sb] - offset4[frame.sampling_frequency][sb] 291 else: 292 loudness = frame.scale_factor[ch][sb] - offset8[frame.sampling_frequency][sb] 293 294 if loudness > 0: 295 bitneed[ch][sb] = loudness/2 296 else: 297 bitneed[ch][sb] = loudness 298 299 # search the maximum bitneed index 300 max_bitneed = 0 301 for ch in range(frame.nr_channels): 302 for sb in range(frame.nr_subbands): 303 if bitneed[ch][sb] > max_bitneed: 304 max_bitneed = bitneed[ch][sb] 305 306 307 # calculate how many bitslices fit into the bitpool 308 bitcount = 0 309 slicecount = 0 310 bitslice = max_bitneed + 1 #/* init just above the largest sf */ 311 312 while True: 313 bitslice -= 1 314 bitcount += slicecount 315 slicecount = 0 316 for ch in range(frame.nr_channels): 317 for sb in range(frame.nr_subbands): 318 if (bitneed[ch][sb] > bitslice+1) and (bitneed[ch][sb] < bitslice+16): 319 slicecount += 1 320 elif bitneed[ch][sb] == bitslice + 1: 321 slicecount += 2 322 if bitcount + slicecount >= frame.bitpool: 323 break 324 325 if bitcount + slicecount == frame.bitpool: 326 bitcount += slicecount 327 bitslice -= 1 328 329 # bits are distributed until the last bitslice is reached 330 for ch in range(frame.nr_channels): 331 for sb in range(frame.nr_subbands): 332 if bitneed[ch][sb] < bitslice+2: 333 bits[ch][sb]=0 334 else: 335 bits[ch][sb] = min(bitneed[ch][sb]-bitslice,16) 336 337 ch = 0 338 sb = 0 339 while bitcount < frame.bitpool and sb < frame.nr_subbands: 340 if bits[ch][sb] >= 2 and bits[ch][sb] < 16: 341 bits[ch][sb] += 1 342 bitcount += 1 343 elif (bitneed[ch][sb] == bitslice+1) and (frame.bitpool > bitcount+1): 344 bits[ch][sb] = 2 345 bitcount += 2 346 if ch == 1: 347 ch = 0 348 sb += 1 349 else: 350 ch = 1 351 352 353 ch = 0 354 sb = 0 355 while bitcount < frame.bitpool and sb < frame.nr_subbands: 356 if bits[ch][sb] < 16: 357 bits[ch][sb]+=1 358 bitcount+=1 359 if ch == 1: 360 ch = 0 361 sb += 1 362 else: 363 ch = 1 364 365 if bits.sum() != frame.bitpool: 366 print "bit allocation failed, bitpool %d, allocated %d" % (bits.sum() , frame.bitpool) 367 exit(1) 368 return bits 369 370 371def sbc_bit_allocation_mono_dual(frame): 372 #print "Bit allocation for mono/dual channel" 373 bitneed = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 374 bits = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 375 loudness = 0 376 377 for ch in range(frame.nr_channels): 378 # bitneed values are derived from the scale factors 379 if frame.allocation_method == SNR: 380 for sb in range(frame.nr_subbands): 381 bitneed[ch][sb] = frame.scale_factor[ch][sb] 382 else: 383 for sb in range(frame.nr_subbands): 384 if frame.scale_factor[ch][sb] == 0: 385 bitneed[ch][sb] = -5 386 else: 387 if frame.nr_subbands == 4: 388 loudness = frame.scale_factor[ch][sb] - offset4[frame.sampling_frequency][sb] 389 else: 390 loudness = frame.scale_factor[ch][sb] - offset8[frame.sampling_frequency][sb] 391 if loudness > 0: 392 bitneed[ch][sb] = loudness/2 393 else: 394 bitneed[ch][sb] = loudness 395 396 # search the maximum bitneed index 397 max_bitneed = 0 398 for sb in range(frame.nr_subbands): 399 if bitneed[ch][sb] > max_bitneed: 400 max_bitneed = bitneed[ch][sb] 401 402 print "mono: bitneed", bitneed, max_bitneed 403 # calculate how many bitslices fit into the bitpool 404 bitcount = 0 405 slicecount = 0 406 bitslice = max_bitneed + 1 407 408 while True: 409 bitslice = bitslice - 1 410 bitcount = bitcount + slicecount 411 slicecount = 0 412 for sb in range(frame.nr_subbands): 413 if (bitneed[ch][sb] > bitslice+1) and (bitneed[ch][sb] < bitslice+16): 414 slicecount = slicecount + 1 415 elif bitneed[ch][sb] == bitslice + 1: 416 slicecount = slicecount + 2 417 if bitcount + slicecount >= frame.bitpool: 418 break 419 420 if bitcount + slicecount == frame.bitpool: 421 bitcount = bitcount + slicecount 422 bitslice = bitslice - 1 423 424 print "mono: bitslice", bitslice 425 for sb in range(frame.nr_subbands): 426 if bitneed[ch][sb] < bitslice+2 : 427 bits[ch][sb]=0; 428 else: 429 bits[ch][sb] = min(bitneed[ch][sb]-bitslice,16) 430 431 sb = 0 432 while bitcount < frame.bitpool and sb < frame.nr_subbands: 433 if bits[ch][sb] >= 2 and bits[ch][sb] < 16: 434 bits[ch][sb] = bits[ch][sb] + 1 435 bitcount = bitcount + 1 436 437 elif (bitneed[ch][sb] == bitslice+1) and (frame.bitpool > bitcount+1): 438 bits[ch][sb] = 2 439 bitcount += 2 440 441 sb = sb + 1 442 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