X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=nageru%2Fpbo_frame_allocator.cpp;h=709a2bf359e505ab7e089f567fce33b502427834;hb=HEAD;hp=133b65fe3310c2b0c69b27330098286e9f6cb994;hpb=e01e8253288b3b706b22ea0c788c2c8f50bfac2e;p=nageru diff --git a/nageru/pbo_frame_allocator.cpp b/nageru/pbo_frame_allocator.cpp index 133b65f..6ebe13a 100644 --- a/nageru/pbo_frame_allocator.cpp +++ b/nageru/pbo_frame_allocator.cpp @@ -1,16 +1,22 @@ #include "pbo_frame_allocator.h" #include +#include +#include #include +#include #include #include #include #include +#include +#include -#include "flags.h" #include "mjpeg_encoder.h" +#include "defs.h" +#include "shared/va_resource_pool.h" #include "v210_converter.h" -#include "va_display_with_cleanup.h" +#include "shared/va_display.h" using namespace std; @@ -29,11 +35,22 @@ void set_clamp_to_edge() } // namespace PBOFrameAllocator::PBOFrameAllocator(bmusb::PixelFormat pixel_format, size_t frame_size, GLuint width, GLuint height, unsigned card_index, MJPEGEncoder *mjpeg_encoder, size_t num_queued_frames, GLenum buffer, GLenum permissions, GLenum map_bits) - : card_index(card_index), mjpeg_encoder(mjpeg_encoder), pixel_format(pixel_format), buffer(buffer) + : card_index(card_index), + mjpeg_encoder(mjpeg_encoder), + pixel_format(pixel_format), + buffer(buffer), + frame_size(frame_size), + num_queued_frames(num_queued_frames), + width(width), + height(height), + permissions(permissions), + map_bits(map_bits) { userdata.reset(new Userdata[num_queued_frames]); for (size_t i = 0; i < num_queued_frames; ++i) { - init_frame(i, frame_size, width, height, permissions, map_bits); + Frame frame; + init_frame(frame, &userdata[i], this, pixel_format, frame_size, width, height, permissions, map_bits, buffer, generation); + freelist.push(frame); } glBindBuffer(buffer, 0); check_error(); @@ -41,7 +58,7 @@ PBOFrameAllocator::PBOFrameAllocator(bmusb::PixelFormat pixel_format, size_t fra check_error(); } -void PBOFrameAllocator::init_frame(size_t frame_idx, size_t frame_size, GLuint width, GLuint height, GLenum permissions, GLenum map_bits) +void PBOFrameAllocator::init_frame(Frame &frame, Userdata *ud, PBOFrameAllocator *owner, bmusb::PixelFormat pixel_format, size_t frame_size, GLuint width, GLuint height, GLenum permissions, GLenum map_bits, GLenum buffer, int generation) { GLuint pbo; glGenBuffers(1, &pbo); @@ -51,17 +68,16 @@ void PBOFrameAllocator::init_frame(size_t frame_idx, size_t frame_size, GLuint w glBufferStorage(buffer, frame_size, nullptr, permissions | GL_MAP_PERSISTENT_BIT); check_error(); - Frame frame; frame.data = (uint8_t *)glMapBufferRange(buffer, 0, frame_size, permissions | map_bits | GL_MAP_PERSISTENT_BIT); frame.data2 = frame.data + frame_size / 2; check_error(); frame.size = frame_size; - Userdata *ud = &userdata[frame_idx]; frame.userdata = ud; + ud->generation = generation; ud->pbo = pbo; ud->pixel_format = pixel_format; ud->data_copy_malloc = new uint8_t[frame_size]; - frame.owner = this; + frame.owner = owner; // For 8-bit non-planar Y'CbCr, we ask the driver to split Y' and Cb/Cr // into separate textures. For 10-bit, the input format (v210) @@ -199,8 +215,6 @@ void PBOFrameAllocator::init_frame(size_t frame_idx, size_t frame_size, GLuint w assert(false); } } - - freelist.push(frame); } PBOFrameAllocator::~PBOFrameAllocator() @@ -226,7 +240,7 @@ void PBOFrameAllocator::destroy_frame(Frame *frame) check_error(); glDeleteBuffers(1, &pbo); check_error(); - switch (pixel_format) { + switch (ud->pixel_format) { case bmusb::PixelFormat_10BitYCbCr: glDeleteTextures(2, ud->tex_v210); check_error(); @@ -254,12 +268,20 @@ void PBOFrameAllocator::destroy_frame(Frame *frame) default: assert(false); } + + if (ud->generation != generation) { + auto it = lingering_generations.find(ud->generation); + assert(it != lingering_generations.end()); + if (--it->second.num_frames_left == 0) { + lingering_generations.erase(it); // Deallocates the userdata block. + } + } } //static int sumsum = 0; bmusb::FrameAllocator::Frame PBOFrameAllocator::alloc_frame() { - Frame vf; + Frame vf; lock_guard lock(freelist_mutex); // Meh. if (freelist.empty()) { @@ -287,7 +309,12 @@ bmusb::FrameAllocator::Frame PBOFrameAllocator::alloc_frame() bmusb::FrameAllocator::Frame PBOFrameAllocator::create_frame(size_t width, size_t height, size_t stride) { - Frame vf; + Frame vf; + + size_t desired_frame_bytes = width * stride; + if (stride > 8192 * 4 || height > 8192 || desired_frame_bytes > MAX_FRAME_SIZE) { + return vf; + } { lock_guard lock(freelist_mutex); @@ -301,17 +328,29 @@ bmusb::FrameAllocator::Frame PBOFrameAllocator::create_frame(size_t width, size_ freelist.pop(); } } - vf.len = 0; - vf.overflow = 0; Userdata *userdata = (Userdata *)vf.userdata; + assert(generation == userdata->generation); + if (vf.size < desired_frame_bytes || (vf.size > FRAME_SIZE && vf.size > desired_frame_bytes * 2)) { + // Frame is either too small or way too large, so reallocate it. + // Note that width and height now automatically becomes the right size + // (the one we just asked for, instead of the default for the allocator, + // which is generally the global resolution); it doesn't matter + // for correctness, since we'll recreate the texture on upload if needed, + // but it is nice to save that step. + destroy_frame(&vf); + init_frame(vf, userdata, this, pixel_format, std::max(desired_frame_bytes, FRAME_SIZE), width, height, permissions, map_bits, buffer, generation); + }; + + vf.len = 0; + vf.overflow = 0; if (mjpeg_encoder != nullptr && mjpeg_encoder->should_encode_mjpeg_for_card(card_index)) { if (mjpeg_encoder->using_vaapi()) { VADisplay va_dpy = mjpeg_encoder->va_dpy->va_dpy; - MJPEGEncoder::VAResources resources = mjpeg_encoder->get_va_resources(width, height); - MJPEGEncoder::ReleaseVAResources release(mjpeg_encoder, resources); + VAResourcePool::VAResources resources = mjpeg_encoder->get_va_pool()->get_va_resources(width, height, VA_FOURCC_UYVY); // Only used by DeckLinkCapture, so always 4:2:2. + ReleaseVAResources release(mjpeg_encoder->get_va_pool(), resources); if (resources.image.pitches[0] == stride) { userdata->va_resources = move(resources); @@ -375,8 +414,8 @@ void PBOFrameAllocator::release_frame(Frame frame) { // In case we never got to upload the frame to MJPEGEncoder. Userdata *userdata = (Userdata *)frame.userdata; - MJPEGEncoder::VAResources resources __attribute__((unused)) = move(userdata->va_resources); - MJPEGEncoder::ReleaseVAResources release = move(userdata->va_resources_release); + VAResourcePool::VAResources resources __attribute__((unused)) = move(userdata->va_resources); + ReleaseVAResources release = move(userdata->va_resources_release); if (frame.data_copy != nullptr && userdata->data_copy_current_src == Userdata::FROM_VA_API) { VADisplay va_dpy = mjpeg_encoder->va_dpy->va_dpy; @@ -388,6 +427,66 @@ void PBOFrameAllocator::release_frame(Frame frame) } lock_guard lock(freelist_mutex); - freelist.push(frame); + Userdata *userdata = (Userdata *)frame.userdata; + if (userdata->generation == generation) { + freelist.push(frame); + } else { + destroy_frame(&frame); + } //--sumsum; } + +void PBOFrameAllocator::reconfigure(bmusb::PixelFormat pixel_format, + size_t frame_size, + GLuint width, GLuint height, + unsigned card_index, + MJPEGEncoder *mjpeg_encoder, + size_t num_queued_frames, + GLenum buffer, + GLenum permissions, + GLenum map_bits) +{ + if (pixel_format == this->pixel_format && + frame_size == this->frame_size && + width == this->width && height == this->height && + card_index == this->card_index && + mjpeg_encoder == this->mjpeg_encoder && + num_queued_frames == this->num_queued_frames && + buffer == this->buffer && + permissions == this->permissions && + map_bits == this->map_bits) { + return; + } + + lock_guard lock(freelist_mutex); + lingering_generations[generation] = LingeringGeneration{ move(userdata), this->num_queued_frames }; + ++generation; + + while (!freelist.empty()) { + Frame frame = freelist.front(); + freelist.pop(); + destroy_frame(&frame); + } + + this->pixel_format = pixel_format; + this->frame_size = frame_size; + this->width = width; + this->height = height; + this->card_index = card_index; + this->mjpeg_encoder = mjpeg_encoder; + this->num_queued_frames = num_queued_frames; + this->buffer = buffer; + this->permissions = permissions; + this->map_bits = map_bits; + + userdata.reset(new Userdata[num_queued_frames]); + for (size_t i = 0; i < num_queued_frames; ++i) { + Frame frame; + init_frame(frame, &userdata[i], this, pixel_format, frame_size, width, height, permissions, map_bits, buffer, generation); + freelist.push(frame); + } + + // There may still be frames out with the old configuration + // (for instance, living in GLWidget); they will be destroyed + // when they come back in release_frame(). +}