Проверь мне надо сохранить картинку с нарисованными объектами while (task->queuesize >…
- User
Проверь мне надо сохранить картинку с нарисованными объектами
while (task->queue_size > 0) { uint64_t frame_time = start_ns();
pthread_mutex_lock(&task->queue_mutex); AVFrame *frame = task->frame_queue[task->read_pos]; task->read_pos = (task->read_pos + 1) % MAX_FRAMES_QUEUE; task->queue_size--; pthread_mutex_unlock(&task->queue_mutex); resize_and_copy_frame_to_input(frame, &rknn_ctx); ret = rknn_run( rknn_ctx.ctx, NULL); if (ret >= 0) { post_process((int8_t *)rknn_ctx.output_mems[0]->virt_addr, (int8_t *)rknn_ctx.output_mems[1]->virt_addr, (int8_t *)rknn_ctx.output_mems[2]->virt_addr, rknn_ctx.img_height, rknn_ctx.img_width, BOX_THRESH, NMS_THRESH, (float)rknn_ctx.img_width / rknn_ctx.img_width, (float)rknn_ctx.img_height / rknn_ctx.img_height, rknn_ctx.out_zps, rknn_ctx.out_scales, &detect_result_group); uint8_t *img = (uint8_t *)rknn_ctx.input_mem->virt_addr; int width = rknn_ctx.img_width; int height = rknn_ctx.img_height; for (int i = 0; i < detect_result_group.count; i++) { detect_result_t *det = &detect_result_group.results[i]; // Рисуем красную рамку вокруг объекта draw_rect_rgb(img, width, height, det->box.left, det->box.top, det->box.right, det->box.bottom, 255, 0, 0); } // После этого можно сохранять изображение save_frame_as_jpeg(frame, width, height, counter); /* for (int i = 0; i < detect_result_group.count; i++) { detect_result_t *det = &detect_result_group.results[i]; printf("Detected %s at [%d, %d, %d, %d] confidence: %.2f%%\n", det->name, det->box.left, det->box.top, det->box.right, det->box.bottom, det->prop * 100); } */ } av_frame_free(&frame); // Освобождаем кадр после обработки printf( "%s: %d - RKNN %s / Найдено %d\r\n", GLOBAL_TIME_PRINT(), counter, stop_ms(frame_time), detect_result_group.count ); counter++; }void draw_rect_rgb(uint8_t *img, int width, int height, int left, int top, int right, int bottom, uint8_t r, uint8_t g, uint8_t b) { // Ограничим координаты, чтобы не выйти за пределы if(left < 0) left = 0; if(top < 0) top = 0; if(right >= width) right = width - 1; if(bottom >= height) bottom = height - 1;
// Толщина рамки 1 пиксель for (int x = left; x <= right; x++) { // Верхняя линия int idx_top = (top*width + x)*3; img[idx_top] = r; img[idx_top + 1] = g; img[idx_top + 2] = b; // Нижняя линия int idx_bottom = (bottom*width + x)*3; img[idx_bottom] = r; img[idx_bottom + 1] = g; img[idx_bottom + 2] = b; } for (int y = top; y <= bottom; y++) { // Левая линия int idx_left = (y*width + left)*3; img[idx_left] = r; img[idx_left + 1] = g; img[idx_left + 2] = b; // Правая линия int idx_right = (y*width + right)*3; img[idx_right] = r; img[idx_right + 1] = g; img[idx_right + 2] = b; }}
- Assistant
Ваш код в целом выглядит логично — вы получаете фрейм, запускаете inference, рисуете прямоугольники и сохраняете изображение. Однако есть несколько важных моментов, которые стоит проверить и уточнить, чтобы убедиться, что картинка с нарисованными объектами действительно сохраняется корректно:
1. Формат изображения в
imgи используемый сdraw_rect_rgbimg— это указатель наrknn_ctx.input_mem->virt_addr, похоже, это raw RGB данные с 3 байтами на пиксель.- Вы в функции рисуете рамки, предполагая, что каждый пиксель — 3 байта RGB. Это корректно, если изображение дожно быть именно в RGB24 формате.
- Проверьте, что
rknn_ctx.input_memдействительно содержит RGB24 изображение во втором формате с шириной и высотой совпадающими сrknn_ctx.img_widthиrknn_ctx.img_height.
2. Что происходит в
save_frame_as_jpeg- Вы вызываете:
save_frame_as_jpeg(frame, width, height, counter); - Однако вы пишете рамки в
img(rknn_ctx.input_mem), а сохраняете кадрframe. - Обычно
AVFrameсодержит данные в формате YUV или другом формате, который не совпадает напрямую с вашимimg. - По сути вы рисуете поверх
img, но сохраняете исходныйframe, который к этому моменту не содержит ваших рамок.
Следовательно, если хотите сохранить изображение с рамками, нужно либо:
- Конвертировать
img(RGB) вAVFrameили структуру, которую принимаетsave_frame_as_jpeg, или - Реализовать сохранение JPEG напрямую из
imgс нарисованными рамками, либо - Нарисовать рамки непосредственно в данных
frame, если они в RGB формате.
3. Варианты исправления
Вариант 1: Сохранять из массива
imgРеализуйте функцию сохранения JPEG из
img, RGB24 буфера, например с помощью libjpeg.Примерная идея:
#include <jpeglib.h> void save_rgb_image_as_jpeg(const uint8_t *rgb_buf, int width, int height, const char *filename) { struct jpeg_compress_struct cinfo; struct jpeg_error_mgr jerr; FILE *outfile = fopen(filename, "wb"); if (!outfile) { fprintf(stderr, "Cannot open %s\n", filename); return; } cinfo.err = jpeg_std_error(&jerr); jpeg_create_compress(&cinfo); jpeg_stdio_dest(&cinfo, outfile); cinfo.image_width = width; cinfo.image_height = height; cinfo.input_components = 3; cinfo.in_color_space = JCS_RGB; jpeg_set_defaults(&cinfo); jpeg_start_compress(&cinfo, TRUE); JSAMPROW row_pointer[1]; int row_stride = width * 3; while (cinfo.next_scanline < cinfo.image_height) { row_pointer[0] = (JSAMPROW)&rgb_buf[cinfo.next_scanline * row_stride]; jpeg_write_scanlines(&cinfo, row_pointer, 1); } jpeg_finish_compress(&cinfo); jpeg_destroy_compress(&cinfo); fclose(outfile); }Затем вместо
save_frame_as_jpeg(frame, width, height, counter);делайте:char filename[256]; snprintf(filename, sizeof(filename), "frame_%04d.jpg", counter); save_rgb_image_as_jpeg(img, width, height, filename);Вариант 2: Нарисовать рамки поверх
AVFrameЭто сложнее, потому что формат кадра может быть YUV и придется делать конвертацию туда-обратно, либо сложную отрисовку.
4. Проверка правильной блокировки/освобождения
Ваш захват и освобождение кадра выглядит корректно.
Итог
- Ваша функция
draw_rect_rgbрисует наimg(raw RGB). - Вы сохраняете исходный
AVFrame frame, который не содержит ваших изменений. - Вам нужно сохранять изображение именно из
img, после того как нарисовали рамки. - Для этого сделайте сохранение JPEG из RGB напрямую (вариант 1).
Если нужно, могу помочь с реализацией функции сохранения JPEG из
img. - User
не функция сохранения именно такая save_frame_as_jpeg(AVFrame *pFrame, width, height, counter);
если pFrame- надо что-то подставить правильное
- Assistant
Спасибо за уточнение.
Если у вас есть функция
save_frame_as_jpeg(AVFrame *pFrame, int width, int height, int counter);и
pFrame— этоAVFrame *, то ваша проблема в том, что вы рисуете красные рамки в другом буфере — вrknn_ctx.input_mem->virt_addr(массиваimg), а сохраняете исходный кадрframe, который не был модифицирован.Чтобы ваша функция
save_frame_as_jpegсохранила изображение с нарисованными рамками, необходимо:- Нарисовать эти рамки в самом кадре
frame, либо - Обновить
frameданными изimg, в который нанесены рамки.
Вариант 1. Рисовать рамки в
frame- Если формат
frame— RGB (что маловероятно), то рисовать рамку можно аналогичноdraw_rect_rgbпрямо поframe->data[0]. - Если формат другой (например, YUV420p), то рисование рамки сложнее, надо либо преобразовать координаты, либо сделать conversion кадра в RGB, нарисовать рамку и сохранить.
Вариант 2. Обновить содержимое
frame->data[0]изimg- Предположим, что
frame->format— AV_PIX_FMT_RGB24. - Тогда можно сделать memcpy из
imgвframe->data[0].
Пример:
if (frame->format == AV_PIX_FMT_RGB24) { // Обычно AVFrame stride хранится в frame->linesize[0] // Обычно linesize[0] может быть >= ширина * 3, надо копировать построчно uint8_t *src_ptr = img; uint8_t *dst_ptr = frame->data[0]; int src_stride = width * 3; int dst_stride = frame->linesize[0]; for (int y = 0; y < height; y++) { memcpy(dst_ptr + y * dst_stride, src_ptr + y * src_stride, src_stride); } }После такого кадр
frameбудет содержать RGB с вашими нарисованными рамками, и вызовsave_frame_as_jpeg(frame, width, height, counter);сохранит нужное изображение.
Как проверить формат кадра?
Появится важный вопрос: в каком формате
frame?Вы можете проверить так:
printf("Frame format: %d\n", frame->format);Если формат не
AV_PIX_FMT_RGB24, скорее всегоframe— в YUV.В этом случае нужно выполнить конвертацию
img(RGB) обратно вframe(YUV) с помощьюsws_scale(swscale) или наоборот преобразовыватьframeв RGB, рисовать и сохранять.
Итог
У вас 3 варианта:
- Нарисовать рамки в самом
frame->data[0], если он в RGB24. - Копировать
img(с нарисованными рамками) вframe->data[0](тоже при условии RGB24). - Конвертировать RGB
imgв тот формат, что уframe, и положить вframeперед сохранением (наиболее универсальный, но сложный вариант).
Если хотите, я помогу с примером кода для конвертации RGB->YUV с swscale, чтобы обновить
frameперед сохранением. Просто скажите! - Нарисовать эти рамки в самом кадре
- User
Давай внимательнее вот я достал кадр и первел в ркнн AVFrame *frame = task->frame_queue[task->read_pos]; resize_and_copy_frame_to_input(frame, &rknn_ctx);
- Assistant
Спасибо за пояснение. Давайте разберемся подробнее по шагам.
Что происходит в вашем коде:
-
Вы достаете
AVFrame *frameиз очереди:AVFrame *frame = task->frame_queue[task->read_pos];Этот кадр, скорее всего, в формате, в котором он был получен (чаще всего YUV или другой формат, не RGB24).
-
Вы вызываете
resize_and_copy_frame_to_input(frame, &rknn_ctx);Эта функция, скорее всего, конвертирует
frameиз его исходного формата в RGB, изменяет размер (resize) и копирует данные картинки вrknn_ctx.input_mem->virt_addr(который у вас и называетсяimgдалее).То есть, именно в
rknn_ctx.input_mem->virt_addrи лежит RGB-картинка, на которой вы уже рисуете рамки. -
Далее вы запускаете inference и рисуете рамки именно в
img:uint8_t *img = (uint8_t *)rknn_ctx.input_mem->virt_addr; draw_rect_rgb(img, width, height, ...); -
Вы вызываете
save_frame_as_jpeg(frame, width, height, counter);— но при этом передаете исходный
frame, который не содержит ваших отрисованных рамок, потому что вы рисовали поверхimg, а не во фрейме.
Главное:
- Вы начальная картинка — это
frame; - Вы делаете конвертацию/resize и кладете в
img(RGB); - Рисуете рамки в
img; - Но потом для сохранения используете исходный
frameбез изменений.
Как правильно сохранить картинку с рамками?
Вариант 1 (предпочтительный):
- Сохранять не исходный
frame, а буферimgпосле рисования рамок! - Для этого нужно изменить функцию
save_frame_as_jpeg, чтобы она умела принимать прямо RGB буфер (не AVFrame), либо сделать промежуточныйAVFrameтолько для сохранения.
Если
save_frame_as_jpegвынуждена приниматьAVFrame, то можно создать новыйAVFrame, в который положитьimg(RGB данные), и передать этот новый кадр.Пример создания AVFrame из RGB буфера:
AVFrame *frame_rgb = av_frame_alloc(); frame_rgb->format = AV_PIX_FMT_RGB24; frame_rgb->width = width; frame_rgb->height = height; av_image_fill_arrays(frame_rgb->data, frame_rgb->linesize, img, AV_PIX_FMT_RGB24, width, height, 1);Потом вызываем
save_frame_as_jpeg(frame_rgb, width, height, counter);И освобождаем
frame_rgbпосле.
Вариант 2 (более сложный):
- Нарисовать рамки не в
img, а на самомframe.
Для этого нужно понимать формат
frame(смотритеframe->format) и делать отрисовку рамок именно в его данных (чтобы это было корректно в его цветовой модели — чаще всего YUV420p).Для этого заметно сложнее рисовать визуально — нужна конвертация координат, или проще:
- Сделать конвертацию исходного
frameв RGB; - Нарисовать рамки;
- Сохранить RGB изображение.
Вывод
Самый простой и надежный способ:
// 1. Достаете кадр AVFrame *frame = task->frame_queue[task->read_pos]; // 2. Вызываете resize_and_copy_frame_to_input(frame, &rknn_ctx); // В rknn_ctx.input_mem->virt_addr лежит rgb24 изображение в img // 3. Рисуете рамки поверх img draw_rect_rgb(img, width, height, ...); // 4. Создаете новый AVFrame поверх img AVFrame *frame_rgb = av_frame_alloc(); frame_rgb->format = AV_PIX_FMT_RGB24; frame_rgb->width = width; frame_rgb->height = height; av_image_fill_arrays(frame_rgb->data, frame_rgb->linesize, img, AV_PIX_FMT_RGB24, width, height, 1); // 5. Сохраняете JPEG save_frame_as_jpeg(frame_rgb, width, height, counter); // 6. Освобождаете frame_rgb av_frame_free(&frame_rgb); // 7. Освобождаете исходный frame av_frame_free(&frame);
Если
save_frame_as_jpegу вас требует YUV кадр, тогда после рисования рамок в RGB нужно сделать обратную конвертацию RGB->YUV (через sws_scale) и положить результат вframe.Могу помочь с этим тоже, если нужно.
-
- User
вот так я аперевел
void resize_and_copy_frame_to_input(AVFrame *rgb_frame, RKNNContext *rknn_ctx) { int width = rknn_ctx->img_width; int height = rknn_ctx->img_height; int channels = 3; // RGB24 uint8_t *dst_ptr = (uint8_t *)rknn_ctx->input_mem->virt_addr; int stride = rknn_ctx->input_attr.w_stride;
if (stride == width) { memcpy(dst_ptr, rgb_frame->data[0], width * height * channels); } else { int src_stride = rgb_frame->linesize[0]; for (int h = 0; h < height; ++h) { memcpy(dst_ptr + h * stride * channels, rgb_frame->data[0] + h * src_stride, width * channels); } }}
- Assistant
Спасибо за дополнение!
Что у вас сейчас происходит:
resize_and_copy_frame_to_input()получаетAVFrame *rgb_frame, формат которого уже RGB24 (важно!).- Она копирует данные из
rgb_frame->data[0]в буферrknn_ctx->input_mem->virt_addr(вашimg), учитывая stride.
Ключевой момент:
- Значит, исходный
frameизtask->frame_queueсначала конвертируется в RGB кадр и передается вresize_and_copy_frame_to_input(). - Это означает, что
rgb_frame— уже RGB24, с правильными размерами. - После этого вы рисуете рамки в
img. - Для сохранения нужно использовать точно тот же RGB24 буфер, на который вы нарисовали рамки.
Практическое решение для сохранения:
1. Создайте новый
AVFrameповерх вашего RGB буфераimg:AVFrame *frame_to_save = av_frame_alloc(); frame_to_save->format = AV_PIX_FMT_RGB24; frame_to_save->width = rknn_ctx->img_width; frame_to_save->height = rknn_ctx->img_height; av_image_fill_arrays(frame_to_save->data, frame_to_save->linesize, (uint8_t *)rknn_ctx->input_mem->virt_addr, AV_PIX_FMT_RGB24, frame_to_save->width, frame_to_save->height, 1);2. Вызовите сохранение:
save_frame_as_jpeg(frame_to_save, frame_to_save->width, frame_to_save->height, counter);3. Освободите
frame_to_save:av_frame_free(&frame_to_save);
Почему так?
- Ваш
rgb_frame(в функциюresize_and_copy_frame_to_input) иrknn_ctx->input_mem->virt_addr— разные объекты данных. - Рамки нарисованы именно в
rknn_ctx->input_mem->virt_addr. - Исходный
frameиз очереди у вас, как я понял, формат не RGB и с рамками не связан. - Следовательно, кадр, который нужно сохранять — это именно RGB кадр с рамками, хранящийся в
rknn_ctx->input_mem->virt_addr.
Итог
В вашем основном коде (псевдо):
while (...) { AVFrame *frame = task->frame_queue[task->read_pos]; // frame, вероятно, в YUV или raw - у вас есть RGB версия - передаете туда resize_and_copy_frame_to_input(frame, &rknn_ctx); // Теперь rknn_ctx.input_mem->virt_addr содержит RGB данные // Запускаете обработку rknn_run(...); post_process(...); // Рисуете рамки в rknn_ctx.input_mem->virt_addr uint8_t *img = (uint8_t *)rknn_ctx.input_mem->virt_addr; draw_rect_rgb(img, width, height, ...); // Создаем AVFrame для сохранения AVFrame *frame_to_save = av_frame_alloc(); frame_to_save->format = AV_PIX_FMT_RGB24; frame_to_save->width = width; frame_to_save->height = height; av_image_fill_arrays(frame_to_save->data, frame_to_save->linesize, img, AV_PIX_FMT_RGB24, width, height, 1); // Сохраняем с рамками save_frame_as_jpeg(frame_to_save, width, height, counter); av_frame_free(&frame_to_save); av_frame_free(&frame); counter++; }
Если ваша функция
save_frame_as_jpegкорректно работает с rgb24 AVFrame — все будет хорошо.
Если нужно, могу помочь проверить или исправить
save_frame_as_jpeg. - User
покажи полный пример что и куда добавить
- Assistant
Конечно! Ниже — полный пример рабочего цикла с объяснениями, как правильно рисовать рамки в RGB буфере и сохранить кадр с этими рамками, используя
AVFrame.
Ваш текущий цикл обработки, адаптированный:
while (task->queue_size > 0) { uint64_t frame_time = start_ns(); pthread_mutex_lock(&task->queue_mutex); AVFrame *frame = task->frame_queue[task->read_pos]; task->read_pos = (task->read_pos + 1) % MAX_FRAMES_QUEUE; task->queue_size--; pthread_mutex_unlock(&task->queue_mutex); // Ширина и высота для простоты int width = rknn_ctx.img_width; int height = rknn_ctx.img_height; // 1. Копируем и масштабируем из исходного frame (возможно YUV) в rgb-буфер rknn_ctx.input_mem resize_and_copy_frame_to_input(frame, &rknn_ctx); // 2. Запускаем инференс int ret = rknn_run(rknn_ctx.ctx, NULL); if (ret >= 0) { // 3. Постобработка результатов post_process((int8_t *)rknn_ctx.output_mems[0]->virt_addr, (int8_t *)rknn_ctx.output_mems[1]->virt_addr, (int8_t *)rknn_ctx.output_mems[2]->virt_addr, height, width, BOX_THRESH, NMS_THRESH, (float)width / width, (float)height / height, rknn_ctx.out_zps, rknn_ctx.out_scales, &detect_result_group); // 4. Получаем указатель на rgb-буфер, в котором сейчас изображение uint8_t *img = (uint8_t *)rknn_ctx.input_mem->virt_addr; // 5. Рисуем рамки for (int i = 0; i < detect_result_group.count; i++) { detect_result_t *det = &detect_result_group.results[i]; draw_rect_rgb(img, width, height, det->box.left, det->box.top, det->box.right, det->box.bottom, 255, 0, 0); } // 6. Создаем AVFrame поверх rgb-буфера img для сохранения AVFrame *frame_to_save = av_frame_alloc(); frame_to_save->format = AV_PIX_FMT_RGB24; frame_to_save->width = width; frame_to_save->height = height; av_image_fill_arrays(frame_to_save->data, frame_to_save->linesize, img, AV_PIX_FMT_RGB24, width, height, 1); // 7. Сохраняем jpeg с рамками save_frame_as_jpeg(frame_to_save, width, height, counter); av_frame_free(&frame_to_save); } // Освобождаем исходный кадр av_frame_free(&frame); printf("%s: %d - RKNN %s / Найдено %d\r\n", GLOBAL_TIME_PRINT(), counter, stop_ms(frame_time), detect_result_group.count); counter++; }
Что именно вы должны добавить или проверить:
- Ваша функция рисования рамок (она уже есть):
void draw_rect_rgb(uint8_t *img, int width, int height, int left, int top, int right, int bottom, uint8_t r, uint8_t g, uint8_t b) { if (left < 0) left = 0; if (top < 0) top = 0; if (right >= width) right = width - 1; if (bottom >= height) bottom = height - 1; for (int x = left; x <= right; x++) { int idx_top = (top*width + x)*3; img[idx_top] = r; img[idx_top + 1] = g; img[idx_top + 2] = b; int idx_bottom = (bottom*width + x)*3; img[idx_bottom] = r; img[idx_bottom + 1] = g; img[idx_bottom + 2] = b; } for (int y = top; y <= bottom; y++) { int idx_left = (y*width + left)*3; img[idx_left] = r; img[idx_left + 1] = g; img[idx_left + 2] = b; int idx_right = (y*width + right)*3; img[idx_right] = r; img[idx_right + 1] = g; img[idx_right + 2] = b; } }- Функция
resize_and_copy_frame_to_input()(как у вас):
void resize_and_copy_frame_to_input(AVFrame *rgb_frame, RKNNContext *rknn_ctx) { int width = rknn_ctx->img_width; int height = rknn_ctx->img_height; int channels = 3; // RGB24 uint8_t *dst_ptr = (uint8_t *)rknn_ctx->input_mem->virt_addr; int stride = rknn_ctx->input_attr.w_stride; if (stride == width) { memcpy(dst_ptr, rgb_frame->data[0], width * height * channels); } else { int src_stride = rgb_frame->linesize[0]; for (int h = 0; h < height; ++h) { memcpy(dst_ptr + h * stride * channels, rgb_frame->data[0] + h * src_stride, width * channels); } } }- Создаём временный
AVFrameиз rgb-буфера для сохранения, именно после рисования рамок:
AVFrame *frame_to_save = av_frame_alloc(); frame_to_save->format = AV_PIX_FMT_RGB24; frame_to_save->width = width; frame_to_save->height = height; av_image_fill_arrays(frame_to_save->data, frame_to_save->linesize, img, AV_PIX_FMT_RGB24, width, height, 1);- Сохраняете
frame_to_save:
save_frame_as_jpeg(frame_to_save, width, height, counter); av_frame_free(&frame_to_save);
Дополнительно
- Убедитесь, что
save_frame_as_jpegумеет сохранятьAVFrameв форматеAV_PIX_FMT_RGB24. - Если
save_frame_as_jpegожидает другой формат, например YUV, нужно будет добавить конвертацию черезlibswscale.
Если хотите, могу помочь с примером
save_frame_as_jpegдля сохранения RGB AVFrame через FFmpeg/libav, дайте знать! - User
так
for (int i = 0; i < detect_result_group.count; i++) { detect_result_t *det = &detect_result_group.results[i]; // Рисуем красную рамку вокруг объекта draw_rect_rgb(img, width, height, det->box.left, det->box.top, det->box.right, det->box.bottom, 255, 0, 0); } // Рисуете рамки в rknn_ctx.input_mem->virt_addr uint8_t *img = (uint8_t *)rknn_ctx.input_mem->virt_addr; draw_rect_rgb(img, width, height, ...); // Создаем AVFrame для сохранения AVFrame *frame_to_save = av_frame_alloc(); frame_to_save->format = AV_PIX_FMT_RGB24; frame_to_save->width = width; frame_to_save->height = height; av_image_fill_arrays(frame_to_save->data, frame_to_save->linesize, img, AV_PIX_FMT_RGB24, width, height, 1); // Сохраняем с рамками save_frame_as_jpeg(frame_to_save, width, height, counter); av_frame_free(&frame_to_save); av_frame_free(&frame); - Assistant
Порядок действий и код почти правильный, но у вас есть один избыточный вызов
draw_rect_rgb, и стоит поправить переменные, т.к. вы пытаетесь рисовать рамки дважды — сначала с помощью цикла по detected objects, а затем ещё раз сdraw_rect_rgb(img, width, height, ...)с неопределёнными параметрами (...).Правильный и скомпонованный кусок будет выглядеть так:
// Получаем указатель на RGB изображение для отрисовки рамок uint8_t *img = (uint8_t *)rknn_ctx.input_mem->virt_addr; // Рисуем рамки вокруг всех обнаруженных объектов for (int i = 0; i < detect_result_group.count; i++) { detect_result_t *det = &detect_result_group.results[i]; draw_rect_rgb(img, width, height, det->box.left, det->box.top, det->box.right, det->box.bottom, 255, 0, 0); } // Создаем AVFrame, "оболочку" для rgb-буфера, с которого будем сохранять AVFrame *frame_to_save = av_frame_alloc(); frame_to_save->format = AV_PIX_FMT_RGB24; frame_to_save->width = width; frame_to_save->height = height; av_image_fill_arrays(frame_to_save->data, frame_to_save->linesize, img, AV_PIX_FMT_RGB24, width, height, 1); // Сохраняем кадр с нарисованными рамками save_frame_as_jpeg(frame_to_save, width, height, counter); // Освобождаем временный AVFrame av_frame_free(&frame_to_save); // Освобождаем исходный AVFrame (если нужно) av_frame_free(&frame);
Ключевые моменты:
- Переменную
imgнужно получить до цикла с отрисовкой рамок. - Отрисовку рамок делаем один раз в цикле.
- Не вызывайте
draw_rect_rgbеще раз с параметром...— непонятно, что туда ставить. - Создаете только один
AVFrameдля сохранения, который указывает на тот же буфер, гдеimgи есть. - Затем вызываете сохранение.
- Не забудьте корректно освободить используемые кадры.
Если
save_frame_as_jpegпринимаетAVFrame *в формате RGB24 и корректно сохраняет jpeg, то такого подхода достаточно. - Переменную