path: root/Gui.d

module Gui;

import gtkc.gtk;

import gtk.Main;
import gtk.MainWindow;
import gtk.Alignment;
import gtk.Button;
import gtk.ToggleButton;
import gtk.CheckButton;
import gtk.RadioButton;
import gtk.ComboBox;
import gtk.SpinButton;
import gtk.Label;
import gtk.Frame;
import gtk.HBox;
import gtk.VBox;
import gtk.Table;
import gtk.Widget;
import gtkc.gtktypes;
import glib.ListSG;
import tango.math.Math;

import tango.io.Stdout;

import BitrateCalculator;

void main(char[][] args)
{
	Main.init(args);
	new BitrateWindow();
	Main.run();
}

public class BitrateWindow : MainWindow
{
	VideoFrame  videoFrame;
	AudioFrame  audioFrame1;
	AudioFrame  audioFrame2;
	ComboBox    codecCombo;
	ComboBox    containCombo;
	RadioButton fileRadio;
	SpinButton  sizeKBSpin;
	SpinButton  sizeMBSpin;
	ComboBox    mediumCombo;
	RadioButton bitrRadio;
	SpinButton  bitrSpin;
	SpinButton  videoSizeKBSpin;
	SpinButton  videoSizeMBSpin;

	bool handlingEvents;

	this()
	{
		super("Bitrate Calculator");

		Initialize();
		CreateLayout();
		SetDefaults();
		SetEvents();

		showAll();
	}

	void Initialize()
	{
		//Video
		videoFrame = new VideoFrame;

		//Audio
		audioFrame1 = new AudioFrame("Audio 1");
		audioFrame2 = new AudioFrame("Audio 2");

		//Codec
		codecCombo = new ComboBox(true);
		foreach(char[] string; videoCodecs) codecCombo.appendText(string);

		//Container
		containCombo = new ComboBox(true);
		foreach(char[] string; containerTypes) containCombo.appendText(string);
		
		//Size
		fileRadio = new RadioButton(cast(ListSG)null, "File Size");
		sizeKBSpin = new SpinButton(0, int.max, 1);
		sizeMBSpin = new SpinButton(0, int.max, 1);
		mediumCombo = new ComboBox(true);
		foreach(char[] string; storageMediums) mediumCombo.appendText(string);

		//Results
		bitrRadio = new RadioButton(fileRadio, "Average Bitrate");
		bitrSpin = new SpinButton(0, int.max, 1);
		videoSizeKBSpin = new SpinButton(0, int.max, 1);
		videoSizeMBSpin = new SpinButton(0, int.max, 1);

		videoSizeKBSpin.setState(StateType.INSENSITIVE);
		videoSizeMBSpin.setState(StateType.INSENSITIVE);
	}

