KR20070104552A - 기록된 컴퓨터 세션의 플레이백 인스트럭션을 생성하는방법 및 시스템 - Google Patents

Abstract

제1 디바이스 상에서 실행되는 프로토콜 엔진은 제2 디바이스 상에서 실행되는 애플리케이션 프로그램이 생성하는 디스플레이 데이터를 표현하는 복수의 패킷을 포함하는 기록된 스트림을 수신한다. 프로토콜 엔진은 기록된 스트림내 패킷에 대해서, 그 패킷의 콘텐츠를 인간이 지각할 수 있는 방식으로 렌더링하는 것을 결정한다. 프로토콜 엔진은 그 결정 결과를 플레이백 데이터 구조에 저장한다. 패킷은 그 패킷이 저장하는 입력의 유형에 대응하여 마킹된다. 패킷의 콘텐츠를 렌더링하기 위한 목적지를 그 마킹에 대응하여 플레이백 데이터 구조에 저장한다. 또 다른 측면에서, 백그라운드 프로토콜 엔진은 기록된 세션내 복수의 패킷의 적어도 일부가 표현하는 복잡도를 결정하는 것에 대응하여 복수의 패킷의 적어도 일부들 사이에서의 확인한 시간의 간격을 조절한다. 백그라운드 프로토콜 엔진은 조절한 시간의 간격을 저장한다. 포그라운드 프로토콜 엔진은 플레이백 데이터 구조에 대응하여 기록된 스트림을 렌더링한다.

플레이백, 재생성 인스트럭션, 무활동

Description

기록된 컴퓨터 세션의 플레이백 인스트럭션을 생성하는 방법 및 시스템{METHODS AND SYSTEMS FOR GENERATING PLAYBACK INSTRUCTIONS FOR A RECORDED COMPUTER SESSION}

본 발명은 재생성 인스트럭션을 생성하는 방법 및 시스템에 관한 것이고, 특히, 기록된 컴퓨터 세션을 렌더링(rendering)하는데 있어서, 자동 시간-워프형 플레이백(automatic time-warped palyback)을 포함하는 플레이백 인스트럭션의 생성에 관한 것이다.

플로리다주 Ft. Lauderdale에 소재하는 싸이트릭스 시스템 주식회사가 제작한 ICA 프로토콜, X.org Foundation의 X 프로토콜, AT&T사의 가상 네트워크 컴퓨팅 프로토콜, 또는 워싱턴주 레드몬드에 소재하는 마이크로소프트사가 제작한 RDP 프로토콜과 같은 원격 표현 프로토콜이 현재 사용되고 있다. 기록된 표현 프로토콜 데이터(presentation protocol data)의 스트림에서 특정 지점을 보기 위해서는 그 스트림의 플레이백이 스트림의 시작부로부터 정확히 시작해야 하고 원하는 지점에 도달할 때까지 순차적으로 플레이백되어야 한다.

세션 기록을 위한 다수의 종래의 방법은, 주기적으로 스크린 스냅샷(screen snapshots)을 획득하는 것으로 동작하고, 이들 중 몇몇의 종래의 방법에서는 세션 활동(session activity)로부터 수집한 관심의 대상일 수 있는 표시에 대응하여 스냅샷의 빈도를 증가시킨다. 영상의 시퀀스는 슬라이드 쇼(slide shows)로서 또는 영상 수집 관리 툴을 이용하여 볼 수 있다. 다른 방법들은 MPG 또는 AVI와 같은 디지털 비디오 포맷을 기초로 하여 기록할 수 있고, 이들 포맷은 윈도우 미디어 플레이어(Windows Media Player) 또는 퀵 타임 플레이어(QuickTime player)와 같은 적절한 미디어 플레이어를 이용하여 본다. 여러 종래의 방법에는 어떤 윈도우 또는 애플리케이션과의 상호작용(interactions)을 보이는 섹션들을 삭제하여 보기 시간을 감소시키는 기능이 없다.

어떤 종래의 방법에서는 실시간 속도의 여러 배수로 기록된 세션을 플레이백시킬 수 있다. 사용자는 이들 실시간 속도의 여러 배수 중 임의의 일 속도로 플레이백하도록 선택할 수 있고, 플레이백 동안에 속도 배율기(speed multiplier)를 조절할 수 있다. 그러나, 사용자는 렌더링되는 대상에 대해 알지 못하므로, 관심이 낮은 섹션 동안에 속도를 증가시키도록 조절하기가 쉬우며, 이로써 관심이 높은 섹션의 시작 부분에서 세부사항들을 놓치기 쉽다. 또한, 중요하지 않은 사용자 활동의 긴 섹션을 다시 보기하는 경우에는 실시간보다 수 배 빠른 속도도 주관적으로는 느리다.

다수의 종래의 시스템에서 스트림 전체 보기(stream traversal)의 속도를 증가시키기 위해 스냅샷 생성을 최소화함으로써 플레이백을 최적화하려는 시도를 해왔다. 어떤 예에서, 이러한 시스템들 중 몇몇에서는 중요한 활동(activity)이 검출될 때까지는 스크린 스냅샷을 수행의 빈도를 낮추고, 중요한 활동이 검출되면 스 냅샷의 빈도를 증가시킨다. 그러나, 이들 시스템에서는 스냅샷들간에 입력 및 상태 변화가 캡쳐되지 않는 경우 상태를 상실할 수 있다는 단점이 있다.

본 발명은 플로리다주 Ft. Lauderdale에 소재하는 싸이트릭스 시스템 주식회사가 제작한 ICA 프로토콜, X.org Fondation의 X 프로토콜, AT&T사의 가상 네트워크 컴퓨팅 프로토콜, 또는 워싱턴주 레드몬드에 소재하는 마이크로소프트사가 제작한 RDP 프로토콜과 같은 원격 표현 프로토콜의 기록 및 플레이백 방법을 제공한다. 본 발명은 중요한 변화가 발생되지 않음을 자동으로 결정하여 하나 이상의 기록된 세션을 플레이백에서 제거함으로써 세션 기록을 수동 검토하는 데 소요되는 시간을 감소시킨다. 본 발명은 방향성 플레이백(directed playback), 즉 기록된 세션의 양방향 택일 렌더링(alternative rendering)을 제공한다. 본 발명은 방향성 플레이백을 수행하는 방법을 기술하는 플레이백 데이터 구조를 생성하도록 오프-스크린 렌더링 동작(off-screen rendering operation)을 향상시키고, 그 플레이백 데이터 구조를 이용하여 온-스크린 렌더링 프로세스(on-screen rendering process)를 조절한다. 사용자가 단독으로 선택하는 다수의 실시간을 제공하는 대신에, 본 발명은 리뷰어에 의해서 추가로 조절될 수도 있는 자동으로 변화되는 상황에 대응하여 변화하는 플레이백 속도(context-senstive playback rates)를 제공한다. 본 발명은 리뷰어의 이해 속도에 근사하게 자동으로 선택된 속도로 리뷰어에게 정보를 표시한다.

일 측면에서, 본 발명은 기록된 컴퓨터 세션의 플레이백을 위한 플레이백 인스트럭션을 생성하는 방법에 관한 것이다. 제1 디바이스 상에서 실행하는 프로토콜 엔진은 제2 디바이스 상에서 실행되는 애플리케이션 프로그램이 생성하는 디스플레이 데이터를 표현하는 복수의 패킷을 포함한다. 프로토콜 엔진은 기록된 스트림내 패킷에 대해서, 그 패킷의 콘텐츠가 인간이 지각할 수 있는 방식으로 렌더링되는 지를 결정한다. 프로토콜 엔진은 그 결정(determination)을 플레이백 데이터 구조에 저장한다.

또 다른 측면에서, 본 발명은 기록된 컴퓨터 세션의 플레이백 방법에 관한 것이다. 제1 디바이스 상에서 실행하는 백그라운드 프로토콜 엔진은 제2 디바이스 상에서 실행하는 애플리케이션 프로그램에 의해 생성되는 디스플레이 데이터를 표현하는 복수의 패킷을 포함하는 기록된 스트림을 수신한다. 백그라운드 프로토콜 엔진은 그 패킷이 인간이 지각할 수 있는 방식으로 렌더링되는 지를 결정한다. 백그라운드 프로토콜 엔진은 그 결정을 플레이백 데이터 구조에 저장한다. 포그라운드 프로토콜 엔진은 기록된 스트림으로부터 적어도 하나의 패킷을 검색한다. 포그라운드 프로토콜 엔진은 플레이백 데이터 구조를 액세스한다. 포그라운드 프로토콜 엔진은 플레이백 데이터 구조에 대응하여 적어도 하나의 패킷을 렌더링한다.

또 다른 측면에서, 본 발명은 기록된 세션을 렌더링하는 시스템에 관한 것이다. 제1 디바이스 상에서 실행하는 백그라운드 프로토콜 엔진은 기록된 스트림을 수신하는 것에 대응하여 플레이백 데이터 구조를 생성하며, 상기 기록된 스트림은 제2 디바이스 상에서 실행되는 애플리케이션 프로그램이 생성하는 디스플레이 데이터를 표현한다. 기록된 스트림을 수신하는 포그라운드 프로토콜 엔진은 백그라운드 프로토콜 엔진이 생성하는 플레이백 데이터 구조에 대응하여 기록된 스트림을 렌더링한다.

일 측면에서, 본 발명은 기록된 세션을 렌더링하기 위한 플레이백 인스트럭션을 생성하는 방법에 관한 것이다. 기록된 세션 ― 상기 기록된 세션은 애플리케이션 프로그램이 생성한 디스플레이 데이터를 표현하는 복수의 패킷을 포함함 ― 내의 패킷에 의해 저장된 입력의 유형이 식별된다. 패킷은 입력의 유형에 대응하여 마킹된다(marked). 패킷의 콘텐츠를 렌더링하기 위한 목적지는 그 마킹에 대응하여 플레이백 데이터 구조에 저장된다.

일 측면에서, 본 발명은 기록된 세션을 렌더링하는데 있어서 비활동(inactivity)의 기간을 삭제하는 방법에 관한 것이다. 기록된 세션 ― 상기 기록된 세션은 복수의 패킷을 포함하며 디스플레이 데이터를 표현함 ― 내 제1 패킷을 식별한다. 기록된 세션내 제2 패킷을 식별하며, 상기 제2 패킷은 제1 패킷을 바로 앞선다. 제1 패킷과 제2 패킷간의 제1 시간 간격을 결정한다. 제1 시간 간격이 임계를 초과한다고 결정한다. 제1 패킷과 제2 패킷간의 제2 시간 간격 ― 상기 제2 시간 간격은 제1 시간 간격보다 짧은 시간을 포함함 ― 을 이용하여 기록된 세션의 콘텐츠를 렌더링한다. 일 실시예에서, 제2 패킷은 제1 패킷을 바로 뒤따른다.

또 다른 측면에서, 본 발명은 기록된 세션을 렌더링하는데 있어서 비활동의 기간을 삭제하는 방법에 관한 것이다. 기록된 세션 ― 상기 기록된 세션은 복수의 패킷을 포함하며 디스플레이 데이터를 표현함 ― 내에서 마킹된 패킷과 이전의 최근접의 마킹된 패킷간의 제1 시간 간격을 결정한다. 제1 시간 간격이 임계를 초과한다고 결정한다. 마킹된 패킷과 이전의 최근접 마킹된 패킷간의 제2 시간 간격 ― 상기 제2 시간 간격은 제 1 시간 간격보다 짧은 시간을 포함함 ― 을 이용하여 기록된 세션의 콘텐츠를 렌더링한다.

또 다른 측면에서 본 발명은 기록된 세션을 렌더링하는데 있어서 그래픽 업데이트(graphics updates)를 삭제하는 방법에 관한 것이다. 애플리케이션 프로그램이 생성하는 디스플레이 데이터를 표현하는 기록된 세션내의 패킷을 식별한다. 상기 패킷은 제1 그래픽 업데이트를 포함한다. 제1 그래픽 업데이트에 의해서 영향을 받은 스크린 영역이 결정된다. 제1 그래픽 업데이트 후 스크린 영역의 상태와 그 스크린의 위치 표시를 저장한다. 시간 간격내에 그 스크린 영역에 영향을 미치는 제2 그래픽 업데이트를 식별한다. 제2 그래픽 업데이트 후 그 스크린 영역의 상태가 제1 그래픽 업데이트 후 스크린 영역의 상태와 상이한 지에 대응하여, 그 스크린 영역에 영향을 미치는 제2 그래픽 업데이트를 포함하는 제2 패킷의 렌더링 목적지를 플레이백 데이터 구조에 표시한다. 제2 그래픽 업데이트 후 그 스크린 영역의 상태가 제1 그래픽 업데이트 후 스크린 영역의 상태와 상이한 지에 대응하여 그 스크린 영역에 영향을 미치는 제2 그래픽 업데이트를 포함하는 제2 패킷과 연관된 렌더링 시간 간격을 플레이백 데이터 구조에 표시한다.

또 다른 실시예에서, 본 발명은 기록된 세션을 렌더링하는데 있어서 상호작용 시퀀스(interaction sequences)를 삭제하는 방법에 관한 것이다. 정책에 대응하여, 적어도 하나의 패킷의 상호작용 시퀀스의 시작을 확인한다. 상호작용 시퀀스가 버퍼에 렌더링되어야 함을 플레이백 데이터 구조에 표시한다. 그 상호작용 시퀀스의 종료를 확인한다. 확인된 상호작용 시퀀스의 시작을 앞서는 패킷과, 확인된 상호작용 시퀀스의 종료 다음에 오는 패킷간의 제1 시간 간격을 식별한다. 제1 시간 간격보다 짧은 제2의 렌더링 시간 간격을 플레이백 데이터 구조에 표시한다.

일 측면에서, 본 발명은 기록된 컴퓨터 세션을 렌더링하는데 있어서 자동 시간-워프형 플래이백 방법(method for automatic time-warped playback)에 관한 것이다. 백그라운드 프로토콜 엔진이 기록된 세션 ― 상기 기록된 세션은 복수의 패킷을 포함하며 디스플레이 데이터를 포함함 ― 을 수신한다. 백그라운드 프로토콜 엔진은 기록된 세션내 복수의 패킷의 적어도 일부가 표현하는 복잡도(measure of complexity)를 결정한다. 백그라운드 프로토콜 엔진은 기록된 세션내 복수의 패킷의 적어도 일부들간의 시간 간격을 확인한다. 백그라운드 프로토콜 엔진은 기록된 세션내 복수의 패킷의 적어도 일부가 표현하는 복잡도에 대응하여 확인된 시간 간격을 조절한다(modifies). 백그라운드 프로토콜 엔진은 조절된 시간의 간겨기을 플레이백 데이터 구조에 저장한다. 포그라운드 프로토콜 엔진은 플레이백 데이터 구조에 대응하여 기록된 스트림을 렌더링한다.

또 다른 측면에서, 본 발명은 기록된 컴퓨터 세션을 렌더링하는데 있어서 또 다른 자동 시간-워프형 플레이백 방법에 관한 것이다. 복수의 패킷을 포함하며 디스플레이 데이터를 표현하는 기록된 세션을 수신한다. 포커스를 갖는 윈도우 ― 상기 윈도우는 애플리케이션을 표시함 ― 를 표시하는 콘텐츠를 가지고 있는 제1 패킷을 식별한다. 제1 패킷의 콘텐츠를 렌더링하기 이전에 그 콘텐츠가 렌더링되는 제2 패킷과, 제1 패킷의 콘텐츠를 렌더링한 후에 그 콘텐츠가 렌더링되는 제3 패킷간의 시간 간격을 확인한다. 표시된 애플리케이션에 대응하여 그 시간 간격을 조절한다. 기록된 세션내 적어도 하나의 패킷을 그 조절에 대응하여 렌더링한다.

또 다른 측면에서, 본 발명은 기록된 컴퓨터 세션을 렌더링하는데 있어서, 자동 시간-워프형 플레이백 시스템에 관한 것이다. 프로토콜 엔진은 기록된 스트림 ― 상기 기록된 스트림은 복수의 패킷을 포함함 ― 을 수신하는 것에 대응하여 플레이백 데이터 구조를 생성하고, 상기 프로토콜 엔진은 생성된 플레이백 데이터 구조에 대응하여 기록된 스트림내의 적어도 하나의 패킷을 렌더링한다.

본 발명은 본 발명을 예시하되 제한하려는 것이 아닌 첨부 도면 및 이하 상세한 설명으로부터 보다 명확해질 것이다.

도 1A는 본 발명의 일 실시예를 실시하기에 적합한 클라이언트-서버 시스템을 도시하는 블럭도이다.

도 1B 및 1C는 본 발명과 관련하여 유용한 컴퓨터들의 실시예를 도시하는 블럭도이다.

도 2는 본 발명이 수행되는 네트워크(200)의 실시예를 도시하는 블럭도이다.

도 3 및 도 4는 네트워크(200)상의 기록 장치를 대체하는 선택적인 실시예를 도시하는 블럭도이다.

도 5는 프로토콜 데이터 스트림에 의해 표현되는 디스플레이 데이터를 표현하기 위한 시스템의 일 실시예를 도시하는 블럭도이다.

도 6은 서버-생성된 데이터를 기록하고 재생하기 위한 방법을 도시하는 흐름도이다.

도 7은 프로토콜 데이터 스트림에 의해 표현되는 디스플레이 데이터를 기록하기 위한 시스템내의 기록 장치를 상세히 도시하는 블럭도이다.

도 8은 프로토콜 데이터 스트림의 기록의 일 실시예를 나타낸다.

도 9는 상태유지 원격 표현 프로토콜의 플레이백 중에 실시간 탐색을 위한 방법에서 행하는 단계들의 일 실시예를 도시하는 흐름도이다.

도 10은 원격 표현 프로토콜의 플레이백 중에 실시간 탐색을 가능하게 하는 상태-스냅샷을 생성하기 위한 단계들의 일 실시예를 도시하는 흐름도이다.

도 11은 상태유지 원격 표현 프로토콜의 플레이백 중에 실시간 탐색을 위한 시스템을 도시하는 블럭도이다.

도 12는 상태-스냅샷의 적응성 생성을 위해 행하는 단계들의 일 실시예를 도시하는 흐름도이다.

도 13은 일 실시예의 탐색 가능성 분배의 세가지 타입을 도시하는 도면이다.

도 14는 결정된 탐색 가능성 분배에 대응하여 상태-스냅샷을 생성하는 일 실시예를 도시하는 도면이다.

도 15는 프로토콜 데이터 스트림의 표시의 사용자에 대한 사용 패턴의 일 실시예를 나타낸다.

도 16은 백그라운드 프로토콜 엔진, 포그라운드 프로토콜 엔진, 프로토콜 데이터 스트림, 활동 프로파일, 상태-스냅샷을 포함하는, 상태-스냅샷의 적응성 생성을 위한 시스템의 일 실시예를 도시하는 블럭도이다.

도 17은 기록된 세션을 표현하기 위한 시스템의 일 실시예를 도시하는 블럭도이다.

도 18은 기록된 컴퓨터 세션의 플레이백을 위한 플레이백 명령을 생성하기 위해 행하는 단계들의 일 실시예를 도시하는 흐름도이다.

도 19는 기록된 컴퓨터 세션의 플레이백을 위한 방법에서 행하는 단계들의 일 실시예를 도시하는 흐름도이다.

도 20은 기록된 세션을 표현하기 위한 플레이백 명령을 생성하는데 행하는 단계들의 일 실시예를 도시하는 흐름도이다.

도 21은 재생성된 기록된 스트림의 일 실시예를 나타내며, 그 콘텐츠는 플레이백 데이터 구조에 대응하여 표현된다.

도 22는 중요한 사용자 활동을 표현하는 콘텐츠를 갖는 기록된 스트림내의 임의의 패킷의 일 실시예를 나타내며, 이 실시예에서 마우스 입력은 실제 마우스 버튼 상태를 지시한다.

도 23은 기록된 세션을 표현하는데 있어 중요치 않은 활동을 갖는 기간을 제거하기 위해 행하는 단계들의 일 실시예를 도시하는 흐름도이다.

도 24는 기록된 세션을 표현하는데 있어 그래픽 업데이트를 제거하기 위해 행하는 단계들의 일 실시예를 도시하는 흐름도이다.

도 25는 제1 그래픽 업데이트 이후의 스크린 영역의 상태로부터 제2 그래픽 업데이트 이후의 스크린 영역의 상태에 변화가 있는지 여부에 대응하여 재생성된 기록된 세션을 표현하는 일 실시예를 나타낸다.

도 26은 기록된 세션을 표현하는데 있어 인터액션 시퀀스를 제거하기 위해 행하는 단계들의 일 실시예를 도시하는 흐름도이다.

도 27은 기록된 컴퓨터 세션을 표현하는데 있어 자동적 타임-워프형(time-warped) 플레이백이 행하는 단계들의 일 실시예를 도시하는 흐름도이다.

도 28은 기록된 컴퓨터 세션을 표현하는데 있어 식별된 애플리케이션에 대응하여 자동적 타임-워프된 플레이백이 행하는 단계들의 일 실시예를 도시하는 흐름도이다.

도 29는 기록된 컴퓨터 세션을 표현하는데 있어 자동적 타임-워프된 플레이백을 위한 시스템의 일 실시예를 도시하는 블럭도이다.

도 1A를 참조하면, 본 발명이 사용될 수 있는 클라이언트-서버 시스템의 일 실시예가 도시되어 있다. 제1 컴퓨팅 디바이스 (100', 100)는 통신 네트워크(180)를 통해 제2 컴퓨팅 디바이스(140', 140)와 통신한다. 제1 디바이스(100)와 제2 디바이스(140)와의 통신을 위한 네트워크(180)의 토폴로지는 버스, 스타, 또는 링 토폴로지일 수 있다. 네트워크(180)는 지역 네트워크(LAN), 대도시 네트워크(MAN), 또는 인터넷과 같은 광역 네트워크(WAN)일 수 있다. 도 1A에는 2개의 제1 컴퓨팅 디바이스(100, 100')와 2개의 제2 컴퓨팅 디바이스(140, 140')가 도시되 어 있지만, 다른 실시예에서는 다수의 디바이스들이 네트워크(180)에 연결될 수 있다.

