vaapi-fits是什么

Vaapi-fits 是一个开源的 VAAPI (Video Acceleration API) 插件，它可以在 Linux 平台上提供硬件加速的视频编码和解码功能，支持多种视频编码格式，如 H.264、H.265、VP8、VP9 等。

相关问题

linux buildroot ffmpeg vaapi

Linux Buildroot是一个用于嵌入式系统的开源工具箱，它允许用户自定义和构建Linux操作系统。通过Buildroot，用户可以选择所需的软件包，并进行交叉编译，从而构建出适用于特定嵌入式设备的定制化Linux系统。Buildroot支持包括x86、ARM、MIPS和PowerPC等多种处理器架构，并提供了丰富的软件包选项，包括FFmpeg。

FFmpeg是一个开源多媒体框架，提供了音频和视频编解码器、格式转换、流媒体和多媒体处理等功能。在Linux Buildroot中使用FFmpeg时，我们可以将其选为所需的软件包，然后在构建过程中进行交叉编译。通过配置Buildroot的设置，我们可以决定要包括的FFmpeg编解码器和功能，以便适应特定的嵌入式设备需求。

在使用FFmpeg进行视频编解码时，可以结合VAAPI（Video Acceleration API）来提高性能。VAAPI是一个Linux上的视频加速接口，允许硬件加速视频处理。通过在FFmpeg中启用VAAPI支持，可以利用支持硬件加速的嵌入式设备的特殊功能，如GPU硬件解码和编码器，以提供更高效的视频处理能力。

因此，将FFmpeg和VAAPI与Linux Buildroot结合使用，可以构建出定制化的Linux嵌入式系统，该系统在嵌入式设备上能够支持令人满意的音视频播放和处理能力。这种结合提供了广泛的自定义选项和优化能力，使得用户可以根据具体需求构建满足特定要求的嵌入式Linux系统。

android下使用FFMpeg的VAAPI播放视频的代码

使用FFmpeg和VAAPI播放视频需要以下步骤：

1. 初始化FFmpeg和VAAPI环境：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <va/va.h>
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>

// VAAPI
static VADisplay va_dpy;
static VAConfigID va_config;
static VAContextID va_context;
static VASurfaceID va_surfaces[10];
static int va_buffers[10];
static int va_buffers_num;

// 初始化VAAPI
static bool va_init(AVCodecContext *p_codec_ctx, int num_surfaces)
{
    VAStatus va_status;
    VASurfaceAttrib va_surface_attrib[2];
    VAConfigAttrib va_config_attrib;
    int major_version, minor_version;
    int num_entries;
    VAEntrypoint *entrypoints;
    VAProfile *profiles;

    va_dpy = vaGetDisplayDRM(0);
    va_status = vaInitialize(va_dpy, &major_version, &minor_version);
    if (va_status != VA_STATUS_SUCCESS) {
        fprintf(stderr, "vaInitialize failed: %d\n", va_status);
        return false;
    }

    num_entries = vaMaxNumEntrypoints(va_dpy);
    entrypoints = malloc(num_entries * sizeof(*entrypoints));
    vaQueryConfigEntrypoints(va_dpy, VAProfileH264High, entrypoints, &num_entries);

    num_entries = vaMaxNumProfiles(va_dpy);
    profiles = malloc(num_entries * sizeof(*profiles));
    vaQueryConfigProfiles(va_dpy, profiles, &num_entries);

    va_status = vaCreateConfig(va_dpy, VAProfileH264High, VAEntrypointVLD, NULL, 0, &va_config);
    if (va_status != VA_STATUS_SUCCESS) {
        fprintf(stderr, "vaCreateConfig failed: %d\n", va_status);
        return false;
    }

    va_surface_attrib[0].type = VASurfaceAttribPixelFormat;
    va_surface_attrib[0].value.type = VAGenericValueTypeInteger;
    va_surface_attrib[0].flags = VA_SURFACE_ATTRIB_SETTABLE;
    va_surface_attrib[0].value.value.i = VA_FOURCC('N', 'V', '1', '2');

    va_surface_attrib[1].type = VASurfaceAttribMemoryType;
    va_surface_attrib[1].value.type = VAGenericValueTypeInteger;
    va_surface_attrib[1].flags = VA_SURFACE_ATTRIB_SETTABLE;
    va_surface_attrib[1].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME;

    va_status = vaCreateSurfaces(va_dpy, VA_RT_FORMAT_YUV420, p_codec_ctx->width, p_codec_ctx->height,
                                 va_surfaces, num_surfaces, va_surface_attrib, 2);
    if (va_status != VA_STATUS_SUCCESS) {
        fprintf(stderr, "vaCreateSurfaces failed: %d\n", va_status);
        return false;
    }

    va_config_attrib.type = VAConfigAttribRTFormat;
    vaQueryConfigAttributes(va_dpy, va_config, &va_config_attrib, 1);
    if ((va_config_attrib.value & VA_RT_FORMAT_YUV420) == 0) {
        fprintf(stderr, "RT format not supported\n");
        return false;
    }

    va_buffers_num = vaMaxNumBufferSlots(va_dpy);

    va_status = vaCreateContext(va_dpy, va_config, p_codec_ctx->width, p_codec_ctx->height,
                                VA_PROGRESSIVE, va_surfaces, num_surfaces, &va_context);
    if (va_status != VA_STATUS_SUCCESS) {
        fprintf(stderr, "vaCreateContext failed: %d\n", va_status);
        return false;
    }

    free(entrypoints);
    free(profiles);

    return true;
}

