TanSanC

import time
import cv2
import numpy as np
from mss import mss

red_color = (255, 255, 255)

def checkImage(src, dst):
difference = cv2.subtract(src, dst)
ret, difference = cv2.threshold(difference, 55, 255, cv2.THRESH_BINARY)
nzCount = cv2.countNonZero(difference)
return nzCount

def checkContentsImage(src, srcNum, imageContents1 , imageContents2, imageContents3, imageContents4, lcapturedImage ):


returnValue = 0
if checkImage(src, imageContents1) < imageContentsTh:
print("Detected " + str(srcNum) + "-1 " + str(checkImage(src, imageContents1)))
returnValue = 1
if checkImage(src, imageContents2) < imageContentsTh:
print("Detected " + str(srcNum) + "-2 " + str(checkImage(src, imageContents2)))
returnValue = 2
if checkImage(src, imageContents3) < imageContentsTh:
print("Detected " + str(srcNum) + "-3 " + str(checkImage(src, imageContents3)))
returnValue = 3
if checkImage(src, imageContents4) < imageContentsTh:
print("Detected " + str(srcNum) + "-4 " + str(checkImage(src, imageContents4)))
returnValue = 4

if returnValue != 0:
if srcNum == 1:
lcapturedImage = cv2.rectangle(lcapturedImage, (3, 1), (116, 115), red_color, 2)
if srcNum == 3:
lcapturedImage = cv2.rectangle(lcapturedImage, (3, 1+141), (116, 115+141), red_color, 2)
if srcNum == 5:
lcapturedImage = cv2.rectangle(lcapturedImage, (3, 1+141+141), (116, 115+141+141), red_color, 2)
if srcNum == 7:
lcapturedImage = cv2.rectangle(lcapturedImage, (3, 1+141+141+141), (116, 115+141+141+141), red_color, 2)

if srcNum == 2:
lcapturedImage = cv2.rectangle(lcapturedImage, (143, 1), (143+116, 115), red_color, 2)
if srcNum == 4:
lcapturedImage = cv2.rectangle(lcapturedImage, (143, 1+ 141), (143+116, 115+141), red_color, 2)
if srcNum == 6:
lcapturedImage = cv2.rectangle(lcapturedImage, (143, 1 + 141 + 141), (143+116, 115+141+141), red_color, 2)
if srcNum == 8:
lcapturedImage = cv2.rectangle(lcapturedImage, (143, 1 + 141 + 141 + 141), (143+116, 115+141+141+141), red_color, 2)

return returnValue



print("load finger png files...")
imageFinger1 = cv2.imread("finger1.bmp", cv2.IMREAD_GRAYSCALE)
imageFinger2 = cv2.imread("finger2.bmp", cv2.IMREAD_GRAYSCALE)
imageFinger3 = cv2.imread("finger3.bmp", cv2.IMREAD_GRAYSCALE)
imageFinger4 = cv2.imread("finger4.bmp", cv2.IMREAD_GRAYSCALE)
#imageFinger1 = cv2.imread("finger1.bmp")
#imageFinger2 = cv2.imread("finger2.bmp")
#imageFinger3 = cv2.imread("finger1.png")
#imageFinger4 = cv2.imread("finger1.png")
print("load finger png files... Done")


with mss() as sct:
mon1 = sct.monitors[1]
mon2 = sct.monitors[2]
box = {'top': mon1['top'] +178, 'left': mon1['left'] + 913, 'width': 458, 'height': 516}
componentsbox = {'top': mon1['top'] +290, 'left': mon1['left'] + 486, 'width': 257, 'height': 536}
componentsbox1 = {'top': mon1['top'] +290, 'left': mon1['left'] + 486, 'width': 114, 'height': 115}
componentsbox2 = {'top': mon1['top'] +290, 'left': mon1['left'] + 626, 'width': 114, 'height': 115}
componentsbox3 = {'top': mon1['top'] +430, 'left': mon1['left'] + 486, 'width': 114, 'height': 115}
componentsbox4 = {'top': mon1['top'] +430, 'left': mon1['left'] + 626, 'width': 114, 'height': 115}
componentsbox5 = {'top': mon1['top'] +570, 'left': mon1['left'] + 486, 'width': 114, 'height': 115}
componentsbox6 = {'top': mon1['top'] +570, 'left': mon1['left'] + 626, 'width': 114, 'height': 115}
componentsbox7 = {'top': mon1['top'] +710, 'left': mon1['left'] + 486, 'width': 114, 'height': 115}
componentsbox8 = {'top': mon1['top'] +710, 'left': mon1['left'] + 626, 'width': 114, 'height': 115}

