cmd/gapit/inputs.go - platform/tools/gpu - Git at Google

 // Copyright (C) 2016 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package main

 import (
 	"fmt"
 	"io"
 	"io/ioutil"
 	"math"
 	"os"
 	"regexp"
 	"strconv"
 	"strings"
 	"sync"
 	"time"

 	"android.googlesource.com/platform/tools/gpu/client/adb"
 	"android.googlesource.com/platform/tools/gpu/framework/log"
 	"android.googlesource.com/platform/tools/gpu/framework/task"
 )

 // The input file is essentially a sparse table of integer values.
 type inputProperty string
 type inputEvent map[inputProperty]int
 type inputEvents []inputEvent

 var inputProperties []inputProperty

 func registerInputPropery(prop string) inputProperty {
 	inputProperties = append(inputProperties, inputProperty(prop))
 	return inputProperty(prop)
 }

 var (
 	// Display dimensions
 	kOrientation = registerInputPropery("orientation")
 	kWidth       = registerInputPropery("width")
 	kHeight      = registerInputPropery("height")
 	// Touch-screen dimensions
 	kMinX = registerInputPropery("minX")
 	kMaxX = registerInputPropery("maxX")
 	kMinY = registerInputPropery("minY")
 	kMaxY = registerInputPropery("maxY")
 	// Frame statistics
 	kTime          = registerInputPropery("time")
 	kFrame         = registerInputPropery("frame")
 	kDrawsPerFrame = registerInputPropery("drawsPerFrame")
 	// Screen tap/swipe
 	kX       = registerInputPropery("x")
 	kY       = registerInputPropery("y")
 	kPressed = registerInputPropery("pressed")
 	// End of recording
 	kEnd = registerInputPropery("end")
 )

 func writeEvent(out io.Writer, event inputEvent) {
 	var line []string
 	for _, name := range inputProperties {
 		if value, ok := event[name]; ok {
 			line = append(line, fmt.Sprintf("%s:%v", name, value))
 		}
 	}
 	fmt.Fprintf(out, "%s\n", strings.Join(line, " "))
 }

 func parseEvent(line string) (inputEvent, error) {
 	input := inputEvent{}
 	for _, kvp := range strings.Split(line, " ") {
 		if kvp != "" {
 			parts := strings.Split(kvp, ":")
 			if len(parts) == 2 {
 				name := inputProperty(parts[0])
 				value, err := strconv.Atoi(parts[1])
 				if err != nil {
 					return nil, err
 				}
 				input[name] = value
 			} else {
 				return nil, fmt.Errorf("Failed to parse key-value pair: '%s'", kvp)
 			}
 		}
 	}
 	return input, nil
 }

 // Implementation of the Writer interface which forwards the text to a lambda.
 type lambdaWriter struct {
 	f func(s string)
 }

 func (w *lambdaWriter) Write(p []byte) (n int, err error) {
 	w.f(string(p))
 	return len(p), nil
 }

 func atoi(s string) int {
 	v, err := strconv.Atoi(s)
 	if err != nil {
 		panic(err)
 	}
 	return v
 }

 type frameInfo struct{ frame, drawsPerFrame int }

 // Monitor logcat and parse frame statistics.
 func monitorFrameStatistics(ctx log.Context, d adb.Device, out chan frameInfo) {
 	re := regexp.MustCompile("NumFrames:([0-9]+).*NumDrawsPerFrame:([0-9]+)")
 	stdout := &lambdaWriter{f: func(s string) {
 		for _, match := range re.FindAllStringSubmatch(s, -1) {
 			out <- frameInfo{frame: atoi(match[1]), drawsPerFrame: atoi(match[2])}
 		}
 	}}
 	d.Command("logcat", "-T", "1", "-s", "GAPID:I").Capture(stdout, nil).Run(ctx)
 	close(out)
 }

 type currentFrameInfo struct {
 	value frameInfo
 	mutex sync.Mutex
 }

 // Observe channel and make copy of the most recent value.
 // We need to make copy of the channel to observe it.
 func (info *currentFrameInfo) update(in <-chan frameInfo, out chan frameInfo) {
 	for v := range in {
 		info.mutex.Lock()
 		info.value = v
 		info.mutex.Unlock()
 		if out != nil {
 			out <- v
 		}
 	}
 	if out != nil {
 		close(out)
 	}
 }

 func (info *currentFrameInfo) get() frameInfo {
 	info.mutex.Lock()
 	v := info.value
 	info.mutex.Unlock()
 	return v
 }

 // Write frame statistics into a file (rate limited).
 func recordFrameStatistics(out io.Writer, in <-chan frameInfo) {
 	const rate_limit = 10
 	const min_change = 0.2
 	startTime := time.Now()
 	nextFrame, lastDrawsPerFrame := 0, 0
 	for info := range in {
 		// Emit statistics only if the number of draws changed significantly
 		// and if it has been at least couple of frame since last time.
 		change := float64(info.drawsPerFrame+1)/float64(lastDrawsPerFrame+1) - 1.0
 		if info.frame >= nextFrame && math.Abs(change) >= min_change {
 			t := int(time.Now().Sub(startTime).Seconds() * 1000)
 			writeEvent(out, inputEvent{kTime: t, kFrame: info.frame, kDrawsPerFrame: info.drawsPerFrame})
 			nextFrame = info.frame + rate_limit
 			lastDrawsPerFrame = info.drawsPerFrame
 		}
 	}
 }

 type touchInfo struct{ x, y, pressed int }

 // Monitor and parse touch screen events.
 func monitorTouchScreen(ctx log.Context, d adb.Device, out chan touchInfo) {
 	x, y, pressed := 0, 0, 0
 	stdout := &lambdaWriter{f: func(s string) {
 		for _, line := range strings.Split(s, "\n") {
 			var device_id, value int
 			var event_type, event_code string
 			if _, err := fmt.Sscanf(line, "/dev/input/event%d: %s %s %x",
 				&device_id, &event_type, &event_code, &value); err == nil {
 				switch {
 				case event_type == "EV_ABS" && event_code == "ABS_MT_POSITION_X":
 					x, pressed = value, 1
 				case event_type == "EV_ABS" && event_code == "ABS_MT_POSITION_Y":
 					y, pressed = value, 1
 				case event_type == "EV_SYN" && event_code == "SYN_REPORT":
 					out <- touchInfo{x: x, y: y, pressed: pressed}
 					pressed = 0
 				}
 			}
 		}
 	}}
 	d.Shell("getevent", "-l").Capture(stdout, nil).Run(ctx)
 	close(out)
 }

 // Write touch-screen events to file (rate limited).
 // The touch event will also include the most recent frame information.
 func recordTouchInfo(out io.Writer, currentInfo *currentFrameInfo, in <-chan touchInfo) {
 	const rate_limit = 10
 	startTime := time.Now()
 	wasPressed, nextPressedFrame := 0, 0
 	for info := range in {
 		frameInfo := currentInfo.get()
 		if wasPressed != info.pressed || (info.pressed == 1 && frameInfo.frame >= nextPressedFrame) {
 			wasPressed = info.pressed
 			t := int(time.Now().Sub(startTime).Seconds() * 1000)
 			writeEvent(out, inputEvent{kTime: t,
 				kFrame: frameInfo.frame, kDrawsPerFrame: frameInfo.drawsPerFrame,
 				kX: info.x, kY: info.y, kPressed: info.pressed})
 			nextPressedFrame = frameInfo.frame + rate_limit
 		}
 	}
 }

 func startRecordingInputs(ctx log.Context, d adb.Device, filename string) (cleanup func(), err error) {
 	out, err := os.Create(filename)
 	if err != nil {
 		return nil, err
 	}
 	fmt.Fprintf(out, "# %s\n", strings.Join(os.Args, " "))

 	// Record screen dimensions
 	if orientation, width, height, ok := d.GetScreenDimensions(ctx); ok {
 		writeEvent(out, inputEvent{kOrientation: orientation, kWidth: width, kHeight: height})
 	}

 	// Record touch dimensions
 	if _, minX, maxX, minY, maxY, ok := d.GetTouchDimensions(ctx); ok {
 		writeEvent(out, inputEvent{kMinX: minX, kMaxX: maxX, kMinY: minY, kMaxY: maxY})
 	}

 	touchInfos := make(chan touchInfo, 256)
 	frameInfos := make(chan frameInfo, 256)
 	frameInfosCopy := make(chan frameInfo, 256)
 	stats := &currentFrameInfo{}

 	go monitorTouchScreen(ctx, d, touchInfos)
 	go monitorFrameStatistics(ctx, d, frameInfos)
 	go stats.update(frameInfos, frameInfosCopy)
 	go recordTouchInfo(out, stats, touchInfos)
 	go recordFrameStatistics(out, frameInfosCopy)

 	startTime := time.Now()
 	return func() {
 		t := int(time.Now().Sub(startTime).Seconds() * 1000)
 		writeEvent(out, inputEvent{kTime: t, kEnd: 1})
 	}, nil
 }

 func loadReplayInputs(filename string) (inputs inputEvents, err error) {
 	data, err := ioutil.ReadFile(filename)
 	if err != nil {
 		return nil, err
 	}
 	for _, line := range strings.Split(string(data), "\n") {
 		if !strings.HasPrefix(line, "#") {
 			input, err := parseEvent(line)
 			if err != nil {
 				return nil, err
 			}
 			inputs = append(inputs, input)
 		}
 	}
 	return
 }

 // Load given file and start replaying the user inputs.
 // 'eof' will be signalled when the end of file is reached.
 func startReplayingInputs(ctx log.Context, d adb.Device, replayInputsIn string, stop task.CancelFunc) error {
 	inputs, err := loadReplayInputs(replayInputsIn)
 	if err != nil {
 		return err
 	}
 	deviceId, _, maxX, _, maxY, ok := d.GetTouchDimensions(ctx)
 	if !ok {
 		return fmt.Errorf("Faild to get touchscreen dimensions")
 	}
 	stats := currentFrameInfo{}
 	frameInfos := make(chan frameInfo, 256)
 	go monitorFrameStatistics(ctx, d, frameInfos)
 	go stats.update(frameInfos, nil)
 	go func() {
 		ctx := ctx.Enter("Inputs")
 		info := ctx.Info().Logf
 		startTime := time.Now()
 		time_drift := time.Duration(0)
 		value_of := inputEvent{} // Keep track of most recent state.
 		for _, input := range inputs {
 			for k, v := range input {
 				value_of[k] = v
 			}
 			if target, ok := input[kTime]; ok {
 				// Wait for the minimum time
 				current := time.Now().Sub(startTime)
 				target := time.Duration(target)*time.Millisecond + time_drift
 				if current < target {
 					info("Wait until %.1fs", target.Seconds())
 					time.Sleep(target - current)
 				} else {
 					time_drift = time_drift + current - target
 					info("Time drift: %.1fs", time_drift.Seconds())
 				}
 			}
 			if target, ok := input[kFrame]; ok {
 				// Wait for the minimum frame
 				for stats.get().frame < target {
 					time_drift = time_drift + time.Second
 					info("Wait for more frames (%v seen, %v needed, %.1fs drift)",
 						stats.get().frame, target, time_drift.Seconds())
 					time.Sleep(time.Second)
 				}
 			}
 			if target, ok := input[kDrawsPerFrame]; ok {
 				// Wait for the minimum draw count
 				target = target - target/10 - 1
 				for stats.get().drawsPerFrame < target {
 					time_drift = time_drift + time.Second
 					info("Wait for more draws (%v seen, %v needed, %.1fs drift)",
 						stats.get().drawsPerFrame, target, time_drift.Seconds())
 					time.Sleep(time.Second)
 					target = target - target/10 - 1 // relax over time to ensure progress
 				}
 			}
 			if pressed, ok := input[kPressed]; ok {
 				// Press/release screen
 				x, y := input[kX]*maxX/value_of[kMaxX], input[kY]*maxY/value_of[kMaxY]
 				info("Touch: x:%v y:%v pressed:%v", x, y, pressed)
 				d.SendTouch(ctx, deviceId, x, y, pressed != 0)
 			}
 			if end, ok := input[kEnd]; ok && end == 1 {
 				stop()
 				return
 			}
 		}
 	}()
 	return nil
 }
	// Copyright (C) 2016 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package main

	import (
	"fmt"
	"io"
	"io/ioutil"
	"math"
	"os"
	"regexp"
	"strconv"
	"strings"
	"sync"
	"time"

	"android.googlesource.com/platform/tools/gpu/client/adb"
	"android.googlesource.com/platform/tools/gpu/framework/log"
	"android.googlesource.com/platform/tools/gpu/framework/task"
	)

	// The input file is essentially a sparse table of integer values.
	type inputProperty string
	type inputEvent map[inputProperty]int
	type inputEvents []inputEvent

	var inputProperties []inputProperty

	func registerInputPropery(prop string) inputProperty {
	inputProperties = append(inputProperties, inputProperty(prop))
	return inputProperty(prop)
	}

	var (
	// Display dimensions
	kOrientation = registerInputPropery("orientation")
	kWidth = registerInputPropery("width")
	kHeight = registerInputPropery("height")
	// Touch-screen dimensions
	kMinX = registerInputPropery("minX")
	kMaxX = registerInputPropery("maxX")
	kMinY = registerInputPropery("minY")
	kMaxY = registerInputPropery("maxY")
	// Frame statistics
	kTime = registerInputPropery("time")
	kFrame = registerInputPropery("frame")
	kDrawsPerFrame = registerInputPropery("drawsPerFrame")
	// Screen tap/swipe
	kX = registerInputPropery("x")
	kY = registerInputPropery("y")
	kPressed = registerInputPropery("pressed")
	// End of recording
	kEnd = registerInputPropery("end")
	)

	func writeEvent(out io.Writer, event inputEvent) {
	var line []string
	for _, name := range inputProperties {
	if value, ok := event[name]; ok {
	line = append(line, fmt.Sprintf("%s:%v", name, value))
	}
	}
	fmt.Fprintf(out, "%s\n", strings.Join(line, " "))
	}

	func parseEvent(line string) (inputEvent, error) {
	input := inputEvent{}
	for _, kvp := range strings.Split(line, " ") {
	if kvp != "" {
	parts := strings.Split(kvp, ":")
	if len(parts) == 2 {
	name := inputProperty(parts[0])
	value, err := strconv.Atoi(parts[1])
	if err != nil {
	return nil, err
	}
	input[name] = value
	} else {
	return nil, fmt.Errorf("Failed to parse key-value pair: '%s'", kvp)
	}
	}
	}
	return input, nil
	}

	// Implementation of the Writer interface which forwards the text to a lambda.
	type lambdaWriter struct {
	f func(s string)
	}

	func (w *lambdaWriter) Write(p []byte) (n int, err error) {
	w.f(string(p))
	return len(p), nil
	}

	func atoi(s string) int {
	v, err := strconv.Atoi(s)
	if err != nil {
	panic(err)
	}
	return v
	}

	type frameInfo struct{ frame, drawsPerFrame int }

	// Monitor logcat and parse frame statistics.
	func monitorFrameStatistics(ctx log.Context, d adb.Device, out chan frameInfo) {
	re := regexp.MustCompile("NumFrames:([0-9]+).*NumDrawsPerFrame:([0-9]+)")
	stdout := &lambdaWriter{f: func(s string) {
	for _, match := range re.FindAllStringSubmatch(s, -1) {
	out <- frameInfo{frame: atoi(match[1]), drawsPerFrame: atoi(match[2])}
	}
	}}
	d.Command("logcat", "-T", "1", "-s", "GAPID:I").Capture(stdout, nil).Run(ctx)
	close(out)
	}

	type currentFrameInfo struct {
	value frameInfo
	mutex sync.Mutex
	}

	// Observe channel and make copy of the most recent value.
	// We need to make copy of the channel to observe it.
	func (info *currentFrameInfo) update(in <-chan frameInfo, out chan frameInfo) {
	for v := range in {
	info.mutex.Lock()
	info.value = v
	info.mutex.Unlock()
	if out != nil {
	out <- v
	}
	}
	if out != nil {
	close(out)
	}
	}

	func (info *currentFrameInfo) get() frameInfo {
	info.mutex.Lock()
	v := info.value
	info.mutex.Unlock()
	return v
	}

	// Write frame statistics into a file (rate limited).
	func recordFrameStatistics(out io.Writer, in <-chan frameInfo) {
	const rate_limit = 10
	const min_change = 0.2
	startTime := time.Now()
	nextFrame, lastDrawsPerFrame := 0, 0
	for info := range in {
	// Emit statistics only if the number of draws changed significantly
	// and if it has been at least couple of frame since last time.
	change := float64(info.drawsPerFrame+1)/float64(lastDrawsPerFrame+1) - 1.0
	if info.frame >= nextFrame && math.Abs(change) >= min_change {
	t := int(time.Now().Sub(startTime).Seconds() * 1000)
	writeEvent(out, inputEvent{kTime: t, kFrame: info.frame, kDrawsPerFrame: info.drawsPerFrame})
	nextFrame = info.frame + rate_limit
	lastDrawsPerFrame = info.drawsPerFrame
	}
	}
	}

	type touchInfo struct{ x, y, pressed int }

	// Monitor and parse touch screen events.
	func monitorTouchScreen(ctx log.Context, d adb.Device, out chan touchInfo) {
	x, y, pressed := 0, 0, 0
	stdout := &lambdaWriter{f: func(s string) {
	for _, line := range strings.Split(s, "\n") {
	var device_id, value int
	var event_type, event_code string
	if _, err := fmt.Sscanf(line, "/dev/input/event%d: %s %s %x",
	&device_id, &event_type, &event_code, &value); err == nil {
	switch {
	case event_type == "EV_ABS" && event_code == "ABS_MT_POSITION_X":
	x, pressed = value, 1
	case event_type == "EV_ABS" && event_code == "ABS_MT_POSITION_Y":
	y, pressed = value, 1
	case event_type == "EV_SYN" && event_code == "SYN_REPORT":
	out <- touchInfo{x: x, y: y, pressed: pressed}
	pressed = 0
	}
	}
	}
	}}
	d.Shell("getevent", "-l").Capture(stdout, nil).Run(ctx)
	close(out)
	}

	// Write touch-screen events to file (rate limited).
	// The touch event will also include the most recent frame information.
	func recordTouchInfo(out io.Writer, currentInfo *currentFrameInfo, in <-chan touchInfo) {
	const rate_limit = 10
	startTime := time.Now()
	wasPressed, nextPressedFrame := 0, 0
	for info := range in {
	frameInfo := currentInfo.get()
	if wasPressed != info.pressed \|\| (info.pressed == 1 && frameInfo.frame >= nextPressedFrame) {
	wasPressed = info.pressed
	t := int(time.Now().Sub(startTime).Seconds() * 1000)
	writeEvent(out, inputEvent{kTime: t,
	kFrame: frameInfo.frame, kDrawsPerFrame: frameInfo.drawsPerFrame,
	kX: info.x, kY: info.y, kPressed: info.pressed})
	nextPressedFrame = frameInfo.frame + rate_limit
	}
	}
	}

	func startRecordingInputs(ctx log.Context, d adb.Device, filename string) (cleanup func(), err error) {
	out, err := os.Create(filename)
	if err != nil {
	return nil, err
	}
	fmt.Fprintf(out, "# %s\n", strings.Join(os.Args, " "))

	// Record screen dimensions
	if orientation, width, height, ok := d.GetScreenDimensions(ctx); ok {
	writeEvent(out, inputEvent{kOrientation: orientation, kWidth: width, kHeight: height})
	}

	// Record touch dimensions
	if _, minX, maxX, minY, maxY, ok := d.GetTouchDimensions(ctx); ok {
	writeEvent(out, inputEvent{kMinX: minX, kMaxX: maxX, kMinY: minY, kMaxY: maxY})
	}

	touchInfos := make(chan touchInfo, 256)
	frameInfos := make(chan frameInfo, 256)
	frameInfosCopy := make(chan frameInfo, 256)
	stats := &currentFrameInfo{}

	go monitorTouchScreen(ctx, d, touchInfos)
	go monitorFrameStatistics(ctx, d, frameInfos)
	go stats.update(frameInfos, frameInfosCopy)
	go recordTouchInfo(out, stats, touchInfos)
	go recordFrameStatistics(out, frameInfosCopy)

	startTime := time.Now()
	return func() {
	t := int(time.Now().Sub(startTime).Seconds() * 1000)
	writeEvent(out, inputEvent{kTime: t, kEnd: 1})
	}, nil
	}

	func loadReplayInputs(filename string) (inputs inputEvents, err error) {
	data, err := ioutil.ReadFile(filename)
	if err != nil {
	return nil, err
	}
	for _, line := range strings.Split(string(data), "\n") {
	if !strings.HasPrefix(line, "#") {
	input, err := parseEvent(line)
	if err != nil {
	return nil, err
	}
	inputs = append(inputs, input)
	}
	}
	return
	}

	// Load given file and start replaying the user inputs.
	// 'eof' will be signalled when the end of file is reached.
	func startReplayingInputs(ctx log.Context, d adb.Device, replayInputsIn string, stop task.CancelFunc) error {
	inputs, err := loadReplayInputs(replayInputsIn)
	if err != nil {
	return err
	}
	deviceId, _, maxX, _, maxY, ok := d.GetTouchDimensions(ctx)
	if !ok {
	return fmt.Errorf("Faild to get touchscreen dimensions")
	}
	stats := currentFrameInfo{}
	frameInfos := make(chan frameInfo, 256)
	go monitorFrameStatistics(ctx, d, frameInfos)
	go stats.update(frameInfos, nil)
	go func() {
	ctx := ctx.Enter("Inputs")
	info := ctx.Info().Logf
	startTime := time.Now()
	time_drift := time.Duration(0)
	value_of := inputEvent{} // Keep track of most recent state.
	for _, input := range inputs {
	for k, v := range input {
	value_of[k] = v
	}
	if target, ok := input[kTime]; ok {
	// Wait for the minimum time
	current := time.Now().Sub(startTime)
	target := time.Duration(target)*time.Millisecond + time_drift
	if current < target {
	info("Wait until %.1fs", target.Seconds())
	time.Sleep(target - current)
	} else {
	time_drift = time_drift + current - target
	info("Time drift: %.1fs", time_drift.Seconds())
	}
	}
	if target, ok := input[kFrame]; ok {
	// Wait for the minimum frame
	for stats.get().frame < target {
	time_drift = time_drift + time.Second
	info("Wait for more frames (%v seen, %v needed, %.1fs drift)",
	stats.get().frame, target, time_drift.Seconds())
	time.Sleep(time.Second)
	}
	}
	if target, ok := input[kDrawsPerFrame]; ok {
	// Wait for the minimum draw count
	target = target - target/10 - 1
	for stats.get().drawsPerFrame < target {
	time_drift = time_drift + time.Second
	info("Wait for more draws (%v seen, %v needed, %.1fs drift)",
	stats.get().drawsPerFrame, target, time_drift.Seconds())
	time.Sleep(time.Second)
	target = target - target/10 - 1 // relax over time to ensure progress
	}
	}
	if pressed, ok := input[kPressed]; ok {
	// Press/release screen
	x, y := input[kX]maxX/value_of[kMaxX], input[kY]maxY/value_of[kMaxY]
	info("Touch: x:%v y:%v pressed:%v", x, y, pressed)
	d.SendTouch(ctx, deviceId, x, y, pressed != 0)
	}
	if end, ok := input[kEnd]; ok && end == 1 {
	stop()
	return
	}
	}
	}()
	return nil
	}