2. 解码视频并将解码后的帧渲染到VAAPI surface上：

// 解码视频并将解码后的帧渲染到VAAPI surface上
int decode_and_render(AVCodecContext *p_codec_ctx, AVPacket *p_pkt, AVFrame **pp_frame, int *pi_frame_available)
{
    int i_ret;
    AVFrame *p_frame;
    VAStatus va_status;
    VABufferID va_buffers[3];
    VAEncPictureParameterBufferH264 va_pic_param;
    VAEncSliceParameterBufferH264 va_slice_param;
    int i_surface_index;
    int i;

    *pi_frame_available = 0;

    i_ret = avcodec_send_packet(p_codec_ctx, p_pkt);
    if (i_ret < 0) {
        fprintf(stderr, "avcodec_send_packet failed\n");
        return i_ret;
    }

    while (1) {
        p_frame = av_frame_alloc();
        if (!p_frame) {
            fprintf(stderr, "av_frame_alloc failed\n");
            return -1;
        }

        i_ret = avcodec_receive_frame(p_codec_ctx, p_frame);
        if (i_ret == AVERROR(EAGAIN)) {
            av_frame_free(&p_frame);
            break;
        }

        if (i_ret < 0) {
            fprintf(stderr, "avcodec_receive_frame failed\n");
            av_frame_free(&p_frame);
            return i_ret;
        }

        for (i = 0; i < va_buffers_num; i++) {
            if (va_buffers[i] == VA_INVALID_ID) {
                va_buffers[i] = vaCreateBuffer(va_dpy, va_context, VAEncPictureParameterBufferType,
                                               sizeof(va_pic_param), 1, &va_pic_param, NULL);
                break;
            }
        }

        if (i == va_buffers_num) {
            fprintf(stderr, "no free picture parameter buffers available\n");
            av_frame_free(&p_frame);
            return -1;
        }

        memset(&va_pic_param, 0, sizeof(va_pic_param));
        va_pic_param.CurrPic.picture_id = va_surfaces[i_surface_index];
        va_pic_param.CurrPic.TopFieldOrderCnt = p_frame->coded_picture_number;
        va_pic_param.CurrPic.BottomFieldOrderCnt = p_frame->coded_picture_number;
        va_pic_param.ReferenceFrames[0].picture_id = VA_INVALID_SURFACE;
        va_pic_param.ReferenceFrames[0].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
        va_pic_param.picture_width_in_mbs_minus1 = (p_codec_ctx->width + 15) / 16 - 1;
        va_pic_param.picture_height_in_mbs_minus1 = (p_codec_ctx->height + 15) / 16 - 1;
        va_pic_param.bits_per_pixel = 0x20;
        va_pic_param.num_slice_groups_minus1 = 0;
        va_pic_param.slice_group_map_type = VA_SLICE_GROUP_MAP_TYPE_INTERLEAVED;
        va_pic_param.num_ref_idx_l0_active_minus1 = 0;
        va_pic_param.num_ref_idx_l1_active_minus1 = 0;
        va_pic_param.chroma_qp_index_offset = 0;
        va_pic_param.second_chroma_qp_index_offset = 0;
        va_pic_param.pic_init_qp_minus26 = p_codec_ctx->qmin;
        va_pic_param.num_ref_frames = 1;
        va_pic_param.frame_num = p_frame->coded_picture_number;
        va_pic_param.frametype = VA_FRAME_PICTURE;

        va_status = vaMapBuffer(va_dpy, va_buffers[i], (void **)&va_pic_param);
        if (va_status != VA_STATUS_SUCCESS) {
            fprintf(stderr, "vaMapBuffer failed: %d\n", va_status);
            av_frame_free(&p_frame);
            return -1;
        }

        i_surface_index = (i_surface_index + 1) % num_surfaces;

        for (i = 0; i < va_buffers_num; i++) {
            if (va_buffers[i] == VA_INVALID_ID) {
                va_buffers[i] = vaCreateBuffer(va_dpy, va_context, VAEncSliceParameterBufferType,
                                               sizeof(va_slice_param), 1, &va_slice_param, NULL);
                break;
            }
        }

        if (i == va_buffers_num) {
            fprintf(stderr, "no free slice parameter buffers available\n");
            av_frame_free(&p_frame);
            return -1;
        }

        memset(&va_slice_param, 0, sizeof(va_slice_param));
        va_slice_param.slice_data_size = p_frame->pkt_size;
        va_slice_param.slice_data_offset = 0;
        va_slice_param.slice_type = VA_SLICE_TYPE_I;
        va_slice_param.pic_parameter_set_id = 0;
        va_slice_param.slice_group_change_cycle = 0;
        va_slice_param.num_macroblocks = (p_codec_ctx->height / 16) * (p_codec_ctx->width / 16);
        va_slice_param.disable_deblocking_filter_idc = 0;
        va_slice_param.slice_alpha_c0_offset_div2 = 0;
        va_slice_param.slice_beta_offset_div2 = 0;

        va_status = vaMapBuffer(va_dpy, va_buffers[i], (void **)&va_slice_param);
        if (va_status != VA_STATUS_SUCCESS) {
            fprintf(stderr, "vaMapBuffer failed: %d\n", va_status);
            av_frame_free(&p_frame);
            return -1;
        }

        i_surface_index = (i_surface_index + 1) % num_surfaces;

        for (i = 0; i < va_buffers_num; i++) {
            if (va_buffers[i] == VA_INVALID_ID) {
                va_buffers[i] = vaCreateBuffer(va_dpy, va_context, VAEncCodedBufferType,
                                               p_frame->pkt_size, 1, NULL, NULL);
                break;
            }
        }

        if (i == va_buffers_num) {
            fprintf(stderr, "no free coded buffers available\n");
            av_frame_free(&p_frame);
            return -1;
        }

        va_status = vaMapBuffer(va_dpy, va_buffers[i], (void **)&va_buffers[i]);
        if (va_status != VA_STATUS_SUCCESS) {
            fprintf(stderr, "vaMapBuffer failed: %d\n", va_status);
            av_frame_free(&p_frame);
            return -1;
        }

        if (vaBeginPicture(va_dpy, va_context, va_surfaces[i_surface_index]) != VA_STATUS_SUCCESS) {
            fprintf(stderr, "vaBeginPicture failed\n");
            av_frame_free(&p_frame);
            return -1;
        }

        if (vaRenderPicture(va_dpy, va_context, va_buffers, 3) != VA_STATUS_SUCCESS) {
            fprintf(stderr, "vaRenderPicture failed\n");
            av_frame_free(&p_frame);
            return -1;
        }

        if (vaEndPicture(va_dpy, va_context) != VA_STATUS_SUCCESS) {
            fprintf(stderr, "vaEndPicture failed\n");
            av_frame_free(&p_frame);
            return -1;
        }

        av_frame_free(&p_frame);

        *pi_frame_available = 1;
        *pp_frame = p_frame;
    }

    return 0;
}

3. 使用SDL或其他图形库将VAAPI surface上的帧渲染到屏幕上。

完整的代码示例可以参考以下链接：https://github.com/FFmpeg/FFmpeg/blob/master/doc/examples/hw_decode.c