DebugMode = False
# mon = sct.monitors[0]
while True:
last_time = time.time()
capturedImage = np.array(sct.grab(box))
capturedImage = cv2.cvtColor(capturedImage, cv2.COLOR_BGR2GRAY)

#ret, capturedImage = cv2.threshold(capturedImage, 127, 255, cv2.THRESH_BINARY)
#ret, imageFinger1 = cv2.threshold(imageFinger1, 127, 255, cv2.THRESH_BINARY)
#ret, imageFinger2 = cv2.threshold(imageFinger2, 127, 255, cv2.THRESH_BINARY)

#capturedImage = cv2.cvtColor(capturedImage, cv2.COLOR_BGR2RGB)
#capturedImage = cv2.cvtColor(capturedImage, cv2.COLOR_BGR2GRAY)
#capturedImage = cv2.threshold(capturedImage, 127,255, cv2.THRESH_BINARY)
#imageFinger1 = cv2.threshold(imageFinger1, 127, 255, cv2.THRESH_BINARY)
#imageFinger2 = cv2.threshold(imageFinger2, 127, 255, cv2.THRESH_BINARY)


#print('fps: {0}'.format(1 / (time.time()-last_time)))

#cv2.imshow('capturedImage', capturedImage)

difference = cv2.subtract(capturedImage, imageFinger1)
ret, difference = cv2.threshold(difference, 55, 255, cv2.THRESH_BINARY)
if DebugMode == True:
cv2.imshow('imageFinger1', difference)
nzCount1 = cv2.countNonZero(difference)
#print("imageFinger1 : " + str(nzCount1))

difference = cv2.subtract(capturedImage, imageFinger2)
ret, difference = cv2.threshold(difference, 55, 255, cv2.THRESH_BINARY)
if DebugMode == True:
cv2.imshow('imageFinger2', difference)
nzCount2 = cv2.countNonZero(difference)
#print("imageFinger2 : " + str(nzCount2))



difference = cv2.subtract(capturedImage, imageFinger3)
ret, difference = cv2.threshold(difference, 55, 255, cv2.THRESH_BINARY)
if DebugMode == True:
cv2.imshow('imageFinger3', difference)
nzCount3 = cv2.countNonZero(difference)
#print("imageFinger3 : " + str(nzCount3))

difference = cv2.subtract(capturedImage, imageFinger4)
ret, difference = cv2.threshold(difference, 55, 255, cv2.THRESH_BINARY)
if DebugMode == True:
cv2.imshow('imageFinger4', difference)
nzCount4 = cv2.countNonZero(difference)
#print("imageFinger4 : " + str(nzCount4))
imageFingerNumber = 0

if nzCount1 < 10000 and nzCount2 > 10000 and nzCount3 > 10000 and nzCount4 > 10000:
print("imageFinger1 : " + str(nzCount1))
imageFingerNumber = 1

if nzCount1 > 10000 and nzCount2 < 10000 and nzCount3 > 10000 and nzCount4 > 10000:
print("imageFinger2 : " + str(nzCount2))
imageFingerNumber = 2

if nzCount1 > 10000 and nzCount2 > 10000 and nzCount3 < 10000 and nzCount4 > 10000:
print("imageFinger3 : " + str(nzCount3))
imageFingerNumber = 3

