aboutsummaryrefslogtreecommitdiff
path: root/src/encoder
diff options
context:
space:
mode:
Diffstat (limited to 'src/encoder')
-rw-r--r--src/encoder/encoder.c155
-rw-r--r--src/encoder/video/nvenc.c29
-rw-r--r--src/encoder/video/software.c33
-rw-r--r--src/encoder/video/vaapi.c37
-rw-r--r--src/encoder/video/video.c12
-rw-r--r--src/encoder/video/vulkan.c298
6 files changed, 343 insertions, 221 deletions
diff --git a/src/encoder/encoder.c b/src/encoder/encoder.c
new file mode 100644
index 0000000..0f8eda5
--- /dev/null
+++ b/src/encoder/encoder.c
@@ -0,0 +1,155 @@
+#include "../../include/encoder/encoder.h"
+#include "../../include/utils.h"
+
+#include <string.h>
+#include <stdio.h>
+
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+
+bool gsr_encoder_init(gsr_encoder *self, gsr_replay_storage replay_storage, size_t replay_buffer_num_packets, double replay_buffer_time, const char *replay_directory) {
+ memset(self, 0, sizeof(*self));
+ self->num_recording_destinations = 0;
+ self->recording_destination_id_counter = 0;
+
+ if(pthread_mutex_init(&self->file_write_mutex, NULL) != 0) {
+ fprintf(stderr, "gsr error: gsr_encoder_init: failed to create mutex\n");
+ return false;
+ }
+ self->mutex_created = true;
+
+ if(replay_buffer_num_packets > 0) {
+ self->replay_buffer = gsr_replay_buffer_create(replay_storage, replay_directory, replay_buffer_time, replay_buffer_num_packets);
+ if(!self->replay_buffer) {
+ fprintf(stderr, "gsr error: gsr_encoder_init: failed to create replay buffer\n");
+ gsr_encoder_deinit(self);
+ return false;
+ }
+ }
+
+ return true;
+}
+
+void gsr_encoder_deinit(gsr_encoder *self) {
+ if(self->mutex_created) {
+ self->mutex_created = false;
+ pthread_mutex_destroy(&self->file_write_mutex);
+ }
+
+ if(self->replay_buffer) {
+ gsr_replay_buffer_destroy(self->replay_buffer);
+ self->replay_buffer = NULL;
+ }
+
+ self->num_recording_destinations = 0;
+ self->recording_destination_id_counter = 0;
+}
+
+void gsr_encoder_receive_packets(gsr_encoder *self, AVCodecContext *codec_context, int64_t pts, int stream_index) {
+ for(;;) {
+ AVPacket *av_packet = av_packet_alloc();
+ if(!av_packet)
+ break;
+
+ av_packet->data = NULL;
+ av_packet->size = 0;
+ int res = avcodec_receive_packet(codec_context, av_packet);
+ if(res == 0) { // we have a packet, send the packet to the muxer
+ av_packet->stream_index = stream_index;
+ av_packet->pts = pts;
+ av_packet->dts = pts;
+
+ if(self->replay_buffer) {
+ const double time_now = clock_get_monotonic_seconds();
+ if(!gsr_replay_buffer_append(self->replay_buffer, av_packet, time_now))
+ fprintf(stderr, "gsr error: gsr_encoder_receive_packets: failed to add replay buffer data\n");
+ }
+
+ pthread_mutex_lock(&self->file_write_mutex);
+ const bool is_keyframe = av_packet->flags & AV_PKT_FLAG_KEY;
+ for(size_t i = 0; i < self->num_recording_destinations; ++i) {
+ gsr_encoder_recording_destination *recording_destination = &self->recording_destinations[i];
+ if(recording_destination->codec_context != codec_context)
+ continue;
+
+ if(is_keyframe)
+ recording_destination->has_received_keyframe = true;
+ else if(!recording_destination->has_received_keyframe)
+ continue;
+
+ av_packet->pts = pts - recording_destination->start_pts;
+ av_packet->dts = pts - recording_destination->start_pts;
+
+ av_packet_rescale_ts(av_packet, codec_context->time_base, recording_destination->stream->time_base);
+ // TODO: Is av_interleaved_write_frame needed?. Answer: might be needed for mkv but dont use it! it causes frames to be inconsistent, skipping frames and duplicating frames.
+ // TODO: av_interleaved_write_frame might be needed for cfr, or always for flv
+ const int ret = av_write_frame(recording_destination->format_context, av_packet);
+ if(ret < 0) {
+ char error_buffer[AV_ERROR_MAX_STRING_SIZE];
+ if(av_strerror(ret, error_buffer, sizeof(error_buffer)) < 0)
+ snprintf(error_buffer, sizeof(error_buffer), "Unknown error");
+ fprintf(stderr, "gsr error: gsr_encoder_receive_packets: failed to write frame index %d to muxer, reason: %s (%d)\n", av_packet->stream_index, error_buffer, ret);
+ }
+ }
+ pthread_mutex_unlock(&self->file_write_mutex);
+
+ av_packet_free(&av_packet);
+ } else if (res == AVERROR(EAGAIN)) { // we have no packet
+ // fprintf(stderr, "No packet!\n");
+ av_packet_free(&av_packet);
+ break;
+ } else if (res == AVERROR_EOF) { // this is the end of the stream
+ av_packet_free(&av_packet);
+ fprintf(stderr, "End of stream!\n");
+ break;
+ } else {
+ av_packet_free(&av_packet);
+ fprintf(stderr, "Unexpected error: %d\n", res);
+ break;
+ }
+ }
+}
+
+size_t gsr_encoder_add_recording_destination(gsr_encoder *self, AVCodecContext *codec_context, AVFormatContext *format_context, AVStream *stream, int64_t start_pts) {
+ if(self->num_recording_destinations >= GSR_MAX_RECORDING_DESTINATIONS) {
+ fprintf(stderr, "gsr error: gsr_encoder_add_recording_destination: failed to add destination, reached the max amount of recording destinations (%d)\n", GSR_MAX_RECORDING_DESTINATIONS);
+ return (size_t)-1;
+ }
+
+ for(size_t i = 0; i < self->num_recording_destinations; ++i) {
+ if(self->recording_destinations[i].stream == stream) {
+ fprintf(stderr, "gsr error: gsr_encoder_add_recording_destination: failed to add destination, the stream %p already exists as an output\n", (void*)stream);
+ return (size_t)-1;
+ }
+ }
+
+ pthread_mutex_lock(&self->file_write_mutex);
+ gsr_encoder_recording_destination *recording_destination = &self->recording_destinations[self->num_recording_destinations];
+ recording_destination->id = self->recording_destination_id_counter;
+ recording_destination->codec_context = codec_context;
+ recording_destination->format_context = format_context;
+ recording_destination->stream = stream;
+ recording_destination->start_pts = start_pts;
+ recording_destination->has_received_keyframe = false;
+
+ ++self->recording_destination_id_counter;
+ ++self->num_recording_destinations;
+ pthread_mutex_unlock(&self->file_write_mutex);
+
+ return recording_destination->id;
+}
+
+bool gsr_encoder_remove_recording_destination(gsr_encoder *self, size_t id) {
+ bool found = false;
+ pthread_mutex_lock(&self->file_write_mutex);
+ for(size_t i = 0; i < self->num_recording_destinations; ++i) {
+ if(self->recording_destinations[i].id == id) {
+ self->recording_destinations[i] = self->recording_destinations[self->num_recording_destinations - 1];
+ --self->num_recording_destinations;
+ found = true;
+ break;
+ }
+ }
+ pthread_mutex_unlock(&self->file_write_mutex);
+ return found;
+}
diff --git a/src/encoder/video/nvenc.c b/src/encoder/video/nvenc.c
index e83d0e8..5f578c2 100644
--- a/src/encoder/video/nvenc.c
+++ b/src/encoder/video/nvenc.c
@@ -65,21 +65,6 @@ static bool gsr_video_encoder_nvenc_setup_context(gsr_video_encoder_nvenc *self,
return true;
}
-static unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format) {
- unsigned int texture_id = 0;
- egl->glGenTextures(1, &texture_id);
- egl->glBindTexture(GL_TEXTURE_2D, texture_id);
- egl->glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
-
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-
- egl->glBindTexture(GL_TEXTURE_2D, 0);
- return texture_id;
-}
-
static bool cuda_register_opengl_texture(gsr_cuda *cuda, CUgraphicsResource *cuda_graphics_resource, CUarray *mapped_array, unsigned int texture_id) {
CUresult res;
res = cuda->cuGraphicsGLRegisterImage(cuda_graphics_resource, texture_id, GL_TEXTURE_2D, CU_GRAPHICS_REGISTER_FLAGS_NONE);
@@ -110,7 +95,7 @@ static bool gsr_video_encoder_nvenc_setup_textures(gsr_video_encoder_nvenc *self
const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size
for(int i = 0; i < 2; ++i) {
- self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i]);
+ self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i], GL_NEAREST);
if(self->target_textures[i] == 0) {
fprintf(stderr, "gsr error: gsr_video_encoder_nvenc_setup_textures: failed to create opengl texture\n");
return false;
@@ -138,6 +123,18 @@ static bool gsr_video_encoder_nvenc_start(gsr_video_encoder *encoder, AVCodecCon
return false;
}
+ video_codec_context->width = FFALIGN(video_codec_context->width, 2);
+ video_codec_context->height = FFALIGN(video_codec_context->height, 2);
+
+ if(video_codec_context->width < 128)
+ video_codec_context->width = 128;
+
+ if(video_codec_context->height < 128)
+ video_codec_context->height = 128;
+
+ frame->width = video_codec_context->width;
+ frame->height = video_codec_context->height;
+
if(!gsr_video_encoder_nvenc_setup_context(self, video_codec_context)) {
gsr_video_encoder_nvenc_stop(self, video_codec_context);
return false;
diff --git a/src/encoder/video/software.c b/src/encoder/video/software.c
index be227f2..d8d9828 100644
--- a/src/encoder/video/software.c
+++ b/src/encoder/video/software.c
@@ -1,5 +1,6 @@
#include "../../../include/encoder/video/software.h"
#include "../../../include/egl.h"
+#include "../../../include/utils.h"
#include <libavcodec/avcodec.h>
#include <libavutil/frame.h>
@@ -14,21 +15,6 @@ typedef struct {
unsigned int target_textures[2];
} gsr_video_encoder_software;
-static unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format) {
- unsigned int texture_id = 0;
- egl->glGenTextures(1, &texture_id);
- egl->glBindTexture(GL_TEXTURE_2D, texture_id);
- egl->glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
-
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-
- egl->glBindTexture(GL_TEXTURE_2D, 0);
- return texture_id;
-}
-
static bool gsr_video_encoder_software_setup_textures(gsr_video_encoder_software *self, AVCodecContext *video_codec_context, AVFrame *frame) {
int res = av_frame_get_buffer(frame, LINESIZE_ALIGNMENT);
if(res < 0) {
@@ -48,7 +34,7 @@ static bool gsr_video_encoder_software_setup_textures(gsr_video_encoder_software
const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size
for(int i = 0; i < 2; ++i) {
- self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i]);
+ self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i], GL_NEAREST);
if(self->target_textures[i] == 0) {
fprintf(stderr, "gsr error: gsr_capture_kms_setup_cuda_textures: failed to create opengl texture\n");
return false;
@@ -85,20 +71,19 @@ void gsr_video_encoder_software_stop(gsr_video_encoder_software *self, AVCodecCo
}
static void gsr_video_encoder_software_copy_textures_to_frame(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion) {
- gsr_video_encoder_software *self = encoder->priv;
+ (void)encoder;
+ //gsr_video_encoder_software *self = encoder->priv;
// TODO: hdr support
const unsigned int formats[2] = { GL_RED, GL_RG };
+ const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size
for(int i = 0; i < 2; ++i) {
- self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[i]);
- // We could use glGetTexSubImage and then we wouldn't have to use a specific linesize (LINESIZE_ALIGNMENT) that adds padding,
- // but glGetTexSubImage is only available starting from opengl 4.5.
- self->params.egl->glGetTexImage(GL_TEXTURE_2D, 0, formats[i], GL_UNSIGNED_BYTE, frame->data[i]);
+ // TODO: Use glPixelStore?
+ gsr_color_conversion_read_destination_texture(color_conversion, i, 0, 0, frame->width / div[i], frame->height / div[i], formats[i], GL_UNSIGNED_BYTE, frame->data[i]);
}
- self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
// cap_kms->kms.base.egl->eglSwapBuffers(cap_kms->kms.base.egl->egl_display, cap_kms->kms.base.egl->egl_surface);
- self->params.egl->glFlush();
- self->params.egl->glFinish();
+ //self->params.egl->glFlush();
+ //self->params.egl->glFinish();
}
static void gsr_video_encoder_software_get_textures(gsr_video_encoder *encoder, unsigned int *textures, int *num_textures, gsr_destination_color *destination_color) {
diff --git a/src/encoder/video/vaapi.c b/src/encoder/video/vaapi.c
index d558785..0daf4d8 100644
--- a/src/encoder/video/vaapi.c
+++ b/src/encoder/video/vaapi.c
@@ -121,10 +121,8 @@ static bool gsr_video_encoder_vaapi_setup_textures(gsr_video_encoder_vaapi *self
}
self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[i]);
- self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
while(self->params.egl->glGetError()) {}
while(self->params.egl->eglGetError() != EGL_SUCCESS){}
@@ -167,32 +165,21 @@ static bool gsr_video_encoder_vaapi_start(gsr_video_encoder *encoder, AVCodecCon
} else {
video_codec_context->height = FFALIGN(video_codec_context->height, 16);
}
+ } else {
+ video_codec_context->width = FFALIGN(video_codec_context->width, 2);
+ video_codec_context->height = FFALIGN(video_codec_context->height, 2);
}
- const int crop_top = (video_codec_context->height - frame->height) / 2;
- const int crop_left = (video_codec_context->width - frame->width) / 2;
- if(crop_top != 0 || crop_left != 0) {
+ if(FFALIGN(video_codec_context->width, 2) != FFALIGN(frame->width, 2) || FFALIGN(video_codec_context->height, 2) != FFALIGN(frame->height, 2)) {
fprintf(stderr, "gsr warning: gsr_video_encoder_vaapi_start: black bars have been added to the video because of a bug in AMD drivers/hardware. Record with h264 codec instead (-k h264) to get around this issue\n");
-#if 0
- #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(61, 10, 100)
- const int crop_bottom = crop_top;
- const int crop_right = crop_left;
- fprintf(stderr, "gsr info: cropping metadata has been added to the file to try and workaround this issue. Video players that support this will remove the black bars when the video is playing\n");
- const int frame_cropping_data_size = 4 * sizeof(uint32_t);
- uint8_t *frame_cropping = av_malloc(frame_cropping_data_size);
- if(frame_cropping) {
- AV_WL32(frame_cropping + 0, crop_top);
- AV_WL32(frame_cropping + 4, crop_bottom);
- AV_WL32(frame_cropping + 8, crop_left);
- AV_WL32(frame_cropping + 12, crop_right);
- const bool sidedata_added = av_packet_side_data_add(&video_stream->codecpar->coded_side_data, &video_stream->codecpar->nb_coded_side_data, AV_PKT_DATA_FRAME_CROPPING, frame_cropping, frame_cropping_data_size, 0) != NULL;
- if(!sidedata_added)
- av_free(frame_cropping);
- }
- #endif
-#endif
}
+ if(video_codec_context->width < 128)
+ video_codec_context->width = 128;
+
+ if(video_codec_context->height < 128)
+ video_codec_context->height = 128;
+
frame->width = video_codec_context->width;
frame->height = video_codec_context->height;
diff --git a/src/encoder/video/video.c b/src/encoder/video/video.c
index 76d53b0..ce3b61b 100644
--- a/src/encoder/video/video.c
+++ b/src/encoder/video/video.c
@@ -1,4 +1,5 @@
#include "../../../include/encoder/video/video.h"
+
#include <assert.h>
bool gsr_video_encoder_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) {
@@ -9,6 +10,12 @@ bool gsr_video_encoder_start(gsr_video_encoder *encoder, AVCodecContext *video_c
return res;
}
+void gsr_video_encoder_destroy(gsr_video_encoder *encoder, AVCodecContext *video_codec_context) {
+ assert(encoder->started);
+ encoder->started = false;
+ encoder->destroy(encoder, video_codec_context);
+}
+
void gsr_video_encoder_copy_textures_to_frame(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion) {
assert(encoder->started);
if(encoder->copy_textures_to_frame)
@@ -19,8 +26,3 @@ void gsr_video_encoder_get_textures(gsr_video_encoder *encoder, unsigned int *te
assert(encoder->started);
encoder->get_textures(encoder, textures, num_textures, destination_color);
}
-
-void gsr_video_encoder_destroy(gsr_video_encoder *encoder, AVCodecContext *video_codec_context) {
- assert(encoder->started);
- encoder->destroy(encoder, video_codec_context);
-}
diff --git a/src/encoder/video/vulkan.c b/src/encoder/video/vulkan.c
index 0b6c380..802934d 100644
--- a/src/encoder/video/vulkan.c
+++ b/src/encoder/video/vulkan.c
@@ -8,33 +8,22 @@
//#include <vulkan/vulkan_core.h>
+#define GL_HANDLE_TYPE_OPAQUE_FD_EXT 0x9586
#define GL_TEXTURE_TILING_EXT 0x9580
#define GL_OPTIMAL_TILING_EXT 0x9584
#define GL_LINEAR_TILING_EXT 0x9585
-#define GL_PIXEL_PACK_BUFFER 0x88EB
-#define GL_PIXEL_UNPACK_BUFFER 0x88EC
-#define GL_STREAM_READ 0x88E1
-#define GL_STREAM_DRAW 0x88E0
-#define GL_READ_ONLY 0x88B8
-#define GL_WRITE_ONLY 0x88B9
-#define GL_READ_FRAMEBUFFER 0x8CA8
-
typedef struct {
gsr_video_encoder_vulkan_params params;
unsigned int target_textures[2];
AVBufferRef *device_ctx;
- AVVulkanDeviceContext* vv;
- unsigned int pbo_y[2];
- unsigned int pbo_uv[2];
- AVFrame *sw_frame;
} gsr_video_encoder_vulkan;
static bool gsr_video_encoder_vulkan_setup_context(gsr_video_encoder_vulkan *self, AVCodecContext *video_codec_context) {
AVDictionary *options = NULL;
//av_dict_set(&options, "linear_images", "1", 0);
//av_dict_set(&options, "disable_multiplane", "1", 0);
-
+#if 0
// TODO: Use correct device
if(av_hwdevice_ctx_create(&self->device_ctx, AV_HWDEVICE_TYPE_VULKAN, NULL, options, 0) < 0) {
fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_context: failed to create hardware device context\n");
@@ -68,25 +57,10 @@ static bool gsr_video_encoder_vulkan_setup_context(gsr_video_encoder_vulkan *sel
video_codec_context->hw_frames_ctx = av_buffer_ref(frame_context);
av_buffer_unref(&frame_context);
+#endif
return true;
}
-static unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format) {
- unsigned int texture_id = 0;
- egl->glGenTextures(1, &texture_id);
- egl->glBindTexture(GL_TEXTURE_2D, texture_id);
- //egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_TILING_EXT, GL_OPTIMAL_TILING_EXT);
- egl->glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
-
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-
- egl->glBindTexture(GL_TEXTURE_2D, 0);
- return texture_id;
-}
-
static AVVulkanDeviceContext* video_codec_context_get_vulkan_data(AVCodecContext *video_codec_context) {
AVBufferRef *hw_frames_ctx = video_codec_context->hw_frames_ctx;
if(!hw_frames_ctx)
@@ -100,6 +74,24 @@ static AVVulkanDeviceContext* video_codec_context_get_vulkan_data(AVCodecContext
return (AVVulkanDeviceContext*)device_context->hwctx;
}
+static uint32_t get_memory_type_idx(VkPhysicalDevice pdev, const VkMemoryRequirements *mem_reqs, VkMemoryPropertyFlagBits prop_flags, PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties) {
+ VkPhysicalDeviceMemoryProperties pdev_mem_props;
+ uint32_t i;
+
+ vkGetPhysicalDeviceMemoryProperties(pdev, &pdev_mem_props);
+
+ for (i = 0; i < pdev_mem_props.memoryTypeCount; i++) {
+ const VkMemoryType *type = &pdev_mem_props.memoryTypes[i];
+
+ if ((mem_reqs->memoryTypeBits & (1 << i)) &&
+ (type->propertyFlags & prop_flags) == prop_flags) {
+ return i;
+ break;
+ }
+ }
+ return UINT32_MAX;
+}
+
static bool gsr_video_encoder_vulkan_setup_textures(gsr_video_encoder_vulkan *self, AVCodecContext *video_codec_context, AVFrame *frame) {
const int res = av_hwframe_get_buffer(video_codec_context->hw_frames_ctx, frame, 0);
if(res < 0) {
@@ -107,56 +99,133 @@ static bool gsr_video_encoder_vulkan_setup_textures(gsr_video_encoder_vulkan *se
return false;
}
- //AVVkFrame *target_surface_id = (AVVkFrame*)frame->data[0];
- self->vv = video_codec_context_get_vulkan_data(video_codec_context);
+ while(self->params.egl->glGetError()) {}
+#if 0
+ AVVkFrame *target_surface_id = (AVVkFrame*)frame->data[0];
+ AVVulkanDeviceContext* vv = video_codec_context_get_vulkan_data(video_codec_context);
+ const size_t luma_size = frame->width * frame->height;
+ if(vv) {
+ PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)vv->get_proc_addr(vv->inst, "vkGetImageMemoryRequirements");
+ PFN_vkAllocateMemory vkAllocateMemory = (PFN_vkAllocateMemory)vv->get_proc_addr(vv->inst, "vkAllocateMemory");
+ PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)vv->get_proc_addr(vv->inst, "vkGetPhysicalDeviceMemoryProperties");
+ PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = (PFN_vkGetMemoryFdKHR)vv->get_proc_addr(vv->inst, "vkGetMemoryFdKHR");
+
+ VkMemoryRequirements mem_reqs = {0};
+ vkGetImageMemoryRequirements(vv->act_dev, target_surface_id->img[0], &mem_reqs);
+
+ fprintf(stderr, "size: %lu, alignment: %lu, memory bits: 0x%08x\n", mem_reqs.size, mem_reqs.alignment, mem_reqs.memoryTypeBits);
+ VkDeviceMemory mem;
+ {
+ VkExportMemoryAllocateInfo exp_mem_info;
+ VkMemoryAllocateInfo mem_alloc_info;
+ VkMemoryDedicatedAllocateInfoKHR ded_info;
+
+ memset(&exp_mem_info, 0, sizeof(exp_mem_info));
+ exp_mem_info.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
+ exp_mem_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
+
+ memset(&ded_info, 0, sizeof(ded_info));
+ ded_info.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
+ ded_info.image = target_surface_id->img[0];
+
+ exp_mem_info.pNext = &ded_info;
+
+ memset(&mem_alloc_info, 0, sizeof(mem_alloc_info));
+ mem_alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+ mem_alloc_info.pNext = &exp_mem_info;
+ mem_alloc_info.allocationSize = target_surface_id->size[0];
+ mem_alloc_info.memoryTypeIndex = get_memory_type_idx(vv->phys_dev, &mem_reqs, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, vkGetPhysicalDeviceMemoryProperties);
+
+ if (mem_alloc_info.memoryTypeIndex == UINT32_MAX) {
+ fprintf(stderr, "No suitable memory type index found.\n");
+ return VK_NULL_HANDLE;
+ }
+
+ if (vkAllocateMemory(vv->act_dev, &mem_alloc_info, 0, &mem) !=
+ VK_SUCCESS)
+ return VK_NULL_HANDLE;
+
+ fprintf(stderr, "memory: %p\n", (void*)mem);
- const unsigned int internal_formats_nv12[2] = { GL_RGBA8, GL_RGBA8 };
- const unsigned int internal_formats_p010[2] = { GL_R16, GL_RG16 };
- const unsigned int formats[2] = { GL_RED, GL_RG };
- const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size
+ }
- for(int i = 0; i < 2; ++i) {
- self->target_textures[i] = gl_create_texture(self->params.egl, video_codec_context->width / div[i], video_codec_context->height / div[i], self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i]);
- if(self->target_textures[i] == 0) {
- fprintf(stderr, "gsr error: gsr_video_encoder_cuda_setup_textures: failed to create opengl texture\n");
- return false;
+ fprintf(stderr, "target surface id: %p, %zu, %zu\n", (void*)target_surface_id->mem[0], target_surface_id->offset[0], target_surface_id->offset[1]);
+ fprintf(stderr, "vkGetMemoryFdKHR: %p\n", (void*)vkGetMemoryFdKHR);
+
+ int fd = 0;
+ VkMemoryGetFdInfoKHR fd_info;
+ memset(&fd_info, 0, sizeof(fd_info));
+ fd_info.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR;
+ fd_info.memory = target_surface_id->mem[0];
+ fd_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
+ if(vkGetMemoryFdKHR(vv->act_dev, &fd_info, &fd) != VK_SUCCESS) {
+ fprintf(stderr, "failed!\n");
+ } else {
+ fprintf(stderr, "fd: %d\n", fd);
}
- }
- self->params.egl->glGenBuffers(2, self->pbo_y);
+ fprintf(stderr, "glImportMemoryFdEXT: %p, size: %zu\n", (void*)self->params.egl->glImportMemoryFdEXT, target_surface_id->size[0]);
+ const int tiling = target_surface_id->tiling == VK_IMAGE_TILING_LINEAR ? GL_LINEAR_TILING_EXT : GL_OPTIMAL_TILING_EXT;
+
+ if(tiling != GL_OPTIMAL_TILING_EXT) {
+ fprintf(stderr, "tiling %d is not supported, only GL_OPTIMAL_TILING_EXT (%d) is supported\n", tiling, GL_OPTIMAL_TILING_EXT);
+ }
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, self->pbo_y[0]);
- self->params.egl->glBufferData(GL_PIXEL_PACK_BUFFER, frame->width * frame->height, 0, GL_STREAM_READ);
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, self->pbo_y[1]);
- self->params.egl->glBufferData(GL_PIXEL_PACK_BUFFER, frame->width * frame->height, 0, GL_STREAM_READ);
+ unsigned int gl_memory_obj = 0;
+ self->params.egl->glCreateMemoryObjectsEXT(1, &gl_memory_obj);
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+ //const int dedicated = GL_TRUE;
+ //self->params.egl->glMemoryObjectParameterivEXT(gl_memory_obj, GL_DEDICATED_MEMORY_OBJECT_EXT, &dedicated);
- self->params.egl->glGenBuffers(2, self->pbo_uv);
+ self->params.egl->glImportMemoryFdEXT(gl_memory_obj, target_surface_id->size[0], GL_HANDLE_TYPE_OPAQUE_FD_EXT, fd);
+ if(!self->params.egl->glIsMemoryObjectEXT(gl_memory_obj))
+ fprintf(stderr, "failed to create object!\n");
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, self->pbo_uv[0]);
- self->params.egl->glBufferData(GL_PIXEL_PACK_BUFFER, (frame->width/2 * frame->height/2) * 2, 0, GL_STREAM_READ);
+ fprintf(stderr, "gl memory obj: %u, error: %d\n", gl_memory_obj, self->params.egl->glGetError());
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, self->pbo_uv[1]);
- self->params.egl->glBufferData(GL_PIXEL_PACK_BUFFER, (frame->width/2 * frame->height/2) * 2, 0, GL_STREAM_READ);
+ // fprintf(stderr, "0 gl error: %d\n", self->params.egl->glGetError());
+ // unsigned int vertex_buffer = 0;
+ // self->params.egl->glGenBuffers(1, &vertex_buffer);
+ // self->params.egl->glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
+ // self->params.egl->glBufferStorageMemEXT(GL_ARRAY_BUFFER, target_surface_id->size[0], gl_memory_obj, target_surface_id->offset[0]);
+ // fprintf(stderr, "1 gl error: %d\n", self->params.egl->glGetError());
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+ // fprintf(stderr, "0 gl error: %d\n", self->params.egl->glGetError());
+ // unsigned int buffer = 0;
+ // self->params.egl->glCreateBuffers(1, &buffer);
+ // self->params.egl->glNamedBufferStorageMemEXT(buffer, target_surface_id->size[0], gl_memory_obj, target_surface_id->offset[0]);
+ // fprintf(stderr, "1 gl error: %d\n", self->params.egl->glGetError());
- self->sw_frame = av_frame_alloc();
- self->sw_frame->format = AV_PIX_FMT_NV12;
- self->sw_frame->width = frame->width;
- self->sw_frame->height = frame->height;
+ self->params.egl->glGenTextures(1, &self->target_textures[0]);
+ self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[0]);
- // TODO: Remove
- if(av_frame_get_buffer(self->sw_frame, 0) < 0) {
- fprintf(stderr, "failed to allocate sw frame\n");
- }
+ fprintf(stderr, "1 gl error: %d\n", self->params.egl->glGetError());
+ self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_TILING_EXT, tiling);
- // TODO: Remove
- if(av_frame_make_writable(self->sw_frame) < 0) {
- fprintf(stderr, "failed to make writable\n");
- }
+ fprintf(stderr, "tiling: %d\n", tiling);
+
+ fprintf(stderr, "2 gl error: %d\n", self->params.egl->glGetError());
+ self->params.egl->glTexStorageMem2DEXT(GL_TEXTURE_2D, 1, GL_R8, frame->width, frame->height, gl_memory_obj, target_surface_id->offset[0]);
+
+ fprintf(stderr, "3 gl error: %d\n", self->params.egl->glGetError());
+ self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
+
+ self->params.egl->glGenTextures(1, &self->target_textures[1]);
+ self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[1]);
+
+ fprintf(stderr, "1 gl error: %d\n", self->params.egl->glGetError());
+ self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_TILING_EXT, tiling);
+
+ fprintf(stderr, "tiling: %d\n", tiling);
+
+ fprintf(stderr, "2 gl error: %d\n", self->params.egl->glGetError());
+ self->params.egl->glTexStorageMem2DEXT(GL_TEXTURE_2D, 1, GL_RG8, frame->width/2, frame->height/2, gl_memory_obj, target_surface_id->offset[0] + luma_size);
+
+ fprintf(stderr, "3 gl error: %d\n", self->params.egl->glGetError());
+ self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
+ }
+#endif
return true;
}
@@ -165,6 +234,18 @@ static void gsr_video_encoder_vulkan_stop(gsr_video_encoder_vulkan *self, AVCode
static bool gsr_video_encoder_vulkan_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) {
gsr_video_encoder_vulkan *self = encoder->priv;
+ video_codec_context->width = FFALIGN(video_codec_context->width, 2);
+ video_codec_context->height = FFALIGN(video_codec_context->height, 2);
+
+ if(video_codec_context->width < 128)
+ video_codec_context->width = 128;
+
+ if(video_codec_context->height < 128)
+ video_codec_context->height = 128;
+
+ frame->width = video_codec_context->width;
+ frame->height = video_codec_context->height;
+
if(!gsr_video_encoder_vulkan_setup_context(self, video_codec_context)) {
gsr_video_encoder_vulkan_stop(self, video_codec_context);
return false;
@@ -189,91 +270,6 @@ void gsr_video_encoder_vulkan_stop(gsr_video_encoder_vulkan *self, AVCodecContex
av_buffer_unref(&self->device_ctx);
}
-static void nop_free(void *opaque, uint8_t *data) {
-
-}
-
-static void gsr_video_encoder_vulkan_copy_textures_to_frame(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion) {
- gsr_video_encoder_vulkan *self = encoder->priv;
-
- static int counter = 0;
- ++counter;
-
- // AVBufferRef *av_buffer_create(uint8_t *data, size_t size,
- // void (*free)(void *opaque, uint8_t *data),
- // void *opaque, int flags);
-
- while(self->params.egl->glGetError()){}
- self->params.egl->glBindFramebuffer(GL_READ_FRAMEBUFFER, color_conversion->framebuffers[0]);
- //fprintf(stderr, "1 gl err: %d\n", self->params.egl->glGetError());
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, self->pbo_y[counter % 2]);
- self->params.egl->glBufferData(GL_PIXEL_PACK_BUFFER, frame->width * frame->height, 0, GL_STREAM_READ);
- self->params.egl->glReadPixels(0, 0, frame->width, frame->height, GL_RED, GL_UNSIGNED_BYTE, 0);
- //fprintf(stderr, "2 gl err: %d\n", self->params.egl->glGetError());
-
- const int next_pbo_y = (counter + 1) % 2;
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, self->pbo_y[next_pbo_y]);
- self->params.egl->glBufferData(GL_PIXEL_PACK_BUFFER, frame->width * frame->height, 0, GL_STREAM_READ);
- //fprintf(stderr, "3 gl err: %d\n", self->params.egl->glGetError());
- uint8_t *ptr_y = (uint8_t*)self->params.egl->glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY);
- //fprintf(stderr, "4 gl err: %d\n", self->params.egl->glGetError());
- if(!ptr_y) {
- fprintf(stderr, "failed to map buffer y!\n");
- }
-
- while(self->params.egl->glGetError()){}
- self->params.egl->glBindFramebuffer(GL_READ_FRAMEBUFFER, color_conversion->framebuffers[1]);
- //fprintf(stderr, "5 gl err: %d\n", self->params.egl->glGetError());
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, self->pbo_uv[counter % 2]);
- self->params.egl->glBufferData(GL_PIXEL_PACK_BUFFER, (frame->width/2 * frame->height/2) * 2, 0, GL_STREAM_READ);
- //fprintf(stderr, "5.5 gl err: %d\n", self->params.egl->glGetError());
- self->params.egl->glReadPixels(0, 0, frame->width/2, frame->height/2, GL_RG, GL_UNSIGNED_BYTE, 0);
- //fprintf(stderr, "6 gl err: %d\n", self->params.egl->glGetError());
-
- const int next_pbo_uv = (counter + 1) % 2;
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, self->pbo_uv[next_pbo_uv]);
- self->params.egl->glBufferData(GL_PIXEL_PACK_BUFFER, (frame->width/2 * frame->height/2) * 2, 0, GL_STREAM_READ);
- //fprintf(stderr, "7 gl err: %d\n", self->params.egl->glGetError());
- uint8_t *ptr_uv = (uint8_t*)self->params.egl->glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY);
- //fprintf(stderr, "8 gl err: %d\n", self->params.egl->glGetError());
- if(!ptr_uv) {
- fprintf(stderr, "failed to map buffer uv!\n");
- }
-
- //self->sw_frame->buf[0] = av_buffer_create(ptr_y, 3840 * 2160, nop_free, NULL, 0);
- //self->sw_frame->buf[1] = av_buffer_create(ptr_uv, 1920 * 1080 * 2, nop_free, NULL, 0);
- //self->sw_frame->data[0] = self->sw_frame->buf[0]->data;
- //self->sw_frame->data[1] = self->sw_frame->buf[1]->data;
- //self->sw_frame->extended_data[0] = self->sw_frame->data[0];
- //self->sw_frame->extended_data[1] = self->sw_frame->data[1];
-
- self->sw_frame->data[0] = ptr_y;
- self->sw_frame->data[1] = ptr_uv;
-
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
- self->params.egl->glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
-
- //self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[1]);
- //self->params.egl->glGetTexImage(GL_TEXTURE_2D, 0, GL_RG, GL_UNSIGNED_BYTE, sw_frame->data[1]);
-
- //self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
-
- int ret = av_hwframe_transfer_data(frame, self->sw_frame, 0);
- if(ret < 0) {
- fprintf(stderr, "transfer data failed, error: %s\n", av_err2str(ret));
- }
-
- //av_buffer_unref(&self->sw_frame->buf[0]);
- //av_buffer_unref(&self->sw_frame->buf[1]);
-
- //av_frame_free(&sw_frame);
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, self->pbo_y[next_pbo_y]);
- self->params.egl->glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, self->pbo_y[next_pbo_uv]);
- self->params.egl->glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
- self->params.egl->glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-}
-
static void gsr_video_encoder_vulkan_get_textures(gsr_video_encoder *encoder, unsigned int *textures, int *num_textures, gsr_destination_color *destination_color) {
gsr_video_encoder_vulkan *self = encoder->priv;
textures[0] = self->target_textures[0];
@@ -303,7 +299,7 @@ gsr_video_encoder* gsr_video_encoder_vulkan_create(const gsr_video_encoder_vulka
*encoder = (gsr_video_encoder) {
.start = gsr_video_encoder_vulkan_start,
- .copy_textures_to_frame = gsr_video_encoder_vulkan_copy_textures_to_frame,
+ .copy_textures_to_frame = NULL,
.get_textures = gsr_video_encoder_vulkan_get_textures,
.destroy = gsr_video_encoder_vulkan_destroy,
.priv = encoder_vulkan
generated by cgit v1.2.3-70-g09d2 (git 2.48.1) at 2025-07-01 03:22:12 +0000