제1 및 제2 디바이스(100, 140)는 표준 전화선, LAN 또는 WAN 링크(예를 들면, T1, T3, 56Kb, X.25), 광대역 연결(ISDN, Frame Relay, ATM) 그리고 무선 연결을 통해 네트워크(180)에 연결될 수 있다. 이러한 연결은 다양한 통신 프로토콜(예를 들면, TCP/IP, IPX, SPX, NetBIOS, NetBEUI, SMB, Ethernet, ARCNET, Fiber Distributed Data Interface(FDDI), RS232, IEEE802.11, IEEE802.11a, IEE802.11b, IEEE802.11g, direct asynchronous connections)을 이용하여 구축될 수 있다.

제1 디바이스(100)는 하나 이상의 제2 컴퓨팅 디바이스(140)에 의해 실행되는 애플리케이션들로부터 출력을 수신하고 디스플레이할 수 있으며 본 명세서에 개시된 프로토콜에 따라 동작할 수 있다. 제1 디바이스(100)는 퍼스널 컴퓨터, 윈도우-기반 터미널, 네트워크 컴퓨터, 인포메이션 어플라이언스, X-디바이스, 워크스테이션, 미니 컴퓨터, 퍼스널 디지털 어시스턴트, 또는 휴대폰일 수 있다.

이와 유사하게, 제2 컴퓨팅 디바이스(140)는 애플리케이션을 실행하기 위한 사용자 입력을 제1 컴퓨팅 디바이스(100)로부터 수신하고, 제1 디바이스(100)에 따라 애플리케이션 프로그램을 실행하고, 본 명세서에 개시된 프로토콜을 이용하여 제1 컴퓨팅 디바이스(100)와 상호작용할 수 있는 임의의 컴퓨팅 디바이스일 수 있다. 제2 컴퓨팅 디바이스(140)는 논리적으로 하나의 서버 시스템으로서 수행하는 서버 디바이스들의 그룹(본 명세서에서는 서버팜으로 언급됨)으로 제공될 수 있다. 일 실시예에서, 제2 컴퓨팅 디바이스(140)는 하나 이상의 제1 디바이스(100)으로부 터 다중 동시 접속을 지원하는 다중-사용자 서버 시스템일 수 있다.

도 1B 및 1C는 제1 컴퓨팅 디바이스(100) 및 제2 컴퓨팅 디바이스(140)로서 사용가능한 전형적인 컴퓨터의 블럭도를 도시한다. 도 1B 및 1C에 도시된 바와 같이, 각각의 컴퓨터(100)는 중앙 프로세스 유닛(102), 메인 메모리 유닛(104)을 포함한다. 각각의 컴퓨터(100)는 또한 다른 선택 요소들, 하나 이상의 입력/출력 디바이스(130a-130b)(일반적으로 참조번호 130으로 언급됨), 중앙 프로세스 유닛(102)와 통신하는 캐쉬 메모리(145)를 포함한다.

중앙 프로세싱 유닛(102)은 메인 메모리 유닛(104)으로부터 펫치된 명령들에 응답하여 이를 처리하는 임의의 논리 회로소자이다. 많은 실시예들에서, 중앙 프로세싱 유닛은 인텔사의 8088, 80286, 80386, 80486, 펜티엄, 펜티엄 프로, 펜티엄 II, 셀러론, Xeon 프로세서; 모토로라사의 68000, 68010, 68020, 68030, 68040, PowerPC601, PowerPC604, PowerPC604e, MPC603e, MPC603ei, MPC603ev, MPC603r, MPC603p, MPC740, MPC745, MPC750, MPC755, MPC7400, MPC7410, MPC7441, MPC7445, MPC7447, MPC7450, MPC7451, MPC7455, MPC7457 프로세서; 트랜스메타사의 Crusoe TM5800, Crusoe TM5600, Crusoe TM5500, Crusoe TM5400, Efficeon TM8600, Efficeon TM8300, Efficeon TM8620; 인터내셔널 비지니스 머신사의 RS/6000 프로세서, RS64, RS64 II, P2SC, POWER3, RS64III, POWER3-II, RS64IV, POWER4, POWER4+, POWER5, POWER6 프로세서; 어드밴스드 마이크로 디바이스의 AMD Opteron, AMD Athlon 64 FX, AMD Athlon, AMD Duron 프로세서와 같은 마이크로프로세서 유닛에 의해 제공된다.

메인 메모리 유닛(104)은 데이터를 저장하고 마이크로프로세서(102)에 의해 직접 접속될 수 있는 임의의 저장 위치를 허용할 수 있는 이하와 같은 하나 이상의 메모리 칩일 수 있다; Static random access memory(SRAM), Burst SRAM 또는 SynchBurst SRAM(BSRAM), Dynamic random access memory(DRAM), Fast Page Mode DRAM(FPM DRAM), Enhanced DRAM(EDRAM), Extended Data Output RAM(EDO RAM), Extended Data Output DRAM(EDO DRAM), Burst Extended Data Output DRAM(BEDO DRAM), Enhanced DRAM(EDRAM), synchronous DRAM(SDRAM), JEDEC SRAM, PC100SDRAM, Double Data Rate SDRAM(DDR SDRAM), Enhanced SDRAM(ESDRAM), SyncLink DRAM(SLDRAM), Direct Rambus DRAM(DRDRAM), Ferroelectric RAM(FRAM). 도 1B에 도시된 실시예에서, 프로세서(102)는 시스템 버스(120)를 통해 메인 메모리(104)와 통신한다. 도 1C는 프로세서가 메모리 포트를 통해 메인 메모리(104)와 직접 통신하는 컴퓨터 시스템(100)의 실시예를 도시한다. 예를 들면, 도 1C에서 메인 메모리는 DRDRAM일 수 있다.

도 1B 및 1C는 메인 프로세서(102)가 세컨더리 버스(때로는 "백사이드" 버스로 언급됨)를 통해 캐쉬 메모리(145)와 직접 통신하는 실시예를 도시한다. 다른 실시예에서, 메인 프로세서(102)는 시스템 버스(120)를 사용하여 캐쉬 메모리(145)와 통신한다. 캐쉬 메모리(145)는 일반적으로 메인 메모리(104)보다 빠른 응답시간을 가지며 SRAM, BSRAM, 또는 EDRAM으로 제공된다.

도 1B에 도시된 실시예에서, 프로세서(102)는 로컬 시스템 버스(120)를 통해 다양한 I/O 디바이스(130)와 통신한다. 중앙 프로세싱 유닛(102)을 I/O 디바이 스(130)에 연결시키도록 VESA VL 버스, ISA 버스, EISA 버스, MicroChannel Architecture(MCA) 버스, PCI 버스, PCI-X 버스, PCI-Express 버스, NuBus를 포함하는 다양한 버스가 이용될 수 있다. I/O 디바이스가 비디오 디스플레이인 실시예에서, 프로세서(102)는 디스플레이와 통신하기 위해 Advanced Graphics Port(AGP)를 사용할 수 있다. 도 1C는 메인 프로세서(102)가 HyperTransport, Rapid I/O, 또는 InfiniBand를 통해 I/O 디바이스(130b)와 직접 통신하는 컴퓨터 시스템(100)의 실시예를 도시한다. 도 1C는 또한 로컬 버스와 직접 통신이 합쳐진 실시예를 도시한다: 프로세서(102)는 로컬 상호접속 버스를 사용하여 I/O 디바이스(130a)와 통신하는 반면 I/O 디바이스(130b)와는 직접 통신한다.

다양한 I/O 디바이스(130)가 컴퓨터 시스템(100)에 존재할 수 있다. 입력 디바이스는 키보드, 마우스, 트랙패드, 트랙볼, 마이크로폰, 드로잉 테블릿을 포함한다. 출력 디바이스는 비디오 디스플레이, 스피커, 잉크젯 프린터, 레이저 프린터, 다이-서브리미션 프린터를 포함한다. I/O 디바이스는 하드 디스크 드라이브, 3.5-인치, 5.25 인치 디스크 또는 ZIP 디스크와 같은 플로피 디스크를 수용하는 플로피 디스크 드라이브, CD-ROM 드라이브, CD-R/RW 드라이브, DVD-ROM 드라이브, DVD-R 드라이브, DVD-RW 드라이브, 다양한 형태의 테이프 드라이브, Twintech Industry사의 USB Flash Drive 라인과 같은 USB 기록 장치와 같이 대용량 기록 장치를 제공할 수 있다.

다른 실시예에서, I/O 디바이스(130)는 시스템 버스(120)와 외부 통신 버스(USB bus, Apple Desktop Bus, RS-232 serial connection, SCSI bus, FireWire bus, FireWire 800 bus, Ethernet bus, AppleTalk bus, Gigabit Ethernet bus, Asynchronous Transfer Mode bus, HIPPI bus, Super HIPPI bus, SerialPlus bus, SCI/LAMP bus, FibreChannel bus, Serial Attached small computer system interface bus) 사이의 브리지일 수 있다.

도 1B 및 1C에 도시된 종류의 범용 데스크탑 컴퓨터는 일반적으로 작업 스케줄 및 시스템 리소스로의 액세스를 제어하는, 운영 시스템의 제어하에서 동작한다. 일반적인 운영 시스템은 마이크로소프트사의 MICROSOFT WINDOWS; 애플 컴퓨터사의 MacOS; 인터내셔널 비지니스 머신사의 OS/2; 칼데라 사에 의해 제공되는 무료 운영 시스템인 Linux를 포함한다.

다른 실시예에서, 제1 디바이스(100) 또는 제2 디바이스(140)는 다른 프로세서, 운영 시스템, 입력 디바이스를 가질 수 있다. 예를 들면, 일 실시예에서 제1 디바이스(100)는 Palm 사의 Zire71 퍼스널 디지털 어시스턴트이다. 이 실시예에서, Zire 71 은 Texas Instrument의 OMAP 310 프로세서를 사용하고 PalmOS 운영 시스템의 제어하에서 동작하고 액정 디스플레이 스크린, 스타일러스 입력 디바이스, five-way 네비게이터 디바이스를 포함한다.

도 2를 참조하면, 본 발명이 수행될 수 있는 네트워크(200)의 실시예를 도시하며, 제1 디바이스(202), 원격 표현 프로토콜 서버 엔진(204), 기록 장치(206), 프로토콜 데이터 스트림(208), 기록된 프로토콜 데이터 스트림(210), 제2 디바이스(212), 원격 표현 프로토콜 클라이언트 엔진(214), 디스플레이(216), 저장부(218), 기록된 프로토콜 데이터 스트림(220)을 포함한다. 기록 장치(206)는 프 로토콜 데이터 스트림(208)을 인터셉트한다. 기록 장치(206)는 프로토콜 데이터 스트림(208)으로부터 적어도 하나의 패킷을 복사하고 적어도 하나의 복사된 패킷을 이용하여 프로토콜 데이터 스트림의 기록(210)을 생성한다.

도 2를 참조하여 더욱 상세히 설명하면, 제1 디바이스(202)는 프로토콜 데이터 스트림(208)을 제2 디바이스(212)로 전송한다. 일 실시예에서, 제1 디바이스(202)는 프로토콜 데이터 스트림(208)을 제2 디바이스(212)에 전송하기 위해 원격 표현 프로토콜 서버 엔진(204)을 이용한다. 일 실시예에서, 제2 디바이스(212)는 제1 디바이스(202)로부터 프로토콜 데이터 스트림(208)을 수신하기 위해 원격 표현 프로토콜 클라이언트 엔진(214)을 이용한다. 일 실시예에서, 원격 표현 프로토콜은 사이트릭스 시스템사의 ICA 프로토콜, X.org 파운데이션의 X 프로토콜, AT&T 사의 Virtual Network Computing 프로토콜, 마이크로소프트사의 RDP 프로토콜과 같은 씬-클라이언트 프로토콜을 포함한다.

프로토콜 데이터 스트림(208)은 적어도 일부는 디스플레이 데이터를 표현하는, 다수의 패킷을 포함한다. 일 실시예에서, 프로토콜 데이터 스트림(208)은 기록된 세션에 대한 정보를 포함한다. 일 실시예에서, 프로토콜 데이터 스트림(208)은 메타데이터(metadata)를 포함한다. 다른 실시예에서, 프로토콜 데이터 스트림(208)은 기록된 세션내의 사용자에 대한 정보를 포함한다. 다른 실시예에서, 프로토콜 데이터 스트림(208)은 기록된 데이터를 생성하는 서버에 관한 정보를 포함한다. 다른 실시예에서, 프로토콜 데이터 스트림(208)은 시간스탬프(timestamp)를 포함한다.

일 실시예에서, 프로토콜 데이터 스트림(208)은 다수의 채널을 포함한다. 이 실시예에서, 채널은 데이터가 전송되는 피어-투-피어 접속을 포함한다. 다른 실시예에서, 프로토콜 데이터 스트림(208)은 다수의 가상 채널을 포함한다. 이 실시예에서, 가상 채널은 다른 채널에서 와핑(wrapped)된 채널이다. 제2 디바이스(212)는 프로토콜 데이터 스트림(208)을 수신하고, 일 실시예에서, 디스플레이 데이터를 재생성하기 위해 원격 표현 프로토콜 클라이언트 엔진(214)을 이용한다. 프로토콜 데이터 스트림(208)을 처리하여 제2 디바이스가 디스플레이(216)를 통해 사용자에게 디스플레이하도록 한다. 제2 디바이스(212)는 디스플레이 데이터를 처리하기 위해 원격 표현 프로토콜 클라이언트 엔진(214)을 이용할 수 있다. 디스플레이는 그 제한없이 청각, 시각, 촉각, 또는 후각적 표현들, 또는 이들의 조합을 포함한다.

기록 장치(206)는 제1 디바이스(202)로부터 제2 디바이스로 전송되는 프로토콜 데이터 스트림(208)을 인터셉트한다. 일 실시예에서, 기록 장치(206)는 하나 이상의 채널을 인터셉트하여 프로토콜 데이터 스트림(208)을 인터셉트한다. 다른 실시예에서, 기록 장치(206)는 하나 이상의 가상 채널을 인터셉트하여 프로토콜 데이터 스트림(208)을 인터셉트한다. 일 실시예에서, 기록 장치(206)는 제1 디바이스(202)가 제2 디바이스에 프로토콜 데이터 스트림(208)을 전송할 수 있는 하나 이상의 가상 채널을 모니터한다. 기록 장치(206)는 프로토콜 데이터 스트림으로부터 적어도 하나의 패킷을 복사한다. 일 실시예에서, 기록 장치(206)는 일정 방식(policy)에 응답하여 프로토콜 데이터 스트림의 특정 패킷을 복사하도록 결정한 다. 일 실시예에서, 이러한 일정 방식은 패킷내에 포함된 데이터 유형에 기반하여 기록 장치(206)가 기록하는 패킷을 규정한다. 다른 실시예에서, 기록 장치(206)는 패킷이 데이터를 포함하는지 여부에 대한 결정에 근거하여 프로토콜 데이터 스트림의 패킷을 복사할 것인지 결정한다. 일 실시예에서, 기록 장치(206)는 빈 패킷을 기록하지 않으며 다른 실시예에서는 빈 패킷을 기록한다. 일 실시예에서, 기록 장치(206)는 프로토콜 데이터 스트림(208)내의 모든 패킷을 기록한다.

기록 장치(206)는 적어도 하나의 복사된 패킷을 이용하여 기록된 프로토콜 데이터 스트림(210)을 생성한다. 일 실시예에서, 기록 장치(206)는 적어도 하나의 복사된 패킷을 정보와 결합시킨다. 일 실시예에서, 기록 장치(206)는 적어도 하나의 복사된 패킷을 시간스탬프와 결합시킨다. 다른 실시예에서, 기록 장치(206)는 패킷과 데이터 길이 표시자를 결합시킨다. 기록 장치(206)가 적어도 하나의 복사된 패킷을 정보, 예를 들면 시간 스탬프 또는 데이터 길이 표시자와 결합시키는 실시예에서, 기록 장치(206)는 패킷에 추가하여 이러한 정보를 기록된 프로토콜 데이터 스트림(210)내로 내장시킬 수 있으며 또는 기록 장치(206)는 이러한 정보를 패킷에 직접 내장시킬 수 있으며, 또는 기록 장치(206)는 패킷 및 기록된 프로토콜 데이터 스트림(210)으로부터 분리된 장소에 이 결합을 저장할 수 있다.

도 2에 도시된 바와 같이, 기록 장치(206)는 제1 디바이스상에 존재할 수 있다. 도 3은 기록 장치(206)가 제2 디바이스(212)상에 존재하는 실시예를 도시한다. 도 4는 기록 장치(206)가 제3 디바이스상에 존재하는 실시예를 도시한다. 기록 장치(206)가 존재할 수 있는 디바이스들은 클라이언트 컴퓨팅 시스템, 서버 컴 퓨팅 시스템, 프록시 서버 컴퓨팅 시스템, 네트워크 패킷 스니핑 컴퓨팅 시스템, 프로토콜 분석 컴퓨터 시스템 그리고 패스쓰루 서버 컴퓨팅 시스템을 포함한다.

기록 장치(206)는 적어도 하나의 복사된 패킷을 이용하여 그리고 일 실시예에서는 적어도 하나의 복사된 패킷과 결합된 정보를 이용하여 기록된 프로토콜 데이터 스트림(210)을 생성한다. 일 실시예에서, 기록 장치(206)는 생성한 이후에 프로토콜 데이터 스트림의 기록을 저장한다. 일 실시예에서, 기록 장치(206)는 프로토콜 데이터 스트림의 기록을 저장부(218)에 저장한다. 저장부(218)는 전력이 제거되었을 때 데이터 상태를 유지하는, 하드 드라이브, 플로피 드라이브, CD-RW, DVD-RW와 같은 영구 기록 장치를 포함할 수 있다. 다른 실시예에서, 저장부는 Static random access memory(SRAM), Burst SRAM 또는 SynchBurst SRAM(BSRAM), Dynamic random access memory(DRAM), Fast Page Mode DRAM(FPM DRAM), Enhanced DRAM(EDRAM), Extended Data Output RAM(EDO RAM), Extended Data Output DRAM(EDO DRAM), Burst Extended Data Output DRAM(BEDO DRAM), Enhanced DRAM(EDRAM), synchronous DRAM(SDRAM), JEDEC SRAM, PC100SDRAM, Double Data Rate SDRAM(DDR SDRAM), Enhanced SDRAM(ESDRAM), SyncLink DRAM(SLDRAM), Direct Rambus DRAM(DRDRAM), Ferroelectric RAM(FRAM) 과 같은 하나 이상의 휘발성 메모리를 포함할 수 있다.

일 실시예에서 저장부는 네트워크 저장 디바이스를 포함한다. 저장부(218)는 제1 디바이스 또는 제2 디바이스상에 존재할 수 있다. 다른 실시예에서, 저장부(218)는 프록시 서버 컴퓨팅 디바이스 또는 패스쓰루 서버 컴퓨팅 디바이스와 같 은 제3 디바이스상에 존재할 수 있다. 다른 실시예에서, 저장부(218)는 네트워크상에 존재하고 기록 장치(206)는 프로토콜 데이터 스트림의 기록(220)을 저장하기 위해 네트워크를 통해 저장부(218)에 액세스한다. 다른 실시예에서, 기록 장치(206)는 기록 장치가 존재하는 동일 디바이스상에 프로토콜 데이터 스트림의 기록을 저장한다.

도 5를 참조하면, 프로토콜 데이터 스트림의 기록으로부터 적어도 하나의 복사된 패킷을 판독하고, 프로토콜 데이터 스트림(506)에 의해 표현되는 디스플레이 데이터를 재생성하기 위해 적어도 하나의 복사된 패킷과 결합된 정보를 이용하는 프로토콜 엔진(502)을 도시한다. 프로토콜 엔진(502)은 프로토콜 데이터 스트림(506)을 수신한다. 일 실시예에서, 프로토콜 엔진(502)은 저장부(504)로부터 프로토콜 데이터 스트림(506)을 검색한다. 다른 실시예에서, 프로토콜 엔진(502)은 기록 장치(206)로부터 프로토콜 데이터 스트림을 검색한다. 다른 실시예에서, 프로토콜 엔진은 다른 컴퓨팅 디바이스로부터 프로토콜 데이터 스트림을 검색한다.

일 실시예에서, 프로토콜 엔진(502)은 패킷 판독기(508)와 디스플레이 데이터 재생성부(510)를 포함한다. 이 실시예에서, 패킷 판독기는 프로토콜 데이터 스트림의 기록으로부터 적어도 하나의 복사된 패킷을 판독한다. 일 실시예에서, 패킷 판독기(508)는 프로토콜 데이터 스트림의 기록으로부터 순차적으로 적어도 하나의 복사된 패킷을 판독한다.

프로토콜 엔진(502)는 적어도 하나의 복사된 패킷과 적어도 하나의 복사된 패킷과 결합된 임의의 정보를 처리한다. 프로토콜 엔진(502)은, 일 실시예에서, 이러한 처리를 위해 디스플레이 데이터 재생성부(510)를 이용한다. 패킷은 사용자에게 제공되는 디스플레이의 재생성을 가능하게 하는 데이터를 포함한다. 일 실시예에서, 제2 디바이스(212)는 도 2에 도시된 바와 같이 이러한 데이터를 처리한다. 일 실시예에서, 처리는 적어도 하나의 복사된 패킷의 콘텐츠를 버퍼로 렌더링(rendering)하는 것을 포함한다. 다른 실시예에서, 처리는 적어도 하나의 복사된 패킷의 콘텐츠를 지각할 수 있는 방식으로 렌더링하는 것을 포함한다. 재생성된 디스플레이는 그 제한없이, 청각, 시각, 촉각, 또는 후각적 표현들, 또는 이들의 조합을 포함한다.