if nzCount1 > 10000 and nzCount2 > 10000 and nzCount3 > 10000 and nzCount4 < 10000:
print("imageFinger4 : " + str(nzCount4))
imageFingerNumber = 4



capturedImage = np.array(sct.grab(componentsbox))
capturedImage = cv2.cvtColor(capturedImage, cv2.COLOR_BGR2GRAY)
cv2.imshow('ContentsBox', capturedImage)

if imageFingerNumber != 0:
print("Detected finger Number : !!!" + str(imageFingerNumber))

imageContents1 = cv2.imread("Acontent"+ str(imageFingerNumber) + "-1.bmp", cv2.IMREAD_GRAYSCALE)
imageContents2 = cv2.imread("Acontent"+ str(imageFingerNumber) + "-2.bmp", cv2.IMREAD_GRAYSCALE)
imageContents3 = cv2.imread("Acontent"+ str(imageFingerNumber) + "-3.bmp", cv2.IMREAD_GRAYSCALE)
imageContents4 = cv2.imread("Acontent"+ str(imageFingerNumber) + "-4.bmp", cv2.IMREAD_GRAYSCALE)

imageContentsTh = 120

#cv2.imshow('ContentsBox', capturedImage )

capturedImage1 = np.array(sct.grab(componentsbox1))
capturedImage1 = cv2.cvtColor(capturedImage1, cv2.COLOR_BGR2GRAY)

checkContentsImage(capturedImage1, 1, imageContents1, imageContents2, imageContents3, imageContents4, capturedImage)

capturedImage2 = np.array(sct.grab(componentsbox2))
capturedImage2 = cv2.cvtColor(capturedImage2, cv2.COLOR_BGR2GRAY)

checkContentsImage(capturedImage2, 2, imageContents1, imageContents2, imageContents3, imageContents4, capturedImage)

capturedImage3 = np.array(sct.grab(componentsbox3))
capturedImage3 = cv2.cvtColor(capturedImage3, cv2.COLOR_BGR2GRAY)

checkContentsImage(capturedImage3, 3, imageContents1, imageContents2, imageContents3, imageContents4, capturedImage)

capturedImage4 = np.array(sct.grab(componentsbox4))
capturedImage4 = cv2.cvtColor(capturedImage4, cv2.COLOR_BGR2GRAY)


checkContentsImage(capturedImage4, 4, imageContents1, imageContents2, imageContents3, imageContents4, capturedImage)

capturedImage5 = np.array(sct.grab(componentsbox5))
capturedImage5 = cv2.cvtColor(capturedImage5, cv2.COLOR_BGR2GRAY)



checkContentsImage(capturedImage5, 5, imageContents1, imageContents2, imageContents3, imageContents4, capturedImage)

capturedImage6 = np.array(sct.grab(componentsbox6))
capturedImage6 = cv2.cvtColor(capturedImage6, cv2.COLOR_BGR2GRAY)


checkContentsImage(capturedImage6, 6, imageContents1, imageContents2, imageContents3, imageContents4, capturedImage)

capturedImage7 = np.array(sct.grab(componentsbox7))
capturedImage7 = cv2.cvtColor(capturedImage7, cv2.COLOR_BGR2GRAY)


checkContentsImage(capturedImage7, 7, imageContents1, imageContents2, imageContents3, imageContents4, capturedImage)


capturedImage8 = np.array(sct.grab(componentsbox8))
capturedImage8 = cv2.cvtColor(capturedImage8, cv2.COLOR_BGR2GRAY)


checkContentsImage(capturedImage8, 8, imageContents1, imageContents2, imageContents3, imageContents4, capturedImage)


#Check Contents1
cv2.imshow('ContentsBox', capturedImage)

if cv2.waitKey(1000) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break

import time
import cv2
import numpy as np
from mss import mss


