programing

x264 C API를 사용하여 일련의 이미지를 H264로 인코딩하려면 어떻게 해야 합니까?

javaba 2022. 7. 6. 00:06
반응형

x264 C API를 사용하여 일련의 이미지를 H264로 인코딩하려면 어떻게 해야 합니까?

x264 C API를 사용하여 RBG 이미지를 H264 프레임으로 인코딩하려면 어떻게 해야 합니까?RBG 이미지 시퀀스는 이미 작성했습니다만, 이 시퀀스를 H264 프레임 시퀀스로 변환하려면 어떻게 해야 합니까?특히 이 RGB 이미지의 시퀀스를 H264 프레임의 시퀀스로 인코딩하려면 어떻게 해야 합니까?H264 프레임은 1개의 초기 H264 키 프레임에 이어 의존 H264 프레임으로 구성됩니다.

먼저 x264.h 파일을 확인합니다.각 기능 및 구조에 대한 참조가 어느 정도 포함되어 있습니다.다운로드에서 찾을 수 있는 x264.c 파일에는 구현 예가 포함되어 있습니다.대부분의 사람들은 그것을 기반으로 한다고 말하지만, 저는 초보자에게는 다소 복잡하다고 생각합니다만, 예를 들어 참고하는 것이 좋습니다.

처음에 x264_type_t의 몇 가지 파라미터를 설정했을 때 파라미터를 설명하는 적절한 사이트는 http://mewiki.project357.com/wiki/X264_Settings 입니다.또, 다음의 정보를 참조해 주세요.x264_param_default_preset이 기능을 사용하면 모든 (때로는 매우 복잡한) 파라미터를 이해할 필요 없이 일부 기능을 대상으로 할 수 있습니다.또한 사용x264_param_apply_profile그 후 (아마도 '프로파일'이 필요하게 될 것입니다)

다음은 내 코드의 설정 예입니다.

x264_param_t param;
x264_param_default_preset(&param, "veryfast", "zerolatency");
param.i_threads = 1;
param.i_width = width;
param.i_height = height;
param.i_fps_num = fps;
param.i_fps_den = 1;
// Intra refres:
param.i_keyint_max = fps;
param.b_intra_refresh = 1;
//Rate control:
param.rc.i_rc_method = X264_RC_CRF;
param.rc.f_rf_constant = 25;
param.rc.f_rf_constant_max = 35;
//For streaming:
param.b_repeat_headers = 1;
param.b_annexb = 1;
x264_param_apply_profile(&param, "baseline");

그 후, 다음과 같이 인코더를 초기화할 수 있습니다.

x264_t* encoder = x264_encoder_open(&param);
x264_picture_t pic_in, pic_out;
x264_picture_alloc(&pic_in, X264_CSP_I420, w, h)

X264는 YUV420P 데이터를 예상하고 있습니다(다른 데이터도 있을 수 있지만 일반적인 데이터입니다).libswscale(fffmpeg에서)을 사용하여 이미지를 올바른 형식으로 변환할 수 있습니다.초기화는 다음과 같습니다(24bpp의 RGB 데이터를 상정).

struct SwsContext* convertCtx = sws_getContext(in_w, in_h, PIX_FMT_RGB24, out_w, out_h, PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);

각 프레임에 대해 다음과 같이 부호화가 간단합니다.

//data is a pointer to you RGB structure
int srcstride = w*3; //RGB stride is just 3*width
sws_scale(convertCtx, &data, &srcstride, 0, h, pic_in.img.plane, pic_in.img.stride);
x264_nal_t* nals;
int i_nals;
int frame_size = x264_encoder_encode(encoder, &nals, &i_nals, &pic_in, &pic_out);
if (frame_size >= 0)
{
    // OK
}

이 일을 계기로 잘 해 주셨으면 합니다.」라고 하는 것은, 저 스스로 오랜 시간을 들여서 시작한 것입니다.X264는 매우 강력하지만 때로는 복잡한 소프트웨어입니다.

edit: 다른 파라미터를 사용하는 경우 지연 프레임이 발생하지만 (대부분 nolatency 옵션 때문에) 내 파라미터에는 해당되지 않습니다.이 경우 frame_size가 0이 될 수 있으므로 전화해야 합니다.x264_encoder_encode기능하는 한x264_encoder_delayed_frames는 0을 반환하지 않습니다.단, 이 기능을 사용하려면 x264.c 및 x264.h에 대해 자세히 알아봐야 합니다.

raw yuv 프레임을 생성하고 x264를 사용하여 인코딩하는 예를 업로드했습니다.자세한 코드는, https://gist.github.com/roxlu/6453908 를 참조해 주세요.