일 실시예에서, 프로토콜 엔진(502)은 제1 디바이스(202)상에 존재한다. 다른 실시예에서, 프로토콜 엔진(502)은 제2 디바이스(212)상에 존재한다. 다른 실시예에서 프로토콜 엔진은 프록시 서버 컴퓨팅 디바이스 또는 패스쓰루 서버 컴퓨팅 디바이스와 같은, 제3 디바이스상에 존재한다.

도 7을 참조하여, 기록 장치(702)에 대해 더욱 자세히 설명한다. 기록 장치(702)는 프로토콜 데이터 스트림(710)의 인터셉션과 프로토콜 데이터 스트림(710)의 기록의 생성을 통해 서버-생성된 데이터를 기록한다.

일 실시예에서, 기록 장치(702)는 프로토콜 데이터 스트림 인터셉터(704), 패킷 복사기(706), 기록 생성기(708)를 포함한다. 일 실시예에서, 기록 장치(702)는 프로토콜 데이터 스트림(710)을 모니터하기 위해 프로토콜 데이터 스트림 인터셉터(704)를 이용한다. 다른 실시예에서, 기록 장치(702)는 제1 디바이스(202)로부터 제2 디바이스(212)로 전송되는 다수의 패킷을 포함하는 프로토콜 데이터 스트 림(710)을 인터셉트하기 위해 프로토콜 데이터 스트림 인터셉터(702)를 이용한다. 패킷 복사기(706)는 프로토콜 데이터 스트림의 적어도 하나의 패킷을 복사한다. 패킷 복사기(706)는 프로토콜 데이터 스트림내의 패킷을 복사할지 여부를 결정한다. 일 실시예에서, 패킷 복사기(706)는 일정 방식에 따라 이러한 결정을 한다. 이 실시예에서, 패킷 복사기(706)는 패킷이 임의의 데이터를 포함하는지 여부에 따라 또는 패킷내에 포함된 데이터 유형에 따라 패킷을 복사할지 결정할 수 있다.

일 실시예에서, 기록 장치(702)는 프로토콜 데이터 스트림의 기록을 생성하기 위해 적어도 하나의 복사된 패킷을 이용하는 기록 생성기(708)을 사용한다. 기록 생성기는 적어도 하나의 복사된 패킷을 조합하여 프로토콜 데이터 스트림의 기록으로 만든다. 일 실시예에서, 기록 생성기(708)는 프로토콜 데이터 스트림의 기록에 정보를 내장시킨다. 이러한 정보는 그 제한없이, 언제 패킷내에 포함된 데이터에 의해 표현되는 디스플레이 데이터를 재생성하는지 표시하는 시간 기준(tiem reference), 패킷내에 포함되는 데이터의 기술(descriptive)인 데이터 길이 표시자, 또는 프로토콜 데이터 스트림내에 포함되는 데이터에 의해 표현되는 디스플레이 데이터를 재생성하는데 이용되는 다양한 유형의 정보를 포함한다.

도 8은 프로토콜 데이터 스트림(710)의 기록(712)의 일 실시예를 도시한다. 도시된 실시예에서, 기록 생성기(708)는 적어도 하나의 복사된 패킷을 원격 표현 프로토콜 데이터 청크(chunk)로 분류했다. 기록 생성기(708)는 시간 기준 및 데이터 길이를 각각의 원격 표현 프로토콜 데이터 청크와 결합시키고 정보와 패킷들을 함께 조합하여 프로토콜 데이터 스트림(710)의 기록(712)으로 만든다.

도 7을 다시 참조하여, 일 실시예에서, 기록 장치(702)는 완성된 프로토콜 데이터 스트림의 기록을 저장부에 저장한다. 일 실시예에서, 저장부는 네트워크상에 배치되며 기록 장치(702)는 네트워크를 통해 기록을 저장부(714)에 전송한다. 다른 실시예에서, 저장부는 프록시 서버 컴퓨팅 디바이스상에 배치된다. 다른 실시예에서, 저장부는 패스쓰루 서버 컴퓨팅 디바이스상에 배치된다. 일 실시예에서, 저장부(714)는 기록 장치(702)와 같이 동일 디바이스상에 존재한다.

일 실시예에서, 도 7에서 어둡게 도시된, 프로토콜 데이터 스트림을 기록하고 플레이백하기 위한 시스템은 도 5에 설명되는 플레이백 디바이스(514)뿐만 아니라 기록 장치(702)도 포함한다. 플레이백 디바이스(514)는 프로토콜 데이터 스트림의 기록(712)으로부터 적어도 하나의 복사된 패킷을 수신하고 판독하기 위해 패킷 판독기(508)을 사용하고 프로토콜 데이터 스트림의 기록(712)에 의해 표현되는 디스플레이 데이터를 재생성하기 위해 내장된 정보를 사용하는, 프로토콜 엔진(502)을 포함한다. 일 실시예에서, 프로토콜 엔진(502)은 재생성된 디스플레이 데이터에서 순차적으로 패킷을 판독한다.

도 7에 도시된 다른 실시예에서, 서버-생성된 데이터를 기록하고 재생하기 위한 시스템은 기록 장치(702), 저장부(714), 그리고 프로토콜 엔진(502)을 포함한다. 기록 장치(702)는 프로토콜 데이터 스트림의 기록을 생성하고 저장부(714)에 기록(712)을 저장한다. 기록 장치는 프로토콜 데이터 스트림으로부터 적어도 하나의 패킷을 복사하고 정보(시간 기준 또는 패킷내의 데이터 길이를 기술하는 데이터 길이 표시자, 이에 제한되는 것은 아님)를 적어도 하나의 패킷에 결합시킨다. 저 장부(714)와 통신하는, 프로토콜 엔진(502)은 프로토콜 데이터 스트림으로부터 적어도 하나의 패킷을 판독하고 프로토콜 데이터 스트림(710)의 기록(712)에 의해 표현되는 디스플레이 데이터를 재생성하기 위해 적어도 하나의 패킷과 결합된 정보를 이용한다.

일 실시예에서, 기록 장치(702), 프로토콜 엔진(502), 또는 저장부(714)는 제1 디바이스(202)상에 함께 또는 분리되어 배치될 수 있다. 다른 실시예에서, 이들은 제2 디바이스(212)상에 함께 또는 분리되어 배치될 수 있다. 다른 실시예에서, 프록시 서버 컴퓨팅 디바이스, 네트워크 패킷 스니퍼, 패스쓰루 서버 컴퓨팅 디바이스와 같은 제3 디바이스상에 함께 또는 분리되어 존재할 수 있다. 다른 실시예에서, 저장부(714)는 기록 장치(702) 및 프로토콜 엔진(502)과 분리되어 저장 영역 네트워크상에 존재할 수 있다.

도 6을 참조하면, 서버-생성된 데이터를 기록하고 재생하기 위한 방법을 요약하는 흐름도가 도시되어 있다. 기록 장치(206)는 제1 디바이스(202)로부터 제2 디바이스(212)로 전송되는 다수의 패킷을 포함하는 프로토콜 데이터 스트림(208)을 인터셉트한다(단계602). 기록 장치(206)는 프로토콜 데이터 스트림(208)으로부터 적어도 하나의 패킷을 복사하고(단계604) 프로토콜 데이터 스트림의 기록(210)을 생성하며(단계606), 프로토콜 엔진(502)은 후에 기록된 프로토콜 데이터 스트림(210)에 의해 표현되는 디스플레이 데이터를 재생성하는데 사용한다(단계 608, 610).

기록 장치(206)는 제1 디바이스(202)로부터 제2 디바이스(212)로 전송되는 디스플레이 데이터를 표현하는, 다수의 패킷을 포함하는 프로토콜 데이터 스트림(208)을 인터셉트한다. 기록 장치는 프로토콜 데이터 스트림(208)의 적어도 하나의 패킷을 복사한다. 기록 장치(206)는 적어도 하나의 복사된 패킷을 이용하여 프로토콜 데이터 스트림의 기록을 생성한다. 일 실시예에서, 기록 장치(206)는 적어도 하나의 복사된 패킷과 정보를 결합시킨다. 이러한 정보는 시간 스탬프 또는 데이터 길이 표시자를 포함할 수 있다. 이 실시예에서, 기록 장치(206)는 패킷과 결합된 정보를 프로토콜 데이터 스트림의 기록(210)에 내장시킨다. 이 실시예의 다른예에서, 기록 장치(206)는 패킷과 결합된 정보를 분리된 프로토콜 데이터 스트림내에 저장한다. 이 실시예의 다른예에서, 기록 장치는 패킷과 결합된 정보를 데이터 저장소내에 저장한다. 프로토콜 엔진(502)은 프로토콜 데이터 스트림의 기록(210)으로부터 적어도 하나의 복사된 패킷을 판독하고 프로토콜 데이터 스트림에 의해 표현되는 디스플레이 데이터를 재생성하기 위해 적어도 하나의 복사된 패킷과 결합된 정보를 이용한다.

도 11을 참조하면, 상태유지 원격 표현 프로토콜의 플레이백중에 실시간 탐색을 위한 시스템을 도시하고 있다. 이 도면은 상태-스냅샷(1104) 및 디스플레이(1108)뿐만 아니라 2개의 프로토콜 엔진(502), 백그라운드 프로토콜 엔진(1102) 그리고 포그라운드 프로토콜 엔진(1106)을 포함하는 플레이백 디바이스(514)의 실시예를 도시한다. 백그라운드 프로토콜 엔진(1102)은 다수의 패킷을 포함하고 디스플레이 데이터를 표현하는, 프로토콜 데이터 스트림의 기록(1110)을 수신하고 판독한다. 일 실시예에서, 플레이백 디바이스(514)는 프로토콜 데이터 스트림(1110) 내의 적어도 하나의 패킷의 콘텐츠를 렌더링하고 그 결과를 디스플레이(1108)를 이용하여 디스플레이하여 디스플레이 데이터를 재생성한다. 이러한 결과는 지각할 수 있는 청각, 시각, 촉각 또는 후각적 표현을 포함한다.

도 11을 참조하면, 백그라운드 프로토콜 엔진(1102)은 렌더링된 디스플레이 데이터의 수신인(recipient)이 프로토콜 데이터 스트림(1110)의 표현중에 실시간으로 콘텐츠를 탐색하는 것을 가능하게 한다. 백그라운드 프로토콜 엔진(1102)은 프로토콜 데이터 스트림(1110)으로부터 적어도 하나의 패킷을 판독하는중에 적어도 하나의 상태-스냅샷(1104)을 생성한다. 일 실시예에서, 백그라운드 프로토콜 엔진(1102)은 적어도 하나의 패킷의 콘텐츠를 버퍼로 렌더링한다. 이 실시예에서, 버퍼는 오프-스크린 버퍼를 포함할 수 있다. 이 실시예에서, 백그라운드 프로토콜 엔진(1102)은 적어도 하나의 패킷의 콘텐츠를 렌더링하는 것과 같이 적어도 하나의 상태-스냅샷(1104)을 생성한다. 백그라운드 프로토콜 엔진(1102)은 포그라운드 프로토콜 엔진(1106)에 이용가능하도록 상태-스냅샷(1104)을 만든다.

상태-스냅샷(1104)은 기록 장치(206)가 프로토콜 데이터 스트림(208)으로부터 적어도 하나의 패킷을 프로토콜 데이터 스트림의 기록(1110)으로 복사하는 때의 임의 지점에서 프로토콜 데이터 스트림(1110)을 렌더링하는 프로토콜 엔진의 상태를 저장하기 때문에 디스플레이 데이터의 재생성을 가능하게 한다. 일 실시예에서, 상태-스냅샷(1104)은 임의의 시점에서의 스크린의 상태를 기술하는 데이터 구조를 포함한다. 다른 실시예에서, 상태-스냅샷(1104)은 프로토콜 데이터 스트림(1110)내의 기준 지점에서 프로토콜 엔진의 상태를 구성하는 모든 변수들, 이미 지들 그리고 데이터 요소들을 표현한다. 포그라운드 프로토콜 엔진(1106)은 또한 프로토콜 데이터 스트림(1110)의 기록을 수신하고 프로토콜 데이터 스트림(1110)을 원래 렌더링하는 프로토콜 엔진의 상태를 재생성하는 것에 의해 프로토콜 데이터 스트림(1110)내의 적어도 하나의 패킷의 콘텐츠를 렌더링한다. 일 실시예에서, 포그라운드 프로토콜 엔진(1106)은 적어도 하나의 패킷의 콘텐츠를 렌더링하기 위해 상태-스냅샷(1104)의 콘텐츠를 이용한다.

일 실시예에서, 상태-스냅샷(1104)은 데이터 구조를 포함한다. 다른 실시예에서, 상태-스냅샷(1104)은 데이터베이스를 포함한다. 일 실시예에서, 상태-스냅샷(1104)의 콘텐츠는 가시 표면(visible surface)의 상태에 관한 디스플레이 데이터를 포함한다. 다른 실시예에서, 상태-스냅샷(1104)의 콘텐츠는 오프-스크린 표면의 상태에 관한 디스플레이 데이터를 포함한다. 다른 실시예에서, 상태-스냅샷(1104)의 콘텐츠는 드로잉 오브젝트의 상태에 관한 디스플레이 데이터를 포함한다. 일 실시예에서, 상태-스냅샷(1104)의 콘텐츠는 컬러 파레트의 상태에 관한 디스플레이 데이터를 포함한다. 다른 실시예에서, 상태-스냅샷(1104)의 콘텐츠는 캐쉬드 오브젝트의 상태에 관한 디스플레이 데이터를 포함한다. 다른 실시예에서, 상태-스냅샷(1104)의 콘텐츠는 버퍼의 상태에 관한 디스플레이 데이터를 포함한다.

포그라운드 프로토콜 엔진(1106)은 프로토콜 데이터 스트림의 기록을 수신하고 요청된 디지털 데이터의 표현을 포함하는 패킷을 식별하기 위해 그리고 패킷을 렌더링하기 위해 상태-스냅샷(1104)을 이용한다. 일 실시예에서, 포그라운드 프로토콜 엔진(1106)은 디스플레이(1108)를 이용하는 뷰어에게 표시하기 위해 프로토콜 데이터 스트림의 기록의 지각할 수 있는(perceptible) 실시간 표현을 생성한다. 일 실시예에서, 포그라운드 프로토콜 엔진(1106)은 프로토콜 데이터 스트림(1110)내의 적어도 하나의 패킷의 콘텐츠를 렌더링하여 지각할 수 있는 실시간 표현을 생성한다. 지각할 수 있는 표현은 그 제한없이, 개별적으로 또는 함께 청각, 시각, 촉각 또는 후각적 표현을 포함한다.

포그라운드 프로토콜 엔진(1106)이 프로토콜 데이터 스트림(1110)내의 적어도 하나의 패킷의 콘텐츠를 렌더링하는 실시예에서, 포그라운드 프로토콜 엔진(1106)은 백그라운드 프로토콜 엔진(1102)에 의한 렌더링과 동시에 프로토콜 데이터 스트림(1110)내의 적어도 하나의 패킷의 콘텐츠를 렌더링하는 것을 개시한다. 그러나 백그라운드 프로토콜 엔진(1102)은 오직 버퍼에 렌더링하고 포그라운드 프로토콜 엔진(1106)에 의해 개시된 실시간 렌더링의 완성 이전에 렌더링 및 적어도 하나의 상태-스냅샷(1104)의 생성을 완성하며, 일 실시예에서는, 버퍼 및 지각할 수 있는 방식내에서 렌더링한다. 일 실시예에서, 백그라운드 프로토콜 엔진(1102)은 기록과 결합된 임의의 시간 스탬프에 상관없이 최대 가능 속도에서 프로토콜 데이터 스트림(1110)을 렌더링한다. 따라서, 적어도 하나의 상태-스냅샷(1104)은 프로토콜 데이터 스트림(1110)의 기록의 실시간 표현의 생성중 포그라운드 프로토콜 엔진(1106)에 이용가능하다.

일 실시예에서, 포그라운드 프로토콜 엔진(1106)은 프로토콜 데이터 스트림(1110)의 기록내의 다수의 패킷의 콘텐츠를 순차적 방식으로 렌더링한다. 이 실시예에서, 사용자에게 렌더링되고 표현되는 디스플레이 데이터는 디스플레이를 그 순번으로 표현하며 이것은 프로토콜 데이터 스트림이 기록된 시간에서 발생된다. 프로토콜 데이터 스트림의 기록은 디스플레이 데이터를 순차적으로 렌더링하는데 포그라운드 프로토콜 엔진(1106)에 의해 이용되는, 시간 스탬프와 같은 정보를 포함할 수 있다. 일 실시예에서, 포그라운드 프로토콜 엔진(1106)은 디스플레이 데이터를 실시간으로 렌더링한다. 프로토콜 데이터 스트림(1110)의 기록내의 특정 패킷에 의해 표현되는 특정 디스플레이 데이터를 재생성하는 요청을 포그라운드 프로토콜 엔진(1106)이 수신하면, 포그라운드 프로토콜 엔진(1106)은 식별된 상태-스냅샷(1104)의 콘텐츠를 이용하여 요청된 디스플레이 데이터를 렌더링한다.

일 실시예에서, 백그라운드 프로토콜 엔진(1102) 및 포그라운드 프로토콜 엔진(1106)은 동일 디바이스상에 존재한다. 다른 실시예에서, 백그라운드 프로토콜 엔진(1102) 및 포그라운드 프로토콜 엔진(1106)은 분리된 디바이스상에 존재한다.

도 9를 참조하면, 상태유지 원격 표현 프로토콜의 플레이백중 실시간 탐색을 위한 방법에서 이뤄지는 단계들의 일 실시예가 도시된다. 프로토콜 데이터 스트림의 기록내의 패킷의 컨텐츠에 의해 표현되는 데이터 디스플레이의 렌더링에 대한 요청이 존재한다(단계902). 요청된 패킷과 관련된 시간 스탬프보다 늦지 않은 시간 스탬프를 갖는 상태-스냅샷을 식별하고(단계904) 식별된 상태-스냅샷에 대응하여 요청된 컨텐츠를 렌더링하여(단계906) 적절한 패킷의 컨텐츠가 렌더링된다.

일 실시예에서, 포그라운드 프로토콜 엔진(1106)은 프로토콜 데이터 스트림(1110)의 기록내의 패킷의 컨텐츠를 렌더링하는 요청을 수신한다. 프로토콜 데이터 스트림(1110)은 다수의 패킷을 포함하며, 패킷의 컨텐츠는 디스플레이 데이터 를 표현한다. 일 실시예에서, 포그라운드 프로토콜 엔진(1106)이 프로토콜 데이터 스트림의 기록내의 패킷의 컨텐츠를 렌더링하는 것에 의해 디스플레이 데이터를 재생성할 때 요청에 대한 결과가 디스플레이(1108)를 이용하여 뷰어에게 제공되며 뷰어는 특정 디스플레이 데이터를 탐색하길 원한다.

포그라운드 프로토콜 엔진(1106)은 요청된 패킷과 관련된 시간 스탬프보다 늦지 않은 시간 스탬프를 갖는 상태-스냅샷(1104)을 식별한다. 포그라운드 프로토콜 엔진(1106)은 식별된 상태-스냅샷(1104)에 대응하여 요청된 패킷의 컨텐츠에 의해 표현되는 디스플레이 데이터를 디스플레이한다. 일 실시예에서, 식별된 상태-스냅샷(1104)은 프로토콜 데이터 스트림(1110)으로부터 정확한 패킷을 표시하고, 그 컨텐츠를 포그라운드 프로토콜 엔진(1106)은 요청된 디스플레이 데이터를 사용자에게 제공하기 위해 렌더링할 수 있다.

다른 실시예에서, 식별된 상태-스냅샷(1104)은 기록 장치가 프로토콜 데이터 스트림(1110)으로부터 패킷을 복사할 때 그러나 복사된 패킷의 콘텐츠에 의해 표현되는 디스플레이 데이터가 뷰어에 의해 요청된 디스플레이 데이터보다 앞서는 임의의 지점에서 프로토콜 데이터 스트림을 렌더링하는 프로토콜 엔진의 상태를 포함한다. 이러한 실시예들에서, 상태-스냅샷과 요청된 디스플레이 데이터의 표현을 포함하는 패킷 사이에는 다수의 패킷들이 존재한다. 이 실시예에서, 포그라운드 프로토콜 엔진(1106)은 중간 패킷 또는 패킷들의 콘텐츠를 오직 오프-스크린 버퍼에 렌더링한다. 그 다음 포그라운드 프로토콜 엔진(1106)은 디스플레이 데이터를 표현하는 콘텐츠의 패킷을 오프-스크린 버퍼 및 사용자 모두에게 렌더링한다. 일 실 시예에서, 포그라운드 프로토콜 엔진(1106)은 요청된 패킷의 콘텐츠에 의해 표현되는 디스플레이 데이터에 앞서 중간 패킷들의 콘텐츠에 의해 표현되는 디스플레이 데이터를 렌더링한다.

도 10을 참조하면, 원격 표현 프로토콜의 플레이백중 실시간 탐색을 가능하게 하는 상태-스냅샷을 생성하기 위한 단계의 일 실시예를 도시한다. 백그라운드 프로토콜 엔진(1102)은 프로토콜 데이터 스트림(1110)의 기록을 수신하고 프로토콜 데이터 스트림(1110)내의 다수의 패킷의 콘텐츠에 의해 표현되는 디스플레이 데이터를 재생성하는 중에 적어도 하나의 상태-스냅샷을 생성한다.