	void CreateLayout()
	{
		//Audio
		HBox audioBox = new HBox(false, 4);
		audioBox.add(audioFrame1);
		audioBox.add(audioFrame2);

		//Codec
		Frame codecFrame = new Frame("Codec");

		Alignment codecAlign = new Alignment(0, 0.5, 0.2, 0);
		codecAlign.setPadding(4, 4, 4, 4);
		codecAlign.add(codecCombo);

		codecFrame.add(codecAlign);

		//Container
		Frame containFrame = new Frame("Container");

		Alignment containAlign = new Alignment(0, 0.5, 0.2, 0);
		containAlign.setPadding(4, 4, 4, 4);
		containAlign.add(containCombo);

		containFrame.add(containAlign);

		//Size
		Frame sizeFrame = new Frame("Total size");
		Table sizeTable = new Table(3, 3, false);
		sizeTable.setRowSpacings(5);
		sizeTable.setColSpacings(5);

		Alignment sizeAlign = new Alignment(0, 0.5, 0.2, 0);
		sizeAlign.setPadding(4, 4, 4, 4);
		sizeFrame.add(sizeAlign);

		sizeTable.attachDefaults(fileRadio, 0, 1, 0, 1);
		sizeTable.attachDefaults(sizeKBSpin, 1, 2, 0, 1);
		sizeTable.attachDefaults(new Label("KB"), 2, 3, 0, 1);
		sizeTable.attachDefaults(sizeMBSpin, 1, 2, 1, 2);
		sizeTable.attachDefaults(new Label("MB"), 2, 3, 1, 2);
		sizeTable.attachDefaults(new Label("Storage medium"), 0, 1, 2, 3);
		sizeTable.attachDefaults(mediumCombo, 1, 2, 2, 3);
		sizeAlign.add(sizeTable);

		//Results
		Frame resultFrame = new Frame("Results");
		Table resultTable = new Table(3, 3, false);
		resultTable.setRowSpacings(5);
		resultTable.setColSpacings(5);

		Alignment resultAlign = new Alignment(0, 0.5, 0.2, 0);
		resultAlign.setPadding(4, 4, 4, 4);
		resultFrame.add(resultAlign);

		Alignment fileSizeAlign = new Alignment(1, 0.5, 0, 0);
		fileSizeAlign.add(new Label("Video file size"));

		resultTable.attachDefaults(bitrRadio, 0, 1, 0, 1);
		resultTable.attachDefaults(bitrSpin, 1, 2, 0, 1);
		resultTable.attachDefaults(new Label("kbit/s"), 2, 3, 0, 1);
		resultTable.attachDefaults(fileSizeAlign, 0, 1, 1, 2);
		resultTable.attachDefaults(videoSizeKBSpin, 1, 2, 1, 2);
		resultTable.attachDefaults(new Label("KB"), 2, 3, 1, 2);
		resultTable.attachDefaults(videoSizeMBSpin, 1, 2, 2, 3);
		resultTable.attachDefaults(new Label("MB"), 2, 3, 2, 3);
		resultAlign.add(resultTable);

		//Left
		VBox leftBox  = new VBox(false, 4);

		leftBox.add(videoFrame);
		leftBox.add(audioBox);

		//Right
		VBox rightBox = new VBox(false, 4);

		Alignment closeAlign = new Alignment(1, 1, 0.1, 0);
		closeAlign.add(new Button(StockID.CLOSE, &OnClose));

		rightBox.packStart(codecFrame, false, false, 0);
		rightBox.packStart(containFrame, false, false, 0);
		rightBox.packStart(sizeFrame, false, false, 0);
		rightBox.packStart(resultFrame, false, false, 0);
		rightBox.add(closeAlign);

		//top
		HBox topBox = new HBox(false, 6);
		topBox.setBorderWidth(4);

		topBox.add(leftBox);
		topBox.add(rightBox);

		this.add(topBox);
	}

	void SetDefaults()
	{
		handlingEvents = true;

		codecCombo.setActive(1);
		containCombo.setActive(0);
		sizeKBSpin.setValue(storageMediumSizeKB[8]);
		sizeMBSpin.setValue(rndint(cast(double)storageMediumSizeKB[8] / 1024));
		mediumCombo.setActive(8);

		handlingEvents = false;
	}

	void SetEvents()
	{
		videoFrame.addOnFramesChanged( &onFramesChanged);
		videoFrame.addOnBFramesChanged(&onBFramesChanged);

		audioFrame1.addOnAudioChanged(&onAudioChanged);
		audioFrame2.addOnAudioChanged(&onAudioChanged);

		codecCombo.addOnChanged(   &OnCodecContainerChange);
		containCombo.addOnChanged( &OnCodecContainerChange);

		sizeKBSpin.addOnValueChanged( &OnSizeChange);
		sizeMBSpin.addOnValueChanged( &OnSizeChange);
		mediumCombo.addOnChanged(     &OnMediumChange);

		bitrSpin.addOnValueChanged(        &OnBitrateChange);
		//videoSizeKBSpin.addOnValueChanged( &OnVideoSizeChange);
		//videoSizeMBSpin.addOnValueChanged( &OnVideoSizeChange);
	}

	public void onFramesChanged()
	{
		audioFrame1.setLengthInSeconds(videoFrame.getTotalLengthInSeconds);
		audioFrame2.setLengthInSeconds(videoFrame.getTotalLengthInSeconds);

		Calculate();
	}

	public void onBFramesChanged()
	{
		Calculate();
	}

	public void onAudioChanged()
	{
		Calculate();
	}

	public void OnCodecContainerChange(ComboBox cmb)
	{
		Calculate();
	}

	public void OnSizeChange(SpinButton spin)
	{
		if (handlingEvents) return;
		handlingEvents = true;

		fileRadio.setActive(true);

		if(spin is sizeKBSpin)
			sizeMBSpin.setValue(rndint(sizeKBSpin.getValue() / 1024));
		else
			sizeKBSpin.setValue(sizeMBSpin.getValueAsInt() * 1024);

		Calculate();

		handlingEvents = false;
	}

	public void OnMediumChange(ComboBox cmb)
	{
		if (handlingEvents) return;
		handlingEvents = true;

		fileRadio.setActive(true);

		sizeKBSpin.setValue(storageMediumSizeKB[mediumCombo.getActive()]);
		sizeMBSpin.setValue(rndint(cast(double)storageMediumSizeKB[mediumCombo.getActive()] / 1024));

		Calculate();

		handlingEvents = false;
	}

