Что делает эта функция *swsctx = swsgetContext( (*codec_ctx)->width,…
- 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
- 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); // дополнительные параметры: фильтры и т.п. (не используются)- Исходное изображение должно иметь ширину и высоту из
(*codec_ctx), а формат пикселей —(*codec_ctx)->pix_fmt(например, YUV420P, NV12 и т.п.). - Цель – преобразовать это изображение в размер 640x640 пикселей (
IMG_WIDTHиIMG_HEIGHTравны 640) с форматом RGB24. - Алгоритм масштабирования — SWS_FAST_BILINEAR — обеспечивает быстрое, но не самое качественное сглаживание (билинейная интерполяция).
- Если инициализация контекста
sws_ctxне удалась — выводится сообщение об ошибке и функция возвращает-1.
Для чего это нужно
SwsContext*используется для преобразования изображения из одного размера и формата в другой. Часто это необходимо:- для конвертации кадров декодированного видео в форму, удобную для отображения,
- для изменения разрешения кадра,
- для последующей обработки в RGB цветовой модели (например, для отображения или дальнейшего анализа).
В итоге
Этот код создает и инициализирует контекст для преобразования (масштабирования + конвертации цвета) видео кадра с исходного формата и размера (из
codec_ctx) в RGB24 формат с размером 640x640 пикселей. Если контекст создать не удается, функция сообщает об ошибке.
Если понадобится, могу помочь с примером, как пользоваться этим
sws_ctxдля конвертации кадров и вызоваsws_scale(). - Исходное изображение должно иметь ширину и высоту из
- 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; } - 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.
В итоге
Этот код:
- Подготавливает структуру
rgb_frameдля хранения rgb-изображения размером 640x640. - Выделяет память под данные кадра, чтобы туда могло быть записано изображение после конвертации/sws_scale.
Эта часть обычно стоит перед вызовом
sws_scale(), где вrgb_frameбудет записано сконвертированное видео изображение в нужном формате и размере. - Здесь устанавливаются параметры кадра: формат пикселей —
- User
т.е по итогу вот проихошло декодирование
while (avcodec_receive_frame(codec_ctx, frame) == 0) { и какие размеры и форто у меня получилось
- 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. -
- User
вооот sws_scale(sws_ctx, (const uint8_t const*)frame->data, frame->linesize, 0, frame->height, rgb_frame->data, rgb_frame->linesize); теперь смотри у меня входное разрешение может быть разное а на выходе надо получить 640x640! но пропорциональное либо уменьшить либо увеличить - но приоритет по ширине, а высоту либо добабвить, либо просто обрезать относительно ценрта - сверху и снизу чтобы получилось тоже 640
- 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 изображение именно как вы хотите
Если понадобится, могу помочь с более детальной интеграцией кода или с освобождением памяти.
- 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); - 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, либо интегрировать вызов в ваш цикл. - User
а почему в функции struct SwsContext **sws_ctx
если у меня определен struct SwsContext *sws_ctx
потом он настраивается
потом передается в функцию scale_crop_letterbox_to_square(frame, rgb_frame, sws_ctx)
- 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(без двойного указателя), где всё создание и проверка контекста будет снаружи. - Ваша переменная
- User
а зачем пересоздавать динамически.. мы получаем избражение с камеры которое постоянное - не меняется.. и постоянно обрезаем его
- 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статичны. - Не нужно отслеживать динамические изменения или пересоздавать контекст.
- Однократное создание и многократное использование — оптимальный подход с низкой нагрузкой.
Если хотите, могу помочь с полным примером кода инициализации и цикла обработки с этим подходом — просто скажите!
- Контекст
- User
ну я так и сделал.. Контекст struct SwsContext *sws_ctx создать один раз при старте, с указанным разрешением исходного кадра и целевым размером. Передавать его в функцию как просто struct SwsContext *sws_ctx (одинарный указатель). переделай свобю функцию
- 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с проверками или автоматической вычислением параметров — скажите! - 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;}
- Assistant
Функция
save_frame_as_jpegвыглядит в целом корректной и выполняет сохранение кадра в формате JPEG с конвертацией из RGB24 в YUVJ420P, кодированием и записью в файл.Ниже небольшой разбор, рекомендации и варианты улучшения.
Разбор вашей функции
Что происходит:
- Ищется MJPEG кодек.
- Создаётся контекст кодека с нужными параметрами (ширина, высота, формат YUVJ420P).
- Отрывается кодек.
- Создаётся
SwsContextдля конвертации входного RGB24 (pFrame->format) вYUVJ420P. - Выделяется кадр
frame_yuvпод YUV данные. - RGB->YUV конвертация с помощью
sws_scale. - Отправляется кадр в кодек (
avcodec_send_frame()). - Получается сжатый пакет (
avcodec_receive_packet()). - Пакет пишется в файл
/tmp/frame_<iFrame>.jpg. - Освобождается память.
Замечания:
- В строках с
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 (например, с повторным созданием кодека вне функции).
- Отдельную инициализацию/деинициализацию кодека для серийной записи.
Если есть вопросы — пишите!
- 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)
- Assistant
Судя по приведённой информации и стектрейсу, вы попали в crash (SIGSEGV) внутри функции из libswscale (
sws_scale). Это классическая ошибка несоответствия параметров, или неправильного состояния памяти при вызовеsws_scale.
Возможные причины ошибки и пути отладки
1. Неверные входные данные для
sws_scalepFrame->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);
Отладка
- Выведите туда сюда размеры, форматы, проверяйте
dataиlinesizeна валидность. - Попробуйте вызвать sws_scale на минимальном кадре (например, 1x1) — проверить базовый путь.
- Запустите программу через 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— помогу проверить на ошибки. Или минимальный воспроизводимый пример.
Если нужна помощь с детальной отладкой — готов помочь!
- 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]#
- Assistant
Судя по логам:
- Входной формат кадра:
format = 0 - Выходной формат кадра:
format = 2 - В
libavutil/pixfmt.hобычно:AV_PIX_FMT_YUV420P = 0AV_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).
Рекомендации по отладке:
- Прямо перед вызовом
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);-
Проверьте, что перед вызовом
save_frame_as_jpegrgb_frameбыл выделен, его буфер заполнен вашей функциейscale_crop_letterbox_to_square, и данные валидны. -
Можно проверить, что перед
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. - Фрагмент с инициализацией кадров в вашем коде.
- Или минимальный воспроизводимый пример.
Могу помочь найти точку, где память повреждается или используется некорректно.
- Входной формат кадра:
- 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);
}
-
- 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, выделения кадров и обработкой потока. - User
неееееееееееееет приоритет ВСЕГДА ШИРИНА
- 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, выделения кадров и примером вызова. - 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;}
- Assistant
Спасибо за подробности. Ошибка
SIGSEGVвозникает в вашемsave_frame_as_jpegпри вызовеsws_scaleили куда-то рядом с конвертацией из RGB в YUV для JPEG. Рассмотрим возможные причины и исправим вашу функцию.
Возможные причины сбоя:
-
Несовместимый формат входного кадра (
pFrame) с параметрамиSwsContext.- Вы указываете
pFrame->format == AV_PIX_FMT_RGB24, но для MJPEG энкодера стоит использоватьAV_PIX_FMT_YUVJ420P(в новых версиях лучшеAV_PIX_FMT_YUV420P). - При создании
SwsContextпроисходит конвертация из RGB в YUVJ420P — тут важно, чтобыwidth,heightиformatточно совпадали с данными кадров.
- Вы указываете
-
Выделение или инициализация кадра
frame_yuvвыполнено некорректно (недостаточный буфер, неверный формат). -
Параметры
avcodec_open2и настройки кодека могут нуждаться в настройкеflagsилиbit_rateдля лучшей стабильности. -
Доступ к
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 — это улучшит производительность и надежность.
Если будет нужна помощь с этим — пишите!
-
- User
у меня версия ffmpeg 4.4.6
- 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 для вашей задачи
-
Используйте
AV_PIX_FMT_YUVJ420Pкак вы сейчас, если уже было успешно — не спешите менять, чтобы избежать лишних багов. -
Проверяйте, что параметры при создании контекста совпадают по формату и размерам с фактическими данными.
sws_getContextдолжен создаваться с теми же параметрами, что и уpFrameиframe_yuv. -
Инициализация кодека и
SwsContext— желательно один раз при старте, а не на каждый кадр.
Повторное создание и уничтожение приводит к затратам и рискам ошибок. -
Проверяйте ошибки тщательно.
Каждый вызов 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 с нужными параметрами.
- 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;} так предеелай полностью функци чтобы все работало
- 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.
Если хотите, могу помочь интегрировать это в ваш текущий проект, или дать более подробный пример по подготовке кадров.