Esempio n. 1
1
func getOutputLine(cmd *exec.Cmd) (string, error) {
	out, err := cmd.Output()
	if err != nil {
		return "", err
	}
	return strings.Trim(string(out), " \n\t\r"), nil
}
Esempio n. 2
0
func ShellExec(cmd *exec.Cmd) []byte {
	stdout, err := cmd.Output()
	if err != nil {
		log.Fatalln(err)
	}
	return stdout
}
Esempio n. 3
0
// Log returns an array of Commit objects, representing the history as like
// git log. Newest commit is at index zero, oldest at the end. Leave hashish
// as a blank string to get the default "git log" result.
func Log(path, hashish string) ([]*Commit, error) {
	logFormat := "%H" // Just the hashes
	var cmd *exec.Cmd

	if hashish == "" {
		cmd = command("git", "log", "--pretty="+logFormat)
	} else {
		cmd = command("git", "log", "--pretty="+logFormat, hashish)
	}
	cmd.Dir = path
	output, err := cmd.Output()
	if err != nil {
		return []*Commit{}, err
	}

	lineBytes := bytes.Split(output, []byte{'\n'})
	// The last split is just an empty string, right?
	lineBytes = lineBytes[0 : len(lineBytes)-1]
	commits := make([]*Commit, len(lineBytes))

	for x := 0; x < len(lineBytes); x++ {
		commit, commitErr := NewCommit(path, string(lineBytes[x]))
		if commitErr != nil {
			return []*Commit{}, commitErr
		}
		commits[x] = commit
	}

	return commits, nil
}
Esempio n. 4
0
File: main.go Progetto: kr/blog
func mustGetOutput(c *exec.Cmd) []byte {
	b, err := c.Output()
	if err != nil {
		panic(err)
	}
	return b
}
Esempio n. 5
0
/* Checks if the constants are equal to the ones in Python by running the python interpreter.
   Also exercises the New(), Join() and Encode() functions.
*/
func TestConstants(t *testing.T) {
	var shouldBeBytes []byte
	var cmd *exec.Cmd
	constants := []string{"ascii_letters", "ascii_lowercase", "ascii_uppercase", "digits", "hexdigits", "octdigits", "punctuation", "printable", "whitespace"}
	shouldbe := []string{ASCII_letters, ASCII_lowercase, ASCII_uppercase, Digits, HexDigits, OctDigits, Punctuation, Printable, Whitespace}
	for i, constant := range constants {
		// Make sure to use python3. Tested on Fedora and Arch Linux.
		cmd = exec.Command("python3", "-c", "import string; print(string."+constant+")")
		output, err := cmd.Output()
		if err != nil {
			/* One of the commands failed, assume Python is not available */
			// This can be used if one doesn't want to ignore the lack of python:
			//t.Errorf("execution failed: %s %s\n", New(" ").Join(cmd.Args), output)
			return
		}
		shouldBeBytes = New(shouldbe[i]).Encode()
		for i2, b := range shouldBeBytes {
			if (i2 >= len(output)) || (b != output[i2]) {
				if len(output) == 0 {
					output = New("no output").Encode()
				}
				t.Errorf("constant %s failed, got: %s\n", constants[i], output)
				return
			}
		}
	}
}
Esempio n. 6
0
// Utility Functions
func bExec(cmd exec.Cmd) (out []byte) {
	out, err := cmd.Output()
	if err != nil {
		log.Fatal(err)
	}
	return
}
Esempio n. 7
0
func pluginInfo(name string) (ver, short, long string) {
	if os.Getenv("HKPLUGINMODE") == "info" {
		return "", "plugin exec loop", "plugin exec loop"
	}
	short = "no description"
	long = name + ": unknown description"
	var cmd exec.Cmd
	cmd.Args = []string{name}
	cmd.Path = lookupPlugin(name)
	cmd.Env = append([]string{"HKPLUGINMODE=info"}, os.Environ()...)
	buf, err := cmd.Output()
	if err != nil {
		return
	}
	info := string(buf)
	if !strings.HasPrefix(info, name+" ") {
		return
	}
	info = info[len(name)+1:]
	i := strings.Index(info, ": ")
	if i < 0 {
		return
	}
	ver, info = info[:i], info[i+2:]
	i = strings.Index(info, "\n\n")
	if i < 0 || 50 < i || strings.Contains(info[:i], "\n") {
		return
	}
	short, long = info[:i], info[i+2:]
	return ver, strings.TrimSpace(short), strings.TrimSpace(long)
}
Esempio n. 8
0
func GetWireDefaultGateway() (net.IP, error) {
	var regex *regexp.Regexp
	var command *exec.Cmd

	switch runtime.GOOS {
	case "darwin":
		command = exec.Command("netstat", "-rn", "-f", "inet")
		regex = regexp.MustCompile(`default\s+(\d+\.\d+\.\d+\.\d+)\s+.*`)
	case "linux":
		command = exec.Command("ip", "-4", "route", "show")
		regex = regexp.MustCompile(`default\s+via\s+(\d+\.\d+\.\d+\.\d+)\s+.*`)
	default:
		return nil, fmt.Errorf("Getting gateway is not supported in %v", runtime.GOOS)
	}

	output, err := command.Output()
	if err != nil {
		return nil, err
	}
	if result := regex.FindSubmatch(output); result == nil {
		return nil, fmt.Errorf("Unable to get default gateway")
	} else {
		return net.ParseIP(string(result[1])), nil
	}
}
Esempio n. 9
0
func (spec SpecPackage) checkVersionPackageExact(defaults PlatformDefaults) (err error) {
	var cmd *exec.Cmd
	var verRex string

	switch spec.Type {
	case "homebrew":
		// sbt 0.12.3 0.12.4 0.13.0
		cmd = exec.Command("/usr/local/bin/brew", "ls", "--versions", spec.Name)
		verRex = " " + spec.Version + "( |$)"
	default:
		return errors.New("Unknown package manager type " + spec.Type)
	}

	out, err := cmd.Output()
	if err != nil {
		return err
	}

	re, err := regexp.Compile(verRex)
	if err != nil {
		return fmt.Errorf("Bad verRex %s for package manager type %s", verRex, spec.Type)
	}

	if re.FindIndex(out) == nil && !spec.Absent {
		return errors.New("No such version installed")
	}

	return nil
}
Esempio n. 10
0
File: gawp.go Progetto: sombr/gawp
func worker(throttle chan struct{}, wg *sync.WaitGroup, e fsnotify.Op, f string) {
	defer func() {
		<-throttle

		wg.Done()
	}()

	m := findMatch(e, f)

	if m == nil {
		return
	}

	// Atomicity for the given match
	m.mu.Lock()

	defer m.mu.Unlock()

	var cmd *exec.Cmd

	for i, c := range m.cmds {
		if len(c) == 1 {
			cmd = exec.Command(c[0])
		} else {
			cmd = exec.Command(c[0], c[1:]...)
		}

		if b, err := cmd.Output(); err != nil {
			log.Printf("command (%s) error: %s", c, err)
		} else if len(b) > 0 {
			log.Printf("%s\n%s", m.rule.cmds[i], b)
		}
	}
}
Esempio n. 11
0
// stem words and add them to vocabulary
func (vocabulary Dictionary) add(words []string, mode string) (wordIDs []int) {
	var lemma string
	wordIDs = make([]int, len(words))
	for idx, word := range words {
		if _, ok := vocabulary.Vtoi[word]; ok {
			wordIDs[idx] = vocabulary.Vtoi[word]
		} else {
			python := new(exec.Cmd)
			args := []string{"lemmatizer.py", "--vocabulary"}
			args = append(args, word)
			args = append(args, "--pos")
			args = append(args, mode)
			python.Args = args
			//       python.Path = "/home/lea/Code/Python/lemmatizer.py"
			python.Path = "/local/lea/thesis/python/lemmatizer.py"
			out, _ := python.Output()
			lemma = strings.Trim(string(out), "\n")
			if _, ok := vocabulary.Vtoi[lemma]; !ok {
				vocabulary.VList[vocabIdx] = lemma
				vocabulary.Vtoi[lemma] = vocabIdx
				vocabulary.Itov[vocabIdx] = lemma
				vocabulary.POSList[vocabIdx] = mode
				vocabIdx++
			}
			wordIDs[idx] = vocabulary.Vtoi[lemma]
		}
	}
	return wordIDs
}
Esempio n. 12
0
func Recon(pkgPath string) (pkgInfo *PkgInfo, err error) {
	var gitProgPath, pkgPathAbs string

	// Firstly look up if they've got Git
	gitProgPath, err = exec.LookPath("git")
	if err != nil {
		return
	}

	pkgPathAbs = goSrcify(pkgPath)

	args := []string{gitProgPath}
	args = append(args, prettyGitHashGetArgs...)

	cmd := exec.Cmd{
		Args: args,
		Dir:  pkgPathAbs,
		Path: gitProgPath,
	}

	var output []byte
	if output, err = cmd.Output(); err != nil {
		return
	}

	pkgInfo = &PkgInfo{
		CommitHash: string(output),
		OsInfo:     strings.Join([]string{runtime.GOOS, runtime.GOARCH}, "/"),
		GoVersion:  runtime.Version(),
	}

	return
}
Esempio n. 13
0
func executeCommand(targetPath string, command string) (logContent string, err error) {
	logBuffer := new(bytes.Buffer)
	defer func() {
		logContent = logBuffer.String()
	}()
	bufferLog(logBuffer, separator)
	bufferLog(logBuffer, "\nEntry into target Path: %s\n", targetPath)
	err = os.Chdir(targetPath)
	if err != nil {
		bufferLog(logBuffer, "ChdirError (%s): %s\n", targetPath, err)
		return "", err
	}
	cmdWithArgs := strings.Split(command, " ")
	var cmd *exec.Cmd
	cmdLength := len(cmdWithArgs)
	realCmd := cmdWithArgs[0]
	args := cmdWithArgs[1:cmdLength]
	bufferLog(logBuffer, "Execute command (cmd=%s, args=%s)...\n", realCmd, args)
	if cmdLength > 1 {
		cmd = exec.Command(realCmd, args...)
	} else {
		cmd = exec.Command(realCmd)
	}
	result, err := cmd.Output()
	if err != nil {
		bufferLog(logBuffer, "CmdRunError (cmd=%s, args=%v): %s\n", realCmd, args, err)
		return "", err
	}
	bufferLog(logBuffer, "Output: %v\n", string(result))
	return "", nil
}
Esempio n. 14
0
File: plugin.go Progetto: uriel/hk
func pluginInfo(name string) (ver, short, long string) {
	if os.Getenv("HKPLUGINMODE") == "info" {
		return "", "[plugin exec loop]", "[plugin exec loop]\n"
	}
	var cmd exec.Cmd
	cmd.Args = []string{name}
	cmd.Path = lookupPlugin(name)
	cmd.Env = append([]string{"HKPLUGINMODE=info"}, os.Environ()...)
	buf, err := cmd.Output()
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		return "", "[unknown description]", "[unknown description]\n"
	}
	info := string(buf)
	if !strings.HasPrefix(info, name+" ") {
		return "", "[unknown description]", "[unknown description]\n"
	}
	info = info[len(name)+1:]
	i := strings.Index(info, ": ")
	ver, info = info[:i], info[i+2:]
	i = strings.Index(info, "\n\n")
	short, long = info[:i], info[i+2:]
	if len(short) > 50 || strings.Contains(short, "\n") {
		return "", "[unknown description]", "[unknown description]\n"
	}
	return ver, short, long
}
Esempio n. 15
0
/**
 * Execute command inside shell on linux or windows
 */
