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 sb_sample = np.zeros(shape = (frame.nr_blocks,2,frame.nr_subbands), dtype = np.int32) 169 for blk in range(frame.nr_blocks): 170 for sb in range(frame.nr_subbands): 171 sb_sample[blk][0][sb] = (frame.sb_sample[blk][0][sb] + frame.sb_sample[blk][1][sb])/2 172 sb_sample[blk][1][sb] = (frame.sb_sample[blk][0][sb] - frame.sb_sample[blk][1][sb])/2 173 174 scale_factor, scalefactor = calculate_scalefactors(frame.nr_blocks, frame.nr_channels, frame.nr_subbands, sb_sample) 175 176 for sb in range(frame.nr_subbands-1): 177 suma = frame.scale_factor[0][sb] + frame.scale_factor[1][sb] 178 sumb = scale_factor[0][sb] + scale_factor[1][sb] 179 180 if suma >= sumb: 181 frame.channel_mode = JOINT_STEREO 182 frame.join[sb] = 1 183 184 frame.scale_factor[0][sb] = scale_factor[0][sb] 185 frame.scale_factor[1][sb] = scale_factor[1][sb] 186 frame.scalefactor[0][sb] = scalefactor[0][sb] 187 frame.scalefactor[1][sb] = scalefactor[1][sb] 188 189 for blk in range(frame.nr_blocks): 190 frame.sb_sample[blk][0][sb] = sb_sample[blk][0][sb] 191 frame.sb_sample[blk][1][sb] = sb_sample[blk][1][sb] 192 193 194class SBCFrame: 195 syncword = 0 196 sampling_frequency = 0 197 nr_blocks = 0 198 channel_mode = 0 199 nr_channels = 0 200 allocation_method = 0 201 nr_subbands = 0 202 bitpool = 0 203 crc_check = 0 204 # pro subband - 1 205 join = np.zeros(8, dtype = np.uint8) 206 scale_factor = np.zeros(shape=(2, 8), dtype = np.int32) 207 scalefactor = np.zeros(shape=(2, 8), dtype = np.int32) 208 audio_sample = np.zeros(shape = (16,2,8), dtype = np.uint16) 209 sb_sample = np.zeros(shape = (16,2,8), dtype = np.uint16) 210 X = np.zeros(8, dtype = np.int16) 211 EX = np.zeros(8) 212 pcm = np.zeros(shape=(2, 8*16), dtype = np.int16) 213 bits = np.zeros(shape=(2, 8)) 214 levels = np.zeros(shape=(2, 8), dtype = np.int32) 215 216 217 def __init__(self, nr_blocks=16, nr_subbands=4, nr_channels=1, bitpool=31, sampling_frequency=44100, allocation_method = 0): 218 self.nr_blocks = nr_blocks 219 self.nr_subbands = nr_subbands 220 self.nr_channels = nr_channels 221 self.sampling_frequency = sampling_frequency_index(sampling_frequency) 222 self.bitpool = bitpool 223 self.allocation_method = allocation_method 224 self.init(nr_blocks, nr_subbands, nr_channels) 225 return 226 227 def init(self, nr_blocks, nr_subbands, nr_channels): 228 self.scale_factor = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 229 self.scalefactor = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 230 self.audio_sample = np.zeros(shape=(nr_blocks, nr_channels, nr_subbands), dtype = np.uint16) 231 self.sb_sample = np.zeros(shape=(nr_blocks, nr_channels, nr_subbands), dtype = np.uint16) 232 self.levels = np.zeros(shape=(nr_channels, nr_subbands), dtype = np.int32) 233 self.pcm = np.zeros(shape=(nr_channels, nr_subbands*nr_blocks), dtype = np.int16) 234 self.join = np.zeros(nr_subbands, dtype = np.uint8) 235 self.X = np.zeros(nr_subbands, dtype = np.int16) 236 self.EX = np.zeros(nr_subbands) 237 238 def dump_audio_samples(self, blk, ch): 239 print self.audio_sample[blk][ch] 240 241 def dump_subband_samples(self, blk, ch): 242 print self.sb_sample[blk][ch] 243 244 def dump_state(self): 245 res = "SBCFrameHeader state:" 246 res += "\n - nr channels %d" % self.nr_channels 247 res += "\n - nr blocks %d" % self.nr_blocks 248 res += "\n - nr subbands %d" % self.nr_subbands 249 res += "\n - scale factors: %s" % self.scale_factor 250 res += "\n - levels: %s" % self.levels 251 res += "\n - join: %s" % self.join 252 res += "\n - bits: %s" % self.bits 253 print res 254 255 def __str__(self): 256 res = "SBCFrameHeader:" 257 res += "\n - syncword %d" % self.syncword 258 res += "\n - sampling frequency %d Hz" % sampling_frequency_to_str(self.sampling_frequency) 259 260 res += "\n - nr channels %d" % self.nr_channels 261 res += "\n - nr blocks %d" % self.nr_blocks 262 res += "\n - nr subbands %d" % self.nr_subbands 263 264 res += "\n - channel mode %s" % channel_mode_to_str(self.channel_mode) 265 res += "\n - allocation method %s" % allocation_method_to_str(self.allocation_method) 266 267 res += "\n - bitpool %d" % self.bitpool 268 res += "\n - crc check %d" % self.crc_check 269 return res 270 271 272def sbc_bit_allocation_stereo_joint(frame): 273 bitneed = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 274 bits = np.zeros(shape=(frame.nr_channels, frame.nr_subbands), dtype = np.int32) 275 276 loudness = 0 277 278 if frame.allocation_method == SNR: 279 for ch in range(frame.nr_channels): 280 for sb in range(frame.nr_subbands): 281 bitneed[ch][sb] = frame.scale_factor[ch][sb] 282 else: 283 for ch in range(frame.nr_channels): 284 for sb in range(frame.nr_subbands): 285 if frame.scale_factor[ch][sb] == 0: 286 bitneed[ch][sb] = -5 287 else: 288 if frame.nr_subbands == 4: 289 loudness = frame.scale_factor[ch][sb] - offset4[frame.sampling_frequency][sb] 290 else: 291 loudness = frame.scale_factor[ch][sb] - offset8[frame.sampling_frequency][sb] 292 293 if loudness > 0: 294 bitneed[ch][sb] = loudness/2 295 else: 296 bitneed[ch][sb] = loudness 297 298 # search the maximum bitneed index 299 max_bitneed = 0 300 for ch in range(frame.nr_channels): 301 for sb in range(frame.nr_subbands): 302 if bitneed[ch][sb] > max_bitneed: 303 max_bitneed = bitneed[ch][sb] 304 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 sb = 0 441 while bitcount < frame.bitpool and sb < frame.nr_subbands: 442 if bits[ch][sb] < 16: 443 bits[ch][sb] = bits[ch][sb] + 1 444 bitcount = bitcount + 1 445 sb = sb + 1 446 447 return bits 448 449def sbc_bit_allocation(frame): 450 if frame.channel_mode == MONO or frame.channel_mode == DUAL_CHANNEL: 451 return sbc_bit_allocation_mono_dual(frame) 452 elif frame.channel_mode == STEREO or frame.channel_mode == JOINT_STEREO: 453 return sbc_bit_allocation_stereo_joint(frame) 454 else: 455 print "Wrong channel mode ", frame.channel_mode 456 return -1 457 458def sbc_sampling_frequency_index(sample_rate): 459 sbc_sampling_frequency_index = 0 460 for i in range(len(sampling_frequency)): 461 if sample_rate == sampling_frequency[i]: 462 sbc_sampling_frequency_index = i 463 break 464 return sbc_sampling_frequency_index 465 466 467def sbc_crc8(data, data_len): 468 crc = 0x0f 469 j = 0 470 for i in range(data_len / 8): 471 crc = crc_table[crc ^ data[i]] 472 j = i + 1 473 474 bits_left = data_len%8 475 if bits_left: 476 octet = data[j] 477 for i in range(data_len%8): 478 bit = ((octet ^ crc) & 0x80) >> 7 479 if bit: 480 bit = 0x1d 481 crc = ((crc & 0x7f) << 1) ^ bit 482 octet = octet << 1 483 return crc 484 485 486bitstream = None 487bitstream_index = -1 488bitstream_bits_available = 0 489 490def init_bitstream(): 491 global bitstream, bitstream_bits_available, bitstream_index 492 bitstream = [] 493 bitstream_index = -1 494 bitstream_bits_available = 0 495 496def add_bit(bit): 497 global bitstream, bitstream_bits_available, bitstream_index 498 if bitstream_bits_available == 0: 499 bitstream.append(0) 500 bitstream_bits_available = 8 501 bitstream_index += 1 502 503 bitstream[bitstream_index] |= bit << (bitstream_bits_available - 1) 504 bitstream_bits_available -= 1 505 506 507def add_bits(bits, len): 508 global bitstream, bitstream_bits_available 509 for i in range(len): 510 add_bit((bits >> (len-1-i)) & 1) 511 512ibuffer = None 513ibuffer_count = 0 514 515def get_bit(fin): 516 global ibuffer, ibuffer_count 517 if ibuffer_count == 0: 518 ibuffer = ord(fin.read(1)) 519 ibuffer_count = 8 520 521 bit = (ibuffer >> 7) & 1 522 ibuffer = ibuffer << 1 523 ibuffer_count = ibuffer_count - 1 524 return bit 525 526def drop_remaining_bits(): 527 global ibuffer_count 528 #print "dropping %d bits" % ibuffer_count 529 ibuffer_count = 0 530 531def get_bits(fin, bit_count): 532 bits = 0 533 for i in range(bit_count): 534 bits = (bits << 1) | get_bit(fin) 535 # print "get bits: %d -> %02x" %(bit_count, bits) 536 return bits 537 538 539def calculate_crc(frame): 540 global bitstream, bitstream_bits_available, bitstream_index 541 init_bitstream() 542 543 add_bits(frame.sampling_frequency, 2) 544 add_bits(frame.nr_blocks/4-1, 2) 545 add_bits(frame.channel_mode, 2) 546 add_bits(frame.allocation_method, 1) 547 add_bits(frame.nr_subbands/4-1, 1) 548 add_bits(frame.bitpool, 8) 549 if frame.channel_mode == JOINT_STEREO: 550 for sb in range(frame.nr_subbands): 551 add_bits(frame.join[sb],1) 552 553 for ch in range(frame.nr_channels): 554 for sb in range(frame.nr_subbands): 555 add_bits(frame.scale_factor[ch][sb], 4) 556 557 bitstream_len = (bitstream_index + 1) * 8 558 if bitstream_bits_available: 559 bitstream_len -= bitstream_bits_available 560 561 return sbc_crc8(bitstream, bitstream_len) 562 563 564 565def frame_to_bitstream(frame): 566 global bitstream, bitstream_bits_available, bitstream_index 567 init_bitstream() 568 569 add_bits(frame.syncword, 8) 570 add_bits(frame.sampling_frequency, 2) 571 add_bits(frame.nr_blocks/4-1, 2) 572 add_bits(frame.channel_mode, 2) 573 add_bits(frame.allocation_method, 1) 574 add_bits(frame.nr_subbands/4-1, 1) 575 add_bits(frame.bitpool, 8) 576 add_bits(frame.crc_check, 8) 577 578 if frame.channel_mode == JOINT_STEREO: 579 for sb in range(frame.nr_subbands-1): 580 add_bits(frame.join[sb],1) 581 add_bits(0,1) 582 583 for ch in range(frame.nr_channels): 584 for sb in range(frame.nr_subbands): 585 add_bits(frame.scale_factor[ch][sb], 4) 586 587 for blk in range(frame.nr_blocks): 588 for ch in range(frame.nr_channels): 589 for sb in range(frame.nr_subbands): 590 add_bits(frame.audio_sample[blk][ch][sb], frame.bits[ch][sb]) 591 592 bitstream_bits_available = 0 593 return bitstream 594 595def mse(a,b): 596 count = 1 597 for i in a.shape: 598 count *= i 599 delta = a - b 600 sqr = delta ** 2 601 res = sqr.sum()*1.0/count 602 # res = ((a - b) ** 2).mean() 603 return res 604