print("load finger png files...")
imageFinger1 = cv2.imread("finger1.png")
imageFinger2 = cv2.imread("finger2.png")
imageFinger3 = cv2.imread("finger3.png")
imageFinger4 = cv2.imread("finger4.png")
print("load finger png files... Done")


with mss() as sct:
mon1 = sct.monitors[1]
mon2 = sct.monitors[2]
mon3 = sct.monitors[3]
mon4 = sct.monitors[4]
box = {'top': mon4['top'] +400, 'left': mon4['left'] + 200, 'width': 150, 'height': 190}
# mon = sct.monitors[0]
while True:
last_time = time.time()
capturedImage = np.array(sct.grab(box))
capturedImage = cv2.cvtColor(capturedImage, cv2.COLOR_BGRA2RGB)
imageFinger1 = cv2.cvtColor(imageFinger1, cv2.COLOR_BGRA2RGB)
imageFinger2 = cv2.cvtColor(imageFinger2, cv2.COLOR_BGRA2RGB)

#print('fps: {0}'.format(1 / (time.time()-last_time)))

#cv2.imshow('capturedImage', capturedImage)

difference = cv2.subtract(capturedImage, imageFinger1)
b, g, r = cv2.split(difference)
diff = cv2.countNonZero(b) + cv2.countNonZero(g) + cv2.countNonZero(r)
cv2.imshow('imageFinger1', difference)
print("png 1 diff = " + str(diff))
if diff == 0:
print("Detected finger png 1 !!!")
cv2.imshow('imageFinger1', difference )

difference = cv2.subtract(capturedImage, imageFinger2)
b, g, r = cv2.split(difference)
diff = cv2.countNonZero(b) + cv2.countNonZero(g) + cv2.countNonZero(r)
print("png b bbbb = " + str(b))
print("png b diff = " + str(cv2.countNonZero(b)))
print("png g diff = " + str(cv2.countNonZero(g)))
print("png r diff = " + str(cv2.countNonZero(r)))
cv2.imshow('imageFinger2', difference)
print("png 2 diff = " + str(diff))

if diff == 0:
print("Detected finger png 2 !!!")
cv2.imshow('imageFinger1', difference)


if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break

[NTP] CNtpTime, sntp.h, sntp.cpp 의 문제점 정리

NTP 프로토콜을 이용하여 클라이언트 시간 동기화시

sntp.h, sntp.cpp 로 만들어진

CNtpTime 클래스를 많이 사용하는것 같다.

ex)

https://github.com/hsluoyz/rmtsvc/blob/master/net4cpp21/protocol/sntpclnt.cpp

http://read.pudn.com/downloads142/sourcecode/hack/trojan/616424/sntpclient%202008-08-03/NtpTime.c__.htm

https://github.com/domz1/integrity/blob/master/Source/Virtuos_v17/Build/Program/_Network/Misc/Src/Sntp.cpp

위 코드들 모두 누군가 만든 CNtpTime 을 그대로 사용하고있는데...

그런데 이 클래스에 문제점이 있다.

CNtpTime::operator SYSTEMTIME() 

CNtpTime 을 SystemTime 으로 형변환 해주는 오퍼레이터 함수인데

  st.wMilliseconds = NtpFractionToMs(Fraction());

이 부분에 문제가 있다.

Fraction 을 Milliseconds 로 변경한 결과가 1000 이 되는 경우가 발생한다.

NtpTime 실제 값을 저장 할 시에

FileTime 을 사용하는데

FileTime 은

Second 와 NanoSecond 를 구분하여 16진수 기준 앞 8자리 뒤 8자리로 표현한다.

NanoSecond 의 값이 0x100000000 이 1Second 인데

NanoSecond 의 표현부는 0xFFFFFFF 이므로 1Second 도 0xFFFFFFF 로 표기된다.

위 구조 상

NtpFractionToMs( Fraction() ) 의 결과값이 1000 이어도

Second 로의 올림이 발생하지 않아서

Milliseconds 가 1000 인 채로 다음 연산으로 넘어가게 된다.

Milliseconds 가 1000 인 상태에서