func ExecShellScriptOrPanic(args string) string {
	var (
		shell string
		cmd   *exec.Cmd
	)

	switch runtime.GOOS {
	case "windows":
		shell = "cmd.exe"
		cmdArgs := []string{"/C", args}
		cmd = exec.Command(shell, cmdArgs...)
		break
	case "linux":
		shell = "bash"
		cmdArgs := []string{"-c", args}
		cmd = exec.Command(shell, cmdArgs...)
		break
	default:
		panic("Unsupported target OS, unable to exec command !")
		break
	}

	output, err := cmd.Output()
	if err != nil {
		panic(err)
	}
	return string(output)
}
Esempio n. 16
0
func getHostNS(configNSPath bool) (string, error) {
	//2. Get the namespaces on host
	/*
		ipc:[4026531839]
		mnt:[4026531840]
		mnt:[4026531856]
		mnt:[4026532129]
		net:[4026531956]
		net:[4026532265]
		pid:[4026531836]
		pid:[4026532263]
		user:[4026531837]
		user:[4026532227]
		uts:[4026531838]
	*/
	var cmd *exec.Cmd
	if configNSPath {
		cmd = exec.Command("/bin/sh", "-c", "readlink /proc/1/ns/* | sort -u")
	} else {
		cmd = exec.Command("/bin/sh", "-c", "readlink /proc/*/ns/* | sort -u")
	}

	out, err := cmd.Output()
	if err != nil {
		return "", err
	}

	str := strings.TrimSuffix(string(out), "\n")
	str = strings.TrimSpace(str)
	if str == "" {
		return "", errors.New("can not find namespace on host.")
	}
	return str, nil
}
Esempio n. 17
0
// getRevisionFromPath takes a path like /home/csparr/go/src/github.com/sparrc/gdm
// and the VCS Repository information and returns the currently checked out
// revision, ie, 759e96ebaffb01c3cba0e8b129ef29f56507b323
func getRevisionFromPath(fullpath string, root *vcs.RepoRoot) string {
	// Check that we have the executable available
	_, err := exec.LookPath(root.VCS.Cmd)
	if err != nil {
		fmt.Fprintf(os.Stderr, "gdm missing %s command.\n", root.VCS.Name)
		os.Exit(1)
	}

	// Determine command to get the current hash
	var cmd *exec.Cmd
	switch root.VCS.Cmd {
	case "git":
		cmd = exec.Command("git", "rev-parse", "HEAD")
	case "hg":
		cmd = exec.Command("hg", "id", "-i")
	case "bzr":
		cmd = exec.Command("bzr", "revno")
	default:
		fmt.Fprintf(os.Stderr, "gdm does not support %s\n", root.VCS.Cmd)
		os.Exit(1)
	}
	cmd.Dir = fullpath

	output, err := cmd.Output()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error getting revision hash at %s, %s\n",
			fullpath, err.Error())
		os.Exit(1)
	}
	return strings.TrimSpace(string(output))
}
Esempio n. 18
0
/*
GetCommandOutputString runs the given command, returning its output
as a string - or an error on failure.
*/
func GetCommandOutputString(command *exec.Cmd) (outputString string, err error) {
	bytes, err := command.Output()
	if err != nil {
		return "", err
	}

	return string(bytes), nil
}
Esempio n. 19
0
File: cmd.go Progetto: nodirt/ggt
// trimOutput runs the command and returns its stdout output with trimmed whitespace.
// if cmd.Stderr is not set, it is set to redStderr.
func trimOutput(cmd *exec.Cmd) (string, error) {
	if cmd.Stderr == nil {
		cmd.Stderr = redStderr
	}
	logCmd(cmd)
	out, err := cmd.Output()
	return strings.TrimSpace(string(out)), err
}
Esempio n. 20
0
func (repository *gitRepository) runGitCommand(cmd *exec.Cmd) (string, error) {
	cmd.Dir = repository.DirPath
	out, err := cmd.Output()
	if err != nil {
		return "", err
	}
	return strings.Trim(string(out), " \n"), nil
}
Esempio n. 21
0
File: pathutil.go Progetto: jq/kati
func wildcardGlob(pat string) ([]string, error) {
	// TODO(ukai): use find cache for glob if exists.
	pat = wildcardUnescape(pat)
	pattern := filepath.Clean(pat)
	if pattern != pat {
		// For some reason, go's Glob normalizes
		// foo/../bar to bar.
		i := strings.IndexAny(pattern, "*?[")
		if i < 0 {
			// no wildcard. if any files matched with pattern,
			// return pat.
			_, err := os.Stat(pat)
			if err != nil {
				return nil, nil
			}
			return []string{pat}, nil
		}
		if strings.Contains(pattern[i+1:], "..") {
			// We ask shell to expand a glob to avoid this.
			cmdline := []string{"/bin/sh", "-c", "/bin/ls -d " + pat}
			cmd := exec.Cmd{
				Path: cmdline[0],
				Args: cmdline,
			}
			// Ignore errors.
			out, _ := cmd.Output()
			ws := newWordScanner(out)
			var files []string
			for ws.Scan() {
				files = append(files, string(ws.Bytes()))
			}
			return files, nil
		}
		// prefix + meta + suffix, and suffix doesn't have '..'
		prefix := pattern[:i]
		i = strings.IndexAny(pat, "*?[")
		if i < 0 {
			return nil, fmt.Errorf("wildcard metachar mismatch? pattern=%q pat=%q", pattern, pat)
		}
		oprefix := pat[:i]
		matched, err := filepath.Glob(pattern)
		if err != nil {
			return nil, err
		}
		var files []string
		for _, m := range matched {
			file := oprefix + strings.TrimPrefix(m, prefix)
			_, err := os.Stat(file)
			if err != nil {
				continue
			}
			files = append(files, file)
		}
		return files, nil
	}
	return filepath.Glob(pat)
}
Esempio n. 22
0
// Run executes cmd with option STDIN
func (c DefaultCommander) Run(cmd *exec.Cmd) ([]byte, error) {
	out, err := cmd.Output()
	defer func() {
		// If this fails, there isn't much to do
		_ = cmd.Process.Kill()
	}()

	return out, err
}
Esempio n. 23
0
func configureTuntap(is_client bool, devName string) {
	// Set default IP address, if needed.
	if len(ipaddr) == 0 {
		if is_client {
			ipaddr = "10.93.0.2"
		} else {
			ipaddr = "10.93.0.1"
		}
	}

	// Need to run: ifconfig tunX 10.0.0.1 10.0.0.1 netmask 255.255.255.0 up
	var cmd *exec.Cmd
	if is_client {
		cmd = exec.Command("/sbin/ifconfig", devName, ipaddr, server_addr, "netmask", netmask, "up")
	} else {
		cmd = exec.Command("/sbin/ifconfig", devName, ipaddr, ipaddr, "netmask", netmask, "up")
	}

	out, err := cmd.Output()
	if err != nil {
		log.Printf("Error running configuration command: %s\n", err)
	} else {
		log.Printf("Configured successfully (output: '%s')\n", out)
	}

	// TODO: we should repeatedly check until the interface is up, rather than
	// just waiting for a given length
	<-time.After(1 * time.Second)

	// Get output of ifconfig.
	stat := exec.Command("/sbin/ifconfig")
	out, err = stat.Output()
	if err != nil {
		log.Printf("Error running status command: %s\n", err)
	} else {
		lines := strings.Split(string(out), "\n")

		var out_lines []string
		found := false
		for _, l := range lines {
			// We start grabbing at the tun device, and stop when we hit a blank line,
			// which indicates another device.
			if strings.HasPrefix(l, devName) {
				found = true
			} else if found && l == "" {
				found = false
			}

			if found {
				out_lines = append(out_lines, l)
			}
		}

		log.Printf("ifconfig output:\n%s", strings.Join(out_lines, "\n"))
	}
}
Esempio n. 24
0
File: func.go Progetto: zchee/kati
func (f *funcShell) Eval(w evalWriter, ev *Evaluator) error {
	err := assertArity("shell", 1, len(f.args))
	if err != nil {
		return err
	}
	abuf := newEbuf()
	err = f.args[1].Eval(abuf, ev)
	if err != nil {
		return err
	}
	if ev.avoidIO && !hasNoIoInShellScript(abuf.Bytes()) {
		te := traceEvent.begin("shell", tmpval(abuf.Bytes()), traceEventMain)
		ev.hasIO = true
		io.WriteString(w, "$(")
		w.Write(abuf.Bytes())
		writeByte(w, ')')
		traceEvent.end(te)
		abuf.release()
		return nil
	}
	arg := abuf.String()
	abuf.release()
	if bc, err := parseBuiltinCommand(arg); err != nil {
		glog.V(1).Infof("sh builtin: %v", err)
	} else {
		glog.Info("use sh builtin:", arg)
		glog.V(2).Infof("builtin command: %#v", bc)
		te := traceEvent.begin("sh-builtin", literal(arg), traceEventMain)
		bc.run(w)
		traceEvent.end(te)
		return nil
	}

	shellVar, err := ev.EvaluateVar("SHELL")
	if err != nil {
		return err
	}
	cmdline := []string{shellVar, "-c", arg}
	if glog.V(1) {
		glog.Infof("shell %q", cmdline)
	}
	cmd := exec.Cmd{
		Path:   cmdline[0],
		Args:   cmdline,
		Stderr: os.Stderr,
	}
	te := traceEvent.begin("shell", literal(arg), traceEventMain)
	out, err := cmd.Output()
	shellStats.add(time.Since(te.t))
	if err != nil {
		glog.Warningf("$(shell %q) failed: %q", arg, err)
	}
	w.Write(formatCommandOutput(out))
	traceEvent.end(te)
	return nil
}
Esempio n. 25
0
func CmdOutput(cmd *exec.Cmd) ([]byte, error) {
	bs := bytes.Buffer{}
	cmd.Stderr = &bs
	if output, err := cmd.Output(); err != nil {
		fmt.Printf("Error running %v %v:\n%v\n%v\n", cmd.Path, cmd.Args, string(output), string(bs.Bytes()))
		return nil, err
	} else {
		return output, nil
	}
}
Esempio n. 26
0
// commandOutput runs an exec.Cmd, builds for every line of the output
// a new Searchresult, and passes these into channel c.
func commandOutput(cmd *exec.Cmd, c chan []Searchresult) {
	out, _ := cmd.Output()
	res := make([]Searchresult, 0)
	split := strings.Split(string(out), "\n")
	for _, i := range split {
		sr := NewSearchResult(i)
		res = append(res, *sr)
	}
	c <- res
}
Esempio n. 27
0
func GetCmdOutput(cmd *exec.Cmd) (string, error) {
	buf := &bytes.Buffer{}
	cmd.Stderr = buf
	out, err := cmd.Output()
	if err != nil {
		return "", fmt.Errorf("External program '%s' failed (%s), with "+
			"output:\n%s", cmd.Args[0], err, buf.String())
	}
	return strings.TrimSpace(string(out)), nil
}
Esempio n. 28
0
func openBuf(data []byte, filetype string) (obuf []byte, err error) {
	p, err := exec.LookPath("sox")
	if err != nil {
		log.Fatalln("no sox installed!", err)
	}
	var c *exec.Cmd
	var reader io.Reader
	switch filetype {
	case "mp3":
		fallthrough
	case "wav":
		fallthrough
	case "ogg":
		fallthrough
	case "au":
		reader = bytes.NewReader(data)
	case "mp4":
		fallthrough
	case "m4a":
		// else write to tmpfile, then invoke sox, defer deletion of tmpfile. weak.
		w, err := mktemp(filetype)
		if err != nil {
			log.Println("couldn't make tmp file", err)
			return nil, err
		}

		defer func() { w.Close(); os.Remove(w.Name()) }()

		var n int
		n, err = w.Write(data)
		if n != len(data) {
			log.Println("couldn't write all data to tmp file!")
		}
		if err != nil {
			log.Println("couldn't write to tmp file", w.Name(), err)
			return nil, err
		}
		w.Seek(0, os.SEEK_SET)
		reader = w
	default:
		return nil, errors.New("unrecognized filetype")
	}

	// use samplerate from args, 16 bits, big endian, two channels
	c = exec.Command(p, "-t", filetype, "-", "-b", "16", "-c", "2", "-e", "signed-integer", "-t", "raw", "-r", strconv.Itoa(samplerate), "-B", "-")
	c.Stdin = reader
	errbuf := new(bytes.Buffer)
	c.Stderr = errbuf
	obuf, err = c.Output()
	if err != nil {
		log.Println("error running sox", err, string(errbuf.Bytes()))
		return nil, err
	}
	return
}
Esempio n. 29
0
func main() {
	fmt.Printf("GoHEVC Analyzer %v for HM\n\n", hevc.Version)

	if len(os.Args) == 3 {
		var cmd *exec.Cmd
		const refYUV = "temp.yuv"

		if os.Args[2] == "hm80" {
			cmd = exec.Command("TAppDecoder80", "-b", os.Args[1], "-o", refYUV)
		} else if os.Args[2] == "hm90" {
			cmd = exec.Command("TAppDecoder90", "-b", os.Args[1], "-o", refYUV)
		} else if os.Args[2] == "hm91" {
			cmd = exec.Command("TAppDecoder91", "-b", os.Args[1], "-o", refYUV)
		} else {
			fmt.Printf("Unsupported HM Version\n")
			return
		}
		fmt.Printf("Decoding %s", os.Args[1])

		out, err := cmd.Output()
		if err != nil {
			log.Fatal(err)
		} else {
			fmt.Printf("%s\n", out)

			fmt.Printf("\nAnalyzing %s\n", os.Args[1])

			traceFile, err := os.Open("TraceDec.txt")
			if err != nil {
				log.Fatal(err)
			}
			defer traceFile.Close()

			yuvFile, err := os.Open(refYUV)
			if err != nil {
				log.Fatal(err)
			}
			defer yuvFile.Close()

			var ha hevc.Analyzer

			if err = ha.ParseTrace(traceFile); err != nil {
				log.Fatal(err)
			} else {
				if err = ha.ParseYUV(yuvFile); err != nil {
					log.Fatal(err)
				} else {
					ha.ParseCmd(os.Args[1], bufio.NewReader(os.Stdin), string(out))
				}
			}
		}
	} else {
		fmt.Printf("Usage: gohevc.exe bitstream.265 hmversion(hm80/hm90/hm91)\n")
	}
}
Esempio n. 30
0
func runCheck(cmd *exec.Cmd, name string, context string) bool {
	log.Print("running: ", name)

	out, err := cmd.Output()
	if err != nil {
		log.Print("could not run command: ", err.Error())
	}

	// We assume a command ran correctly if there is no output
	return len(out) == 0
}