	public void OnBitrateChange(SpinButton spin)
	{
		if (handlingEvents) return;
		handlingEvents = true;

		bitrRadio.setActive(true);

		Calculate();

		handlingEvents = false;
	}

	public void OnVideoSizeChange(SpinButton spin)
	{
		if (handlingEvents) return;
		handlingEvents = true;

		fileRadio.setActive(true);
		long audioSizeKB = (audioFrame1.getAudioStream.SizeBytes + audioFrame2.getAudioStream.SizeBytes) / 1024;

		Stdout(audioSizeKB).newline;

		if(spin is videoSizeKBSpin)
		{
			Stdout(rndint(videoSizeKBSpin.getValue() + audioSizeKB)).newline;
			sizeKBSpin.setValue(rndint(videoSizeKBSpin.getValue() + audioSizeKB));
			sizeMBSpin.setValue(rndint(videoSizeKBSpin.getValue() + audioSizeKB / 1024));
		}
		else
		{
			Stdout(rndint(videoSizeMBSpin.getValue() * 1024 + audioSizeKB)).newline;
			sizeKBSpin.setValue(rndint(videoSizeMBSpin.getValue() * 1024 + audioSizeKB));
			sizeMBSpin.setValue(rndint(videoSizeMBSpin.getValue() + audioSizeKB / 1024));
		}

		Calculate();

		bitrRadio.setActive(true);

		handlingEvents = false;
	}


	public void OnClose(Button btn)
	{
		Main.exit(0);
	}

	void Calculate()
	{
		handlingEvents = true;

		BitrateCalculator bitr = new BitrateCalculator();

		VideoCodec codec = cast(VideoCodec)codecCombo.getActive();
		bool useBframes = videoFrame.getUseBFrames();
		ContainerType container = cast(ContainerType)containCombo.getActive();
		AudioStream [] audioStreams;
		int nbOfFrames = videoFrame.getFrames();
		double framerate = videoFrame.getFrameRate();
		int videoSizeKB;

		if(audioFrame1.getAudioStream.SizeBytes > 0)
			audioStreams ~= audioFrame1.getAudioStream;
		if(audioFrame2.getAudioStream.SizeBytes > 0)
			audioStreams ~= audioFrame2.getAudioStream;

		if(bitrRadio.getActive() == true) // calculate FileSize
		{
			int desiredBitrate = bitrSpin.getValueAsInt();

			int sizeKB = bitr.CalculateFileSizeKB(codec, useBframes, container, audioStreams, desiredBitrate, nbOfFrames, framerate, videoSizeKB);

			sizeKBSpin.setValue(sizeKB);
			sizeMBSpin.setValue(rndint(cast(double)sizeKB / 1024));
		}
		else // calculate Bitrate
		{
			long desiredOutputSizeBytes = sizeKBSpin.getValueAsInt() * 1024L;
			
			bitrSpin.setValue(bitr.CalculateBitrateKBits(codec, useBframes, container, audioStreams, desiredOutputSizeBytes, nbOfFrames, framerate, videoSizeKB));
		}

		videoSizeKBSpin.setValue(videoSizeKB);
		videoSizeMBSpin.setValue(rndint(cast(double)videoSizeKB / 1024));

		handlingEvents = false;
	}
}

class VideoFrame : Frame
{
	void delegate()[] onFramesChangedDelegates;
	void delegate()[] onBFramesChangedDelegates;

	SpinButton  hourSpin;
	SpinButton  minSpin;
	SpinButton  secSpin;
	SpinButton  totalSecSpin;
	ComboBox    frameRateCombo;
	SpinButton  framesSpin;
	CheckButton bFramesCheckBtn;

	bool handlingEvents;

