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 # 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 if frame.channel_mode == JOINT_STEREO: 551 for sb in range(frame.nr_subbands): 552 add_bits(frame.join[sb],1) 553 554 for ch in range(frame.nr_channels): 555 for sb in range(frame.nr_subbands): 556 add_bits(frame.scale_factor[ch][sb], 4) 557 558 bitstream_len = (bitstream_index + 1) * 8 559 if bitstream_bits_available: 560 bitstream_len -= bitstream_bits_available 561 562 return sbc_crc8(bitstream, bitstream_len) 563 564 565 566def frame_to_bitstream(frame): 567 global bitstream, bitstream_bits_available, bitstream_index 568 init_bitstream() 569 570 add_bits(frame.syncword, 8) 571 add_bits(frame.sampling_frequency, 2) 572 add_bits(frame.nr_blocks/4-1, 2) 573 add_bits(frame.channel_mode, 2) 574 add_bits(frame.allocation_method, 1) 575 add_bits(frame.nr_subbands/4-1, 1) 576 add_bits(frame.bitpool, 8) 577 add_bits(frame.crc_check, 8) 578 579 if frame.channel_mode == JOINT_STEREO: 580 for sb in range(frame.nr_subbands-1): 581 add_bits(frame.join[sb],1) 582 add_bits(0,1) 583 584 for ch in range(frame.nr_channels): 585 for sb in range(frame.nr_subbands): 586 add_bits(frame.scale_factor[ch][sb], 4) 587 588 for blk in range(frame.nr_blocks): 589 for ch in range(frame.nr_channels): 590 for sb in range(frame.nr_subbands): 591 add_bits(frame.audio_sample[blk][ch][sb], frame.bits[ch][sb]) 592 593 bitstream_bits_available = 0 594 return bitstream 595 596def mse(a,b): 597 count = 1 598 for i in a.shape: 599 count *= i 600 delta = a - b 601 sqr = delta ** 2 602 res = sqr.sum()*1.0/count 603 # res = ((a - b) ** 2).mean() 604 return res 605