백그라운드 프로토콜 엔진(1102)은 다수의 패킷을 포함하는 프로토콜 데이터 스트림의 기록을 수신한다(단계1002). 백그라운드 프로토콜 엔진(1102)은 프로토콜 데이터 스트림의 기록의 표현을 생성한다. 일 실시예에서, 백그라운드 프로토콜 엔진(1102)은 다수의 패킷의 콘텐츠를 버퍼에 렌더링하여 이러한 표현을 생성한다. 일 실시예에서, 버퍼는 오프-스크린 버퍼이다.

일 실시예에서, 포그라운드 프로토콜 엔진(1106)은 또한 프로토콜 데이터 스트림(1110)의 기록을 수신한다. 이 실시예에서, 포그라운드 프로토콜 엔진(1106)은 프로토콜 데이터 스트림의 기록의 인간이 지각할 수 있는 표현을 생성하며, 전술한 바와 같이, 포그라운드 프로토콜 엔진은 오프-스크린 버퍼에 지각할 수 있는 방식으로 렌더링한다(단계 1004). 이 실시예에서, 포그라운드 프로토콜 엔진(1106)은 백그라운드 프로토콜 엔진(1102)이 프로토콜 데이터 스트림의 기록의 판독중에 적어도 하나의 상태-스냅샷을 생성하는 것과 실질적으로 동일하게 다수의 패킷의 콘텐츠를 렌더링하여 프로토콜 데이터 스트림의 기록의 인간이 지각할 수 있는 표현을 생성한다.

프로토콜 데이터 스트림(1110)의 기록내의 적어도 하나의 패킷의 기록 이후에, 백그라운드 프로토콜 엔진(1102)은 적어도 하나의 상태-스냅샷을 생성한다(단계1006). 일 실시예에서, 백그라운드 프로토콜 엔진(1102)은 프로토콜 데이터 스트림의 기록의 순차적 판독중에 적어도 하나의 상태-스냅샷을 생성한다. 다른 실시예에서, 백그라운드 프로토콜 엔진(1102)은 버퍼로 패킷의 콘텐츠를 렌더링하는 것과 동시에 프로토콜 데이터 스트림의 기록내의 적어도 하나의 패킷을 판독한다. 일 실시예에서, 백그라운드 프로토콜 엔진(1102)은 그 다음 생성된 상태-스냅샷(1104)을 저장한다(단계1008). 백그라운드 프로토콜 엔진이 다수의 상태-스냅샷을 주기적으로 생성하는 실시예에서, 상태-스냅샷은 프로토콜 데이터 스트림내의 특정 지점의 위치 그리고 상태-스냅샷 이전 또는 이후에 오는 패킷들의 위치에 대한 마커(marker)로서의 역할을 할 수 있다.

도 12를 참조하면, 상태-스냅샷의 적응성(adaptive) 생성을 위해 이뤄지는 단계들의 일 실시예를 도시하는 흐름도이다. 백그라운드 프로토콜 엔진(1102)은 뷰어의 활동을 모니터하고 뷰어의 활동 레벨에 대응하여 하나 이상의 상태 스냅샷(1104)을 생성한다.

사용자에 대한 프로토콜 데이터 스트림의 기록의 표현의 표시중에(단계1202), 백그라운드 프로토콜 엔진(1102)은 사용자의 활동을 모니터한다(단계1204). 일 실시예에서, 포그라운드 프로토콜 엔진(1106)은 프로토콜 데이터 스트림(1110) 의 기록의 표현을 생성하고 그것을 디스플레이(1108)로 사용자에게 표시한다. 다른 실시예에서, 백그라운드 프로토콜 엔진(1102)은 표현을 생성한다. 다른 실시예에서, 제3 디바이스가 이러한 표현을 생성한다.

백그라운드 프로토콜 엔진(1102)은 표시중에 사용자의 활동을 모니터한다(단계1204). 사용자의 활동을 모니터함으로써, 백그라운드 프로토콜 엔진(1102)은 활동의 모니터링에 대응하여 활동 프로파일을 전개한다(develop)(단계1206). 백그라운드 프로토콜 엔진은 전개된 활동 프로파일에 대응하여 적어도 하나의 상태-스냅샷(1104)을 생성한다(단계1208).

일 실시예에서, 백그라운드 프로토콜 엔진(1102)은 사용자 활동의 레벨을 식별한다. 일 실시예에서, 백그라운드 프로토콜 엔진은 비활동 기간을 식별한다. 다른 실시예에서, 백그라운드 프로토콜 엔진은 디스플레이 데이터내의 사용자 관심 영역을 식별한다. 활동 프로파일은 이러한 식별을 반영한다.

백그라운드 프로토콜 엔진(1102)은 활동 프로파일에 대응하여 적어도 하나의 상태-스냅샷을 생성한다. 일 실시예에서, 백그라운드 프로토콜 엔진은 하나 이상의 상태-스냅샷 사이의 간격을 연장하도록 결정한다. 다른 실시예에서, 백그라운드 프로토콜 엔진은 하나 이상의 상태-스냅샷 사이의 간결을 줄이도록 결정한다. 다른 실시예에서, 백그라운드 프로토콜 엔진은 활동 프로파일에 대응하여 적어도 하나의 상태-스냅샷을 제거하도록 결정한다. 다른 실시예에서, 백그라운드 프로토콜 엔진은 활동 프로파일에 대응하여 적어도 하나의 상태-스냅샷을 추가하도록 결정한다.

일 실시예에서, 백그라운드 프로토콜 엔진은 탐색 확률의 통계적 분포를 포함한다. 도 13은 일 실시예의 탐색 확률 분포의 3가지 유형을 도시한다. 이 실시예에서, 백그라운드 프로토콜 엔진(1102)은 사용자에 의한 탐색 요청에 대한 데이터를 수집하고 저장한다. 일 실시예에서, 데이터는 사용자가 얼마나 정기적으로 탐색 요청을 하는지를 포함한다. 일 실시예에서, 데이터는 각각의 탐색 요청의 범위, 요청된 디스플레이 데이터 사이의 거리 그리고 프로토콜 데이터 스트림의 기록내의 패킷의 콘텐츠를 렌더링함으로써 사용자에게 표시되는 현재 디스플레이 데이터를 포함한다. 범위는 시간 단위 또는 프로토콜 데이터 스트림 기록의 전체 길이에 연관된 단위로 기술될 수 있다. 일 실시예에서, 탐색 요청이 이뤄진 곳의 시간스탬프가 기록된다.

도 14는 결정된 탐색 확률 분포에 대응하여 상태-스냅샷을 생성하는 일 실시예를 도시한다. 백그라운드 프로토콜 엔진(1102)은 현재 표시되는 디스플레이 데이터가 중앙에 있는 탐색 확률 분포 그래프를 생성하기 위해 수집된 탐색 요청 데이터를 이용한다. 백그라운드 프로토콜 엔진은 스트림내의 각각의 지점에 사용자가 그 지점과 관련된 디스플레이 데이터를 탐색하는 요청할 것이라는 추정된 확률을 표시하는 값으로 할당한다. 이 데이터로, 백그라운드 프로토콜 엔진은 생성된 상태-스냅샷을 어디에 배치할 것인지 결정하고 탐색 확률의 통계적 분포에 대응하여 적어도 하나의 상태-스냅샷을 생성한다.

도 15는 사용자의 사용 패턴의 일 실시예를 도시한다. 일 실시예에서, 백그라운드 프로토콜 엔진은 사용자의 사용 패턴에 기반하여 사용자에 대한 활동 프로 파일을 전개한다. 사용 패턴은 식별된 탐색 확률을 반영한다. 높은 탐색 확률의 영역은 높은 상태-스냅샷 밀도로 제공될 것이며 낮은 탐색 확률의 영역은 낮은 상태-스냅샷 밀도로 제공될 것이다. 일 실시예에서, 임의의 한쌍의 상태-스냅샷간의 거리는 그들간의 평균 탐색 확률에 반비례한다. 백그라운드 프로토콜 엔진은 사용자가 높은 확률 영역을 탐색할 것을 예상하고 따라서 탐색의 대부분은 생성된 상태-스냅샷간의 공간이 상대적으로 짧을수록 빨라질 것이다. 탐색 확률이 매우 낮을때라도, 개별적 탐색 요청이 과도하게 늦어지지 않도록, 일 실시예에서 백그라운드 프로토콜 엔진은 생성된 상태-스냅샷의 공간에 상한(upper bound)을 부과할 것이다. 이와 같이, 다른 실시예에서 하한(lower bound)은 매우 높은 확률 영역에서 상태-스냅샷들간에 너무 근접하여 함께 배치되는 것을 방지한다. 일 실시예에서, 레이턴시(latency)를 최소화하기 위해, 상태-스냅샷 배치를 결정할 때 인접한 상태-스냅샷간의 렌더링의 양이 고려된다.

새로운 사용자 또는 특별한 사용 패턴이 없는 사용자를 갖는 실시예에서, 백그라운드 프로토콜 엔진(1102)은 디폴트 상태-스냅샷 생성 패턴을 적용한다. 이 패턴은 대부분의 탐색이 현재 프레임의 양 방향으로 근접하여 발생할 것이라고 가정한다. 일반적인 사용자는 많은 세세한 탐색 단계들이 조그 휠 입력 디바이스에 의해 이뤄짐에 따라 현재 프레임 근처의 앞뒤로 조깅(jogging)할 때 고성능을 요구한다. 긴 범위 탐색은 일반적이지 않으며 지각가능한 지연은 받아들일 수 있는 트레이드-오프가 될 수 있다.

사용자가 지각된 사용 패턴에서 벗어나는 경우, 백그라운드 프로토콜 엔 진(1102)은 사용자의 지각없이 플레이백중에 상태-스냅샷 생성 패턴을 수정한다. 백그라운드 프로토콜 엔진은 새로운 사용 패턴으로 수정하기 위해 상태-스냅샷 위치를 이동시킨다. 예들 들면, 일반적으로 마우스 휠로 작은 단계로 탐색하던 사용자가 긴 범위의 탐색을 시작하는 경우, 백그라운드 프로토콜 엔진은 긴 범위에서의 영역내에 상태-스냅샷을 추가하기 위한 리소스를 비우기 위해 현재 프레임 주변의 상태-스냅샷의 수를 줄인다.

도 16은 백그라운드 프로토콜 엔진(1602), 포그라운드 프로토콜 엔진(1608), 프로토콜 데이터 스트림(1612), 활동 프로파일(1604), 상태-스냅샷(1606)을 포함하는, 상태-스냅샷의 적응성 생성을 위한 시스템에서 사용되는 전술한 방법의 일 실시예를 도시한다. 포그라운드 프로토콜 엔진(1608)은 뷰어에게 프로토콜 데이터 스트림의 기록의 표현을 표시한다. 백그라운드 프로토콜 엔진(1602)는 표시중에 뷰어의 활동을 모니터하고, 모니터링에 대응하여 활동 프로파일(1604)을 전개하고 활동 프로파일에 대응하여 상태-스냅샷(1606)을 생성하고 유지한다.

도 18을 참조하면, 기록된 컴퓨터 세션의 플레이백을 위한 플레이백 명령을 생성하는데 이뤄지는 단계들의 일 실시예을 도시한다. 제1 디바이스상에서 실행되는 프로토콜 엔진은 기록된 세션을 수신한다(단계1802). 기록된 스트림은 제2 디바이스상에서 실행되는 애플리케이션 프로그램에 의해 생성된 디스플레이 데이터를 표현하는 다수의 패킷을 포함한다. 프로토콜 엔진은 인간이 지각할 수 있는 방식으로 패킷의 콘텐츠를 렌더링하기 위해 기록된 스트림내의 패킷에 대해 결정한다(단계1804). 그 다음 프로토콜 엔진은 플레이백 데이터 구조내에 이러한 결정을 저장한다(단계1806).

일 실시예에서, 상기 프로토콜 엔진은 도 5에 도시된 프로토콜 엔진(502)을 포함한다. 다른 실시예에서, 상기 프로토콜 엔진은 도 11에 도시된 백그라운드 프로토콜 엔진(1102)을 포함한다. 다른 실시예에서, 상기 프로토콜 엔진은 도 11에 도시된 포그라운드 프로토콜 엔진(1106)을 포함한다. 상기 프로토콜 엔진이 백그라운드 프로토콜 엔진을 포함하는 일 실시예에서, 프로토콜 엔진은 백그라운드 프로토콜 엔진(1102)의 기능을 수행하는 것을 중단시킬 수 있으며 포그라운드 프로토콜 엔진(1106)의 기능을 수행하는 것을 시작할 수 있다. 상기 프로토콜 엔진이 포그라운드 프로토콜 엔진을 포함하는 실시예에서, 상기 프로토콜 엔진은 포그라운드 프로토콜 엔진(1106)의 기능을 수행하는 것을 중단시키고 백그라운드 프로토콜 엔진(1102)의 기능을 수행하는 것을 시작할 수 있다. 다른 실시예에서, 상기 프로토콜 엔진은 백그라운드 프로토콜 엔진(1102) 및 포그라운드 프로토콜 엔진(1106) 모두를 포함한다. 이 실시예에서, 백그라운드 프로토콜 엔진(1102) 및 포그라운드 프로토콜 엔진(1106)은 동일 디바이스상에 존재한다. 다른 실시예에서, 백그라운드 프로토콜 엔진(1102) 및 포그라운드 프로토콜 엔진(1106)은 개별적인 디바이스상에 존재한다.

일 실시예에서, 프로토콜 엔진은 인간이 지각할 수 있는 방식으로 패킷을 디스플레이하기 위해 기록된 스트림내의 패킷을 결정한다(단계1804). 디스플레이는 그 제한없이 청각, 시각, 촉각, 후각적 표시 또는 이들의 조합을 포함한다. 일 실시예에서, 프로토콜 엔진은 패킷의 콘텐츠에 대응하여 패킷을 디스플레이하도록 결 정한다. 이 실시예에서, 프로토콜 엔진은 입력 포커스를 갖는 애플리케이션 프로그램의 표시에 대응하여 이러한 결정을 만든다. 이러한 실시예중 다른 예에서, 프로토콜 엔진은 패킷내에 저장된 사용자 입력의 유형의 평가에 대응하여 이러한 결정을 만든다. 일 실시예에서, 프로토콜 엔진은 패킷에 의해 저장된 그래픽 업데이트의 유형의 평가에 대응하여 이러한 결정을 만든다. 일 실시예에서, 프로토콜 엔진은 패킷에 의해 저장된 대화 시퀀스의 유형의 평가에 대응하여 이러한 결정을 만든다.

일 실시예에서, 프로토콜 엔진은 플레이백 데이터 구조(1806)내에 이러한 결정을 저장한다. 일 실시예에서, 플레이백 데이터 구조는 기록된 스트림내에 포함된 디스플레이 데이터를 어떻게 재생성할 것인지 기술한다. 일 실시예에서, 플레이백 데이터 구조내에 저장된 명령은 디스플레이 데이터의 렌더링 처리를 제어한다. 일 실시예에서, 플레이백 데이터 구조는 기록된 스트림내의 패킷의 콘텐츠를 렌더링하기 위한 시간을 포함한다. 이 실시예에서, 플레이백 데이터 구조내에 포함된 시간은 패킷의 콘텐츠를 렌더링하는데 이용되고 기록내 패킷과 관련된 렌더링 시간이 아니다. 일 실시예에서, 플레이백 데이터 구조는 렌더링 시간의 변경에서 사용자 입력을 받아들인다.

일 실시예에서, 플레이백 데이터 구조는 기록된 세션의 하나 이상의 플레이백을 어떻게 수행할 것인지 기술하는 메타데이터를 포함한다. 일 실시예에서, 플레이백 데이터 구조는 플레이백중에 패킷의 콘텐츠가 렌더링되어야 하는 관련 지점을 표시하는, 기록된 스트림내의 각각의 패킷에 대한 기록으로 구성된다. 일 실시 예에서, 메타데이터는 또한 패킷 시작의 파일내에 오프셋(offset)을 포함한다.

도 17을 참조하면, 제1 디바이스(1702), 백그라운드 프로토콜 엔진(1704), 플레이백 데이터 구조(1706), 포그라운드 프로토콜 엔진(1708), 디스플레이(1710), 제2 디바이스(1712), 기록된 스트림(1714)을 포함하는, 기록된 세션을 렌더링하기 위한 시스템의 일 실시예를 도시한다. 백그라운드 프로토콜 엔진(1704)는 제1 디바이스(1702)상에서 실행하고 기록된 스트림(1714)을 수신하는 것에 대응하여 플레이백 데이터 구조(1706)를 생성하며, 상기 기록된 스트림(1714)은 제2 디바이스 또는 제3 디바이스상에서 실행되는 애플리케이션 프로그램에 의해 생성되는 디스플레이 데이터를 표현한다. 포그라운드 프로토콜 엔진(1708)은 기록된 스트림(1714)을 수신하고 백그라운드 프로토콜 엔진(1704)에 의해 생성된 플레이백 데이터 구조(1706)에 대응하여 기록된 스트림(1714)을 렌더링한다.

일 실시예에서, 백그라운드 프로토콜 엔진(1704) 및 포그라운드 프로토콜 엔진(1708) 각각은 기록된 스트림(1714)을 수신한다. 이 실시예에서, 백그라운드 프로토콜 엔진(1704)은 기록된 스트림을 렌더링하는 포그라운드 프로토콜 엔진(1708)과 동시에 플레이백 데이터 구조를 생성한다.

일 실시예에서, 포그라운드 프로토콜 엔진(1708)은 제1 디바이스(1702)상에 존재한다. 다른 실시예에서, 포그라운드 프로토콜 엔진(1708)은 도 17의 어두운 부분인 제1 디바이스(1702) 및 제2 디바이스(1712)상에 모두 존재하지 않는다. 다른 실시예에서, 포그라운드 프로토콜 엔진(1708)은 제3 디바이스상에 존재한다. 일 실시예에서, 포그라운드 프로토콜 엔진은 백그라운드 프로토콜 엔진을 포함한 다. 이 실시예에서, 백그라운드 프로토콜 엔진(1102) 및 포그라운드 프로토콜 엔진(1106)은 동일 디바이스상에 존재한다. 다른 실시예에서, 백그라운드 프로토콜 엔진(1102) 및 포그라운드 프로토콜 엔진(1106)은 분리된 디바이스상에 존재한다.

일 실시예에서, 백그라운드 프로토콜 엔진은 기록된 스트림내의 적어도 하나의 패킷을 렌더링하기 위한 적어도 하나의 명령을 플레이백 데이터 구조내에 저장한다. 다른 실시예에서, 백그라운드 프로토콜 엔진은 플레이백 데이터 구조내에 메타데이터를 저장한다. 다른 실시예에서, 백그라운드 프로토콜 엔진은 기록된 세션내의 적어도 하나의 패킷을 렌더링하는 시간을 표시하는 기록을 플레이백 데이터 구조내에 저장한다.

포그라운드 프로토콜 엔진(1708)은 플레이백 데이터 구조에 대응하여 기록된 세션내의 적어도 하나의 패킷을 렌더링한다. 일 실시예에서, 포그라운드 프로토콜 엔진은 기록된 세션내의 적어도 하나의 패킷을 인간이 지각할 수 있는 방식으로 그리고 버퍼에 렌더링한다. 다른 실시예에서, 포그라운드 프로토콜 엔진은 기록된 세션내의 적어도 하나의 패킷을 버퍼로 렌더링한다.

도 19를 참조하면, 기록된 컴퓨터 세션의 플레이백을 위한 방법에서 이뤄지는 단계들의 일 실시예를 도시하는 흐름도이다. 백그라운드 프로토콜 엔진은 제2 디바이스상에서 실행하는 애플리케이션 프로그램에 의해 생성된 디스플레이 데이터를 표현하는 다수의 패킷을 포함하는 기록된 스트림을 수신한다(단계1902). 백그라운드 프로토콜 엔진은 패킷을 인간이 지각할 수 있는 방식으로 렌더링하기 위해, 기록된 스트림내의 적어도 하나의 패킷을 결정한다(단계1904). 백그라운드 프로토 콜 엔진은 플레이백 데이터 구조내에 이러한 결정을 저장한다(단계1906). 포그라운드 프로토콜 엔진은 기록된 스트림으로부터 적어도 하나의 패킷을 검색하고(단계1908), 플레이백 데이터 구조에 액세스하고(단계1910), 플레이백 데이터 구조에 대응하여 적어도 하나의 패킷을 렌더링한다(단계1912).

일 실시예에서, 프로토콜 엔진은 패킷을 인간이 지각할 수 있는 방식으로 디스플레이하기 위해 기록된 스트림내의 패킷을 결정한다(단계1904). 디스플레이는 그 제한없이, 청각, 시각, 촉각, 후각적 표현 또는 그 조합을 포함한다. 일 실시예에서, 프로토콜 엔진은 패킷의 콘텐츠에 대응하여 패킷을 디스플레이할 것을 결정한다. 이 실시예에서, 프로토콜 엔진은 입력 포커스를 갖는 애플리케이션 프로그램의 표시에 대응하여 이러한 결정을 만든다. 다른 예에서, 프로토콜 엔진은 패킷내에 저장된 사용자 입력의 유형의 평가에 대응하여 이러한 결정을 만든다. 일 실시예에서, 프로토콜 엔진은 패킷에 의해 저장된 그래픽 업데이트의 유형의 평가에 대응하여 이러한 결정을 만든다. 일 실시예에서, 프로토콜 엔진은 패킷에 의해 저장된 대화 시퀀스의 유형의 평가에 대응하여 이러한 결정을 만든다. 일 실시예에서, 프로토콜 엔진은 플레이백 데이터 구조(1906)내에 이러한 결정을 저장한다.