	public this(char[] title = "Video")
	{
		super(title);

		hourSpin = new SpinButton(0, 40, 1);
		hourSpin.setWidthChars(3);
		minSpin = new SpinButton(0, 59, 1);
		minSpin.setWidthChars(3);
		secSpin = new SpinButton(0, 59, 1);
		secSpin.setWidthChars(3);

		HBox timeBox = new HBox(false, 4);
		timeBox.add(new Label("Hours"));
		timeBox.add(hourSpin);
		timeBox.add(new Label("Minutes"));
		timeBox.add(minSpin);
		timeBox.add(new Label("Seconds"));
		timeBox.add(secSpin);

		totalSecSpin = new SpinButton(0, 363599, 1);
		frameRateCombo = new ComboBox(true);
		foreach(char[] string; frameRates) frameRateCombo.appendText(string);
		framesSpin = new SpinButton(0, 9089975, 1);
		bFramesCheckBtn = new CheckButton("B-frames");

		Table videoTable = new Table(4, 2, false);
		videoTable.setRowSpacings(5);
		videoTable.attachDefaults(Alignment.west(new Label("Total lenght in seconds")), 0, 1, 0, 1);
		videoTable.attachDefaults(totalSecSpin, 1, 2, 0, 1);
		videoTable.attachDefaults(Alignment.west(new Label("Framerate")), 0, 1, 1, 2);
		videoTable.attachDefaults(frameRateCombo, 1, 2, 1, 2);
		videoTable.attachDefaults(Alignment.west(new Label("Number of frames")), 0, 1, 2, 3);
		videoTable.attachDefaults(framesSpin, 1, 2, 2, 3);
		videoTable.attachDefaults(bFramesCheckBtn, 0, 2, 3, 4);

		VBox videoBox = new VBox(false, 4);
		videoBox.setBorderWidth(4);
		videoBox.add(timeBox);
		videoBox.add(videoTable);

		this.add(videoBox);

		hourSpin.addOnValueChanged(     &onTimeChanged);
		minSpin.addOnValueChanged(      &onTimeChanged);
		secSpin.addOnValueChanged(      &onTimeChanged);
		totalSecSpin.addOnValueChanged( &onSecondsChanged);
		frameRateCombo.addOnChanged(    &onFrameRateChanged);
		framesSpin.addOnValueChanged(   &onFramesChanged);
		bFramesCheckBtn.addOnToggled(   &onBFramesChanged);

		hourSpin.grabFocus();
		frameRateCombo.setActive(2);
		bFramesCheckBtn.setActive(true);
	}

	int getTotalLengthInSeconds()
		{ return totalSecSpin.getValueAsInt(); }

	double getFrameRate()
		{ return FrameRate[frameRateCombo.getActive()]; }

	int getFrames()
		{ return framesSpin.getValueAsInt(); }

	bool getUseBFrames()
		{ return cast(bool)bFramesCheckBtn.getActive(); }

	void addOnFramesChanged(void delegate() dlg)
	{
		onFramesChangedDelegates ~= dlg;
	}
	void framesChanged()
	{
		foreach(dlg; onFramesChangedDelegates)
			dlg();
	}

	void addOnBFramesChanged(void delegate() dlg)
	{
		onBFramesChangedDelegates ~= dlg;
	}
	void bFramesChanged()
	{
		foreach(dlg; onBFramesChangedDelegates)
			dlg();
	}

	void onTimeChanged(SpinButton sb)
	{
		if (handlingEvents) return;
		handlingEvents = true;

		int seconds = hourSpin.getValueAsInt * 3600;
		seconds += minSpin.getValueAsInt * 60;
		seconds += secSpin.getValueAsInt;

		totalSecSpin.setValue(seconds);

		framesSpin.setValue(cast(int)(seconds * FrameRate[frameRateCombo.getActive()]));
		framesChanged();

		handlingEvents = false;
	}

	void onSecondsChanged(SpinButton sb)
	{
		if (handlingEvents) return;
		handlingEvents = true;

		CalculateTime();

		framesSpin.setValue(cast(int)(totalSecSpin.getValue() * FrameRate[frameRateCombo.getActive()]));
		framesChanged();

		handlingEvents = false;
	}

	void onFrameRateChanged(ComboBox cb)
	{
		framesSpin.setValue(rndint(totalSecSpin.getValue() * FrameRate[frameRateCombo.getActive()]));
	}

	void onFramesChanged(SpinButton sb)
	{
		if (handlingEvents) return;
		handlingEvents = true;

		framesChanged();

		totalSecSpin.setValue(rndint(framesSpin.getValue() / FrameRate[frameRateCombo.getActive()]));

		CalculateTime();

		handlingEvents = false;
	}

	void onBFramesChanged(ToggleButton tb)
	{
		bFramesChanged();
	}

	public void CalculateTime()
	{
		int seconds = totalSecSpin.getValueAsInt();

		hourSpin.setValue(cast(int)floor(seconds / 3600));
		seconds -= hourSpin.getValueAsInt() * 3600;

		minSpin.setValue(cast(int)floor(seconds / 60));
		seconds -= minSpin.getValueAsInt() * 60;

		secSpin.setValue(seconds);
	}
}

class AudioFrame : Frame
{
	void delegate()[] onAudioChangedDelegates;