SystemTime 을 FileTime 으로 바꾸는 SystemTimeToFileTime 함수를 실행하게 되면

비정상값이 리턴된다.

[CPP] NTP Sync LocalClockOffset

NTP 는

Network Time Protocol 으로 네트워크를 통해 시간을 동기화 하는 프로토콜입니다.

NTP 서버 시간에 클라이언트 시간을 맞추기 위한 프로토콜입니다.

[현재 시점] 서버의 현재 시간과 클라이언트의 현재 시간이 다를 수 있고,

[지속 되는 상태] 서버의 1초와 클라이언트의 1초가 다를 수 있습니다.

서버 혹은 클라이언트간 시간이 아주 중요한 프로그램에서는

NTP 는 한번만 수행하는 것이 아닌 지속적으로 수행하여 동기화 하게 됩니다.

서버와 클라이언트의 시간 차이를 LocalClockOffset 으로 표기합니다.

여러 클라이언트의 시간을

NTP서버와 동기화하여

각 클라이언트간 시간이 동기화 하도록 하기 위해 사용 되는 값이 offset 입니다.

계산 식은

Timestamp Name ID When Generated

------------------------------------------------------------

Originate Timestamp T1 time request sent by client      C1

Receive Timestamp T2 time request received by server  S1

Transmit Timestamp T3 time reply sent by server         S2

Destination Timestamp T4 time reply received by client C2

The roundtrip delay d and system clock offset t are defined as:

d = (T4 - T1) - (T3 - T2)

t = ((T2 - T1) + (T3 - T4)) / 2.

t = ((S1 - C1) + (S2 - C2)) / 2.

여기서

여기서 서버와 클라리언트가 패킷을 주고 받는데 걸리는 딜레이(delay1, delay2)는 같다고 가정한다.

***** 1.인증하기-퍼온 글입니다 *****

 ▶ Step1. 파일명.CAB 을 인증서가 있는 폴더에 붙여넣습니다.

▶ Step 2. MSDOS 프롬프트에서 ActiveX Control이 모여있는 폴더로 이동한 뒤 다음과 같이  입력합니다.

    makecert -n "CN=test" -sv test.pvk test.cer  

▶ Step 3. 다음과 같이 개인공개키를 생성하는 화면이 나타납니다.

    적당한 패스워드를 입력해 주십시오.     

▶ Step 4. test.pvk와 test.cer 파일이 생성됩니다. 생성된 ser 파일을 이용해서 spc 파일을  생성합니다. dos 창에서 아래와같이 입력합니다.

    cert2spc test.cer test.spc  

▶ Step 5. Succeeded라는 메시지가 나타나고 spc 파일이 성공적으로 생성된것입니다.

    cab 파일 서명을 위해 다음과 같이 입력합니다.  

    signcode -spc test.spc -v test.pvk -n "test" 파일명.cab

▶ Step 6. 이전에 설정한 비밀번호를 입력합니다.  

▶ Step 7. Test Sign 과정이 마무리됩니다. DOS 창에서 다음과 같이 인증확인을 해볼 수 있습니다.

   chktrust 파일명.cab  

 　* 생성과정 중간에 Warning은 서명한 시간이 없어서 그런 것인데,

　 　테스트용은 원래 시간을 적지 않습니다.

▶ Step 8. 인증한 파일명.CAB파일(인증하기명령어가 있는 폴더에 붙여넣은 파일)을 원하는 폴더(웹호스팅폴더)에 업로드합니다.

***** 2.배포하기 *****

<!--

이부분은 보통 필요하지 않으므로 주석상태 이대로 두시면 됩니다.

<OBJECT CLASSID="clsid:5220cb21-c88d-11cf-b347-00aa00a28331">

    <PARAM NAME="LPKPath" VALUE="LPKfilename.LPK">

</OBJECT>

-->

<OBJECT ID="test1"