FFmpeg 2.8.6 C 실행 가능 예시

FFpmeg를 x264의 래퍼로 사용하는 것은 여러 인코더에 대해 균일한 API를 제공하기 때문에 좋은 생각입니다.따라서 형식을 변경해야 할 경우 새로운 API를 학습하는 대신 하나의 매개 변수만 변경할 수 있습니다.

에서는, 「Colorful frame」이 한, 「을.generate_rgb.

프레임 타입(I, P, B)의 제어에 대해서는, 가능한 한 적은 수의 키 프레임(첫 번째 프레임은 제외)에 대해 설명합니다.https://stackoverflow.com/a/36412909/895245 여기서 설명한 바와 같이, 대부분의 애플리케이션에 대해서는 권장하지 않습니다.

여기서 프레임 타입 제어를 실시하는 키 라인은 다음과 같습니다.

/* Minimal distance of I-frames. This is the maximum value allowed,
or else we get a warning at runtime. */
c->keyint_min = 600;

또, 다음과 같이 합니다.

if (frame->pts == 1) {
    frame->key_frame = 1;
    frame->pict_type = AV_PICTURE_TYPE_I;
} else {
    frame->key_frame = 0;
    frame->pict_type = AV_PICTURE_TYPE_P;
}

다음으로 프레임 타입을 확인할 수 있습니다.

ffprobe -select_streams v \
    -show_frames \
    -show_entries frame=pict_type \
    -of csv \
    tmp.h264

다음 URL에서 설명했듯이 https://superuser.com/questions/885452/extracting-the-index-of-key-frames-from-a-video-using-ffmpeg

생성된 출력의 미리 보기입니다.

메인

#include <libavcodec/avcodec.h>
#include <libavutil/imgutils.h>
#include <libavutil/opt.h>
#include <libswscale/swscale.h>

static AVCodecContext *c = NULL;
static AVFrame *frame;
static AVPacket pkt;
static FILE *file;
struct SwsContext *sws_context = NULL;

static void ffmpeg_encoder_set_frame_yuv_from_rgb(uint8_t *rgb) {
    const int in_linesize[1] = { 3 * c->width };
    sws_context = sws_getCachedContext(sws_context,
            c->width, c->height, AV_PIX_FMT_RGB24,
            c->width, c->height, AV_PIX_FMT_YUV420P,
            0, 0, 0, 0);
    sws_scale(sws_context, (const uint8_t * const *)&rgb, in_linesize, 0,
            c->height, frame->data, frame->linesize);
}

uint8_t* generate_rgb(int width, int height, int pts, uint8_t *rgb) {
    int x, y, cur;
    rgb = realloc(rgb, 3 * sizeof(uint8_t) * height * width);
    for (y = 0; y < height; y++) {
        for (x = 0; x < width; x++) {
            cur = 3 * (y * width + x);
            rgb[cur + 0] = 0;
            rgb[cur + 1] = 0;
            rgb[cur + 2] = 0;
            if ((frame->pts / 25) % 2 == 0) {
                if (y < height / 2) {
                    if (x < width / 2) {
                        /* Black. */
                    } else {
                        rgb[cur + 0] = 255;
                    }
                } else {
                    if (x < width / 2) {
                        rgb[cur + 1] = 255;
                    } else {
                        rgb[cur + 2] = 255;
                    }
                }
            } else {
                if (y < height / 2) {
                    rgb[cur + 0] = 255;
                    if (x < width / 2) {
                        rgb[cur + 1] = 255;
                    } else {
                        rgb[cur + 2] = 255;
                    }
                } else {
                    if (x < width / 2) {
                        rgb[cur + 1] = 255;
                        rgb[cur + 2] = 255;
                    } else {
                        rgb[cur + 0] = 255;
                        rgb[cur + 1] = 255;
                        rgb[cur + 2] = 255;
                    }
                }
            }
        }
    }
    return rgb;
}

