6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2024-09-27 18:55:48 +00:00
Code Issues Projects Releases Wiki Activity

A shortcut here and a shortcut there; this allows me at least to determine whether use of a PBO gains anything.

Browse Source
This commit is contained in:
Thomas Harte 2016-03-19 17:07:05 -04:00
parent 5b37a651ac
commit 4ac1f959e9
7 changed files with 108 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
View File

@ -333,6 +333,7 @@
/* End PBXContainerItemProxy section */
/* Begin PBXFileReference section */
4B0B6E121C9DBD5D00FFB60D /* CRTConstants.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = CRTConstants.hpp; sourceTree = "<group>"; };
4B0CCC421C62D0B3001CAC5F /* CRT.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CRT.cpp; sourceTree = "<group>"; };
4B0CCC431C62D0B3001CAC5F /* CRT.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = CRT.hpp; sourceTree = "<group>"; };
4B0EBFB61C487F2F00A11F35 /* AudioQueue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AudioQueue.h; sourceTree = "<group>"; };
@ -1217,6 +1218,7 @@
4BBF99111C8FBA6F0075DAFB /* Shader.hpp */,
4BBF99121C8FBA6F0075DAFB /* TextureTarget.cpp */,
4BBF99131C8FBA6F0075DAFB /* TextureTarget.hpp */,
4B0B6E121C9DBD5D00FFB60D /* CRTConstants.hpp */,
);
path = Internals;
sourceTree = "<group>";

2
Outputs/CRT/CRT.hpp
View File