CLASSID="clsid:D743E11F-1E3D-4290-8844-D8DB1A36A5B7" CODEBASE="download/ocx/test1.CAB#version=1,0,4,0">

</OBJECT>

▶ clsid:D743E11F-1E3D-4290-8844-D8DB1A36A5B7 이부분은 CAB만드시고 압축을 풀어보시면

   test1.inf파일을 열어서 보시면 [test1.ocx]부분에 보시면 clsid={D743E11F-1E3D-4290-8844-D8DB1A36A5B7} 이걸 적어주시면 됩니다.

▶ CODEBASE는 위에 분의 말씀대로 다운로드 받을 경로(상대 or절대경로)적어주시고 #Version은 수정될때 업데이트 할때 필요합니다.

***** 3.체크하기 ***** 

만약 [1.인증하기]에서 chktrust 파일명.cab 했을때 설치할건지 물어보는 창이 뜬는데...

설치가 안된다.

[익스플로어]-[도구]-[인터넷옵션]-[보안]-[사용자지정수준]-[ActiveX컨트롤 및 플러그인]

  1.서명 안 된 ActiveX컨트롤 다운로드 - [사용] or [확인] 에 체크하십시오.

  2.안전하지 않은 것으로 표시된 ActiveX컨트롤 초기화 및 스크립팅 - [사용] or [확인] 에 체크

     -이 부분에 [사용안함]으로 체크시 웹코딩에서 <PARAM>으로 ActiveX에 프로퍼티넘길때 작동하지 않고

      스크립팅에서도 작동하지 않음

  3.ActiveX컨트롤 및 플로그인 실행  - [사용]체크해야 되겠죠

**** 배포전에 수동설치로 테스트하기 *****

우선 배포전에 해당ActiveX를 수동으로 로컬PC에 설치해보십시오.

1. WINDOW\system32\폴더에 해당OCX파일을 복사하시고

2. [실행]-regsvr32 파일명.ocx 로 레지스트리에 등록

3. 웹코딩에서 해당 ocx의 CLASSID="CLSID:D743E11F-1E3D-4290-8844-D8DB1A36A5B7"로 참조

4. 웹페이제에서 작동하면 OCX에는 이상이 없는 거겠죠

5. 설치한 OCX제거하기

6. [실행]-[regedit]-[HKEY_CLASSES_ROOT]-[편집메뉴]-[찾기]-D743E11F-1E3D-4290-8844-D8DB1A36A5B7복사

7. {D743E11F-1E3D-4290-8844-D8DB1A36A5B7}에 커서가 선택되어 있으면 [마우스오른쪽버튼]-[삭제]

8. 열어둔 익스플로어 닫고 새로 열어서 테스트 화면을 엽니다.(새로고침하면 계속작동이 됩니다.)

9. 그러면 해당OCX가 삭제 되서 OCX가 작동하지 않겠죠

10. 배포방법이 올바르면 설치할건지 알림창이 하나 뜨겠죠.

11. 설치 눌러서 설치가 됐다면 OCX가 제대로 작동하겠죠.

12. 만약에 설치창이 뜨고 [예]를 눌러서 설치를 했는데도 작동을 하지 않는다면...

13. 6번 방법으로 해당 OCX가 설치되었는지 확인하십시오.

14. 설치가 됐는데도 안 뜬다면...  [3.체크하기]의 보안-ActiveX의 사용여부 사항을 체크을 확인하시기 바랍니다.

window 를 open 으로 팝업시

parent window 에서 강제로

다시 window 를 open 하면

child window 가 닫긴다.

Audio Wave Form Renderer

Test Harness App

https://markheath.net/post/naudio-png-waveform-rendering