/* Allocate resources and write header data to the output file. */
void ffmpeg_encoder_start(const char *filename, int codec_id, int fps, int width, int height) {
    AVCodec *codec;
    int ret;

    codec = avcodec_find_encoder(codec_id);
    if (!codec) {
        fprintf(stderr, "Codec not found\n");
        exit(1);
    }
    c = avcodec_alloc_context3(codec);
    if (!c) {
        fprintf(stderr, "Could not allocate video codec context\n");
        exit(1);
    }
    c->bit_rate = 400000;
    c->width = width;
    c->height = height;
    c->time_base.num = 1;
    c->time_base.den = fps;
    c->keyint_min = 600;
    c->pix_fmt = AV_PIX_FMT_YUV420P;
    if (codec_id == AV_CODEC_ID_H264)
        av_opt_set(c->priv_data, "preset", "slow", 0);
    if (avcodec_open2(c, codec, NULL) < 0) {
        fprintf(stderr, "Could not open codec\n");
        exit(1);
    }
    file = fopen(filename, "wb");
    if (!file) {
        fprintf(stderr, "Could not open %s\n", filename);
        exit(1);
    }
    frame = av_frame_alloc();
    if (!frame) {
        fprintf(stderr, "Could not allocate video frame\n");
        exit(1);
    }
    frame->format = c->pix_fmt;
    frame->width  = c->width;
    frame->height = c->height;
    ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height, c->pix_fmt, 32);
    if (ret < 0) {
        fprintf(stderr, "Could not allocate raw picture buffer\n");
        exit(1);
    }
}

/*
Write trailing data to the output file
and free resources allocated by ffmpeg_encoder_start.
*/
void ffmpeg_encoder_finish(void) {
    uint8_t endcode[] = { 0, 0, 1, 0xb7 };
    int got_output, ret;
    do {
        fflush(stdout);
        ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
        if (ret < 0) {
            fprintf(stderr, "Error encoding frame\n");
            exit(1);
        }
        if (got_output) {
            fwrite(pkt.data, 1, pkt.size, file);
            av_packet_unref(&pkt);
        }
    } while (got_output);
    fwrite(endcode, 1, sizeof(endcode), file);
    fclose(file);
    avcodec_close(c);
    av_free(c);
    av_freep(&frame->data[0]);
    av_frame_free(&frame);
}

/*
Encode one frame from an RGB24 input and save it to the output file.
Must be called after ffmpeg_encoder_start, and ffmpeg_encoder_finish
must be called after the last call to this function.
*/
void ffmpeg_encoder_encode_frame(uint8_t *rgb) {
    int ret, got_output;
    ffmpeg_encoder_set_frame_yuv_from_rgb(rgb);
    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;
    if (frame->pts == 1) {
        frame->key_frame = 1;
        frame->pict_type = AV_PICTURE_TYPE_I;
    } else {
        frame->key_frame = 0;
        frame->pict_type = AV_PICTURE_TYPE_P;
    }
    ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
    if (ret < 0) {
        fprintf(stderr, "Error encoding frame\n");
        exit(1);
    }
    if (got_output) {
        fwrite(pkt.data, 1, pkt.size, file);
        av_packet_unref(&pkt);
    }
}

/* Represents the main loop of an application which generates one frame per loop. */
static void encode_example(const char *filename, int codec_id) {
    int pts;
    int width = 320;
    int height = 240;
    uint8_t *rgb = NULL;
    ffmpeg_encoder_start(filename, codec_id, 25, width, height);
    for (pts = 0; pts < 100; pts++) {
        frame->pts = pts;
        rgb = generate_rgb(width, height, pts, rgb);
        ffmpeg_encoder_encode_frame(rgb);
    }
    ffmpeg_encoder_finish();
}

int main(void) {
    avcodec_register_all();
    encode_example("tmp.h264", AV_CODEC_ID_H264);
    encode_example("tmp.mpg", AV_CODEC_ID_MPEG1VIDEO);
    return 0;
}

컴파일 및 실행 대상:

gcc -o main.out -std=c99 -Wextra main.c -lavcodec -lswscale -lavutil
./main.out
ffplay tmp.mpg
ffplay tmp.h264

Ubuntu 16.04로 테스트.GitHub 업스트림

언급URL : https://stackoverflow.com/questions/2940671/how-does-one-encode-a-series-of-images-into-h264-using-the-x264-c-api

반응형
저작자표시

'programing' 카테고리의 다른 글

Vue.js Axios 삭제 방법 어레이에서 잘못된 개체 삭제  (0) 2022.07.10
Vue.js - "속성 또는 메서드가 정의되어 있지 않습니다"에 대한 v-.js  (0) 2022.07.10
크기를 확인하거나 범위를 벗어나지 않고 문자열의 첫 번째 n자를 가져오려면 어떻게 해야 합니까?  (0) 2022.07.05
Vue.js 앱을 컨테이너화하는 방법  (0) 2022.07.05
vuex 스토어에서 상태를 지우려면 어떻게 해야 합니까?  (0) 2022.07.05

'programing'의 다른글

  • 현재글x264 C API를 사용하여 일련의 이미지를 H264로 인코딩하려면 어떻게 해야 합니까?

관련글

댓글

티스토리툴바