X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=flat_input.h;h=bcaca50012facb2dcfb3d77879b11d99cac9a456;hp=a906a5d36a812938aeba6647c30c657385f82eda;hb=29dbee6d7375145fda1346dbd2531017c9ce8e1e;hpb=0dc1dfe6444a700ebd2c9f006cba000b90c3a7b0 diff --git a/flat_input.h b/flat_input.h index a906a5d..bcaca50 100644 --- a/flat_input.h +++ b/flat_input.h @@ -1,64 +1,172 @@ -#ifndef _FLAT_INPUT_H -#define _FLAT_INPUT_H 1 +#ifndef _MOVIT_FLAT_INPUT_H +#define _MOVIT_FLAT_INPUT_H 1 +#include +#include +#include + +#include "effect.h" +#include "effect_chain.h" +#include "fp16.h" +#include "image_format.h" #include "input.h" +namespace movit { + +class ResourcePool; + // A FlatInput is the normal, “classic” case of an input, where everything // comes from a single 2D array with chunky pixels. class FlatInput : public Input { public: - FlatInput(ImageFormat format, unsigned width, unsigned height); + FlatInput(ImageFormat format, MovitPixelFormat pixel_format, GLenum type, unsigned width, unsigned height); + ~FlatInput(); + + virtual std::string effect_type_id() const { return "FlatInput"; } - // Create the texture itself. We cannot do this in the constructor, - // because we don't necessarily know all the settings (sRGB texture, - // mipmap generation) at that point. - void finalize(); + virtual bool can_output_linear_gamma() const { + // On desktop OpenGL, there's also GL_SLUMINANCE8 which could give us + // support for single-channel sRGB decoding, but it's not supported + // on GLES, and we're already actively rewriting single-channel inputs + // to GL_RED (even on desktop), so we stick to 3- and 4-channel inputs. + return (type == GL_UNSIGNED_BYTE && + (pixel_format == FORMAT_RGB || + pixel_format == FORMAT_RGBA_POSTMULTIPLIED_ALPHA) && + (image_format.gamma_curve == GAMMA_LINEAR || + image_format.gamma_curve == GAMMA_sRGB)); + } + virtual AlphaHandling alpha_handling() const { + switch (pixel_format) { + case FORMAT_RGBA_PREMULTIPLIED_ALPHA: + return INPUT_AND_OUTPUT_PREMULTIPLIED_ALPHA; + case FORMAT_RGBA_POSTMULTIPLIED_ALPHA: + return OUTPUT_POSTMULTIPLIED_ALPHA; + case FORMAT_R: + case FORMAT_RG: + case FORMAT_RGB: + return OUTPUT_BLANK_ALPHA; + default: + assert(false); + } + } std::string output_fragment_shader(); // Uploads the texture if it has changed since last time. void set_gl_state(GLuint glsl_program_num, const std::string& prefix, unsigned *sampler_num); - ColorSpace get_color_space() { return image_format.color_space; } - GammaCurve get_gamma_curve() { return image_format.gamma_curve; } + unsigned get_width() const { return width; } + unsigned get_height() const { return height; } + Colorspace get_color_space() const { return image_format.color_space; } + GammaCurve get_gamma_curve() const { return image_format.gamma_curve; } + virtual bool is_single_texture() const { return true; } // Tells the input where to fetch the actual pixel data. Note that if you change // this data, you must either call set_pixel_data() again (using the same pointer // is fine), or invalidate_pixel_data(). Otherwise, the texture won't be re-uploaded // on subsequent frames. - void set_pixel_data(const unsigned char *pixel_data) + // + // The data can either be a regular pointer (if pbo==0), or a byte offset + // into a PBO. The latter will allow you to start uploading the texture data + // asynchronously to the GPU, if you have any CPU-intensive work between the + // call to set_pixel_data() and the actual rendering. In either case, + // the pointer (and PBO, if set) has to be valid at the time of the render call. + void set_pixel_data(const unsigned char *pixel_data, GLuint pbo = 0) + { + assert(this->type == GL_UNSIGNED_BYTE); + this->pixel_data = pixel_data; + this->pbo = pbo; + invalidate_pixel_data(); + } + + void set_pixel_data(const unsigned short *pixel_data, GLuint pbo = 0) { + assert(this->type == GL_UNSIGNED_SHORT); this->pixel_data = pixel_data; + this->pbo = pbo; invalidate_pixel_data(); } - void invalidate_pixel_data() + void set_pixel_data_fp16(const fp16_int_t *pixel_data, GLuint pbo = 0) { - needs_update = true; + assert(this->type == GL_HALF_FLOAT); + this->pixel_data = pixel_data; + this->pbo = pbo; + invalidate_pixel_data(); } - const unsigned char *get_pixel_data() const + void set_pixel_data(const float *pixel_data, GLuint pbo = 0) { - return pixel_data; + assert(this->type == GL_FLOAT); + this->pixel_data = pixel_data; + this->pbo = pbo; + invalidate_pixel_data(); + } + + void invalidate_pixel_data(); + + // Note: Sets pitch to width, so even if your pitch is unchanged, + // you will need to re-set it after this call. + void set_width(unsigned width) + { + assert(width != 0); + this->pitch = this->width = width; + invalidate_pixel_data(); + } + + void set_height(unsigned height) + { + assert(height != 0); + this->height = height; + invalidate_pixel_data(); } void set_pitch(unsigned pitch) { - assert(!finalized); + assert(pitch != 0); this->pitch = pitch; + invalidate_pixel_data(); } - unsigned get_pitch() { - return pitch; + // Tells the input to use the specific OpenGL texture as pixel data. + // This is useful if you want to share the same texture between multiple + // EffectChain instances, or if you somehow can get the data into a texture more + // efficiently than through a normal upload (e.g. a video codec decoding straight + // into a texture). Note that you are responsible for setting the right sampler + // parameters (e.g. clamp-to-edge) yourself, as well as generate any mipmaps + // if they are needed. + // + // NOTE: The input does not take ownership of this texture; you are responsible + // for releasing it yourself. In particular, if you call invalidate_pixel_data() + // or anything calling it, the texture will silently be removed from the input. + void set_texture_num(GLuint texture_num) + { + possibly_release_texture(); + this->texture_num = texture_num; + this->owns_texture = false; + } + + virtual void inform_added(EffectChain *chain) + { + resource_pool = chain->get_resource_pool(); } private: + // Release the texture if we have any, and it is owned by us. + void possibly_release_texture(); + ImageFormat image_format; - GLenum format; + MovitPixelFormat pixel_format; + GLenum type; GLuint pbo, texture_num; - bool needs_update, finalized; - int use_srgb_texture_format, needs_mipmaps; - unsigned width, height, pitch, bytes_per_pixel; - const unsigned char *pixel_data; + int output_linear_gamma, needs_mipmaps; + unsigned width, height, pitch; + bool owns_texture; + const void *pixel_data; + ResourcePool *resource_pool; + bool fixup_swap_rb, fixup_red_to_grayscale; + GLint uniform_tex; }; -#endif // !defined(_FLAT_INPUT_H) +} // namespace movit + +#endif // !defined(_MOVIT_FLAT_INPUT_H)