@ -107,7 +107,7 @@ class CRT {
@see @c set_rgb_sampling_function , @c set_composite_sampling_function
*/
CRT(unsigned int cycles_per_line, unsigned int common_output_divisor, unsigned int height_of_display, ColourSpace colour_space, unsigned int colour_cycle_numerator, unsigned int colour_cycle_denominator, unsigned int number_of_buffers, ...);
CRT(unsigned int cycles_per_line, unsigned int common_output_divisor, unsigned int height_of_display, ColourSpace colour_space, unsigned int colour_cycle_numerator, unsigned int colour_cycle_denominator, unsigned int buffer_depth, ...);
/*! Constructs the CRT with the specified clock rate, with the display height and colour
subcarrier frequency dictated by a standard display type and with the requested number of

57
Outputs/CRT/Internals/CRTConstants.hpp Normal file
View File

@ -0,0 +1,57 @@
//
// CRTContants.hpp
// Clock Signal
//
// Created by Thomas Harte on 19/03/2016.
// Copyright © 2016 Thomas Harte. All rights reserved.
//
#ifndef CRTConstants_h
#define CRTConstants_h
#include "OpenGL.hpp"
#include <cstddef>
namespace Outputs {
namespace CRT {
// Output vertices are those used to copy from an input buffer — whether it describes data that maps directly to RGB
// or is one of the intermediate buffers that we've used to convert from composite towards RGB.
const size_t OutputVertexOffsetOfPosition = 0;
const size_t OutputVertexOffsetOfTexCoord = 4;
const size_t OutputVertexOffsetOfTimestamp = 8;
const size_t OutputVertexOffsetOfLateral = 12;
const size_t OutputVertexSize = 16;
// Input vertices, used only in composite mode, map from the input buffer to temporary buffer locations; such
// remapping occurs to ensure a continous stream of data for each scan, giving correct out-of-bounds behaviour
const size_t InputVertexOffsetOfInputPosition = 0;
const size_t InputVertexOffsetOfOutputPosition = 4;
const size_t InputVertexOffsetOfPhaseAndAmplitude = 8;
const size_t InputVertexOffsetOfPhaseTime = 12;
const size_t InputVertexSize = 16;
// These constants hold the size of the rolling buffer to which the CPU writes
const int InputBufferBuilderWidth = 2048;
const int InputBufferBuilderHeight = 1024;
// This is the size of the intermediate buffers used during composite to RGB conversion
const int IntermediateBufferWidth = 2048;
const int IntermediateBufferHeight = 2048;
// Some internal
const GLsizeiptr InputVertexBufferDataSize = 262080; // a multiple of 6 * OutputVertexSize
const GLsizeiptr InputTextureBufferDataSize = InputBufferBuilderWidth*InputBufferBuilderHeight;
// Runs are divided discretely by vertical syncs in order to put a usable bounds on the uniform used to track
// run age; that therefore creates a discrete number of fields that are stored. This number should be the
// number of historic fields that are required fully to
const int NumberOfFields = 3;
}
}
#endif /* CRTContants_h */

6
Outputs/CRT/Internals/CRTInputBufferBuilder.cpp
View File

@ -41,8 +41,7 @@ void CRTInputBufferBuilder::allocate_write_area(size_t required_length)
if(_next_write_x_position + required_length + 2 > InputBufferBuilderWidth)
{
_next_write_x_position = 0;
_next_write_y_position = (_next_write_y_position+1)%InputBufferBuilderHeight;
move_to_new_line();
}
_write_x_position = _next_write_x_position + 1;
@ -53,6 +52,8 @@ void CRTInputBufferBuilder::allocate_write_area(size_t required_length)
void CRTInputBufferBuilder::reduce_previous_allocation_to(size_t actual_length)
{
// book end the allocation with duplicates of the first and last pixel, to protect
// against rounding errors when this run is drawn
for(int c = 0; c < number_of_buffers; c++)
{
memcpy( &buffers[c].data[(_write_target_pointer - 1) * buffers[c].bytes_per_pixel],
@ -64,6 +65,7 @@ void CRTInputBufferBuilder::reduce_previous_allocation_to(size_t actual_length)
buffers[c].bytes_per_pixel);
}
// return any allocated length that wasn't actually used to the available pool
_next_write_x_position -= (_last_allocation_amount - actual_length);
}

7
Outputs/CRT/Internals/CRTInputBufferBuilder.hpp
View File

@ -12,6 +12,7 @@
#include <stdint.h>
#include <stdarg.h>
#include <stddef.h>
#include "CRTConstants.hpp"
namespace Outputs {
namespace CRT {
@ -40,6 +41,12 @@ struct CRTInputBufferBuilder {
// Storage for the amount of buffer uploaded so far; initialised correctly by the buffer
// builder but otherwise entrusted to the CRT to update.
unsigned int last_uploaded_line;
inline void move_to_new_line()
{
_next_write_x_position = 0;
_next_write_y_position = (_next_write_y_position+1)%InputBufferBuilderHeight;
}
};
}

88
Outputs/CRT/Internals/CRTOpenGL.cpp
View File

@ -25,7 +25,8 @@ OpenGLOutputBuilder::OpenGLOutputBuilder(unsigned int number_of_buffers, va_list
_composite_shader(nullptr),
_rgb_shader(nullptr),
_output_buffer_data(nullptr),
_output_buffer_sync(nullptr)
_output_buffer_sync(nullptr),
_input_texture_data(nullptr)
{
_run_builders = new CRTRunBuilder *[NumberOfFields];
for(int builder = 0; builder < NumberOfFields; builder++)
@ -47,7 +48,9 @@ OpenGLOutputBuilder::~OpenGLOutputBuilder()
delete _run_builders[builder];
}
delete[] _run_builders;
delete[] _output_buffer_data;
// delete[] _input_texture_data;
glUnmapBuffer(GL_ARRAY_BUFFER);
free(_composite_shader);
free(_rgb_shader);
@ -82,10 +85,12 @@ void OpenGLOutputBuilder::draw_frame(unsigned int output_width, unsigned int out
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
GLenum format = formatForDepth(_buffer_builder->buffers[buffer].bytes_per_pixel);
glTexImage2D(GL_TEXTURE_2D, 0, (GLint)format, InputBufferBuilderWidth, InputBufferBuilderHeight, 0, format, GL_UNSIGNED_BYTE, _buffer_builder->buffers[buffer].data);
}
glGenBuffers(1, &_input_texture_array);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, _input_texture_array);
glBufferData(GL_PIXEL_UNPACK_BUFFER, InputTextureBufferDataSize, NULL, GL_STREAM_DRAW);
printf("%s\n", glGetString(GL_VERSION));
glTexImage2D(GL_TEXTURE_2D, 0, (GLint)format, InputBufferBuilderWidth, InputBufferBuilderHeight, 0, format, GL_UNSIGNED_BYTE, nullptr);
}
prepare_composite_input_shader();
prepare_rgb_output_shader();
@ -97,7 +102,6 @@ void OpenGLOutputBuilder::draw_frame(unsigned int output_width, unsigned int out
glBindBuffer(GL_ARRAY_BUFFER, output_array_buffer);
glBufferData(GL_ARRAY_BUFFER, InputVertexBufferDataSize, NULL, GL_STREAM_DRAW);
_output_buffer_data = new uint8_t[InputVertexBufferDataSize];
_output_buffer_data_pointer = 0;
glBindVertexArray(output_vertex_array);
@ -109,22 +113,30 @@ void OpenGLOutputBuilder::draw_frame(unsigned int output_width, unsigned int out
glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint *)&defaultFramebuffer);
// Create intermediate textures and bind to slots 0, 1 and 2
glActiveTexture(GL_TEXTURE0);
compositeTexture = std::unique_ptr<OpenGL::TextureTarget>(new OpenGL::TextureTarget(IntermediateBufferWidth, IntermediateBufferHeight));
glActiveTexture(GL_TEXTURE1);
filteredYTexture = std::unique_ptr<OpenGL::TextureTarget>(new OpenGL::TextureTarget(IntermediateBufferWidth, IntermediateBufferHeight));
glActiveTexture(GL_TEXTURE2);
filteredTexture = std::unique_ptr<OpenGL::TextureTarget>(new OpenGL::TextureTarget(IntermediateBufferWidth, IntermediateBufferHeight));
// glActiveTexture(GL_TEXTURE0);
// compositeTexture = std::unique_ptr<OpenGL::TextureTarget>(new OpenGL::TextureTarget(IntermediateBufferWidth, IntermediateBufferHeight));
// glActiveTexture(GL_TEXTURE1);
// filteredYTexture = std::unique_ptr<OpenGL::TextureTarget>(new OpenGL::TextureTarget(IntermediateBufferWidth, IntermediateBufferHeight));
// glActiveTexture(GL_TEXTURE2);
// filteredTexture = std::unique_ptr<OpenGL::TextureTarget>(new OpenGL::TextureTarget(IntermediateBufferWidth, IntermediateBufferHeight));
}
// lock down any further work on the current frame
_output_mutex->lock();
// release the mapping, giving up on trying to draw if data has been lost
if(glUnmapBuffer(GL_ARRAY_BUFFER) == GL_FALSE)
{
for(int c = 0; c < NumberOfFields; c++)
_run_builders[c]->reset();
}
glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
// upload more source pixel data if any; we'll always resubmit the last line submitted last
// time as it may have had extra data appended to it
for(unsigned int buffer = 0; buffer < _buffer_builder->number_of_buffers; buffer++)
{
glActiveTexture(GL_TEXTURE0 + first_supplied_buffer_texture_unit + buffer);
// glActiveTexture(GL_TEXTURE0 + first_supplied_buffer_texture_unit + buffer);
GLenum format = formatForDepth(_buffer_builder->buffers[0].bytes_per_pixel);
if(_buffer_builder->_next_write_y_position < _buffer_builder->last_uploaded_line)
{
@ -132,7 +144,7 @@ void OpenGLOutputBuilder::draw_frame(unsigned int output_width, unsigned int out
0, (GLint)_buffer_builder->last_uploaded_line,
InputBufferBuilderWidth, (GLint)(InputBufferBuilderHeight - _buffer_builder->last_uploaded_line),
format, GL_UNSIGNED_BYTE,
&_buffer_builder->buffers[0].data[_buffer_builder->last_uploaded_line * InputBufferBuilderWidth * _buffer_builder->buffers[0].bytes_per_pixel]);
(void *)(_buffer_builder->last_uploaded_line * InputBufferBuilderWidth * _buffer_builder->buffers[0].bytes_per_pixel));
_buffer_builder->last_uploaded_line = 0;
}
@ -142,7 +154,7 @@ void OpenGLOutputBuilder::draw_frame(unsigned int output_width, unsigned int out
0, (GLint)_buffer_builder->last_uploaded_line,
InputBufferBuilderWidth, (GLint)(1 + _buffer_builder->_next_write_y_position - _buffer_builder->last_uploaded_line),
format, GL_UNSIGNED_BYTE,
&_buffer_builder->buffers[0].data[_buffer_builder->last_uploaded_line * InputBufferBuilderWidth * _buffer_builder->buffers[0].bytes_per_pixel]);
(void *)(_buffer_builder->last_uploaded_line * InputBufferBuilderWidth * _buffer_builder->buffers[0].bytes_per_pixel));
_buffer_builder->last_uploaded_line = _buffer_builder->_next_write_y_position;
}
}
@ -177,7 +189,6 @@ void OpenGLOutputBuilder::draw_frame(unsigned int output_width, unsigned int out
// draw all sitting frames
unsigned int run = (unsigned int)_run_write_pointer;
// printf("%d: %zu v %zu\n", run, _run_builders[run]->uploaded_vertices, _run_builders[run]->number_of_vertices);
GLint total_age = 0;
for(int c = 0; c < NumberOfFields; c++)
{
@ -186,47 +197,6 @@ void OpenGLOutputBuilder::draw_frame(unsigned int output_width, unsigned int out
if(_run_builders[run]->amount_of_data > 0)
{
// upload if required
if(_run_builders[run]->amount_of_data != _run_builders[run]->amount_of_uploaded_data)
{
size_t start = (_run_builders[run]->start + _run_builders[run]->amount_of_uploaded_data) % InputVertexBufferDataSize;
size_t length = _run_builders[run]->amount_of_data + _run_builders[run]->amount_of_uploaded_data;
if(start + length > InputVertexBufferDataSize)
{
if(_output_buffer_sync)
{
glClientWaitSync(_output_buffer_sync, GL_SYNC_FLUSH_COMMANDS_BIT, ~(GLuint64)0);
glDeleteSync(_output_buffer_sync);
}
_output_buffer_sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
uint8_t *target = (uint8_t *)glMapBufferRange(GL_ARRAY_BUFFER, 0, InputVertexBufferDataSize, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
if(target)
{
size_t first_size = InputVertexBufferDataSize - start;
memcpy(&target[start], &_output_buffer_data[start], first_size);
memcpy(target, _output_buffer_data, length - first_size);
}
}
else
{
uint8_t *target = (uint8_t *)glMapBufferRange(GL_ARRAY_BUFFER, (GLintptr)start, (GLsizeiptr)length, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
if(target)
{
memcpy(target, &_output_buffer_data[start], length);
}
}
while(glUnmapBuffer(GL_ARRAY_BUFFER) == GL_FALSE)
{
// "the data store contents are undefined. An application must detect this rare condition and reinitialize the data store."
uint8_t *target = (uint8_t *)glMapBufferRange(GL_ARRAY_BUFFER, 0, InputVertexBufferDataSize, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
memcpy(target, _output_buffer_data, InputVertexBufferDataSize);
}
_run_builders[run]->amount_of_uploaded_data = _run_builders[run]->amount_of_data;
}
// draw
glUniform1f(timestampBaseUniform, (GLfloat)total_age);
GLsizei count = (GLsizei)(_run_builders[run]->amount_of_data / InputVertexSize);
@ -247,6 +217,10 @@ void OpenGLOutputBuilder::draw_frame(unsigned int output_width, unsigned int out
}
}
// drawing commands having been issued, reclaim the array buffer pointer
_buffer_builder->move_to_new_line();
_output_buffer_data = (uint8_t *)glMapBufferRange(GL_ARRAY_BUFFER, 0, InputVertexBufferDataSize, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
_input_texture_data = (uint8_t *)glMapBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, InputTextureBufferDataSize, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
_output_mutex->unlock();
}

42
Outputs/CRT/Internals/CRTOpenGL.hpp
View File

@ -10,6 +10,7 @@
#define CRTOpenGL_h
#include "../CRTTypes.hpp"
#include "CRTConstants.hpp"
#include "OpenGL.hpp"
#include "TextureTarget.hpp"
#include "Shader.hpp"
@ -21,41 +22,6 @@
namespace Outputs {
namespace CRT {
// Output vertices are those used to copy from an input buffer — whether it describes data that maps directly to RGB
// or is one of the intermediate buffers that we've used to convert from composite towards RGB.
const size_t OutputVertexOffsetOfPosition = 0;
const size_t OutputVertexOffsetOfTexCoord = 4;
const size_t OutputVertexOffsetOfTimestamp = 8;
const size_t OutputVertexOffsetOfLateral = 12;
const size_t OutputVertexSize = 16;
// Input vertices, used only in composite mode, map from the input buffer to temporary buffer locations; such
// remapping occurs to ensure a continous stream of data for each scan, giving correct out-of-bounds behaviour
const size_t InputVertexOffsetOfInputPosition = 0;
const size_t InputVertexOffsetOfOutputPosition = 4;
const size_t InputVertexOffsetOfPhaseAndAmplitude = 8;
const size_t InputVertexOffsetOfPhaseTime = 12;
const size_t InputVertexSize = 16;
// These constants hold the size of the rolling buffer to which the CPU writes
const int InputBufferBuilderWidth = 2048;
const int InputBufferBuilderHeight = 1024;
// This is the size of the intermediate buffers used during composite to RGB conversion
const int IntermediateBufferWidth = 2048;
const int IntermediateBufferHeight = 2048;
// Some internal
const GLsizeiptr InputVertexBufferDataSize = 262080; // a multiple of 6 * OutputVertexSize
// Runs are divided discretely by vertical syncs in order to put a usable bounds on the uniform used to track
// run age; that therefore creates a discrete number of fields that are stored. This number should be the
// number of historic fields that are required fully to
const int NumberOfFields = 3;
class OpenGLOutputBuilder {
private:
// colour information
@ -212,7 +178,8 @@ class OpenGLOutputBuilder {
inline uint8_t *get_write_target_for_buffer(int buffer)
{
return _buffer_builder->get_write_target_for_buffer(buffer);
return &_input_texture_data[_buffer_builder->_write_target_pointer]; // * _buffer_builder->bytes_per_pixel
// return _buffer_builder->get_write_target_for_buffer(buffer);
}
inline uint16_t get_last_write_x_posiiton()
@ -241,6 +208,9 @@ class OpenGLOutputBuilder {
// TODO: update related uniforms
}
uint8_t *_input_texture_data;
GLuint _input_texture_array;
uint8_t *_output_buffer_data;
size_t _output_buffer_data_pointer;
GLsync _output_buffer_sync;