	SpinButton  bitrSpin;
	SpinButton  sizeKBSpin;
	SpinButton  sizeMBSpin;
	ComboBox    typeCombo;

	bool handlingEvents;
	int totalLengthInSeconds;
	AudioStream audioStream;

	public this(char[] title = "Audio")
	{
		super(title);

		bitrSpin = new SpinButton(0, 1000, 1);
		sizeKBSpin = new SpinButton(0, int.max, 1);
		sizeMBSpin = new SpinButton(0, int.max, 1);
		typeCombo = new ComboBox(true);
		foreach(char[] string; audioTypes) typeCombo.appendText(string);

		Alignment clearAlign = new Alignment(1, 0.5, 0.2, 0);
		clearAlign.add(new Button(StockID.CLEAR, &OnClearAudio));

		HBox kbBox = new HBox(false, 0);
		kbBox.add(sizeKBSpin);
		kbBox.add(new Label("KB"));

		HBox mbBox = new HBox(false, 0);
		mbBox.add(sizeMBSpin);
		mbBox.add(new Label("MB"));

		HBox typeBox = new HBox(false, 0);
		typeBox.add(new Label("Type"));
		typeBox.add(typeCombo);

		VBox audioBox = new VBox(false, 4);
		audioBox.setBorderWidth(4);
		audioBox.add(new Label("Bitrate"));
		audioBox.add(bitrSpin);
		audioBox.add(new Label("Size"));
		audioBox.add(kbBox);
		audioBox.add(mbBox);
		audioBox.add(typeBox);
		audioBox.add(clearAlign);

		this.add(audioBox);

		bitrSpin.addOnValueChanged(   &OnAudioBitrateChange);
		sizeKBSpin.addOnValueChanged( &OnAudioSizeChange);
		sizeMBSpin.addOnValueChanged( &OnAudioSizeChange);
		typeCombo.addOnChanged(       &OnAudioTypeChange);

		typeCombo.setActive(0);
	}

	void setLengthInSeconds(int length)
	{
		totalLengthInSeconds = length;
		CalculateAudioSize();
	}

	AudioStream getAudioStream()
	{
		return audioStream;
	}

	void addOnAudioChanged(void delegate() dlg)
	{
		onAudioChangedDelegates ~= dlg;
	}
	void audioChanged()
	{
		foreach(dlg; onAudioChangedDelegates)
			dlg();
	}

	public void OnAudioBitrateChange(SpinButton spin)
	{
		if (handlingEvents) return;
		handlingEvents = true;

		CalculateAudioSize();
		audioChanged();

		handlingEvents = false;
	}

	public void OnAudioSizeChange(SpinButton spin)
	{
		if (handlingEvents) return;
		handlingEvents = true;

		if(spin is sizeMBSpin)
		{
			sizeKBSpin.setValue(sizeMBSpin.getValueAsInt() * 1024);
			audioStream.SizeBytes = sizeKBSpin.getValueAsInt() * 1024;
		}
		else if(spin is sizeKBSpin)
		{
			sizeMBSpin.setValue(rndint(sizeKBSpin.getValue() / 1024));
			audioStream.SizeBytes = sizeKBSpin.getValueAsInt() * 1024;
		}

		audioChanged();
		CalculateAudioBitrate();

		handlingEvents = false;
	}

	public void OnAudioTypeChange(ComboBox cmb)
	{
		audioStream.Type = cast(AudioType)typeCombo.getActive();
		audioChanged();
	}

	public void OnClearAudio(Button btn)
	{
		bitrSpin.setValue(0);
		sizeKBSpin.setValue(0);
		sizeMBSpin.setValue(0);
		typeCombo.setActive(0);

		audioStream = AudioStream.init;
		audioChanged();
	}

	void CalculateAudioSize()
	{
		double CalculateSize(int bitrate)
		{
			double bytesPerSecond = cast(double)bitrate * 1000 / 8;
			return (totalLengthInSeconds * bytesPerSecond);
			return 100;
		}

		double sizeInBytes = CalculateSize(bitrSpin.getValueAsInt());

		audioStream.SizeBytes = rndlong(sizeInBytes);
		sizeKBSpin.setValue(rndint(sizeInBytes / 1024));
		sizeMBSpin.setValue(rndint(sizeInBytes / 1024 / 1024));
	}

	void CalculateAudioBitrate()
	{
		int CalculateBitrate(long sizeInBytes)
		{
			double bytesPerSecond = sizeInBytes / totalLengthInSeconds;
			return cast(int)floor(bytesPerSecond * 8 / 1000);
		}

		bitrSpin.setValue(CalculateBitrate(audioStream.SizeBytes));
	}
}