일 실시예에서, 포그라운드 프로토콜 엔진은 기록된 세션을 검색한다. 다른 실시예에서, 포그라운드 프로토콜 엔진은 기록된 세션을 검색한다. 이러한 실시예들 중 일 실시예에서, 포그라운드 프로토콜 엔진은 저장부로부터 기록된 세션을 검색한다.

일 실시예에서, 포그라운드 프로토콜 엔진은 기록된 세션으로부터 적어도 하 나의 패킷을 검색한다(단계1908). 이 실시예에서, 포그라운드 프로토콜 엔진은 그 다음 플레이백 데이터 구조에 액세스하고(단계1910) 플레이백 데이터 구조에 대응하여 패킷의 콘텐츠를 렌더링한다(단계1912). 일 실시예에서, 플레이백 데이터 구조는 패킷의 콘텐츠를 지각할 수 있는 방식으로 렌더링하기 위한 명령을 포함한다. 이 실시예에서, 포그라운드 프로토콜 엔진은 패킷의 콘텐츠를 온-스크린에 렌더링한다. 일 실시예에서, 포그라운드 프로토콜 엔진은 항상 적어도 하나의 패킷의 콘텐츠를 버퍼에 렌더링한다. 많은 실시예들에서, 포그라운드 프로토콜 엔진이 패킷의 콘텐츠를 버퍼에 렌더링할 때, 버퍼는 오프-스크린 버퍼이다. 이 실시예에서, 포그라운드 프로토콜 엔진은 패킷의 콘텐츠를 오프-스크린 버퍼에 렌더링하고 또한 플레이백 데이터 구조에 의해 정해지는 것과 같이, 패킷의 컨텐츠를 온-스크린에 렌더링한다.

다른 실시예에서, 플레이백 데이터 구조는 패킷의 콘텐츠를 렌더링 하지 않도록 하는 명령을 포함한다. 이 실시예에서, 플레이백 데이터 구조 액세스하에서, 포그라운드 프로토콜 엔진은 패킷의 콘텐츠를 지각할 수 있는 방식으로 렌더링하지 않으나 패킷의 콘텐츠를 버퍼로 렌더링한다.

포그라운드 프로토콜 엔진이 플레이백 데이터 구조에 대응하여, 패킷의 콘텐츠를 오직 오프-스크린 버퍼에 렌더링하는 실시예에서, 포그라운드 프로토콜 엔진은 기록된 스트림과 다른 디스플레이 데이터를 재생성한다. 일 실시예에서, 이 결과는 원래 기록된 스트림보다 짧은 디스플레이 데이터의 표현을 초래한다. 일 실시예에서, 렌더링된 패킷의 콘텐츠는 원래 디스플레이 데이터의 간결 한(streamlined) 재생성을 제공한다. 다른 실시예에서, 렌더링된 패킷의 콘텐츠는 디스플레이 데이터의 커스터마이징된(customized) 버전을 제공한다. 일 실시예에서, 지각할 수 있는 방식으로 패킷의 콘텐츠를 렌더링하도록 하는 결정은 일정 방식 또는 사용자 요청에 대응한다. 이 실시예는 기록된 세션의 플레이백에 대한 제어를 사용자에게 제공한다.

도 21을 참조하면, 아무런 활동을 포함하지 않는 시간 간격으로 기록된 세션을 렌더링하는 일 실시예가 도시되어 있다. 이 도면에서, 검은 블럭은 사용자 입력을 포함하는 패킷 또는 패킷들을 나타내며 점선으로 된 블럭은 그래픽 명령을 포함하는 패킷 또는 패킷들을 나타낸다. "사용자 입력" 및 "그래픽" 열에서 하얀색 블럭으로 나타난 시간 간격은 아무런 패킷을 갖지 않으며 따라서 활동이 전혀 없다.

아무런 활동이 없는 시간 간격을 제거하기 위한 방법의 일 실시예를 이하에서 설명한다. 기록된 세션내의 제1 패킷이 식별된다. 기록된 세션은 디스플레이 데이터를 표현하는 다수의 패킷을 포함한다. 기록된 세션내에서 제1 패킷에 가장 이전 패킷이 제2 패킷으로 식별된다. 제1 시간 간격이 결정되고, 이 시간 간격은 제1 패킷과 제2 패킷 사이에 발생한다. 제1 시간 간격이 임계치를 초과하는지 결정한다. 기록된 세션내의 패킷의 콘텐츠가 제1 시간 간격보다 짧은 제1 패킷과 제2 패킷 사이의 제2 시간 간격으로 렌더링된다.

일 실시예에서, 프로토콜 엔진은 이러한 결정을 만든다. 일 실시예에서, 프로토콜 엔진은 플레이백 데이터 구조내에 이러한 결정을 저장한다. 일 실시예에 서, 동일한 프로토콜 엔진이 플레이백 데이터 구조에 대응하여 기록된 세션을 렌더링한다. 다른 실시예에서, 백그라운드 프로토콜 엔진을 포함하는 프로토콜 엔진은 이러한 결정을 만들며 포그라운드 프로토콜 엔진을 포함하는 프로토콜 엔진을 기록된 세션을 렌더링한다.

일 실시예에서, 프로토콜 엔진이 시간 간격이 임계치를 초과했다고 결정하는 경우, 프로토콜 엔진은 이러한 시간 간격을 지각할 수 있는 시간 간격으로 분류한다(categorize). 재생성된 기록된 세션의 사용자가 시간 부족 활동의 기간이 경과했다는 것을 지각할 수 있는 경우 시간 간격이 지각될 수 있다. 일 실시예에서, 일정 방식은 이러한 임계치를 결정한다. 다른 실시예에서, 프로토콜 엔진은 미리 지정된 임계치로 변경되지 못하게 코드화된다(hard coded). 이 실시예에서, 프로토콜 엔진은 원래 시간 간격 대신에 제1 및 제2 패킷 사이의 더 짧은 시간 간격으로 렌더링하기 위한 명령을 플레이백 데이터 구조내에 저장한다. 다른 실시예에서, 시간 간격이 임계치를 초과하는지 결정하는 프로토콜 엔진은 또한 기록된 세션의 콘텐츠를 렌더링한다. 이 실시예에서, 프로토콜 엔진은 더 짧은 시간 간격으로 렌더링하는 명령을 플레이백 데이터 구조내에 저장하지 않는다. 시간 간격이 지각할 수 있게 분류되지 않는 경우, 짧아진 시간 간격은 필요치 않으며 원래 시간 간격이 제1 및 제2 패킷 사이에서 렌더링된다.

도 20을 참조하면, 기록된 세션을 렌더링하기 위한 플레이백 명령을 생성하기 위한 단계들의 일 실시예가 도시된다. 기록된 세션내 패킷에 의해 저장된 입력의 유형이 식별되고(단계2002) 입력 유형에 대응하여 패킷이 마킹된다(단계2004). 마킹에 대응하여, 패킷의 콘텐츠를 렌더링하기 위한 목적지가 플레이백 데이터 구조내에 저장된다.

일 실시예에서, 패킷에 의해 저장되는 입력의 유형은 패킷이 렌더링될지 여부를 결정한다. 일 실시예에서, 패킷은 아무런 콘텐츠도 포함하지 않는다. 일 실시예에서, 적어도 하나의 패킷은 아무런 콘텐츠도 포함하지 않는다. 이 실시예에서, 아무런 콘텐츠도 포함하지 않는 적어도 하나의 패킷으로 구성된 시간 간격이 식별된다. 일 실시예에서, 시간 간격은 렌더링되지 않을 것이다.

일 실시예에서, 입력 디바이스들의 특정 유형은 그 제한없이, 키보드, 마우스, 마이크로폰, 카메라를 포함한다. 일 실시예에서 입력 유형을 식별하는 단계는 입력 디바이스로부터 입력으로 입력 유형을 식별하는 단계를 더 포함한다. 다른 실시예에서, 입력 유형을 식별하는 단계는 키보드 입력으로서 입력 유형을 식별하는 단계를 더 포함한다. 다른 실시예에서, 입력 유형은 입력 디바이스와 관련되지 않는다. 이 실시예에서, 입력 유형은 커맨드(command)로서 식별된다.

입력을 포함하는 패킷이 입력 유형에 대응하여 마킹된다(단계2004). 일 실시예에서, 패킷은 일정 방식에 대응하여 마킹된다. 이 실시예에서, 일정 방식은 입력 유형을 결정하고 그 결과 패킷이 마킹된다. 다른 실시예에서, 아무 마킹도 필요치 않다.

마킹에 대응하여, 패킷을 렌더링하기 위한 목적지가 플레이백 데이터 구조내에 저장된다(단계2006). 일 실시예에서, 목적지는 버퍼를 포함한다. 일 실시예에서, 패킷의 버퍼로의 렌더링을 지시하는 명령이 플레이백 데이터 구조내에 저장된 다. 일 실시예에서, 버퍼는 오프-스크린 버퍼이며 패킷의 콘텐츠가 버퍼로 렌더링될 때 이것은 사용자에게 지각되지 않는다. 일 실시예에서, 마킹된 패킷이 지각할 수 있는 방식으로 그리고 버퍼에 렌더링할 것을 지시하는 명령이 플레이백 데이터 구조내에 저장된다.

일 실시예에서, 아무런 의미없는 활동을 포함하는 시간 간격을 제거한다. 이 실시예에서, 일정 방식은 중요한 입력의 특정 유형을 식별한다. 이러한 일정 방식은 프로토콜 엔진내에 코드화 될 수 있다. 다른 실시예에서, 관리자가 이러한 일정 방식을 구성한다.

일 실시예에서, 프로토콜 엔진은 패킷이 아무런 콘텐츠도 포함하지 않는 경우 중요하지 않은 패킷으로 식별한다. 이러한 실시예에서, 패킷은 기록된 스트림(1714)내로 기록될 사용자의 활동이 발생하지 않는 시간 간격을 표현한다. 이 실시예에서, 프로토콜 엔진은 임의의 중요하지 않은 패킷은 지각할 수 있는 방식으로 렌더링하지 않는 방법으로 기록된 스트림내의 다수의 패킷 각각을 렌더링하기 위한 목적지를 플레이백 데이터 구조에 저장한다. 도 22는 재생성된 기록된 스트림의 콘텐츠가 플레이백 데이터 구조에 대응하여 렌더링되는 일 실시예를 도시한다. 이 실시예에서, 플레이백 데이터 구조에 대응하여 렌더링하는 것은, 의미없는 활동을 포함하는 시간 간격(활동을 전혀 포함하지 않는 시간 간격을 포함)의 제거를 허용한다(도 22에서 흰색, 줄무늬 블럭으로 도시됨). 이러한 렌더링은 기록된 세션의 보다 의미있는 재생성을 사용자에게 제공하며, 일정 방식은 콘텐츠가 중요한 활동을 표현할 때 결정한다. 일 실시예에서, 중요한 활동을 표현하는 콘텐츠는 사용자 입력의 유형을 포함한다.

일 실시예에서, 프로토콜 엔진은 의미없는 시간을 포함하는, 이전에 규정된 입력 유형에 대응하여 입력 유형을 식별한다. 일 실시예에서, 의미없는 시간은 아무런 패킷도 임의의 콘텐츠를 포함하지 않는 시간 간격을 포함한다. 다른 실시예에서, 일정 방식은 의미없는 시간을 설정하는, 입력 유형을 규정한다. 다른 실시예에서, 의미없는 시간을 포함하는 입력 유형의 규정은 프로토콜 엔진으로 코드화될 수 있다.

일 실시예에서, 패킷의 콘텐츠는 사용자 활동을 표현하나 의미없는 활동으로 식별된 활동은 그렇지 않다. 이 실시예에서, 일정 방식은 재생성된 기록된 세션의 사용자에게 아무 관심없는 것으로 간주되는 활동으로서 의미없는 활동을 규정한다. 일정 방식에 의해 규정되는 것과 같이, 의미있는(중요한) 패킷은 재생성된 기록된 세션의 사용자에게 관심있는 콘텐츠를 포함한다. 일 실시예에서, 의미없는 패킷은 애플리케이션과 중요하게 대화하는 입력을 표현하는 콘텐츠를 갖지 않는다. 다른 실시예에서, 기록된 스트림이 생성되는 프로토콜 데이터 스트림내의 애플리케이션 데이터를 전송하는 디바이스는 의미있는 스크린 업데이트를 전송하지 않는다.

일 실시예에서, 프로토콜 엔진은 기록된 세션내의 적어도 하나의 패킷에 대해 그 패킷의 콘텐츠가 입력 유형(제한 없이, 키보드 입력, 마우스 입력, 커맨드 메시지)을 포함하는지 여부를 결정한다. 패킷이 키보드 입력과 같은 입력 유형을 포함하는 경우, 프로토콜 엔진은 패킷을 의미있는 패킷으로 마킹한다. 패킷이 특정 입력 유형을 포함하지 않는 경우, 프로토콜 엔진은 패킷을 의미없는 것으로 마 킹한다. 일 실시예에서, 패킷의 모든 콘텐츠가 의미없는 것일 경우에만 패킷은 의미없는 것이다. 다른 실시예에서, 패킷은 하나 이상의 입력 유형을 포함하며 그 각각은 의미있는 또는 의미없는 것으로 마킹될 수 있다.

일 실시예에서, 프로토콜 엔진이 패킷을 의미없는 것으로 마킹한 경우, 프로토콜 엔진은 패킷의 콘텐츠가 지각할 수 있는 방식으로 렌더링되서는 안되는 것으로 결정한다. 일 실시예에서, 프로토콜 엔진은 패킷의 콘텐츠가 버퍼로 렌더링되어야 하는 것으로 결정한다. 이러한 실시예에서, 버퍼는 오프-스크린 버퍼이다. 패킷이 의미있는 패킷으로 마킹된 경우, 프로토콜 엔진은 패킷의 콘텐츠가 지각할 수 있는 방식으로 렌더링되어야 하는 것으로 결정한다. 일 실시예에서, 지각할 수 있는 방식은 온-스크린에 렌더링하는 것을 포함한다. 일 실시예에서, 프로토콜 엔진은 패킷이 지각할 수 있는 방식으로 그리고 버퍼에 렌더링되어야 한다는 것을 결정한다. 이 실시예에서, 패킷의 콘텐츠는 온-스크린 디스플레이 및 오프-스크린 버퍼 모두에 렌더링된다. 프로토콜 엔진은 이러한 결정을 플레이백 데이터 구조내에 저장한다.

도 22에 도시된 바와 같이, 일 실시예에서, 기록된 스트림내의 특정 패킷은 의미있는 사용자 활동을 표현하는 콘텐츠를 가지며, 이 실시예에서 활성 마우스 버튼 상태를 표시하는 마우스 입력은 도 22에서 검은 블럭으로 나타난다. 기록된 스트림내의 다른 패킷들은 비활성 마우스 버튼 상태를 표시하는 마우스 입력을 표현하는 콘텐츠를 가지며, 도 22에서 줄무늬 블럭으로 나타난다. 프로토콜 엔진은 비활성 마우스 버튼 상태를 표시하는 마우스 입력과 같이, 의미없는 활동만을 포함하는 적 어도 하나의 패킷을 식별하고, 패킷의 콘텐츠가 지각할 수 있는 방식으로 렌더링되지 않도록 하는 결정을 플레이백 데이터 구조내에 저장한다. 이러한 결정을 만드는 것에 의해, 플레이백 데이터 구조에 대응하여 기록된 스트림의 콘텐츠를 렌더링하는 프로토콜 엔진은 재생성된 기록된 세션의 사용자와 연관된 디스플레이 데이터만을 재생성하며, 일정 방식이 이러한 연관성을 규정하거나 또는 프로토콜 엔진이 연관된 콘텐츠의 규정을 포함한다.

이제 도 23을 참조하면, 기록된 세션을 렌더링하는데 있어서 의미있는 활동이 없는 기간을 제거하기 위해 행하는 단계들의 일 실시예를 흐름도가 나타낸다. 제1 시간 간격이 결정되며, 시간 간격은 레코딩된 세션에서 마킹 패킷(marked packet)과 최근접의 이전 마킹 패킷 사이에서 발생한다(단계 2302). 기록된 세션은 디스플레이 데이터를 나타내는 복수의 패킷을 포함한다. 제1 시간 간격이 임계를 초과하는 지에 대한 결정을 한다(단계 2304). 기록된 세션에서 패킷의 콘텐츠는 마킹 패킷과 최근접의 이전 마킹 패킷 사이에서 제1 시간 간격보다 짧은 제2 시간 간격으로 렌더링된다(단계 2306).

일 실시예에서, 프로토콜 엔진이 결정을 한다. 일 실시예에서, 결정을 프로토콜 엔진은 재생 데이터 구조에 저장한다. 일 실시예에서, 동일한 프로토콜 엔진이 재생 데이터 구조에 대응하여 기록된 세션을 렌더링한다. 또 다른 실시예에서, 결정을 하는 프로토콜 엔진은 백그라운드 프토로콜 엔진을 포함하고, 기록된 세션을 렌더링하는 프로토콜 엔진은 포그라운드 프로토콜 엔진을 포함한다.

일 실시예에서, 프로토콜 엔진은 제1 시간 간격을 결정하고(단계 2302), 패 킷이 패킷내에 포함되는 입력의 유형에 대응하여 의미 있는 패킷으로서 마킹된 후에 제1 시간 간격이 임계를 초과하는지 여부를 결정한다(단계 2304). 이러한 실시예들 중 일 실시예에서, 패킷내에 포함되는 출력의 유형은 패킷을 마킹하는 결정에 영향을 미친다. 일 실시예에서, 프로토콜 엔진은 의미 있는 것으로 마킹된 패킷과 최근접하는 이전의 의미 있는 패킷간의 시간 간격을 또는 이전의 의미 있는 패킷이 없으면 레코딩의 시작을 결정한다. 또 다른 실시예에서, 프로토콜 엔진은 기록된 세션의 콘텐츠를 마킹 패킷과 이전 패킷 사이에서 제1 시간 간격보다 짧은 시간 간격을 포함하는 제2 시간 간격으로 렌더링한다. 또 다른 실시예에서, 프로토콜 엔진은 기록된 세션의 콘텐츠를 마킹 패킷과 그 마킹 패킷을 뒤따르는 패킷 사이에서 제2 시간 간격으로 렌더링하되, 상기 제2 시간 간격은 제1 시간 간격보다 짧은 시간 간격을 포함한다.

일 실시예에서, 프로토콜 엔진이 시간 간격이 임계를 초과하는지를 결정하면(단계 2304), 프로토콜 엔진은 그 시간 간격이 지각할 수 있는 시간 간격으로서 분류한다. 렌더링되어 기록된 세션의 사용자가 활동이 없는 시간이 경과했음을 지각할 수 있으면 시간 간격을 지각할 수 있다. 일 실시예에서, 정책이 임계를 결정한다. 다른 실시예에서, 프로토콜 엔진은 사전 정의된 임계를 이용하여 하드 코딩된다(hard coded). 이러한 실시예에서, 프로토콜 엔진은 원래의 시간 간격 대신에 2개의 의미 있는 패킷들간에 보다 짧은 시간 간격을 렌더링하기 위한 인스트럭션을 플레이백 데이터 구조에 저장한다. 또 다른 실시예에서, 시간 간격이 임계를 초과한다는 것을 결정하는 프로토콜 엔진은 또한 그 기록된 세션의 콘텐츠를 렌더링한 다. 이러한 실시예에서, 프로토콜 엔진은 보다 짧은 시간 간격을 렌더링하기 위한 인스트럭션을 플레이백 데이터 구조에 저장하지는 않는다. 지각할 수 없는 것으로 분류된 시간 간격 동안에는 짧아진 시간 간격이 필요하지 않고, 2개의 의미있는 패킷들간의 원래의 시간 간격이 렌더링된다.

일 실시예에서, 기록된 스트림내의 패킷의 콘텐츠는 스크린 영역에 영향을 미치는 그래픽 업데이트(graphics updates)를 표시한다. 일 실시예에서, 그래픽 업데이트는 플래쉬 시스템 트레이 아이콘(flashing system tray icons), 타이틀 바 또는 테스크 바 엔트리(title bars or task bar entries), 웹 페이지 또는 애플리케이션내의 블링킹 텍스트, 클록 디스플레이, 시스템 애니메이션, 애플리케이션 애니메이션 및 스톡 티커(stock tickers) 및 기차 주기적으로 업데이트되는 정보 디스플레이들을 포함하나, 이제 국한되지 않는다. 일 실시예에서, 이들과 같은 그래픽 업데이트는 재생성되는 기록된 스트림의 사용자에게 중요하지 않은 것으로 결정된다. 이러한 실시예들 중 하나의 실시예에서, 프로토콜 엔진은 이러한 결정을 포함한다. 이러한 실시예들 중 또 다른 실시예에서, 정책은 적어도 하나의 그래픽 업데이트를 중요하지 않은 것으로 정의한다. 이러한 실시예에서, 관리자는 정책을 생성한다. 또 다른 실시예에서, 재생성되는 기록된 스트림의 사용자는 정책을 생성한다.

이제 도 24를 참조하면, 흐름도는 기록된 세션을 렌더링하는데 있어서 그래픽 업데이트를 삭제하기 위해 행하는 단계들의 일 실시예를 도시한다. 개괄적으로, 그래픽 업데이트가 식별되고(단계 2402) 그 그래픽 업데이트에 의해 영향을 받 은 스크린 영역이 결정된다(단계 2404). 영향을 받은 스크린 영역의 위치 및 상태의 표시가 저장되고(단계 2406), 그 스크린 영역에 영향을 미치는 제2 그래픽 업데이트가 식별된다(단계 2408). 그 다음, 제1 그래픽 업데이트에 의해 영향을 받은 영역을 제2 그래픽 업데이트가 변화시키는 것에 대응하여, 렌더링을 위한 목적지 및 렌더링되는 시간 간격이 표시된다(단계 2410 및 단계 2412).

