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

Что делает эта функция *swsctx = swsgetContext( (*codec_ctx)->width,…

  1. User

    Что делает эта функция *sws_ctx = sws_getContext( (*codec_ctx)->width, (*codec_ctx)->height, (*codec_ctx)->pix_fmt, IMG_WIDTH, IMG_HEIGHT, AV_PIX_FMT_RGB24, SWS_FAST_BILINEAR, NULL, NULL, NULL); if (!*sws_ctx) { fprintf(stderr, "Failed to initialize sws context\n"); return -1; } Константы - это 640

  2. Assistant

    Этот фрагмент кода инициализирует контекст масштабирования и конвертации изображения с помощью библиотеки libswscale из проекта FFmpeg.

    Что делает конкретно эта функция:

    *sws_ctx = sws_getContext(
        (*codec_ctx)->width,            // ширина исходного изображения
        (*codec_ctx)->height,           // высота исходного изображения
        (*codec_ctx)->pix_fmt,          // формат пикселей исходного изображения
        IMG_WIDTH,                      // целевая ширина (в вашем случае 640)
        IMG_HEIGHT,                     // целевая высота (тоже 640)
        AV_PIX_FMT_RGB24,               // целевой формат пикселей (RGB24)
        SWS_FAST_BILINEAR,              // алгоритм масштабирования (быстрый билинейный)
        NULL, NULL, NULL);              // дополнительные параметры: фильтры и т.п. (не используются)
    
    1. Исходное изображение должно иметь ширину и высоту из (*codec_ctx), а формат пикселей — (*codec_ctx)->pix_fmt (например, YUV420P, NV12 и т.п.).
    2. Цель – преобразовать это изображение в размер 640x640 пикселей (IMG_WIDTH и IMG_HEIGHT равны 640) с форматом RGB24.
    3. Алгоритм масштабирования — SWS_FAST_BILINEAR — обеспечивает быстрое, но не самое качественное сглаживание (билинейная интерполяция).
    4. Если инициализация контекста sws_ctx не удалась — выводится сообщение об ошибке и функция возвращает -1.

    Для чего это нужно

    SwsContext* используется для преобразования изображения из одного размера и формата в другой. Часто это необходимо:

    • для конвертации кадров декодированного видео в форму, удобную для отображения,
    • для изменения разрешения кадра,
    • для последующей обработки в RGB цветовой модели (например, для отображения или дальнейшего анализа).

    В итоге

    Этот код создает и инициализирует контекст для преобразования (масштабирования + конвертации цвета) видео кадра с исходного формата и размера (из codec_ctx) в RGB24 формат с размером 640x640 пикселей. Если контекст создать не удается, функция сообщает об ошибке.


    Если понадобится, могу помочь с примером, как пользоваться этим sws_ctx для конвертации кадров и вызова sws_scale().

  3. User

    а что происъодит тут

    (*rgb_frame)->format = AV_PIX_FMT_RGB24;
    (*rgb_frame)->width = IMG_WIDTH; //(*codec_ctx)->width;
    (*rgb_frame)->height = IMG_HEIGHT; //(*codec_ctx)->height;
    
    if (av_frame_get_buffer(*rgb_frame, 0) < 0) {
        fprintf(stderr, "Failed to allocate buffer for rgb frame\n");
        return -1;
    }
    
  4. Assistant

    Этот фрагмент кода занимается подготовкой кадра (AVFrame) для хранения изображения в формате RGB24 с размером 640x640.

    Разбор по строкам:

    (*rgb_frame)->format = AV_PIX_FMT_RGB24;
    (*rgb_frame)->width = IMG_WIDTH;     // 640
    (*rgb_frame)->height = IMG_HEIGHT;   // 640
    
    • Здесь устанавливаются параметры кадра: формат пикселей — AV_PIX_FMT_RGB24 (т.е. 3 байта на пиксель, по одному на красный, зеленый и синий каналы).
    • Размер кадра — тоже явно задается: ширина и высота по 640 пикселей.

    Далее:

    if (av_frame_get_buffer(*rgb_frame, 0) < 0) {
        fprintf(stderr, "Failed to allocate buffer for rgb frame\n");
        return -1;
    }
    
    • Вызов av_frame_get_buffer() выделяет в памяти физические буферы для хранения данных изображения внутри структуры rgb_frame.
    • Второй параметр 0 — флаги выделения (например, выравнивание), здесь указано по умолчанию.
    • Если выделение памяти не удалось (возвращается отрицательное значение), выводится ошибка, и функция возвращает -1.

    В итоге

    Этот код:

    1. Подготавливает структуру rgb_frame для хранения rgb-изображения размером 640x640.
    2. Выделяет память под данные кадра, чтобы туда могло быть записано изображение после конвертации/sws_scale.

    Эта часть обычно стоит перед вызовом sws_scale(), где в rgb_frame будет записано сконвертированное видео изображение в нужном формате и размере.

  5. User

    т.е по итогу вот проихошло декодирование

    while (avcodec_receive_frame(codec_ctx, frame) == 0) { и какие размеры и форто у меня получилось

  6. Assistant

    Давайте разберём подробнее, что происходит после вызова:

    while (avcodec_receive_frame(codec_ctx, frame) == 0) {
        // обработка кадра
    }
    

    1. Что происходит при avcodec_receive_frame

    • Эта функция получает декодированный видео кадр из декодера codec_ctx.

    • В переменную frame помещается один декодированный сырый кадр.

    • При возврате 0 — кадр успешно получен.

    • Формат (pix_fmt), ширина, высота и другие параметры кадра будут такими, как в исходном видео, то есть:

      • frame->width == исходная ширина видео, например, 640 (или другая, если видео имеет другое разрешение).
      • frame->height == исходная высота видео.
      • frame->format == пиксельный формат исходного видео (например, AV_PIX_FMT_YUV420P или другой).

    2. Какой формат и размеры у декодированного кадра

    Формат и размеры зависят от видео потока, который вы декодируете, и они будут храниться в самом декодированном кадре:

    int width = frame->width;
    int height = frame->height;
    enum AVPixelFormat pix_fmt = frame->format;
    

    Эти параметры будут соответствовать исходному видео. Например, если видео в формате 1280x720 и пиксельном формате YUV420P, то кадр будет таким же.


    3. Что происходит дальше в вашем коде

    • Вы создаёте контекст для конвертации sws_ctx от формата и размеров frame ((*codec_ctx)->width/height и (*codec_ctx)->pix_fmt) к 640x640 RGB24:
    *sws_ctx = sws_getContext(
        (*codec_ctx)->width, (*codec_ctx)->height, (*codec_ctx)->pix_fmt, 
        640, 640, AV_PIX_FMT_RGB24, 
        SWS_FAST_BILINEAR, NULL, NULL, NULL);
    
    • Вы создаёте rgb_frame с параметрами 640x640 RGB24 и выделяете под него буфер.
    • Затем, предположительно, вызываете:
    sws_scale(*sws_ctx, (const uint8_t* const*)frame->data, frame->linesize,
              0, frame->height,
              rgb_frame->data, rgb_frame->linesize);
    
    • В итоге вы получаете конвертированный и масштабированный кадр именно 640x640 в формате RGB24.

    Итог

    • Исходный декодированный кадр (frame) имеет формат и размеры вашего исходного видео (например, 1280x720, YUV420P).
    • rgb_frame — это ваш преобразованный кадр с фиксированным размером 640x640 и форматом RGB24.
    • Для перевода из формата/размера исходного кадра в RGB 640x640 вы инициализировали sws_ctx.
    • После sws_scale данные кадра сконвертируются и масштабируются в rgb_frame.

    Если хотите, могу помочь проверить код конвертации или объяснить, что конкретно происходит в функции sws_scale.

  7. User

    вооот sws_scale(sws_ctx, (const uint8_t const*)frame->data, frame->linesize, 0, frame->height, rgb_frame->data, rgb_frame->linesize); теперь смотри у меня входное разрешение может быть разное а на выходе надо получить 640x640! но пропорциональное либо уменьшить либо увеличить - но приоритет по ширине, а высоту либо добабвить, либо просто обрезать относительно ценрта - сверху и снизу чтобы получилось тоже 640

  8. Assistant

    Понял задачу:

    • Исходный кадр может иметь произвольное разрешение (ширина и высота).
    • На выходе нужен квадратный кадр 640x640.
    • При этом приоритет — сохранить ширину кадра (масштабируем исходную ширину до 640).
    • Высоту при масштабировании либо:
      • если выходит меньше 640 — дополняем сверху и снизу (черными полосами, паддингом);
      • если выходит больше 640 — обрезаем по центру, чтобы получить ровно 640 пикселей по высоте.

    Как это можно реализовать?


    Шаг 1: Вычисляем масштаб

    Пусть:

    • W_in, H_in — ширина и высота исходного кадра.
    • IMG_WIDTH = IMG_HEIGHT = 640 — Wanted output size.

    Из условия:

    • По ширине надо подогнать ровно 640.
    • Высота будет масштабироваться пропорционально:
    scale_factor = 640.0 / W_in;
    scaled_height = H_in * scale_factor;
    

    Шаг 2: Подготавливаем промежуточный размер

    Для конвертации нам нужен контекст sws_ctx, который будет масштабировать с W_in x H_in в 640 x scaled_height.

    Например:

    int target_width = 640;
    int target_height = (int)(H_in * scale_factor + 0.5);
    

    Шаг 3: Создаем промежуточный AVFrame для результата масштабирования:

    Пока что с размером 640 x target_height.

    AVFrame* intermediate_rgb_frame = av_frame_alloc();
    intermediate_rgb_frame->format = AV_PIX_FMT_RGB24;
    intermediate_rgb_frame->width = target_width;
    intermediate_rgb_frame->height = target_height;
    if (av_frame_get_buffer(intermediate_rgb_frame, 0) < 0) {
        fprintf(stderr, "Failed to allocate buffer\n");
        // Обработка ошибки
    }
    

    Шаг 4: Создаем sws_ctx для такого масштабирования

    struct SwsContext* sws_ctx = sws_getContext(
        W_in, H_in, pix_fmt_in,
        target_width, target_height, AV_PIX_FMT_RGB24,
        SWS_BILINEAR, NULL, NULL, NULL);
    

    Шаг 5: Масштабируем из исходного кадра в этот промежуточный кадр

    sws_scale(sws_ctx, frame->data, frame->linesize, 0, H_in,
              intermediate_rgb_frame->data, intermediate_rgb_frame->linesize);
    

    Шаг 6: Формируем итоговый кадр 640x640 — либо с паддингом, либо с обрезкой по высоте

    • Если target_height < 640 — надо сделать вертикальные поля (черные полосы) сверху и снизу.
    • Если target_height > 640 — надо взять центральную область высотой 640 из intermediate_rgb_frame.

    Можно создать итоговый кадр:

    AVFrame* final_rgb_frame = av_frame_alloc();
    final_rgb_frame->format = AV_PIX_FMT_RGB24;
    final_rgb_frame->width = 640;
    final_rgb_frame->height = 640;
    if (av_frame_get_buffer(final_rgb_frame, 0) < 0) {
        fprintf(stderr, "Failed to allocate buffer\n");
        // Обработка ошибки
    }
    

    Шаг 7: Копируем данные с учётом паддинга или кропа


    Сценарий 1: target_height < 640 — делаем вертикальный паддинг (черные полосы) сверху и снизу

    Вычисляем отступ сверху:

    int pad_top = (640 - target_height) / 2; 
    

    Нужно записать изображение в final_rgb_frame начиная со строки pad_top.

    Чтобы очистить весь кадр черным (0):

    memset(final_rgb_frame->data[0], 0, final_rgb_frame->linesize[0] * 640);
    

    После обнуления копируем каждый ряд из intermediate_rgb_frame в final_rgb_frame начиная с pad_top:

    for (int y = 0; y < target_height; y++) {
        memcpy(
            final_rgb_frame->data[0] + (y + pad_top) * final_rgb_frame->linesize[0],
            intermediate_rgb_frame->data[0] + y * intermediate_rgb_frame->linesize[0],
            target_width * 3); // RGB24 - 3 байта на пиксель
    }
    

    Сценарий 2: target_height > 640 — обрезаем по центру

    Вычисляем смещение по высоте:

    int crop_top = (target_height - 640) / 2;
    

    Копируем ровно 640 строк, начиная с crop_top в final_rgb_frame:

    for (int y = 0; y < 640; y++) {
        memcpy(
            final_rgb_frame->data[0] + y * final_rgb_frame->linesize[0],
            intermediate_rgb_frame->data[0] + (y + crop_top) * intermediate_rgb_frame->linesize[0],
            target_width * 3);
    }
    

    Итог: простой алгоритм с 2-проходным масштабированием и выравниванием

    Если хочется, можно для оптимизации сделать 1 проход с sws_scale сразу в размер 640x640, но тогда будет искажение пропорций.

    А описанный метод даёт именно сохранение пропорций по ширине с обрезкой или паддингом по высоте, как вы и хотели.


    Небольшой псевдокод, собранный воедино:

    int W_in = frame->width;
    int H_in = frame->height;
    enum AVPixelFormat pix_fmt_in = frame->format;
    
    int target_width = 640;
    float scale_factor = (float)target_width / W_in;
    int target_height = (int)(H_in * scale_factor + 0.5);
    
    // 1. Allocate intermediate frame for scaled image
    AVFrame* intermediate_rgb_frame = av_frame_alloc();
    intermediate_rgb_frame->format = AV_PIX_FMT_RGB24;
    intermediate_rgb_frame->width = target_width;
    intermediate_rgb_frame->height = target_height;
    av_frame_get_buffer(intermediate_rgb_frame, 0);
    
    // 2. Setup sws context for scaling
    struct SwsContext* sws_ctx = sws_getContext(
       W_in, H_in, pix_fmt_in,
       target_width, target_height, AV_PIX_FMT_RGB24,
       SWS_BILINEAR, NULL, NULL, NULL);
    
    // 3. Scale to intermediate frame
    sws_scale(sws_ctx, frame->data, frame->linesize, 0, H_in,
              intermediate_rgb_frame->data, intermediate_rgb_frame->linesize);
    
    // 4. Allocate final frame 640x640
    AVFrame* final_rgb_frame = av_frame_alloc();
    final_rgb_frame->format = AV_PIX_FMT_RGB24;
    final_rgb_frame->width = 640;
    final_rgb_frame->height = 640;
    av_frame_get_buffer(final_rgb_frame, 0);
    
    // 5. Fill final frame with black
    memset(final_rgb_frame->data[0], 0, final_rgb_frame->linesize[0] * 640);
    
    // 6. Copy scaled image either with padding or cropping:
    if (target_height < 640) {
        int pad_top = (640 - target_height)/2;
        for (int y = 0; y < target_height; y++) {
            memcpy(final_rgb_frame->data[0] + (y + pad_top)*final_rgb_frame->linesize[0],
                   intermediate_rgb_frame->data[0] + y*intermediate_rgb_frame->linesize[0],
                   target_width*3);
        }
    } else {
        int crop_top = (target_height - 640) / 2;
        for (int y = 0; y < 640; y++) {
            memcpy(final_rgb_frame->data[0] + y*final_rgb_frame->linesize[0],
                   intermediate_rgb_frame->data[0] + (y + crop_top)*intermediate_rgb_frame->linesize[0],
                   target_width*3);
        }
    }
    
    // ...
    // Далее final_rgb_frame содержит ровно 640x640 RGB изображение именно как вы хотите
    

    Если понадобится, могу помочь с более детальной интеграцией кода или с освобождением памяти.

  9. User

    Давай оформи это в виде одной функции учитывая чтобы это работало минимально по времени и загрузке ЦПУ

    		//
    															if(width_ok != frame->width || height_ok != frame->height) {
    																cam_work = 0;
    																break;
    															}
    															
    															
    															//
    															uint64_t START3 = GLOBAL_TIME_START();
    															scale_crop_letterbox_to_square(frame, rgb_frame, sws_ctx);
    																printf("0 %s: длительность: %s %.3f, %d: queue size: %d\n", GLOBAL_TIME_PRINT(), GLOBAL_TIME_END_PRNT(START3), GLOBAL_TIME_END(START3), args->id, args->task->queue_size);
    
  10. Assistant

    Конечно! Ниже предлагаю функцию scale_crop_letterbox_to_square(), которая масштабирует байтовый кадр AVFrame *frame с любым разрешением и форматом пикселей, преобразует его к RGB24 (используя SwsContext *sws_ctx), и получает на выходе квадратный кадр размером 640x640 с сохранением пропорций по ширине, добавляя паддинг или обрезая высоту по центру.


    Ваши уточнения по задачи:

    • frame — входной декодированный кадр (любой формат).
    • rgb_frame — кадр для выхода, уже выделенный с размером 640x640 RGB24.
    • sws_ctx — контекст масштабирования (подробнее ниже, при необходимости можно создать внутри).

    Решение

    Вот реализация функции с учётом минимизации нагрузки на CPU (используется один sws_scale от исходного кадра на промежуточный буфер, затем копирование и паддинг/кроп):

    #include <libavutil/frame.h>
    #include <libswscale/swscale.h>
    #include <string.h>
    #include <stdio.h>
    
    #define IMG_SIZE 640
    
    // Выделяем промежуточный временный кадр с заданным форматом и размером
    static AVFrame* alloc_frame(int width, int height, enum AVPixelFormat pix_fmt) {
        AVFrame* frame = av_frame_alloc();
        if (!frame) return NULL;
        frame->format = pix_fmt;
        frame->width = width;
        frame->height = height;
        if (av_frame_get_buffer(frame, 0) < 0) {
            av_frame_free(&frame);
            return NULL;
        }
        return frame;
    }
    
    /**
     * Масштабирует и конвертирует кадр frame в квадратный rgb_frame (640x640, rgb24),
     * приоритет - сохранить ширину, масштабированную к 640,
     * высоту - добавить паддинг или обрезать по центру.
     *
     * - frame: входной кадр (любой формат)
     * - rgb_frame: выходной rgb-фрейм 640x640, выделенный заранее (rgb24)
     * - sws_ctx: контекст для масштабирования из frame->format в rgb24 с произвольным размером,
     *   или NULL для создания локального
     *
     * Возвращает 0 при успехе, отрицательное значение при ошибке.
     */
    int scale_crop_letterbox_to_square(AVFrame *frame, AVFrame *rgb_frame, struct SwsContext **sws_ctx) {
        if (!frame || !rgb_frame) return -1;
    
        int W_in = frame->width;
        int H_in = frame->height;
    
        // Целевой квадратный размер
        const int target_width = IMG_SIZE;
        const int target_height = IMG_SIZE;
    
        // Вычисляем масштаб по ширине
        double scale_factor = (double)target_width / W_in;
        int scaled_height = (int)(H_in * scale_factor + 0.5);
    
        // Проверка значений
        if (scaled_height <= 0) return -1;
    
        // Если sws_ctx не указан или изменился исходный размер, создаём/пересоздаём контекст
        if (*sws_ctx != NULL) {
            struct SwsContext* ctx = *sws_ctx;
            if (ctx && (ctx->srcW != W_in || ctx->srcH != H_in || ctx->dstW != target_width || ctx->dstH != scaled_height)) {
                sws_freeContext(ctx);
                *sws_ctx = NULL;
            }
        }
        if (*sws_ctx == NULL) {
            *sws_ctx = sws_getContext(
                W_in, H_in, frame->format,
                target_width, scaled_height, AV_PIX_FMT_RGB24,
                SWS_BILINEAR, NULL, NULL, NULL);
            if (!*sws_ctx) {
                fprintf(stderr, "Failed to create sws scaling context\n");
                return -1;
            }
        }
    
        // Выделяем промежуточный кадр под сразу отмасштабированное rgb из исходного (640 x scaled_height)
        AVFrame *intermediate = alloc_frame(target_width, scaled_height, AV_PIX_FMT_RGB24);
        if (!intermediate) {
            fprintf(stderr, "Failed to allocate intermediate frame\n");
            return -1;
        }
    
        // Конвертация + масштабирование с помощью sws_scale
        int ret = sws_scale(*sws_ctx,
                            (const uint8_t* const*)frame->data,
                            frame->linesize,
                            0,
                            H_in,
                            intermediate->data,
                            intermediate->linesize);
    
        if (ret <= 0) {
            fprintf(stderr, "sws_scale failed or returned zero\n");
            av_frame_free(&intermediate);
            return -1;
        }
    
        // Теперь формируем конечный квадратный кадр 640x640 с паддингом или кропом
    
        // Обнуляем итоговый кадр для паддингов (черный цвет)
        memset(rgb_frame->data[0], 0, rgb_frame->linesize[0] * target_height);
    
        if (scaled_height < target_height) {
            // Паддинг сверху/снизу
            int pad_top = (target_height - scaled_height) / 2;
            for (int y = 0; y < scaled_height; y++) {
                memcpy(rgb_frame->data[0] + (y + pad_top) * rgb_frame->linesize[0],
                       intermediate->data[0] + y * intermediate->linesize[0],
                       target_width * 3); // 3 байта на пиксель RGB24
            }
        } else if (scaled_height > target_height) {
            // Кроп по центру
            int crop_top = (scaled_height - target_height) / 2;
            for (int y = 0; y < target_height; y++) {
                memcpy(rgb_frame->data[0] + y * rgb_frame->linesize[0],
                       intermediate->data[0] + (y + crop_top) * intermediate->linesize[0],
                       target_width * 3);
            }
        } else {
            // Ровно совпадает по высоте — просто копируем
            memcpy(rgb_frame->data[0], intermediate->data[0], target_width * 3 * target_height);
        }
    
        av_frame_free(&intermediate);
        return 0;
    }
    

    Использование

    struct SwsContext *sws_ctx = NULL;
    // ... где-то у вас есть AVFrame *frame (декодированный кадр) и AVFrame *rgb_frame (выделенный размером 640x640 RGB24)
    // выделение rgb_frame размером 640x640 должно быть сделано заранее!
    
    int res = scale_crop_letterbox_to_square(frame, rgb_frame, &sws_ctx);
    if (res < 0) {
        fprintf(stderr, "Scale and crop failed\n");
    }
    
    // В конце освободите sws_ctx, когда он больше не нужен
    if (sws_ctx) sws_freeContext(sws_ctx);
    

    Пояснения по эффективности

    • Минимум операций: масштабирование только один раз, на промежуточный буфер.
    • Малый копирующий цикл: копируем либо с паддингом, либо с обрезкой, что быстро (просто memcpy и memset).
    • Повторное использование sws_ctx: пересоздаем контекст только если размеры изменились.
    • Отсутствие лишних аллокаций: промежуточный буфер аллоцируется внутри функции и сразу освобождается.

    Если нужно — помогу добавить создание и выделение rgb_frame, либо интегрировать вызов в ваш цикл.

  11. User

    а почему в функции struct SwsContext **sws_ctx

    если у меня определен struct SwsContext *sws_ctx

    потом он настраивается

    потом передается в функцию scale_crop_letterbox_to_square(frame, rgb_frame, sws_ctx)

  12. Assistant

    Отличный вопрос!


    Почему в функции параметр типа struct SwsContext **sws_ctx, а не просто struct SwsContext *sws_ctx?


    Ваш текущий вариант:

    Вы у себя объявляете:

    struct SwsContext *sws_ctx = NULL;
    

    И передаете его в функцию так:

    scale_crop_letterbox_to_square(frame, rgb_frame, sws_ctx);
    

    Мой вариант:

    int scale_crop_letterbox_to_square(AVFrame *frame, AVFrame *rgb_frame, struct SwsContext **sws_ctx);
    

    И вызывается так:

    scale_crop_letterbox_to_square(frame, rgb_frame, &sws_ctx);
    

    В чем суть?

    • Ваша переменная sws_ctx — это указатель на структуру SwsContext.
    • Если в функции вам нужно только использовать этот указатель, а не менять его значение (в том числе значение самого указателя, то есть адрес), то достаточно передать struct SwsContext *sws_ctx.
    • Но если вы хотите внутри функции создавать или пересоздавать sws_ctx и при этом, чтобы при возврате из функции указатель в вызывающей функции обновился — то есть, чтобы вы изменили сам указатель, а не то, что по нему лежит — тогда нужно передавать указатель на указатель, то есть struct SwsContext **sws_ctx.

    Разбор по коду из вашей задачи

    В функции scale_crop_letterbox_to_square есть такой код (в моём примере):

    if (*sws_ctx != NULL) {
        struct SwsContext* ctx = *sws_ctx;
        if (ctx && (ctx->srcW != W_in || ctx->srcH != H_in || ctx->dstW != target_width || ctx->dstH != scaled_height)) {
            sws_freeContext(ctx);
            *sws_ctx = NULL;
        }
    }
    if (*sws_ctx == NULL) {
        *sws_ctx = sws_getContext(
            ...);
    }
    

    Здесь мы возможное создание нового контекста и освобождение старого выполняем напрямую, меняя переменную, на которую указывает *sws_ctx.

    То есть передавая struct SwsContext **sws_ctx (указатель на указатель), мы можем:

    • Освободить: sws_freeContext(*sws_ctx);
    • Создать и записать в вызывающую функцию новый указатель: *sws_ctx = sws_getContext(...);

    Если передать просто struct SwsContext *sws_ctx

    То внутри функции можно работать с самим объектом, на него ссылаться, но нельзя менять значение указателя, чтобы оно обновилось у вызывающего.

    Например:

    int func(struct SwsContext *sws_ctx) {
        sws_ctx = sws_getContext(...); // Это изменит локальную копию указателя, а у вызывающего ничего не поменяется!
        return 0;
    }
    

    Если же нужно только использовать, а создавать контекст заранее и передавать в функцию готовый указатель — можно делать так:

    Вызов:

    struct SwsContext *sws_ctx = sws_getContext(...);
    scale_crop_letterbox_to_square(frame, rgb_frame, sws_ctx);
    

    Функция:

    int scale_crop_letterbox_to_square(AVFrame *frame, AVFrame *rgb_frame, struct SwsContext *sws_ctx) {
        // Просто используем sws_ctx, не создаём новый внутри
    }
    

    Но тогда у вас не получится динамически пересоздавать контекст при изменении размеров внутри функции


    Резюме:

    ПараметрКогда использоватьЧто получится
    struct SwsContext *sws_ctxЕсли контекст создается вне функции и не меняетсяФункция просто использует существующий контекст
    struct SwsContext **sws_ctxЕсли функция сама создает / пересоздает / освобождает контекстФункция может менять сам указатель контекста внутри вызывающего кода

    Ваш выбор зависит от архитектуры кода:

    • Если вы хотите, чтобы функция сама создавала или изменяла sws_ctx — используйте struct SwsContext **sws_ctx и передавайте адрес &sws_ctx.
    • Если контекст создаётся один раз вне функции, и функция только читает и использует его — передавайте просто struct SwsContext *sws_ctx.

    Если хотите, могу переписать функцию под вариант с struct SwsContext *sws_ctx (без двойного указателя), где всё создание и проверка контекста будет снаружи.

  13. User

    а зачем пересоздавать динамически.. мы получаем избражение с камеры которое постоянное - не меняется.. и постоянно обрезаем его

  14. Assistant

    Отлично! Если у вас фиксированное разрешение входного видео с камеры, которое не меняется в процессе работы, тогда пересоздавать контекст динамически не нужно — это и проще, и эффективнее.


    Что рекомендуют в вашем случае?

    • Контекст struct SwsContext *sws_ctx создать один раз при старте, с указанным разрешением исходного кадра и целевым размером.
    • Передавать его в функцию как просто struct SwsContext *sws_ctx (одинарный указатель).
    • Функция только пользоваться готовым контекстом, не создавать новый и не освобождать старый.
    • В конце работы с видео контекст освободить один раз.

    Ваша функция будет проще и понятнее

    Например:

    int scale_crop_letterbox_to_square(AVFrame *frame, AVFrame *rgb_frame, struct SwsContext *sws_ctx) {
        if (!frame || !rgb_frame || !sws_ctx) return -1;
    
        int W_in = frame->width;
        int H_in = frame->height;
    
        const int target_width = IMG_SIZE;
        const int target_height = IMG_SIZE;
    
        double scale_factor = (double)target_width / W_in;
        int scaled_height = (int)(H_in * scale_factor + 0.5);
        if (scaled_height <= 0) return -1;
    
        // Выделяем промежуточный кадр 640xscaled_height RGB24
        AVFrame *intermediate = alloc_frame(target_width, scaled_height, AV_PIX_FMT_RGB24);
        if (!intermediate) {
            fprintf(stderr, "Failed to allocate intermediate frame\n");
            return -1;
        }
    
        // Применяем sws_scale (буфер и размеры должны совпадать с созданным sws_ctx)
        int ret = sws_scale(sws_ctx,
                            (const uint8_t* const*)frame->data,
                            frame->linesize,
                            0,
                            H_in,
                            intermediate->data,
                            intermediate->linesize);
        if (ret <= 0) {
            fprintf(stderr, "sws_scale failed\n");
            av_frame_free(&intermediate);
            return -1;
        }
    
        // Заполняем итоговый rgb_frame чёрным
        memset(rgb_frame->data[0], 0, rgb_frame->linesize[0] * target_height);
    
        // Паддинг или кроп по высоте
        if (scaled_height < target_height) {
            int pad_top = (target_height - scaled_height) / 2;
            for (int y = 0; y < scaled_height; y++) {
                memcpy(rgb_frame->data[0] + (y + pad_top) * rgb_frame->linesize[0],
                       intermediate->data[0] + y * intermediate->linesize[0],
                       target_width * 3);
            }
        } else if (scaled_height > target_height) {
            int crop_top = (scaled_height - target_height) / 2;
            for (int y = 0; y < target_height; y++) {
                memcpy(rgb_frame->data[0] + y * rgb_frame->linesize[0],
                       intermediate->data[0] + (y + crop_top) * intermediate->linesize[0],
                       target_width * 3);
            }
        } else {
            memcpy(rgb_frame->data[0], intermediate->data[0], target_width * 3 * target_height);
        }
    
        av_frame_free(&intermediate);
        return 0;
    }
    

    При вызове:

    • Вы один раз создаёте sws_ctx:
    struct SwsContext *sws_ctx = sws_getContext(
        W_in, H_in, pix_fmt_in,
        IMG_SIZE, (int)(H_in * ((double)IMG_SIZE / W_in) + 0.5), AV_PIX_FMT_RGB24,
        SWS_BILINEAR, NULL, NULL, NULL);
    
    if (!sws_ctx) {
        fprintf(stderr, "Failed to create sws context\n");
        // Обработка ошибки
    }
    
    • И потом в цикле:
    while (avcodec_receive_frame(codec_ctx, frame) == 0) {
        scale_crop_letterbox_to_square(frame, rgb_frame, sws_ctx);
        // Используйте rgb_frame...
    }
    
    • По окончании:
    sws_freeContext(sws_ctx);
    

    Вот почему

    • Разрешение камеры постоянное и не меняется — параметры W_in, H_in и pix_fmt статичны.
    • Не нужно отслеживать динамические изменения или пересоздавать контекст.
    • Однократное создание и многократное использование — оптимальный подход с низкой нагрузкой.

    Если хотите, могу помочь с полным примером кода инициализации и цикла обработки с этим подходом — просто скажите!

  15. User

    ну я так и сделал.. Контекст struct SwsContext *sws_ctx создать один раз при старте, с указанным разрешением исходного кадра и целевым размером. Передавать его в функцию как просто struct SwsContext *sws_ctx (одинарный указатель). переделай свобю функцию

  16. Assistant

    Понял, что контекст SwsContext *sws_ctx у вас создаётся один раз вне функции и не меняется, а вы хотите простую функцию, которая принимает sws_ctx как обычный указатель, не меняет его, а просто использует для конвертации и формирования конечного кадра 640x640 с паддингом / обрезкой по высоте.

    Вот упрощённый и оптимальный вариант вашей функции:

    #include <libavutil/frame.h>
    #include <libswscale/swscale.h>
    #include <string.h>
    #include <stdio.h>
    
    #define IMG_SIZE 640
    
    static AVFrame* alloc_frame(int width, int height, enum AVPixelFormat pix_fmt) {
        AVFrame* frame = av_frame_alloc();
        if (!frame) return NULL;
        frame->format = pix_fmt;
        frame->width = width;
        frame->height = height;
        if (av_frame_get_buffer(frame, 0) < 0) {
            av_frame_free(&frame);
            return NULL;
        }
        return frame;
    }
    
    /**
     * Масштабирует входящий кадр frame в квадратный rgb_frame 640x640 RGB24.
     * Используется заранее созданный sws_ctx с параметрами конкретного входного размера -> 640xscaled_height RGB24.
     *
     * Приоритет — сохранить ширину, масштабировать высоту пропорционально,
     * затем добавить паддинг сверху/снизу (черные полосы) либо обрезать по центру,
     * чтобы итоговый размер был 640x640.
     *
     * frame: входной кадр (любой формат, W_in x H_in)
     * rgb_frame: выходной кадр (должен быть выделен заранее 640x640 RGB24)
     * sws_ctx: заранее созданный контекст, масштабирующий из frame->format, W_in x H_in в 640 x scaled_height RGB24
     *
     * Возвращает 0 при успехе, <0 при ошибке
     */
    int scale_crop_letterbox_to_square(const AVFrame *frame, AVFrame *rgb_frame, struct SwsContext *sws_ctx) {
        if (!frame || !rgb_frame || !sws_ctx) return -1;
    
        const int W_in = frame->width;
        const int H_in = frame->height;
    
        const int target_width = IMG_SIZE;
        const int target_height = IMG_SIZE;
    
        // Ваша ширина всегда 640, высота от масштаба
        double scale_factor = (double)target_width / W_in;
        int scaled_height = (int)(H_in * scale_factor + 0.5);
    
        if (scaled_height <= 0) return -1;
    
        // Выделяем промежуточный кадр RGB24 размером 640 x scaled_height
        AVFrame *intermediate = alloc_frame(target_width, scaled_height, AV_PIX_FMT_RGB24);
        if (!intermediate) {
            fprintf(stderr, "Failed to allocate intermediate frame\n");
            return -1;
        }
    
        // Конвертация + масштабирование с помощью sws_scale
        int ret = sws_scale(sws_ctx,
                            (const uint8_t* const*)frame->data,
                            frame->linesize,
                            0,
                            H_in,
                            intermediate->data,
                            intermediate->linesize);
        if (ret <= 0) {
            fprintf(stderr, "sws_scale failed\n");
            av_frame_free(&intermediate);
            return -1;
        }
    
        // Очистить итоговый rgb_frame чёрным (черный фон для паддинга)
        memset(rgb_frame->data[0], 0, rgb_frame->linesize[0] * target_height);
    
        if (scaled_height < target_height) {
            // Добавляем паддинг сверху и снизу
            int pad_top = (target_height - scaled_height) / 2;
            for (int y = 0; y < scaled_height; y++) {
                memcpy(rgb_frame->data[0] + (y + pad_top) * rgb_frame->linesize[0],
                       intermediate->data[0] + y * intermediate->linesize[0],
                       target_width * 3); // RGB24 = 3 байта на пиксель
            }
        } else if (scaled_height > target_height) {
            // Обрезаем по центру
            int crop_top = (scaled_height - target_height) / 2;
            for (int y = 0; y < target_height; y++) {
                memcpy(rgb_frame->data[0] + y * rgb_frame->linesize[0],
                       intermediate->data[0] + (y + crop_top) * intermediate->linesize[0],
                       target_width * 3);
            }
        } else {
            // Высоты совпадают — просто копируем
            memcpy(rgb_frame->data[0], intermediate->data[0], target_width * 3 * target_height);
        }
    
        av_frame_free(&intermediate);
        return 0;
    }
    

    Особенности и предпосылки

    • sws_ctx нужно создать один раз при старте, примерно так:
    struct SwsContext *sws_ctx = sws_getContext(
        W_in, H_in, pix_fmt_in,
        IMG_SIZE, (int)(H_in * ((double)IMG_SIZE / W_in) + 0.5),
        AV_PIX_FMT_RGB24,
        SWS_BILINEAR, NULL, NULL, NULL);
    
    • rgb_frame должен быть предварительно выделен и иметь формат AV_PIX_FMT_RGB24 и размер 640x640.
    • frame — входящий декодированный кадр с разрешением W_in x H_in и форматом pix_fmt_in.

    Как это использовать в коде:

    // Инициализация - один раз
    struct SwsContext *sws_ctx = sws_getContext(
        W_in, H_in, pix_fmt_in,
        IMG_SIZE, (int)(H_in * ((double)IMG_SIZE / W_in) + 0.5),
        AV_PIX_FMT_RGB24,
        SWS_BILINEAR, NULL, NULL, NULL);
    
    if (!sws_ctx) {
        fprintf(stderr, "Can't create sws_ctx\n");
        // Обработка ошибки
    }
    
    // Выделяем rgb_frame один раз с нужным размером
    AVFrame *rgb_frame = av_frame_alloc();
    rgb_frame->format = AV_PIX_FMT_RGB24;
    rgb_frame->width = IMG_SIZE;
    rgb_frame->height = IMG_SIZE;
    if (av_frame_get_buffer(rgb_frame, 0) < 0) {
        fprintf(stderr, "Can't allocate rgb_frame buffer\n");
        // Обработка ошибки
    }
    
    // В цикле декодирования
    while (avcodec_receive_frame(codec_ctx, frame) == 0) {
        int ret = scale_crop_letterbox_to_square(frame, rgb_frame, sws_ctx);
        if (ret < 0) {
            fprintf(stderr, "Scaling failed\n");
            break;
        }
        // Дальше rgb_frame содержит 640x640 RGB изображение с буквойбоксом / кропом
    }
    
    // В конце
    sws_freeContext(sws_ctx);
    av_frame_free(&rgb_frame);
    

    Если хотите, могу помочь с примером создания sws_ctx с проверками или автоматической вычислением параметров — скажите!

  17. User

    Отлично теперь после обработки твоей функции я хочу сохранить так

    int save_frame_as_jpeg(AVFrame *pFrame, int width, int height, int iFrame) { int ret = 0;

    const AVCodec *jpegCodec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
    if (!jpegCodec) {
        fprintf(stderr, "JPEG encoder not found\n");
        return -1;
    }
    
    AVCodecContext *jpegContext = avcodec_alloc_context3(jpegCodec);
    if (!jpegContext) {
        fprintf(stderr, "Could not allocate JPEG codec context\n");
        return -1;
    }
    
    jpegContext->pix_fmt = AV_PIX_FMT_YUVJ420P; // Поддерживаемый формат
    	
    jpegContext->width = width;
    jpegContext->height = height;
    jpegContext->time_base = (AVRational){1, 25};
    
    if ((ret = avcodec_open2(jpegContext, jpegCodec, NULL)) < 0) {
        fprintf(stderr, "Could not open JPEG codec\n");
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    // Конвертация RGB24 -> YUVJ420P
    struct SwsContext *sws_ctx = sws_getContext(width, height, pFrame->format,
                                                width, height, jpegContext->pix_fmt,
                                                SWS_BILINEAR, NULL, NULL, NULL);
    if (!sws_ctx) {
        fprintf(stderr, "Could not create sws context\n");
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    AVFrame *frame_yuv = av_frame_alloc();
    if (!frame_yuv) {
        fprintf(stderr, "Could not allocate frame for YUV\n");
        sws_freeContext(sws_ctx);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    frame_yuv->format = jpegContext->pix_fmt;
    frame_yuv->width = width;
    frame_yuv->height = height;
    
    if ((ret = av_frame_get_buffer(frame_yuv, 32)) < 0) {
        fprintf(stderr, "Could not allocate buffer for YUV frame\n");
        av_frame_free(&frame_yuv);
        sws_freeContext(sws_ctx);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    sws_scale(sws_ctx, (const uint8_t * const *)pFrame->data, pFrame->linesize, 0, height,
              frame_yuv->data, frame_yuv->linesize);
    sws_freeContext(sws_ctx);
    
    AVPacket *pkt = av_packet_alloc();
    if (!pkt) {
        fprintf(stderr, "Could not allocate packet\n");
        av_frame_free(&frame_yuv);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    ret = avcodec_send_frame(jpegContext, frame_yuv);
    av_frame_free(&frame_yuv);
    
    if (ret < 0) {
        fprintf(stderr, "Error sending frame to encoder\n");
        av_packet_free(&pkt);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    ret = avcodec_receive_packet(jpegContext, pkt);
    if (ret < 0) {
        fprintf(stderr, "Error receiving packet from encoder\n");
        av_packet_free(&pkt);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    char filename[64];
    	
    	char filename2[64] = {0};
    	snprintf(filename2, 99, "/tmp/frame_%d.jpg", iFrame);
    snprintf(filename, sizeof(filename), filename2);
    FILE *JPEGFile = fopen(filename, "wb");
    if (!JPEGFile) {
        perror("Failed to open output file");
        av_packet_unref(pkt);
        av_packet_free(&pkt);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    fwrite(pkt->data, 1, pkt->size, JPEGFile);
    fclose(JPEGFile);
    //printf("Saved frame: %s (%d KB)\n", filename, pkt->size / 1024);
    
    av_packet_unref(pkt);
    av_packet_free(&pkt);
    avcodec_free_context(&jpegContext);
    
    return 0;
    

    }

  18. Assistant

    Функция save_frame_as_jpeg выглядит в целом корректной и выполняет сохранение кадра в формате JPEG с конвертацией из RGB24 в YUVJ420P, кодированием и записью в файл.

    Ниже небольшой разбор, рекомендации и варианты улучшения.


    Разбор вашей функции

    Что происходит:

    1. Ищется MJPEG кодек.
    2. Создаётся контекст кодека с нужными параметрами (ширина, высота, формат YUVJ420P).
    3. Отрывается кодек.
    4. Создаётся SwsContext для конвертации входного RGB24 (pFrame->format) в YUVJ420P.
    5. Выделяется кадр frame_yuv под YUV данные.
    6. RGB->YUV конвертация с помощью sws_scale.
    7. Отправляется кадр в кодек (avcodec_send_frame()).
    8. Получается сжатый пакет (avcodec_receive_packet()).
    9. Пакет пишется в файл /tmp/frame_<iFrame>.jpg.
    10. Освобождается память.

    Замечания:

    • В строках с snprintf:
    char filename[64];
    char filename2[64] = {0};
    snprintf(filename2, 99, "/tmp/frame_%d.jpg", iFrame);
    snprintf(filename, sizeof(filename), filename2);
    

    filename2 имеет размер 64, а вы пишете в неё с 99 — возможен выход за пределы массива. И потом вы делаете snprintf(filename, sizeof(filename), filename2); — а это избыточно и неудобно.

    Лучше просто:

    char filename[128];
    snprintf(filename, sizeof(filename), "/tmp/frame_%d.jpg", iFrame);
    

    Улучшенный код функции

    int save_frame_as_jpeg(AVFrame *pFrame, int width, int height, int iFrame) {
        int ret;
    
        const AVCodec *jpegCodec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
        if (!jpegCodec) {
            fprintf(stderr, "JPEG encoder not found\n");
            return -1;
        }
    
        AVCodecContext *jpegContext = avcodec_alloc_context3(jpegCodec);
        if (!jpegContext) {
            fprintf(stderr, "Could not allocate JPEG codec context\n");
            return -1;
        }
    
        jpegContext->pix_fmt = AV_PIX_FMT_YUVJ420P;
        jpegContext->width = width;
        jpegContext->height = height;
        jpegContext->time_base = (AVRational){1, 25};
    
        if ((ret = avcodec_open2(jpegContext, jpegCodec, NULL)) < 0) {
            fprintf(stderr, "Could not open JPEG codec\n");
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        struct SwsContext *sws_ctx = sws_getContext(width, height, pFrame->format,
                                                    width, height, jpegContext->pix_fmt,
                                                    SWS_BILINEAR, NULL, NULL, NULL);
        if (!sws_ctx) {
            fprintf(stderr, "Could not create sws context\n");
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        AVFrame *frame_yuv = av_frame_alloc();
        if (!frame_yuv) {
            fprintf(stderr, "Could not allocate frame for YUV\n");
            sws_freeContext(sws_ctx);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        frame_yuv->format = jpegContext->pix_fmt;
        frame_yuv->width = width;
        frame_yuv->height = height;
    
        if ((ret = av_frame_get_buffer(frame_yuv, 32)) < 0) {
            fprintf(stderr, "Could not allocate buffer for YUV frame\n");
            av_frame_free(&frame_yuv);
            sws_freeContext(sws_ctx);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        sws_scale(sws_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, height,
                  frame_yuv->data, frame_yuv->linesize);
        sws_freeContext(sws_ctx);
    
        AVPacket *pkt = av_packet_alloc();
        if (!pkt) {
            fprintf(stderr, "Could not allocate packet\n");
            av_frame_free(&frame_yuv);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        ret = avcodec_send_frame(jpegContext, frame_yuv);
        av_frame_free(&frame_yuv);
    
        if (ret < 0) {
            fprintf(stderr, "Error sending frame to encoder\n");
            av_packet_free(&pkt);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        ret = avcodec_receive_packet(jpegContext, pkt);
        if (ret < 0) {
            fprintf(stderr, "Error receiving packet from encoder\n");
            av_packet_free(&pkt);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        char filename[128];
        snprintf(filename, sizeof(filename), "/tmp/frame_%d.jpg", iFrame);
    
        FILE *JPEGFile = fopen(filename, "wb");
        if (!JPEGFile) {
            perror("Failed to open output file");
            av_packet_unref(pkt);
            av_packet_free(&pkt);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        fwrite(pkt->data, 1, pkt->size, JPEGFile);
        fclose(JPEGFile);
    
        av_packet_unref(pkt);
        av_packet_free(&pkt);
        avcodec_free_context(&jpegContext);
    
        return 0;
    }
    

    Рекомендации по использованию с вашей функцией конвертации

    • После того как вы получили RGB24 кадр (rgb_frame размером 640x640), вызывайте эту функцию:
    int iFrame = 0; // номер кадра
    int ret = save_frame_as_jpeg(rgb_frame, rgb_frame->width, rgb_frame->height, iFrame);
    
    • Убедитесь, что формат rgb_frame — именно AV_PIX_FMT_RGB24.

    • Теперь вы сохраняете именно то изображение, которое получили после масштабирования и буквыбоксинга.


    Если хотите, могу также помочь сделать:

    • Функцию, сохраняющую кадр в PNG (если необходимо).
    • Оптимизацию записи JPEG (например, с повторным созданием кодека вне функции).
    • Отдельную инициализацию/деинициализацию кодека для серийной записи.

    Если есть вопросы — пишите!

  19. User

    что -то там не то

    0 2025-06-29 12:07:28.393452586: длительность: 0.032022 s 0.032, 1: queue size: 0 2 [Writer 1] wp=1 rp=0 size=1 3 [Reader] rp=1 wp=1 size=0 1 2025-06-29 12:07:28.400882795: длительность: 0.142334 s 0.142, 1: queue size: 0 0 2025-06-29 12:07:28.524317003: длительность: 0.061795 s 0.062, 1: queue size: 0 2 [Writer 1] wp=2 rp=1 size=1 1 2025-06-29 12:07:28.525616378: длительность: 0.123060 s 0.123, 1: queue size: 1 4 2025-06-29 12:07:28.622812253: длительность: 0.229102 s 0.229 thread 1 5 2025-06-29 12:07:28.625610503: длительность: 0.230834 s 0.231 3 [Reader] rp=2 wp=2 size=0

    Thread 3 "zzz" received signal SIGSEGV, Segmentation fault. [Switching to LWP 1637] 0xa6cf1ec4 in ?? () from /usr/lib/libswscale.so.5 (gdb) bt #0 0xa6cf1ec4 in ?? () from /usr/lib/libswscale.so.5 #1 0x000ba9f8 in ?? () Backtrace stopped: previous frame identical to this frame (corrupt stack?) (gdb)

  20. Assistant

    Судя по приведённой информации и стектрейсу, вы попали в crash (SIGSEGV) внутри функции из libswscale (sws_scale). Это классическая ошибка несоответствия параметров, или неправильного состояния памяти при вызове sws_scale.


    Возможные причины ошибки и пути отладки

    1. Неверные входные данные для sws_scale

    • pFrame->data или pFrame->linesize равны NULL или повреждены.
    • Размеры width, height не совпадают с размерами в структуре AVFrame.
    • Формат входного фрейма (pFrame->format) не тот, что указан при создании контекста масштабирования.
    • Промежуточный AVFrame, который подаётся в sws_scale для вывода (frame_yuv) не выделен или неправильно инициализирован.

    2. Несоответствие между созданным SwsContext и параметрами sws_scale

    • Создаётся контекст для одних параметров width_height_fmt, а в sws_scale используется другой фрейм с другими параметрами (например, разные размеры, разные форматы).
    • Входные/выходные кадры не совпадают с параметрами, переданными в sws_getContext.

    3. Неверное выделение или освобождение памяти

    • av_frame_get_buffer() не был вызван или завершился с ошибкой до sws_scale.
    • data[] или linesize[] не проинициализированы.

    Конкретные рекомендации по вашему случаю

    Проверьте, что:

    pFrame->format == AV_PIX_FMT_RGB24
    

    (или тот формат, который указан при создании sws_ctx).


    Убедитесь, что кадр, который вы передаёте в sws_scale, действительно содержит валидные данные.

    • Например, сразу после декодирования:
    printf("Input frame format: %d, width: %d, height: %d\n", pFrame->format, pFrame->width, pFrame->height);
    

    Для промежуточного фрейма frame_yuv:

    • Вызывайте av_frame_get_buffer(frame_yuv, 32) и проверяйте результат.
    • Проверяйте, что frame_yuv->data[0] != NULL перед вызовом sws_scale.

    Проследите создание и использование SwsContext

    • Создайте SwsContext ОДИН раз с точными параметрами:
    struct SwsContext *sws_ctx = sws_getContext(
        pFrame->width,
        pFrame->height,
        pFrame->format,
        width,
        height,
        jpegContext->pix_fmt,
        SWS_BILINEAR,
        NULL,
        NULL,
        NULL);
    
    if (!sws_ctx) {
        fprintf(stderr, "Failed to create sws context\n");
        return -1;
    }
    
    • Передайте этот sws_ctx в sws_scale.

    Типичный шаблон вызова:

    int ret = sws_scale(
        sws_ctx,
        (const uint8_t* const*)pFrame->data,
        pFrame->linesize,
        0,
        pFrame->height,
        frame_yuv->data,
        frame_yuv->linesize);
    

    Отладка

    1. Выведите туда сюда размеры, форматы, проверяйте data и linesize на валидность.
    2. Попробуйте вызвать sws_scale на минимальном кадре (например, 1x1) — проверить базовый путь.
    3. Запустите программу через valgrind (если можете) — обнаружит ошибки чтения/записи памяти.

    Быстрый пример исправленной части

    // Подтверждаю, что pFrame->format == AV_PIX_FMT_RGB24
    if (pFrame->format != AV_PIX_FMT_RGB24) {
        fprintf(stderr, "Input frame format is not RGB24: %d\n", pFrame->format);
        return -1;
    }
    
    // Проверяем выделение промежуточного кадра
    if (av_frame_get_buffer(frame_yuv, 32) < 0) {
        fprintf(stderr, "Failed to allocate buffer for YUV frame\n");
        ...
    }
    
    // Проверка data и linesize
    if (!pFrame->data[0] || pFrame->linesize[0] <= 0) {
        fprintf(stderr, "Invalid input frame data or linesize\n");
        ...
    }
    
    if (!frame_yuv->data[0] || frame_yuv->linesize[0] <= 0) {
        fprintf(stderr, "Invalid output frame data or linesize\n");
        ...
    }
    

    Итог

    Ошибка SIGSEGV в libswscale почти всегда связана с:

    • Некорректными входными указателями (data или linesize).
    • Неправильно созданным SwsContext (несовпадение параметров).
    • Неверно выделенной памятью под кадры.

    Если хотите — пришлите срез кода с вашей инициализацией pFrame, sws_ctx, и вызовом sws_scale — помогу проверить на ошибки. Или минимальный воспроизводимый пример.


    Если нужна помощь с детальной отладкой — готов помочь!

  21. User

    it_rate 0 bit 0 delay 0 3 2025-06-29 12:09:40.200341073: длительность: 1.101289 s 1.101 4 Stream resolution: 720x480 0 2025-06-29 12:09:40.818502614: длительность: 0.031906 s 0.032, 1: queue size: 0 Input frame format: 0, width: 720, height: 480 Output frame format: 2, width: 640, height: 640 2 [Writer 1] wp=1 rp=0 size=1 3 [Reader] rp=1 wp=1 size=0 Parse frame format: 2, width: 640, height: 640 1 2025-06-29 12:09:40.826871406: длительность: 0.137903 s 0.138, 1: queue size: 0 0 2025-06-29 12:09:40.958771239: длительность: 0.065024 s 0.065, 1: queue size: 0 Input frame format: 0, width: 720, height: 480 Output frame format: 2, width: 640, height: 640 2 [Writer 1] wp=2 rp=1 size=1 1 2025-06-29 12:09:40.966254531: длительность: 0.137884 s 0.138, 1: queue size: 1 Segmentation fault [root@luckfox ppp]#

  22. Assistant

    Судя по логам:

    • Входной формат кадра: format = 0
    • Выходной формат кадра: format = 2
    • В libavutil/pixfmt.h обычно:
      • AV_PIX_FMT_YUV420P = 0
      • AV_PIX_FMT_RGB24 = 2 (может отличаться по версиям, но в FFmpeg именно так)

    То есть у вас:

    • Исходный кадр в формате YUV420P,
    • После вашей функции масштабирования и конвертации в RGB24.

    Где может быть проблема?

    Вы пытаетесь сохранить формат RGB24 как JPEG, но ваш save_frame_as_jpeg ожидает RGB24 в pFrame->format и конвертирует его в YUVJ420P. То есть функция конвертации правильная.

    Но иногда бывает, что внутри кадра pFrame->format не меняется корректно, или вы передаете в save_frame_as_jpeg не последний подготовленный RGB24 кадр, а исходный YUV420P.


    Проверьте:

    • Что в момент вызова save_frame_as_jpeg(rgb_frame, ...) у rgb_frame->format == AV_PIX_FMT_RGB24.
    • Что параметры rgb_frame->width == 640, rgb_frame->height == 640 совпадают с выделенной памятью.
    • Что rgb_frame->data и rgb_frame->linesize заполнены и валидны (после вызова av_frame_get_buffer и вашей функции масштабирования).

    В вашем случае ошибку может дать:

    • Попытка вызвать sws_scale на кадре, где указатели NULL или повреждены.
    • Передача в save_frame_as_jpeg кадра с неверным форматом (например, исходный YUV420P вместо RGB24).
    • Несоответствие параметров SwsContext тому, что реально используется.
    • Освобождение или переиспользование кадров между потоками некорректно (стек не позволяет видеть полный backtrace).

    Рекомендации по отладке:

    1. Прямо перед вызовом save_frame_as_jpeg напечатайте:
    printf("save_frame_as_jpeg: format: %d, width: %d, height: %d\n",
        rgb_frame->format,
        rgb_frame->width,
        rgb_frame->height);
    
    1. Проверьте, что перед вызовом save_frame_as_jpeg rgb_frame был выделен, его буфер заполнен вашей функцией scale_crop_letterbox_to_square, и данные валидны.

    2. Можно проверить, что перед sws_scale в save_frame_as_jpeg указатели данные указаны верно:

    if (!pFrame->data[0] || !pFrame->linesize[0]) {
        fprintf(stderr, "Invalid input frame data or linesize\n");
        return -1;
    }
    

    Еще важный нюанс по pix_fmt

    В save_frame_as_jpeg вы используете AV_PIX_FMT_YUVJ420P. В современных версиях FFmpeg эта константа считается deprecated. Лучше использовать AV_PIX_FMT_YUV420P, и для JPEG можно уточнить что работает корректно. При необходимости можно проверить, что кодек поддерживает данный формат.


    Итог структурирован:

    • Убедитесь, что:
    rgb_frame->format == AV_PIX_FMT_RGB24
    rgb_frame->width == 640
    rgb_frame->height == 640
    
    • В функции сохранения JPEG:
    struct SwsContext* sws_ctx = sws_getContext(width, height, pFrame->format,
                                                width, height, AV_PIX_FMT_YUVJ420P,
                                                SWS_BILINEAR, NULL, NULL, NULL);
    

    где pFrame->format — именно RGB24, входящий.

    • Всё правильно выделено.

    Если не помогло

    Покажите, пожалуйста (фрагмент):

    • Как именно вызываете scale_crop_letterbox_to_square.
    • Как потом вызываете save_frame_as_jpeg.
    • Фрагмент с инициализацией кадров в вашем коде.
    • Или минимальный воспроизводимый пример.

    Могу помочь найти точку, где память повреждается или используется некорректно.

  23. User

    Функция не правильная,, она пропорциональ вписала в 640 640 - т.е появились черные полосы сверху и сниху.. - по итогу шиниа стала меньше

    static AVFrame* alloc_frame(int width, int height, enum AVPixelFormat pix_fmt) { AVFrame* frame = av_frame_alloc(); if (!frame) return NULL; frame->format = pix_fmt; frame->width = width; frame->height = height; if (av_frame_get_buffer(frame, 0) < 0) { av_frame_free(&frame); return NULL; } return frame; }

    /**

    • Масштабирует входящий кадр frame в квадратный rgb_frame 640x640 RGB24.

    • Используется заранее созданный sws_ctx с параметрами конкретного входного размера -> 640xscaled_height RGB24.

    • Приоритет — сохранить ширину, масштабировать высоту пропорционально,

    • затем добавить паддинг сверху/снизу (черные полосы) либо обрезать по центру,

    • чтобы итоговый размер был 640x640.

    • frame: входной кадр (любой формат, W_in x H_in)

    • rgb_frame: выходной кадр (должен быть выделен заранее 640x640 RGB24)

    • sws_ctx: заранее созданный контекст, масштабирующий из frame->format, W_in x H_in в 640 x scaled_height RGB24

    • Возвращает 0 при успехе, <0 при ошибке */ void scale_crop_letterbox_to_square(const AVFrame *frame, AVFrame *rgb_frame, struct SwsContext *sws_ctx) { if (!frame || !rgb_frame || !sws_ctx) return ;

      const int W_in = frame->width; const int H_in = frame->height;

      const int target_width = IMG_WIDTH; const int target_height = IMG_HEIGHT;

      // Ваша ширина всегда 640, высота от масштаба double scale_factor = (double)target_width / W_in; int scaled_height = (int)(H_in * scale_factor + 0.5);

      if (scaled_height <= 0) return ;

      // Выделяем промежуточный кадр RGB24 размером 640 x scaled_height AVFrame *intermediate = alloc_frame(target_width, scaled_height, AV_PIX_FMT_RGB24); if (!intermediate) { fprintf(stderr, "Failed to allocate intermediate frame\n"); return ; }

      // Конвертация + масштабирование с помощью sws_scale int ret = sws_scale(sws_ctx, (const uint8_t* const*)frame->data, frame->linesize, 0, H_in, intermediate->data, intermediate->linesize); if (ret <= 0) { fprintf(stderr, "sws_scale failed\n"); av_frame_free(&intermediate); return ; }

      // Очистить итоговый rgb_frame чёрным (черный фон для паддинга) memset(rgb_frame->data[0], 0, rgb_frame->linesize[0] * target_height);

      if (scaled_height < target_height) { // Добавляем паддинг сверху и снизу int pad_top = (target_height - scaled_height) / 2; for (int y = 0; y < scaled_height; y++) { memcpy(rgb_frame->data[0] + (y + pad_top) * rgb_frame->linesize[0], intermediate->data[0] + y * intermediate->linesize[0], target_width * 3); // RGB24 = 3 байта на пиксель } } else if (scaled_height > target_height) { // Обрезаем по центру int crop_top = (scaled_height - target_height) / 2; for (int y = 0; y < target_height; y++) { memcpy(rgb_frame->data[0] + y * rgb_frame->linesize[0], intermediate->data[0] + (y + crop_top) * intermediate->linesize[0], target_width * 3); } } else { // Высоты совпадают — просто копируем memcpy(rgb_frame->data[0], intermediate->data[0], target_width * 3 * target_height); }

      av_frame_free(&intermediate);

    }

  24. Assistant

    Понял вашу проблему: текущая функция масштабирует по ширине с приоритетом, а высоту подгоняет пропорционально, в результате получается картинка шириной ровно 640, а высота может быть меньше 640 — поэтому сверху/снизу появляются черные полосы (letterbox).

    Вы хотите сделать так, чтобы итоговое изображение было ровно 640x640, где:

    • Изначально масштабируете входное изображение пропорционально, чтобы полностью заполнить квадрат 640x640 по высоте или по ширине (без искажений).
    • Затем, если после масштабирования одна из сторон больше 640 — делается центральное обрезание (crop).
    • Пропорции сохраняются, и на выходе именно ровный квадрат 640x640 без черных полос.

    То есть приоритет по высоте (640) или ширине (640) — но чтобы картинка была полностью вписана в квадрат 640x640, и при необходимости с обрезкой по центру в одной из осей.


    Что менять?

    Вместо текущей стратегии "ширина = 640, высота пропорционально" сделаем так:

    • Посчитаем отдельно масштаб по ширине (scale_w) и по высоте (scale_h), чтобы нормализовать размер к квадрату 640x640.
    • Выберем максимальный масштаб, чтобы изображение полностью заполняло квадрат и лишние части по меньшей стороне можно было обрезать.
    • Масштабируем изображение пропорционально, согласно этому максимальному масштабу.
    • Если после масштабирования одна сторона больше 640 — делаем crop по центру. Если меньше — (теоретически не должно случаться, но если случится — паддинг).

    Обновлённая функция (собственно масштаб + crop по центру):

    void scale_crop_to_square(const AVFrame *frame, AVFrame *rgb_frame, struct SwsContext *sws_ctx) {
        if (!frame || !rgb_frame || !sws_ctx) return;
    
        const int W_in = frame->width;
        const int H_in = frame->height;
    
        const int target_size = IMG_WIDTH; // 640
    
        // Вычисляем масштаб для обеих осей
        double scale_w = (double)target_size / W_in;
        double scale_h = (double)target_size / H_in;
    
        // Выбираем максимальный масштаб, чтобы заполнить квадрат целиком (с обрезкой)
        double scale = (scale_w > scale_h) ? scale_w : scale_h;
    
        int scaled_width = (int)(W_in * scale + 0.5);
        int scaled_height = (int)(H_in * scale + 0.5);
    
        if (scaled_width <= 0 || scaled_height <= 0) return;
    
        // Отлаживаем
        // printf("Input: %dx%d, scale: %.3f, scaled size: %dx%d\n", W_in, H_in, scale, scaled_width, scaled_height);
    
        // Выделяем промежуточный кадр RGB24 с размером scaled_width x scaled_height
        AVFrame *intermediate = alloc_frame(scaled_width, scaled_height, AV_PIX_FMT_RGB24);
        if (!intermediate) {
            fprintf(stderr, "Failed to allocate intermediate frame\n");
            return;
        }
    
        // Создаём (или используем) sws_ctx для масштабирования из input -> intermediate
        // Предполагается, что sws_ctx создан заранее для W_in x H_in -> scaled_width x scaled_height
    
        int ret = sws_scale(
            sws_ctx,
            (const uint8_t * const *)frame->data,
            frame->linesize,
            0,
            H_in,
            intermediate->data,
            intermediate->linesize
        );
    
        if (ret <= 0) {
            fprintf(stderr, "sws_scale failed\n");
            av_frame_free(&intermediate);
            return;
        }
    
        // Теперь формируем финальный квадратный rgb_frame 640x640 из intermediate с crop по центру
    
        // Очищаем rgb_frame чёрным фоном
        memset(rgb_frame->data[0], 0, rgb_frame->linesize[0] * target_size);
    
        int x_offset = 0;
        int y_offset = 0;
    
        // Если ширина больше 640 — обрезаем по центру
        if (scaled_width > target_size) {
            x_offset = (scaled_width - target_size) / 2;
        }
    
        // Если высота больше 640 — обрезаем по центру
        if (scaled_height > target_size) {
            y_offset = (scaled_height - target_size) / 2;
        }
    
        // Копируем crop 640x640 из intermediate в rgb_frame
        for (int y = 0; y < target_size; y++) {
            memcpy(
                rgb_frame->data[0] + y * rgb_frame->linesize[0],
                intermediate->data[0] + (y + y_offset) * intermediate->linesize[0] + x_offset * 3, // 3 байта на пиксель RGB24
                target_size * 3
            );
        }
    
        av_frame_free(&intermediate);
    }
    

    Что ещё нужно учесть?

    Создание sws_ctx

    Так как теперь масштаб может отличаться, sws_ctx нужно создавать именно под динамические размеры scaled_width x scaled_height (зависит от входного кадра):

    struct SwsContext *sws_ctx = sws_getContext(
        W_in, H_in, frame->format,
        scaled_width, scaled_height, AV_PIX_FMT_RGB24,
        SWS_BILINEAR, NULL, NULL, NULL);
    

    То есть в вашем основном коде сначала надо вычислить scaled_width и scaled_height как описано, создать context, вызвать функцию, потом при следующем кадре - проверить, требуется ли пересоздание контекста.

    Или, если разрешение исходного кадра не меняется, создать контекст в начале и использовать один раз — но в этом случае у вас фиксированный масштаб и могут появиться черные полосы (letterbox).


    Пример использования

    // 1. Посчитаем масштаб и размер
    double scale_w = (double)IMG_WIDTH / W_in;
    double scale_h = (double)IMG_HEIGHT / H_in;
    double scale = (scale_w > scale_h) ? scale_w : scale_h;
    
    int scaled_width = (int)(W_in * scale + 0.5);
    int scaled_height = (int)(H_in * scale + 0.5);
    
    // 2. Создаём sws_ctx для этого размера
    struct SwsContext *sws_ctx = sws_getContext(
        W_in, H_in, frame->format,
        scaled_width, scaled_height, AV_PIX_FMT_RGB24,
        SWS_BILINEAR, NULL, NULL, NULL);
    
    // 3. Выделяем rgb_frame 640x640 RGB24 заранее (один раз)
    //    и вызываем функцию
    scale_crop_to_square(frame, rgb_frame, sws_ctx);
    

    Итог

    • Функция масштабирует пропорционально с приоритетом на полное заполнение квадрата.
    • Обрезает центр лишнего по ширине или высоте.
    • На выходе чистый квадрат 640x640 без черных полос.

    Если нужно — помогу с переработкой вашего кода создания sws_ctx, выделения кадров и обработкой потока.

  25. User

    неееееееееееееет приоритет ВСЕГДА ШИРИНА

  26. Assistant

    Понял, приоритет ВСЕГДА ширина!

    То есть поведение такое:

    • Исходное изображение масштабируется таким образом, чтобы ширина была ровно 640 (без искажений),
    • высота масштабируется пропорционально,
    • затем, если высота после масштабирования больше 640 — по вертикали обрезаем по центру (crop),
    • если меньше 640 — заполнение сверху и снизу черными полосами (letterbox).

    Вот исправленная функция с приоритетом ширины ± вертикальное crop или letterbox

    void scale_crop_letterbox_fixed_width(const AVFrame *frame, AVFrame *rgb_frame, struct SwsContext *sws_ctx) {
        if (!frame || !rgb_frame || !sws_ctx) return;
    
        const int W_in = frame->width;
        const int H_in = frame->height;
        const int target_width = IMG_WIDTH;  // 640
        const int target_height = IMG_HEIGHT; // 640
    
        // Масштабируем только по ширине
        double scale_factor = (double)target_width / W_in;
        int scaled_height = (int)(H_in * scale_factor + 0.5);
    
        if (scaled_height <= 0) return;
    
        // Выделяем промежуточный кадр RGB24 размером 640 x scaled_height
        AVFrame *intermediate = alloc_frame(target_width, scaled_height, AV_PIX_FMT_RGB24);
        if (!intermediate) {
            fprintf(stderr, "Failed to allocate intermediate frame\n");
            return;
        }
    
        // Выполняем масштабирование с помощью sws_scale
        int ret = sws_scale(
            sws_ctx,
            (const uint8_t* const*)frame->data,
            frame->linesize,
            0,
            H_in,
            intermediate->data,
            intermediate->linesize);
        if (ret <= 0) {
            fprintf(stderr, "sws_scale failed\n");
            av_frame_free(&intermediate);
            return;
        }
    
        // Очищаем финальный rgb_frame (640x640) черным цветом для паддинга
        memset(rgb_frame->data[0], 0, rgb_frame->linesize[0] * target_height);
    
        if (scaled_height == target_height) {
            // Высоты совпадают — просто копируем
            memcpy(
                rgb_frame->data[0],
                intermediate->data[0],
                target_width * 3 * target_height);
        } else if (scaled_height < target_height) {
            // Высота меньше 640 — добавляем паддинг сверху и снизу
            int pad_top = (target_height - scaled_height) / 2;
            for (int y = 0; y < scaled_height; y++) {
                memcpy(
                    rgb_frame->data[0] + (y + pad_top) * rgb_frame->linesize[0],
                    intermediate->data[0] + y * intermediate->linesize[0],
                    target_width * 3);
            }
        } else {
            // Высота больше 640 — делаем кроп по вертикали по центру
            int crop_top = (scaled_height - target_height) / 2;
            for (int y = 0; y < target_height; y++) {
                memcpy(
                    rgb_frame->data[0] + y * rgb_frame->linesize[0],
                    intermediate->data[0] + (y + crop_top) * intermediate->linesize[0],
                    target_width * 3);
            }
        }
    
        av_frame_free(&intermediate);
    }
    

    Важные моменты:

    • sws_ctx нужно создать заранее с параметрами именно для масштабирования из W_in x H_in и входного формата в 640 x scaled_height RGB24, например:
    int W_in = frame->width;
    int H_in = frame->height;
    double scale_factor = (double)IMG_WIDTH / W_in;
    int scaled_height = (int)(H_in * scale_factor + 0.5);
    
    struct SwsContext *sws_ctx = sws_getContext(
        W_in, H_in, frame->format,
        IMG_WIDTH, scaled_height, AV_PIX_FMT_RGB24,
        SWS_BILINEAR, NULL, NULL, NULL);
    
    • В функции масштабируем из frame в intermediate размером 640 x scaled_height.
    • Потом делаем в rgb_frame итоговое ровное 640x640 — берём из промежуточного кадра нужную часть вертикально (crop или letterbox).

    Предположения:

    • rgb_frame уже выделен (640x640, RGB24).
    • Вся память подготовлена корректно.

    Если нужно, могу помочь с примером создания sws_ctx, выделения кадров и примером вызова.

  27. User

    так теперь я сохраняю rgb_frame вот лог Input frame format: 0, width: 720, height: 480 Output frame format: 2, width: 640, height: 640 2 [Writer 1] wp=9 rp=5 size=4 1 2025-06-29 12:22:17.246060294: длительность: 0.123404 s 0.123, 1: queue size: 4 4 2025-06-29 12:22:17.405194211: длительность: 0.221037 s 0.221 thread 1 5 2025-06-29 12:22:17.408022211: длительность: 0.223865 s 0.224 3 [Reader] rp=6 wp=9 size=3 Parse frame format: 2, width: 640, height: 640 Segmentation fault

    int save_frame_as_jpeg(AVFrame *pFrame, int width, int height, int iFrame) { int ret;

    	// Подтверждаю, что pFrame->format == AV_PIX_FMT_RGB24
    	if (pFrame->format != AV_PIX_FMT_RGB24) {
    			fprintf(stderr, "Input frame format is not RGB24: %d\n", pFrame->format);
    			return -1;
    	}
    
    const AVCodec *jpegCodec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
    if (!jpegCodec) {
        fprintf(stderr, "JPEG encoder not found\n");
        return -1;
    }
    
    AVCodecContext *jpegContext = avcodec_alloc_context3(jpegCodec);
    if (!jpegContext) {
        fprintf(stderr, "Could not allocate JPEG codec context\n");
        return -1;
    }
    
    jpegContext->pix_fmt = AV_PIX_FMT_YUVJ420P;
    jpegContext->width = width;
    jpegContext->height = height;
    jpegContext->time_base = (AVRational){1, 25};
    
    if ((ret = avcodec_open2(jpegContext, jpegCodec, NULL)) < 0) {
        fprintf(stderr, "Could not open JPEG codec\n");
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    struct SwsContext *sws_ctx = sws_getContext(width, height, pFrame->format,
                                                width, height, jpegContext->pix_fmt,
                                                SWS_BILINEAR, NULL, NULL, NULL);
    if (!sws_ctx) {
        fprintf(stderr, "Could not create sws context\n");
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    AVFrame *frame_yuv = av_frame_alloc();
    if (!frame_yuv) {
        fprintf(stderr, "Could not allocate frame for YUV\n");
        sws_freeContext(sws_ctx);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    frame_yuv->format = jpegContext->pix_fmt;
    frame_yuv->width = width;
    frame_yuv->height = height;
    
    if ((ret = av_frame_get_buffer(frame_yuv, 32)) < 0) {
        fprintf(stderr, "Could not allocate buffer for YUV frame\n");
        av_frame_free(&frame_yuv);
        sws_freeContext(sws_ctx);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    sws_scale(sws_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, height,
              frame_yuv->data, frame_yuv->linesize);
    sws_freeContext(sws_ctx);
    
    AVPacket *pkt = av_packet_alloc();
    if (!pkt) {
        fprintf(stderr, "Could not allocate packet\n");
        av_frame_free(&frame_yuv);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    ret = avcodec_send_frame(jpegContext, frame_yuv);
    av_frame_free(&frame_yuv);
    
    if (ret < 0) {
        fprintf(stderr, "Error sending frame to encoder\n");
        av_packet_free(&pkt);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    ret = avcodec_receive_packet(jpegContext, pkt);
    if (ret < 0) {
        fprintf(stderr, "Error receiving packet from encoder\n");
        av_packet_free(&pkt);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    char filename[128];
    snprintf(filename, sizeof(filename), "/tmp/frame_%d.jpg", iFrame);
    
    FILE *JPEGFile = fopen(filename, "wb");
    if (!JPEGFile) {
        perror("Failed to open output file");
        av_packet_unref(pkt);
        av_packet_free(&pkt);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    fwrite(pkt->data, 1, pkt->size, JPEGFile);
    fclose(JPEGFile);
    
    av_packet_unref(pkt);
    av_packet_free(&pkt);
    avcodec_free_context(&jpegContext);
    
    return 0;
    

    }

  28. Assistant

    Спасибо за подробности. Ошибка SIGSEGV возникает в вашем save_frame_as_jpeg при вызове sws_scale или куда-то рядом с конвертацией из RGB в YUV для JPEG. Рассмотрим возможные причины и исправим вашу функцию.


    Возможные причины сбоя:

    1. Несовместимый формат входного кадра (pFrame) с параметрами SwsContext.

      • Вы указываете pFrame->format == AV_PIX_FMT_RGB24, но для MJPEG энкодера стоит использовать AV_PIX_FMT_YUVJ420P (в новых версиях лучше AV_PIX_FMT_YUV420P).
      • При создании SwsContext происходит конвертация из RGB в YUVJ420P — тут важно, чтобы width, height и format точно совпадали с данными кадров.
    2. Выделение или инициализация кадра frame_yuv выполнено некорректно (недостаточный буфер, неверный формат).

    3. Параметры avcodec_open2 и настройки кодека могут нуждаться в настройке flags или bit_rate для лучшей стабильности.

    4. Доступ к pFrame->data и pFrame->linesize до вызова sws_scale возможно плохой.


    Основные рекомендации и исправления:

    А. Пока не используйте AV_PIX_FMT_YUVJ420P, измените на AV_PIX_FMT_YUV420P

    В последних версиях ffmpeg YUVJ420P считается устаревшим, YUV420P — основной для MJPEG.

    jpegContext->pix_fmt = AV_PIX_FMT_YUV420P;
    

    Б. Инициализация frame_yuv

    Если frame_yuv с форматом YUV420P, при вызове av_frame_get_buffer желательно использовать 32-байтное выравнивание (как вы делаете).


    В. Убедитесь, что sws_getContext соответствует именно входным параметрам:

    struct SwsContext *sws_ctx = sws_getContext(
        width, height, pFrame->format,
        width, height, jpegContext->pix_fmt,
        SWS_FAST_BILINEAR, NULL, NULL, NULL);
    

    Если pFrame->format действительно AV_PIX_FMT_RGB24, а jpegContext->pix_fmt — AV_PIX_FMT_YUV420P.


    Г. Проверяйте ошибки sws_scale — они у вас не проверяются подробно.


    Д. Рекомендуется создавать и открывать кодек и sws_ctx один раз в жизни программы, а не на каждый кадр.


    Исправленная ваша функция (упрощённый, более надежный вариант):

    int save_frame_as_jpeg(AVFrame *pFrame, int width, int height, int iFrame) {
        int ret;
    
        if (pFrame->format != AV_PIX_FMT_RGB24) {
            fprintf(stderr, "Input frame format is not RGB24: %d\n", pFrame->format);
            return -1;
        }
    
        // Найти MJPEG энкодер
        const AVCodec *jpegCodec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
        if (!jpegCodec) {
            fprintf(stderr, "JPEG encoder not found\n");
            return -1;
        }
    
        AVCodecContext *jpegContext = avcodec_alloc_context3(jpegCodec);
        if (!jpegContext) {
            fprintf(stderr, "Could not allocate JPEG codec context\n");
            return -1;
        }
    
        jpegContext->pix_fmt = AV_PIX_FMT_YUV420P; // безопаснее
        jpegContext->width = width;
        jpegContext->height = height;
        jpegContext->time_base = (AVRational){1, 25};
    
        if ((ret = avcodec_open2(jpegContext, jpegCodec, NULL)) < 0) {
            fprintf(stderr, "Could not open JPEG codec\n");
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        // Создать SwsContext для RGB->YUV420P конвертации
        struct SwsContext *sws_ctx = sws_getContext(
            width, height, AV_PIX_FMT_RGB24,
            width, height, jpegContext->pix_fmt,
            SWS_BILINEAR, NULL, NULL, NULL);
        if (!sws_ctx) {
            fprintf(stderr, "Could not create sws context\n");
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        AVFrame *frame_yuv = av_frame_alloc();
        if (!frame_yuv) {
            fprintf(stderr, "Could not allocate frame for YUV\n");
            sws_freeContext(sws_ctx);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        frame_yuv->format = jpegContext->pix_fmt;
        frame_yuv->width = width;
        frame_yuv->height = height;
    
        if ((ret = av_frame_get_buffer(frame_yuv, 32)) < 0) {
            fprintf(stderr, "Could not allocate buffer for YUV frame\n");
            av_frame_free(&frame_yuv);
            sws_freeContext(sws_ctx);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        // Конвертация RGB->YUV
        ret = sws_scale(sws_ctx,
                        (const uint8_t * const *)pFrame->data,
                        pFrame->linesize,
                        0,
                        height,
                        frame_yuv->data,
                        frame_yuv->linesize);
        if (ret <= 0) {
            fprintf(stderr, "sws_scale failed\n");
            av_frame_free(&frame_yuv);
            sws_freeContext(sws_ctx);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        sws_freeContext(sws_ctx);
    
        AVPacket *pkt = av_packet_alloc();
        if (!pkt) {
            fprintf(stderr, "Could not allocate packet\n");
            av_frame_free(&frame_yuv);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        ret = avcodec_send_frame(jpegContext, frame_yuv);
        av_frame_free(&frame_yuv);
        if (ret < 0) {
            fprintf(stderr, "Error sending frame to encoder\n");
            av_packet_free(&pkt);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        ret = avcodec_receive_packet(jpegContext, pkt);
        if (ret < 0) {
            fprintf(stderr, "Error receiving packet from encoder\n");
            av_packet_free(&pkt);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        char filename[128];
        snprintf(filename, sizeof(filename), "/tmp/frame_%d.jpg", iFrame);
    
        FILE *JPEGFile = fopen(filename, "wb");
        if (!JPEGFile) {
            perror("Failed to open output file");
            av_packet_unref(pkt);
            av_packet_free(&pkt);
            avcodec_free_context(&jpegContext);
            return -1;
        }
    
        fwrite(pkt->data, 1, pkt->size, JPEGFile);
        fclose(JPEGFile);
    
        av_packet_unref(pkt);
        av_packet_free(&pkt);
        avcodec_free_context(&jpegContext);
    
        return 0;
    }
    

    Дополнительно

    • Поскольку вы вызываете avcodec_alloc_context3 и avcodec_open2 на каждый кадр — это тяжелая операция, которая замедляет работу и может вызвать утечки.
      Рекомендуется делать инициализацию один раз (создавать и открывать кодек), а затем просто отправлять кадры и получать пакеты, после окончания работы — освобождать контекст.

    • Собственно, выделение и освобождение sws_ctx тоже лучше сделать единоразово.


    Если хотите, могу помочь переписать код с кэшированием/повторным использованием кодека и sws_ctx — это улучшит производительность и надежность.


    Если будет нужна помощь с этим — пишите!

  29. User

    у меня версия ffmpeg 4.4.6

  30. Assistant

    Понял, у вас FFmpeg 4.4.6 — достаточно свежая стабильная версия, где всё, описанное выше, актуально, но с некоторыми нюансами:

    Особенности FFmpeg 4.4.6 по форме пикселей

    • AV_PIX_FMT_YUVJ420P (jpeg full-range variant) в 4.4.6 ещё поддерживается и часто используют для JPEG с правильным цветом.
    • Однако официально рекомендуется переходить на AV_PIX_FMT_YUV420P и управлять цветовым диапазоном через параметры, т.к. YUVJ420P считается deprecated.
    • Но если у вас было успешно в FFmpeg 4.4.6 сохранять JPEG с YUVJ420P, можно и так оставить.

    Рекомендации для FFmpeg 4.4.6 для вашей задачи

    1. Используйте AV_PIX_FMT_YUVJ420P как вы сейчас, если уже было успешно — не спешите менять, чтобы избежать лишних багов.

    2. Проверяйте, что параметры при создании контекста совпадают по формату и размерам с фактическими данными.
      sws_getContext должен создаваться с теми же параметрами, что и у pFrame и frame_yuv.

    3. Инициализация кодека и SwsContext — желательно один раз при старте, а не на каждый кадр.
      Повторное создание и уничтожение приводит к затратам и рискам ошибок.

    4. Проверяйте ошибки тщательно.
      Каждый вызов FFmpeg API возвращает код и их стоит логировать.


    Важно: пример правильного порядка для FFmpeg 4.4.6

    // Инициализация (один раз)
    AVCodec *jpegCodec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
    AVCodecContext *jpegContext = avcodec_alloc_context3(jpegCodec);
    
    jpegContext->pix_fmt = AV_PIX_FMT_YUVJ420P;  // или AV_PIX_FMT_YUV420P с управлением цвета
    jpegContext->width = IMG_WIDTH;
    jpegContext->height = IMG_HEIGHT;
    jpegContext->time_base = (AVRational){1, 25};
    avcodec_open2(jpegContext, jpegCodec, NULL);
    
    // Создаем sws_ctx один раз
    struct SwsContext *sws_ctx = sws_getContext(
        IMG_WIDTH, IMG_HEIGHT, AV_PIX_FMT_RGB24,  // источник — RGB24!
        IMG_WIDTH, IMG_HEIGHT, jpegContext->pix_fmt,
        SWS_BILINEAR, NULL, NULL, NULL);
    
    // При сохранении кадра
    int save_frame_as_jpeg(AVFrame *rgb_frame, int frame_number) {
        AVFrame *frame_yuv = av_frame_alloc();
        frame_yuv->format = jpegContext->pix_fmt;
        frame_yuv->width  = IMG_WIDTH;
        frame_yuv->height = IMG_HEIGHT;
        av_frame_get_buffer(frame_yuv, 32);
    
        sws_scale(sws_ctx,
                  (const uint8_t* const*)rgb_frame->data, rgb_frame->linesize,
                  0, IMG_HEIGHT,
                  frame_yuv->data, frame_yuv->linesize);
    
        AVPacket *pkt = av_packet_alloc();
        avcodec_send_frame(jpegContext, frame_yuv);
        avcodec_receive_packet(jpegContext, pkt);
    
        char filename[128];
        snprintf(filename, sizeof(filename), "/tmp/frame_%d.jpg", frame_number);
        FILE* f = fopen(filename, "wb");
        fwrite(pkt->data, 1, pkt->size, f);
        fclose(f);
    
        av_packet_unref(pkt);
        av_packet_free(&pkt);
        av_frame_free(&frame_yuv);
    
        return 0;
    }
    
    // В конце программы
    sws_freeContext(sws_ctx);
    avcodec_free_context(&jpegContext);
    

    Если сохранение всё равно падает с ошибками:

    • Проверьте, что rgb_frame реально заполнен, data и linesize валидны.
    • Запустите с отладчиком или valgrind (memcheck), чтобы проверить повреждения памяти.
    • Можно добавить печать rgb_frame полей перед вызовом sws_scale.

    Резюме

    • FFmpeg 4.4.6 поддерживает ваши подходы.
    • Используйте единоразовую инициализацию кодека и sws_ctx.
    • Применяйте AV_PIX_FMT_YUVJ420P или AV_PIX_FMT_YUV420P на своё усмотрение, но с согласованной логикой.
    • Тщательно проверяйте ошибки.

    Если хотите, могу помочь вам написать небольшой минимальный пример под FFmpeg 4.4.6, который будет стабильно сохранять RGB24 в JPEG с нужными параметрами.

  31. User

    int save_frame_as_jpeg(AVFrame *pFrame, int width, int height, int iFrame) { int ret;

    	// Подтверждаю, что pFrame->format == AV_PIX_FMT_RGB24
    	if (pFrame->format != AV_PIX_FMT_RGB24) {
    			fprintf(stderr, "Input frame format is not RGB24: %d\n", pFrame->format);
    			return -1;
    	}
    
    const AVCodec *jpegCodec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
    if (!jpegCodec) {
        fprintf(stderr, "JPEG encoder not found\n");
        return -1;
    }
    
    AVCodecContext *jpegContext = avcodec_alloc_context3(jpegCodec);
    if (!jpegContext) {
        fprintf(stderr, "Could not allocate JPEG codec context\n");
        return -1;
    }
    
    jpegContext->pix_fmt = AV_PIX_FMT_YUVJ420P;
    jpegContext->width = width;
    jpegContext->height = height;
    jpegContext->time_base = (AVRational){1, 25};
    
    if ((ret = avcodec_open2(jpegContext, jpegCodec, NULL)) < 0) {
        fprintf(stderr, "Could not open JPEG codec\n");
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    struct SwsContext *sws_ctx = sws_getContext(width, height, pFrame->format,
                                                width, height, jpegContext->pix_fmt,
                                                SWS_BILINEAR, NULL, NULL, NULL);
    if (!sws_ctx) {
        fprintf(stderr, "Could not create sws context\n");
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    AVFrame *frame_yuv = av_frame_alloc();
    if (!frame_yuv) {
        fprintf(stderr, "Could not allocate frame for YUV\n");
        sws_freeContext(sws_ctx);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    frame_yuv->format = jpegContext->pix_fmt;
    frame_yuv->width = width;
    frame_yuv->height = height;
    
    if ((ret = av_frame_get_buffer(frame_yuv, 32)) < 0) {
        fprintf(stderr, "Could not allocate buffer for YUV frame\n");
        av_frame_free(&frame_yuv);
        sws_freeContext(sws_ctx);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    sws_scale(sws_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, height,
              frame_yuv->data, frame_yuv->linesize);
    sws_freeContext(sws_ctx);
    
    AVPacket *pkt = av_packet_alloc();
    if (!pkt) {
        fprintf(stderr, "Could not allocate packet\n");
        av_frame_free(&frame_yuv);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    ret = avcodec_send_frame(jpegContext, frame_yuv);
    av_frame_free(&frame_yuv);
    
    if (ret < 0) {
        fprintf(stderr, "Error sending frame to encoder\n");
        av_packet_free(&pkt);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    ret = avcodec_receive_packet(jpegContext, pkt);
    if (ret < 0) {
        fprintf(stderr, "Error receiving packet from encoder\n");
        av_packet_free(&pkt);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    char filename[128];
    snprintf(filename, sizeof(filename), "/tmp/frame_%d.jpg", iFrame);
    
    FILE *JPEGFile = fopen(filename, "wb");
    if (!JPEGFile) {
        perror("Failed to open output file");
        av_packet_unref(pkt);
        av_packet_free(&pkt);
        avcodec_free_context(&jpegContext);
        return -1;
    }
    
    fwrite(pkt->data, 1, pkt->size, JPEGFile);
    fclose(JPEGFile);
    
    av_packet_unref(pkt);
    av_packet_free(&pkt);
    avcodec_free_context(&jpegContext);
    
    return 0;
    

    } так предеелай полностью функци чтобы все работало

  32. Assistant

    Конечно! Вот полностью переработанный и оптимизированный вариант функции сохранения кадра RGB24 в JPEG с использованием FFmpeg 4.4.6 (и подходом с сохранением кодека и sws контекста между вызовами):


    Основные изменения и улучшения:

    • Инициализация кодека и sws контекста выделена в отдельную функцию, чтобы создавать их один раз.
    • Функция сохранения кадра принимает уже подготовленные jpegContext и SwsContext, а не инициализирует их на каждый вызов.
    • В функции сохранения кадра происходит конвертация RGB->YUV и кодирование без лишних аллокаций/инициализаций.
    • Выделение и освобождение пакета, буферов и кадров строго контролируется.
    • Улучшена проверка ошибок и освобождение ресурсов.

    Код:

    #include <libavcodec/avcodec.h>
    #include <libavutil/imgutils.h>
    #include <libavutil/frame.h>
    #include <libswscale/swscale.h>
    #include <stdio.h>
    
    #define IMG_WIDTH  640
    #define IMG_HEIGHT 640
    
    // Контекст для сохранения JPEG
    typedef struct {
        AVCodecContext *jpegContext;
        struct SwsContext *sws_ctx;
        AVFrame *frame_yuv; // Отформатированный кадр для кодека
    } JPEGState;
    
    // Инициализация JPEG encoder + SwsContext
    int init_jpeg_encoder(JPEGState *state, int width, int height) {
        if (!state) return -1;
    
        const AVCodec *jpegCodec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
        if (!jpegCodec) {
            fprintf(stderr, "JPEG encoder not found\n");
            return -1;
        }
    
        state->jpegContext = avcodec_alloc_context3(jpegCodec);
        if (!state->jpegContext) {
            fprintf(stderr, "Could not allocate JPEG codec context\n");
            return -1;
        }
    
        state->jpegContext->pix_fmt = AV_PIX_FMT_YUVJ420P; // или AV_PIX_FMT_YUV420P
        state->jpegContext->width = width;
        state->jpegContext->height = height;
        state->jpegContext->time_base = (AVRational){1, 25};
    
        if (avcodec_open2(state->jpegContext, jpegCodec, NULL) < 0) {
            fprintf(stderr, "Could not open JPEG codec\n");
            avcodec_free_context(&state->jpegContext);
            return -1;
        }
    
        // Для конвертации из RGB24 в YUV420P
        state->sws_ctx = sws_getContext(
            width, height, AV_PIX_FMT_RGB24,
            width, height, state->jpegContext->pix_fmt,
            SWS_BILINEAR, NULL, NULL, NULL
        );
    
        if (!state->sws_ctx) {
            fprintf(stderr, "Could not create sws context\n");
            avcodec_free_context(&state->jpegContext);
            return -1;
        }
    
        state->frame_yuv = av_frame_alloc();
        if (!state->frame_yuv) {
            fprintf(stderr, "Could not allocate frame for YUV\n");
            sws_freeContext(state->sws_ctx);
            avcodec_free_context(&state->jpegContext);
            return -1;
        }
    
        state->frame_yuv->format = state->jpegContext->pix_fmt;
        state->frame_yuv->width = width;
        state->frame_yuv->height = height;
    
        if (av_frame_get_buffer(state->frame_yuv, 32) < 0) {
            fprintf(stderr, "Could not allocate buffer for YUV frame\n");
            av_frame_free(&state->frame_yuv);
            sws_freeContext(state->sws_ctx);
            avcodec_free_context(&state->jpegContext);
            return -1;
        }
    
        return 0;
    }
    
    // Освобождение ресурсов JPEGState
    void free_jpeg_encoder(JPEGState *state) {
        if (!state) return;
    
        if (state->frame_yuv) {
            av_frame_free(&state->frame_yuv);
            state->frame_yuv = NULL;
        }
        if (state->sws_ctx) {
            sws_freeContext(state->sws_ctx);
            state->sws_ctx = NULL;
        }
        if (state->jpegContext) {
            avcodec_free_context(&state->jpegContext);
            state->jpegContext = NULL;
        }
    }
    
    // Сохраняем один кадр из rgb_frame (RGB24)
    int save_frame_as_jpeg(JPEGState *state, AVFrame *rgb_frame, int iFrame) {
        if (!state || !rgb_frame) {
            fprintf(stderr, "Invalid parameters to save_frame_as_jpeg\n");
            return -1;
        }
    
        // Проверка формата входного кадра
        if (rgb_frame->format != AV_PIX_FMT_RGB24) {
            fprintf(stderr, "Input frame format is not RGB24: %d\n", rgb_frame->format);
            return -1;
        }
    
        // Конвертация RGB24 -> YUV420P
        int ret = sws_scale(
            state->sws_ctx,
            (const uint8_t * const *)rgb_frame->data,
            rgb_frame->linesize,
            0,
            rgb_frame->height,
            state->frame_yuv->data,
            state->frame_yuv->linesize
        );
        if (ret <= 0) {
            fprintf(stderr, "sws_scale failed\n");
            return -1;
        }
    
        // Отправляем кадр кодеку
        ret = avcodec_send_frame(state->jpegContext, state->frame_yuv);
        if (ret < 0) {
            fprintf(stderr, "Error sending frame to encoder: %d\n", ret);
            return -1;
        }
    
        AVPacket *pkt = av_packet_alloc();
        if (!pkt) {
            fprintf(stderr, "Could not allocate packet\n");
            return -1;
        }
    
        ret = avcodec_receive_packet(state->jpegContext, pkt);
        if (ret < 0) {
            fprintf(stderr, "Error receiving packet from encoder: %d\n", ret);
            av_packet_free(&pkt);
            return -1;
        }
    
        // Запись файла
        char filename[128];
        snprintf(filename, sizeof(filename), "/tmp/frame_%d.jpg", iFrame);
        FILE *JPEGFile = fopen(filename, "wb");
        if (!JPEGFile) {
            perror("Failed to open output file");
            av_packet_unref(pkt);
            av_packet_free(&pkt);
            return -1;
        }
    
        fwrite(pkt->data, 1, pkt->size, JPEGFile);
        fclose(JPEGFile);
    
        av_packet_unref(pkt);
        av_packet_free(&pkt);
    
        return 0;
    }
    

    Пример использования:

    int main() {
        // Инициализация FFmpeg (если требуется)
        avcodec_register_all();
        av_log_set_level(AV_LOG_ERROR);
    
        JPEGState jpeg_state = {0};
        if (init_jpeg_encoder(&jpeg_state, IMG_WIDTH, IMG_HEIGHT) < 0) {
            fprintf(stderr, "Failed to initialize JPEG encoder\n");
            return -1;
        }
    
        // rgb_frame — ваш RGB24 кадр с размером IMG_WIDTH x IMG_HEIGHT
        AVFrame *rgb_frame = ... ; // Предположим, что у вас он готов
    
        for (int i = 0; i < 10; i++) {
            if (save_frame_as_jpeg(&jpeg_state, rgb_frame, i) < 0) {
                fprintf(stderr, "Failed to save frame %d\n", i);
            }
        }
    
        free_jpeg_encoder(&jpeg_state);
    
        return 0;
    }
    

    Важные моменты:

    • Создавайте jpegContext и sws_ctx один раз, чтобы не тратить время и ресурсы.
    • Следите за тем, чтобы rgb_frame имел формат AV_PIX_FMT_RGB24 и размер 640x640 (или ваш нужный).
    • Кодировку и сохранение делайте через функцию save_frame_as_jpeg, передавая подготовленный объект JPEGState.

    Если хотите, могу помочь интегрировать это в ваш текущий проект, или дать более подробный пример по подготовке кадров.