C# Panel DirectShow Video ScrollBar

        public System.Windows.Forms.Panel pnlVideo;

        public QuartzTypeLib.FilgraphManager m_objFilterGraph = null;

        public QuartzTypeLib.IBasicAudio m_objBasicAudio = null;

        public QuartzTypeLib.IVideoWindow m_objVideoWindow = null;

        public QuartzTypeLib.IMediaEvent m_objMediaEvent = null;

        public QuartzTypeLib.IMediaEventEx m_objMediaEventEx = null;

        public QuartzTypeLib.IMediaPosition m_objMediaPosition = null;

        public QuartzTypeLib.IMediaControl m_objMediaControl = null;

         m_objVideoWindow.SetWindowPosition(pnlVideo.ClientRectangle.Left,

                        pnlVideo.ClientRectangle.Top,

                        pnlVideo.ClientRectangle.Height * (int)videoResolutionRate,

                        pnlVideo.ClientRectangle.Height);

m_objVideoWindow shows the video at original rate

1. ScrollBar Padding 20px

                    m_objVideoWindow.SetWindowPosition(pnlVideo.ClientRectangle.Left,

                        pnlVideo.ClientRectangle.Top,

                        (pnlVideo.ClientRectangle.Height - 20) * (int)videoResolutionRate,

                        pnlVideo.ClientRectangle.Height - 20);

2. Size and Scroll Bar Enable

                pnlVideo.HorizontalScroll.Visible = true;

                pnlVideo.AutoScroll = true;

                pnlVideo.MaximumSize = new Size(this.ClientSize.Width, this.ClientSize.Height - 80);

                pnlVideo.AutoScrollMinSize = new Size((int)UserControl1.videoResolutionRate * (this.ClientSize.Height - 80), this.ClientSize.Height - 80);

                pnlVideo.ClientSize = new Size(this.ClientSize.Width, this.ClientSize.Height - 80);

                pnlVideo.Size = new Size(this.ClientSize.Width, this.ClientSize.Height - 80);

참조 dll 이

빌드할 프로젝트는 없고

dll 만 존재 할 경우

다시 강력키로 빌드하는 방법

1. 키파일을 생성한다.

sn -k key.snk

2. MSIL를 얻어온다.

ildasm TEST.dll /out:TEST.il

3.원본 dll backup

xcopy TEST.dll TEST.dll.orig

4. 추출된 MSIL와 key파일을 이용해서 새로운 assembly를 생성한다.

ilasm TEST.il /dll /key= key.snk

player.cpp(57): error C4996: 'av_register_all': deprecated로 선언되었습니다.

include\libavformat\avformat.h(2025) : 'av_register_all' 선언을 참조하십시오.

#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libswscale/swscale.h>

#include <stdio.h>

// compatibility with newer API

#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55,28,1)

#define av_frame_alloc avcodec_alloc_frame

#define av_frame_free avcodec_free_frame

#endif

void SaveFrame(AVFrame *pFrame, int width, int height, int iFrame) {

      FILE *pFile;

      char szFilename[32];

      int  y;

      // Open file

      sprintf_s(szFilename, "frame%d.ppm", iFrame);

      fopen_s(&pFile, szFilename, "wb");

      if (pFile == NULL)

            return;

      // Write header

      fprintf(pFile, "P6\n%d %d\n255\n", width, height);

      // Write pixel data

      for (y = 0; y<height; y++)

            fwrite(pFrame->data[0] + y*pFrame->linesize[0], 1, width * 3, pFile);

      // Close file

      fclose(pFile);

}

