av/parser/parser_test.go

/*
NAME
  parser_test.go

DESCRIPTION
  See Readme.md

AUTHOR
  Saxon Nelson-Milton <saxon@ausocean.org>

LICENSE
  parser_test.go is Copyright (C) 2017 the Australian Ocean Lab (AusOcean)

  It is free software: you can redistribute it and/or modify them
  under the terms of the GNU General Public License as published by the
  Free Software Foundation, either version 3 of the License, or (at your
  option) any later version.

  It is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 for more details.

  You should have received a copy of the GNU General Public License
  along with revid in gpl.txt.  If not, see http://www.gnu.org/licenses.
*/

package parser

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"strconv"
	"testing"
)

const (
	mjpegInputFileName = "testInput/testInput.avi"
	h264fName          = "../../test/test-data/av/input/betterInput.h264"
	nOfFrames          = 4
	outChanSize        = 100
)

func TestH264Parser(t *testing.T) {
	log.SetOutput(os.Stderr)
	log.Println("Opening input file!")
	inputFile, err := os.Open(h264fName)
	if err != nil {
		t.Errorf("Should not have got error opening file!")
		return
	}

	log.Println("Reading data from file!")
	data, err := ioutil.ReadAll(inputFile)
	if err != nil {
		t.Errorf("Should not have got read error!")
		return
	}

	// Create 'parser' and start it up
	log.Println("Creating parser!")
	parser := NewH264Parser()
	parser.SetOutputChan(make(chan []byte, outChanSize))
	parser.Start()

	for i, n := 0, 0; n <= nOfFrames; i++ {
		select {
		case parser.InputChan() <- data[i]:
		case frame := <-parser.OutputChan():
			path := fmt.Sprintf("testOutput/" + strconv.Itoa(n) + "h264_frame")
			out, err := os.Create(path)
			if err != nil {
				t.Errorf("Unexpected error creating %q: %v", path, err)
				return
			}
			out.Write(frame)
			out.Close()
			n++
		default:
		}
	}
}

/*
func TestMJPEGParser(t *testing.T) {
	log.Println("Opening input file!")
	// Open the input file
	inputFile, err := os.Open(testInputFileName)
	if err != nil {
		t.Errorf("Should not have got error opening file!")
	}
	log.Println("Getting file stats!")
	stats, err := inputFile.Stat()
	if err != nil {
		t.Errorf("Could not get input file stats!")
		return
	}
	log.Println("Creating space for file data!")
	data := make([]byte, stats.Size())
	_, err = inputFile.Read(data)
	if err != nil {
		t.Errorf("Should not have got read error!")
		return
	}
	log.Println("Creating parser!")
	parser := NewMJPEGParser(len(data) + 1)
	parser.SetOutputChan(make(chan []byte, 10000))
	parser.Start()
	log.Printf("len(data): %v\n", len(data))
	for i := range data {
		parser.GetInputChan() <- data[i]
	}
	log.Println("Writing jpegs to files!")
	for i := 0; len(parser.GetOutputChan()) > 0; i++ {
		// Open a new output file
		out, err := os.Create("testOutput/image" + strconv.Itoa(i) + ".jpeg")
		if err != nil {
			t.Errorf("Should not have got error creating output file!")
			return
		}
		out.Write(<-parser.GetOutputChan())
		out.Close()
	}
}
*/