Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

Проверь мне надо сохранить картинку с нарисованными объектами while (task->queuesize >…

  1. 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;
    }
    

    }

  2. Assistant

    Ваш код в целом выглядит логично — вы получаете фрейм, запускаете inference, рисуете прямоугольники и сохраняете изображение. Однако есть несколько важных моментов, которые стоит проверить и уточнить, чтобы убедиться, что картинка с нарисованными объектами действительно сохраняется корректно:

    1. Формат изображения в img и используемый с draw_rect_rgb

    • img — это указатель на 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.

  3. User

    не функция сохранения именно такая save_frame_as_jpeg(AVFrame *pFrame, width, height, counter);

    если pFrame- надо что-то подставить правильное

  4. 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 варианта:

    1. Нарисовать рамки в самом frame->data[0], если он в RGB24.
    2. Копировать img (с нарисованными рамками) в frame->data[0] (тоже при условии RGB24).
    3. Конвертировать RGB img в тот формат, что у frame, и положить в frame перед сохранением (наиболее универсальный, но сложный вариант).

    Если хотите, я помогу с примером кода для конвертации RGB->YUV с swscale, чтобы обновить frame перед сохранением. Просто скажите!

  5. User

    Давай внимательнее вот я достал кадр и первел в ркнн AVFrame *frame = task->frame_queue[task->read_pos]; resize_and_copy_frame_to_input(frame, &rknn_ctx);

  6. Assistant

    Спасибо за пояснение. Давайте разберемся подробнее по шагам.


    Что происходит в вашем коде:

    1. Вы достаете AVFrame *frame из очереди:

      AVFrame *frame = task->frame_queue[task->read_pos];
      

      Этот кадр, скорее всего, в формате, в котором он был получен (чаще всего YUV или другой формат, не RGB24).

    2. Вы вызываете

      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-картинка, на которой вы уже рисуете рамки.

    3. Далее вы запускаете inference и рисуете рамки именно в img:

      uint8_t *img = (uint8_t *)rknn_ctx.input_mem->virt_addr;
      draw_rect_rgb(img, width, height, ...);
      
    4. Вы вызываете

      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.

    Могу помочь с этим тоже, если нужно.

  7. 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);
        }
    }
    

    }

  8. 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.

  9. User

    покажи полный пример что и куда добавить

  10. 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++;
    }
    

    Что именно вы должны добавить или проверить:

    1. Ваша функция рисования рамок (она уже есть):
    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;
        }
    }
    
    1. Функция 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);
            }
        }
    }
    
    1. Создаём временный 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);
    
    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, дайте знать!

  11. 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);
    
  12. 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, то такого подхода достаточно.