일 실시예에서, 프로토콜 엔진은 도 24에 도시하는 단계들을 수행한다. 이러한 실시예에서, 프로토콜 엔진은 애플리케이션 프로그램에 의해 생성된 디스플레이 데이터를 표현하는 기록된 세션내에서 제1 그래픽 업데이트를 포함하는 패킷을 식별한다. 프로토콜 엔진은 제1 그래픽 업데이트에 의해서 영향을 받는 스크린 영역을 결정한다. 일 실시예에서, 그래픽 업데이트는 그 스크린 부분에 디스플레이되는 데이터를 변경하는 것에 의해 스크린 영역에 영향을 미친다. 프로토콜 엔진은, 제1 그래픽 업데이트 후 그 스크린 영역의 상태와 그 스크린 영역의 위치의 표시를 저장한다. 일 실시예에서, 프로토콜 엔진은 업데이트된 스크린 영역의 카피를 저장한다. 또 다른 실시예에서, 프로토콜 엔진은 업데이트된 스크린 영역의 해쉬(hash)를 저장한다.

일 실시예에서, 프로토콜 엔진은 시간 간격내에 그 스크린 영역에 영향을 미치는 제2 그래픽 업데이트를 확인한다. 일 실시예에서, 정책은 시간 간격의 길이를 결정한다. 이러한 실시예들 중 일 실시예에서, 정책은 애플리케이션 및 운영 체제가 사용하는 인간 범위 주기(human scale cyclic periods)의 상한을 추정하는 시간 간격을 결정한다. 일 실시예에서, 스크린의 영역이 사용자가 보도록 설계된 주기로 주기 디스플레이되면, 그 디스플레이는 인간 범위 주기를 포함한다. 일 실시예에서, 프로토콜 엔진은 그 시간 간격의 길이의 정의를 포함한다.

프로토콜 엔진이, 제1 그래픽 업데이트에 의해서 영향을 받은 스크린 영역에 영향을 미치는 제2 그래픽 업데이트를 식별하는 실시예에서, 프로토콜 엔진은, 제2 그래픽 업데이트 후의 스크린 영역의 상태가 제1 그래픽 업데이트 후의 스크린 영역의 상태와 다른 지를 결정한다. 그 스크린 영역이 제2 그래픽 업데이트 후에 변경되지 않으면, 제2 그래픽 업데이트는 재생성되는 기록된 세션에서 렌더링될 필요가 없다. 이러한 실시예에서, 프로토콜 엔진이, 그 그래픽 업데이트가 인간 범위 속도로 그리기 명령어의 싸이클을 수행 중이고 그 업데이트가 재생성되는 기록된 세션의 사용자에게 보일 수 있게 하며 그 그래픽 업데이트가 사용자에게 중요하지 않은 정보를 가지고 있다고 결정했으므로 그래픽 업데이트는 렌더링될 필요가 없다. 일 실시예에서, 그래픽 업데이트는 캐릿 플래쉬(caret flashing), 플래쉬 태스크바 아이콘, 네트워크 동작 표시자 또는 스크롤 텍스트(scrolling text)를 그리기함으로써 스크린 영역에 영향을 미친다. 일 실시예에서, 정책은, 그 유형의 그래픽 업데이트를 이용하여 스크린 영역에 영향을 미치는 것이 의미 있는 활동(activity)을 이루지 않아, 사용자를 위한 기록된 세션의 재생성시에 렌더링되지 않아야 한다고 결정한다. 다른 실시예에서, 프로토콜 엔진은 이러한 결정을 포함한다.

일 실시예에서, 그 스크린 영역에 영향을 미치는 제2 그래픽 업데이트를 포함하는 제2 패킷을 렌더링하기 위한 목적지의 표시는 제2 그래픽 업데이트 후에 스 크린 영역이 변경되는 지에 대응하여 플레이백 데이터 구조에 저장된다. 또 다른 실시예에서, 스크린 영역에 영향을 미치는 제2 그래픽 업데이트를 포함하는 제2 패킷과 관련된 렌더링 시간 간격의 표시는, 제2 그래픽 업데이트 후의 스크린 영역의 상태가 제1 그래픽 업데이트 후의 스크린 영역의 상태와 다른 지에 대응하여 플레이백 데이터 구조에 저장된다.

도 25는 제2 그래픽 업데이트 후의 스크린 영역의 상태가 제1 그래픽 업데이트 후의 스크린 영역의 상태와 다른 지에 대응하여 플레이백 데이터 구조에 저장된 표시에 대응하여 재생성되는 기록된 세션을 렌더링하는 일 실시예를 도시한다. 일 실시예에서, 제1 그래픽 업데이트에 의해 영향을 받은 스크린 영역은 제2 그래픽 업데이트 후 변경되지 않는다. 이러한 실시예에서, 표시는 제2 그래픽 업데이트를 지각할 수 있는 방식으로 렌더링하지 않도록 플레이백 데이터 구조에 저장된다. 일 실시예에서, 제2 그래픽 업데이트를 지각할 수 없게 렌더링하는 것은 제2 그래픽 업데이트를 온-스크린(on-scree)으로 렌더링하는 것이 아닌 오프-스크린(off-screen)으로 렌더링하는 것을 포함한다. 일 실시예에서, 제2 그래픽 업데이트를 지각할 수 없게 렌더링하는 것은, 제2 그래픽 업데이트를 오프-스크린 버퍼에 렌더링하는 것을 포함한다. 일 실시예에서, 제2 그래픽 업데이트를 지각할 수 없게 렌더링하는 것은 제2 그래픽 업데이트를 렌더링하지 않는 것을 포함한다. 일 실시예에서, 제2 그래픽 업데이트를 지각할 수 있게 렌더링하지 않도록 하는 결정은 그 그래픽 업데이트가 렌더링되지 않는다는 지각할 수 있는 마커를 렌더링하는 것을 포함한다. 이러한 실시예들 중 일 실시예에서, 재생성되는 기록된 세션의 사 용자는 제2 그래픽 업데이트가 지각할 수 있게 렌더링되도록 요청할 수도 있다.

도 25는 제2 그래픽 업데이트 후의 스크린 영역의 상태가 제1 그래픽 업데이트 후의 스크린 영역의 상태로부터 변경되지 않았다고 결정하는 것에 의해 순환 업데이트(cyclic update)를 검출하고 그 순환 업데이트의 검출에 대응하여 제2 그래픽 업데이트를 렌더링하지 않도록 결정하는 실시예를 도시한다. 제2 그래픽 업데이트에 의해 영향을 받은 스크린 영역의 상태가 제1 그래픽 업데이트 후의 스크린 영역의 상태로부터 변경되지 않은 일 실시예에서, 패킷의 콘텐츠를 지각할 수 있는 방식으로 버퍼에 렌더링하도록 결정한다.

일 실시예에서, 복수 개의 패킷 콘텐츠가 그래픽 업데이트를 나타낸다. 이러한 실시예들 중 일 실시예에서, 스크린 영역 상에서의 3번 이상의 그래픽 업데이트의 결과에 대응하여 그래픽 업데이트를 지각할 수 있는 방식으로 렌더링하도록 결정한다. 일 실시예에서, 그래픽 업데이트를 렌더링하기 위한 목적지의 결정은 식별된 복수 개의 패킷의 각 패킷의 콘텐츠가 나타내는 그래픽 업데이트에 대응한다.

일 실시예에서, 기록된 스트림의 패킷의 콘텐츠는 상호작용 시퀀스(interaction sequence)를 표시한다. 일 실시예에서, 상호작용 시퀀스는 로그온 시퀀스, 로그오프 시퀀스 또는 증명서(credentials)의 입력을 포함하나, 이에 국한되지 않는다. 일 실시예에서, 이들과 같은 상호작용 시퀀스는 재생성되는 기록된 스트림의 사용자에게 중요하지 않다고 결정된다. 이러한 실시예들 중 일 실시예에서, 프로토콜 엔진은 이러한 결정을 포함한다. 이러한 실시예들 중 또 다른 실시 예에서, 정책은 적어도 하나의 상호작용 시퀀스를 중요하지 않은 것으로 정의한다. 이러한 실시예에서, 관리자는 정책을 생성한다. 또 다른 실시예에서, 재생성되는 기록된 스트림의 사용자가 정책을 생성한다.

이제 도 26을 참조하면, 흐름도는 기록된 세션을 렌더링하는데 있어서 상호작용 시퀀스를 삭제하기 위하여 행하는 단계들의 일 실시예를 도시한다. 정책에 대응하여 적어도 하나의 패킷의 상호작용 시퀀스의 시작을 확인한다(단계 2602). 플레이백 데이터 구조에는 상호작용 시퀀스가 버퍼에 렌더링되어야 한다는 표시가 있다(단계 2604). 적어도 하나의 패킷의 상호작용 시퀀스의 종료를 확인한다(단계 2606). 식별된 상호작용 시퀀스의 시작을 앞서는 패킷과 식별된 상호작용 시퀀스의 종료 다음의 패킷간의 제1 시간 간격을 확인한다(단계 2608). 플레이백 데이터 구조는 제1 시간 간격보다 짧은 제2 시간 간격을 렌더링하기 위한 표시를 포함한다(단계 2610).

일 실시예에서, 프로토콜 엔진은 상호작용 시퀀스를 삭제하기 위한 ID 및 표시를 형성한다. 상호작용 시퀀스의 시작을 확인한다(단계 2602). 일 실시예에서, 상호작용 시퀀스의 시작은 시각 마커(visual marker)를 확인함으로써 확인된다. 일 실시예에서, 시각 마커는 모든 세션에 대해 동일한 방식으로 디스플레이되는 인증서 윈도우를 포함한다. 또 다른 실시예에서, 시각 마커는 인증서 윈도우를 블랭크 스크린(blank screen)으로 그 다음 데스크탑 백그라운드로의 교체하는 것을 포함한다. 일 실시예에서, 시각 마커는 지각할 수 있는 아이콘의 디스플레이를 포함한다.

일 실시예에서, 상호작용 시퀀스의 시작은 상호작용 시퀀스의 시작 시간을 결정함으로써 확인된다. 이러한 실시예들 중 일 실시예에서, 일 구성요소가 상호작용 시퀀스에서 이벤트의 시작 시각을 검출한다. 이러한 실시예들 중 또 다른 실시예에서 일 구성요소가 로그온 시퀀스의 시작 시각을 검출한다. 이러한 실시예들 중 또 다른 실시예에서, 일 구성요소가 로그오프 시퀀스의 시작 시각을 검출한다. 일 실시예에서, 상호작용 시퀀스의 시작의 확인은 입력 포커스를 갖는 윈도우를 식별하는 것에 대응한다.

플레이백 데이터 구조내에, 버퍼에 상호작용 시퀀스가 렌더링되어야 한다는 것을 표시한다(단계 2604). 이러한 실시예에서, 확인된 상호작용 시퀀스가 지각할 수 없게 렌더링되어야 하는 경우에, 그 상호작용 시퀀스는 버퍼에 렌더링된다. 상호작용 시퀀스를 버퍼에 렌더링하는 것에 의해, 렌더링되는 사용자에게 그 상호작용 시퀀스는 지각할 수 없게 된다. 정책 또는 사용자가 그 상호작용 시퀀스를 중요하지 않은 것으로 분류한 경우, 이러한 렌더링으로 인해 중요하지 않은 상호작용 시퀀스가 삭제된다.

또한, 상호작용 시퀀스의 종료를 확인한다(단계 2606). 일 실시예에서, 상호작용 시퀀스의 종료는 시각 마커를 식별함으로써 확인된다. 다른 실시예에서, 상호작용 시퀀스의 종료는 상호작용 시퀀스의 종료 시각을 결정하는 것에 의해 확인된다. 이러한 실시예들 중 일 실시예에서, 일 구성요소가 상호작용 시퀀스에서 이벤트의 종료 시각을 검출한다. 이러한 실시예들 중 또 다른 실시예에서, 일 구성요소가 로그온 시퀀스의 종료 시각을 검출한다. 이러한 실시예들 중 또 다른 실 시예에서, 일 구성요소가 로그오프 시퀀스의 종료 시각을 검출한다. 또 다른 실시예에서, 상호작용 시퀀스의 종료를 확인하는 것은 입력 포커스를 갖는 윈도우를 확인하는 것에 대응한다.

일 실시예에서, 상호작용 시퀀스는 애플리케이션의 사용을 포함한다. 이러한 실시예들 중 일 실시예에서, 정책이 애플리케이션의 사용을 포함하는 상호작용 시퀀스가 지각할 수 없게 렌더링되어야 한다는 것을 확인한다. 일 실시예에서, 이러한 애플리케이션은 워드 프로세싱 문서를 포함하나, 이에 국한되지는 않는다.

이러한 실시예들 중 일 실시예에서, 상호작용 시퀀스의 시작은 입력 포커스를 갖는 애플리케이션을 확인하는 것에 의해 확인된다. 패킷이 콘텐츠가 포커스를 갖는 윈도우를 표현하면, 그 윈도우를 생성한 프로세스를 담당하는 애플리케이션에 대해 결정을 한다. 일 실시예에서, 포커스를 갖는 윈도우를 표현하는 패킷의 콘텐츠는 입력 포커스의 변화를 표시하는 윈도우 통지 메세지(window notification message)를 포함한다. 담당 애플리케이션이, 지각할 수 없게 렌더링되어야 하는 상호작용 시퀀스의 시작을 식별하면, 상호작용 시퀀스를 버퍼에 렌더링하기 위한 표시를 플레이백 데이터 구조에 저장한다. 프로세스가 가지고 있는 윈도우가 포커스를 획득한 것을 확인함으로써 상호작용 시퀀스의 종료를 확인한다.

일 실시예에서, 제1 시간 간격은 상호작용 시퀀스와 연관되어 있다. 상호작용 시퀀스 자체가 렌더링되지 않는 일 실시예에서, 상호작용 시퀀스와 연관되어 있는 시간 간격을 지각할 수 있게 렌더링하는 것에 의해서, 렌더링 사용자에게 디스플레이 데이터가 렌더링되지 않는 지각할 수 있는 시간 주기가 생기고, 사용자는 상호작용 시퀀스 이후의 패킷의 콘텐츠를 렌더링하기 전에 그 시간 간격 동안 대기한다. 일 실시예는 원래의 시간 간격 대신에 보다 짧은 시간 간격을 렌더링함으로써 그 상호작용 시퀀스와 관련되어 있던 시간 간격을 삭제한다. 이러한 실시예에서, 식별된 상호작용 시퀀스의 시작을 앞서는 패킷과 식별된 상호작용 시퀀스의 종료 다음의 패킷간의 제1 시간 간격을 확인한다(단계 2608). 플레이백 데이터 구조는 제1 시간 간격보다 짧은 제2 시간 간격을 렌더링하기 위한 표시를 포함한다(단계 2610).

일 실시예에서, 프로토콜 엔진이 기록된 세션내의 패킷의 콘텐츠를 렌더링하여 사용자에게 기록된 세션을 재생성한다. 이러한 실시예들 중 일 실시예에서, 프로토콜 엔진은 적어도 하나의 패킷의 콘텐츠들의 렌더링 시간 간격을 자동으로 변화시켜, 상황 의존형 시간 워프형 플레이백(context-sensitive time-warped palyback)이 생긴다. 이러한 실시예에서, 렌더링은 사용자에게 표현되는(present)디스플레이 데이터를 사용자가 거의 이해할 수 있게 한다(appoximate). 일 실시예에서, 패킷의 콘텐츠에 의해 표현되는 디스플레이 데이터가 정책이 정의하는 것에 대응하여 보다 높은 복잡도나 중요도 레벨을 갖는다고 결정하면 패킷 콘텐츠들간의 렌더링 시간 간격이 증가한다. 또 다른 실시예에서, 패킷의 콘텐츠에 의해 표현되는 디스플레이 데이터가 정책이 정의하는 것에 대응하여 보다 낮은 복잡도나 중요도 레벨을 갖는다고 결정하면 패킷 콘텐츠들간의 렌더링 시간 간격은 감소한다. 이러한 실시예에서, 프로토콜 엔진은 사용자가 디스플레이 데이터를 거의 포함할 수 있게 하고, 사용자에게 그 렌더링을 포함하는 시간을 제공하기 위하여 보다 느 리게 콘텐츠를 렌더링하거나, 또는 사용자가 보다 짧은 포함 시간을 필요로 하면 보다 빠르게 콘텐츠를 렌더링한다.

이제 도 27을 참조하면, 흐름도는 기록된 컴퓨터 세션을 렌더링하는데 있어서 자동 시간 워프형 플레이백으로 수행되는 단계들의 일 실시예를 도시한다. 프로토콜 엔진이 기록된 세션 ― 기록된 세션은 복수의 패킷을 포함하고 디스플레이 데이터를 표현함 ― 을 수신하고(단계 2702), 기록된 세션내의 복수의 패킷의 적어도 일부에 의해 표현되는 복잡도를 프로토콜 엔진이 결정한다. 프로토콜 엔진이 기록된 세션내의 복수의 패킷의 적어도 일부들간의 시간 간격을 확인하고(단계 2706), 기록된 세션내 복수의 패킷의 적어도 일부에 의해 표현되는 복잡도에 대응하여 시간 간격을 조절한다(단계 2708). 프로토콜 엔진이 조절된 시간 간격을 플레이백 데이터 구조에 저장하고(단계 2710), 기록된 데이트 스트림은 그 플레이백 데이터 구조에 대응하여 렌더링된다(단계 2712).

일 실시예에서, 복잡도를 정하고, 시간 간격을 확인하고, 시간 간격을 조절하고, 조절 내용을 저장하는 프로토콜 엔진은 백그라운드 프로토콜 엔진이다. 이러한 실시예들 중 일 실시예에서, 백그라운드 프로토콜 엔진은 또한 기록된 스트림을 렌더링한다. 이러한 실시예들 중 또 다른 실시예에서, 포그라운드 프로토콜 엔진이 기록된 스트림을 플레이백 데이터 구조에 대응하여 렌더링한다. 일 실시예에서, 백그라운드 프로토콜 엔진 및 포그라운드 프로토콜 엔진은 동일한 디바이스에 상주한다. 다른 실시예에서, 백그라운드 프로토콜 엔진 및 포그라운드 프로토콜 엔진은 별도의 디바이스에 상주한다.

일 실시예에서, 프로토콜 엔진은 기록된 세션내 복수의 패킷의 적어도 일부에 의해 표현되는 복잡도를 결정한다(단계 2704). 이러한 실시예들 중 일 실시예에서, 프로토콜 엔진은 키보드 입력에서 가능성이 있는 타이핑의 시퀀스를 확인함으로써 복잡도를 결정한다. 일 실시예에서, 프로토콜 엔진은 키보드 입력에서 가능성이 있는 타이핑 시퀀스를 확인하기 위해 포함된 적어도 일 유형의 키를 검사한다(inspects). 또 다른 실시예에서, 프로토콜 엔진은 렌더링되는 적어도 하나의 표지(glyph)의 시퀀스를 검사하여 키보드 입력에서 가능성이 있는 타이핑 시퀀스를 발견적으로 근사(heuristic approximation)한다.

이러한 실시예들 중 일 실시예에서, 프로토콜 엔진은 키의 특성에 의해 결정되는 키의 종류(classifications)를 저장한다. 키 특성은 프린트 가능 특성 또는 프린트 불가 특성, 공백(white space), 네비게이션 키(navigation keys) 또는 기능 키를 포함하고 이 특성들의 조합을 포함하나 이에 국한되지는 않는다. 일 실시예에서, 프로토콜 엔진은, 프린트 가능 특성 및 간헐적인 네비게이션 키를 포함하는 입력이 세션이 정상적인 타이핑을 구성하는 반면, 대부분의 비 가시적인 키를 갖는 세션은 정상적인 타이핑을 구성하지 않는다고 결정한다. 일 실시예에서, 프로토콜 엔진은 식별된 공백의 양에 대응하여 복잡도를 결정한다. 이러한 실시예에서, 프로토콜 엔진은 전형적인 타이핑 패턴에서 공백이 평균 대략 5 내지 8개의 문자마다 나타남을 표시하는 워드 프로세싱의 정의를 포함한다.

일 실시예에서, 프로토콜 엔진은 복잡도를 결정하기 위해 나타나는 프린트 불가 문자들을 이용한다. 또 다른 실시예에서, 프로토콜 엔진은 거의 동시에 함께 나타나는 공백이 아닌 프린트 가능 문자들의 시퀀스를 확인하기 위하여 키스트로크 시퀀스를 액세스한다. 이러한 실시예에서, 프로토콜 엔진은 키 스트로크 시퀀스를 사전과 비교하여 유효 단어들을 식별하고 유효한 단어들 대 유효하지 않은 단어들를 사용자가 이해할 수 있는 정도와 관련된 복잡도를 결정하는 기능(capacity)을 포함한다.

또 다른 실시예에서, 프로토콜 엔진은 패킷의 콘텐츠가 표지를 렌더링하라는 명령어를 포함함을 결정한다. 이러한 실시예에서, 프로토콜 엔진은 표지(glyphs)를 이용하여, 디스플레이 데이터가 사용자의 타이핑 작용을 표시하는 지를 결정한다. 이러한 실시예에서, 표지 렌더링 속도가 짧은 지연을 가지며 키보드 입력 속도에 근사하면, 키 스트로크가 직접적으로 표지가 생기게 하여 사용자가 타이핑하는 것처럼 만든다. 일 실시예에서, 프로토콜 엔진은 입력되는 키를 생성되는 표지와 상관시킨다. 또 다른 실시예에서, 프로토콜 엔진은 렌더링된 표지의 공간적 시퀀스(좌측에서 우측으로, 우측에서 좌측으로 등)를 결정하여 사용자가 타이핑하는 것을 결정한다. 일 실시예에서, 프로토콜 엔진은 복수의 패킷의 콘텐츠를 분석하고 그 콘텐츠에 의해 표현되는 패턴 및 작용들을 식별하는 결과에 따른 복잡도를 결정한다.

