def findSYNC(source):
found = []
max_value = 0
max_index = -1
pn = UT.getPN(sync_pn_seed, pnsize) * 100
#print("pn: ", pn[:20])
corrarray = []
aa = datetime.datetime.now()
for idx in range(frameSize + 2):
transformed = np.fft.fft(source[idx:idx + int(frameSize)])
begin, end = UT.getTargetFreqBand(transformed, pnsize, subband[0])
corr = abs(np.corrcoef(transformed.real[begin:end], pn)[0][1])
#corr = np.correlate(transformed[begin:end, 1], pn)
corrarray.append(corr)
if max_value <= corr:
max_value = corr
max_index = idx
bb = datetime.datetime.now()
print("execution time: ", bb - aa)
print("max: ", max_value, max_index)
print("pn_max/min : ", pn.max(), pn.min())
# plt.plot(corrarray)
# plt.show()
if max_value > detectionThreshold:
return max_index
else:
print("Can't find cross-correlation peak over 0.8, max:%d in idx:%d" %
(max_value, max_index))
return -1
def insertBit(inbuf, outbuf, bit, pn, overwrite = False):
numOfPartialPNs = int((pnsize + partialPnSize - 1) / partialPnSize)
embededData = pn * bit
for idx in range(numOfPartialPNs):
begin = idx * partialPnSize
end = begin + partialPnSize
if end > pnsize:
end = pnsize
embededDataLength = end - begin
partialEmbededData = embededData[begin:end]
targetFrame = inbuf.read(frameSize)
if targetFrame.size < frameSize:
raise NotEnoughData("insertBit", outbuf, targetFrame)
targetSpectrum = np.fft.fft(targetFrame)
for band in subband: # embed a bit to multiple subbands
begin, end = UT.getTargetFreqBand(targetSpectrum, embededDataLength, band)
if overwrite == True:
targetSpectrum.real[begin:end] = partialEmbededData * (len(targetSpectrum) * 0.7 / (end - begin)) # Magnitude 강화
else:
targetSpectrum.real[begin:end] += partialEmbededData
u = np.fft.ifft(targetSpectrum)
outbuf.write(np.fft.ifft(targetSpectrum).real)
def insertBit1(inbuf, outbuf, partialPN):
bandsPer1PN = 3
fullWindow = get_window('hamming', frameSize)
leftHalfWindow = fullWindow.copy()
rightHalfWindow = fullWindow.copy()
center = int(frameSize / 2)
leftHalfWindow[:center] = leftHalfWindow[center]
rightHalfWindow[center:] = rightHalfWindow[center]
# In Freq domain, Generate 3 Frames of New Signal Y which embed data
emptySpectrum = np.array([
np.complex128(0.0) for i in range(
int(frameSize * NUM_OF_FRAMES_PER_PARTIAL_SYNC_PN / 2 + 1))
])
beginBand, endBand = UT.getTargetFreqBand(emptySpectrum,
len(partialPN) * bandsPer1PN,
subband[0])
for idx, value in enumerate(partialPN):
b = beginBand + idx * bandsPer1PN * NUM_OF_FRAMES_PER_PARTIAL_SYNC_PN
e = b + bandsPer1PN * NUM_OF_FRAMES_PER_PARTIAL_SYNC_PN
emptySpectrum.real[b] = value * (len(emptySpectrum.real) * 0.7 /
(endBand - beginBand)) # Magnitude 강화
#print (len(emptySpectrum.real), " ", idx, ". b: %d" % b, ", val: ", emptySpectrum.real[b:b+3])
#emptySpectrum.imag[b] = emptySpectrum.real[b]
# IFFT
dataSignal = np.fft.irfft(emptySpectrum)
# UT.plotInNewProcess("freq", abs(emptySpectrum))
# UT.plotInNewProcess("org", dataSignal)
# wy = windowing to 3 frames
dataSignal[:frameSize] *= leftHalfWindow
dataSignal[-frameSize:] *= rightHalfWindow
dataSignal /= max(abs(dataSignal.max()), abs(dataSignal.min()))
# UT.plotInNewProcess("L window", leftHalfWindow)
# UT.plotInNewProcess("R window", rightHalfWindow)
# UT.plotInNewProcess("C window", fullWindow)
# UT.plotInNewProcess("windowed", dataSignal, True)
# output = mix (org, wy)
mixedSignal = np.array([
np.float32(0.0)
for i in range(frameSize * NUM_OF_FRAMES_PER_PARTIAL_SYNC_PN)
])
for i in range(NUM_OF_FRAMES_PER_PARTIAL_SYNC_PN):
frame = inbuf.read(frameSize)
if frame.size < frameSize:
raise NotEnoughData("insertBit", frame.size, "/", frameSize)
mixedSignal[frameSize * i:frameSize * (i + 1)] = mix(
frame, dataSignal[frameSize * i:frameSize * (i + 1)])
outbuf.write(mixedSignal)
def insertBitOld(sourceSignal, bit, pnSeed, framesize, overwrite = False):
pn = UT.getPN(pnSeed, pnsize)
#print("insertBit, pn:", pn[:5])
if (True): # Basic Algorithm
#watermarkedSignal = np.add(originalSignal, np.multiply(pn, bit))
sourceSpectrum = np.fft.fft(sourceSignal)
#plt.plot(sourceSpectrum)
adjustedSpectrum = sourceSpectrum.copy()
# plt.plot(adjustedSpectrum[:,1])
for band in subband:
begin, end = UT.getTargetFreqBand(adjustedSpectrum, pnsize, band)
if overwrite == True:
adjustedSpectrum.real[begin:end] = pn * bit
else:
adjustedSpectrum.real[begin:end] += (pn * bit / 10000)
# plt.plot(adjustedSpectrum[:, 1])
#print ("%d -> %d " % (bit, UT.SGN(adjustedSpectrum[begin:end, 1], pn)))
watermarkedSignal = np.fft.ifft(adjustedSpectrum).real
# l1, = plt.plot(sourceSignal, label="L1")
# l2, = plt.plot(watermarkedSignal, label='l2')
# l3, = plt.plot(watermarkedSignal - sourceSignal, label='diff')
# plt.legend(handles = [l1,l2,l3])
# plt.show()
#watermarkedSignal = np.multiply(sourceSignal, np.multiply(pn, bit))
#watermarkedSignal = np.multiply(pn, bit)
#watermarkedSignal = pn
else: # improved algorithm (Not work well)
a1 = 0.005
a2 = 0.001
nlambda = 0.9
psi = UT.norminnerproduct(sourceSignal, pn)
if (psi >= 0 and bit == 1):
watermarkedSignal = np.add(sourceSignal, np.multiply(pn, a1))
elif (psi >= 0 and bit == -1):
watermarkedSignal = np.add(sourceSignal, np.multiply(pn, -1 * (a2 + nlambda * psi)))
elif (psi < 0 and bit == -1):
watermarkedSignal = np.add(sourceSignal, np.multiply(pn, -1 * a1))
elif (psi < 0 and bit == 1):
watermarkedSignal = np.add(sourceSignal, np.multiply(pn, -1 * (a2 - nlambda * psi)))
return watermarkedSignal
def printMSG(posRead):
print("---------------------------")
source, realPos = yield from rb.readfrom(frameSize * 88, posRead)
ix = 0
ppn = UT.getPN(msg_pn_seed, pnsize)
bitseq = []
for n in range(88):
begin = ix + n * frameSize
end = begin + frameSize
fram = source[begin:end]
tr = np.fft.fft(fram)
begin, end = UT.getTargetFreqBand(tr, pnsize, subband[0])
re, accu = UT.SGN(tr.real[begin:end], ppn)
bitseq.append(re)
UT.convertNegative2Zero(bitseq)
UT.print8bitAlignment(bitseq)
def showPN(position=415797, count=11, numOfShift=4):
global rb
pn = UT.getPN(sync_pn_seed, pnsize)
numOfPartialPNs = int((pnsize + partialPnSize - 1) / partialPnSize)
corrarray = np.ndarray(shape=(numOfShift, count))
corrarray.fill(0.0)
targetFrameSize = frameSize * numOfPartialPNs
orgPos = position
for shift in range(numOfShift):
position = orgPos + shift
for idx in range(count):
source, realPos = yield from rb.readfrom(targetFrameSize, position)
if (realPos != position):
print("warning!! wrong position realPos %d, position %d" %
(realPos, position))
try:
extractedPN = np.ndarray(shape=(pnsize))
extractedPN.fill(0.0)
for pnIdx in range(numOfPartialPNs):
begin = pnIdx * frameSize
end = begin + frameSize
transformed = np.fft.fft(source[begin:end])
b, e = UT.getTargetFreqBand(transformed, partialPnSize,
subband[0])
extractedPN[pnIdx * partialPnSize:(pnIdx + 1) *
partialPnSize] = transformed.real[b:e]
posRead = realPos + int(targetFrameSize)
r1, r2 = UT.SGN(extractedPN, pn)
#print("before: ", r1, extractedPN)
#extractedPN = extractedPN * r1 # pn 사인 원복
#print("after: ", r1, extractedPN)
#print (r1)
corr = abs(np.corrcoef(extractedPN, pn)[0][1])
corrarray[shift][idx] = corr
except Exception as err:
print(err)
return -1, posRead
position = posRead + targetFrameSize
print(corrarray)
plt.plot(corrarray[:, :])
plt.show()
return
def extractSYNC(outbuf, position):
found = []
for bitIdx, value in enumerate(SYNC):
pn = UT.getPN(sync_pn_seed, pnsize)
numOfPartialPNs = int((pnsize + partialPnSize - 1) / partialPnSize)
embededData = []
for idx in range(numOfPartialPNs):
begin = idx * partialPnSize
end = begin + partialPnSize
if end > pnsize:
end = pnsize
embededDataLength = end - begin
srcBegin = position + idx * frameSize
srcEnd = srcBegin + frameSize
targetFrame, realPos = outbuf.readfromSync(frameSize, srcBegin, update_ptr=False)
srcSpectrum = np.fft.fft(targetFrame)
begin, end = UT.getTargetFreqBand(srcSpectrum, embededDataLength, subband[0])
embededData.extend(srcSpectrum.real[begin:end])
position = srcEnd
result, accuracy = UT.SGN(embededData, pn)
if (result == value):
found.append(result)
else:
break
UT.printwithsign("SYNC:", SYNC)
UT.printwithsign("BITS:", found)
if (found == SYNC):
print("SYNC is found")
return True
else:
print("SYNC is not found: ", found)
return False
def extractMSG(outbuf, position):
idx = 0
numOfPartialPNs = int((pnsize + partialPnSize - 1) / partialPnSize)
pnlist = UT.generatePnList()
result = str("")
while (True):
begin = position + (idx * frameSize * numOfPartialPNs)
end = begin + frameSize * numOfPartialPNs
idx += 1
embededCode = [[] for i in subband]
for frameIdx in range(numOfPartialPNs):
b = begin + frameIdx * frameSize
e = b + frameSize
frame, realPos = outbuf.readfromSync(frameSize, b, update_ptr=False)
transformed = np.fft.fft(frame)
for num, band in enumerate(subband):
b, e = UT.getTargetFreqBand(transformed, partialPnSize, band)
embededCode[num].extend(transformed.real[b:e])
maxCorr = 0
maxCorrIdx = -1
for num, band in enumerate(subband):
for i, value in enumerate(pnlist):
corr = abs(np.corrcoef(embededCode[num], value)[0][1])
if corr > maxCorr:
maxCorr = corr
maxCorrIdx = i
character = chr(maxCorrIdx)
print("%c[ %d ]" % (character, maxCorrIdx), end=" ")
if character == '\n':
break
result += character
print("")
return result, end
def insertBit0(inbuf, outbuf, partialPN):
bandsPer1PN = 3
hopSize = 512
orgSignal = np.array([
np.float32(0.0)
for i in range(frameSize * NUM_OF_FRAMES_PER_PARTIAL_SYNC_PN)
])
newSignal = np.array([
np.float32(0.0)
for i in range(frameSize * NUM_OF_FRAMES_PER_PARTIAL_SYNC_PN)
])
begin = 0
filledOrgSignal = 0
fullWindow = get_window('hamming', frameSize)
leftHalfWindow = fullWindow.copy()
rightHalfWindow = fullWindow.copy()
center = int(frameSize / 2)
leftHalfWindow[:center] = leftHalfWindow[center]
rightHalfWindow[center:] = rightHalfWindow[center]
# normalized window
fullWindow = fullWindow / sum(fullWindow)
leftHalfWindow = leftHalfWindow / sum(leftHalfWindow)
rightHalfWindow = rightHalfWindow / sum(rightHalfWindow)
bo = True
while (begin + frameSize <= frameSize * NUM_OF_FRAMES_PER_PARTIAL_SYNC_PN
): # N frames 에 hop size 만큼 이동하면서 partialPN을 입력
if filledOrgSignal < begin + frameSize:
frame = inbuf.read(frameSize)
if frame.size < frameSize:
raise NotEnoughData("insertBit", frame.size, "/", frameSize)
orgSignal[filledOrgSignal:filledOrgSignal + frameSize] = frame
filledOrgSignal += frameSize
AllowedFrameToEmbedData = True
# Windowing
end = begin + frameSize
if begin == 0: # left half는 윈도우 제거
windowedSignal = orgSignal[begin:end] * leftHalfWindow
AllowedFrameToEmbedData = False
elif begin + frameSize == frameSize * NUM_OF_FRAMES_PER_PARTIAL_SYNC_PN: # right half는 윈도우 제거
windowedSignal = orgSignal[begin:end] * rightHalfWindow
AllowedFrameToEmbedData = False
else:
windowedSignal = orgSignal[begin:end] * fullWindow
AllowedFrameToEmbedData = True
# Time to Frequency domain transform
targetSpectrum = np.fft.rfft(windowedSignal)
# if bo:
# UT.plotInNewProcess("org", orgSignal[begin:end])
# UT.plotInNewProcess("win", windowedSignal)
# UT.plotInNewProcess("tSpec", targetSpectrum.real)
# Data Embedding
for band in subband: # embed a bit to multiple subbands
beginBand, endBand = UT.getTargetFreqBand(
targetSpectrum,
len(partialPN) * bandsPer1PN, band)
for idx, value in enumerate(partialPN):
b = beginBand + idx * bandsPer1PN
e = b + bandsPer1PN
if AllowedFrameToEmbedData is True:
#targetSpectrum.real[b:e] = value * (len(targetSpectrum.real) * 0.7 / (endBand - beginBand)) # Magnitude 강화
targetSpectrum.real[256] = 128.0
# Frequency to Time domain transform
newSignal[begin:end] += np.fft.irfft(targetSpectrum) # * hopSize
#print ("max : ", newSignal[begin:end], newSignal.max())
# if bo:
# bo = False
# UT.plotInNewProcess("tSpec2", targetSpectrum.real)
# UT.plotInNewProcess("partialPN", partialPN)
# UT.plotInNewProcess("new", newSignal[begin:end], True)
begin += hopSize
outbuf.write(newSignal)