int main(int argc, char *argv[]) {

      // Initalizing these to NULL prevents segfaults!

      AVFormatContext   *pFormatCtx = NULL;

      int               i, videoStream;

      AVCodecContext    *pCodecCtxOrig = NULL;

      AVCodecContext    *pCodecCtx = NULL;

      AVCodec           *pCodec = NULL;

      AVFrame           *pFrame = NULL;

      AVFrame           *pFrameRGB = NULL;

      AVPacket          packet;

      int               frameFinished;

      int               numBytes;

      uint8_t           *buffer = NULL;

      struct SwsContext *sws_ctx = NULL;

      if (argc < 2) {

            printf("Please provide a movie file\n");

            return -1;

      }

      // Register all formats and codecs

      av_register_all();

      // Open video file

      if (avformat_open_input(&pFormatCtx, argv[1], NULL, NULL) != 0)

            return -1; // Couldn't open file

      // Retrieve stream information

      if (avformat_find_stream_info(pFormatCtx, NULL)<0)

            return -1; // Couldn't find stream information

      // Dump information about file onto standard error

      av_dump_format(pFormatCtx, 0, argv[1], 0);

      // Find the first video stream

      videoStream = -1;

      for (i = 0; i<pFormatCtx->nb_streams; i++)

            if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {

                  videoStream = i;

                  break;

            }

      if (videoStream == -1)

            return -1; // Didn't find a video stream

      // Get a pointer to the codec context for the video stream

      pCodecCtxOrig = pFormatCtx->streams[videoStream]->codec;

      // Find the decoder for the video stream

      pCodec = avcodec_find_decoder(pCodecCtxOrig->codec_id);

      if (pCodec == NULL) {

            fprintf(stderr, "Unsupported codec!\n");

            return -1; // Codec not found

      }

      // Copy context

      pCodecCtx = avcodec_alloc_context3(pCodec);

      if (avcodec_copy_context(pCodecCtx, pCodecCtxOrig) != 0) {

            fprintf(stderr, "Couldn't copy codec context");

            return -1; // Error copying codec context

      }

      // Open codec

      if (avcodec_open2(pCodecCtx, pCodec, NULL)<0)

            return -1; // Could not open codec

      // Allocate video frame

      pFrame = av_frame_alloc();

      // Allocate an AVFrame structure

      pFrameRGB = av_frame_alloc();

      if (pFrameRGB == NULL)

            return -1;

      // Determine required buffer size and allocate buffer

      numBytes = avpicture_get_size(PIX_FMT_RGB24, pCodecCtx->width,

            pCodecCtx->height);

      buffer = (uint8_t *)av_malloc(numBytes*sizeof(uint8_t));

      // Assign appropriate parts of buffer to image planes in pFrameRGB

      // Note that pFrameRGB is an AVFrame, but AVFrame is a superset

      // of AVPicture

      avpicture_fill((AVPicture *)pFrameRGB, buffer, PIX_FMT_RGB24,

            pCodecCtx->width, pCodecCtx->height);

      // initialize SWS context for software scaling

      sws_ctx = sws_getContext(pCodecCtx->width,

            pCodecCtx->height,

            pCodecCtx->pix_fmt,

            pCodecCtx->width,

            pCodecCtx->height,

            PIX_FMT_RGB24,

            SWS_BILINEAR,

            NULL,

            NULL,

            NULL

            );

      // Read frames and save first five frames to disk

      i = 0;

      while (av_read_frame(pFormatCtx, &packet) >= 0) {

            // Is this a packet from the video stream?

            if (packet.stream_index == videoStream) {

                  // Decode video frame

                 avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);

                  // Did we get a video frame?

                  if (frameFinished) {

                        // Convert the image from its native format to RGB

                        sws_scale(sws_ctx, (uint8_t const * const *)pFrame->data,

                             pFrame->linesize, 0, pCodecCtx->height,

                             pFrameRGB->data, pFrameRGB->linesize);

                        // Save the frame to disk

                        if (++i <= 5)

                             SaveFrame(pFrameRGB, pCodecCtx->width, pCodecCtx->height,

                             i);

                  }

            }

            // Free the packet that was allocated by av_read_frame

            av_free_packet(&packet);

      }

      // Free the RGB image

      av_free(buffer);

      av_frame_free(&pFrameRGB);

      // Free the YUV frame

      av_frame_free(&pFrame);

      // Close the codecs

      avcodec_close(pCodecCtx);

      avcodec_close(pCodecCtxOrig);

      // Close the video file

      avformat_close_input(&pFormatCtx);

      return 0;

}

Solution

https://github.com/intel/libyami-utils/commit/124712bfd4cccd43ab60bd160b0f8990d20e5911