다른 실시예에서, 프로토콜 엔진은 확인된 마우스 입력의 유형에 대응하여 복잡도를 결정한다. 일 실시예에서, 프로토콜 엔진은, 마우스의 클릭을 표하는 마우스 입력이, 특히 타이핑의 시퀀스를 뒤 이은 클릭의 경우, 이해를 위하여 보다 느린 렌더링 속도를 필요로 할 수 있는 동작을 야기한다고 결정한다. 또 다른 실 시예에서, 프로토콜 엔진은 마우스 클릭을 표하지 않는 마우스 입력은 디스플레이 데이터의 사용자 이해도에 영향을 미치지 않고, 따라서 복잡도에 영향을 미치지 않는다고 결정한다.

다른 실시예에서, 프로토콜 엔진은 그래픽 업데이트의 복잡도에 대한 발견적인 근사를 확인하는 것에 응하여 복잡도를 결정한다. 일 실시예에서, 프로토콜 엔진은 영역(들)의 크기가 업데이트되는 것, 그래픽 명령에 의해 변경되는 영역의 면적의 크기, 주기적인 그래픽 명령, 그래픽 명령의 개수, 그래픽 명령의 빈도, 그래픽 명령을 포함하는 콘텐츠들의 인접 패킷들간의 시간 간격 또는 그래픽 업데이트의 유형 등에 기초하여 그래픽 업데이트의 관찰적인 근사를 확인한다. 프로토콜 엔진이 그래픽 업데이트에 대하여 저 복잡도를 확인하는 실시예에서, 프로토콜 엔진은 그래픽 업데이트를 포함하는 패킷이 표현하는 저 복잡도를 결정한다. 프로토콜 엔진이 그래픽 업데이트에 대하여 고 복잡도를 확인하는 실시예에서, 프로토콜 엔진은 그래픽 업데이트를 포함하는 패킷이 표현하는 고 복잡도를 결정한다.

일 실시예에서, 프로토콜 엔진은 기록된 세션내 복수의 패킷 중 적어도 일부들간의 시간 간격을 확인한다(단계 2706). 이러한 실시예에서, 프로토콜 엔진은 결정된 복잡도에 대응하여 시간의 간격을 조절한다(단계 2708). 기록된 세션내 복수의 패킷의 적어도 일부가 고 복잡도와 연관된 디스플레이 데이터를 표현하는 실시예에서, 프로토콜 엔진은 패킷들간의 시간 간격을 증가시켜 증가한 시간 동안 렌더링 사용자가 렌더링된 디스플레이 데이터를 이해할 수 있게 한다. 기록된 세션내 복수의 패킷의 적어도 일부가 저 복잡도와 연관된 디스플레이 데이터를 표현하 는 또 다른 실시예에서, 프로토콜 엔진은 그 패킷들간의 시간의 간격을 감소시켜 사용자가 렌더링된 디스플레이 데이터를 이해하는 데 필요한 시간이 감소되었음을 반영한다. 일 실시예에서, 사용자는 프로토콜 엔진에 의해 렌더링되는 시간보다 렌더링되는 패킷의 콘텐츠들 사이에 상이한 시간을 필요로 한다. 이러한 실시예에서, 사용자는 사용자가 그 렌더링된 디스플레이 데이터를 이해하는 데 필요로 하는 시간을 반영하기 위하여 시간의 간격을 조절한다. 일 실시예에서, 프로토콜 엔진은 또한 복수의 패킷의 적어도 일부와 나머지 복수의 패킷들간의 시간 간격을 확인하여 그 패킷 집합들간에 확인된 시간의 간격을 조절한다.

일 실시예에서, 프로토콜 엔진은 기록된 세션내의 일 패킷과 연관된 제1 마커를 식별한다. 일 실시예에서, 패킷은 그 마커를 포함한다. 또 다른 실시예에서, 기록된 세션은 그 마커를 포함한다.

일 실시예에서, 디스플레이 데이터의 렌더링 사용자는 그 마커를 정의한다. 또 다른 실시예에서, 프로토콜 엔진이 그 마커를 정의한다. 프로토콜 엔진이 마커를 식별하는 실시예에서 프로토콜 엔진은 제1 마커에 대응하여 시간의 간격을 조절한다. 일 실시예에서, 프로토콜 엔진은 시간의 간격을 증가시켜 디스플레이 데이터의 렌더링 사용자에게 제1 마커와 연관된 패킷의 콘텐츠를 포함시키기 위한 추가의 시간을 제공한다. 다른 실시예에서, 프로토콜 엔진은 제2 패킷에서 제2 마커를 식별한다. 이러한 실시예에서, 프로토콜 엔진은 제1 마커와 제2 마커간의 거리에 대응하여 시간의 간격을 조절한다. 이러한 실시예에서, 프로토콜 엔진은 마킹된 패킷의 콘텐츠가 표현하는 디스플레이 데이터를 포함시키기 위해서는 시간을 증가 시켜 주고, 마킹되지 않은 패킷의 콘텐츠가 표현하는 데이터를 포함하기 위해서는 시간을 감소시켜 준다. 일 실시예에서, 사용자는 사용자가 관심을 가지는 디스플레이 데이터에 대한 마커를 정의하고, 프로토콜 엔진은 사용자가 관심을 가지는 디스플레이 데이터에 대해서는 렌더링 시간을 마커에 의해 결정된 만큼 추가하고 사용자가 관심을 가지지 않는 디스플레이 데이터에 대해서는 렌더링 시간을 감소시킨다.

일 실시예에서, 프로토콜 엔진은 기록된 세션내에 복수의 패킷의 적어도 일부에서 제1 마커를 식별하며, 상기 마커는 기록된 세션내의 복수의 패킷의 적어도 일부 중 최초 패킷을 표시한다. 프로토콜 엔진은 제1 마커에 대응하여 시간의 간격을 조절한다. 프로토콜 엔진은 기록된 세션내의 복수의 패킷의 적어도 일부 중 두 번 째 패킷에서 제2 마커를 식별하며, 상기 제2 마커는 기록된 세션내 상기 복수의 패킷의 적어도 일부 중 마지막 패킷을 표시하며 제1 마커와 제2 마커 사이의 시간의 간격에 대응하여 시간의 간격을 조절한다.

일 실시예에서, 프로토콜 엔진은 플레이백 데이터 구조에 조절된 시간의 간격을 저장하고(단계 2710), 기록된 스트림은 플레이백 데이터 구조의 콘텐츠에 대응하여 렌더링된다(단계 2712). 일 실시예에서, 프로토콜 엔진은 또한 조절된 시간 간격에 관한 플레이백 데이터 구조에 대응하여 기록된 스트림을 렌더링한다. 또 다른 실시예에서, 별도의 포그라운드 프로토콜 엔진이 기록된 스트림을 렌더링한다.

일 실시예에서, 렌더링되는 디스플레이 데이터의 포함을 위해 렌더링 사용자 에게 증가된 시간을 제공하기 위하여 기록된 애플리케이션과의 상호작용은 렌더링에 증가된 시간을 필요로 하지 않는다는 결정을 한다. 이러한 실시예들 중 일 실시예에서, 증가된 시간을 필요로 하는 애플리케이션이 증가된 시간을 필요로 하지 않는 애플리케이션보다 중요한 애플리케이션을 포함한다는 결정을 한다. 이러한 실시예들 중 일 실시예에서, 사용자가 결정을 한다. 이러한 실시예들 중 일 실시예에서, 정책이 결정을 한다. 이러한 실시예들 중 또 다른 실시예에서, 프로토콜 엔진은 증가된 시간을 필요로 하는 애플리케이션의 정의를 포함한다.

이제 도 28을 참조하면, 흐름도는 기록된 컴퓨터 세션을 렌더링하는데 있어서 식별된 애플리케이션에 대응하여 자동 시간-워프형 플레이백되도록 수행되는 단계들의 일 실시예를 도시한다. 복수의 패킷을 포함하며 디스플레이 데이터를 표현하는 기록된 세션을 수신한다(단계 2802). 포커스를 갖는 윈도우 ― 상기 윈도우는 애플리케이션을 표시함 ― 를 표현하는 콘텐츠를 갖는 제1 패킷을 식별한다(단계 2804). 제1 패킷의 콘텐츠를 렌더링하기 이전에 그 콘텐츠가 렌더링되는 제2 패킷과, 제1 패킷의 콘텐츠를 렌더링한 후에 그 콘텐츠가 렌더링되는 제3 패킷간의 시간 간격을 식별한다(단계 2806). 식별된 시간 간격을 표시된 시간 간격에 대응하여 조절한다(단계 2808). 기록된 스트림내의 적어도 하나의 패킷을 상기 조절에 대응하여 렌더링한다(단계 2810).

일 실시예에서, 프로토콜 엔진은 기록된 세션을 수신한다(단계 2802). 이러한 실시예에서, 프로토콜 엔진은 또한 포커스를 갖는 윈도우를 표현하는 콘텐츠를 가지고 있는 제1 패킷을 식별하며, 상기 윈도우는 애플리케이션을 표시한다(단계 2804). 일 실시예에서, 포커스를 갖는 윈도우를 표현하는 패킷의 콘텐츠는 입력 포커스의 변화를 표시하는 윈도우 통지 메세지(window notification messages)를 포함한다. 일 실시예에서, 제1 패킷의 콘텐츠가 렌더링되기 이전에 그 콘텐츠가 렌더링되는 제2 패킷과, 제1 패킷의 콘텐츠가 렌더링된 후에 그 콘텐츠가 렌더링되는 제3 패킷 사이에서 시간 간격을 확인한다(단계 2806). 이러한 실시예에서, 프로토콜 엔진은 포커스를 갖는 애플리케이션 윈도우를 표현하는 콘텐츠가 렌더링되기 이전에 그 콘텐츠가 렌더링되는 패킷과, 포커스를 갖는 애플리케이션 윈도우를 그 콘텐츠가 표현하는 패킷과, 더 이상 포커스를 갖지 않는 애플리케이션 윈도우를 그 콘텐츠가 표현하는 패킷을 식별한다.

일 실시예에서, 프로토콜 엔진은 포커스를 갖는 애플리케이션을 앞서는 시간 간격을 조절한다. 다른 실시예에서, 프로토콜 엔진은 포커스를 갖는 애플리케이션 뒤를 잇는 시간 간격을 조절한다. 일 실시예에서, 프로토콜 엔진은 그 후, 애플리케이션 윈도우가 포커스를 가지는 시간 간격을 결정하고, 그 시간 간격을 애플리케이션의 유형에 따라 조절한다. 일 실시예에서, 프로토콜 엔진은 식별된 시간 간격을 증가시킨다. 이러한 실시예에서, 프로토콜 엔진은 렌더링 사용자에게 애플리케이션을 리뷰하는 시간을 증가시켜 제공한다. 또 다른 실시예에서, 프로토콜 엔진은 식별된 시간 간격을 감소시킨다. 이러한 실시예에서, 프로토콜 엔진은 렌더링의 사용자에게 그 애플리케이션을 리뷰하는 시간을 감소시켜 제공하여 애플리케이션에 대한 관심의 감소량을 반영한다.

일 실시예에서, 프로토콜 엔진은 조절에 대응하여 기록된 스트림내의 적어도 하나의 패킷을 렌더링한다. 일 실시예에서, 프로토콜 엔진은 기록된 스트림내의 적어도 하나의 패킷의 콘텐츠를 버퍼에 렌더링한다. 일 실시예에서, 버퍼에 렌더링하는 것은 패킷의 콘텐츠를 지각할 수 있는 방식으로 렌더링하지 않는다. 또 다른 실시예에서, 프로토콜 엔진은 기록된 스트림내의 적어도 하나의 콘텐츠를 버퍼에 지각할 수 있는 방식으로 렌더링한다. 일 실시예에서, 프로토콜 엔진은 조절된 시간 간격을 플레이백 데이터 구조에 표시하고 별도의 프로토콜 엔진이 플레이백 데이터 구조에 저장된 정보에 대응하여 기록된 세션을 렌더링한다.

이제, 도 29를 참조하면, 블록도는 기록된 컴퓨터 세션을 렌더링하는데 있어서의 자동 시간-워프형 플레이백 시스템으로서, 프로토콜 엔진(2902), 기록된 스트림(2910), 프레이백 데이터 구조(2904) 및 디스플레이(2908)를 포함하는 자동 시간-워프형 플레이백 시스템의 일 실시예를 도시한다. 개괄적으로, 프로토콜 엔진(2902)은 기록된 스트림(2910)을 수신하는 것에 대응하여 플레이백 데이터 구조(2904)를 생성하며, 상기 기록된 스트림(2910)은 복수의 패킷을 포함하고, 상기 프로토콜 엔진(2902)은 생성된 플레이백 데이터 구조(2904)에 대응하여 기록된 스트림내의 적어도 하나의 패킷을 렌더링한다.

일 실시예에서, 프로토콜 엔진(2902)은 백그라운드 프로토콜 엔진 및 포그라운드 프로토콜 엔진을 포함한다. 이러한 실시예에서, 백그라운드 프로토콜 엔진은 기록된 스트림(2910)을 수신하고 플레이백 데이터 구조(2904)를 생성한다. 이러한 실시예에서, 포그라운드 프로토콜 엔진은 기록된 스트림(2910)을 수신하고 생성된 플레이백 데이터 구조(2904)에 대응하여 기록된 스트림내의 적어도 하나의 패킷을 렌더링한다. 일 실시예에서, 백그라운드 프로토콜 엔진 및 포그라운드 프로토콜 엔진은 동일한 디바이스에 상주한다. 또 다른 실시예에서, 백그라운드 프로토콜 엔진은 제1 디바이스에 상주하고 포그라운드 프로토콜 엔진은 제2 디바이스에 상주한다.

또 다른 실시예에서, 시스템은 플레이백 데이터 구조(2904)를 생성하며 생성된 플레이백 데이터 구조(2904)에 대응하여 기록된 스트림내의 적어도 하나의 패킷을 렌더링하는 단일의 프로토콜 엔진(2902)을 포함한다.

일 실시예에서, 프로토콜 엔진(2902)은 기록된 세션을 렌더링하기 위한 적어도 하나의 인스트럭션을 플레이백 데이터 구조에 저장한다. 일 실시예에서, 그 인스트럭션은 기록된 세션내의 패킷의 콘텐츠를 렌더링하기 위하여 식별된 시간의 조절을 포함한다. 또 다른 실시예에서, 프로토콜 엔진은 플레이백 데이터 구조에 메타데이터를 저장한다. 이러한 실시예에서, 메타데이터는 패킷의 콘텐츠를 렌더링하기 위한 상급 인스트럭션(higher order instructions)을 포함한다.

일 실시예에서, 프로토콜 엔진은 플레이백 데이터 구조의 콘텐츠에 대응하여 기록된 세션내의 적어도 하나의 패킷의 콘텐츠를 렌더링한다. 일 실시예에서, 프로토콜 엔진은 기록된 세션내의 적어도 하나의 패킷을 지각할 수 있는 방식으로 버퍼에 렌더링한다. 또 다른 실시예에서, 프로토콜 엔진은 기록된 세션내의 적어도 하나의 패킷을 버퍼에 렌더링한다.

일 실시예에서, 패킷의 랜더링된 콘텐츠를 원래의 디스플레이 데이터의 스트림라인형 재생성(streamlined regeneration)을 제공한다. 다른 실시예에서, 패킷 의 렌더링된 콘텐츠는 디스플레이 데이터의 맞춤 형태를 제공한다. 일 실시예에서, 패킷의 콘텐츠를 인실할 수 있는 방식으로 렌더링하라는 결정은 정책 또는 사용자 요청에 대응한다. 이러한 실시예들은 사용자가 기록된 세션을 렌더링하는 것을 제어할 수 있게 한다.

본 발명은 일 이상의 제품내 또는 제품 상에서 구현되는 하나 이상의 컴퓨터 판독 가능 프로그램으로서 제공될 수 있다. 제품은 플로피 디스크, 하드 디스크, 소형 디스크, 디지털 휘발성 디스크, 플래쉬 메모리 카드, PROM, RAM, ROM 또는 마그네틱 테이프일 수도 있다. 일반적으로, 컴퓨터 판독 가능 프로그램은 임의의 프로그래밍 언어로 구현될 수도 있다. 사용될 수 있는 언어의 몇몇 예에는 C, C++, C# 또는 JAVA가 있다. 소프트웨어 프로그램은 일 이상의 제품내 또는 제품 상에 저장될 수도 있다.

특정의 바람직한 실시예를 참조하여 본 발명을 도시하고 설명하였으나, 당업자라면, 다음 청구의 범위에 의해 정의되는 본 발명의 사상 및 범주로부터 이탈함이 없이 그 형태 및 세부사항에 있어 다양한 변경이 이루어질 수 있음을 이해할 수 있을 것이다.

Claims (73)

1. 기록된 컴퓨터 세션을 플레이백(playback)하기 위한 플레이백 인스트럭션 생성 방법으로서,

   (a) 제1 디바이스 상에서 실행하는 프로토콜 엔진에 의해서, 제2 디바이스 상에서 실행되는 애플리케이션 프로그램에 의해 생성된 디스플레이 데이터를 표현하는 복수의 패킷을 포함하는 기록된 스트림(recorded stream)을 수신하는 단계;

   (b) 상기 프로토콜 엔진에 의해서, 상기 기록된 스트림내의 패킷이 상기 패킷의 콘텐츠를 인간이 지각할 수 있는 방식으로 렌더링(render)되는 지를 결정하는 단계; 및

   (c) 상기 프로토콜 엔진에 의해서, 상기 결정 결과를 플레이백 데이터 구조(playback data structure)에 저장하는 단계를 포함하는,

   플레이백 인스트럭션 생성 방법.
2. 제 1 항에 있어서,

   단계(b)는 입력 포커스(input focus)를 갖는 애플리케이션 프로그램의 표시(indication)에 대응하여 적어도 하나의 패킷을 렌더링하는 것을 결정하는 것을 더 포함하는, 플레이백 인스트럭션 생성 방법.
3. 제 1 항에 있어서,

   단계(b)는 적어도 하나의 상기 패킷에 저장된 사용자 입력의 유형 평가에 대응하여 상기 적어도 하나의 패킷을 렌더링하는 것을 결정하는 것을 더 포함하는, 플레이백 인스트럭션 생성 방법.
4. 제 1 항에 있어서,

   단계(b)는 적어도 하나의 상기 패킷에 의해 저장된 그래픽 업데이트의 유형 평가에 대응하여 상기 적어도 하나의 패킷을 렌더링하는 것을 결정하는 것을 더 포함하는, 플레이백 인스트럭션 생성 방법.
5. 제 1 항에 있어서,

   단계(b)는 적어도 하나의 상기 패킷에 의해 저장된 상호작용 시퀀스의 유형 평가에 대응하여 상기 적어도 하나의 패킷을 렌더링하는 것을 결정하는 것을 더 포함하는, 플레이백 인스트럭션 생성 방법.
6. 기록된 컴퓨터 세션을 플레이백하기 위한 방법으로서,

   (a) 제1 디바이스 상에서 실행하는 백그라운드 프로토콜 엔진에 의해서, 제2 디바이스 상에서 실행하는 애플리케이션 프로그램에 의해 생성된 디스플레이 데이터를 표현하는 복수의 패킷을 포함하는 기록된 스트림을 수신하는 단계;

   (b) 상기 백그라운드 프로토콜 엔진에 의해서, 상기 기록된 스트림내의 적어도 하나의 패킷에 대해 인간이 지각할 수 있는 방식으로 상기 패킷을 렌더링하는 것을 결정하는 단계;

   (c) 상기 백그라운드 프로토콜 엔진에 의해서, 상기 결정을 상기 플레이백 데이터 구조에 저장하는 단계;

   (d) 포그라운드 프로토콜 엔진에 의해서, 상기 기록된 스트림으로부터 적어도 하나의 패킷을 검색하는 단계;

   (e) 상기 포그라운드 프로토콜 엔진에 의해서, 상기 플레이백 데이터 구조를 액세스하는 단계; 및

   (f) 상기 포그라운드 프로토콜 엔진에 의해서, 상기 플레이백 데이터 구조에 대응하여 상기 적어도 하나의 패킷을 렌더링하는 단계를 포함하는,

   플레이백 방법.
7. 제 6 항에 있어서,

   단계(b)는 입력 초점(input focus)을 갖는 애플리케이션 프로그램의 표시(indication)에 대응하여 적어도 하나의 패킷을 렌더링하는 것을 결정하는 단계 를 더 포함하는, 플레이백 방법.
8. 제 6 항에 있어서,

   단계(b)는 상기 적어도 하나의 패킷에 저장된 사용자 입력의 유형 평가에 대응하여 상기 적어도 하나의 패킷을 렌더링하는 것을 결정하는 단계를 더 포함하는, 플레이백 방법.
9. 제 6 항에 있어서,

   단계(b)는 상기 적어도 하나의 상기 패킷에 의해 저장된 그래픽 업데이트의 유형 평가에 대응하여 상기 적어도 하나의 패킷을 렌더링하는 것을 결정하는 단계를 더 포함하는, 플레이백 방법.
10. 제 6 항에 있어서,

    단계(b)는 상기 적어도 하나의 상기 패킷에 의해 저장된 상호작용 시퀀스의 유형 평가에 대응하여 상기 적어도 하나의 패킷을 렌더링하는 것을 결정하는 단계를 더 포함하는, 플레이백 방법.
