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(frame): 159 if frame.nr_channels == 1: 160 frame.channel_mode = MONO 161 else: 162 frame.channel_mode = STEREO 163 frame.join = np.zeros(frame.nr_subbands, dtype = np.uint8) 164 return 165 sb_sample1 = np.zeros(shape = (frame.nr_blocks,2,frame.nr_subbands), dtype = np.uint16) 166 167 for blk in range(frame.nr_blocks): 168 for sb in range(frame.nr_subbands): 169 sb_sample1[blk][0][sb] = (frame.sb_sample[blk][0][sb] + frame.sb_sample[blk][1][sb])/2 170 sb_sample1[blk][1][sb] = (frame.sb_sample[blk][0][sb] - frame.sb_sample[blk][1][sb])/2 171 172 scale_factor, scalefactor = calculate_scalefactors(frame.nr_blocks, frame.nr_channels, frame.nr_subbands, sb_sample1) 173 174 175 for sb in range(frame.nr_subbands): 176 suma = frame.scale_factor[0][sb] + frame.scale_factor[1][sb] 177 sumb = scale_factor[0][sb] + scale_factor[1][sb] 178 179 if suma > sumb: 180 frame.channel_mode = JOINT_STEREO 181 frame.join[sb] = 1 182 183 frame.scale_factor[0][sb] = scale_factor[0][sb] 184 frame.scale_factor[1][sb] = scale_factor[1][sb] 185 frame.scalefactor[0][sb] = scalefactor[0][sb] 186 frame.scalefactor[1][sb] = scalefactor[1][sb] 187 188 for blk in range(frame.nr_blocks): 189 frame.sb_sample[blk][0][sb] = sb_sample1[blk][0][sb] 190 frame.sb_sample[blk][1][sb] = sb_sample1[blk][1][sb] 191 192 print " channel_mode = JOINT_STEREO" 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 = 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 # calculate how many bitslices fit into the bitpool 307 bitcount = 0 308 slicecount = 0 309 bitslice = max_bitneed + 1 #/* init just above the largest sf */ 310 311 while True: 312 bitslice -= 1 313 bitcount += slicecount 314 slicecount = 0 315 for ch in range(frame.nr_channels): 316 for sb in range(frame.nr_subbands): 317 if (bitneed[ch][sb] > bitslice+1) and (bitneed[ch][sb] < bitslice+16): 318 slicecount += 1 319 elif bitneed[ch][sb] == bitslice + 1: 320 slicecount += 2 321 if bitcount + slicecount >= frame.bitpool: 322 break 323 324 if bitcount + slicecount == frame.bitpool: 325 bitcount += slicecount 326 bitslice -= 1 327 328 # bits are distributed until the last bitslice is reached 329 for ch in range(frame.nr_channels): 330 for sb in range(frame.nr_subbands): 331 if bitneed[ch][sb] < bitslice+2 : 332 bits[ch][sb]=0; 333 else: 334 bits[ch][sb] = min(bitneed[ch][sb]-bitslice,16) 335 336 ch = 0 337 sb = 0 338 while bitcount < frame.bitpool and sb < frame.nr_subbands: 339 if bits[ch][sb] >= 2 and bits[ch][sb] < 16: 340 bits[ch][sb] += 1 341 bitcount += 1 342 elif (bitneed[ch][sb] == bitslice+1) and (frame.bitpool > bitcount+1): 343 bits[ch][sb] = 2 344 bitcount += 2 345 if ch == 1: 346 ch = 0 347 sb += 1 348 else: 349 ch = 1 350 351 352 ch = 0 353 sb = 0 354 while bitcount < frame.bitpool and sb < frame.nr_subbands: 355 if bits[ch][sb] < 16: 356 bits[ch][sb]+=1 357 bitcount+=1 358 if ch == 1: 359 ch = 0 360 sb += 1 361 else: 362 ch = 1 363 364 if bits.sum() != frame.bitpool: 365 print "bit allocation failed, bitpool %d, allocated %d" % (bits.sum() , frame.bitpool) 366 exit(1) 367 return bits 368 369 370def sbc_bit_allocation_mono_dual(frame): 371 #print "Bit allocation for mono/dual channel" 372 bitneed = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 373 bits = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 374 loudness = 0 375 376 for ch in range(frame.nr_channels): 377 # bitneed values are derived from the scale factors 378 if frame.allocation_method == SNR: 379 for sb in range(frame.nr_subbands): 380 bitneed[ch][sb] = frame.scale_factor[ch][sb] 381 else: 382 for sb in range(frame.nr_subbands): 383 if frame.scale_factor[ch][sb] == 0: 384 bitneed[ch][sb] = -5 385 else: 386 if frame.nr_subbands == 4: 387 loudness = frame.scale_factor[ch][sb] - offset4[frame.sampling_frequency][sb] 388 else: 389 loudness = frame.scale_factor[ch][sb] - offset8[frame.sampling_frequency][sb] 390 if loudness > 0: 391 bitneed[ch][sb] = loudness/2 392 else: 393 bitneed[ch][sb] = loudness 394 395 # search the maximum bitneed index 396 max_bitneed = 0 397 for sb in range(frame.nr_subbands): 398 if bitneed[ch][sb] > max_bitneed: 399 max_bitneed = bitneed[ch][sb] 400 401 # calculate how many bitslices fit into the bitpool 402 bitcount = 0 403 slicecount = 0 404 bitslice = max_bitneed + 1 405 406 while True: 407 bitslice = bitslice - 1 408 bitcount = bitcount + slicecount 409 slicecount = 0 410 for sb in range(frame.nr_subbands): 411 if (bitneed[ch][sb] > bitslice+1) and (bitneed[ch][sb] < bitslice+16): 412 slicecount = slicecount + 1 413 elif bitneed[ch][sb] == bitslice + 1: 414 slicecount = slicecount + 2 415 if bitcount + slicecount >= frame.bitpool: 416 break 417 418 if bitcount + slicecount == frame.bitpool: 419 bitcount = bitcount + slicecount 420 bitslice = bitslice - 1 421 422 for sb in range(frame.nr_subbands): 423 if bitneed[ch][sb] < bitslice+2 : 424 bits[ch][sb]=0; 425 else: 426 bits[ch][sb] = min(bitneed[ch][sb]-bitslice,16) 427 428 sb = 0 429 while bitcount < frame.bitpool and sb < frame.nr_subbands: 430 if bits[ch][sb] >= 2 and bits[ch][sb] < 16: 431 bits[ch][sb] = bits[ch][sb] + 1 432 bitcount = bitcount + 1 433 434 elif (bitneed[ch][sb] == bitslice+1) and (frame.bitpool > bitcount+1): 435 bits[ch][sb] = 2 436 bitcount += 2 437 438 sb = sb + 1 439 440 441 sb = 0 442 while bitcount < frame.bitpool and sb < frame.nr_subbands: 443 if bits[ch][sb] < 16: 444 bits[ch][sb] = bits[ch][sb] + 1 445 bitcount = bitcount + 1 446 sb = sb + 1 447 448 return bits 449 450def sbc_bit_allocation(frame): 451 if frame.channel_mode == MONO or frame.channel_mode == DUAL_CHANNEL: 452 return sbc_bit_allocation_mono_dual(frame) 453 elif frame.channel_mode == STEREO or frame.channel_mode == JOINT_STEREO: 454 return sbc_bit_allocation_stereo_joint(frame) 455 else: 456 print "Wrong channel mode ", frame.channel_mode 457 return -1 458 459def sbc_sampling_frequency_index(sample_rate): 460 sbc_sampling_frequency_index = 0 461 for i in range(len(sampling_frequency)): 462 if sample_rate == sampling_frequency[i]: 463 sbc_sampling_frequency_index = i 464 break 465 return sbc_sampling_frequency_index 466 467 468def sbc_crc8(data, data_len): 469 crc = 0x0f 470 j = 0 471 for i in range(data_len / 8): 472 crc = crc_table[crc ^ data[i]] 473 j = i + 1 474 475 bits_left = data_len%8 476 if bits_left: 477 octet = data[j] 478 for i in range(data_len%8): 479 bit = ((octet ^ crc) & 0x80) >> 7 480 if bit: 481 bit = 0x1d 482 crc = ((crc & 0x7f) << 1) ^ bit 483 octet = octet << 1 484 return crc 485 486 487bitstream = None 488bitstream_index = -1 489bitstream_bits_available = 0 490 491def init_bitstream(): 492 global bitstream, bitstream_bits_available, bitstream_index 493 bitstream = [] 494 bitstream_index = -1 495 bitstream_bits_available = 0 496 497def add_bit(bit): 498 global bitstream, bitstream_bits_available, bitstream_index 499 if bitstream_bits_available == 0: 500 bitstream.append(0) 501 bitstream_bits_available = 8 502 bitstream_index += 1 503 504 bitstream[bitstream_index] |= bit << (bitstream_bits_available - 1) 505 bitstream_bits_available -= 1 506 507 508def add_bits(bits, len): 509 global bitstream, bitstream_bits_available 510 for i in range(len): 511 add_bit((bits >> (len-1-i)) & 1) 512 513ibuffer = None 514ibuffer_count = 0 515 516def get_bit(fin): 517 global ibuffer, ibuffer_count 518 if ibuffer_count == 0: 519 ibuffer = ord(fin.read(1)) 520 ibuffer_count = 8 521 522 bit = (ibuffer >> 7) & 1 523 ibuffer = ibuffer << 1 524 ibuffer_count = ibuffer_count - 1 525 return bit 526 527def drop_remaining_bits(): 528 global ibuffer_count 529 #print "dropping %d bits" % ibuffer_count 530 ibuffer_count = 0 531 532def get_bits(fin, bit_count): 533 bits = 0 534 for i in range(bit_count): 535 bits = (bits << 1) | get_bit(fin) 536 # print "get bits: %d -> %02x" %(bit_count, bits) 537 return bits 538 539 540def calculate_crc(frame): 541 global bitstream, bitstream_bits_available, bitstream_index 542 init_bitstream() 543 544 add_bits(frame.sampling_frequency, 2) 545 add_bits(frame.nr_blocks/4-1, 2) 546 add_bits(frame.channel_mode, 2) 547 add_bits(frame.allocation_method, 1) 548 add_bits(frame.nr_subbands/4-1, 1) 549 add_bits(frame.bitpool, 8) 550 551 if frame.channel_mode == JOINT_STEREO: 552 #print ("Joint Stereo!") 553 for sb in range(frame.nr_subbands): 554 add_bits(frame.join[sb],1) 555 556 for ch in range(frame.nr_channels): 557 for sb in range(frame.nr_subbands): 558 add_bits(frame.scale_factor[ch][sb], 4) 559 560 bitstream_len = (bitstream_index + 1) * 8 561 if bitstream_bits_available: 562 bitstream_len -= bitstream_bits_available 563 564 return sbc_crc8(bitstream, bitstream_len) 565 566 567 568def frame_to_bitstream(frame): 569 global bitstream, bitstream_bits_available, bitstream_index 570 init_bitstream() 571 572 add_bits(frame.syncword, 8) 573 add_bits(frame.sampling_frequency, 2) 574 add_bits(frame.nr_blocks/4-1, 2) 575 add_bits(frame.channel_mode, 2) 576 add_bits(frame.allocation_method, 1) 577 add_bits(frame.nr_subbands/4-1, 1) 578 add_bits(frame.bitpool, 8) 579 add_bits(frame.crc_check, 8) 580 581 if frame.channel_mode == JOINT_STEREO: 582 for sb in range(frame.nr_subbands-1): 583 add_bits(frame.join[sb],1) 584 add_bits(0,1) 585 586 for ch in range(frame.nr_channels): 587 for sb in range(frame.nr_subbands): 588 add_bits(frame.scale_factor[ch][sb], 4) 589 590 for blk in range(frame.nr_blocks): 591 for ch in range(frame.nr_channels): 592 for sb in range(frame.nr_subbands): 593 add_bits(frame.audio_sample[blk][ch][sb], frame.bits[ch][sb]) 594 595 bitstream_bits_available = 0 596 return bitstream 597 598def mse(a,b): 599 count = 1 600 for i in a.shape: 601 count *= i 602 delta = a - b 603 sqr = delta ** 2 604 res = sqr.sum()*1.0/count 605 # res = ((a - b) ** 2).mean() 606 return res 607