11. 제 6 항에 있어서,

    단계(c)는 상기 백그라운드 프로토콜 엔진에 의해서, 상기 패킷을 버퍼에 렌더링하기 위한 인스트럭션을 상기 플레이백 데이터 구조에 저장하는 단계를 더 포함하는, 플레이백 방법.
12. 제 6 항에 있어서,

    단계(f)는 상기 포그라운드 프로토콜 엔진에 의해서, 상기 적어도 하나의 패킷의 콘텐츠를 버퍼에 렌더링하는 단계를 더 포함하는, 플레이백 방법.
13. 기록된 세션을 렌더링하는 시스템으로서,

    제1 디바이스 상에서 실행되며, 기록된 스트림 ― 상기 기록된 스트림은 제2 디바이스 상에서 실행되는 애플리케이션 프로그램에 의해 생성된 디스플레이 데이터를 표현함 ― 을 수신하는 것에 대응하여 플레이백 데이터 구조를 생성하는 백그라운드 프로토콜 엔진; 및

    상기 기록된 스트림을 수신하고, 상기 백그라운드 프로토콜 엔진에 의해 생성된 상기 플레이백 데이터 구조에 대응하여 상기 기록된 스트림을 렌더링하는 포그라운드 프로토콜 엔진을 포함하는,

    기록된 세션 렌더링 시스템.
14. 제 13 항에 있어서,

    상기 백그라운드 프로토콜 엔진은, 상기 포그라운드 프로토콜 엔진이 상기 기록된 스트림을 렌더링하는 것과 거의 동시에 상기 플레이백 데이터 구조를 생성하는, 기록된 세션 렌더링 시스템.
15. 제 13 항에 있어서,

    상기 포그라운드 프로토콜 엔진은 상기 제1 디바이스에 상주하는, 기록된 세션 렌더링 시스템.
16. 제 13 항에 있어서,

    상기 백그라운드 프로토콜 엔진은 상기 기록된 스트림내의 적어도 하나의 패킷을 렌더링하기 위한 적어도 하나의 인스트럭션을 상기 플레이백 데이터 구조에 저장하는 것을 더 포함하는, 기록된 세션 렌더링 시스템.
17. 제 13 항에 있어서,

    상기 백그라운드 프로토콜 엔진은 메타데이터(metadata)를 상기 플레이백 데이터 구조에 저장하는 것을 더 포함하는, 기록된 세션 렌더링 시스템.
18. 제 13 항에 있어서,

    상기 백그라운드 프로토콜 엔진은 상기 기록된 세션내의 적어도 하나의 패킷을 렌더링하는 시간을 표시하는 레코드를 상기 플레이백 데이터 구조에 저장하는 것을 더 포함하는, 기록된 세션 렌더링 시스템.
19. 제 13 항에 있어서,

    상기 포그라운드 프로토콜 엔진은 상기 기록된 세션내 적어도 하나의 패킷을 인간이 지각할 수 있는 방식으로 버퍼에 렌더링하는, 기록된 세션 렌더링 시스템.
20. 제 13 항에 있어서,

    상기 포그라운드 프로토콜 엔진은 상기 기록된 세션내의 적어도 하나의 패킷을 버퍼에 렌더링하는, 기록된 세션 렌더링 시스템.
21. 기록된 세션을 렌더링하기 위한 플레이백 인스트럭션을 생성하는 방법으로서,

    (a) 기록된 세션 ― 상기 기록된 세션은 애플리케이션 프로그램에 의해 생성된 디스플레이 데이터를 표현하는 복수의 패킷을 포함함 ― 내의 패킷에 의해 저장된 입력의 유형을 식별하는 단계;

    (b) 상기 입력의 유형에 대응하여 상기 패킷을 마킹하는 단계; 및

    (c) 상기 마킹에 대응하여 상기 패킷의 콘텐츠를 렌더링하기 위한 목적지를 플레이백 데이터 구조에 저장하는 단계를 포함하는,

    플레이백 인스트럭션 생성 방법.
22. 제 21 항에 있어서,

    단계(a)는 입력 디바이스로부터의 입력으로서 입력의 유형을 식별하는 것을 더 포함하는, 플레이백 인스트럭션 생성 방법.
23. 제 21 항에 있어서,

    단계(a)는 키보드 입력으로서 입력의 유형을 식별하는 것을 더 포함하는, 플레이백 인스트럭션 생성 방법.
24. 제 21 항에 있어서,

    단계(a)는 명령어(command)로서 입력의 유형을 식별하는 것을 더 포함하는, 플레이백 인스트럭션 생성 방법.
25. 제 21 항에 있어서,

    단계(b)는 정책에 대응하여 상기 패킷을 마킹하는 것을 더 포함하는, 플레이백 인스트럭션 생성 방법.
26. 제 21 항에 있어서,

    단계(c)는 상기 마킹된 패킷의 콘텐츠를 지각할 수 있는 방식으로 버퍼에 렌더링하기 위한 인스트럭션을 플레이백 데이터 구조에 저장하는 것을 더 포함하는, 플레이백 인스트럭션 생성 방법.
27. 제 21 항에 있어서,

    단계(c)는 상기 마킹된 패킷의 콘텐츠를 버퍼에 렌더링하기 위한 인스트럭션 을 상기 플레이백 데이터 구조에 저장하는 것을 더 포함하는, 플레이백 인스트럭션 생성 방법.
28. 기록된 세션을 렌더링하는데 있어서 무활동의 기간(period of inactivity)을 삭제하는 방법으로서,

    (a) 기록된 세션 ― 상기 기록된 세션은 디스플레이 데이터를 표현하는 복수의 패킷을 포함함 ― 내의 제1 패킷을 식별하는 단계;

    (b) 상기 기록된 세션내에서, 상기 제1 패킷을 바로 앞서는 제2 패킷을 식별하는 단계;

    (c) 상기 제1 패킷과 상기 제2 패킷간의 제1 시간 간격을 결정하는 단계;

    (d) 상기 제1 시간 간격이 임계를 초과하는 지에 대해 결정하는 단계; 및

    (e) 상기 제1 패킷과 상기 제2 패킷 사이에서 제2 시간 간격 ― 상기 제2 시간 간격은 상기 제1 시간 간격보다 짧은 시간 간격을 포함함 ― 을 이용하여 상기 기록된 세션의 콘텐츠를 렌더링하는 단계를 포함하는,

    무활동 기간 삭제 방법.
29. 제 28 항에 있어서,

    단계(e)는 상기 제1 패킷과 상기 제2 패킷 사이에서 상기 제2 시간 간격을 이용하여 상기 기록된 세션의 콘텐츠를 렌더링하기 위한 표시를 플레이백 데이터 구조에 저장하는 것을 더 포함하는, 무활동 기간 삭제 방법.
30. 제 28 항에 있어서,

    상기 기록된 세션내에서, 상기 제1 패킷을 바로 뒤따르는 제2 패킷을 식별하는 것을 더 포함하는, 무활동 기간 삭제 방법.
31. 기록된 세션을 렌더링하는데 있어서 의미 있는 활동(activity)을 포함하는 기간을 삭제하는 방법으로서,

    (a) 기록된 세션내 ― 상기 기록된 세션은 디스플레이 데이터를 표현하는 복수의 패킷을 포함함 ― 에서 마킹된 패킷과 이와 최근접한 이전의 마킹된 패킷간의 제1 시간 간격을 결정하는 단계;

    (b) 상기 제1 시간 간격이 임계를 초과하는 것을 결정하는 단계; 및

    (c) 상기 마킹된 패킷과 상기 최근접한 이전의 마킹된 패킷 사이의 제2 시간 간격 ― 상기 제2 시간 간격은 상기 제1 시간 간격보다 짧은 시간 간격을 포함함 ― 을 이용하여 상기 기록된 세션의 콘텐츠를 렌더링하는 단계를 포함하는,

    기간 삭제 방법.
32. 제 31 항에 있어서,

    단계(c)는 상기 마킹된 패킷과 이전의 패킷 사이의 제2 시간 간격 ― 상기 제2 시간 간격은 상기 제1 시간 간격보다 짧은 시간 간격을 포함함 ― 을 이용하여 상기 기록된 세션의 콘텐츠를 렌더링하는 것을 더 포함하는, 기간 삭제 방법.
33. 제 31 항에 있어서,

    단계(c)는 상기 마킹된 패킷과 상기 마킹된 패킷을 후속하는 패킷 사이의 상기 제2 시간 간격 ― 상기 제2 시간 간격은 상기 제1 시간 간격보다 짧은 시간 간격을 포함함 ― 을 이용하여 상기 기록된 세션의 패킷을 렌더링하는 것을 더 포함하는, 기간 삭제 방법.
34. 기록된 세션을 렌더링하는데 있어서 그래픽 업데이트를 삭제하는 방법으로서,

    (a) 기록된 세션내에서, 애플리케이션 프로그램에 의해 생성된 디스플레이 데이터를 표현하는 패킷 ― 상기 패킷은 제1 그래픽 업데이트를 포함함 ― 을 식별하는 단계;

    (b) 상기 제1 그래픽 업데이트에 의해 영향을 받은 스크린 영역을 결정하는 단계;

    (c) 상기 제1 그래픽 업데이트 후의 상기 스크린 영역의 상태와 상기 스크린 영역의 위치의 표시를 저장하는 단계;

    (d) 시간 간격내에서 상기 스크린 영역에 영향을 미치는 제2 그래픽 영역을 식별하는 단계;

    (e) 상기 제2 그래픽 업데이트 후의 상기 스크린 영역의 상태가 상기 제1 그래픽 업데이트 후의 상기 스크린 영역의 상태와 다른 지 여부에 대응하여, 상기 스크린 영역에 영향을 미치는 상기 제2 그래픽 업데이트 포함 제2 패킷을 렌더링하기 위한 목적지를 플레이백 데이터 구조에 표현하는 단계; 및

    (f) 제2 그래픽 업데이트 후의 상기 스크린 영역의 상태가 상기 제1 그래픽 업데이트 후의 상기 스크린 영역의 상태와 다른 지 여부에 대응하여, 상기 스크린 영역에 영향을 미치는 상기 제2 그래픽 업데이트 포함 제2 패킷과 관련된 렌더링 시간 간격을 플레이백 데이터에 표시하는 단계를 포함하는,

    그래픽 업데이트 삭제 방법.
35. 제 34 항에 있어서,

    단계(b)는 복수의 패킷내에 포함되는 그래픽 업데이트를 식별하는 것을 더 포함하는, 그래픽 업데이트 삭제 방법.
36. 제 34 항에 있어서,

    단계(b)는 상기 식별된 복수의 패킷내의 각각의 패킷에 의해 저장된 그래픽 업데이트에 대응하여 영향을 받는 스크린 영역을 결정하는 것을 더 포함하는, 그래픽 업데이트 삭제 방법.
37. 제 34 항에 있어서,

    단계(c)는 상기 그래픽 업데이트에 의해 영향을 받은 상기 스크린 영역의 카피를 저장하는 것을 더 포함하는, 그래픽 업데이트 삭제 방법.
38. 제 34 항에 있어서,

    단계(d)는 인간 범위 순환 주기(human scale cyclic period)의 대략 상한으로 정의되는 시간 간격을 더 포함하는, 그래픽 업데이트 삭제 방법.
39. 제 34 항에 있어서,

    단계(e)는 상기 백그라운드 프로토콜 엔진에 의해서, 상기 패킷의 콘텐츠를 지각할 수 있는 방식으로 버퍼에 렌더링하는 것을 플레이백 데이터 구조에 표시하 는 것을 더 포함하는, 그래픽 업데이트 삭제 방법.
40. 제 34 항에 있어서,

    단계(e)는 상기 패킷의 콘텐츠를 버퍼에 렌더링하는 것을 플레이백 데이터 구조에 표시하는 것을 더 포함하는, 그래픽 업데이트 삭제 방법.
41. 기록된 세션을 렌더링하는데 있어서 상호작용 시퀀스를 삭제하는 방법으로서,

    (a) 정책에 대응하여, 적어도 하나의 패킷의 상호작용 시퀀스의 시작을 식별하는 단계;

    (b) 상기 상호작용 시퀀스가 버퍼에 렌터링되어야 함을 플레이백 데이터 구조에 표시하는 단계;

    (c) 상호작용 시퀀스의 종료를 식별하는 단계;

    (d) 식별된 상기 상호작용 시퀀스의 시작을 앞서는 패킷과, 식별된 상기 상호작용 시퀀의 종료를 후속하는 패킷간의 제1 시간 간격을 식별하는 단계; 및

    (e) 상기 제1 시간 간격보다 짧은 제2의 랜더링 시간 간격을 플레이백 데이터 구조에 표시하는 단계를 포함하는,

    상호작용 시퀀스 삭제 방법.
42. 제 41 항에 있어서,

    상기 상호작용 시퀀스는 로그-온 시퀀스를 포함하는, 상호작용 시퀀스 삭제 방법.
43. 제 41 항에 있어서,

    상기 상호작용 시퀀스는 로그-오프 시퀀스를 포함하는, 상호작용 시퀀스 삭제 방법.
44. 제 41 항에 있어서,

    정책은 상기 상호작용 시퀀스를 정의하는, 상호작용 시퀀스 삭제 방법.
45. 제 41 항에 있어서,

    단계(a)는 시각 마커(visual marker)를 식별함으로써 상기 상호작용의 시퀀스의 시작을 식별하는 것을 더 포함하는, 상호작용 시퀀스 삭제 방법.
46. 제 41 항에 있어서,

    단계(a)는 상호작용 시퀀스의 시작 시간을 결정하는 것에 의해 상기 상호작용 시퀀스의 시작을 식별하는 것을 더 포함하는, 상호작용 시퀀스 삭제 방법.
47. 제 41 항에 있어서,

    단계(a)는 입력 포커스를 갖는 윈도우를 식별하는 것에 대응하여 상기 상호작용 시퀀스의 시작을 식별하는 것을 더 포함하는, 상호작용 시퀀스 삭제 방법.
48. 제 41 항에 있어서,

    단계(c)는 시각 마커를 식별하여 상기 상호작용 시퀀스의 종료를 식별하는 것을 더 포함하는, 상호작용 시퀀스 삭제 방법.
49. 제 41 항에 있어서,

    단계(c)는 상호작용 시퀀스의 종료 시각을 결정하는 것에 의해 상기 상호작용 시퀀스의 종료를 식별하는 것을 더 포함하는, 상호작용 시퀀스 삭제 방법.
50. 제 41 항에 있어서,

    단계(c)는 입력 포커스를 갖는 윈도우를 식별하는 것에 대응하여 상기 상호작용 시퀀스의 종료를 식별하는 것을 더 포함하는, 상호작용 시퀀스 삭제 방법.
51. 기록된 컴퓨터 세션을 렌더링하는데 있어서 자동 시간 워프되는 플레이백 방법(method of automatic time-warped playback)으로서,

    (a) 백그라운드 프로토콜 엔진에 의해서, 기록된 세션 ― 상기 기록된 세션은 복수의 패킷을 포함하며 디스플레이 데이터를 표현함 ― 을 수신하는 단계;

    (b) 상기 백그라운드 프로토콜 엔진에 의해서, 상기 복수의 패킷의 적어도 일부가 표현하는 복잡도(measure of complexity)를 결정하는 단계;

    (c) 상기 백그라운드 프로토콜 엔진에 의해서, 상기 기록된 세션내 복수의 패킷의 적어도 일부들간의 시간의 간격을 확인하는 단계;

    (d) 상기 백그라운드 프로토콜 엔진에 의해서, 상기 기록된 세션내 복수의 패킷의 상기 적어도 일부가 표현하는 복잡도에 대응하여 상기 시간의 간격을 조절하는 단계;

    (e) 상기 백그라운드 프로토콜 엔진에 의해서, 조절된 상기 시간의 간격을 플레이백 데이터 구조(playback data structure)에 저장하는 단계; 및

    (f) 포그라운드 프로토콜 엔진에 의해서, 상기 플레이백 데이터 구조에 대응 하여 상기 기록된 스트림을 렌더링하는 단계를 포함하는,

    자동 시간 워프형 플레이백 방법.
52. 제 51 항에 있어서,

    단계(b)는 키보드 입력에서 가능성이 있는 타이핑의 시퀀스를 식별하는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
53. 제 52 항에 있어서,

    단계(b)는 포함되는 적어도 일 유형의 키를 검사(inspecting)하는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
54. 제 51 항에 있어서,

    단계(b)는 키보드 입력에서 가능성이 있는 타이핑의 시퀀스를 관찰적 근사(heuristic approximation)하기 위하여 렌더링되는 적어도 하나의 표지(glyph)의 시퀀스를 검사하는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
55. 제 51 항에 있어서,

    단계(b)는 마우스 입력의 속도를 식별하는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
56. 제 51 항에 있어서,

    단계(b)는 그래픽 업데이트의 복잡도의 관찰적 근사를 식별하는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
57. 제 51 항에 있어서,

    단계(b)는 상기 기록된 세션내 복수의 패킷의 적어도 일부에서 제1 마커(first marker)를 식별하는 단계를 더 포함하며, 상기 마커는 상기 기록된 세션내 복수의 패킷의 상기 적어도 일부에서 시작 패킷을 표시하는, 자동 시간 워프형 플레이백 방법.
58. 제 57 항에 있어서,

    단계(d)는 상기 제1 마크에 대응하여 상기 시간의 간격을 조절하는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
59. 제 57 항에 있어서,

    단계(d)는 상기 기록된 세션내에서 상기 복수의 패킷의 적어도 일부 중 제2 패킷에서 제2 마커를 식별하는 단계를 더 포함하며, 상기 제2 마커는 상기 기록된 세션내 상기 복수의 패킷의 상기 적어도 일부 중 마지막 패킷을 표시하며 상기 제1 마커와 상기 제2 마커 사이의 시간의 간격에 대응하여 그 시간의 간격을 조절하는, 자동 시간 워프형 플레이백 방법.
60. 제 51 항에 있어서,

    단계(d)는 상기 시간의 간격을 감소시키는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
61. 제 51 항에 있어서,

    단계(d)는 상기 시간의 간격을 조절하는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
62. 제 51 항에 있어서,

    단계(d)는 요청에 대응하여 상기 시간의 간격을 조절하는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
63. 기록된 컴퓨터 세션을 렌더링하는데 있어서 자동 시간 워프형 플레이백 방법으로서,

    (a) 복수의 패킷을 포함하며 디스플레이 데이터를 표현하는 기록된 세션을 수신하는 단계;

    (b) 포커스를 갖는 윈도우 ― 상기 윈도우는 애플리케이션을 표시함 ― 를 표현하는 콘텐츠를 갖는 제1 패킷을 식별하는 단계;

    (c) 상기 제1 패킷의 콘텐츠를 렌더링하기 이전에 그 콘텐츠가 렌더링되는 제2 패킷과 상기 제1 패킷의 콘텐츠를 렌더링한 이후에 그 콘텐츠가 렌더링되는 제3 패킷간의 시간 간격을 식별하는 단계;

    (d) 상기 표시된 애플리케이션에 대응하여 식별된 상기 시간 간격을 조절하는 단계; 및

    (e) 상기 조절에 대응하여 상기 기록된 스트림내의 적어도 하나의 패킷을 렌더링하는 단계를 포함하는,

    자동 시간 워프형 플레이백 방법.
64. 제 63 항에 있어서,

    단계(d)는 상기 식별된 시간 간격을 증가시키는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
65. 제 63 항에 있어서,

    단계(d)는 상기 식별된 시간 간격을 감소시키는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
66. 제 63 항에 있어서,

    단계(e)는 상기 기록된 스트림내 상기 적어도 하나의 패킷을 버퍼에 렌더링하는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
67. 제 63 항에 있어서,

    단계(e)는 상기 기록된 스트림내 상기 적어도 하나의 패킷을 버퍼에 지각할 수 있는 방식으로 렌더링하는 단계를 더 포함하는, 자동 시간 워프형 플레이백 방법.
68. 기록된 컴퓨터 세션을 렌더링하는데 있어서 자동 시간-워프되는 플레이백 시스템으로서,

    기록된 스트림 ― 상기 기록된 스트림은 복수의 패킷을 포함함 ― 을 수신하는 것에 대응하여 플레이백 데이터 구조를 생성하며, 상기 생성된 플레이백 데이터 구조에 대응하여 상기 기록된 스트램내 적어도 하나의 패킷을 렌더링하는 프로토콜 엔진을 포함하는, 자동 시간-워프형 플레이백 시스템.
69. 제 68 항에 있어서,

    상기 프로토콜 엔진은 상기 기록된 스트림을 렌더링하기 위한 적어도 하나의 인스트럭션을 상기 플레이백 데이터 구조에 저장하는 것을 더 포함하는, 자동 시간-워프형 플레이백 시스템.
70. 제 69 항에 있어서,

    상기 프로토콜 엔진은 상기 플레이백 데이터 구조에 메타데이터(metadata)를 저장하는 것을 더 포함하는, 자동 시간-워프형 플레이백 시스템.
71. 제 68 항에 있어서,

    상기 프로토콜 엔진은 상기 기록된 세션내의 상기 적어도 하나의 패킷을 지각할 수 있는 방식으로 버퍼에 렌더링하는, 자동 시간-워프형 플레이백 시스템.
72. 제 68 항에 있어서,

    상기 프로토콜 엔진은 상기 기록된 세션내의 상기 적어도 하나의 패킷을 버퍼에 렌더링하는, 자동 시간-워프형 플레이백 시스템.
73. 제 68 항에 있어서,

    제2 프로토콜 엔진은 상기 생성된 플레이백 데이터 구조에 대응하여 상기 기록된 스트림내의 상기 적어도 하나의 패킷을 렌더링하는, 자동 시간-워프형 플레이백 시스템.

Images